parsanol 1.3.112-aarch64-linux → 1.3.114-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e622ed0c55dbbcc4295a1b3740c36e0dc725a89251eb36c7799d6b60dbb026ff
-  data.tar.gz: d6d4c119f0e08a8b167faae5f1bb8203cf1f18d77d9cebd132a8bed6c2817882
+  metadata.gz: 8fc3b8894eb91a11d91f9992914d6051c711ddc66b695b83f513088323c10d99
+  data.tar.gz: e3492ffc96d70fc028c17bb347ac315029caf706b3c49ea70e65deaa46b8f52f
 SHA512:
-  metadata.gz: 6db2994d50d7d9e77a5a9b6614d3b0b461a623d06372bace9d30e9c45e09f6f55aa4efffbaa411ff00462e93e1f8b4681edc9229a15b391034293875a319846b
-  data.tar.gz: 4a36caf756fb3e162bdbe24235f1005a1a56e322677e86e2606900441994dbe6107ca8ce4822d02314bdda6bc38fb246dbd9767f1e816566daea4482e0ea558f
+  metadata.gz: 4527d1fb5b73608aec071c81e972034bd73d98c254be9536d52cce6d4e381d37aea76834a30982912335bab11a7076d42a0a9fc3499d4f4a93172fd590ddb98d
+  data.tar.gz: a9a9e610e50b4ff6bd156a9889c8899ec92ee97b7c2d6c7ff815abdb15cb9868c0d9783123dc8df35c3ebbdf36f604e7b97c2d20258f121f60315c9056399729

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: 45892256 bytes
-sha256: baf93c649b2dc899fc6b6a9e42d2f83ba44c08738db11fbb3ce74c1788507e55
+size: 46122264 bytes
+sha256: 4c782021e134c6025ae13057d9f1bfc7dcfa845d0227606474b767d23e7c0afe

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: 46127304 bytes
-sha256: 542480a12619696edd8e73bbb30d995b2ed2bae78f660050ea5f3cbcbc39f94c
+size: 46357288 bytes
+sha256: 8ab53f41d835b00b78c69abd9a8abcf40bab2255f3d48af7465c8e201f0dcd5a

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: 46122944 bytes
-sha256: d01871833b692c8d59f1d88b7c69792d1c44ed14fa9d62180534cabf508eb440
+size: 46356976 bytes
+sha256: 99972eec6d81c218e3f39f63db827914d58d9f5214aa605d31dfc0c8c5cb05a5

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: 46132984 bytes
-sha256: a3d424e1bdd7e31770de8e830d3531df4010f7cb1ef5d9e10a9da04d1ac935b2
+size: 46366976 bytes
+sha256: 827c2e86e427e028b8022ef0cc7530794cd64c954b88022e0db1faa2fa02cbc6

data/lib/parsanol/native/libparsanol.so

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: data/lib/parsanol/native/libparsanol.so
-size: 41651720 bytes
-sha256: cff3505da15196c090a20db6db228680d94b0467a1daa0d28ebc1e22f2066145
+size: 41881688 bytes
+sha256: 0cbe6973c43062f450a0cdabbdfb09d9401991038df1bd62dc67d78e030092c7

data/lib/parsanol/parg/artifact.rb

@@ -27,8 +27,16 @@ module Parsanol
       SUPPORTED_SHAPE = "parsanol-tree/v2"
 
       # The editions this runtime parses (ruby#357's consolidation):
-      # v1 = the legacy shapes; v2 = named trees + explicit spans.
-      SUPPORTED_EDITIONS = %w[v1 v2].freeze
+      # 1 = the legacy shapes; 2 = named trees + explicit spans.
+      SUPPORTED_EDITIONS = [1, 2].freeze
+
+      # The header and envelope spellings that have shipped: the quoted
+      # v-forms stay loadable so artifacts baked before the numeric
+      # surface remain readable.
+      EDITION_ALIASES = {
+        1 => 1, "1" => 1, "v1" => 1, "classic" => 1,
+        2 => 2, "2" => 2, "v2" => 2
+      }.freeze
 
       def initialize(envelope, path, tables_dir, imports_dir: nil)
         unless envelope["shape"] == SUPPORTED_SHAPE
@@ -42,16 +50,13 @@ module Parsanol
         bindings = envelope["bindings"]
         validate_bindings!(bindings) unless bindings.nil?
         @envelope = envelope
-        # ruby#353: absent field = the pre-1.3.109 semantics. A level
-        # above this runtime's is a hard error (the trees would carry
-        # nodes this engine never emits); a lower one warns — parsing
-        # works, but frozen tree comparisons will differ.
         # The declared edition must be one this runtime understands
-        # (ruby#357's consolidation: one axis, `edition`, values v1/v2).
-        edition = envelope["edition"] || "v1"
+        # (ruby#357's consolidation: one axis, `edition`). Absent field
+        # = the pre-1.3.109 artifacts, whose trees are edition 1.
+        edition = EDITION_ALIASES[envelope.fetch("edition", 1)]
         unless SUPPORTED_EDITIONS.include?(edition)
           raise ArtifactError,
-                "artifact declares edition #{edition.inspect}; this " \
+                "artifact declares edition #{envelope['edition'].inspect}; this " \
                 "runtime supports #{SUPPORTED_EDITIONS.map(&:inspect).join(', ')}"
         end
         @path = path
@@ -66,6 +71,13 @@ module Parsanol
 
       def version = envelope["version"]
 
+      # The edition the artifact's trees carry: 1 = the legacy shapes,
+      # 2 = fully named trees. Legacy artifacts that spell the field
+      # "v2" (or omit it) normalize here.
+      def edition
+        EDITION_ALIASES.fetch(envelope.fetch("edition", 1))
+      end
+
       # Freshness (parsanol-ruby#209): what source revision and compiler
       # produced this artifact. `source_hash` is the SHA-256 of the .parg
       # text at compile time; nil on artifacts baked before the field

data/lib/parsanol/parg/compiler.rb

@@ -233,12 +233,24 @@ module Parsanol
       # compile time — the tree shape consumers read, opt-in via
       # `mode` in the grammar header. Engines see ordinary
       # Named atoms; identity rides the differential corpus.
-      def apply_modern_captures(atom)
+      def apply_modern_captures(atom, rule_name)
         return atom if @document.edition == "v1"
+        # A glue rule's own body compiles unwrapped (parsanol-ruby#364):
+        # the declaration means the tree never sees this subtree named,
+        # inside or out.
+        return atom if glue_rule?(rule_name)
 
         wrap_uncaptured(atom)
       end
 
+      # The `glue` declaration's verdict (parsanol-ruby#364): references
+      # to declared glue rules never wrap — the trivia exemption's
+      # "glue never becomes a capture", author-declared for rules that
+      # eat more than whitespace.
+      def glue_rule?(name)
+        @document.glue_rules.include?(name.to_s)
+      end
+
       def wrap_uncaptured(atom)
         case atom
         when Atoms::Named
@@ -254,10 +266,11 @@ module Parsanol
           # capture-producing refs both stay unwrapped; the bodies
           # agree by design.
           if trivia_only?(atom.rule_name.to_s, { atom.rule_name.to_s => true }) ||
+              glue_rule?(atom.rule_name.to_s) ||
               produces_capture?(atom.parslet)
             atom
           else
-            Atoms::Named.new(atom, atom.rule_name.to_s)
+            Atoms::Named.new(atom, atom.rule_name.to_sym)
           end
           # rubocop:enable Lint/DuplicateBranch
         when Atoms::Sequence, Atoms::Alternative
@@ -274,10 +287,10 @@ module Parsanol
       end
 
       # Whether the named rule's body is provably whitespace-only:
-      # literals strip to empty; sequence/alternation/repetition
-      # compose the verdict; references resolve through the atom cache
-      # with a cycle set; anything else (classes, customs, authored
-      # captures) disqualifies.
+      # literals strip to empty, character classes are whitespace-only;
+      # sequence/alternation/repetition compose the verdict; references
+      # resolve through the atom cache with a cycle set; anything else
+      # (customs, authored captures) disqualifies.
       def trivia_only?(name, seen)
         return false unless @document.rules.key?(name)
 
@@ -288,6 +301,8 @@ module Parsanol
         case atom
         when Atoms::Str
           atom.str.to_s.strip.empty?
+        when Atoms::Re
+          whitespace_class?(atom.match)
         when Atoms::Sequence, Atoms::Alternative
           kids = atom.respond_to?(:alternatives) ? atom.alternatives : atom.parslets
           kids.all? { |child| trivia_walk(child, seen) }
@@ -304,6 +319,91 @@ module Parsanol
         end
       end
 
+      # A class matches only whitespace when every codepoint it admits
+      # strips to empty — the same verdict Atoms::Str gets. Compiled
+      # classes are the dialect class_pattern emits: bracket bodies of
+      # literal chars, \t\n\v\f\r, \xHH, \uXXXX and \u{...}, plus ranges
+      # between them. Anything else disqualifies.
+      def whitespace_class?(pattern)
+        body = pattern.to_s[/\A\[(.*)\]\z/m, 1]
+        return false if body.nil? || body.empty? || body.start_with?("^")
+
+        ranges = class_ranges(body)
+        ranges&.all? { |lo, hi| whitespace_range?(lo, hi) }
+      end
+
+      WHITESPACE_CODEPOINTS = [0x00, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x20].freeze
+
+      def whitespace_range?(low, high)
+        return false if low > high
+
+        union = WHITESPACE_CODEPOINTS.count { |code| code.between?(low, high) }
+        union == high - low + 1
+      end
+
+      def class_ranges(body)
+        slots = []
+        pending_range = false
+        index = 0
+        while index < body.length
+          if body[index] == "-" && !pending_range && !slots.empty?
+            pending_range = true
+            index += 1
+            next
+          end
+
+          code, index = class_token(body, index)
+          return nil unless code
+
+          if pending_range
+            previous = slots.pop
+            slots << [previous[0], code].minmax
+            pending_range = false
+          else
+            slots << [code, code]
+          end
+        end
+        return nil if pending_range
+
+        slots
+      end
+
+      def class_token(body, index)
+        char = body[index]
+        unless char == "\\"
+          return [char.ord, index + 1]
+        end
+
+        escaped = body[index + 1]
+        return nil if escaped.nil?
+
+        case escaped
+        when "x" then hex_token(body, index + 2, 2)
+        when "u"
+          if body[index + 2] == "{"
+            close = body.index("}", index + 3)
+            return nil unless close
+
+            [body[(index + 3)...close].to_i(16), close + 1]
+          else
+            hex_token(body, index + 2, 4)
+          end
+        when "t" then [0x09, index + 2]
+        when "n" then [0x0A, index + 2]
+        when "v" then [0x0B, index + 2]
+        when "f" then [0x0C, index + 2]
+        when "r" then [0x0D, index + 2]
+        else [escaped.ord, index + 2]
+        end
+      end
+
+      def hex_token(body, start, length)
+        hex = body[start, length]
+        return nil unless hex&.match?(/\A\h{#{length}}\z/)
+
+        [hex.to_i(16), start + length]
+      end
+
       # Whether the atom's flattening surfaces any Named capture:
       # rule references resolve through (their own wrap pass already
       # ran — a wrapped ref produces a capture), trivia never
@@ -353,7 +453,11 @@ module Parsanol
         case atom
         when Atoms::Named then nil
         when Atoms::Entity
-          unless produces_capture?(atom.parslet)
+          # Mirror wrap_uncaptured's verdicts: trivia glue, declared
+          # glue, and capture-producing refs all stay bare.
+          unless trivia_only?(atom.rule_name.to_s, { atom.rule_name.to_s => true }) ||
+              glue_rule?(atom.rule_name.to_s) ||
+              produces_capture?(atom.parslet)
             lines << "rule #{site}: reference to #{atom.rule_name} produces no capture -- " \
                      "modern mode would name it #{atom.rule_name}"
           end
@@ -392,7 +496,7 @@ module Parsanol
           # atom_for; a mutual-reference grammar must hit the cache,
           # not rebuild), then the cache takes the wrapped tree.
           @atom_cache[name] = atom
-          atom = apply_modern_captures(atom)
+          atom = apply_modern_captures(atom, name)
           @atom_cache[name] = atom
           atom
         end
@@ -1233,13 +1337,11 @@ module Parsanol
           "unicode_tables" => "onigmo (Ruby #{RUBY_VERSION})",
           "compiler_version" => Parsanol::VERSION,
         }
-        # ruby#304: the envelope always names the capture dialect —
-        # consumers read the tree-shape contract before parsing.
-        envelope["edition"] = @document.edition
-        # ruby#353: the language-semantics level the trees were frozen
-        # against (1.3.108's implicit-capture shapes = 1; the
-        # explicit end_guard/marker/hyphen nodes = 2). Consumers freeze
-        # tree shapes and mappers; the loader asserts the level at
+        # ruby#304: the envelope always names the capture edition —
+        # consumers read the tree-shape contract before parsing. The
+        # numeric form is canonical: 1 = the legacy shapes, 2 = fully
+        # named trees + explicit spans.
+        envelope["edition"] = @document.edition == "v2" ? 2 : 1
         if @document.skip_declaration
           # parsanol-ruby#134: declared trivia rule. Injection is baked
           # into the compiled trees (plain atom kinds), so consumers

data/lib/parsanol/parg/diff.rb

@@ -21,7 +21,7 @@ module Parsanol
 
       def diff(old_envelope, new_envelope)
         findings = []
-        findings.concat(diff_mode(old_envelope, new_envelope))
+        findings.concat(diff_edition(old_envelope, new_envelope))
         findings.concat(diff_entries(old_envelope, new_envelope))
         findings.concat(diff_bindings(old_envelope, new_envelope))
         findings.concat(diff_tests(old_envelope, new_envelope))
@@ -168,18 +168,25 @@ module Parsanol
         branches.uniq.sort
       end
 
-      # -- mode ---------------------------------------------------------
+      # -- edition ------------------------------------------------------
 
-      def diff_mode(old_env, new_env)
-        old_mode = old_env["mode"]
-        new_mode = new_env["mode"]
-        return [] if old_mode == new_mode
+      def diff_edition(old_env, new_env)
+        old_edition = edition_level(old_env)
+        new_edition = edition_level(new_env)
+        return [] if old_edition == new_edition
 
-        [Finding.new(:major, :mode_changed,
-                     "mode changed #{old_mode.inspect} -> #{new_mode.inspect} " \
+        [Finding.new(:major, :edition_changed,
+                     "edition changed #{old_edition.inspect} -> #{new_edition.inspect} " \
                      "(every uncaptured node's tree shape changes)")]
       end
 
+      # Artifacts baked before the numeric surface spell the edition
+      # "v1"/"v2"; they mean the same levels, not a change.
+      def edition_level(envelope)
+        declared = envelope.fetch("edition", 1)
+        Artifact::EDITION_ALIASES.fetch(declared, declared)
+      end
+
       # -- bindings -----------------------------------------------------
 
       def diff_bindings(old_env, new_env)

data/lib/parsanol/parg/document.rb

@@ -18,7 +18,7 @@ module Parsanol
       Test = Struct.new(:entry, :kind, :input, :expect)
 
       attr_accessor :grammar_name, :version, :edition, :source, :uses, :skip_declaration, :skip_source,
-                    :atomic_rules, :skip_capture_key, :brace_rules
+                    :atomic_rules, :skip_capture_key, :brace_rules, :glue_rules
       # R2 declared resync: rule name -> skip pattern (the span matched
       # at a recovery point is consumed as annotated error text).
       attr_reader :resyncs
@@ -60,6 +60,10 @@ module Parsanol
         # contiguously).
         @atomic_rules = []
         @brace_rules = []
+        # Rules declared `glue <name> ...` (parsanol-ruby#364): the
+        # edition-2 wrap never names them — references stay bare and
+        # the rule's own body compiles unwrapped.
+        @glue_rules = []
         @authored_rules = nil
         # R2 declared resync: rule -> skip pattern. Recovery consumes
         # each pattern match at a failure point as annotated error text

data/lib/parsanol/parg/parser.rb

@@ -18,6 +18,14 @@ module Parsanol
 
       IN_BLOCK_SECTIONS = %w[entry bindings preprocess test].freeze
 
+      # The header's edition spellings: the bare numbers are canonical
+      # (Rust's Cargo.toml model); the quoted forms stay accepted as
+      # aliases for grammars written before the numeric surface.
+      EDITIONS = {
+        "1" => "v1", "v1" => "v1", "classic" => "v1",
+        "2" => "v2", "v2" => "v2"
+      }.freeze
+
       STATE_KEYWORDS = %w[custom state].freeze
       KEYWORDS = %w[grammar as alt from_table column bindings render derive
                     preprocess entry table_lookup custom state set switch
@@ -227,6 +235,23 @@ module Parsanol
 
       def punct(char) = expect(:punct, char)
 
+      def edition_value
+        token = advance
+        raw = case token&.type
+              when :num then token.value
+              when :str then unquote(token.value)
+              else
+                raise ParseError,
+                      "edition must be a number (1 or 2) or a quoted alias " \
+                      "(\"v1\", \"v2\", \"classic\")"
+              end
+        EDITIONS.fetch(raw) do
+          raise ParseError,
+                "unknown edition #{raw.inspect} -- supported editions are " \
+                "1 (default) and 2 (named trees)"
+        end
+      end
+
       def parse_grammar(document)
         document.grammar_name = ident.value
         ident("version")
@@ -234,19 +259,14 @@ module Parsanol
         # `edition` — the language edition (ruby#304, ruby#357's
         # consolidation; Rust's Cargo.toml `edition` is the model):
         # the author declares, per grammar, which tree semantics the
-        # grammar means. THE DEFAULT IS "v1" (the legacy shapes — the
-        # owner's 2026-10-28 reversal). "v2" = fully named trees +
+        # grammar means. THE DEFAULT IS 1 (the legacy shapes — the
+        # owner's 2026-10-28 reversal). 2 = fully named trees +
         # explicit spans. `mode` remains accepted as a deprecated
         # alias for the keyword. The edition is canonicalized here —
         # everything downstream only ever sees "v1"/"v2".
         if peek&.type == :ident && %w[edition mode].include?(peek.value)
-          keyword = advance.value
-          edition = unquote(expect(:str).value)
-          unless %w[v2 v1 classic].include?(edition)
-            raise ParseError,
-                  "unknown edition #{edition.inspect} -- supported editions are \"v1\" (default) and \"v2\" (named trees)"
-          end
-          document.edition = edition == "v2" ? "v2" : "v1"
+          advance
+          document.edition = edition_value
         end
         punct("{")
         skip_newlines
@@ -318,6 +338,24 @@ module Parsanol
             skip_newlines
             next
           end
+          # `glue <rule> [<rule>...]` (parsanol-ruby#364): names rules
+          # whose references edition 2 never wraps — glue the tree must
+          # not see. Same-line names accumulate; the declaration may
+          # appear any number of times.
+          if peek&.type == :ident && peek.value == "glue"
+            advance
+            names = []
+            while peek&.type == :ident
+              names << ident.value
+            end
+            if names.empty?
+              raise ParseError, "glue must name at least one rule"
+            end
+
+            document.glue_rules.concat(names)
+            skip_newlines
+            next
+          end
           # `atomic <rule> = ...` suppresses skip-trivia injection inside
           # the rule body: token-shaped rules match their input
           # contiguously instead of spanning trivia between iterations.

data/lib/parsanol/version.rb

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

metadata

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