rubocop 0.91.1 → 1.1.0

data/lib/rubocop/cop/lint/empty_block.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for blocks without a body.
+      # Such empty blocks are typically an oversight or we should provide a comment
+      # be clearer what we're aiming for.
+      #
+      # @example
+      #   # bad
+      #   items.each { |item| }
+      #
+      #   # good
+      #   items.each { |item| puts item }
+      #
+      # @example AllowComments: true (default)
+      #   # good
+      #   items.each do |item|
+      #     # TODO: implement later (inner comment)
+      #   end
+      #
+      #   items.each { |item| } # TODO: implement later (inline comment)
+      #
+      # @example AllowComments: false
+      #   # bad
+      #   items.each do |item|
+      #     # TODO: implement later (inner comment)
+      #   end
+      #
+      #   items.each { |item| } # TODO: implement later (inline comment)
+      #
+      class EmptyBlock < Base
+        MSG = 'Empty block detected.'
+
+        def on_block(node)
+          return if node.body
+          return if cop_config['AllowComments'] &&
+                    processed_source.contains_comment?(node.source_range)
+
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/flip_flop.rb

@@ -3,8 +3,14 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop looks for uses of flip-flop operator.
-      # flip-flop operator is deprecated since Ruby 2.6.0.
+      # This cop looks for uses of flip-flop operator
+      # based on the Ruby Style Guide.
+      #
+      # Here is the history of flip-flops in Ruby.
+      # flip-flop operator is deprecated in Ruby 2.6.0 and
+      # the deprecation has been reverted by Ruby 2.7.0 and
+      # backported to Ruby 2.6.
+      # See: https://bugs.ruby-lang.org/issues/5400
       #
       # @example
       #   # bad

data/lib/rubocop/cop/lint/hash_compare_by_identity.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Prefer using `Hash#compare_by_identity` than using `object_id` for hash keys.
+      #
+      # This cop is marked as unsafe as a hash possibly can contain other keys
+      # besides `object_id`s.
+      #
+      # @example
+      #   # bad
+      #   hash = {}
+      #   hash[foo.object_id] = :bar
+      #   hash.key?(baz.object_id)
+      #
+      #   # good
+      #   hash = {}.compare_by_identity
+      #   hash[foo] = :bar
+      #   hash.key?(baz)
+      #
+      class HashCompareByIdentity < Base
+        RESTRICT_ON_SEND = %i[key? has_key? fetch [] []=].freeze
+
+        MSG = 'Use `Hash#compare_by_identity` instead of using `object_id` for keys.'
+
+        def_node_matcher :id_as_hash_key?, <<~PATTERN
+          (send _ {:key? :has_key? :fetch :[] :[]=} (send _ :object_id) ...)
+        PATTERN
+
+        def on_send(node)
+          add_offense(node) if id_as_hash_key?(node)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/literal_in_interpolation.rb

@@ -31,12 +31,18 @@ module RuboCop
           return if special_keyword?(final_node)
           return unless prints_as_self?(final_node)
 
+          # %W and %I split the content into words before expansion
+          # treating each interpolation as a word component, so
+          # interpolation should not be removed if the expanded value
+          # contains a space character.
+          expanded_value = autocorrected_value(final_node)
+          return if in_array_percent_literal?(begin_node) &&
+                    /\s/.match?(expanded_value)
+
           add_offense(final_node) do |corrector|
             return if final_node.dstr_type? # nested, fixed in next iteration
 
-            value = autocorrected_value(final_node)
-
-            corrector.replace(final_node.parent, value)
+            corrector.replace(final_node.parent, expanded_value)
           end
         end
 
@@ -92,6 +98,14 @@ module RuboCop
             (COMPOSITE.include?(node.type) &&
               node.children.all? { |child| prints_as_self?(child) })
         end
+
+        def in_array_percent_literal?(node)
+          parent = node.parent
+          return false unless parent.dstr_type? || parent.dsym_type?
+
+          grandparent = parent.parent
+          grandparent&.array_type? && grandparent&.percent_literal?
+        end
       end
     end
   end

data/lib/rubocop/cop/lint/mixed_regexp_capture_types.rb

@@ -25,6 +25,7 @@ module RuboCop
               'in a Regexp literal.'
 
         def on_regexp(node)
+          return if node.interpolation?
           return if node.each_capture(named: false).none?
           return if node.each_capture(named: true).none?
 

data/lib/rubocop/cop/lint/number_conversion.rb

@@ -7,6 +7,17 @@ module RuboCop
       # number conversion can cause unexpected error if auto type conversion
       # fails. Cop prefer parsing with number class instead.
       #
+      # Conversion with `Integer`, `Float`, etc. will raise an `ArgumentError`
+      # if given input that is not numeric (eg. an empty string), whereas
+      # `to_i`, etc. will try to convert regardless of input (`''.to_i => 0`).
+      # As such, this cop is disabled by default because it's not necessarily
+      # always correct to raise if a value is not numeric.
+      #
+      # NOTE: Some values cannot be converted properly using one of the `Kernel`
+      # method (for instance, `Time` and `DateTime` values are allowed by this
+      # cop by default). Similarly, Rails' duration methods do not work well
+      # with `Integer()` and can be ignored with `IgnoredMethods`.
+      #
       # @example
       #
       #   # bad
@@ -20,8 +31,19 @@ module RuboCop
       #   Integer('10', 10)
       #   Float('10.2')
       #   Complex('10')
+      #
+      # @example IgnoredMethods: [minutes]
+      #
+      #   # good
+      #   10.minutes.to_i
+      #
+      # @example IgnoredClasses: [Time, DateTime] (default)
+      #
+      #   # good
+      #   Time.now.to_datetime.to_i
       class NumberConversion < Base
         extend AutoCorrector
+        include IgnoredMethods
 
         CONVERSION_METHOD_CLASS_MAPPING = {
           to_i: "#{Integer.name}(%<number_object>s, 10)",
@@ -38,13 +60,9 @@ module RuboCop
           (send $_ ${:to_i :to_f :to_c})
         PATTERN
 
-        def_node_matcher :datetime?, <<~PATTERN
-          (send (const {nil? (cbase)} {:Time :DateTime}) ...)
-        PATTERN
-
         def on_send(node)
           to_method(node) do |receiver, to_method|
-            next if receiver.nil? || date_time_object?(receiver)
+            next if receiver.nil? || ignore_receiver?(receiver)
 
             message = format(
               MSG,
@@ -60,18 +78,33 @@ module RuboCop
 
         private
 
-        def date_time_object?(node)
-          child = node
-          while child&.send_type?
-            return true if datetime? child
+        def correct_method(node, receiver)
+          format(CONVERSION_METHOD_CLASS_MAPPING[node.method_name],
+                 number_object: receiver.source)
+        end
 
-            child = child.children[0]
+        def ignore_receiver?(receiver)
+          if receiver.send_type? && ignored_method?(receiver.method_name)
+            true
+          elsif (receiver = top_receiver(receiver))
+            receiver.const_type? && ignored_class?(receiver.const_name)
+          else
+            false
           end
         end
 
-        def correct_method(node, receiver)
-          format(CONVERSION_METHOD_CLASS_MAPPING[node.method_name],
-                 number_object: receiver.source)
+        def top_receiver(node)
+          receiver = node
+          receiver = receiver.receiver until receiver.receiver.nil?
+          receiver
+        end
+
+        def ignored_classes
+          cop_config.fetch('IgnoredClasses', [])
+        end
+
+        def ignored_class?(name)
+          ignored_classes.include?(name.to_s)
         end
       end
     end

data/lib/rubocop/cop/lint/out_of_range_regexp_ref.rb

@@ -19,7 +19,7 @@ module RuboCop
       #   puts $1 # => foo
       #
       class OutOfRangeRegexpRef < Base
-        MSG = 'Do not use out of range reference for the Regexp.'
+        MSG = '$%<backref>s is out of range (%<count>s regexp capture %<group>s detected).'
 
         REGEXP_RECEIVER_METHODS = %i[=~ === match].to_set.freeze
         REGEXP_ARGUMENT_METHODS = %i[=~ match grep gsub gsub! sub sub! [] slice slice! index rindex
@@ -35,14 +35,13 @@ module RuboCop
           check_regexp(node.children.first)
         end
 
-        def on_send(node)
+        def after_send(node)
           @valid_ref = nil
 
-          if node.receiver&.regexp_type?
-            check_regexp(node.receiver)
-          elsif node.first_argument&.regexp_type? \
-            && REGEXP_ARGUMENT_METHODS.include?(node.method_name)
+          if regexp_first_argument?(node)
             check_regexp(node.first_argument)
+          elsif regexp_receiver?(node)
+            check_regexp(node.receiver)
           end
         end
 
@@ -56,9 +55,16 @@ module RuboCop
 
         def on_nth_ref(node)
           backref, = *node
-          return if @valid_ref.nil?
+          return if @valid_ref.nil? || backref <= @valid_ref
+
+          message = format(
+            MSG,
+            backref: backref,
+            count: @valid_ref.zero? ? 'no' : @valid_ref,
+            group: @valid_ref == 1 ? 'group' : 'groups'
+          )
 
-          add_offense(node) if backref > @valid_ref
+          add_offense(node, message: message)
         end
 
         private
@@ -73,6 +79,19 @@ module RuboCop
                          node.each_capture(named: false).count
                        end
         end
+
+        def regexp_first_argument?(send_node)
+          send_node.first_argument&.regexp_type? \
+            && REGEXP_ARGUMENT_METHODS.include?(send_node.method_name)
+        end
+
+        def regexp_receiver?(send_node)
+          send_node.receiver&.regexp_type?
+        end
+
+        def nth_ref_receiver?(send_node)
+          send_node.receiver&.nth_ref_type?
+        end
       end
     end
   end

data/lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb

@@ -43,7 +43,7 @@ module RuboCop
           end
 
           node.operator_method? || node.setter_method? || chained_calls?(node) ||
-            operator_keyword?(node)
+            operator_keyword?(node) || node.first_argument.hash_type?
         end
 
         def first_argument_starts_with_left_parenthesis?(node)

data/lib/rubocop/cop/lint/redundant_safe_navigation.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for redundant safe navigation calls.
+      # `instance_of?`, `kind_of?`, `is_a?`, `eql?`, `respond_to?`, and `equal?` methods
+      # are checked by default. These are customizable with `AllowedMethods` option.
+      #
+      # This cop is marked as unsafe, because auto-correction can change the
+      # return type of the expression. An offending expression that previously
+      # could return `nil` will be auto-corrected to never return `nil`.
+      #
+      # In the example below, the safe navigation operator (`&.`) is unnecessary
+      # because `NilClass` has methods like `respond_to?` and `is_a?`.
+      #
+      # @example
+      #   # bad
+      #   do_something if attrs&.respond_to?(:[])
+      #
+      #   # good
+      #   do_something if attrs.respond_to?(:[])
+      #
+      #   # bad
+      #   while node&.is_a?(BeginNode)
+      #     node = node.parent
+      #   end
+      #
+      #   # good
+      #   while node.is_a?(BeginNode)
+      #     node = node.parent
+      #   end
+      #
+      #   # good - without `&.` this will always return `true`
+      #   foo&.respond_to?(:to_a)
+      #
+      class RedundantSafeNavigation < Base
+        include AllowedMethods
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Redundant safe navigation detected.'
+
+        NIL_SPECIFIC_METHODS = (nil.methods - Object.new.methods).to_set.freeze
+
+        def_node_matcher :respond_to_nil_specific_method?, <<~PATTERN
+          (csend _ :respond_to? (sym %NIL_SPECIFIC_METHODS))
+        PATTERN
+
+        def on_csend(node)
+          return unless check?(node) && allowed_method?(node.method_name)
+          return if respond_to_nil_specific_method?(node)
+
+          range = range_between(node.loc.dot.begin_pos, node.source_range.end_pos)
+          add_offense(range) do |corrector|
+            corrector.replace(node.loc.dot, '.')
+          end
+        end
+
+        private
+
+        def check?(node)
+          parent = node.parent
+          return false unless parent
+
+          condition?(parent, node) ||
+            parent.and_type? ||
+            parent.or_type? ||
+            (parent.send_type? && parent.negation_method?)
+        end
+
+        def condition?(parent, node)
+          (parent.conditional? || parent.post_condition_loop?) && parent.condition == node
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/to_enum_arguments.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop ensures that `to_enum`/`enum_for`, called for the current method,
+      # has correct arguments.
+      #
+      # @example
+      #   # bad
+      #   def method(x, y = 1)
+      #     return to_enum(__method__, x) # `y` is missing
+      #   end
+      #
+      #   # good
+      #   def method(x, y = 1)
+      #     return to_enum(__method__, x, y)
+      #   end
+      #
+      #   # bad
+      #   def method(required:)
+      #     return to_enum(:method, required: something) # `required` has incorrect value
+      #   end
+      #
+      #   # good
+      #   def method(required:)
+      #     return to_enum(:method, required: required)
+      #   end
+      #
+      class ToEnumArguments < Base
+        MSG = 'Ensure you correctly provided all the arguments.'
+
+        RESTRICT_ON_SEND = %i[to_enum enum_for].freeze
+
+        def_node_matcher :enum_conversion_call?, <<~PATTERN
+          (send {nil? self} {:to_enum :enum_for} $_ $...)
+        PATTERN
+
+        def_node_matcher :method_name?, <<~PATTERN
+          {(send nil? :__method__) (sym %1)}
+        PATTERN
+
+        def_node_matcher :passing_keyword_arg?, <<~PATTERN
+          (pair (sym %1) (lvar %1))
+        PATTERN
+
+        def on_send(node)
+          def_node = node.each_ancestor(:def, :defs).first
+          return unless def_node
+
+          enum_conversion_call?(node) do |method_node, arguments|
+            add_offense(node) unless method_name?(method_node, def_node.method_name) &&
+                                     arguments_match?(arguments, def_node)
+          end
+        end
+
+        private
+
+        def arguments_match?(arguments, def_node)
+          index = 0
+
+          def_node.arguments.reject(&:blockarg_type?).all? do |def_arg|
+            send_arg = arguments[index]
+            case def_arg.type
+            when :arg, :restarg, :optarg
+              index += 1
+            end
+
+            send_arg && argument_match?(send_arg, def_arg)
+          end
+        end
+
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+        def argument_match?(send_arg, def_arg)
+          def_arg_name = def_arg.children[0]
+
+          case def_arg.type
+          when :arg, :restarg
+            send_arg.source == def_arg.source
+          when :optarg
+            send_arg.source == def_arg_name.to_s
+          when :kwoptarg, :kwarg
+            send_arg.hash_type? &&
+              send_arg.pairs.any? { |pair| passing_keyword_arg?(pair, def_arg_name) }
+          when :kwrestarg
+            send_arg.each_child_node(:kwsplat).any? { |child| child.source == def_arg.source }
+          when :forward_arg
+            send_arg.forwarded_args_type?
+          end
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+      end
+    end
+  end
+end