rubocop 0.88.0 → 0.89.1

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.'
 
+        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
 

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__)`.'
@@ -74,44 +75,42 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          if (captured_values = file_expand_path(node))
-            current_path, default_dir = captured_values
+          return unless node.method?(:expand_path)
 
+          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)

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces the use of explicit block argument to avoid writing
+      # block literal that just passes its arguments to another block.
+      #
+      # @example
+      #   # bad
+      #   def with_tmp_dir
+      #     Dir.mktmpdir do |tmp_dir|
+      #       Dir.chdir(tmp_dir) { |dir| yield dir } # block just passes arguments
+      #     end
+      #   end
+      #
+      #   # bad
+      #   def nine_times
+      #     9.times { yield }
+      #   end
+      #
+      #   # good
+      #   def with_tmp_dir(&block)
+      #     Dir.mktmpdir do |tmp_dir|
+      #       Dir.chdir(tmp_dir, &block)
+      #     end
+      #   end
+      #
+      #   with_tmp_dir do |dir|
+      #     puts "dir is accessible as a parameter and pwd is set: #{dir}"
+      #   end
+      #
+      #   # good
+      #   def nine_times(&block)
+      #     9.times(&block)
+      #   end
+      #
+      class ExplicitBlockArgument < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Consider using explicit block argument in the '\
+              "surrounding method's signature over `yield`."
+
+        def_node_matcher :yielding_block?, <<~PATTERN
+          (block $_ (args $...) (yield $...))
+        PATTERN
+
+        def initialize(config = nil, options = nil)
+          super
+          @def_nodes = Set.new
+        end
+
+        def on_yield(node)
+          block_node = node.parent
+
+          yielding_block?(block_node) do |send_node, block_args, yield_args|
+            return unless yielding_arguments?(block_args, yield_args)
+
+            add_offense(block_node) do |corrector|
+              corrector.remove(block_body_range(block_node, send_node))
+
+              add_block_argument(send_node, corrector)
+
+              def_node = block_node.each_ancestor(:def, :defs).first
+              add_block_argument(def_node, corrector) if @def_nodes.add?(def_node)
+            end
+          end
+        end
+
+        private
+
+        def yielding_arguments?(block_args, yield_args)
+          yield_args.zip(block_args).all? do |yield_arg, block_arg|
+            block_arg && yield_arg.children.first == block_arg.children.first
+          end
+        end
+
+        def add_block_argument(node, corrector)
+          if node.arguments?
+            last_arg = node.arguments.last
+            arg_range = range_with_surrounding_comma(last_arg.source_range, :right)
+            replacement = ' &block'
+            replacement = ",#{replacement}" unless arg_range.source.end_with?(',')
+            corrector.insert_after(arg_range, replacement) unless last_arg.blockarg_type?
+          elsif node.send_type?
+            corrector.insert_after(node, '(&block)')
+          else
+            corrector.insert_after(node.loc.name, '(&block)')
+          end
+        end
+
+        def block_body_range(block_node, send_node)
+          range_between(
+            send_node.loc.expression.end_pos,
+            block_node.loc.end.end_pos
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -58,7 +58,7 @@ module RuboCop
       #   1e4
       #   12e5
       #
-      class ExponentialNotation < Cop
+      class ExponentialNotation < Base
         include ConfigurableEnforcedStyle
         MESSAGES = {
           scientific: 'Use a mantissa in [1, 10[.',

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

@@ -39,7 +39,7 @@ module RuboCop
       #
       #   # good
       #   a.fdiv(b)
-      class FloatDivision < Cop
+      class FloatDivision < Base
         include ConfigurableEnforcedStyle
         MESSAGES = {
           left_coerce: 'Prefer using `.to_f` on the left side.',

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

@@ -38,9 +38,10 @@ module RuboCop
       #     end
       #   end
       #
-      class For < Cop
+      class For < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         EACH_LENGTH = 'each'.length
         PREFER_EACH = 'Prefer `each` over `for`.'
@@ -48,8 +49,10 @@ module RuboCop
 
         def on_for(node)
           if style == :each
-            add_offense(node, message: PREFER_EACH) do
-              opposite_style_detected
+            return unless opposite_style_detected
+
+            add_offense(node, message: PREFER_EACH) do |corrector|
+              ForToEachCorrector.new(node).call(corrector)
             end
           else
             correct_style_detected
@@ -60,27 +63,20 @@ module RuboCop
           return unless suspect_enumerable?(node)
 
           if style == :for
-            add_offense(node, message: PREFER_FOR) do
-              opposite_style_detected
+            return unless opposite_style_detected
+
+            add_offense(node, message: PREFER_FOR) do |corrector|
+              EachToForCorrector.new(node).call(corrector)
             end
           else
             correct_style_detected
           end
         end
 
-        def autocorrect(node)
-          if style == :each
-            ForToEachCorrector.new(node)
-          else
-            EachToForCorrector.new(node)
-          end
-        end
-
         private
 
         def suspect_enumerable?(node)
-          node.multiline? &&
-            node.send_node.method?(:each) && !node.send_node.arguments?
+          node.multiline? && node.send_node.method?(:each) && !node.send_node.arguments?
         end
       end
     end

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

@@ -35,11 +35,14 @@ module RuboCop
       #   # good
       #   puts '%10s' % 'hoge'
       #
-      class FormatString < Cop
+      class FormatString < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG = 'Favor `%<prefer>s` over `%<current>s`.'
 
+        FORMAT_METHODS = %i[format sprintf %].freeze
+
         def_node_matcher :formatter, <<~PATTERN
           {
             (send nil? ${:sprintf :format} _ _ ...)
@@ -53,46 +56,45 @@ module RuboCop
         PATTERN
 
         def on_send(node)
+          return unless FORMAT_METHODS.include?(node.method_name)
+
           formatter(node) do |selector|
             detected_style = selector == :% ? :percent : selector
 
             return if detected_style == style
 
-            add_offense(node, location: :selector,
-                              message: message(detected_style))
+            add_offense(node.loc.selector, message: message(detected_style)) do |corrector|
+              autocorrect(corrector, node)
+            end
           end
         end
 
+        private
+
         def message(detected_style)
-          format(MSG,
-                 prefer: method_name(style),
-                 current: method_name(detected_style))
+          format(MSG, prefer: method_name(style), current: method_name(detected_style))
         end
 
         def method_name(style_name)
           style_name == :percent ? 'String#%' : style_name
         end
 
-        def autocorrect(node)
+        def autocorrect(corrector, node)
           return if variable_argument?(node)
 
-          lambda do |corrector|
-            case node.method_name
-            when :%
-              autocorrect_from_percent(corrector, node)
+          case node.method_name
+          when :%
+            autocorrect_from_percent(corrector, node)
+          when :format, :sprintf
+            case style
+            when :percent
+              autocorrect_to_percent(corrector, node)
             when :format, :sprintf
-              case style
-              when :percent
-                autocorrect_to_percent(corrector, node)
-              when :format, :sprintf
-                corrector.replace(node.loc.selector, style.to_s)
-              end
+              corrector.replace(node.loc.selector, style.to_s)
             end
           end
         end
 
-        private
-
         def autocorrect_from_percent(corrector, node)
           percent_rhs = node.first_argument
           args = case percent_rhs.type