parsanol 1.3.61 → 1.3.63

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2391a03bae387ae90f7b30f074b3d56168b8c7f7b2462977ae8c1cac1784d72f
-  data.tar.gz: 25a1eb4a3c448c69d8300737c21f02330b68a3a0f19b0a5dc85cbd143044deb8
+  metadata.gz: f7ad59a2f852639eec49d8aaf0cfce4be63d8e13a20941b7db8f325244445e47
+  data.tar.gz: b4f7021d4c4dd9f30df4eddf64b2109da9005291b4d39edadd5075e54c6600c0
 SHA512:
-  metadata.gz: d666731dd83e2055d0c08fcca0f8c07f3a441ac4b29d018b6540799959530dbecb7c4a09ee9968aa90e6f94b16784bedfe14a89bf4c9c1aa98f0e2770904fb54
-  data.tar.gz: 8d39d2a6996cd2158973e8afceb1e73163e6edcaae75ee08943f1b1fcf66af15d9577610cec5eefc7a173c14ad49a2683e4b1e77d088fa70cedccb47a7096064
+  metadata.gz: d5fe08eb23fa452e06432cb8b72cb101b257b854fb33ae71455fd8c2a0d81356704f66fd11af330392783aa6c6a5b4730df1884718459c5d4acfe3abc74b8b48
+  data.tar.gz: b2d8251fc66c8d47085bf6338457975b6f29e707a173c8e107d5755137bd850ead86c6d130b6410b29e4155e87ae4c67cac3739278f0ddd4a7826fc94ffba53e

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,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: parsanol
 version: !ruby/object:Gem::Version
-  version: 1.3.61
+  version: 1.3.63
 platform: ruby
 authors:
 - Ribose Inc.