ruby-merge 7.1.3 → 7.1.4

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,219 @@
+# frozen_string_literal: true
+
+module Ruby
+  module Merge
+    # Normalizes rescue clause ordering while preserving source-defined
+    # exception hierarchies and Ruby's broader-handler semantics.
+    # rubocop:disable Metrics/AbcSize, Metrics/ClassLength, Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/MethodLength, Metrics/PerceivedComplexity
+    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])
+                                if defined_names.include?(candidate_name)
+                                  candidate_name
+                                else
+                                  normalize_exception_name(definition[:superclass])
+                                end
+                              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
+    # rubocop:enable Metrics/MethodLength, Metrics/PerceivedComplexity
+    # rubocop:enable Metrics/AbcSize, Metrics/ClassLength, Metrics/CyclomaticComplexity
+  end
+end

data/lib/ruby/merge/scaffold_chunk_support.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Ruby
+  module Merge
+    # Shared chunk anchors used when preserving project-specific Rake sections.
+    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

data/lib/ruby/merge/signature_support.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Ruby
+  module Merge
+    # Stable structural signatures used by Ruby owner and method matching.
+    module SignatureSupport
+      module_function
+
+      def method_definition(name, params)
+        [:def, name, Array(params)]
+      end
+
+      def class_definition(constant_path)
+        [:class, constant_path]
+      end
+
+      def module_definition(constant_path)
+        [:module, constant_path]
+      end
+
+      def singleton_class(expression)
+        [:singleton_class, expression]
+      end
+
+      def constant(name)
+        [:const, name]
+      end
+
+      def variable_assignment(kind, name)
+        [kind, name]
+      end
+
+      def multi_write(targets)
+        [:multi_write, Array(targets)]
+      end
+
+      def conditional(kind, predicate)
+        [kind, predicate]
+      end
+
+      def case_statement(predicate)
+        [:case, predicate || '']
+      end
+
+      def case_match_statement(predicate)
+        [:case_match, predicate || '']
+      end
+
+      def loop_statement(kind, *parts)
+        [kind, *parts]
+      end
+
+      def begin_block(first_statement_preview)
+        [:begin, first_statement_preview || '']
+      end
+
+      def call(method_name, identifier, block: false)
+        [block ? :call_with_block : :call, method_name, identifier]
+      end
+
+      def super_call(block:)
+        [:super, block ? :with_block : :no_block]
+      end
+
+      def forwarding_super_call(block:)
+        [:forwarding_super, block ? :with_block : :no_block]
+      end
+
+      def call_operator_write(write_name, receiver)
+        [:call_op_write, write_name, receiver]
+      end
+
+      def lambda_literal(parameters_source)
+        [:lambda, parameters_source || '']
+      end
+
+      def execution_block(kind, line_number)
+        [kind, line_number]
+      end
+
+      def parenthesized(first_expression_preview)
+        [:parens, first_expression_preview || '']
+      end
+
+      def embedded(statements_source)
+        [:embedded, statements_source || '']
+      end
+
+      def other(class_name, line_number)
+        [:other, class_name, line_number]
+      end
+
+      def textual_method_signature(receiver_prefix, method_name)
+        "#{receiver_prefix}#{method_name}"
+      end
+    end
+  end
+end

data/lib/ruby/merge/version.rb

@@ -5,7 +5,7 @@ module Ruby
     # Version namespace for this gem.
     module Version
       # Current gem version.
-      VERSION = '7.1.3'
+      VERSION = '7.1.4'
     end
     # Current gem version exposed at the traditional constant location.
     VERSION = Version::VERSION # Traditional Constant Location