rubocop 0.51.0 → 0.87.0

data/lib/rubocop/cop/internal_affairs/node_type_predicate.rb

@@ -13,29 +13,26 @@ module RuboCop
       #   # good
       #   node.send_type?
       #
-      class NodeTypePredicate < Cop
-        MSG = 'Use `#%s_type?` to check node type.'.freeze
+      class NodeTypePredicate < Base
+        extend AutoCorrector
 
-        def_node_matcher :node_type_check, <<-PATTERN
+        MSG = 'Use `#%<type>s_type?` to check node type.'
+
+        def_node_matcher :node_type_check, <<~PATTERN
           (send (send $_ :type) :== (sym $_))
         PATTERN
 
         def on_send(node)
-          node_type_check(node) do |_receiver, node_type|
+          node_type_check(node) do |receiver, node_type|
             return unless Parser::Meta::NODE_TYPES.include?(node_type)
 
-            add_offense(node, message: format(MSG, node_type))
-          end
-        end
-
-        def autocorrect(node)
-          receiver, node_type = node_type_check(node)
-          range = Parser::Source::Range.new(node.source_range.source_buffer,
-                                            receiver.loc.expression.end_pos + 1,
-                                            node.loc.expression.end_pos)
-
-          lambda do |corrector|
-            corrector.replace(range, "#{node_type}_type?")
+            message = format(MSG, type: node_type)
+            add_offense(node, message: message) do |corrector|
+              range = node.loc.expression.with(
+                begin_pos: receiver.loc.expression.end_pos + 1
+              )
+              corrector.replace(range, "#{node_type}_type?")
+            end
           end
         end
       end

data/lib/rubocop/cop/internal_affairs/offense_location_keyword.rb

@@ -14,32 +14,33 @@ module RuboCop
       #   # good
       #   add_offense(node, location: :selector)
       class OffenseLocationKeyword < Cop
-        MSG = 'Use `:%s` as the location argument to `#add_offense`.'.freeze
+        MSG = 'Use `:%<keyword>s` as the location argument to ' \
+              '`#add_offense`.'
 
         def on_send(node)
           node_type_check(node) do |node_arg, kwargs|
             find_offending_argument(node_arg, kwargs) do |location, keyword|
-              add_offense(location, message: format(MSG, keyword))
+              add_offense(location, message: format(MSG, keyword: keyword))
             end
           end
         end
 
+        def autocorrect(node)
+          (*, keyword) = offending_location_argument(node.parent)
+
+          ->(corrector) { corrector.replace(node, ":#{keyword}") }
+        end
+
         private
 
-        def_node_matcher :node_type_check, <<-PATTERN
+        def_node_matcher :node_type_check, <<~PATTERN
           (send nil? :add_offense $_node $hash)
         PATTERN
 
-        def_node_matcher :offending_location_argument, <<-PATTERN
+        def_node_matcher :offending_location_argument, <<~PATTERN
           (pair (sym :location) $(send (send $_node :loc) $_keyword))
         PATTERN
 
-        def autocorrect(node)
-          (*, keyword) = offending_location_argument(node.parent)
-
-          ->(corrector) { corrector.replace(node.source_range, ":#{keyword}") }
-        end
-
         def find_offending_argument(searched_node, kwargs)
           kwargs.pairs.each do |pair|
             offending_location_argument(pair) do |location, node, keyword|

data/lib/rubocop/cop/internal_affairs/redundant_location_argument.rb

@@ -17,14 +17,14 @@ module RuboCop
       #   add_offense(node, location: :selector)
       #
       class RedundantLocationArgument < Cop
-        MSG = 'Redundant location argument to `#add_offense`.'.freeze
+        include RangeHelp
 
-        def_node_matcher :add_offense_kwargs, <<-PATTERN
-          (send nil? :add_offense _ $hash)
-        PATTERN
+        MSG = 'Redundant location argument to `#add_offense`.'
 
-        def_node_matcher :redundant_location_argument?, <<-PATTERN
-          (pair (sym :location) (sym :expression))
+        def_node_matcher :redundant_location_argument, <<~PATTERN
+          (send nil? :add_offense _
+            (hash <$(pair (sym :location) (sym :expression)) ...>)
+          )
         PATTERN
 
         def on_send(node)
@@ -37,19 +37,8 @@ module RuboCop
           ->(corrector) { corrector.remove(range) }
         end
 
-        private
-
-        def redundant_location_argument(node)
-          add_offense_kwargs(node) do |kwargs|
-            result =
-              kwargs.pairs.find { |arg| redundant_location_argument?(arg) }
-
-            yield result if result
-          end
-        end
-
         def offending_range(node)
-          with_space = range_with_surrounding_space(node.loc.expression)
+          with_space = range_with_surrounding_space(range: node.loc.expression)
 
           range_with_surrounding_comma(with_space, :left)
         end

data/lib/rubocop/cop/internal_affairs/redundant_message_argument.rb

@@ -20,13 +20,15 @@ module RuboCop
       #   add_offense(node, message: message(other_node))
       #
       class RedundantMessageArgument < Cop
-        MSG = 'Redundant message argument to `#add_offense`.'.freeze
+        include RangeHelp
 
-        def_node_matcher :node_type_check, <<-PATTERN
+        MSG = 'Redundant message argument to `#add_offense`.'
+
+        def_node_matcher :node_type_check, <<~PATTERN
           (send nil? :add_offense $_node $hash)
         PATTERN
 
-        def_node_matcher :redundant_message_argument, <<-PATTERN
+        def_node_matcher :redundant_message_argument, <<~PATTERN
           (pair
             (sym :message)
             ${(const nil? :MSG) (send nil? :message) (send nil? :message _)})
@@ -51,7 +53,7 @@ module RuboCop
         private
 
         def offending_range(node)
-          with_space = range_with_surrounding_space(node.loc.expression)
+          with_space = range_with_surrounding_space(range: node.loc.expression)
 
           range_with_surrounding_comma(with_space, :left)
         end

data/lib/rubocop/cop/internal_affairs/useless_message_assertion.rb

@@ -14,13 +14,13 @@ module RuboCop
       #     expect(cop.messages).to eq(['Do not write bad code like that.'])
       #
       class UselessMessageAssertion < Cop
-        MSG = 'Do not specify cop behavior using `described_class::MSG`.'.freeze
+        MSG = 'Do not specify cop behavior using `described_class::MSG`.'
 
-        def_node_search :described_class_msg, <<-PATTERN
+        def_node_search :described_class_msg, <<~PATTERN
           (const (send nil? :described_class) :MSG)
         PATTERN
 
-        def_node_matcher :rspec_expectation_on_msg?, <<-PATTERN
+        def_node_matcher :rspec_expectation_on_msg?, <<~PATTERN
           (send (send nil? :expect #contains_described_class_msg?) :to ...)
         PATTERN
 

data/lib/rubocop/cop/internal_affairs.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
 
+require_relative 'internal_affairs/method_name_equal'
+require_relative 'internal_affairs/node_destructuring'
 require_relative 'internal_affairs/node_type_predicate'
 require_relative 'internal_affairs/offense_location_keyword'
 require_relative 'internal_affairs/redundant_message_argument'
 require_relative 'internal_affairs/redundant_location_argument'
 require_relative 'internal_affairs/useless_message_assertion'
-require_relative 'internal_affairs/deprecated_positional_arguments'

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

@@ -3,12 +3,11 @@
 module RuboCop
   module Cop
     module Layout
-      # Modifiers should be indented as deep as method definitions, or as deep
-      # as the class/module keyword, depending on configuration.
-      #
-      # @example
-      #   # EnforcedStyle: indent (default)
+      # Bare access modifiers (those not applying to specific methods) should be
+      # indented as deep as method definitions, or as deep as the class/module
+      # keyword, depending on configuration.
       #
+      # @example EnforcedStyle: indent (default)
       #   # bad
       #   class Plumbus
       #   private
@@ -21,8 +20,7 @@ module RuboCop
       #     def smooth; end
       #   end
       #
-      #   # EnforcedStyle: outdent
-      #
+      # @example EnforcedStyle: outdent
       #   # bad
       #   class Plumbus
       #     private
@@ -35,46 +33,37 @@ module RuboCop
       #     def smooth; end
       #   end
       class AccessModifierIndentation < Cop
-        include AutocorrectAlignment
+        include Alignment
         include ConfigurableEnforcedStyle
+        include RangeHelp
 
-        MSG = '%s access modifiers like `%s`.'.freeze
+        MSG = '%<style>s access modifiers like `%<node>s`.'
 
         def on_class(node)
-          _name, _base_class, body = *node
-          check_body(body, node)
-        end
-
-        def on_sclass(node)
-          _name, body = *node
-          check_body(body, node)
-        end
+          return unless node.body&.begin_type?
 
-        def on_module(node)
-          _name, body = *node
-          check_body(body, node)
+          check_body(node.body, node)
         end
+        alias on_sclass on_class
+        alias on_module on_class
+        alias on_block  on_class
 
-        def on_block(node)
-          return unless node.class_constructor?
-
-          check_body(node.body, node)
+        def autocorrect(node)
+          AlignmentCorrector.correct(processed_source, node, @column_delta)
         end
 
         private
 
         def check_body(body, node)
-          return if body.nil? # Empty class etc.
-
-          modifiers = body.each_child_node(:send).select(&:access_modifier?)
-          class_column = node.source_range.column
+          modifiers = body.each_child_node(:send)
+                          .select(&:bare_access_modifier?)
+          end_range = node.loc.end
 
-          modifiers.each { |modifier| check_modifier(modifier, class_column) }
+          modifiers.each { |modifier| check_modifier(modifier, end_range) }
         end
 
-        def check_modifier(send_node, class_start_col)
-          access_modifier_start_col = send_node.source_range.column
-          offset = access_modifier_start_col - class_start_col
+        def check_modifier(send_node, end_range)
+          offset = column_offset_between(send_node.source_range, end_range)
 
           @column_delta = expected_indent_offset - offset
           if @column_delta.zero?
@@ -91,7 +80,7 @@ module RuboCop
         end
 
         def message(node)
-          format(MSG, style.capitalize, node.loc.selector.source)
+          format(MSG, style: style.capitalize, node: node.loc.selector.source)
         end
 
         def expected_indent_offset

data/lib/rubocop/cop/layout/{align_parameters.rb → argument_alignment.rb}

@@ -3,27 +3,31 @@
 module RuboCop
   module Cop
     module Layout
-      # Here we check if the parameters on a multi-line method call or
+      # Here we check if the arguments on a multi-line method
       # definition are aligned.
       #
-      # @example
-      #
-      #   # EnforcedStyle: with_first_parameter
-      #
+      # @example EnforcedStyle: with_first_argument (default)
       #   # good
       #
       #   foo :bar,
       #       :baz
       #
+      #   foo(
+      #     :bar,
+      #     :baz
+      #   )
+      #
       #   # bad
       #
       #   foo :bar,
       #     :baz
       #
-      # @example
-      #
-      #   # EnforcedStyle: with_fixed_indentation
+      #   foo(
+      #     :bar,
+      #       :baz
+      #   )
       #
+      # @example EnforcedStyle: with_fixed_indentation
       #   # good
       #
       #   foo :bar,
@@ -33,14 +37,14 @@ module RuboCop
       #
       #   foo :bar,
       #       :baz
-      class AlignParameters < Cop
-        include AutocorrectAlignment
+      class ArgumentAlignment < Cop
+        include Alignment
 
-        ALIGN_PARAMS_MSG = 'Align the parameters of a method %s if they span ' \
-          'more than one line.'.freeze
+        ALIGN_PARAMS_MSG = 'Align the arguments of a method call if ' \
+          'they span more than one line.'
 
-        FIXED_INDENT_MSG = 'Use one level of indentation for parameters ' \
-          'following the first line of a multi-line method %s.'.freeze
+        FIXED_INDENT_MSG = 'Use one level of indentation for arguments ' \
+          'following the first line of a multi-line method call.'
 
         def on_send(node)
           return if node.arguments.size < 2 ||
@@ -48,16 +52,16 @@ module RuboCop
 
           check_alignment(node.arguments, base_column(node, node.arguments))
         end
-        alias on_def  on_send
-        alias on_defs on_send
+        alias on_csend on_send
 
-        private
+        def autocorrect(node)
+          AlignmentCorrector.correct(processed_source, node, column_delta)
+        end
 
-        def message(node)
-          type = node && node.parent.send_type? ? 'call' : 'definition'
-          msg = fixed_indentation? ? FIXED_INDENT_MSG : ALIGN_PARAMS_MSG
+        private
 
-          format(msg, type)
+        def message(_node)
+          fixed_indentation? ? FIXED_INDENT_MSG : ALIGN_PARAMS_MSG
         end
 
         def fixed_indentation?
@@ -76,9 +80,7 @@ module RuboCop
         end
 
         def target_method_lineno(node)
-          if node.def_type? || node.defs_type?
-            node.loc.keyword.line
-          elsif node.loc.selector
+          if node.loc.selector
             node.loc.selector.line
           else
             # l.(1) has no selector, so we use the opening parenthesis instead

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Here we check if the elements of a multi-line array literal are
+      # aligned.
+      #
+      # @example EnforcedStyle: with_first_element (default)
+      #   # good
+      #
+      #   array = [1, 2, 3,
+      #            4, 5, 6]
+      #   array = ['run',
+      #            'forrest',
+      #            'run']
+      #
+      #   # bad
+      #
+      #   array = [1, 2, 3,
+      #     4, 5, 6]
+      #   array = ['run',
+      #        'forrest',
+      #        'run']
+      #
+      # @example EnforcedStyle: with_fixed_indentation
+      #   # good
+      #
+      #   array = [1, 2, 3,
+      #     4, 5, 6]
+      #
+      #   # bad
+      #
+      #   array = [1, 2, 3,
+      #            4, 5, 6]
+      class ArrayAlignment < Cop
+        include Alignment
+
+        ALIGN_ELEMENTS_MSG = 'Align the elements of an array literal ' \
+          'if they span more than one line.'
+
+        FIXED_INDENT_MSG = 'Use one level of indentation for elements ' \
+          'following the first line of a multi-line array.'
+
+        def on_array(node)
+          return if node.children.size < 2
+
+          check_alignment(node.children, base_column(node, node.children))
+        end
+
+        def autocorrect(node)
+          AlignmentCorrector.correct(processed_source, node, column_delta)
+        end
+
+        private
+
+        def message(_node)
+          fixed_indentation? ? FIXED_INDENT_MSG : ALIGN_ELEMENTS_MSG
+        end
+
+        def fixed_indentation?
+          cop_config['EnforcedStyle'] == 'with_fixed_indentation'
+        end
+
+        def base_column(node, args)
+          if fixed_indentation?
+            lineno = target_method_lineno(node)
+            line = node.source_range.source_buffer.source_line(lineno)
+            indentation_of_line = /\S.*/.match(line).begin(0)
+            indentation_of_line + configured_indentation_width
+          else
+            display_column(args.first.source_range)
+          end
+        end
+
+        def target_method_lineno(node)
+          node.loc.line
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/layout/{indent_assignment.rb → assignment_indentation.rb}

@@ -21,21 +21,34 @@ module RuboCop
       #
       # The indentation of the remaining lines can be corrected with
       # other cops such as `IndentationConsistency` and `EndAlignment`.
-      class IndentAssignment < Cop
+      class AssignmentIndentation < Cop
         include CheckAssignment
-        include AutocorrectAlignment
+        include Alignment
 
         MSG = 'Indent the first line of the right-hand-side of a ' \
-              'multi-line assignment.'.freeze
+              'multi-line assignment.'
 
         def check_assignment(node, rhs)
           return unless rhs
           return unless node.loc.operator
-          return if node.loc.operator.line == rhs.loc.line
+          return if node.loc.operator.line == rhs.first_line
 
-          base = display_column(node.source_range)
+          base = display_column(leftmost_multiple_assignment(node).source_range)
           check_alignment([rhs], base + configured_indentation_width)
         end
+
+        def autocorrect(node)
+          AlignmentCorrector.correct(processed_source, node, column_delta)
+        end
+
+        def leftmost_multiple_assignment(node)
+          return node unless same_line?(node, node.parent) &&
+                             node.parent.assignment?
+
+          leftmost_multiple_assignment(node.parent)
+
+          node.parent
+        end
       end
     end
   end

data/lib/rubocop/cop/{lint → layout}/block_alignment.rb

@@ -2,7 +2,7 @@
 
 module RuboCop
   module Cop
-    module Lint
+    module Layout
       # This cop checks whether the end keywords are aligned properly for do
       # end blocks.
       #
@@ -18,8 +18,7 @@ module RuboCop
       # `either` (which is the default) : the `end` is allowed to be in either
       # location. The autofixer will default to `start_of_line`.
       #
-      # @example
-      #
+      # @example EnforcedStyleAlignWith: either (default)
       #   # bad
       #
       #   foo.bar
@@ -27,30 +26,34 @@ module RuboCop
       #        baz
       #          end
       #
-      # @example
-      #
-      #   # EnforcedStyleAlignWith: either (default)
-      #
       #   # good
       #
       #   variable = lambda do |i|
       #     i
       #   end
       #
-      # @example
+      # @example EnforcedStyleAlignWith: start_of_block
+      #   # bad
       #
-      #   # EnforcedStyleAlignWith: start_of_block
+      #   foo.bar
+      #      .each do
+      #        baz
+      #          end
       #
       #   # good
       #
       #   foo.bar
       #     .each do
-      #        baz
-      #      end
+      #       baz
+      #     end
       #
-      # @example
+      # @example EnforcedStyleAlignWith: start_of_line
+      #   # bad
       #
-      #   # EnforcedStyleAlignWith: start_of_line
+      #   foo.bar
+      #      .each do
+      #        baz
+      #          end
       #
       #   # good
       #
@@ -60,10 +63,11 @@ module RuboCop
       #   end
       class BlockAlignment < Cop
         include ConfigurableEnforcedStyle
+        include RangeHelp
 
-        MSG = '%s is not aligned with %s%s.'.freeze
+        MSG = '%<current>s is not aligned with %<prefer>s%<alt_prefer>s.'
 
-        def_node_matcher :block_end_align_target?, <<-PATTERN
+        def_node_matcher :block_end_align_target?, <<~PATTERN
           {assignment?
            splat
            and
@@ -80,6 +84,19 @@ module RuboCop
           'EnforcedStyleAlignWith'
         end
 
+        def autocorrect(node)
+          ancestor_node = start_for_block_node(node)
+          start_col = compute_start_col(ancestor_node, node)
+          loc_end = node.loc.end
+          delta = start_col - loc_end.column
+
+          if delta.positive?
+            add_space_before(loc_end, delta)
+          elsif delta.negative?
+            remove_space_before(loc_end.begin_pos, -delta)
+          end
+        end
+
         private
 
         def start_for_block_node(block_node)
@@ -108,7 +125,7 @@ module RuboCop
         end
 
         def disqualified_parent?(parent, node)
-          parent && parent.loc && parent.loc.line != node.loc.line &&
+          parent&.loc && parent.first_line != node.first_line &&
             !parent.masgn_type?
         end
 
@@ -153,9 +170,11 @@ module RuboCop
                            error_source_line_column)
           format(
             MSG,
-            format_source_line_column(loc_to_source_line_column(end_loc)),
-            format_source_line_column(error_source_line_column),
-            alt_start_msg(start_loc, do_source_line_column)
+            current: format_source_line_column(
+              loc_to_source_line_column(end_loc)
+            ),
+            prefer: format_source_line_column(error_source_line_column),
+            alt_prefer: alt_start_msg(start_loc, do_source_line_column)
           )
         end
 
@@ -211,19 +230,6 @@ module RuboCop
           (ancestor_node || node).source_range.column
         end
 
-        def autocorrect(node)
-          ancestor_node = start_for_block_node(node)
-          start_col = compute_start_col(ancestor_node, node)
-          loc_end = node.loc.end
-          delta = start_col - loc_end.column
-
-          if delta > 0
-            add_space_before(loc_end, delta)
-          elsif delta < 0
-            remove_space_before(loc_end.begin_pos, -delta)
-          end
-        end
-
         def add_space_before(loc, delta)
           ->(corrector) { corrector.insert_before(loc, ' ' * delta) }
         end