rubocop 1.26.0 → 1.36.0

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for usages of `Hash#reject`, `Hash#select`, and `Hash#filter` methods
+      # Checks for usages of `Hash#reject`, `Hash#select`, and `Hash#filter` methods
       # that can be replaced with `Hash#except` method.
       #
       # This cop should only be enabled on Ruby version 3.0 or higher.
@@ -19,6 +19,9 @@ module RuboCop
       #   {foo: 1, bar: 2, baz: 3}.reject {|k, v| k == :bar }
       #   {foo: 1, bar: 2, baz: 3}.select {|k, v| k != :bar }
       #   {foo: 1, bar: 2, baz: 3}.filter {|k, v| k != :bar }
+      #   {foo: 1, bar: 2, baz: 3}.reject {|k, v| %i[foo bar].include?(k) }
+      #   {foo: 1, bar: 2, baz: 3}.select {|k, v| !%i[foo bar].include?(k) }
+      #   {foo: 1, bar: 2, baz: 3}.filter {|k, v| !%i[foo bar].include?(k) }
       #
       #   # good
       #   {foo: 1, bar: 2, baz: 3}.except(:bar)
@@ -33,15 +36,36 @@ module RuboCop
         MSG = 'Use `%<prefer>s` instead.'
         RESTRICT_ON_SEND = %i[reject select filter].freeze
 
-        # @!method bad_method?(node)
-        def_node_matcher :bad_method?, <<~PATTERN
+        # @!method bad_method_with_poro?(node)
+        def_node_matcher :bad_method_with_poro?, <<~PATTERN
           (block
             (send _ _)
             (args
               (arg _)
               (arg _))
-            (send
-              _ {:== :!= :eql?} _))
+            {
+              (send
+                _ {:== :!= :eql? :include?} _)
+              (send
+                (send
+                  _ {:== :!= :eql? :include?} _) :!)
+              })
+        PATTERN
+
+        # @!method bad_method_with_active_support?(node)
+        def_node_matcher :bad_method_with_active_support?, <<~PATTERN
+          (block
+            (send _ _)
+            (args
+              (arg _)
+              (arg _))
+            {
+              (send
+                _ {:== :!= :eql? :in? :include? :exclude?} _)
+              (send
+                (send
+                  _ {:== :!= :eql? :in? :include? :exclude?} _) :!)
+              })
         PATTERN
 
         def on_send(node)
@@ -52,7 +76,7 @@ module RuboCop
           return if except_key.nil? || !safe_to_register_offense?(block, except_key)
 
           range = offense_range(node)
-          preferred_method = "except(#{except_key.source})"
+          preferred_method = "except(#{except_key_source(except_key)})"
 
           add_offense(range, message: format(MSG, prefer: preferred_method)) do |corrector|
             corrector.replace(range, preferred_method)
@@ -61,28 +85,80 @@ module RuboCop
 
         private
 
+        def bad_method?(block)
+          if active_support_extensions_enabled?
+            bad_method_with_active_support?(block)
+          else
+            bad_method_with_poro?(block)
+          end
+        end
+
         def semantically_except_method?(send, block)
           body = block.body
 
+          negated = body.method?('!')
+          body = body.receiver if negated
+
           case send.method_name
           when :reject
-            body.method?('==') || body.method?('eql?')
+            body.method?('==') || body.method?('eql?') || included?(negated, body)
           when :select, :filter
-            body.method?('!=')
+            body.method?('!=') || not_included?(negated, body)
           else
             false
           end
         end
 
+        def included?(negated, body)
+          body.method?('include?') || body.method?('in?') || (negated && body.method?('exclude?'))
+        end
+
+        def not_included?(negated, body)
+          body.method?('exclude?') || (negated && (body.method?('include?') || body.method?('in?')))
+        end
+
         def safe_to_register_offense?(block, except_key)
+          extracted = extract_body_if_nagated(block.body)
+          if extracted.method?('in?') || extracted.method?('include?') || \
+             extracted.method?('exclude?')
+            return true
+          end
           return true if block.body.method?('eql?')
 
           except_key.sym_type? || except_key.str_type?
         end
 
+        def extract_body_if_nagated(body)
+          return body unless body.method?('!')
+
+          body.receiver
+        end
+
+        def except_key_source(key)
+          if key.array_type?
+            key = if key.percent_literal?
+                    key.each_value.map { |v| decorate_source(v) }
+                  else
+                    key.each_value.map(&:source)
+                  end
+            return key.join(', ')
+          end
+
+          key.literal? ? key.source : "*#{key.source}"
+        end
+
+        def decorate_source(value)
+          return ":\"#{value.source}\"" if value.dsym_type?
+          return "\"#{value.source}\"" if value.dstr_type?
+          return ":#{value.source}" if value.sym_type?
+
+          "'#{value.source}'"
+        end
+
         def except_key(node)
           key_argument = node.argument_list.first.source
-          lhs, _method_name, rhs = *node.body
+          body = extract_body_if_nagated(node.body)
+          lhs, _method_name, rhs = *body
           return if [lhs, rhs].map(&:source).none?(key_argument)
 
           [lhs, rhs].find { |operand| operand.source != key_argument }

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for places where `case-when` represents a simple 1:1
+      # Checks for places where `case-when` represents a simple 1:1
       # mapping and can be replaced with a hash lookup.
       #
       # @example MinBranchesCount: 3 (default)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks hash literal syntax.
+      # Checks hash literal syntax.
       #
       # It can enforce either the use of the class hash rocket syntax or
       # the use of the newer Ruby 1.9 syntax (when applicable).
@@ -28,6 +28,7 @@ module RuboCop
       # * always - forces use of the 3.1 syntax (e.g. {foo:})
       # * never - forces use of explicit hash literal value
       # * either - accepts both shorthand and explicit use of hash literal value
+      # * consistent - like "always", but will avoid mixing styles in a single hash
       #
       # @example EnforcedStyle: ruby19 (default)
       #   # bad
@@ -89,6 +90,20 @@ module RuboCop
       #   # good
       #   {foo:, bar:}
       #
+      # @example EnforcedShorthandSyntax: consistent
+      #
+      #   # bad
+      #   {foo: , bar: bar}
+      #
+      #   # good
+      #   {foo:, bar:}
+      #
+      #   # bad
+      #   {foo: , bar: baz}
+      #
+      #   # good
+      #   {foo: foo, bar: baz}
+      #
       class HashSyntax < Base
         include ConfigurableEnforcedStyle
         include HashShorthandSyntax
@@ -104,6 +119,8 @@ module RuboCop
 
           return if pairs.empty?
 
+          on_hash_for_mixed_shorthand(node)
+
           if style == :hash_rockets || force_hash_rockets?(pairs)
             hash_rockets_check(pairs)
           elsif style == :ruby19_no_mixed_keys
@@ -223,7 +240,7 @@ module RuboCop
           operator = pair_node.loc.operator
 
           range = key.join(operator)
-          range_with_surrounding_space(range: range, side: :right)
+          range_with_surrounding_space(range, side: :right)
         end
 
         def argument_without_space?(node)
@@ -235,7 +252,7 @@ module RuboCop
 
           key_with_hash_rocket = ":#{pair_node.key.source}#{pair_node.inverse_delimiter(true)}"
           corrector.replace(pair_node.key, key_with_hash_rocket)
-          corrector.remove(range_with_surrounding_space(range: op))
+          corrector.remove(range_with_surrounding_space(op))
         end
 
         def autocorrect_no_mixed_keys(corrector, pair_node)

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

@@ -3,10 +3,12 @@
 module RuboCop
   module Cop
     module Style
-      # This cop looks for uses of `_.each_with_object({}) {...}`,
+      # Looks for uses of `_.each_with_object({}) {...}`,
       # `_.map {...}.to_h`, and `Hash[_.map {...}]` that are actually just
       # transforming the keys of a hash, and tries to use a simpler & faster
       # call to `transform_keys` instead.
+      # It should only be enabled on Ruby version 2.5 or newer.
+      # (`transform_keys` was added in Ruby 2.5.)
       #
       # @safety
       #   This cop is unsafe, as it can produce false positives if we are
@@ -26,6 +28,9 @@ module RuboCop
       class HashTransformKeys < Base
         include HashTransformMethod
         extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.5
 
         # @!method on_bad_each_with_object(node)
         def_node_matcher :on_bad_each_with_object, <<~PATTERN

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop looks for uses of `_.each_with_object({}) {...}`,
+      # Looks for uses of `_.each_with_object({}) {...}`,
       # `_.map {...}.to_h`, and `Hash[_.map {...}]` that are actually just
       # transforming the values of a hash, and tries to use a simpler & faster
       # call to `transform_values` instead.
@@ -26,6 +26,9 @@ module RuboCop
       class HashTransformValues < Base
         include HashTransformMethod
         extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.4
 
         # @!method on_bad_each_with_object(node)
         def_node_matcher :on_bad_each_with_object, <<~PATTERN

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for identical expressions at the beginning or end of
+      # Checks for identical expressions at the beginning or end of
       # each branch of a conditional expression. Such expressions should normally
       # be placed outside the conditional expression - before or after it.
       #
@@ -12,8 +12,8 @@ module RuboCop
       # in a future major RuboCop release.
       #
       # @safety
-      #   Auto-correction is unsafe because changing the order of method invocations
-      #   may change the behaviour of the code. For example:
+      #   Autocorrection is unsafe because changing the order of method invocations
+      #   may change the behavior of the code. For example:
       #
       #   [source,ruby]
       #   ----
@@ -27,7 +27,7 @@ module RuboCop
       #   ----
       #
       #   In this example, `method_that_relies_on_global_state` will be moved before
-      #   `method_that_modifies_global_state`, which changes the behaviour of the program.
+      #   `method_that_modifies_global_state`, which changes the behavior of the program.
       #
       # @example
       #   # bad

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

@@ -37,7 +37,7 @@ module RuboCop
       class IfUnlessModifier < Base
         include StatementModifier
         include LineLengthHelp
-        include IgnoredPattern
+        include AllowedPattern
         include RangeHelp
         extend AutoCorrector
 
@@ -87,15 +87,16 @@ module RuboCop
             !another_statement_on_same_line?(node)
         end
 
-        def ignored_patterns
-          config.for_cop('Layout/LineLength')['IgnoredPatterns'] || []
+        def allowed_patterns
+          line_length_config = config.for_cop('Layout/LineLength')
+          line_length_config['AllowedPatterns'] || line_length_config['IgnoredPatterns'] || []
         end
 
         def too_long_single_line?(node)
           return false unless max_line_length
 
           range = node.source_range
-          return false unless range.first_line == range.last_line
+          return false unless range.single_line?
           return false unless line_length_enabled_at_line?(range.first_line)
 
           line = range.source_line
@@ -105,7 +106,7 @@ module RuboCop
         end
 
         def too_long_line_based_on_config?(range, line)
-          return false if matches_ignored_pattern?(line)
+          return false if matches_allowed_pattern?(line)
 
           too_long = too_long_line_based_on_ignore_cop_directives?(range, line)
           return too_long unless too_long == :undetermined

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

@@ -3,12 +3,14 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for redundant `if` with boolean literal branches.
+      # Checks for redundant `if` with boolean literal branches.
       # It checks only conditions to return boolean value (`true` or `false`) for safe detection.
       # The conditions to be checked are comparison methods, predicate methods, and double negative.
+      # `nonzero?` method is allowed by default.
+      # These are customizable with `AllowedMethods` option.
       #
       # @safety
-      #   Auto-correction is unsafe because there is no guarantee that all predicate methods
+      #   Autocorrection is unsafe because there is no guarantee that all predicate methods
       #   will return a boolean value. Those methods can be allowed with `AllowedMethods` config.
       #
       # @example

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for `raise` or `fail` statements which do not specify an
+      # Checks for `raise` or `fail` statements which do not specify an
       # explicit exception class. (This raises a `RuntimeError`. Some projects
       # might prefer to use exception classes which more precisely identify the
       # nature of the error.)
@@ -15,8 +15,8 @@ module RuboCop
       #   # good
       #   raise ArgumentError, 'Error message here'
       class ImplicitRuntimeError < Base
-        MSG = 'Use `%<method>s` with an explicit exception class and message,' \
-              ' rather than just a message.'
+        MSG = 'Use `%<method>s` with an explicit exception class and message, ' \
+              'rather than just a message.'
         RESTRICT_ON_SEND = %i[raise fail].freeze
 
         # @!method implicit_runtime_error_raise_or_fail(node)

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

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

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for trailing inline comments.
+      # Checks for trailing inline comments.
       #
       # @example
       #

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop check for usages of not (`not` or `!`) called on a method
+      # Check for usages of not (`not` or `!`) called on a method
       # when an inverse of that method can be used instead.
       #
       # Methods that can be inverted by a not (`not` or `!`) should be defined
@@ -59,18 +59,18 @@ module RuboCop
         def_node_matcher :inverse_candidate?, <<~PATTERN
           {
             (send $(send $(...) $_ $...) :!)
-            (send (block $(send $(...) $_) $...) :!)
+            (send ({block numblock} $(send $(...) $_) $...) :!)
             (send (begin $(send $(...) $_ $...)) :!)
           }
         PATTERN
 
         # @!method inverse_block?(node)
         def_node_matcher :inverse_block?, <<~PATTERN
-          (block $(send (...) $_) ... { $(send ... :!)
-                                        $(send (...) {:!= :!~} ...)
-                                        (begin ... $(send ... :!))
-                                        (begin ... $(send (...) {:!= :!~} ...))
-                                      })
+          ({block numblock} $(send (...) $_) ... { $(send ... :!)
+                                                   $(send (...) {:!= :!~} ...)
+                                                   (begin ... $(send ... :!))
+                                                   (begin ... $(send (...) {:!= :!~} ...))
+                                                 })
         PATTERN
 
         def on_send(node)
@@ -94,7 +94,7 @@ module RuboCop
 
             # Inverse method offenses inside of the block of an inverse method
             # offense, such as `y.reject { |key, _value| !(key =~ /c\d/) }`,
-            # can cause auto-correction to apply improper corrections.
+            # can cause autocorrection to apply improper corrections.
             ignore_node(block)
             add_offense(node, message: message(method, inverse_blocks[method])) do |corrector|
               correct_inverse_block(corrector, node)
@@ -102,6 +102,8 @@ module RuboCop
           end
         end
 
+        alias on_numblock on_block
+
         private
 
         def correct_inverse_method(corrector, node)

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

@@ -5,7 +5,7 @@ require 'resolv'
 module RuboCop
   module Cop
     module Style
-      # This cop checks for hardcoded IP addresses, which can make code
+      # Checks for hardcoded IP addresses, which can make code
       # brittle. IP addresses are likely to need to be changed when code
       # is deployed to a different server or environment, which may break
       # a deployment if forgotten. Prefer setting IP addresses in ENV or

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop enforces that optional keyword parameters are placed at the
+      # Enforces that optional keyword parameters are placed at the
       # end of the parameters list.
       #
       # This improves readability, because when looking through the source,
@@ -65,7 +65,7 @@ module RuboCop
 
         def remove_kwargs(kwarg_nodes, corrector)
           kwarg_nodes.each do |kwarg|
-            with_space = range_with_surrounding_space(range: kwarg.source_range)
+            with_space = range_with_surrounding_space(kwarg.source_range)
             corrector.remove(range_with_surrounding_comma(with_space, :left))
           end
         end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop (by default) checks for uses of the lambda literal syntax for
+      # (by default) checks for uses of the lambda literal syntax for
       # single line lambdas, and the method call syntax for multiline lambdas.
       # It is configurable to enforce one of the styles for both single line
       # and multiline lambdas as well.

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for use of the lambda.(args) syntax.
+      # Checks for use of the lambda.(args) syntax.
       #
       # @example EnforcedStyle: call (default)
       #  # bad

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for string literal concatenation at
+      # Checks for string literal concatenation at
       # the end of a line.
       #
       # @safety
@@ -70,7 +70,7 @@ module RuboCop
 
         def autocorrect(corrector, operator_range)
           # Include any trailing whitespace so we don't create a syntax error.
-          operator_range = range_with_surrounding_space(range: operator_range,
+          operator_range = range_with_surrounding_space(operator_range,
                                                         side: :right,
                                                         newlines: false)
           one_more_char = operator_range.resize(operator_range.size + 1)