parsanol 1.3.91-arm-linux → 1.3.93-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 35f9007af2a376a99643f989a6b302702da5b02f8f0b7afc6f85e03f3f0b5791
-  data.tar.gz: 0ec6ceb1d8a6b2b67f81164caf3e54c724544e94b67a1ad2e6405822bfc459a5
+  metadata.gz: 38e6903eee4c564df8586705d284a07671cbf0935ed4c7641e8b44015c4c510e
+  data.tar.gz: c6f1c81c282193fd596386c717e756aa35d87ffd22d5c3c1554ba3b09d4e0e02
 SHA512:
-  metadata.gz: dd6700a33f24fdb535e1949998bce420617548d8ff74f5d13d0479729ecef4cbf4287292f2f8861836cb9256b13c48d11302c85157fd0bbcfa3011e4b76547b7
-  data.tar.gz: b7d1cb42710b38820fa27d4b8c56ea6e47819dea518707c33460e6a92ba167f18e876ff1bf738b97eca56ee11332dd599cb8fc05ee30908bc1cfea620743f231
+  metadata.gz: 94c5b1eb30a297566ca23877a53b1d63be7cff2fa04a92084fb1e9ff0102b238723fba755469daadb5d38b2113638cf0a02697f06a65671d04e631b2bd8647bf
+  data.tar.gz: ce29e977d953b08817a2f425f86090d4272cde2fc41e29d0d68b90571765e01951cdd3b90242671d0e9de018bc36f3aa8e52fc5359e5578a7b0ce8bd14554cab

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: 34005012 bytes
-sha256: a8d9bf7504fcf0ac72af4bac22ef380f91ffb941c38d27badd31a38aae2cdd0c
+size: 34333284 bytes
+sha256: 46c18a5ba0af8926c012eb98c6417dfca64931a837629b317fb7c3cc430b9085

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: 34190272 bytes
-sha256: 8ae6bfd6ecf22108657162245248e494a911493c8ab4ce1feccf520fc68254e0
+size: 34518452 bytes
+sha256: 0752c79e340c4c722b106443ff1faf6ff6d6d7c5800570906d1c548585e06a58

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: 34184432 bytes
-sha256: 2403ab2731c77acff92e87d5bfd55be82eecbeeb91349f0aef2a159508f53bf7
+size: 34512620 bytes
+sha256: 9b0744875d02d5c1957b82cdf9249129ce62214696606b84886609243342e23f

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: 34194168 bytes
-sha256: 897db94d6190f5fde15254a05fabe8dde3043951497c0b166ba168a7ca4a24ad
+size: 34522276 bytes
+sha256: 834bad07a21ef4ccaeb47fbfaf85c567866142fb141f6d93205d5d9958e0c2f2

data/lib/parsanol/native/parser.rb

@@ -167,59 +167,58 @@ module Parsanol
         end
 
         def grammar_structure_hash(atom)
-          Digest::MD5.hexdigest(atom_structure(atom).to_s)
+          Digest::MD5.hexdigest(append_atom_structure(atom))
         end
 
-        def atom_structure(atom, visited = {})
-          # Cycle detection - return a placeholder if we've seen this atom before
-          obj_id = atom.object_id
-          if visited[obj_id]
-            return [:cycle, atom.class.name]
+        def append_atom_structure(atom, visited = {}.compare_by_identity, output = +"")
+          if visited[atom]
+            return output << "[:cycle, " << atom.class.name.inspect << "]"
           end
 
-          visited[obj_id] = true
-
+          visited[atom] = true
           case atom
-          when ::Parsanol::Atoms::Entity
-            # Recursively resolve entity to get actual structure for hash
-            atom_structure(atom.parslet, visited)
-          when ::Parsanol::Atoms::Str
-            [:str, atom.str]
-          when ::Parsanol::Atoms::Re
-            [:re, atom.match]
-          when ::Parsanol::Atoms::Sequence
-            [:seq, atom.parslets.map { |p| atom_structure(p, visited) }]
-          when ::Parsanol::Atoms::Alternative
-            [:alt, atom.alternatives.map { |p| atom_structure(p, visited) }]
-          when ::Parsanol::Atoms::Repetition
-            [:rep, atom.min, atom.max, atom_structure(atom.parslet, visited)]
-          when ::Parsanol::Atoms::Named
-            [:named, atom.name.to_s, atom_structure(atom.parslet, visited)]
-          when ::Parsanol::Atoms::Lookahead
-            [:lookahead, atom.positive,
-             atom_structure(atom.bound_parslet, visited)]
-          when ::Parsanol::Atoms::Constant
-            # The value differentiates otherwise-identical constant
-            # atoms — without it every Constant hashes alike and the
-            # grammar cache serves the first wire forever.
-            [:constant, atom.value.inspect]
-          when ::Parsanol::Atoms::Lookbehind
-            [:lookbehind, atom.count, atom.pattern, atom.positive]
-          # Subclass first: TriviaCapture < Trivia < Ignored (the same
-          # dispatch discipline as the serializer's).
-          when ::Parsanol::Atoms::TriviaCapture
-            # The capturer table differentiates capture-carrying
-            # grammars from plain-trivia ones — without it the grammar
-            # cache serves one variant's wire to every other and the
-            # wrong marker table reaches the engine (parsanol-ruby#180).
-            [:trivia_capture, atom.capturers.to_a.sort,
-             atom_structure(atom.wrapped_atom, visited)]
-          when ::Parsanol::Atoms::Trivia
-            [:trivia, atom_structure(atom.wrapped_atom, visited)]
-          when ::Parsanol::Atoms::Ignored
-            [:ignored, atom_structure(atom.wrapped_atom, visited)]
+          when Parsanol::Atoms::Entity
+            append_atom_structure(atom.parslet, visited, output)
+          when Parsanol::Atoms::Str
+            output << "[:str, " << atom.str.inspect << "]"
+          when Parsanol::Atoms::Re
+            output << "[:re, " << atom.match.inspect << "]"
+          when Parsanol::Atoms::Sequence, Parsanol::Atoms::Alternative
+            children = atom.is_a?(Parsanol::Atoms::Sequence) ? atom.parslets : atom.alternatives
+            output << (atom.is_a?(Parsanol::Atoms::Sequence) ? "[:seq, [" : "[:alt, [")
+            index = 0
+            while index < children.length
+              output << ", " unless index.zero?
+              append_atom_structure(children[index], visited, output)
+              index += 1
+            end
+            output << "]]"
+          when Parsanol::Atoms::Repetition
+            output << "[:rep, " << atom.min.inspect << ", " << atom.max.inspect << ", "
+            append_atom_structure(atom.parslet, visited, output) << "]"
+          when Parsanol::Atoms::Named
+            output << "[:named, " << atom.name.to_s.inspect << ", "
+            append_atom_structure(atom.parslet, visited, output) << "]"
+          when Parsanol::Atoms::Lookahead
+            output << "[:lookahead, " << atom.positive.inspect << ", "
+            append_atom_structure(atom.bound_parslet, visited, output) << "]"
+          when Parsanol::Atoms::Constant
+            # The inspected constant remains a string inside the fingerprint.
+            output << "[:constant, " << atom.value.inspect.inspect << "]"
+          when Parsanol::Atoms::Lookbehind
+            output << "[:lookbehind, " << atom.count.inspect << ", " << atom.pattern.inspect << ", " << atom.positive.inspect << "]"
+          # Capturing trivia must precede its Trivia and Ignored parents.
+          when Parsanol::Atoms::TriviaCapture
+            output << "[:trivia_capture, " << atom.capturers.to_a.sort.inspect << ", "
+            append_atom_structure(atom.wrapped_atom, visited, output) << "]"
+          when Parsanol::Atoms::Trivia
+            output << "[:trivia, "
+            append_atom_structure(atom.wrapped_atom, visited, output) << "]"
+          when Parsanol::Atoms::Ignored
+            output << "[:ignored, "
+            append_atom_structure(atom.wrapped_atom, visited, output) << "]"
           else
-            [:unknown, atom.class.name]
+            output << "[:unknown, " << atom.class.name.inspect << "]"
           end
         end
       end

data/lib/parsanol/parg/artifact.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "digest"
 require "json"
 require "yaml"
 
@@ -11,20 +12,21 @@ module Parsanol
     # consume; the embedded PARG source lets a Ruby runtime recompile the atom
     # tree locally without any other dependency.
     class Artifact
-      attr_reader :envelope, :path, :tables_dir
+      attr_reader :envelope, :path, :tables_dir, :imports_dir
 
-      def self.load(path, tables_dir: nil)
+      def self.load(path, tables_dir: nil, imports_dir: nil)
         envelope = JSON.parse(PARG.read_utf8(path))
-        new(envelope, path, tables_dir || File.dirname(path))
+        new(envelope, path, tables_dir || File.dirname(path),
+            imports_dir: imports_dir)
       end
 
-      def self.from_json(text, tables_dir: nil)
-        new(JSON.parse(text), nil, tables_dir)
+      def self.from_json(text, tables_dir: nil, imports_dir: nil)
+        new(JSON.parse(text), nil, tables_dir, imports_dir: imports_dir)
       end
 
       SUPPORTED_SHAPE = "parsanol-tree/v2"
 
-      def initialize(envelope, path, tables_dir)
+      def initialize(envelope, path, tables_dir, imports_dir: nil)
         unless envelope["shape"] == SUPPORTED_SHAPE
           raise ArtifactError,
                 "unsupported artifact shape #{envelope['shape'].inspect} " \
@@ -38,12 +40,30 @@ module Parsanol
         @envelope = envelope
         @path = path
         @tables_dir = tables_dir
+        # parsanol-ruby#208: `use`-importing grammars need the imported
+        # sources when the pure-Ruby path recompiles the embedded source;
+        # in-memory artifacts (path nil) pass the directory explicitly.
+        @imports_dir = imports_dir
         verify_checksum!
         @compiler = nil
       end
 
       def version = envelope["version"]
 
+      # Freshness (parsanol-ruby#209): what source revision and compiler
+      # produced this artifact. `source_hash` is the SHA-256 of the .parg
+      # text at compile time; nil on artifacts baked before the field
+      # existed, so `fresh_against?` answers false rather than guessing.
+      def source_hash = envelope["source_hash"]
+
+      def compiler_version = envelope["compiler_version"]
+
+      def fresh_against?(source_text)
+        return false if source_hash.nil?
+
+        source_hash == Digest::SHA256.hexdigest(source_text.to_s)
+      end
+
       def entries = envelope["entries"].keys
 
       def entry(name)
@@ -137,16 +157,33 @@ module Parsanol
           hash = test.is_a?(Document::Test) ? test_to_hash(test) : test
           entry_name = hash["entry"] || entries.first
           begin
-            bound = parse_and_bind(entry_name, hash["input"], mode: mode)
-            if hash["kind"] == "reject"
+            shape = parse(entry_name, hash["input"], mode: mode)
+            case hash["kind"]
+            when "reject"
               "test #{hash['input'].inspect}: expected the input to be rejected"
-            elsif hash["kind"] == "example"
+            when "example"
+              bound = apply_bindings(entry_name, shape)
               expect = hash["expect"].to_h { |key, value| [key.to_sym, value] }
-              mismatched = expect.reject { |key, value| bound.key?(key) && bound[key] == value }
+              mismatched = expect.reject do |key, value|
+                bound.key?(key) && Bindings.canonical(bound[key]) == Bindings.canonical(value)
+              end
               next if mismatched.empty?
 
               "test #{hash['input'].inspect}: expected captures " \
                 "#{mismatched.transform_values(&:inspect).inspect}, got #{bound.inspect}"
+            when "capture"
+              captures = Bindings.collect_captures(shape)
+              mismatched = hash["expect"].reject do |key, value|
+                actual = captures[key.to_sym]&.first
+                !actual.nil? && Bindings.canonical(actual) == Bindings.canonical(value)
+              end
+              next if mismatched.empty?
+
+              actuals = mismatched.keys.to_h do |key|
+                [key, Bindings.canonical(captures[key.to_sym]&.first)]
+              end
+              "test #{hash['input'].inspect}: expected captures " \
+                "#{mismatched.transform_values(&:inspect).inspect}, got #{actuals.inspect}"
             end
           rescue Parsanol::ParseFailed
             unless hash["kind"] == "reject"
@@ -263,8 +300,10 @@ module Parsanol
           # without this the pure-Ruby path fails on artifacts whose
           # native atom graphs inline everything. The imported sources
           # sit beside the artifact (vendors ship them together).
-          imports_dir = path && File.directory?(File.dirname(path)) ? File.dirname(path) : nil
-          Imports.merge!(document, [imports_dir].compact) if imports_dir
+          dirs = [path ? File.dirname(path) : nil, @imports_dir]
+            .compact
+            .select { |dir| File.directory?(dir) }
+          Imports.merge!(document, dirs) unless dirs.empty?
           Compiler.new(document, @tables_dir)
         end
       end

data/lib/parsanol/parg/bindings.rb

@@ -23,6 +23,19 @@ module Parsanol
         out
       end
 
+      # Canonical test-value form: one equality surface for capture and
+      # example expectations on both sides of the comparison (Slice vs
+      # source literal was comparing heterogeneous types). Terminals
+      # reduce to their text; structure recurses; keys stringify.
+      def canonical(value)
+        case value
+        when Hash then value.to_h { |key, item| [key.to_s, canonical(item)] }
+        when Array then value.map { |item| canonical(item) }
+        when nil, true, false, Integer then value
+        else String(value)
+        end
+      end
+
       def collect_captures(shape)
         found = Hash.new { |hash, key| hash[key] = [] }
         queue = [shape]

data/lib/parsanol/parg/cli.rb

@@ -22,6 +22,10 @@ module Parsanol
           test    <file.parg|artifact.json>   run the grammar's test section
           parse   <file> [--entry E] INPUT  parse one input; prints the tree
                                             and the bound captures
+          check   --source x.parg --artifact y.json
+                                            verify the artifact was compiled
+                                            from that source (source hash +
+                                            compiler version); exit 1 stale
           repl    <file> [--entry E]        interactive parse loop (blank
                                             line quits, :quit exits)
           doc     <file> [rule]             print rule documentation
@@ -53,6 +57,7 @@ module Parsanol
         when "test" then test
         when "schema" then schema
         when "parse" then parse
+        when "check" then check
         when "repl" then repl
         when "doc" then doc
         when "lsp" then Lsp.new.run && 0
@@ -88,6 +93,33 @@ module Parsanol
         0
       end
 
+      # Freshness (parsanol-ruby#209): verify an artifact was compiled
+      # from the given source. The stale-shipped-artifact incident class
+      # (an old artifact silently taking precedence over the corrected
+      # grammar) is undetectable without the recorded source hash.
+      # Exit 0 fresh, 1 stale or unrecorded.
+      def check
+        source = flag_value("--source")
+        artifact_path = flag_value("--artifact")
+        unless source && artifact_path && File.file?(source) && File.file?(artifact_path)
+          warn USAGE
+          return 1
+        end
+        artifact = Artifact.load(artifact_path)
+        if artifact.source_hash.nil?
+          puts "STALE?  #{artifact_path}: no source hash recorded (pre-freshness artifact)"
+          return 1
+        end
+        if artifact.fresh_against?(PARG.read_utf8(source))
+          puts "FRESH   #{artifact_path} == #{source} (compiler #{artifact.compiler_version})"
+          0
+        else
+          puts "STALE   #{artifact_path} does not match #{source} " \
+               "(built from #{artifact.source_hash[0, 12]}… by #{artifact.compiler_version})"
+          1
+        end
+      end
+
       def test
         target = @argv.shift
         if File.directory?(target)
@@ -200,11 +232,13 @@ module Parsanol
 
       def artifact_for(file)
         if file.end_with?(".json")
-          Parsanol::PARG::Artifact.load(file, tables_dir: @tables_dir || default_tables_dir(file))
+          Parsanol::PARG::Artifact.load(file, tables_dir: @tables_dir || default_tables_dir(file),
+                                              imports_dir: File.dirname(file))
         else
           artifact = compile_source(file)
           Parsanol::PARG::Artifact.from_json(JSON.generate(artifact.envelope),
-                                             tables_dir: @tables_dir || default_tables_dir(file))
+                                             tables_dir: @tables_dir || default_tables_dir(file),
+                                             imports_dir: File.dirname(file))
         end
       end
 

data/lib/parsanol/parg/compiler.rb

@@ -314,22 +314,43 @@ module Parsanol
       def run_tests
         return [] if @document.tests.empty?
 
-        default_entry = resolve_default_entry
         view = test_view
         @document.tests.filter_map do |test|
           entry_name = test.entry || default_entry
           rule = @document.entries.fetch(entry_name)
           begin
             shape = atom_for(rule).parse(test.input)
-            if test.kind == :reject
+            case test.kind
+            when :reject
               "test #{test.input.inspect}: expected the input to be rejected"
-            elsif test.kind == :example
-              bound = Bindings.apply(view, { "bindings" => binding_list(rule) }, shape)
-              mismatched = test.expect.reject { |key, value| bound.key?(key) && bound[key] == value }
+            when :example
+              bindings = binding_list(rule)
+              if bindings.empty?
+                raise CompileError,
+                      "example tests need a bindings section (use `capture` " \
+                      "for raw-capture assertions)"
+              end
+              bound = Bindings.apply(view, { "bindings" => bindings }, shape)
+              mismatched = test.expect.reject do |key, value|
+                bound.key?(key) && Bindings.canonical(bound[key]) == Bindings.canonical(value)
+              end
               next if mismatched.empty?
 
               "test #{test.input.inspect}: expected captures " \
                 "#{mismatched.transform_values(&:inspect).inspect}, got #{bound.inspect}"
+            when :capture
+              captures = Bindings.collect_captures(shape)
+              mismatched = test.expect.reject do |key, value|
+                actual = captures[key.to_sym]&.first
+                !actual.nil? && Bindings.canonical(actual) == Bindings.canonical(value)
+              end
+              next if mismatched.empty?
+
+              actuals = mismatched.keys.to_h do |key|
+                [key, Bindings.canonical(captures[key.to_sym]&.first)]
+              end
+              "test #{test.input.inspect}: expected captures " \
+                "#{mismatched.transform_values(&:inspect).inspect}, got #{actuals.inspect}"
             end
           rescue Parsanol::ParseFailed
             unless test.kind == :reject
@@ -339,6 +360,13 @@ module Parsanol
         end
       end
 
+      # Only consulted when a test omits its entry: a multi-entry
+      # grammar whose tests are all explicit must compile (parsanol-
+      # ruby#216). Memoized so the raise happens once, on first need.
+      def default_entry
+        @default_entry ||= resolve_default_entry
+      end
+
       def resolve_default_entry
         own = @document.own_entries
         return own.first if own && own.size == 1
@@ -758,6 +786,12 @@ module Parsanol
           end,
           "docs" => @document.docs,
           "source" => @document.source,
+          # Freshness (parsanol-ruby#209): what the artifact was compiled
+          # from and with, so loaders can detect a stale artifact and fall
+          # back to a reference implementation instead of failing obscurely
+          # at parse time. Checksummed like the rest of the envelope.
+          "source_hash" => Digest::SHA256.hexdigest(@document.source.to_s),
+          "compiler_version" => Parsanol::VERSION,
         }
         if @document.skip_declaration
           # parsanol-ruby#134: declared trivia rule. Injection is baked

data/lib/parsanol/parg/document.rb

@@ -5,7 +5,15 @@ module Parsanol
     # Parsed PARG document: grammar rules plus the binding sections.
     class Document
       Binding = Struct.new(:capture, :path, :type, :card, :preprocess)
-      TEST_KINDS = %i[accept reject example].freeze
+      # `capture` = phase 1 (grammar layer): asserts the raw capture tree,
+      # no bindings section needed. `example` = phase 2 (bindings layer):
+      # asserts the bound, preprocessed attribute hash.
+      # `capture` = phase 1 (grammar layer): asserts the raw capture tree,
+      # no bindings section needed. `example` = phase 2 (bindings layer):
+      # asserts the bound, preprocessed attribute hash.
+      TEST_KINDS = %i[accept reject example capture].freeze
+      # Test kinds whose expectations are `{ key: value }` pairs.
+      PAIR_KINDS = %w[example capture].freeze
 
       Test = Struct.new(:entry, :kind, :input, :expect)
 

data/lib/parsanol/parg/parser.rb

@@ -83,7 +83,7 @@ module Parsanol
           kind = ident.value
           input = unquote(expect(:str).value)
           expect_pairs = {}
-          if kind == "example" && peek&.type == :punct && peek.value == "{"
+          if Document::PAIR_KINDS.include?(kind) && peek&.type == :punct && peek.value == "{"
             advance
             skip_newlines
             until peek&.type == :punct && peek.value == "}"

data/lib/parsanol/version.rb

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

data/lib/parsanol/vm.rb

@@ -146,7 +146,12 @@ module Parsanol
           # The shared program's compile-time analysis (heavy-memo
           # seeding) covered this structure; the fresh root inherits
           # it so its first parse memoizes like the original's.
-          (@heavy ||= {}.compare_by_identity)[root] = true if @heavy_by_hash&.[](hash_key)
+          if @heavy_by_hash&.[](hash_key)
+            (@heavy ||= {}.compare_by_identity)[root] = true
+            trim_cache(@heavy)
+          end
+          cache[root] = shared
+          trim_cache(cache)
           return shared
         end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parsanol
 version: !ruby/object:Gem::Version
-  version: 1.3.91
+  version: 1.3.93
 platform: arm-linux
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-10-11 00:00:00.000000000 Z
+date: 2026-10-16 00:00:00.000000000 Z
 dependencies: []
 description: A small Ruby library for constructing parsers in the PEG (Parsing Expression
   Grammar) fashion. Parsanol provides Parslet-compatible API with additional features