optimization

Author: le0pard

lib/json_mend/parser.rb

@@ -357,7 +357,7 @@ def parse_string
       char = prepare_string_parsing
 
       # A valid string can only start with a valid quote or, in our case, with a literal
-      while !@scanner.eos? && !STRING_DELIMITERS.include?(char) && !char.match?(/[\p{L}0-9]/)
+      while !@scanner.eos? && !STRING_DELIMITERS.include?(char) && !char.match?(/[\p{L}0-9$_-]/)
         return '' if TERMINATORS_STRING_GUESSED.include?(char)
 
         @scanner.getch
@@ -436,7 +436,7 @@ def determine_delimiters(char:)
       when '“'
         lstring_delimiter = '“'
         rstring_delimiter = '”'
-      when /[\p{L}0-9]/
+      when /[\p{L}0-9$_-]/
         # Could be a boolean/null, but not if it's an object key.
         if BOOLEAN_OR_NULL_CHARS.include?(char.downcase) && !current_context?(:object_key)
           # parse_literal is non-destructive if it fails to match.
@@ -512,12 +512,13 @@ def check_unmatched_delimiters(
       # --- Main Parsing Loop ---
       while !@scanner.eos? && char != rstring_delimiter
         # Fast-path for unquoted keys (e.g. { key: val })
-        # consumes a chunk of valid identifier characters at once.
+        # consumes a chunk of valid identifier characters at once
         if missing_quotes && current_context?(:object_key)
           chunk = @scanner.scan(/[a-zA-Z0-9_$-]+/)
           if chunk
             string_parts << chunk
             char = peek_char
+            next
           end
         end
 
@@ -991,8 +992,7 @@ def parse_number
 
       # Handle cases where the number ends with an invalid character.
       if !scanned_str.empty? && INVALID_NUMBER_TRAILERS.include?(scanned_str[-1])
-        # Rewind scanner for the invalid char so it can be handled by the main loop (e.g. as a separator)
-        @scanner.pos -= 1
+        # Do not rewind scanner, simply discard the invalid trailing char (garbage)
         scanned_str = scanned_str[0...-1]
       # Handle cases where what looked like a number is actually a string.
       # e.g. "123-abc"
@@ -1218,7 +1218,7 @@ def context_contain?(value)
 
     # Checks if the character signifies the start of a string or literal
     def string_start?(char)
-      STRING_DELIMITERS.include?(char) || char&.match?(/\p{L}/)
+      STRING_DELIMITERS.include?(char) || char&.match?(/[\p{L}$_]/)
     end
 
     # Checks if the character signifies the start of a number

spec/json_mend_spec.rb

@@ -1204,6 +1204,123 @@
       end
     end
 
+    context 'when fast-path for unquoted keys' do
+      [
+        {
+          input: '{ simple: "val" }',
+          expected_output: JSON.dump({ 'simple' => 'val' }),
+          desc: 'simple alphabetic unquoted key'
+        },
+        {
+          input: '{ my_var_name: "val" }',
+          expected_output: JSON.dump({ 'my_var_name' => 'val' }),
+          desc: 'underscored identifier'
+        },
+        {
+          input: '{ $special-var_1: "val" }',
+          expected_output: JSON.dump({ '$special-var_1' => 'val' }),
+          desc: 'special characters ($, -) allowed in fast-path regex'
+        },
+        {
+          input: '{ key1: "v1", key2: "v2", key3: "v3" }',
+          expected_output: JSON.dump({ 'key1' => 'v1', 'key2' => 'v2', 'key3' => 'v3' }),
+          desc: 'sequence of fast-path keys'
+        },
+        {
+          input: '{veryLongVariableNameThatShouldBeScannedInOneGo: true}',
+          expected_output: JSON.dump({ 'veryLongVariableNameThatShouldBeScannedInOneGo' => true }),
+          desc: 'long key triggering chunk scan'
+        },
+        {
+          input: '{ key:val }',
+          expected_output: JSON.dump({ 'key' => 'val' }),
+          desc: 'unquoted key and unquoted value'
+        }
+      ].each do |tc|
+        it "correctly parses #{tc[:desc]}" do
+          expect(described_class.repair(tc[:input])).to eq(tc[:expected_output])
+        end
+      end
+    end
+
+    context 'when parse_number optimization and rewind logic' do
+      [
+        {
+          input: '{"a":1,"b":2}',
+          expected_output: JSON.dump({ 'a' => 1, 'b' => 2 }),
+          desc: 'compact JSON with comma immediately following number'
+        },
+        {
+          input: '{"a":123,"b":456}',
+          expected_output: JSON.dump({ 'a' => 123, 'b' => 456 }),
+          desc: 'compact JSON with multi-digit numbers'
+        },
+        {
+          input: '{"float":1.5,"int":1}',
+          expected_output: JSON.dump({ 'float' => 1.5, 'int' => 1 }),
+          desc: 'compact JSON with mixed number types'
+        },
+        {
+          input: '[1,2,3,4]',
+          expected_output: JSON.dump([1, 2, 3, 4]),
+          desc: 'compact array with numbers'
+        },
+        {
+          input: '{"a": 1, "b": 2}',
+          expected_output: JSON.dump({ 'a' => 1, 'b' => 2 }),
+          desc: 'standard spacing (boundary check)'
+        },
+        {
+          input: '{"key": 1e5,}',
+          expected_output: JSON.dump({ 'key' => 100_000.0 }),
+          desc: 'scientific notation followed by comma'
+        },
+        {
+          input: '{"key": 123-}',
+          expected_output: JSON.dump({ 'key' => 123 }),
+          desc: 'number with invalid trailer needing strip and rewind'
+        }
+      ].each do |tc|
+        it "correctly handles #{tc[:desc]}" do
+          expect(described_class.repair(tc[:input])).to eq(tc[:expected_output])
+        end
+      end
+    end
+
+    context 'when peek_char unicode stability' do
+      [
+        {
+          input: '{"ascii": 1, "uni\u00f6": 2}',
+          expected_output: JSON.dump({ 'ascii' => 1, 'uniö' => 2 }),
+          desc: 'mixed ASCII and Unicode escape'
+        },
+        {
+          input: '{"👍": "thumbs_up"}',
+          expected_output: JSON.dump({ '👍' => 'thumbs_up' }),
+          desc: 'multibyte emoji as key'
+        },
+        {
+          input: '{"“smart”": "quotes"}',
+          expected_output: JSON.dump({ '“smart”' => 'quotes' }),
+          desc: 'multibyte smart quotes as key'
+        },
+        {
+          input: '{"key": "value with — dash"}',
+          expected_output: JSON.dump({ 'key' => 'value with — dash' }),
+          desc: 'multibyte char in value'
+        },
+        {
+          input: '{"Український": "text"}',
+          expected_output: JSON.dump({ 'Український' => 'text' }),
+          desc: 'Cyrillic characters'
+        }
+      ].each do |tc|
+        it "correctly parses #{tc[:desc]}" do
+          expect(described_class.repair(tc[:input])).to eq(tc[:expected_output])
+        end
+      end
+    end
+
     context 'with valid JSON (direct parser usage)' do
       [
         {