markdown-merge 1.0.3 → 7.1.1

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Markdown
+  module Merge
+    module Cleanse
+      # Composes targeted repair passes for known templating corruption
+      # signatures seen in historical kettle-jem runs.
+      class TemplatingCorruption
+        PASS_TYPES = [
+          ListMarkerDuplication,
+          CondensedLinkRefs,
+          CodeFenceSpacing,
+          BlockSpacing
+        ].freeze
+
+        attr_reader :source, :passes, :issues
+
+        def initialize(source)
+          @source = source.to_s
+          @passes = []
+          @issues = []
+          analyze
+        end
+
+        def malformed?
+          issues.any?
+        end
+
+        def issue_count
+          issues.length
+        end
+
+        def fix
+          current = source
+
+          PASS_TYPES.each do |pass_type|
+            pass = pass_type.new(current)
+            next unless pass_issues?(pass)
+
+            current = pass_output(pass, current)
+          end
+
+          current
+        end
+
+        private
+
+        def analyze
+          current = source
+
+          PASS_TYPES.each do |pass_type|
+            pass = pass_type.new(current)
+            @passes << pass
+            append_issues(pass)
+            current = pass_output(pass, current) if pass_issues?(pass)
+          end
+        end
+
+        def append_issues(pass)
+          if pass.respond_to?(:issues)
+            issues.concat(Array(pass.issues))
+          elsif pass_issues?(pass)
+            issues << {
+              type: pass.class.name.split('::').last.gsub(/([a-z])([A-Z])/, '\1_\2').downcase.to_sym,
+              description: "#{pass.class.name} detected malformed content"
+            }
+          end
+        end
+
+        def pass_issues?(pass)
+          pass.respond_to?(:malformed?) ? pass.malformed? : pass.respond_to?(:condensed?) && pass.condensed?
+        end
+
+        def pass_output(pass, fallback)
+          if pass.respond_to?(:fix)
+            pass.fix
+          elsif pass.respond_to?(:expand)
+            pass.expand
+          else
+            fallback
+          end
+        end
+      end
+    end
+  end
+end

data/lib/markdown/merge/cleanse.rb

@@ -34,9 +34,11 @@ module Markdown
     # @see Cleanse::BlockSpacing For fixing missing blank lines between block elements
     # @api public
     module Cleanse
-      autoload :BlockSpacing, "markdown/merge/cleanse/block_spacing"
-      autoload :CodeFenceSpacing, "markdown/merge/cleanse/code_fence_spacing"
-      autoload :CondensedLinkRefs, "markdown/merge/cleanse/condensed_link_refs"
+      autoload :BlockSpacing, 'markdown/merge/cleanse/block_spacing'
+      autoload :CodeFenceSpacing, 'markdown/merge/cleanse/code_fence_spacing'
+      autoload :CondensedLinkRefs, 'markdown/merge/cleanse/condensed_link_refs'
+      autoload :ListMarkerDuplication, 'markdown/merge/cleanse/list_marker_duplication'
+      autoload :TemplatingCorruption, 'markdown/merge/cleanse/templating_corruption'
     end
   end
 end

data/lib/markdown/merge/code_block_match_refiner.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Markdown
+  module Merge
+    # Fuzzy matches fenced code blocks by fence info and surrounding markdown context
+    # so inner code-block merging can run even when block content itself differs.
+    class CodeBlockMatchRefiner < Ast::Merge::MatchRefinerBase
+      include Ast::Merge::JaccardSimilarity
+
+      DEFAULT_THRESHOLD = 0.65
+
+      def initialize(threshold: DEFAULT_THRESHOLD, **options)
+        super(threshold: threshold, node_types: [:code_block], **options)
+      end
+
+      def call(template_nodes, dest_nodes, context = {})
+        template_blocks = template_nodes.select { |node| node_type(node).to_s == 'code_block' }
+        dest_blocks = dest_nodes.select { |node| node_type(node).to_s == 'code_block' }
+        return [] if template_blocks.empty? || dest_blocks.empty?
+
+        greedy_match(template_blocks, dest_blocks) do |template_node, dest_node|
+          compute_similarity(template_node, dest_node, context)
+        end
+      end
+
+      private
+
+      def compute_similarity(template_node, dest_node, context)
+        return 0.0 unless normalized_fence_info(template_node) == normalized_fence_info(dest_node)
+
+        template_analysis = context[:template_analysis]
+        dest_analysis = context[:dest_analysis]
+        context_score = surrounding_context_similarity(template_node, template_analysis, dest_node, dest_analysis)
+        position_score = relative_position_similarity(template_node, template_analysis, dest_node, dest_analysis)
+
+        0.75 + (context_score * 0.15) + (position_score * 0.10)
+      end
+
+      def normalized_fence_info(node)
+        raw = Ast::Merge::NodeTyping.unwrap(node)
+        raw.respond_to?(:fence_info) ? raw.fence_info.to_s.strip.downcase : ''
+      end
+
+      def surrounding_context_similarity(template_node, template_analysis, dest_node, dest_analysis)
+        template_context = [preceding_context_text(template_node, template_analysis),
+                            following_context_text(template_node, template_analysis)].join(' ')
+        dest_context = [preceding_context_text(dest_node, dest_analysis),
+                        following_context_text(dest_node, dest_analysis)].join(' ')
+        return 0.0 if template_context.empty? || dest_context.empty?
+
+        jaccard(extract_tokens(template_context), extract_tokens(dest_context))
+      end
+
+      def relative_position_similarity(template_node, template_analysis, dest_node, dest_analysis)
+        template_index = statement_index(template_analysis, template_node)
+        dest_index = statement_index(dest_analysis, dest_node)
+        template_count = statement_count(template_analysis)
+        dest_count = statement_count(dest_analysis)
+        return 0.0 unless template_index && dest_index && template_count.positive? && dest_count.positive?
+
+        template_ratio = template_index.to_f / template_count
+        dest_ratio = dest_index.to_f / dest_count
+        1.0 - (template_ratio - dest_ratio).abs
+      end
+
+      def preceding_context_text(node, analysis)
+        return '' unless analysis
+
+        index = statement_index(analysis, 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 list].include?(signature.first)
+
+          return candidate.text.to_s
+        end
+
+        ''
+      end
+
+      def following_context_text(node, analysis)
+        return '' unless analysis
+
+        index = statement_index(analysis, node)
+        return '' unless index
+
+        ((index + 1)...analysis.statements.length).each do |current_index|
+          candidate = analysis.statements[current_index]
+          signature = analysis.signature_at(current_index)
+          next unless signature.is_a?(Array) && %i[heading paragraph list].include?(signature.first)
+
+          return candidate.text.to_s
+        end
+
+        ''
+      end
+
+      def statement_index(analysis, node)
+        return unless analysis
+
+        analysis.statements.index(node)
+      end
+
+      def statement_count(analysis)
+        Array(analysis&.statements).length
+      end
+    end
+  end
+end