parsanol 1.3.56-x86_64-linux → 1.3.57-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 66df514ceaedfb9d973a67ba46aa9a207602d8bba9103864bfdb39db558dc6ab
-  data.tar.gz: 853d2a548335096d7672ab4b4292770a25c260ccaaae8fae79cd2567bb9fa391
+  metadata.gz: 4a611b335d9ec0bb11eb58195d1c4cbc53c7f44c18a49d7d91dc2dded1c1f22a
+  data.tar.gz: dcdf2f61d1c5673f953aa7532a4ac36a0470b10feccb833ac4a35f5f6c2b6c31
 SHA512:
-  metadata.gz: 5ffb88f39d23d6fcb14d2ac9ca589b8f44699dbb6691911e75265253d9f48c3447e14dd7c77a11bfc4047ab3d99fa7a3c9e4be030d798564d7757338904d40af
-  data.tar.gz: 24f5ce2a2b09f7b0c9d12d758cac3fba3372a1ba5ca22d209c193856d405a307f593d9246c8dbd6e80a9e25f6b9746ee79b0819a701afd174950f45018180208
+  metadata.gz: 6efce812c6ecca13bd6fd73c9c1f8214e459452bc964ded5083fcb6e25b23395c20ddc190f5ff9f3610e0d9a63a5b5019665daf86983d0b73ce9e0f99dbd5d6c
+  data.tar.gz: b4ebc57677baa4b6c8e51d1f0ce580b220c103643df44c14c7a374a8b687f49b74a773f4314a6d59bfca58e837e1f6f709c57feacf217b64f3cb3a91c1641eb3

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/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: 35066072 bytes
-sha256: 754a72fbf04eb7c51adb630381a3a695011edda945f6f728e5a22ae1bbfaf52a
+size: 39039928 bytes
+sha256: fce80ea722af36f85c9486bd51038c509c036f2feed3fbdf211f009d2f5ed150

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: 35296024 bytes
-sha256: d85a6d3939482a73ed925708bdb6de3d1cc61ade10c01d2ecf4e7a24a6c3fe2b
+size: 39269840 bytes
+sha256: eb7a20a4173dfee8593d53260427c53b0e3725db352b859588f62ba6e8d522fb

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: 35295024 bytes
-sha256: b820397175deb40fe91edbb41a2c90a1b1529c8ed2c8d3e32284089442c5baac
+size: 39268832 bytes
+sha256: 9edbb5d0963d2cad4a6485c50f9f5d719e02684698be05eb5c77457bb4fd6777

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: 35304912 bytes
-sha256: 6ebf6401932f29a1efd4cf417197979d72d449a6fda639d04df1efdbdabbac2b
+size: 39278776 bytes
+sha256: c3b9c56f68adb58b20804796e1871b91db32205893198d6bbcee77ceabfbf251

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/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

data/lib/parsanol/parg/bindings.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Parsanol
+  module PARG
+    # Applies an entry's artifact bindings to a parsanol-shape parse tree,
+    # producing the attribute hash that fills a lutaml-model class:
+    # capture collection -> preprocessing -> type cast -> path assignment.
+    module Bindings
+      module_function
+
+      def apply(artifact, entry, shape)
+        bindings = entry["bindings"] || []
+        captures = collect_captures(shape)
+        out = {}
+        scalar, arrays = bindings.partition { |binding| !binding["path"].to_s.include?("[]") }
+        scalar.each do |binding|
+          validate_path!(binding)
+          assign_scalar(out, artifact, binding, captures)
+        end
+        arrays.group_by { |binding| binding["path"].split("[]").first }.each do |prefix, group|
+          assign_array(out, artifact, prefix, group, captures)
+        end
+        out
+      end
+
+      def collect_captures(shape)
+        found = Hash.new { |hash, key| hash[key] = [] }
+        queue = [shape]
+        until queue.empty?
+          node = queue.shift
+          case node
+          when Hash
+            node.each do |key, value|
+              found[key.to_sym] << value
+              queue << value
+            end
+          when Array then queue.concat(node)
+          end
+        end
+        found
+      end
+
+      def assign_scalar(out, artifact, binding, captures)
+        value = captures[binding["capture"].to_sym].first
+        return if value.nil?
+
+        out[leaf_key(binding)] = finalize(artifact, binding, value)
+      end
+
+      def assign_array(out, artifact, prefix, group, captures)
+        count = group.map { |binding| captures[binding["capture"].to_sym].length }.max || 0
+        return if count.zero?
+
+        list = (out[prefix] ||= [])
+        count.times do |index|
+          element = {}
+          group.each do |binding|
+            value = captures[binding["capture"].to_sym][index]
+            next if value.nil?
+
+            element[leaf_key(binding)] = finalize(artifact, binding, value)
+          end
+          list << element
+        end
+      end
+
+      def validate_path!(binding)
+        path = binding["path"].to_s
+        return unless path.include?(".") || path.include?("[")
+
+        raise ArtifactError,
+              "binding #{binding['capture'].inspect}: nested path " \
+              "#{path.inspect} is not supported; bind the components instead"
+      end
+
+      def leaf_key(binding)
+        path = binding["path"].to_s
+        leaf = path.include?("[]") ? path.split("].").last : path
+        leaf.to_sym
+      end
+
+      def finalize(artifact, binding, value)
+        cast(preprocess(artifact, binding, value), binding["type"])
+      end
+
+      def preprocess(artifact, binding, value)
+        return value if binding["preprocess"].nil?
+
+        steps = artifact.envelope["preprocess"].fetch(binding["preprocess"]) do
+          raise ArtifactError,
+                "preprocess step #{binding['preprocess'].inspect} not declared"
+        end
+        steps.each do |step|
+          case step["op"]
+          when "table_lookup"
+            map = artifact.table_rows(step["table"]).to_h do |row|
+              [row[step["from"]].to_s, row[step["to"]]]
+            end
+            value = map[value.to_s] || value
+          else
+            raise ArtifactError, "unknown preprocess op #{step['op'].inspect}"
+          end
+        end
+        value
+      end
+
+      def cast(value, type)
+        case type
+        when "integer" then Integer(value)
+        when "float" then Float(value)
+        when "string"
+          # Parsanol::Slice (Ruby atom runtime) and native leaf objects are
+          # the shape contract's capture leaves; their to_s is the text.
+          scalar = value.nil? || value.is_a?(String) || value.is_a?(Numeric) ||
+            value == true || value == false || value.is_a?(Parsanol::Slice)
+          unless scalar
+            raise ArtifactError,
+                  "cannot bind a #{value.class} capture to (string); " \
+                  "captures must be scalar"
+          end
+
+          value.to_s
+        when "boolean" then value == true || value.to_s.casecmp("true").zero?
+        else value
+        end
+      end
+    end
+  end
+end