rubocop 0.85.1 → 0.89.1

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,43 +35,45 @@ 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
-          return if case_node.when_branches.any? do |when_branch|
-            when_branch.each_descendant.any?(&:return_type?)
-          end
 
-          if (else_branch = case_node.else_branch)
-            return if else_branch.return_type? ||
-                      else_branch.each_descendant.any?(&:return_type?)
+          branch_bodies = [
+            *case_node.when_branches.map(&:body),
+            case_node.else_branch
+          ].compact
+
+          return if branch_bodies.any? do |body|
+            body.return_type? ||
+            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')
@@ -91,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

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

@@ -40,8 +40,9 @@ module RuboCop
       #
       #   def self.foo(bar)
       #   end
-      class EmptyMethod < Cop
+      class EmptyMethod < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG_COMPACT = 'Put empty method definitions on a single line.'
         MSG_EXPANDED = 'Put the `end` of empty method definitions on the ' \
@@ -51,19 +52,15 @@ module RuboCop
           return if node.body || comment_lines?(node)
           return if correct_style?(node)
 
-          add_offense(node)
-        end
-        alias on_defs on_def
-
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(node) do |corrector|
             corrector.replace(node, corrected(node))
           end
         end
+        alias on_defs on_def
 
         private
 
-        def message(_node)
+        def message(_range)
           compact_style? ? MSG_COMPACT : MSG_EXPANDED
         end
 
@@ -73,13 +70,13 @@ module RuboCop
         end
 
         def corrected(node)
-          if node.arguments?
-            arguments   = node.arguments.source
-            extra_space = ' ' unless parentheses?(node.arguments)
-          end
           scope = node.receiver ? "#{node.receiver.source}." : ''
+          arguments = if node.arguments?
+                        args = node.arguments.map(&:source).join(', ')
 
-          signature = [scope, node.method_name, extra_space, arguments].join
+                        parentheses?(node.arguments) ? "(#{args})" : " #{args}"
+                      end
+          signature = [scope, node.method_name, arguments].join
 
           ["def #{signature}", 'end'].join(joint(node))
         end

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

@@ -9,27 +9,23 @@ module RuboCop
       #   # encoding: UTF-8
       #   # coding: UTF-8
       #   # -*- coding: UTF-8 -*-
-      class Encoding < Cop
+      class Encoding < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG_UNNECESSARY = 'Unnecessary utf-8 encoding comment.'
         ENCODING_PATTERN = /#.*coding\s?[:=]\s?(?:UTF|utf)-8/.freeze
         SHEBANG = '#!'
 
-        def investigate(processed_source)
+        def on_new_investigation
           return if processed_source.buffer.source.empty?
 
           line_number = encoding_line_number(processed_source)
           return unless (@message = offense(processed_source, line_number))
 
           range = processed_source.buffer.line_range(line_number + 1)
-          add_offense(range, location: range, message: @message)
-        end
-
-        def autocorrect(range)
-          lambda do |corrector|
-            corrector.remove(range_with_surrounding_space(range: range,
-                                                          side: :right))
+          add_offense(range, message: @message) do |corrector|
+            corrector.remove(range_with_surrounding_space(range: range, side: :right))
           end
         end
 
@@ -42,7 +38,7 @@ module RuboCop
         end
 
         def encoding_omitable?(line)
-          line =~ ENCODING_PATTERN
+          ENCODING_PATTERN.match?(line)
         end
 
         def encoding_line_number(processed_source)

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

@@ -12,16 +12,14 @@ module RuboCop
       #   # good
       #   at_exit { puts 'Goodbye!' }
       #
-      class EndBlock < Cop
+      class EndBlock < Base
+        extend AutoCorrector
+
         MSG = 'Avoid the use of `END` blocks. ' \
               'Use `Kernel#at_exit` instead.'
 
         def on_postexe(node)
-          add_offense(node, location: :keyword)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(node.loc.keyword) do |corrector|
             corrector.replace(node.loc.keyword, 'at_exit')
           end
         end

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

@@ -31,12 +31,14 @@ module RuboCop
       #     def do_something
       #     end
       #   RUBY
-      class EvalWithLocation < Cop
+      class EvalWithLocation < Base
         MSG = 'Pass `__FILE__` and `__LINE__` to `eval` method, ' \
               'as they are used by backtraces.'
         MSG_INCORRECT_LINE = 'Use `%<expected>s` instead of `%<actual>s`, ' \
                              'as they are used by backtraces.'
 
+        EVAL_METHODS = %i[eval class_eval module_eval instance_eval].to_set.freeze
+
         def_node_matcher :eval_without_location?, <<~PATTERN
           {
             (send nil? :eval ${str dstr})
@@ -61,6 +63,8 @@ module RuboCop
         PATTERN
 
         def on_send(node)
+          return unless EVAL_METHODS.include?(node.method_name)
+
           eval_without_location?(node) do |code|
             if with_lineno?(node)
               on_with_lineno(node, code)
@@ -122,23 +126,21 @@ module RuboCop
           end
         end
 
-        def add_offense_for_same_line(node, line_node)
+        def add_offense_for_same_line(_node, line_node)
           return if special_line_keyword?(line_node)
 
           add_offense(
-            node,
-            location: line_node.loc.expression,
+            line_node.loc.expression,
             message: message_incorrect_line(line_node, nil, 0)
           )
         end
 
-        def add_offense_for_different_line(node, line_node, line_diff)
+        def add_offense_for_different_line(_node, line_node, line_diff)
           sign = line_diff.positive? ? :+ : :-
           return if line_with_offset?(line_node, sign, line_diff.abs)
 
           add_offense(
-            node,
-            location: line_node.loc.expression,
+            line_node.loc.expression,
             message: message_incorrect_line(line_node, sign, line_diff.abs)
           )
         end

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

@@ -15,7 +15,9 @@ module RuboCop
       #   # good
       #   if x.even?
       #   end
-      class EvenOdd < Cop
+      class EvenOdd < Base
+        extend AutoCorrector
+
         MSG = 'Replace with `Integer#%<method>s?`.'
 
         def_node_matcher :even_odd_candidate?, <<~PATTERN
@@ -27,18 +29,12 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          even_odd_candidate?(node) do |_base_number, method, arg|
-            replacement_method = replacement_method(arg, method)
-            add_offense(node, message: format(MSG, method: replacement_method))
-          end
-        end
-
-        def autocorrect(node)
           even_odd_candidate?(node) do |base_number, method, arg|
             replacement_method = replacement_method(arg, method)
-
-            correction = "#{base_number.source}.#{replacement_method}?"
-            ->(corrector) { corrector.replace(node, correction) }
+            add_offense(node, message: format(MSG, method: replacement_method)) do |corrector|
+              correction = "#{base_number.source}.#{replacement_method}?"
+              corrector.replace(node, correction)
+            end
           end
         end