rubocop 0.82.0 → 1.18.4

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

@@ -13,21 +13,21 @@ module RuboCop
       #     # good
       #     expect(cop.messages).to eq(['Do not write bad code like that.'])
       #
-      class UselessMessageAssertion < Cop
+      class UselessMessageAssertion < Base
         MSG = 'Do not specify cop behavior using `described_class::MSG`.'
 
+        # @!method described_class_msg(node)
         def_node_search :described_class_msg, <<~PATTERN
           (const (send nil? :described_class) :MSG)
         PATTERN
 
+        # @!method rspec_expectation_on_msg?(node)
         def_node_matcher :rspec_expectation_on_msg?, <<~PATTERN
           (send (send nil? :expect #contains_described_class_msg?) :to ...)
         PATTERN
 
-        def investigate(_processed_source)
-          assertions_using_described_class_msg.each do |node|
-            add_offense(node)
-          end
+        def on_new_investigation
+          assertions_using_described_class_msg.each { |node| add_offense(node) }
         end
 
         private
@@ -38,7 +38,7 @@ module RuboCop
 
         def assertions_using_described_class_msg
           described_class_msg(processed_source.ast).reject do |node|
-            node.ancestors.any?(&method(:rspec_expectation_on_msg?))
+            node.ancestors.any? { |ancestor| rspec_expectation_on_msg?(ancestor) }
           end
         end
 

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

@@ -32,10 +32,11 @@ module RuboCop
       #   private
       #     def smooth; end
       #   end
-      class AccessModifierIndentation < Cop
+      class AccessModifierIndentation < Base
         include Alignment
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         MSG = '%<style>s access modifiers like `%<node>s`.'
 
@@ -48,15 +49,14 @@ module RuboCop
         alias on_module on_class
         alias on_block  on_class
 
-        def autocorrect(node)
-          AlignmentCorrector.correct(processed_source, node, @column_delta)
-        end
-
         private
 
+        def autocorrect(corrector, node)
+          AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
+        end
+
         def check_body(body, node)
-          modifiers = body.each_child_node(:send)
-                          .select(&:bare_access_modifier?)
+          modifiers = body.each_child_node(:send).select(&:bare_access_modifier?)
           end_range = node.loc.end
 
           modifiers.each { |modifier| check_modifier(modifier, end_range) }
@@ -69,18 +69,20 @@ module RuboCop
           if @column_delta.zero?
             correct_style_detected
           else
-            add_offense(send_node) do
+            add_offense(send_node) do |corrector|
               if offset == unexpected_indent_offset
                 opposite_style_detected
               else
                 unrecognized_style_detected
               end
+
+              autocorrect(corrector, send_node)
             end
           end
         end
 
-        def message(node)
-          format(MSG, style: style.capitalize, node: node.loc.selector.source)
+        def message(range)
+          format(MSG, style: style.capitalize, node: range.source)
         end
 
         def expected_indent_offset

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

@@ -10,55 +10,72 @@ module RuboCop
       #   # good
       #
       #   foo :bar,
-      #       :baz
+      #       :baz,
+      #       key: value
       #
       #   foo(
       #     :bar,
-      #     :baz
+      #     :baz,
+      #     key: value
       #   )
       #
       #   # bad
       #
       #   foo :bar,
-      #     :baz
+      #     :baz,
+      #     key: value
       #
       #   foo(
       #     :bar,
-      #       :baz
+      #       :baz,
+      #       key: value
       #   )
       #
       # @example EnforcedStyle: with_fixed_indentation
       #   # good
       #
       #   foo :bar,
-      #     :baz
+      #     :baz,
+      #     key: value
       #
       #   # bad
       #
       #   foo :bar,
-      #       :baz
-      class ArgumentAlignment < Cop
+      #       :baz,
+      #       key: value
+      class ArgumentAlignment < Base
         include Alignment
+        extend AutoCorrector
 
-        ALIGN_PARAMS_MSG = 'Align the arguments of a method call if ' \
-          'they span more than one line.'
+        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 arguments ' \
-          'following the first line of a multi-line method call.'
+                           'following the first line of a multi-line method call.'
 
         def on_send(node)
-          return if node.arguments.size < 2 ||
-                    node.send_type? && node.method?(:[]=)
+          first_arg = node.first_argument
+          return if !multiple_arguments?(node, first_arg) || node.send_type? && node.method?(:[]=)
 
-          check_alignment(node.arguments, base_column(node, node.arguments))
+          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
         end
         alias on_csend on_send
 
-        def autocorrect(node)
-          AlignmentCorrector.correct(processed_source, node, column_delta)
+        private
+
+        def multiple_arguments?(node, first_argument)
+          return true if node.arguments.size >= 2
+
+          first_argument&.hash_type? && first_argument.pairs.count >= 2
         end
 
-        private
+        def autocorrect(corrector, node)
+          AlignmentCorrector.correct(corrector, processed_source, node, column_delta)
+        end
 
         def message(_node)
           fixed_indentation? ? FIXED_INDENT_MSG : ALIGN_PARAMS_MSG
@@ -68,14 +85,14 @@ module RuboCop
           cop_config['EnforcedStyle'] == 'with_fixed_indentation'
         end
 
-        def base_column(node, args)
-          if fixed_indentation?
+        def base_column(node, first_argument)
+          if fixed_indentation? || first_argument.nil?
             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)
+            display_column(first_argument.source_range)
           end
         end
 

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

@@ -33,28 +33,30 @@ module RuboCop
       #
       #   array = [1, 2, 3,
       #            4, 5, 6]
-      class ArrayAlignment < Cop
+      class ArrayAlignment < Base
         include Alignment
+        extend AutoCorrector
 
         ALIGN_ELEMENTS_MSG = 'Align the elements of an array literal ' \
-          'if they span more than one line.'
+                             '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.'
+                           'following the first line of a multi-line array.'
 
         def on_array(node)
           return if node.children.size < 2
+          return if node.parent&.masgn_type?
 
           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)
+        def autocorrect(corrector, node)
+          AlignmentCorrector.correct(corrector, processed_source, node, column_delta)
+        end
+
+        def message(_range)
           fixed_indentation? ? FIXED_INDENT_MSG : ALIGN_ELEMENTS_MSG
         end
 

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

@@ -21,12 +21,14 @@ module RuboCop
       #
       # The indentation of the remaining lines can be corrected with
       # other cops such as `IndentationConsistency` and `EndAlignment`.
-      class AssignmentIndentation < Cop
+      class AssignmentIndentation < Base
         include CheckAssignment
         include Alignment
+        extend AutoCorrector
 
-        MSG = 'Indent the first line of the right-hand-side of a ' \
-              'multi-line assignment.'
+        MSG = 'Indent the first line of the right-hand-side of a multi-line assignment.'
+
+        private
 
         def check_assignment(node, rhs)
           return unless rhs
@@ -37,13 +39,12 @@ module RuboCop
           check_alignment([rhs], base + configured_indentation_width)
         end
 
-        def autocorrect(node)
-          AlignmentCorrector.correct(processed_source, node, column_delta)
+        def autocorrect(corrector, node)
+          AlignmentCorrector.correct(corrector, processed_source, node, column_delta)
         end
 
         def leftmost_multiple_assignment(node)
-          return node unless same_line?(node, node.parent) &&
-                             node.parent.assignment?
+          return node unless same_line?(node, node.parent) && node.parent.assignment?
 
           leftmost_multiple_assignment(node.parent)
 

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop 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
+      # `end` shall be aligned with the start of the line where the `begin`
+      # keyword is. If it's set to `begin`, the `end` shall be aligned with the
+      # `begin` keyword.
+      #
+      # `Layout/EndAlignment` cop aligns with keywords (e.g. `if`, `while`, `case`)
+      # by default. On the other hand, `||= begin` that this cop targets tends to
+      # align with the start of the line, it defaults to `EnforcedStyleAlignWith: start_of_line`.
+      # These style can be configured by each cop.
+      #
+      # @example EnforcedStyleAlignWith: start_of_line (default)
+      #   # bad
+      #   foo ||= begin
+      #             do_something
+      #           end
+      #
+      #   # good
+      #   foo ||= begin
+      #     do_something
+      #   end
+      #
+      # @example EnforcedStyleAlignWith: begin
+      #   # bad
+      #   foo ||= begin
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   foo ||= begin
+      #             do_something
+      #           end
+      #
+      class BeginEndAlignment < Base
+        include EndKeywordAlignment
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = '`end` at %d, %d is not aligned with `%s` at %d, %d.'
+
+        def on_kwbegin(node)
+          check_begin_alignment(node)
+        end
+
+        private
+
+        def check_begin_alignment(node)
+          align_with = { begin: node.loc.begin, start_of_line: start_line_range(node) }
+          check_end_kw_alignment(node, align_with)
+        end
+
+        def autocorrect(corrector, node)
+          AlignmentCorrector.align_end(corrector, processed_source, node, alignment_node(node))
+        end
+
+        def alignment_node(node)
+          case style
+          when :begin
+            node
+          else
+            start_line_range(node)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -61,12 +61,14 @@ module RuboCop
       #     .each do
       #        baz
       #   end
-      class BlockAlignment < Cop
+      class BlockAlignment < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         MSG = '%<current>s is not aligned with %<prefer>s%<alt_prefer>s.'
 
+        # @!method block_end_align_target?(node, child)
         def_node_matcher :block_end_align_target?, <<~PATTERN
           {assignment?
            splat
@@ -84,19 +86,6 @@ 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)
@@ -120,13 +109,11 @@ module RuboCop
         end
 
         def end_align_target?(node, parent)
-          disqualified_parent?(parent, node) ||
-            !block_end_align_target?(parent, node)
+          disqualified_parent?(parent, node) || !block_end_align_target?(parent, node)
         end
 
         def disqualified_parent?(parent, node)
-          parent&.loc && parent.first_line != node.first_line &&
-            !parent.masgn_type?
+          parent&.loc && parent.first_line != node.first_line && !parent.masgn_type?
         end
 
         def check_block_alignment(start_node, block_node)
@@ -134,19 +121,12 @@ module RuboCop
           return unless begins_its_line?(end_loc)
 
           start_loc = start_node.source_range
-          return unless start_loc.column != end_loc.column ||
-                        style == :start_of_block
+          return unless start_loc.column != end_loc.column || style == :start_of_block
 
-          do_source_line_column =
-            compute_do_source_line_column(block_node, end_loc)
+          do_source_line_column = compute_do_source_line_column(block_node, end_loc)
           return unless do_source_line_column
 
-          register_offense(
-            block_node,
-            start_loc,
-            end_loc,
-            do_source_line_column
-          )
+          register_offense(block_node, start_loc, end_loc, do_source_line_column)
         end
 
         def register_offense(block_node,
@@ -163,16 +143,29 @@ module RuboCop
           message = format_message(start_loc, end_loc, do_source_line_column,
                                    error_source_line_column)
 
-          add_offense(block_node, location: end_loc, message: message)
+          add_offense(end_loc, message: message) do |corrector|
+            autocorrect(corrector, block_node)
+          end
+        end
+
+        def autocorrect(corrector, 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(corrector, loc_end, delta)
+          elsif delta.negative?
+            remove_space_before(corrector, loc_end.begin_pos, -delta)
+          end
         end
 
         def format_message(start_loc, end_loc, do_source_line_column,
                            error_source_line_column)
           format(
             MSG,
-            current: format_source_line_column(
-              loc_to_source_line_column(end_loc)
-            ),
+            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)
           )
@@ -188,8 +181,7 @@ module RuboCop
           # blocks.
           match = /\S.*/.match(do_loc.source_line)
           indentation_of_do_line = match.begin(0)
-          return unless end_loc.column != indentation_of_do_line ||
-                        style == :start_of_line
+          return unless end_loc.column != indentation_of_do_line || style == :start_of_line
 
           {
             source: match[0],
@@ -207,19 +199,18 @@ module RuboCop
         end
 
         def alt_start_msg(start_loc, source_line_column)
-          if style != :either
-            ''
-          elsif start_loc.line == source_line_column[:line] &&
-                start_loc.column == source_line_column[:column]
+          if style != :either ||
+             (start_loc.line == source_line_column[:line] &&
+                 start_loc.column == source_line_column[:column])
             ''
           else
-            ' or ' + format_source_line_column(source_line_column)
+            " or #{format_source_line_column(source_line_column)}"
           end
         end
 
         def format_source_line_column(source_line_column)
           "`#{source_line_column[:source]}` at #{source_line_column[:line]}, " \
-          "#{source_line_column[:column]}"
+            "#{source_line_column[:column]}"
         end
 
         def compute_start_col(ancestor_node, node)
@@ -230,13 +221,14 @@ module RuboCop
           (ancestor_node || node).source_range.column
         end
 
-        def add_space_before(loc, delta)
-          ->(corrector) { corrector.insert_before(loc, ' ' * delta) }
+        def add_space_before(corrector, loc, delta)
+          corrector.insert_before(loc, ' ' * delta)
         end
 
-        def remove_space_before(end_pos, delta)
+        def remove_space_before(corrector, end_pos, delta)
           range = range_between(end_pos - delta, end_pos)
-          ->(corrector) { corrector.remove(range) }
+
+          corrector.remove(range)
         end
       end
     end