markbridge 0.1.0

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Processors
+    module DiscourseMarkdown
+      module Detectors
+        # Detects Discourse poll blocks [poll]...[/poll].
+        #
+        # @example
+        #   detector = Poll.new
+        #   input = "[poll type=\"regular\"]\n* A\n* B\n[/poll]"
+        #   match = detector.detect(input, 0)
+        #   match.node.type # => "regular"
+        class Poll < Base
+          OPEN_TAG_PATTERN = /\[poll([^\]]*)\]/i
+          CLOSE_TAG_PATTERN = %r{\[/poll\]}i
+
+          # Attempt to detect a poll 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])
+
+            # Extract options from content between tags
+            content = remaining[open_match.end(0)...close_match.begin(0)]
+            options = extract_options(content)
+
+            node =
+              AST::Poll.new(
+                name: attrs["name"] || "poll",
+                type: attrs["type"],
+                results: attrs["results"],
+                public: attrs["public"] == "true",
+                chart_type: attrs["charttype"] || attrs["chartType"],
+                options:,
+                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
+
+          def extract_options(content)
+            options = []
+            content.each_line do |line|
+              line = line.strip
+              if line.start_with?("* ")
+                options << line[2..].strip
+              elsif line.start_with?("- ")
+                options << line[2..].strip
+              elsif line.match?(/^\d+\.\s/)
+                options << line.sub(/^\d+\.\s*/, "").strip
+              end
+            end
+            options
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Processors
+    module DiscourseMarkdown
+      module Detectors
+        # Detects Discourse upload references using upload:// URLs.
+        #
+        # Supports two formats:
+        # - Images: ![alt|dimensions](upload://sha1.ext)
+        # - Attachments: [filename|attachment](upload://sha1.ext) (size)
+        #
+        # @example Image
+        #   detector = Upload.new
+        #   input = "![logo|64x64](upload://abc123.png)"
+        #   match = detector.detect(input, 0)
+        #   match.node.type # => :image
+        #
+        # @example Attachment
+        #   detector = Upload.new
+        #   input = "[doc.pdf|attachment](upload://xyz789.pdf) (1.2 MB)"
+        #   match = detector.detect(input, 0)
+        #   match.node.type # => :attachment
+        class Upload < Base
+          # Pattern for image: ![alt|dimensions](upload://sha1.ext)
+          IMAGE_PATTERN = %r{!\[([^\]]*)\]\(upload://([^)]+)\)}
+
+          # Pattern for attachment: [filename|attachment](upload://sha1.ext) followed by optional (size)
+          ATTACHMENT_PATTERN = %r{\[([^\]]*\|attachment)\]\(upload://([^)]+)\)(\s*\([^)]+\))?}
+
+          # Attempt to detect an upload 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)
+            char = input[pos]
+            return nil unless char == "!" || char == "["
+
+            remaining = input[pos..]
+
+            if char == "!"
+              detect_image(remaining, pos)
+            else
+              detect_attachment(remaining, pos)
+            end
+          end
+
+          private
+
+          def detect_image(remaining, pos)
+            match = IMAGE_PATTERN.match(remaining)
+            return nil unless match&.begin(0)&.zero?
+
+            raw = match[0]
+            alt_part = match[1]
+            url_part = match[2]
+
+            # Parse alt and dimensions from "alt|dimensions" format
+            alt, dimensions = parse_alt_dimensions(alt_part)
+
+            # Extract SHA1 and filename from URL
+            sha1, filename = parse_upload_url(url_part)
+
+            node = AST::Upload.new(sha1:, filename:, type: :image, alt:, dimensions:, raw:)
+
+            Match.new(start_pos: pos, end_pos: pos + raw.length, node:)
+          end
+
+          def detect_attachment(remaining, pos)
+            match = ATTACHMENT_PATTERN.match(remaining)
+            return nil unless match&.begin(0)&.zero?
+
+            raw = match[0]
+            name_part = match[1]
+            url_part = match[2]
+            size_part = match[3]
+
+            # Parse filename from "filename|attachment" format
+            filename = name_part.sub(/\|attachment$/i, "")
+
+            # Extract SHA1 from URL
+            sha1, _url_filename = parse_upload_url(url_part)
+
+            # Parse size if present
+            size = size_part&.strip&.delete_prefix("(")&.delete_suffix(")")
+
+            node = AST::Upload.new(sha1:, filename:, type: :attachment, size:, raw:)
+
+            Match.new(start_pos: pos, end_pos: pos + raw.length, node:)
+          end
+
+          def parse_alt_dimensions(alt_part)
+            return nil, nil if alt_part.nil? || alt_part.empty?
+
+            if alt_part.include?("|")
+              parts = alt_part.split("|", 2)
+              alt = parts[0].empty? ? nil : parts[0]
+              dimensions = parts[1]
+              [alt, dimensions]
+            else
+              [alt_part, nil]
+            end
+          end
+
+          def parse_upload_url(url_part)
+            # URL format: sha1.ext or just sha1
+            if url_part.include?(".")
+              parts = url_part.split(".", 2)
+              sha1 = parts[0]
+              filename = url_part
+            else
+              sha1 = url_part
+              filename = nil
+            end
+
+            [sha1, filename]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Processors
+    module DiscourseMarkdown
+      # Result of scanning Discourse Markdown
+      # @attr_reader markdown [String] the processed markdown with placeholders
+      # @attr_reader nodes [Array<AST::Node>] extracted AST nodes in order of appearance
+      ScanResult = Data.define(:markdown, :nodes)
+
+      # Single-pass scanner for Discourse Markdown that extracts specific constructs
+      # (mentions, polls, events, uploads) while preserving all other content unchanged.
+      #
+      # The scanner respects code blocks (fenced, indented, and inline) and will not
+      # extract constructs that appear within code.
+      #
+      # @example Basic usage
+      #   scanner = Scanner.new
+      #   result = scanner.scan("Hello @gerhard!")
+      #   result.nodes.first # => AST::Mention
+      #
+      # @example With custom tag library for rendering
+      #   scanner = Scanner.new(tag_library: my_library)
+      #   result = scanner.scan(input)
+      #   result.markdown # => "Hello <<MENTION:1>>!"
+      #
+      # @example With mention type resolver
+      #   scanner = Scanner.new(mention_resolver: ->(name) {
+      #     groups.include?(name) ? :group : :user
+      #   })
+      #   result = scanner.scan("@Testers and @gerhard")
+      #   result.nodes[0].type # => :group
+      #   result.nodes[1].type # => :user
+      class Scanner
+        # Default detectors in priority order
+        DEFAULT_DETECTORS = [
+          Detectors::Poll,
+          Detectors::Event,
+          Detectors::Upload,
+          Detectors::Mention,
+        ].freeze
+
+        # Characters that can start a construct (for fast bailout)
+        TRIGGER_CHARS = Set.new(["@", "[", "!"]).freeze
+
+        # @param detectors [Array<Class>] detector classes to use (instantiated automatically)
+        # @param tag_library [Renderers::Discourse::TagLibrary, nil] tag library for rendering placeholders
+        # @param mention_resolver [#call, nil] callable that takes a name and returns :user or :group
+        def initialize(detectors: DEFAULT_DETECTORS, tag_library: nil, mention_resolver: nil)
+          @detector_instances = build_detectors(detectors, mention_resolver)
+          @tag_library = tag_library
+        end
+
+        # Scan input and extract constructs.
+        #
+        # @param input [String] Discourse Markdown input
+        # @return [ScanResult] result containing processed markdown and extracted nodes
+        def scan(input)
+          return ScanResult.new(markdown: "", nodes: []) if input.nil? || input.empty?
+
+          @code_tracker = CodeBlockTracker.new
+          @result = +""
+          @nodes = []
+          @node_index = 0
+          @pos = 0
+          @input = input
+          @line_start = true
+
+          scan_input
+
+          ScanResult.new(markdown: @result, nodes: @nodes)
+        end
+
+        private
+
+        def build_detectors(detectors, mention_resolver)
+          detectors.map do |klass|
+            if klass.is_a?(Class)
+              if klass == Detectors::Mention && mention_resolver
+                klass.new(type_resolver: mention_resolver)
+              else
+                klass.new
+              end
+            else
+              klass
+            end
+          end
+        end
+
+        def scan_input
+          while @pos < @input.length
+            # Check for fenced code block boundary at line start
+            if @line_start
+              new_pos = @code_tracker.check_fenced_boundary(@input, @pos, line_start: true)
+              if new_pos
+                @result << @input[@pos...new_pos]
+                @pos = new_pos
+                @line_start = new_pos > 0 && @input[new_pos - 1] == "\n"
+                next
+              end
+
+              # Check for indented code block (4+ spaces or tab)
+              new_pos = @code_tracker.check_indented_boundary(@input, @pos, line_start: true)
+              if new_pos
+                @result << @input[@pos...new_pos]
+                @pos = new_pos
+                @line_start = new_pos > 0 && @input[new_pos - 1] == "\n"
+                next
+              end
+            end
+
+            # Check for inline code boundary
+            if @input[@pos] == "`" && !@code_tracker.in_fenced_block &&
+                 !@code_tracker.in_indented_block
+              new_pos = @code_tracker.check_inline_boundary(@input, @pos)
+              if new_pos
+                @result << @input[@pos...new_pos]
+                @pos = new_pos
+                @line_start = false
+                next
+              end
+            end
+
+            # If in code, pass through unchanged
+            if @code_tracker.in_code?
+              @result << @input[@pos]
+              @line_start = @input[@pos] == "\n"
+              @pos += 1
+              next
+            end
+
+            # Fast path: only try detectors if current char could start a construct
+            char = @input[@pos]
+            if TRIGGER_CHARS.include?(char)
+              match = detect_at_position
+              if match
+                handle_match(match)
+                next
+              end
+            end
+
+            @result << char
+            @line_start = char == "\n"
+            @pos += 1
+          end
+        end
+
+        def detect_at_position
+          @detector_instances.each do |detector|
+            match = detector.detect(@input, @pos)
+            return match if match
+          end
+          nil
+        end
+
+        def handle_match(match)
+          node = match.node
+          @nodes << node
+
+          # Render placeholder using tag library if available
+          placeholder = render_placeholder(node)
+          @result << placeholder
+
+          @pos = match.end_pos
+          @line_start = @pos > 0 && @input[@pos - 1] == "\n"
+          @node_index += 1
+        end
+
+        def render_placeholder(node)
+          if @tag_library
+            tag = @tag_library[node.class]
+            if tag
+              # Create a minimal interface for rendering
+              return tag.render(node, nil)
+            end
+          end
+
+          # Default placeholder format if no tag library or tag not found
+          default_placeholder(node)
+        end
+
+        def default_placeholder(node)
+          case node
+          when AST::Mention
+            "<<MENTION:#{@node_index}:#{node.name}>>"
+          when AST::Poll
+            "<<POLL:#{@node_index}:#{node.name}>>"
+          when AST::Event
+            "<<EVENT:#{@node_index}:#{node.name}>>"
+          when AST::Upload
+            "<<UPLOAD:#{@node_index}:#{node.sha1}>>"
+          else
+            "<<UNKNOWN:#{@node_index}>>"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/markbridge/processors/discourse_markdown.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "discourse_markdown/code_block_tracker"
+require_relative "discourse_markdown/detectors/base"
+require_relative "discourse_markdown/detectors/mention"
+require_relative "discourse_markdown/detectors/poll"
+require_relative "discourse_markdown/detectors/event"
+require_relative "discourse_markdown/detectors/upload"
+require_relative "discourse_markdown/scanner"
+
+module Markbridge
+  module Processors
+    module DiscourseMarkdown
+    end
+  end
+end

data/lib/markbridge/processors.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative "processors/discourse_markdown"
+
+module Markbridge
+  module Processors
+  end
+end

data/lib/markbridge/renderers/discourse/builders/list_item_builder.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Markbridge
+  module Renderers
+    module Discourse
+      module Builders
+        # Builder for list item formatting
+        # Handles complex multi-line formatting with proper indentation
+        # and preservation of blank lines and nested list items
+        class ListItemBuilder
+          # Build a formatted list item string
+          # @param content [String] the item content
+          # @param marker [String] the list marker ("- " or "1. ")
+          # @param indent [String] the indentation string
+          # @return [String]
+          def build(content, marker:, indent:)
+            lines = content.split("\n")
+            lines = [""] if lines.empty? # Handle empty content
+            first_line = "#{indent}#{marker}#{lines.first}"
+
+            return "#{first_line}\n" if lines.size == 1
+
+            # Handle multi-line content with sophisticated blank line handling
+            format_multiline(lines, first_line, indent)
+          end
+
+          private
+
+          # Format multi-line content with proper indentation
+          # @param lines [Array<String>] content lines
+          # @param first_line [String] the formatted first line
+          # @param indent [String] base indentation
+          # @return [String]
+          def format_multiline(lines, first_line, indent)
+            continuation_indent = "#{indent}  "
+            continuation_lines = lines[1..]
+
+            rest =
+              continuation_lines.each_with_index.filter_map do |line, idx|
+                format_continuation_line(line, idx, continuation_lines, continuation_indent)
+              end
+
+            "#{([first_line] + rest).join("\n")}\n"
+          end
+
+          # Format a single continuation line
+          # @param line [String] the line to format
+          # @param idx [Integer] index in continuation_lines array
+          # @param continuation_lines [Array<String>] all continuation lines
+          # @param continuation_indent [String] indent for continuation
+          # @return [String, nil] formatted line or nil to skip
+          def format_continuation_line(line, idx, continuation_lines, continuation_indent)
+            # Handle empty lines
+            return handle_empty_line(idx, continuation_lines, continuation_indent) if line.empty?
+
+            # Check if line is already a list item (has indentation + marker)
+            if line.match?(/\A\s*(?:-|\d+\.)\s/)
+              # Already a list item - don't add extra indentation
+              line
+            else
+              # Regular continuation line - add indentation
+              "#{continuation_indent}#{line}"
+            end
+          end
+
+          # Handle empty lines in continuation
+          # @param idx [Integer] index in continuation_lines
+          # @param continuation_lines [Array<String>] all continuation lines
+          # @param continuation_indent [String] indent for continuation
+          # @return [String, nil] formatted line or nil to skip
+          def handle_empty_line(idx, continuation_lines, continuation_indent)
+            # Skip empty lines that come before nested list items (structural blanks)
+            next_line = continuation_lines[idx + 1]
+            return nil if next_line&.match?(/\A\s*(?:-|\d+\.)\s/)
+
+            # Preserve empty lines within text content (paragraph breaks) with indentation
+            continuation_indent
+          end
+        end
+      end
+    end
+  end
+end