rubocop 1.50.2 → 1.59.0

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

@@ -4,12 +4,12 @@ module RuboCop
   module Cop
     module Style
       # Ensures that eval methods (`eval`, `instance_eval`, `class_eval`
-      # and `module_eval`) are given filename and line number values (`__FILE__`
-      # and `__LINE__`). This data is used to ensure that any errors raised
+      # and `module_eval`) are given filename and line number values (`\_\_FILE\_\_`
+      # and `\_\_LINE\_\_`). This data is used to ensure that any errors raised
       # within the evaluated code will be given the correct identification
       # in a backtrace.
       #
-      # The cop also checks that the line number given relative to `__LINE__` is
+      # The cop also checks that the line number given relative to `\_\_LINE\_\_` is
       # correct.
       #
       # This cop will autocorrect incorrect or missing filename and line number
@@ -57,7 +57,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Pass `__FILE__` and `__LINE__` to `%<method_name>s`.'
-        MSG_EVAL = 'Pass a binding, `__FILE__` and `__LINE__` to `eval`.'
+        MSG_EVAL = 'Pass a binding, `__FILE__`, and `__LINE__` to `eval`.'
         MSG_INCORRECT_FILE = 'Incorrect file for `%<method_name>s`; ' \
                              'use `%<expected>s` instead of `%<actual>s`.'
         MSG_INCORRECT_LINE = 'Incorrect line number for `%<method_name>s`; ' \
@@ -84,7 +84,7 @@ module RuboCop
           # are considered.
           return if node.method?(:eval) && !valid_eval_receiver?(node.receiver)
 
-          code = node.arguments.first
+          code = node.first_argument
           return unless code && (code.str_type? || code.dstr_type?)
 
           check_location(node, code)
@@ -165,7 +165,7 @@ module RuboCop
         end
 
         def check_line(node, code)
-          line_node = node.arguments.last
+          line_node = node.last_argument
           line_diff = line_difference(line_node, code)
           if line_diff.zero?
             add_offense_for_same_line(node, line_node)
@@ -210,7 +210,7 @@ module RuboCop
         def add_offense_for_missing_line(node, code)
           register_offense(node) do |corrector|
             line_str = missing_line(node, code)
-            corrector.insert_after(node.source_range.end, ", #{line_str}")
+            corrector.insert_after(node.last_argument.source_range.end, ", #{line_str}")
           end
         end
 
@@ -227,7 +227,7 @@ module RuboCop
         end
 
         def missing_line(node, code)
-          line_diff = line_difference(node.arguments.last, code)
+          line_diff = line_difference(node.last_argument, code)
           sign = line_diff.positive? ? :+ : :-
           expected_line(sign, line_diff)
         end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for exact regexp match inside Regexp literals.
+      #
+      # @example
+      #
+      #   # bad
+      #   string =~ /\Astring\z/
+      #   string === /\Astring\z/
+      #   string.match(/\Astring\z/)
+      #   string.match?(/\Astring\z/)
+      #
+      #   # good
+      #   string == 'string'
+      #
+      #   # bad
+      #   string !~ /\Astring\z/
+      #
+      #   # good
+      #   string != 'string'
+      #
+      class ExactRegexpMatch < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<prefer>s`.'
+        RESTRICT_ON_SEND = %i[=~ === !~ match match?].freeze
+
+        # @!method exact_regexp_match(node)
+        def_node_matcher :exact_regexp_match, <<~PATTERN
+          (call
+            _ {:=~ :=== :!~ :match :match?}
+            (regexp
+              (str $_)
+              (regopt)))
+        PATTERN
+
+        def on_send(node)
+          return unless (regexp = exact_regexp_match(node))
+
+          parsed_regexp = Regexp::Parser.parse(regexp)
+          return unless exact_match_pattern?(parsed_regexp)
+
+          prefer = "#{node.receiver.source} #{new_method(node)} '#{parsed_regexp[1].text}'"
+
+          add_offense(node, message: format(MSG, prefer: prefer)) do |corrector|
+            corrector.replace(node, prefer)
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def exact_match_pattern?(parsed_regexp)
+          tokens = parsed_regexp.map(&:token)
+          return false unless tokens[0] == :bos && tokens[1] == :literal && tokens[2] == :eos
+
+          !parsed_regexp[1].quantifier
+        end
+
+        def new_method(node)
+          node.method?(:!~) ? '!=' : '=='
+        end
+      end
+    end
+  end
+end

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

@@ -86,7 +86,7 @@ module RuboCop
 
         def extract_block_name(def_node)
           if def_node.block_argument?
-            def_node.arguments.last.name
+            def_node.last_argument.name
           else
             'block'
           end
@@ -127,7 +127,7 @@ module RuboCop
         end
 
         def insert_argument(node, corrector, block_name)
-          last_arg = node.arguments.last
+          last_arg = node.last_argument
           arg_range = range_with_surrounding_comma(last_arg.source_range, :right)
           replacement = " &#{block_name}"
           replacement = ",#{replacement}" unless arg_range.source.end_with?(',')

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

@@ -63,7 +63,7 @@ module RuboCop
 
         # @!method block_read?(node)
         def_node_matcher :block_read?, <<~PATTERN
-          (block _ (args (arg $_)) (send (lvar $_) :read))
+          (block _ (args (arg _name)) (send (lvar _name) :read))
         PATTERN
 
         def on_send(node)
@@ -100,7 +100,7 @@ module RuboCop
         def file_open_read?(node)
           return true if send_read?(node)
 
-          block_read?(node) { |block_arg, read_lvar| block_arg == read_lvar }
+          block_read?(node)
         end
 
         def read_method(mode)

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

@@ -80,7 +80,7 @@ module RuboCop
         private
 
         def suspect_enumerable?(node)
-          node.multiline? && node.send_node.method?(:each) && !node.send_node.arguments?
+          node.multiline? && node.method?(:each) && !node.send_node.arguments?
         end
       end
     end

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

@@ -4,13 +4,25 @@ module RuboCop
   module Cop
     module Style
       # Enforces the use of a single string formatting utility.
-      # Valid options include Kernel#format, Kernel#sprintf and String#%.
+      # Valid options include `Kernel#format`, `Kernel#sprintf`, and `String#%`.
       #
-      # The detection of String#% cannot be implemented in a reliable
+      # The detection of `String#%` cannot be implemented in a reliable
       # manner for all cases, so only two scenarios are considered -
       # if the first argument is a string literal and if the second
       # argument is an array literal.
       #
+      # Autocorrection will be applied when using argument is a literal or known built-in conversion
+      # methods such as `to_d`, `to_f`, `to_h`, `to_i`, `to_r`, `to_s`, and `to_sym` on variables,
+      # provided that their return value is not an array. For example, when using `to_s`,
+      # `'%s' % [1, 2, 3].to_s` can be autocorrected without any incompatibility:
+      #
+      # [source,ruby]
+      # ----
+      # '%s' % [1, 2, 3]        #=> '1'
+      # format('%s', [1, 2, 3]) #=> '[1, 2, 3]'
+      # '%s' % [1, 2, 3].to_s   #=> '[1, 2, 3]'
+      # ----
+      #
       # @example EnforcedStyle: format (default)
       #   # bad
       #   puts sprintf('%10s', 'hoge')
@@ -42,6 +54,9 @@ module RuboCop
         MSG = 'Favor `%<prefer>s` over `%<current>s`.'
         RESTRICT_ON_SEND = %i[format sprintf %].freeze
 
+        # Known conversion methods whose return value is not an array.
+        AUTOCORRECTABLE_METHODS = %i[to_d to_f to_h to_i to_r to_s to_sym].freeze
+
         # @!method formatter(node)
         def_node_matcher :formatter, <<~PATTERN
           {
@@ -53,7 +68,7 @@ module RuboCop
 
         # @!method variable_argument?(node)
         def_node_matcher :variable_argument?, <<~PATTERN
-          (send {str dstr} :% {send_type? lvar_type?})
+          (send {str dstr} :% #autocorrectable?)
         PATTERN
 
         def on_send(node)
@@ -70,6 +85,12 @@ module RuboCop
 
         private
 
+        def autocorrectable?(node)
+          return true if node.lvar_type?
+
+          node.send_type? && !AUTOCORRECTABLE_METHODS.include?(node.method_name)
+        end
+
         def message(detected_style)
           format(MSG, prefer: method_name(style), current: method_name(detected_style))
         end

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

@@ -142,7 +142,9 @@ module RuboCop
           end
 
           next_token = processed_source.tokens[token_number]
-          token = next_token if Encoding::ENCODING_PATTERN.match?(next_token&.text)
+          if next_token&.text&.valid_encoding? && Encoding::ENCODING_PATTERN.match?(next_token.text)
+            token = next_token
+          end
 
           token
         end

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

@@ -55,6 +55,25 @@ module RuboCop
       #   foo || raise('exception') if something
       #   ok
       #
+      #   # bad
+      #   define_method(:test) do
+      #     if something
+      #       work
+      #     end
+      #   end
+      #
+      #   # good
+      #   define_method(:test) do
+      #     return unless something
+      #
+      #     work
+      #   end
+      #
+      #   # also good
+      #   define_method(:test) do
+      #     work if something
+      #   end
+      #
       # @example AllowConsecutiveConditionals: false (default)
       #   # bad
       #   def test
@@ -110,6 +129,13 @@ module RuboCop
         end
         alias on_defs on_def
 
+        def on_block(node)
+          return unless node.method?(:define_method) || node.method?(:define_singleton_method)
+
+          on_def(node)
+        end
+        alias on_numblock on_block
+
         def on_if(node)
           return if accepted_form?(node)
 
@@ -187,6 +213,8 @@ module RuboCop
           if_branch = node.if_branch
           else_branch = node.else_branch
 
+          corrector.replace(node.loc.begin, "\n") if node.loc.begin&.is?('then')
+
           if if_branch&.send_type? && heredoc?(if_branch.last_argument)
             autocorrect_heredoc_argument(corrector, node, if_branch, else_branch, guard)
           elsif else_branch&.send_type? && heredoc?(else_branch.last_argument)

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

@@ -10,6 +10,16 @@ module RuboCop
       # `Hash[*ary]` can be replaced with `ary.each_slice(2).to_h` but it will be complicated.
       # So, `AllowSplatArgument` option is true by default to allow splat argument for simple code.
       #
+      # @safety
+      #   This cop's autocorrection is unsafe because `ArgumentError` occurs
+      #   if the number of elements is odd:
+      #
+      #   [source,ruby]
+      #   ----
+      #   Hash[[[1, 2], [3]]] #=> {1=>2, 3=>nil}
+      #   [[1, 2], [5]].to_h  #=> wrong array length at 1 (expected 2, was 1) (ArgumentError)
+      #   ----
+      #
       # @example
       #   # bad
       #   Hash[ary]

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']
@@ -28,26 +34,51 @@ module RuboCop
       #   execute(sql).keys.each { |v| p v }
       #   execute(sql).values.each { |v| p v }
       class HashEachMethods < Base
+        include AllowedReceivers
         include Lint::UnusedArgument
         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."
 
         # @!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
 
+        # rubocop:disable Metrics/AbcSize
         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
+
+          return unless (key, value = each_arguments(node))
+
+          if unused_block_arg_exist?(node, value)
+            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 unused_block_arg_exist?(node, key)
+            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
 
         alias on_numblock on_block
 
@@ -59,27 +90,70 @@ module RuboCop
 
         private
 
+        def handleable?(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).all? do |block_arg|
+              lvar_sources.none?(block_arg.source)
+            end
+          else
+            lvar_sources.none?(block_arg.source)
+          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 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)
@@ -102,7 +176,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
 
@@ -116,28 +190,6 @@ module RuboCop
         def kv_range(outer_node)
           outer_node.receiver.loc.selector.join(outer_node.loc.selector)
         end
-
-        def allowed_receiver?(receiver)
-          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
       end
     end
   end

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

@@ -43,15 +43,15 @@ module RuboCop
         # @!method bad_method_with_poro?(node)
         def_node_matcher :bad_method_with_poro?, <<~PATTERN
           (block
-            (send _ _)
+            (call _ _)
             (args
-              (arg _)
+              $(arg _)
               (arg _))
             {
-              (send
+              $(send
                 _ {:== :!= :eql? :include?} _)
               (send
-                (send
+                $(send
                   _ {:== :!= :eql? :include?} _) :!)
               })
         PATTERN
@@ -61,13 +61,13 @@ module RuboCop
           (block
             (send _ _)
             (args
-              (arg _)
+              $(arg _)
               (arg _))
             {
-              (send
+              $(send
                 _ {:== :!= :eql? :in? :include? :exclude?} _)
               (send
-                (send
+                $(send
                   _ {:== :!= :eql? :in? :include? :exclude?} _) :!)
               })
         PATTERN
@@ -86,16 +86,28 @@ 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)
           if active_support_extensions_enabled?
-            bad_method_with_active_support?(block)
+            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)
+            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

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

@@ -3,8 +3,8 @@
 module RuboCop
   module Cop
     module Style
-      # Looks for uses of `_.each_with_object({}) {...}`,
-      # `_.map {...}.to_h`, and `Hash[_.map {...}]` that are actually just
+      # 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.

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

@@ -3,8 +3,8 @@
 module RuboCop
   module Cop
     module Style
-      # Looks for uses of `_.each_with_object({}) {...}`,
-      # `_.map {...}.to_h`, and `Hash[_.map {...}]` that are actually just
+      # 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.
       #

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

@@ -136,7 +136,7 @@ module RuboCop
 
         private
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable Metrics/AbcSize, 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.
@@ -149,22 +149,47 @@ module RuboCop
                     branches.any? { |branch| single_child_branch?(branch) }
 
           heads = branches.map { |branch| head(branch) }
-          check_expressions(node, heads, :before_condition) if duplicated_expressions?(node, heads)
+
+          return unless duplicated_expressions?(node, heads)
+
+          condition_variable = assignable_condition_value(node)
+
+          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
+            assigned_value = head.send_type? ? head.receiver.source : head.name.to_s
+
+            return if condition_variable == assigned_value
+          end
+
+          check_expressions(node, heads, :before_condition)
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def duplicated_expressions?(node, expressions)
           unique_expressions = expressions.uniq
           return false unless expressions.size >= 1 && unique_expressions.one?
 
           unique_expression = unique_expressions.first
-          return true unless unique_expression.assignment?
+          return true unless unique_expression&.assignment?
 
           lhs = unique_expression.child_nodes.first
           node.condition.child_nodes.none? { |n| n.source == lhs.source if n.variable? }
         end
 
-        def check_expressions(node, expressions, insert_position) # rubocop:disable Metrics/MethodLength
+        def assignable_condition_value(node)
+          if node.condition.call_type?
+            (receiver = node.condition.receiver) ? receiver.source : node.condition.source
+          elsif node.condition.variable?
+            node.condition.source
+          end
+        end
+
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        def check_expressions(node, expressions, insert_position)
+          return if expressions.any?(&:nil?)
+
           inserted_expression = false
 
           expressions.each do |expression|
@@ -184,6 +209,7 @@ module RuboCop
             end
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
         def last_child_of_parent?(node)
           return true unless (parent = node.parent)