markbridge 0.1.0 → 0.1.2

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

@@ -31,11 +31,12 @@ module Markbridge
 
         def initialize
           @in_fenced_block = false
-          @fence_char = nil
-          @fence_length = 0
           @in_indented_block = false
           @in_inline_code = false
-          @inline_delimiter = nil
+          # @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
@@ -52,55 +53,21 @@ 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)
+          # 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 == "~"
 
-          # 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 +83,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,42 +108,109 @@ 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] != "`"
+          # 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
-            # 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
+
+        # 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
 
-            # Return position after opening delimiter
-            pos
+        # 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
 
-        # Reset the tracker state
+        # 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
-          @fence_char = nil
-          @fence_length = 0
           @in_indented_block = false
           @in_inline_code = false
-          @inline_delimiter = nil
         end
       end
     end

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

@@ -38,17 +38,23 @@ module Markbridge
             !prev_char.match?(/\w/)
           end
 
-          # Helper to extract a word starting at position
+          WORD_PATTERN = /\A[\w\-]*/
+          private_constant :WORD_PATTERN
+
+          # Helper to extract a word starting at position. Caller must ensure
+          # pos is within input bounds (`pos <= input.length`).
           # @param input [String] the input string
           # @param pos [Integer] starting position
           # @return [String] the word (may be empty)
           def extract_word(input, pos)
-            word = +""
-            while pos < input.length && input[pos].match?(/[\w\-]/)
-              word << input[pos]
-              pos += 1
-            end
-            word
+            input[pos..].match(WORD_PATTERN)[0]
+          end
+
+          # Parse key="value" or key='value' attribute pairs from a string.
+          # @param attr_string [String] the attribute string to parse
+          # @return [Hash<String, String>] parsed attributes with downcased keys
+          def parse_attributes(attr_string)
+            attr_string.scan(/(\w+)=["']([^"']*)["']/).to_h.transform_keys(&:downcase)
           end
         end
       end

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

@@ -12,7 +12,7 @@ module Markbridge
         #   match = detector.detect(input, 0)
         #   match.node.name # => "Meeting"
         class Event < Base
-          OPEN_TAG_PATTERN = /\[event([^\]]*)\]/i
+          OPEN_TAG_PATTERN = /\[event(?<attrs>[^\]]*)\]/i
           CLOSE_TAG_PATTERN = %r{\[/event\]}i
 
           # Attempt to detect an event at the given position.
@@ -21,15 +21,14 @@ module Markbridge
           # @param pos [Integer] current position to check
           # @return [Match, nil] match result or nil if no match
           def detect(input, pos)
-            return nil unless input[pos] == "["
-
-            # Check for opening tag
             remaining = input[pos..]
             open_match = OPEN_TAG_PATTERN.match(remaining)
             return nil unless open_match&.begin(0)&.zero?
 
-            # Find closing tag
-            close_match = CLOSE_TAG_PATTERN.match(remaining, open_match.end(0))
+            # Find closing tag. The opening tag pattern forbids `]` between
+            # `[event` and its closing `]`, so `[/event]` cannot appear inside
+            # the opening tag - no need to skip past it.
+            close_match = CLOSE_TAG_PATTERN.match(remaining)
             return nil unless close_match
 
             # Extract raw content
@@ -37,15 +36,17 @@ module Markbridge
             raw = input[pos...end_pos]
 
             # Parse attributes from opening tag
-            attrs = parse_attributes(open_match[1])
+            attrs = parse_attributes(open_match[:attrs])
 
             # Validate required attributes
-            return nil unless attrs["name"] && attrs["start"]
+            name = attrs["name"]
+            starts_at = attrs["start"]
+            return nil if name.nil? || starts_at.nil?
 
             node =
               AST::Event.new(
-                name: attrs["name"],
-                starts_at: attrs["start"],
+                name:,
+                starts_at:,
                 ends_at: attrs["end"],
                 status: attrs["status"],
                 timezone: attrs["timezone"],
@@ -56,16 +57,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

@@ -12,8 +12,7 @@ module Markbridge
         #   match = detector.detect(input, 0)
         #   match.node.type # => "regular"
         class Poll < Base
-          OPEN_TAG_PATTERN = /\[poll([^\]]*)\]/i
-          CLOSE_TAG_PATTERN = %r{\[/poll\]}i
+          TAG_PATTERN = %r{\A\[poll(?<attrs>[^\]]*)\](?<content>.*?)\[/poll\]}im
 
           # Attempt to detect a poll at the given position.
           #
@@ -21,67 +20,30 @@ module Markbridge
           # @param pos [Integer] current position to check
           # @return [Match, nil] match result or nil if no match
           def detect(input, pos)
-            return nil unless input[pos] == "["
-
-            # Check for opening tag
-            remaining = input[pos..]
-            open_match = OPEN_TAG_PATTERN.match(remaining)
-            return nil unless open_match&.begin(0)&.zero?
-
-            # Find closing tag
-            close_match = CLOSE_TAG_PATTERN.match(remaining, open_match.end(0))
-            return nil unless close_match
-
-            # Extract raw content
-            end_pos = pos + close_match.end(0)
-            raw = input[pos...end_pos]
-
-            # Parse attributes from opening tag
-            attrs = parse_attributes(open_match[1])
-
-            # Extract options from content between tags
-            content = remaining[open_match.end(0)...close_match.begin(0)]
-            options = extract_options(content)
+            match = TAG_PATTERN.match(input[pos..])
+            return nil unless match
 
+            attrs = parse_attributes(match[:attrs])
             node =
               AST::Poll.new(
                 name: attrs["name"] || "poll",
                 type: attrs["type"],
                 results: attrs["results"],
                 public: attrs["public"] == "true",
-                chart_type: attrs["charttype"] || attrs["chartType"],
-                options:,
-                raw:,
+                chart_type: attrs["charttype"],
+                options: extract_options(match[:content]),
+                raw: match[0],
               )
 
-            Match.new(start_pos: pos, end_pos:, node:)
+            Match.new(start_pos: pos, end_pos: pos + match.end(0), node:)
           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
+          OPTION_PATTERN = /\A\s*(?:\*\s|-\s|\d+\.\s+)(?<value>.+?)\s*\z/
 
           def extract_options(content)
-            options = []
-            content.each_line do |line|
-              line = line.strip
-              if line.start_with?("* ")
-                options << line[2..].strip
-              elsif line.start_with?("- ")
-                options << line[2..].strip
-              elsif line.match?(/^\d+\.\s/)
-                options << line.sub(/^\d+\.\s*/, "").strip
-              end
-            end
-            options
+            content.each_line.filter_map { |line| OPTION_PATTERN.match(line)&.[](:value) }
           end
         end
       end

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

@@ -22,11 +22,18 @@ module Markbridge
         #   match = detector.detect(input, 0)
         #   match.node.type # => :attachment
         class Upload < Base
-          # Pattern for image: ![alt|dimensions](upload://sha1.ext)
-          IMAGE_PATTERN = %r{!\[([^\]]*)\]\(upload://([^)]+)\)}
-
-          # Pattern for attachment: [filename|attachment](upload://sha1.ext) followed by optional (size)
-          ATTACHMENT_PATTERN = %r{\[([^\]]*\|attachment)\]\(upload://([^)]+)\)(\s*\([^)]+\))?}
+          # Image: ![alt|dimensions](upload://sha1.ext)
+          IMAGE_PATTERN =
+            %r{\A!\[(?<alt>[^|\]]*)(?:\|(?<dimensions>[^\]]*))?\]\(upload://(?<url>[^)]+)\)}
+
+          # Attachment: [filename|attachment](upload://sha1.ext) (size)
+          ATTACHMENT_PATTERN =
+            %r{
+            \A
+            \[(?<filename>[^|\]]*)\|attachment\]
+            \(upload://(?<url>[^)]+)\)
+            (?:\s*\((?<size>[^)]+)\))?
+          }xi
 
           # Attempt to detect an upload at the given position.
           #
@@ -34,14 +41,11 @@ module Markbridge
           # @param pos [Integer] current position to check
           # @return [Match, nil] match result or nil if no match
           def detect(input, pos)
-            char = input[pos]
-            return nil unless char == "!" || char == "["
-
             remaining = input[pos..]
-
-            if char == "!"
+            case input[pos]
+            when "!"
               detect_image(remaining, pos)
-            else
+            when "["
               detect_attachment(remaining, pos)
             end
           end
@@ -50,71 +54,42 @@ module Markbridge
 
           def detect_image(remaining, pos)
             match = IMAGE_PATTERN.match(remaining)
-            return nil unless match&.begin(0)&.zero?
-
-            raw = match[0]
-            alt_part = match[1]
-            url_part = match[2]
+            return nil unless match
 
-            # Parse alt and dimensions from "alt|dimensions" format
-            alt, dimensions = parse_alt_dimensions(alt_part)
+            sha1, filename = parse_upload_url(match[:url])
+            alt = match[:alt]
+            alt = nil if alt.empty?
 
-            # Extract SHA1 and filename from URL
-            sha1, filename = parse_upload_url(url_part)
+            # `type: :image` is omitted because it is AST::Upload's default -
+            # passing it explicitly was an equivalent-mutation surface.
+            node =
+              AST::Upload.new(sha1:, filename:, alt:, dimensions: match[:dimensions], raw: match[0])
 
-            node = AST::Upload.new(sha1:, filename:, type: :image, alt:, dimensions:, raw:)
-
-            Match.new(start_pos: pos, end_pos: pos + raw.length, node:)
+            Match.new(start_pos: pos, end_pos: pos + match[0].length, node:)
           end
 
           def detect_attachment(remaining, pos)
             match = ATTACHMENT_PATTERN.match(remaining)
-            return nil unless match&.begin(0)&.zero?
-
-            raw = match[0]
-            name_part = match[1]
-            url_part = match[2]
-            size_part = match[3]
-
-            # Parse filename from "filename|attachment" format
-            filename = name_part.sub(/\|attachment$/i, "")
+            return nil unless match
 
-            # Extract SHA1 from URL
-            sha1, _url_filename = parse_upload_url(url_part)
+            sha1, = parse_upload_url(match[:url])
 
-            # Parse size if present
-            size = size_part&.strip&.delete_prefix("(")&.delete_suffix(")")
+            node =
+              AST::Upload.new(
+                sha1:,
+                filename: match[:filename],
+                type: :attachment,
+                size: match[:size],
+                raw: match[0],
+              )
 
-            node = AST::Upload.new(sha1:, filename:, type: :attachment, size:, raw:)
-
-            Match.new(start_pos: pos, end_pos: pos + raw.length, node:)
-          end
-
-          def parse_alt_dimensions(alt_part)
-            return nil, nil if alt_part.nil? || alt_part.empty?
-
-            if alt_part.include?("|")
-              parts = alt_part.split("|", 2)
-              alt = parts[0].empty? ? nil : parts[0]
-              dimensions = parts[1]
-              [alt, dimensions]
-            else
-              [alt_part, nil]
-            end
+            Match.new(start_pos: pos, end_pos: pos + match[0].length, node:)
           end
 
+          # URL format: sha1.ext or just sha1. Returns [sha1, filename-or-nil].
           def parse_upload_url(url_part)
-            # URL format: sha1.ext or just sha1
-            if url_part.include?(".")
-              parts = url_part.split(".", 2)
-              sha1 = parts[0]
-              filename = url_part
-            else
-              sha1 = url_part
-              filename = nil
-            end
-
-            [sha1, filename]
+            sha1, _, ext = url_part.partition(".")
+            [sha1, ext.empty? ? nil : url_part]
           end
         end
       end