parsanol 1.3.54-x86_64-linux → 1.3.56-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5bae514bef05a395e67e1a181092c66abad3879886b25dc7b58ce1fc6ca7232b
-  data.tar.gz: d5bdca47f56229e079c2f58561ce3e8c170426c72bf332f72bf0bd6845e69c6c
+  metadata.gz: 66df514ceaedfb9d973a67ba46aa9a207602d8bba9103864bfdb39db558dc6ab
+  data.tar.gz: 853d2a548335096d7672ab4b4292770a25c260ccaaae8fae79cd2567bb9fa391
 SHA512:
-  metadata.gz: e5a87768c9e0fa87778f4ac19d1a143a784e0b1237eeaefeccb72513bb32d87f430c7b07858c0a29fad100a2fbf78c2310ca23c0b09a9beb740b93d48a348068
-  data.tar.gz: 5fdd8f646eb0ac9cb94fa9691f766257e6b769774f0cb425c3b60beb388d5ba16f787114b80996df48ec571181d910aaeb9423a598a0dc35bc4255f2f48321c6
+  metadata.gz: 5ffb88f39d23d6fcb14d2ac9ca589b8f44699dbb6691911e75265253d9f48c3447e14dd7c77a11bfc4047ab3d99fa7a3c9e4be030d798564d7757338904d40af
+  data.tar.gz: 24f5ce2a2b09f7b0c9d12d758cac3fba3372a1ba5ca22d209c193856d405a307f593d9246c8dbd6e80a9e25f6b9746ee79b0819a701afd174950f45018180208

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: 35019384 bytes
-sha256: e66763c08671dfa852759e529022361937f1d9bc4be44882fd1b670a371ba775
+size: 35066072 bytes
+sha256: 754a72fbf04eb7c51adb630381a3a695011edda945f6f728e5a22ae1bbfaf52a

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: 35249328 bytes
-sha256: 68f8e41d8578bd32e09711b10a6bc6e06d470056ade2cb0752203507e09fdd5d
+size: 35296024 bytes
+sha256: d85a6d3939482a73ed925708bdb6de3d1cc61ade10c01d2ecf4e7a24a6c3fe2b

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: 35248328 bytes
-sha256: 3177620199f2e4b5284fb28478dfef6b5a99c83b391293976c0424c4a06a3e4a
+size: 35295024 bytes
+sha256: b820397175deb40fe91edbb41a2c90a1b1529c8ed2c8d3e32284089442c5baac

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: 35258216 bytes
-sha256: 9546d92c2061bbfa436b8e14f43825bb05197f78501ee2a4a0d7209ce91cfd9a
+size: 35304912 bytes
+sha256: 6ebf6401932f29a1efd4cf417197979d72d449a6fda639d04df1efdbdabbac2b

data/lib/parsanol/atoms/base.rb

@@ -208,7 +208,7 @@ module Parsanol
 
       # Converts raw input to Source if needed.
       def normalize_input(source)
-        source.respond_to?(:line_and_column) ? source : Parsanol::Source.new(source)
+        source.is_a?(Parsanol::Source) ? source : Parsanol::Source.new(source)
       end
 
       # Detects if we're in a Parser context.

data/lib/parsanol/atoms/cut.rb

@@ -42,7 +42,7 @@ module Parsanol
         # 1. Mark the current position as a cut point
         # 2. Empty the backtrack stack (we won't backtrack past here)
         # 3. Aggressively evict cache entries before this position
-        context.cut!(source.bytepos) if context.respond_to?(:cut!)
+        context.cut!(source.bytepos)
 
         [success, value]
       end

data/lib/parsanol/atoms/repetition.rb

@@ -66,7 +66,7 @@ module Parsanol
       # @return [Array(Boolean, Object)] result
       def try(source, context, consume_all)
         # Check for tree memoization support
-        if context.respond_to?(:use_tree_memoization?) && context.use_tree_memoization?
+        if context.use_tree_memoization?
           return with_tree_cache(source, context, consume_all)
         end
 
@@ -183,6 +183,7 @@ module Parsanol
         last_failure = nil
 
         loop do
+          iteration_start = source.bytepos
           success, value = @parslet.apply(source, context, false)
 
           unless success
@@ -193,6 +194,11 @@ module Parsanol
           occurrence += 1
           result[occurrence] = value
 
+          # A body match that consumes nothing cannot make progress;
+          # looping again would re-match empty forever. Count the empty
+          # match, then stop — the min check below applies as usual.
+          break if source.bytepos == iteration_start
+
           break if @max && occurrence >= @max
         end
 
@@ -254,6 +260,7 @@ module Parsanol
         last_failure = nil
 
         loop do
+          iteration_start = source.bytepos
           success, value = @parslet.apply(source, context, false)
 
           unless success
@@ -265,6 +272,10 @@ module Parsanol
           result[occurrence] = value
           positions << source.bytepos
 
+          # Zero-width body match: count it, stop iterating (the min
+          # check below applies as usual) — mirrors try_general.
+          break if source.bytepos == iteration_start
+
           break if @max && occurrence >= @max
         end
 
@@ -287,7 +298,7 @@ module Parsanol
           context.store_tree_memo(cache_key, start_pos,
                                   result[1, occurrence], end_pos)
         end
-        context.release_array(positions) if context.respond_to?(:release_array)
+        context.release_array(positions)
 
         # Check minimum
         if occurrence < @min

data/lib/parsanol/cause.rb

@@ -74,7 +74,7 @@ module Parsanol
       line_num, col_num = @source.line_and_column(@position)
 
       formatted_msg = @message.map do |msg|
-        msg.respond_to?(:to_slice) ? msg.content.inspect : msg.to_s
+        msg.is_a?(Parsanol::Slice) ? msg.content.inspect : msg.to_s
       end.join
 
       "#{formatted_msg} at line #{line_num} char #{col_num}#{@parsing_label}."

data/lib/parsanol/error_reporter/contextual.rb

@@ -72,7 +72,7 @@ module Parsanol
         cause = super
 
         # Apply label if the atom has one
-        if atom.respond_to?(:label) && (lbl = atom.label)
+        if atom.is_a?(Parsanol::Atoms::Base) && (lbl = atom.label)
           maybe_update_label(lbl, src.pos.bytepos)
           cause.set_label(@active_label_text)
         end

data/lib/parsanol/lazy_result.rb

@@ -103,6 +103,15 @@ module Parsanol
 
     alias kind_of? is_a?
 
+    # The delegated interface: Array's full class contract (including
+    # Enumerable), computed once against the type rather than probed on
+    # instances.
+    ARRAY_METHODS = (
+      Array.instance_methods(true) + Enumerable.instance_methods + [:to_ary]
+    ).freeze
+
+    private_constant :ARRAY_METHODS
+
     # Respond to array methods.
     #
     # @param method [Symbol] Method name
@@ -110,7 +119,7 @@ module Parsanol
     # @return [Boolean] true if responds
     #
     def respond_to?(method, include_private = false)
-      super || to_a.respond_to?(method, include_private)
+      super || ARRAY_METHODS.include?(method)
     end
 
     # Delegate unknown methods to materialized array.
@@ -121,7 +130,7 @@ module Parsanol
     # @return [Object] Result of method call
     #
     def method_missing(method, ...)
-      if to_a.respond_to?(method)
+      if ARRAY_METHODS.include?(method)
         to_a.public_send(method, ...)
       else
         super
@@ -135,7 +144,7 @@ module Parsanol
     # @return [Boolean] true if method is supported
     #
     def respond_to_missing?(method, include_private = false)
-      to_a.respond_to?(method, include_private) || super
+      ARRAY_METHODS.include?(method) || super
     end
 
     # Compare with another object.

data/lib/parsanol/native/transformer.rb

@@ -391,15 +391,19 @@ module Parsanol
           return left.is_a?(Hash) ? left.merge(right) : left + right
         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)
-
-          return left.to_str + right.to_str
+        # String-like = String or Slice (both implement to_str). When
+        # only ONE side is string-like, the OTHER side wins — the
+        # original duck-typed priority, preserved exactly.
+        left_stringlike = left.is_a?(String) || left.is_a?(Parsanol::Slice)
+        right_stringlike = right.is_a?(String) || right.is_a?(Parsanol::Slice)
+        if left_stringlike && right_stringlike
+          return right if right.is_a?(Parsanol::Slice)
+          return left if left.is_a?(Parsanol::Slice)
+
+          return left + right
         end
-
-        return left if right.respond_to?(:to_str)
-        return right if left.respond_to?(:to_str)
+        return left if right_stringlike
+        return right if left_stringlike
 
         return left + [right] if right.is_a?(Hash)
         return [left] + right if left.is_a?(Hash)

data/lib/parsanol/native.rb

@@ -216,7 +216,9 @@ module Parsanol
         # cause from that directly — the failure path never needs a
         # reporter reparse. The single interpreter pass below stays only
         # to recover inputs from grammars native cannot express.
-        if grammar.respond_to?(:parse) && (m = error.message.match(NATIVE_POS_MARKER))
+        parsanol_grammar =
+          grammar.is_a?(Parsanol::Atoms::Base) || grammar.is_a?(Parsanol::Parser)
+        if parsanol_grammar && (m = error.message.match(NATIVE_POS_MARKER))
           source = Parsanol::Source.new(input)
           success, value = grammar.run_with_context(source, nil, true)
           return grammar.finalize_result(value) if success
@@ -227,7 +229,7 @@ module Parsanol
           raise Parsanol::ParseFailed.new(cause.to_s, cause)
         end
 
-        if grammar.respond_to?(:parse)
+        if parsanol_grammar
           # No native diagnostics (e.g. incomplete-input errors): one
           # interpreter pass with the reporter attached — a success
           # recovers the tree, a failure raises the cause tree.

data/lib/parsanol/parser.rb

@@ -255,7 +255,7 @@ module Parsanol
     # already produced. The full per-atom event stream of the Ruby
     # engine remains available via an explicit `mode: :ruby`.
     def feed_native_reporter(reporter, input, error)
-      return unless reporter.respond_to?(:err_at)
+      return unless reporter.is_a?(Parsanol::ErrorReporter::Base)
 
       source = Parsanol::Source.new(input)
       cause = error.parse_failure_cause

data/lib/parsanol/pattern.rb

@@ -90,7 +90,7 @@ module Parsanol
       return true if pattern_val === target
 
       # Check if pattern is a binding expression (like simple(:x))
-      if pattern_val.respond_to?(:can_bind?) && pattern_val.can_bind?(target)
+      if pattern_val.is_a?(Parsanol::Pattern::SubtreeBind) && pattern_val.can_bind?(target)
         return capture_binding(target, pattern_val, captured)
       end
 

data/lib/parsanol/pool.rb

@@ -119,7 +119,7 @@ module Parsanol
       end
 
       # Reset object state if it supports the protocol
-      obj.reset! if obj.respond_to?(:reset!)
+      obj.reset! if obj.is_a?(Parsanol::Resettable)
 
       @stats[:released] += 1
       @available.push(obj)

data/lib/parsanol/rope.rb

@@ -67,7 +67,7 @@ module Parsanol
     #
     # @return [Integer] The sum of all segment sizes
     def size
-      @segments.sum { |s| s.respond_to?(:size) ? s.size : s.to_s.size }
+      @segments.sum(&:size)
     end
 
     # Creates a rope from an existing string.

data/lib/parsanol/slice.rb

@@ -142,18 +142,16 @@ module Parsanol
 
     # Unified line/column computation:
     # - String input: compute from input string
-    # - LineCache: delegate to cache
+    # - Source / LineCache: delegate
     def line_and_column_at(pos)
-      if @input.respond_to?(:line_and_column)
-        # LineCache or duck-typed object
-        @input.line_and_column(pos)
-      else
-        # String input
+      if @input.is_a?(String)
         prefix = @input.byteslice(0, pos) || ""
         line = 1 + prefix.count("\n")
         last_nl = prefix.rindex("\n")
         column = last_nl ? pos - last_nl : pos + 1
         [line, column]
+      else
+        @input.line_and_column(pos)
       end
     end
   end

data/lib/parsanol/source/line_cache.rb

@@ -34,7 +34,7 @@ module Parsanol
       def line_and_column(position)
         scan_buffer_once
 
-        position = position.bytepos if position.respond_to?(:bytepos)
+        position = position.bytepos if position.is_a?(Parsanol::Source)
 
         line_idx = @breaks.lower_bound_index(position)
 

data/lib/parsanol/source.rb

@@ -33,9 +33,9 @@ module Parsanol
     # @raise [ArgumentError] if input doesn't respond to to_str
     #
     def initialize(input)
-      unless input.respond_to?(:to_str)
+      unless input.is_a?(String)
         raise ArgumentError,
-              "Source requires a string-like object (responds to to_str)"
+              "Source requires a String (got #{input.class})"
       end
 
       @raw_string = input.to_str

data/lib/parsanol/version.rb

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

data/lib/parsanol/vm.rb

@@ -149,6 +149,7 @@ module Parsanol
       def compile_with_inline(atom, inline)
         root = atom.is_a?(Parsanol::Parser) ? atom.root : atom
         compiler = Compiler.new(inline: inline)
+        validate_alternatives(root)
         return nil unless compiler.compile_atom(root, true)
 
         # HALT terminates the MAIN program; subroutines follow it so the
@@ -174,6 +175,81 @@ module Parsanol
         compiler.to_program
       end
 
+      def validate_choice_branches(atom)
+        atom.alternatives.each_with_index do |branch, idx|
+          walk_branch = branch
+          next if idx == atom.alternatives.size - 1
+
+          # Entities resolve lazily and may be recursive; resolve
+          # through the wrapper for the nullability check only.
+          while walk_branch.is_a?(Parsanol::Atoms::Entity) ||
+              walk_branch.is_a?(Parsanol::Atoms::Named)
+            walk_branch = begin
+              walk_branch.parslet
+            rescue StandardError
+              nil
+            end
+            break if walk_branch.nil?
+          end
+          next if walk_branch.nil?
+          next unless Compiler.new.nullable?(walk_branch)
+
+          raise Parsanol::GrammarError,
+                "wrong grammar: alternative branch #{idx} " \
+                "(#{branch.inspect}) can match empty input and is not " \
+                "the last branch — ordered choice commits to its empty " \
+                "match, so #{atom.alternatives.size - idx - 1} later " \
+                "branch(es) can never match at positions where it " \
+                "matches empty. Reorder branches so empty-matchable " \
+                "ones come last, or make the branch non-empty."
+        end
+      end
+
+      # Grammar validation, run once per compile: an ordered-choice
+      # branch that can match empty input while not being last commits
+      # to its empty match and permanently shadows every later branch —
+      # the grammar is wrong, and inputs it would mis-parse fail with a
+      # baffling cause. Raise before any input is seen.
+      def validate_alternatives(root)
+        visited = {}.compare_by_identity
+        walk = lambda do |atom, depth|
+          next if atom.nil? || depth > 20
+          next if visited[atom]
+
+          visited[atom] = true
+          case atom
+          when Parsanol::Atoms::Alternative
+            validate_choice_branches(atom)
+            atom.alternatives.each { |c| walk.call(c, depth + 1) }
+          when Parsanol::Atoms::Sequence
+            atom.parslets.each { |c| walk.call(c, depth + 1) }
+          when Parsanol::Atoms::Repetition, Parsanol::Atoms::Named
+            walk.call(atom.parslet, depth + 1)
+          when Parsanol::Atoms::Lookahead
+            walk.call(atom.bound_parslet, depth + 1)
+          when Parsanol::Atoms::Ignored
+            walk.call(atom.wrapped_atom, depth + 1)
+          when Parsanol::Atoms::Entity
+            begin
+              walk.call(atom.parslet, depth + 1)
+            rescue Parsanol::GrammarError
+              raise
+            rescue StandardError
+              # Lazily resolved / recursive entity that cannot resolve
+              # outside a parse: skip this branch of the walk.
+              nil
+            end
+          when Parsanol::Atoms::Scope
+            begin
+              walk.call(atom.block.call, depth + 1)
+            rescue StandardError
+              nil
+            end
+          end
+        end
+        walk.call(root, 0)
+      end
+
       # Executes a compiled program. Returns [true, value] on success;
       # [false, nil] on failure or budget exhaustion — callers fall back
       # to the interpreter, which reproduces exact diagnostics.
@@ -977,12 +1053,24 @@ module Parsanol
             count = frames[cbase]
             return BAIL if count.nil?
 
+            old_end = frames[cbase + 1]
             count += 1
             frames[cbase] = count
             frames[cbase + 1] = pos
             max = ops[pc + 3]
             pc = if max && count >= max
                    ops[pc + 2] # exit
+                 elsif pos == old_end
+                   # Zero-width body match: count it, stop iterating.
+                   # Mirrors Repetition#try_general: success with the
+                   # prefix when min is met, failure of the repetition
+                   # otherwise.
+                   if count >= frames[cbase + 3]
+                     ops[pc + 2] # exit
+                   else
+                     frames.slice!(cbase..)
+                     fail_pc
+                   end
                  else
                    ops[pc + 1] # test
                  end

data/lib/parsanol.rb

@@ -44,6 +44,12 @@ module Parsanol
     base.extend(ClassMethods)
   end
 
+  # Raised when the GRAMMAR itself is malformed — detected before any
+  # input is parsed. The canonical case: an ordered-choice branch that
+  # can match empty input while not being last, which commits to its
+  # empty match and permanently shadows every later branch.
+  class GrammarError < StandardError; end
+
   # Exception raised when parsing fails. Contains detailed error information
   # in the #parse_failure_cause attribute.
   class ParseFailed < StandardError

metadata

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