coradoc-markdown 1.0.10 → 1.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 45a195eaddedba173983f2ba2ab08ce81044fe089124b8287b4a643262dbc6f8
-  data.tar.gz: b163677948cdc8459692c411c2840f2bfa0cfe401e47453d61e88d156bbfc910
+  metadata.gz: 232eab66f6d33edae8a3cca57f5ebd16cca11ed96c4dd9a51611b9669410595b
+  data.tar.gz: 1b0f0051729a0e226826c66d49bed0c4227732491b0bbf6148f42df524b1e95f
 SHA512:
-  metadata.gz: 3b6c63bf4e97c80a63c4f6289576f80577434d6aa8176aafd3067c026abbad4c9ab72fbe509e936933f60ef6cf02c7e3b6087efab353f541618ffe75d6c93ad1
-  data.tar.gz: 0a7a78dc0d92fd3c03344df7a6063429b443dcacfc760686a7d3080b6df7daff9b873251a1576d73307bbacfa8e642e08e02561625f6cfcd2d493f524843dd4b
+  metadata.gz: d20d1132ed4f527557207c11736d3ad10289fecf47a480341ed3b768bee9b2e812195fcf77d377a374b9c82804044c8c2aa701688c7e08706070ef62f957545c
+  data.tar.gz: 24547cfb89cbe67a61f0bb63cee59495d2520d61df54ed03141963f5245e2cd5b1c537b80b2903a55b9cfa36d51639fc85f170a963686a6b71faff2a95845b11

data/lib/coradoc/markdown/parser/ast_processor.rb

@@ -84,8 +84,8 @@ module Coradoc
               node.map { |child| process_node(child) }
             when Hash
               process_hash(node)
-            when Parslet::Slice
-              # Process escape sequences in Parslet::Slice values
+            when Parsanol::Slice
+              # Process escape sequences in Parsanol::Slice values
               process_escapes(node.to_s)
             else
               node
@@ -161,7 +161,7 @@ module Coradoc
             return value if value.nil?
 
             case value
-            when Parslet::Slice
+            when Parsanol::Slice
             end
             text = value.to_s
 
@@ -229,13 +229,13 @@ module Coradoc
             result
           end
 
-          # Process a text value (Parslet::Slice or String)
+          # Process a text value (Parsanol::Slice or String)
           # Only processes escape sequences without changing structure
           def process_text_value(value)
             return value if value.nil?
 
             case value
-            when Parslet::Slice
+            when Parsanol::Slice
             end
             process_escapes(value.to_s)
           end
@@ -374,7 +374,7 @@ module Coradoc
                 joined = extract_text_content(result)
                 { ln: joined }
               end
-            rescue Parslet::ParseFailed
+            rescue Parsanol::ParseFailed
               # If parsing fails, return original text in ln structure
               { ln: text }
             end
@@ -390,7 +390,7 @@ module Coradoc
 
             # Pattern to match HTML tags with markdown attribute
             # Captures: tag name, markdown value, content, closing tag
-            pattern = %r{<(#{HTML_TAG_PATTERN})\s+([^>]*?)markdown\s*=\s*["']([^"']+)["']([^>]*)>(.*?)</\1>}im
+            pattern = %r{<(#{HTML_TAG_PATTERN})\s+([^>]*?)markdown\s*=\s*["']([^"']+)["']([^>]*)>(.*?)</\1>}imo
 
             text.gsub(pattern) do |_match|
               tag_name = ::Regexp.last_match(1)
@@ -441,7 +441,7 @@ module Coradoc
 
               # Convert result back to string representation
               inline_result_to_string(result)
-            rescue Parslet::ParseFailed
+            rescue Parsanol::ParseFailed
               content
             end
           end

data/lib/coradoc/markdown/parser/block_parser.rb

@@ -3,11 +3,10 @@
 module Coradoc
   module Markdown
     module Parser
-      autoload :ParsletExtras, "#{__dir__}/parslet_extras"
-
-      class BlockParser < Parslet::Parser
-        using ParsletExtras
+      # Load-time DSL side effect (sanctioned require_relative exception)
+      require_relative 'parsanol_atoms'
 
+      class BlockParser < Parsanol::Parser
         # NOTE: Debug method for parser development. Outputs current parse position
         # and capture context. Only called during parser debugging sessions.
         def debug(msg)
@@ -23,16 +22,16 @@ module Coradoc
 
         rule(:whitespace) { match[" \t"] }
         # NOTE: repeat(1) before EOF (any.absent?) because infinite loop otherwise
-        rule(:blank_line) { (whitespace.repeat(1) >> any.absent? | whitespace.repeat >> line_ending).ignore }
+        rule(:blank_line) { ((whitespace.repeat(1) >> any.absent?) | (whitespace.repeat >> line_ending)).ignore }
         rule(:blank_line_verbatim) do
-          whitespace.repeat(1).as(:ln) >> any.absent? | whitespace.repeat.as(:ln) >> line_ending
+          (whitespace.repeat(1).as(:ln) >> any.absent?) | (whitespace.repeat.as(:ln) >> line_ending)
         end
         rule(:line_char) { match["^\r\n"] }
         rule(:line_verbatim) { line_char.repeat(1).as(:ln) >> line_ending_or_eof }
 
         rule(:non_indent_space) { str(' ').repeat(0, 3) }
 
-        # Block nesting is the tricky part, but Parslet's `dynamic` and `scope`
+        # Block nesting is the tricky part, but Parsanol's `dynamic` and `scope`
         # make it possible to be aware of what blocks we're already in, and implement
         # a check for whether we're still inside of those blocks on the beginning of
         # every line. The rules that match the line run inside of the innermost
@@ -53,11 +52,17 @@ module Coradoc
 
         def open_block(kind, cont_rule)
           dynamic do |_src, ctx|
-            parent_scope = ctx.captures.current.parent
-            ctx.captures[:cont] = cont_rule
-            ctx.captures[:cont] = parent_scope[:cont] >> cont_rule if parent_scope.key?(:cont)
-            ctx.captures[:block] = kind
-            # puts "starting block #{kind} at #{src.line_and_column} (#{src.bytepos}): #{ctx.captures[:cont]}"
+            caps = ctx.captures
+            # Chain-read before the write: picks up the enclosing
+            # block's continuation rule when one is in scope (Parsanol's
+            # Scope#[] searches parent frames; #key? is chain-aware).
+            caps[:cont] =
+              if caps.key?(:cont)
+                caps[:cont] >> cont_rule
+              else
+                cont_rule
+              end
+            caps[:block] = kind
             any.present? | any.absent?
           end
         end
@@ -222,7 +227,7 @@ module Coradoc
         end
 
         rule(:paragraph_line) do
-          line_char.repeat(1).as(:ln) >> any.absent? | line_char.repeat.as(:ln) >> line_ending
+          (line_char.repeat(1).as(:ln) >> any.absent?) | (line_char.repeat.as(:ln) >> line_ending)
         end
 
         rule(:paragraph_continued_line) do
@@ -286,8 +291,8 @@ module Coradoc
         rule(:ial_key_value) do
           match['\\w\\-'].repeat(1) >> str('=') >>
             (
-              str('"') >> match['^"'].repeat(0) >> str('"') |
-              str("'") >> match["^'"].repeat(0) >> str("'") |
+              (str('"') >> match['^"'].repeat(0) >> str('"')) |
+              (str("'") >> match["^'"].repeat(0) >> str("'")) |
               match['^\\s\\}'].repeat(1)
             )
         end
@@ -322,8 +327,8 @@ module Coradoc
         rule(:extension_option) do
           match['\\w\\-'].repeat(1) >> str('=') >>
             (
-              str('"') >> match['^"'].repeat(0) >> str('"') |
-              str("'") >> match["^'"].repeat(0) >> str("'") |
+              (str('"') >> match['^"'].repeat(0) >> str('"')) |
+              (str("'") >> match["^'"].repeat(0) >> str("'")) |
               match['^\\s/\\}'].repeat(1)
             )
         end
@@ -466,11 +471,11 @@ module Coradoc
         # List item continuation line (indented content that's not a block)
         # Excludes lines that look like nested list markers
         rule(:list_continuation_line) do
-          (str('    ') | str("\t")) >>
+          ((str('    ') | str("\t")) >>
             nested_list_marker.absent? >>
-            line_verbatim |
-            nested_list_marker.absent? >>
-            line_verbatim
+            line_verbatim) |
+            (nested_list_marker.absent? >>
+            line_verbatim)
         end
 
         # Nested list marker detection (for 4-space indented lists)
@@ -513,8 +518,8 @@ module Coradoc
 
         # Nested block (indented list, etc.)
         rule(:nested_block) do
-          (str('    ') | str("\t")) >> nested_unordered_list |
-            (str('    ') | str("\t")) >> nested_ordered_list
+          ((str('    ') | str("\t")) >> nested_unordered_list) |
+            ((str('    ') | str("\t")) >> nested_ordered_list)
         end
 
         # Nested unordered list (4-space indented)
@@ -727,7 +732,7 @@ module Coradoc
         def self.parse(filename)
           content = File.read(filename)
           new.parse(content)
-        rescue Parslet::ParseFailed => e
+        rescue Parsanol::ParseFailed => e
           puts e.parse_failure_cause.ascii_tree
         end
 
@@ -735,7 +740,7 @@ module Coradoc
         def self.parse_with_processing(content)
           ast = new.parse(content)
           AstProcessor.process(ast)
-        rescue Parslet::ParseFailed => e
+        rescue Parsanol::ParseFailed => e
           puts e.parse_failure_cause.ascii_tree
           nil
         end

data/lib/coradoc/markdown/parser/inline_parser.rb

@@ -3,11 +3,12 @@
 module Coradoc
   module Markdown
     module Parser
-      autoload :ParsletExtras, "#{__dir__}/parslet_extras"
+      # Load-time DSL side effect (sanctioned require_relative exception)
+      require_relative 'parsanol_atoms'
+
       autoload :HtmlEntities, "#{__dir__}/html_entities"
 
-      class InlineParser < Parslet::Parser
-        using ParsletExtras
+      class InlineParser < Parsanol::Parser
 
         rule(:line_ending) { (str("\n") | str("\r\n") | str("\r")).ignore }
         rule(:line_ending_or_eof) { line_ending | any.absent? }
@@ -266,7 +267,7 @@ module Coradoc
         end
 
         def parse(io, options = {})
-          process_emphasis(super(io, options))
+          process_emphasis(super)
         end
       end
     end

data/lib/coradoc/markdown/parser/parsanol_atoms.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require 'parsanol'
+
+module Coradoc
+  module Markdown
+    module Parser
+      # Custom grammar atoms and DSL surface for the Markdown parser,
+      # built on Parsanol::Atoms::Custom — the sanctioned extension
+      # point. Replaces the former parslet_extras module, which
+      # reached into Parslet internals via refinements.
+      module ParsanolAtoms
+        # Matches +parslet+ but yields a fixed +value+.
+        class Output < Parsanol::Atoms::Custom
+          attr_reader :parslet, :value
+
+          def initialize(parslet, value)
+            @parslet = parslet
+            @value = value
+            super()
+          end
+
+          def try_match(source, context, consume_all)
+            success, = parslet.apply(source, context, consume_all)
+            [success, success ? value : nil]
+          end
+        end
+
+        # Matches +parslet+ and yields the callable applied to the
+        # flattened match value.
+        class DynamicOutput < Parsanol::Atoms::Custom
+          include Parsanol::Atoms::CanFlatten
+
+          attr_reader :parslet, :callable
+
+          def initialize(parslet, callable)
+            @parslet = parslet
+            @callable = callable
+            super()
+          end
+
+          def try_match(source, context, consume_all)
+            success, value = parslet.apply(source, context, consume_all)
+            return [false, nil] unless success
+
+            [true, callable.call(flatten(value))]
+          end
+        end
+
+        # Positive/negative lookbehind: succeeds (zero-width) when the
+        # preceding +number+ characters are/are not matched by
+        # +bound_parslet+. Character-accurate for multibyte input —
+        # rewinds over UTF-8 continuation bytes.
+        class Lookbehind < Parsanol::Atoms::Custom
+          attr_reader :positive, :number, :bound_parslet
+
+          def initialize(bound_parslet, number, positive: true)
+            @positive = positive
+            @number = number
+            @bound_parslet = bound_parslet
+            super()
+          end
+
+          def error_msgs
+            @error_msgs ||= {
+              positive: ['Input should be preceded by ', bound_parslet],
+              negative: ['Input should not be preceded by ', bound_parslet]
+            }
+          end
+
+          def try_match(source, context, _consume_all)
+            rewind_pos = source.bytepos
+            if rewind_pos.zero?
+              return [true, nil] unless positive
+
+              return context.err_at(self, source, error_msgs[:positive], source.pos)
+            end
+
+            source.bytepos = rewind_chars(source, number)
+            error_pos = source.pos
+            success, = bound_parslet.apply(source, context, false)
+
+            if positive
+              return [true, nil] if success
+
+              context.err_at(self, source, error_msgs[:positive], error_pos)
+            elsif success
+              context.err_at(self, source, error_msgs[:negative], error_pos)
+            else
+              [true, nil]
+            end
+          ensure
+            source.bytepos = rewind_pos
+          end
+
+          private
+
+          def rewind_chars(source, nchars)
+            input = source.input
+            pos = source.bytepos
+            nchars.times do
+              pos -= 1
+              pos -= 1 while pos.positive? && (input.getbyte(pos) & 0xC0) == 0x80
+            end
+            [pos, 0].max
+          end
+        end
+      end
+    end
+  end
+end
+
+# Additive DSL surface (no overrides): exposes the custom atoms on
+# every atom the way the former parslet_extras refinements did.
+module Parsanol
+  module Atoms
+    module DSL
+      def output(value)
+        Coradoc::Markdown::Parser::ParsanolAtoms::Output.new(self, value)
+      end
+
+      def dynamic_output(callable)
+        Coradoc::Markdown::Parser::ParsanolAtoms::DynamicOutput.new(self, callable)
+      end
+
+      def precedes?(num = 1)
+        Coradoc::Markdown::Parser::ParsanolAtoms::Lookbehind.new(self, num, positive: true)
+      end
+
+      def does_not_precede?(num = 1)
+        Coradoc::Markdown::Parser::ParsanolAtoms::Lookbehind.new(self, num, positive: false)
+      end
+    end
+  end
+end

data/lib/coradoc/markdown/parser_util.rb

@@ -71,11 +71,11 @@ module Coradoc
         def self.extract_quoted_value(scanner, handle_escapes: false)
           if scanner.scan(/"([^"\\]*(?:\\.[^"\\]*)*)"/)
             value = scanner[1]
-            value = value.gsub(/\\"/, '"') if handle_escapes
+            value = value.gsub('\"', '"') if handle_escapes
             value
           elsif scanner.scan(/'([^'\\]*(?:\\.[^'\\]*)*)'/)
             value = scanner[1]
-            value = value.gsub(/\\'/, "'") if handle_escapes
+            value = value.gsub('\\\'', "'") if handle_escapes
             value
           elsif scanner.scan(/(\S+)/)
             scanner[1]

data/lib/coradoc/markdown/serializer/config.rb

@@ -48,7 +48,7 @@ module Coradoc
         end
 
         def with(overrides)
-          self.class.new(**to_h.merge(symbolize(overrides)))
+          self.class.new(**to_h, **symbolize(overrides))
         end
 
         private
@@ -58,15 +58,9 @@ module Coradoc
         end
 
         def validate_options!(resolved)
-          unless %i[github container html gfm_alert].include?(resolved.fetch(:admonition_style))
-            raise ArgumentError, "Unknown admonition_style: #{resolved[:admonition_style].inspect}"
-          end
-          unless %i[html flatten].include?(resolved.fetch(:definition_list_nested))
-            raise ArgumentError, "Unknown definition_list_nested: #{resolved[:definition_list_nested].inspect}"
-          end
-          unless [true, false].include?(resolved.fetch(:suppress_comments))
-            raise ArgumentError, 'suppress_comments must be boolean'
-          end
+          raise ArgumentError, "Unknown admonition_style: #{resolved[:admonition_style].inspect}" unless %i[github container html gfm_alert].include?(resolved.fetch(:admonition_style))
+          raise ArgumentError, "Unknown definition_list_nested: #{resolved[:definition_list_nested].inspect}" unless %i[html flatten].include?(resolved.fetch(:definition_list_nested))
+          raise ArgumentError, 'suppress_comments must be boolean' unless [true, false].include?(resolved.fetch(:suppress_comments))
           return if [true, false].include?(resolved.fetch(:autolinks))
 
           raise ArgumentError, 'autolinks must be boolean'

data/lib/coradoc/markdown/serializer/registry.rb

@@ -39,7 +39,7 @@ module Coradoc
         def lookup!(element)
           lookup(element) || raise(ArgumentError,
                                    "Unknown element type for serialization: #{element.class}. " \
-                                     'Expected a known Markdown model type.')
+                                   'Expected a known Markdown model type.')
         end
 
         private

data/lib/coradoc/markdown/serializer/runner.rb

@@ -40,7 +40,7 @@ module Coradoc
             else
               raise ArgumentError,
                     "Unknown element type for serialization: #{element.class}. " \
-                      'Expected a known Markdown model type.'
+                    'Expected a known Markdown model type.'
             end
           end
         end

data/lib/coradoc/markdown/transform/from_core_model.rb

@@ -55,6 +55,8 @@ module Coradoc
               Coradoc::Markdown::Text.new(content: model.title.to_s)
             when Coradoc::CoreModel::CommentLine
               Coradoc::Markdown::Comment.new(text: model.text.to_s)
+            when Coradoc::CoreModel::Include
+              transform_include(model)
             when Coradoc::CoreModel::TextContent
               model.text.to_s
             when Array
@@ -66,6 +68,17 @@ module Coradoc
 
           private
 
+          # Markdown has no transclusion — an unresolved include edge is
+          # preserved as an HTML comment so no information is lost and
+          # serialization never crashes on graph-mode documents.
+          def transform_include(element)
+            Coradoc::Markdown::Comment.new(text: include_directive_text(element))
+          end
+
+          def include_directive_text(element)
+            "include::#{element.target}[#{element.raw_options}]"
+          end
+
           def transform_structural_element(element)
             case element
             when CoreModel::DocumentElement

data/lib/coradoc/markdown/transformer.rb

@@ -1,17 +1,17 @@
 # frozen_string_literal: true
 
-require 'parslet'
+require 'parsanol'
 
 module Coradoc
   module Markdown
     autoload :ParserUtil, "#{__dir__}/parser_util"
 
-    # Transformer converts Parslet AST into Markdown Document Model objects.
+    # Transformer converts Parsanol AST into Markdown Document Model objects.
     #
     # This transformer takes the raw output from the BlockParser/InlineParser
     # and converts it into semantic model objects (Heading, Paragraph, etc.)
     #
-    class Transformer < Parslet::Transform
+    class Transformer < Parsanol::Transform
       # ATX Heading: # Heading
       rule(heading: simple(:heading), text: simple(:text)) do
         Heading.new(level: heading.to_s.length, text: text.to_s.strip)
@@ -198,7 +198,7 @@ module Coradoc
           when Array
             # Transform each item
             element.map { |e| transform_element(e) }.compact
-          when Parslet::Slice
+          when Parsanol::Slice
             Text.new(content: element.to_s)
           else
             Text.new(content: element.to_s)
@@ -536,7 +536,7 @@ module Coradoc
             else
               content.values.map { |v| extract_text(v) }.join
             end
-          when Parslet::Slice
+          when Parsanol::Slice
             content.to_s
           else
             content.to_s

data/lib/coradoc/markdown/version.rb

@@ -2,6 +2,6 @@
 
 module Coradoc
   module Markdown
-    VERSION = '1.0.10'
+    VERSION = '1.0.12'
   end
 end

data/lib/coradoc/markdown.rb

@@ -5,7 +5,7 @@
 # This gem provides Markdown support for the Coradoc document processing library.
 # It includes:
 # - Markdown Document Model (Coradoc::Markdown::*)
-# - Markdown Parser (CommonMark-compliant, Parslet-based)
+# - Markdown Parser (CommonMark-compliant, Parsanol-based)
 # - Markdown Serializer (round-trip capable)
 # - Kramdown extensions support (IAL, ALD, math, TOC)
 #
@@ -18,7 +18,8 @@
 #   # Serialize back to Markdown
 #   output = Coradoc::Markdown.serialize(document)
 
-require 'parslet'
+require 'parsanol'
+require 'parsanol/convenience'
 require 'lutaml/model'
 
 # Coradoc document transformation library.
@@ -91,7 +92,7 @@ module Coradoc
     module Parser
       autoload :BlockParser, 'coradoc/markdown/parser/block_parser'
       autoload :InlineParser, 'coradoc/markdown/parser/inline_parser'
-      autoload :ParsletExtras, 'coradoc/markdown/parser/parslet_extras'
+      autoload :ParsanolAtoms, 'coradoc/markdown/parser/parsanol_atoms'
       autoload :HTML_ENTITIES, 'coradoc/markdown/parser/html_entities'
       autoload :AstProcessor, 'coradoc/markdown/parser/ast_processor'
       autoload :FrontmatterParser, 'coradoc/markdown/parser/frontmatter_parser'
@@ -127,9 +128,9 @@ module Coradoc
       # @param filename [String] Path to the Markdown file
       # @param options [Hash] Parsing options (see #parse)
       # @return [Array] The parsed AST
-      def from_file(filename, **options)
+      def from_file(filename, **)
         content = File.read(filename)
-        parse(content, **options)
+        parse(content, **)
       end
 
       # Parse inline Markdown content
@@ -150,6 +151,13 @@ module Coradoc
         Serializer.serialize(document, options)
       end
 
+      # Markdown preserves unresolved include edges as HTML comments
+      # (Transform::FromCoreModel#transform_include) — lossy formatting,
+      # but never silent content loss.
+      def preserves_unresolved_includes?
+        true
+      end
+
       # Check if this format can transform the given model to CoreModel
       #
       # @param model [Object] The model to check

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: coradoc-markdown
 version: !ruby/object:Gem::Version
-  version: 1.0.10
+  version: 1.0.12
 platform: ruby
 authors:
 - Ribose Inc.
@@ -38,7 +38,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.8.0
 - !ruby/object:Gem::Dependency
-  name: parslet
+  name: parsanol
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -94,7 +94,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 description: Provides Markdown parsing and serialization capabilities for Coradoc.
-  Includes the Markdown Document Model, a CommonMark-compliant Parslet-based parser,
+  Includes the Markdown Document Model, a CommonMark-compliant Parsanol-based parser,
   and round-trip capable serializer.
 email:
 - open.source@ribose.com
@@ -152,7 +152,7 @@ files:
 - lib/coradoc/markdown/parser/frontmatter_parser.rb
 - lib/coradoc/markdown/parser/html_entities.rb
 - lib/coradoc/markdown/parser/inline_parser.rb
-- lib/coradoc/markdown/parser/parslet_extras.rb
+- lib/coradoc/markdown/parser/parsanol_atoms.rb
 - lib/coradoc/markdown/parser_util.rb
 - lib/coradoc/markdown/serializer.rb
 - lib/coradoc/markdown/serializer/builder.rb
@@ -232,6 +232,7 @@ metadata:
   homepage_uri: https://github.com/metanorma/coradoc
   source_code_uri: https://github.com/metanorma/coradoc
   changelog_uri: https://github.com/metanorma/coradoc/releases
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib

data/lib/coradoc/markdown/parser/parslet_extras.rb

@@ -1,215 +0,0 @@
-# frozen_string_literal: true
-
-require 'parslet'
-require 'parslet/convenience'
-
-module Coradoc
-  module Markdown
-    module Parser
-      module ParsletExtras
-        refine Parslet::Source do
-          def rewind(nchars)
-            # https://github.com/ruby/strscan/issues/122
-            self.charpos = @str.charpos - nchars
-          end
-
-          def charpos=(pos)
-            @str.reset
-            @str.getch while @str.charpos < pos
-          end
-
-          def charpos
-            @str.charpos
-          end
-
-          def peek_byte
-            @str.peek(1)
-          end
-        end
-
-        refine Parslet::Scope do
-          attr_reader :current
-
-          def key?(...)
-            @current.key?(...)
-          end
-
-          def has_key?(...)
-            @current.key?(...)
-          end
-
-          def root
-            scope = current
-            scope = scope.parent while scope.parent
-            scope
-          end
-        end
-
-        refine Parslet::Scope::Binding do
-          def key?(...)
-            @hash.key?(...)
-          end
-
-          def has_key?(...)
-            @hash.key?(...)
-          end
-
-          def initialize_copy(original)
-            super
-            @hash = @hash.clone
-          end
-        end
-
-        # like Named but returning other things
-        class Output < Parslet::Atoms::Base
-          attr_reader :parslet, :value
-
-          def initialize(parslet, value)
-            super()
-
-            @parslet = parslet
-            @value = value
-          end
-
-          def apply(source, context, consume_all)
-            success, = result = parslet.apply(source, context, consume_all)
-
-            return result unless success
-
-            succ(@value)
-          end
-
-          def to_s_inner(prec)
-            "#{value}:#{parslet.to_s(prec)}"
-          end
-        end
-
-        class DynamicOutput < Parslet::Atoms::Base
-          attr_reader :parslet, :callable
-
-          def initialize(parslet, callable)
-            super()
-
-            @parslet = parslet
-            @callable = callable
-          end
-
-          def apply(source, context, consume_all)
-            success, value = result = parslet.apply(source, context, consume_all)
-
-            return result unless success
-
-            succ(@callable.call(flatten(value)))
-          end
-
-          def to_s_inner(prec)
-            "#{callable}:#{parslet.to_s(prec)}"
-          end
-        end
-
-        class Lookbehind < Parslet::Atoms::Base
-          using ParsletExtras
-          attr_reader :positive
-          attr_reader :number, :bound_parslet
-
-          def initialize(bound_parslet, number, positive: true)
-            super()
-
-            # Model positive and negative lookbehind by testing this flag.
-            @positive = positive
-            @number = number
-            @bound_parslet = bound_parslet
-          end
-
-          def error_msgs
-            @error_msgs ||= {
-              positive: ['Input should be preceded by ', bound_parslet],
-              negative: ['Input should not be preceded by ', bound_parslet]
-            }
-          end
-
-          def try(source, context, consume_all)
-            rewind_pos = source.bytepos
-            if source.bytepos.zero?
-              return succ(nil) unless positive
-
-              return context.err_at(self, source, error_msgs[:positive], source.pos)
-            end
-            source.rewind(number)
-            error_pos = source.pos
-
-            success, = bound_parslet.apply(source, context, consume_all)
-
-            if positive
-              return succ(nil) if success
-
-              context.err_at(self, source, error_msgs[:positive], error_pos)
-            else
-              return succ(nil) unless success
-
-              context.err_at(self, source, error_msgs[:negative], error_pos)
-            end
-          ensure
-            source.bytepos = rewind_pos
-          end
-
-          def to_s_inner(prec)
-            @char = positive ? '&' : '!'
-            "<#{@char}<#{number}<#{bound_parslet.to_s(prec)}"
-          end
-        end
-
-        # Like Dynamic but does not return a further parslet, just a reject/accept boolean
-        module ::Parslet
-          module Atoms
-            class Check < ::Parslet::Atoms::Base
-              attr_reader :block
-
-              def initialize(block)
-                super()
-                @block = block
-              end
-
-              def cached?
-                false
-              end
-
-              def try(source, context, _consume_all)
-                [block.call(source, context), nil]
-              end
-
-              def to_s_inner(_prec)
-                'check { ... }'
-              end
-            end
-          end
-        end
-
-        refine ::Parslet do
-          def check(&block)
-            ::Parslet::Atoms::Check.new(block)
-          end
-          module_function :check
-        end
-
-        refine ::Parslet::Atoms::DSL do
-          def output(value)
-            Output.new(self, value)
-          end
-
-          def dynamic_output(value)
-            DynamicOutput.new(self, value)
-          end
-
-          def precedes?(num = 1)
-            Lookbehind.new(self, num, positive: true)
-          end
-
-          def does_not_precede?(num = 1)
-            Lookbehind.new(self, num, positive: false)
-          end
-        end
-      end
-    end
-  end
-end