rubocop 1.6.1 → 1.9.1

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

@@ -3,9 +3,14 @@
 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.
       #
       # @example
       #   # bad
@@ -32,27 +37,17 @@ module RuboCop
       #     end
       #   RUBY
       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.'
+        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
 
-        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? _)
-          }
+        def_node_matcher :valid_eval_receiver?, <<~PATTERN
+          { nil? (const {nil? cbase} :Kernel) }
         PATTERN
 
         def_node_matcher :line_with_offset?, <<~PATTERN
@@ -63,17 +58,31 @@ 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
+          # 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?)
+
+          file, line = file_and_line(node)
+
+          if line
+            check_file(node, file)
+            check_line(node, code)
+          else
+            register_offense(node)
           end
         end
 
         private
 
+        def register_offense(node)
+          msg = node.method?(:eval) ? MSG_EVAL : format(MSG, method_name: node.method_name)
+          add_offense(node, message: msg)
+        end
+
         def special_file_keyword?(node)
           node.str_type? &&
             node.source == '__FILE__'
@@ -84,6 +93,11 @@ module RuboCop
             node.source == '__LINE__'
         end
 
+        def file_and_line(node)
+          base = node.method?(:eval) ? 2 : 1
+          [node.arguments[base], node.arguments[base + 1]]
+        end
+
         # FIXME: It's a Style/ConditionalAssignment's false positive.
         # rubocop:disable Style/ConditionalAssignment
         def with_lineno?(node)
@@ -95,17 +109,32 @@ module RuboCop
         end
         # rubocop:enable Style/ConditionalAssignment
 
-        def message_incorrect_line(actual, sign, line_diff)
+        def message_incorrect_line(method_name, 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)
+
+          format(MSG_INCORRECT_LINE,
+                 method_name: method_name,
+                 actual: actual.source,
+                 expected: expected)
+        end
+
+        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)
         end
 
-        def on_with_lineno(node, code)
+        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
@@ -124,22 +153,22 @@ 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(
             line_node.loc.expression,
-            message: message_incorrect_line(line_node, nil, 0)
+            message: message_incorrect_line(node.method_name, 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(
             line_node.loc.expression,
-            message: message_incorrect_line(line_node, sign, line_diff.abs)
+            message: message_incorrect_line(node.method_name, line_node, sign, line_diff.abs)
           )
         end
       end

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

@@ -6,6 +6,9 @@ module RuboCop
       # 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
@@ -75,7 +78,14 @@ module RuboCop
         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

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

@@ -7,6 +7,9 @@ module RuboCop
       # It is recommended to either always use `fdiv` or coerce one side only.
       # This cop also provides other options for code consistency.
       #
+      # This cop is marked as unsafe, because if operand variable is a string object
+      # then `.to_f` will be removed and an error will occur.
+      #
       # @example EnforcedStyle: single_coerce (default)
       #   # bad
       #   a.to_f / b.to_f

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

@@ -51,6 +51,7 @@ module RuboCop
           if style == :each
             add_offense(node, message: PREFER_EACH) do |corrector|
               ForToEachCorrector.new(node).call(corrector)
+              opposite_style_detected
             end
           else
             correct_style_detected
@@ -63,6 +64,7 @@ module RuboCop
           if style == :for
             add_offense(node, message: PREFER_FOR) do |corrector|
               EachToForCorrector.new(node).call(corrector)
+              opposite_style_detected
             end
           else
             correct_style_detected

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

@@ -11,6 +11,8 @@ module RuboCop
       # The reason is that _unannotated_ format is very similar
       # to encoded URLs or Date/Time formatting strings.
       #
+      # This cop can be customized ignored methods with `IgnoredMethods`.
+      #
       # @example EnforcedStyle: annotated (default)
       #
       #   # bad
@@ -58,12 +60,18 @@ module RuboCop
       #
       #   # good
       #   format('%06d', 10)
+      #
+      # @example IgnoredMethods: [redirect]
+      #
+      #   # good
+      #   redirect('foo/%{bar_id}')
+      #
       class FormatStringToken < Base
         include ConfigurableEnforcedStyle
+        include IgnoredMethods
 
         def on_str(node)
-          return unless node.value.include?('%')
-          return if node.each_ancestor(:xstr, :regexp).any?
+          return if format_string_token?(node) || use_ignored_method?(node)
 
           detections = collect_detections(node)
           return if detections.empty?
@@ -88,6 +96,14 @@ module RuboCop
           }
         PATTERN
 
+        def format_string_token?(node)
+          !node.value.include?('%') || node.each_ancestor(:xstr, :regexp).any?
+        end
+
+        def use_ignored_method?(node)
+          (parent = node.parent) && parent.send_type? && ignored_method?(parent.method_name)
+        end
+
         def unannotated_format?(node, detected_style)
           detected_style == :unannotated && !format_string_in_typical_context?(node)
         end

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for usages of `Hash#reject`, `Hash#select`, and `Hash#filter` methods
+      # that can be replaced with `Hash#except` method.
+      #
+      # This cop should only be enabled on Ruby version 3.0 or higher.
+      # (`Hash#except` was added in Ruby 3.0.)
+      #
+      # For safe detection, it is limited to commonly used string and symbol comparisons
+      # when used `==`.
+      # And do not check `Hash#delete_if` and `Hash#keep_if` to change receiver object.
+      #
+      # @example
+      #
+      #   # bad
+      #   {foo: 1, bar: 2, baz: 3}.reject {|k, v| k == :bar }
+      #   {foo: 1, bar: 2, baz: 3}.select {|k, v| k != :bar }
+      #   {foo: 1, bar: 2, baz: 3}.filter {|k, v| k != :bar }
+      #
+      #   # good
+      #   {foo: 1, bar: 2, baz: 3}.except(:bar)
+      #
+      class HashExcept < Base
+        include RangeHelp
+        extend TargetRubyVersion
+        extend AutoCorrector
+
+        minimum_target_ruby_version 3.0
+
+        MSG = 'Use `%<prefer>s` instead.'
+        RESTRICT_ON_SEND = %i[reject select filter].freeze
+
+        def_node_matcher :bad_method?, <<~PATTERN
+          (block
+            (send _ _)
+            (args
+              (arg _)
+              (arg _))
+            (send
+              _ {:== :!= :eql?} _))
+        PATTERN
+
+        def on_send(node)
+          block = node.parent
+          return unless bad_method?(block) && semantically_except_method?(node, block)
+
+          except_key = except_key(block)
+          return unless safe_to_register_offense?(block, except_key)
+
+          range = offense_range(node)
+          preferred_method = "except(#{except_key.source})"
+
+          add_offense(range, message: format(MSG, prefer: preferred_method)) do |corrector|
+            corrector.replace(range, preferred_method)
+          end
+        end
+
+        private
+
+        def semantically_except_method?(send, block)
+          body = block.body
+
+          case send.method_name
+          when :reject
+            body.method?('==') || body.method?('eql?')
+          when :select, :filter
+            body.method?('!=')
+          else
+            false
+          end
+        end
+
+        def safe_to_register_offense?(block, except_key)
+          return true if block.body.method?('eql?')
+
+          except_key.sym_type? || except_key.str_type?
+        end
+
+        def except_key(node)
+          key_argument = node.argument_list.first
+          lhs, _method_name, rhs = *node.body
+
+          [lhs, rhs].find { |operand| operand.source != key_argument.source }
+        end
+
+        def offense_range(node)
+          range_between(node.loc.selector.begin_pos, node.parent.loc.end.end_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -68,7 +68,8 @@ module RuboCop
           length = cop_config['MinBranchesCount'] || 3
           return length if length.is_a?(Integer) && length.positive?
 
-          raise 'MinBranchesCount needs to be a positive integer!'
+          warn Rainbow('`MinBranchesCount` needs to be a positive integer!').red
+          exit!
         end
       end
     end

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

@@ -82,15 +82,14 @@ module RuboCop
         def autocorrect(corrector, node)
           if node.modifier_form?
             correct_to_elsif_from_modifier_form(corrector, node)
-            end_range = node.parent.loc.end
           else
             correct_to_elsif_from_if_inside_else_form(corrector, node, node.condition)
-            end_range = node.loc.end
           end
-          corrector.remove(range_by_whole_lines(end_range, include_final_newline: true))
-          corrector.remove(
-            range_by_whole_lines(node.if_branch.source_range, include_final_newline: true)
-          )
+          corrector.remove(range_by_whole_lines(find_end_range(node), include_final_newline: true))
+          return unless (if_branch = node.if_branch)
+
+          range = range_by_whole_lines(if_branch.source_range, include_final_newline: true)
+          corrector.remove(range)
         end
 
         def correct_to_elsif_from_modifier_form(corrector, node)
@@ -103,13 +102,26 @@ module RuboCop
 
         def correct_to_elsif_from_if_inside_else_form(corrector, node, condition)
           corrector.replace(node.parent.loc.else, "elsif #{condition.source}")
-          if_condition_range = range_between(
-            node.loc.keyword.begin_pos, condition.source_range.end_pos
-          )
-          corrector.replace(if_condition_range, node.if_branch.source)
+          if_condition_range = if_condition_range(node, condition)
+          if (if_branch = node.if_branch)
+            corrector.replace(if_condition_range, if_branch.source)
+          else
+            corrector.remove(range_by_whole_lines(if_condition_range, include_final_newline: true))
+          end
           corrector.remove(condition)
         end
 
+        def find_end_range(node)
+          end_range = node.loc.end
+          return end_range if end_range
+
+          find_end_range(node.parent)
+        end
+
+        def if_condition_range(node, condition)
+          range_between(node.loc.keyword.begin_pos, condition.source_range.end_pos)
+        end
+
         def allow_if_modifier_in_else_branch?(else_branch)
           allow_if_modifier? && else_branch&.modifier_form?
         end

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

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for redundant `if` with boolean literal branches.
+      # It checks only conditions to return boolean value (`true` or `false`) for safe detection.
+      # The conditions to be checked are comparison methods, predicate methods, and double negative.
+      # However, auto-correction is unsafe because there is no guarantee that all predicate methods
+      # will return boolean value. Those methods can be allowed with `AllowedMethods` config.
+      #
+      # @example
+      #   # bad
+      #   if foo == bar
+      #     true
+      #   else
+      #     false
+      #   end
+      #
+      #   # bad
+      #   foo == bar ? true : false
+      #
+      #   # good
+      #   foo == bar
+      #
+      # @example AllowedMethods: ['nonzero?']
+      #   # good
+      #   num.nonzero? ? true : false
+      #
+      class IfWithBooleanLiteralBranches < Base
+        include AllowedMethods
+        extend AutoCorrector
+
+        MSG = 'Remove redundant %<keyword>s with boolean literal branches.'
+        MSG_FOR_ELSIF = 'Use `else` instead of redundant `elsif` with boolean literal branches.'
+
+        def_node_matcher :if_with_boolean_literal_branches?, <<~PATTERN
+          (if #return_boolean_value? {(true) (false) | (false) (true)})
+        PATTERN
+        def_node_matcher :double_negative?, '(send (send _ :!) :!)'
+
+        def on_if(node)
+          return unless if_with_boolean_literal_branches?(node)
+
+          condition = node.condition
+          range, keyword = offense_range_with_keyword(node, condition)
+
+          add_offense(range, message: message(node, keyword)) do |corrector|
+            replacement = replacement_condition(node, condition)
+
+            if node.elsif?
+              corrector.insert_before(node, "else\n")
+              corrector.replace(node, "#{indent(node.if_branch)}#{replacement}")
+            else
+              corrector.replace(node, replacement)
+            end
+          end
+        end
+
+        private
+
+        def offense_range_with_keyword(node, condition)
+          if node.ternary?
+            range = condition.source_range.end.join(node.source_range.end)
+
+            [range, 'ternary operator']
+          else
+            keyword = node.loc.keyword
+
+            [keyword, "`#{keyword.source}`"]
+          end
+        end
+
+        def message(node, keyword)
+          message_template = node.elsif? ? MSG_FOR_ELSIF : MSG
+
+          format(message_template, keyword: keyword)
+        end
+
+        def return_boolean_value?(condition)
+          if condition.begin_type?
+            return_boolean_value?(condition.children.first)
+          elsif condition.or_type?
+            return_boolean_value?(condition.lhs) && return_boolean_value?(condition.rhs)
+          elsif condition.and_type?
+            return_boolean_value?(condition.rhs)
+          else
+            assume_boolean_value?(condition)
+          end
+        end
+
+        def assume_boolean_value?(condition)
+          return false unless condition.send_type?
+          return false if allowed_method?(condition.method_name)
+
+          condition.comparison_method? || condition.predicate_method? || double_negative?(condition)
+        end
+
+        def replacement_condition(node, condition)
+          bang = '!' if opposite_condition?(node)
+
+          if bang && require_parentheses?(condition)
+            "#{bang}(#{condition.source})"
+          else
+            "#{bang}#{condition.source}"
+          end
+        end
+
+        def opposite_condition?(node)
+          !node.unless? && node.if_branch.false_type? || node.unless? && node.if_branch.true_type?
+        end
+
+        def require_parentheses?(condition)
+          condition.and_type? || condition.or_type? ||
+            condition.send_type? && condition.comparison_method?
+        end
+      end
+    end
+  end
+end