rubocop 0.78.0 → 1.13.0

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

@@ -3,9 +3,19 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks `eval` method usage. `eval` can receive source location
-      # metadata, that are filename and line number. The metadata is used by
-      # backtraces. This cop recommends to pass the metadata to `eval` method.
+      # This cop ensures that eval methods (`eval`, `instance_eval`, `class_eval`
+      # and `module_eval`) are given filename and line number values (`__FILE__`
+      # and `__LINE__`). This data is used to ensure that any errors raised
+      # within the evaluated code will be given the correct identification
+      # in a backtrace.
+      #
+      # The cop also checks that the line number given relative to `__LINE__` is
+      # correct.
+      #
+      # This cop will autocorrect incorrect or missing filename and line number
+      # values. However, if `eval` is called without a binding argument, the cop
+      # will not attempt to automatically add a binding, or add filename and
+      # line values.
       #
       # @example
       #   # bad
@@ -31,28 +41,36 @@ module RuboCop
       #     def do_something
       #     end
       #   RUBY
-      class EvalWithLocation < Cop
-        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.'
+      #
+      # This cop works only when a string literal is given as a code string.
+      # No offence is reported if a string variable is given as below:
+      #
+      # @example
+      #   # not checked
+      #   code = <<-RUBY
+      #     def do_something
+      #     end
+      #   RUBY
+      #   eval code
+      #
+      class EvalWithLocation < Base
+        extend AutoCorrector
 
-        def_node_matcher :eval_without_location?, <<~PATTERN
-          {
-            (send nil? :eval ${str dstr})
-            (send nil? :eval ${str dstr} _)
-            (send nil? :eval ${str dstr} _ #special_file_keyword?)
-            (send nil? :eval ${str dstr} _ #special_file_keyword? _)
-
-            (send _ {:class_eval :module_eval :instance_eval}
-              ${str dstr})
-            (send _ {:class_eval :module_eval :instance_eval}
-              ${str dstr} #special_file_keyword?)
-            (send _ {:class_eval :module_eval :instance_eval}
-              ${str dstr} #special_file_keyword? _)
-          }
+        MSG = 'Pass `__FILE__` and `__LINE__` to `%<method_name>s`.'
+        MSG_EVAL = 'Pass a binding, `__FILE__` and `__LINE__` to `eval`.'
+        MSG_INCORRECT_FILE = 'Incorrect file for `%<method_name>s`; ' \
+                             'use `%<expected>s` instead of `%<actual>s`.'
+        MSG_INCORRECT_LINE = 'Incorrect line number for `%<method_name>s`; ' \
+                             'use `%<expected>s` instead of `%<actual>s`.'
+
+        RESTRICT_ON_SEND = %i[eval class_eval module_eval instance_eval].freeze
+
+        # @!method valid_eval_receiver?(node)
+        def_node_matcher :valid_eval_receiver?, <<~PATTERN
+          { nil? (const {nil? cbase} :Kernel) }
         PATTERN
 
+        # @!method line_with_offset?(node, sign, num)
         def_node_matcher :line_with_offset?, <<~PATTERN
           {
             (send #special_line_keyword? %1 (int %2))
@@ -61,25 +79,53 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          eval_without_location?(node) do |code|
-            if with_lineno?(node)
-              on_with_lineno(node, code)
-            else
-              add_offense(node)
-            end
-          end
+          # Classes should not redefine eval, but in case one does, it shouldn't
+          # register an offense. Only `eval` without a receiver and `Kernel.eval`
+          # are considered.
+          return if node.method?(:eval) && !valid_eval_receiver?(node.receiver)
+
+          code = node.arguments.first
+          return unless code && (code.str_type? || code.dstr_type?)
+
+          check_location(node, code)
         end
 
         private
 
+        def check_location(node, code)
+          file, line = file_and_line(node)
+
+          if line
+            check_file(node, file)
+            check_line(node, code)
+          elsif file
+            check_file(node, file)
+            add_offense_for_missing_line(node, code)
+          else
+            add_offense_for_missing_location(node, code)
+          end
+        end
+
+        def register_offense(node, &block)
+          msg = node.method?(:eval) ? MSG_EVAL : format(MSG, method_name: node.method_name)
+          add_offense(node, message: msg, &block)
+        end
+
         def special_file_keyword?(node)
-          node.str_type? &&
-            node.source == '__FILE__'
+          node.str_type? && node.source == '__FILE__'
         end
 
         def special_line_keyword?(node)
-          node.int_type? &&
-            node.source == '__LINE__'
+          node.int_type? && node.source == '__LINE__'
+        end
+
+        def file_and_line(node)
+          base = node.method?(:eval) ? 2 : 1
+          [node.arguments[base], node.arguments[base + 1]]
+        end
+
+        def with_binding?(node)
+          node.method?(:eval) ? node.arguments.size >= 2 : true
         end
 
         # FIXME: It's a Style/ConditionalAssignment's false positive.
@@ -93,20 +139,34 @@ module RuboCop
         end
         # rubocop:enable Style/ConditionalAssignment
 
-        def message_incorrect_line(actual, sign, line_diff)
-          expected =
-            if line_diff.zero?
-              '__LINE__'
-            else
-              "__LINE__ #{sign} #{line_diff}"
-            end
-          format(MSG_INCORRECT_LINE, actual: actual.source, expected: expected)
+        def add_offense_for_incorrect_line(method_name, line_node, sign, line_diff)
+          expected = expected_line(sign, line_diff)
+          message = format(MSG_INCORRECT_LINE,
+                           method_name: method_name,
+                           actual: line_node.source,
+                           expected: expected)
+
+          add_offense(line_node.loc.expression, message: message) do |corrector|
+            corrector.replace(line_node, expected)
+          end
         end
 
-        def on_with_lineno(node, code)
+        def check_file(node, file_node)
+          return true if special_file_keyword?(file_node)
+
+          message = format(MSG_INCORRECT_FILE,
+                           method_name: node.method_name,
+                           expected: '__FILE__',
+                           actual: file_node.source)
+
+          add_offense(file_node, message: message) do |corrector|
+            corrector.replace(file_node, '__FILE__')
+          end
+        end
+
+        def check_line(node, code)
           line_node = node.arguments.last
-          lineno_range = line_node.loc.expression
-          line_diff = string_first_line(code) - lineno_range.first_line
+          line_diff = line_difference(line_node, code)
           if line_diff.zero?
             add_offense_for_same_line(node, line_node)
           else
@@ -114,6 +174,10 @@ module RuboCop
           end
         end
 
+        def line_difference(line_node, code)
+          string_first_line(code) - line_node.loc.expression.first_line
+        end
+
         def string_first_line(str_node)
           if str_node.heredoc?
             str_node.loc.heredoc_body.first_line
@@ -125,22 +189,47 @@ module RuboCop
         def add_offense_for_same_line(node, line_node)
           return if special_line_keyword?(line_node)
 
-          add_offense(
-            node,
-            location: line_node.loc.expression,
-            message: message_incorrect_line(line_node, nil, 0)
-          )
+          add_offense_for_incorrect_line(node.method_name, line_node, nil, 0)
         end
 
         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,
-            message: message_incorrect_line(line_node, sign, line_diff.abs)
-          )
+          add_offense_for_incorrect_line(node.method_name, line_node, sign, line_diff.abs)
+        end
+
+        def expected_line(sign, line_diff)
+          if line_diff.zero?
+            '__LINE__'
+          else
+            "__LINE__ #{sign} #{line_diff.abs}"
+          end
+        end
+
+        def add_offense_for_missing_line(node, code)
+          register_offense(node) do |corrector|
+            line_str = missing_line(node, code)
+            corrector.insert_after(node.loc.expression.end, ", #{line_str}")
+          end
+        end
+
+        def add_offense_for_missing_location(node, code)
+          if node.method?(:eval) && !with_binding?(node)
+            register_offense(node)
+            return
+          end
+
+          register_offense(node) do |corrector|
+            line_str = missing_line(node, code)
+            corrector.insert_after(node.last_argument.source_range.end, ", __FILE__, #{line_str}")
+          end
+        end
+
+        def missing_line(node, code)
+          line_diff = line_difference(node.arguments.last, code)
+          sign = line_diff.positive? ? :+ : :-
+          expected_line(sign, line_diff)
         end
       end
     end

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

@@ -15,9 +15,13 @@ 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
 
+        # @!method even_odd_candidate?(node)
         def_node_matcher :even_odd_candidate?, <<~PATTERN
           (send
             {(send $_ :% (int 2))
@@ -27,18 +31,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.source_range, 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,13 +52,17 @@ module RuboCop
                            'instead of ' \
                            '`Pathname.new(__FILE__).parent.expand_path`.'
 
+        RESTRICT_ON_SEND = %i[expand_path].freeze
+
+        # @!method file_expand_path(node)
         def_node_matcher :file_expand_path, <<~PATTERN
           (send
-            (const nil? :File) :expand_path
+            (const {nil? cbase} :File) :expand_path
             $_
             $_)
         PATTERN
 
+        # @!method pathname_parent_expand_path(node)
         def_node_matcher :pathname_parent_expand_path, <<~PATTERN
           (send
             (send
@@ -65,53 +70,48 @@ module RuboCop
                 $_) :parent) :expand_path)
         PATTERN
 
+        # @!method pathname_new_parent_expand_path(node)
         def_node_matcher :pathname_new_parent_expand_path, <<~PATTERN
           (send
             (send
               (send
-                (const nil? :Pathname) :new
+                (const {nil? cbase} :Pathname) :new
                 $_) :parent) :expand_path)
         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) { |corrector| autocorrect(corrector, node) }
           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.loc.expression, '__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 +127,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)
@@ -145,8 +147,8 @@ module RuboCop
           else
             new_path = "'#{parent_path(stripped_current_path)}'"
 
-            corrector.replace(current_path.loc.expression, new_path)
-            corrector.replace(default_dir.loc.expression, '__dir__')
+            corrector.replace(current_path, new_path)
+            corrector.replace(default_dir, '__dir__')
           end
         end
 

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

@@ -0,0 +1,114 @@
+# 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.
+      #
+      # NOTE: This cop only registers an offense if the block args match the
+      # yield args exactly.
+      #
+      # @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`."
+
+        # @!method yielding_block?(node)
+        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)
+
+            def_node = block_node.each_ancestor(:def, :defs).first
+            # if `yield` is being called outside of a method context, ignore
+            # this is not a valid ruby pattern, but can happen in haml or erb,
+            # so this can cause crashes in haml_lint
+            return unless def_node
+
+            add_offense(block_node) do |corrector|
+              corrector.remove(block_body_range(block_node, send_node))
+
+              add_block_argument(send_node, corrector)
+              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 = yield_args.dup.fill(
+            nil,
+            yield_args.length, block_args.length - yield_args.length
+          )
+
+          yield_args.zip(block_args).all? do |yield_arg, block_arg|
+            next false unless 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.call_type? || node.zsuper_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