parsanol 1.3.131-arm-linux → 1.3.133-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: afe72da9ae0123c684e14712e7beca91be06a3aed47a9d23fb2773ff7c416cc0
-  data.tar.gz: 8fad49c822d064b20bec1dcec0fc02744b3bf37286bea421e507fc1aecc1585c
+  metadata.gz: da3a095c72f65652ddab5b934de4f64f2c0826745224d43036097f558e4bbac0
+  data.tar.gz: 1f67d5b9aa5d48361539b2ca731bda6e06e53cf9d6200134ac7c2dcea4e2d493
 SHA512:
-  metadata.gz: 0c3f6852886fcfe5dc98f3bef82e2c4b4c848f8a5d52c15f678e27b48d5f5961790ac546ca8148c0798c032d830419906124b16b7989d290fc01c5b96e0f510b
-  data.tar.gz: 0551ad716b7fea06944d131b7fbe34f383fe3688a0ebd9bb6feaffe6370d3dbbd678d31c669bd1928a7ff6ce2578f061b04439cb69f673e64e07e89ef01b4be3
+  metadata.gz: 293d7578ea11e2c9c7d304e3a9175a45ff6eeb7fc281ce80ad47f9ba3d61af6c3beae8acde36578b6a8fb5d22c4c4dfcffb8202a15c51958ddf8fa9ed1ec9a69
+  data.tar.gz: 18c817da76188bf803072750d0c190aa70c712516e0e5d329d75cdddc0500350d3ec3a1281a7d39a879c6a38652263c7344f01ff3b6991795ff405f689627307

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: 40173400 bytes
-sha256: 4f4f7afe991509053ac56d1e5a4bc2718135cf981c5711216d5f8b0b265d4730
+size: 40174108 bytes
+sha256: a4abd3f5e778228091e4116065ebb81d15adc599f3482bf9b622737742021ec4

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: 40358648 bytes
-sha256: 91dfea077cfaf283708470d56715a62a81a17400208028919120885c9dbb0e23
+size: 40359356 bytes
+sha256: fbdca2cc15d273d19be06530ec4fa0f3510de1b1279bd8afef9ff9dbf519accc

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: 40352828 bytes
-sha256: 15b7e39ba58fcb8ae89e22b7214abf02ad8482f2e48fd0b807bbcf0b9bb7c9f7
+size: 40353544 bytes
+sha256: e35eba05fd94a28eac6d1251f1be6cd2db12e9b18cad47a211d8b1106edfc743

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: 40362520 bytes
-sha256: 9d4f5c17a39732673f9428062ad93f804e6072d64c125dc9b8c6999a419b9797
+size: 40363240 bytes
+sha256: 986c052f3c478ec717dbc61f81d11a1210428cf300d9e6c140b23ba68994fe66

data/lib/parsanol/native/libparsanol.so

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: data/lib/parsanol/native/libparsanol.so
-size: 36496040 bytes
-sha256: e4ef5fc8222655352eb28aa1e0ac0076aa0ee9d82a570fd54f9ed0d6dcafd061
+size: 36496788 bytes
+sha256: 2bf9b4db07fed268f82cee8074cf77bb08a302ceec53c8bd8f48bfdf00220ae4

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: arm-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