parsanol 1.3.90-aarch64-linux → 1.3.92-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0a5eae02b01793cba6627f5e7e91d63789b3b4870da638d45868b6857dc557bd
-  data.tar.gz: c32369c415f06ed312afe42cbb2621c59918b4ca10c8c1945d9b39bd69e9244f
+  metadata.gz: d97e0ef9b1ba9281cfce8b847384654d3420fdc8c0ad4fbd0284af5a35522653
+  data.tar.gz: 9836bdd4bf811c8bc7ef99820e0b0c96a088bfbf33cbf52749ffdf3adb4aa2f3
 SHA512:
-  metadata.gz: 9c3fa5252fa8b34f870c741a0df64f27edf52e587217a07c56dbaefd344259870e483def84a1260eebb867af9da4c9b18ac8d799b2d18f678a44865d9c691bfa
-  data.tar.gz: 59d50b74eb42a3451108150ba3ba99bb537f561fad472fab7b6645859688adbbda8345e0090a03c975b1da20bc365b7005b4f04ad4a30629c08a419286bc7776
+  metadata.gz: f0d8078fe690e009410e0c54268468370fe7897007cdbb261de6bca40f64301b1fb45a098f41beffe7beb3bfba1be2fbe0533864484e063d89081ebee4d0f791
+  data.tar.gz: 37346c31aeb72a9e5ca78fbee2135a43d10414134644633b8b224414a6eca32e162292d81bd8b9009dd91e9806617a72365d68681e670699c5f46b9f7b329086

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: 40163120 bytes
-sha256: b4ba2e137bf79ff65acc08112463958c8e939ff55ac33e4be62e169deadb34bc
+size: 40176952 bytes
+sha256: 58f5e7bcb9c7665ab38daba62f63533a89966dbe2b9e2d8c56d2c37bd7afeb37

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: 40398232 bytes
-sha256: 3340fdd237c5a4891ac783d4813fa0a50dc187c9696838749b5a034d7191c35e
+size: 40412064 bytes
+sha256: c2b4e8331d61feecb2146feb05047ff9b20da8543910429eb87c3111b6a871ed

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: 40389704 bytes
-sha256: 5b82593f060f232222f35db442182aef4672803e7fbb947cb49d72596967bcda
+size: 40403520 bytes
+sha256: 35be9d4c9905ab8a9d0fcce4c55d7909850b093d1065cf658f131a2081f9ca31

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: 40399720 bytes
-sha256: f188a3cbded7e033a982b4347c4f600727e2852ee5e39c2f4fb5896a55c5ca09
+size: 40413544 bytes
+sha256: 62c8e268e3990442aa746edfd13a0d24bc2fe40cbd58db8a845c7dfb67efdab0

data/lib/parsanol/native/libparsanol.so

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: data/lib/parsanol/native/libparsanol.so
-size: 35972480 bytes
-sha256: 9070921a0aa8beda1912fe436442ae2c172b3a258feaea6b3209b3c18f32ec03
+size: 35960704 bytes
+sha256: 579c6ce133fca3eec741131db52977ea97348767e59d3cb1c8e0149dc6f1bb91

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)
@@ -263,8 +283,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/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

@@ -758,6 +758,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/parser.rb

@@ -77,6 +77,13 @@ module Parsanol
       # `skip = trivia capture: comments` shape) instead of being
       # discarded; whitespace-shaped units never record.
       #
+      # +exempt:+ (parsanol-ruby#195) lists rule names whose bodies
+      # build WITHOUT injection — the DSL mirror of the PARG
+      # compiler's automatic skip-rule-closure exemption. Declare it
+      # for rules that manage their own trivia explicitly (expressir's
+      # remark rules): a wrapper inside them consumes text the rule
+      # itself captures, corrupting the value and double-recording it.
+      #
       # @example
       #   class MyParser < Parsanol::Parser
       #     rule(:spaces) { match(/[ \t]/).repeat(1) }

data/lib/parsanol/skip.rb

@@ -41,11 +41,46 @@ module Parsanol
 
       markers = capturer_markers(parser_instance, captures)
       whitespace_kind = whitespace&.to_sym
-      exempt_names = exempt.nil? ? nil : Set.new(exempt.map(&:to_s))
+      exempt_names = Set.new(exempt.nil? ? [] : exempt.map(&:to_s))
+      exempt_names.merge(closure_names(skip_atom))
       injector = Injector.new(skip_atom, markers, whitespace_kind, exempt_names)
       [injector.inject(root_atom, entry: true), skip_atom]
     end
 
+    # The skip rule's transitive rule-reference closure (parsanol-ruby#195
+    # follow-up): those rule bodies build without injection — the same
+    # exemption the PARG compiler applies to its skip declaration's
+    # closure. The docstring promised this; the code exempted only the
+    # skip atom itself. Rules the grammar manages explicitly stay
+    # declarable through +exempt:+ (their names merge with these).
+    def self.closure_names(skip_atom)
+      names = Set.new
+      seen = {}.compare_by_identity
+      queue = [skip_atom]
+      until queue.empty?
+        node = queue.shift
+        next if node.nil? || seen.key?(node)
+
+        seen[node] = true
+        case node
+        when Atoms::Entity
+          names << node.rule_name.to_s
+          begin
+            queue << node.parslet
+          rescue StandardError
+            nil
+          end
+        else
+          queue.concat(node.parslets) if node.respond_to?(:parslets)
+          queue.concat(node.alternatives) if node.respond_to?(:alternatives)
+          queue << node.parslet if node.respond_to?(:parslet)
+          queue << node.bound_parslet if node.respond_to?(:bound_parslet)
+          queue << node.wrapped_atom if node.respond_to?(:wrapped_atom)
+        end
+      end
+      names
+    end
+
     # Derives each capturer's leading literal (the leftmost Str the
     # rule can start with) and keys the marker table by it — the same
     # derivation the PARG compiler applies to its skip declaration. A

data/lib/parsanol/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parsanol
 version: !ruby/object:Gem::Version
-  version: 1.3.90
+  version: 1.3.92
 platform: aarch64-linux
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-10-10 00:00:00.000000000 Z
+date: 2026-10-15 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