rubocop 1.22.0 → 1.45.1

data/lib/rubocop/cop/internal_affairs.rb

@@ -1,17 +1,28 @@
 # frozen_string_literal: true
 
+require_relative 'internal_affairs/cop_description'
+require_relative 'internal_affairs/create_empty_file'
 require_relative 'internal_affairs/empty_line_between_expect_offense_and_correction'
 require_relative 'internal_affairs/example_description'
+require_relative 'internal_affairs/example_heredoc_delimiter'
 require_relative 'internal_affairs/inherit_deprecated_cop_class'
+require_relative 'internal_affairs/lambda_or_proc'
+require_relative 'internal_affairs/location_line_equality_comparison'
+require_relative 'internal_affairs/method_name_end_with'
 require_relative 'internal_affairs/method_name_equal'
 require_relative 'internal_affairs/node_destructuring'
 require_relative 'internal_affairs/node_matcher_directive'
 require_relative 'internal_affairs/node_type_predicate'
+require_relative 'internal_affairs/numblock_handler'
 require_relative 'internal_affairs/offense_location_keyword'
+require_relative 'internal_affairs/redundant_context_config_parameter'
 require_relative 'internal_affairs/redundant_described_class_as_subject'
 require_relative 'internal_affairs/redundant_let_rubocop_config_new'
 require_relative 'internal_affairs/redundant_location_argument'
 require_relative 'internal_affairs/redundant_message_argument'
+require_relative 'internal_affairs/redundant_method_dispatch_node'
+require_relative 'internal_affairs/single_line_comparison'
 require_relative 'internal_affairs/style_detected_api_use'
 require_relative 'internal_affairs/undefined_config'
 require_relative 'internal_affairs/useless_message_assertion'
+require_relative 'internal_affairs/useless_restrict_on_send'

data/lib/rubocop/cop/layout/argument_alignment.rb

@@ -53,23 +53,55 @@ module RuboCop
                            'following the first line of a multi-line method call.'
 
         def on_send(node)
-          first_arg = node.first_argument
-          return if !multiple_arguments?(node, first_arg) || (node.send_type? && node.method?(:[]=))
+          return if !multiple_arguments?(node) || (node.send_type? && node.method?(:[]=)) ||
+                    autocorrect_incompatible_with_other_cops?
 
-          if first_arg.hash_type? && !first_arg.braces?
-            pairs = first_arg.pairs
-            check_alignment(pairs, base_column(node, pairs.first))
-          else
-            check_alignment(node.arguments, base_column(node, first_arg))
-          end
+          items = flattened_arguments(node)
+
+          check_alignment(items, base_column(node, items.first))
         end
+
         alias on_csend on_send
 
         private
 
-        def multiple_arguments?(node, first_argument)
+        def autocorrect_incompatible_with_other_cops?
+          with_first_argument_style? && enforce_hash_argument_with_separator?
+        end
+
+        def flattened_arguments(node)
+          if fixed_indentation?
+            arguments_with_last_arg_pairs(node)
+          else
+            arguments_or_first_arg_pairs(node)
+          end
+        end
+
+        def arguments_with_last_arg_pairs(node)
+          items = node.arguments[0..-2]
+          last_arg = node.arguments.last
+
+          if last_arg.hash_type? && !last_arg.braces?
+            items += last_arg.pairs
+          else
+            items << last_arg
+          end
+          items
+        end
+
+        def arguments_or_first_arg_pairs(node)
+          first_arg = node.first_argument
+          if first_arg.hash_type? && !first_arg.braces?
+            first_arg.pairs
+          else
+            node.arguments
+          end
+        end
+
+        def multiple_arguments?(node)
           return true if node.arguments.size >= 2
 
+          first_argument = node.first_argument
           first_argument&.hash_type? && first_argument.pairs.count >= 2
         end
 
@@ -85,6 +117,10 @@ module RuboCop
           cop_config['EnforcedStyle'] == 'with_fixed_indentation'
         end
 
+        def with_first_argument_style?
+          cop_config['EnforcedStyle'] == 'with_first_argument'
+        end
+
         def base_column(node, first_argument)
           if fixed_indentation? || first_argument.nil?
             lineno = target_method_lineno(node)
@@ -104,6 +140,18 @@ module RuboCop
             node.loc.begin.line
           end
         end
+
+        def enforce_hash_argument_with_separator?
+          return false unless hash_argument_config['Enabled']
+
+          RuboCop::Cop::Layout::HashAlignment::SEPARATOR_ALIGNMENT_STYLES.any? do |style|
+            hash_argument_config[style]&.include?('separator')
+          end
+        end
+
+        def hash_argument_config
+          config.for_cop('Layout/HashAlignment')
+        end
       end
     end
   end

data/lib/rubocop/cop/layout/array_alignment.rb

@@ -76,7 +76,7 @@ module RuboCop
         end
 
         def target_method_lineno(node)
-          node.loc.line
+          node.bracketed? ? node.loc.line : node.parent.loc.line
         end
       end
     end

data/lib/rubocop/cop/layout/assignment_indentation.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks the indentation of the first line of the
+      # Checks the indentation of the first line of the
       # right-hand-side of a multi-line assignment.
       #
       # @example
@@ -33,7 +33,7 @@ module RuboCop
         def check_assignment(node, rhs)
           return unless rhs
           return unless node.loc.operator
-          return if node.loc.operator.line == rhs.first_line
+          return if same_line?(node.loc.operator, rhs)
 
           base = display_column(leftmost_multiple_assignment(node).source_range)
           check_alignment([rhs], base + configured_indentation_width)

data/lib/rubocop/cop/layout/begin_end_alignment.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks whether the end keyword of `begin` is aligned properly.
+      # Checks whether the end keyword of `begin` is aligned properly.
       #
       # Two modes are supported through the `EnforcedStyleAlignWith` configuration
       # parameter. If it's set to `start_of_line` (which is the default), the

data/lib/rubocop/cop/layout/block_alignment.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks whether the end keywords are aligned properly for do
+      # Checks whether the end keywords are aligned properly for do
       # end blocks.
       #
       # Three modes are supported through the `EnforcedStyleAlignWith`
@@ -22,23 +22,24 @@ module RuboCop
       #   # bad
       #
       #   foo.bar
-      #      .each do
-      #        baz
-      #          end
+      #     .each do
+      #       baz
+      #         end
       #
       #   # good
       #
-      #   variable = lambda do |i|
-      #     i
+      #   foo.bar
+      #     .each do
+      #       baz
       #   end
       #
       # @example EnforcedStyleAlignWith: start_of_block
       #   # bad
       #
       #   foo.bar
-      #      .each do
-      #        baz
-      #          end
+      #     .each do
+      #       baz
+      #         end
       #
       #   # good
       #
@@ -51,16 +52,17 @@ module RuboCop
       #   # bad
       #
       #   foo.bar
-      #      .each do
-      #        baz
-      #          end
+      #     .each do
+      #       baz
+      #         end
       #
       #   # good
       #
       #   foo.bar
       #     .each do
-      #        baz
+      #       baz
       #   end
+      #
       class BlockAlignment < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
@@ -82,6 +84,8 @@ module RuboCop
           check_block_alignment(start_for_block_node(node), node)
         end
 
+        alias on_numblock on_block
+
         def style_parameter_name
           'EnforcedStyleAlignWith'
         end
@@ -101,11 +105,11 @@ module RuboCop
         def block_end_align_target(node)
           lineage = [node, *node.ancestors]
 
-          target = lineage.each_cons(2) do |current, parent|
-            break current if end_align_target?(current, parent)
+          lineage.each_cons(2) do |current, parent|
+            return current if end_align_target?(current, parent)
           end
 
-          target || lineage.last
+          lineage.last
         end
 
         def end_align_target?(node, parent)

data/lib/rubocop/cop/layout/block_end_newline.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks whether the end statement of a do..end block
+      # Checks whether the end statement of a do..end block
       # is on its own line.
       #
       # @example
@@ -36,24 +36,60 @@ module RuboCop
           # If the end is on its own line, there is no offense
           return if begins_its_line?(node.loc.end)
 
-          add_offense(node.loc.end, message: message(node)) do |corrector|
-            corrector.replace(delimiter_range(node), "\n#{node.loc.end.source}#{offset(node)}")
-          end
+          register_offense(node)
         end
 
+        alias on_numblock on_block
+
         private
 
+        def register_offense(node)
+          add_offense(node.loc.end, message: message(node)) do |corrector|
+            offense_range = offense_range(node)
+            replacement = replacement(node)
+
+            if (heredoc = last_heredoc_argument(node.body))
+              corrector.remove(offense_range)
+              corrector.insert_after(heredoc.loc.heredoc_end, replacement)
+            else
+              corrector.replace(offense_range, replacement)
+            end
+          end
+        end
+
         def message(node)
           format(MSG, line: node.loc.end.line, column: node.loc.end.column + 1)
         end
 
-        def delimiter_range(node)
+        def last_heredoc_argument(node)
+          return unless node&.call_type?
+          return unless (arguments = node&.arguments)
+
+          heredoc = arguments.reverse.detect { |arg| arg.str_type? && arg.heredoc? }
+          return heredoc if heredoc
+
+          last_heredoc_argument(node.children.first)
+        end
+
+        def offense_range(node)
           Parser::Source::Range.new(
             node.loc.expression.source_buffer,
             node.children.compact.last.loc.expression.end_pos,
-            node.loc.expression.end_pos
+            end_of_method_chain(node).loc.expression.end_pos
           )
         end
+
+        def replacement(node)
+          end_with_method_chain = node.loc.end.join(end_of_method_chain(node).loc.expression.end)
+
+          "\n#{end_with_method_chain.source.strip}"
+        end
+
+        def end_of_method_chain(node)
+          return node unless node.parent&.call_type?
+
+          end_of_method_chain(node.parent)
+        end
       end
     end
   end

data/lib/rubocop/cop/layout/case_indentation.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks how the `when` and `in`s of a `case` expression
+      # Checks how the `when` and ``in``s of a `case` expression
       # are indented in relation to its `case` or `end` keyword.
       #
       # It will register a separate offense for each misaligned `when` and `in`.
@@ -119,18 +119,34 @@ module RuboCop
 
         def on_case(case_node)
           return if case_node.single_line?
+          return if enforced_style_end? && end_and_last_conditional_same_line?(case_node)
 
           case_node.each_when { |when_node| check_when(when_node, 'when') }
         end
 
         def on_case_match(case_match_node)
           return if case_match_node.single_line?
+          return if enforced_style_end? && end_and_last_conditional_same_line?(case_match_node)
 
           case_match_node.each_in_pattern { |in_pattern_node| check_when(in_pattern_node, 'in') }
         end
 
         private
 
+        def end_and_last_conditional_same_line?(node)
+          end_line = node.loc.end&.line
+          last_conditional_line = if node.loc.else
+                                    node.loc.else.line
+                                  else
+                                    node.child_nodes.last.loc.begin&.line
+                                  end
+          end_line && last_conditional_line && end_line == last_conditional_line
+        end
+
+        def enforced_style_end?
+          cop_config[style_parameter_name] == 'end'
+        end
+
         def check_when(when_node, branch_type)
           when_column = when_node.loc.keyword.column
           base_column = base_column(when_node.parent, style)

data/lib/rubocop/cop/layout/class_structure.rb

@@ -132,25 +132,20 @@ module RuboCop
       #     end
       #   end
       #
-      # @see https://rubystyle.guide#consistent-classes
       class ClassStructure < Base
         include VisibilityHelp
+        include CommentsHelp
         extend AutoCorrector
 
         HUMANIZED_NODE_TYPE = {
           casgn: :constants,
-          defs: :class_methods,
+          defs: :public_class_methods,
           def: :public_methods,
           sclass: :class_singleton
         }.freeze
 
         MSG = '`%<category>s` is supposed to appear before `%<previous>s`.'
 
-        # @!method dynamic_constant?(node)
-        def_node_matcher :dynamic_constant?, <<~PATTERN
-          (casgn nil? _ (send ...))
-        PATTERN
-
         # Validates code style on class declaration.
         # Add offense when find a node out of expected order.
         def on_class(class_node)
@@ -169,7 +164,7 @@ module RuboCop
 
         # Autocorrect by swapping between two nodes autocorrecting them
         def autocorrect(corrector, node)
-          previous = node.left_siblings.find do |sibling|
+          previous = node.left_siblings.reverse.find do |sibling|
             !ignore_for_autocorrect?(node, sibling)
           end
           return unless previous
@@ -222,7 +217,7 @@ module RuboCop
         def walk_over_nested_class_definition(class_node)
           class_elements(class_node).each do |node|
             classification = classify(node)
-            next if ignore?(classification)
+            next if ignore?(node, classification)
 
             yield node, classification
           end
@@ -240,17 +235,20 @@ module RuboCop
           end
         end
 
-        def ignore?(classification)
+        def ignore?(node, classification)
           classification.nil? ||
             classification.to_s.end_with?('=') ||
-            expected_order.index(classification).nil?
+            expected_order.index(classification).nil? ||
+            private_constant?(node)
         end
 
         def ignore_for_autocorrect?(node, sibling)
           classification = classify(node)
           sibling_class = classify(sibling)
 
-          ignore?(sibling_class) || classification == sibling_class || dynamic_constant?(node)
+          ignore?(sibling, sibling_class) ||
+            classification == sibling_class ||
+            dynamic_constant?(node)
         end
 
         def humanize_node(node)
@@ -262,19 +260,28 @@ module RuboCop
           HUMANIZED_NODE_TYPE[node.type] || node.type
         end
 
-        def source_range_with_comment(node)
-          begin_pos, end_pos =
-            if (node.def_type? && !node.method?(:initialize)) ||
-               (node.send_type? && node.def_modifier?)
-              start_node = find_visibility_start(node) || node
-              end_node = find_visibility_end(node) || node
-              [begin_pos_with_comment(start_node),
-               end_position_for(end_node) + 1]
-            else
-              [begin_pos_with_comment(node), end_position_for(node)]
-            end
+        def dynamic_constant?(node)
+          return false unless node.casgn_type? && node.namespace.nil?
+
+          expression = node.expression
+          expression.send_type? &&
+            !(expression.method?(:freeze) && expression.receiver&.recursive_basic_literal?)
+        end
+
+        def private_constant?(node)
+          return false unless node.casgn_type? && node.namespace.nil?
+          return false unless (parent = node.parent)
+
+          parent.each_child_node(:send) do |child_node|
+            return true if marked_as_private_constant?(child_node, node.name)
+          end
+          false
+        end
+
+        def marked_as_private_constant?(node, name)
+          return false unless node.method?(:private_constant)
 
-          Parser::Source::Range.new(buffer, begin_pos, end_pos)
+          node.arguments.any? { |arg| (arg.sym_type? || arg.str_type?) && arg.value == name }
         end
 
         def end_position_for(node)

data/lib/rubocop/cop/layout/closing_parenthesis_indentation.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks the indentation of hanging closing parentheses in
+      # Checks the indentation of hanging closing parentheses in
       # method calls, method definitions, and grouped expressions. A hanging
       # closing parenthesis means `)` preceded by a line break.
       #
@@ -144,7 +144,7 @@ module RuboCop
         def expected_column(left_paren, elements)
           if line_break_after_left_paren?(left_paren, elements)
             source_indent = processed_source.line_indentation(first_argument_line(elements))
-            new_indent    = source_indent - indentation_width
+            new_indent    = source_indent - configured_indentation_width
 
             new_indent.negative? ? 0 : new_indent
           elsif all_elements_aligned?(elements)
@@ -157,7 +157,7 @@ module RuboCop
         def all_elements_aligned?(elements)
           elements.flat_map do |e|
             if e.hash_type?
-              e.each_pair.map { |pair| pair.loc.column }
+              e.each_child_node.map { |child| child.loc.column }
             else
               e.loc.column
             end
@@ -184,10 +184,6 @@ module RuboCop
           end
         end
 
-        def indentation_width
-          @config.for_cop('Layout/IndentationWidth')['Width'] || 2
-        end
-
         def line_break_after_left_paren?(left_paren, elements)
           elements.first && elements.first.loc.line > left_paren.line
         end

data/lib/rubocop/cop/layout/comment_indentation.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks the indentation of comments.
+      # Checks the indentation of comments.
       #
       # @example
       #   # bad
@@ -32,6 +32,19 @@ module RuboCop
       #     true
       #   end
       #
+      # @example AllowForAlignment: false (default)
+      #   # bad
+      #   a = 1 # A really long comment
+      #         # spanning two lines.
+      #
+      #   # good
+      #   # A really long comment spanning one line.
+      #   a = 1
+      #
+      # @example AllowForAlignment: true
+      #   # good
+      #   a = 1 # A really long comment
+      #         # spanning two lines.
       class CommentIndentation < Base
         include Alignment
         extend AutoCorrector
@@ -40,7 +53,7 @@ module RuboCop
               'instead of %<correct_comment_indentation>d).'
 
         def on_new_investigation
-          processed_source.comments.each { |comment| check(comment) }
+          processed_source.comments.each_with_index { |comment, ix| check(comment, ix) }
         end
 
         private
@@ -76,7 +89,7 @@ module RuboCop
           AlignmentCorrector.correct(corrector, processed_source, comment, @column_delta)
         end
 
-        def check(comment)
+        def check(comment, comment_index)
           return unless own_line_comment?(comment)
 
           next_line = line_after_comment(comment)
@@ -94,11 +107,27 @@ module RuboCop
             return if column == correct_comment_indentation
           end
 
+          return if correctly_aligned_with_preceding_comment?(comment_index, column)
+
           add_offense(comment, message: message(column, correct_comment_indentation)) do |corrector|
             autocorrect(corrector, comment)
           end
         end
 
+        # Returns true if:
+        # a) the cop is configured to allow extra indentation for alignment, and
+        # b) the currently inspected comment is aligned with the nearest preceding end-of-line
+        #    comment.
+        def correctly_aligned_with_preceding_comment?(comment_index, column)
+          return false unless cop_config['AllowForAlignment']
+
+          processed_source.comments[0...comment_index].reverse_each do |other_comment|
+            return other_comment.loc.column == column unless own_line_comment?(other_comment)
+          end
+
+          false
+        end
+
         def message(column, correct_comment_indentation)
           format(MSG, column: column, correct_comment_indentation: correct_comment_indentation)
         end
@@ -110,7 +139,7 @@ module RuboCop
 
         def line_after_comment(comment)
           lines = processed_source.lines
-          lines[comment.loc.line..-1].find { |line| !line.blank? }
+          lines[comment.loc.line..].find { |line| !line.blank? }
         end
 
         def correct_indentation(next_line)
@@ -125,7 +154,9 @@ module RuboCop
         end
 
         def less_indented?(line)
-          /^\s*(end\b|[)}\]])/.match?(line)
+          rule = config.for_cop('Layout/AccessModifierIndentation')['EnforcedStyle'] == 'outdent'
+          access_modifier = 'private|protected|public'
+          /\A\s*(end\b|[)}\]])/.match?(line) || (rule && /\A\s*(#{access_modifier})\b/.match?(line))
         end
 
         def two_alternatives?(line)

data/lib/rubocop/cop/layout/condition_position.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks for conditions that are not on the same line as
+      # Checks for conditions that are not on the same line as
       # if/while/until.
       #
       # @example

data/lib/rubocop/cop/layout/def_end_alignment.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks whether the end keywords of method definitions are
+      # Checks whether the end keywords of method definitions are
       # aligned properly.
       #
       # Two modes are supported through the EnforcedStyleAlignWith configuration

data/lib/rubocop/cop/layout/dot_position.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks the . position in multi-line method calls.
+      # Checks the . position in multi-line method calls.
       #
       # @example EnforcedStyle: leading (default)
       #   # bad
@@ -27,6 +27,10 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
+        def self.autocorrect_incompatible_with
+          [Style::RedundantSelf]
+        end
+
         def on_send(node)
           return unless node.dot? || ampersand_dot?(node)
 
@@ -68,12 +72,12 @@ module RuboCop
         end
 
         def proper_dot_position?(node)
-          receiver_line = receiver_end_line(node.receiver)
-          selector_line = selector_range(node).line
+          selector_range = selector_range(node)
 
-          # receiver and selector are on the same line
-          return true if selector_line == receiver_line
+          return true if same_line?(selector_range, end_range(node.receiver))
 
+          selector_line = selector_range.line
+          receiver_line = receiver_end_line(node.receiver)
           dot_line = node.loc.dot.line
 
           # don't register an offense if there is a line comment between the
@@ -119,7 +123,13 @@ module RuboCop
           (node.str_type? || node.dstr_type?) && node.heredoc?
         end
 
+        def end_range(node)
+          node.source_range.end
+        end
+
         def selector_range(node)
+          return node unless node.call_type?
+
           # l.(1) has no selector, so we use the opening parenthesis instead
           node.loc.selector || node.loc.begin
         end