parsanol 1.3.112-arm-linux → 1.3.114-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f86341729e0c13dfe000814acffe0a7806dd23c2112c75f0f46720e839d1437e
-  data.tar.gz: 9880883b997abf73225f2e33aa8ffba669b838b3962bc2554e0177e9d021d666
+  metadata.gz: 9ccfe53145a4fbf2af4f7c2cc47071231be0016d8047e9bb0f75386738ff0480
+  data.tar.gz: 395d7bccac544d4842b29e5764d1198816ab823e1f9defdc3874009395caaa24
 SHA512:
-  metadata.gz: 725b8abcd3649a8e59d773075469c1a6774618510d16bea92961b58aadbb104597fa293aeb599d0b62f04f0f70efd75cfacc57992012b854e27d68f9046075ae
-  data.tar.gz: daef10d533ff00cc4b7a9206949b48a13f104897c56a10d463ce71e1d7d040bab389f2b6d50a6ea3b1ea06eb5a6c0b278b62d7b9157b1c99f3737cf34d48be83
+  metadata.gz: b1436b7af7ea025b302e14fc14970c42252c75f5aa6a2252f1701862ebca604ccc05349a39fdbd77b09fef78c7e633b9a6ff15c3f22e3a36845f49133a84eb7a
+  data.tar.gz: 188fe5c41d516ab6f3372ca339d0c313b0460e912e122a9e32ed5f8b948deb743c3a38f406997dddbb97cc9e3a5a7a25587640273eb44c97dde75d518d24ad6b

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: 38874288 bytes
-sha256: 754877c02d5009e0d9b1ce188976c6434e47db3b5830bb521a2d7db5d9176110
+size: 39082700 bytes
+sha256: d252dd306fb0dcb4726ed8a1deb826cecfc1ca8bf5528603f50ac20058e0aea9

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: 39059492 bytes
-sha256: a46e280499f470142aabcb4d87986248d39e869193ee0121418515cf55a77bf1
+size: 39267920 bytes
+sha256: 4f500faf69c8b85dff0055043e37d08bdb897cabd0bc814ce1a5a7f31db0fad4

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: 39053696 bytes
-sha256: 95bd7e4ca67253501ba472ef1f5da717a9cf1bd64fd3eac4e83713ce802f85c8
+size: 39262108 bytes
+sha256: b24c02b2f5d0848c59dba33cf4751107b1799ec8f96c961c3952114e96eb10f7

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: 39063392 bytes
-sha256: 5824569712de4619ca2c8122c521cbca91f0e284e3f6b85e54ec2e0a4310f08e
+size: 39271824 bytes
+sha256: 3bc6176aec3d4bb697ce024b174ddeca6a4b50a297bdd84492a277205e46efed

data/lib/parsanol/native/libparsanol.so

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: data/lib/parsanol/native/libparsanol.so
-size: 35234412 bytes
-sha256: 25dc6c51f9f09389dbf57c462ffec5d2aea36e04b6a9597c58f7eb6520b32e76
+size: 35442920 bytes
+sha256: 0a129844ae8acce2330a6b009be2fc9d918a6f46d53f744429ae02b9bf039aea

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: arm-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