json-repair 0.7.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fdf2958528b936eba0faf6c724a20d10a3a3e0b95329bc1866740c99432f6fe3
-  data.tar.gz: 33fa97d2c7689ea594723e5d0d412646cf57a2ebdbf79f3b62947d4928963f32
+  metadata.gz: 6de36fcd3ab73ce63e1f9367d4e86dd7373dd7430b2dc87d451d75dd1f5fd685
+  data.tar.gz: 7221ab8c14253abf6cf4d40ff8fb8e6bd93c20504a8b5e6608c93a159420dc2f
 SHA512:
-  metadata.gz: 587323c57caac3e53af1da24cfeee47df18ff738516d8fd2862d37a547c6e864cf5653c8b43427ec58aa47be3f2e958c991208b36de098c5ffc9503f2c64a0a2
-  data.tar.gz: f5380cfdca6a4f60833ab57fc8465715b546415fa4f6ed5781b6bb24653ce324d2b6d928f9a5ff87b4deead145391303c1e805bf0fbff238b9ef1c7024a1f4aa
+  metadata.gz: 5083d8d8ada9a0b0a67beb8cb8ad1f1af53435e4e5c99632de5c68e19fd02d6dc85567b8c44cfc3068ae44118934c073d5a1acc22abf7f3d089b2add3899e083
+  data.tar.gz: 01d4eb164137dcb0e5b3b11703e2b1099efff6749f633466c3b37e1cccec07904e04006ddca1961d30702b5f133e35b88f8c37edce2bfa72ad61a6172dbbbada

data/CHANGELOG.md

@@ -1,5 +1,54 @@
 # Changes
 
+### 2026-06-11 (0.10.0)
+
+* Repair Markdown list markers in front of top-level values:
+  `- {"a": 1}` → `{"a":1}`, and multi-line lists become arrays via the
+  existing newline-delimited JSON handling
+  (`"- {\"a\": 1}\n- {\"b\": 2}"` → `[{"a":1},{"b":2}]`). Bullet
+  markers `-`, `*`, `+` and ordered markers like `1.` / `2)` (up to
+  nine digits, the CommonMark limit) are recognized at the start of
+  the root value and of each newline-delimited line, only when
+  followed by same-line whitespace and a value — so `-5`, a trailing
+  `"- "`, and newline-delimited decimals like `"1.5\n2.5"` keep their
+  number readings, and nothing changes inside nested structures.
+  Previously these inputs raised `JSONRepairError`; two non-raising
+  behaviors change for the better: `"3\n- 5\n7"` now repairs to
+  `[3,5,7]` instead of the corrupt `[3,0,5,7]`, and a single-line
+  `* text` becomes `"text"` instead of `"* text"`. Deliberate
+  divergence from upstream
+  [jsonrepair](https://github.com/josdejong/jsonrepair) (no Markdown
+  list handling as of v3.14.0), and more precise than Python
+  [`json_repair`](https://github.com/mangiucugna/json_repair), which
+  collapses scalar list items to `""`.
+
+### 2026-06-11 (0.9.0)
+
+* Repair numbers missing the digit before their decimal point:
+  `.5` → `0.5`, `-.5` → `-0.5`, and truncated forms like `.` → `0.0`.
+  Previously these leaked a raw stdlib `JSON::ParserError` out of
+  `JSON.repair` because the repairer emitted the leading-dot number
+  unchanged (invalid JSON) and the canonical-output re-parse choked on
+  it. This is a deliberate divergence from upstream
+  [jsonrepair](https://github.com/josdejong/jsonrepair) (which leaves
+  leading-dot numbers unrepaired as of v3.14.0), matching
+  [dirty-json](https://github.com/RyanMarcus/dirty-json) behavior.
+* `JSON.repair` now guards its error contract: if the repairer ever
+  emits a string stdlib JSON cannot parse (a repairer bug), the stdlib
+  error is wrapped in `JSON::JSONRepairError` instead of leaking
+  `JSON::ParserError` to callers.
+
+### 2026-05-15 (0.8.0)
+
+* `JSON.repair_file(path)` and `JSON.repair_io(io)` convenience
+  wrappers around `JSON.repair`. `repair_file` reads a path from disk
+  (accepts a `String` or `Pathname`); `repair_io` reads from any
+  object responding to `#read` (e.g. `File`, `StringIO`, `$stdin`)
+  without closing it. Both forward `return_objects:` and
+  `skip_json_loads:` through to `JSON.repair`. Mirrors Python's
+  [`json_repair`](https://github.com/mangiucugna/json_repair)
+  `load` / `from_file` helpers.
+
 ### 2026-05-12 (0.7.0)
 
 * `JSON.repair` now always returns canonical JSON via

data/README.md

@@ -31,6 +31,12 @@ puts repaired_json  # Outputs: {"name":"Alice","age":25}
 
 The `repair` method takes a string containing JSON data and returns a corrected version of this string, ensuring it is valid JSON.
 
+Markdown markup in LLM output is handled too: fenced code blocks like `` ```json `` are stripped, and list markers (`-`, `*`, `+`, `1.`) in front of top-level values are removed — a multi-line list becomes an array:
+
+```ruby
+JSON.repair("- {\"a\": 1}\n- {\"b\": 2}")  # => '[{"a":1},{"b":2}]'
+```
+
 Pass `return_objects: true` to get the parsed Ruby value (Hash, Array, or scalar) instead of a string:
 
 ```ruby
@@ -53,6 +59,20 @@ If you need the parsed Ruby value instead of a string, pass `return_objects: tru
 
 `skip_json_loads: true` skips the stdlib `JSON.parse` attempt and routes the input straight through the repairer. The output is the same; the option is purely a performance knob for callers who know their input will need repair.
 
+### Reading from a file or IO
+
+`JSON.repair_file(path)` reads a file from disk and repairs its contents. `JSON.repair_io(io)` does the same with any object that responds to `#read` (e.g. `File`, `StringIO`, `$stdin`). Both forward `return_objects:` and `skip_json_loads:` to `JSON.repair`.
+
+```ruby
+JSON.repair_file('broken.json')
+JSON.repair_file('broken.json', return_objects: true)
+
+File.open('broken.json') { |io| JSON.repair_io(io) }
+JSON.repair_io($stdin)
+```
+
+`JSON.repair_io` does not close the IO — the caller manages its lifecycle.
+
 ## Command line
 
 The gem ships a `json-repair` executable. It reads from stdin or a file and writes to stdout, `--output FILE`, or back over the input file with `--overwrite`.

data/Rakefile

@@ -19,6 +19,9 @@ task :steep do
   sh 'bundle exec steep check'
 end
 
+desc 'Type-check: rbs validate + steep check'
+task typecheck: %i[rbs steep]
+
 desc 'Run benchmark/run.rb (regression baseline for JSON.repair)'
 task :bench do
   ruby '-Ilib', 'benchmark/run.rb'

data/lib/json/repair/string_utils.rb

@@ -60,13 +60,14 @@ module JSON
 
       # Functions to check character chars
       def hex?(char)
-        (char >= ZERO && char <= NINE) ||
-          (char >= UPPERCASE_A && char <= UPPERCASE_F) ||
-          (char >= LOWERCASE_A && char <= LOWERCASE_F)
+        !char.nil? &&
+          ((char >= ZERO && char <= NINE) ||
+           (char >= UPPERCASE_A && char <= UPPERCASE_F) ||
+           (char >= LOWERCASE_A && char <= LOWERCASE_F))
       end
 
       def digit?(char)
-        char && char >= ZERO && char <= NINE
+        !char.nil? && char >= ZERO && char <= NINE
       end
 
       def valid_string_character?(char)
@@ -74,11 +75,11 @@ module JSON
       end
 
       def delimiter?(char)
-        REGEX_DELIMITER.match?(char)
+        !char.nil? && REGEX_DELIMITER.match?(char)
       end
 
       def unquoted_string_delimiter?(char)
-        REGEX_UNQUOTED_STRING_DELIMITER.match?(char)
+        !char.nil? && REGEX_UNQUOTED_STRING_DELIMITER.match?(char)
       end
 
       REGEX_FUNCTION_NAME_CHAR_START = /\A[a-zA-Z_$]\z/
@@ -93,19 +94,19 @@ module JSON
       end
 
       def start_of_value?(char)
-        REGEX_START_OF_VALUE.match?(char) || (char && quote?(char))
+        !char.nil? && (REGEX_START_OF_VALUE.match?(char) || quote?(char))
       end
 
       def control_character?(char)
-        [NEWLINE, RETURN, TAB, BACKSPACE, FORM_FEED].include?(char)
+        !char.nil? && [NEWLINE, RETURN, TAB, BACKSPACE, FORM_FEED].include?(char)
       end
 
       def whitespace?(char)
-        [SPACE, NEWLINE, TAB, RETURN].include?(char)
+        !char.nil? && [SPACE, NEWLINE, TAB, RETURN].include?(char)
       end
 
       def whitespace_except_newline?(char)
-        [SPACE, TAB, RETURN].include?(char)
+        !char.nil? && [SPACE, TAB, RETURN].include?(char)
       end
 
       def special_whitespace?(char)
@@ -122,6 +123,10 @@ module JSON
           (char >= EN_QUAD && char <= ZERO_WIDTH_SPACE)
       end
 
+      def same_line_whitespace?(char)
+        whitespace_except_newline?(char) || special_whitespace?(char)
+      end
+
       def quote?(char)
         double_quote_like?(char) || single_quote_like?(char)
       end
@@ -135,20 +140,25 @@ module JSON
       end
 
       def double_quote_like?(char)
-        [DOUBLE_QUOTE, DOUBLE_QUOTE_LEFT, DOUBLE_QUOTE_RIGHT].include?(char)
+        !char.nil? && [DOUBLE_QUOTE, DOUBLE_QUOTE_LEFT, DOUBLE_QUOTE_RIGHT].include?(char)
       end
 
       def single_quote_like?(char)
-        [QUOTE, QUOTE_LEFT, QUOTE_RIGHT, GRAVE_ACCENT, ACUTE_ACCENT].include?(char)
+        !char.nil? && [QUOTE, QUOTE_LEFT, QUOTE_RIGHT, GRAVE_ACCENT, ACUTE_ACCENT].include?(char)
       end
 
-      # Strip last occurrence of text_to_strip from text
+      # Strip last occurrence of text_to_strip from text.
+      #
+      # `|| ''` on the slices below (and in `insert_before_last_whitespace` /
+      # `remove_at_index`) is for steep's nil-narrowing: `String#[range]` is
+      # typed `String?`, but every call site here keeps indices within
+      # `0..text.length`, so the slices never actually return `nil`.
       def strip_last_occurrence(text, text_to_strip, strip_remaining_text: false)
         index = text.rindex(text_to_strip)
         return text unless index
 
-        remaining_text = strip_remaining_text ? '' : text[index + 1..]
-        text[0...index] + remaining_text
+        remaining_text = strip_remaining_text ? '' : (text[index + 1..] || '')
+        (text[0...index] || '') + remaining_text
       end
 
       def insert_before_last_whitespace(text, text_to_insert)
@@ -158,7 +168,7 @@ module JSON
 
         index -= 1 while whitespace?(text[index - 1])
 
-        text[0...index] + text_to_insert + text[index..]
+        (text[0...index] || '') + text_to_insert + (text[index..] || '')
       end
 
       # Parse keywords true, false, null
@@ -187,7 +197,7 @@ module JSON
       end
 
       def remove_at_index(text, start, count)
-        text[0...start] + text[start + count..]
+        (text[0...start] || '') + (text[start + count..] || '')
       end
 
       def ends_with_comma_or_newline?(text)

data/lib/json/repair/version.rb

@@ -2,6 +2,6 @@
 
 module JSON
   module Repair
-    VERSION = '0.7.0'
+    VERSION = '0.10.0'
   end
 end

data/lib/json/repair.rb

@@ -20,6 +20,22 @@ module JSON
     return_objects ? parsed : JSON.generate(parsed)
   end
 
+  # Inlined rather than calling `repair(...)` so the literal-bool overloads
+  # in sig/json/repair.rbs narrow correctly per caller — forwarding a
+  # `bool`-typed `return_objects` will not resolve against the literal-
+  # `true`/`false` overloads on `JSON.repair`.
+  def self.repair_io(io, return_objects: false, skip_json_loads: false)
+    json = io.read || ''
+    parsed = skip_json_loads ? repaired_parse(json) : tolerant_parse(json)
+    return_objects ? parsed : JSON.generate(parsed)
+  end
+
+  def self.repair_file(path, return_objects: false, skip_json_loads: false)
+    json = File.read(path.to_s)
+    parsed = skip_json_loads ? repaired_parse(json) : tolerant_parse(json)
+    return_objects ? parsed : JSON.generate(parsed)
+  end
+
   def self.tolerant_parse(json)
     JSON.parse(json)
   rescue JSON::ParserError
@@ -27,8 +43,14 @@ module JSON
   end
   private_class_method :tolerant_parse
 
+  # The rescue guards the JSONRepairError-only error contract: if the
+  # Repairer ever emits a string stdlib JSON cannot parse (a Repairer bug),
+  # wrap the stdlib error instead of leaking JSON::ParserError to callers.
   def self.repaired_parse(json)
-    JSON.parse(Repairer.new(json).repair)
+    repaired = Repairer.new(json).repair
+    JSON.parse(repaired)
+  rescue JSON::ParserError => e
+    raise JSONRepairError, "Internal error: repaired output is not valid JSON (#{e.message})"
   end
   private_class_method :repaired_parse
 end

data/lib/json/repairer.rb

@@ -37,6 +37,12 @@ module JSON
     def repair
       parse_markdown_code_block(MARKDOWN_OPEN_BLOCKS)
 
+      # repair: skip a Markdown list marker before the root value
+      # (and any comments before it, which parse_value would otherwise
+      # only consume after the marker check has already failed)
+      parse_whitespace_and_skip_comments
+      skip_markdown_list_marker
+
       processed = parse_value
 
       throw_unexpected_end unless processed
@@ -46,7 +52,8 @@ module JSON
       processed_comma = parse_character(COMMA)
       parse_whitespace_and_skip_comments if processed_comma
 
-      if start_of_value?(@json[@index]) && ends_with_comma_or_newline?(@output)
+      if (start_of_value?(@json[@index]) || markdown_list_marker_length) &&
+         ends_with_comma_or_newline?(@output)
         # start of a new value after end of the root level object: looks like
         # newline delimited JSON -> turn into a root level array
         unless processed_comma
@@ -170,6 +177,52 @@ module JSON
       false
     end
 
+    # Look ahead from @index for a Markdown list marker like "- ", "* ",
+    # "+ ", or "12. " that precedes a value. Returns the marker's length,
+    # or nil when there is no marker. Only consulted at the top level —
+    # the root value and each newline-delimited value — never inside
+    # nested structures. A marker must be followed by same-line
+    # whitespace and a value, so "-5", a trailing "- ", and "-\n{...}"
+    # keep their number readings. Ordered markers are capped at nine
+    # digits (the CommonMark limit) so long truncated decimals are not
+    # mistaken for markers. Divergence from upstream (no Markdown list
+    # handling as of v3.14.0): LLMs frequently emit JSON values as
+    # Markdown list items.
+    def markdown_list_marker_length
+      j = @index
+
+      if [MINUS, ASTERISK, PLUS].include?(@json[j])
+        j += 1
+      elsif digit?(@json[j])
+        j += 1 while digit?(@json[j]) && j - @index < 9
+        return nil unless [DOT, CLOSE_PARENTHESIS].include?(@json[j])
+
+        j += 1
+      else
+        return nil
+      end
+
+      marker_length = j - @index
+      return nil unless same_line_whitespace?(@json[j])
+
+      j += 1 while same_line_whitespace?(@json[j])
+      # a leading-dot number like ".5" is also a value here: parse_number
+      # repairs it to "0.5" even though start_of_value? does not match it
+      return nil unless start_of_value?(@json[j]) || @json[j] == DOT
+
+      marker_length
+    end
+
+    # Repair a value behind a Markdown list marker, like "- {"a":1}",
+    # by skipping the marker. See markdown_list_marker_length.
+    def skip_markdown_list_marker
+      length = markdown_list_marker_length
+      return false unless length
+
+      @index += length
+      true
+    end
+
     # Parse an object like '{"key": "value"}'
     def parse_object
       return false unless @json[@index] == OPENING_BRACE
@@ -570,7 +623,9 @@ module JSON
           repair_number_ending_with_numeric_symbol(start)
           return true
         end
-        unless digit?(@json[@index])
+        # also accept a dot so "-.5" continues into the fraction branch
+        # below (divergence from upstream, which leaves "-.5" unrepaired)
+        unless digit?(@json[@index]) || @json[@index] == DOT
           @index = start
           return false
         end
@@ -620,7 +675,7 @@ module JSON
         num = @json[start...@index]
         has_invalid_leading_zero = num.match?(/^0\d/)
 
-        @output << (has_invalid_leading_zero ? "\"#{num}\"" : num)
+        @output << (has_invalid_leading_zero ? "\"#{num}\"" : repair_leading_dot_number(num))
         return true
       end
 
@@ -711,7 +766,18 @@ module JSON
       # repair numbers cut off at the end
       # this will only be called when we end after a '.', '-', or 'e' and does not
       # change the number more than it needs to make it valid JSON
-      @output << "#{@json[start...@index]}0"
+      @output << repair_leading_dot_number("#{@json[start...@index]}0")
+    end
+
+    # Repair a number missing its digit before the decimal point, like ".5"
+    # or "-.5", into "0.5" / "-0.5". Divergence from upstream, which emits
+    # the invalid leading-dot number unchanged. The guard keeps the common
+    # case (a number that needs no repair) allocation-free; `sub` copies
+    # its receiver even when the pattern does not match.
+    def repair_leading_dot_number(num)
+      return num unless num.start_with?('.', '-.')
+
+      num.sub(/\A(?<sign>-?)\./, '\k<sign>0.')
     end
 
     # Parse and repair Newline Delimited JSON (NDJSON):
@@ -732,6 +798,10 @@ module JSON
           end
         end
 
+        # repair: skip a Markdown list marker before the next value
+        parse_whitespace_and_skip_comments
+        skip_markdown_list_marker
+
         processed_value = parse_value
       end
 

data/sig/json/repair/string_utils.rbs

@@ -1,9 +1,9 @@
 module JSON
   module Repair
     module StringUtils
-      @output: untyped
+      @output: ::String
 
-      @index: untyped
+      @index: ::Integer
 
       # Constants for character chars
       BACKSLASH: "\\"
@@ -24,17 +24,17 @@ module JSON
 
       CLOSE_PARENTHESIS: ")"
 
-      SPACE: " "
+      SPACE: ::String
 
-      NEWLINE: "\n"
+      NEWLINE: ::String
 
-      TAB: "\t"
+      TAB: ::String
 
-      RETURN: "\r"
+      RETURN: ::String
 
-      BACKSPACE: "\b"
+      BACKSPACE: ::String
 
-      FORM_FEED: "\f"
+      FORM_FEED: ::String
 
       DOUBLE_QUOTE: "\""
 
@@ -110,56 +110,62 @@ module JSON
 
       REGEX_FUNCTION_NAME_CHAR: ::Regexp
 
-      # Functions to check character chars
-      def hex?: (untyped char) -> untyped
+      # Functions to check character chars.
+      # `char` is `::String?` because every caller passes `@json[@index]`,
+      # which is `nil` past the end of input. The predicates either guard
+      # against `nil` explicitly or rely on `Array#include?` / `==` /
+      # `Regexp#match?` returning a safe value for `nil`.
+      def hex?: (::String? char) -> bool
 
-      def digit?: (untyped char) -> untyped
+      def digit?: (::String? char) -> bool
 
-      def valid_string_character?: (untyped char) -> untyped
+      def valid_string_character?: (::String char) -> bool
 
-      def delimiter?: (untyped char) -> untyped
+      def delimiter?: (::String? char) -> bool
 
-      def unquoted_string_delimiter?: (untyped char) -> untyped
+      def unquoted_string_delimiter?: (::String? char) -> bool
 
-      def function_name_char_start?: (untyped char) -> untyped
+      def function_name_char_start?: (::String? char) -> bool
 
-      def function_name_char?: (untyped char) -> untyped
+      def function_name_char?: (::String? char) -> bool
 
-      def start_of_value?: (untyped char) -> untyped
+      def start_of_value?: (::String? char) -> bool
 
-      def control_character?: (untyped char) -> untyped
+      def control_character?: (::String? char) -> bool
 
-      def whitespace?: (untyped char) -> untyped
+      def whitespace?: (::String? char) -> bool
 
-      def whitespace_except_newline?: (untyped char) -> untyped
+      def whitespace_except_newline?: (::String? char) -> bool
 
-      def special_whitespace?: (untyped char) -> untyped
+      def special_whitespace?: (::String? char) -> bool
 
-      def quote?: (untyped char) -> untyped
+      def same_line_whitespace?: (::String? char) -> bool
 
-      def double_quote?: (untyped char) -> untyped
+      def quote?: (::String? char) -> bool
 
-      def single_quote?: (untyped char) -> untyped
+      def double_quote?: (::String? char) -> bool
 
-      def double_quote_like?: (untyped char) -> untyped
+      def single_quote?: (::String? char) -> bool
 
-      def single_quote_like?: (untyped char) -> untyped
+      def double_quote_like?: (::String? char) -> bool
+
+      def single_quote_like?: (::String? char) -> bool
 
       # Strip last occurrence of text_to_strip from text
-      def strip_last_occurrence: (untyped text, untyped text_to_strip, ?strip_remaining_text: bool) -> untyped
+      def strip_last_occurrence: (::String text, ::String text_to_strip, ?strip_remaining_text: bool) -> ::String
 
-      def insert_before_last_whitespace: (untyped text, untyped text_to_insert) -> untyped
+      def insert_before_last_whitespace: (::String text, ::String text_to_insert) -> ::String
 
       # Parse keywords true, false, null
       # Repair Python keywords True, False, None
       # Repair Ruby keyword nil
-      def parse_keywords: () -> untyped
+      def parse_keywords: () -> bool
 
-      def parse_keyword: (untyped name, untyped value) -> (true | false)
+      def parse_keyword: (::String name, ::String value) -> bool
 
-      def remove_at_index: (untyped text, untyped start, untyped count) -> untyped
+      def remove_at_index: (::String text, ::Integer start, ::Integer count) -> ::String
 
-      def ends_with_comma_or_newline?: (untyped text) -> untyped
+      def ends_with_comma_or_newline?: (::String text) -> bool
     end
   end
 end

data/sig/json/repair.rbs

@@ -1,4 +1,10 @@
 module JSON
+  # Recursive type for any `JSON.parse` result. Mirrors what stdlib's
+  # `JSON.parse` produces (and the JS upstream emits): scalars, arrays,
+  # and objects of the same. Used in place of `untyped` for the
+  # `return_objects: true` and internal `*_parse` paths.
+  type json_value = ::Hash[::String, json_value] | ::Array[json_value] | ::String | ::Integer | ::Float | bool | nil
+
   class JSONRepairError < StandardError
     attr_reader position: ::Integer?
 
@@ -9,13 +15,25 @@ module JSON
     VERSION: ::String
   end
 
+  interface _Readable
+    def read: () -> ::String?
+  end
+
   def self.repair: (::String json, return_objects: false, ?skip_json_loads: bool) -> ::String
-                 | (::String json, return_objects: true, ?skip_json_loads: bool) -> untyped
+                 | (::String json, return_objects: true, ?skip_json_loads: bool) -> json_value
                  | (::String json, ?skip_json_loads: bool) -> ::String
 
+  def self.repair_io: (_Readable io, return_objects: false, ?skip_json_loads: bool) -> ::String
+                    | (_Readable io, return_objects: true, ?skip_json_loads: bool) -> json_value
+                    | (_Readable io, ?skip_json_loads: bool) -> ::String
+
+  def self.repair_file: (::String | ::Pathname path, return_objects: false, ?skip_json_loads: bool) -> ::String
+                      | (::String | ::Pathname path, return_objects: true, ?skip_json_loads: bool) -> json_value
+                      | (::String | ::Pathname path, ?skip_json_loads: bool) -> ::String
+
   private
 
-  def self.tolerant_parse: (::String json) -> untyped
+  def self.tolerant_parse: (::String json) -> json_value
 
-  def self.repaired_parse: (::String json) -> untyped
+  def self.repaired_parse: (::String json) -> json_value
 end

data/sig/json/repairer.rbs

@@ -11,7 +11,7 @@ module JSON
     # `lib/json/repairer.rb`).
     @json: untyped
 
-    @index: Integer
+    @index: ::Integer
 
     @output: ::String
 
@@ -31,25 +31,32 @@ module JSON
 
     private
 
-    def parse_value: () -> untyped
+    def parse_value: () -> bool
 
-    def parse_whitespace: (?skip_newline: bool) -> (true | false)
+    def parse_whitespace: (?skip_newline: bool) -> bool
 
-    def parse_comment: () -> (true | false)
+    def parse_comment: () -> bool
 
     # Find and skip over a Markdown fenced code block
-    def parse_markdown_code_block: (::Array[::String] blocks) -> (true | false)
+    def parse_markdown_code_block: (::Array[::String] blocks) -> bool
 
-    def skip_markdown_code_block: (::Array[::String] blocks) -> (true | false)
+    def skip_markdown_code_block: (::Array[::String] blocks) -> bool
+
+    # Look ahead for a Markdown list marker like "- " or "12. " that
+    # precedes a value; returns the marker's length, or nil when there
+    # is no marker.
+    def markdown_list_marker_length: () -> ::Integer?
+
+    def skip_markdown_list_marker: () -> bool
 
     # Parse an object like '{"key": "value"}'
-    def parse_object: () -> (false | true)
+    def parse_object: () -> bool
 
-    def skip_character: (untyped char) -> (true | false)
+    def skip_character: (::String char) -> bool
 
     # Skip ellipsis like "[1,2,3,...]" or "[1,2,3,...,9]" or "[...,7,8,9]"
     # or a similar construct in objects.
-    def skip_ellipsis: () -> untyped
+    def skip_ellipsis: () -> void
 
     # Parse a string enclosed by double quotes "...". Can contain escaped quotes
     # Repair strings enclosed in single quotes or special quotes
@@ -62,51 +69,59 @@ module JSON
     #   more conservative way, stopping the string at the first next delimiter
     #   and fixing the string by inserting a quote there, or stopping at a
     #   stop index detected in the first iteration.
-    def parse_string: (?stop_at_delimiter: bool, ?stop_at_index: ::Integer) -> (untyped | true | false)
+    def parse_string: (?stop_at_delimiter: bool, ?stop_at_index: ::Integer) -> bool
 
     # Repair an unquoted string by adding quotes around it
     # Repair a MongoDB function call like NumberLong("2")
     # Repair a JSONP function call like callback({...});
-    def parse_unquoted_string: (bool is_key) -> (false | true)
+    def parse_unquoted_string: (bool is_key) -> bool
 
     # Parse a regular expression literal like /foo/ or /foo\/bar/
-    def parse_regex: () -> (false | true)
+    def parse_regex: () -> bool
 
-    def parse_character: (untyped char) -> (true | false)
+    def parse_character: (::String char) -> bool
 
-    def parse_whitespace_and_skip_comments: (?skip_newline: bool) -> untyped
+    def parse_whitespace_and_skip_comments: (?skip_newline: bool) -> bool
 
     # Parse a number like 2.4 or 2.4e6
-    def parse_number: () -> (true | false)
+    def parse_number: () -> bool
 
-    def at_end_of_number?: () -> untyped
+    def at_end_of_number?: () -> bool
 
     # Parse an array like '["item1", "item2", ...]'
-    def parse_array: () -> (true | false)
+    def parse_array: () -> bool
 
-    def prev_non_whitespace_index: (untyped start) -> untyped
+    def prev_non_whitespace_index: (::Integer start) -> ::Integer
 
     # Repair concatenated strings like "hello" + "world", change this into "helloworld"
-    def parse_concatenated_string: () -> untyped
+    def parse_concatenated_string: () -> bool
+
+    def repair_number_ending_with_numeric_symbol: (::Integer start) -> void
 
-    def repair_number_ending_with_numeric_symbol: (untyped start) -> untyped
+    # Repair a number missing its digit before the decimal point, like ".5"
+    # or "-.5", into "0.5" / "-0.5".
+    def repair_leading_dot_number: (::String num) -> ::String
 
     # Parse and repair Newline Delimited JSON (NDJSON):
     # multiple JSON objects separated by a newline character
-    def parse_newline_delimited_json: () -> untyped
+    def parse_newline_delimited_json: () -> void
 
-    def skip_escape_character: () -> untyped
+    def skip_escape_character: () -> bool
 
-    def throw_invalid_character: (untyped char) -> untyped
+    # `bot` (bottom) because these always raise — steep needs this to
+    # treat their call sites as unreachable so methods like `repair`
+    # type-check (the trailing `throw_unexpected_character` must not
+    # contribute `void` to the method's union return type).
+    def throw_invalid_character: (::String char) -> bot
 
-    def throw_unexpected_character: () -> untyped
+    def throw_unexpected_character: () -> bot
 
-    def throw_unexpected_end: () -> untyped
+    def throw_unexpected_end: () -> bot
 
-    def throw_object_key_expected: () -> untyped
+    def throw_object_key_expected: () -> bot
 
-    def throw_colon_expected: () -> untyped
+    def throw_colon_expected: () -> bot
 
-    def throw_invalid_unicode_character: () -> untyped
+    def throw_invalid_unicode_character: () -> bot
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: json-repair
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Aleksandr Zykov