parsanol 1.3.128 → 1.3.130

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f80a73c511be09a4f5ab40755cf43eed3d7fb004020be3546dbb08adbcee8c48
-  data.tar.gz: 5b1c6d675ff9a19939a3e560c0b7a0b27565d3c8210ca018bc33c5df425fcd70
+  metadata.gz: 55b823bf0f799b613ed22ad730a010327cbfb0b40411bd25690053602371cc0d
+  data.tar.gz: 61b8cd059944fc95c2f6b52f4a7be68d3083831a19a7479a1c5f187ce96c0004
 SHA512:
-  metadata.gz: ee0819062881fabbc94b6e3ddd0466e4bc06e7753c40f069570f566ddde62894365472633ef0ea5226e8ab5af8a95d98267b7acc9ccc8c35d74347490561bddd
-  data.tar.gz: e7249db3f3fd1c5a8fb5e70c47c158db6e5ca13ab04209552a39637cb36b00cf9ee08480c0e735cbcbddf20ebe66efe9895de988eb2a9685426553aa75fba2d0
+  metadata.gz: '08137851d78de165952bdaf0afc3e64a6f215f47f945ef2be0c4f3f7a94313f7768c698cd72ef0a5b70c7b648a210f1b69028526166f0b770aa25c4175b5233b'
+  data.tar.gz: 66897e1afc6cb82c08a202285495d60c7b80e8da7cd5ecb5d16e947f36e036476184342e01f80191bf5be3ee68f6578d1d54d9ad430df69a0cbb1a34f814795d

data/Cargo.lock

@@ -307,9 +307,9 @@ checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 
 [[package]]
 name = "parsanol"
-version = "0.20.0"
+version = "0.20.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa25545d2493d7c0be6e70054f9a8aef360e5ff6046dce5ceae664065e1d5039"
+checksum = "05d9bc5274d8d4eca8ee343b3f97df52691e303284f26a71b3903048019565c7"
 dependencies = [
  "ahash",
  "getrandom 0.3.4",
@@ -326,9 +326,9 @@ dependencies = [
 
 [[package]]
 name = "parsanol-derive"
-version = "0.20.0"
+version = "0.20.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "54c23675b697407e9d2c495c269537407548641b782c6cd79c7c93e079c91988"
+checksum = "80669ec1c0b53f0cab38799570a8df7c0f8edd8decd02940ea8bb124ad401e4b"
 dependencies = [
  "proc-macro2",
  "quote",

data/lib/parsanol/parg/artifact.rb

@@ -95,6 +95,18 @@ module Parsanol
         source_hash == Digest::SHA256.hexdigest(source_text.to_s)
       end
 
+      # The declared per-target binding artifact for this parse artifact
+      # (parsanol-ruby#432): the entry binding records extracted into
+      # their own checksummed artifact, pinned to this grammar by source
+      # hash. Targets: ruby, rs, ts, python.
+      def bindings_artifact(target)
+        Bindings::Artifact.emit(envelope, target)
+      end
+
+      def bindings_artifact_json(target)
+        Bindings::Artifact.emit_json(envelope, target)
+      end
+
       def entries = envelope["entries"].keys
 
       def entry(name)

data/lib/parsanol/parg/bindings/artifact.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Parsanol
+  module PARG
+    module Bindings
+      # The declared per-target binding artifact (parsanol-ruby#432): from
+      # one compiled grammar the toolchain emits one checksummed bindings
+      # artifact per target, each carrying the entry binding records and
+      # pinned to its grammar by source hash. Declared and diffable, not
+      # baked: consumers pin and verify what they load.
+      #
+      # Boundary: the records carry AST construction only — the
+      # production-to-binding mapping. Semantics live in the model layer
+      # (LML), never here. Execution resources (preprocess steps and their
+      # tables) resolve from the PAIRED parse artifact, which is why
+      # #pair_with! is mandatory before #apply.
+      class Artifact
+        KIND = "parg-bindings"
+        TARGETS = %w[ruby rs ts python].freeze
+        SUPPORTED_BINDING_VERSION = 1
+
+        attr_reader :target, :binding_version, :grammar, :grammar_version,
+                    :grammar_source_hash, :entries, :payload
+
+        class << self
+          # Emit the per-target bindings artifact from a compiled parse
+          # artifact envelope. Returns the verified artifact; the payload
+          # is checksummed with the artifact checksum scheme (canonical
+          # JSON sha256 over everything except the checksum itself), so
+          # every engine re-derives it identically.
+          def emit(envelope, target)
+            target = target.to_s
+            unless TARGETS.include?(target)
+              raise ArtifactError,
+                    "unknown binding target #{target.inspect}; known: #{TARGETS.join(', ')}"
+            end
+
+            artifact = new(build(envelope, target))
+            artifact.verify
+          end
+
+          # The emitted artifact as JSON (the bake/CLI surface).
+          def emit_json(envelope, target)
+            JSON.generate(emit(envelope, target).payload)
+          end
+
+          # Parse and fully verify an emitted bindings artifact. `target:`
+          # pins the expected target; omit it in multi-target tooling that
+          # accepts any declared target.
+          def from_json(json, target: nil)
+            artifact = new(JSON.parse(json))
+            artifact.verify
+            artifact.verify_target!(target) unless target.nil?
+            artifact
+          end
+
+          private
+
+          def build(envelope, target)
+            payload = {
+              "artifact_kind" => KIND,
+              "target" => target,
+              "binding_version" => SUPPORTED_BINDING_VERSION,
+              "grammar" => envelope["grammar"],
+              "grammar_version" => envelope["version"],
+              "grammar_source_hash" => envelope["source_hash"],
+              "shape" => envelope["shape"],
+              "entries" => envelope["entries"].to_h do |name, entry|
+                [name, { "bindings" => entry["bindings"].to_a }]
+              end,
+            }
+            payload.merge("checksum" => Compiler.checksum(payload))
+          end
+        end
+
+        def initialize(payload)
+          raise ArtifactError, "bindings artifact payload must be an object" unless payload.is_a?(Hash)
+
+          @payload = payload
+          @target = payload["target"]
+          @binding_version = payload["binding_version"]
+          @grammar = payload["grammar"]
+          @grammar_version = payload["grammar_version"]
+          @grammar_source_hash = payload["grammar_source_hash"]
+          @entries = payload["entries"]
+          @parg_artifact = nil
+        end
+
+        # Structural verification: kind, checksum, binding version,
+        # target, entries map. Every loader path goes through here.
+        def verify
+          unless @payload["artifact_kind"] == KIND
+            raise ArtifactError,
+                  "not a #{KIND} artifact (artifact_kind #{@payload['artifact_kind'].inspect})"
+          end
+
+          expected = Compiler.checksum(@payload)
+          actual = @payload["checksum"]
+          unless actual.is_a?(String) && actual == expected
+            raise ArtifactError,
+                  "bindings artifact checksum mismatch: expected #{expected}, got #{actual.inspect}"
+          end
+
+          unless TARGETS.include?(@target)
+            raise ArtifactError,
+                  "unknown binding target #{@target.inspect}; known: #{TARGETS.join(', ')}"
+          end
+          unless @binding_version == SUPPORTED_BINDING_VERSION
+            raise ArtifactError,
+                  "unsupported binding_version #{@binding_version.inspect} " \
+                  "(supported: #{SUPPORTED_BINDING_VERSION})"
+          end
+          unless @entries.is_a?(Hash)
+            raise ArtifactError, "bindings artifact carries no entries map"
+          end
+
+          self
+        end
+
+        def verify_target!(target)
+          target = target.to_s
+          return if @target == target
+
+          raise ArtifactError,
+                "bindings artifact targets #{@target.inspect}, not #{target.inspect}"
+        end
+
+        # Pair with the parse artifact this layer was compiled from: same
+        # grammar, same version, same source. The pairing is what lets
+        # apply resolve preprocess references — they live in the parse
+        # artifact's checksummed envelope.
+        def pair_with!(parg_artifact)
+          envelope = parg_artifact.envelope
+          mismatches = []
+          mismatches << "grammar (#{@grammar.inspect} vs #{envelope['grammar'].inspect})" if @grammar != envelope["grammar"]
+          if @grammar_version != envelope["version"]
+            mismatches << "version (#{@grammar_version.inspect} vs #{envelope['version'].inspect})"
+          end
+          if @grammar_source_hash != envelope["source_hash"]
+            mismatches << "source_hash (#{@grammar_source_hash.inspect} vs #{envelope['source_hash'].inspect})"
+          end
+          unless mismatches.empty?
+            raise ArtifactError,
+                  "bindings artifact does not pair with the parse artifact: #{mismatches.join(', ')}"
+          end
+
+          @parg_artifact = parg_artifact
+          self
+        end
+
+        def entry(name)
+          @entries.fetch(name) { raise ArtifactError, "unknown entry #{name.inspect}" }
+        end
+
+        def bindings(name)
+          entry(name)["bindings"]
+        end
+
+        def entry_names
+          @entries.keys
+        end
+
+        # Materialize the bound map from a parse shape using the DECLARED
+        # records. The paired parse artifact supplies entry context and
+        # preprocess resolution; the same Bindings.apply runs as for the
+        # embedded records, so a standalone artifact and its parse
+        # artifact's baked records produce identical bound maps.
+        def apply(entry_name, shape)
+          parg = @parg_artifact
+          if parg.nil?
+            raise ArtifactError,
+                  "pair_with! the parse artifact before applying bindings"
+          end
+
+          crafted = { "name" => entry_name, "bindings" => bindings(entry_name) }
+          Bindings.apply(parg, crafted, shape)
+        end
+      end
+    end
+  end
+end

data/lib/parsanol/parg/bindings.rb

@@ -8,6 +8,9 @@ module Parsanol
     # producing the attribute hash that fills a lutaml-model class:
     # capture collection -> preprocessing -> type cast -> path assignment.
     module Bindings
+      # The declared per-target binding artifact (parsanol-ruby#432).
+      autoload :Artifact, "parsanol/parg/bindings/artifact"
+
       module_function
 
       def apply(artifact, entry, shape)
@@ -36,11 +39,14 @@ module Parsanol
         # bound map (parsanol-ruby#413): a capture present in the parse
         # but bound nowhere is silent data loss, the one case the
         # binding layer's other checks miss. Absence in the TREE is
-        # legitimate optionality and never raises. Coverage is checked
-        # against every hash key anywhere in the bound map, not just the
-        # binding's own leaf: a `(raw)` binding carries its entire
+        # legitimate optionality and never raises. Delivery is EITHER
+        # the binding's own leaf/prefix reaching the map (the capture
+        # may rename on the way — capture "doc_year" binds under path
+        # "year", parsanol-ruby#434) OR the capture name appearing as a
+        # key anywhere in the map: a `(raw)` binding carries its entire
         # subtree, so captures nested inside a raw-bound ancestor are
-        # delivered through it (parsanol-ruby#427 — BS 9113 bundled_list).
+        # delivered through it (parsanol-ruby#427 — BS 9113
+        # bundled_list).
         bound_keys = {}
         walk_keys = lambda do |node|
           case node
@@ -53,7 +59,7 @@ module Parsanol
         walk_keys.call(out)
         lost = bindings.select do |binding|
           capture = binding["capture"].to_sym
-          present.include?(capture) && !bound_keys.key?(capture)
+          present.include?(capture) && !bound?(out, binding) && !bound_keys.key?(capture)
         end
         unless lost.empty?
           raise BindError,
@@ -63,6 +69,23 @@ module Parsanol
         out
       end
 
+      # Did this binding contribute anything to the bound map? Scalars
+      # bind under their leaf key; array groups bind under their prefix.
+      # The leaf is the PATH's tail, so a capture-to-path rename reads
+      # as delivered when its own path landed (parsanol-ruby#434).
+      def bound?(out, binding)
+        path = binding["path"].to_s
+        if path.include?("[]")
+          prefix = path.split("[]").first.to_sym
+          rows = out[prefix]
+          rows.is_a?(Array) && rows.any? do |row|
+            row.is_a?(Hash) && row.key?(leaf_key(binding))
+          end
+        else
+          out.key?(leaf_key(binding))
+        end
+      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

data/lib/parsanol/parg/imports.rb

@@ -46,6 +46,12 @@ module Parsanol
 
           document.rules[qualified] = copy(node, prefix)
         end
+        # The `atomic` exemption rides the rule name: a component's
+        # atomic rules qualify with everything else, or the exemption
+        # never matches post-merge.
+        used.atomic_rules.each do |name|
+          document.atomic_rules << "#{prefix}#{name}"
+        end
         used.entries.each do |entry, rule|
           document.entries["#{prefix}#{entry}"] = "#{prefix}#{rule}"
         end
@@ -79,7 +85,17 @@ module Parsanol
         when :pred
           Node.new(:pred, node.a, copy(node.b, prefix), node.c)
         when :cap then Node.new(:cap, node.a, copy(node.b, prefix))
-        when :ref then Node.new(:ref, "#{prefix}#{node.a}")
+        # A qualified reference (`other.rule`) already names its own
+        # imported grammar — prefixing would double-qualify it
+        # (cross-import references compose: the other grammar's rules
+        # are prefixed by their own merge).
+        when :ref
+          name = node.a.to_s
+          if name.include?(".")
+            Node.new(:ref, name)
+          else
+            Node.new(:ref, "#{prefix}#{name}")
+          end
         else node
         end
       end

data/lib/parsanol/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: parsanol
 version: !ruby/object:Gem::Version
-  version: 1.3.128
+  version: 1.3.130
 platform: ruby
 authors:
 - Ribose Inc.
@@ -118,6 +118,7 @@ files:
 - lib/parsanol/parg/artifact.rb
 - lib/parsanol/parg/authoring.rb
 - lib/parsanol/parg/bindings.rb
+- lib/parsanol/parg/bindings/artifact.rb
 - lib/parsanol/parg/cli.rb
 - lib/parsanol/parg/compiler.rb
 - lib/parsanol/parg/derive.rb