rubocop 0.87.1 → 0.89.1

data/lib/rubocop/cop/style/class_and_module_children.rb

@@ -21,9 +21,10 @@ module RuboCop
       #   end
       #
       # The compact style is only forced for classes/modules with one child.
-      class ClassAndModuleChildren < Cop
+      class ClassAndModuleChildren < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         NESTED_MSG = 'Use nested module/class definitions instead of ' \
                      'compact style.'
@@ -40,14 +41,6 @@ module RuboCop
           check_style(node, node.body)
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            return if node.class_type? && node.parent_class && style != :nested
-
-            nest_or_compact(corrector, node)
-          end
-        end
-
         private
 
         def nest_or_compact(corrector, node)
@@ -129,13 +122,23 @@ module RuboCop
         def check_nested_style(node)
           return unless compact_node_name?(node)
 
-          add_offense(node, location: :name, message: NESTED_MSG)
+          add_offense(node.loc.name, message: NESTED_MSG) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
         def check_compact_style(node, body)
           return unless one_child?(body) && !compact_node_name?(node)
 
-          add_offense(node, location: :name, message: COMPACT_MSG)
+          add_offense(node.loc.name, message: COMPACT_MSG) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        def autocorrect(corrector, node)
+          return if node.class_type? && node.parent_class && style != :nested
+
+          nest_or_compact(corrector, node)
         end
 
         def one_child?(body)

data/lib/rubocop/cop/style/class_check.rb

@@ -23,8 +23,9 @@ module RuboCop
       #   var.kind_of?(Time)
       #   var.kind_of?(String)
       #
-      class ClassCheck < Cop
+      class ClassCheck < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG = 'Prefer `Object#%<prefer>s` over `Object#%<current>s`.'
 
@@ -34,15 +35,12 @@ module RuboCop
           class_check?(node) do |method_name|
             return if style == method_name
 
-            add_offense(node, location: :selector)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            replacement = node.method?(:is_a?) ? 'kind_of?' : 'is_a?'
+            message = message(node)
+            add_offense(node.loc.selector, message: message) do |corrector|
+              replacement = node.method?(:is_a?) ? 'kind_of?' : 'is_a?'
 
-            corrector.replace(node.loc.selector, replacement)
+              corrector.replace(node.loc.selector, replacement)
+            end
           end
         end
 

data/lib/rubocop/cop/style/class_methods.rb

@@ -20,7 +20,9 @@ module RuboCop
       #       # ...
       #     end
       #   end
-      class ClassMethods < Cop
+      class ClassMethods < Base
+        extend AutoCorrector
+
         MSG = 'Use `self.%<method>s` instead of `%<class>s.%<method>s`.'
 
         def on_class(node)
@@ -36,23 +38,17 @@ module RuboCop
         end
         alias on_module on_class
 
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.name, 'self') }
-        end
-
         private
 
         def check_defs(name, node)
           # check if the class/module name matches the definee for the defs node
           return unless name == node.receiver
 
-          add_offense(node.receiver, location: :name)
-        end
-
-        def message(node)
-          _, class_name = *node
+          message = format(MSG, method: node.method_name, class: name.source)
 
-          format(MSG, method: node.parent.method_name, class: class_name)
+          add_offense(node.receiver.loc.name, message: message) do |corrector|
+            corrector.replace(node.receiver, 'self')
+          end
         end
       end
     end

data/lib/rubocop/cop/style/class_vars.rb

@@ -45,23 +45,19 @@ module RuboCop
       #     end
       #   end
       #
-      class ClassVars < Cop
-        MSG = 'Replace class var %<class_var>s with a class ' \
-              'instance var.'
+      class ClassVars < Base
+        MSG = 'Replace class var %<class_var>s with a class instance var.'
 
         def on_cvasgn(node)
-          add_offense(node, location: :name)
+          add_offense(node.loc.name, message: format(MSG, class_var: node.children.first))
         end
 
         def on_send(node)
           return unless node.method?(:class_variable_set)
 
-          add_offense(node.first_argument)
-        end
-
-        def message(node)
-          class_var, = *node
-          format(MSG, class_var: class_var)
+          add_offense(
+            node.first_argument, message: format(MSG, class_var: node.first_argument.source)
+          )
         end
       end
     end

data/lib/rubocop/cop/style/collection_methods.rb

@@ -37,8 +37,9 @@ module RuboCop
       #   items.select
       #   items.include?
       #
-      class CollectionMethods < Cop
+      class CollectionMethods < Base
         include MethodPreference
+        extend AutoCorrector
 
         MSG = 'Prefer `%<prefer>s` over `%<current>s`.'
 
@@ -47,31 +48,24 @@ module RuboCop
         end
 
         def on_send(node)
-          return unless node.arguments.one? &&
-                        node.first_argument.block_pass_type?
+          return unless node.arguments.one? && node.first_argument.block_pass_type?
 
           check_method_node(node)
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.loc.selector,
-                              preferred_method(node.loc.selector.source))
-          end
-        end
-
         private
 
-        def message(node)
-          format(MSG,
-                 prefer: preferred_method(node.method_name),
-                 current: node.method_name)
-        end
-
         def check_method_node(node)
           return unless preferred_methods[node.method_name]
 
-          add_offense(node, location: :selector)
+          message = message(node)
+          add_offense(node.loc.selector, message: message) do |corrector|
+            corrector.replace(node.loc.selector, preferred_method(node.loc.selector.source))
+          end
+        end
+
+        def message(node)
+          format(MSG, prefer: preferred_method(node.method_name), current: node.method_name)
         end
       end
     end

data/lib/rubocop/cop/style/colon_method_call.rb

@@ -17,7 +17,9 @@ module RuboCop
       #   FileUtils.rmdir(dir)
       #   Marshal.dump(obj)
       #
-      class ColonMethodCall < Cop
+      class ColonMethodCall < Base
+        extend AutoCorrector
+
         MSG = 'Do not use `::` for method calls.'
 
         def_node_matcher :java_type_node?, <<~PATTERN
@@ -30,17 +32,14 @@ module RuboCop
         end
 
         def on_send(node)
-          # ignore Java interop code like Java::int
-          return if java_type_node?(node)
-
           return unless node.receiver && node.double_colon?
           return if node.camel_case_method?
+          # ignore Java interop code like Java::int
+          return if java_type_node?(node)
 
-          add_offense(node, location: :dot)
-        end
-
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.dot, '.') }
+          add_offense(node.loc.dot) do |corrector|
+            corrector.replace(node.loc.dot, '.')
+          end
         end
       end
     end

data/lib/rubocop/cop/style/colon_method_definition.rb

@@ -19,17 +19,17 @@ module RuboCop
       #     end
       #   end
       #
-      class ColonMethodDefinition < Cop
+      class ColonMethodDefinition < Base
+        extend AutoCorrector
+
         MSG = 'Do not use `::` for defining class methods.'
 
         def on_defs(node)
           return unless node.loc.operator.source == '::'
 
-          add_offense(node, location: :operator)
-        end
-
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.operator, '.') }
+          add_offense(node.loc.operator) do |corrector|
+            corrector.replace(node.loc.operator, '.')
+          end
         end
       end
     end

data/lib/rubocop/cop/style/command_literal.rb

@@ -75,8 +75,9 @@ module RuboCop
       # @example AllowInnerBackticks: true
       #   # good
       #   `echo \`ls\``
-      class CommandLiteral < Cop
+      class CommandLiteral < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG_USE_BACKTICKS = 'Use backticks around command string.'
         MSG_USE_PERCENT_X = 'Use `%x` around command string.'
@@ -85,43 +86,41 @@ module RuboCop
           return if node.heredoc?
 
           if backtick_literal?(node)
-            check_backtick_literal(node)
+            check_backtick_literal(node, MSG_USE_PERCENT_X)
           else
-            check_percent_x_literal(node)
-          end
-        end
-
-        def autocorrect(node)
-          return if contains_backtick?(node)
-
-          replacement = if backtick_literal?(node)
-                          ['%x', ''].zip(preferred_delimiter).map(&:join)
-                        else
-                          %w[` `]
-                        end
-
-          lambda do |corrector|
-            corrector.replace(node.loc.begin, replacement.first)
-            corrector.replace(node.loc.end, replacement.last)
+            check_percent_x_literal(node, MSG_USE_BACKTICKS)
           end
         end
 
         private
 
-        def check_backtick_literal(node)
+        def check_backtick_literal(node, message)
           return if allowed_backtick_literal?(node)
 
-          add_offense(node)
+          add_offense(node, message: message) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
-        def check_percent_x_literal(node)
+        def check_percent_x_literal(node, message)
           return if allowed_percent_x_literal?(node)
 
-          add_offense(node)
+          add_offense(node, message: message) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
-        def message(node)
-          backtick_literal?(node) ? MSG_USE_PERCENT_X : MSG_USE_BACKTICKS
+        def autocorrect(corrector, node)
+          return if contains_backtick?(node)
+
+          replacement = if backtick_literal?(node)
+                          ['%x', ''].zip(preferred_delimiter).map(&:join)
+                        else
+                          %w[` `]
+                        end
+
+          corrector.replace(node.loc.begin, replacement.first)
+          corrector.replace(node.loc.end, replacement.last)
         end
 
         def allowed_backtick_literal?(node)

data/lib/rubocop/cop/style/comment_annotation.rb

@@ -30,9 +30,10 @@ module RuboCop
       #
       #   # good
       #   # OPTIMIZE: does not work
-      class CommentAnnotation < Cop
+      class CommentAnnotation < Base
         include AnnotationComment
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Annotation keywords like `%<keyword>s` should be all ' \
               'upper case, followed by a colon, and a space, ' \
@@ -40,7 +41,7 @@ module RuboCop
         MISSING_NOTE = 'Annotation comment, with keyword `%<keyword>s`, ' \
                        'is missing a note.'
 
-        def investigate(processed_source)
+        def on_new_investigation
           processed_source.comments.each_with_index do |comment, index|
             next unless first_comment_line?(processed_source.comments, index) ||
                         inline_comment?(comment)
@@ -49,26 +50,25 @@ module RuboCop
             next unless annotation?(comment) &&
                         !correct_annotation?(first_word, colon, space, note)
 
-            add_offense(
-              comment,
-              location: annotation_range(comment, margin,
-                                         first_word, colon, space),
-              message: format(note ? MSG : MISSING_NOTE, keyword: first_word)
-            )
+            range = annotation_range(comment, margin, first_word, colon, space)
+
+            register_offense(range, note, first_word)
           end
         end
 
-        def autocorrect(comment)
-          margin, first_word, colon, space, note = split_comment(comment)
-          return if note.nil?
+        private
 
-          range = annotation_range(comment, margin, first_word, colon, space)
+        def register_offense(range, note, first_word)
+          add_offense(
+            range,
+            message: format(note ? MSG : MISSING_NOTE, keyword: first_word)
+          ) do |corrector|
+            next if note.nil?
 
-          ->(corrector) { corrector.replace(range, "#{first_word.upcase}: ") }
+            corrector.replace(range, "#{first_word.upcase}: ")
+          end
         end
 
-        private
-
         def first_comment_line?(comments, index)
           index.zero? ||
             comments[index - 1].loc.line < comments[index].loc.line - 1

data/lib/rubocop/cop/style/commented_keyword.rb

@@ -38,7 +38,7 @@ module RuboCop
               '`%<keyword>s` keyword.'
 
         def investigate(processed_source)
-          processed_source.each_comment do |comment|
+          processed_source.comments.each do |comment|
             add_offense(comment) if offensive?(comment)
           end
         end
@@ -46,17 +46,20 @@ module RuboCop
         private
 
         KEYWORDS = %w[begin class def end module].freeze
+        KEYWORD_REGEXES = KEYWORDS.map { |w| /^\s*#{w}\s/ }.freeze
+
         ALLOWED_COMMENTS = %w[
           :nodoc:
           :yields:
           rubocop:disable
           rubocop:todo
         ].freeze
+        ALLOWED_COMMENT_REGEXES = ALLOWED_COMMENTS.map { |c| /#\s*#{c}/ }.freeze
 
         def offensive?(comment)
           line = line(comment)
-          KEYWORDS.any? { |word| /^\s*#{word}\s/.match?(line) } &&
-            ALLOWED_COMMENTS.none? { |c| /#\s*#{c}/.match?(line) }
+          KEYWORD_REGEXES.any? { |r| r.match?(line) } &&
+            ALLOWED_COMMENT_REGEXES.none? { |r| r.match?(line) }
         end
 
         def message(comment)

data/lib/rubocop/cop/style/conditional_assignment.rb

@@ -30,7 +30,7 @@ module RuboCop
         end
 
         def tail(branch)
-          branch.begin_type? ? [*branch].last : branch
+          branch.begin_type? ? Array(branch).last : branch
         end
 
         # rubocop:disable Metrics/AbcSize
@@ -43,7 +43,7 @@ module RuboCop
           when :and_asgn, :or_asgn
             "#{node.children[0].source} #{node.loc.operator.source} "
           when :casgn
-            "#{node.children[1]} = "
+            lhs_for_casgn(node)
           when *ConditionalAssignment::VARIABLE_ASSIGNMENT_TYPES
             "#{node.children[0]} = "
           else
@@ -67,7 +67,7 @@ module RuboCop
 
         private
 
-        def expand_elsif(node, elsif_branches = []) # rubocop:todo Metrics/CyclomaticComplexity
+        def expand_elsif(node, elsif_branches = [])
           return [] if node.nil? || !node.if_type? || !node.elsif?
 
           elsif_branches << node.if_branch
@@ -93,6 +93,15 @@ module RuboCop
           end
         end
 
+        def lhs_for_casgn(node)
+          namespace = node.children[0]
+          if namespace.nil? || namespace.cbase_type?
+            "#{namespace&.source}#{node.children[1]} = "
+          else
+            "#{namespace.source}::#{node.children[1]} = "
+          end
+        end
+
         def setter_method?(method_name)
           method_name.to_s.end_with?(EQUAL) &&
             !%i[!= == === >= <=].include?(method_name)
@@ -224,7 +233,7 @@ module RuboCop
         def_node_matcher :assignment_type?, <<~PATTERN
           {
             #{ASSIGNMENT_TYPES.join(' ')}
-            (send _recv {:[]= :<< :=~ :!~ :<=> #end_with_eq?} ...)
+            (send _recv {:[]= :<< :=~ :!~ :<=> #end_with_eq? :< :>} ...)
           }
         PATTERN