rubocop 0.89.0 → 0.92.0

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

@@ -26,7 +26,7 @@ module RuboCop
       #     public_constant :BAZ
       #   end
       #
-      class ConstantVisibility < Cop
+      class ConstantVisibility < Base
         MSG = 'Explicitly make `%<constant_name>s` public or private using ' \
               'either `#public_constant` or `#private_constant`.'
 
@@ -34,7 +34,8 @@ module RuboCop
           return unless class_or_module_scope?(node)
           return if visibility_declaration?(node)
 
-          add_offense(node)
+          message = message(node)
+          add_offense(node, message: message)
         end
 
         private

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

@@ -15,28 +15,24 @@ module RuboCop
       # that RuboCop scans, a comment that matches this regex must be found or
       # an offense is reported.
       #
-      class Copyright < Cop
+      class Copyright < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Include a copyright notice matching /%<notice>s/ before ' \
               'any code.'
         AUTOCORRECT_EMPTY_WARNING = 'An AutocorrectNotice must be defined in ' \
                                     'your RuboCop config'
 
-        def investigate(processed_source)
-          return if notice.empty?
-          return if notice_found?(processed_source)
+        def on_new_investigation
+          return if notice.empty? || notice_found?(processed_source)
 
-          range = source_range(processed_source.buffer, 1, 0)
-          add_offense(insert_notice_before(processed_source),
-                      location: range, message: format(MSG, notice: notice))
-        end
-
-        def autocorrect(token)
-          verify_autocorrect_notice!
+          add_offense(offense_range, message: format(MSG, notice: notice)) do |corrector|
+            verify_autocorrect_notice!
 
-          lambda do |corrector|
+            token = insert_notice_before(processed_source)
             range = token.nil? ? range_between(0, 0) : token.pos
+
             corrector.insert_before(range, "#{autocorrect_notice}\n")
           end
         end
@@ -51,6 +47,10 @@ module RuboCop
           cop_config['AutocorrectNotice']
         end
 
+        def offense_range
+          source_range(processed_source.buffer, 1, 0)
+        end
+
         def verify_autocorrect_notice!
           raise Warning, AUTOCORRECT_EMPTY_WARNING if autocorrect_notice.empty?
 

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

@@ -41,7 +41,9 @@ module RuboCop
       #
       #   # good
       #   something.to_time
-      class DateTime < Cop
+      class DateTime < Base
+        extend AutoCorrector
+
         CLASS_MSG = 'Prefer Time over DateTime.'
         COERCION_MSG = 'Do not use #to_datetime.'
 
@@ -63,7 +65,10 @@ module RuboCop
           return if historic_date?(node)
 
           message = to_datetime?(node) ? COERCION_MSG : CLASS_MSG
-          add_offense(node, message: message)
+
+          add_offense(node, message: message) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
         private
@@ -71,6 +76,12 @@ module RuboCop
         def disallow_coercion?
           !cop_config['AllowCoercion']
         end
+
+        def autocorrect(corrector, node)
+          return if to_datetime?(node)
+
+          corrector.replace(node.receiver.loc.name, 'Time')
+        end
       end
     end
   end

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,9 +16,11 @@ 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."
+        RESTRICT_ON_SEND = %i[expand_path dirname].freeze
 
         def_node_matcher :dir_replacement?, <<~PATTERN
           {(send (const {nil? cbase} :File) :expand_path (send (const {nil? cbase} :File) :dirname  #file_keyword?))
@@ -27,13 +29,9 @@ module RuboCop
 
         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)

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,10 +32,11 @@ 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 (`!!`).'
+        RESTRICT_ON_SEND = %i[!].freeze
 
         def_node_matcher :double_negative?, '(send (send _ :!) :!)'
 
@@ -43,7 +44,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,32 +37,30 @@ 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
 
-        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
 
-        private
-
         def simple_method_arg?(method_arg)
           method_arg&.basic_literal?
         end

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

@@ -21,9 +21,10 @@ module RuboCop
       #
       #   # good
       #   a { do_something }
-      class EmptyBlockParameter < Cop
+      class EmptyBlockParameter < Base
         include EmptyParameter
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Omit pipes for the empty block parameters.'
 
@@ -32,15 +33,13 @@ module RuboCop
           check(node) unless send_node.send_type? && send_node.lambda_literal?
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            block = node.parent
-            range = range_between(
-              block.loc.begin.end_pos,
-              node.loc.expression.end_pos
-            )
-            corrector.remove(range)
-          end
+        private
+
+        def autocorrect(corrector, node)
+          block = node.parent
+          range = range_between(block.loc.begin.end_pos, node.loc.expression.end_pos)
+
+          corrector.remove(range)
         end
       end
     end

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