rubocop 1.11.0 → 1.15.0

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

@@ -16,8 +16,7 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Use `method?(%<method_name>s)` instead of ' \
-              '`method_name == %<method_name>s`.'
+        MSG = 'Use `method?(%<method_name>s)` instead of `method_name == %<method_name>s`.'
         RESTRICT_ON_SEND = %i[==].freeze
 
         # @!method method_name?(node)
@@ -43,9 +42,7 @@ module RuboCop
         private
 
         def range(method_name_node, node)
-          range_between(
-            method_name_node.loc.selector.begin_pos, node.source_range.end_pos
-          )
+          range_between(method_name_node.loc.selector.begin_pos, node.source_range.end_pos)
         end
       end
     end

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

@@ -30,9 +30,7 @@ module RuboCop
         PATTERN
 
         def on_masgn(node)
-          node_destructuring?(node) do
-            add_offense(node)
-          end
+          node_destructuring?(node) { add_offense(node) }
         end
 
         private

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

@@ -30,9 +30,7 @@ module RuboCop
 
             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
-              )
+              range = node.loc.expression.with(begin_pos: receiver.loc.expression.end_pos + 1)
               corrector.replace(range, "#{node_type}_type?")
             end
           end

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

@@ -16,8 +16,7 @@ module RuboCop
       class OffenseLocationKeyword < Base
         extend AutoCorrector
 
-        MSG = 'Use `:%<keyword>s` as the location argument to ' \
-              '`#add_offense`.'
+        MSG = 'Use `:%<keyword>s` as the location argument to `#add_offense`.'
         RESTRICT_ON_SEND = %i[add_offense].freeze
 
         def on_send(node)

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

@@ -58,8 +58,7 @@ module RuboCop
         MSG_FOR_NEGATIVE_WITHOUT_POSITIVE =
           'negative `*_style_detected` methods called without ' \
           'calling `correct_style_detected` method.'
-        MSG_FOR_CONDITIONAL_USE =
-          '`*_style_detected` method called in conditional.'
+        MSG_FOR_CONDITIONAL_USE = '`*_style_detected` method called in conditional.'
         RESTRICT_ON_SEND = %i[
           correct_style_detected opposite_style_detected
           unexpected_style_detected ambiguous_style_detected

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

@@ -27,9 +27,7 @@ module RuboCop
         PATTERN
 
         def on_new_investigation
-          assertions_using_described_class_msg.each do |node|
-            add_offense(node)
-          end
+          assertions_using_described_class_msg.each { |node| add_offense(node) }
         end
 
         private

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,71 @@ 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.'
 
         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?
+            check_alignment(first_arg.pairs, base_column(node, first_arg.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 +84,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,8 +33,9 @@ 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.'
@@ -49,13 +50,13 @@ module RuboCop
           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

@@ -52,10 +52,7 @@ module RuboCop
         private
 
         def check_begin_alignment(node)
-          align_with = {
-            begin: node.loc.begin,
-            start_of_line: start_line_range(node)
-          }
+          align_with = { begin: node.loc.begin, start_of_line: start_line_range(node) }
           check_end_kw_alignment(node, align_with)
         end
 

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

@@ -109,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)
@@ -123,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,
@@ -174,9 +165,7 @@ module RuboCop
                            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)
           )
@@ -192,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],

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

@@ -24,8 +24,9 @@ module RuboCop
       #   blah { |i|
       #     foo(i)
       #   }
-      class BlockEndNewline < Cop
+      class BlockEndNewline < Base
         include Alignment
+        extend AutoCorrector
 
         MSG = 'Expression at %<line>d, %<column>d should be on its own line.'
 
@@ -35,13 +36,8 @@ 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, location: :end)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(delimiter_range(node),
-                              "\n#{node.loc.end.source}#{offset(node)}")
+          add_offense(node.loc.end, message: message(node)) do |corrector|
+            corrector.replace(delimiter_range(node), "\n#{node.loc.end.source}#{offset(node)}")
           end
         end
 

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

@@ -78,9 +78,7 @@ module RuboCop
         def on_case(case_node)
           return if case_node.single_line?
 
-          case_node.each_when do |when_node|
-            check_when(when_node)
-          end
+          case_node.each_when { |when_node| check_when(when_node) }
         end
 
         private

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

@@ -144,8 +144,7 @@ module RuboCop
           sclass: :class_singleton
         }.freeze
 
-        MSG = '`%<category>s` is supposed to appear before ' \
-              '`%<previous>s`.'
+        MSG = '`%<category>s` is supposed to appear before `%<previous>s`.'
 
         # @!method dynamic_constant?(node)
         def_node_matcher :dynamic_constant?, <<~PATTERN
@@ -159,11 +158,8 @@ module RuboCop
           walk_over_nested_class_definition(class_node) do |node, category|
             index = expected_order.index(category)
             if index < previous
-              message = format(MSG, category: category,
-                                    previous: expected_order[previous])
-              add_offense(node, message: message) do |corrector|
-                autocorrect(corrector, node)
-              end
+              message = format(MSG, category: category, previous: expected_order[previous])
+              add_offense(node, message: message) { |corrector| autocorrect(corrector, node) }
             end
             previous = index
           end
@@ -254,9 +250,7 @@ module RuboCop
           classification = classify(node)
           sibling_class = classify(sibling)
 
-          ignore?(sibling_class) ||
-            classification == sibling_class ||
-            dynamic_constant?(node)
+          ignore?(sibling_class) || classification == sibling_class || dynamic_constant?(node)
         end
 
         def humanize_node(node)