markdown-merge 1.0.3 → 7.1.1

data/lib/markdown/merge/backend_support.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+module Markdown
+  module Merge
+    # Shared boilerplate for backend-specific Markdown wrapper backends.
+    module BackendSupport
+      DEFAULT_CAPABILITIES = {
+        query: false,
+        bytes_field: false,
+        incremental: false,
+        pure_ruby: false,
+        markdown_only: true,
+        error_tolerant: true
+      }.freeze
+
+      module_function
+
+      def install!(backend_module:, backend_name:, gem_name:, require_path:, capabilities: {})
+        install_availability_methods!(
+          backend_module: backend_module,
+          backend_name: backend_name,
+          gem_name: gem_name,
+          capabilities: capabilities
+        )
+        install_tree_wrapper!(backend_module)
+        register_backend!(
+          backend_module: backend_module,
+          backend_name: backend_name,
+          gem_name: gem_name,
+          require_path: require_path
+        )
+      end
+
+      def configure_markdown_only_language_class!(klass, backend_label:, factory_method: :markdown,
+                                                  unsupported_language_message: nil)
+        klass.singleton_class.class_eval do
+          define_method(:from_library) do |_path = nil, symbol: nil, name: nil|
+            lang_name = name || symbol&.to_s&.sub(/^tree_sitter_/, '')&.to_sym || :markdown
+
+            unless lang_name == :markdown
+              message = if unsupported_language_message.respond_to?(:call)
+                          unsupported_language_message.call(lang_name)
+                        else
+                          unsupported_language_message || "#{backend_label} backend only supports Markdown, not #{lang_name}."
+                        end
+              raise TreeHaver::NotAvailable, message
+            end
+
+            public_send(factory_method)
+          end
+        end
+      end
+
+      def configure_node_link_and_navigation!(klass, next_sibling_selector:, prev_sibling_selector:,
+                                              parent_selector: :parent)
+        klass.class_eval do
+          define_method(:url) do
+            Markdown::Merge::BackendSupport.send(:safe_inner_node_call, inner_node, :url)
+          end
+
+          define_method(:title) do
+            Markdown::Merge::BackendSupport.send(:safe_inner_node_call, inner_node, :title)
+          end
+
+          define_method(:next_sibling) do
+            sibling = Markdown::Merge::BackendSupport.send(:safe_inner_node_call, inner_node, next_sibling_selector)
+            sibling ? self.class.new(sibling, source: source, lines: lines) : nil
+          end
+
+          define_method(:prev_sibling) do
+            sibling = Markdown::Merge::BackendSupport.send(:safe_inner_node_call, inner_node, prev_sibling_selector)
+            sibling ? self.class.new(sibling, source: source, lines: lines) : nil
+          end
+
+          define_method(:parent) do
+            parent_node = Markdown::Merge::BackendSupport.send(:safe_inner_node_call, inner_node, parent_selector)
+            parent_node ? self.class.new(parent_node, source: source, lines: lines) : nil
+          end
+        end
+      end
+
+      def configure_node_heading_and_code_block_helpers!(klass, heading_matcher:, code_block_matcher:,
+                                                         heading_level_extractor: nil,
+                                                         code_block_info_extractor: nil)
+        klass.class_eval do
+          define_method(:header_level) do
+            return unless Markdown::Merge::BackendSupport.send(:node_helper_match?, self, heading_matcher)
+
+            if heading_level_extractor.respond_to?(:call)
+              heading_level_extractor.call(inner_node)
+            else
+              Markdown::Merge::BackendSupport.send(:safe_inner_node_call, inner_node, :header_level)
+            end
+          end
+
+          define_method(:fence_info) do
+            return unless Markdown::Merge::BackendSupport.send(:node_helper_match?, self, code_block_matcher)
+
+            if code_block_info_extractor.respond_to?(:call)
+              code_block_info_extractor.call(inner_node)
+            else
+              Markdown::Merge::BackendSupport.send(:safe_inner_node_call, inner_node, :fence_info)
+            end
+          end
+        end
+      end
+
+      def install_availability_methods!(backend_module:, backend_name:, gem_name:, capabilities: {})
+        backend_module.instance_variable_set(:@load_attempted, false)
+        backend_module.instance_variable_set(:@loaded, false)
+
+        merged_capabilities = DEFAULT_CAPABILITIES.merge(backend: backend_name).merge(capabilities)
+
+        backend_module.singleton_class.class_eval do
+          define_method(:available?) do
+            return @loaded if @load_attempted
+
+            @load_attempted = true
+            begin
+              require gem_name
+              @loaded = true
+            rescue LoadError, StandardError
+              @loaded = false
+            end
+            @loaded
+          end
+
+          define_method(:reset!) do
+            @load_attempted = false
+            @loaded = false
+          end
+
+          define_method(:capabilities) do
+            return {} unless available?
+
+            merged_capabilities.dup
+          end
+        end
+      end
+      private_class_method :install_availability_methods!
+
+      def install_tree_wrapper!(backend_module)
+        return if backend_module.const_defined?(:Tree, false)
+
+        tree_class = Class.new(::TreeHaver::Base::Tree) do
+          define_method(:initialize) do |document, source|
+            super(document, source: source)
+          end
+
+          define_method(:root_node) do
+            backend_module.const_get(:Node).new(inner_tree, source: source, lines: lines)
+          end
+        end
+
+        backend_module.const_set(:Tree, tree_class)
+        backend_module.const_set(:Point, ::TreeHaver::Base::Point) unless backend_module.const_defined?(:Point, false)
+      end
+      private_class_method :install_tree_wrapper!
+
+      def register_backend!(backend_module:, backend_name:, gem_name:, require_path:)
+        ::TreeHaver::BackendRegistry.register(
+          ::TreeHaver::BackendReference.new(id: backend_name.to_s, family: 'native')
+        )
+
+        ::TreeHaver.register_language(
+          :markdown,
+          backend_type: backend_name,
+          backend_module: backend_module,
+          gem_name: gem_name
+        )
+
+        if ::TreeHaver::BackendRegistry.respond_to?(:register_tag)
+          ::TreeHaver::BackendRegistry.register_tag(
+            :"#{backend_name}_backend",
+            category: :backend,
+            backend_name: backend_name,
+            require_path: require_path
+          ) { backend_module.available? }
+        else
+          ::TreeHaver::BackendRegistry.register_availability_checker(backend_name) do
+            backend_module.available?
+          end
+        end
+      end
+      private_class_method :register_backend!
+
+      def safe_inner_node_call(node, method_name)
+        node.public_send(method_name)
+      rescue StandardError
+        nil
+      end
+      private_class_method :safe_inner_node_call
+
+      def node_helper_match?(node, matcher)
+        matcher.respond_to?(:call) ? matcher.call(node) : false
+      end
+      private_class_method :node_helper_match?
+    end
+  end
+end

data/lib/markdown/merge/cleanse/block_spacing.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "parslet"
+require 'parslet'
 
 module Markdown
   module Merge
@@ -34,9 +34,9 @@ module Markdown
         THEMATIC_BREAK = /\A\s*(?:---+|\*\*\*+|___+)\s*\z/
         HEADING = /\A\s*\#{1,6}\s+/
         LIST_ITEM = /\A\s*(?:[-*+]|\d+\.)\s+/
-        HTML_CLOSE_TAG = /\A\s*<\/[a-zA-Z][a-zA-Z0-9]*>\s*\z/
+        HTML_CLOSE_TAG = %r{\A\s*</[a-zA-Z][a-zA-Z0-9]*>\s*\z}
         HTML_OPEN_TAG = /\A\s*<[a-zA-Z][a-zA-Z0-9]*(?:\s|>)/
-        HTML_ANY_TAG = /\A\s*<\/?[a-zA-Z]/
+        HTML_ANY_TAG = %r{\A\s*</?[a-zA-Z]}
         LINK_REF_DEF = /\A\s*\[[^\]]+\]:\s*/
 
         # Block-level HTML elements that can span multiple lines
@@ -75,24 +75,25 @@ module Markdown
         ].freeze
 
         # Pattern to match opening block-level HTML tags
-        HTML_BLOCK_OPEN = /\A\s*<(#{HTML_BLOCK_ELEMENTS.join("|")})(?:\s|>)/i
+        HTML_BLOCK_OPEN = /\A\s*<(#{HTML_BLOCK_ELEMENTS.join('|')})(?:\s|>)/i
 
         # Pattern to match closing block-level HTML tags
-        HTML_BLOCK_CLOSE = /\A\s*<\/(#{HTML_BLOCK_ELEMENTS.join("|")})>/i
+        HTML_BLOCK_CLOSE = %r{\A\s*</(#{HTML_BLOCK_ELEMENTS.join('|')})>}i
 
         # HTML elements that contain markdown content (not HTML content)
         # These should have blank lines before their closing tags
         MARKDOWN_CONTAINER_ELEMENTS = %w[details].freeze
 
         # Pattern to match closing tags for markdown containers
-        MARKDOWN_CONTAINER_CLOSE = /\A\s*<\/(#{MARKDOWN_CONTAINER_ELEMENTS.join("|")})>/i
+        MARKDOWN_CONTAINER_CLOSE = %r{\A\s*</(#{MARKDOWN_CONTAINER_ELEMENTS.join('|')})>}i
 
         # Markdown content: anything that's not blank, not HTML, and not a link ref def
-        MARKDOWN_CONTENT = ->(line) {
+        MARKDOWN_CONTENT = lambda { |line|
           stripped = line.strip
           return false if stripped.empty?
-          return false if stripped.start_with?("<")
+          return false if stripped.start_with?('<')
           return false if line.match?(LINK_REF_DEF)
+
           true
         }
 
@@ -138,9 +139,7 @@ module Markdown
           lines.each_with_index do |line, idx|
             result << line
             # If this line needs a blank line after it, add one
-            if insertions.include?(idx + 1) # issues use 1-based line numbers
-              result << "\n" unless line.strip.empty?
-            end
+            result << "\n" if insertions.include?(idx + 1) && !line.strip.empty? # issues use 1-based line numbers
           end
 
           result.join
@@ -158,7 +157,7 @@ module Markdown
 
           lines.each_with_index do |line, idx|
             next_line = lines[idx + 1]
-            prev_line = (idx > 0) ? lines[idx - 1] : nil
+            prev_line = idx.positive? ? lines[idx - 1] : nil
 
             # Special case: closing tags for markdown containers like </details>
             # These contain markdown content, so we need blank lines before them
@@ -175,9 +174,7 @@ module Markdown
               end
 
               # Check for issues that need blank line BEFORE current line
-              if prev_line && !prev_line.strip.empty?
-                check_markdown_before_html(prev_line, line, idx)
-              end
+              check_markdown_before_html(prev_line, line, idx) if prev_line && !prev_line.strip.empty?
             end
 
             # Special case: always check for blank line before </details> etc.
@@ -188,13 +185,11 @@ module Markdown
 
             # Update HTML block depth AFTER checking for issues
             # Count opening block-level tags
-            if line.match?(HTML_BLOCK_OPEN)
-              html_block_depth += 1
-            end
+            html_block_depth += 1 if line.match?(HTML_BLOCK_OPEN)
 
             # Check for closing block-level tags
             line.scan(HTML_BLOCK_CLOSE) do
-              html_block_depth -= 1 if html_block_depth > 0
+              html_block_depth -= 1 if html_block_depth.positive?
             end
           end
         end
@@ -206,7 +201,7 @@ module Markdown
           @issues << {
             type: :thematic_break_needs_blank,
             line: idx + 1,
-            description: "Thematic break should be followed by blank line",
+            description: 'Thematic break should be followed by blank line'
           }
         end
 
@@ -217,7 +212,7 @@ module Markdown
           @issues << {
             type: :list_before_heading,
             line: idx + 1,
-            description: "List item should be followed by blank line before heading",
+            description: 'List item should be followed by blank line before heading'
           }
         end
 
@@ -231,7 +226,7 @@ module Markdown
           @issues << {
             type: :html_before_markdown,
             line: idx + 1,
-            description: "HTML close tag should be followed by blank line before markdown",
+            description: 'HTML close tag should be followed by blank line before markdown'
           }
         end
 
@@ -244,7 +239,7 @@ module Markdown
           @issues << {
             type: :markdown_before_html,
             line: idx, # Insert blank line BEFORE this line (so after prev_line)
-            description: "Markdown content should be followed by blank line before HTML",
+            description: 'Markdown content should be followed by blank line before HTML'
           }
         end
       end

data/lib/markdown/merge/cleanse/code_fence_spacing.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "parslet"
+require 'parslet'
 
 module Markdown
   module Merge
@@ -93,11 +93,11 @@ module Markdown
         class CodeFenceGrammar < Parslet::Parser
           # Any amount of indentation (handles code blocks in lists)
           # Captured as string, not array
-          rule(:indent) { match("[ ]").repeat }
+          rule(:indent) { match('[ ]').repeat }
 
           # Fence markers - 3+ backticks or tildes
-          rule(:backtick) { str("`") }
-          rule(:tilde) { str("~") }
+          rule(:backtick) { str('`') }
+          rule(:tilde) { str('~') }
           rule(:backtick_fence) { backtick.repeat(3, nil) }
           rule(:tilde_fence) { tilde.repeat(3, nil) }
           rule(:fence) { backtick_fence | tilde_fence }
@@ -117,9 +117,9 @@ module Markdown
 
           # Fence line with optional indentation, optional spacing, optional info
           # Capture: indent (raw), fence (as :fence), spacing (as :spacing), info (as :info)
-          rule(:fence_line) {
+          rule(:fence_line) do
             indent.as(:indent) >> fence.as(:fence) >> spaces?.as(:spacing) >> info_string.maybe.as(:info) >> line_end
-          }
+          end
 
           root(:fence_line)
         end
@@ -175,9 +175,9 @@ module Markdown
 
             fence = parsed[:fence]
             fence_char = fence[0]
-            spacing = parsed[:spacing] || ""
-            info = parsed[:info] || ""
-            indent = parsed[:indent] || ""
+            spacing = parsed[:spacing] || ''
+            info = parsed[:info] || ''
+            indent = parsed[:indent] || ''
 
             # Closing fence: matches current fence type and has no info
             if in_code_block && fence_char == current_fence_char && info.empty?
@@ -192,7 +192,7 @@ module Markdown
 
             # Extract just the language (first word of info string)
             language = info.strip.split(/\s+/).first
-            language = nil if language&.empty?
+            language = nil if language && language.empty?
 
             @code_blocks << {
               indent: indent,
@@ -202,7 +202,7 @@ module Markdown
               spacing: spacing,
               malformed: !spacing.empty? && !language.nil?,
               line_number: line_number,
-              original: line.chomp,
+              original: line.chomp
             }
           end
 
@@ -259,16 +259,16 @@ module Markdown
 
           info_val = tree[:info]
           info_str = if info_val.is_a?(Array)
-            info_val.join
-          else
-            (info_val ? info_val.to_s : "")
-          end
+                       info_val.join
+                     else
+                       (info_val ? info_val.to_s : '')
+                     end
 
           {
             indent: indent_str,
             fence: tree[:fence].to_s,
             spacing: spacing_str,
-            info: info_str,
+            info: info_str
           }
         rescue Parslet::ParseFailed
           nil

data/lib/markdown/merge/cleanse/condensed_link_refs.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "parslet"
+require 'parslet'
 
 module Markdown
   module Merge
@@ -105,14 +105,14 @@ module Markdown
 
           # Bracket content: handles nested brackets recursively
           # Same as LinkParser::DefinitionGrammar
-          rule(:bracket_content) {
+          rule(:bracket_content) do
             (
-              str("[") >> bracket_content.maybe >> str("]") |
-              str("]").absent? >> any
+              str('[') >> bracket_content.maybe >> str(']') |
+              str(']').absent? >> any
             ).repeat
-          }
+          end
 
-          rule(:label) { str("[") >> bracket_content.as(:label) >> str("]") }
+          rule(:label) { str('[') >> bracket_content.as(:label) >> str(']') }
 
           # URL characters - everything except whitespace, >, and [
           # The [ is excluded because it signals the start of the next definition
@@ -120,36 +120,36 @@ module Markdown
           rule(:bare_url) { url_char.repeat(1) }
 
           # Angled URLs can contain [ since they're delimited by <>
-          rule(:angled_url_char) { match("[^>]") }
-          rule(:angled_url) { str("<") >> angled_url_char.repeat(1) >> str(">") }
+          rule(:angled_url_char) { match('[^>]') }
+          rule(:angled_url) { str('<') >> angled_url_char.repeat(1) >> str('>') }
 
           rule(:url) { (angled_url | bare_url).as(:url) }
 
           # Title handling (same as LinkParser)
           rule(:title_content_double) { (str('"').absent? >> any).repeat }
           rule(:title_content_single) { (str("'").absent? >> any).repeat }
-          rule(:title_content_paren) { (str(")").absent? >> any).repeat }
+          rule(:title_content_paren) { (str(')').absent? >> any).repeat }
 
           rule(:title_double) { str('"') >> title_content_double.as(:title) >> str('"') }
           rule(:title_single) { str("'") >> title_content_single.as(:title) >> str("'") }
-          rule(:title_paren) { str("(") >> title_content_paren.as(:title) >> str(")") }
+          rule(:title_paren) { str('(') >> title_content_paren.as(:title) >> str(')') }
           rule(:title) { title_double | title_single | title_paren }
 
           # A single definition
-          rule(:definition) {
+          rule(:definition) do
             spaces? >>
               label >>
-              str(":") >>
+              str(':') >>
               spaces? >>
               url >>
               (spaces >> title).maybe >>
               spaces?
-          }
+          end
 
           # Multiple definitions, possibly with or without newlines between them
-          rule(:definitions) {
+          rule(:definitions) do
             (definition.as(:definition) >> newlines?).repeat(1)
-          }
+          end
 
           root(:definitions)
         end
@@ -209,8 +209,8 @@ module Markdown
             next unless parsed && !parsed.empty?
 
             # Check if line has content before first definition
-            first_bracket = line.index("[")
-            has_prefix = first_bracket && first_bracket > 0 && !line[0...first_bracket].strip.empty?
+            first_bracket = line.index('[')
+            has_prefix = first_bracket&.positive? && !line[0...first_bracket].strip.empty?
 
             # Include if: multiple definitions OR single definition with prefix
             next unless parsed.size > 1 || has_prefix
@@ -272,11 +272,12 @@ module Markdown
         # @return [Boolean] true if there's content before first `[label]:`
         def has_content_before_definition?(line)
           # Skip if no link definition pattern
-          return false unless line.include?("]:")
+          return false unless line.include?(']:')
 
           # Find first occurrence of [label]:
-          first_bracket = line.index("[")
+          first_bracket = line.index('[')
           return false unless first_bracket
+          return false if inside_inline_code?(line, first_bracket)
 
           # Check if there's non-whitespace content before it
           prefix = line[0...first_bracket].strip
@@ -296,12 +297,13 @@ module Markdown
         # @return [Array<Hash>, nil] array of definition parse trees, or nil if parse fails
         def parse_line(line)
           # Skip lines that don't look like link definitions
-          return unless line.include?("]:")
+          return unless line.include?(']:')
 
           # First, try to find where the first link definition starts
           # Look for pattern: [anything]:
-          first_bracket = line.index("[")
+          first_bracket = line.index('[')
           return unless first_bracket
+          return if inside_inline_code?(line, first_bracket)
 
           # Try parsing from the first bracket onward
           candidate = line[first_bracket..]
@@ -315,7 +317,7 @@ module Markdown
 
             # Filter out non-definition nodes and return only definitions
             defs.select { |node| node.is_a?(Hash) && node.key?(:definition) }
-              .map { |node| node[:definition] }
+                .map { |node| node[:definition] }
           rescue Parslet::ParseFailed
             nil
           end
@@ -335,7 +337,7 @@ module Markdown
 
           {
             label: label,
-            url: clean_url(url),
+            url: clean_url(url)
           }
         end
 
@@ -352,8 +354,8 @@ module Markdown
           return line unless parsed && !parsed.empty?
 
           # Find where the first definition starts
-          first_bracket = line.index("[")
-          prefix = (first_bracket && first_bracket > 0) ? line[0...first_bracket].strip : ""
+          first_bracket = line.index('[')
+          prefix = first_bracket&.positive? ? line[0...first_bracket].strip : ''
 
           # Case 1: Multiple definitions - always expand
           if parsed.size > 1
@@ -361,10 +363,10 @@ module Markdown
 
             # First definition gets the prefix if present
             result = if prefix && !prefix.empty?
-              "#{prefix}\n#{definitions.join("\n")}"
-            else
-              definitions.join("\n")
-            end
+                       "#{prefix}\n#{definitions.join("\n")}"
+                     else
+                       definitions.join("\n")
+                     end
 
             result += "\n" if line.end_with?("\n")
             return result
@@ -397,7 +399,11 @@ module Markdown
         # @return [String] cleaned URL
         def clean_url(url)
           url = url.strip
-          (url.start_with?("<") && url.end_with?(">")) ? url[1..-2] : url
+          url.start_with?('<') && url.end_with?('>') ? url[1..-2] : url
+        end
+
+        def inside_inline_code?(line, index)
+          line[0...index].count('`').odd?
         end
       end
     end

data/lib/markdown/merge/cleanse/list_marker_duplication.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Markdown
+  module Merge
+    module Cleanse
+      # Repairs templating corruption where an ordered-list marker was prefixed
+      # onto an existing unordered-list marker, producing lines like:
+      #
+      #   1. - item
+      #   2. * item
+      #
+      # The repair keeps the original inner bullet marker and removes the
+      # synthetic ordered marker.
+      class ListMarkerDuplication
+        DUPLICATED_MARKER = /\A(?<indent>\s*)(?<number>\d+)\.\s+(?<bullet>[-*+])(?<tail>(?:\s+.*)?\s*)\z/
+
+        attr_reader :source, :issues
+
+        def initialize(source)
+          @source = source.to_s
+          @issues = []
+          analyze
+        end
+
+        def malformed?
+          issues.any?
+        end
+
+        def issue_count
+          issues.length
+        end
+
+        def fix
+          return source unless malformed?
+
+          source.each_line.with_index(1).map do |line, line_number|
+            duplicated_marker_line?(line) ? repaired_line(line, line_number) : line
+          end.join
+        end
+
+        private
+
+        def analyze
+          source.each_line.with_index(1) do |line, line_number|
+            next unless duplicated_marker_line?(line)
+
+            issues << {
+              type: :duplicated_list_marker,
+              line: line_number,
+              description: 'Ordered-list marker duplicated an existing unordered-list marker'
+            }
+          end
+        end
+
+        def duplicated_marker_line?(line)
+          line.match?(DUPLICATED_MARKER)
+        end
+
+        def repaired_line(line, _line_number)
+          match = line.match(DUPLICATED_MARKER)
+          "#{match[:indent]}#{match[:bullet]}#{match[:tail]}"
+        end
+      end
+    end
+  end
+end