markbridge 0.1.0

data/lib/markbridge/renderers/discourse/tag.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Renderers
+    module Discourse
+      # Base class for rendering tags
+      # Can be subclassed for complex tags or initialized with a block for simple tags
+      class Tag
+        # Initialize a tag
+        # @param block [Proc, nil] optional block for rendering
+        def initialize(&block)
+          @render_block = block
+        end
+
+        # Render a node to Discourse Markdown
+        # @param element [AST::Node] the node to render
+        # @param interface [RenderingInterface] the rendering interface
+        # @return [String] the rendered markdown
+        def render(element, interface)
+          if @render_block
+            @render_block.call(element, interface)
+          else
+            raise NotImplementedError, "#{self.class} must implement #render or provide a block"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/markbridge/renderers/discourse/tag_library.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Renderers
+    module Discourse
+      # Library of rendering tags for different element types
+      class TagLibrary
+        def initialize
+          @tags = {}
+        end
+
+        # Register a tag for an element class
+        # @param element_class [Class] the element class
+        # @param tag [Tag] the tag instance
+        def register(element_class, tag)
+          @tags[element_class] = tag
+          self
+        end
+
+        # Get tag for an element class
+        # @param element_class [Class]
+        # @return [Tag, nil]
+        def [](element_class)
+          @tags[element_class]
+        end
+
+        # Auto-register all tags using naming convention
+        # Convention: BoldTag handles AST::Bold, ItalicTag handles AST::Italic, etc.
+        # @return [self]
+        def auto_register!
+          Tags.constants.each do |tag_constant|
+            tag_class = Tags.const_get(tag_constant)
+            next unless tag_class.is_a?(Class) && tag_class < Tag
+
+            # Extract element name from tag name: BoldTag → Bold
+            element_name = tag_constant.to_s.sub(/Tag$/, "")
+            element_class =
+              begin
+                AST.const_get(element_name)
+              rescue StandardError
+                nil
+              end
+
+            register(element_class, tag_class.new) if element_class
+          end
+
+          self
+        end
+
+        # Create the default tag library for Discourse Markdown
+        # @return [TagLibrary]
+        def self.default
+          library = new
+
+          # Auto-register tags based on naming convention
+          library.auto_register!
+
+          # Special cases: inline tags that don't follow the convention
+          library.register AST::LineBreak, Tags::LineBreakTag.new
+          library.register AST::HorizontalRule, Tags::HorizontalRuleTag.new
+
+          library
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Renderers
+    module Discourse
+      module Tags
+        # Tag for rendering aligned text
+        # Renders as HTML div with align attribute
+        class AlignTag < Tag
+          def render(element, interface)
+            child_context = interface.with_parent(element)
+            content = interface.render_children(element, context: child_context)
+
+            if element.alignment
+              "<div align=\"#{element.alignment}\">#{content}</div>"
+            else
+              content
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Renderers
+    module Discourse
+      module Tags
+        # Placeholder tag for rendering attachments.
+        #
+        # This is a STUB implementation that outputs metadata as a comment.
+        # Applications using Markbridge should provide their own custom renderer
+        # that maps attachment IDs/indices to actual upload URLs.
+        #
+        # @example Custom renderer
+        #   class MyAttachmentTag < Markbridge::Renderers::Discourse::Tags::AttachmentTag
+        #     def render(element, interface)
+        #       url = lookup_attachment_url(element.id || element.index)
+        #       alt = element.alt || element.filename || ""
+        #       "![#{alt}](#{url})"
+        #     end
+        #   end
+        #
+        #   library = Markbridge::Renderers::Discourse::TagLibrary.default
+        #   library.register(Markbridge::AST::Attachment, MyAttachmentTag.new)
+        class AttachmentTag < Tag
+          def render(element, interface)
+            # Build metadata comment for downstream processing
+            metadata = build_metadata(element)
+            "<!-- ATTACHMENT: #{metadata} -->"
+          end
+
+          private
+
+          def build_metadata(element)
+            parts = []
+            parts << "id=#{element.id}" if element.id
+            parts << "index=#{element.index}" if element.index
+            parts << "filename=#{element.filename}" if element.filename
+            parts << "alt=#{element.alt}" if element.alt
+
+            parts.empty? ? "UNIDENTIFIED" : parts.join(" ")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Renderers
+    module Discourse
+      module Tags
+        # Tag for rendering bold text
+        class BoldTag < 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/code_tag.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Renderers
+    module Discourse
+      module Tags
+        # Tag for rendering code
+        class CodeTag < Tag
+          def render(element, interface)
+            child_context = interface.with_parent(element)
+            content = interface.render_children(element, context: child_context)
+
+            # Determine if inline or block based on context
+            if interface.block_context?(element)
+              render_block(content, element.language)
+            else
+              render_inline(content)
+            end
+          end
+
+          private
+
+          def render_inline(content)
+            "`#{content}`"
+          end
+
+          def render_block(content, language)
+            fence = calculate_fence(content)
+            lang = language || ""
+
+            "#{fence}#{lang}\n#{content}\n#{fence}"
+          end
+
+          def calculate_fence(content)
+            # Find longest sequence of backticks and tildes
+            max_backticks = content.scan(/`+/).map(&:length).max || 0
+            max_tildes = content.scan(/~+/).map(&:length).max || 0
+
+            # Need fence longer than any sequence in content (minimum 3)
+            required_backticks = [3, max_backticks + 1].max
+            required_tildes = [3, max_tildes + 1].max
+
+            # Choose whichever requires fewer characters
+            if required_backticks <= required_tildes
+              "`" * required_backticks
+            else
+              "~" * required_tildes
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Renderers
+    module Discourse
+      module Tags
+        # Tag for rendering email links
+        class EmailTag < Tag
+          def render(element, interface)
+            child_context = interface.with_parent(element)
+            text = interface.render_children(element, context: child_context)
+            address = element.address
+
+            if address
+              "[#{text}](mailto:#{address})"
+            else
+              text
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Renderers
+    module Discourse
+      module Tags
+        # Placeholder tag for rendering events.
+        #
+        # This is a STUB implementation that outputs the original raw BBCode.
+        # Applications using Markbridge should provide their own custom tag
+        # to render events as placeholders or convert them to another format.
+        #
+        # @example Custom renderer with placeholder
+        #   class MyEventTag < Markbridge::Renderers::Discourse::Tags::EventTag
+        #     def render(element, interface)
+        #       id = register_event(element)
+        #       "<<EVENT:#{id}>>"
+        #     end
+        #   end
+        class EventTag < Tag
+          def render(element, interface)
+            # Return raw BBCode if available, otherwise reconstruct
+            return element.raw if element.raw
+
+            build_event_bbcode(element)
+          end
+
+          private
+
+          def build_event_bbcode(element)
+            attrs = build_attributes(element)
+            "[event#{attrs}]\n[/event]"
+          end
+
+          def build_attributes(element)
+            parts = []
+            parts << %( name="#{element.name}")
+            parts << %( start="#{element.starts_at}")
+            parts << %( end="#{element.ends_at}") if element.ends_at
+            parts << %( status="#{element.status}") if element.status
+            parts << %( timezone="#{element.timezone}") if element.timezone
+
+            parts.join
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Renderers
+    module Discourse
+      module Tags
+        # Tag for rendering headings
+        # Renders as ATX-style Markdown headings (# through ######)
+        class HeadingTag < Tag
+          def render(element, interface)
+            child_context = interface.with_parent(element)
+            content = interface.render_children(element, context: child_context)
+            prefix = "#" * element.level
+
+            "#{prefix} #{content}\n\n"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Renderers
+    module Discourse
+      module Tags
+        # Tag for rendering horizontal rules
+        class HorizontalRuleTag < Tag
+          def render(_element, _interface)
+            "\n\n---\n\n"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Renderers
+    module Discourse
+      module Tags
+        # Tag for rendering images
+        # Renders to Markdown image syntax with optional Discourse sizing
+        class ImageTag < Tag
+          def render(element, interface)
+            src = element.src || ""
+            width = element.width
+            height = element.height
+
+            # Build Discourse image syntax with dimensions
+            # Format: ![alt|WIDTHxHEIGHT](url) or ![alt|WIDTH](url)
+            if width && height
+              "![|#{width}x#{height}](#{src})"
+            elsif width
+              "![|#{width}](#{src})"
+            else
+              "![](#{src})"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Renderers
+    module Discourse
+      module Tags
+        # Tag for rendering italic text
+        class ItalicTag < 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/line_break_tag.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Renderers
+    module Discourse
+      module Tags
+        # Tag for rendering line breaks
+        class LineBreakTag < Tag
+          def render(_element, _interface)
+            "\n"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Renderers
+    module Discourse
+      module Tags
+        # Tag for rendering list items
+        class ListItemTag < Tag
+          def initialize
+            super
+            @builder = Builders::ListItemBuilder.new
+          end
+
+          def render(element, interface)
+            # Create new context with this list item as parent
+            child_context = interface.with_parent(element)
+
+            # Render children with updated context
+            content = interface.render_children(element, context: child_context).strip
+            return "" if content.empty?
+
+            # Get parent list to determine marker
+            parent_list = interface.find_parent(AST::List)
+            marker = determine_marker(parent_list)
+
+            # Calculate indentation based on ancestor lists
+            indent = calculate_indent(interface)
+
+            # Delegate formatting to builder
+            @builder.build(content, marker:, indent:)
+          end
+
+          private
+
+          # Determine the list marker based on parent list type
+          # @param parent_list [AST::List, nil]
+          # @return [String]
+          def determine_marker(parent_list)
+            parent_list&.ordered? ? "1. " : "- "
+          end
+
+          # Calculate indentation for this list item
+          # @param interface [RenderingInterface]
+          # @return [String]
+          def calculate_indent(interface)
+            # Calculate indentation: count ancestor Lists (not including direct parent)
+            # The direct parent List shouldn't add indentation, only grandparent Lists
+            list_count = interface.count_parents(AST::List)
+            # Subtract 1 because the immediate parent list doesn't contribute to indent
+            ancestor_lists = list_count.positive? ? list_count - 1 : 0
+
+            # Indentation width depends on markers of ancestor lists
+            # Walk up the context to determine correct indentation
+            calculate_indent_from_ancestors(interface.context, ancestor_lists)
+          end
+
+          # Calculate the correct indentation for nested list items
+          # Each level matches the marker width of its parent: ordered="1. " (3 chars), unordered="- " (2 chars)
+          # @param context [RenderContext] the rendering context
+          # @param ancestor_count [Integer] number of ancestor lists
+          # @return [String] the indentation string
+          def calculate_indent_from_ancestors(context, ancestor_count)
+            return "" if ancestor_count.zero?
+
+            # Walk through parents from outermost to innermost to build indentation
+            # Each ancestor contributes indentation based on ITS OWN marker width
+            lists = context.parents.select { |p| p.is_a?(AST::List) }
+
+            # Skip the immediate parent (last list in the array)
+            ancestor_lists = lists[0...-1]
+
+            # Build indentation string
+            indent = ""
+            ancestor_lists
+              .first(ancestor_count)
+              .each do |list|
+                # Each level's indentation matches that list's marker width
+                indent += list.ordered? ? "   " : "  "
+              end
+
+            indent
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Renderers
+    module Discourse
+      module Tags
+        # Tag for rendering lists
+        class ListTag < Tag
+          def render(element, interface)
+            # Create new context with this list as parent
+            child_context = interface.with_parent(element)
+
+            # Render children with updated context, dropping empty items
+            rendered_items =
+              element.children.filter_map do |child|
+                rendered = interface.render_node(child, context: child_context)
+                rendered unless rendered.strip.empty?
+              end
+
+            content = rendered_items.join
+
+            # Check if we're nested - either inside another List OR inside a ListItem
+            has_list_parent = interface.has_parent?(AST::List)
+            has_list_item_parent = interface.has_parent?(AST::ListItem)
+            nested = has_list_parent || has_list_item_parent
+
+            if nested
+              # Nested list: add leading newline so it starts on its own line
+              "\n#{content}"
+            else
+              # Top-level list: add spacing
+              "\n\n#{content}\n\n"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Renderers
+    module Discourse
+      module Tags
+        # Placeholder tag for rendering mentions.
+        #
+        # This is a STUB implementation that outputs a placeholder.
+        # Applications using Markbridge should provide their own custom tag
+        # or use the raw mention format.
+        #
+        # @example Custom renderer that preserves original format
+        #   class MyMentionTag < Markbridge::Renderers::Discourse::Tags::MentionTag
+        #     def render(element, interface)
+        #       "@#{element.name}"
+        #     end
+        #   end
+        #
+        # @example Custom renderer that links to user
+        #   class MyMentionTag < Markbridge::Renderers::Discourse::Tags::MentionTag
+        #     def render(element, interface)
+        #       "[@#{element.name}](/u/#{element.name})"
+        #     end
+        #   end
+        class MentionTag < Tag
+          def render(element, interface)
+            "@#{element.name}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Renderers
+    module Discourse
+      module Tags
+        # Tag for rendering paragraphs
+        # Paragraphs are separated by blank lines in Markdown
+        class ParagraphTag < Tag
+          def render(element, interface)
+            child_context = interface.with_parent(element)
+            content = interface.render_children(element, context: child_context)
+
+            # Paragraph followed by blank line (two newlines)
+            "#{content}\n\n"
+          end
+        end
+      end
+    end
+  end
+end