parsanol 1.3.113-arm-linux → 1.3.115-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 59bf45f5736835d38547fff0ff9d13b7ad23825119796444a80dce968400f4fd
-  data.tar.gz: 8db9c700e580e573cc7756ee0c3e1db29569485786b2f09f5690bdafdbadfa16
+  metadata.gz: 87e094abf1d96459b9558d746f9a436b32e0b3ac58d6529b565159a771e1a9e9
+  data.tar.gz: a4331601780b6d3681b45ed55dfbdbe94c227d59cff2c743d3804b5ad2a263bf
 SHA512:
-  metadata.gz: 4561a05b21b1632884400ee4ac534d7b1a530de59d504fe15bc8522b481083a63a37c8c26f1c7eec8ee6dce32eb0c7ff8525e5eaf600a135e21cf6ddd0a830de
-  data.tar.gz: f7b545fc61370ddbafeca737ed5152e98d6f0cc79249a8235a7f550814c896c588dfc01b10bc106f02b4065da6e597199061012d9c9e58b6b75396612ee7a669
+  metadata.gz: 491dd96953046d5f729a5bbb403cdb4ce0ce7d1db7365b14fbd395145067e26e1a43968dae4d31176f6e77dc19978039a6297363e27ea63dfbd225370b42430d
+  data.tar.gz: 01e15a6809c13dde391770ba64eac2edca3c794df440278e8099832696d212f6c8446d7eded2c03d443879c11b7877314a1178cf1b328c5c6f0da576aaf3edec

data/README.adoc

@@ -31,6 +31,17 @@ While maintaining full API compatibility with Parslet, Parsanol features a compl
 * <<debug-tools,Debug Tools>> - Tracing and grammar visualization
 * <<benchmarking,Benchmarking>> - Built-in performance testing tools
 
+== Releases
+
+parsanol is one product on **four runtimes**: **rs** (crates.io +
+`@parsanol/wasm` + release binaries), **ruby** (rubygems), **python**
+(PyPI, `parsanol`), and **typescript** (npm, `parsanol` — the
+wasm-backed runtime). **Every engine update releases all four
+together**; a release that ships some runtimes and not the rest is
+incomplete. If the runtime you use lags the latest grammar-language
+features, check the other registries' changelogs and the release train
+on the https://github.com/parsanol/parsanol-ruby/actions[Release workflow].
+
 == Installation
 
 Add this line to your application's Gemfile:

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: 38879708 bytes
-sha256: cfda9148339117f0a402c721cc6fe0c8b6eb9a9f1e6379349535800678d12984
+size: 39170404 bytes
+sha256: bbab9454dfa91df09fdcc00143cf18ff89d277657f975d13959c01255f7c5707

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: 39064908 bytes
-sha256: 676a7d260f73301517018e397e50405a74af0a13eceeac0edc47c04c3d4759ba
+size: 39355636 bytes
+sha256: 808eb780f0317adb4f98e7323b90e7d99e55d729a8d961b1b63fcf4660ab4562

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: 39059120 bytes
-sha256: 5deb0995f7b0602d389163621434f6631b4a65d284fa9e78876b19a3842ed94d
+size: 39349796 bytes
+sha256: bbc22c4d658fc4a0a9a72344e5765a44ec9985e0ef1373704cc31014565e711d

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: 39068812 bytes
-sha256: 991d4aa597d6457f3571a791b3cc53a733d9db6caebfab09c4618efc7f78f4da
+size: 39359512 bytes
+sha256: 017f6f3c4909e39c878a6f28f562d577a8b02442de38a0ac9760b48873871426

data/lib/parsanol/native/libparsanol.so

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: data/lib/parsanol/native/libparsanol.so
-size: 35239956 bytes
-sha256: 70ffc11f9a321d8162cb81609cd9b43529c45b7f22095d1ddfa86bc94329b1b6
+size: 35531016 bytes
+sha256: 968ae4d54093a740fd7ce2e59fe10ab73dd853e23a852e5d22e292168a3f9c5a

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
@@ -440,9 +453,10 @@ module Parsanol
         case atom
         when Atoms::Named then nil
         when Atoms::Entity
-          # Mirror wrap_uncaptured's verdicts: trivia glue and
-          # capture-producing refs both stay bare.
+          # 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}"
@@ -482,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

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/frontend.rb

@@ -20,9 +20,24 @@ module Parsanol
       ENTRY_LINE = /\Aentry\s+(\w+)\s*:\s*(\w+)/
       USE_LINE = /\Ause\s+(\w+)/
       GRAMMAR_LINE = /\Agrammar\s+(\w+)\s+version\s+"([^"]+)"/
+      # The capture-edition tail: the canonical numeric spelling or the
+      # quoted aliases (ruby#361); `mode` stays the deprecated keyword.
+      EDITION_TAIL = /
+        \s+(?:edition\s+(?:"(?<quoted>[^"]+)"|(?<number>\d+))|mode\s+"(?<mode>[^"]+)")
+      /x
+      GLUE_LINE = /\Aglue\s+([a-z_][a-z0-9_]*(?:\s+[a-z_][a-z0-9_]*)*)\s*\z/
 
       module_function
 
+      # Brace depth for the line-oriented collection: braces inside
+      # string literals are grammar data — test pins quote whole
+      # language forms, including deliberately malformed ones whose
+      # unbalanced braces would push the section depth off (ruby#369).
+      def brace_delta(line)
+        bare = line.gsub(/"(?:[^"\\]|\\.)*"/, "")
+        bare.scan("{").count - bare.scan("}").count
+      end
+
       def parse(source)
         SelfHost.validate(source) unless SelfHost.available? && !SelfHost.valid?(source)
 
@@ -43,7 +58,17 @@ module Parsanol
           end
           next if stripped.empty? || stripped.start_with?("#")
 
-          if state[:section]
+          if state[:rule_depth]&.positive?
+            # A brace-form rule body spans lines (ruby#311): keep
+            # appending until its braces balance.
+            state[:rule_lines][state[:rule_depth_name]] << line
+            state[:rule_depth] += brace_delta(line)
+            if state[:rule_depth].zero?
+              merge_rule(document, state[:rule_lines][state[:rule_depth_name]])
+              state[:rule_depth] = nil
+              state[:rule_depth_name] = nil
+            end
+          elsif state[:section]
             advance_section(document, state, line, deferred, preprocess_texts)
           else
             route_top_level(document, stripped, line, state,
@@ -59,7 +84,7 @@ module Parsanol
       # Consumes one line inside a deferred/closed-by-brace section.
       def advance_section(document, state, line, deferred, preprocess_texts)
         section = state[:section]
-        state[:depth] += line.scan("{").count - line.scan("}").count
+        state[:depth] += brace_delta(line)
         if state[:depth].positive?
           preprocess_texts.last << line if section == "preprocess"
           state[:section_lines] << line
@@ -91,9 +116,19 @@ module Parsanol
         when USE_LINE
           document.uses << Regexp.last_match(1)
           doc_comments = []
+        when GLUE_LINE
+          document.glue_rules.concat(Regexp.last_match(1).split)
+          doc_comments = []
         when GRAMMAR_LINE
           document.grammar_name = Regexp.last_match(1)
           document.version = Regexp.last_match(2)
+          tail = stripped.match(EDITION_TAIL)
+          document.edition = if tail.nil?
+                               "v1"
+                             else
+                               level = tail[:number] || tail[:quoted] || tail[:mode]
+                               ["2", "v2"].include?(level) ? "v2" : "v1"
+                             end
           doc_comments = []
         when NAMED_SECTION
           state[:section] = Regexp.last_match(1)
@@ -128,7 +163,15 @@ module Parsanol
           document.docs[rule_name] = doc_comments.join("\n") unless doc_comments.empty?
           doc_comments = []
           state[:rule_lines][rule_name] = line
-          merge_rule(document, line)
+          depth = brace_delta(line)
+          if depth.positive?
+            # Brace-form body opens (ruby#311): the rule completes on a
+            # later line; the continuation loop appends and merges then.
+            state[:rule_depth] = depth
+            state[:rule_depth_name] = rule_name
+          else
+            merge_rule(document, line)
+          end
         else
           doc_comments = []
         end

data/lib/parsanol/parg/parser.rb

@@ -338,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.113"
+  VERSION = "1.3.115"
 end

data/lib/parsanol/vm.rb

@@ -452,6 +452,11 @@ module Parsanol
         @subs = {}      # [obj_id, flag] => pc or :pending
         @pending = {}   # [obj_id, flag] => [[call_idx, body], ...]
         @backtracking_prone = false
+        # Grammar rules form a shared graph. Re-analyzing every reference
+        # repeats whole alternative trees during inlining. These caches
+        # live only for this compiler and retain the depth limit's meaning.
+        @first_byte_tables = {}.compare_by_identity
+        @nullability = {}.compare_by_identity
       end
 
       attr_reader :ops, :backtracking_prone
@@ -484,6 +489,13 @@ module Parsanol
       def first_byte_table(atom, depth = 0)
         return nil if depth > 10
 
+        cached = (@first_byte_tables[atom] ||= {})
+        return cached[depth] if cached.key?(depth)
+
+        cached[depth] = compute_first_byte_table(atom, depth)&.freeze
+      end
+
+      def compute_first_byte_table(atom, depth)
         case atom
         when Parsanol::Atoms::Str
           b = atom.str.getbyte(0)
@@ -508,7 +520,7 @@ module Parsanol
                 i += 1
               end
             else
-              t = ct
+              t = ct.dup
             end
             unless nullable?(child, depth + 1)
               nullable_all = false
@@ -529,7 +541,7 @@ module Parsanol
                 i += 1
               end
             else
-              t = bt
+              t = bt.dup
             end
           end
           t
@@ -572,6 +584,13 @@ module Parsanol
       def nullable?(atom, depth = 0)
         return false if depth > 10
 
+        cached = (@nullability[atom] ||= {})
+        return cached[depth] if cached.key?(depth)
+
+        cached[depth] = compute_nullable(atom, depth)
+      end
+
+      def compute_nullable(atom, depth)
         case atom
         when Parsanol::Atoms::Str then atom.str.bytesize.zero?
         when Parsanol::Atoms::Re then false

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parsanol
 version: !ruby/object:Gem::Version
-  version: 1.3.113
+  version: 1.3.115
 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