rubocop 0.86.0 → 0.89.1

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

@@ -33,24 +33,22 @@ module RuboCop
       #   def Baz.foo
       #     # does a thing
       #   end
-      class DefWithParentheses < Cop
+      class DefWithParentheses < Base
+        extend AutoCorrector
+
         MSG = "Omit the parentheses in defs when the method doesn't accept " \
               'any arguments.'
 
         def on_def(node)
           return if node.single_line?
-          return unless !node.arguments? && node.arguments.loc.begin
+          return unless !node.arguments? && (node_arguments_loc_begin = node.arguments.loc.begin)
 
-          add_offense(node.arguments, location: :begin)
-        end
-        alias on_defs on_def
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.remove(node.loc.begin)
-            corrector.remove(node.loc.end)
+          add_offense(node_arguments_loc_begin) do |corrector|
+            corrector.remove(node_arguments_loc_begin)
+            corrector.remove(node.arguments.loc.end)
           end
         end
+        alias on_defs on_def
       end
     end
   end

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

@@ -16,24 +16,21 @@ module RuboCop
       #
       #   # good
       #   path = __dir__
-      class Dir < Cop
-        MSG = 'Use `__dir__` to get an absolute path to the current ' \
-              "file's directory."
+      class Dir < Base
+        extend AutoCorrector
+
+        MSG = "Use `__dir__` to get an absolute path to the current file's directory."
 
         def_node_matcher :dir_replacement?, <<~PATTERN
-          {(send (const nil? :File) :expand_path (send (const nil? :File) :dirname  #file_keyword?))
-           (send (const nil? :File) :dirname     (send (const nil? :File) :realpath #file_keyword?))}
+          {(send (const {nil? cbase} :File) :expand_path (send (const {nil? cbase} :File) :dirname  #file_keyword?))
+           (send (const {nil? cbase} :File) :dirname     (send (const {nil? cbase} :File) :realpath #file_keyword?))}
         PATTERN
 
         def on_send(node)
           dir_replacement?(node) do
-            add_offense(node)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node, '__dir__')
+            add_offense(node) do |corrector|
+              corrector.replace(node, '__dir__')
+            end
           end
         end
 

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

@@ -20,21 +20,19 @@ module RuboCop
       #   def fixed_method_name_and_no_rubocop_comments
       #   end
       #
-      class DisableCopsWithinSourceCodeDirective < Cop
+      class DisableCopsWithinSourceCodeDirective < Base
+        extend AutoCorrector
+
         # rubocop:enable Lint/RedundantCopDisableDirective
         MSG = 'Comment to disable/enable RuboCop.'
 
-        def investigate(processed_source)
+        def on_new_investigation
           processed_source.comments.each do |comment|
             next unless rubocop_directive_comment?(comment)
 
-            add_offense(comment)
-          end
-        end
-
-        def autocorrect(comment)
-          lambda do |corrector|
-            corrector.replace(comment, '')
+            add_offense(comment) do |corrector|
+              corrector.replace(comment, '')
+            end
           end
         end
 

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

@@ -55,7 +55,7 @@ module RuboCop
       #       Public = Class.new
       #     end
       #
-      class Documentation < Cop
+      class Documentation < Base
         include DocumentationComment
 
         MSG = 'Missing top-level %<type>s documentation comment.'
@@ -84,9 +84,7 @@ module RuboCop
           return if compact_namespace?(node) &&
                     nodoc_comment?(outer_module(node).first)
 
-          add_offense(node,
-                      location: :keyword,
-                      message: format(MSG, type: type))
+          add_offense(node.loc.keyword, message: format(MSG, type: type))
         end
 
         def namespace?(node)
@@ -112,17 +110,17 @@ module RuboCop
         # proceeds to check its ancestors for :nodoc: all.
         # Note: How end-of-line comments are associated with code changed in
         # parser-2.2.0.4.
-        def nodoc_comment?(node, require_all = false)
+        def nodoc_comment?(node, require_all: false)
           return false unless node&.children&.first
 
           nodoc = nodoc(node)
 
-          return true if same_line?(nodoc, node) && nodoc?(nodoc, require_all)
+          return true if same_line?(nodoc, node) && nodoc?(nodoc, require_all: require_all)
 
-          nodoc_comment?(node.parent, true)
+          nodoc_comment?(node.parent, require_all: true)
         end
 
-        def nodoc?(comment, require_all = false)
+        def nodoc?(comment, require_all: false)
           /^#\s*:nodoc:#{"\s+all\s*$" if require_all}/.match?(comment.text)
         end
 

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

@@ -91,7 +91,7 @@ module RuboCop
       #     end
       #   end
       #
-      class DocumentationMethod < Cop
+      class DocumentationMethod < Base
         include DocumentationComment
         include DefNode
 

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

@@ -24,29 +24,26 @@ module RuboCop
       #   def f # rubocop:disable Style/For, Metrics/AbcSize
       #   end
       #
-      class DoubleCopDisableDirective < Cop
+      class DoubleCopDisableDirective < Base
+        extend AutoCorrector
+
         # rubocop:enable Style/For, Style/DoubleCopDisableDirective
         # rubocop:enable Lint/RedundantCopDisableDirective, Metrics/AbcSize
         MSG = 'More than one disable comment on one line.'
 
-        def investigate(processed_source)
+        def on_new_investigation
           processed_source.comments.each do |comment|
             next unless comment.text.scan(/# rubocop:(?:disable|todo)/).size > 1
 
-            add_offense(comment)
-          end
-        end
-
-        def autocorrect(comment)
-          prefix = if comment.text.start_with?('# rubocop:disable')
-                     '# rubocop:disable'
-                   else
-                     '# rubocop:todo'
-                   end
+            add_offense(comment) do |corrector|
+              prefix = if comment.text.start_with?('# rubocop:disable')
+                         '# rubocop:disable'
+                       else
+                         '# rubocop:todo'
+                       end
 
-          lambda do |corrector|
-            corrector.replace(comment,
-                              comment.text[/#{prefix} \S+/])
+              corrector.replace(comment, comment.text[/#{prefix} \S+/])
+            end
           end
         end
       end

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

@@ -32,7 +32,7 @@ module RuboCop
       # !!something and !something.nil? are not the same thing.
       # As you're unlikely to write code that can accept values of any type
       # this is rarely a problem in practice.
-      class DoubleNegation < Cop
+      class DoubleNegation < Base
         include ConfigurableEnforcedStyle
 
         MSG = 'Avoid the use of double negation (`!!`).'
@@ -43,7 +43,7 @@ module RuboCop
           return unless double_negative?(node) && node.prefix_bang?
           return if style == :allowed_in_returns && allowed_in_returns?(node)
 
-          add_offense(node, location: :selector)
+          add_offense(node.loc.selector)
         end
 
         private

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

@@ -22,7 +22,9 @@ module RuboCop
       #
       #   # good
       #   10.times {}
-      class EachForSimpleLoop < Cop
+      class EachForSimpleLoop < Base
+        extend AutoCorrector
+
         MSG = 'Use `Integer#times` for a simple loop which iterates a fixed ' \
               'number of times.'
 
@@ -33,17 +35,12 @@ module RuboCop
 
           range = send_node.receiver.source_range.join(send_node.loc.selector)
 
-          add_offense(node, location: range)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(range) do |corrector|
             range_type, min, max = offending_each_range(node)
 
             max += 1 if range_type == :irange
 
-            corrector.replace(node.send_node,
-                              "#{max - min}.times")
+            corrector.replace(node.send_node, "#{max - min}.times")
           end
         end
 

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

@@ -16,7 +16,8 @@ module RuboCop
       #
       #   # good
       #   [1, 2].each_with_object({}) { |e, a| a[e] = e }
-      class EachWithObject < Cop
+      class EachWithObject < Base
+        extend AutoCorrector
         include RangeHelp
 
         MSG = 'Use `each_with_object` instead of `%<method>s`.'
@@ -36,33 +37,29 @@ module RuboCop
             return unless first_argument_returned?(args, return_value)
             return if accumulator_param_assigned_to?(body, args)
 
-            add_offense(node, location: method.loc.selector,
-                              message: format(MSG, method: method_name))
+            message = format(MSG, method: method_name)
+            add_offense(method.loc.selector, message: message) do |corrector|
+              autocorrect(corrector, node, return_value)
+            end
           end
         end
 
-        # rubocop:disable Metrics/AbcSize
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.send_node.loc.selector, 'each_with_object')
+        private
 
-            first_arg, second_arg = *node.arguments
+        def autocorrect(corrector, node, return_value)
+          corrector.replace(node.send_node.loc.selector, 'each_with_object')
 
-            corrector.replace(first_arg, second_arg.source)
-            corrector.replace(second_arg, first_arg.source)
+          first_arg, second_arg = *node.arguments
 
-            return_value = return_value(node.body)
+          corrector.replace(first_arg, second_arg.source)
+          corrector.replace(second_arg, first_arg.source)
 
-            if return_value_occupies_whole_line?(return_value)
-              corrector.remove(whole_line_expression(return_value))
-            else
-              corrector.remove(return_value)
-            end
+          if return_value_occupies_whole_line?(return_value)
+            corrector.remove(whole_line_expression(return_value))
+          else
+            corrector.remove(return_value)
           end
         end
-        # rubocop:enable Metrics/AbcSize
-
-        private
 
         def simple_method_arg?(method_arg)
           method_arg&.basic_literal?

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

@@ -35,11 +35,11 @@ module RuboCop
       #   else
       #     puts 'more'
       #   end
-      class EmptyCaseCondition < Cop
+      class EmptyCaseCondition < Base
         include RangeHelp
+        extend AutoCorrector
 
-        MSG = 'Do not use empty `case` condition, instead use an `if` '\
-              'expression.'
+        MSG = 'Do not use empty `case` condition, instead use an `if` expression.'
 
         def on_case(case_node)
           return if case_node.condition
@@ -54,26 +54,26 @@ module RuboCop
             body.each_descendant.any?(&:return_type?)
           end
 
-          add_offense(case_node, location: :keyword)
+          add_offense(case_node.loc.keyword) do |corrector|
+            autocorrect(corrector, case_node)
+          end
         end
 
-        def autocorrect(case_node)
+        private
+
+        def autocorrect(corrector, case_node)
           when_branches = case_node.when_branches
 
-          lambda do |corrector|
-            correct_case_when(corrector, case_node, when_branches)
-            correct_when_conditions(corrector, when_branches)
-          end
+          correct_case_when(corrector, case_node, when_branches)
+          correct_when_conditions(corrector, when_branches)
         end
 
-        private
-
         def correct_case_when(corrector, case_node, when_nodes)
           case_range = case_node.loc.keyword.join(when_nodes.first.loc.keyword)
 
           corrector.replace(case_range, 'if')
 
-          keep_first_when_comment(case_node, when_nodes.first, corrector)
+          keep_first_when_comment(case_range, corrector)
 
           when_nodes[1..-1].each do |when_node|
             corrector.replace(when_node.loc.keyword, 'elsif')
@@ -93,15 +93,14 @@ module RuboCop
           end
         end
 
-        def keep_first_when_comment(case_node, first_when_node, corrector)
-          comment = processed_source.comments_before_line(
-            first_when_node.loc.keyword.line
-          ).map(&:text).join("\n")
-
-          line = range_by_whole_lines(case_node.source_range)
+        def keep_first_when_comment(case_range, corrector)
+          indent = ' ' * case_range.column
+          comments = processed_source.each_comment_in_lines(
+            case_range.first_line...case_range.last_line
+          ).map { |comment| "#{indent}#{comment.text}\n" }.join
 
-          corrector.insert_before(line, "#{comment}\n") if !comment.empty? &&
-                                                           !case_node.parent
+          line_beginning = case_range.adjust(begin_pos: -case_range.column)
+          corrector.insert_before(line_beginning, comments)
         end
       end
     end

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

@@ -89,10 +89,11 @@ module RuboCop
       #   if condition
       #     statement
       #   end
-      class EmptyElse < Cop
+      class EmptyElse < Base
         include OnNormalIfUnless
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Redundant `else`-clause.'
 
@@ -104,16 +105,6 @@ module RuboCop
           check(node)
         end
 
-        def autocorrect(node)
-          return false if autocorrect_forbidden?(node.type.to_s)
-          return false if comment_in_else?(node)
-
-          lambda do |corrector|
-            end_pos = base_node(node).loc.end.begin_pos
-            corrector.remove(range_between(node.loc.else.begin_pos, end_pos))
-          end
-        end
-
         private
 
         def check(node)
@@ -132,24 +123,31 @@ module RuboCop
         def empty_check(node)
           return unless node.else? && !node.else_branch
 
-          add_offense(node, location: :else)
+          add_offense(node.loc.else) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
         def nil_check(node)
           return unless node.else_branch&.nil_type?
 
-          add_offense(node, location: :else)
+          add_offense(node.loc.else) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
-        def comment_in_else?(node)
-          range = else_line_range(node.loc)
-          processed_source.find_comment { |c| range.include?(c.loc.line) }
+        def autocorrect(corrector, node)
+          return false if autocorrect_forbidden?(node.type.to_s)
+          return false if comment_in_else?(node.loc)
+
+          end_pos = base_node(node).loc.end.begin_pos
+          corrector.remove(range_between(node.loc.else.begin_pos, end_pos))
         end
 
-        def else_line_range(loc)
-          return 0..0 if loc.else.nil? || loc.end.nil?
+        def comment_in_else?(loc)
+          return false if loc.else.nil? || loc.end.nil?
 
-          loc.else.first_line..loc.end.first_line
+          processed_source.contains_comment?(loc.else.join(loc.end))
         end
 
         def base_node(node)

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

@@ -16,44 +16,43 @@ module RuboCop
       #   a = []
       #   h = {}
       #   s = ''
-      class EmptyLiteral < Cop
+      class EmptyLiteral < Base
         include FrozenStringLiteral
         include RangeHelp
+        extend AutoCorrector
 
         ARR_MSG = 'Use array literal `[]` instead of `Array.new`.'
         HASH_MSG = 'Use hash literal `{}` instead of `Hash.new`.'
-        STR_MSG = 'Use string literal `%<prefer>s` instead of ' \
-                  '`String.new`.'
+        STR_MSG = 'Use string literal `%<prefer>s` instead of `String.new`.'
 
-        def_node_matcher :array_node, '(send (const nil? :Array) :new)'
-        def_node_matcher :hash_node, '(send (const nil? :Hash) :new)'
-        def_node_matcher :str_node, '(send (const nil? :String) :new)'
+        def_node_matcher :array_node, '(send (const {nil? cbase} :Array) :new)'
+        def_node_matcher :hash_node, '(send (const {nil? cbase} :Hash) :new)'
+        def_node_matcher :str_node, '(send (const {nil? cbase} :String) :new)'
         def_node_matcher :array_with_block,
-                         '(block (send (const nil? :Array) :new) args _)'
+                         '(block (send (const {nil? cbase} :Array) :new) args _)'
         def_node_matcher :hash_with_block,
-                         '(block (send (const nil? :Hash) :new) args _)'
+                         '(block (send (const {nil? cbase} :Hash) :new) args _)'
 
         def on_send(node)
-          add_offense(node, message: ARR_MSG)  if offense_array_node?(node)
-          add_offense(node, message: HASH_MSG) if offense_hash_node?(node)
+          return unless (message = offense_message(node))
 
-          str_node(node) do
-            return if frozen_string_literals_enabled?
-
-            add_offense(node,
-                        message: format(STR_MSG,
-                                        prefer: preferred_string_literal))
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(node, message: message) do |corrector|
             corrector.replace(replacement_range(node), correction(node))
           end
         end
 
         private
 
+        def offense_message(node)
+          if offense_array_node?(node)
+            ARR_MSG
+          elsif offense_hash_node?(node)
+            HASH_MSG
+          elsif str_node(node) && !frozen_string_literals_enabled?
+            format(STR_MSG, prefer: preferred_string_literal)
+          end
+        end
+
         def preferred_string_literal
           enforce_double_quotes? ? '""' : "''"
         end