markdown-merge 1.0.3 → 7.1.1

data/lib/markdown/merge/comment_tracker.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Markdown
+  module Merge
+    # Conservatively tracks standalone HTML comment lines in Markdown sources.
+    class CommentTracker < Ast::Merge::Comment::HashTrackerBase
+      STANDALONE_HTML_COMMENT_REGEX = /\A(?<indent>\s*)<!--\s?(?<text>.*?)\s?-->\s*\z/
+
+      def initialize(lines)
+        super(Array(lines))
+      end
+
+      private
+
+      def comment_style
+        :html_comment
+      end
+
+      def extract_comments
+        @lines.each_with_index.filter_map do |line, index|
+          match = line.match(STANDALONE_HTML_COMMENT_REGEX)
+          next unless match
+
+          {
+            line: index + 1,
+            indent: match[:indent].length,
+            text: match[:text].to_s,
+            full_line: true,
+            raw: line
+          }
+        end
+      end
+
+      def owner_line_num(owner)
+        pos = owner.respond_to?(:source_position) ? owner.source_position : nil
+        return pos[:start_line] if pos && pos[:start_line]
+
+        nil
+      end
+    end
+  end
+end

data/lib/markdown/merge/conflict_resolver.rb

@@ -34,6 +34,8 @@ module Markdown
       # @param dest_analysis [FileAnalysisBase] Analysis of the destination file
       # @param options [Hash] Additional options for forward compatibility
       def initialize(preference:, template_analysis:, dest_analysis:, **options)
+        @resolution_mode = options.fetch(:resolution_mode, :eager)
+        @unresolved_policy = Ast::Merge::UnresolvedPolicy.coerce(options[:unresolved_policy])
         super(
           strategy: :node,
           preference: preference,
@@ -59,7 +61,7 @@ module Markdown
             source: :destination,
             template_node: template_node,
             dest_node: dest_node,
-            reason: dest_node.reason,
+            reason: dest_node.reason
           )
         end
 
@@ -68,7 +70,7 @@ module Markdown
             source: :template,
             template_node: template_node,
             dest_node: dest_node,
-            reason: template_node.reason,
+            reason: template_node.reason
           )
         end
 
@@ -76,14 +78,21 @@ module Markdown
         if content_identical?(template_node, dest_node)
           return identical_resolution(
             template_node: template_node,
-            dest_node: dest_node,
+            dest_node: dest_node
+          )
+        end
+
+        if unresolved_mode? && @unresolved_policy.unresolved_for?(:matched_block)
+          return unresolved_resolution(
+            template_node: template_node,
+            dest_node: dest_node
           )
         end
 
         # Use preference to decide
         preference_resolution(
           template_node: template_node,
-          dest_node: dest_node,
+          dest_node: dest_node
         )
       end
 
@@ -100,6 +109,50 @@ module Markdown
         template_text == dest_text
       end
 
+      def unresolved_resolution(template_node:, dest_node:)
+        preferred_resolution = preference_resolution(template_node: template_node, dest_node: dest_node)
+        provisional_winner = @unresolved_policy.provisional_winner_for(
+          :matched_block,
+          fallback: preferred_resolution[:source]
+        )
+        line = node_line_range(dest_node)&.first || node_line_range(template_node)&.first
+        case_id = ['markdown', 'matched_block', line].compact.join('-')
+        surface_path = unresolved_surface_path("matched_block[line=#{line}]")
+
+        unresolved_case = Ast::Merge::Runtime::ResolutionCase.new(
+          case_id: case_id,
+          reason: :conflict,
+          candidates: {
+            template: node_to_text(template_node, @template_analysis),
+            destination: node_to_text(dest_node, @dest_analysis)
+          },
+          provisional_winner: provisional_winner,
+          surface_path: surface_path,
+          metadata: {
+            match_kind: :matched_block,
+            template_lines: node_line_range(template_node),
+            destination_lines: node_line_range(dest_node),
+            node_type: markdown_node_type(dest_node || template_node)
+          }.compact
+        )
+
+        {
+          source: provisional_winner,
+          decision: Ast::Merge::MergeResultBase::DECISION_UNRESOLVED,
+          template_node: template_node,
+          dest_node: dest_node,
+          unresolved_case: unresolved_case,
+          conflict: {
+            case_id: case_id,
+            reason: :conflict,
+            template: unresolved_case.candidates[:template],
+            destination: unresolved_case.candidates[:destination],
+            provisional_winner: provisional_winner,
+            location: line ? "line #{line}" : nil
+          }.compact
+        }
+      end
+
       # Convert a node to its source text
       #
       # @param node [Object] Node to convert
@@ -117,12 +170,30 @@ module Markdown
           if start_line && end_line
             analysis.source_range(start_line, end_line)
           else
-            # :nocov: defensive - Markdown nodes typically have source positions
+            # simplecov:disable defensive - Markdown nodes typically have source positions
             node.to_commonmark
-            # :nocov:
+            # simplecov:enable
           end
         end
       end
+
+      def node_line_range(node)
+        if node.respond_to?(:source_position)
+          pos = node.source_position
+          start_line = pos&.dig(:start_line)
+          end_line = pos&.dig(:end_line)
+          return [start_line, end_line] if start_line && end_line
+        end
+        return [node.start_line, node.end_line] if node.respond_to?(:start_line) && node.respond_to?(:end_line)
+
+        nil
+      end
+
+      def markdown_node_type(node)
+        return node.type.to_sym if node.respond_to?(:type) && !node.type.nil?
+
+        node.class.name.split('::').last
+      end
     end
   end
 end

data/lib/markdown/merge/debug_logger.rb

@@ -19,8 +19,8 @@ module Markdown
       extend Ast::Merge::DebugLogger
 
       # Configure for markdown-merge
-      self.env_var_name = "MARKDOWN_MERGE_DEBUG"
-      self.log_prefix = "[markdown-merge]"
+      self.env_var_name = 'MARKDOWN_MERGE_DEBUG'
+      self.log_prefix = '[markdown-merge]'
     end
   end
 end

data/lib/markdown/merge/document_problems.rb

@@ -28,7 +28,7 @@ module Markdown
       # Problem entry struct
       Problem = Struct.new(:category, :severity, :details, keyword_init: true) do
         def to_h
-          {category: category, severity: severity, **details}
+          { category: category, severity: severity, **details }
         end
 
         def warning?
@@ -177,13 +177,13 @@ module Markdown
       def validate_category!(category)
         return if CATEGORIES.include?(category)
 
-        raise ArgumentError, "Invalid category: #{category}. Valid: #{CATEGORIES.join(", ")}"
+        raise ArgumentError, "Invalid category: #{category}. Valid: #{CATEGORIES.join(', ')}"
       end
 
       def validate_severity!(severity)
         return if SEVERITIES.include?(severity)
 
-        raise ArgumentError, "Invalid severity: #{severity}. Valid: #{SEVERITIES.join(", ")}"
+        raise ArgumentError, "Invalid severity: #{severity}. Valid: #{SEVERITIES.join(', ')}"
       end
     end
   end