rubocop 1.24.1 → 1.64.1

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

@@ -7,12 +7,15 @@ module RuboCop
       #
       # If you prefer a style that allows block for method with arguments,
       # please set `true` to `AllowMethodsWithArguments`.
+      # `define_method?` methods are allowed by default.
+      # These are customizable with `AllowedMethods` option.
       #
       # @safety
-      #   This cop is unsafe because `proc`s and blocks work differently
-      #   when additional arguments are passed in. A block will silently
-      #   ignore additional arguments, but a `proc` will raise
-      #   an `ArgumentError`.
+      #   This cop is unsafe because there is a difference that a `Proc`
+      #   generated from `Symbol#to_proc` behaves as a lambda, while
+      #   a `Proc` generated from a block does not.
+      #   For example, a lambda will raise an `ArgumentError` if the
+      #   number of arguments is wrong, but a non-lambda `Proc` will not.
       #
       #   For example:
       #
@@ -34,6 +37,42 @@ module RuboCop
       #   # ArgumentError: wrong number of arguments (given 1, expected 0)
       #   ----
       #
+      #   It is also unsafe because `Symbol#to_proc` does not work with
+      #   `protected` methods which would otherwise be accessible.
+      #
+      #   For example:
+      #
+      #   [source,ruby]
+      #   ----
+      #   class Box
+      #     def initialize
+      #       @secret = rand
+      #     end
+      #
+      #     def normal_matches?(*others)
+      #       others.map { |other| other.secret }.any?(secret)
+      #     end
+      #
+      #     def symbol_to_proc_matches?(*others)
+      #       others.map(&:secret).any?(secret)
+      #     end
+      #
+      #     protected
+      #
+      #     attr_reader :secret
+      #   end
+      #
+      #   boxes = [Box.new, Box.new]
+      #   Box.new.normal_matches?(*boxes)
+      #   # => false
+      #   boxes.first.normal_matches?(*boxes)
+      #   # => true
+      #   Box.new.symbol_to_proc_matches?(*boxes)
+      #   # => NoMethodError: protected method `secret' called for #<Box...>
+      #   boxes.first.symbol_to_proc_matches?(*boxes)
+      #   # => NoMethodError: protected method `secret' called for #<Box...>
+      #   ----
+      #
       # @example
       #   # bad
       #   something.map { |s| s.upcase }
@@ -52,19 +91,68 @@ module RuboCop
       # @example AllowMethodsWithArguments: true
       #   # good
       #   something.do_something(foo) { |o| o.bar }
+      #
+      # @example AllowComments: false (default)
+      #   # bad
+      #   something.do_something do |s| # some comment
+      #     # some comment
+      #     s.upcase # some comment
+      #     # some comment
+      #   end
+      #
+      # @example AllowComments: true
+      #   # good  - if there are comment in either position
+      #   something.do_something do |s| # some comment
+      #     # some comment
+      #     s.upcase # some comment
+      #     # some comment
+      #   end
+      #
+      # @example AllowedMethods: [define_method] (default)
+      #   # good
+      #   define_method(:foo) { |foo| foo.bar }
+      #
+      # @example AllowedPatterns: [] (default)
+      #   # bad
+      #   something.map { |s| s.upcase }
+      #
+      # @example AllowedPatterns: ['map'] (default)
+      #   # good
+      #   something.map { |s| s.upcase }
+      #
+      # @example AllCops:ActiveSupportExtensionsEnabled: false (default)
+      #   # bad
+      #   ->(x) { x.foo }
+      #   proc { |x| x.foo }
+      #   Proc.new { |x| x.foo }
+      #
+      #   # good
+      #   lambda(&:foo)
+      #   proc(&:foo)
+      #   Proc.new(&:foo)
+      #
+      # @example AllCops:ActiveSupportExtensionsEnabled: true
+      #   # good
+      #   ->(x) { x.foo }
+      #   proc { |x| x.foo }
+      #   Proc.new { |x| x.foo }
+      #
       class SymbolProc < Base
+        include CommentsHelp
         include RangeHelp
-        include IgnoredMethods
+        include AllowedMethods
+        include AllowedPattern
         extend AutoCorrector
 
         MSG = 'Pass `&:%<method>s` as an argument to `%<block_method>s` instead of a block.'
         SUPER_TYPES = %i[super zsuper].freeze
+        LAMBDA_OR_PROC = %i[lambda proc].freeze
 
         # @!method proc_node?(node)
         def_node_matcher :proc_node?, '(send (const {nil? cbase} :Proc) :new)'
 
         # @!method symbol_proc_receiver?(node)
-        def_node_matcher :symbol_proc_receiver?, '{(send ...) (super ...) zsuper}'
+        def_node_matcher :symbol_proc_receiver?, '{(call ...) (super ...) zsuper}'
 
         # @!method symbol_proc?(node)
         def_node_matcher :symbol_proc?, <<~PATTERN
@@ -78,20 +166,24 @@ module RuboCop
           [Layout::SpaceBeforeBlockBraces]
         end
 
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_block(node)
           symbol_proc?(node) do |dispatch_node, arguments_node, method_name|
-            # TODO: Rails-specific handling that we should probably make
-            # configurable - https://github.com/rubocop/rubocop/issues/1485
-            # we should ignore lambdas & procs
-            return if proc_node?(dispatch_node)
-            return if %i[lambda proc].include?(dispatch_node.method_name)
-            return if ignored_method?(dispatch_node.method_name)
-            return if allow_if_method_has_argument?(node)
+            if active_support_extensions_enabled?
+              return if proc_node?(dispatch_node)
+              return if LAMBDA_OR_PROC.include?(dispatch_node.method_name)
+            end
+            return if unsafe_hash_usage?(dispatch_node)
+            return if unsafe_array_usage?(dispatch_node)
+            return if allowed_method_name?(dispatch_node.method_name)
+            return if allow_if_method_has_argument?(node.send_node)
             return if node.block_type? && destructuring_block_argument?(arguments_node)
+            return if allow_comments? && contains_comments?(node)
 
             register_offense(node, method_name, dispatch_node.method_name)
           end
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         alias on_numblock on_block
 
         def destructuring_block_argument?(argument_node)
@@ -100,6 +192,19 @@ module RuboCop
 
         private
 
+        # See: https://github.com/rubocop/rubocop/issues/10864
+        def unsafe_hash_usage?(node)
+          node.receiver&.hash_type? && %i[reject select].include?(node.method_name)
+        end
+
+        def unsafe_array_usage?(node)
+          node.receiver&.array_type? && %i[min max].include?(node.method_name)
+        end
+
+        def allowed_method_name?(name)
+          allowed_method?(name) || matches_allowed_pattern?(name)
+        end
+
         def register_offense(node, method_name, block_method_name)
           block_start = node.loc.begin.begin_pos
           block_end = node.loc.end.end_pos
@@ -118,6 +223,8 @@ module RuboCop
         end
 
         def autocorrect_without_args(corrector, node)
+          autocorrect_lambda_block(corrector, node) if node.send_node.lambda_literal?
+
           corrector.replace(block_range_with_space(node), "(&:#{node.body.method_name})")
         end
 
@@ -130,9 +237,17 @@ module RuboCop
           corrector.remove(block_range_with_space(node))
         end
 
+        def autocorrect_lambda_block(corrector, node)
+          send_node_loc = node.send_node.loc
+          corrector.replace(send_node_loc.selector, 'lambda')
+
+          range = range_between(send_node_loc.selector.end_pos, node.loc.begin.end_pos - 2)
+          corrector.remove(range)
+        end
+
         def block_range_with_space(node)
           block_range = range_between(begin_pos_for_replacement(node), node.loc.end.end_pos)
-          range_with_surrounding_space(range: block_range, side: :left)
+          range_with_surrounding_space(block_range, side: :left)
         end
 
         def begin_pos_for_replacement(node)
@@ -145,8 +260,12 @@ module RuboCop
           end
         end
 
-        def allow_if_method_has_argument?(node)
-          !!cop_config.fetch('AllowMethodsWithArguments', false) && !node.arguments.count.zero?
+        def allow_if_method_has_argument?(send_node)
+          !!cop_config.fetch('AllowMethodsWithArguments', false) && !send_node.arguments.count.zero?
+        end
+
+        def allow_comments?
+          cop_config.fetch('AllowComments', false)
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for the presence of parentheses around ternary
+      # Checks for the presence of parentheses around ternary
       # conditions. It is configurable to enforce inclusion or omission of
       # parentheses using `EnforcedStyle`. Omission is only enforced when
       # removing the parentheses won't cause a different behavior.
@@ -67,8 +67,11 @@ module RuboCop
         MSG_COMPLEX = '%<command>s parentheses for ternary expressions with complex conditions.'
 
         def on_if(node)
-          return if only_closing_parenthesis_is_last_line?(node.condition)
-          return unless node.ternary? && !infinite_loop? && offense?(node)
+          condition = node.condition
+
+          return if only_closing_parenthesis_is_last_line?(condition)
+          return if condition_as_parenthesized_one_line_pattern_matching?(condition)
+          return unless node.ternary? && offense?(node)
 
           message = message(node)
 
@@ -77,11 +80,22 @@ module RuboCop
           end
         end
 
+        private
+
         def only_closing_parenthesis_is_last_line?(condition)
           condition.source.split("\n").last == ')'
         end
 
-        private
+        def condition_as_parenthesized_one_line_pattern_matching?(condition)
+          return false unless condition.parenthesized_call?
+          return false unless (first_child = condition.children.first)
+
+          if target_ruby_version >= 3.0
+            first_child.match_pattern_p_type?
+          else
+            first_child.match_pattern_type? # For Ruby 2.7's one line pattern matching AST.
+          end
+        end
 
         def autocorrect(corrector, node)
           condition = node.condition
@@ -152,26 +166,13 @@ module RuboCop
           style == :require_parentheses_when_complex
         end
 
-        def redundant_parentheses_enabled?
-          @config.for_cop('Style/RedundantParentheses').fetch('Enabled')
-        end
-
         def parenthesized?(node)
           node.begin_type?
         end
 
-        # When this cop is configured to enforce parentheses and the
-        # `RedundantParentheses` cop is enabled, it will cause an infinite loop
-        # as they compete to add and remove the parentheses respectively.
-        def infinite_loop?
-          (require_parentheses? || require_parentheses_when_complex?) &&
-            redundant_parentheses_enabled?
-        end
-
         def unsafe_autocorrect?(condition)
           condition.children.any? do |child|
-            unparenthesized_method_call?(child) ||
-              below_ternary_precedence?(child)
+            unparenthesized_method_call?(child) || below_ternary_precedence?(child)
           end
         end
 

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

@@ -63,6 +63,8 @@ module RuboCop
           add_offense(node)
         end
 
+        alias on_numblock on_block
+
         private
 
         def top_level_method_definition?(node)
@@ -75,7 +77,7 @@ module RuboCop
 
         # @!method define_method_block?(node)
         def_node_matcher :define_method_block?, <<~PATTERN
-          (block (send _ {:define_method} _) ...)
+          ({block numblock} (send _ :define_method _) ...)
         PATTERN
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for trailing code after the class definition.
+      # Checks for trailing code after the class definition.
       #
       # @example
       #   # bad
@@ -34,6 +34,7 @@ module RuboCop
             )
           end
         end
+        alias on_sclass on_class
       end
     end
   end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for trailing code after the method definition.
+      # Checks for trailing code after the method definition.
       #
       # NOTE: It always accepts endless method definitions that are basically on the same line.
       #

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for trailing code after the module definition.
+      # Checks for trailing code after the module definition.
       #
       # @example
       #   # bad

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for trailing comma in argument lists.
+      # Checks for trailing comma in argument lists.
       # The supported styles are:
       #
       # * `consistent_comma`: Requires a comma after the last argument,
@@ -88,6 +88,10 @@ module RuboCop
         include TrailingComma
         extend AutoCorrector
 
+        def self.autocorrect_incompatible_with
+          [Layout::HeredocArgumentClosingParenthesis]
+        end
+
         def on_send(node)
           return unless node.arguments? && node.parenthesized?
 
@@ -96,10 +100,6 @@ module RuboCop
                 node.source_range.end_pos)
         end
         alias on_csend on_send
-
-        def self.autocorrect_incompatible_with
-          [Layout::HeredocArgumentClosingParenthesis]
-        end
       end
     end
   end

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

@@ -3,14 +3,14 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for trailing comma in array literals.
+      # Checks for trailing comma in array literals.
       # The configuration options are:
       #
       # * `consistent_comma`: Requires a comma after the
       # last item of all non-empty, multiline array literals.
       # * `comma`: Requires a comma after last item in an array,
       # but only when each item is on its own line.
-      # * `no_comma`: Does not requires a comma after the
+      # * `no_comma`: Does not require a comma after the
       # last item in an array
       #
       # @example EnforcedStyleForMultiline: consistent_comma

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks whether trailing commas in block arguments are
+      # Checks whether trailing commas in block arguments are
       # required. Blocks with only one argument and a trailing comma require
       # that comma to be present. Blocks with more than one argument never
       # require a trailing comma.
@@ -64,7 +64,7 @@ module RuboCop
 
         MSG = 'Useless trailing comma present in block arguments.'
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           # lambda literal (`->`) never has block arguments.
           return if node.send_node.lambda_literal?
           return unless useless_trailing_comma?(node)

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

@@ -3,14 +3,14 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for trailing comma in hash literals.
+      # Checks for trailing comma in hash literals.
       # The configuration options are:
       #
       # * `consistent_comma`: Requires a comma after the
       # last item of all non-empty, multiline hash literals.
       # * `comma`: Requires a comma after the last item in a hash,
       # but only when each item is on its own line.
-      # * `no_comma`: Does not requires a comma after the
+      # * `no_comma`: Does not require a comma after the
       # last item in a hash
       #
       # @example EnforcedStyleForMultiline: consistent_comma

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for trailing code after the method definition.
+      # Checks for trailing code after the method definition.
       #
       # @example
       #   # bad
@@ -42,10 +42,7 @@ module RuboCop
           return if node.endless? || !trailing_end?(node)
 
           add_offense(node.loc.end) do |corrector|
-            corrector.insert_before(
-              node.loc.end,
-              "\n#{' ' * node.loc.keyword.column}"
-            )
+            corrector.insert_before(node.loc.end, "\n#{' ' * node.loc.keyword.column}")
           end
         end
 

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for extra underscores in variable assignment.
+      # Checks for extra underscores in variable assignment.
       #
       # @example
       #   # bad
@@ -144,7 +144,7 @@ module RuboCop
         end
 
         def range_for_parentheses(offense, left)
-          range_between(offense.source_range.begin_pos - 1, left.loc.expression.end_pos - 1)
+          range_between(offense.source_range.begin_pos - 1, left.source_range.end_pos - 1)
         end
       end
     end

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

@@ -3,8 +3,11 @@
 module RuboCop
   module Cop
     module Style
-      # This cop looks for trivial reader/writer methods, that could
+      # Looks for trivial reader/writer methods, that could
       # have been created with the attr_* family of functions automatically.
+      # `to_ary`, `to_a`, `to_c`, `to_enum`, `to_h`, `to_hash`, `to_i`, `to_int`, `to_io`,
+      # `to_open`, `to_path`, `to_proc`, `to_r`, `to_regexp`, `to_str`, `to_s`, and `to_sym` methods
+      # are allowed by default. These are customizable with `AllowedMethods` option.
       #
       # @example
       #   # bad
@@ -167,8 +170,8 @@ module RuboCop
           allowed_methods.map(&:to_sym) + [:initialize]
         end
 
-        def dsl_writer?(method_name)
-          !method_name.to_s.end_with?('=')
+        def dsl_writer?(node)
+          !node.assignment_method?
         end
 
         def trivial_reader?(node)
@@ -180,8 +183,7 @@ module RuboCop
         end
 
         def trivial_writer?(node)
-          looks_like_trivial_writer?(node) &&
-            !allowed_method_name?(node) && !allowed_writer?(node.method_name)
+          looks_like_trivial_writer?(node) && !allowed_method_name?(node) && !allowed_writer?(node)
         end
 
         # @!method looks_like_trivial_writer?(node)
@@ -195,8 +197,8 @@ module RuboCop
             (exact_name_match? && !names_match?(node))
         end
 
-        def allowed_writer?(method_name)
-          allow_dsl_writers? && dsl_writer?(method_name)
+        def allowed_writer?(node)
+          allow_dsl_writers? && dsl_writer?(node)
         end
 
         def allowed_reader?(node)
@@ -206,11 +208,11 @@ module RuboCop
         def names_match?(node)
           ivar_name, = *node.body
 
-          node.method_name.to_s.sub(/[=?]$/, '') == ivar_name[1..-1]
+          node.method_name.to_s.sub(/[=?]$/, '') == ivar_name[1..]
         end
 
         def trivial_accessor_kind(node)
-          if trivial_writer?(node) && !dsl_writer?(node.method_name)
+          if trivial_writer?(node) && !dsl_writer?(node)
             'writer'
           elsif trivial_reader?(node)
             'reader'
@@ -236,7 +238,7 @@ module RuboCop
 
           indent = ' ' * node.loc.column
           corrector.replace(
-            node.source_range,
+            node,
             ['class << self',
              "#{indent}  #{accessor(kind, node.method_name)}",
              "#{indent}end"].join("\n")

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop looks for `unless` expressions with `else` clauses.
+      # Looks for `unless` expressions with `else` clauses.
       #
       # @example
       #   # bad
@@ -32,10 +32,14 @@ module RuboCop
             body_range = range_between_condition_and_else(node, node.condition)
             else_range = range_between_else_and_end(node)
 
+            next if part_of_ignored_node?(node)
+
             corrector.replace(node.loc.keyword, 'if')
             corrector.replace(body_range, else_range.source)
             corrector.replace(else_range, body_range.source)
           end
+
+          ignore_node(node)
         end
 
         def range_between_condition_and_else(node, condition)

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

@@ -3,11 +3,12 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for the use of logical operators in an `unless` condition.
+      # Checks for the use of logical operators in an `unless` condition.
       # It discourages such code, as the condition becomes more difficult
       # to read and understand.
       #
       # This cop supports two styles:
+      #
       # - `forbid_mixed_logical_operators` (default)
       # - `forbid_logical_operators`
       #

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for accessing the first element of `String#unpack`
+      # Checks for accessing the first element of `String#unpack`
       # which can be replaced with the shorter method `unpack1`.
       #
       # @example
@@ -19,39 +19,39 @@ module RuboCop
       #
       class UnpackFirst < Base
         extend AutoCorrector
+        extend TargetRubyVersion
 
-        MSG = 'Use `%<receiver>s.unpack1(%<format>s)` instead of '\
-              '`%<receiver>s.unpack(%<format>s)%<method>s`.'
+        minimum_target_ruby_version 2.4
+
+        MSG = 'Use `unpack1(%<format>s)` instead of `%<current>s`.'
         RESTRICT_ON_SEND = %i[first [] slice at].freeze
 
         # @!method unpack_and_first_element?(node)
         def_node_matcher :unpack_and_first_element?, <<~PATTERN
           {
-            (send $(send (...) :unpack $(...)) :first)
-            (send $(send (...) :unpack $(...)) {:[] :slice :at} (int 0))
+            (call $(call (...) :unpack $(...)) :first)
+            (call $(call (...) :unpack $(...)) {:[] :slice :at} (int 0))
           }
         PATTERN
 
         def on_send(node)
           unpack_and_first_element?(node) do |unpack_call, unpack_arg|
-            range = first_element_range(node, unpack_call)
-            message = format(MSG,
-                             receiver: unpack_call.receiver.source,
-                             format: unpack_arg.source,
-                             method: range.source)
-            add_offense(node, message: message) do |corrector|
-              corrector.remove(first_element_range(node, unpack_call))
+            first_element_range = first_element_range(node, unpack_call)
+            offense_range = unpack_call.loc.selector.join(node.source_range.end)
+            message = format(MSG, format: unpack_arg.source, current: offense_range.source)
+
+            add_offense(offense_range, message: message) do |corrector|
+              corrector.remove(first_element_range)
               corrector.replace(unpack_call.loc.selector, 'unpack1')
             end
           end
         end
+        alias on_csend on_send
 
         private
 
         def first_element_range(node, unpack_call)
-          Parser::Source::Range.new(node.loc.expression.source_buffer,
-                                    unpack_call.loc.expression.end_pos,
-                                    node.loc.expression.end_pos)
+          unpack_call.source_range.end.join(node.source_range.end)
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for variable interpolation (like "#@ivar").
+      # Checks for variable interpolation (like "#@ivar").
       #
       # @example
       #   # bad

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for `when;` uses in `case` expressions.
+      # Checks for `when;` uses in `case` expressions.
       #
       # @example
       #   # bad