markdown-merge 1.0.3 → 7.1.1

data/lib/markdown/merge/link_parser.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "parslet"
+require 'parslet'
 
 module Markdown
   module Merge
@@ -35,33 +35,33 @@ module Markdown
         rule(:spaces?) { space.repeat }
 
         # Bracket content: handles nested brackets recursively
-        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(']') }
 
         rule(:url_char) { match('[^\s>]') }
         rule(:bare_url) { url_char.repeat(1) }
-        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) }
 
         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 }
 
-        rule(:definition) {
-          spaces? >> label >> str(":") >> spaces? >> url >> (spaces >> title).maybe >> spaces?
-        }
+        rule(:definition) do
+          spaces? >> label >> str(':') >> spaces? >> url >> (spaces >> title).maybe >> spaces?
+        end
 
         root(:definition)
       end
@@ -72,22 +72,22 @@ module Markdown
         rule(:spaces) { space.repeat(1) }
 
         # Bracket content with recursive nesting
-        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(:link_text) { str("[") >> bracket_content.as(:text) >> str("]") }
+        rule(:link_text) { str('[') >> bracket_content.as(:text) >> str(']') }
 
         # URL content - handles balanced parens inside URLs
-        rule(:paren_content) {
+        rule(:paren_content) do
           (
-            str("(") >> paren_content.maybe >> str(")") |
+            str('(') >> paren_content.maybe >> str(')') |
             match('[^()\s"\']')
           ).repeat
-        }
+        end
 
         rule(:url) { paren_content.as(:url) }
 
@@ -97,7 +97,7 @@ module Markdown
         rule(:title_single) { str("'") >> title_content_single.as(:title) >> str("'") }
         rule(:title) { title_double | title_single }
 
-        rule(:url_part) { str("(") >> url >> (spaces >> title).maybe >> str(")") }
+        rule(:url_part) { str('(') >> url >> (spaces >> title).maybe >> str(')') }
 
         rule(:inline_link) { link_text >> url_part }
 
@@ -109,21 +109,21 @@ module Markdown
         rule(:space) { match('[ \t]') }
         rule(:spaces) { space.repeat(1) }
 
-        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(:alt_text) { str("![") >> bracket_content.as(:alt) >> str("]") }
+        rule(:alt_text) { str('![') >> bracket_content.as(:alt) >> str(']') }
 
-        rule(:paren_content) {
+        rule(:paren_content) do
           (
-            str("(") >> paren_content.maybe >> str(")") |
+            str('(') >> paren_content.maybe >> str(')') |
             match('[^()\s"\']')
           ).repeat
-        }
+        end
 
         rule(:url) { paren_content.as(:url) }
 
@@ -133,7 +133,7 @@ module Markdown
         rule(:title_single) { str("'") >> title_content_single.as(:title) >> str("'") }
         rule(:title) { title_double | title_single }
 
-        rule(:url_part) { str("(") >> url >> (spaces >> title).maybe >> str(")") }
+        rule(:url_part) { str('(') >> url >> (spaces >> title).maybe >> str(')') }
 
         rule(:inline_image) { alt_text >> url_part }
 
@@ -170,11 +170,11 @@ module Markdown
 
         url = result[:url].to_s
         # Strip angle brackets if present
-        url = url[1..-2] if url.start_with?("<") && url.end_with?(">")
+        url = url[1..-2] if url.start_with?('<') && url.end_with?('>')
 
         definition = {
           label: result[:label].to_s,
-          url: url,
+          url: url
         }
         definition[:title] = result[:title].to_s if result[:title]
         definition
@@ -239,7 +239,7 @@ module Markdown
       def build_link_tree(links, images)
         # Combine all items
         all_items = links.map { |l| l.merge(type: :link) } +
-          images.map { |i| i.merge(type: :image) }
+                    images.map { |i| i.merge(type: :image) }
 
         # Sort by start position
         sorted = all_items.sort_by { |item| item[:start_pos] }
@@ -297,15 +297,15 @@ module Markdown
       def find_constructs(content, type)
         results = []
         pos = 0
-        grammar = (type == :image) ? @image_grammar : @link_grammar
-        start_marker = (type == :image) ? "![" : "["
+        grammar = type == :image ? @image_grammar : @link_grammar
+        start_marker = type == :image ? '![' : '['
 
         while pos < content.length
           idx = content.index(start_marker, pos)
           break unless idx
 
           # For links, skip if preceded by ! (that's an image)
-          if type == :link && idx > 0 && content[idx - 1] == "!"
+          if type == :link && idx > 0 && content[idx - 1] == '!'
             pos = idx + 1
             next
           end
@@ -327,12 +327,12 @@ module Markdown
         remaining = content[start_idx..]
 
         # Find the closing ) by tracking balanced brackets/parens
-        bracket_end = find_bracket_end(remaining, (type == :image) ? 1 : 0)
+        bracket_end = find_bracket_end(remaining, type == :image ? 1 : 0)
         return unless bracket_end
 
         # Check for ( after ]
         return if bracket_end + 1 >= remaining.length
-        return unless remaining[bracket_end + 1] == "("
+        return unless remaining[bracket_end + 1] == '('
 
         paren_end = find_paren_end(remaining, bracket_end + 1)
         return unless paren_end
@@ -344,22 +344,22 @@ module Markdown
           result = grammar.parse(substring)
 
           parsed = if type == :image
-            {
-              alt: result[:alt].to_s,
-              url: result[:url].to_s,
-              start_pos: start_idx,
-              end_pos: start_idx + substring.length,
-              original: substring,
-            }
-          else
-            {
-              text: result[:text].to_s,
-              url: result[:url].to_s,
-              start_pos: start_idx,
-              end_pos: start_idx + substring.length,
-              original: substring,
-            }
-          end
+                     {
+                       alt: result[:alt].to_s,
+                       url: result[:url].to_s,
+                       start_pos: start_idx,
+                       end_pos: start_idx + substring.length,
+                       original: substring
+                     }
+                   else
+                     {
+                       text: result[:text].to_s,
+                       url: result[:url].to_s,
+                       start_pos: start_idx,
+                       end_pos: start_idx + substring.length,
+                       original: substring
+                     }
+                   end
 
           parsed[:title] = result[:title].to_s if result[:title]
           parsed
@@ -374,9 +374,9 @@ module Markdown
 
         while pos < text.length
           case text[pos]
-          when "["
+          when '['
             depth += 1
-          when "]"
+          when ']'
             depth -= 1
             return pos if depth == 0
           end
@@ -395,7 +395,7 @@ module Markdown
         while pos < text.length
           char = text[pos]
 
-          if !in_quotes && (char == '"' || char == "'")
+          if !in_quotes && ['"', "'"].include?(char)
             in_quotes = true
             quote_char = char
           elsif in_quotes && char == quote_char
@@ -403,9 +403,9 @@ module Markdown
             quote_char = nil
           elsif !in_quotes
             case char
-            when "("
+            when '('
               depth += 1
-            when ")"
+            when ')'
               depth -= 1
               return pos if depth == 0
             end

data/lib/markdown/merge/link_reference_rehydrator.rb

@@ -105,8 +105,8 @@ module Markdown
         result = content.dup
         replacements.sort_by { |r| -r[:start_pos] }.each do |replacement|
           result = result[0...replacement[:start_pos]] +
-            replacement[:replacement] +
-            result[replacement[:end_pos]..]
+                   replacement[:replacement] +
+                   result[replacement[:end_pos]..]
         end
 
         result
@@ -158,10 +158,10 @@ module Markdown
           else
             # Leaf node - process directly
             replacement = if item[:type] == :image
-              process_image(item)
-            else
-              process_link(item)
-            end
+                            process_image(item)
+                          else
+                            process_link(item)
+                          end
             replacements << replacement if replacement
           end
         end
@@ -190,14 +190,14 @@ module Markdown
             severity: :info,
             text: item[:text],
             url: item[:url],
-            title: item[:title],
+            title: item[:title]
           )
           return
         end
 
         # Build the new link text by applying child replacements to the original text
         # Extract the original "text" part of the link (between [ and ])
-        original_text = item[:text] || ""
+        original_text = item[:text] || ''
 
         # Apply child replacements to build the new text content
         # Children positions are relative to the document, so we need to adjust
@@ -223,7 +223,7 @@ module Markdown
         {
           start_pos: item[:start_pos],
           end_pos: item[:end_pos],
-          replacement: "[#{new_text}][#{label}]",
+          replacement: "[#{new_text}][#{label}]"
         }
       end
 
@@ -257,7 +257,7 @@ module Markdown
             severity: :warning,
             url: url,
             labels: labels,
-            selected_label: @url_to_label[url],
+            selected_label: @url_to_label[url]
           )
         end
       end
@@ -273,7 +273,7 @@ module Markdown
             severity: :info,
             text: link_text,
             url: url,
-            title: title,
+            title: title
           )
           return
         end
@@ -285,7 +285,7 @@ module Markdown
         {
           start_pos: link[:start_pos],
           end_pos: link[:end_pos],
-          replacement: "[#{link_text}][#{label}]",
+          replacement: "[#{link_text}][#{label}]"
         }
       end
 
@@ -300,7 +300,7 @@ module Markdown
             severity: :info,
             alt: alt_text,
             url: url,
-            title: title,
+            title: title
           )
           return
         end
@@ -312,7 +312,7 @@ module Markdown
         {
           start_pos: image[:start_pos],
           end_pos: image[:end_pos],
-          replacement: "![#{alt_text}][#{label}]",
+          replacement: "![#{alt_text}][#{label}]"
         }
       end
     end

data/lib/markdown/merge/list_match_refiner.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Markdown
+  module Merge
+    # Fuzzy matches markdown list nodes by item-token overlap so inner list merging
+    # can repair previously-corrupted lists that no longer share an exact signature.
+    class ListMatchRefiner < Ast::Merge::MatchRefinerBase
+      include Ast::Merge::JaccardSimilarity
+
+      DEFAULT_THRESHOLD = 0.45
+
+      def initialize(threshold: DEFAULT_THRESHOLD, **options)
+        super(threshold: threshold, node_types: [:list], **options)
+      end
+
+      def call(template_nodes, dest_nodes, context = {})
+        template_lists = template_nodes.select { |node| node_type(node).to_s == 'list' }
+        dest_lists = dest_nodes.select { |node| node_type(node).to_s == 'list' }
+        return [] if template_lists.empty? || dest_lists.empty?
+
+        greedy_match(template_lists, dest_lists) do |template_node, dest_node|
+          compute_similarity(template_node, dest_node, context)
+        end
+      end
+
+      private
+
+      def compute_similarity(template_node, dest_node, context)
+        template_items = list_item_anchors(template_node)
+        dest_items = list_item_anchors(dest_node)
+        return 0.0 if template_items.empty? || dest_items.empty?
+
+        containment = template_item_containment(template_items, dest_items)
+        token_overlap = jaccard(list_tokens(template_node), list_tokens(dest_node))
+        first_item_score = template_items.first == dest_items.first ? 1.0 : 0.0
+        context_score = context_similarity(
+          template_node,
+          context[:template_analysis],
+          dest_node,
+          context[:dest_analysis]
+        )
+
+        (containment * 0.35) + (token_overlap * 0.35) + (context_score * 0.2) + (first_item_score * 0.1)
+      end
+
+      def list_item_anchors(list_node)
+        raw = Ast::Merge::NodeTyping.unwrap(list_node)
+
+        raw.each_with_object([]) do |child, anchors|
+          next unless child.respond_to?(:type) && %w[list_item item].include?(child.type.to_s)
+
+          anchors << normalize_anchor(child.text.to_s)
+        end
+      end
+
+      def list_tokens(list_node)
+        extract_tokens(list_node.text.to_s)
+      end
+
+      def template_item_containment(template_items, dest_items)
+        template_set = template_items.to_set
+        dest_set = dest_items.to_set
+        return 0.0 if template_set.empty?
+
+        (template_set & dest_set).size.to_f / template_set.size
+      end
+
+      def context_similarity(template_node, template_analysis, dest_node, dest_analysis)
+        template_context = preceding_context_text(template_node, template_analysis)
+        dest_context = preceding_context_text(dest_node, dest_analysis)
+        return 0.0 if template_context.empty? || dest_context.empty?
+
+        jaccard(extract_tokens(template_context), extract_tokens(dest_context))
+      end
+
+      def preceding_context_text(node, analysis)
+        return '' unless analysis
+
+        index = analysis.statements.index(node)
+        return '' unless index
+
+        (index - 1).downto(0) do |current_index|
+          candidate = analysis.statements[current_index]
+          signature = analysis.signature_at(current_index)
+          next unless signature.is_a?(Array) && %i[heading paragraph code_block].include?(signature.first)
+
+          return candidate.text.to_s
+        end
+
+        ''
+      end
+
+      def normalize_anchor(text)
+        text.to_s.strip.gsub(/\s+/, ' ').downcase
+      end
+    end
+  end
+end