rubocop 0.93.0 → 1.3.0

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/redundant_cop_enable_directive.rb

@@ -88,31 +88,34 @@ module RuboCop
           begin_pos = reposition(source, begin_pos, -1)
           end_pos = reposition(source, end_pos, 1)
 
-          comma_pos =
-            if source[begin_pos - 1] == ','
-              :before
-            elsif source[end_pos] == ','
-              :after
-            else
-              :none
-            end
-
-          range_to_remove(begin_pos, end_pos, comma_pos, comment)
+          range_to_remove(begin_pos, end_pos, comment)
         end
 
-        def range_to_remove(begin_pos, end_pos, comma_pos, comment)
+        def range_to_remove(begin_pos, end_pos, comment)
           start = comment_start(comment)
+          source = comment.loc.expression.source
 
-          case comma_pos
-          when :before
-            range_between(start + begin_pos - 1, start + end_pos)
-          when :after
-            range_between(start + begin_pos, start + end_pos + 1)
+          if source[begin_pos - 1] == ','
+            range_with_comma_before(start, begin_pos, end_pos)
+          elsif source[end_pos] == ','
+            range_with_comma_after(comment, start, begin_pos, end_pos)
           else
             range_between(start, comment.loc.expression.end_pos)
           end
         end
 
+        def range_with_comma_before(start, begin_pos, end_pos)
+          range_between(start + begin_pos - 1, start + end_pos)
+        end
+
+        # If the list of cops is comma-separated, but without a empty space after the comma,
+        # we should **not** remove the prepending empty space, thus begin_pos += 1
+        def range_with_comma_after(comment, start, begin_pos, end_pos)
+          begin_pos += 1 if comment.loc.expression.source[end_pos + 1] != ' '
+
+          range_between(start + begin_pos, start + end_pos + 1)
+        end
+
         def all_or_name(name)
           name == 'all' ? 'all cops' : name
         end

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

@@ -4,29 +4,52 @@ module RuboCop
   module Cop
     module Lint
       # This cop checks for redundant safe navigation calls.
-      # It is marked as unsafe, because it can produce code that returns
-      # non `nil` while `nil` result is expected on `nil` receiver.
+      # `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
-      #   attrs&.respond_to?(:[])
-      #   foo&.dup&.inspect
+      #   do_something if attrs&.respond_to?(:[])
+      #
+      #   # good
+      #   do_something if attrs.respond_to?(:[])
+      #
+      #   # bad
+      #   while node&.is_a?(BeginNode)
+      #     node = node.parent
+      #   end
       #
       #   # good
-      #   attrs.respond_to?(:[])
-      #   foo.dup.inspect
+      #   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 IgnoredMethods
+        include AllowedMethods
         include RangeHelp
         extend AutoCorrector
 
         MSG = 'Redundant safe navigation detected.'
 
-        NIL_METHODS = nil.methods.to_set.freeze
+        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_method?(node.method_name)
+          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|
@@ -36,8 +59,18 @@ module RuboCop
 
         private
 
-        def check_method?(method_name)
-          NIL_METHODS.include?(method_name) && !ignored_method?(method_name)
+        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

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

@@ -140,11 +140,10 @@ module RuboCop
           rescued_groups.each_cons(2).all? do |x, y|
             if x.include?(Exception)
               false
-            elsif y.include?(Exception)
-              true
-            elsif x.none? || y.none?
-              # consider sorted if a group is empty or only contains
-              # `nil`s
+            elsif y.include?(Exception) ||
+                  # consider sorted if a group is empty or only contains
+                  # `nil`s
+                  x.none? || y.none?
               true
             else
               (x <=> y || 0) <= 0

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

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

@@ -31,7 +31,7 @@ module RuboCop
       class ToJSON < Base
         extend AutoCorrector
 
-        MSG = ' `#to_json` requires an optional argument to be parsable ' \
+        MSG = '`#to_json` requires an optional argument to be parsable ' \
           'via JSON.generate(obj).'
 
         def on_def(node)

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

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Looks for `reduce` or `inject` blocks where the value returned (implicitly or
+      # explicitly) does not include the accumulator. A block is considered valid as
+      # long as at least one return value includes the accumulator.
+      #
+      # If the accumulator is not included in the return value, then the entire
+      # block will just return a transformation of the last element value, and
+      # could be rewritten as such without a loop.
+      #
+      # Also catches instances where an index of the accumulator is returned, as
+      # this may change the type of object being retained.
+      #
+      # NOTE: For the purpose of reducing false positives, this cop only flags
+      # returns in `reduce` blocks where the element is the only variable in
+      # the expression (since we will not be able to tell what other variables
+      # relate to via static analysis).
+      #
+      # @example
+      #
+      #   # bad
+      #   (1..4).reduce(0) do |acc, el|
+      #     el * 2
+      #   end
+      #
+      #   # bad, may raise a NoMethodError after the first iteration
+      #   %w(a b c).reduce({}) do |acc, letter|
+      #     acc[letter] = true
+      #   end
+      #
+      #   # good
+      #   (1..4).reduce(0) do |acc, el|
+      #     acc + el * 2
+      #   end
+      #
+      #   # good, element is returned but modified using the accumulator
+      #   values.reduce do |acc, el|
+      #     el << acc
+      #     el
+      #   end
+      #
+      #   # good, returns the accumulator instead of the index
+      #   %w(a b c).reduce({}) do |acc, letter|
+      #     acc[letter] = true
+      #     acc
+      #   end
+      #
+      #   # good, at least one branch returns the accumulator
+      #   values.reduce(nil) do |result, value|
+      #     break result if something?
+      #     value
+      #   end
+      #
+      #   # ignored as the return value cannot be determined
+      #   enum.reduce do |acc, el|
+      #     x = foo(acc, el)
+      #     bar(x)
+      #   end
+      class UnmodifiedReduceAccumulator < Base
+        MSG = 'Ensure the accumulator `%<accum>s` will be modified by `%<method>s`.'
+        MSG_INDEX = 'Do not return an element of the accumulator in `%<method>s`.'
+
+        def_node_matcher :reduce_with_block?, <<~PATTERN
+          (block (send _recv {:reduce :inject} ...) (args arg+) ...)
+        PATTERN
+
+        def_node_matcher :accumulator_index?, <<~PATTERN
+          (send (lvar %1) {:[] :[]=} ...)
+        PATTERN
+
+        def_node_search :element_modified?, <<~PATTERN
+          {
+            (send _receiver !{:[] :[]=} <`(lvar %1) `_ ...>)               # method(el, ...)
+            (send (lvar %1) _message <{ivar gvar cvar lvar send} ...>)     # el.method(...)
+            (lvasgn %1 _)                                                  # el = ...
+            (%RuboCop::AST::Node::SHORTHAND_ASSIGNMENTS (lvasgn %1) ... _) # el += ...
+          }
+        PATTERN
+
+        def_node_matcher :lvar_used?, <<~PATTERN
+          {
+            (lvar %1)
+            (lvasgn %1 ...)
+            (send (lvar %1) :<< ...)
+            (dstr (begin (lvar %1)))
+            (%RuboCop::AST::Node::SHORTHAND_ASSIGNMENTS (lvasgn %1))
+          }
+        PATTERN
+
+        def_node_search :expression_values, <<~PATTERN
+          {
+            (%RuboCop::AST::Node::VARIABLES $_)
+            (%RuboCop::AST::Node::EQUALS_ASSIGNMENTS $_ ...)
+            (send (%RuboCop::AST::Node::VARIABLES $_) :<< ...)
+            $(send _ _)
+            (dstr (begin {(%RuboCop::AST::Node::VARIABLES $_)}))
+            (%RuboCop::AST::Node::SHORTHAND_ASSIGNMENTS (%RuboCop::AST::Node::EQUALS_ASSIGNMENTS $_) ...)
+          }
+        PATTERN
+
+        def on_block(node)
+          return unless reduce_with_block?(node)
+
+          check_return_values(node)
+        end
+
+        private
+
+        # Return values in a block are either the value given to next,
+        # the last line of a multiline block, or the only line of the block
+        def return_values(block_body_node)
+          nodes = [block_body_node.begin_type? ? block_body_node.child_nodes.last : block_body_node]
+
+          block_body_node.each_descendant(:next, :break) do |n|
+            # Ignore `next`/`break` inside an inner block
+            next if n.each_ancestor(:block).first != block_body_node.parent
+            next unless n.first_argument
+
+            nodes << n.first_argument
+          end
+
+          nodes
+        end
+
+        def check_return_values(block_node)
+          return_values = return_values(block_node.body)
+          accumulator_name = block_arg_name(block_node, 0)
+          element_name = block_arg_name(block_node, 1)
+          message_opts = { method: block_node.method_name, accum: accumulator_name }
+
+          if (node = returned_accumulator_index(return_values, accumulator_name))
+            add_offense(node, message: format(MSG_INDEX, message_opts))
+          elsif potential_offense?(return_values, block_node.body, element_name, accumulator_name)
+            return_values.each do |return_val|
+              unless acceptable_return?(return_val, element_name)
+                add_offense(return_val, message: format(MSG, message_opts))
+              end
+            end
+          end
+        end
+
+        def block_arg_name(node, index)
+          node.arguments[index].node_parts[0]
+        end
+
+        # Look for an index of the accumulator being returned
+        # This is always an offense, in order to try to catch potential exceptions
+        # due to type mismatches
+        def returned_accumulator_index(return_values, accumulator_name)
+          return_values.detect { |val| accumulator_index?(val, accumulator_name) }
+        end
+
+        def potential_offense?(return_values, block_body, element_name, accumulator_name)
+          !(element_modified?(block_body, element_name) ||
+            returns_accumulator_anywhere?(return_values, accumulator_name))
+        end
+
+        # If the accumulator is used in any return value, the node is acceptable since
+        # the accumulator has a chance to change each iteration
+        def returns_accumulator_anywhere?(return_values, accumulator_name)
+          return_values.any? { |node| lvar_used?(node, accumulator_name) }
+        end
+
+        # Determine if a return value is acceptable for the purposes of this cop
+        # If it is an expression containing the accumulator, it is acceptable
+        # Otherwise, it is only unacceptable if it contains the iterated element, since we
+        # otherwise do not have enough information to prevent false positives.
+        def acceptable_return?(return_val, element_name)
+          vars = expression_values(return_val).uniq
+          return true if vars.none? || (vars - [element_name]).any?
+
+          false
+        end
+
+        # Exclude `begin` nodes inside a `dstr` from being collected by `return_values`
+        def allowed_type?(parent_node)
+          !parent_node.dstr_type?
+        end
+      end
+    end
+  end
+end