parsanol 1.3.61-arm-linux → 1.3.63-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b9cb26b86a6945fa3e32d5a273d1202c32dc1b29207ceb26ec254bcbd89c99b5
-  data.tar.gz: 264d5cc2e7f99688a67f8ce095955491d98b77aa607fed90ed8f628d5949b159
+  metadata.gz: 686fbbce80e4f2fabc5b050d06eb209ccf919c347fc9bc4a6a755e5b7aadc69e
+  data.tar.gz: 342c41ab713eaade585308f97cd5d94016612e66a06069a93c531aec32395a25
 SHA512:
-  metadata.gz: 1ea23aac23e879ac4b599aba68778485b2336a7576466b271794309dee6cfc462123e552574123d4c572a2b5ee1a0d71badce00aed5d570e425c78515aee9691
-  data.tar.gz: 9cf3429cb1f051a6514b1dd1c68673af18eaea577780413374c3441e89f1ccfed7c78ce268c8c090af1e4717dd2bd9541478ca86f1ed7786a5a1aca9a9614410
+  metadata.gz: 9eb70ff88a8d02ac69f7ddcdcce3dba5e4015ff0e60331259b165d2f470474b09cf2435b4a0f43c6965c05e6ea7be798fd72d494b4b87ad064681052b99d55ab
+  data.tar.gz: 7d0f829a1c4ab6b068420873d90aee866b5e2cb5f1c200857750a6ac54d5eedccc0abfdc221a693be9126fc17db6ef8c1ab206903bc474801650b1e41199622a

data/lib/parsanol/native.rb

@@ -220,15 +220,21 @@ module Parsanol
         # to recover inputs from grammars native cannot express.
         parsanol_grammar =
           grammar.is_a?(Parsanol::Atoms::Base) || grammar.is_a?(Parsanol::Parser)
-        if parsanol_grammar && (m = error.message.match(NATIVE_POS_MARKER))
+        # The position capture is extracted as a plain String: a MatchData
+        # would pin its subject — the full multi-KB failure message — for
+        # as long as anything downstream retains it, and callers that
+        # rescue-and-collect (pubid's flavor dispatcher) retain millions
+        # across long parses (#123).
+        message = error.message
+        if parsanol_grammar && (pos_str = message[NATIVE_POS_MARKER, 1])
           source = Parsanol::Source.new(input)
           success, value = grammar.run_with_context(source, nil, true)
           return grammar.finalize_result(value) if success
 
-          pos = m[1].to_i
-          msg = error.message.sub(NATIVE_POS_MARKER, "")
+          pos = pos_str.to_i
+          msg = message.sub(NATIVE_POS_MARKER, "")
           cause = Parsanol::Cause.new(msg, source, pos)
-          raise Parsanol::ParseFailed.new(cause.to_s, cause)
+          raise Parsanol::ParseFailed.new(cause.to_s, cause), cause: nil
         end
 
         if parsanol_grammar
@@ -243,17 +249,20 @@ module Parsanol
           value.raise
         end
 
-        if (marker = error.message.match(NATIVE_POS_MARKER))
+        # Same capture-string extraction as above; `cause: nil` keeps the
+        # retained ParseFailed from pinning the original RuntimeError and
+        # its message through the exception-cause chain (#123).
+        if (pos_str = message[NATIVE_POS_MARKER, 1])
           source = Parsanol::Source.new(input)
           cause = Parsanol::Cause.new(
-            error.message.sub(NATIVE_POS_MARKER, ""), source, marker[1].to_i
+            message.sub(NATIVE_POS_MARKER, ""), source, pos_str.to_i
           )
-          raise Parsanol::ParseFailed.new(cause.to_s, cause)
+          raise Parsanol::ParseFailed.new(cause.to_s, cause), cause: nil
         end
 
         source = Parsanol::Source.new(input)
-        cause = Parsanol::Cause.new(error.message, source, source.bytepos)
-        raise Parsanol::ParseFailed.new(cause.to_s, cause)
+        cause = Parsanol::Cause.new(message, source, source.bytepos)
+        raise Parsanol::ParseFailed.new(cause.to_s, cause), cause: nil
       end
 
       # Pre-serialized JSON grammar path (library authors with cached JSON).

data/lib/parsanol/parg/artifact.rb

@@ -14,7 +14,7 @@ module Parsanol
       attr_reader :envelope, :path, :tables_dir
 
       def self.load(path, tables_dir: nil)
-        envelope = JSON.parse(File.read(path))
+        envelope = JSON.parse(PARG.read_utf8(path))
         new(envelope, path, tables_dir || File.dirname(path))
       end
 
@@ -28,8 +28,13 @@ module Parsanol
         unless envelope["shape"] == SUPPORTED_SHAPE
           raise ArtifactError,
                 "unsupported artifact shape #{envelope['shape'].inspect} " \
-                "(this runtime implements #{SUPPORTED_SHAPE.inspect})"
+                "(this runtime implements #{SUPPORTED_SHAPE.inspect}; the " \
+                "contract is docs/PARSANOL-SHAPE-v2.md in parsanol-rs — " \
+                "a shape bump requires a new engine family, artifacts " \
+                "declaring #{SUPPORTED_SHAPE.inspect} parse identically forever)"
         end
+        bindings = envelope["bindings"]
+        validate_bindings!(bindings) unless bindings.nil?
         @envelope = envelope
         @path = path
         @tables_dir = tables_dir
@@ -139,15 +144,27 @@ module Parsanol
 
       # Structured parse diagnostics (PN 2): {offset, message} for the
       # deepest failure of the most recent parse attempt on this entry.
+      # Structured parse diagnostics — the flat v1 wire format every
+      # backend agrees on (parsanol-rs#145): offset, the expected-symbol
+      # list, and a message, fetched out-of-band so success paths pay
+      # nothing. Full cause trees stay a Ruby-side diagnostic.
       def parse_with_diagnostics(entry_name, input, mode: :native)
         shape = parse(entry_name, input, mode: mode)
-        { "ok" => true, "offset" => nil, "message" => nil, "shape" => shape }
+        { "ok" => true, "offset" => nil, "expected" => [],
+          "message" => nil, "shape" => shape }
       rescue Parsanol::ParseFailed => e
         cause = deepest_cause(e.parse_failure_cause)
         { "ok" => false, "offset" => cause&.position,
+          "expected" => expected_labels_for(cause),
           "message" => cause&.message || e.message, "shape" => nil }
       end
 
+      def expected_labels_for(cause)
+        return [] unless cause.respond_to?(:expected)
+
+        Array(cause.expected)
+      end
+
       def deepest_cause(cause)
         return cause if cause.nil? || cause.children.empty?
 
@@ -169,7 +186,7 @@ module Parsanol
 
         file = declared
         path = File.join(@tables_dir.to_s, file)
-        raw = path.end_with?(".json") ? JSON.parse(File.read(path)) : YAML.safe_load_file(path, aliases: true)
+        raw = path.end_with?(".json") ? JSON.parse(PARG.read_utf8(path)) : YAML.safe_load(PARG.read_utf8(path), aliases: true)
         rows = case raw
                when Hash
                  raw.map { |key, value| { "name" => key.to_s }.merge(value.to_h.transform_keys(&:to_s)) }
@@ -179,6 +196,39 @@ module Parsanol
         @table_cache[name] = rows
       end
 
+      # The envelope's optional grammar-to-model bindings section
+      # (envelope v2, parsanol-rs#143): capture name -> model attribute
+      # paths, type casts, cardinality, and preprocessing step refs,
+      # declared once and consumed identically by every tier's binder.
+      # Phase 1 validates the section's shape and exposes it as data.
+      def bindings
+        envelope["bindings"]
+      end
+
+      BINDINGS_ALLOWED_KEYS = %w[captures entries version].freeze
+
+      def validate_bindings!(bindings)
+        unless bindings.is_a?(Hash)
+          raise ArtifactError, "bindings section must be a map (got #{bindings.class})"
+        end
+
+        unknown = bindings.keys - BINDINGS_ALLOWED_KEYS
+        unless unknown.empty?
+          raise ArtifactError, "bindings section has unknown keys: #{unknown.inspect}"
+        end
+
+        (bindings["captures"] || {}).each do |name, spec|
+          unless spec.is_a?(Hash) && spec["path"].is_a?(String)
+            raise ArtifactError,
+                  "bindings capture #{name.inspect} must declare a string :path"
+          end
+        end
+      rescue ArtifactError
+        raise
+      rescue StandardError => e
+        raise ArtifactError, "malformed bindings section: #{e.class}: #{e.message}"
+      end
+
       def compiler
         @compiler ||= begin
           document = Parser.new(envelope.fetch("source")).parse

data/lib/parsanol/parg/authoring.rb

@@ -25,7 +25,7 @@ module Parsanol
       end
 
       def read_file(file)
-        content = File.read(file).gsub(/^#[^\n]*\n/, "")
+        content = PARG.read_utf8(file).gsub(/^#[^\n]*\n/, "")
         header = content.match(/suite\s+\w+(?:\s+for\s+entry\s+(?<entry>\w+))?\s*\{/)
         unless header
           raise ParseError,

data/lib/parsanol/parg/cli.rb

@@ -36,7 +36,8 @@ module Parsanol
       end
 
       def initialize(argv)
-        @argv = argv.dup
+        # Under a non-UTF-8 locale ARGV arrives as BINARY; inputs are UTF-8.
+        @argv = argv.map { |arg| arg.dup.force_encoding(Encoding::UTF_8) }
         @tables_dir = nil
       end
 
@@ -82,7 +83,7 @@ module Parsanol
         source = @argv.shift
         out = flag_value("-o") || default_artifact_name(source)
         envelope = compile_source(source).envelope
-        File.write(out, "#{JSON.generate(envelope)}\n")
+        File.write(out, "#{JSON.generate(envelope)}\n", encoding: Encoding::UTF_8)
         puts "#{out}  #{envelope['checksum']}  warnings=#{envelope['lint']['order_warnings'].size}"
         0
       end
@@ -161,7 +162,7 @@ module Parsanol
         puts "parsanol parg repl — #{file} entry #{entry_name.inspect}; blank line quits"
         loop do
           print "> "
-          input = $stdin.gets
+          input = $stdin.gets&.force_encoding(Encoding::UTF_8)
           break if input.nil? || input.strip.empty?
 
           begin
@@ -209,7 +210,7 @@ module Parsanol
 
       def compile_source(file)
         tables = @tables_dir || default_tables_dir(file)
-        document = Parsanol::PARG::Parser.new(File.read(file)).parse
+        document = Parsanol::PARG::Parser.new(PARG.read_utf8(file)).parse
         Parsanol::PARG::Imports.merge!(document, [File.dirname(file)])
         Parsanol::PARG::Compiler.compile(document, tables_dir: tables)
       end

data/lib/parsanol/parg/compiler.rb

@@ -40,9 +40,13 @@ module Parsanol
         end
       end
 
-      def initialize(document, tables_dir)
+      def initialize(document, tables_dir, bindings: nil)
         @document = document
         @tables_dir = tables_dir
+        # Envelope v2 (parsanol-rs#143): grammar-to-model bindings bake
+        # into the checksummed envelope so every tier consumes one
+        # declaration. Data pass-through in phase 1.
+        @bindings = bindings
         @atom_cache = {}
         @first_cache = {}.compare_by_identity
         @ref_stack = []
@@ -254,7 +258,7 @@ module Parsanol
         end
 
         raw = if path.end_with?(".json")
-                JSON.parse(File.read(path))
+                JSON.parse(PARG.read_utf8(path))
               else
                 YAML.safe_load_file(path, aliases: true)
               end
@@ -396,6 +400,7 @@ module Parsanol
           [name, entry_envelope(rule)]
         end
         envelope = {
+          "bindings" => @bindings,
           "version" => @document.version,
           "grammar" => @document.grammar_name,
           "shape" => "parsanol-tree/v2",

data/lib/parsanol/parg/imports.rb

@@ -19,7 +19,7 @@ module Parsanol
           raise CompileError, "import cycle: #{(merging + [name]).join(' -> ')}" if merging.include?(name)
 
           source = find_file(name, import_dirs)
-          used = Parser.new(File.read(source)).parse
+          used = Parser.new(PARG.read_utf8(source)).parse
           merge!(used, import_dirs, merging + [name])
           merge_used(document, used, "#{name}.")
         end

data/lib/parsanol/parg/selfhost.rb

@@ -32,7 +32,7 @@ module Parsanol
       def validate(source)
         raise ArtifactError, "parg artifact not found (set PG_ARTIFACT)" unless available?
 
-        envelope = JSON.parse(File.read(artifact_path))
+        envelope = JSON.parse(PARG.read_utf8(artifact_path))
         artifact = Artifact.new(envelope, nil, nil)
         artifact.parse("file", source)
       end

data/lib/parsanol/parg.rb

@@ -38,5 +38,12 @@ module Parsanol
     autoload :Imports, "parsanol/parg/imports"
     autoload :Suite, "parsanol/parg/authoring"
     autoload :Schema, "parsanol/parg/authoring"
+
+    # PARG sources and JSON artifacts are UTF-8 by definition: read them as
+    # UTF-8 whatever the locale's default external encoding, and skip a
+    # byte-order mark the way YAML.safe_load_file does (GH-121).
+    def self.read_utf8(path)
+      File.read(path, mode: "r:bom|utf-8")
+    end
   end
 end

data/lib/parsanol/version.rb

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

metadata

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