rubocop 1.3.0 → 1.5.0

data/lib/rubocop/cop/layout/space_around_method_call_operator.rb

@@ -51,7 +51,7 @@ module RuboCop
         alias on_csend on_send
 
         def on_const(node)
-          return unless node.loc.double_colon
+          return unless node.loc.respond_to?(:double_colon) && node.loc.double_colon
 
           check_space_after_double_colon(node)
         end

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

@@ -53,7 +53,8 @@ module RuboCop
         def find_offense_node(node, regexp_receiver)
           return node unless node.parent
 
-          if node.parent.send_type? || method_chain_to_regexp_receiver?(node, regexp_receiver)
+          if (node.parent.send_type? && node.receiver) ||
+             method_chain_to_regexp_receiver?(node, regexp_receiver)
             node = find_offense_node(node.parent, regexp_receiver)
           end
 

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

@@ -50,8 +50,11 @@ module RuboCop
       #     end
       #   end
       #
-      # @example AllowedMethods: ['enums']
+      # @example AllowedMethods: ['enums'] (default)
       #   # good
+      #
+      #   # `enums` for Typed Enums via `T::Enum` in Sorbet.
+      #   # https://sorbet.org/docs/tenum
       #   class TestEnum < T::Enum
       #     enums do
       #       Foo = new("foo")

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

@@ -95,7 +95,7 @@ module RuboCop
         def autocorrected_value_for_array(node)
           return node.source.gsub('"', '\"') unless node.percent_literal?
 
-          contents_range(node).source.split(' ').to_s.gsub('"', '\"')
+          contents_range(node).source.split.to_s.gsub('"', '\"')
         end
 
         # Does node print its own source when converted to a string?

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

@@ -6,6 +6,11 @@ module RuboCop
       # This cop checks for the presence of constructors and lifecycle callbacks
       # without calls to `super`.
       #
+      # This cop does not consider `method_missing` (and `respond_to_missing?`)
+      # because in some cases it makes sense to overtake what is considered a
+      # missing method. In other cases, the theoretical ideal handling could be
+      # challenging or verbose for no actual gain.
+      #
       # @example
       #   # bad
       #   class Employee < Person
@@ -43,15 +48,13 @@ module RuboCop
 
         STATELESS_CLASSES = %w[BasicObject Object].freeze
 
-        OBJECT_LIFECYCLE_CALLBACKS  = %i[method_missing respond_to_missing?].freeze
         CLASS_LIFECYCLE_CALLBACKS   = %i[inherited].freeze
         METHOD_LIFECYCLE_CALLBACKS  = %i[method_added method_removed method_undefined
                                          singleton_method_added singleton_method_removed
                                          singleton_method_undefined].freeze
 
-        CALLBACKS = (OBJECT_LIFECYCLE_CALLBACKS +
-                      CLASS_LIFECYCLE_CALLBACKS +
-                      METHOD_LIFECYCLE_CALLBACKS).to_set.freeze
+        CALLBACKS = (CLASS_LIFECYCLE_CALLBACKS +
+                     METHOD_LIFECYCLE_CALLBACKS).to_set.freeze
 
         def on_def(node)
           return unless offender?(node)

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

@@ -40,7 +40,7 @@ module RuboCop
       #                     do_something
       #                   end
       #
-      class NoReturnInBeginEndBlocks < Cop
+      class NoReturnInBeginEndBlocks < Base
         MSG = 'Do not `return` in `begin..end` blocks in assignment contexts.'
 
         def on_lvasgn(node)

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

@@ -8,23 +8,14 @@ module RuboCop
       #
       # @example
       #   # bad
-      #   def method(x, y = 1)
-      #     return to_enum(__method__, x) # `y` is missing
+      #   def foo(x, y = 1)
+      #     return to_enum(__callee__, 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)
+      #   def foo(x, y = 1)
+      #     return to_enum(__callee__, x, y)
+      #     # alternatives to `__callee__` are `__method__` and `:foo`
       #   end
       #
       class ToEnumArguments < Base
@@ -37,7 +28,7 @@ module RuboCop
         PATTERN
 
         def_node_matcher :method_name?, <<~PATTERN
-          {(send nil? :__method__) (sym %1)}
+          {(send nil? {:__method__ :__callee__}) (sym %1)}
         PATTERN
 
         def_node_matcher :passing_keyword_arg?, <<~PATTERN

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

@@ -54,6 +54,9 @@ module RuboCop
       #     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)
@@ -64,7 +67,10 @@ module RuboCop
         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+) ...)
+          {
+            (block (send _recv {:reduce :inject} ...) args ...)
+            (numblock (send _recv {:reduce :inject} ...) ...)
+          }
         PATTERN
 
         def_node_matcher :accumulator_index?, <<~PATTERN
@@ -103,9 +109,11 @@ module RuboCop
 
         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
 
@@ -131,7 +139,7 @@ module RuboCop
           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))
+          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|
@@ -143,14 +151,20 @@ module RuboCop
         end
 
         def block_arg_name(node, index)
-          node.arguments[index].node_parts[0]
+          node.argument_list[index].name
         end
 
-        # Look for an index of the accumulator being returned
+        # 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)
-          return_values.detect { |val| accumulator_index?(val, accumulator_name) }
+        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)

data/lib/rubocop/cop/metrics/abc_size.rb

@@ -7,6 +7,27 @@ module RuboCop
       # configured maximum. The ABC size is based on assignments, branches
       # (method calls), and conditions. See http://c2.com/cgi/wiki?AbcMetric
       # and https://en.wikipedia.org/wiki/ABC_Software_Metric.
+      #
+      # You can have repeated "attributes" calls count as a single "branch".
+      # For this purpose, attributes are any method with no argument; no attempt
+      # is meant to distinguish actual `attr_reader` from other methods.
+      #
+      # @example CountRepeatedAttributes: false (default is true)
+      #
+      #    # `model` and `current_user`, refenced 3 times each,
+      #    # are each counted as only 1 branch each if
+      #    # `CountRepeatedAttributes` is set to 'false'
+      #
+      #    def search
+      #      @posts = model.active.visible_by(current_user)
+      #                .search(params[:q])
+      #      @posts = model.some_process(@posts, current_user)
+      #      @posts = model.another_process(@posts, current_user)
+      #
+      #      render 'pages/search/page'
+      #    end
+      #
+      # This cop also takes into account `IgnoredMethods` (defaults to `[]`)
       class AbcSize < Base
         include MethodComplexity
 
@@ -16,7 +37,10 @@ module RuboCop
         private
 
         def complexity(node)
-          Utils::AbcSizeCalculator.calculate(node)
+          Utils::AbcSizeCalculator.calculate(
+            node,
+            discount_repeated_attributes: !cop_config['CountRepeatedAttributes']
+          )
         end
       end
     end

data/lib/rubocop/cop/metrics/block_length.rb

@@ -12,6 +12,10 @@ module RuboCop
       # Available are: 'array', 'hash', and 'heredoc'. Each literal
       # will be counted as one line regardless of its actual size.
       #
+      #
+      # NOTE: The `ExcludedMethods` configuration is deprecated and only kept
+      # for backwards compatibility. Please use `IgnoredMethods` instead.
+      #
       # @example CountAsOne: ['array', 'heredoc']
       #
       #   something do
@@ -33,11 +37,15 @@ module RuboCop
       # NOTE: This cop does not apply for `Struct` definitions.
       class BlockLength < Base
         include CodeLength
+        include IgnoredMethods
+
+        ignored_methods deprecated_key: 'ExcludedMethods'
 
         LABEL = 'Block'
 
         def on_block(node)
-          return if excluded_method?(node)
+          return if ignored_method?(node.method_name)
+          return if method_receiver_excluded?(node)
           return if node.class_constructor? || node.struct_constructor?
 
           check_code_length(node)
@@ -45,11 +53,13 @@ module RuboCop
 
         private
 
-        def excluded_method?(node)
+        def method_receiver_excluded?(node)
           node_receiver = node.receiver&.source&.gsub(/\s+/, '')
           node_method = String(node.method_name)
 
-          excluded_methods.any? do |config|
+          ignored_methods.any? do |config|
+            next unless config.is_a?(String)
+
             receiver, method = config.split('.')
 
             unless method
@@ -61,10 +71,6 @@ module RuboCop
           end
         end
 
-        def excluded_methods
-          cop_config['ExcludedMethods'] || []
-        end
-
         def cop_label
           LABEL
         end

data/lib/rubocop/cop/metrics/method_length.rb

@@ -11,6 +11,9 @@ module RuboCop
       # Available are: 'array', 'hash', and 'heredoc'. Each literal
       # will be counted as one line regardless of its actual size.
       #
+      # NOTE: The `ExcludedMethods` configuration is deprecated and only kept
+      # for backwards compatibility. Please use `IgnoredMethods` instead.
+      #
       # @example CountAsOne: ['array', 'heredoc']
       #
       #   def m
@@ -31,12 +34,14 @@ module RuboCop
       #
       class MethodLength < Base
         include CodeLength
+        include IgnoredMethods
+
+        ignored_methods deprecated_key: 'ExcludedMethods'
 
         LABEL = 'Method'
 
         def on_def(node)
-          excluded_methods = cop_config['ExcludedMethods']
-          return if excluded_methods.include?(String(node.method_name))
+          return if ignored_method?(node.method_name)
 
           check_code_length(node)
         end

data/lib/rubocop/cop/metrics/parameter_lists.rb

@@ -4,17 +4,76 @@ module RuboCop
   module Cop
     module Metrics
       # This cop checks for methods with too many parameters.
+      #
       # The maximum number of parameters is configurable.
-      # Keyword arguments can optionally be excluded from the total count.
+      # Keyword arguments can optionally be excluded from the total count,
+      # as they add less complexity than positional or optional parameters.
+      #
+      # @example Max: 3
+      #   # good
+      #   def foo(a, b, c = 1)
+      #   end
+      #
+      # @example Max: 2
+      #   # bad
+      #   def foo(a, b, c = 1)
+      #   end
+      #
+      # @example CountKeywordArgs: true (default)
+      #   # counts keyword args towards the maximum
+      #
+      #   # bad (assuming Max is 3)
+      #   def foo(a, b, c, d: 1)
+      #   end
+      #
+      #   # good (assuming Max is 3)
+      #   def foo(a, b, c: 1)
+      #   end
+      #
+      # @example CountKeywordArgs: false
+      #   # don't count keyword args towards the maximum
+      #
+      #   # good (assuming Max is 3)
+      #   def foo(a, b, c, d: 1)
+      #   end
+      #
+      # This cop also checks for the maximum number of optional parameters.
+      # This can be configured using the `MaxOptionalParameters` config option.
+      #
+      # @example MaxOptionalParameters: 3 (default)
+      #   # good
+      #   def foo(a = 1, b = 2, c = 3)
+      #   end
+      #
+      # @example MaxOptionalParameters: 2
+      #   # bad
+      #   def foo(a = 1, b = 2, c = 3)
+      #   end
+      #
       class ParameterLists < Base
         include ConfigurableMax
 
         MSG = 'Avoid parameter lists longer than %<max>d parameters. ' \
               '[%<count>d/%<max>d]'
+        OPTIONAL_PARAMETERS_MSG = 'Method has too many optional parameters. [%<count>d/%<max>d]'
 
         NAMED_KEYWORD_TYPES = %i[kwoptarg kwarg].freeze
         private_constant :NAMED_KEYWORD_TYPES
 
+        def on_def(node)
+          optargs = node.arguments.select(&:optarg_type?)
+          return if optargs.count <= max_optional_parameters
+
+          message = format(
+            OPTIONAL_PARAMETERS_MSG,
+            max: max_optional_parameters,
+            count: optargs.count
+          )
+
+          add_offense(node, message: message)
+        end
+        alias on_defs on_def
+
         def on_args(node)
           count = args_count(node)
           return unless count > max_params
@@ -44,6 +103,10 @@ module RuboCop
           cop_config['Max']
         end
 
+        def max_optional_parameters
+          cop_config['MaxOptionalParameters']
+        end
+
         def count_keyword_args?
           cop_config['CountKeywordArgs']
         end