json_completer 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: acf870fc5a65bf4f4f1b586cfa61e012137fc96c0c48e3345d26a38da7d765bf
-  data.tar.gz: fe454f3e2485ae789840bb9c55c7fe72f3e8c9afffc9eccd0d13cc53ede8c05f
+  metadata.gz: 5d460af0d48e2cecf87411ba30d2a6aeac00fe38208d0222bf8b7218e373a2cc
+  data.tar.gz: 448401c51bc04e0a38fae036d3a64d94e5090846c39f69d081a8032b0b58e80a
 SHA512:
-  metadata.gz: 5cb2ad4d01e5f204cafc9b7fb4df996e319ba2c0dccdce6a16f23eacd2493cbdf1168c068c15586b7e4643863935ca70fe8e2628ed8e0994439fefa2151c60b7
-  data.tar.gz: 7dcd0cee8613e5a45f9cedbee90386234f31fe36ce832bb5abe160d4993b25a06d891340b9f17c0559026dd8e4b5bb4754a9a350ca480baed8791496f2837437
+  metadata.gz: 256f6ba460ef729a9babe9f9355f0d888c3c7f3dc64e3b4c85c2ae69ad6cb6c3a4b107aced36fe55b04e06302034b672f63c94c6db03b074a0462223eee8d5d1
+  data.tar.gz: 101f08a619d56129398b751815077897e3f557d581b76d075e41f57098e93ec92aa14d9f7edb1c88dbb8179f26d3aaf0fde3d81cfa986d2c912aa70b77294074

data/README.md

@@ -64,6 +64,8 @@ result3 = completer.parse('{"users": [{"name": "Alice"}, {"name": "Bob"}]}')
 # => {"users" => [{"name" => "Alice"}, {"name" => "Bob"}]}
 ```
 
+Stateful `JsonCompleter` instances assume append-only input. If earlier bytes change, create a new instance; truncation to a shorter prefix still resets state automatically.
+
 ### String Output with `.complete`
 
 Use `.complete` when you specifically need completed JSON text instead of parsed Ruby objects:
@@ -83,6 +85,7 @@ This is the second-tier option when another layer expects JSON text and you want
 - **Zero reprocessing**: Maintains parsing state to avoid reparsing previously processed data
 - **Linear complexity**: Each chunk processed in O(n) time where n = new data size, not total size
 - **Memory efficient**: Uses token-based accumulation with minimal state overhead
+- **Byte-oriented string scanning**: Walks JSON input as bytes and copies contiguous non-escape string content in slices to reduce per-character overhead on long streamed strings
 - **Context preservation**: Tracks nested structures without full document analysis
 
 ### Common Use Cases

data/lib/json_completer/completion_engine.rb

@@ -4,29 +4,31 @@ class JsonCompleter
   module CompletionEngine
     def complete(partial_json)
       input = partial_json
+      # Same byte-oriented trick as parse: compare ASCII JSON syntax as integers and avoid
+      # allocating transient 1-character strings in the streaming loop.
+      input_length = input.bytesize
 
-      if @state.nil? || @state.input_length > input.length
+      if @state.nil? || @state.input_length > input_length
         @state = ParsingState.new
       end
 
       return input if input.empty?
       return input if valid_json_primitive_or_document?(input)
 
-      if @state.input_length == input.length && !@state.output_tokens.empty?
+      if @state.input_length == input_length && !@state.output_tokens.empty?
         return finalize_completion(@state.output_tokens.dup, @state.context_stack.dup, @state.incomplete_string_token)
       end
 
       output_tokens = @state.output_tokens.dup
       context_stack = @state.context_stack.dup
       index = @state.last_index
-      length = input.length
       incomplete_string_token = @state.incomplete_string_token
 
       if incomplete_string_token && output_tokens.last&.start_with?('"') && output_tokens.last.end_with?('"')
         output_tokens.pop
       end
 
-      while index < length
+      while index < input_length
         if incomplete_string_token && index == @state.last_index
           index, status = Scanners.scan_string(input, index, incomplete_string_token)
 
@@ -38,32 +40,16 @@ class JsonCompleter
           next
         end
 
-        char = input[index]
+        byte = input.getbyte(index)
         last_significant_char_in_output = get_last_significant_char(output_tokens)
 
-        case char
-        when '{'
-          ensure_comma_before_new_item(output_tokens, context_stack, last_significant_char_in_output)
-          ensure_colon_if_value_expected(output_tokens, context_stack, last_significant_char_in_output)
-          output_tokens << char
-          context_stack << '{'
-          index += 1
-        when '['
-          ensure_comma_before_new_item(output_tokens, context_stack, last_significant_char_in_output)
-          ensure_colon_if_value_expected(output_tokens, context_stack, last_significant_char_in_output)
-          output_tokens << char
-          context_stack << '['
-          index += 1
-        when '}'
-          remove_trailing_comma(output_tokens)
-          output_tokens << char
-          context_stack.pop if !context_stack.empty? && context_stack.last == '{'
+        # ASCII byte values: 9/10/13/32 = whitespace, 34 = ", 44 = ,, 45 = -, 58 = :,
+        # 91/93 = [] , 102/110/116 = f/n/t, 123/125 = {}.
+        case byte
+        when 9, 10, 13, 32
+          output_tokens << input.byteslice(index, 1)
           index += 1
-        when ']'
-          output_tokens << char
-          context_stack.pop if !context_stack.empty? && context_stack.last == '['
-          index += 1
-        when '"'
+        when 34
           ensure_comma_before_new_item(output_tokens, context_stack, last_significant_char_in_output)
           ensure_colon_if_value_expected(output_tokens, context_stack, last_significant_char_in_output)
 
@@ -75,30 +61,62 @@ class JsonCompleter
           else
             incomplete_string_token = string_token
           end
-        when ':'
+        when 44
+          remove_trailing_comma(output_tokens)
+          output_tokens << ','
+          index += 1
+        when 45, 48..57
+          ensure_comma_before_new_item(output_tokens, context_stack, last_significant_char_in_output)
+          ensure_colon_if_value_expected(output_tokens, context_stack, last_significant_char_in_output)
+
+          num_str, consumed = Scanners.scan_number_literal(input, index)
+          output_tokens << num_str
+          index += consumed
+        when 58
           remove_trailing_comma(output_tokens) if last_significant_char_in_output == ','
-          output_tokens << char
+          output_tokens << ':'
           index += 1
-        when ','
-          remove_trailing_comma(output_tokens)
-          output_tokens << char
+        when 91
+          ensure_comma_before_new_item(output_tokens, context_stack, last_significant_char_in_output)
+          ensure_colon_if_value_expected(output_tokens, context_stack, last_significant_char_in_output)
+          output_tokens << '['
+          context_stack << '['
+          index += 1
+        when 93
+          output_tokens << ']'
+          context_stack.pop if !context_stack.empty? && context_stack.last == '['
           index += 1
-        when 't', 'f', 'n'
+        when 102
           ensure_comma_before_new_item(output_tokens, context_stack, last_significant_char_in_output)
           ensure_colon_if_value_expected(output_tokens, context_stack, last_significant_char_in_output)
 
-          keyword_val, consumed = Scanners.scan_keyword_literal(input, index, KEYWORD_MAP[char.downcase])
+          keyword_val, consumed = Scanners.scan_keyword_literal(input, index, KEYWORD_MAP['f'])
           output_tokens << keyword_val
           index += consumed
-        when '-', '0'..'9'
+        when 110
           ensure_comma_before_new_item(output_tokens, context_stack, last_significant_char_in_output)
           ensure_colon_if_value_expected(output_tokens, context_stack, last_significant_char_in_output)
 
-          num_str, consumed = Scanners.scan_number_literal(input, index)
-          output_tokens << num_str
+          keyword_val, consumed = Scanners.scan_keyword_literal(input, index, KEYWORD_MAP['n'])
+          output_tokens << keyword_val
+          index += consumed
+        when 116
+          ensure_comma_before_new_item(output_tokens, context_stack, last_significant_char_in_output)
+          ensure_colon_if_value_expected(output_tokens, context_stack, last_significant_char_in_output)
+
+          keyword_val, consumed = Scanners.scan_keyword_literal(input, index, KEYWORD_MAP['t'])
+          output_tokens << keyword_val
           index += consumed
-        when /\s/
-          output_tokens << char
+        when 123
+          ensure_comma_before_new_item(output_tokens, context_stack, last_significant_char_in_output)
+          ensure_colon_if_value_expected(output_tokens, context_stack, last_significant_char_in_output)
+          output_tokens << '{'
+          context_stack << '{'
+          index += 1
+        when 125
+          remove_trailing_comma(output_tokens)
+          output_tokens << '}'
+          context_stack.pop if !context_stack.empty? && context_stack.last == '{'
           index += 1
         else
           index += 1
@@ -109,7 +127,7 @@ class JsonCompleter
         output_tokens: output_tokens,
         context_stack: context_stack,
         last_index: index,
-        input_length: length,
+        input_length: input_length,
         incomplete_string_token: incomplete_string_token
       )
 

data/lib/json_completer/parser_engine.rb

@@ -4,72 +4,79 @@ class JsonCompleter
   module ParserEngine
     def parse(partial_json)
       input = partial_json
+      # The hot path works on raw bytes, not 1-character Ruby strings. JSON punctuation is ASCII,
+      # so getbyte/bytesize let us compare cheap integers while multibyte UTF-8 payload stays intact.
+      input_length = input.bytesize
 
       if @parse_state.nil? ||
-         @parse_state.input_length > input.length ||
-         (@parse_state.input_snapshot && !input.start_with?(@parse_state.input_snapshot))
+         @parse_state.input_length > input_length ||
+         (@parse_state.input_length < input_length && reset_parse_state_for_input_growth?(input))
+        @parse_state = self.class.new_parse_state
+      elsif @parse_state.input_length == input_length
+        if @parse_state.input_snapshot == input
+          finalize_parse_result
+          return @parse_state.root
+        end
+
         @parse_state = self.class.new_parse_state
       end
 
       return nil if input.empty?
 
       begin
-        if @parse_state.input_length == input.length
-          finalize_parse_result
-          return @parse_state.root
-        end
-
         prepare_parse_state_for_incremental_input
 
         index = @parse_state.last_index
-        while index < input.length
+        while index < input_length
           if @parse_state.token_state
             index = continue_parse_token(input, index)
             next
           end
 
-          char = input[index]
-          if top_level_value_complete? && char !~ /\s/
+          byte = input.getbyte(index)
+          if top_level_value_complete? && !whitespace_byte?(byte)
             raise ParseError, 'unexpected token after top-level value'
           end
 
-          case char
-          when /\s/
+          # ASCII byte values: 9/10/13/32 = whitespace, 34 = ", 44 = ,, 45 = -, 58 = :,
+          # 91/93 = [] , 102/110/116 = f/n/t, 123/125 = {}.
+          case byte
+          when 9, 10, 13, 32
             index += 1
-          when '{'
-            start_parse_container({})
+          when 34
+            start_parse_string_token
             index += 1
-          when '['
-            start_parse_container([])
+          when 44
+            parse_comma!
             index += 1
-          when '}'
-            close_parse_object!
+          when 45, 48..57
+            start_parse_number_token(byte)
             index += 1
-          when ']'
-            close_parse_array!
+          when 58
+            parse_colon!
             index += 1
-          when '"'
-            start_parse_string_token
+          when 91
+            start_parse_container([])
             index += 1
-          when ':'
-            parse_colon!
+          when 93
+            close_parse_array!
             index += 1
-          when ','
-            parse_comma!
+          when 102, 110, 116
+            start_parse_keyword_token(byte)
             index += 1
-          when 't', 'f', 'n'
-            start_parse_keyword_token(char)
+          when 123
+            start_parse_container({})
             index += 1
-          when '-', '0'..'9'
-            start_parse_number_token(char)
+          when 125
+            close_parse_object!
             index += 1
           else
-            raise ParseError, "unexpected token #{char.inspect}"
+            raise ParseError, "unexpected token #{input.byteslice(index, 1).inspect}"
           end
         end
 
         @parse_state.last_index = index
-        @parse_state.input_length = input.length
+        @parse_state.input_length = input_length
         @parse_state.input_snapshot = input
         finalize_parse_result
         @parse_state.root
@@ -172,10 +179,10 @@ class JsonCompleter
       @parse_state.token_state = nil
     end
 
-    def start_parse_number_token(first_char)
+    def start_parse_number_token(first_byte)
       slot = parse_value_slot!
       token = Scanners::NumberToken.new(slot: slot)
-      token.append(first_char)
+      token.append_byte(first_byte)
       assign_parse_slot(slot, token.parsed_value)
       transition_after_parse_value(slot)
       @parse_state.token_state = token
@@ -183,21 +190,22 @@ class JsonCompleter
 
     def continue_parse_number_token(input, index)
       token = @parse_state.token_state
+      length = input.bytesize
 
-      while index < input.length && token.append(input[index])
+      while index < length && token.append_byte(input.getbyte(index))
         assign_parse_slot(token.slot, token.parsed_value)
         index += 1
       end
 
       raise ParseError, 'invalid number literal' if token.invalid?
 
-      @parse_state.token_state = nil if index < input.length
+      @parse_state.token_state = nil if index < length
       index
     end
 
-    def start_parse_keyword_token(first_char)
+    def start_parse_keyword_token(first_byte)
       slot = parse_value_slot!
-      token = Scanners::KeywordToken.new(slot: slot, target: KEYWORD_MAP[first_char], matched: 1)
+      token = Scanners::KeywordToken.new(slot: slot, target: keyword_target_for_byte(first_byte), matched: 1)
       assign_parse_slot(slot, token.parsed_value)
       transition_after_parse_value(slot)
       @parse_state.token_state = token
@@ -205,14 +213,15 @@ class JsonCompleter
 
     def continue_parse_keyword_token(input, index)
       token = @parse_state.token_state
+      length = input.bytesize
 
-      while index < input.length && token.matched < token.target.length && token.append(input[index])
+      while index < length && token.matched < token.target.length && token.append_byte(input.getbyte(index))
         index += 1
       end
 
-      raise ParseError, 'invalid keyword literal' if token.matched < token.target.length && index < input.length
+      raise ParseError, 'invalid keyword literal' if token.matched < token.target.length && index < length
 
-      @parse_state.token_state = nil if index < input.length || token.matched == token.target.length
+      @parse_state.token_state = nil if index < length || token.matched == token.target.length
       index
     end
 
@@ -238,7 +247,6 @@ class JsonCompleter
 
         context.mode = :key_or_end
         context.current_key = nil
-
       end
     end
 
@@ -339,6 +347,39 @@ class JsonCompleter
       token.visible_key_replaced_value = token.context.container[current_key]
       token.context.container[current_key] = nil
     end
+
+    def reset_parse_state_for_input_growth?(input)
+      return false unless @parse_state.input_snapshot
+      return false unless prefix_validation_required?
+
+      !input.start_with?(@parse_state.input_snapshot)
+    end
+
+    def prefix_validation_required?
+      @parse_state.context_stack.empty?
+    end
+
+    def keyword_target_for_byte(byte)
+      case byte
+      when 102
+        'false'
+      when 110
+        'null'
+      when 116
+        'true'
+      else
+        raise ParseError, "unexpected keyword token byte: #{byte}"
+      end
+    end
+
+    def whitespace_byte?(byte)
+      case byte
+      when 9, 10, 13, 32
+        true
+      else
+        false
+      end
+    end
   end
 
   include ParserEngine

data/lib/json_completer/scanners.rb

@@ -14,15 +14,16 @@ class JsonCompleter
         self.escape_state = :backslash
       end
 
-      def append_char(char)
-        buffer << char
+      def append_slice(input, start_index, length)
+        buffer << input.byteslice(start_index, length)
       end
 
-      def append_simple_escape(char)
-        buffer << char
+      # completion keeps escape bytes verbatim, so convert the ASCII byte back into a 1-byte string.
+      def append_simple_escape(byte)
+        buffer << byte.chr(Encoding::UTF_8)
       end
 
-      def valid_simple_escape?(_char)
+      def valid_simple_escape?(_byte)
         true
       end
 
@@ -31,9 +32,9 @@ class JsonCompleter
         buffer << 'u'
       end
 
-      def append_unicode_digit(char)
-        unicode_digits << char
-        buffer << char
+      def append_unicode_digit(byte)
+        unicode_digits << byte
+        buffer << byte.chr(Encoding::UTF_8)
       end
 
       def finish_unicode_escape!; end
@@ -84,37 +85,43 @@ class JsonCompleter
         self.escape_state = :backslash
       end
 
-      def append_char(char)
-        buffer << char
+      def append_slice(input, start_index, length)
+        buffer << input.byteslice(start_index, length)
       end
 
-      def append_simple_escape(char)
-        buffer << case char
-                  when 'b'
+      # ASCII escape bytes: 98/102/110/114/116 = b/f/n/r/t.
+      def append_simple_escape(byte)
+        buffer << case byte
+                  when 98
                     "\b"
-                  when 'f'
+                  when 102
                     "\f"
-                  when 'n'
+                  when 110
                     "\n"
-                  when 'r'
+                  when 114
                     "\r"
-                  when 't'
+                  when 116
                     "\t"
                   else
-                    char
+                    byte
                   end
       end
 
-      def valid_simple_escape?(char)
-        ['"', '\\', '/', 'b', 'f', 'n', 'r', 't'].include?(char)
+      def valid_simple_escape?(byte)
+        case byte
+        when 34, 92, 47, 98, 102, 110, 114, 116
+          true
+        else
+          false
+        end
       end
 
       def start_unicode_escape!
         self.unicode_digits = String.new
       end
 
-      def append_unicode_digit(char)
-        unicode_digits << char
+      def append_unicode_digit(byte)
+        unicode_digits << byte
       end
 
       def finish_unicode_escape!
@@ -160,94 +167,97 @@ class JsonCompleter
         self.raw ||= String.new
       end
 
-      def append(char)
+      # append_byte consumes ASCII bytes, not 1-character strings:
+      # 45 = -, 46 = ., 48..57 = 0..9, 69/101 = E/e.
+      def append_byte(byte)
         case phase
         when nil
-          case char
-          when '-'
-            raw << char
+          case byte
+          when 45
+            raw << byte
             self.phase = :sign
-          when '0'
-            raw << char
+          when 48
+            raw << byte
             self.phase = :zero
-          when /[0-9]/
-            raw << char
+          when 49..57
+            raw << byte
             self.phase = :int
           else
             return false
           end
         when :sign
-          case char
-          when '0'
-            raw << char
+          case byte
+          when 48
+            raw << byte
             self.phase = :zero
-          when /[0-9]/
-            raw << char
+          when 49..57
+            raw << byte
             self.phase = :int
-          when '.'
-            raw << char
+          when 46
+            raw << byte
             self.phase = :frac_start
           else
             return false
           end
         when :zero
-          if char.match?(/[0-9]/)
+          if Scanners.digit_byte?(byte)
             self.invalid = true
             return false
-          elsif char == '.'
-            raw << char
+          elsif byte == 46
+            raw << byte
             self.phase = :frac_start
-          elsif %w[e E].include?(char)
-            raw << char
+          elsif Scanners.exponent_byte?(byte)
+            raw << byte
             self.phase = :exp_start
           else
             return false
           end
         when :int
-          if char.match?(/[0-9]/)
-            raw << char
-          elsif char == '.'
-            raw << char
+          if Scanners.digit_byte?(byte)
+            raw << byte
+          elsif byte == 46
+            raw << byte
             self.phase = :frac_start
-          elsif %w[e E].include?(char)
-            raw << char
+          elsif Scanners.exponent_byte?(byte)
+            raw << byte
             self.phase = :exp_start
           else
             return false
           end
         when :frac_start
-          return false unless char.match?(/[0-9]/)
+          return false unless Scanners.digit_byte?(byte)
 
-          raw << char
+          raw << byte
           self.phase = :frac
         when :frac
-          if char.match?(/[0-9]/)
-            raw << char
-          elsif %w[e E].include?(char)
-            raw << char
+          if Scanners.digit_byte?(byte)
+            raw << byte
+          elsif Scanners.exponent_byte?(byte)
+            raw << byte
             self.phase = :exp_start
           else
             return false
           end
         when :exp_start
-          if ['+', '-'].include?(char)
-            raw << char
+          case byte
+          when 43, 45
+            raw << byte
             self.phase = :exp_sign
-          elsif char.match?(/[0-9]/)
-            raw << char
+          when 48..57
+            raw << byte
             self.phase = :exp
           else
             return false
           end
         when :exp_sign
-          return false unless char.match?(/[0-9]/)
+          return false unless Scanners.digit_byte?(byte)
 
-          raw << char
+          raw << byte
           self.phase = :exp
         when :exp
-          return false unless char.match?(/[0-9]/)
+          return false unless Scanners.digit_byte?(byte)
 
-          raw << char
+          raw << byte
         end
 
         true
@@ -285,9 +295,9 @@ class JsonCompleter
         super
       end
 
-      def append(char)
+      def append_byte(byte)
         return false if matched >= target.length
-        return false unless char.downcase == target[matched]
+        return false unless (byte | 0x20) == target.getbyte(matched)
 
         self.matched += 1
         true
@@ -307,13 +317,17 @@ class JsonCompleter
 
     def scan_string(input, index, token)
       strict = token.is_a?(ParsedStringToken)
+      # JSON string syntax is ASCII, so scanning bytes is safe here: multibyte UTF-8 content is
+      # treated as opaque payload and copied via byteslice until we hit an ASCII delimiter/escape.
+      length = input.bytesize
+      segment_start = index
 
-      while index < input.length
-        char = input[index]
+      while index < length
+        byte = input.getbyte(index)
 
         if token.unicode_digits
-          if char.match?(/[0-9a-fA-F]/)
-            token.append_unicode_digit(char)
+          if hex_digit_byte?(byte)
+            token.append_unicode_digit(byte)
             index += 1
 
             if token.unicode_digits.length == 4
@@ -323,6 +337,7 @@ class JsonCompleter
               return [index, :invalid_unicode] if status == :invalid_unicode
             end
 
+            segment_start = index
             next
           end
 
@@ -332,54 +347,67 @@ class JsonCompleter
         end
 
         if token.escape_state == :backslash
-          if strict && token.pending_high_surrogate && char != 'u'
+          if strict && token.pending_high_surrogate && byte != 117
             return [index, :invalid_unicode]
           end
 
-          if char == 'u'
+          if byte == 117
             token.start_unicode_escape!
             index += 1
+            segment_start = index
             next
           end
 
-          return [index, :invalid_escape] unless token.valid_simple_escape?(char)
+          return [index, :invalid_escape] unless token.valid_simple_escape?(byte)
 
-          token.append_simple_escape(char)
+          token.append_simple_escape(byte)
           token.escape_state = nil
           index += 1
+          segment_start = index
           next
         end
 
-        case char
-        when '\\'
-          token.start_escape!
-          index += 1
-        when '"'
+        if strict && token.pending_high_surrogate && byte != 92
+          return [index, :invalid_unicode]
+        end
+
+        if byte == 34
+          token.append_slice(input, segment_start, index - segment_start) if index > segment_start
+
           if strict && token.pending_high_surrogate
             return [index, :invalid_unicode]
           end
 
           token.terminate!
           return [index + 1, :terminated]
-        else
-          if strict
-            return [index, :invalid_control_character] if char.ord < 0x20
-            return [index, :invalid_unicode] if token.pending_high_surrogate
-          end
+        end
 
-          token.append_char(char)
+        if byte == 92
+          token.append_slice(input, segment_start, index - segment_start) if index > segment_start
+          token.start_escape!
           index += 1
+          segment_start = index
+          next
+        end
+
+        if strict && byte < 0x20
+          token.append_slice(input, segment_start, index - segment_start) if index > segment_start
+          return [index, :invalid_control_character]
         end
+
+        index += 1
       end
 
+      token.append_slice(input, segment_start, index - segment_start) if index > segment_start
       [index, :incomplete]
     end
 
     def scan_number_literal(input, index)
       start_index = index
       token = NumberToken.new
+      length = input.bytesize
 
-      while index < input.length && token.append(input[index])
+      while index < length && token.append_byte(input.getbyte(index))
         index += 1
       end
 
@@ -389,14 +417,32 @@ class JsonCompleter
     def scan_keyword_literal(input, index, target_keyword)
       start_index = index
       token = KeywordToken.new(target: target_keyword)
+      length = input.bytesize
 
-      while index < input.length && token.append(input[index])
+      while index < length && token.append_byte(input.getbyte(index))
         index += 1
       end
 
-      return [input[start_index], 1] if token.matched.zero?
+      return [input.byteslice(start_index, 1), 1] if token.matched.zero?
 
       [target_keyword, index - start_index]
     end
+
+    def digit_byte?(byte)
+      byte.between?(48, 57)
+    end
+
+    def exponent_byte?(byte)
+      case byte
+      when 69, 101
+        true
+      else
+        false
+      end
+    end
+
+    def hex_digit_byte?(byte)
+      digit_byte?(byte) || byte.between?(65, 70) || byte.between?(97, 102)
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: json_completer
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Aha! (www.aha.io)
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-11 00:00:00.000000000 Z
+date: 2026-03-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec