parsanol 1.3.112 → 1.3.113

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 683289b7d0453a88c2dfb691d54479ebacf6be93cc30f527c4199557bb99b48d
-  data.tar.gz: '0182a60c9bca2c3c1fcf1f450fed4623aeb915fb3b3e80f3a14ee716c09f3ffd'
+  metadata.gz: d9a04b4f0add7d25933bf9ddd041f28cf067e9b2750abb6595915d63cdd4cd3a
+  data.tar.gz: 69767361cdcb52ddeb7e0dbd4b05498e72fffe4d64639c4c5d00aad723f7c659
 SHA512:
-  metadata.gz: 15607095c23776f36bf34dcf4e53849a739cd373e9a31a766c484331fd998a01b4d66faebd528fb61077d648e58e7e35173e6ec7e3280640e1b2eaee17a884cc
-  data.tar.gz: 8fc517dc729088dcac71596911ed5a57a8b72c580d246b315a1b8313cb0157ef7ee63b04b20d723583f03ac4699af4810ca1cb61e5c91d9aed1514fe68806a27
+  metadata.gz: 8407c77dbca38833e2e2ddf189d601be84ed14f07bbe5e972feb76ce016df3f88c7725951ed20ba74b5403ad83dae25fef8d3f1259c6312e6e4158e709c037ba
+  data.tar.gz: 9fe4fd4df2ba548a686226ee50c80c60945dfad0e3719d7b1593fe9678a5a2f464df833940cb87201e86b98243c025d94ab42664b914f29ea3ca2649773c6aff

data/Cargo.lock

@@ -307,9 +307,9 @@ checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 
 [[package]]
 name = "parsanol"
-version = "0.19.6"
+version = "0.19.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ffe7e92d626c65e83d2c53c148a18db5897879858bcd37ebd0f406f5a251036"
+checksum = "5233088cf0cde65b9a6e5e41d558b689becc722ccf156946c8f118049f2d3f5c"
 dependencies = [
  "ahash",
  "getrandom 0.3.4",
@@ -326,9 +326,9 @@ dependencies = [
 
 [[package]]
 name = "parsanol-derive"
-version = "0.19.6"
+version = "0.19.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b94bb50df3fe1a9f66b6d8ee784672c27262e9e609568d5e9d14e1f7d6bec91"
+checksum = "c84688541fbbd11509183b9c53debd924bcdbfae8cf8aca053414ea11a7aa7e9"
 dependencies = [
  "proc-macro2",
  "quote",

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: ruby
 authors:
 - Ribose Inc.