markbridge 0.1.0 → 0.1.2

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

@@ -49,6 +49,8 @@ module Markbridge
         def initialize(detectors: DEFAULT_DETECTORS, tag_library: nil, mention_resolver: nil)
           @detector_instances = build_detectors(detectors, mention_resolver)
           @tag_library = tag_library
+          # @code_tracker / @result / @nodes / @node_index / @pos / @input /
+          # @line_start are set by #scan before use; no defensive init needed.
         end
 
         # Scan input and extract constructs.
@@ -56,14 +58,12 @@ module Markbridge
         # @param input [String] Discourse Markdown input
         # @return [ScanResult] result containing processed markdown and extracted nodes
         def scan(input)
-          return ScanResult.new(markdown: "", nodes: []) if input.nil? || input.empty?
-
           @code_tracker = CodeBlockTracker.new
           @result = +""
           @nodes = []
           @node_index = 0
           @pos = 0
-          @input = input
+          @input = input.to_s
           @line_start = true
 
           scan_input
@@ -75,14 +75,10 @@ module Markbridge
 
         def build_detectors(detectors, mention_resolver)
           detectors.map do |klass|
-            if klass.is_a?(Class)
-              if klass == Detectors::Mention && mention_resolver
-                klass.new(type_resolver: mention_resolver)
-              else
-                klass.new
-              end
+            if klass == Detectors::Mention
+              klass.new(type_resolver: mention_resolver)
             else
-              klass
+              klass.new
             end
           end
         end
@@ -91,27 +87,14 @@ module Markbridge
           while @pos < @input.length
             # Check for fenced code block boundary at line start
             if @line_start
-              new_pos = @code_tracker.check_fenced_boundary(@input, @pos, line_start: true)
-              if new_pos
-                @result << @input[@pos...new_pos]
-                @pos = new_pos
-                @line_start = new_pos > 0 && @input[new_pos - 1] == "\n"
-                next
-              end
-
-              # Check for indented code block (4+ spaces or tab)
-              new_pos = @code_tracker.check_indented_boundary(@input, @pos, line_start: true)
-              if new_pos
-                @result << @input[@pos...new_pos]
-                @pos = new_pos
-                @line_start = new_pos > 0 && @input[new_pos - 1] == "\n"
-                next
-              end
+              next if advance_code_boundary(:check_fenced_boundary)
+              next if advance_code_boundary(:check_indented_boundary)
             end
 
-            # Check for inline code boundary
-            if @input[@pos] == "`" && !@code_tracker.in_fenced_block &&
-                 !@code_tracker.in_indented_block
+            # Check for inline code boundary. check_inline_boundary's
+            # own fenced/indented guard means we don't need to pre-check
+            # here — it'll just return nil in those cases.
+            if @input[@pos] == "`"
               new_pos = @code_tracker.check_inline_boundary(@input, @pos)
               if new_pos
                 @result << @input[@pos...new_pos]
@@ -145,6 +128,22 @@ module Markbridge
           end
         end
 
+        def advance_code_boundary(method)
+          new_pos = @code_tracker.public_send(method, @input, @pos, line_start: true)
+          return false unless new_pos
+
+          # check_fenced_boundary / check_indented_boundary always stop
+          # at pos_after_line, which is either after a "\n" or at EOF.
+          # After-newline → @line_start should be true; at EOF the
+          # outer `while @pos < @input.length` exits and @line_start
+          # is unobservable. Setting true unconditionally drops the
+          # `@input[new_pos - 1] == "\n"` dance.
+          @result << @input[@pos...new_pos]
+          @pos = new_pos
+          @line_start = true
+          true
+        end
+
         def detect_at_position
           @detector_instances.each do |detector|
             match = detector.detect(@input, @pos)
@@ -156,26 +155,24 @@ module Markbridge
         def handle_match(match)
           node = match.node
           @nodes << node
+          @result << render_placeholder(node)
 
-          # Render placeholder using tag library if available
-          placeholder = render_placeholder(node)
-          @result << placeholder
-
+          # Every detector shipped today matches content that ends on a
+          # non-newline byte (`]`, `)`, `_`, alphanumeric), so @line_start
+          # is always false after a successful match. If a future custom
+          # detector produces a match whose end_pos sits right after
+          # "\n", re-introduce the `@input[@pos - 1] == "\n"` check.
           @pos = match.end_pos
-          @line_start = @pos > 0 && @input[@pos - 1] == "\n"
+          @line_start = false
           @node_index += 1
         end
 
         def render_placeholder(node)
           if @tag_library
             tag = @tag_library[node.class]
-            if tag
-              # Create a minimal interface for rendering
-              return tag.render(node, nil)
-            end
+            return tag.render(node, nil) if tag
           end
 
-          # Default placeholder format if no tag library or tag not found
           default_placeholder(node)
         end
 
@@ -189,8 +186,6 @@ module Markbridge
             "<<EVENT:#{@node_index}:#{node.name}>>"
           when AST::Upload
             "<<UPLOAD:#{@node_index}:#{node.sha1}>>"
-          else
-            "<<UNKNOWN:#{@node_index}>>"
           end
         end
       end

data/lib/markbridge/renderers/discourse/builders/list_item_builder.rb

@@ -15,12 +15,10 @@ module Markbridge
           # @return [String]
           def build(content, marker:, indent:)
             lines = content.split("\n")
-            lines = [""] if lines.empty? # Handle empty content
             first_line = "#{indent}#{marker}#{lines.first}"
 
-            return "#{first_line}\n" if lines.size == 1
+            return "#{first_line}\n" if lines.size < 2
 
-            # Handle multi-line content with sophisticated blank line handling
             format_multiline(lines, first_line, indent)
           end
 
@@ -63,15 +61,17 @@ module Markbridge
             end
           end
 
-          # Handle empty lines in continuation
+          # Handle empty lines in continuation. Caller (format_continuation_line)
+          # only invokes this when `line.empty?`, and `content.split("\n")`
+          # trims trailing empty strings, so the LAST continuation line is
+          # never empty — `idx + 1` is always in bounds when we get here.
           # @param idx [Integer] index in continuation_lines
           # @param continuation_lines [Array<String>] all continuation lines
           # @param continuation_indent [String] indent for continuation
           # @return [String, nil] formatted line or nil to skip
           def handle_empty_line(idx, continuation_lines, continuation_indent)
             # Skip empty lines that come before nested list items (structural blanks)
-            next_line = continuation_lines[idx + 1]
-            return nil if next_line&.match?(/\A\s*(?:-|\d+\.)\s/)
+            return nil if continuation_lines[idx + 1].match?(/\A\s*(?:-|\d+\.)\s/)
 
             # Preserve empty lines within text content (paragraph breaks) with indentation
             continuation_indent

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "cgi"
+
+module Markbridge
+  module Renderers
+    module Discourse
+      # Escapes text for safe inclusion in HTML output. Used when rendering
+      # content inside a CommonMark HTML block (e.g. TableTag's fallback)
+      # where Markdown-level escaping would not be applied.
+      class HtmlEscaper
+        # @param text [String, nil]
+        # @return [String]
+        def self.escape(text)
+          CGI.escapeHTML(text || "")
+        end
+      end
+    end
+  end
+end