rubocop 1.57.1 → 1.65.0

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

@@ -17,10 +17,16 @@ module RuboCop
       # @example
       #   # bad
       #   hash.keys.each { |k| p k }
-      #   hash.values.each { |v| p v }
+      #   hash.each { |k, unused_value| p k }
       #
       #   # good
       #   hash.each_key { |k| p k }
+      #
+      #   # bad
+      #   hash.values.each { |v| p v }
+      #   hash.each { |unused_key, v| p v }
+      #
+      #   # good
       #   hash.each_value { |v| p v }
       #
       # @example AllowedReceivers: ['execute']
@@ -33,25 +39,59 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
+        UNUSED_BLOCK_ARG_MSG = "#{MSG.chop} and remove the unused `%<unused_code>s` block argument."
+        ARRAY_CONVERTER_METHODS = %i[assoc chunk flatten rassoc sort sort_by to_a].freeze
 
         # @!method kv_each(node)
         def_node_matcher :kv_each, <<~PATTERN
-          ({block numblock} $(send (send _ ${:keys :values}) :each) ...)
+          ({block numblock} $(call (call _ ${:keys :values}) :each) ...)
+        PATTERN
+
+        # @!method each_arguments(node)
+        def_node_matcher :each_arguments, <<~PATTERN
+          (block (call _ :each)(args $_key $_value) ...)
         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 _)))
+          (call $(call _ ${:keys :values}) :each (block_pass (sym _)))
         PATTERN
 
         def on_block(node)
+          return unless handleable?(node)
+
           kv_each(node) do |target, method|
-            register_kv_offense(target, method)
+            register_kv_offense(target, method) and return
           end
-        end
 
+          return unless (key, value = each_arguments(node))
+
+          check_unused_block_args(node, key, value)
+        end
         alias on_numblock on_block
 
+        # rubocop:disable Metrics/AbcSize
+        def check_unused_block_args(node, key, value)
+          return if node.body.nil?
+
+          value_unused = unused_block_arg_exist?(node, value)
+          key_unused = unused_block_arg_exist?(node, key)
+          return if value_unused && key_unused
+
+          if value_unused
+            message = message('each_key', node.method_name, value.source)
+            unused_range = key.source_range.end.join(value.source_range.end)
+
+            register_each_args_offense(node, message, 'each_key', unused_range)
+          elsif key_unused
+            message = message('each_value', node.method_name, key.source)
+            unused_range = key.source_range.begin.join(value.source_range.begin)
+
+            register_each_args_offense(node, message, 'each_value', unused_range)
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
         def on_block_pass(node)
           kv_each_with_block_pass(node.parent) do |target, method|
             register_kv_with_block_pass_offense(node, target, method)
@@ -60,27 +100,81 @@ module RuboCop
 
         private
 
+        def handleable?(node)
+          return false if use_array_converter_method_as_preceding?(node)
+          return false unless (root_receiver = root_receiver(node))
+
+          !root_receiver.literal? || root_receiver.hash_type?
+        end
+
         def register_kv_offense(target, method)
           return unless (parent_receiver = target.receiver.receiver)
           return if allowed_receiver?(parent_receiver)
 
-          add_offense(kv_range(target), message: format_message(method)) do |corrector|
+          current = target.receiver.loc.selector.join(target.source_range.end).source
+
+          add_offense(kv_range(target), message: format_message(method, current)) do |corrector|
             correct_key_value_each(target, corrector)
           end
         end
 
+        def unused_block_arg_exist?(node, block_arg)
+          lvar_sources = node.body.each_descendant(:lvar).map(&:source)
+
+          if block_arg.mlhs_type?
+            block_arg.each_descendant(:arg, :restarg).all? do |block_arg|
+              lvar_sources.none?(block_arg.source.delete_prefix('*'))
+            end
+          else
+            lvar_sources.none?(block_arg.source.delete_prefix('*'))
+          end
+        end
+
+        def message(prefer, method_name, unused_code)
+          format(
+            UNUSED_BLOCK_ARG_MSG, prefer: prefer, current: method_name, unused_code: unused_code
+          )
+        end
+
+        def register_each_args_offense(node, message, prefer, unused_range)
+          add_offense(node, message: message) do |corrector|
+            corrector.replace(node.send_node.loc.selector, prefer)
+            corrector.remove(unused_range)
+          end
+        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|
+          range = target.loc.selector.join(node.parent.loc.selector.end)
+
+          add_offense(range, message: format_message(method, range.source)) 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")
+        def use_array_converter_method_as_preceding?(node)
+          return false unless (preceding_method = node.children.first.children.first)
+          unless preceding_method.call_type? ||
+                 preceding_method.block_type? || preceding_method.numblock_type?
+            return false
+          end
+
+          ARRAY_CONVERTER_METHODS.include?(preceding_method.method_name)
+        end
+
+        def root_receiver(node)
+          receiver = node.receiver
+          if receiver&.receiver
+            root_receiver(receiver)
+          else
+            receiver
+          end
+        end
+
+        def format_message(method_name, current)
+          format(MSG, prefer: "each_#{method_name[0..-2]}", current: current)
         end
 
         def check_argument(variable)
@@ -103,7 +197,7 @@ module RuboCop
           name = "each_#{node.receiver.method_name.to_s.chop}"
           return correct_implicit(node, corrector, name) unless receiver
 
-          new_source = receiver.source + ".#{name}"
+          new_source = receiver.source + "#{node.loc.dot.source}#{name}"
           corrector.replace(node, new_source)
         end
 

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

@@ -23,9 +23,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) }
+      #   {foo: 1, bar: 2, baz: 3}.reject {|k, v| %i[bar].include?(k) }
+      #   {foo: 1, bar: 2, baz: 3}.select {|k, v| !%i[bar].include?(k) }
+      #   {foo: 1, bar: 2, baz: 3}.filter {|k, v| !%i[bar].include?(k) }
       #
       #   # good
       #   {foo: 1, bar: 2, baz: 3}.except(:bar)
@@ -43,7 +43,7 @@ module RuboCop
         # @!method bad_method_with_poro?(node)
         def_node_matcher :bad_method_with_poro?, <<~PATTERN
           (block
-            (send _ _)
+            (call _ _)
             (args
               $(arg _)
               (arg _))
@@ -73,8 +73,9 @@ module RuboCop
         PATTERN
 
         def on_send(node)
+          method_name = node.method_name
           block = node.parent
-          return unless bad_method?(block) && semantically_except_method?(node, block)
+          return unless bad_method?(method_name, block) && semantically_except_method?(node, block)
 
           except_key = except_key(block)
           return if except_key.nil? || !safe_to_register_offense?(block, except_key)
@@ -86,11 +87,12 @@ module RuboCop
             corrector.replace(range, preferred_method)
           end
         end
+        alias on_csend on_send
 
         private
 
         # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        def bad_method?(block)
+        def bad_method?(method_name, 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
@@ -102,6 +104,8 @@ module RuboCop
             end
           else
             bad_method_with_poro?(block) do |key_arg, send_node|
+              return false if method_name == :reject && block.body.method?(:!)
+
               !send_node.method?(:include?) || send_node.first_argument&.source == key_arg.source
             end
           end

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

@@ -29,6 +29,8 @@ module RuboCop
       # * 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
+      # * either_consistent - accepts both shorthand and explicit use of hash literal value,
+      #                       but they must be consistent
       #
       # @example EnforcedStyle: ruby19 (default)
       #   # bad
@@ -110,6 +112,22 @@ module RuboCop
       #   # good - can't omit `baz`
       #   {foo: foo, bar: baz}
       #
+      # @example EnforcedShorthandSyntax: either_consistent
+      #
+      #   # good - `foo` and `bar` values can be omitted, but they are consistent, so it's accepted
+      #   {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
@@ -195,6 +213,7 @@ module RuboCop
           acceptable_19_syntax_symbol?(pair.key.source)
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def acceptable_19_syntax_symbol?(sym_name)
           sym_name.delete_prefix!(':')
 
@@ -209,9 +228,12 @@ module RuboCop
           # Most hash keys can be matched against a simple regex.
           return true if /\A[_a-z]\w*[?!]?\z/i.match?(sym_name)
 
-          # For more complicated hash keys, let the parser validate the syntax.
-          parse("{ #{sym_name}: :foo }").valid_syntax?
+          return false if target_ruby_version <= 2.1
+
+          (sym_name.start_with?("'") && sym_name.end_with?("'")) ||
+            (sym_name.start_with?('"') && sym_name.end_with?('"'))
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def check(pairs, delim, msg)
           pairs.each do |pair|

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

@@ -153,7 +153,18 @@ module RuboCop
           return unless duplicated_expressions?(node, heads)
 
           condition_variable = assignable_condition_value(node)
-          return if heads.first.assignment? && condition_variable == heads.first.name.to_s
+
+          head = heads.first
+          if head.assignment?
+            # The `send` node is used instead of the `indexasgn` node, so `name` cannot be used.
+            # https://github.com/rubocop/rubocop-ast/blob/v1.29.0/lib/rubocop/ast/node/indexasgn_node.rb
+            #
+            # FIXME: It would be better to update `RuboCop::AST::OpAsgnNode` or its subclasses to
+            # handle `self.foo ||= value` as a solution, instead of using `head.node_parts[0].to_s`.
+            assigned_value = head.send_type? ? head.receiver.source : head.node_parts[0].to_s
+
+            return if condition_variable == assigned_value
+          end
 
           check_expressions(node, heads, :before_condition)
         end

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

@@ -112,9 +112,11 @@ module RuboCop
         end
 
         def message(node, keyword)
-          message_template = node.elsif? ? MSG_FOR_ELSIF : MSG
-
-          format(message_template, keyword: keyword)
+          if node.elsif?
+            MSG_FOR_ELSIF
+          else
+            format(MSG, keyword: keyword)
+          end
         end
 
         def return_boolean_value?(condition)

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

@@ -60,25 +60,25 @@ module RuboCop
         # @!method inverse_candidate?(node)
         def_node_matcher :inverse_candidate?, <<~PATTERN
           {
-            (send $(send $(...) $_ $...) :!)
-            (send ({block numblock} $(send $(...) $_) $...) :!)
-            (send (begin $(send $(...) $_ $...)) :!)
+            (send $(call $(...) $_ $...) :!)
+            (send ({block numblock} $(call $(...) $_) $...) :!)
+            (send (begin $(call $(...) $_ $...)) :!)
           }
         PATTERN
 
         # @!method inverse_block?(node)
         def_node_matcher :inverse_block?, <<~PATTERN
-          ({block numblock} $(send (...) $_) ... { $(send ... :!)
+          ({block numblock} $(call (...) $_) ... { $(call ... :!)
                                                    $(send (...) {:!= :!~} ...)
-                                                   (begin ... $(send ... :!))
+                                                   (begin ... $(call ... :!))
                                                    (begin ... $(send (...) {:!= :!~} ...))
                                                  })
         PATTERN
 
         def on_send(node)
-          inverse_candidate?(node) do |_method_call, lhs, method, rhs|
+          inverse_candidate?(node) do |method_call, lhs, method, rhs|
             return unless inverse_methods.key?(method)
-            return if negated?(node)
+            return if negated?(node) || relational_comparison_with_safe_navigation?(method_call)
             return if part_of_ignored_node?(node)
             return if possible_class_hierarchy_check?(lhs, rhs, method)
 
@@ -87,6 +87,7 @@ module RuboCop
             end
           end
         end
+        alias on_csend on_send
 
         def on_block(node)
           inverse_block?(node) do |_method_call, method, block|
@@ -154,16 +155,16 @@ module RuboCop
           node.parent.respond_to?(:method?) && node.parent.method?(:!)
         end
 
+        def relational_comparison_with_safe_navigation?(node)
+          node.csend_type? && CLASS_COMPARISON_METHODS.include?(node.method_name)
+        end
+
         def not_to_receiver(node, method_call)
-          Parser::Source::Range.new(node.source_range.source_buffer,
-                                    node.loc.selector.begin_pos,
-                                    method_call.source_range.begin_pos)
+          node.loc.selector.begin.join(method_call.source_range.begin)
         end
 
         def end_parentheses(node, method_call)
-          Parser::Source::Range.new(node.source_range.source_buffer,
-                                    method_call.source_range.end_pos,
-                                    node.source_range.end_pos)
+          method_call.source_range.end.join(node.source_range.end)
         end
 
         # When comparing classes, `!(Integer < Numeric)` is not the same as

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

@@ -32,12 +32,14 @@ module RuboCop
       #   foo unless x != y
       #   foo unless x >= 10
       #   foo unless x.even?
+      #   foo unless odd?
       #
       #   # good
       #   foo if bar
       #   foo if x == y
       #   foo if x < 10
       #   foo if x.odd?
+      #   foo if even?
       #
       #   # bad (complex condition)
       #   foo unless x != y || x.even?
@@ -51,7 +53,7 @@ module RuboCop
       class InvertibleUnlessCondition < Base
         extend AutoCorrector
 
-        MSG = 'Favor `if` with inverted condition over `unless`.'
+        MSG = 'Prefer `%<prefer>s` over `%<current>s`.'
 
         def on_if(node)
           return unless node.unless?
@@ -59,7 +61,10 @@ module RuboCop
           condition = node.condition
           return unless invertible?(condition)
 
-          add_offense(node) do |corrector|
+          message = format(MSG, prefer: "#{node.inverse_keyword} #{preferred_condition(condition)}",
+                                current: "#{node.keyword} #{condition.source}")
+
+          add_offense(node, message: message) do |corrector|
             corrector.replace(node.loc.keyword, node.inverse_keyword)
             autocorrect(corrector, condition)
           end
@@ -88,6 +93,43 @@ module RuboCop
             (argument.const_type? && argument.short_name.to_s.upcase != argument.short_name.to_s)
         end
 
+        def preferred_condition(node)
+          case node.type
+          when :begin    then "(#{preferred_condition(node.children.first)})"
+          when :send     then preferred_send_condition(node)
+          when :or, :and then preferred_logical_condition(node)
+          end
+        end
+
+        def preferred_send_condition(node) # rubocop:disable Metrics/CyclomaticComplexity
+          receiver_source = node.receiver&.source
+          return receiver_source if node.method?(:!)
+
+          # receiver may be implicit (self)
+          dotted_receiver_source = receiver_source ? "#{receiver_source}." : ''
+
+          inverse_method_name = inverse_methods[node.method_name]
+          return "#{dotted_receiver_source}#{inverse_method_name}" unless node.arguments?
+
+          argument_list = node.arguments.map(&:source).join(', ')
+          if node.operator_method?
+            return "#{receiver_source} #{inverse_method_name} #{argument_list}"
+          end
+
+          if node.parenthesized?
+            return "#{dotted_receiver_source}#{inverse_method_name}(#{argument_list})"
+          end
+
+          "#{dotted_receiver_source}#{inverse_method_name} #{argument_list}"
+        end
+
+        def preferred_logical_condition(node)
+          preferred_lhs = preferred_condition(node.lhs)
+          preferred_rhs = preferred_condition(node.rhs)
+
+          "#{preferred_lhs} #{node.inverse_operator} #{preferred_rhs}"
+        end
+
         def autocorrect(corrector, node)
           case node.type
           when :begin

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

@@ -4,6 +4,7 @@ module RuboCop
   module Cop
     module Style
       # Prefer `select` or `reject` over `map { ... }.compact`.
+      # This cop also handles `filter_map { ... }`, similar to `map { ... }.compact`.
       #
       # @example
       #
@@ -11,6 +12,9 @@ module RuboCop
       #   array.map { |e| some_condition? ? e : next }.compact
       #
       #   # bad
+      #   array.filter_map { |e| some_condition? ? e : next }
+      #
+      #   # bad
       #   array.map do |e|
       #     if some_condition?
       #       e
@@ -40,54 +44,73 @@ module RuboCop
       class MapCompactWithConditionalBlock < Base
         extend AutoCorrector
 
-        MSG = 'Replace `map { ... }.compact` with `%<method>s`.'
-
-        # @!method map_and_compact?(node)
-        def_node_matcher :map_and_compact?, <<~RUBY
-          (send
-            (block
-              (send _ :map)
-              (args
-                $(arg _))
-              {
-                (if $_ $(lvar _) {next nil?})
-                (if $_ {next nil?} $(lvar _))
-                (if $_ (next $(lvar _)) {next nil nil?})
-                (if $_ {next nil nil?} (next $(lvar _)))
-                (begin
-                  {
-                    (if $_ next nil?)
-                    (if $_ nil? next)
-                  }
-                  $(lvar _))
-                (begin
-                  {
-                    (if $_ (next $(lvar _)) nil?)
-                    (if $_ nil? (next $(lvar _)))
-                  }
-                  (nil))
-              }) :compact)
+        MSG = 'Replace `%<current>s` with `%<method>s`.'
+        RESTRICT_ON_SEND = %i[compact filter_map].freeze
+
+        # @!method conditional_block(node)
+        def_node_matcher :conditional_block, <<~RUBY
+          (block
+            (call _ {:map :filter_map})
+            (args
+              $(arg _))
+            {
+              (if $_ $(lvar _) {next nil?})
+              (if $_ {next nil?} $(lvar _))
+              (if $_ (next $(lvar _)) {next nil nil?})
+              (if $_ {next nil nil?} (next $(lvar _)))
+              (begin
+                {
+                  (if $_ next nil?)
+                  (if $_ nil? next)
+                }
+                $(lvar _))
+              (begin
+                {
+                  (if $_ (next $(lvar _)) nil?)
+                  (if $_ nil? (next $(lvar _)))
+                }
+                (nil))
+            })
         RUBY
 
         def on_send(node)
-          map_and_compact?(node) do |block_argument_node, condition_node, return_value_node|
-            return unless returns_block_argument?(block_argument_node, return_value_node)
-            return if condition_node.parent.elsif?
-
-            method = truthy_branch?(return_value_node) ? 'select' : 'reject'
-            range = range(node)
-
-            add_offense(range, message: format(MSG, method: method)) do |corrector|
-              corrector.replace(
-                range,
-                "#{method} { |#{block_argument_node.source}| #{condition_node.source} }"
-              )
-            end
+          map_candidate = node.children.first
+          if (block_argument, condition, return_value = conditional_block(map_candidate))
+            return unless node.method?(:compact) && node.arguments.empty?
+
+            range = map_with_compact_range(node)
+          elsif (block_argument, condition, return_value = conditional_block(node.parent))
+            return unless node.method?(:filter_map)
+
+            range = filter_map_range(node)
+          else
+            return
           end
+
+          inspect(node, block_argument, condition, return_value, range)
         end
+        alias on_csend on_send
 
         private
 
+        def inspect(node, block_argument_node, condition_node, return_value_node, range)
+          return unless returns_block_argument?(block_argument_node, return_value_node)
+          return if condition_node.parent.elsif?
+
+          method = truthy_branch?(return_value_node) ? 'select' : 'reject'
+          current = current(node)
+
+          add_offense(range, message: format(MSG, current: current, method: method)) do |corrector|
+            return if part_of_ignored_node?(node) || ignored_node?(node)
+
+            corrector.replace(
+              range, "#{method} { |#{block_argument_node.source}| #{condition_node.source} }"
+            )
+
+            ignore_node(node)
+          end
+        end
+
         def returns_block_argument?(block_argument_node, return_value_node)
           block_argument_node.name == return_value_node.children.first
         end
@@ -115,20 +138,29 @@ module RuboCop
         def truthy_branch_for_guard?(node)
           if_node = node.left_sibling
 
-          if if_node.if? || if_node.ternary?
-            if_node.else_branch.nil?
-          elsif if_node.unless?
-            if_node.if_branch.nil?
+          if if_node.if?
+            if_node.if_branch.arguments.any?
+          else
+            if_node.if_branch.arguments.none?
           end
         end
 
-        def range(node)
-          buffer = node.source_range.source_buffer
-          map_node = node.receiver.send_node
-          begin_pos = map_node.loc.selector.begin_pos
-          end_pos = node.source_range.end_pos
+        def current(node)
+          if node.method?(:compact)
+            map_or_filter_map_method = node.children.first
+
+            "#{map_or_filter_map_method.method_name} { ... }.compact"
+          else
+            'filter_map { ... }'
+          end
+        end
+
+        def map_with_compact_range(node)
+          node.receiver.send_node.loc.selector.begin.join(node.source_range.end)
+        end
 
-          Parser::Source::Range.new(buffer, begin_pos, end_pos)
+        def filter_map_range(node)
+          node.loc.selector.join(node.parent.source_range.end)
         end
       end
     end