markbridge 0.2.0 → 0.3.0

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

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-module Markbridge
-  module Processors
-    module DiscourseMarkdown
-      module Detectors
-        # Result of a successful detection
-        # @attr_reader start_pos [Integer] start position in input
-        # @attr_reader end_pos [Integer] end position in input (exclusive)
-        # @attr_reader node [AST::Node] the AST node representing the detected construct
-        Match = Data.define(:start_pos, :end_pos, :node)
-
-        # Base class for construct detectors.
-        # Subclasses implement detection logic for specific constructs
-        # (mentions, polls, events, uploads).
-        #
-        # @abstract Subclass and implement {#detect}
-        class Base
-          # Attempt to detect a construct 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)
-            raise NotImplementedError, "#{self.class} must implement #detect"
-          end
-
-          private
-
-          # Helper to check if position is at a word boundary (for mentions, etc.)
-          # @param input [String] the input string
-          # @param pos [Integer] position to check
-          # @return [Boolean] true if at word boundary
-          def word_boundary?(input, pos)
-            return true if pos == 0
-
-            prev_char = input[pos - 1]
-            !prev_char.match?(/\w/)
-          end
-
-          WORD_PATTERN = /\A[\w\-]*/
-          private_constant :WORD_PATTERN
-
-          # Helper to extract a word starting at position. Caller must ensure
-          # pos is within input bounds (`pos <= input.length`).
-          # @param input [String] the input string
-          # @param pos [Integer] starting position
-          # @return [String] the word (may be empty)
-          def extract_word(input, pos)
-            input[pos..].match(WORD_PATTERN)[0]
-          end
-
-          # Parse key="value" or key='value' attribute pairs from a string.
-          # @param attr_string [String] the attribute string to parse
-          # @return [Hash<String, String>] parsed attributes with downcased keys
-          def parse_attributes(attr_string)
-            attr_string.scan(/(\w+)=["']([^"']*)["']/).to_h.transform_keys(&:downcase)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-module Markbridge
-  module Processors
-    module DiscourseMarkdown
-      module Detectors
-        # Detects Discourse event blocks [event]...[/event].
-        #
-        # @example
-        #   detector = Event.new
-        #   input = '[event name="Meeting" start="2025-12-15 14:00"][/event]'
-        #   match = detector.detect(input, 0)
-        #   match.node.name # => "Meeting"
-        class Event < Base
-          OPEN_TAG_PATTERN = /\[event(?<attrs>[^\]]*)\]/i
-          CLOSE_TAG_PATTERN = %r{\[/event\]}i
-
-          # Attempt to detect an event 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)
-            remaining = input[pos..]
-            open_match = OPEN_TAG_PATTERN.match(remaining)
-            return nil unless open_match&.begin(0)&.zero?
-
-            # Find closing tag. The opening tag pattern forbids `]` between
-            # `[event` and its closing `]`, so `[/event]` cannot appear inside
-            # the opening tag - no need to skip past it.
-            close_match = CLOSE_TAG_PATTERN.match(remaining)
-            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[:attrs])
-
-            # Validate required attributes
-            name = attrs["name"]
-            starts_at = attrs["start"]
-            return nil if name.nil? || starts_at.nil?
-
-            node =
-              AST::Event.new(
-                name:,
-                starts_at:,
-                ends_at: attrs["end"],
-                status: attrs["status"],
-                timezone: attrs["timezone"],
-                raw:,
-              )
-
-            Match.new(start_pos: pos, end_pos:, node:)
-          end
-
-          private
-        end
-      end
-    end
-  end
-end

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

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-module Markbridge
-  module Processors
-    module DiscourseMarkdown
-      module Detectors
-        # Detects user and group mentions (@username, @groupname).
-        #
-        # @example Basic usage
-        #   detector = Mention.new
-        #   match = detector.detect("Hello @gerhard!", 6)
-        #   match.node.name # => "gerhard"
-        #   match.node.type # => :user (default)
-        #
-        # @example With type resolver
-        #   resolver = ->(name) { name == "Testers" ? :group : :user }
-        #   detector = Mention.new(type_resolver: resolver)
-        #   match = detector.detect("@Testers", 0)
-        #   match.node.type # => :group
-        class Mention < Base
-          # @param type_resolver [#call, nil] callable that takes a name and returns :user or :group
-          def initialize(type_resolver: nil)
-            @type_resolver = type_resolver
-          end
-
-          # Attempt to detect a mention 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] == "@"
-            return nil unless word_boundary?(input, pos)
-
-            # Extract the username/group name
-            name = extract_word(input, pos + 1)
-            return nil if name.empty?
-
-            end_pos = pos + 1 + name.length
-            type = resolve_type(name)
-            node = AST::Mention.new(name:, type:)
-
-            Match.new(start_pos: pos, end_pos:, node:)
-          end
-
-          private
-
-          def resolve_type(name)
-            return :user unless @type_resolver
-
-            @type_resolver.call(name) || :user
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,52 +0,0 @@
-# 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
-          TAG_PATTERN = %r{\A\[poll(?<attrs>[^\]]*)\](?<content>.*?)\[/poll\]}im
-
-          # 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)
-            match = TAG_PATTERN.match(input[pos..])
-            return nil unless match
-
-            attrs = parse_attributes(match[:attrs])
-            node =
-              AST::Poll.new(
-                name: attrs["name"] || "poll",
-                type: attrs["type"],
-                results: attrs["results"],
-                public: attrs["public"] == "true",
-                chart_type: attrs["charttype"],
-                options: extract_options(match[:content]),
-                raw: match[0],
-              )
-
-            Match.new(start_pos: pos, end_pos: pos + match.end(0), node:)
-          end
-
-          private
-
-          OPTION_PATTERN = /\A\s*(?:\*\s|-\s|\d+\.\s+)(?<value>.+?)\s*\z/
-
-          def extract_options(content)
-            content.each_line.filter_map { |line| OPTION_PATTERN.match(line)&.[](:value) }
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,98 +0,0 @@
-# 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
-          # Image: ![alt|dimensions](upload://sha1.ext)
-          IMAGE_PATTERN =
-            %r{\A!\[(?<alt>[^|\]]*)(?:\|(?<dimensions>[^\]]*))?\]\(upload://(?<url>[^)]+)\)}
-
-          # Attachment: [filename|attachment](upload://sha1.ext) (size)
-          ATTACHMENT_PATTERN =
-            %r{
-            \A
-            \[(?<filename>[^|\]]*)\|attachment\]
-            \(upload://(?<url>[^)]+)\)
-            (?:\s*\((?<size>[^)]+)\))?
-          }xi
-
-          # 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)
-            remaining = input[pos..]
-            case input[pos]
-            when "!"
-              detect_image(remaining, pos)
-            when "["
-              detect_attachment(remaining, pos)
-            end
-          end
-
-          private
-
-          def detect_image(remaining, pos)
-            match = IMAGE_PATTERN.match(remaining)
-            return nil unless match
-
-            sha1, filename = parse_upload_url(match[:url])
-            alt = match[:alt]
-            alt = nil if alt.empty?
-
-            # `type: :image` is omitted because it is AST::Upload's default -
-            # passing it explicitly was an equivalent-mutation surface.
-            node =
-              AST::Upload.new(sha1:, filename:, alt:, dimensions: match[:dimensions], raw: match[0])
-
-            Match.new(start_pos: pos, end_pos: pos + match[0].length, node:)
-          end
-
-          def detect_attachment(remaining, pos)
-            match = ATTACHMENT_PATTERN.match(remaining)
-            return nil unless match
-
-            sha1, = parse_upload_url(match[:url])
-
-            node =
-              AST::Upload.new(
-                sha1:,
-                filename: match[:filename],
-                type: :attachment,
-                size: match[:size],
-                raw: match[0],
-              )
-
-            Match.new(start_pos: pos, end_pos: pos + match[0].length, node:)
-          end
-
-          # URL format: sha1.ext or just sha1. Returns [sha1, filename-or-nil].
-          def parse_upload_url(url_part)
-            sha1, _, ext = url_part.partition(".")
-            [sha1, ext.empty? ? nil : url_part]
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,194 +0,0 @@
-# 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
-          # @code_tracker / @result / @nodes / @node_index / @pos / @input /
-          # @line_start are set by #scan before use; no defensive init needed.
-        end
-
-        # Scan input and extract constructs.
-        #
-        # @param input [String] Discourse Markdown input
-        # @return [ScanResult] result containing processed markdown and extracted nodes
-        def scan(input)
-          @code_tracker = CodeBlockTracker.new
-          @result = +""
-          @nodes = []
-          @node_index = 0
-          @pos = 0
-          @input = input.to_s
-          @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 == Detectors::Mention
-              klass.new(type_resolver: mention_resolver)
-            else
-              klass.new
-            end
-          end
-        end
-
-        def scan_input
-          while @pos < @input.length
-            # Check for fenced code block boundary at line start
-            if @line_start
-              next if advance_code_boundary(:check_fenced_boundary)
-              next if advance_code_boundary(:check_indented_boundary)
-            end
-
-            # Check for inline code boundary. check_inline_boundary's
-            # own fenced/indented guard means we don't need to pre-check
-            # here — it'll just return nil in those cases.
-            if @input[@pos] == "`"
-              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 advance_code_boundary(method)
-          new_pos = @code_tracker.public_send(method, @input, @pos, line_start: true)
-          return false unless new_pos
-
-          # check_fenced_boundary / check_indented_boundary always stop
-          # at pos_after_line, which is either after a "\n" or at EOF.
-          # After-newline → @line_start should be true; at EOF the
-          # outer `while @pos < @input.length` exits and @line_start
-          # is unobservable. Setting true unconditionally drops the
-          # `@input[new_pos - 1] == "\n"` dance.
-          @result << @input[@pos...new_pos]
-          @pos = new_pos
-          @line_start = true
-          true
-        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
-          @result << render_placeholder(node)
-
-          # Every detector shipped today matches content that ends on a
-          # non-newline byte (`]`, `)`, `_`, alphanumeric), so @line_start
-          # is always false after a successful match. If a future custom
-          # detector produces a match whose end_pos sits right after
-          # "\n", re-introduce the `@input[@pos - 1] == "\n"` check.
-          @pos = match.end_pos
-          @line_start = false
-          @node_index += 1
-        end
-
-        def render_placeholder(node)
-          if @tag_library
-            tag = @tag_library[node.class]
-            return tag.render(node, nil) if tag
-          end
-
-          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}>>"
-          end
-        end
-      end
-    end
-  end
-end

data/lib/markbridge/processors/discourse_markdown.rb

@@ -1,16 +0,0 @@
-# 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

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