coradoc-markdown 1.0.11 → 1.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 860562e968c6a646a564edac417a882d9d477ef09c7bb84c477a6ab13fcd6fd0
-  data.tar.gz: de5901c3b2e6eb123a718a14466d6bf688358e350ad95564abfcc17ebd62c660
+  metadata.gz: 232eab66f6d33edae8a3cca57f5ebd16cca11ed96c4dd9a51611b9669410595b
+  data.tar.gz: 1b0f0051729a0e226826c66d49bed0c4227732491b0bbf6148f42df524b1e95f
 SHA512:
-  metadata.gz: 313e3f097c07329bfacd65ce3283c33087136a9e3d8f5259298c40781b76d10495b98dd89c3c3977b27e40d667d0a056ef9c012dc89165bcecc47293333e3442
-  data.tar.gz: 5125a17bab25bde3da034de5b898fd28214f9e18857a9ca471e03795683fd2a9f85d3d7c3bd2925d0abf1f4b36acf6e37c71ef6f4ce2aa7389a65c7e562f8bf3
+  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
@@ -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)
@@ -32,7 +31,7 @@ module Coradoc
 
         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
@@ -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? }

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/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.11'
+    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'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: coradoc-markdown
 version: !ruby/object:Gem::Version
-  version: 1.0.11
+  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

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