markbridge 0.2.0 → 0.3.0

data/lib/markbridge/renderers/discourse/render_context.rb

@@ -3,30 +3,74 @@
 module Markbridge
   module Renderers
     module Discourse
-      # Immutable context for rendering that wraps the parent chain.
+      # Immutable context for rendering, implemented as a linked parent
+      # chain: each context holds the nearest parent element plus a link
+      # to the enclosing context. {#with_parent} runs once per rendered
+      # element — the chain form makes it a single fixed-size allocation
+      # instead of copying (and freezing) a parents array per element.
       # Provides query methods to ask about parent elements without the
       # renderer knowing about specific element types.
       class RenderContext
-        attr_reader :parents, :depth
+        # @return [Integer] number of parent elements in the chain
+        attr_reader :depth
 
-        def initialize(parents = [], html_mode: false)
-          @parents = parents.freeze
-          @depth = parents.size
+        # @return [AST::Element, nil] the nearest parent element (nil at root)
+        attr_reader :element
+
+        # @return [RenderContext, nil] the enclosing context (nil at root)
+        attr_reader :parent_context
+
+        # @param parents [Array<AST::Element>] parent elements in document
+        #   order (outermost first); convenience form for building a
+        #   context from scratch. Ignored when +element:+ is given.
+        # @param html_mode [Boolean] see {#html_mode?}
+        # @param parent [RenderContext, nil] enclosing context (chain form)
+        # @param element [AST::Element, nil] nearest parent element (chain form)
+        def initialize(parents = [], html_mode: false, parent: nil, element: nil)
           @html_mode = html_mode
+          if element
+            @parent_context = parent
+            @element = element
+            @depth = (parent ? parent.depth : 0) + 1
+          elsif parents.empty?
+            # Root context: @element and @parent_context stay unset and
+            # read as nil.
+            @depth = 0
+          else
+            @parent_context = self.class.new(parents[0, parents.size - 1], html_mode:)
+            @element = parents.last
+            @depth = parents.size
+          end
+        end
+
+        # Parent elements in document order (outermost first), materialized
+        # from the chain into a frozen Array. Allocates on every call —
+        # prefer {#find_parent} / {#has_parent?} / {#count_parents} on hot
+        # paths.
+        # @return [Array<AST::Element>]
+        def parents
+          result = []
+          context = self
+          while context && (parent = context.element)
+            result << parent
+            context = context.parent_context
+          end
+          result.reverse!
+          result.freeze
         end
 
         # Create new context with element added to parent chain.
         # @param element [AST::Element]
         # @return [RenderContext]
         def with_parent(element)
-          self.class.new(@parents + [element], html_mode: @html_mode)
+          self.class.new(html_mode: @html_mode, parent: self, element:)
         end
 
         # Create new context with html_mode toggled.
         # @param value [Boolean]
         # @return [RenderContext]
         def with_html_mode(value)
-          self.class.new(@parents, html_mode: value)
+          self.class.new(html_mode: value, parent: @parent_context, element: @element)
         end
 
         # @return [Boolean]
@@ -35,24 +79,43 @@ module Markbridge
         end
 
         # Find closest parent that is_a? klass (handles subclasses).
+        # The chain walks are inlined in each query (instead of a shared
+        # yielding helper) — these run several times per rendered text
+        # node, and a plain while loop avoids the block invocation.
         # @param klass [Class]
-        # @return [AST::Element, nil]
+        # @return [AST::Element, nil] nil when no parent matches (implicit
+        #   from the exhausted while loop)
         def find_parent(klass)
-          @parents.reverse_each.find { |parent| parent.is_a?(klass) }
+          context = self
+          while context && (parent = context.element)
+            return parent if parent.is_a?(klass)
+            context = context.parent_context
+          end
         end
 
         # Count parents that are is_a? klass (handles subclasses).
         # @param klass [Class]
         # @return [Integer]
         def count_parents(klass)
-          @parents.count { |parent| parent.is_a?(klass) }
+          count = 0
+          context = self
+          while context && (parent = context.element)
+            count += 1 if parent.is_a?(klass)
+            context = context.parent_context
+          end
+          count
         end
 
         # Check if any parent is_a? klass (handles subclasses).
         # @param klass [Class]
         # @return [Boolean]
         def has_parent?(klass)
-          @parents.any? { |parent| parent.is_a?(klass) }
+          context = self
+          while context && (parent = context.element)
+            return true if parent.is_a?(klass)
+            context = context.parent_context
+          end
+          false
         end
 
         # Check if we're at the root (no parents).

data/lib/markbridge/renderers/discourse/renderer.rb

@@ -8,7 +8,7 @@ module Markbridge
         attr_reader :postprocessor
 
         def initialize(tag_library: nil, escaper: nil, html_escaper: nil, postprocessor: nil)
-          @tag_library = tag_library || TagLibrary.default
+          @tag_library = tag_library || TagLibrary.shared_default
           @escaper = escaper || MarkdownEscaper.new
           @html_escaper = html_escaper || HtmlEscaper
           @postprocessor = postprocessor || Postprocessor::DEFAULT
@@ -20,26 +20,56 @@ module Markbridge
         # @param node [AST::Node]
         # @param context [RenderContext] rendering context with parent chain
         # @return [String]
+        # @raise [TypeError] when the tag bound to the node's class returns
+        #   something other than a String (a nil from a custom tag would
+        #   otherwise surface as an inscrutable concatenation error deep
+        #   inside render_children)
         def render(node, context: RenderContext.new)
           root_call = @interface_cache.nil?
           @interface_cache = {} if root_call
 
           tag = @tag_library[node.class]
           if tag
-            interface = interface_for(context)
-            return tag.render(node, interface)
+            result = tag.render(node, interface_for(context))
+            unless result.is_a?(String)
+              raise TypeError,
+                    "#{tag.class} rendered #{node.class} to " \
+                      "#{result.inspect} — tags must return a String " \
+                      "(use interface.render_default(node) to fall back " \
+                      "to the stock rendering)"
+            end
+            return result
           end
 
-          case node
-          when AST::Element # Document is an Element subclass
-            render_children(node, context:)
-          when AST::MarkdownText
-            render_markdown_text(node, context)
-          when AST::Text
-            render_text(node, context)
-          else
-            ""
-          end
+          render_without_tag(node, context)
+        ensure
+          @interface_cache = nil if root_call
+        end
+
+        # Render a node with the stock tag for its class, ignoring any
+        # override registered in this renderer's tag library. Lets a
+        # custom tag intercept only the nodes it cares about and delegate
+        # the rest:
+        #
+        #   library.register(AST::Quote, Tag.new do |node, interface|
+        #     next interface.render_default(node) unless node.username&.start_with?("legacy_")
+        #     ...custom rendering...
+        #   end)
+        #
+        # Children still render through this renderer, so overrides for
+        # other node classes keep applying inside the delegated subtree.
+        #
+        # @param node [AST::Node]
+        # @param context [RenderContext] rendering context with parent chain
+        # @return [String]
+        def render_default(node, context: RenderContext.new)
+          root_call = @interface_cache.nil?
+          @interface_cache = {} if root_call
+
+          tag = default_tag_library[node.class]
+          return tag.render(node, interface_for(context)) if tag
+
+          render_without_tag(node, context)
         ensure
           @interface_cache = nil if root_call
         end
@@ -83,6 +113,26 @@ module Markbridge
           @interface_cache[context.object_id] ||= RenderingInterface.new(self, context)
         end
 
+        # Pristine default library backing #render_default. Built lazily —
+        # most renders never need it.
+        def default_tag_library
+          @default_tag_library ||= TagLibrary.default
+        end
+
+        # The tag-less rendering paths shared by #render and #render_default.
+        def render_without_tag(node, context)
+          case node
+          when AST::Element # Document is an Element subclass
+            render_children(node, context:)
+          when AST::MarkdownText
+            render_markdown_text(node, context)
+          when AST::Text
+            render_text(node, context)
+          else
+            ""
+          end
+        end
+
         # In html_mode, surround pre-formatted Markdown with blank lines so that
         # CommonMark terminates the enclosing HTML block (e.g. <table>) and
         # parses the content as Markdown before the closing tags reopen another

data/lib/markbridge/renderers/discourse/rendering_interface.rb

@@ -18,6 +18,14 @@ module Markbridge
           @renderer.render(node, context:)
         end
 
+        # Render a node with the stock tag for its class, bypassing any
+        # override in the renderer's tag library. Lets a custom tag handle
+        # only the nodes it cares about and delegate the rest — see
+        # Renderer#render_default.
+        def render_default(node, context: @context)
+          @renderer.render_default(node, context:)
+        end
+
         def render_children(element, context: @context)
           @renderer.render_children(element, context:)
         end
@@ -63,6 +71,11 @@ module Markbridge
           node.children.any? { |c| c.instance_of?(AST::Text) && c.text.include?("\n") }
         end
 
+        # Leading or trailing whitespace (Unicode-aware, matching the
+        # flanking-preservation sub in #wrap_inline).
+        EDGE_WHITESPACE = /\A[[:space:]]|[[:space:]]\z/m
+        private_constant :EDGE_WHITESPACE
+
         # Helper: wrap inline content with markers
         # Handles edge cases like existing markers and whitespace
         def wrap_inline(content, open_marker, close_marker = nil)
@@ -82,8 +95,20 @@ module Markbridge
             end
           end
 
-          # Preserve leading/trailing whitespace (Unicode-aware, since
-          # CommonMark's flanking rules treat e.g. nbsp as whitespace).
+          apply_markers(content, open_marker, close_marker)
+        end
+
+        private
+
+        # Wrap content in markers, keeping leading/trailing whitespace
+        # outside the markers (Unicode-aware, since CommonMark's flanking
+        # rules treat e.g. nbsp as whitespace).
+        def apply_markers(content, open_marker, close_marker)
+          # Fast path: no edge whitespace to preserve (the common case), so
+          # plain interpolation replaces the capture-group sub below and its
+          # MatchData + capture allocations.
+          return "#{open_marker}#{content}#{close_marker}" unless content.match?(EDGE_WHITESPACE)
+
           content.sub(/\A([[:space:]]*)(.+?)([[:space:]]*)\z/m) do
             match = Regexp.last_match
             "#{match[1]}#{open_marker}#{match[2]}#{close_marker}#{match[3]}"

data/lib/markbridge/renderers/discourse/tag_library.rb

@@ -106,6 +106,26 @@ module Markbridge
         def self.default
           new.auto_register!
         end
+
+        # Shared, deep-frozen default library for the no-customization
+        # fast path. Built once per process; {Renderer} falls back to it
+        # when no +tag_library:+ is given, skipping the constant-scan and
+        # ~30 tag instantiations of {.default} on every render. Tags are
+        # stateless, so sharing is safe across renderers and threads.
+        # +dup+ yields a mutable copy (see {#initialize_copy}).
+        #
+        # @return [TagLibrary] the same frozen instance on every call
+        def self.shared_default
+          @shared_default ||= default.freeze
+        end
+
+        # Freeze the library together with its internal Hash so that
+        # registration on a shared instance fails loudly instead of
+        # silently mutating state visible to every renderer.
+        def freeze
+          @tags.freeze
+          super
+        end
       end
     end
   end

data/lib/markbridge/renderers/discourse/tags/quote_tag.rb

@@ -14,14 +14,16 @@ module Markbridge
             return "<blockquote>#{content}</blockquote>" if interface.html_mode?
 
             # Build Discourse quote BBCode
-            # Format: [quote="username, post:123, topic:456"]content[/quote]
+            # Format: [quote="username, post:2, topic:456"]content[/quote]
+            # (post: is the post number within the topic, topic: the topic id)
             body =
-              if element.post && element.topic && element.username
+              if element.post_number && element.topic_id && element.username
                 # Full Discourse quote with context
-                "[quote=\"#{element.username}, post:#{element.post}, topic:#{element.topic}\"]\n#{content}\n[/quote]"
-              elsif element.author
-                # Quote with author attribution only
-                "[quote=\"#{element.author}\"]\n#{content}\n[/quote]"
+                "[quote=\"#{element.username}, post:#{element.post_number}, topic:#{element.topic_id}\"]\n#{content}\n[/quote]"
+              elsif element.author || element.username
+                # Name-only attribution; a bare post_id/user_id can't
+                # produce a valid Discourse post reference.
+                "[quote=\"#{element.author || element.username}\"]\n#{content}\n[/quote]"
               else
                 # Plain quote rendered as Markdown blockquote
                 content.split("\n").map { |line| "> #{line}" }.join("\n")

data/lib/markbridge/renderers/discourse/tags/url_tag.rb

@@ -5,20 +5,54 @@ module Markbridge
     module Discourse
       module Tags
         # Tag for rendering URLs
+        #
+        # Bare URLs (a single Text child equal to the href, or no link
+        # text at all) render as the plain href instead of a Markdown
+        # link — in Discourse a bare URL on its own line oneboxes, a
+        # `[text](url)` link does not.
         class UrlTag < Tag
+          # Schemes that are safe to link. Anything else that *looks*
+          # like a scheme (javascript:, data:, vbscript:, …) is dropped;
+          # scheme-less hrefs (relative paths, anchors, protocol-relative
+          # URLs) pass through — common in forum exports and harmless.
+          ALLOWED_SCHEMES = /\A(?:https?|ftps?|mailto):/i
+          SCHEME_LIKE = /\A[a-z][a-z0-9+.-]*:/i
+          private_constant :ALLOWED_SCHEMES, :SCHEME_LIKE
+
           def render(element, interface)
             child_context = interface.with_parent(element)
             text = interface.render_children(element, context: child_context)
             href = element.href
 
-            return text unless href&.match?(/\A(?:https?|ftps?|mailto):/i)
+            return text unless linkable?(href)
 
             if interface.html_mode?
               %(<a href="#{HtmlEscaper.escape(href)}">#{text}</a>)
+            elsif element.bare? || text.empty?
+              # Url#bare? judges the AST (so label escaping can't confuse
+              # it); the rendered-text check additionally catches labels
+              # that render to nothing (e.g. an empty formatting child).
+              href
             else
-              "[#{text}](#{href})"
+              "[#{text}](#{markdown_destination(href)})"
             end
           end
+
+          private
+
+          # CommonMark link destinations cannot contain whitespace unless
+          # wrapped in <> — relevant for relative targets like MediaWiki
+          # page names ("Main Page").
+          def markdown_destination(href)
+            href.match?(/\s/) ? "<#{href}>" : href
+          end
+
+          def linkable?(href)
+            return false if href.nil? || href.empty?
+            return true if href.match?(ALLOWED_SCHEMES)
+
+            !href.match?(SCHEME_LIKE)
+          end
         end
       end
     end

data/lib/markbridge/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Markbridge
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/markbridge.rb

@@ -6,7 +6,6 @@ require_relative "markbridge/conversion"
 
 require_relative "markbridge/ast"
 require_relative "markbridge/renderers/discourse"
-require_relative "markbridge/processors"
 
 module Markbridge
   class << self

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: markbridge
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Discourse Team
@@ -130,15 +130,6 @@ files:
 - lib/markbridge/parsers/text_formatter/handlers/table_cell_handler.rb
 - lib/markbridge/parsers/text_formatter/handlers/url_handler.rb
 - lib/markbridge/parsers/text_formatter/parser.rb
-- lib/markbridge/processors.rb
-- lib/markbridge/processors/discourse_markdown.rb
-- lib/markbridge/processors/discourse_markdown/code_block_tracker.rb
-- lib/markbridge/processors/discourse_markdown/detectors/base.rb
-- lib/markbridge/processors/discourse_markdown/detectors/event.rb
-- lib/markbridge/processors/discourse_markdown/detectors/mention.rb
-- lib/markbridge/processors/discourse_markdown/detectors/poll.rb
-- lib/markbridge/processors/discourse_markdown/detectors/upload.rb
-- lib/markbridge/processors/discourse_markdown/scanner.rb
 - lib/markbridge/renderers/discourse.rb
 - lib/markbridge/renderers/discourse/builders/list_item_builder.rb
 - lib/markbridge/renderers/discourse/html_escaper.rb

data/lib/markbridge/processors/discourse_markdown/code_block_tracker.rb

@@ -1,218 +0,0 @@
-# frozen_string_literal: true
-
-module Markbridge
-  module Processors
-    module DiscourseMarkdown
-      # Tracks whether the current position is inside a code block.
-      # Handles fenced code blocks (``` or ~~~), indented code blocks (4+ spaces),
-      # and inline code (`).
-      #
-      # Fenced code blocks:
-      # - Can have leading whitespace (up to 3 spaces)
-      # - Opening fence: 3+ backticks or tildes, optionally followed by language
-      # - Closing fence: same or more fence characters as opening
-      #
-      # Indented code blocks:
-      # - Lines indented by 4+ spaces or 1+ tab
-      # - Continues until a non-blank line with less indentation
-      #
-      # Inline code:
-      # - Single or multiple backticks as delimiter
-      # - Content between matching backticks
-      class CodeBlockTracker
-        # @return [Boolean] true if currently inside a fenced code block
-        attr_reader :in_fenced_block
-
-        # @return [Boolean] true if currently inside an indented code block
-        attr_reader :in_indented_block
-
-        # @return [Boolean] true if currently inside an inline code span
-        attr_reader :in_inline_code
-
-        def initialize
-          @in_fenced_block = false
-          @in_indented_block = false
-          @in_inline_code = false
-          # @fence_char / @fence_length / @inline_delimiter are set by
-          # open_fence / open_inline before any helper reads them;
-          # they're only consulted when the corresponding in_X flag is
-          # true, which requires a prior open_* call.
-        end
-
-        # Check if currently inside any code context
-        # @return [Boolean]
-        def in_code?
-          @in_fenced_block || @in_indented_block || @in_inline_code
-        end
-
-        # Check if position is at start of a fenced code block boundary
-        # @param input [String] the full input string
-        # @param pos [Integer] current position
-        # @param line_start [Boolean] true if pos is at the start of a line
-        # @return [Integer, nil] end position after fence, or nil if no fence
-        def check_fenced_boundary(input, pos, line_start:)
-          return nil unless line_start
-
-          input_length = input.length
-          scan_pos = skip_leading_spaces(input, pos)
-          # No `scan_pos >= input_length` guard: `input[input_length]` is
-          # nil, and `nil == "`"` / `nil == "~"` are both false so the
-          # next check returns nil anyway.
-          fence_char = input[scan_pos]
-          return nil unless fence_char == "`" || fence_char == "~"
-
-          fence_length, scan_pos = count_fence_chars(input, scan_pos, fence_char, input_length)
-          return nil if fence_length < 3
-
-          if @in_fenced_block
-            try_close_fence(input, scan_pos, fence_char, fence_length, input_length)
-          else
-            open_fence(input, scan_pos, fence_char, fence_length, input_length)
-          end
-        end
-
-        # Check if line at position is an indented code block line.
-        # A line is considered indented code if it starts with 4+ spaces or 1+ tab.
-        # Blank lines within an indented block are considered part of it.
-        #
-        # @param input [String] the full input string
-        # @param pos [Integer] current position (must be at line start)
-        # @param line_start [Boolean] true if pos is at the start of a line
-        # @return [Integer, nil] end position after the line, or nil if not indented code
-        def check_indented_boundary(input, pos, line_start:)
-          return nil unless line_start
-          return nil if @in_fenced_block # Fenced blocks take precedence
-
-          input_length = input.length
-          line_end = input.index("\n", pos) || input_length
-          line_content = input[pos...line_end]
-          is_blank = line_content.match?(/\A\s*\z/)
-          has_code_indent = line_content.start_with?("    ") || line_content.start_with?("\t")
-
-          if @in_indented_block
-            if is_blank || has_code_indent
-              pos_after_line(line_end, input_length)
-            else
-              @in_indented_block = false
-              nil
-            end
-          elsif has_code_indent
-            @in_indented_block = true
-            pos_after_line(line_end, input_length)
-          end
-        end
-
-        # Check for inline code boundary
-        # @param input [String] the full input string
-        # @param pos [Integer] current position
-        # @return [Integer, nil] end position after inline code, or nil if not at boundary
-        def check_inline_boundary(input, pos)
-          return nil if @in_fenced_block || @in_indented_block
-          # No `pos >= input_length` guard: `input[input_length]` is nil,
-          # and `nil != "`"` is true so the next check returns nil anyway.
-          return nil if input[pos] != "`"
-
-          input_length = input.length
-          if @in_inline_code
-            try_close_inline(input, pos, input_length)
-          else
-            open_inline(input, pos, input_length)
-          end
-        end
-
-        private
-
-        # Skip up to 3 leading spaces of indentation.
-        def skip_leading_spaces(input, pos)
-          scan_pos = pos
-          spaces = 0
-          while spaces < 3 && input[scan_pos] == " "
-            spaces += 1
-            scan_pos += 1
-          end
-          scan_pos
-        end
-
-        # Count consecutive fence characters and return [count, new_position].
-        def count_fence_chars(input, scan_pos, fence_char, input_length)
-          fence_length = 0
-          while scan_pos < input_length && input[scan_pos] == fence_char
-            fence_length += 1
-            scan_pos += 1
-          end
-          [fence_length, scan_pos]
-        end
-
-        # Try to close an open fenced code block. Returns position after fence or nil.
-        def try_close_fence(input, scan_pos, fence_char, fence_length, input_length)
-          return nil unless fence_char == @fence_char && fence_length >= @fence_length
-
-          # Closing fence must be followed only by spaces then newline/EOF
-          scan_pos += 1 while scan_pos < input_length && input[scan_pos] == " "
-          return nil unless scan_pos >= input_length || input[scan_pos] == "\n"
-
-          # @fence_char / @fence_length are not reset here: they are only
-          # consulted while @in_fenced_block is true, and open_fence
-          # overwrites them on the next opening.
-          @in_fenced_block = false
-          pos_after_line(scan_pos, input_length)
-        end
-
-        # Open a new fenced code block. Returns position after the opening line.
-        def open_fence(input, scan_pos, fence_char, fence_length, input_length)
-          # Skip to end of line (info string)
-          scan_pos += 1 while scan_pos < input_length && input[scan_pos] != "\n"
-
-          @in_fenced_block = true
-          @fence_char = fence_char
-          @fence_length = fence_length
-          pos_after_line(scan_pos, input_length)
-        end
-
-        # Try to close inline code. Returns position after delimiter or nil.
-        def try_close_inline(input, pos, input_length)
-          delimiter_length = @inline_delimiter.length
-          return nil unless input[pos, delimiter_length] == @inline_delimiter
-
-          # Should not be followed by another backtick
-          next_pos = pos + delimiter_length
-          return nil if next_pos < input_length && input[next_pos] == "`"
-
-          # @inline_delimiter is not reset here: it is only consulted
-          # while @in_inline_code is true, and open_inline overwrites it
-          # on the next opening.
-          @in_inline_code = false
-          next_pos
-        end
-
-        # Open inline code. Returns position after opening delimiter.
-        def open_inline(input, pos, input_length)
-          delimiter_start = pos
-          pos += 1 while pos < input_length && input[pos] == "`"
-
-          @inline_delimiter = input[delimiter_start...pos]
-          @in_inline_code = true
-          pos
-        end
-
-        # Return position after a line (after newline if present, otherwise at end).
-        def pos_after_line(line_end, input_length)
-          line_end < input_length ? line_end + 1 : line_end
-        end
-
-        public
-
-        # Reset the tracker state. The @fence_char / @fence_length /
-        # @inline_delimiter companions are not cleared: they're only
-        # consulted while the corresponding in_* flag is true, and
-        # open_fence / open_inline overwrites them on the next
-        # opening (same pattern as try_close_fence / try_close_inline).
-        def reset!
-          @in_fenced_block = false
-          @in_indented_block = false
-          @in_inline_code = false
-        end
-      end
-    end
-  end
-end