markbridge 0.1.0 → 0.1.1

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

@@ -52,55 +52,20 @@ module Markbridge
         def check_fenced_boundary(input, pos, line_start:)
           return nil unless line_start
 
-          # Skip up to 3 spaces of indentation
-          scan_pos = pos
-          spaces = 0
-          while spaces < 3 && scan_pos < input.length && input[scan_pos] == " "
-            spaces += 1
-            scan_pos += 1
-          end
-
-          return nil if scan_pos >= input.length
+          input_length = input.length
+          scan_pos = skip_leading_spaces(input, pos, input_length)
+          return nil if scan_pos >= input_length
 
           fence_char = input[scan_pos]
           return nil unless fence_char == "`" || fence_char == "~"
 
-          # Count consecutive fence characters
-          fence_start = scan_pos
-          fence_length = 0
-          while scan_pos < input.length && input[scan_pos] == fence_char
-            fence_length += 1
-            scan_pos += 1
-          end
-
+          fence_length, scan_pos = count_fence_chars(input, scan_pos, fence_char, input_length)
           return nil if fence_length < 3
 
           if @in_fenced_block
-            # Check if this closes the current block
-            if fence_char == @fence_char && fence_length >= @fence_length
-              # Closing fence - must be followed by newline or end of input
-              # Skip any trailing whitespace
-              scan_pos += 1 while scan_pos < input.length && input[scan_pos] == " "
-
-              if scan_pos >= input.length || input[scan_pos] == "\n"
-                @in_fenced_block = false
-                @fence_char = nil
-                @fence_length = 0
-                # Return position after the newline if present
-                return scan_pos < input.length ? scan_pos + 1 : scan_pos
-              end
-            end
-            nil
+            try_close_fence(input, scan_pos, fence_char, fence_length, input_length)
           else
-            # Opening fence - 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
-
-            # Return position after the newline if present
-            scan_pos < input.length ? scan_pos + 1 : scan_pos
+            open_fence(input, scan_pos, fence_char, fence_length, input_length)
           end
         end
 
@@ -116,38 +81,23 @@ module Markbridge
           return nil unless line_start
           return nil if @in_fenced_block # Fenced blocks take precedence
 
-          # Find end of line
-          line_end = input.index("\n", pos) || input.length
-
-          # Check if line is blank
+          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/)
-
-          # Check indentation (4+ spaces or tab)
           has_code_indent = line_content.start_with?("    ") || line_content.start_with?("\t")
 
           if @in_indented_block
-            if is_blank
-              # Blank lines continue the indented block
-              # Return end of line (after newline if present)
-              return line_end < input.length ? line_end + 1 : line_end
-            elsif has_code_indent
-              # Still in indented code
-              return line_end < input.length ? line_end + 1 : line_end
+            if is_blank || has_code_indent
+              pos_after_line(line_end, input_length)
             else
-              # Non-blank, non-indented line ends the block
               @in_indented_block = false
-              return nil
-            end
-          else
-            if has_code_indent
-              # Start of indented code block
-              @in_indented_block = true
-              return line_end < input.length ? line_end + 1 : line_end
+              nil
             end
+          elsif has_code_indent
+            @in_indented_block = true
+            pos_after_line(line_end, input_length)
           end
-
-          nil
         end
 
         # Check for inline code boundary
@@ -156,34 +106,96 @@ module Markbridge
         # @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
-          return nil if pos >= input.length || input[pos] != "`"
+
+          input_length = input.length
+          return nil if pos >= input_length || input[pos] != "`"
 
           if @in_inline_code
-            # Check if this closes the current inline code
-            delimiter_length = @inline_delimiter.length
-            if input[pos, delimiter_length] == @inline_delimiter
-              # Check what follows - should not be another backtick
-              next_pos = pos + delimiter_length
-              if next_pos >= input.length || input[next_pos] != "`"
-                @in_inline_code = false
-                @inline_delimiter = nil
-                return next_pos
-              end
-            end
-            nil
+            try_close_inline(input, pos, input_length)
           else
-            # Opening inline code - count backticks
-            delimiter_start = pos
-            pos += 1 while pos < input.length && input[pos] == "`"
+            open_inline(input, pos, input_length)
+          end
+        end
 
-            @inline_delimiter = input[delimiter_start...pos]
-            @in_inline_code = true
+        private
 
-            # Return position after opening delimiter
-            pos
+        # Skip up to 3 leading spaces of indentation.
+        def skip_leading_spaces(input, pos, input_length)
+          scan_pos = pos
+          spaces = 0
+          while spaces < 3 && scan_pos < input_length && 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"
+
+          @in_fenced_block = false
+          @fence_char = nil
+          @fence_length = 0
+          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] == "`"
+
+          @in_inline_code = false
+          @inline_delimiter = nil
+          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
         def reset!
           @in_fenced_block = false

data/lib/markbridge/processors/discourse_markdown/detectors/base.rb

@@ -50,6 +50,18 @@ module Markbridge
             end
             word
           end
+
+          # Parse key="value" or key='value' attribute pairs from a string
+          # @param attr_string [String, nil] the attribute string to parse
+          # @return [Hash<String, String>] parsed attributes with downcased keys
+          def parse_attributes(attr_string)
+            attrs = {}
+            return attrs if attr_string.nil? || attr_string.empty?
+
+            attr_string.scan(/(\w+)=["']([^"']*)["']/) { |key, value| attrs[key.downcase] = value }
+
+            attrs
+          end
         end
       end
     end

data/lib/markbridge/processors/discourse_markdown/detectors/event.rb

@@ -56,16 +56,6 @@ module Markbridge
           end
 
           private
-
-          def parse_attributes(attr_string)
-            attrs = {}
-            return attrs if attr_string.nil? || attr_string.empty?
-
-            # Match key="value" or key='value' patterns
-            attr_string.scan(/(\w+)=["']([^"']*)["']/) { |key, value| attrs[key.downcase] = value }
-
-            attrs
-          end
         end
       end
     end

data/lib/markbridge/processors/discourse_markdown/detectors/poll.rb

@@ -59,16 +59,6 @@ module Markbridge
 
           private
 
-          def parse_attributes(attr_string)
-            attrs = {}
-            return attrs if attr_string.nil? || attr_string.empty?
-
-            # Match key="value" or key='value' patterns
-            attr_string.scan(/(\w+)=["']([^"']*)["']/) { |key, value| attrs[key.downcase] = value }
-
-            attrs
-          end
-
           def extract_options(content)
             options = []
             content.each_line do |line|

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

@@ -49,6 +49,13 @@ 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 = nil
+          @result = nil
+          @nodes = nil
+          @node_index = 0
+          @pos = 0
+          @input = nil
+          @line_start = true
         end
 
         # Scan input and extract constructs.
@@ -91,22 +98,8 @@ 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
@@ -145,6 +138,16 @@ 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
+
+          @result << @input[@pos...new_pos]
+          @pos = new_pos
+          @line_start = new_pos > 0 && @input[new_pos - 1] == "\n"
+          true
+        end
+
         def detect_at_position
           @detector_instances.each do |detector|
             match = detector.detect(@input, @pos)