Release v0.1.9

Author: nshkrdotcom

CHANGELOG.md

@@ -7,6 +7,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.1.9] - 2025-10-28
+
+### Fixed
+- **Multi-item arrays**: Layer 2 now closes missing braces and brackets between array elements, avoiding mismatched delimiter swaps during comma handling and restoring proper validation (#8).
+
+### Added
+- **Regression coverage**: Added LF and CRLF variants of the reporter's samples to ensure multi-element arrays with missing terminators stay repaired.
+
 ## [0.1.8] - 2025-10-27
 
 ### Added
@@ -340,7 +348,8 @@ This is a **100% rewrite** - all previous code has been replaced with the new la
 - Minimal memory overhead (< 8KB for repairs)
 - All operations pass performance thresholds
 
-[Unreleased]: https://github.com/nshkrdotcom/json_remedy/compare/v0.1.8...HEAD
+[Unreleased]: https://github.com/nshkrdotcom/json_remedy/compare/v0.1.9...HEAD
+[0.1.9]: https://github.com/nshkrdotcom/json_remedy/compare/v0.1.8...v0.1.9
 [0.1.8]: https://github.com/nshkrdotcom/json_remedy/compare/v0.1.7...v0.1.8
 [0.1.7]: https://github.com/nshkrdotcom/json_remedy/compare/v0.1.6...v0.1.7
 [0.1.6]: https://github.com/nshkrdotcom/json_remedy/compare/v0.1.5...v0.1.6

README.md

@@ -74,6 +74,7 @@ Runs **before** the main layer pipeline to handle complex patterns that would ot
 
 ### 🏗️ **Structural Repairs (Layer 2)**
 - **Missing closing delimiters**: `{"name": "Alice"` → `{"name": "Alice"}`
+- **Array element terminators**: Multi-item arrays recover missing braces/brackets between elements *(v0.1.9)*
 - **Extra delimiters**: `{"name": "Alice"}}}` → `{"name": "Alice"}`
 - **Mismatched delimiters**: `[{"name": "Alice"}]` → proper structure
 - **Missing opening braces**: `["key": "value"]` → `[{"key": "value"}]`
@@ -159,7 +160,7 @@ Add JsonRemedy to your `mix.exs`:
 ```elixir
 def deps do
   [
-    {:json_remedy, "~> 0.1.8"}
+    {:json_remedy, "~> 0.1.9"}
   ]
 end
 ```

lib/json_remedy/layer2/structural_repair.ex

@@ -137,6 +137,9 @@ defmodule JsonRemedy.Layer2.StructuralRepair do
       "]" ->
         handle_closing_bracket(state, char)
 
+      "," ->
+        handle_comma(state, char)
+
       _ ->
         # Regular character, just add to result
         %{state | result_chars: [char | state.result_chars]}
@@ -288,6 +291,12 @@ defmodule JsonRemedy.Layer2.StructuralRepair do
     end
   end
 
+  @spec handle_comma(state :: state_map(), char :: <<_::8>>) :: state_map()
+  defp handle_comma(state, char) do
+    adjusted_state = maybe_close_contexts_before_separator(state)
+    %{adjusted_state | result_chars: [char | adjusted_state.result_chars]}
+  end
+
   @spec determine_state_from_stack(stack :: [context_frame()]) :: parser_state()
   defp determine_state_from_stack([]), do: :root
   defp determine_state_from_stack([%{type: :brace} | _]), do: :object
@@ -344,29 +353,7 @@ defmodule JsonRemedy.Layer2.StructuralRepair do
       state.context_stack
       |> Enum.reduce({[], []}, fn context_frame, {chars_acc, repairs_acc} ->
         {close_char, repair} =
-          case context_frame.type do
-            :brace ->
-              repair = %{
-                layer: :structural_repair,
-                action: "added missing closing brace",
-                position: state.position + length(chars_acc),
-                original: nil,
-                replacement: "}"
-              }
-
-              {"}", repair}
-
-            :bracket ->
-              repair = %{
-                layer: :structural_repair,
-                action: "added missing closing bracket",
-                position: state.position + length(chars_acc),
-                original: nil,
-                replacement: "]"
-              }
-
-              {"]", repair}
-          end
+          closing_info(context_frame.type, state.position + length(chars_acc))
 
         {[close_char | chars_acc], [repair | repairs_acc]}
       end)
@@ -380,6 +367,98 @@ defmodule JsonRemedy.Layer2.StructuralRepair do
     }
   end
 
+  @spec maybe_close_contexts_before_separator(state_map()) :: state_map()
+  defp maybe_close_contexts_before_separator(state) do
+    next_char = next_significant_char(state)
+
+    cond do
+      next_char in [nil, "\""] ->
+        state
+
+      requires_array_boundary_closure?(state.context_stack) ->
+        close_contexts_until_array(state)
+
+      true ->
+        state
+    end
+  end
+
+  @spec next_significant_char(state_map()) :: String.t() | nil
+  defp next_significant_char(state) do
+    remaining_length = String.length(state.input) - state.position - 1
+
+    if remaining_length <= 0 do
+      nil
+    else
+      state.input
+      |> String.slice(state.position + 1, remaining_length)
+      |> String.graphemes()
+      |> Enum.find(fn char ->
+        char not in [" ", "\t", "\n", "\r"]
+      end)
+    end
+  end
+
+  @spec requires_array_boundary_closure?([context_frame()]) :: boolean()
+  defp requires_array_boundary_closure?(stack) do
+    case Enum.find_index(stack, &match?(%{type: :bracket}, &1)) do
+      nil -> false
+      0 -> false
+      _ -> true
+    end
+  end
+
+  @spec close_contexts_until_array(state_map()) :: state_map()
+  defp close_contexts_until_array(state) do
+    {to_close, remaining} =
+      Enum.split_while(state.context_stack, fn %{type: type} -> type != :bracket end)
+
+    if Enum.empty?(to_close) do
+      state
+    else
+      {result_chars, repairs} =
+        Enum.with_index(to_close)
+        |> Enum.reduce({state.result_chars, state.repairs}, fn {%{type: type}, idx},
+                                                               {chars_acc, repairs_acc} ->
+          {close_char, repair} = closing_info(type, state.position + idx)
+          {[close_char | chars_acc], [repair | repairs_acc]}
+        end)
+
+      %{
+        state
+        | context_stack: remaining,
+          current_state: determine_state_from_stack(remaining),
+          result_chars: result_chars,
+          repairs: repairs
+      }
+    end
+  end
+
+  @spec closing_info(delimiter_type(), non_neg_integer()) :: {String.t(), repair_action()}
+  defp closing_info(:brace, position) do
+    repair = %{
+      layer: :structural_repair,
+      action: "added missing closing brace",
+      position: position,
+      original: nil,
+      replacement: "}"
+    }
+
+    {"}", repair}
+  end
+
+  defp closing_info(:bracket, position) do
+    repair = %{
+      layer: :structural_repair,
+      action: "added missing closing bracket",
+      position: position,
+      original: nil,
+      replacement: "]"
+    }
+
+    {"]", repair}
+  end
+
   # LayerBehaviour callback implementations
 
   @doc """

mix.exs

@@ -1,7 +1,7 @@
 defmodule JsonRemedy.MixProject do
   use Mix.Project
 
-  @version "0.1.8"
+  @version "0.1.9"
   @source_url "https://github.com/nshkrdotcom/json_remedy"
 
   def project do

test/unit/issue8_missing_terminators_test.exs

@@ -0,0 +1,157 @@
+defmodule JsonRemedy.Issue8MissingTerminatorsTest do
+  use ExUnit.Case
+
+  @newline_variants ["\n", "\r\n"]
+
+  describe "issue #8 regressions for missing terminators in array elements" do
+    test "repairs missing closing brace on first array element" do
+      input = """
+      {
+          "foo": [
+              {
+                  "bar": {
+                      "baz":  {
+              }},
+              {
+                  "foo": {
+                      "bar":  1
+                  }
+              }
+          ]
+      }
+      """
+
+      expected = %{
+        "foo" => [
+          %{
+            "bar" => %{
+              "baz" => %{}
+            }
+          },
+          %{
+            "foo" => %{
+              "bar" => 1
+            }
+          }
+        ]
+      }
+
+      Enum.each(@newline_variants, fn newline ->
+        normalized_input = ensure_line_endings(input, newline)
+        assert {:ok, ^expected} = JsonRemedy.repair(normalized_input)
+      end)
+    end
+
+    test "repairs multiple missing closing braces across array elements" do
+      input = """
+      {
+          "foo": [
+              {
+                  "bar": {
+                      "baz":  {
+              },
+              {
+                  "foo": {
+                      "bar":  1
+                  }
+              }
+          ]
+      }
+      """
+
+      expected = %{
+        "foo" => [
+          %{
+            "bar" => %{
+              "baz" => %{}
+            }
+          },
+          %{
+            "foo" => %{
+              "bar" => 1
+            }
+          }
+        ]
+      }
+
+      Enum.each(@newline_variants, fn newline ->
+        normalized_input = ensure_line_endings(input, newline)
+        assert {:ok, ^expected} = JsonRemedy.repair(normalized_input)
+      end)
+    end
+
+    test "repairs missing closing square bracket in nested array" do
+      input = """
+      {
+          "foo": [
+              {
+                  "bar": {
+                      "baz":  [
+              },
+              {
+                  "foo": {
+                      "bar":  1
+                  }
+              }
+          ]
+      }
+      """
+
+      expected = %{
+        "foo" => [
+          %{
+            "bar" => %{
+              "baz" => []
+            }
+          },
+          %{
+            "foo" => %{
+              "bar" => 1
+            }
+          }
+        ]
+      }
+
+      Enum.each(@newline_variants, fn newline ->
+        normalized_input = ensure_line_endings(input, newline)
+        assert {:ok, ^expected} = JsonRemedy.repair(normalized_input)
+      end)
+    end
+
+    test "still repairs single-element array baseline" do
+      input = """
+      {
+          "foo": [
+              {
+                  "bar": {
+                      "baz":  [
+              }
+          ]
+      }
+      """
+
+      expected = %{
+        "foo" => [
+          %{
+            "bar" => %{
+              "baz" => []
+            }
+          }
+        ]
+      }
+
+      Enum.each(@newline_variants, fn newline ->
+        normalized_input = ensure_line_endings(input, newline)
+        assert {:ok, ^expected} = JsonRemedy.repair(normalized_input)
+      end)
+    end
+  end
+
+  defp ensure_line_endings(input, "\n"), do: input
+
+  defp ensure_line_endings(input, "\r\n") do
+    input
+    |> String.replace("\r\n", "\n")
+    |> String.replace("\n", "\r\n")
+  end
+end