rubocop 0.87.1 → 0.91.0

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_lambda_parameter.rb

@@ -16,9 +16,10 @@ module RuboCop
       #
       #   # good
       #   -> (arg) { do_something(arg) }
-      class EmptyLambdaParameter < Cop
+      class EmptyLambdaParameter < Base
         include EmptyParameter
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Omit parentheses for the empty lambda parameters.'
 
@@ -29,15 +30,13 @@ module RuboCop
           check(node) if node.send_node.lambda_literal?
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            send_node = node.parent.send_node
-            range = range_between(
-              send_node.loc.expression.end_pos,
-              node.loc.expression.end_pos
-            )
-            corrector.remove(range)
-          end
+        private
+
+        def autocorrect(corrector, node)
+          send_node = node.parent.send_node
+          range = range_between(send_node.loc.expression.end_pos, node.loc.expression.end_pos)
+
+          corrector.remove(range)
         end
       end
     end

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

@@ -16,14 +16,16 @@ 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`.'
+
+        RESTRICT_ON_SEND = %i[new].freeze
 
         def_node_matcher :array_node, '(send (const {nil? cbase} :Array) :new)'
         def_node_matcher :hash_node, '(send (const {nil? cbase} :Hash) :new)'
@@ -34,26 +36,25 @@ module RuboCop
                          '(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)
-
-          str_node(node) do
-            return if frozen_string_literals_enabled?
-
-            add_offense(node,
-                        message: format(STR_MSG,
-                                        prefer: preferred_string_literal))
-          end
-        end
+          return unless (message = offense_message(node))
 
-        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
@@ -70,7 +71,7 @@ module RuboCop
           parent = node.parent
           return false unless parent && %i[send super zsuper].include?(parent.type)
 
-          node.object_id == parent.arguments.first.object_id &&
+          node.equal?(parent.arguments.first) &&
             !parentheses?(node.parent)
         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
 

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.'
 
+        RESTRICT_ON_SEND = %i[eval class_eval module_eval instance_eval].freeze
+
         def_node_matcher :eval_without_location?, <<~PATTERN
           {
             (send nil? :eval ${str dstr})
@@ -122,23 +124,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,8 +15,11 @@ module RuboCop
       #   # good
       #   if x.even?
       #   end
-      class EvenOdd < Cop
+      class EvenOdd < Base
+        extend AutoCorrector
+
         MSG = 'Replace with `Integer#%<method>s?`.'
+        RESTRICT_ON_SEND = %i[== !=].freeze
 
         def_node_matcher :even_odd_candidate?, <<~PATTERN
           (send
@@ -27,18 +30,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
 

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

@@ -40,8 +40,9 @@ module RuboCop
       #   # good
       #   Pathname.new(__dir__).expand_path
       #
-      class ExpandPathArguments < Cop
+      class ExpandPathArguments < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use `expand_path(%<new_path>s%<new_default_dir>s)` instead of ' \
               '`expand_path(%<current_path>s, __FILE__)`.'
@@ -51,6 +52,8 @@ module RuboCop
                            'instead of ' \
                            '`Pathname.new(__FILE__).parent.expand_path`.'
 
+        RESTRICT_ON_SEND = %i[expand_path].freeze
+
         def_node_matcher :file_expand_path, <<~PATTERN
           (send
             (const {nil? cbase} :File) :expand_path
@@ -74,44 +77,40 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          if (captured_values = file_expand_path(node))
-            current_path, default_dir = captured_values
-
+          if (current_path, default_dir = file_expand_path(node))
             inspect_offense_for_expand_path(node, current_path, default_dir)
           elsif (default_dir = pathname_parent_expand_path(node))
             return unless unrecommended_argument?(default_dir)
 
-            add_offense(node, message: PATHNAME_MSG)
+            add_offense(node, message: PATHNAME_MSG) do |corrector|
+              autocorrect(corrector, node)
+            end
           elsif (default_dir = pathname_new_parent_expand_path(node))
             return unless unrecommended_argument?(default_dir)
 
-            add_offense(node, message: PATHNAME_NEW_MSG)
+            add_offense(node, message: PATHNAME_NEW_MSG) do |corrector|
+              autocorrect(corrector, node)
+            end
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            if (captured_values = file_expand_path(node))
-              current_path, default_dir = captured_values
+        private
 
-              autocorrect_expand_path(corrector, current_path, default_dir)
-            elsif (default_dir = pathname_parent_expand_path(node)) ||
-                  (default_dir = pathname_new_parent_expand_path(node))
-              corrector.replace(default_dir, '__dir__')
-              remove_parent_method(corrector, default_dir)
-            end
+        def autocorrect(corrector, node)
+          if (current_path, default_dir = file_expand_path(node))
+            autocorrect_expand_path(corrector, current_path, default_dir)
+          elsif (dir = pathname_parent_expand_path(node) || pathname_new_parent_expand_path(node))
+            corrector.replace(dir, '__dir__')
+            remove_parent_method(corrector, dir)
           end
         end
 
-        private
-
         def unrecommended_argument?(default_dir)
           default_dir.source == '__FILE__'
         end
 
         def inspect_offense_for_expand_path(node, current_path, default_dir)
-          return unless unrecommended_argument?(default_dir) &&
-                        current_path.str_type?
+          return unless unrecommended_argument?(default_dir) && current_path.str_type?
 
           current_path = strip_surrounded_quotes!(current_path.source)
 
@@ -127,7 +126,9 @@ module RuboCop
             current_path: "'#{current_path}'"
           )
 
-          add_offense(node, location: :selector, message: message)
+          add_offense(node.loc.selector, message: message) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
         def autocorrect_expand_path(corrector, current_path, default_dir)