rubocop 0.82.0 → 1.18.4

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for "triple quotes" (strings delimted by any odd number
+      # of quotes greater than 1).
+      #
+      # Ruby allows multiple strings to be implicitly concatenated by just
+      # being adjacent in a statement (ie. `"foo""bar" == "foobar"`). This sometimes
+      # gives the impression that there is something special about triple quotes, but
+      # in fact it is just extra unnecessary quotes and produces the same string. Each
+      # pair of quotes produces an additional concatenated empty string, so the result
+      # is still only the "actual" string within the delimiters.
+      #
+      # NOTE: Although this cop is called triple quotes, the same behavior is present
+      # for strings delimited by 5, 7, etc. quotation marks.
+      #
+      # @example
+      #   # bad
+      #   """
+      #     A string
+      #   """
+      #
+      #   # bad
+      #   '''
+      #     A string
+      #   '''
+      #
+      #   # good
+      #   "
+      #     A string
+      #   "
+      #
+      #   # good
+      #   <<STRING
+      #     A string
+      #   STRING
+      #
+      #   # good (but not the same spacing as the bad case)
+      #   'A string'
+      class TripleQuotes < Base
+        extend AutoCorrector
+
+        MSG = 'Delimiting a string with multiple quotes has no effect, use a single quote instead.'
+
+        def on_dstr(node)
+          return if (empty_str_nodes = empty_str_nodes(node)).none?
+
+          opening_quotes = node.source.scan(/(?<=\A)['"]*/)[0]
+          return if opening_quotes.size < 3
+
+          # If the node is composed of only empty `str` nodes, keep one
+          empty_str_nodes.shift if empty_str_nodes.size == node.child_nodes.size
+
+          add_offense(node) do |corrector|
+            empty_str_nodes.each do |str|
+              corrector.remove(str)
+            end
+          end
+        end
+
+        private
+
+        def empty_str_nodes(node)
+          node.each_child_node(:str).select { |str| str.value == '' }
+        end
+      end
+    end
+  end
+end

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

@@ -40,17 +40,15 @@ module RuboCop
       #     {_id: _id, profit: revenue - cost}
       #   end
       #
-      class UnderscorePrefixedVariableName < Cop
+      class UnderscorePrefixedVariableName < Base
         MSG = 'Do not use prefix `_` for a variable that is used.'
 
-        def join_force?(force_class)
-          force_class == VariableForce
+        def self.joining_forces
+          VariableForce
         end
 
         def after_leaving_scope(scope, _variable_table)
-          scope.variables.each_value do |variable|
-            check_variable(variable)
-          end
+          scope.variables.each_value { |variable| check_variable(variable) }
         end
 
         def check_variable(variable)
@@ -66,7 +64,7 @@ module RuboCop
                        node.loc.name
                      end
 
-          add_offense(nil, location: location)
+          add_offense(location)
         end
 
         private

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for a block that is known to need more positional
+      # block arguments than are given (by default this is configured for
+      # `Enumerable` methods needing 2 arguments). Optional arguments are allowed,
+      # although they don't generally make sense as the default value will
+      # be used. Blocks that have no receiver, or take splatted arguments
+      # (ie. `*args`) are always accepted.
+      #
+      # Keyword arguments (including `**kwargs`) do not get counted towards
+      # this, as they are not used by the methods in question.
+      #
+      # NOTE: This cop matches for method names only and hence cannot tell apart
+      # methods with same name in different classes.
+      #
+      # Method names and their expected arity can be configured like this:
+      #
+      # Methods:
+      #   inject: 2
+      #   reduce: 2
+      #
+      # @example
+      #   # bad
+      #   values.reduce {}
+      #   values.min { |a| a }
+      #   values.sort { |a; b| a + b }
+      #
+      #   # good
+      #   values.reduce { |memo, obj| memo << obj }
+      #   values.min { |a, b| a <=> b }
+      #   values.sort { |*x| x[0] <=> x[1] }
+      #
+      class UnexpectedBlockArity < Base
+        MSG = '`%<method>s` expects at least %<expected>i positional arguments, got %<actual>i.'
+
+        def on_block(node)
+          return if acceptable?(node)
+
+          expected = expected_arity(node.method_name)
+          actual = arg_count(node)
+          return if actual >= expected
+
+          message = format(MSG, method: node.method_name, expected: expected, actual: actual)
+          add_offense(node, message: message)
+        end
+
+        alias on_numblock on_block
+
+        private
+
+        def methods
+          cop_config.fetch('Methods', [])
+        end
+
+        def acceptable?(node)
+          !(included_method?(node.method_name) && node.receiver)
+        end
+
+        def included_method?(name)
+          methods.key?(name.to_s)
+        end
+
+        def expected_arity(method)
+          cop_config['Methods'][method.to_s]
+        end
+
+        def arg_count(node)
+          return node.children[1] if node.numblock_type? # the maximum numbered param for the block
+
+          # Only `arg`, `optarg` and `mlhs` (destructuring) count as arguments that
+          # can be used. Keyword arguments are not used for these methods so are
+          # ignored.
+          node.arguments.count do |arg|
+            return Float::INFINITY if arg.restarg_type?
+
+            arg.arg_type? || arg.optarg_type? || arg.mlhs_type?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -17,9 +17,12 @@ module RuboCop
       #   # good
       #
       #   1.is_a?(Integer)
-      class UnifiedInteger < Cop
+      class UnifiedInteger < Base
+        extend AutoCorrector
+
         MSG = 'Use `Integer` instead of `%<klass>s`.'
 
+        # @!method fixnum_or_bignum_const(node)
         def_node_matcher :fixnum_or_bignum_const, <<~PATTERN
           (:const {nil? (:cbase)} ${:Fixnum :Bignum})
         PATTERN
@@ -29,11 +32,7 @@ module RuboCop
 
           return unless klass
 
-          add_offense(node, message: format(MSG, klass: klass))
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(node, message: format(MSG, klass: klass)) do |corrector|
             corrector.replace(node.loc.name, 'Integer')
           end
         end

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

@@ -0,0 +1,204 @@
+# 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
+      #
+      #   # good, recursive
+      #   keys.reduce(self) { |result, key| result[key] }
+      #
+      #   # 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`.'
+
+        # @!method reduce_with_block?(node)
+        def_node_matcher :reduce_with_block?, <<~PATTERN
+          {
+            (block (send _recv {:reduce :inject} ...) args ...)
+            (numblock (send _recv {:reduce :inject} ...) ...)
+          }
+        PATTERN
+
+        # @!method accumulator_index?(node, accumulator_name)
+        def_node_matcher :accumulator_index?, <<~PATTERN
+          (send (lvar %1) {:[] :[]=} ...)
+        PATTERN
+
+        # @!method element_modified?(node, element_name)
+        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
+
+        # @!method lvar_used?(node, name)
+        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
+
+        # @!method expression_values(node)
+        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)
+          return unless node.argument_list.length >= 2
+
+          check_return_values(node)
+        end
+        alias on_numblock on_block
+
+        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, element_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.argument_list[index].name
+        end
+
+        # Look for an index of the accumulator being returned, except where the index
+        # is the element.
+        # 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, element_name)
+          return_values.detect do |val|
+            next unless accumulator_index?(val, accumulator_name)
+            next true if val.method?(:[]=)
+
+            val.arguments.none? { |arg| lvar_used?(arg, element_name) }
+          end
+        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

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

@@ -5,7 +5,7 @@ module RuboCop
     module Lint
       # This cop checks for unreachable code.
       # The check are based on the presence of flow of control
-      # statement in non-final position in *begin*(implicit) blocks.
+      # statement in non-final position in `begin` (implicit) blocks.
       #
       # @example
       #
@@ -34,7 +34,7 @@ module RuboCop
       #   def some_method
       #     do_something
       #   end
-      class UnreachableCode < Cop
+      class UnreachableCode < Base
         MSG = 'Unreachable code detected.'
 
         def on_begin(node)
@@ -51,6 +51,7 @@ module RuboCop
 
         private
 
+        # @!method flow_command?(node)
         def_node_matcher :flow_command?, <<~PATTERN
           {
             return next break retry redo
@@ -80,8 +81,7 @@ module RuboCop
         def check_if(node)
           if_branch = node.if_branch
           else_branch = node.else_branch
-          if_branch && else_branch &&
-            flow_expression?(if_branch) && flow_expression?(else_branch)
+          if_branch && else_branch && flow_expression?(if_branch) && flow_expression?(else_branch)
         end
 
         def check_case(node)
@@ -89,9 +89,7 @@ module RuboCop
           return false unless else_branch
           return false unless flow_expression?(else_branch)
 
-          node.when_branches.all? do |branch|
-            branch.body && flow_expression?(branch.body)
-          end
+          node.when_branches.all? { |branch| branch.body && flow_expression?(branch.body) }
         end
       end
     end