markbridge 0.1.0

data/lib/markbridge/renderers/discourse/tags/poll_tag.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Renderers
+    module Discourse
+      module Tags
+        # Placeholder tag for rendering polls.
+        #
+        # This is a STUB implementation that outputs the original raw BBCode.
+        # Applications using Markbridge should provide their own custom tag
+        # to render polls as placeholders or convert them to another format.
+        #
+        # @example Custom renderer with placeholder
+        #   class MyPollTag < Markbridge::Renderers::Discourse::Tags::PollTag
+        #     def render(element, interface)
+        #       id = register_poll(element)
+        #       "<<POLL:#{id}>>"
+        #     end
+        #   end
+        class PollTag < Tag
+          def render(element, interface)
+            # Return raw BBCode if available, otherwise reconstruct
+            return element.raw if element.raw
+
+            build_poll_bbcode(element)
+          end
+
+          private
+
+          def build_poll_bbcode(element)
+            attrs = build_attributes(element)
+            options = element.options.map { |opt| "* #{opt}" }.join("\n")
+
+            "[poll#{attrs}]\n#{options}\n[/poll]"
+          end
+
+          def build_attributes(element)
+            parts = []
+            parts << %( name="#{element.name}") if element.name && element.name != "poll"
+            parts << %( type="#{element.type}") if element.type
+            parts << %( results="#{element.results}") if element.results
+            parts << %( public="true") if element.public
+            parts << %( chartType="#{element.chart_type}") if element.chart_type
+
+            parts.join
+          end
+        end
+      end
+    end
+  end
+end

data/lib/markbridge/renderers/discourse/tags/quote_tag.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Renderers
+    module Discourse
+      module Tags
+        # Tag for rendering quotes
+        # Renders to Discourse BBCode quote format to preserve attribution
+        class QuoteTag < Tag
+          def render(element, interface)
+            child_context = interface.with_parent(element)
+            content = interface.render_children(element, context: child_context)
+
+            # Build Discourse quote BBCode
+            # Format: [quote="username, post:123, topic:456"]content[/quote]
+            if element.post && element.topic && element.username
+              # Full Discourse quote with context
+              "[quote=\"#{element.username}, post:#{element.post}, topic:#{element.topic}\"]\n#{content}\n[/quote]"
+            elsif element.author
+              # Quote with author attribution only
+              "[quote=\"#{element.author}\"]\n#{content}\n[/quote]"
+            else
+              # Plain quote - could use Markdown blockquote or BBCode
+              # Using Markdown blockquote for plain quotes
+              content.split("\n").map { |line| "> #{line}" }.join("\n")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/markbridge/renderers/discourse/tags/size_tag.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Renderers
+    module Discourse
+      module Tags
+        # Tag for rendering sized text
+        # Note: Discourse doesn't support inline size changes by default
+        # Renders as plain text with HTML comment noting the size was lost
+        class SizeTag < Tag
+          def render(element, interface)
+            child_context = interface.with_parent(element)
+            content = interface.render_children(element, context: child_context)
+
+            if element.size
+              # Render as HTML span with style - requires HTML to be enabled
+              # Alternative: just output the text without size
+              "<span style=\"font-size: #{element.size}px\">#{content}</span>"
+            else
+              content
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/markbridge/renderers/discourse/tags/spoiler_tag.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Renderers
+    module Discourse
+      module Tags
+        # Tag for rendering spoilers
+        # Renders to Discourse BBCode spoiler format
+        class SpoilerTag < Tag
+          def render(element, interface)
+            child_context = interface.with_parent(element)
+            content = interface.render_children(element, context: child_context)
+
+            if element.title
+              "[spoiler=#{element.title}]#{content}[/spoiler]"
+            else
+              "[spoiler]#{content}[/spoiler]"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/markbridge/renderers/discourse/tags/strikethrough_tag.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Renderers
+    module Discourse
+      module Tags
+        # Tag for rendering strikethrough text
+        class StrikethroughTag < Tag
+          def render(element, interface)
+            child_context = interface.with_parent(element)
+            content = interface.render_children(element, context: child_context)
+            interface.wrap_inline(content, "~~")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/markbridge/renderers/discourse/tags/subscript_tag.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Renderers
+    module Discourse
+      module Tags
+        # Tag for rendering subscript text
+        # Renders to HTML <sub> tag
+        class SubscriptTag < Tag
+          def render(element, interface)
+            child_context = interface.with_parent(element)
+            content = interface.render_children(element, context: child_context)
+            "<sub>#{content}</sub>"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/markbridge/renderers/discourse/tags/superscript_tag.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Renderers
+    module Discourse
+      module Tags
+        # Tag for rendering superscript text
+        # Renders to HTML <sup> tag
+        class SuperscriptTag < Tag
+          def render(element, interface)
+            child_context = interface.with_parent(element)
+            content = interface.render_children(element, context: child_context)
+            "<sup>#{content}</sup>"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/markbridge/renderers/discourse/tags/underline_tag.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Renderers
+    module Discourse
+      module Tags
+        # Tag for rendering underline text
+        class UnderlineTag < Tag
+          def render(element, interface)
+            child_context = interface.with_parent(element)
+            content = interface.render_children(element, context: child_context)
+            # Discourse uses HTML for underline
+            "<u>#{content}</u>"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/markbridge/renderers/discourse/tags/upload_tag.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Renderers
+    module Discourse
+      module Tags
+        # Placeholder tag for rendering Discourse uploads.
+        #
+        # This is a STUB implementation that outputs the original raw Markdown.
+        # Applications using Markbridge should provide their own custom tag
+        # to render uploads as placeholders or resolve upload:// URLs.
+        #
+        # @example Custom renderer with placeholder
+        #   class MyUploadTag < Markbridge::Renderers::Discourse::Tags::UploadTag
+        #     def render(element, interface)
+        #       "<<UPLOAD:#{element.sha1}>>"
+        #     end
+        #   end
+        #
+        # @example Custom renderer that resolves URLs
+        #   class MyUploadTag < Markbridge::Renderers::Discourse::Tags::UploadTag
+        #     def render(element, interface)
+        #       url = resolve_upload(element.sha1)
+        #       if element.type == :image
+        #         "![#{element.alt}](#{url})"
+        #       else
+        #         "[#{element.filename}](#{url})"
+        #       end
+        #     end
+        #   end
+        class UploadTag < Tag
+          def render(element, interface)
+            # Return raw Markdown if available, otherwise reconstruct
+            return element.raw if element.raw
+
+            build_upload_markdown(element)
+          end
+
+          private
+
+          def build_upload_markdown(element)
+            if element.type == :image
+              build_image_markdown(element)
+            else
+              build_attachment_markdown(element)
+            end
+          end
+
+          def build_image_markdown(element)
+            alt = build_alt(element)
+            url = build_upload_url(element)
+
+            "![#{alt}](#{url})"
+          end
+
+          def build_attachment_markdown(element)
+            filename = element.filename || "attachment"
+            url = build_upload_url(element)
+            size_part = element.size ? " (#{element.size})" : ""
+
+            "[#{filename}|attachment](#{url})#{size_part}"
+          end
+
+          def build_alt(element)
+            parts = []
+            parts << element.alt if element.alt
+            parts << element.dimensions if element.dimensions
+
+            parts.join("|")
+          end
+
+          def build_upload_url(element)
+            filename = element.filename || element.sha1
+            "upload://#{filename}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/markbridge/renderers/discourse/tags/url_tag.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Renderers
+    module Discourse
+      module Tags
+        # Tag for rendering URLs
+        class UrlTag < Tag
+          def render(element, interface)
+            child_context = interface.with_parent(element)
+            text = interface.render_children(element, context: child_context)
+            href = element.href
+
+            if href&.match?(/^(https?|ftps?|mailto):/i)
+              "[#{text}](#{href})"
+            else
+              text
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/markbridge/renderers/discourse.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "discourse/tag"
+require_relative "discourse/tag_library"
+require_relative "discourse/render_context"
+require_relative "discourse/rendering_interface"
+require_relative "discourse/markdown_escaper"
+
+# Builders
+require_relative "discourse/builders/list_item_builder"
+
+# Tags
+require_relative "discourse/tags/align_tag"
+require_relative "discourse/tags/attachment_tag"
+require_relative "discourse/tags/bold_tag"
+require_relative "discourse/tags/code_tag"
+require_relative "discourse/tags/color_tag"
+require_relative "discourse/tags/email_tag"
+require_relative "discourse/tags/heading_tag"
+require_relative "discourse/tags/horizontal_rule_tag"
+require_relative "discourse/tags/line_break_tag"
+require_relative "discourse/tags/image_tag"
+require_relative "discourse/tags/italic_tag"
+require_relative "discourse/tags/list_tag"
+require_relative "discourse/tags/list_item_tag"
+require_relative "discourse/tags/paragraph_tag"
+require_relative "discourse/tags/quote_tag"
+require_relative "discourse/tags/size_tag"
+require_relative "discourse/tags/spoiler_tag"
+require_relative "discourse/tags/strikethrough_tag"
+require_relative "discourse/tags/subscript_tag"
+require_relative "discourse/tags/superscript_tag"
+require_relative "discourse/tags/underline_tag"
+require_relative "discourse/tags/url_tag"
+
+# Discourse-specific tags
+require_relative "discourse/tags/event_tag"
+require_relative "discourse/tags/mention_tag"
+require_relative "discourse/tags/poll_tag"
+require_relative "discourse/tags/upload_tag"
+
+# Renderer itself
+require_relative "discourse/renderer"
+
+module Markbridge
+  module Renderers
+    module Discourse
+    end
+  end
+end

data/lib/markbridge/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Markbridge
+  VERSION = "0.1.0"
+end

data/lib/markbridge.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require_relative "markbridge/version"
+require_relative "markbridge/configuration"
+
+require_relative "markbridge/ast"
+require_relative "markbridge/renderers/discourse"
+require_relative "markbridge/parsers/media_wiki"
+require_relative "markbridge/parsers/text_formatter"
+require_relative "markbridge/processors"
+
+module Markbridge
+  class << self
+    # Parse BBCode to AST
+    # @param input [String] BBCode source
+    # @param handlers [HandlerRegistry, nil] custom handler registry or use default
+    # @return [AST::Document]
+    def parse_bbcode(input, handlers: nil)
+      raise ArgumentError, "input cannot be nil" if input.nil?
+
+      input = input.to_s # Coerce to string
+      handlers ||= default_handlers
+
+      parser = Parsers::BBCode::Parser.new(handlers:)
+      parser.parse(input)
+    end
+
+    # Convert BBCode to Discourse Markdown
+    # @param input [String] BBCode source
+    # @param handlers [HandlerRegistry, nil] custom handler registry or use default
+    # @param tag_library [TagLibrary, nil] custom tag library or use default
+    # @return [String] Markdown output
+    def bbcode_to_markdown(input, handlers: nil, tag_library: nil)
+      raise ArgumentError, "input cannot be nil" if input.nil?
+
+      handlers ||= default_handlers
+      tag_library ||= default_tag_library
+
+      ast = parse_bbcode(input, handlers:)
+      renderer = build_renderer(tag_library:)
+
+      # Clean up output
+      result = renderer.render(ast)
+      cleanup_markdown(result)
+    end
+
+    # Parse HTML to AST
+    # @param input [String] HTML source
+    # @param handlers [HandlerRegistry, nil] custom handler registry or use default
+    # @return [AST::Document]
+    def parse_html(input, handlers: nil)
+      raise ArgumentError, "input cannot be nil" if input.nil?
+
+      input = input.to_s # Coerce to string
+      handlers ||= default_html_handlers
+
+      parser = Parsers::HTML::Parser.new(handlers:)
+      parser.parse(input)
+    end
+
+    # Convert HTML to Discourse Markdown
+    # @param input [String] HTML source
+    # @param handlers [HandlerRegistry, nil] custom handler registry or use default
+    # @param tag_library [TagLibrary, nil] custom tag library or use default
+    # @return [String] Markdown output
+    def html_to_markdown(input, handlers: nil, tag_library: nil)
+      raise ArgumentError, "input cannot be nil" if input.nil?
+
+      handlers ||= default_html_handlers
+      tag_library ||= default_tag_library
+
+      ast = parse_html(input, handlers:)
+      renderer = build_renderer(tag_library:)
+
+      # Clean up output
+      result = renderer.render(ast)
+      cleanup_markdown(result)
+    end
+
+    # Parse s9e/TextFormatter XML to AST
+    # @param input [String] XML source in s9e/TextFormatter format
+    # @param handlers [Parsers::TextFormatter::HandlerRegistry, nil] custom handler registry or use default
+    # @return [AST::Document]
+    def parse_text_formatter_xml(input, handlers: nil)
+      raise ArgumentError, "input cannot be nil" if input.nil?
+
+      input = input.to_s
+      handlers ||= default_text_formatter_handlers
+
+      parser = Parsers::TextFormatter::Parser.new(handlers:)
+      parser.parse(input)
+    end
+
+    # Convert s9e/TextFormatter XML to Discourse Markdown
+    # @param input [String] XML source in s9e/TextFormatter format
+    # @param handlers [Parsers::TextFormatter::HandlerRegistry, nil] custom handler registry or use default
+    # @param tag_library [TagLibrary, nil] custom tag library or use default
+    # @return [String] Markdown output
+    def text_formatter_xml_to_markdown(input, handlers: nil, tag_library: nil)
+      raise ArgumentError, "input cannot be nil" if input.nil?
+
+      handlers ||= default_text_formatter_handlers
+      tag_library ||= default_tag_library
+
+      ast = parse_text_formatter_xml(input, handlers:)
+      renderer = build_renderer(tag_library:)
+
+      result = renderer.render(ast)
+      cleanup_markdown(result)
+    end
+
+    # Parse MediaWiki wikitext to AST
+    # @param input [String] MediaWiki source
+    # @return [AST::Document]
+    def parse_mediawiki(input)
+      raise ArgumentError, "input cannot be nil" if input.nil?
+
+      input = input.to_s
+      parser = Parsers::MediaWiki::Parser.new
+      parser.parse(input)
+    end
+
+    # Convert MediaWiki wikitext to Discourse Markdown
+    # @param input [String] MediaWiki source
+    # @param tag_library [TagLibrary, nil] custom tag library or use default
+    # @return [String] Markdown output
+    def mediawiki_to_markdown(input, tag_library: nil)
+      raise ArgumentError, "input cannot be nil" if input.nil?
+
+      tag_library ||= default_tag_library
+
+      ast = parse_mediawiki(input)
+      renderer = build_renderer(tag_library:)
+
+      result = renderer.render(ast)
+      cleanup_markdown(result)
+    end
+
+    # Get default handler registry
+    # @return [Parsers::BBCode::HandlerRegistry]
+    def default_handlers
+      @default_handlers ||= Parsers::BBCode::HandlerRegistry.default
+    end
+
+    # Get default HTML handler registry
+    # @return [Parsers::HTML::HandlerRegistry]
+    def default_html_handlers
+      @default_html_handlers ||= Parsers::HTML::HandlerRegistry.default
+    end
+
+    # Get default tag library
+    # @return [Renderers::Discourse::TagLibrary]
+    def default_tag_library
+      @default_tag_library ||= Renderers::Discourse::TagLibrary.default
+    end
+
+    # Get default s9e/TextFormatter handler registry
+    # @return [Parsers::TextFormatter::HandlerRegistry]
+    def default_text_formatter_handlers
+      @default_text_formatter_handlers ||= Parsers::TextFormatter::HandlerRegistry.default
+    end
+
+    # Get the global configuration
+    # @return [Configuration]
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    # Configure Markbridge with a block
+    # @yield [Configuration]
+    def configure
+      yield configuration
+    end
+
+    # Reset defaults (useful for testing)
+    def reset_defaults!
+      @default_handlers = nil
+      @default_html_handlers = nil
+      @default_tag_library = nil
+      @default_text_formatter_handlers = nil
+      @configuration = nil
+    end
+
+    private
+
+    def build_renderer(tag_library:)
+      escaper =
+        Renderers::Discourse::MarkdownEscaper.new(
+          escape_hard_line_breaks: configuration.escape_hard_line_breaks,
+        )
+      Renderers::Discourse::Renderer.new(tag_library:, escaper:)
+    end
+
+    def cleanup_markdown(text)
+      text
+        .gsub(/\n{3,}/, "\n\n") # Max 2 consecutive newlines
+        .gsub(/^[ \t]+$/m, "") # Remove whitespace-only lines
+        .strip # Trim leading/trailing whitespace
+    end
+  end
+end