ruby-merge 7.1.1 → 7.1.3

data/lib/ruby/merge/gemspec_support.rb

@@ -1,32 +0,0 @@
-# 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

@@ -1,128 +0,0 @@
-# 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

@@ -1,75 +0,0 @@
-# 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

@@ -1,75 +0,0 @@
-# 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

@@ -1,46 +0,0 @@
-# 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

@@ -1,209 +0,0 @@
-# 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

@@ -1,74 +0,0 @@
-# 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