markbridge 0.1.0

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Parsers
+    module HTML
+      module Handlers
+        # Handler for <a> tags
+        class UrlHandler < BaseHandler
+          def initialize
+            @element_class = AST::Url
+          end
+
+          def process(element:, parent:)
+            href = element["href"]
+            ast_element = AST::Url.new(href:)
+            parent << ast_element
+
+            # Return element to signal: process children into this element (link text)
+            ast_element
+          end
+
+          attr_reader :element_class
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Parsers
+    module HTML
+      # Parses HTML into an AST using Nokogiri
+      class Parser
+        attr_reader :unknown_tags
+
+        # Create a new parser with optional custom handlers
+        # @param handlers [HandlerRegistry, nil] custom handler registry, defaults to HandlerRegistry.default
+        # @yield [HandlerRegistry] optional block to customize the default registry
+        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 HTML string into an AST
+        # @param input [String] HTML source
+        # @return [AST::Document]
+        def parse(input)
+          @unknown_tags.clear
+
+          # Parse HTML with Nokogiri
+          doc = Nokogiri::HTML5.fragment(input)
+
+          # Create root AST document
+          document = AST::Document.new
+
+          # Process all nodes
+          doc.children.each { |node| process_node(node, document) }
+
+          document
+        end
+
+        # Process child nodes of an element (used by handlers)
+        # @param node [Nokogiri::XML::Element]
+        # @param parent [AST::Element]
+        def process_children(node, parent)
+          node.children.each { |child| process_node(child, parent) }
+        end
+
+        private
+
+        # Process a Nokogiri node and add it to the parent AST node
+        # @param node [Nokogiri::XML::Node]
+        # @param parent [AST::Element]
+        def process_node(node, parent)
+          case node
+          when Nokogiri::XML::Text
+            process_text_node(node, parent)
+          when Nokogiri::XML::Element
+            process_element_node(node, parent)
+          end
+        end
+
+        # Process a text node
+        # @param node [Nokogiri::XML::Text]
+        # @param parent [AST::Element]
+        def process_text_node(node, parent)
+          text = node.text
+          parent << AST::Text.new(text) unless text.empty?
+        end
+
+        # Process an element node
+        # @param node [Nokogiri::XML::Element]
+        # @param parent [AST::Element]
+        def process_element_node(node, parent)
+          tag_name = node.name.downcase
+          handler = @handlers[tag_name]
+
+          if handler
+            # Handler returns element if children should be processed, nil otherwise
+            ast_element =
+              if handler.respond_to?(:process)
+                handler.process(element: node, parent:)
+              else
+                handler.call(element: node, parent:)
+              end
+
+            # Automatically process children if handler returned element
+            process_children(node, ast_element) if ast_element
+          else
+            handle_unknown_tag(node, parent)
+          end
+        end
+
+        # Handle unknown tag by tracking it and ignoring the wrapper
+        # while still processing its children
+        # @param node [Nokogiri::XML::Element]
+        # @param parent [AST::Element]
+        def handle_unknown_tag(node, parent)
+          @unknown_tags[node.name.downcase] += 1
+          process_children(node, parent)
+        end
+
+        # Check if an element is a void element (self-closing)
+        # @param tag_name [String]
+        # @return [Boolean]
+        def void_element?(tag_name)
+          %w[area base br col embed hr img input link meta param source track wbr].include?(
+            tag_name.downcase,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/markbridge/parsers/html.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# Dependencies
+require_relative "../gem_loader"
+Markbridge::GemLoader.require_gem(:nokogiri, feature: "HTML parsing")
+
+# AST Nodes
+require_relative "../ast"
+
+# Handlers
+require_relative "html/handlers/base_handler"
+require_relative "html/handlers/simple_handler"
+require_relative "html/handlers/raw_handler"
+require_relative "html/handlers/url_handler"
+require_relative "html/handlers/image_handler"
+require_relative "html/handlers/list_handler"
+require_relative "html/handlers/list_item_handler"
+require_relative "html/handlers/quote_handler"
+require_relative "html/handlers/paragraph_handler"
+
+# Parser components
+require_relative "html/handler_registry"
+require_relative "html/parser"
+
+module Markbridge
+  module Parsers
+    module HTML
+    end
+  end
+end

data/lib/markbridge/parsers/media_wiki/inline_parser.rb

@@ -0,0 +1,332 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Parsers
+    module MediaWiki
+      # Parses inline MediaWiki markup within a line of text.
+      # Handles bold ('''), italic (''), links ([[...]]), external links ([...]),
+      # and HTML inline tags (<code>, <nowiki>, <s>, <del>, <u>, <ins>, <sup>, <sub>, <br>).
+      class InlineParser
+        # Parse inline markup and append resulting AST nodes to the parent element.
+        #
+        # @param text [String] the text to parse for inline markup
+        # @param parent [AST::Element] the element to append children to
+        def parse(text, parent:)
+          @input = text
+          @pos = 0
+          @length = text.length
+          @parent = parent
+          @text_buffer = +""
+
+          while @pos < @length
+            if @input[@pos] == "'" && @pos + 1 < @length && @input[@pos + 1] == "'"
+              parse_bold_italic
+            elsif @input[@pos] == "[" && @pos + 1 < @length && @input[@pos + 1] == "["
+              flush_text
+              parse_internal_link
+            elsif @input[@pos] == "[" && !(@pos + 1 < @length && @input[@pos + 1] == "[")
+              flush_text
+              parse_external_link
+            elsif @input[@pos] == "<"
+              flush_text
+              parse_html_tag
+            else
+              @text_buffer << @input[@pos]
+              @pos += 1
+            end
+          end
+
+          flush_text
+        end
+
+        private
+
+        # Count consecutive apostrophes and dispatch to bold/italic parsing.
+        def parse_bold_italic
+          start = @pos
+          count = 0
+          count += 1 while @pos + count < @length && @input[@pos + count] == "'"
+          count = 5 if count > 5
+
+          if count >= 5
+            flush_text
+            @pos += 5
+            parse_bold_italic_combo(start)
+          elsif count >= 3
+            flush_text
+            @pos += 3
+            parse_bold_content(start)
+          elsif count >= 2
+            flush_text
+            @pos += 2
+            parse_italic_content(start)
+          else
+            @text_buffer << @input[@pos]
+            @pos += 1
+          end
+        end
+
+        # Parse '''''bold italic''''' content.
+        def parse_bold_italic_combo(start)
+          bold = AST::Bold.new
+          italic = AST::Italic.new
+          content = collect_until_apostrophes(5)
+
+          if content
+            inner_parser = InlineParser.new
+            inner_parser.parse(content, parent: italic)
+            bold << italic
+            @parent << bold
+          else
+            # No closing found - treat as literal text
+            @text_buffer << "'''''"
+            @pos = start + 5
+          end
+        end
+
+        # Parse '''bold''' content.
+        def parse_bold_content(start)
+          bold = AST::Bold.new
+          content = collect_until_apostrophes(3)
+
+          if content
+            inner_parser = InlineParser.new
+            inner_parser.parse(content, parent: bold)
+            @parent << bold
+          else
+            @text_buffer << "'''"
+            @pos = start + 3
+          end
+        end
+
+        # Parse ''italic'' content.
+        def parse_italic_content(start)
+          italic = AST::Italic.new
+          content = collect_until_apostrophes(2)
+
+          if content
+            inner_parser = InlineParser.new
+            inner_parser.parse(content, parent: italic)
+            @parent << italic
+          else
+            @text_buffer << "''"
+            @pos = start + 2
+          end
+        end
+
+        # Collect text until we find n consecutive apostrophes.
+        # Returns the collected content string or nil if not found.
+        #
+        # @param count [Integer] number of consecutive apostrophes to match
+        # @return [String, nil]
+        def collect_until_apostrophes(count)
+          start = @pos
+          while @pos < @length
+            if @input[@pos] == "'" && consecutive_apostrophes_at(@pos) >= count
+              content = @input[start...@pos]
+              @pos += count
+              return content
+            end
+            @pos += 1
+          end
+          nil
+        end
+
+        # Count consecutive apostrophes starting at position.
+        #
+        # @param pos [Integer]
+        # @return [Integer]
+        def consecutive_apostrophes_at(pos)
+          count = 0
+          count += 1 while pos + count < @length && @input[pos + count] == "'"
+          count
+        end
+
+        # Parse [[internal link]] or [[target|display text]].
+        def parse_internal_link
+          @pos += 2 # skip [[
+          start = @pos
+
+          # Find closing ]]
+          close_pos = @input.index("]]", @pos)
+          unless close_pos
+            @text_buffer << "[["
+            return
+          end
+
+          content = @input[start...close_pos]
+          @pos = close_pos + 2
+
+          target, display = content.split("|", 2)
+          target = target.strip
+          display = (display || target).strip
+
+          url = AST::Url.new(href: target)
+          url << AST::Text.new(display)
+          @parent << url
+        end
+
+        # Parse [url display text] external link.
+        def parse_external_link
+          @pos += 1 # skip [
+          start = @pos
+
+          # Find closing ]
+          close_pos = @input.index("]", @pos)
+          unless close_pos
+            @text_buffer << "["
+            return
+          end
+
+          content = @input[start...close_pos]
+          @pos = close_pos + 1
+
+          # Split on first space: URL followed by optional display text
+          parts = content.split(" ", 2)
+          href = parts[0]
+          display = parts[1] || href
+
+          url = AST::Url.new(href:)
+          url << AST::Text.new(display)
+          @parent << url
+        end
+
+        # Parse an HTML tag (<code>, <nowiki>, <pre>, <br>, <s>, <del>, <u>, <ins>, <sup>, <sub>).
+        def parse_html_tag
+          tag_match = @input[@pos..].match(%r{\A<(/?)([a-z]+)(?: [^>]*)?\s*(/?)>}i)
+          unless tag_match
+            @text_buffer << "<"
+            @pos += 1
+            return
+          end
+
+          closing = !tag_match[1].empty?
+          tag_name = tag_match[2].downcase
+          self_closing = !tag_match[3].empty?
+          full_match = tag_match[0]
+
+          case tag_name
+          when "nowiki"
+            handle_nowiki_tag(closing, full_match)
+          when "code"
+            handle_paired_raw_tag(tag_name, closing, full_match, AST::Code)
+          when "pre"
+            handle_paired_raw_tag(tag_name, closing, full_match, AST::Code)
+          when "br"
+            @pos += full_match.length
+            @parent << AST::LineBreak.new
+          when "s", "del"
+            handle_paired_tag(tag_name, closing, self_closing, full_match, AST::Strikethrough)
+          when "u", "ins"
+            handle_paired_tag(tag_name, closing, self_closing, full_match, AST::Underline)
+          when "sup"
+            handle_paired_tag(tag_name, closing, self_closing, full_match, AST::Superscript)
+          when "sub"
+            handle_paired_tag(tag_name, closing, self_closing, full_match, AST::Subscript)
+          else
+            # Unknown HTML tag - treat as text
+            @text_buffer << full_match
+            @pos += full_match.length
+          end
+        end
+
+        # Handle <nowiki>...</nowiki> - preserves content as literal text.
+        def handle_nowiki_tag(closing, full_match)
+          if closing
+            @text_buffer << full_match
+            @pos += full_match.length
+            return
+          end
+
+          @pos += full_match.length
+          close_tag = "</nowiki>"
+          close_pos = @input.index(close_tag, @pos)
+
+          if close_pos
+            raw_content = @input[@pos...close_pos]
+            @text_buffer << raw_content
+            @pos = close_pos + close_tag.length
+          else
+            # No closing tag found - treat opening tag as text
+            @text_buffer << full_match
+          end
+        end
+
+        # Handle paired raw tags like <code>...</code> and <pre>...</pre>.
+        # Content inside is not parsed for wiki markup.
+        def handle_paired_raw_tag(tag_name, closing, full_match, element_class)
+          if closing
+            @text_buffer << full_match
+            @pos += full_match.length
+            return
+          end
+
+          @pos += full_match.length
+          close_tag = "</#{tag_name}>"
+          close_pos = @input.index(close_tag, @pos)
+
+          if close_pos
+            raw_content = @input[@pos...close_pos]
+            element = element_class.new
+            element << AST::Text.new(raw_content)
+            @parent << element
+            @pos = close_pos + close_tag.length
+          else
+            @text_buffer << full_match
+          end
+        end
+
+        # Handle paired formatting tags like <s>, <u>, <sup>, <sub>.
+        # Content inside IS parsed for wiki markup.
+        def handle_paired_tag(tag_name, closing, self_closing, full_match, element_class)
+          if closing || self_closing
+            @text_buffer << full_match
+            @pos += full_match.length
+            return
+          end
+
+          @pos += full_match.length
+          # Find matching close tag, accounting for the alias tags
+          close_tags = close_tags_for(tag_name)
+          close_pos = nil
+          close_tag_length = 0
+
+          close_tags.each do |ct|
+            pos = @input.index(ct, @pos)
+            if pos && (close_pos.nil? || pos < close_pos)
+              close_pos = pos
+              close_tag_length = ct.length
+            end
+          end
+
+          if close_pos
+            inner_content = @input[@pos...close_pos]
+            element = element_class.new
+            inner_parser = InlineParser.new
+            inner_parser.parse(inner_content, parent: element)
+            @parent << element
+            @pos = close_pos + close_tag_length
+          else
+            @text_buffer << full_match
+          end
+        end
+
+        # Return the possible closing tags for a given tag name.
+        #
+        # @param tag_name [String]
+        # @return [Array<String>]
+        def close_tags_for(tag_name)
+          ["</#{tag_name}>"]
+        end
+
+        # Flush accumulated text buffer to the parent as a Text node.
+        def flush_text
+          return if @text_buffer.empty?
+
+          @parent << AST::Text.new(@text_buffer)
+          @text_buffer = +""
+        end
+      end
+    end
+  end
+end