markbridge 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1f501e9875d69ca60aa8fcf7d1e46ef5ce83d24b69da46b192121e00b7414919
-  data.tar.gz: db9a49e5d6b0c0c5f68f84109c153f619e59d1b07fbb5e695a6443ed099b1436
+  metadata.gz: 0cee12c41cea526db53cf389e2cc2bc49310568c0ebe9979d03daa7a4c2d23ac
+  data.tar.gz: a6d541954eea2357b6bb31bcfb685a634383de405dd1f505b257c78007e087d4
 SHA512:
-  metadata.gz: 1f5b7bac5d2ee008db7a012040de5394a615811420fcd90a8a95064349a2cf074254c3310dffb27e93f7d0c51c06f47c16b1f361015a9fad61e8fb14380c0a19
-  data.tar.gz: de4b3625ef287981cec8a5c6683ccbbf88d7593af0cd5ca7798393f377dc930a20f3f1228b225d49880f5f0323ccfa8bb7957186b644cbefd55770e153948ade
+  metadata.gz: b7ddd72dd5d0aa197a7b2477f1bfddd72e9cf7a01f26b4def8da341c8edd739503c04a23a501175adbcc23e23064578a2a4bcb17f3518b543f2716059636e3e7
+  data.tar.gz: 409dcbed4de6b6551c420ca51a00ed998abf11aeac8bd3bce9522b49a5ca07d3e524d68737b9461ddb6e3949485c1c84123c30c8e6e44cb57d7a99d873c7c3af

data/lib/markbridge/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Markbridge
-  VERSION = "0.2.0"
+  VERSION = "0.2.1"
 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.2.1
 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

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

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

@@ -1,194 +0,0 @@
-# frozen_string_literal: true
-
-module Markbridge
-  module Processors
-    module DiscourseMarkdown
-      # Result of scanning Discourse Markdown
-      # @attr_reader markdown [String] the processed markdown with placeholders
-      # @attr_reader nodes [Array<AST::Node>] extracted AST nodes in order of appearance
-      ScanResult = Data.define(:markdown, :nodes)
-
-      # Single-pass scanner for Discourse Markdown that extracts specific constructs
-      # (mentions, polls, events, uploads) while preserving all other content unchanged.
-      #
-      # The scanner respects code blocks (fenced, indented, and inline) and will not
-      # extract constructs that appear within code.
-      #
-      # @example Basic usage
-      #   scanner = Scanner.new
-      #   result = scanner.scan("Hello @gerhard!")
-      #   result.nodes.first # => AST::Mention
-      #
-      # @example With custom tag library for rendering
-      #   scanner = Scanner.new(tag_library: my_library)
-      #   result = scanner.scan(input)
-      #   result.markdown # => "Hello <<MENTION:1>>!"
-      #
-      # @example With mention type resolver
-      #   scanner = Scanner.new(mention_resolver: ->(name) {
-      #     groups.include?(name) ? :group : :user
-      #   })
-      #   result = scanner.scan("@Testers and @gerhard")
-      #   result.nodes[0].type # => :group
-      #   result.nodes[1].type # => :user
-      class Scanner
-        # Default detectors in priority order
-        DEFAULT_DETECTORS = [
-          Detectors::Poll,
-          Detectors::Event,
-          Detectors::Upload,
-          Detectors::Mention,
-        ].freeze
-
-        # Characters that can start a construct (for fast bailout)
-        TRIGGER_CHARS = Set.new(["@", "[", "!"]).freeze
-
-        # @param detectors [Array<Class>] detector classes to use (instantiated automatically)
-        # @param tag_library [Renderers::Discourse::TagLibrary, nil] tag library for rendering placeholders
-        # @param mention_resolver [#call, nil] callable that takes a name and returns :user or :group
-        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.
-        #
-        # @param input [String] Discourse Markdown input
-        # @return [ScanResult] result containing processed markdown and extracted nodes
-        def scan(input)
-          @code_tracker = CodeBlockTracker.new
-          @result = +""
-          @nodes = []
-          @node_index = 0
-          @pos = 0
-          @input = input.to_s
-          @line_start = true
-
-          scan_input
-
-          ScanResult.new(markdown: @result, nodes: @nodes)
-        end
-
-        private
-
-        def build_detectors(detectors, mention_resolver)
-          detectors.map do |klass|
-            if klass == Detectors::Mention
-              klass.new(type_resolver: mention_resolver)
-            else
-              klass.new
-            end
-          end
-        end
-
-        def scan_input
-          while @pos < @input.length
-            # Check for fenced code block boundary at line start
-            if @line_start
-              next if advance_code_boundary(:check_fenced_boundary)
-              next if advance_code_boundary(:check_indented_boundary)
-            end
-
-            # 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]
-                @pos = new_pos
-                @line_start = false
-                next
-              end
-            end
-
-            # If in code, pass through unchanged
-            if @code_tracker.in_code?
-              @result << @input[@pos]
-              @line_start = @input[@pos] == "\n"
-              @pos += 1
-              next
-            end
-
-            # Fast path: only try detectors if current char could start a construct
-            char = @input[@pos]
-            if TRIGGER_CHARS.include?(char)
-              match = detect_at_position
-              if match
-                handle_match(match)
-                next
-              end
-            end
-
-            @result << char
-            @line_start = char == "\n"
-            @pos += 1
-          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)
-            return match if match
-          end
-          nil
-        end
-
-        def handle_match(match)
-          node = match.node
-          @nodes << node
-          @result << render_placeholder(node)
-
-          # 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 = false
-          @node_index += 1
-        end
-
-        def render_placeholder(node)
-          if @tag_library
-            tag = @tag_library[node.class]
-            return tag.render(node, nil) if tag
-          end
-
-          default_placeholder(node)
-        end
-
-        def default_placeholder(node)
-          case node
-          when AST::Mention
-            "<<MENTION:#{@node_index}:#{node.name}>>"
-          when AST::Poll
-            "<<POLL:#{@node_index}:#{node.name}>>"
-          when AST::Event
-            "<<EVENT:#{@node_index}:#{node.name}>>"
-          when AST::Upload
-            "<<UPLOAD:#{@node_index}:#{node.sha1}>>"
-          end
-        end
-      end
-    end
-  end
-end

data/lib/markbridge/processors/discourse_markdown.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "discourse_markdown/code_block_tracker"
-require_relative "discourse_markdown/detectors/base"
-require_relative "discourse_markdown/detectors/mention"
-require_relative "discourse_markdown/detectors/poll"
-require_relative "discourse_markdown/detectors/event"
-require_relative "discourse_markdown/detectors/upload"
-require_relative "discourse_markdown/scanner"
-
-module Markbridge
-  module Processors
-    module DiscourseMarkdown
-    end
-  end
-end

data/lib/markbridge/processors.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "processors/discourse_markdown"
-
-module Markbridge
-  module Processors
-  end
-end