rubocop 1.26.0 → 1.36.0

data/lib/rubocop/cop/metrics/utils/code_length_calculator.rb

@@ -30,8 +30,8 @@ module RuboCop
 
               descendant_length = code_length(descendant)
               length = length - descendant_length + 1
-              # Subtract 2 length of opening and closing brace if method argument omits hash braces.
-              length -= 2 if descendant.hash_type? && !descendant.braces?
+              # Subtract length of opening and closing brace if method argument omits hash braces.
+              length -= omit_length(descendant) if descendant.hash_type? && !descendant.braces?
             end
 
             length
@@ -49,7 +49,7 @@ module RuboCop
               when :heredoc
                 ->(node) { heredoc_node?(node) }
               else
-                raise ArgumentError, "Unknown foldable type: #{type.inspect}. "\
+                raise ArgumentError, "Unknown foldable type: #{type.inspect}. " \
                                      "Valid foldable types are: #{FOLDABLE_TYPES.join(', ')}."
               end
             end
@@ -153,6 +153,25 @@ module RuboCop
           def count_comments?
             @count_comments
           end
+
+          def omit_length(descendant)
+            parent = descendant.parent
+            return 0 if another_args?(parent)
+            return 0 unless parenthesized?(parent)
+
+            [
+              parent.loc.begin.end_pos != descendant.loc.expression.begin_pos,
+              parent.loc.end.begin_pos != descendant.loc.expression.end_pos
+            ].count(true)
+          end
+
+          def parenthesized?(node)
+            node.call_type? && node.parenthesized?
+          end
+
+          def another_args?(node)
+            node.call_type? && node.arguments.count > 1
+          end
         end
       end
     end

data/lib/rubocop/cop/mixin/allowed_methods.rb

@@ -12,10 +12,29 @@ module RuboCop
         allowed_methods.include?(name.to_s)
       end
 
+      # @deprecated Use allowed_method? instead
+      alias ignored_method? allowed_method?
+
       # @api public
       def allowed_methods
-        cop_config.fetch('AllowedMethods', [])
+        if cop_config_deprecated_values.any?(Regexp)
+          cop_config_allowed_methods
+        else
+          cop_config_allowed_methods + cop_config_deprecated_values
+        end
+      end
+
+      def cop_config_allowed_methods
+        @cop_config_allowed_methods ||= Array(cop_config.fetch('AllowedMethods', []))
+      end
+
+      def cop_config_deprecated_values
+        @cop_config_deprecated_values ||=
+          Array(cop_config.fetch('IgnoredMethods', [])) +
+          Array(cop_config.fetch('ExcludedMethods', []))
       end
     end
+    # @deprecated IgnoredMethods class has been replaced with AllowedMethods.
+    IgnoredMethods = AllowedMethods
   end
 end

data/lib/rubocop/cop/mixin/allowed_pattern.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module encapsulates the ability to ignore certain lines when
+    # parsing.
+    module AllowedPattern
+      private
+
+      def allowed_line?(line)
+        line = if line.respond_to?(:source_line)
+                 line.source_line
+               elsif line.respond_to?(:node)
+                 line.node.source_range.source_line
+               end
+
+        matches_allowed_pattern?(line)
+      end
+
+      # @deprecated Use allowed_line? instead
+      alias ignored_line? allowed_line?
+
+      def matches_allowed_pattern?(line)
+        allowed_patterns.any? { |pattern| Regexp.new(pattern).match?(line) }
+      end
+
+      # @deprecated Use matches_allowed_pattern?? instead
+      alias matches_ignored_pattern? matches_allowed_pattern?
+
+      def allowed_patterns
+        # Since there could be a pattern specified in the default config, merge the two
+        # arrays together.
+        if cop_config_deprecated_methods_values.any?(Regexp)
+          cop_config_patterns_values + cop_config_deprecated_methods_values
+        else
+          cop_config_patterns_values
+        end
+      end
+
+      def cop_config_patterns_values
+        @cop_config_patterns_values ||=
+          Array(cop_config.fetch('AllowedPatterns', [])) +
+          Array(cop_config.fetch('IgnoredPatterns', []))
+      end
+
+      def cop_config_deprecated_methods_values
+        @cop_config_deprecated_methods_values ||=
+          Array(cop_config.fetch('IgnoredMethods', [])) +
+          Array(cop_config.fetch('ExcludedMethods', []))
+      end
+    end
+
+    # @deprecated IgnoredPattern class has been replaced with AllowedPattern.
+    IgnoredPattern = AllowedPattern
+  end
+end

data/lib/rubocop/cop/mixin/check_line_breakable.rb

@@ -46,6 +46,8 @@ module RuboCop
         if node.send_type?
           args = process_args(node.arguments)
           return extract_breakable_node_from_elements(node, args, max)
+        elsif node.def_type?
+          return extract_breakable_node_from_elements(node, node.arguments, max)
         elsif node.array_type? || node.hash_type?
           return extract_breakable_node_from_elements(node, node.children, max)
         end
@@ -216,7 +218,9 @@ module RuboCop
 
       # @api private
       def already_on_multiple_lines?(node)
-        node.first_line != node.last_line
+        return node.first_line != node.arguments.last.last_line if node.def_type?
+
+        !node.single_line?
       end
     end
   end

data/lib/rubocop/cop/mixin/comments_help.rb

@@ -4,8 +4,6 @@ module RuboCop
   module Cop
     # Help methods for working with nodes containing comments.
     module CommentsHelp
-      include VisibilityHelp
-
       def source_range_with_comment(node)
         begin_pos = begin_pos_with_comment(node)
         end_pos = end_position_for(node)
@@ -13,6 +11,17 @@ module RuboCop
         Parser::Source::Range.new(buffer, begin_pos, end_pos)
       end
 
+      def contains_comments?(node)
+        comments_in_range(node).any?
+      end
+
+      def comments_in_range(node)
+        start_line = node.source_range.line
+        end_line = find_end_line(node)
+
+        processed_source.each_comment_in_lines(start_line...end_line)
+      end
+
       private
 
       def end_position_for(node)
@@ -37,6 +46,23 @@ module RuboCop
       def buffer
         processed_source.buffer
       end
+
+      # Returns the end line of a node, which might be a comment and not part of the AST
+      # End line is considered either the line at which another node starts, or
+      # the line at which the parent node ends.
+      # rubocop:disable Metrics/AbcSize
+      def find_end_line(node)
+        if node.if_type? && node.loc.else
+          node.loc.else.line
+        elsif (next_sibling = node.right_sibling)
+          next_sibling.loc.line
+        elsif (parent = node.parent)
+          parent.loc.end ? parent.loc.end.line : parent.loc.line
+        else
+          node.loc.end.line
+        end
+      end
+      # rubocop:enable Metrics/AbcSize
     end
   end
 end

data/lib/rubocop/cop/mixin/def_node.rb

@@ -5,8 +5,7 @@ module RuboCop
     # Common functionality for checking def nodes.
     module DefNode
       extend NodePattern::Macros
-
-      NON_PUBLIC_MODIFIERS = %w[private protected].freeze
+      include VisibilityHelp
 
       private
 
@@ -15,11 +14,7 @@ module RuboCop
       end
 
       def preceding_non_public_modifier?(node)
-        stripped_source_upto(node.first_line).any? { |line| NON_PUBLIC_MODIFIERS.include?(line) }
-      end
-
-      def stripped_source_upto(index)
-        processed_source[0..index].map(&:strip)
+        node_visibility(node) != :public
       end
 
       # @!method non_public_modifier?(node)

data/lib/rubocop/cop/mixin/duplication.rb

@@ -29,7 +29,7 @@ module RuboCop
       # @param [Array] collection an array to return consecutive duplicates for
       # @return [Array] the consecutive duplicates
       def consecutive_duplicates(collection)
-        grouped_duplicates(collection).flat_map { |items| items[1..-1] }
+        grouped_duplicates(collection).flat_map { |items| items[1..] }
       end
 
       # Returns a hash of grouped duplicates. The key will be the first

data/lib/rubocop/cop/mixin/enforce_superclass.rb

@@ -6,7 +6,8 @@ module RuboCop
     #
     # IMPORTANT: RuboCop core depended on this module when it supported Rails department.
     # Rails department has been extracted to RuboCop Rails gem.
-    # This module is deprecated and will be removed by RuboCop 2.0.
+    #
+    # @deprecated This module is deprecated and will be removed by RuboCop 2.0.
     # It will not be updated to `RuboCop::Cop::Base` v1 API to maintain compatibility
     # with existing RuboCop Rails 2.8 or lower.
     #

data/lib/rubocop/cop/mixin/hash_shorthand_syntax.rb

@@ -5,7 +5,22 @@ module RuboCop
     # This module checks for Ruby 3.1's hash value omission syntax.
     module HashShorthandSyntax
       OMIT_HASH_VALUE_MSG = 'Omit the hash value.'
-      EXPLICIT_HASH_VALUE_MSG = 'Explicit the hash value.'
+      EXPLICIT_HASH_VALUE_MSG = 'Include the hash value.'
+      DO_NOT_MIX_MSG_PREFIX = 'Do not mix explicit and implicit hash values.'
+      DO_NOT_MIX_OMIT_VALUE_MSG = "#{DO_NOT_MIX_MSG_PREFIX} #{OMIT_HASH_VALUE_MSG}"
+      DO_NOT_MIX_EXPLICIT_VALUE_MSG = "#{DO_NOT_MIX_MSG_PREFIX} #{EXPLICIT_HASH_VALUE_MSG}"
+
+      def on_hash_for_mixed_shorthand(hash_node)
+        return if ignore_mixed_hash_shorthand_syntax?(hash_node)
+
+        hash_value_type_breakdown = breakdown_value_types_of_hash(hash_node)
+
+        if hash_with_mixed_shorthand_syntax?(hash_value_type_breakdown)
+          mixed_shorthand_syntax_check(hash_value_type_breakdown)
+        else
+          no_mixed_shorthand_syntax_check(hash_value_type_breakdown)
+        end
+      end
 
       def on_pair(node)
         return if ignore_hash_shorthand_syntax?(node)
@@ -17,6 +32,7 @@ module RuboCop
 
           message = OMIT_HASH_VALUE_MSG
           replacement = "#{hash_key_source}:"
+          self.config_to_allow_offenses = { 'Enabled' => false }
         else
           return unless node.value_omission?
 
@@ -24,15 +40,25 @@ module RuboCop
           replacement = "#{hash_key_source}: #{hash_key_source}"
         end
 
+        register_offense(node, message, replacement)
+      end
+
+      private
+
+      def register_offense(node, message, replacement)
         add_offense(node.value, message: message) do |corrector|
           corrector.replace(node, replacement)
         end
       end
 
-      private
+      def ignore_mixed_hash_shorthand_syntax?(hash_node)
+        target_ruby_version <= 3.0 || enforced_shorthand_syntax != 'consistent' ||
+          !hash_node.hash_type?
+      end
 
       def ignore_hash_shorthand_syntax?(pair_node)
         target_ruby_version <= 3.0 || enforced_shorthand_syntax == 'either' ||
+          enforced_shorthand_syntax == 'consistent' ||
           !pair_node.parent.hash_type?
       end
 
@@ -65,9 +91,8 @@ module RuboCop
 
       def use_modifier_form_without_parenthesized_method_call?(ancestor)
         return false if ancestor.respond_to?(:parenthesized?) && ancestor.parenthesized?
-        return false unless (parent = ancestor.parent)
 
-        parent.respond_to?(:modifier_form?) && parent.modifier_form?
+        ancestor.ancestors.any? { |node| node.respond_to?(:modifier_form?) && node.modifier_form? }
       end
 
       def without_parentheses_call_expr_follows?(ancestor)
@@ -77,6 +102,60 @@ module RuboCop
 
         ancestor.respond_to?(:parenthesized?) && !ancestor.parenthesized? && !!right_sibling
       end
+
+      def breakdown_value_types_of_hash(hash_node)
+        hash_node.pairs.group_by do |pair_node|
+          if pair_node.value_omission?
+            :value_omitted
+          elsif require_hash_value?(pair_node.key.source, pair_node)
+            :value_needed
+          else
+            :value_omittable
+          end
+        end
+      end
+
+      def hash_with_mixed_shorthand_syntax?(hash_value_type_breakdown)
+        hash_value_type_breakdown.keys.size > 1
+      end
+
+      def hash_with_values_that_cant_be_omitted?(hash_value_type_breakdown)
+        hash_value_type_breakdown[:value_needed]&.any?
+      end
+
+      def each_omitted_value_pair(hash_value_type_breakdown, &block)
+        hash_value_type_breakdown[:value_omitted]&.each(&block)
+      end
+
+      def each_omittable_value_pair(hash_value_type_breakdown, &block)
+        hash_value_type_breakdown[:value_omittable]&.each(&block)
+      end
+
+      def mixed_shorthand_syntax_check(hash_value_type_breakdown)
+        if hash_with_values_that_cant_be_omitted?(hash_value_type_breakdown)
+          each_omitted_value_pair(hash_value_type_breakdown) do |pair_node|
+            hash_key_source = pair_node.key.source
+            replacement = "#{hash_key_source}: #{hash_key_source}"
+            register_offense(pair_node, DO_NOT_MIX_EXPLICIT_VALUE_MSG, replacement)
+          end
+        else
+          each_omittable_value_pair(hash_value_type_breakdown) do |pair_node|
+            hash_key_source = pair_node.key.source
+            replacement = "#{hash_key_source}:"
+            register_offense(pair_node, DO_NOT_MIX_OMIT_VALUE_MSG, replacement)
+          end
+        end
+      end
+
+      def no_mixed_shorthand_syntax_check(hash_value_type_breakdown)
+        return if hash_with_values_that_cant_be_omitted?(hash_value_type_breakdown)
+
+        each_omittable_value_pair(hash_value_type_breakdown) do |pair_node|
+          hash_key_source = pair_node.key.source
+          replacement = "#{hash_key_source}:"
+          register_offense(pair_node, OMIT_HASH_VALUE_MSG, replacement)
+        end
+      end
     end
   end
 end

data/lib/rubocop/cop/mixin/hash_transform_method.rb

@@ -14,7 +14,7 @@ module RuboCop
         {(array ...) (send _ :each_with_index) (send _ :with_index _ ?) (send _ :zip ...)}
       PATTERN
 
-      def on_block(node)
+      def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
         on_bad_each_with_object(node) do |*match|
           handle_possible_offense(node, match, 'each_with_object')
         end
@@ -68,6 +68,8 @@ module RuboCop
         # `transform_values` if value transformation uses key.
         return if captures.transformation_uses_both_args?
 
+        return unless captures.use_transformed_argname?
+
         message = "Prefer `#{new_method_name}` over `#{match_desc}`."
         add_offense(node, message: message) do |corrector|
           correction = prepare_correction(node)
@@ -113,11 +115,7 @@ module RuboCop
       end
 
       # Internal helper class to hold match data
-      Captures = Struct.new(
-        :transformed_argname,
-        :transforming_body_expr,
-        :unchanged_body_expr
-      ) do
+      Captures = Struct.new(:transformed_argname, :transforming_body_expr, :unchanged_body_expr) do
         def noop_transformation?
           transforming_body_expr.lvar_type? &&
             transforming_body_expr.children == [transformed_argname]
@@ -126,6 +124,12 @@ module RuboCop
         def transformation_uses_both_args?
           transforming_body_expr.descendants.include?(unchanged_body_expr)
         end
+
+        def use_transformed_argname?
+          transforming_body_expr.each_descendant(:lvar).any? do |node|
+            node.source == transformed_argname.to_s
+          end
+        end
       end
 
       # Internal helper class to hold autocorrect data

data/lib/rubocop/cop/mixin/line_length_help.rb

@@ -39,12 +39,7 @@ module RuboCop
           pos + indentation_difference(line)
         end
 
-        # Extend the end position until the start of the next word, if any.
-        # This allows for URIs that are wrapped in quotes or parens to be handled properly
-        # while not allowing additional words to be added after the URL.
-        if (match = line[end_position..line_length(line)]&.match(/^\S+(?=\s|$)/))
-          end_position += match.offset(0).last
-        end
+        end_position = extend_uri_end_position(line, end_position)
 
         return nil if begin_position < max_line_length && end_position < max_line_length
 
@@ -65,6 +60,22 @@ module RuboCop
         (line.index(/[^\t]/) || 0) * (tab_indentation_width - 1)
       end
 
+      def extend_uri_end_position(line, end_position)
+        # Extend the end position YARD comments with linked URLs of the form {<uri> <title>}
+        if line&.match(/{(\s|\S)*}$/)
+          match = line[end_position..line_length(line)]&.match(/(\s|\S)*}/)
+          end_position += match.offset(0).last
+        end
+
+        # Extend the end position until the start of the next word, if any.
+        # This allows for URIs that are wrapped in quotes or parens to be handled properly
+        # while not allowing additional words to be added after the URL.
+        if (match = line[end_position..line_length(line)]&.match(/^\S+(?=\s|$)/))
+          end_position += match.offset(0).last
+        end
+        end_position
+      end
+
       def tab_indentation_width
         config.for_cop('Layout/IndentationStyle')['IndentationWidth'] ||
           config.for_cop('Layout/IndentationWidth')['Width']

data/lib/rubocop/cop/mixin/method_complexity.rb

@@ -6,21 +6,16 @@ module RuboCop
     #
     # This module handles measurement and reporting of complexity in methods.
     module MethodComplexity
-      include IgnoredMethods
+      include AllowedMethods
+      include AllowedPattern
       include Metrics::Utils::RepeatedCsendDiscount
       extend NodePattern::Macros
       extend ExcludeLimit
 
       exclude_limit 'Max'
 
-      # Ensure cops that include `MethodComplexity` have the config
-      # `attr_accessor`s that `ignored_method?` needs.
-      def self.included(base)
-        base.extend(IgnoredMethods::Config)
-      end
-
       def on_def(node)
-        return if ignored_method?(node.method_name)
+        return if allowed_method?(node.method_name) || matches_allowed_pattern?(node.method_name)
 
         check_complexity(node, node.method_name)
       end
@@ -28,20 +23,20 @@ module RuboCop
 
       def on_block(node)
         define_method?(node) do |name|
-          return if ignored_method?(name)
+          return if allowed_method?(name) || matches_allowed_pattern?(name)
 
           check_complexity(node, name)
         end
       end
 
+      alias on_numblock on_block
+
       private
 
       # @!method define_method?(node)
       def_node_matcher :define_method?, <<~PATTERN
-        (block
-         (send nil? :define_method ({sym str} $_))
-         args
-         _)
+        ({block numblock}
+         (send nil? :define_method ({sym str} $_)) _ _)
       PATTERN
 
       def check_complexity(node, method_name)

data/lib/rubocop/cop/mixin/multiline_element_indentation.rb

@@ -25,15 +25,17 @@ module RuboCop
 
       def check_first(first, left_brace, left_parenthesis, offset)
         actual_column = first.source_range.column
-        expected_column = base_column(left_brace, left_parenthesis) +
-                          configured_indentation_width + offset
+
+        indent_base_column, indent_base_type = indent_base(left_brace, first, left_parenthesis)
+        expected_column = indent_base_column + configured_indentation_width + offset
+
         @column_delta = expected_column - actual_column
         styles = detected_styles(actual_column, offset, left_parenthesis, left_brace)
 
         if @column_delta.zero?
           check_expected_style(styles)
         else
-          incorrect_style_detected(styles, first, left_parenthesis)
+          incorrect_style_detected(styles, first, indent_base_type)
         end
       end
 
@@ -45,14 +47,34 @@ module RuboCop
         end
       end
 
-      def base_column(left_brace, left_parenthesis)
-        if style == brace_alignment_style
-          left_brace.column
-        elsif left_parenthesis && style == :special_inside_parentheses
-          left_parenthesis.column + 1
-        else
-          left_brace.source_line =~ /\S/
+      def indent_base(left_brace, first, left_parenthesis)
+        return [left_brace.column, :left_brace_or_bracket] if style == brace_alignment_style
+
+        pair = hash_pair_where_value_beginning_with(left_brace, first)
+        if pair && key_and_value_begin_on_same_line?(pair) &&
+           right_sibling_begins_on_subsequent_line?(pair)
+          return [pair.loc.column, :parent_hash_key]
         end
+
+        if left_parenthesis && style == :special_inside_parentheses
+          return [left_parenthesis.column + 1, :first_column_after_left_parenthesis]
+        end
+
+        [left_brace.source_line =~ /\S/, :start_of_line]
+      end
+
+      def hash_pair_where_value_beginning_with(left_brace, first)
+        return unless first && first.parent.loc.begin == left_brace
+
+        first.parent&.parent&.pair_type? ? first.parent.parent : nil
+      end
+
+      def key_and_value_begin_on_same_line?(pair)
+        same_line?(pair.key, pair.value)
+      end
+
+      def right_sibling_begins_on_subsequent_line?(pair)
+        pair.right_sibling && (pair.last_line < pair.right_sibling.first_line)
       end
 
       def detected_styles(actual_column, offset, left_parenthesis, left_brace)
@@ -73,8 +95,8 @@ module RuboCop
         styles
       end
 
-      def incorrect_style_detected(styles, first, left_parenthesis)
-        msg = message(base_description(left_parenthesis))
+      def incorrect_style_detected(styles, first, base_column_type)
+        msg = message(base_description(base_column_type))
 
         add_offense(first, message: msg) do |corrector|
           autocorrect(corrector, first)

data/lib/rubocop/cop/mixin/multiline_expression_indentation.rb

@@ -29,7 +29,9 @@ module RuboCop
       #   b c { block }.            <-- b is indented relative to a
       #   d                         <-- d is indented relative to a
       def left_hand_side(lhs)
-        lhs = lhs.parent while lhs.parent&.send_type? && lhs.parent.loc.dot
+        while lhs.parent&.send_type? && lhs.parent.loc.dot && !lhs.parent.assignment_method?
+          lhs = lhs.parent
+        end
         lhs
       end
 
@@ -194,8 +196,7 @@ module RuboCop
 
       def not_for_this_cop?(node)
         node.ancestors.any? do |ancestor|
-          grouped_expression?(ancestor) ||
-            inside_arg_list_parentheses?(node, ancestor)
+          grouped_expression?(ancestor) || inside_arg_list_parentheses?(node, ancestor)
         end
       end