rubocop 1.19.0 → 1.33.0

data/lib/rubocop/cop/naming/memoized_instance_variable_name.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Naming
-      # This cop checks for memoized methods whose instance variable name
+      # Checks for memoized methods whose instance variable name
       # does not match the method name. Applies to both regular methods
       # (defined with `def`) and dynamic methods (defined with
       # `define_method` or `define_singleton_method`).
@@ -14,6 +14,11 @@ module RuboCop
       # convention that is used to implicitly indicate that an ivar should not
       # be set or referenced outside of the memoization method.
       #
+      # @safety
+      #   This cop relies on the pattern `@instance_var ||= ...`,
+      #   but this is sometimes used for other purposes than memoization
+      #   so this cop is considered unsafe.
+      #
       # @example EnforcedStyleForLeadingUnderscores: disallowed (default)
       #   # bad
       #   # Method foo is memoized using an instance variable that is
@@ -139,10 +144,6 @@ module RuboCop
       #   define_method(:foo) do
       #     @_foo ||= calculate_expensive_thing
       #   end
-      #
-      # This cop relies on the pattern `@instance_var ||= ...`,
-      # but this is sometimes used for other purposes than memoization
-      # so this cop is considered unsafe.
       class MemoizedInstanceVariableName < Base
         include ConfigurableEnforcedStyle
 

data/lib/rubocop/cop/naming/method_name.rb

@@ -3,13 +3,13 @@
 module RuboCop
   module Cop
     module Naming
-      # This cop makes sure that all methods use the configured style,
+      # Makes sure that all methods use the configured style,
       # snake_case or camelCase, for their names.
       #
-      # This cop has `IgnoredPatterns` configuration option.
+      # This cop has `AllowedPatterns` configuration option.
       #
       #   Naming/MethodName:
-      #     IgnoredPatterns:
+      #     AllowedPatterns:
       #       - '\A\s*onSelectionBulkChange\s*'
       #       - '\A\s*onSelectionCleared\s*'
       #
@@ -30,7 +30,7 @@ module RuboCop
       #   def fooBar; end
       class MethodName < Base
         include ConfigurableNaming
-        include IgnoredPattern
+        include AllowedPattern
         include RangeHelp
 
         MSG = 'Use %<style>s for method names.'
@@ -46,14 +46,14 @@ module RuboCop
 
           attrs.last.each do |name_item|
             name = attr_name(name_item)
-            next if !name || matches_ignored_pattern?(name)
+            next if !name || matches_allowed_pattern?(name)
 
             check_name(node, name, range_position(node))
           end
         end
 
         def on_def(node)
-          return if node.operator_method? || matches_ignored_pattern?(node.method_name)
+          return if node.operator_method? || matches_allowed_pattern?(node.method_name)
 
           check_name(node, node.method_name, node.loc.name)
         end

data/lib/rubocop/cop/naming/method_parameter_name.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Naming
-      # This cop checks method parameter names for how descriptive they
+      # Checks method parameter names for how descriptive they
       # are. It is highly configurable.
       #
       # The `MinNameLength` config option takes an integer. It represents
@@ -26,7 +26,7 @@ module RuboCop
       #     num1 * num2
       #   end
       #
-      #   # With `MinArgNameLength` set to number greater than 1
+      #   # With `MinNameLength` set to number greater than 1
       #   def baz(a, b, c)
       #     do_stuff(a, b, c)
       #   end

data/lib/rubocop/cop/naming/predicate_name.rb

@@ -3,7 +3,30 @@
 module RuboCop
   module Cop
     module Naming
-      # This cop makes sure that predicates are named properly.
+      # Checks that predicate methods names end with a question mark and
+      # do not start with a forbidden prefix.
+      #
+      # A method is determined to be a predicate method if its name starts
+      # with one of the prefixes defined in the `NamePrefix` configuration.
+      # You can change what prefixes are considered by changing this option.
+      # Any method name that starts with one of these prefixes is required by
+      # the cop to end with a `?`. Other methods can be allowed by adding to
+      # the `AllowedMethods` configuration.
+      #
+      # NOTE: The `is_a?` method is allowed by default.
+      #
+      # If `ForbiddenPrefixes` is set, methods that start with the configured
+      # prefixes will not be allowed and will be removed by autocorrection.
+      #
+      # In other words, if `ForbiddenPrefixes` is empty, a method named `is_foo`
+      # will register an offense only due to the lack of question mark (and will be
+      # autocorrected to `is_foo?`). If `ForbiddenPrefixes` contains `is_`,
+      # `is_foo` will register an offense both because the ? is missing and because of
+      # the `is_` prefix, and will be corrected to `foo?`.
+      #
+      # NOTE: `ForbiddenPrefixes` is only applied to prefixes in `NamePrefix`;
+      # a prefix in the former but not the latter will not be considered by
+      # this cop.
       #
       # @example
       #   # bad
@@ -27,6 +50,12 @@ module RuboCop
       #   # good
       #   def value?
       #   end
+      #
+      # @example AllowedMethods: ['is_a?'] (default)
+      #   # good
+      #   def is_a?(value)
+      #   end
+      #
       class PredicateName < Base
         include AllowedMethods
 
@@ -70,7 +99,7 @@ module RuboCop
           !(method_name.start_with?(prefix) && # cheap check to avoid allocating Regexp
               method_name.match?(/^#{prefix}[^0-9]/)) ||
             method_name == expected_name(method_name, prefix) ||
-            method_name.end_with?('=') ||
+            method_name.end_with?('=') || # rubocop:todo InternalAffairs/MethodNameEndWith
             allowed_method?(method_name)
         end
 
@@ -80,7 +109,7 @@ module RuboCop
                      else
                        method_name.dup
                      end
-          new_name << '?' unless method_name.end_with?('?')
+          new_name << '?' unless method_name.end_with?('?') # rubocop:todo InternalAffairs/MethodNameEndWith
           new_name
         end
 

data/lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Naming
-      # This cop makes sure that rescued exceptions variables are named as
+      # Makes sure that rescued exceptions variables are named as
       # expected.
       #
       # The `PreferredName` config option takes a `String`. It represents
@@ -75,6 +75,9 @@ module RuboCop
           preferred_name = preferred_name(offending_name)
           return if preferred_name.to_sym == offending_name
 
+          # check variable shadowing for exception variable
+          return if shadowed_variable_name?(node)
+
           range = offense_range(node)
           message = message(node)
 
@@ -150,6 +153,10 @@ module RuboCop
           preferred_name = preferred_name(offending_name)
           format(MSG, preferred: preferred_name, bad: offending_name)
         end
+
+        def shadowed_variable_name?(node)
+          node.each_descendant(:lvar).any? { |n| n.children.first.to_s == preferred_name(n) }
+        end
       end
     end
   end

data/lib/rubocop/cop/naming/variable_name.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Naming
-      # This cop makes sure that all variables use the configured style,
+      # Makes sure that all variables use the configured style,
       # snake_case or camelCase, for their names.
       #
       # @example EnforcedStyle: snake_case (default)
@@ -19,12 +19,21 @@ module RuboCop
       #
       #   # good
       #   fooBar = 1
+      #
+      # @example AllowedPatterns: ['_v\d+\z']
+      #   # good
+      #   :release_v1
       class VariableName < Base
         include AllowedIdentifiers
         include ConfigurableNaming
+        include AllowedPattern
 
         MSG = 'Use %<style>s for variable names.'
 
+        def valid_name?(node, name, given_style = style)
+          super || matches_allowed_pattern?(name)
+        end
+
         def on_lvasgn(node)
           name, = *node
           return unless name

data/lib/rubocop/cop/naming/variable_number.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Naming
-      # This cop makes sure that all numbered variables use the
+      # Makes sure that all numbered variables use the
       # configured style, snake_case, normalcase, or non_integer,
       # for their numbering.
       #
@@ -11,23 +11,6 @@ module RuboCop
       # can be used to specify whether method names and symbols should be checked.
       # Both are enabled by default.
       #
-      # @example EnforcedStyle: snake_case
-      #   # bad
-      #   :some_sym1
-      #   variable1 = 1
-      #
-      #   def some_method1; end
-      #
-      #   def some_method_1(arg1); end
-      #
-      #   # good
-      #   :some_sym_1
-      #   variable_1 = 1
-      #
-      #   def some_method_1; end
-      #
-      #   def some_method_1(arg_1); end
-      #
       # @example EnforcedStyle: normalcase (default)
       #   # bad
       #   :some_sym_1
@@ -45,6 +28,23 @@ module RuboCop
       #
       #   def some_method1(arg1); end
       #
+      # @example EnforcedStyle: snake_case
+      #   # bad
+      #   :some_sym1
+      #   variable1 = 1
+      #
+      #   def some_method1; end
+      #
+      #   def some_method_1(arg1); end
+      #
+      #   # good
+      #   :some_sym_1
+      #   variable_1 = 1
+      #
+      #   def some_method_1; end
+      #
+      #   def some_method_1(arg_1); end
+      #
       # @example EnforcedStyle: non_integer
       #   # bad
       #   :some_sym1
@@ -96,12 +96,21 @@ module RuboCop
       #   # good
       #   expect(Open3).to receive(:capture3)
       #
+      # @example AllowedPatterns: ['_v\d+\z']
+      #   # good
+      #   :some_sym_v1
+      #
       class VariableNumber < Base
         include AllowedIdentifiers
         include ConfigurableNumbering
+        include AllowedPattern
 
         MSG = 'Use %<style>s for %<identifier_type>s numbers.'
 
+        def valid_name?(node, name, given_style = style)
+          super || matches_allowed_pattern?(name)
+        end
+
         def on_arg(node)
           @node = node
           name, = *node
@@ -112,6 +121,7 @@ module RuboCop
         alias on_lvasgn on_arg
         alias on_ivasgn on_arg
         alias on_cvasgn on_arg
+        alias on_gvasgn on_arg
 
         def on_def(node)
           @node = node

data/lib/rubocop/cop/offense.rb

@@ -217,7 +217,7 @@ module RuboCop
       alias eql? ==
 
       def hash
-        COMPARISON_ATTRIBUTES.reduce(0) { |hash, attribute| hash ^ public_send(attribute).hash }
+        COMPARISON_ATTRIBUTES.map { |attribute| public_send(attribute) }.hash
       end
 
       # @api public

data/lib/rubocop/cop/security/compound_hash.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Security
+      # Checks for implementations of the `hash` method which combine
+      # values using custom logic instead of delegating to `Array#hash`.
+      #
+      # Manually combining hashes is error prone and hard to follow, especially
+      # when there are many values. Poor implementations may also introduce
+      # performance or security concerns if they are prone to collisions.
+      # Delegating to `Array#hash` is clearer, faster, and safer.
+      #
+      # @safety
+      #   This cop may be unsafe if the application logic depends on the hash
+      #   value, however this is inadvisable anyway.
+      #
+      # @example
+      #
+      #   # bad
+      #   def hash
+      #     @foo ^ @bar
+      #   end
+      #
+      #   # good
+      #   def hash
+      #     [@foo, @bar].hash
+      #   end
+      class CompoundHash < Base
+        COMBINATOR_IN_HASH_MSG = 'Use `[...].hash` instead of combining hash values manually.'
+        MONUPLE_HASH_MSG =
+          'Delegate hash directly without wrapping in an array when only using a single value'
+        REDUNDANT_HASH_MSG = 'Calling .hash on elements of a hashed array is redundant'
+
+        # @!method hash_method_definition?(node)
+        def_node_matcher :hash_method_definition?, <<~PATTERN
+          {#static_hash_method_definition? | #dynamic_hash_method_definition?}
+        PATTERN
+
+        # @!method dynamic_hash_method_definition?(node)
+        def_node_matcher :dynamic_hash_method_definition?, <<~PATTERN
+          (block
+            (send _ {:define_method | :define_singleton_method}
+              (sym :hash))
+            (args)
+            _)
+        PATTERN
+
+        # @!method static_hash_method_definition?(node)
+        def_node_matcher :static_hash_method_definition?, <<~PATTERN
+          ({def | defs _} :hash
+            (args)
+            _)
+        PATTERN
+
+        # @!method bad_hash_combinator?(node)
+        def_node_matcher :bad_hash_combinator?, <<~PATTERN
+          ({send | op-asgn} _ {:^ | :+ | :* | :|} _)
+        PATTERN
+
+        # @!method monuple_hash?(node)
+        def_node_matcher :monuple_hash?, <<~PATTERN
+          (send (array _) :hash)
+        PATTERN
+
+        # @!method redundant_hash?(node)
+        def_node_matcher :redundant_hash?, <<~PATTERN
+          (
+            ^^(send array ... :hash)
+            _ :hash
+          )
+        PATTERN
+
+        def contained_in_hash_method?(node, &block)
+          node.each_ancestor.any? do |ancestor|
+            hash_method_definition?(ancestor, &block)
+          end
+        end
+
+        def outer_bad_hash_combinator?(node)
+          bad_hash_combinator?(node) do
+            yield true if node.each_ancestor.none? { |ancestor| bad_hash_combinator?(ancestor) }
+          end
+        end
+
+        def on_send(node)
+          outer_bad_hash_combinator?(node) do
+            contained_in_hash_method?(node) do
+              add_offense(node, message: COMBINATOR_IN_HASH_MSG)
+            end
+          end
+
+          monuple_hash?(node) do
+            add_offense(node, message: MONUPLE_HASH_MSG)
+          end
+
+          redundant_hash?(node) do
+            add_offense(node, message: REDUNDANT_HASH_MSG)
+          end
+        end
+        alias on_op_asgn on_send
+      end
+    end
+  end
+end

data/lib/rubocop/cop/security/eval.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Security
-      # This cop checks for the use of `Kernel#eval` and `Binding#eval`.
+      # Checks for the use of `Kernel#eval` and `Binding#eval`.
       #
       # @example
       #

data/lib/rubocop/cop/security/io_methods.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Security
+      # Checks for the first argument to `IO.read`, `IO.binread`, `IO.write`, `IO.binwrite`,
+      # `IO.foreach`, and `IO.readlines`.
+      #
+      # If argument starts with a pipe character (`'|'`) and the receiver is the `IO` class,
+      # a subprocess is created in the same way as `Kernel#open`, and its output is returned.
+      # `Kernel#open` may allow unintentional command injection, which is the reason these
+      # `IO` methods are a security risk.
+      # Consider to use `File.read` to disable the behavior of subprocess invocation.
+      #
+      # @safety
+      #   This cop is unsafe because false positive will occur if the variable passed as
+      #   the first argument is a command that is not a file path.
+      #
+      # @example
+      #
+      #   # bad
+      #   IO.read(path)
+      #   IO.read('path')
+      #
+      #   # good
+      #   File.read(path)
+      #   File.read('path')
+      #   IO.read('| command') # Allow intentional command invocation.
+      #
+      class IoMethods < Base
+        extend AutoCorrector
+
+        MSG = '`File.%<method_name>s` is safer than `IO.%<method_name>s`.'
+        RESTRICT_ON_SEND = %i[read binread write binwrite foreach readlines].freeze
+
+        def on_send(node)
+          return unless (receiver = node.receiver) && receiver.source == 'IO'
+
+          argument = node.first_argument
+          return if argument.respond_to?(:value) && argument.value.strip.start_with?('|')
+
+          add_offense(node, message: format(MSG, method_name: node.method_name)) do |corrector|
+            corrector.replace(receiver, 'File')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/security/json_load.rb

@@ -3,16 +3,17 @@
 module RuboCop
   module Cop
     module Security
-      # This cop checks for the use of JSON class methods which have potential
+      # Checks for the use of JSON class methods which have potential
       # security issues.
       #
-      # Autocorrect is disabled by default because it's potentially dangerous.
-      # If using a stream, like `JSON.load(open('file'))`, it will need to call
-      # `#read` manually, like `JSON.parse(open('file').read)`.
-      # If reading single values (rather than proper JSON objects), like
-      # `JSON.load('false')`, it will need to pass the `quirks_mode: true`
-      # option, like `JSON.parse('false', quirks_mode: true)`.
-      # Other similar issues may apply.
+      # @safety
+      #   This cop's autocorrection is unsafe because it's potentially dangerous.
+      #   If using a stream, like `JSON.load(open('file'))`, it will need to call
+      #   `#read` manually, like `JSON.parse(open('file').read)`.
+      #   If reading single values (rather than proper JSON objects), like
+      #   `JSON.load('false')`, it will need to pass the `quirks_mode: true`
+      #   option, like `JSON.parse('false', quirks_mode: true)`.
+      #   Other similar issues may apply.
       #
       # @example
       #   # bad

data/lib/rubocop/cop/security/marshal_load.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Security
-      # This cop checks for the use of Marshal class methods which have
+      # Checks for the use of Marshal class methods which have
       # potential security issues leading to remote code execution when
       # loading from an untrusted source.
       #

data/lib/rubocop/cop/security/open.rb

@@ -3,7 +3,8 @@
 module RuboCop
   module Cop
     module Security
-      # This cop checks for the use of `Kernel#open` and `URI.open`.
+      # Checks for the use of `Kernel#open` and `URI.open` with dynamic
+      # data.
       #
       # `Kernel#open` and `URI.open` enable not only file access but also process
       # invocation by prefixing a pipe symbol (e.g., `open("| ls")`).
@@ -11,15 +12,28 @@ module RuboCop
       # the argument of `Kernel#open` and `URI.open`. It would be better to use
       # `File.open`, `IO.popen` or `URI.parse#open` explicitly.
       #
+      # NOTE: `open` and `URI.open` with literal strings are not flagged by this
+      # cop.
+      #
+      # @safety
+      #   This cop could register false positives if `open` is redefined
+      #   in a class and then used without a receiver in that class.
+      #
       # @example
       #   # bad
       #   open(something)
+      #   open("| #{something}")
       #   URI.open(something)
       #
       #   # good
       #   File.open(something)
       #   IO.popen(something)
       #   URI.parse(something).open
+      #
+      #   # good (literal strings)
+      #   open("foo.text")
+      #   open("| foo")
+      #   URI.open("http://example.com")
       class Open < Base
         MSG = 'The use of `%<receiver>sopen` is a serious security risk.'
         RESTRICT_ON_SEND = %i[open].freeze

data/lib/rubocop/cop/security/yaml_load.rb

@@ -3,17 +3,25 @@
 module RuboCop
   module Cop
     module Security
-      # This cop checks for the use of YAML class methods which have
+      # Checks for the use of YAML class methods which have
       # potential security issues leading to remote code execution when
       # loading from an untrusted source.
       #
+      # NOTE: Ruby 3.1+ (Psych 4) uses `Psych.load` as `Psych.safe_load` by default.
+      #
+      # @safety
+      #   The behavior of the code might change depending on what was
+      #   in the YAML payload, since `YAML.safe_load` is more restrictive.
+      #
       # @example
       #   # bad
-      #   YAML.load("--- foo")
+      #   YAML.load("--- !ruby/object:Foo {}") # Psych 3 is unsafe by default
       #
       #   # good
-      #   YAML.safe_load("--- foo")
-      #   YAML.dump("foo")
+      #   YAML.safe_load("--- !ruby/object:Foo {}", [Foo])                    # Ruby 2.5  (Psych 3)
+      #   YAML.safe_load("--- !ruby/object:Foo {}", permitted_classes: [Foo]) # Ruby 3.0- (Psych 3)
+      #   YAML.load("--- !ruby/object:Foo {}", permitted_classes: [Foo])      # Ruby 3.1+ (Psych 4)
+      #   YAML.dump(foo)
       #
       class YAMLLoad < Base
         extend AutoCorrector
@@ -27,6 +35,8 @@ module RuboCop
         PATTERN
 
         def on_send(node)
+          return if target_ruby_version >= 3.1
+
           yaml_load(node) do
             add_offense(node.loc.selector) do |corrector|
               corrector.replace(node.loc.selector, 'safe_load')

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for grouping of accessors in `class` and `module` bodies.
+      # Checks for grouping of accessors in `class` and `module` bodies.
       # By default it enforces accessors to be placed in grouped declarations,
       # but it can be configured to enforce separating them in multiple declarations.
       #
@@ -59,8 +59,8 @@ module RuboCop
 
         def check(send_node)
           return if previous_line_comment?(send_node)
-          return unless grouped_style? && sibling_accessors(send_node).size > 1 ||
-                        separated_style? && send_node.arguments.size > 1
+          return unless (grouped_style? && sibling_accessors(send_node).size > 1) ||
+                        (separated_style? && send_node.arguments.size > 1)
 
           message = message(send_node)
           add_offense(send_node, message: message) do |corrector|
@@ -72,7 +72,7 @@ module RuboCop
           if (preferred_accessors = preferred_accessors(node))
             corrector.replace(node, preferred_accessors)
           else
-            range = range_with_surrounding_space(range: node.loc.expression, side: :left)
+            range = range_with_surrounding_space(node.loc.expression, side: :left)
             corrector.remove(range)
           end
         end
@@ -122,14 +122,14 @@ module RuboCop
         def preferred_accessors(node)
           if grouped_style?
             accessors = sibling_accessors(node)
-            group_accessors(node, accessors) if node == accessors.first
+            group_accessors(node, accessors) if node.loc == accessors.first.loc
           else
             separate_accessors(node)
           end
         end
 
         def group_accessors(node, accessors)
-          accessor_names = accessors.flat_map { |accessor| accessor.arguments.map(&:source) }
+          accessor_names = accessors.flat_map { |accessor| accessor.arguments.map(&:source) }.uniq
 
           "#{node.method_name} #{accessor_names.join(', ')}"
         end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop enforces the use of either `#alias` or `#alias_method`
+      # Enforces the use of either `#alias` or `#alias_method`
       # depending on configuration.
       # It also flags uses of `alias :symbol` rather than `alias bareword`.
       #
@@ -76,7 +76,7 @@ module RuboCop
 
         def add_offense_for_args(node, &block)
           existing_args  = node.children.map(&:source).join(' ')
-          preferred_args = node.children.map { |a| a.source[1..-1] }.join(' ')
+          preferred_args = node.children.map { |a| a.source[1..] }.join(' ')
           arg_ranges     = node.children.map(&:source_range)
           msg            = format(MSG_SYMBOL_ARGS, prefer: preferred_args, current: existing_args)
           add_offense(arg_ranges.reduce(&:join), message: msg, &block)
@@ -134,8 +134,8 @@ module RuboCop
         end
 
         def correct_alias_with_symbol_args(corrector, node)
-          corrector.replace(node.new_identifier, node.new_identifier.source[1..-1])
-          corrector.replace(node.old_identifier, node.old_identifier.source[1..-1])
+          corrector.replace(node.new_identifier, node.new_identifier.source[1..])
+          corrector.replace(node.old_identifier, node.old_identifier.source[1..])
         end
 
         # @!method identifier(node)