parsanol 1.3.54-arm-linux → 1.3.57-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e49b5e2d3931d3587bc0c152c8ee65bf46063e2537513691aa174d433a5e6eb3
-  data.tar.gz: 8a2b5e3db4e0a4a389253366e2a6e3576871e70e8894f8fa95ab037f31f188b9
+  metadata.gz: b95e9035301a942d6d8f3acea734d6a4b0f6c5716dee43bc003cbb0be22060d1
+  data.tar.gz: c473d80ba7ebcf0ad407c5b1d120641bfc914808d90d7f3cbe45af296f391c69
 SHA512:
-  metadata.gz: cb986c7b091990733d47ad8065b82697e9062edce5964d41714520f22ab07154ba1a8683598e5c5dce7377ceb28e9fec46004013c013df8a727f55ee71c112c4
-  data.tar.gz: c459ffa3b22bb9a056f0582fd4ffa06f2ded2e46e9b3683556c0dab7467e61ba9667d62d5272fea5595206d942d8e55db822294646c561088fbc0c413bbd96e4
+  metadata.gz: f998f1206ae7342ff33b5ed1f8225e0a05b9e6f92af7602d7c7741763ca621ee22c50d95ec303a5f44e2ec2f373ee714e20aeb4a57ccc8da108da1b290895820
+  data.tar.gz: 0a607fc6dda81038d2181e7226afe026a025564deed09b12caab1c938afd25f086096bd3bf6210c0a1b4bb38dfe8445fef032654832dfebd2e24f24b4df2becc

data/exe/parsanol

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "parsanol"
+require "parsanol/parg/cli"
+argv = ARGV[0] == "parg" ? ARGV[1..] : ARGV
+exit Parsanol::PARG::CLI.run(argv)

data/lib/parsanol/atoms/base.rb

@@ -208,7 +208,7 @@ module Parsanol
 
       # Converts raw input to Source if needed.
       def normalize_input(source)
-        source.respond_to?(:line_and_column) ? source : Parsanol::Source.new(source)
+        source.is_a?(Parsanol::Source) ? source : Parsanol::Source.new(source)
       end
 
       # Detects if we're in a Parser context.

data/lib/parsanol/atoms/cut.rb

@@ -42,7 +42,7 @@ module Parsanol
         # 1. Mark the current position as a cut point
         # 2. Empty the backtrack stack (we won't backtrack past here)
         # 3. Aggressively evict cache entries before this position
-        context.cut!(source.bytepos) if context.respond_to?(:cut!)
+        context.cut!(source.bytepos)
 
         [success, value]
       end

data/lib/parsanol/atoms/repetition.rb

@@ -66,7 +66,7 @@ module Parsanol
       # @return [Array(Boolean, Object)] result
       def try(source, context, consume_all)
         # Check for tree memoization support
-        if context.respond_to?(:use_tree_memoization?) && context.use_tree_memoization?
+        if context.use_tree_memoization?
           return with_tree_cache(source, context, consume_all)
         end
 
@@ -183,6 +183,7 @@ module Parsanol
         last_failure = nil
 
         loop do
+          iteration_start = source.bytepos
           success, value = @parslet.apply(source, context, false)
 
           unless success
@@ -193,6 +194,11 @@ module Parsanol
           occurrence += 1
           result[occurrence] = value
 
+          # A body match that consumes nothing cannot make progress;
+          # looping again would re-match empty forever. Count the empty
+          # match, then stop — the min check below applies as usual.
+          break if source.bytepos == iteration_start
+
           break if @max && occurrence >= @max
         end
 
@@ -254,6 +260,7 @@ module Parsanol
         last_failure = nil
 
         loop do
+          iteration_start = source.bytepos
           success, value = @parslet.apply(source, context, false)
 
           unless success
@@ -265,6 +272,10 @@ module Parsanol
           result[occurrence] = value
           positions << source.bytepos
 
+          # Zero-width body match: count it, stop iterating (the min
+          # check below applies as usual) — mirrors try_general.
+          break if source.bytepos == iteration_start
+
           break if @max && occurrence >= @max
         end
 
@@ -287,7 +298,7 @@ module Parsanol
           context.store_tree_memo(cache_key, start_pos,
                                   result[1, occurrence], end_pos)
         end
-        context.release_array(positions) if context.respond_to?(:release_array)
+        context.release_array(positions)
 
         # Check minimum
         if occurrence < @min

data/lib/parsanol/cause.rb

@@ -74,7 +74,7 @@ module Parsanol
       line_num, col_num = @source.line_and_column(@position)
 
       formatted_msg = @message.map do |msg|
-        msg.respond_to?(:to_slice) ? msg.content.inspect : msg.to_s
+        msg.is_a?(Parsanol::Slice) ? msg.content.inspect : msg.to_s
       end.join
 
       "#{formatted_msg} at line #{line_num} char #{col_num}#{@parsing_label}."

data/lib/parsanol/error_reporter/contextual.rb

@@ -72,7 +72,7 @@ module Parsanol
         cause = super
 
         # Apply label if the atom has one
-        if atom.respond_to?(:label) && (lbl = atom.label)
+        if atom.is_a?(Parsanol::Atoms::Base) && (lbl = atom.label)
           maybe_update_label(lbl, src.pos.bytepos)
           cause.set_label(@active_label_text)
         end

data/lib/parsanol/lazy_result.rb

@@ -103,6 +103,15 @@ module Parsanol
 
     alias kind_of? is_a?
 
+    # The delegated interface: Array's full class contract (including
+    # Enumerable), computed once against the type rather than probed on
+    # instances.
+    ARRAY_METHODS = (
+      Array.instance_methods(true) + Enumerable.instance_methods + [:to_ary]
+    ).freeze
+
+    private_constant :ARRAY_METHODS
+
     # Respond to array methods.
     #
     # @param method [Symbol] Method name
@@ -110,7 +119,7 @@ module Parsanol
     # @return [Boolean] true if responds
     #
     def respond_to?(method, include_private = false)
-      super || to_a.respond_to?(method, include_private)
+      super || ARRAY_METHODS.include?(method)
     end
 
     # Delegate unknown methods to materialized array.
@@ -121,7 +130,7 @@ module Parsanol
     # @return [Object] Result of method call
     #
     def method_missing(method, ...)
-      if to_a.respond_to?(method)
+      if ARRAY_METHODS.include?(method)
         to_a.public_send(method, ...)
       else
         super
@@ -135,7 +144,7 @@ module Parsanol
     # @return [Boolean] true if method is supported
     #
     def respond_to_missing?(method, include_private = false)
-      to_a.respond_to?(method, include_private) || super
+      ARRAY_METHODS.include?(method) || super
     end
 
     # Compare with another object.

data/lib/parsanol/native/serializer.rb

@@ -95,9 +95,12 @@ module Parsanol
 
     def serialize_re(atom)
       # Ruby's Regexp#to_s produces "(?-mix:pattern)" format
-      # We need to extract just the pattern for the Rust parser
+      # The pattern must reach the Rust regex engine verbatim, including
+      # inline flag groups: stripping (?i:...) silently turned every
+      # case-insensitive regex into a case-sensitive one on the native
+      # path (the Ruby atom still compiled it with the flag, so the two
+      # engines disagreed). Rust regex understands the same inline groups.
       pattern = atom.match
-      pattern = ::Regexp.last_match(1) if pattern =~ /^\(\?[-mix]*:(.+)\)$/
       {
         "Re" => {
           "pattern" => pattern,

data/lib/parsanol/native/transformer.rb

@@ -391,15 +391,19 @@ module Parsanol
           return left.is_a?(Hash) ? left.merge(right) : left + right
         end
 
-        if left.respond_to?(:to_str) && right.respond_to?(:to_str)
-          return right if right.respond_to?(:to_slice)
-          return left if left.respond_to?(:to_slice)
-
-          return left.to_str + right.to_str
+        # String-like = String or Slice (both implement to_str). When
+        # only ONE side is string-like, the OTHER side wins — the
+        # original duck-typed priority, preserved exactly.
+        left_stringlike = left.is_a?(String) || left.is_a?(Parsanol::Slice)
+        right_stringlike = right.is_a?(String) || right.is_a?(Parsanol::Slice)
+        if left_stringlike && right_stringlike
+          return right if right.is_a?(Parsanol::Slice)
+          return left if left.is_a?(Parsanol::Slice)
+
+          return left + right
         end
-
-        return left if right.respond_to?(:to_str)
-        return right if left.respond_to?(:to_str)
+        return left if right_stringlike
+        return right if left_stringlike
 
         return left + [right] if right.is_a?(Hash)
         return [left] + right if left.is_a?(Hash)

data/lib/parsanol/native.rb

@@ -216,7 +216,9 @@ module Parsanol
         # cause from that directly — the failure path never needs a
         # reporter reparse. The single interpreter pass below stays only
         # to recover inputs from grammars native cannot express.
-        if grammar.respond_to?(:parse) && (m = error.message.match(NATIVE_POS_MARKER))
+        parsanol_grammar =
+          grammar.is_a?(Parsanol::Atoms::Base) || grammar.is_a?(Parsanol::Parser)
+        if parsanol_grammar && (m = error.message.match(NATIVE_POS_MARKER))
           source = Parsanol::Source.new(input)
           success, value = grammar.run_with_context(source, nil, true)
           return grammar.finalize_result(value) if success
@@ -227,7 +229,7 @@ module Parsanol
           raise Parsanol::ParseFailed.new(cause.to_s, cause)
         end
 
-        if grammar.respond_to?(:parse)
+        if parsanol_grammar
           # No native diagnostics (e.g. incomplete-input errors): one
           # interpreter pass with the reporter attached — a success
           # recovers the tree, a failure raises the cause tree.

data/lib/parsanol/parg/artifact.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+require "json"
+require "yaml"
+
+module Parsanol
+  module PARG
+    # A compiled artifact envelope: load, verify checksum, parse inputs.
+    #
+    # The envelope's grammar section is the portable JSON the native engines
+    # consume; the embedded PARG source lets a Ruby runtime recompile the atom
+    # tree locally without any other dependency.
+    class Artifact
+      attr_reader :envelope, :path, :tables_dir
+
+      def self.load(path, tables_dir: nil)
+        envelope = JSON.parse(File.read(path))
+        new(envelope, path, tables_dir || File.dirname(path))
+      end
+
+      def self.from_json(text, tables_dir: nil)
+        new(JSON.parse(text), nil, tables_dir)
+      end
+
+      SUPPORTED_SHAPE = "parsanol-tree/v2"
+
+      def initialize(envelope, path, tables_dir)
+        unless envelope["shape"] == SUPPORTED_SHAPE
+          raise ArtifactError,
+                "unsupported artifact shape #{envelope['shape'].inspect} " \
+                "(this runtime implements #{SUPPORTED_SHAPE.inspect})"
+        end
+        @envelope = envelope
+        @path = path
+        @tables_dir = tables_dir
+        verify_checksum!
+        @compiler = nil
+      end
+
+      def version = envelope["version"]
+
+      def entries = envelope["entries"].keys
+
+      def entry(name)
+        envelope["entries"].fetch(name) do
+          raise ArtifactError, "unknown entry #{name.inspect}"
+        end
+      end
+
+      # Parse via the native engine: the envelope's grammar section is the
+      # exact portable JSON the Rust side registers, so the artifact parse
+      # path is a straight register-and-run — no Ruby recompilation. The
+      # Ruby atom runtime (mode: :ruby) remains available explicitly, and
+      # serves as the fallback on platforms without the extension.
+      def parse(entry_name, input, mode: :native)
+        case mode
+        when :native
+          if Native.available?
+            return Native.parse(JSON.generate(entry(entry_name).fetch("grammar")), input)
+          end
+
+          root_atom(entry_name).parse(input)
+        when :ruby
+          root_atom(entry_name).parse(input)
+        else
+          raise ArgumentError, "unknown mode #{mode.inspect} (use :native or :ruby)"
+        end
+      end
+
+      def apply_bindings(entry_name, shape)
+        Bindings.apply(self, entry(entry_name), shape)
+      end
+
+      # Render the identifier string from a bound attribute map (F6).
+      def render(_entry_name, bound, variant: "default")
+        Render.apply(envelope["render"] || {}, variant, bound)
+      end
+
+      def render_string(entry_name, input, variant: "default")
+        render(entry_name, parse_and_bind(entry_name, input), variant: variant)
+      end
+
+      # Evaluate a named derive spec against a bound map (F6).
+      def derive(name, bound)
+        Derive.apply(envelope["derive"] || {}, name, bound)
+      end
+
+      def derive_string(entry_name, input, name)
+        derive(name, parse_and_bind(entry_name, input))
+      end
+
+      def parse_and_bind(entry_name, input, mode: :native)
+        apply_bindings(entry_name, parse(entry_name, input, mode: mode))
+      end
+
+      # Re-run the grammar's in-file tests against this artifact. Returns
+      # the failure descriptions; empty means every test passes.
+      def run_tests(mode: :native)
+        run_test_list(envelope.fetch("tests", []), mode: mode)
+      end
+
+      # Run an external test list (suite files yield Document::Test
+      # structs; embedded tests are artifact-shaped hashes).
+      def run_test_list(tests, mode: :native)
+        tests.filter_map do |test|
+          hash = test.is_a?(Document::Test) ? test_to_hash(test) : test
+          entry_name = hash["entry"] || entries.first
+          begin
+            bound = parse_and_bind(entry_name, hash["input"], mode: mode)
+            if hash["kind"] == "reject"
+              "test #{hash['input'].inspect}: expected the input to be rejected"
+            elsif hash["kind"] == "example"
+              expect = hash["expect"].to_h { |key, value| [key.to_sym, value] }
+              mismatched = expect.reject { |key, value| bound.key?(key) && bound[key] == value }
+              next if mismatched.empty?
+
+              "test #{hash['input'].inspect}: expected captures " \
+                "#{mismatched.transform_values(&:inspect).inspect}, got #{bound.inspect}"
+            end
+          rescue Parsanol::ParseFailed
+            unless hash["kind"] == "reject"
+              "test #{hash['input'].inspect}: expected the input to parse"
+            end
+          end
+        end
+      end
+
+      def test_to_hash(test)
+        {
+          "entry" => test.entry,
+          "kind" => test.kind.to_s,
+          "input" => test.input,
+          "expect" => test.expect,
+        }
+      end
+
+      # Rule documentation embedded from ## doc comments.
+      def rule_docs = envelope.fetch("docs", {})
+
+      # Structured parse diagnostics (PN 2): {offset, message} for the
+      # deepest failure of the most recent parse attempt on this entry.
+      def parse_with_diagnostics(entry_name, input, mode: :native)
+        shape = parse(entry_name, input, mode: mode)
+        { "ok" => true, "offset" => nil, "message" => nil, "shape" => shape }
+      rescue Parsanol::ParseFailed => e
+        cause = deepest_cause(e.parse_failure_cause)
+        { "ok" => false, "offset" => cause&.position,
+          "message" => cause&.message || e.message, "shape" => nil }
+      end
+
+      def deepest_cause(cause)
+        return cause if cause.nil? || cause.children.empty?
+
+        deepest = cause.children.filter_map { |child| deepest_cause(child) }
+          .max_by { |node| node.position.to_i }
+        (deepest&.position.to_i >= cause.position.to_i ? deepest : cause)
+      end
+
+      def table_rows(name)
+        @table_cache ||= {}
+        return @table_cache[name] if @table_cache.key?(name)
+
+        declared = envelope["tables"].fetch(name) do
+          raise ArtifactError, "artifact does not declare table #{name.inspect}"
+        end
+        if declared.is_a?(Hash) && declared.key?("rows")
+          return @table_cache[name] = declared["rows"]
+        end
+
+        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)
+        rows = case raw
+               when Hash
+                 raw.map { |key, value| { "name" => key.to_s }.merge(value.to_h.transform_keys(&:to_s)) }
+               when Array then raw.map { |row| row.to_h.transform_keys(&:to_s) }
+               else raise ArtifactError, "table #{name.inspect} must be a map or array"
+               end
+        @table_cache[name] = rows
+      end
+
+      def compiler
+        @compiler ||= begin
+          document = Parser.new(envelope.fetch("source")).parse
+          # `use`-importing grammars carry dotted cross-grammar rule
+          # references that only resolve once the imported sources merge;
+          # without this the pure-Ruby path fails on artifacts whose
+          # native atom graphs inline everything. The imported sources
+          # sit beside the artifact (vendors ship them together).
+          imports_dir = path && File.directory?(File.dirname(path)) ? File.dirname(path) : nil
+          Imports.merge!(document, [imports_dir].compact) if imports_dir
+          Compiler.new(document, @tables_dir)
+        end
+      end
+
+      def root_atom(entry_name)
+        rule = entry(entry_name).fetch("root")
+        @compiled ||= {}
+        @compiled[rule] ||= compiler.atom_for(rule)
+      end
+
+      def verify_checksum!
+        stored = envelope["checksum"]
+        computed = Compiler.checksum(envelope)
+        return if stored == computed
+
+        raise ArtifactError,
+              "artifact checksum mismatch: stored #{stored.inspect}, " \
+              "computed #{computed.inspect}"
+      end
+    end
+  end
+end

data/lib/parsanol/parg/authoring.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Parsanol
+  module PARG
+    # External test suites: *.pgtest files carrying the same test syntax
+    # as the inline test section (accept / reject / example). Suites are
+    # development-time corpora — they iterate a grammar against its
+    # binding requirements without being embedded in the artifact.
+    #
+    #   suite smoke for entry identifier {
+    #     accept "ISO 8601-1:2019"
+    #     example "ISO/CD 12345" { stage: "draft20" }
+    #   }
+    module Suite
+      module_function
+
+      # Load every *.pgtest file in a directory.
+      # Returns { suite_name => [Document::Test, ...] }.
+      def load(dir)
+        Dir.glob(File.join(dir, "*.pgtest")).to_h do |file|
+          [File.basename(file, ".pgtest"), read_file(file)]
+        end
+      end
+
+      def read_file(file)
+        content = File.read(file).gsub(/^#[^\n]*\n/, "")
+        header = content.match(/suite\s+\w+(?:\s+for\s+entry\s+(?<entry>\w+))?\s*\{/)
+        unless header
+          raise ParseError,
+                "#{file}: expected 'suite <name> [for <entry>] { ... }'"
+        end
+
+        body = content[header.end(0)..].sub(/\}\s*\z/, "")
+        document = Parser.new("grammar Suite version \"0.0.0\" {\n}\ntest {\n#{body}\n}\n").parse
+        document.tests.map do |test|
+          Document::Test.new(header[:entry] || test.entry, test.kind, test.input, test.expect)
+        end
+      end
+    end
+
+    # The binding-requirements schema: what a language-specific data model
+    # must implement for an entry. Derived from the declared bindings plus
+    # the observed example values.
+    module Schema
+      module_function
+
+      def from_artifact(artifact)
+        artifact.entries.to_h do |entry|
+          entry_data = artifact.entry(entry)
+          fields = entry_data["bindings"].to_h do |binding|
+            requirements = {
+              "type" => binding["type"],
+              "card" => binding["card"] || "1",
+            }
+            requirements["preprocess"] = binding["preprocess"] if binding["preprocess"]
+            [binding["path"], requirements]
+          end
+          examples = artifact.envelope.fetch("tests", [])
+            .select { |test| (test["kind"] == "example" && test["entry"].nil?) || test["entry"] == entry }
+            .map { |test| { "input" => test["input"], "captures" => test["expect"] } }
+          [entry, { "root" => entry_data["root"], "fields" => fields, "examples" => examples }]
+        end
+      end
+
+      # TypeScript materialization types: one interface per entry, one
+      # property per bound field. Cards ending in * become arrays;
+      # 0..1 becomes nullable.
+      def to_typescript(schema)
+        lines = ["// Generated by parsanol parg schema --ts — binding-requirements types."]
+        schema.each do |entry, data|
+          lines << ""
+          lines << "export interface #{ts_name(entry)} {"
+          data["fields"].each do |path, requirements|
+            lines << "  #{ts_prop(path)}: #{ts_type(requirements)};"
+          end
+          lines << "}"
+        end
+        "#{lines.join("\n")}\n"
+      end
+
+      def ts_name(entry)
+        entry.split(/[_.]/).map(&:capitalize).join
+      end
+
+      def ts_prop(path)
+        leaf = path.include?("[]") ? path.split("].").last : path
+        leaf.gsub(/([A-Za-z0-9])_([a-z])/) do
+          "#{Regexp.last_match(1)}#{Regexp.last_match(2).upcase}"
+        end
+      end
+
+      def ts_type(requirements)
+        base = case requirements["type"]
+               when "integer", "float" then "number"
+               when "boolean" then "boolean"
+               else "string"
+               end
+        if requirements["card"].to_s.end_with?("*")
+          "#{base}[]"
+        elsif requirements["card"] == "0..1"
+          "#{base} | null"
+        else
+          base
+        end
+      end
+    end
+  end
+end