markbridge 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 395eaa44d32b7fc497e7153b1648250d6abd675ef3fcafa7939c1282725683e2
-  data.tar.gz: bd1c7215feeeb2a6fd6e0ebb213122c3652037eec277eec396191321e3e050e0
+  metadata.gz: cd32ca1996ac298962ade2f5728f0e0b9999ae0e2934b44474e003ca74888e32
+  data.tar.gz: 43334aa515a7326ac7e514e1ebd252f7517866a6fe254c350f7c51085ca26ba4
 SHA512:
-  metadata.gz: ee252b9c8fdd75437e99e5cf2aa446c71c58f9091a1c1d33a0724feaa3e8239f1267e31154957b60a7d1b72c951ec0cf11367ecf8b13a15a5147e93f702a1d1f
-  data.tar.gz: da07e85f2ba664a1239578c2fead05e2bbbf43a563f2e2da5c6d2f409192d7777cfe5875148bb2058fd1750838ff9f56556938ee8ca000ac918e1a608276d5df
+  metadata.gz: a2d9e6f8ed438bbe9425a33c4cf834e707bea7efc953bfd0d1c1aa53faea9b578ed54d7cb6a0fccb1a79ee433f43feb2a6858bf00f8fc19f8d55bef0237842f0
+  data.tar.gz: 90f49ebacb4bc8be03b27aa0b730aea8a4b6f6206a601e19cd7fdc6cfb56e23916dec63ae990ce05c525103afd29d2949b15e812d74662e53776dced970177f2

data/lib/markbridge/all.rb

@@ -1,9 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "../markbridge"
-
-require_relative "ast"
-require_relative "parsers/bbcode"
-require_relative "parsers/html"
-require_relative "parsers/text_formatter"
-require_relative "renderers/discourse"
+require_relative "bbcode"
+require_relative "html"
+require_relative "mediawiki"
+require_relative "textformatter"

data/lib/markbridge/ast/document.rb

@@ -20,7 +20,7 @@ module Markbridge
       # @param children [Array<Node>] optional array of initial child nodes
       def initialize(children = [])
         super()
-        Array(children).each { |c| self << c }
+        children.each { |c| self << c }
       end
     end
   end

data/lib/markbridge/ast/element.rb

@@ -31,10 +31,10 @@ module Markbridge
       def <<(child)
         unless child.is_a?(Node)
           actual = child.nil? ? "nil" : child.class
-          raise TypeError, "child must be a #{Markbridge::AST::Node} (got #{actual})"
+          raise TypeError, "<< on #{self.class} expected a #{Node}, got #{actual}"
         end
 
-        if child.is_a?(Text) && children.last.is_a?(Text)
+        if child.instance_of?(Text) && children.last.instance_of?(Text)
           @children.last.merge(child)
         else
           @children << child

data/lib/markbridge/ast/list.rb

@@ -21,9 +21,9 @@ module Markbridge
       # @return [List] self for chaining
       # @raise [TypeError] if child is not a Node
       def <<(child)
-        return self if child.is_a?(Text) && child.text.strip.empty?
+        return self if child.instance_of?(Text) && !child.text.match?(/\S/)
 
-        if child.is_a?(ListItem)
+        if child.instance_of?(ListItem)
           super
         else
           @children << ListItem.new if @children.empty?

data/lib/markbridge/ast/table.rb

@@ -8,13 +8,11 @@ module Markbridge
     #   table = AST::Table.new
     #   table << AST::TableRow.new
     class Table < Element
-      # Add a child node to the table.
-      # Whitespace-only Text nodes are ignored.
-      #
-      # @param child [Node] the node to add
-      # @return [Table] self for chaining
+      # HTML/BBCode parsers add a Text("\n") child for the whitespace
+      # between `<table>` and `<tr>` (and equivalent BBCode). Drop
+      # those so the AST contains only TableRow children.
       def <<(child)
-        return self if child.is_a?(Text) && child.text.strip.empty?
+        return self if child.instance_of?(Text) && child.text.strip.empty?
 
         super
       end
@@ -26,13 +24,9 @@ module Markbridge
     #   row = AST::TableRow.new
     #   row << AST::TableCell.new
     class TableRow < Element
-      # Add a child node to the row.
-      # Whitespace-only Text nodes are ignored.
-      #
-      # @param child [Node] the node to add
-      # @return [TableRow] self for chaining
+      # See Table#<< — same whitespace skip for `<tr>` / `<td>` gaps.
       def <<(child)
-        return self if child.is_a?(Text) && child.text.strip.empty?
+        return self if child.instance_of?(Text) && child.text.strip.empty?
 
         super
       end

data/lib/markbridge/ast/text.rb

@@ -19,9 +19,13 @@ module Markbridge
 
       # Create a new text node with the given content.
       #
+      # The text is copied into a fresh mutable buffer so that subsequent
+      # in-place mutations (e.g. via {#merge}) do not leak back to the caller's
+      # original string.
+      #
       # @param text [String] the text content
       def initialize(text)
-        @text = +text
+        @text = text.dup
       end
 
       # Merge another text node's content into this one.

data/lib/markbridge/bbcode.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "../markbridge"
+require_relative "parsers/bbcode"

data/lib/markbridge/gem_loader.rb

@@ -12,10 +12,9 @@ module Markbridge
       private
 
       def missing_message(gem, feature)
-        gem_name = gem.to_s
         [
-          "#{gem_name.capitalize} is required for #{feature}.",
-          "Add 'gem \"#{gem_name}\"' to your Gemfile or install it with 'gem install #{gem_name}'.",
+          "#{gem.capitalize} is required for #{feature}.",
+          "Add 'gem \"#{gem}\"' to your Gemfile or install it with 'gem install #{gem}'.",
         ].join(" ")
       end
     end

data/lib/markbridge/html.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "../markbridge"
+require_relative "parsers/html"

data/lib/markbridge/mediawiki.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "../markbridge"
+require_relative "parsers/media_wiki"

data/lib/markbridge/parsers/bbcode/closing_strategies/base.rb

@@ -9,27 +9,17 @@ module Markbridge
           end
 
           def handle_close(token:, context:, registry:, tokens: nil)
-            return unless context.current.is_a?(AST::Element)
-
             current_handler = registry.handler_for_element(context.current)
             closing_handler = registry[token.tag]
 
             if current_handler == closing_handler
               context.pop
-            elsif try_reorder(context:, tokens:, closing_handler:)
-              # Reordering handled
             elsif @reconciler.try_auto_close(handler: closing_handler, context:)
               # Auto-close succeeded
             else
               context.add_child(AST::Text.new(token.source))
             end
           end
-
-          private
-
-          def try_reorder(context:, tokens:, closing_handler:)
-            false
-          end
         end
       end
     end

data/lib/markbridge/parsers/bbcode/closing_strategies/reordering.rb

@@ -4,11 +4,24 @@ module Markbridge
     module BBCode
       module ClosingStrategies
         class Reordering < Base
-          private
+          def handle_close(token:, context:, registry:, tokens: nil)
+            closing_handler = registry[token.tag]
 
-          def try_reorder(context:, tokens:, closing_handler:)
-            return false unless tokens
-            @reconciler.try_reorder(handler: closing_handler, tokens:, context:)
+            # Fast path: when the current element matches the closing tag,
+            # pop and return. try_reorder/try_reopen are reconciliation
+            # strategies that only make sense when the close is mismatched;
+            # running them eagerly here costs a full elements_from_current
+            # walk plus two sort_by/compare passes on every close token,
+            # which dominates runtime for well-formed input.
+            if registry.handler_for_element(context.current) == closing_handler
+              context.pop
+              return
+            end
+
+            return if tokens && @reconciler.try_reorder(handler: closing_handler, tokens:, context:)
+            return if @reconciler.try_reopen(handler: closing_handler, context:, tokens:)
+
+            super
           end
         end
       end

data/lib/markbridge/parsers/bbcode/closing_strategies/tag_reconciler.rb

@@ -18,15 +18,48 @@ module Markbridge
           # @param context [ParserState]
           # @return [Boolean] true if successful, false if auto-close not possible
           def try_auto_close(handler:, context:)
-            match_depth = find_matching_handler_depth(handler, context)
+            count = auto_close_count(handler, context)
+            return false if count.nil?
+
+            count.times { context.pop }
+            context.auto_close!(count)
+
+            true
+          end
 
-            return false if match_depth.nil? || match_depth >= MAX_AUTO_CLOSE_DEPTH
+          # Attempt to close the target tag and reopen any intervening
+          # auto-closeable tags so subsequent content continues in the same
+          # formatting context. Used when closing tags are not adjacent
+          # (e.g. "[b][i]x[/b] more[/i]").
+          #
+          # Reopening only makes sense when there is upcoming content that
+          # would benefit from the reopened context. If the next token is a
+          # closing tag (or nothing), plain auto-close is correct.
+          #
+          # @param handler [BaseHandler] the handler for the closing tag
+          # @param context [ParserState]
+          # @param tokens [Object, nil] the token stream (used to check that content follows)
+          # @return [Boolean] true if successful, false otherwise
+          def try_reopen(handler:, context:, tokens:)
+            case tokens&.peek
+            when TextToken, TagStartToken
+              nil # content follows -> reopening is justified
+            else
+              return false
+            end
+
+            match_depth = find_matching_handler_depth(handler, context)
+            return false if match_depth.nil? || match_depth.zero?
             return false unless all_auto_closeable?(context, match_depth)
 
+            intervening = context.elements_from_current(match_depth - 1).map(&:class)
+
             count = match_depth + 1
             count.times { context.pop }
             context.auto_close!(count)
 
+            intervening.reverse_each { |klass| context.push(klass.new) }
+
             true
           end
 
@@ -38,24 +71,17 @@ module Markbridge
           # @return [Boolean] true if successful, false otherwise
           def try_reorder(handler:, tokens:, context:)
             match_depth = find_matching_handler_depth(handler, context)
-            return false if match_depth.nil? || match_depth >= MAX_AUTO_CLOSE_DEPTH
-
             opening_handlers = collect_auto_closeable_handlers(context, match_depth)
-            return false if opening_handlers.empty?
 
-            closing_handlers = [handler]
-            closing_handlers.concat(peek_closing_handlers(tokens, opening_handlers.size - 1))
-            return false if closing_handlers.size != opening_handlers.size
+            closing_handlers = [handler, *peek_closing_handlers(tokens, opening_handlers.size - 1)]
             unless opening_handlers.sort_by(&:object_id) == closing_handlers.sort_by(&:object_id)
               return false
             end
 
-            # Consume the extra closing tags
-            (opening_handlers.size - 1).times do
-              peeked = tokens.peek
-              break unless peeked.is_a?(TagEndToken)
-              tokens.next
-            end
+            # Consume the extra closing tags. We've already verified via
+            # peek_closing_handlers that the next opening_handlers.size - 1
+            # tokens are TagEndTokens with handlers we accept.
+            (opening_handlers.size - 1).times { tokens.next }
 
             opening_handlers.each { context.pop }
             context.auto_close!(opening_handlers.size)
@@ -65,15 +91,26 @@ module Markbridge
 
           private
 
-          def find_matching_handler_depth(handler, context)
-            elements = context.elements_from_current(MAX_AUTO_CLOSE_DEPTH)
+          # Number of stack elements to pop in order to close `handler`, or nil
+          # when the handler is not on the stack within MAX_AUTO_CLOSE_DEPTH or
+          # any intervening element is not auto-closeable.
+          def auto_close_count(handler, context)
+            context
+              .elements_from_current(MAX_AUTO_CLOSE_DEPTH - 1)
+              .each_with_index do |element, depth|
+                return nil unless @registry.auto_closeable?(element.class)
+                return depth + 1 if @registry.handler_for_element(element) == handler
+              end
 
-            elements.each_with_index do |element, depth|
-              next unless element.is_a?(AST::Element)
+            nil
+          end
 
-              element_handler = @registry.handler_for_element(element)
-              return depth if element_handler == handler
-            end
+          def find_matching_handler_depth(handler, context)
+            context
+              .elements_from_current(MAX_AUTO_CLOSE_DEPTH - 1)
+              .each_with_index do |element, depth|
+                return depth if @registry.handler_for_element(element) == handler
+              end
 
             nil
           end
@@ -84,35 +121,18 @@ module Markbridge
               .all? { |element| @registry.auto_closeable?(element.class) }
           end
 
+          # Caller must have verified all_auto_closeable?(context, target_depth) first.
           def collect_auto_closeable_handlers(context, target_depth)
-            handlers = []
-
             context
               .elements_from_current(target_depth)
-              .each do |element|
-                return [] unless @registry.auto_closeable?(element.class)
-
-                handler = @registry.handler_for_element(element)
-                handlers << handler if handler
-              end
-
-            handlers
+              .map { |element| @registry.handler_for_element(element) }
           end
 
           def peek_closing_handlers(tokens, max_count)
-            handlers = []
-            peeked_tokens = tokens.peek_ahead(max_count)
-
-            peeked_tokens.each do |token|
-              break unless token.is_a?(TagEndToken)
-
-              handler = @registry[token.tag]
-              break unless handler
-
-              handlers << handler
-            end
-
-            handlers
+            tokens
+              .peek_ahead(max_count)
+              .take_while { |token| token.instance_of?(TagEndToken) }
+              .map { |token| @registry[token.tag] }
           end
         end
       end

data/lib/markbridge/parsers/bbcode/handler_registry.rb

@@ -5,26 +5,33 @@ module Markbridge
     module BBCode
       # Registry of BBCode tag handlers
       class HandlerRegistry
+        include Enumerable
+
         attr_writer :closing_strategy
 
         def initialize(closing_strategy: nil)
           @handlers = {}
-          @normalized_tag_cache = {}
           @element_handlers = {}
           @auto_closeable_elements = Set.new
           @closing_strategy = closing_strategy
         end
 
+        # Iterate over registered (tag_name, handler) pairs.
+        # Useful for debugging custom registries — e.g. confirming an override
+        # has stuck. Iteration order matches registration order.
+        # @yieldparam tag_name [String]
+        # @yieldparam handler [BaseHandler]
+        # @return [Enumerator] when no block is given
+        def each(&block)
+          @handlers.each(&block)
+        end
+
         # Register a handler for one or more tag names and associate it with an element class
         # @param tag_names [String, Array<String>] tag name(s) to register
         # @param handler [BaseHandler] the handler instance
         def register(tag_names, handler)
           element_class = handler.element_class
-          Array(tag_names).each do |tag_name|
-            normalized = tag_name.to_s.downcase
-            @handlers[normalized] = handler
-            @normalized_tag_cache[tag_name.to_s] = normalized
-          end
+          Array(tag_names).each { |tag_name| @handlers[tag_name.to_s.downcase] = handler }
           @element_handlers[element_class] = handler
           @auto_closeable_elements << element_class if handler.auto_closeable?
           self
@@ -34,9 +41,7 @@ module Markbridge
         # @param tag_name [String]
         # @return [BaseHandler, nil]
         def [](tag_name)
-          tag_str = tag_name.to_s
-          normalized = @normalized_tag_cache[tag_str] || tag_str.downcase
-          @handlers[normalized]
+          @handlers[tag_name.to_s.downcase]
         end
 
         # Get handler for an element instance
@@ -61,7 +66,12 @@ module Markbridge
           @closing_strategy&.handle_close(token:, context:, registry: self, tokens:)
         end
 
-        # Create the default handler registry with common BBCode tags
+        # Create the default handler registry with common BBCode tags.
+        #
+        # Each call returns a *fresh* instance — mutations made to one will
+        # not be visible to another. If you want a process-wide singleton,
+        # use {Markbridge.default_handlers} instead, which memoizes.
+        #
         # @param closing_strategy [Object, nil] optional closing strategy to apply, defaults to Reordering strategy
         # @return [HandlerRegistry]
         def self.default(closing_strategy: nil)
@@ -95,7 +105,7 @@ module Markbridge
           )
 
           # Code handlers (raw content)
-          registry.register(%w[code pre tt], Handlers::RawHandler.new(AST::Code))
+          registry.register(%w[code pre tt], Handlers::CodeHandler.new)
 
           # Image handler
           registry.register("img", Handlers::ImageHandler.new)

data/lib/markbridge/parsers/bbcode/handlers/attachment_handler.rb

@@ -38,21 +38,26 @@ module Markbridge
             @collector.collect(token.tag, tokens).content
           end
 
+          CLOSING_TAG_PEEK_DEPTH = 100
+          private_constant :CLOSING_TAG_PEEK_DEPTH
+
           def closing_tag_ahead?(tag, tokens)
-            tokens.peek_ahead(100).any? { |token| token.is_a?(TagEndToken) && token.tag == tag }
+            tokens
+              .peek_ahead(CLOSING_TAG_PEEK_DEPTH)
+              .any? { |token| token.instance_of?(TagEndToken) && token.tag == tag }
           end
 
           def build_attachment(token:, content:)
             attrs = normalize_attrs(token.attrs)
             option = attrs[:option]
-            body = presence(content&.strip)
+            body = presence(content)
 
             id = preferred_id(attrs)
             index = preferred_index(attrs)
             filename = attrs[:filename]
             alt = attrs[:alt]
 
-            index ||= option if option && numeric?(option)
+            index ||= option if numeric?(option)
             id, filename = apply_body_content(body:, id:, index:, filename:)
 
             AST::Attachment.new(id:, index:, filename:, alt:)
@@ -63,8 +68,6 @@ module Markbridge
           end
 
           def apply_body_content(body:, id:, index:, filename:)
-            return id, filename unless body
-
             if id.nil?
               return body, filename if index.nil?
               return body, filename if numeric?(body)
@@ -75,27 +78,29 @@ module Markbridge
             [id, filename]
           end
 
+          # Caller must have applied normalize_attrs first (whitespace already stripped).
           def preferred_id(attrs)
-            presence(attrs[:msg]) || presence(attrs[:id])
+            attrs[:msg] || attrs[:id]
           end
 
+          # Caller must have applied normalize_attrs first.
           def preferred_index(attrs)
-            explicit_index = presence(attrs[:index])
-            smf_index = presence(attrs[:id]) if attrs[:msg]
-
-            explicit_index || smf_index
+            attrs[:index] || (attrs[:id] if attrs[:msg])
           end
 
+          # Callers only ever pass String or nil (via #normalize_attrs
+          # over token.attrs, which the BBCode scanner populates with
+          # String values exclusively), so no defensive non-String
+          # passthrough is needed here or in #numeric?.
           def presence(value)
             return if value.nil?
-            return value unless value.is_a?(String)
 
             stripped = value.strip
             stripped unless stripped.empty?
           end
 
           def numeric?(value)
-            value.is_a?(String) && value.match?(/\A\d+\z/)
+            value&.match?(/\A\d+\z/)
           end
         end
       end

data/lib/markbridge/parsers/bbcode/handlers/base_handler.rb

@@ -5,36 +5,26 @@ module Markbridge
     module BBCode
       module Handlers
         class BaseHandler
-          # Default opening behavior: create element and push to context
-          # Subclasses should override this method
           # @param token [TagStartToken]
           # @param context [ParserState]
           # @param registry [HandlerRegistry]
           # @param tokens [Enumerator, nil]
-          # @return [void]
           def on_open(token:, context:, registry:, tokens: nil)
-            # Default: do nothing, subclasses override
           end
 
-          # Default closing behavior: pop matching element from stack
-          # Subclasses can override or call super for custom behavior
           # @param token [TagEndToken]
           # @param context [ParserState]
           # @param registry [HandlerRegistry]
           # @param tokens [PeekableEnumerator, nil]
-          # @return [void]
           def on_close(token:, context:, registry:, tokens: nil)
             registry.close_element(token:, context:, tokens:)
           end
 
-          # Whether elements created by this handler can be auto-closed
           # @return [Boolean]
           def auto_closeable?
             false
           end
 
-          # The element class created by this handler
-          # Subclasses must expose this via attr_reader :element_class
           # @return [Class]
           attr_reader :element_class
         end

data/lib/markbridge/parsers/bbcode/handlers/code_handler.rb

@@ -4,16 +4,12 @@ module Markbridge
   module Parsers
     module BBCode
       module Handlers
-        # Handler for [code]...[/code] tags
-        #
-        # Preserves content as-is without parsing nested BBCode
-        # Inherits from RawHandler using AST::Code element
-        #
-        # Example:
-        # [code=python]
-        # def hello_world():
-        #   print("Hello, world!")
-        # [/code]
+        # @example
+        #   # [code=python]
+        #   # def hello_world
+        #   #   puts "hi"
+        #   # end
+        #   # [/code]
         class CodeHandler < RawHandler
           def initialize
             super(AST::Code)

data/lib/markbridge/parsers/bbcode/handlers/image_handler.rb

@@ -22,29 +22,21 @@ module Markbridge
             AST::Image.new(src: content, width:, height:)
           end
 
-          def extract_dimensions(token)
-            width = sanitize_dimension(token.attrs[:width])
-            height = sanitize_dimension(token.attrs[:height])
+          OPTION_DIMENSIONS_PATTERN = /\A(?<width>\d+)(?:x(?<height>\d+))?\z/i
+          private_constant :OPTION_DIMENSIONS_PATTERN
 
-            option = token.attrs[:option]
-            if option&.match?(/^\d+x\d+$/i)
-              parts = option.split("x", 2)
-              width = sanitize_dimension(parts[0])
-              height = sanitize_dimension(parts[1])
-            elsif option&.match?(/^\d+$/)
-              width = sanitize_dimension(option)
-            end
+          def extract_dimensions(token)
+            option_match = OPTION_DIMENSIONS_PATTERN.match(token.attrs[:option])
 
-            [width, height]
+            [
+              sanitize_dimension(option_match&.[](:width) || token.attrs[:width]),
+              sanitize_dimension(option_match&.[](:height) || token.attrs[:height]),
+            ]
           end
 
-          # Convert dimension to positive integer or nil
-          # Handles string input from BBCode attributes
           def sanitize_dimension(value)
-            return nil if value.nil?
-
             dim = value.to_i
-            dim.positive? ? dim : nil
+            dim if dim.positive?
           end
         end
       end

data/lib/markbridge/parsers/bbcode/handlers/list_handler.rb

@@ -11,7 +11,6 @@ module Markbridge
           end
 
           def on_open(token:, context:, registry:, tokens: nil)
-            # Check if ordered: explicit ol/olist tag, or type=1, or option=1
             ordered =
               %w[ol olist].include?(token.tag) || token.attrs[:type] == "1" ||
                 token.attrs[:option] == "1"
@@ -21,10 +20,7 @@ module Markbridge
           end
 
           def on_close(token:, context:, registry:, tokens: nil)
-            # Auto-close open list item before closing list
-            context.pop if context.current.is_a?(AST::ListItem)
-
-            # Then use default closing behavior
+            context.pop if context.current.instance_of?(AST::ListItem)
             super
           end
 

data/lib/markbridge/parsers/bbcode/handlers/list_item_handler.rb

@@ -11,8 +11,7 @@ module Markbridge
           end
 
           def on_open(token:, context:, registry:, tokens: nil)
-            # Auto-close previous list item if opening a new one
-            context.pop if context.current.is_a?(AST::ListItem)
+            context.pop if context.current.instance_of?(AST::ListItem)
 
             element = AST::ListItem.new
             context.push(element, token:)