parsanol 1.3.91-arm-linux → 1.3.92-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 35f9007af2a376a99643f989a6b302702da5b02f8f0b7afc6f85e03f3f0b5791
-  data.tar.gz: 0ec6ceb1d8a6b2b67f81164caf3e54c724544e94b67a1ad2e6405822bfc459a5
+  metadata.gz: 94ab60f4150519a940dd2084dcc399fe2e2691c94865d0673c128ef13e551e6c
+  data.tar.gz: f032f98ca251fbbff68a71dce5b143a64602b9956b91d5ab3da97b0cbccb8310
 SHA512:
-  metadata.gz: dd6700a33f24fdb535e1949998bce420617548d8ff74f5d13d0479729ecef4cbf4287292f2f8861836cb9256b13c48d11302c85157fd0bbcfa3011e4b76547b7
-  data.tar.gz: b7d1cb42710b38820fa27d4b8c56ea6e47819dea518707c33460e6a92ba167f18e876ff1bf738b97eca56ee11332dd599cb8fc05ee30908bc1cfea620743f231
+  metadata.gz: f4f5e09e4f5e30fb52b3704e1348341ee2bdfab777392acdd11f98fce87e8aa0d9f69992abce1ecb137856857cac9d0d68b84717470db9235fb736e599bb54fe
+  data.tar.gz: 7d14b295b9e53af62f279c4c66201a492e5cf5b57a550077d69d2d40355d55b65e107e6c0b35b71d3e1ccb8b31231a4fc598c6da3228ef27fbeada7a08a9965d

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: 34018692 bytes
+sha256: 73a0d5df2c8be448527b97be77cf17d2d32406a6fa95bad552ac33c93a3f53de

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: 34203972 bytes
+sha256: c076da7d2462c80cffdaa4fee81a97622f90fd996cddc885ed0c1947bda237f4

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: 34198132 bytes
+sha256: 42ec5b96bfe8efb05a8377c9ae8410635f8916e9e3ea84e2f9e6a8d741159b58

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: 34207868 bytes
+sha256: 56addd9fe8da96b569b0e50b2b30a1a28c382ce12cc035a0debf42d7679d197e

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/version.rb

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

metadata

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