markbridge 0.1.3 → 0.2.1

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

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

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-module Markbridge
-  module Processors
-    module DiscourseMarkdown
-      module Detectors
-        # Result of a successful detection
-        # @attr_reader start_pos [Integer] start position in input
-        # @attr_reader end_pos [Integer] end position in input (exclusive)
-        # @attr_reader node [AST::Node] the AST node representing the detected construct
-        Match = Data.define(:start_pos, :end_pos, :node)
-
-        # Base class for construct detectors.
-        # Subclasses implement detection logic for specific constructs
-        # (mentions, polls, events, uploads).
-        #
-        # @abstract Subclass and implement {#detect}
-        class Base
-          # Attempt to detect a construct at the given position.
-          #
-          # @param input [String] the full input string
-          # @param pos [Integer] current position to check
-          # @return [Match, nil] match result or nil if no match
-          def detect(input, pos)
-            raise NotImplementedError, "#{self.class} must implement #detect"
-          end
-
-          private
-
-          # Helper to check if position is at a word boundary (for mentions, etc.)
-          # @param input [String] the input string
-          # @param pos [Integer] position to check
-          # @return [Boolean] true if at word boundary
-          def word_boundary?(input, pos)
-            return true if pos == 0
-
-            prev_char = input[pos - 1]
-            !prev_char.match?(/\w/)
-          end
-
-          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)
-            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
-    end
-  end
-end

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

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-module Markbridge
-  module Processors
-    module DiscourseMarkdown
-      module Detectors
-        # Detects Discourse event blocks [event]...[/event].
-        #
-        # @example
-        #   detector = Event.new
-        #   input = '[event name="Meeting" start="2025-12-15 14:00"][/event]'
-        #   match = detector.detect(input, 0)
-        #   match.node.name # => "Meeting"
-        class Event < Base
-          OPEN_TAG_PATTERN = /\[event(?<attrs>[^\]]*)\]/i
-          CLOSE_TAG_PATTERN = %r{\[/event\]}i
-
-          # Attempt to detect an event at the given position.
-          #
-          # @param input [String] the full input string
-          # @param pos [Integer] current position to check
-          # @return [Match, nil] match result or nil if no match
-          def detect(input, pos)
-            remaining = input[pos..]
-            open_match = OPEN_TAG_PATTERN.match(remaining)
-            return nil unless open_match&.begin(0)&.zero?
-
-            # 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
-            end_pos = pos + close_match.end(0)
-            raw = input[pos...end_pos]
-
-            # Parse attributes from opening tag
-            attrs = parse_attributes(open_match[:attrs])
-
-            # Validate required attributes
-            name = attrs["name"]
-            starts_at = attrs["start"]
-            return nil if name.nil? || starts_at.nil?
-
-            node =
-              AST::Event.new(
-                name:,
-                starts_at:,
-                ends_at: attrs["end"],
-                status: attrs["status"],
-                timezone: attrs["timezone"],
-                raw:,
-              )
-
-            Match.new(start_pos: pos, end_pos:, node:)
-          end
-
-          private
-        end
-      end
-    end
-  end
-end

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

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-module Markbridge
-  module Processors
-    module DiscourseMarkdown
-      module Detectors
-        # Detects user and group mentions (@username, @groupname).
-        #
-        # @example Basic usage
-        #   detector = Mention.new
-        #   match = detector.detect("Hello @gerhard!", 6)
-        #   match.node.name # => "gerhard"
-        #   match.node.type # => :user (default)
-        #
-        # @example With type resolver
-        #   resolver = ->(name) { name == "Testers" ? :group : :user }
-        #   detector = Mention.new(type_resolver: resolver)
-        #   match = detector.detect("@Testers", 0)
-        #   match.node.type # => :group
-        class Mention < Base
-          # @param type_resolver [#call, nil] callable that takes a name and returns :user or :group
-          def initialize(type_resolver: nil)
-            @type_resolver = type_resolver
-          end
-
-          # Attempt to detect a mention at the given position.
-          #
-          # @param input [String] the full input string
-          # @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] == "@"
-            return nil unless word_boundary?(input, pos)
-
-            # Extract the username/group name
-            name = extract_word(input, pos + 1)
-            return nil if name.empty?
-
-            end_pos = pos + 1 + name.length
-            type = resolve_type(name)
-            node = AST::Mention.new(name:, type:)
-
-            Match.new(start_pos: pos, end_pos:, node:)
-          end
-
-          private
-
-          def resolve_type(name)
-            return :user unless @type_resolver
-
-            @type_resolver.call(name) || :user
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module Markbridge
-  module Processors
-    module DiscourseMarkdown
-      module Detectors
-        # Detects Discourse poll blocks [poll]...[/poll].
-        #
-        # @example
-        #   detector = Poll.new
-        #   input = "[poll type=\"regular\"]\n* A\n* B\n[/poll]"
-        #   match = detector.detect(input, 0)
-        #   match.node.type # => "regular"
-        class Poll < Base
-          TAG_PATTERN = %r{\A\[poll(?<attrs>[^\]]*)\](?<content>.*?)\[/poll\]}im
-
-          # Attempt to detect a poll at the given position.
-          #
-          # @param input [String] the full input string
-          # @param pos [Integer] current position to check
-          # @return [Match, nil] match result or nil if no match
-          def detect(input, pos)
-            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"],
-                options: extract_options(match[:content]),
-                raw: match[0],
-              )
-
-            Match.new(start_pos: pos, end_pos: pos + match.end(0), node:)
-          end
-
-          private
-
-          OPTION_PATTERN = /\A\s*(?:\*\s|-\s|\d+\.\s+)(?<value>.+?)\s*\z/
-
-          def extract_options(content)
-            content.each_line.filter_map { |line| OPTION_PATTERN.match(line)&.[](:value) }
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,98 +0,0 @@
-# frozen_string_literal: true
-
-module Markbridge
-  module Processors
-    module DiscourseMarkdown
-      module Detectors
-        # Detects Discourse upload references using upload:// URLs.
-        #
-        # Supports two formats:
-        # - Images: ![alt|dimensions](upload://sha1.ext)
-        # - Attachments: [filename|attachment](upload://sha1.ext) (size)
-        #
-        # @example Image
-        #   detector = Upload.new
-        #   input = "![logo|64x64](upload://abc123.png)"
-        #   match = detector.detect(input, 0)
-        #   match.node.type # => :image
-        #
-        # @example Attachment
-        #   detector = Upload.new
-        #   input = "[doc.pdf|attachment](upload://xyz789.pdf) (1.2 MB)"
-        #   match = detector.detect(input, 0)
-        #   match.node.type # => :attachment
-        class Upload < Base
-          # 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.
-          #
-          # @param input [String] the full input string
-          # @param pos [Integer] current position to check
-          # @return [Match, nil] match result or nil if no match
-          def detect(input, pos)
-            remaining = input[pos..]
-            case input[pos]
-            when "!"
-              detect_image(remaining, pos)
-            when "["
-              detect_attachment(remaining, pos)
-            end
-          end
-
-          private
-
-          def detect_image(remaining, pos)
-            match = IMAGE_PATTERN.match(remaining)
-            return nil unless match
-
-            sha1, filename = parse_upload_url(match[:url])
-            alt = match[:alt]
-            alt = nil if alt.empty?
-
-            # `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])
-
-            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
-
-            sha1, = parse_upload_url(match[:url])
-
-            node =
-              AST::Upload.new(
-                sha1:,
-                filename: match[:filename],
-                type: :attachment,
-                size: match[:size],
-                raw: match[0],
-              )
-
-            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)
-            sha1, _, ext = url_part.partition(".")
-            [sha1, ext.empty? ? nil : url_part]
-          end
-        end
-      end
-    end
-  end
-end