markbridge 0.1.0

data/lib/markbridge/parsers/text_formatter/handlers/quote_handler.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Parsers
+    module TextFormatter
+      module Handlers
+        # Handler for QUOTE elements in s9e/TextFormatter XML
+        class QuoteHandler < BaseHandler
+          def initialize
+            @element_class = AST::Quote
+          end
+
+          def process(element:, parent:)
+            attrs = extract_attributes(element)
+            node =
+              AST::Quote.new(
+                author: attrs[:author],
+                post: attrs[:post_id] || attrs[:post],
+                topic: attrs[:topic_id] || attrs[:topic],
+                username: attrs[:username],
+              )
+            parent << node
+
+            # Return node to signal: process children into this node
+            node
+          end
+
+          attr_reader :element_class
+        end
+      end
+    end
+  end
+end

data/lib/markbridge/parsers/text_formatter/handlers/simple_handler.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Parsers
+    module TextFormatter
+      module Handlers
+        # Handler for simple XML elements that don't require attributes
+        #
+        # This handler creates an AST node of the specified class and processes
+        # all child elements. Use this for simple formatting tags like B, I, U, S.
+        #
+        # @example
+        #   handler = SimpleHandler.new(AST::Bold)
+        #   registry.register("B", handler)
+        class SimpleHandler < BaseHandler
+          # @param element_class [Class] the AST node class to instantiate
+          def initialize(element_class)
+            @element_class = element_class
+          end
+
+          # Process the element by creating an AST node and processing children
+          # @param element [Nokogiri::XML::Element]
+          # @param parent [AST::Element]
+          def process(element:, parent:)
+            node = @element_class.new
+            parent << node
+
+            # Return node to signal: process children into this node
+            node
+          end
+
+          attr_reader :element_class
+        end
+      end
+    end
+  end
+end

data/lib/markbridge/parsers/text_formatter/handlers/url_handler.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Parsers
+    module TextFormatter
+      module Handlers
+        # Handler for URL elements in s9e/TextFormatter XML
+        #
+        # Extracts the url attribute and creates an AST::Url node
+        class UrlHandler < BaseHandler
+          def initialize
+            @element_class = AST::Url
+          end
+
+          def process(element:, parent:)
+            attrs = extract_attributes(element)
+            node = AST::Url.new(href: attrs[:url])
+            parent << node
+
+            # Return node to signal: process children into this node
+            node
+          end
+
+          attr_reader :element_class
+        end
+      end
+    end
+  end
+end

data/lib/markbridge/parsers/text_formatter/parser.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Parsers
+    module TextFormatter
+      # Parses s9e/TextFormatter XML format into an AST
+      #
+      # The s9e/TextFormatter library (https://github.com/s9e/TextFormatter) stores BBCode as XML:
+      # - Plain text: <t>text content</t>
+      # - Rich text: <r><B>bold</B> <URL url="...">link</URL></r>
+      # - Markup preservation: <s> and <e> elements (ignored during parsing)
+      #
+      # This format is used by phpBB 3.2+ and other forum software.
+      #
+      # Requires Nokogiri gem to be installed. Add to your Gemfile:
+      #   gem "nokogiri"
+      class Parser
+        attr_reader :unknown_tags
+
+        # Create a new parser with optional custom handler registry
+        # @param handlers [HandlerRegistry, nil] custom handler registry, defaults to HandlerRegistry.default
+        # @yield [HandlerRegistry] optional block to customize the default registry
+        # @example Using default mappings
+        #   parser = Parser.new
+        # @example Using custom registry
+        #   parser = Parser.new(handlers: my_registry)
+        # @example Customizing default mappings
+        #   parser = Parser.new do |registry|
+        #     registry.register("CUSTOM", MyCustomHandler.new)
+        #   end
+        def initialize(handlers: nil, &block)
+          @handlers =
+            if block_given?
+              HandlerRegistry.build_from_default(&block)
+            else
+              handlers || HandlerRegistry.default
+            end
+          @unknown_tags = Hash.new(0)
+        end
+
+        # Parse s9e/TextFormatter XML into an AST
+        # @param input [String] XML string in s9e/TextFormatter format
+        # @return [AST::Document]
+        def parse(input)
+          @unknown_tags.clear
+
+          xml_doc = Nokogiri.XML(input)
+          root = xml_doc.root
+
+          unless root
+            # Invalid or non-XML - treat as plain text
+            document = AST::Document.new
+            document << AST::Text.new(input) unless input.empty?
+            return document
+          end
+
+          document = AST::Document.new
+          process_node(root, document)
+          document
+        rescue Nokogiri::XML::SyntaxError => e
+          # Invalid XML - treat as plain text
+          document = AST::Document.new
+          document << AST::Text.new(input)
+          document
+        end
+
+        # Process children of an XML element (public for handler access)
+        # @param element [Nokogiri::XML::Element]
+        # @param ast_parent [AST::Element]
+        def process_children(element, ast_parent)
+          element.children.each { |child| process_node(child, ast_parent) }
+        end
+
+        private
+
+        # Process an XML node and add corresponding AST nodes to parent
+        # @param xml_node [Nokogiri::XML::Element, Nokogiri::XML::Text]
+        # @param ast_parent [AST::Element]
+        def process_node(xml_node, ast_parent)
+          if xml_node.element?
+            process_element(xml_node, ast_parent)
+          elsif xml_node.text?
+            process_text(xml_node, ast_parent)
+          end
+        end
+
+        # Process an XML element
+        # @param element [Nokogiri::XML::Element]
+        # @param ast_parent [AST::Element]
+        def process_element(element, ast_parent)
+          tag_name = element.name
+
+          # Skip markup preservation elements and their content (used for unparsing)
+          return if %w[s e].include?(tag_name)
+
+          # Handle root nodes
+          return process_children(element, ast_parent) if %w[t r].include?(tag_name)
+
+          # Handle line breaks
+          if tag_name == "br"
+            ast_parent << AST::LineBreak.new
+            return
+          end
+
+          # Process element with registered handler
+          # Handler returns element if children should be processed, nil otherwise
+          result_element = @handlers.process_element(element, ast_parent)
+
+          if result_element
+            # Handler succeeded and returned element - process children into it
+            process_children(element, result_element)
+          elsif !@handlers.has_handler?(tag_name)
+            # No handler found - track as unknown and process children directly
+            @unknown_tags[tag_name] += 1
+            process_children(element, ast_parent)
+          end
+          # else: handler returned nil intentionally (no children to process)
+        end
+
+        # Process text node
+        # @param text_node [Nokogiri::XML::Text]
+        # @param ast_parent [AST::Element]
+        def process_text(text_node, ast_parent)
+          text = text_node.content
+          return if text.strip.empty?
+
+          ast_parent << AST::Text.new(text)
+        end
+      end
+    end
+  end
+end

data/lib/markbridge/parsers/text_formatter.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# Dependencies
+require_relative "../gem_loader"
+Markbridge::GemLoader.require_gem(:nokogiri, feature: "s9e/TextFormatter XML parsing")
+
+# AST Nodes
+require_relative "../ast"
+
+# Handler classes
+require_relative "text_formatter/handlers/base_handler"
+require_relative "text_formatter/handlers/simple_handler"
+require_relative "text_formatter/handlers/attribute_handler"
+require_relative "text_formatter/handlers/attachment_handler"
+require_relative "text_formatter/handlers/code_handler"
+require_relative "text_formatter/handlers/email_handler"
+require_relative "text_formatter/handlers/image_handler"
+require_relative "text_formatter/handlers/list_handler"
+require_relative "text_formatter/handlers/quote_handler"
+require_relative "text_formatter/handlers/url_handler"
+
+# Parser components
+require_relative "text_formatter/handler_registry"
+require_relative "text_formatter/parser"
+
+module Markbridge
+  module Parsers
+    module TextFormatter
+    end
+  end
+end

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

@@ -0,0 +1,199 @@
+# 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
+          @fence_char = nil
+          @fence_length = 0
+          @in_indented_block = false
+          @in_inline_code = false
+          @inline_delimiter = nil
+        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
+
+          # 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
+
+          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
+
+          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
+          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
+          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
+
+          # Find end of line
+          line_end = input.index("\n", pos) || input.length
+
+          # Check if line is blank
+          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
+            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
+            end
+          end
+
+          nil
+        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
+          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
+          else
+            # Opening inline code - count backticks
+            delimiter_start = pos
+            pos += 1 while pos < input.length && input[pos] == "`"
+
+            @inline_delimiter = input[delimiter_start...pos]
+            @in_inline_code = true
+
+            # Return position after opening delimiter
+            pos
+          end
+        end
+
+        # Reset the tracker state
+        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
+  end
+end

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

@@ -0,0 +1,57 @@
+# 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
+
+          # Helper to extract a word starting at position
+          # @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
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# 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([^\]]*)\]/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)
+            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])
+
+            # Validate required attributes
+            return nil unless attrs["name"] && attrs["start"]
+
+            node =
+              AST::Event.new(
+                name: attrs["name"],
+                starts_at: attrs["start"],
+                ends_at: attrs["end"],
+                status: attrs["status"],
+                timezone: attrs["timezone"],
+                raw:,
+              )
+
+            Match.new(start_pos: pos, end_pos:, 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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# 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