markbridge 0.1.0

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

@@ -0,0 +1,279 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Parsers
+    module MediaWiki
+      # Parses MediaWiki wikitext into an AST.
+      #
+      # Supports:
+      # - Bold ('''), italic (''), bold italic (''''')
+      # - Headings (= through ======)
+      # - Unordered lists (* / ** / ***)
+      # - Ordered lists (# / ## / ###)
+      # - Horizontal rules (----)
+      # - Internal links ([[target]] / [[target|display]])
+      # - External links ([url text])
+      # - Preformatted text (lines starting with a space)
+      # - HTML tags: <nowiki>, <code>, <pre>, <br>, <s>, <del>, <u>, <ins>, <sup>, <sub>
+      #
+      # @example Basic usage
+      #   parser = Markbridge::Parsers::MediaWiki::Parser.new
+      #   ast = parser.parse("'''bold''' and ''italic''")
+      class Parser
+        # Parse MediaWiki wikitext into an AST Document.
+        #
+        # @param input [String] MediaWiki source
+        # @return [AST::Document]
+        def parse(input)
+          normalized = normalize_line_endings(input)
+          lines = normalized.split("\n", -1)
+
+          @document = AST::Document.new
+          @inline_parser = InlineParser.new
+          @list_stack = []
+
+          process_lines(lines)
+          close_open_lists
+          @document
+        end
+
+        private
+
+        # Normalize line endings (CR, CRLF, and Unicode separators).
+        #
+        # @param input [String]
+        # @return [String]
+        def normalize_line_endings(input)
+          input.gsub(/\r\n?|[\u2028\u2029]+/, "\n")
+        end
+
+        # Process all lines of input.
+        #
+        # @param lines [Array<String>]
+        def process_lines(lines)
+          i = 0
+          while i < lines.length
+            line = lines[i]
+
+            if heading_line?(line)
+              close_open_lists
+              process_heading(line)
+            elsif horizontal_rule_line?(line)
+              close_open_lists
+              @document << AST::HorizontalRule.new
+            elsif list_line?(line)
+              process_list_item(line)
+            elsif preformatted_line?(line)
+              close_open_lists
+              i = process_preformatted_block(lines, i)
+            elsif pre_tag_line?(line)
+              close_open_lists
+              i = process_pre_tag_block(lines, i)
+            elsif blank_line?(line)
+              close_open_lists
+            else
+              close_open_lists
+              process_inline_content(line)
+            end
+
+            i += 1
+          end
+        end
+
+        # Check if a line is a heading (starts and ends with = signs).
+        #
+        # @param line [String]
+        # @return [Boolean]
+        def heading_line?(line)
+          line.match?(/\A={1,6}[^=].*[^=]={1,6}\s*\z/) || line.match?(/\A={1,6}[^=]+=*\s*\z/)
+        end
+
+        # Check if a line is a horizontal rule (4+ dashes).
+        #
+        # @param line [String]
+        # @return [Boolean]
+        def horizontal_rule_line?(line)
+          line.match?(/\A-{4,}\s*\z/)
+        end
+
+        # Check if a line is a list item (starts with * or #).
+        #
+        # @param line [String]
+        # @return [Boolean]
+        def list_line?(line)
+          line.match?(/\A[*#]/)
+        end
+
+        # Check if a line starts with a space (preformatted text).
+        #
+        # @param line [String]
+        # @return [Boolean]
+        def preformatted_line?(line)
+          line.start_with?(" ")
+        end
+
+        # Check if a line starts a <pre> block.
+        #
+        # @param line [String]
+        # @return [Boolean]
+        def pre_tag_line?(line)
+          line.match?(/\A\s*<pre\b/i)
+        end
+
+        # Check if a line is blank.
+        #
+        # @param line [String]
+        # @return [Boolean]
+        def blank_line?(line)
+          line.strip.empty?
+        end
+
+        # Process a heading line and add it to the document.
+        #
+        # @param line [String]
+        def process_heading(line)
+          stripped = line.strip
+          # Count leading = signs for level
+          level = 0
+          level += 1 while level < stripped.length && stripped[level] == "="
+          level = [level, 6].min
+
+          # Remove leading/trailing = signs and whitespace
+          content = stripped[level..].sub(/\s*={1,6}\s*\z/, "").strip
+
+          heading = AST::Heading.new(level:)
+          @inline_parser.parse(content, parent: heading)
+          @document << heading
+        end
+
+        # Process a list item line, managing list nesting.
+        #
+        # @param line [String]
+        def process_list_item(line)
+          # Count prefix characters to determine depth and type
+          prefix = +""
+          i = 0
+          while i < line.length && (line[i] == "*" || line[i] == "#")
+            prefix << line[i]
+            i += 1
+          end
+
+          content = line[i..].strip
+          desired_depth = prefix.length
+
+          # Adjust list stack to match desired depth
+          reconcile_list_stack(prefix, desired_depth)
+
+          # Create list item and add content
+          item = AST::ListItem.new
+          @inline_parser.parse(content, parent: item)
+          @list_stack.last[:list] << item
+        end
+
+        # Reconcile the list stack with the desired prefix.
+        # Opens new lists or closes existing ones as needed.
+        #
+        # @param prefix [String] the list prefix characters (e.g., "**#")
+        # @param desired_depth [Integer]
+        def reconcile_list_stack(prefix, desired_depth)
+          # Close lists that no longer match
+          @list_stack.pop while @list_stack.length > desired_depth
+
+          # Check if existing stack entries match the type at each level
+          prefix.chars.each_with_index do |char, idx|
+            ordered = char == "#"
+            if idx < @list_stack.length
+              # If type changed at this level, close from here and reopen
+              if @list_stack[idx][:ordered] != ordered
+                @list_stack.pop while @list_stack.length > idx
+                open_new_list(ordered, idx)
+              end
+            else
+              open_new_list(ordered, idx)
+            end
+          end
+        end
+
+        # Open a new list at the given depth.
+        #
+        # @param ordered [Boolean]
+        # @param depth [Integer]
+        def open_new_list(ordered, depth)
+          list = AST::List.new(ordered:)
+
+          if depth.zero?
+            @document << list
+          else
+            # Nest inside the last item of the parent list
+            parent_list = @list_stack.last[:list]
+            parent_list << AST::ListItem.new if parent_list.children.empty?
+            parent_list.children.last << list
+          end
+
+          @list_stack << { list:, ordered: }
+        end
+
+        # Close all open lists.
+        def close_open_lists
+          @list_stack.clear
+        end
+
+        # Process consecutive lines starting with a space as a preformatted block.
+        #
+        # @param lines [Array<String>]
+        # @param start_index [Integer]
+        # @return [Integer] the last index consumed (will be incremented by caller)
+        def process_preformatted_block(lines, start_index)
+          content_lines = []
+          i = start_index
+
+          while i < lines.length && lines[i].start_with?(" ")
+            content_lines << lines[i][1..] # Remove leading space
+            i += 1
+          end
+
+          code = AST::Code.new
+          code << AST::Text.new(content_lines.join("\n"))
+          @document << code
+
+          i - 1 # Return last consumed index
+        end
+
+        # Process a <pre>...</pre> block that may span multiple lines.
+        #
+        # @param lines [Array<String>]
+        # @param start_index [Integer]
+        # @return [Integer] the last index consumed
+        def process_pre_tag_block(lines, start_index)
+          combined = +""
+          i = start_index
+
+          while i < lines.length
+            combined << lines[i]
+            break if lines[i].match?(%r{</pre\s*>}i)
+            combined << "\n"
+            i += 1
+          end
+
+          # Extract content between <pre> and </pre>
+          content = combined.sub(/\A\s*<pre\b[^>]*>/i, "").sub(%r{</pre\s*>\s*\z}i, "")
+
+          code = AST::Code.new
+          code << AST::Text.new(content)
+          @document << code
+
+          i
+        end
+
+        # Process a line as inline content wrapped in a paragraph.
+        #
+        # @param line [String]
+        def process_inline_content(line)
+          paragraph = AST::Paragraph.new
+          @inline_parser.parse(line, parent: paragraph)
+          @document << paragraph
+        end
+      end
+    end
+  end
+end

data/lib/markbridge/parsers/media_wiki.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# AST Nodes
+require_relative "../ast"
+
+# Parser components
+require_relative "media_wiki/inline_parser"
+require_relative "media_wiki/parser"
+
+module Markbridge
+  module Parsers
+    module MediaWiki
+    end
+  end
+end

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

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Parsers
+    module TextFormatter
+      # Registry of s9e/TextFormatter XML element handlers
+      #
+      # Manages mappings between XML element names and handler objects.
+      # Handlers must respond to #process(element:, parent:) and return the created element
+      # if children should be processed, or nil otherwise.
+      #
+      # @example Using default mappings
+      #   registry = HandlerRegistry.default
+      #   element = registry.process_element(xml_element, parent)
+      #
+      # @example Customizing mappings with handler objects
+      #   registry = HandlerRegistry.build_from_default do |r|
+      #     r.register("CUSTOM", MyCustomHandler.new)
+      #     r.register("B", SimpleHandler.new(AST::Bold))  # Override default
+      #   end
+      #
+      # @example Using lambdas for simple mappings
+      #   registry = HandlerRegistry.new
+      #   registry.register("CUSTOM", ->(element:, parent:) {
+      #     node = AST::Custom.new
+      #     parent << node
+      #     node  # Return node to process children
+      #   })
+      class HandlerRegistry
+        # Create a new registry with default mappings
+        # @return [HandlerRegistry]
+        def self.default
+          new.tap(&:register_defaults)
+        end
+
+        # Build from default mappings with custom additions
+        # @yield [HandlerRegistry] registry with default mappings loaded
+        # @return [HandlerRegistry]
+        def self.build_from_default
+          default.tap { |registry| yield registry if block_given? }
+        end
+
+        def initialize
+          @mappings = {}
+        end
+
+        # Register a handler for an element
+        # @param element_name [String] XML element name (case-insensitive)
+        # @param handler [#process, #call] Handler object or lambda
+        # @example With handler object
+        #   registry.register("CUSTOM", MyCustomHandler.new)
+        # @example With lambda
+        #   registry.register("CUSTOM", ->(element:, parent:) { ... })
+        def register(element_name, handler)
+          @mappings[element_name.upcase] = handler
+        end
+
+        # Check if a handler is registered for an element
+        # @param element_name [String] XML element name
+        # @return [Boolean] true if handler is registered
+        def has_handler?(element_name)
+          @mappings.key?(element_name.upcase)
+        end
+
+        # Process an XML element using the registered handler
+        # @param element [Nokogiri::XML::Element]
+        # @param parent [AST::Element] parent node to add children to
+        # @return [AST::Element, nil] the created element if children should be processed, nil otherwise
+        def process_element(element, parent)
+          tag_name = element.name.upcase
+          handler = @mappings[tag_name]
+          return nil unless handler
+
+          # Call handler and return its result (element or nil)
+          if handler.respond_to?(:process)
+            handler.process(element:, parent:)
+          elsif handler.respond_to?(:call)
+            handler.call(element:, parent:)
+          else
+            raise ArgumentError, "Handler must respond to :process or :call"
+          end
+        end
+
+        # Register all default s9e/TextFormatter element mappings
+        def register_defaults
+          # Simple formatting elements
+          register("B", Handlers::SimpleHandler.new(AST::Bold))
+          register("I", Handlers::SimpleHandler.new(AST::Italic))
+          register("U", Handlers::SimpleHandler.new(AST::Underline))
+          register("S", Handlers::SimpleHandler.new(AST::Strikethrough))
+
+          # Complex elements with attributes
+          register("URL", Handlers::UrlHandler.new)
+          register("EMAIL", Handlers::EmailHandler.new)
+          register("CODE", Handlers::CodeHandler.new)
+          register("QUOTE", Handlers::QuoteHandler.new)
+          register("IMG", Handlers::ImageHandler.new)
+          register("LIST", Handlers::ListHandler.new)
+          register(
+            "COLOR",
+            Handlers::AttributeHandler.new(AST::Color, attribute: :color, param: :color),
+          )
+          register(
+            "SIZE",
+            Handlers::AttributeHandler.new(AST::Size, attribute: :size, param: :size),
+          )
+          register(
+            "ALIGN",
+            Handlers::AttributeHandler.new(AST::Align, attribute: :align, param: :alignment),
+          )
+          register(
+            "SPOILER",
+            Handlers::AttributeHandler.new(AST::Spoiler, attribute: :title, param: :title),
+          )
+          register("ATTACHMENT", Handlers::AttachmentHandler.new)
+          register("ATTACH", Handlers::AttachmentHandler.new)
+
+          # List item (supports both LI and * for compatibility)
+          register("LI", Handlers::SimpleHandler.new(AST::ListItem))
+          register("*", Handlers::SimpleHandler.new(AST::ListItem))
+
+          # Paragraphs
+          register("P", Handlers::SimpleHandler.new(AST::Paragraph))
+
+          self
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Parsers
+    module TextFormatter
+      module Handlers
+        # Handler for ATTACHMENT and ATTACH elements in s9e/TextFormatter XML
+        class AttachmentHandler < BaseHandler
+          def initialize
+            @element_class = AST::Attachment
+          end
+
+          def process(element:, parent:)
+            attrs = extract_attributes(element)
+            node =
+              AST::Attachment.new(
+                id: attrs[:id],
+                index: attrs[:index],
+                filename: attrs[:filename],
+                alt: attrs[:alt],
+              )
+            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/attribute_handler.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Parsers
+    module TextFormatter
+      module Handlers
+        # Generic handler for elements that take a single attribute
+        #
+        # This handler extracts a specified attribute and passes it to the AST node constructor.
+        # Use this for elements like COLOR, SIZE, ALIGN, SPOILER.
+        #
+        # @example
+        #   # For <COLOR color="red">text</COLOR>
+        #   handler = AttributeHandler.new(AST::Color, attribute: :color, param: :color)
+        #   registry.register("COLOR", handler)
+        class AttributeHandler < BaseHandler
+          # @param element_class [Class] the AST node class to instantiate
+          # @param attribute [Symbol] the XML attribute name to extract
+          # @param param [Symbol] the parameter name to pass to the AST node constructor
+          def initialize(element_class, attribute:, param: nil)
+            @element_class = element_class
+            @attribute = attribute
+            @param = param || attribute
+          end
+
+          def process(element:, parent:)
+            attrs = extract_attributes(element)
+            node = @element_class.new(@param => attrs[@attribute])
+            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/base_handler.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Parsers
+    module TextFormatter
+      module Handlers
+        # Base class for TextFormatter XML element handlers
+        #
+        # Handlers process s9e/TextFormatter XML elements and convert them to AST nodes.
+        # Each handler implements the process method to handle a specific element type.
+        #
+        # @abstract Subclass and override {#process} to implement a custom handler
+        class BaseHandler
+          # Process an XML element and convert it to AST node(s)
+          #
+          # @param element [Nokogiri::XML::Element] the XML element to process
+          # @param parent [AST::Element] the parent AST node to add children to
+          # @return [AST::Element, nil] the created element if children should be processed, nil otherwise
+          def process(element:, parent:)
+            raise NotImplementedError, "#{self.class} must implement #process"
+          end
+
+          # The AST element class this handler creates
+          # Used for introspection and documentation
+          #
+          # @return [Class] the AST node class
+          def element_class
+            raise NotImplementedError, "#{self.class} must implement #element_class"
+          end
+
+          private
+
+          # Extract attributes from XML element as a symbolized hash
+          # @param element [Nokogiri::XML::Element]
+          # @return [Hash<Symbol, String>] attributes hash with symbolized, lowercased keys
+          def extract_attributes(element)
+            attrs = {}
+            element.attributes.each { |name, attr| attrs[name.downcase.to_sym] = attr.value }
+            attrs
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Parsers
+    module TextFormatter
+      module Handlers
+        # Handler for CODE elements in s9e/TextFormatter XML
+        class CodeHandler < BaseHandler
+          def initialize
+            @element_class = AST::Code
+          end
+
+          def process(element:, parent:)
+            attrs = extract_attributes(element)
+            lang = attrs[:lang] || attrs[:language]
+            node = AST::Code.new(language: lang)
+            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/email_handler.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Parsers
+    module TextFormatter
+      module Handlers
+        # Handler for EMAIL elements in s9e/TextFormatter XML
+        class EmailHandler < BaseHandler
+          def initialize
+            @element_class = AST::Email
+          end
+
+          def process(element:, parent:)
+            attrs = extract_attributes(element)
+            node = AST::Email.new(address: attrs[:email])
+            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/image_handler.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Parsers
+    module TextFormatter
+      module Handlers
+        # Handler for IMG elements in s9e/TextFormatter XML
+        class ImageHandler < BaseHandler
+          def initialize
+            @element_class = AST::Image
+          end
+
+          def process(element:, parent:)
+            attrs = extract_attributes(element)
+            node =
+              AST::Image.new(
+                src: attrs[:src],
+                width: attrs[:width]&.to_i,
+                height: attrs[:height]&.to_i,
+              )
+            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/list_handler.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Parsers
+    module TextFormatter
+      module Handlers
+        # Handler for LIST elements in s9e/TextFormatter XML
+        class ListHandler < BaseHandler
+          def initialize
+            @element_class = AST::List
+          end
+
+          def process(element:, parent:)
+            attrs = extract_attributes(element)
+            type_str = attrs[:type]
+            # Ordered if type is not empty, disc, circle, or square
+            ordered = !type_str.nil? && !["", "disc", "circle", "square"].include?(type_str)
+
+            node = AST::List.new(ordered:)
+            parent << node
+
+            # Return node to signal: process children into this node
+            node
+          end
+
+          attr_reader :element_class
+        end
+      end
+    end
+  end
+end