rubocop 1.27.0 → 1.51.0

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for uses of `each_key` and `each_value` Hash methods.
+      # Checks for uses of `each_key` and `each_value` Hash methods.
       #
       # NOTE: If you have an array of two-element arrays, you can put
       #   parentheses around the block arguments to indicate that you're not
@@ -35,29 +35,53 @@ module RuboCop
 
         # @!method kv_each(node)
         def_node_matcher :kv_each, <<~PATTERN
-          (block $(send (send _ ${:keys :values}) :each) ...)
+          ({block numblock} $(send (send _ ${:keys :values}) :each) ...)
+        PATTERN
+
+        # @!method kv_each_with_block_pass(node)
+        def_node_matcher :kv_each_with_block_pass, <<~PATTERN
+          (send $(send _ ${:keys :values}) :each (block_pass (sym _)))
         PATTERN
 
         def on_block(node)
-          register_kv_offense(node)
+          kv_each(node) do |target, method|
+            register_kv_offense(target, method)
+          end
+        end
+
+        alias on_numblock on_block
+
+        def on_block_pass(node)
+          kv_each_with_block_pass(node.parent) do |target, method|
+            register_kv_with_block_pass_offense(node, target, method)
+          end
         end
 
         private
 
-        def register_kv_offense(node)
-          kv_each(node) do |target, method|
-            parent_receiver = target.receiver.receiver
-            return unless parent_receiver
-            return if allowed_receiver?(parent_receiver)
+        def register_kv_offense(target, method)
+          return unless (parent_receiver = target.receiver.receiver)
+          return if allowed_receiver?(parent_receiver)
 
-            msg = format(message, prefer: "each_#{method[0..-2]}", current: "#{method}.each")
+          add_offense(kv_range(target), message: format_message(method)) do |corrector|
+            correct_key_value_each(target, corrector)
+          end
+        end
 
-            add_offense(kv_range(target), message: msg) do |corrector|
-              correct_key_value_each(target, corrector)
-            end
+        def register_kv_with_block_pass_offense(node, target, method)
+          return unless (parent_receiver = node.parent.receiver.receiver)
+          return if allowed_receiver?(parent_receiver)
+
+          range = target.loc.selector.with(end_pos: node.parent.loc.selector.end_pos)
+          add_offense(range, message: format_message(method)) do |corrector|
+            corrector.replace(range, "each_#{method[0..-2]}")
           end
         end
 
+        def format_message(method_name)
+          format(MSG, prefer: "each_#{method_name[0..-2]}", current: "#{method_name}.each")
+        end
+
         def check_argument(variable)
           return unless variable.block_argument?
 
@@ -94,11 +118,23 @@ module RuboCop
         end
 
         def allowed_receiver?(receiver)
-          receiver_name = receiver.send_type? ? receiver.method_name.to_s : receiver.source
+          receiver_name = receiver_name(receiver)
 
           allowed_receivers.include?(receiver_name)
         end
 
+        def receiver_name(receiver)
+          if receiver.send_type?
+            if receiver.receiver
+              "#{receiver_name(receiver.receiver)}.#{receiver.method_name}"
+            else
+              receiver.method_name.to_s
+            end
+          else
+            receiver.source
+          end
+        end
+
         def allowed_receivers
           cop_config.fetch('AllowedReceivers', [])
         end

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.
@@ -13,12 +13,19 @@ module RuboCop
       # when used `==`.
       # And do not check `Hash#delete_if` and `Hash#keep_if` to change receiver object.
       #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   is a `Hash` or responds to the replacement method.
+      #
       # @example
       #
       #   # bad
       #   {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 +40,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? :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 _)
               (arg _))
-            (send
-              _ {:== :!= :eql?} _))
+            {
+              $(send
+                _ {:== :!= :eql? :in? :include? :exclude?} _)
+              (send
+                $(send
+                  _ {:== :!= :eql? :in? :include? :exclude?} _) :!)
+              })
         PATTERN
 
         def on_send(node)
@@ -52,7 +80,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 +89,91 @@ module RuboCop
 
         private
 
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def bad_method?(block)
+          if active_support_extensions_enabled?
+            bad_method_with_active_support?(block) do |key_arg, send_node|
+              if send_node.method?(:in?) && send_node.receiver&.source != key_arg.source
+                return false
+              end
+              return true if !send_node.method?(:include?) && !send_node.method?(:exclude?)
+
+              send_node.first_argument&.source == key_arg.source
+            end
+          else
+            bad_method_with_poro?(block) do |key_arg, send_node|
+              !send_node.method?(:include?) || send_node.first_argument&.source == key_arg.source
+            end
+          end
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
         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_negated(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_negated(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_negated(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)
@@ -37,6 +37,8 @@ module RuboCop
       #   end
       #
       class HashLikeCase < Base
+        include MinBranchesCount
+
         MSG = 'Consider replacing `case-when` with a hash lookup.'
 
         # @!method hash_like_case?(node)
@@ -49,7 +51,7 @@ module RuboCop
         PATTERN
 
         def on_case(node)
-          return if node.when_branches.size < min_branches_count
+          return unless min_branches_count?(node)
 
           hash_like_case?(node) do |condition_nodes, body_nodes|
             if nodes_of_same_type?(condition_nodes) && nodes_of_same_type?(body_nodes)
@@ -63,14 +65,6 @@ module RuboCop
         def nodes_of_same_type?(nodes)
           nodes.all? { |node| node.type == nodes.first.type }
         end
-
-        def min_branches_count
-          length = cop_config['MinBranchesCount'] || 3
-          return length if length.is_a?(Integer) && length.positive?
-
-          warn Rainbow('`MinBranchesCount` needs to be a positive integer!').red
-          exit!
-        end
       end
     end
   end

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 - forces use of the 3.1 syntax only if all values can be omitted in the hash
       #
       # @example EnforcedStyle: ruby19 (default)
       #   # bad
@@ -87,8 +88,28 @@ module RuboCop
       #   {foo: foo, bar: bar}
       #
       #   # good
+      #   {foo: foo, bar:}
+      #
+      #   # good
+      #   {foo:, bar:}
+      #
+      # @example EnforcedShorthandSyntax: consistent
+      #
+      #   # bad - `foo` and `bar` values can be omitted
+      #   {foo: foo, bar: bar}
+      #
+      #   # bad - `bar` value can be omitted
+      #   {foo:, bar: bar}
+      #
+      #   # bad - mixed syntaxes
+      #   {foo:, bar: baz}
+      #
+      #   # good
       #   {foo:, bar:}
       #
+      #   # good - can't omit `baz`
+      #   {foo: foo, bar: baz}
+      #
       class HashSyntax < Base
         include ConfigurableEnforcedStyle
         include HashShorthandSyntax
@@ -104,6 +125,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
@@ -187,7 +210,7 @@ module RuboCop
           return true if /\A[_a-z]\w*[?!]?\z/i.match?(sym_name)
 
           # For more complicated hash keys, let the parser validate the syntax.
-          ProcessedSource.new("{ #{sym_name}: :foo }", target_ruby_version).valid_syntax?
+          parse("{ #{sym_name}: :foo }").valid_syntax?
         end
 
         def check(pairs, delim, msg)
@@ -223,19 +246,20 @@ 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)
-          node.argument? && node.loc.expression.begin_pos == node.parent.loc.selector.end_pos
+          node.argument? && node.source_range.begin_pos == node.parent.loc.selector.end_pos
         end
 
         def autocorrect_hash_rockets(corrector, pair_node)
           op = pair_node.loc.operator
 
           key_with_hash_rocket = ":#{pair_node.key.source}#{pair_node.inverse_delimiter(true)}"
+          key_with_hash_rocket += pair_node.key.source if pair_node.value_omission?
           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
@@ -136,6 +136,7 @@ module RuboCop
 
         private
 
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def check_branches(node, branches)
           # return if any branch is empty. An empty branch can be an `if`
           # without an `else` or a branch that contains only comments.
@@ -144,9 +145,13 @@ module RuboCop
           tails = branches.map { |branch| tail(branch) }
           check_expressions(node, tails, :after_condition) if duplicated_expressions?(node, tails)
 
+          return if last_child_of_parent?(node) &&
+                    branches.any? { |branch| single_child_branch?(branch) }
+
           heads = branches.map { |branch| head(branch) }
           check_expressions(node, heads, :before_condition) if duplicated_expressions?(node, heads)
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def duplicated_expressions?(node, expressions)
           unique_expressions = expressions.uniq
@@ -180,6 +185,16 @@ module RuboCop
           end
         end
 
+        def last_child_of_parent?(node)
+          return true unless (parent = node.parent)
+
+          parent.child_nodes.last == node
+        end
+
+        def single_child_branch?(branch_node)
+          !branch_node.begin_type? || branch_node.children.size == 1
+        end
+
         def message(node)
           format(MSG, source: node.source)
         end

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

@@ -59,11 +59,13 @@ module RuboCop
       #   end
       #
       class IfInsideElse < Base
+        include IgnoredNode
         include RangeHelp
         extend AutoCorrector
 
         MSG = 'Convert `if` nested inside `else` to `elsif`.'
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def on_if(node)
           return if node.ternary? || node.unless?
 
@@ -73,9 +75,13 @@ module RuboCop
           return if allow_if_modifier_in_else_branch?(else_branch)
 
           add_offense(else_branch.loc.keyword) do |corrector|
+            next if part_of_ignored_node?(node)
+
             autocorrect(corrector, else_branch)
+            ignore_node(node)
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         private