parsanol 1.3.54 → 1.3.56

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ea29107bfe3e1b3ce6b66701239beffe98c16a2cb7207da64e81b43ea179544d
-  data.tar.gz: 6c31ecaaa82edb959a17b8a43ce5ac7d3fa3819c175e28637efac3a35e215760
+  metadata.gz: 9fd20e8200bbd5f3eadcab0100d7854cd97cafdea7a2a04c4b6fda000c3a46c5
+  data.tar.gz: d35a9d04dbb252eb567ddd4a267d1603a2e3ec538f32e866ad32bb6adcaf11a8
 SHA512:
-  metadata.gz: f4e3f11ff5bf640b96c2ed79bee2db2d2ef3d68efc409a8da5acb684c9b366d4af902ededc6f6e115163a491c27297027c8d5c9fd10975d43b458ccea2b3548a
-  data.tar.gz: f5ae7316b64a7979558eed0d592e13e3cb5edb79644d1d90c9f997bb34689e71075022f4e8b89dc0c86d5c8e678997eae532e086f36e1bd20c5e70f3408fb9aa
+  metadata.gz: 7432ac5ea256ecc15bc615dd342c38bf0912fca1cda343b7dcbeafb05e636b9461f110e0d15830f81434e426eccd62c353fc786eee21f1b51e94372ed3adf051
+  data.tar.gz: 609460b69aee699d6fd03d7ee90047f22f8d990e6abcd60e3bd8ebf48c99c853a94fd4d9290823069a517741fb3d8f7ff57c86d73a26746809eb35d1d223727b

data/Cargo.lock

@@ -204,7 +204,8 @@ checksum = "f9f8bd3e56ce4dfc153cf470fffbfa98c7620958b312ca5c3a4b8d5181fd13c6"
 [[package]]
 name = "magnus"
 version = "0.9.0"
-source = "git+https://github.com/matsadler/magnus?rev=9407bd9#9407bd98afef6692edca706426c15ea6bef60d0e"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "379d50b6eea4ca84074ccd3e551eb9b07f7865194d5b3198325317e9ef78e5e9"
 dependencies = [
  "magnus-macros",
  "rb-sys",
@@ -215,7 +216,8 @@ dependencies = [
 [[package]]
 name = "magnus-macros"
 version = "0.9.0"
-source = "git+https://github.com/matsadler/magnus?rev=9407bd9#9407bd98afef6692edca706426c15ea6bef60d0e"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ca70566af98184bb92d4d9853daaf533c1a3418b9570d0547ea44970035f3fe"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -252,9 +254,9 @@ checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 
 [[package]]
 name = "parsanol"
-version = "0.8.8"
+version = "0.8.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5709d5bc971fa4e28fccf401709ab1d275d180e447e3ab82fde7ebef2ecc787b"
+checksum = "c28a0cd3b3e2491ef72c99f3dc59ef25ea2e0f13b8cd6ea31a05eb085a33f801"
 dependencies = [
  "ahash",
  "getrandom 0.3.4",
@@ -269,9 +271,9 @@ dependencies = [
 
 [[package]]
 name = "parsanol-derive"
-version = "0.8.8"
+version = "0.8.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93258404b7032b85dffd9a60e3fb1ed003a268282b4f3385f1ab1aba98db34e5"
+checksum = "0ccfdf8325c4890930bbc1510bc9dfc929d485d1aa6c29cb563c5dc77d7a0080"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -280,7 +282,7 @@ dependencies = [
 
 [[package]]
 name = "parsanol_cdylib"
-version = "1.3.50"
+version = "1.3.52"
 dependencies = [
  "parsanol",
 ]

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: ruby
 authors:
 - Ribose Inc.