fix code style

Author: NSHkr

lib/json_remedy.ex

@@ -5,6 +5,12 @@ defmodule JsonRemedy do
   JsonRemedy uses advanced binary pattern matching and functional composition
   to intelligently repair malformed JSON strings while achieving superior performance.
 
+  This module provides the main API for JSON repair functionality. It supports
+  multiple repair strategies and can handle various types of malformed JSON.
+
+  See `@type json_value` for the type specification of parsed JSON values.
+  See `@type repair_result` for the main return type specifications.
+
   ## Examples
 
       iex> JsonRemedy.repair(~s|{name: "Alice", age: 30, active: True}|)
@@ -21,8 +27,12 @@ defmodule JsonRemedy do
   alias JsonRemedy.Combinators
   alias JsonRemedy.Pipeline
 
-  @type repair_result :: {:ok, term()} | {:error, String.t()}
-  @type repair_result_with_logs :: {:ok, term(), [String.t()]} | {:error, String.t()}
+  # Type definitions
+  @type json_value ::
+          nil | boolean() | number() | String.t() | [json_value()] | %{String.t() => json_value()}
+  @type repair_log :: String.t()
+  @type repair_result :: {:ok, json_value()} | {:error, String.t()}
+  @type repair_result_with_logs :: {:ok, json_value(), [repair_log()]} | {:error, String.t()}
   @type strategy :: :binary_patterns | :combinators | :streaming
   @type option :: {:logging, boolean()} | {:strategy, strategy()} | {:strict, boolean()}
 

lib/json_remedy/binary_parser.ex

@@ -5,16 +5,24 @@ defmodule JsonRemedy.BinaryParser do
   This module uses Elixir's advanced binary pattern matching to parse and repair
   JSON without character-by-character iteration. Each function clause matches
   specific binary patterns, making parsing extremely efficient.
+
+  See `@type parse_context` for the context structure used during parsing.
+  See `@type parse_result` for the intermediate parsing result type.
+  See `@type repair_result` for the final repair result type.
   """
 
+  # Type definitions
+  @type json_value ::
+          nil | boolean() | number() | String.t() | [json_value()] | %{String.t() => json_value()}
+  @type repair_log :: String.t()
   @type parse_context :: %{
-          repairs: [String.t()],
+          repairs: [repair_log()],
           position: non_neg_integer(),
           strict: boolean()
         }
-
-  @type parse_result :: {term(), binary(), parse_context()}
-  @type repair_result :: {:ok, term()} | {:ok, term(), [String.t()]} | {:error, String.t()}
+  @type parse_result :: {json_value(), binary(), parse_context()}
+  @type repair_result ::
+          {:ok, json_value()} | {:ok, json_value(), [repair_log()]} | {:error, String.t()}
 
   @doc """
   Main entry point for binary pattern matching repair.

lib/json_remedy/combinators.ex

@@ -6,9 +6,16 @@ defmodule JsonRemedy.Combinators do
   that can each handle and repair specific syntax issues. While more
   elegant than direct parsing, it's currently a placeholder for future
   implementation.
+
+  See `@type repair_result` for the return type specification.
   """
 
-  @type repair_result :: {:ok, term()} | {:ok, term(), [String.t()]} | {:error, String.t()}
+  # Type definitions
+  @type json_value ::
+          nil | boolean() | number() | String.t() | [json_value()] | %{String.t() => json_value()}
+  @type repair_log :: String.t()
+  @type repair_result ::
+          {:ok, json_value()} | {:ok, json_value(), [repair_log()]} | {:error, String.t()}
 
   @doc """
   Repairs JSON using parser combinator approach.

lib/json_remedy/pipeline.ex

@@ -5,9 +5,16 @@ defmodule JsonRemedy.Pipeline do
   This approach processes JSON repair as a stream of transformations,
   making it suitable for large files or real-time processing.
   Currently a placeholder for future implementation.
+
+  See `@type repair_result` for the return type specification.
   """
 
-  @type repair_result :: {:ok, term()} | {:ok, term(), [String.t()]} | {:error, String.t()}
+  # Type definitions
+  @type json_value ::
+          nil | boolean() | number() | String.t() | [json_value()] | %{String.t() => json_value()}
+  @type repair_log :: String.t()
+  @type repair_result ::
+          {:ok, json_value()} | {:ok, json_value(), [repair_log()]} | {:error, String.t()}
 
   @doc """
   Repairs JSON using stream processing approach.