ruby-merge 7.0.0 → 7.1.1

data/lib/ruby/merge/gemspec_support.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'block_binding_support'
+
+module Ruby
+  module Merge
+    module GemspecSupport
+      GEMSPEC_VAR_PLACEHOLDER = :__gemspec_var__
+
+      module_function
+
+      def effective_receiver(receiver, gemspec_block_var)
+        BlockBindingSupport.effective_receiver(receiver, gemspec_block_var, placeholder: GEMSPEC_VAR_PLACEHOLDER)
+      end
+
+      def preferred_block_var(template_var, dest_var)
+        BlockBindingSupport.preferred_block_var(template_var, dest_var)
+      end
+
+      def merged_block_var(var, preferred_var)
+        BlockBindingSupport.merged_block_var(var, preferred_var)
+      end
+
+      def opening_line_with_preferred_block_var(opening_line, dest_var:, preferred_var:, node_preference:)
+        return opening_line unless preferred_var && dest_var && dest_var != preferred_var
+        return opening_line unless node_preference == :destination
+
+        opening_line.sub("|#{dest_var}|", "|#{preferred_var}|")
+      end
+    end
+  end
+end

data/lib/ruby/merge/magic_comment_support.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Ruby
+  module Merge
+    # Ruby magic comment detection and file-header prefix handling.
+    module MagicCommentSupport
+      MAGIC_COMMENT_PATTERNS = {
+        frozen_string_literal: /^frozen_string_literal:\s*(true|false)$/i,
+        encoding: /^(encoding|coding):\s*\S+$/i,
+        warn_indent: /^warn_indent:\s*(true|false)$/i,
+        shareable_constant_value: /^shareable_constant_value:\s*\S+$/i
+      }.freeze
+
+      module_function
+
+      def magic_comment_type_for_text(text)
+        stripped = DocCommentSupport.normalize_comment_content(text)
+
+        MAGIC_COMMENT_PATTERNS.each do |type, pattern|
+          return type if stripped.match?(pattern)
+        end
+
+        nil
+      end
+
+      def comment_only_prefix_info(lines)
+        entries = []
+        suppressed_line_nums = Set.new
+        duplicate_magic_line_nums = Set.new
+
+        if shebang_line?(lines.first)
+          entries << { line_num: 1, text: lines.first.to_s, kind: :shebang }
+          suppressed_line_nums << 1
+        end
+
+        header_magic_types = header_magic_comment_types_for_lines(lines)
+        seen_magic_types = Set.new
+
+        header_magic_types.keys.sort.each do |line_num|
+          magic_type = header_magic_types[line_num]
+          suppressed_line_nums << line_num
+          entries << { line_num: line_num, text: lines[line_num - 1].to_s.chomp, kind: :magic }
+
+          if seen_magic_types.include?(magic_type)
+            duplicate_magic_line_nums << line_num
+          else
+            seen_magic_types << magic_type
+          end
+        end
+
+        if header_magic_types.any?
+          blank_line_num = header_magic_types.keys.max + 1
+
+          while blank_line_num <= lines.length && lines[blank_line_num - 1].to_s.rstrip.empty?
+            entries << { line_num: blank_line_num, text: lines[blank_line_num - 1].to_s, kind: :blank }
+            suppressed_line_nums << blank_line_num
+            blank_line_num += 1
+          end
+        end
+
+        {
+          entries: entries,
+          suppressed_line_nums: suppressed_line_nums,
+          duplicate_magic_line_nums: duplicate_magic_line_nums,
+          header_magic_comment_types: header_magic_types
+        }
+      end
+
+      def header_magic_comment_types_for_lines(lines)
+        types = {}
+        index = shebang_line?(lines.first) ? 1 : 0
+        previous_line_num = shebang_line?(lines.first) ? 1 : nil
+
+        while index < lines.length
+          line_num = index + 1
+          stripped = lines[index].to_s.rstrip
+          break if stripped.empty?
+
+          expected_line_num = previous_line_num ? previous_line_num + 1 : 1
+          break unless line_num == expected_line_num
+
+          magic_type = magic_comment_type_for_text(stripped)
+          break unless magic_type
+
+          types[line_num] = magic_type
+          previous_line_num = line_num
+          index += 1
+        end
+
+        types
+      end
+
+      def prefix_comment_line_numbers_for_comments(comments)
+        prefix_line_nums = Set.new
+        previous_line_num = nil
+        index = 0
+
+        if shebang_comment?(comments.first)
+          prefix_line_nums << 1
+          previous_line_num = 1
+          index = 1
+        end
+
+        while index < comments.length
+          comment = comments[index]
+          line_num = comment.location.start_line
+          expected_line_num = previous_line_num ? previous_line_num + 1 : 1
+          break unless line_num == expected_line_num
+          break unless magic_comment_type_for_text(comment.slice)
+
+          prefix_line_nums << line_num
+          previous_line_num = line_num
+          index += 1
+        end
+
+        prefix_line_nums
+      end
+
+      def shebang_line?(line)
+        line.to_s.start_with?('#!')
+      end
+
+      def shebang_comment?(comment)
+        comment&.slice&.start_with?('#!')
+      end
+    end
+  end
+end

data/lib/ruby/merge/method_similarity.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Ruby
+  module Merge
+    class MethodSimilarity
+      DEFAULT_NAME_WEIGHT = 0.7
+      DEFAULT_PARAMS_WEIGHT = 0.3
+
+      attr_reader :name_weight, :params_weight
+
+      def initialize(name_weight: DEFAULT_NAME_WEIGHT, params_weight: DEFAULT_PARAMS_WEIGHT)
+        @name_weight = name_weight
+        @params_weight = params_weight
+      end
+
+      def call(template_name:, template_params:, dest_name:, dest_params:)
+        name_score = string_similarity(template_name.to_s, dest_name.to_s)
+        param_score = param_similarity(Array(template_params), Array(dest_params))
+
+        (name_score * name_weight) + (param_score * params_weight)
+      end
+
+      def param_similarity(template_params, dest_params)
+        return 1.0 if template_params.empty? && dest_params.empty?
+        return 0.0 if template_params.empty? || dest_params.empty?
+
+        common = (template_params & dest_params).size
+        total = [template_params.size, dest_params.size].max
+        count_ratio = [template_params.size, dest_params.size].min.to_f / total
+        name_match_ratio = common.to_f / total
+
+        (name_match_ratio * 0.7) + (count_ratio * 0.3)
+      end
+
+      def string_similarity(str1, str2)
+        return 1.0 if str1 == str2
+        return 0.0 if str1.empty? || str2.empty?
+
+        distance = levenshtein_distance(str1, str2)
+        max_len = [str1.length, str2.length].max
+
+        1.0 - (distance.to_f / max_len)
+      end
+
+      def levenshtein_distance(str1, str2)
+        return str2.length if str1.empty?
+        return str1.length if str2.empty?
+
+        str1, str2 = str2, str1 if str1.length > str2.length
+
+        m = str1.length
+        n = str2.length
+        previous_row = (0..m).to_a
+        current_row = Array.new(m + 1, 0)
+
+        (1..n).each do |j|
+          current_row[0] = j
+
+          (1..m).each do |i|
+            cost = str1[i - 1] == str2[j - 1] ? 0 : 1
+            current_row[i] = [
+              previous_row[i] + 1,
+              current_row[i - 1] + 1,
+              previous_row[i - 1] + cost
+            ].min
+          end
+
+          previous_row, current_row = current_row, previous_row
+        end
+
+        previous_row[m]
+      end
+    end
+  end
+end

data/lib/ruby/merge/nocov_node_base.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Ruby
+  module Merge
+    # Shared Ruby synthetic node for a balanced coverage-exclusion block.
+    #
+    # Parser-specific merge gems subclass this when they need native AST location
+    # or comment attachment behavior. The structural Ruby semantics live here:
+    # nocov blocks follow file preference and match by their inner content.
+    class NocovNodeBase
+      include Ast::Merge::BlockDirective
+
+      InvalidStructureError = Class.new(StandardError)
+
+      Location = Struct.new(:start_line, :end_line) do
+        def cover?(line)
+          (start_line..end_line).cover?(line)
+        end
+      end
+
+      attr_reader :start_line, :end_line, :nodes, :analysis, :start_marker, :close_marker
+
+      def initialize(start_line:, end_line:, analysis:, nodes: [], start_marker: nil, close_marker: nil)
+        @start_line = start_line
+        @end_line = end_line
+        @analysis = analysis
+        @nodes = nodes
+        @start_marker = start_marker
+        @close_marker = close_marker
+      end
+
+      def kind = :nocov
+
+      def children = @nodes
+
+      def merge_policy = nil
+
+      def location
+        @location ||= Location.new(@start_line, @end_line)
+      end
+
+      def slice
+        return unless @analysis
+
+        lines = @analysis.lines
+        return unless lines
+
+        lines[(@start_line - 1)..(@end_line - 1)]&.join
+      end
+
+      def signature
+        return [:NocovNode, nil] if @nodes.empty? || @analysis.nil?
+
+        if @nodes.length == 1
+          @analysis.generate_signature(@nodes.first)
+        else
+          inner_lines = @analysis.lines && @analysis.lines[@start_line..(@end_line - 2)]
+          [:nocov_multi, inner_lines&.map(&:strip)&.join("\n")]
+        end
+      end
+
+      def merge_type = :nocov_block
+
+      alias type merge_type
+
+      def nocov_node? = true
+
+      def inspect
+        "#<#{self.class} lines=#{@start_line}..#{@end_line} nodes=#{@nodes.length}>"
+      end
+
+      alias to_s inspect
+    end
+  end
+end

data/lib/ruby/merge/nocov_wrapper_base.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Ruby
+  module Merge
+    # Shared Ruby wrapper for nodes carrying unbalanced or inline nocov markers.
+    #
+    # The wrapped parser node remains responsible for structural identity; this
+    # wrapper only marks it as a Ruby coverage directive participant.
+    class NocovWrapperBase
+      include Ast::Merge::BlockDirective
+
+      attr_reader :node, :merge_type
+
+      def initialize(node, merge_type = :nocov)
+        @node = node
+        @merge_type = merge_type
+      end
+
+      def kind = :nocov
+      def children = []
+      def merge_policy = nil
+
+      def start_line
+        @node.location&.start_line
+      end
+
+      def end_line
+        @node.location&.end_line
+      end
+
+      def unwrap = @node
+
+      def location = @node.location
+
+      def slice = @node.slice
+
+      def nocov_wrapper? = true
+      def nocov_node? = false
+      def block_directive? = true
+
+      def inspect
+        "#<#{self.class} merge_type=#{@merge_type.inspect} node=#{@node.inspect}>"
+      end
+    end
+  end
+end

data/lib/ruby/merge/rescue_semantics.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+module Ruby
+  module Merge
+    class RescueSemantics
+      def initialize(source_defined_exception_definitions: [])
+        @source_defined_exception_definitions = source_defined_exception_definitions
+      end
+
+      def merge_ordered_clause_types(primary_types, secondary_types)
+        ordered = primary_types.dup
+
+        secondary_types.each_with_index do |clause_type, secondary_index|
+          next if ordered.include?(clause_type)
+
+          previous_shared = secondary_types[0...secondary_index].reverse.find { |type| ordered.include?(type) }
+          next_shared = secondary_types[(secondary_index + 1)..]&.find { |type| ordered.include?(type) }
+
+          if previous_shared
+            insert_at = ordered.index(previous_shared) + 1
+            ordered.insert(insert_at, clause_type)
+          elsif next_shared
+            insert_at = ordered.index(next_shared)
+            ordered.insert(insert_at, clause_type)
+          else
+            ordered << clause_type
+          end
+        end
+
+        ordered
+      end
+
+      def canonicalize_rescue_clause_order(clause_types)
+        rescue_clause_types = clause_types.select { |clause_type| rescue_clause_type?(clause_type) }
+        return clause_types if rescue_clause_types.length < 2
+
+        ordered_rescue_types = rescue_clause_types.dup
+
+        if rescue_clause_types.any? { |clause_type| broad_rescue_clause_type?(clause_type) } &&
+           rescue_clause_types.any? { |clause_type| !broad_rescue_clause_type?(clause_type) }
+          specific_rescue_types = ordered_rescue_types.reject { |clause_type| broad_rescue_clause_type?(clause_type) }
+          broad_rescue_types = ordered_rescue_types.select { |clause_type| broad_rescue_clause_type?(clause_type) }
+          ordered_rescue_types = specific_rescue_types + broad_rescue_types
+        end
+
+        loop do
+          swapped = false
+
+          (0...(ordered_rescue_types.length - 1)).each do |index|
+            left_clause_type = ordered_rescue_types[index]
+            right_clause_type = ordered_rescue_types[index + 1]
+            next unless broader_rescue_clause_type_than?(left_clause_type, right_clause_type)
+
+            ordered_rescue_types[index] = right_clause_type
+            ordered_rescue_types[index + 1] = left_clause_type
+            swapped = true
+          end
+
+          break unless swapped
+        end
+
+        clause_types.map do |clause_type|
+          rescue_clause_type?(clause_type) ? ordered_rescue_types.shift : clause_type
+        end
+      end
+
+      def canonicalize_begin_clause_kind_order(clause_types)
+        clause_types.each_with_index
+                    .sort_by { |(clause_type, index)| [clause_kind_sort_key(clause_type), index] }
+                    .map(&:first)
+      end
+
+      def rescue_clause_signature(exception_names)
+        normalized_exceptions = Array(exception_names).filter_map { |exception| normalize_exception_name(exception) }
+        if normalized_exceptions.empty? || normalized_exceptions == ['StandardError']
+          [:standard_error]
+        else
+          normalized_exceptions.sort
+        end
+      end
+
+      def rescue_clause_type?(clause_type)
+        clause_type.is_a?(Array) && clause_type.first == :rescue_clause
+      end
+
+      def broad_rescue_clause_type?(clause_type)
+        rescue_clause_type?(clause_type) && clause_type[1] == [:standard_error]
+      end
+
+      def clause_kind_sort_key(clause_type)
+        return 0 if rescue_clause_type?(clause_type)
+        return 1 if clause_type == :else_clause
+        return 2 if clause_type == :ensure_clause
+
+        3
+      end
+
+      def normalize_exception_name(exception_name)
+        return 'StandardError' if exception_name == :standard_error
+
+        name = exception_name.to_s.sub(/\A::/, '')
+        name.empty? ? nil : name
+      end
+
+      def qualify_source_constant_name(constant_name, namespace = nil)
+        normalized_name = normalize_exception_name(constant_name)
+        return if normalized_name.nil?
+        return normalized_name if constant_name.to_s.start_with?('::') || namespace.nil? || namespace.empty?
+
+        "#{namespace}::#{normalized_name}"
+      end
+
+      def source_defined_exception_hierarchy
+        @source_defined_exception_hierarchy ||= begin
+          definitions = @source_defined_exception_definitions
+          defined_names = definitions.map { |definition| definition[:name] }.compact.to_set
+
+          definitions.each_with_object({}) do |definition, hierarchy|
+            next unless definition[:name] && definition[:superclass]
+
+            superclass_name = if definition[:superclass].to_s.start_with?('::')
+                                normalize_exception_name(definition[:superclass])
+                              else
+                                candidate_name = qualify_source_constant_name(definition[:superclass],
+                                                                              definition[:namespace])
+                                defined_names.include?(candidate_name) ? candidate_name : normalize_exception_name(definition[:superclass])
+                              end
+
+            hierarchy[definition[:name]] ||= superclass_name if superclass_name
+          end
+        end
+      end
+
+      def resolve_exception_constant(exception_name)
+        return ::StandardError if exception_name == :standard_error
+        return unless exception_name.is_a?(String) && !exception_name.empty?
+
+        exception_name.split('::').reject(&:empty?).inject(Object) { |scope, const_name| scope.const_get(const_name) }
+      rescue NameError
+        nil
+      end
+
+      def rescue_clause_exception_names(clause_type)
+        return [] unless rescue_clause_type?(clause_type)
+
+        Array(clause_type[1]).filter_map { |exception_name| normalize_exception_name(exception_name) }
+      end
+
+      def rescue_clause_exception_constants(clause_type)
+        rescue_clause_exception_names(clause_type).filter_map do |exception_name|
+          resolve_exception_constant(exception_name)
+        end
+      end
+
+      def exception_constant_covers?(covering_constant, covered_constant)
+        return true if covering_constant == covered_constant
+
+        covered_constant < covering_constant
+      rescue StandardError
+        false
+      end
+
+      def source_defined_exception_covers?(covering_name, covered_name)
+        normalized_covering = normalize_exception_name(covering_name)
+        current_name = normalize_exception_name(covered_name)
+        return false if normalized_covering.nil? || current_name.nil?
+        return true if normalized_covering == current_name
+
+        while (current_name = source_defined_exception_hierarchy[current_name])
+          return true if current_name == normalized_covering
+        end
+
+        false
+      end
+
+      def exception_name_covers?(covering_name, covered_name)
+        covering_constant = resolve_exception_constant(covering_name)
+        covered_constant = resolve_exception_constant(covered_name)
+
+        if covering_constant && covered_constant
+          exception_constant_covers?(covering_constant, covered_constant)
+        else
+          source_defined_exception_covers?(covering_name, covered_name)
+        end
+      end
+
+      def rescue_clause_covers?(covering_clause_type, covered_clause_type)
+        return false unless rescue_clause_type?(covering_clause_type) && rescue_clause_type?(covered_clause_type)
+
+        covering_names = rescue_clause_exception_names(covering_clause_type)
+        covered_names = rescue_clause_exception_names(covered_clause_type)
+        return false if covering_names.empty? || covered_names.empty?
+
+        covered_names.all? do |covered_name|
+          covering_names.any? do |covering_name|
+            exception_name_covers?(covering_name, covered_name)
+          end
+        end
+      end
+
+      def broader_rescue_clause_type_than?(left_clause_type, right_clause_type)
+        return false unless rescue_clause_type?(left_clause_type) && rescue_clause_type?(right_clause_type)
+
+        rescue_clause_covers?(left_clause_type, right_clause_type) &&
+          !rescue_clause_covers?(right_clause_type, left_clause_type)
+      end
+    end
+  end
+end

data/lib/ruby/merge/scaffold_chunk_support.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Ruby
+  module Merge
+    module ScaffoldChunkSupport
+      ChunkSpec = Struct.new(
+        :anchor_type,
+        :anchor_value,
+        :satellite_patterns,
+        :jaccard_threshold,
+        :max_lookahead,
+        :max_lookbehind,
+        keyword_init: true
+      )
+
+      BUNDLER_GEM_TASKS_SPEC = ChunkSpec.new(
+        anchor_type: :require_call,
+        anchor_value: 'bundler/gem_tasks',
+        satellite_patterns: [],
+        jaccard_threshold: 0.35,
+        max_lookahead: 0,
+        max_lookbehind: 0
+      )
+
+      RSPEC_SPEC = ChunkSpec.new(
+        anchor_type: :require_call,
+        anchor_value: 'rspec/core/rake_task',
+        satellite_patterns: ['RSpec::Core::RakeTask.new'],
+        jaccard_threshold: 0.35,
+        max_lookahead: 5,
+        max_lookbehind: 2
+      )
+
+      RUBOCOP_SPEC = ChunkSpec.new(
+        anchor_type: :require_call,
+        anchor_value: 'rubocop/rake_task',
+        satellite_patterns: ['RuboCop::RakeTask.new'],
+        jaccard_threshold: 0.35,
+        max_lookahead: 5,
+        max_lookbehind: 2
+      )
+
+      DEFAULT_TASK_SPEC = ChunkSpec.new(
+        anchor_type: :task_call,
+        anchor_value: 'default',
+        satellite_patterns: [],
+        jaccard_threshold: 0.35,
+        max_lookahead: 0,
+        max_lookbehind: 0
+      )
+
+      ALL_SPECS = [BUNDLER_GEM_TASKS_SPEC, RSPEC_SPEC, RUBOCOP_SPEC, DEFAULT_TASK_SPEC].freeze
+
+      module_function
+
+      def jaccard_tokens(text)
+        text.scan(/[A-Za-z0-9_]+/).to_set
+      end
+
+      def jaccard(a_set, b_set)
+        union = a_set | b_set
+        return 0.0 if union.empty?
+
+        (a_set & b_set).size.to_f / union.size
+      end
+
+      def task_anchor_match?(source, anchor_value, threshold)
+        node_tokens = jaccard_tokens(source.to_s)
+        pattern_tokens = jaccard_tokens("task #{anchor_value}")
+        jaccard(pattern_tokens, node_tokens) >= threshold
+      end
+    end
+  end
+end