parsanol 1.3.112-aarch64-linux → 1.3.113-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e622ed0c55dbbcc4295a1b3740c36e0dc725a89251eb36c7799d6b60dbb026ff
-  data.tar.gz: d6d4c119f0e08a8b167faae5f1bb8203cf1f18d77d9cebd132a8bed6c2817882
+  metadata.gz: 9d346b7aab39294839b92c4c362b605854384254d58b8687b57f426bf9341701
+  data.tar.gz: 7b119bc3421018d3d3c3c5341f9833f1324d4a11b5890e5972dfbfa42e0c6c31
 SHA512:
-  metadata.gz: 6db2994d50d7d9e77a5a9b6614d3b0b461a623d06372bace9d30e9c45e09f6f55aa4efffbaa411ff00462e93e1f8b4681edc9229a15b391034293875a319846b
-  data.tar.gz: 4a36caf756fb3e162bdbe24235f1005a1a56e322677e86e2606900441994dbe6107ca8ce4822d02314bdda6bc38fb246dbd9767f1e816566daea4482e0ea558f
+  metadata.gz: 1d546f40925347f2f7a9c80ec01594907c073fa35398548b21b7b7cebe4050a991d946bda46ed2810c52b3a2e390d406c99aad8b5060553f5dc4684fc5c32628
+  data.tar.gz: 160406b0ae9a185c809825e4590bfd10645e7f1ec4bcbefb498b447984f98cb1df72d0c6193b90fa583bd08ba1f61f167d5d9b366cd8af8648266aed3ad8d3c7

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: 45899640 bytes
+sha256: 2152fb3fabceb57fe7c9c040b62c8c05ce5041c6cd998bd2d1e26c8a02698626

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: 46134680 bytes
+sha256: c2f6e3916142c8dfec0cc1707b071cbf38491cfcec3382452b21f766dc7c42a0

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: 46130320 bytes
+sha256: 817de189148e9924aec84d5ea725fa1cfbc303e3043366db18c140e18efa8100

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: 46140360 bytes
+sha256: c4eb75d0ff822c077450b4fb765a113eddc2138f22fb0164e607034fa9a09999

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: 41659008 bytes
+sha256: f9f0f4e0aee0a6fb9d3ec8fd026b3753719de2a01a016c3eff507288705704f0

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

@@ -274,10 +274,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 +288,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 +306,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 +440,10 @@ module Parsanol
         case atom
         when Atoms::Named then nil
         when Atoms::Entity
-          unless produces_capture?(atom.parslet)
+          # Mirror wrap_uncaptured's verdicts: trivia glue and
+          # capture-producing refs both stay bare.
+          unless trivia_only?(atom.rule_name.to_s, { atom.rule_name.to_s => true }) ||
+              produces_capture?(atom.parslet)
             lines << "rule #{site}: reference to #{atom.rule_name} produces no capture -- " \
                      "modern mode would name it #{atom.rule_name}"
           end
@@ -1233,13 +1323,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/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

data/lib/parsanol/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: parsanol
 version: !ruby/object:Gem::Version
-  version: 1.3.112
+  version: 1.3.113
 platform: aarch64-linux
 authors:
 - Ribose Inc.