parsanol 1.3.128-arm-linux → 1.3.130-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19a0e3a8445f5771ca1a372cfc8ae0b27893883862171a2a691e07f4fa2af094
-  data.tar.gz: c0d334c8671764d372da56c5ce24200b3c84f301e8fb8847dc71cb50f07b1b35
+  metadata.gz: '08291c7ebdfc64af963151769f7276a22723d98be2609c0299841b34bea18a67'
+  data.tar.gz: 3be47e65486f7e76ae124dc326713d7d7fb711295e423a85633e02917622cb1e
 SHA512:
-  metadata.gz: ce55d83f0ebc1f0459f985d41382c2764980f4558ebcd600b35eb1afa370cdcb97ffb5136fef383cebfb9dfca468ba4fa27ece36dcad7af33654b5db3f291c38
-  data.tar.gz: e85ad04b0c81ea1ba1fdbbd1a1652e24e1a2b5ab55fe71d07069ba48a9483f451cf2de995645dcbc6befbd1813cac96c4bf1b24261ed9fe0ceffd5518b885aba
+  metadata.gz: 03b12bbe3c4750b36e2575f8e39909e4337082596a7641e3b479ee75bc902ad0d4a3cda0677d8bfb91708abbfa1a3e719392b4b7763fb00d5af5ec15018621be
+  data.tar.gz: d1f717ea3d3c7836d9e270cb099742262f944422a094ae73bf215904921981c1da69b3ece4cc217eb43942b8ea0a54714aa194908cf1c80a33c11f55ceb94249

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: 39723288 bytes
-sha256: 10f38f0f0c6e8836e1a8066a52c3cd24f470b8e8a825ac8b4d5efd77c68f20b4
+size: 39866820 bytes
+sha256: d427de1a20cb3ce4b7f87f7b9785e1b972e24f0715e17fe642141743d84aa537

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: 39908464 bytes
-sha256: 92b5490941807ecb46f0756350eaa5dbab93733780db0df1bc1e490abb8d2a8e
+size: 40052048 bytes
+sha256: ae5b75934aaa0b288ab140101dfa510f16d7590d15c27744ab5c40576b6c8c76

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: 39902616 bytes
-sha256: a31eb03b3424856d166daa9eaa8b0783fb78d9940cb69b330b13e48e55ec4b9b
+size: 40046192 bytes
+sha256: ef69925f79b48d090ed69227d6dca2a4cf8d7dc6e2ca1cfe1ad4028b43bb7ada

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: 39912372 bytes
-sha256: 8d6c76e8ca867a59018580ec7ed779798b449b53187e4fcb4e04fb44b3ef56fb
+size: 40055908 bytes
+sha256: 4aa30d859f847ed62f581007ed01eaf3225df16066ffac565fff7014b8ee31aa

data/lib/parsanol/native/libparsanol.so

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: data/lib/parsanol/native/libparsanol.so
-size: 36061744 bytes
-sha256: b1b4d96b84b9e088162cd1600e3cd355c65465c0d9d02194d26bd9c76561155c
+size: 36187320 bytes
+sha256: 254ef54622a09917e602bb0e443b7125fa3a35a7a89d4c51300df7ff26019f3a

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: arm-linux
 authors:
 - Ribose Inc.
@@ -101,6 +101,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