parsanol 1.3.44-x86_64-linux → 1.3.45-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3462396a466396e4051285e9dfffad10efc49b495c3730018e360dc53765ce1e
-  data.tar.gz: f3a4f6478ef3efacfd17b3532c7b3b044f18154f94743525a916ee248294a254
+  metadata.gz: 6ed8f95c36bf9e3dd85b870a405ccbcec380716c96289d93cd86b7c37dee85a7
+  data.tar.gz: 862a88b04453dff2b2d592cd0738f7a7f7eae8d33ebf8f12840d3866284a0b95
 SHA512:
-  metadata.gz: e2fce0073aa484546216662e8cfa5752a94df0f38ccf2941851d4201634f936b352b6807bc5d6dcf3037caef723bfb1fb1c9e28262a87f1a750a1bf803129311
-  data.tar.gz: eea570245005ac91445440385e7cde74b56aabd5e5ec39934500220a90494a11bb588853849c4d4cbe4791eadf36b45352967ba5b9df9341929180dec8c10471
+  metadata.gz: b44f418c7e8ad987128ee60d3b75fba74cd20fa424690966343c761908a7054882f76a84b756303794d01c2a2a1082586b8f0894c4964681fceb8b6b5d78971f
+  data.tar.gz: 20d795c4f67853769740817322ade2714d3978cbf6ffa81bb2cb7ace226d682b3165daf3d7888e99c0778df370da79d3a3888b80793fa9f5849528b9549f8615

data/lib/parsanol/3.2/parsanol_native.so

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: data/lib/parsanol/3.2/parsanol_native.so
-size: 33786784 bytes
-sha256: cb9572b970bf3ccdd14ea21deb7301327842e78e6510a0a34527fa805adad109
+size: 34568360 bytes
+sha256: c2f5a5efc114a59720cc992e300aeede1934333de9066e5ad5e502c7e795b78d

data/lib/parsanol/3.3/parsanol_native.so

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: data/lib/parsanol/3.3/parsanol_native.so
-size: 34016368 bytes
-sha256: 363319e524c95c613ae3d5b7fcf44f297ebdd99176acb7a4d5663aca10f64ffa
+size: 34797976 bytes
+sha256: 4d0b945dc2434399b9bb4aebc0a25d39cfef140091eab772320afe027b519a2d

data/lib/parsanol/3.4/parsanol_native.so

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: data/lib/parsanol/3.4/parsanol_native.so
-size: 34015400 bytes
-sha256: 8145581cae5120e09405fd705e2da0f4da292bd5e4e9d4dd50fc81bb8d4a8ba7
+size: 34788784 bytes
+sha256: 9392d2b6618f0a15b0701863b9f5c316eb55274cf67ef5975bfd467719ff90af

data/lib/parsanol/4.0/parsanol_native.so

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: data/lib/parsanol/4.0/parsanol_native.so
-size: 34025312 bytes
-sha256: 10cdb11297339a9df70139ae3f24bc3c3308d07156fe7a008aeccf1070868185
+size: 34798712 bytes
+sha256: 2b0a6f998b61524c94579f09d5aa7dafa1d5961f156110699ff9352bf97f845d

data/lib/parsanol/native/batch_decoder.rb

@@ -169,6 +169,13 @@ module Parsanol
             @pos += 1
             str = decode_inline_string_bytes(len)
             str.to_sym
+          when TAG_INLINE_STRING
+            # Inline string: len, then u64 chunks (same wire form as
+            # TAG_SYMBOL without the to_sym). Emitted by the rs 0.8.x
+            # engine; previously unhandled here (parsanol-ruby#83).
+            len = @data[@pos]
+            @pos += 1
+            decode_inline_string_bytes(len)
           when TAG_REPETITION
             inner = decode_value
             [:repetition, inner].compact

data/lib/parsanol/native/transformer.rb

@@ -83,7 +83,8 @@ module Parsanol
         elsif [REPETITION_SYM, REPETITION_TAG].include?(first)
           # Optimized: transform items starting from index 1
           len = arr.length
-          return EMPTY_ARRAY if len == 1
+          # Empty repetition: named → [], unnamed → "" (CanFlatten#flatten_repetition)
+          return (named ? EMPTY_ARRAY : EMPTY_STRING) if len == 1
 
           items = Array.new(len - 1)
           i = 0
@@ -91,7 +92,7 @@ module Parsanol
             items[i] = transform(arr[i + 1])
             i += 1
           end
-          flatten_repetition(items)
+          flatten_repetition(items, named: named)
         elsif [MAYBE_SYM, MAYBE_TAG].include?(first)
           # Maybe flattens to nil-or-value (named) or ""-or-value (unnamed),
           # never to an array
@@ -290,309 +291,98 @@ module Parsanol
         result
       end
 
-      # Flatten sequence items according to Parslet semantics:
-      # 1. If ALL items are hashes, return as array (this is a repetition result)
-      # 2. If there are named captures (hashes) among Slices/strings, return ONLY the merged hash (discard Slices/strings)
-      # 3. If only Slices/strings, join them preserving position from first Slice
-      # 4. Return single value if only one item
-      #
-      # This matches Parslet's behavior where:
-      #   str('SCHEMA') >> str(' ') >> match('[a-z]').repeat(1).as(:name) >> str(';')
-      #   returns: {:name => "test"}  (not ["SCHEMA ", {:name=>"test"}, ";"])
-      #
-      # But for repetitions with named captures:
-      #   match('[a-z]').as(:x).repeat(2)
-      #   returns: [{:x => "a"}, {:x => "b"}]  (array of hashes, NOT merged!)
-      #
-      # Optimized: Single-pass with direct result building
+      # Exact port of Parslet::Atoms::CanFlatten#flatten_sequence /
+      # #merge_fold / #flatten_repetition / #foldl. Heuristic single-pass
+      # rewrites diverged from this (parsanol-ruby#83); stay byte-for-byte
+      # with parslet's fold. Hot shapes (all-Hash, all-stringlike)
+      # short-circuit before the fold to avoid per-step allocations.
+      def self.foldl(list, &)
+        return EMPTY_STRING if list.empty?
+
+        list.drop(1).inject(list.first, &)
+      end
+
       def self.flatten_sequence(items)
-        return EMPTY_ARRAY if items.empty? # Match Parsanol Ruby mode
-        return items.first if items.length == 1
-
-        # Single pass: categorize items
-        merged_hash = {}
-        slice_or_string_parts = []
-        hash_count = 0
-        total_items = 0
-        has_non_empty_array = false
-
-        items.each do |item|
-          case item
-          when Hash
-            merged_hash.merge!(item)
-            hash_count += 1
-            total_items += 1
-          when ::Parsanol::Slice, String
-            slice_or_string_parts << item
-            total_items += 1
-          when Array
-            # Check if this is a non-empty array (repetition result with content)
-            # Parslet behavior: when a sequence contains a non-empty repetition,
-            # the WHOLE sequence should be kept as array, not merged.
-            if item.empty?
-              # Empty repetition - skip (sequence semantics: merge rest)
-              # Don't increment total_items for empty arrays
-            else
-              # Check if array contains only hashes (repetition wrapper pattern)
-              # In this case, merge the inner hashes into merged_hash
-              non_hash_items = item.grep_v(Hash)
-              all_items_are_hashes = non_hash_items.empty?
-
-              if all_items_are_hashes
-                # Check if merging would overwrite existing keys in merged_hash.
-                # If so, this is a repetition pattern (item >> (sep >> item).repeat)
-                # and should be kept as array, not merged.
-                # Example: merged_hash={namedTypeOrRename: A}, array=[{namedTypeOrRename: B}]
-                # → should produce [{namedTypeOrRename: A}, {namedTypeOrRename: B}]
-                existing_keys = merged_hash.keys
-                repeated_keys = item.flat_map(&:keys).tally.any? { |_key, count| count > 1 }
-                shares_keys = repeated_keys || item.any? do |sub_item|
-                  sub_item.is_a?(Hash) && sub_item.keys.intersect?(existing_keys)
-                end
-
-                if shares_keys
-                  has_non_empty_array = true
-                  item.each do |sub_item|
-                    hash_count += 1 if sub_item.is_a?(Hash)
-                  end
-                  total_items += 1
-                else
-                  item.each do |sub_item|
-                    merged_hash.merge!(sub_item) if sub_item.is_a?(Hash)
-                  end
-                end
-              else
-                # Non-empty repetition with non-hash items - mark that we should keep as array
-                has_non_empty_array = true
-                # Still collect items for potential array result
-                item.each do |sub_item|
-                  case sub_item
-                  when Hash
-                    hash_count += 1
-                  when ::Parsanol::Slice, String
-                    slice_or_string_parts << sub_item
-                  end
-                end
-                total_items += 1
-              end
-            end
-          when nil
-            # Skip nil values (from lookahead or optional that didn't match)
-          else
-            total_items += 1
-          end
+        list = items.compact
+        return EMPTY_STRING if list.empty?
+        return list.first if list.length == 1
+
+        # Hot path: all-hash sequence. Single-pass merge preserves
+        # parslet's merge_fold(Hash, Hash) last-wins semantics.
+        if list.all?(Hash)
+          return list.reduce { |acc, hash| acc.merge(hash) }
         end
 
-        # PARSLET SEQUENCE BEHAVIOR WITH REPETITIONS:
-        # If the sequence contains a non-empty repetition result (array with items),
-        # return as array instead of merging.
-        # Example: factor.as(:left) >> (op >> factor).as(:rhs).repeat
-        # With input "a+b" produces: [{left: {...}}, {rhs: {...}}]
-        # With input "a" produces: {left: {...}} (empty repetition, merge)
-        if has_non_empty_array
-          # Flatten the items: top-level hashes + array items
-          result = []
-          items.each do |item|
-            case item
-            when Hash
-              result << item
-            when Array
-              result.concat(item)
-            when ::Parsanol::Slice, String
-              # Skip unnamed Slices/strings when we have named captures
-            end
-          end
-          return result.length == 1 ? result.first : result
+        # Hot path: all stringlike (String/Slice). Build one Slice
+        # from the first Slice's offset, joining contents in place.
+        if list.all? { |x| x.is_a?(::Parsanol::Slice) || x.is_a?(String) }
+          first_slice = list.find { |x| x.is_a?(::Parsanol::Slice) }
+          content = list.map { |x| x.is_a?(::Parsanol::Slice) ? x.content : x.to_s }.join
+          return first_slice ? ::Parsanol::Slice.new(first_slice.offset, content, first_slice.input) : content
         end
 
-        # KEY INSIGHT: If ALL items are hashes, we need to determine:
-        # 1. WRAPPER PATTERN: All hashes have the SAME single key, and values are HASHES
-        #    => Merge the inner hashes under that key
-        #    Example: [{:syntax => {:spaces => {...}}},
-        #              {:syntax => {:schemaDecl => [...]}}]
-        #    Result: {:syntax => {:spaces => {...}, :schemaDecl => [...]}}
-        #
-        # 2. REPETITION PATTERN: All hashes have the SAME single key, but values are SIMPLE
-        #    => Keep as array (this is a repetition result)
-        #    Example: [{:letter => "a"}, {:letter => "b"}, {:letter => "c"}]
-        #    Result: [{:letter => "a"}, {:letter => "b"}, {:letter => "c"}]
-        #
-        # 3. MIXED KEYS: Hashes have DIFFERENT keys
-        #    => Merge into single hash
-        #    Example: [{:explicitAttr => {...}}, {:whereClause => {...}}]
-        #    Result: {:explicitAttr => {...}, :whereClause => {...}}
-        if hash_count == total_items && hash_count > 1
-          # Check if all hashes have the same single key
-          first_item = items.first
-          if first_item.is_a?(Hash) && first_item.keys.length == 1
-            wrapper_key = first_item.keys.first
-
-            # Verify all items are hashes with the same single key
-            all_same_wrapper = items.all? do |item|
-              item.is_a?(Hash) && item.keys.length == 1 && item.keys.first == wrapper_key
-            end
+        # Cold path: parslet's exact fold (Hash/Slice/String/Array
+        # mixtures, including the #83 paragraph cases).
+        foldl(list) { |acc, item| merge_fold(acc, item) }
+      end
 
-            if all_same_wrapper
-              # Check if values are all hashes (wrapper pattern) or not (repetition pattern)
-              all_values_are_hashes = items.all? do |item|
-                item[wrapper_key].is_a?(Hash)
-              end
-
-              return items unless all_values_are_hashes
-
-              # Check if inner hashes have the same keys or different keys
-              # REPETITION pattern (same keys like entity_decl): keep as array
-              # WRAPPER pattern (different keys like spaces vs schemaDecl): merge
-              first_inner_keys = items.first[wrapper_key].keys.to_set
-              items.all? do |item|
-                item[wrapper_key].keys.to_set == first_inner_keys
-              end
-
-              # Check if items have single keys or multiple keys
-              # - Single key items with repeated outer key = true repetition (keep array)
-              # - Multiple key items with repeated outer key = duplicate labels in sequence (merge)
-              max_keys_per_item = items.map do |item|
-                item.is_a?(Hash) ? item.keys.length : 0
-              end.max || 0
-
-              # Check if inner values are hashes with different keys
-              # This distinguishes:
-              # - True repetition: [{letter: 'a'}, {letter: 'b'}] - inner is string
-              # - Duplicate labels: [{group: {char: 'a'}}, {group: {digit: '5'}}] - inner is hash with different keys
-              inner_keys_all_same = true
-              first_inner_keys = nil
-              if items.all? do |item|
-                item.is_a?(Hash) && item[wrapper_key].is_a?(Hash)
-              end
-                first_inner_keys = items.first[wrapper_key].keys.to_set
-                inner_keys_all_same = items.all? do |item|
-                  item[wrapper_key].keys.to_set == first_inner_keys
-                end
-              end
-
-              # DUPLICATE LABELS IN SEQUENCE: multiple keys per item with repeated outer key
-              # OR inner hashes with different keys
-              # Example: [{group: {char: 'a'}}, {group: {digit: '5'}}]
-              # Ruby semantics: merge with last value wins for the outer key
-              # This is different from true repetition where each item has exactly one key
-              has_duplicate_labels = max_keys_per_item > 1 || (first_inner_keys && !inner_keys_all_same)
-
-              # Check if inner hashes have the same keys or different keys
-              first_inner_keys ||= items.first[wrapper_key].keys.to_set
-              all_same_keys = items.all? do |item|
-                item[wrapper_key].keys.to_set == first_inner_keys
-              end
-
-              if has_duplicate_labels
-                # DUPLICATE LABELS PATTERN: items have multiple keys with repeated outer key
-                # OR inner hashes have different keys
-                # This is a SEQUENCE with duplicate .as() labels
-                # Ruby semantics: merge and keep last value for the outer key
-                merged = {}
-                items.each do |item|
-                  item.each do |k, v|
-                    merged[k] = v # Last value wins
-                  end
-                end
-                # Return only the wrapper key with its last value
-                return { wrapper_key => merged[wrapper_key] }
-              elsif all_same_keys
-                # TRUE REPETITION: each item has exactly one key
-                # Keep as array of hashes
-                # Example: [{letter: 'a'}, {letter: 'b'}] or [{schemaDecl: ...}, {schemaDecl: ...}]
-                return items
-              else
-                # DIFFERENT INNER KEYS with single keys: Same outer key with different inner keys
-                # This is a WRAPPER pattern - keep all items as array
-                # Example: [{:syntax => {:entityDecl => ...}}, {:syntax => {:typeDecl => ...}}]
-                # Should NOT merge or drop items - keep all declarations
-                return items
-              end
-
-              return items unless all_values_are_hashes
-
-              # Repetition pattern: keep as array
+      # Parslet compares exact classes (`left.class == right.class`) and
+      # uses `instance_of?` below — not `is_a?` — so Slice subclasses and
+      # Hash subclasses do not take the wrong branch.
+      def self.merge_fold(left, right)
+        # rubocop:disable Style/ClassEqualityComparison
+        if left.class == right.class
+          # rubocop:enable Style/ClassEqualityComparison
+          return left.is_a?(Hash) ? left.merge(right) : left + right
+        end
 
-            end
-          end
+        if left.respond_to?(:to_str) && right.respond_to?(:to_str)
+          return right if right.respond_to?(:to_slice)
+          return left if left.respond_to?(:to_slice)
 
-          # MIXED KEYS: Hashes have different keys
-          # Parslet sequence semantics: merge into single hash
-          return merged_hash
+          return left.to_str + right.to_str
         end
 
-        # PARSLET SEQUENCE SEMANTICS:
-        # If there are named captures (hashes) mixed with other things,
-        # return ONLY the merged hash (discard unnamed Slices/strings)
-        return merged_hash unless merged_hash.empty?
-
-        # No named captures - handle Slices/strings and other items
-        if slice_or_string_parts.any?
-          # Join Slices/strings, preserving position from first Slice
-          first_slice = slice_or_string_parts.find { |i| i.is_a?(::Parsanol::Slice) }
-          content = slice_or_string_parts.map do |i|
-            i.is_a?(::Parsanol::Slice) ? i.content : i
-          end.join
-
-          if first_slice
-            # Create new Slice with combined content, preserving position from first
-            return ::Parsanol::Slice.new(first_slice.offset, content,
-                                         first_slice.input)
-          else
-            # All plain strings (shouldn't happen with new decode_flat, but handle it)
-            return slice_or_string_parts.length == 1 ? slice_or_string_parts.first : content
-          end
-        end
+        return left if right.respond_to?(:to_str)
+        return right if left.respond_to?(:to_str)
 
-        # Only other items (arrays, etc.)
-        return EMPTY_ARRAY if total_items.zero?
+        return left + [right] if right.is_a?(Hash)
+        return [left] + right if left.is_a?(Hash)
 
-        items.length == 1 ? items.first : items
+        # Fallback: hoist both sides into an array (defensive; parslet
+        # raises here, but native trees can carry nested Arrays that
+        # parslet would already have folded).
+        Array(left) + Array(right)
       end
 
-      # Parslet/Parsanol repetition semantics:
-      # 1. Return [] for empty repetitions
-      # 2. If all items are Slices (or strings), join them preserving position
-      # 3. Otherwise return array
-      def self.flatten_repetition(items)
-        return EMPTY_ARRAY if items.empty?
-
-        # Single-pass flatten and check
-        flat_items = []
-        all_slices_or_strings = true
-
-        items.each do |item|
-          if item.is_a?(Array)
-            item.each do |sub|
-              flat_items << sub
-              all_slices_or_strings = false unless slice_or_string?(sub)
-            end
-          else
-            flat_items << item
-            all_slices_or_strings = false unless slice_or_string?(item)
-          end
+      # Exact port of Parslet::Atoms::CanFlatten#flatten_repetition.
+      # `named` is true only when this repetition is the direct child of
+      # a Named (.as(...)); it controls empty-list folding ([] vs "").
+      # `instance_of?` (not `is_a?`/`any?(Hash)`) matches parslet.
+      def self.flatten_repetition(items, named: false)
+        # rubocop:disable Style/PredicateWithKind
+        if items.any? { |e| e.instance_of?(Hash) }
+          return items.select { |e| e.instance_of?(Hash) }
         end
 
-        return EMPTY_ARRAY if flat_items.empty?
+        if items.any? { |e| e.instance_of?(Array) }
+          return items.select { |e| e.instance_of?(Array) }.flatten(1)
+        end
+        # rubocop:enable Style/PredicateWithKind
 
-        # If all Slices or strings, join them preserving position from first Slice
-        if all_slices_or_strings
-          first_slice = flat_items.find { |i| i.is_a?(::Parsanol::Slice) }
-          content = flat_items.map do |i|
-            i.is_a?(::Parsanol::Slice) ? i.content : i
-          end.join
+        return EMPTY_ARRAY if named && items.empty?
 
-          if first_slice
-            # Create new Slice with combined content, preserving position from first
-            ::Parsanol::Slice.new(first_slice.offset, content,
-                                  first_slice.input)
-          else
-            # All plain strings (shouldn't happen with new decode_flat, but handle it)
-            content
-          end
-        else
-          flat_items
+        # Hot path: all-stringlike repetition → foldl via concat.
+        # Cold path: parslet's exact fold.
+        if items.all? { |x| x.is_a?(::Parsanol::Slice) || x.is_a?(String) }
+          return EMPTY_STRING if items.empty?
+
+          first_slice = items.find { |x| x.is_a?(::Parsanol::Slice) }
+          content = items.map { |x| x.is_a?(::Parsanol::Slice) ? x.content : x.to_s }.join
+          return first_slice ? ::Parsanol::Slice.new(first_slice.offset, content, first_slice.input) : content
         end
+
+        foldl(items.compact) { |acc, item| acc + item }
       end
 
       # Check if value is a Slice or String

data/lib/parsanol/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Parsanol
-  VERSION = "1.3.44"
+  VERSION = "1.3.45"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: parsanol
 version: !ruby/object:Gem::Version
-  version: 1.3.44
+  version: 1.3.45
 platform: x86_64-linux
 authors:
 - Ribose Inc.