rubocop 0.86.0 → 0.89.1

data/lib/rubocop/cop/generator.rb

@@ -54,7 +54,7 @@ module RuboCop
               #   # good
               #   good_foo_method(args)
               #
-              class %<cop_name>s < Cop
+              class %<cop_name>s < Base
                 # TODO: Implement the cop in here.
                 #
                 # In many cases, you can use a node matcher for matching node pattern.

data/lib/rubocop/cop/generator/configuration_injector.rb

@@ -25,9 +25,9 @@ module RuboCop
           target_line = find_target_line
           if target_line
             configuration_entries.insert(target_line,
-                                         new_configuration_entry + "\n")
+                                         "#{new_configuration_entry}\n")
           else
-            configuration_entries.push("\n" + new_configuration_entry)
+            configuration_entries.push("\n#{new_configuration_entry}")
           end
 
           File.write(configuration_file_path, configuration_entries.join)

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

@@ -12,8 +12,9 @@ module RuboCop
       #   # good
       #   node.method?(:do_something)
       #
-      class MethodNameEqual < Cop
+      class MethodNameEqual < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use `method?(%<method_name>s)` instead of ' \
               '`method_name == %<method_name>s`.'
@@ -31,17 +32,8 @@ module RuboCop
 
             range = range(method_name_node, node)
 
-            add_offense(node, location: range, message: message)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            method_name?(node) do |method_name_node, method_name_arg|
-              corrector.replace(
-                range(method_name_node, node),
-                "method?(#{method_name_arg.first.source})"
-              )
+            add_offense(range, message: message) do |corrector|
+              corrector.replace(range, "method?(#{method_name_arg.first.source})")
             end
           end
         end

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

@@ -15,7 +15,7 @@ module RuboCop
       #
       #   # good
       #   method_name = send_node.method_name
-      class NodeDestructuring < Cop
+      class NodeDestructuring < Base
         MSG = 'Use the methods provided with the node extensions instead ' \
               'of manually destructuring nodes.'
 

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

@@ -13,7 +13,9 @@ module RuboCop
       #   # good
       #   node.send_type?
       #
-      class NodeTypePredicate < Cop
+      class NodeTypePredicate < Base
+        extend AutoCorrector
+
         MSG = 'Use `#%<type>s_type?` to check node type.'
 
         def_node_matcher :node_type_check, <<~PATTERN
@@ -21,21 +23,16 @@ module RuboCop
         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, type: 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

@@ -13,24 +13,24 @@ module RuboCop
       #
       #   # good
       #   add_offense(node, location: :selector)
-      class OffenseLocationKeyword < Cop
+      class OffenseLocationKeyword < Base
+        extend AutoCorrector
+
         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: keyword))
+              add_offense(location, message: format(MSG, keyword: keyword)) do |corrector|
+                (*, keyword) = offending_location_argument(location.parent)
+
+                corrector.replace(location, ":#{keyword}")
+              end
             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

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

@@ -16,8 +16,9 @@ module RuboCop
       #   add_offense(node)
       #   add_offense(node, location: :selector)
       #
-      class RedundantLocationArgument < Cop
+      class RedundantLocationArgument < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Redundant location argument to `#add_offense`.'
 
@@ -28,15 +29,17 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          redundant_location_argument(node) { |argument| add_offense(argument) }
-        end
-
-        def autocorrect(node)
-          range = offending_range(node)
+          redundant_location_argument(node) do |argument|
+            add_offense(argument) do |corrector|
+              range = offending_range(argument)
 
-          ->(corrector) { corrector.remove(range) }
+              corrector.remove(range)
+            end
+          end
         end
 
+        private
+
         def offending_range(node)
           with_space = range_with_surrounding_space(range: node.loc.expression)
 

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

@@ -19,8 +19,9 @@ module RuboCop
       #   add_offense(node, message: CUSTOM_MSG)
       #   add_offense(node, message: message(other_node))
       #
-      class RedundantMessageArgument < Cop
+      class RedundantMessageArgument < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Redundant message argument to `#add_offense`.'
 
@@ -39,17 +40,15 @@ module RuboCop
         def on_send(node)
           node_type_check(node) do |node_arg, kwargs|
             find_offending_argument(node_arg, kwargs) do |pair|
-              add_offense(pair)
+              add_offense(pair) do |corrector|
+                range = offending_range(pair)
+
+                corrector.remove(range)
+              end
             end
           end
         end
 
-        def autocorrect(node)
-          range = offending_range(node)
-
-          ->(corrector) { corrector.remove(range) }
-        end
-
         private
 
         def offending_range(node)

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

@@ -13,7 +13,7 @@ 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`.'
 
         def_node_search :described_class_msg, <<~PATTERN
@@ -24,7 +24,7 @@ module RuboCop
           (send (send nil? :expect #contains_described_class_msg?) :to ...)
         PATTERN
 
-        def investigate(_processed_source)
+        def on_new_investigation
           assertions_using_described_class_msg.each do |node|
             add_offense(node)
           end

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

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

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

@@ -67,10 +67,11 @@ module RuboCop
       #   else
       #     y / 3
       #   end
-      class CaseIndentation < Cop
+      class CaseIndentation < Base
         include Alignment
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Indent `when` %<depth>s `%<base>s`.'
 
@@ -82,16 +83,6 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
-          whitespace = whitespace_range(node)
-
-          return false unless whitespace.source.strip.empty?
-
-          lambda do |corrector|
-            corrector.replace(whitespace, replacement(node))
-          end
-        end
-
         private
 
         def check_when(when_node)
@@ -114,22 +105,30 @@ module RuboCop
         end
 
         def incorrect_style(when_node)
+          add_offense(when_node.loc.keyword) do |corrector|
+            detect_incorrect_style(when_node)
+
+            whitespace = whitespace_range(when_node)
+
+            corrector.replace(whitespace, replacement(when_node)) if whitespace.source.strip.empty?
+          end
+        end
+
+        def detect_incorrect_style(when_node)
           when_column = when_node.loc.keyword.column
           base_column = base_column(when_node.parent, alternative_style)
 
-          add_offense(when_node, location: :keyword, message: message(style)) do
-            if when_column == base_column
-              opposite_style_detected
-            else
-              unrecognized_style_detected
-            end
+          if when_column == base_column
+            opposite_style_detected
+          else
+            unrecognized_style_detected
           end
         end
 
-        def message(base)
+        def find_message(*)
           depth = indent_one_step? ? 'one step more than' : 'as deep as'
 
-          format(MSG, depth: depth, base: base)
+          format(MSG, depth: depth, base: style)
         end
 
         def base_column(case_node, base)

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

@@ -134,6 +134,8 @@ module RuboCop
       #
       # @see https://rubystyle.guide#consistent-classes
       class ClassStructure < Cop
+        include VisibilityHelp
+
         HUMANIZED_NODE_TYPE = {
           casgn: :constants,
           defs: :class_methods,
@@ -141,14 +143,9 @@ module RuboCop
           sclass: :class_singleton
         }.freeze
 
-        VISIBILITY_SCOPES = %i[private protected public].freeze
         MSG = '`%<category>s` is supposed to appear before ' \
               '`%<previous>s`.'
 
-        def_node_matcher :visibility_block?, <<~PATTERN
-          (send nil? { :private :protected :public })
-        PATTERN
-
         # Validates code style on class declaration.
         # Add offense when find a node out of expected order.
         def on_class(class_node)
@@ -243,38 +240,6 @@ module RuboCop
             expected_order.index(classification).nil?
         end
 
-        def node_visibility(node)
-          scope = find_visibility_start(node)
-          scope&.method_name || :public
-        end
-
-        def find_visibility_start(node)
-          left_siblings_of(node)
-            .reverse
-            .find(&method(:visibility_block?))
-        end
-
-        # Navigate to find the last protected method
-        def find_visibility_end(node)
-          possible_visibilities = VISIBILITY_SCOPES - [node_visibility(node)]
-          right = right_siblings_of(node)
-          right.find do |child_node|
-            possible_visibilities.include?(node_visibility(child_node))
-          end || right.last
-        end
-
-        def siblings_of(node)
-          node.parent.children
-        end
-
-        def right_siblings_of(node)
-          siblings_of(node)[node.sibling_index..-1]
-        end
-
-        def left_siblings_of(node)
-          siblings_of(node)[0, node.sibling_index]
-        end
-
         def humanize_node(node)
           if node.def_type?
             return :initializer if node.method?(:initialize)
@@ -304,15 +269,11 @@ module RuboCop
         end
 
         def begin_pos_with_comment(node)
-          annotation_line = node.first_line - 1
           first_comment = nil
+          (node.first_line - 1).downto(1) do |annotation_line|
+            break unless (comment = processed_source.comment_at_line(annotation_line))
 
-          processed_source.comments_before_line(annotation_line)
-                          .reverse_each do |comment|
-            if comment.location.line == annotation_line
-              first_comment = comment
-              annotation_line -= 1
-            end
+            first_comment = comment
           end
 
           start_line_position(first_comment || node)

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

@@ -39,7 +39,7 @@ module RuboCop
           'instead of %<correct_comment_indentation>d).'
 
         def investigate(processed_source)
-          processed_source.each_comment { |comment| check(comment) }
+          processed_source.comments.each { |comment| check(comment) }
         end
 
         def autocorrect(comment)

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'set'
-
 module RuboCop
   module Cop
     module Layout

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

@@ -109,6 +109,7 @@ module RuboCop
 
         def allowed_only_before_style?(node)
           if node.special_modifier?
+            return true if processed_source[node.last_line] == 'end'
             return false if next_line_empty?(node.last_line)
           end
 

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

@@ -62,6 +62,7 @@ module RuboCop
       #
       class EmptyLinesAroundAttributeAccessor < Cop
         include RangeHelp
+        include AllowedMethods
 
         MSG = 'Add an empty line after attribute accessor.'
 
@@ -114,14 +115,6 @@ module RuboCop
         def allow_alias_syntax?
           cop_config.fetch('AllowAliasSyntax', true)
         end
-
-        def allowed_method?(name)
-          allowed_methods.include?(name.to_s)
-        end
-
-        def allowed_methods
-          cop_config.fetch('AllowedMethods', [])
-        end
       end
     end
   end

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

@@ -150,9 +150,10 @@ module RuboCop
         end
 
         def alignment_node(node)
-          if style == :keyword
+          case style
+          when :keyword
             node
-          elsif style == :variable
+          when :variable
             alignment_node_for_variable_style(node)
           else
             start_line_range(node)