rubocop 1.10.0 → 1.14.0

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

@@ -19,6 +19,7 @@ module RuboCop
         MSG = 'Use `#%<type>s_type?` to check node type.'
         RESTRICT_ON_SEND = %i[==].freeze
 
+        # @!method node_type_check(node)
         def_node_matcher :node_type_check, <<~PATTERN
           (send (send $_ :type) :== (sym $_))
         PATTERN
@@ -29,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)
@@ -34,10 +33,12 @@ module RuboCop
 
         private
 
+        # @!method node_type_check(node)
         def_node_matcher :node_type_check, <<~PATTERN
           (send nil? :add_offense $_node $hash)
         PATTERN
 
+        # @!method offending_location_argument(node)
         def_node_matcher :offending_location_argument, <<~PATTERN
           (pair (sym :location) $(send (send $_node :loc) $_keyword))
         PATTERN

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

@@ -21,6 +21,7 @@ module RuboCop
 
         MSG = 'Remove the redundant `subject`%<additional_message>s.'
 
+        # @!method described_class_subject?(node)
         def_node_matcher :described_class_subject?, <<~PATTERN
           (block
             (send nil? :subject

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

@@ -25,6 +25,7 @@ module RuboCop
 
         MSG = 'Remove `let` that is `RuboCop::Config.new` with no arguments%<additional_message>s.'
 
+        # @!method let_rubocop_config_new?(node)
         def_node_matcher :let_rubocop_config_new?, <<~PATTERN
           (block
             (send nil? :let

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

@@ -23,6 +23,7 @@ module RuboCop
         MSG = 'Redundant location argument to `#add_offense`.'
         RESTRICT_ON_SEND = %i[add_offense].freeze
 
+        # @!method redundant_location_argument(node)
         def_node_matcher :redundant_location_argument, <<~PATTERN
           (send nil? :add_offense _
             (hash <$(pair (sym :location) (sym :expression)) ...>)

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

@@ -26,16 +26,19 @@ module RuboCop
         MSG = 'Redundant message argument to `#add_offense`.'
         RESTRICT_ON_SEND = %i[add_offense].freeze
 
+        # @!method node_type_check(node)
         def_node_matcher :node_type_check, <<~PATTERN
           (send nil? :add_offense $_node $hash)
         PATTERN
 
+        # @!method redundant_message_argument(node)
         def_node_matcher :redundant_message_argument, <<~PATTERN
           (pair
             (sym :message)
             ${(const nil? :MSG) (send nil? :message) (send nil? :message _)})
         PATTERN
 
+        # @!method message_method_call(node)
         def_node_matcher :message_method_call, '(send nil? :message $_node)'
 
         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
@@ -67,18 +66,22 @@ module RuboCop
           no_acceptable_style! style_detected
         ].freeze
 
+        # @!method correct_style_detected_check(node)
         def_node_matcher :correct_style_detected_check, <<~PATTERN
           (send nil? :correct_style_detected)
         PATTERN
 
+        # @!method negative_style_detected_method_check(node)
         def_node_matcher :negative_style_detected_method_check, <<~PATTERN
           (send nil? /(?:opposite|unexpected|ambiguous|unrecognized)_style_detected|conflicting_styles_detected/ ...)
         PATTERN
 
+        # @!method no_acceptable_style_check(node)
         def_node_matcher :no_acceptable_style_check, <<~PATTERN
           (send nil? :no_acceptable_style!)
         PATTERN
 
+        # @!method style_detected_check(node)
         def_node_matcher :style_detected_check, <<~PATTERN
           (send nil? :style_detected ...)
         PATTERN

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

@@ -16,18 +16,18 @@ module RuboCop
       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 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

@@ -37,29 +37,28 @@ module RuboCop
       #
       #   foo :bar,
       #       :baz
-      class ArgumentAlignment < Cop
+      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?(:[]=)
+          return if node.arguments.size < 2 || node.send_type? && node.method?(:[]=)
 
           check_alignment(node.arguments, base_column(node, node.arguments))
         end
         alias on_csend on_send
 
-        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 message(_node)
           fixed_indentation? ? FIXED_INDENT_MSG : ALIGN_PARAMS_MSG
         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

@@ -68,6 +68,7 @@ module RuboCop
 
         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
@@ -108,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)
@@ -122,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,
@@ -173,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)
           )
@@ -191,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,9 +144,9 @@ 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
           (casgn nil? _ (send ...))
         PATTERN
@@ -158,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
@@ -253,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)