parsanol 1.3.131-aarch64-linux → 1.3.133-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cab7e7f96b08e9558a216f4658540a8ad88572a1ca3a0adb2c77602ee2ed3b61
-  data.tar.gz: ffb527fbf0a3bbd5a99da93148b52f1264a5bf9c9055e1c56e712223aaca9efc
+  metadata.gz: 38474555e976a3aa4a84b09f2dc64e2adcbeccc5eeb75c9f3e8340e9472b2812
+  data.tar.gz: 057f7f9b2e5671584186480cde69550e6a0614bde21727ee55541dc38ab5a2be
 SHA512:
-  metadata.gz: c7e577f8fe5d6c850d6d03950462b41d8f38ef82f0f9b8b64bc066abf321b436a21a5805402276b02238049f0de97d932b109da152855e0f19e826ea6ed6fa38
-  data.tar.gz: 440e7adc83c768447f378b3b1cebccd73fd1e25e1bd1905eef09ea938ee8d6c2d2c980296b783507453da935ef373c9ac1c41eb7bce519f10cbba903e88442a3
+  metadata.gz: ded7ceea7811c46b653da8e7965ed32504d8db2fc2b6b5aba0793f0f5f37306f7a5e2dfc29f1b6365e6255019782c05325ae6102042699720945d072b8b008a4
+  data.tar.gz: f4cae04649e108d2e7b5b5f2f506a7ae4c45d02a24565ba86d3d131fbb60b0808c55e21dc220e738e617b27310f4c72392baf53ba4e2b67c51ce0be63ff41137

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: 47415752 bytes
-sha256: b5df655f1f7e38d27146c84678d78ebf1ac7fe0979ee0318932b95e7ccaf61f4
+size: 47412264 bytes
+sha256: ad5843845e6d583178abc630acb3bf6ea77f7944beb00d3f4312dc19a0e12f7e

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: 47650784 bytes
-sha256: 729b12a5631399a9c51ca0c6e5379a8f7845988b1a39c5f7eff37f48c37bed4c
+size: 47647304 bytes
+sha256: ae55584ad3bb49b78d5f2a2f496cf47bcf6bb89070484f98ff936d45de6a1ad7

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: 47646368 bytes
-sha256: f2b4449cac1d28ef08ab661c81c6c63ef43efc34dc47983361df95a32443b9b0
+size: 47647080 bytes
+sha256: a0a07b8bb12f97e21c7e4056df1c4971ed51578080306b4a4c7961610374ba1b

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: 47656376 bytes
-sha256: c058a8a40c01d04c483705050364261dffec34a911fdcd284f2bafc49dd2ce52
+size: 47657088 bytes
+sha256: bc004ef9e5f6794a52c01ec04536c34d32a9a129c6ee2076c545efec1b1bae7d

data/lib/parsanol/native/libparsanol.so

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: data/lib/parsanol/native/libparsanol.so
-size: 43124920 bytes
-sha256: c1ba12fc7ff6c821f87cb4e4d0bb533abb6891ce5457e44b223f1535e4e98542
+size: 43125664 bytes
+sha256: 63ef8e072548f50461d5624438deb51e41bb60f0b0d1a57c5bb76695367a645d

data/lib/parsanol/parg/cli.rb

@@ -22,7 +22,12 @@ module Parsanol
                                             compile to an artifact envelope;
                                             --bindings also writes one
                                             checksummed per-target binding
-                                            artifact beside it (#432)
+                                            artifact beside it (#432);
+                                            --model-bindings FILE embeds a
+                                            rule -> model sidecar (JSON/YAML)
+                                            in the artifact
+          bindings <artifact.json>          dump the embedded rule -> model
+                                            binding table as JSON (coradoc#307)
           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
@@ -75,6 +80,7 @@ module Parsanol
         when "lint" then lint
         when "export" then export_grammar
         when "diff" then diff_artifacts
+        when "bindings" then dump_bindings
         when "lsp" then Lsp.new.run && 0
         else
           warn USAGE
@@ -145,6 +151,9 @@ module Parsanol
         source = @argv.shift
         out = flag_value("-o") || default_artifact_name(source)
         envelope = compile_source(source).envelope
+        if (sidecar = flag_value("--model-bindings"))
+          envelope = ModelBindings.embed(envelope, ModelBindings.load(sidecar))
+        end
         # Seal: the exact text written is the exact text the byte-level
         # checksum covers (Compiler.seal_json includes the trailing
         # newline).
@@ -162,6 +171,18 @@ module Parsanol
         0
       end
 
+      # `parg bindings ARTIFACT`: the embedded rule -> model table as JSON.
+      def dump_bindings
+        path = @argv.shift
+        unless path
+          warn "usage: parsanol parg bindings ARTIFACT.json"
+          return 2
+        end
+        envelope = ModelBindings.read_envelope(path)
+        puts ModelBindings.dump(envelope)
+        0
+      end
+
       # Every --bindings flag value, `all` expanded to the target set.
       # Empty when the flag is absent (compile emits no binding artifacts).
       def bindings_targets

data/lib/parsanol/parg/compiler.rb

@@ -61,7 +61,8 @@ module Parsanol
       # unicode_tables — is byte-stable when the grammar's behavior is
       # unchanged. Mirrors the cross-engine parity view.
       SEMANTICS_EXCLUDED = %w[checksum byte_checksum compiler_version
-                              unicode_tables semantics_hash validated].freeze
+                              unicode_tables semantics_hash validated
+                              model_bindings].freeze
 
       def self.semantics_hash(envelope)
         payload = envelope.except(*SEMANTICS_EXCLUDED)

data/lib/parsanol/parg/model_bindings.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "json"
+require "yaml"
+
+module Parsanol
+  module PARG
+    # The rule -> model binding table embedded in an artifact (coradoc#307).
+    #
+    # A sidecar (JSON or YAML) declares, per rule, which model a raw-tree
+    # node inflates to:
+    #
+    #   version: 1
+    #   rules:
+    #     thematic_break:
+    #       keys: [hr]                  # exact capture-key set of the node
+    #       model: HorizontalRule
+    #       captures: {}                # attribute => scalar capture key
+    #       children: {}                # attribute => nested-node capture key
+    #       defaults: { style: "---" }  # attributes fixed by the rule
+    #
+    # `parg compile --model-bindings FILE` embeds it under the envelope's
+    # additive "model_bindings" key; artifacts compiled without a sidecar
+    # carry no such key and are byte-identical to before. The table is not
+    # parse semantics, so semantics_hash ignores it; the checksum covers it.
+    module ModelBindings
+      KEY = "model_bindings"
+      VERSION = 1
+      RULE_FIELDS = %w[keys model captures children defaults].freeze
+
+      module_function
+
+      # @param path [String] a .json / .yml / .yaml sidecar
+      # @return [Hash] the validated, string-keyed table
+      def load(path)
+        text = File.read(path, encoding: Encoding::UTF_8)
+        raw = File.extname(path).match?(/\.ya?ml\z/i) ? YAML.safe_load(text) : JSON.parse(text)
+        normalize(raw)
+      rescue JSON::ParserError, Psych::SyntaxError => e
+        raise ArtifactError, "model bindings #{path}: #{e.message}"
+      end
+
+      # @return [Hash] the table with every rule filled to the full shape
+      def normalize(raw)
+        raise ArtifactError, "model bindings: expected a mapping" unless raw.is_a?(Hash)
+
+        table = stringify(raw)
+        unless table["version"] == VERSION
+          raise ArtifactError, "model bindings: unsupported version #{table['version'].inspect} (want #{VERSION})"
+        end
+
+        rules = table["rules"]
+        raise ArtifactError, "model bindings: `rules` must be a mapping" unless rules.is_a?(Hash)
+
+        { "version" => VERSION, "rules" => rules.to_h { |name, rule| [name, normalize_rule(name, rule)] } }
+      end
+
+      def normalize_rule(name, rule)
+        raise ArtifactError, "model bindings: rule #{name.inspect} must be a mapping" unless rule.is_a?(Hash)
+
+        unknown = rule.keys - RULE_FIELDS
+        raise ArtifactError, "model bindings: rule #{name.inspect} has unknown field #{unknown.first.inspect}" unless unknown.empty?
+        unless rule["model"].is_a?(String) && !rule["model"].empty?
+          raise ArtifactError, "model bindings: rule #{name.inspect} needs a `model`"
+        end
+        unless rule["keys"].is_a?(Array) && !rule["keys"].empty?
+          raise ArtifactError, "model bindings: rule #{name.inspect} needs non-empty `keys`"
+        end
+
+        {
+          "keys" => rule["keys"].map(&:to_s),
+          "model" => rule["model"],
+          "captures" => hash_field(name, rule, "captures"),
+          "children" => hash_field(name, rule, "children"),
+          "defaults" => hash_field(name, rule, "defaults"),
+        }
+      end
+
+      def hash_field(name, rule, field)
+        value = rule.fetch(field, {})
+        raise ArtifactError, "model bindings: rule #{name.inspect} `#{field}` must be a mapping" unless value.is_a?(Hash)
+
+        value
+      end
+
+      def stringify(value)
+        case value
+        when Hash then value.to_h { |key, item| [key.to_s, stringify(item)] }
+        when Array then value.map { |item| stringify(item) }
+        else value
+        end
+      end
+
+      # Embed a table in an envelope and re-seal the canonical checksum.
+      def embed(envelope, table)
+        sealed = envelope.merge(KEY => table)
+        sealed["checksum"] = Compiler.checksum(sealed)
+        sealed
+      end
+
+      # Read an artifact file for the dump: JSON plus checksum verification
+      # only, so no grammar source and no custom-atom class is needed.
+      def read_envelope(path)
+        envelope = JSON.parse(File.read(path, encoding: Encoding::UTF_8))
+        unless envelope.is_a?(Hash) && envelope["checksum"] == Compiler.checksum(envelope)
+          raise ArtifactError, "#{path}: artifact checksum mismatch"
+        end
+
+        envelope
+      rescue JSON::ParserError => e
+        raise ArtifactError, "#{path}: #{e.message}"
+      end
+
+      # @return [Hash, nil] the embedded table, nil for an artifact without one
+      def from(envelope)
+        envelope[KEY]
+      end
+
+      # The machine-readable dump: rule -> model/keys/captures/children/defaults.
+      def dump(envelope)
+        table = from(envelope) || { "version" => VERSION, "rules" => {} }
+        JSON.pretty_generate(table)
+      end
+    end
+  end
+end

data/lib/parsanol/parg.rb

@@ -26,6 +26,7 @@ module Parsanol
     autoload :Compiler, "parsanol/parg/compiler"
     autoload :Artifact, "parsanol/parg/artifact"
     autoload :Bindings, "parsanol/parg/bindings"
+    autoload :ModelBindings, "parsanol/parg/model_bindings"
     autoload :Render, "parsanol/parg/render"
     autoload :Derive, "parsanol/parg/derive"
     autoload :SelfHost, "parsanol/parg/selfhost"

data/lib/parsanol/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parsanol
 version: !ruby/object:Gem::Version
-  version: 1.3.131
+  version: 1.3.133
 platform: aarch64-linux
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-11-03 00:00:00.000000000 Z
+date: 2026-11-04 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
@@ -120,6 +120,7 @@ files:
 - lib/parsanol/parg/lints.rb
 - lib/parsanol/parg/lsp.rb
 - lib/parsanol/parg/lutaml.rb
+- lib/parsanol/parg/model_bindings.rb
 - lib/parsanol/parg/node.rb
 - lib/parsanol/parg/parser.rb
 - lib/parsanol/parg/preprocess.rb