rubocop 1.51.0 → 1.54.1

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

@@ -158,13 +158,16 @@ module RuboCop
           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
+        # 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 +187,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)

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

@@ -47,7 +47,7 @@ module RuboCop
         def correct_elsif(node)
           <<~RUBY.chop
             if #{node.condition.source}
-              #{node.if_branch.source}
+              #{node.if_branch&.source}
             #{build_else_branch(node.else_branch).chop}
             end
           RUBY
@@ -56,7 +56,7 @@ module RuboCop
         def build_else_branch(second_condition)
           result = <<~RUBY
             elsif #{second_condition.condition.source}
-              #{second_condition.if_branch.source}
+              #{second_condition.if_branch&.source}
           RUBY
 
           if second_condition.else_branch

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

@@ -72,7 +72,7 @@ module RuboCop
           when :begin
             invertible?(node.children.first)
           when :send
-            return if inheritance_check?(node)
+            return false if inheritance_check?(node)
 
             node.method?(:!) || inverse_methods.key?(node.method_name)
           when :or, :and

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

@@ -69,10 +69,10 @@ module RuboCop
           return unless offending_selector?(node, selector)
 
           add_offense(node.send_node.source_range, message: message(node, selector)) do |corrector|
-            if node.send_node.source == 'lambda'
-              autocorrect_method_to_literal(corrector, node)
-            else
+            if node.send_node.lambda_literal?
               LambdaLiteralToMethodCorrector.new(node).call(corrector)
+            else
+              autocorrect_method_to_literal(corrector, node)
             end
           end
         end

data/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb

@@ -98,7 +98,7 @@ module RuboCop
 
           def call_in_literals?(node)
             parent = node.parent&.block_type? ? node.parent.parent : node.parent
-            return unless parent
+            return false unless parent
 
             parent.pair_type? ||
               parent.array_type? ||
@@ -109,7 +109,7 @@ module RuboCop
 
           def call_in_logical_operators?(node)
             parent = node.parent&.block_type? ? node.parent.parent : node.parent
-            return unless parent
+            return false unless parent
 
             logical_operator?(parent) ||
               (parent.send_type? &&
@@ -135,8 +135,7 @@ module RuboCop
           end
 
           def call_with_braced_block?(node)
-            (node.send_type? || node.super_type?) &&
-              ((node.parent&.block_type? || node.parent&.numblock_type?) && node.parent&.braces?)
+            (node.send_type? || node.super_type?) && node.block_node&.braces?
           end
 
           def call_as_argument_or_chain?(node)

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

@@ -40,6 +40,15 @@ module RuboCop
       #
       #   # good
       #   foo if [b.lightweight, b.heavyweight].include?(a)
+      #
+      # @example ComparisonsThreshold: 2 (default)
+      #   # bad
+      #   foo if a == 'a' || a == 'b'
+      #
+      # @example ComparisonsThreshold: 3
+      #   # good
+      #   foo if a == 'a' || a == 'b'
+      #
       class MultipleComparison < Base
         extend AutoCorrector
 
@@ -58,6 +67,7 @@ module RuboCop
           return unless node == root_of_or_node
           return unless nested_variable_comparison?(root_of_or_node)
           return if @allowed_method_comparison
+          return if @compared_elements.size < comparisons_threshold
 
           add_offense(node) do |corrector|
             elements = @compared_elements.join(', ')
@@ -151,6 +161,10 @@ module RuboCop
         def allow_method_comparison?
           cop_config.fetch('AllowMethodComparison', true)
         end
+
+        def comparisons_threshold
+          cop_config.fetch('ComparisonsThreshold', 2)
+        end
       end
     end
   end

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

@@ -121,7 +121,7 @@ module RuboCop
 
         def allowed_patterns
           # Convert the patterns to be anchored
-          super.map { |regexp| Regexp.new(/\A#{regexp}\z/) }
+          super.map { |regexp| /\A#{regexp}\z/ }
         end
       end
     end

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

@@ -61,7 +61,7 @@ module RuboCop
           if style == :verbose
             "has_#{method_name}"
           else
-            method_name.to_s.sub(/has_/, '')
+            method_name.to_s.delete_prefix('has_')
           end
         end
 

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for the instantiation of array using redundant `Array` constructor.
+      # Autocorrect replaces to array literal which is the simplest and fastest.
+      #
+      # @example
+      #
+      #   # bad
+      #   Array.new([])
+      #   Array[]
+      #   Array([])
+      #   Array.new(['foo', 'foo', 'foo'])
+      #   Array['foo', 'foo', 'foo']
+      #   Array(['foo', 'foo', 'foo'])
+      #
+      #   # good
+      #   []
+      #   ['foo', 'foo', 'foo']
+      #   Array.new(3, 'foo')
+      #   Array.new(3) { 'foo' }
+      #
+      class RedundantArrayConstructor < Base
+        extend AutoCorrector
+
+        MSG = 'Remove the redundant `Array` constructor.'
+
+        RESTRICT_ON_SEND = %i[new [] Array].freeze
+
+        # @!method redundant_array_constructor(node)
+        def_node_matcher :redundant_array_constructor, <<~PATTERN
+          {
+            (send
+              (const {nil? cbase} :Array) :new
+              $(array ...))
+            (send
+              (const {nil? cbase} :Array) :[]
+              $...)
+            (send
+              nil? :Array
+              $(array ...))
+          }
+        PATTERN
+
+        def on_send(node)
+          return unless (array_literal = redundant_array_constructor(node))
+
+          receiver = node.receiver
+          selector = node.loc.selector
+
+          if node.method?(:new)
+            range = receiver.source_range.join(selector)
+            replacement = array_literal
+          elsif node.method?(:Array)
+            range = selector
+            replacement = array_literal
+          else
+            range = receiver
+            replacement = selector.begin.join(node.source_range.end)
+          end
+
+          register_offense(range, node, replacement)
+        end
+
+        private
+
+        def register_offense(range, node, replacement)
+          add_offense(range) do |corrector|
+            corrector.replace(node, replacement.source)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -146,7 +146,7 @@ module RuboCop
         end
 
         def use_modifier_form_after_multiline_begin_block?(node)
-          return unless (parent = node.parent)
+          return false unless (parent = node.parent)
 
           node.multiline? && parent.if_type? && parent.modifier_form?
         end

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

@@ -63,7 +63,7 @@ module RuboCop
         RUBY
 
         def offense?(node)
-          return if node.modifier_form?
+          return false if node.modifier_form?
 
           redundant_condition?(node) || redundant_condition_inverted?(node)
         end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for uses a redundant current directory in path.
+      #
+      # @example
+      #
+      #   # bad
+      #   require_relative './path/to/feature'
+      #
+      #   # good
+      #   require_relative 'path/to/feature'
+      #
+      class RedundantCurrentDirectoryInPath < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Remove the redundant current directory path.'
+        CURRENT_DIRECTORY_PATH = './'
+
+        def on_send(node)
+          return unless node.method?(:require_relative)
+          return unless node.first_argument.str_content&.start_with?(CURRENT_DIRECTORY_PATH)
+          return unless (index = node.first_argument.source.index(CURRENT_DIRECTORY_PATH))
+
+          begin_pos = node.first_argument.source_range.begin.begin_pos + index
+          range = range_between(begin_pos, begin_pos + 2)
+
+          add_offense(range) do |corrector|
+            corrector.remove(range)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Identifies usages of `any?`, `empty?` or `none?` predicate methods
+      # chained to `select`/`filter`/`find_all` and change them to use predicate method instead.
+      #
+      # @example
+      #   # bad
+      #   arr.select { |x| x > 1 }.any?
+      #
+      #   # good
+      #   arr.any? { |x| x > 1 }
+      #
+      #   # bad
+      #   arr.select { |x| x > 1 }.empty?
+      #   arr.select { |x| x > 1 }.none?
+      #
+      #   # good
+      #   arr.none? { |x| x > 1 }
+      #
+      #   # good
+      #   relation.select(:name).any?
+      #   arr.select { |x| x > 1 }.any?(&:odd?)
+      #
+      # @example AllCops:ActiveSupportExtensionsEnabled: false (default)
+      #   # good
+      #   arr.select { |x| x > 1 }.many?
+      #
+      # @example AllCops:ActiveSupportExtensionsEnabled: true
+      #   # bad
+      #   arr.select { |x| x > 1 }.many?
+      #
+      #   # good
+      #   arr.many? { |x| x > 1 }
+      #
+      class RedundantFilterChain < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<prefer>s` instead of `%<first_method>s.%<second_method>s`.'
+
+        RAILS_METHODS = %i[many?].freeze
+        RESTRICT_ON_SEND = (%i[any? empty? none? one?] + RAILS_METHODS).freeze
+
+        # @!method select_predicate?(node)
+        def_node_matcher :select_predicate?, <<~PATTERN
+          (send
+            {
+              (block $(send _ {:select :filter :find_all}) ...)
+              $(send _ {:select :filter :find_all} block_pass_type?)
+            }
+            ${:#{RESTRICT_ON_SEND.join(' :')}})
+        PATTERN
+
+        REPLACEMENT_METHODS = {
+          any?: :any?,
+          empty?: :none?,
+          none?: :none?,
+          one?: :one?,
+          many?: :many?
+        }.freeze
+        private_constant :REPLACEMENT_METHODS
+
+        def on_send(node)
+          return if node.arguments? || node.block_node
+
+          select_predicate?(node) do |select_node, filter_method|
+            return if RAILS_METHODS.include?(filter_method) && !active_support_extensions_enabled?
+
+            register_offense(select_node, node)
+          end
+        end
+
+        private
+
+        def register_offense(select_node, predicate_node)
+          replacement = REPLACEMENT_METHODS[predicate_node.method_name]
+          message = format(MSG, prefer: replacement,
+                                first_method: select_node.method_name,
+                                second_method: predicate_node.method_name)
+
+          offense_range = offense_range(select_node, predicate_node)
+
+          add_offense(offense_range, message: message) do |corrector|
+            corrector.remove(predicate_range(predicate_node))
+            corrector.replace(select_node.loc.selector, replacement)
+          end
+        end
+
+        def offense_range(select_node, predicate_node)
+          select_node.loc.selector.join(predicate_node.loc.selector)
+        end
+
+        def predicate_range(predicate_node)
+          predicate_node.receiver.source_range.end.join(predicate_node.loc.selector)
+        end
+      end
+    end
+  end
+end

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

@@ -116,7 +116,7 @@ module RuboCop
           return false if argument_newline?(node)
 
           source = node.parent ? node.parent.source : node.source
-          parse(source.gsub(/\\\n/, "\n")).valid_syntax?
+          parse(source.gsub("\\\n", "\n")).valid_syntax?
         end
 
         def inside_string_literal?(range, token)
@@ -150,7 +150,7 @@ module RuboCop
         end
 
         def same_line?(node, line)
-          return unless (source_range = node.source_range)
+          return false unless (source_range = node.source_range)
 
           if node.is_a?(AST::StrNode)
             if node.heredoc?

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

@@ -85,7 +85,7 @@ module RuboCop
         end
 
         def allowed_ternary?(node)
-          return unless node&.parent&.if_type?
+          return false unless node&.parent&.if_type?
 
           node.parent.ternary? && ternary_parentheses_required?
         end

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Identifies places where argument can be replaced from
+      # a deterministic regexp to a string.
+      #
+      # @example
+      #   # bad
+      #   'foo'.byteindex(/f/)
+      #   'foo'.byterindex(/f/)
+      #   'foo'.gsub(/f/, 'x')
+      #   'foo'.gsub!(/f/, 'x')
+      #   'foo'.partition(/f/)
+      #   'foo'.rpartition(/f/)
+      #   'foo'.scan(/f/)
+      #   'foo'.split(/f/)
+      #   'foo'.start_with?(/f/)
+      #   'foo'.sub(/f/, 'x')
+      #   'foo'.sub!(/f/, 'x')
+      #
+      #   # good
+      #   'foo'.byteindex('f')
+      #   'foo'.byterindex('f')
+      #   'foo'.gsub('f', 'x')
+      #   'foo'.gsub!('f', 'x')
+      #   'foo'.partition('f')
+      #   'foo'.rpartition('f')
+      #   'foo'.scan('f')
+      #   'foo'.split('f')
+      #   'foo'.start_with?('f')
+      #   'foo'.sub('f', 'x')
+      #   'foo'.sub!('f', 'x')
+      class RedundantRegexpArgument < Base
+        extend AutoCorrector
+
+        MSG = 'Use string `%<prefer>s` as argument instead of regexp `%<current>s`.'
+        RESTRICT_ON_SEND = %i[
+          byteindex byterindex gsub gsub! partition rpartition scan split start_with? sub sub!
+        ].freeze
+        DETERMINISTIC_REGEX = /\A(?:#{LITERAL_REGEX})+\Z/.freeze
+        STR_SPECIAL_CHARS = %w[
+          \a \c \C \e \f \M \n \" \' \\\\ \t \b \f \r \u \v \x \0 \1 \2 \3 \4 \5 \6 \7
+        ].freeze
+
+        def on_send(node)
+          return unless (regexp_node = node.first_argument)
+          return unless regexp_node.regexp_type?
+          return if !regexp_node.regopt.children.empty? || regexp_node.content == ' '
+          return unless determinist_regexp?(regexp_node)
+
+          prefer = preferred_argument(regexp_node)
+          message = format(MSG, prefer: prefer, current: regexp_node.source)
+
+          add_offense(regexp_node, message: message) do |corrector|
+            corrector.replace(regexp_node, prefer)
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def determinist_regexp?(regexp_node)
+          DETERMINISTIC_REGEX.match?(regexp_node.source)
+        end
+
+        def preferred_argument(regexp_node)
+          new_argument = replacement(regexp_node)
+
+          if new_argument.include?('"')
+            new_argument.gsub!("'", "\\\\'")
+            quote = "'"
+          else
+            quote = '"'
+          end
+
+          "#{quote}#{new_argument}#{quote}"
+        end
+
+        def replacement(regexp_node)
+          regexp_content = regexp_node.content
+          stack = []
+          chars = regexp_content.chars.each_with_object([]) do |char, strings|
+            if stack.empty? && char == '\\'
+              stack.push(char)
+            else
+              strings << "#{stack.pop}#{char}"
+            end
+          end
+          chars.map do |char|
+            char = char.dup
+            char.delete!('\\') unless STR_SPECIAL_CHARS.include?(char)
+            char
+          end.join
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for the instantiation of regexp using redundant `Regexp.new` or `Regexp.compile`.
+      # Autocorrect replaces to regexp literal which is the simplest and fastest.
+      #
+      # @example
+      #
+      #   # bad
+      #   Regexp.new(/regexp/)
+      #   Regexp.compile(/regexp/)
+      #
+      #   # good
+      #   /regexp/
+      #   Regexp.new('regexp')
+      #   Regexp.compile('regexp')
+      #
+      class RedundantRegexpConstructor < Base
+        extend AutoCorrector
+
+        MSG = 'Remove the redundant `Regexp.%<method>s`.'
+        RESTRICT_ON_SEND = %i[new compile].freeze
+
+        # @!method redundant_regexp_constructor(node)
+        def_node_matcher :redundant_regexp_constructor, <<~PATTERN
+          (send
+            (const {nil? cbase} :Regexp) {:new :compile}
+            (regexp $... (regopt $...)))
+        PATTERN
+
+        def on_send(node)
+          return unless (regexp, regopt = redundant_regexp_constructor(node))
+
+          add_offense(node, message: format(MSG, method: node.method_name)) do |corrector|
+            pattern = regexp.map(&:source).join
+            regopt = regopt.join
+
+            corrector.replace(node, "/#{pattern}/#{regopt}")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -44,7 +44,8 @@ module RuboCop
 
         def on_regexp(node)
           each_escape(node) do |char, index, within_character_class|
-            next if allowed_escape?(node, char, index, within_character_class)
+            next if char.valid_encoding? && allowed_escape?(node, char, index,
+                                                            within_character_class)
 
             location = escape_range_at_index(node, index)
 

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

@@ -62,7 +62,9 @@ module RuboCop
         end
 
         def multiple_statements?(branch)
-          branch && branch.children.compact.count > 1
+          return false unless branch&.begin_type?
+
+          !branch.children.empty?
         end
 
         def self_assign?(variable, branch)

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

@@ -198,7 +198,7 @@ module RuboCop
         end
 
         def with_logical_operator?(node)
-          return unless (parent = node.parent)
+          return false unless (parent = node.parent)
 
           parent.or_type? || parent.and_type?
         end

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

@@ -157,6 +157,8 @@ module RuboCop
             return delimiter?(node.parent, char)
           end
 
+          return true unless node.loc.begin
+
           delimiters = [node.loc.begin.source[-1], node.loc.end.source[0]]
 
           delimiters.include?(char)

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

@@ -106,8 +106,9 @@ module RuboCop
             break unless sibling&.send_type? && sibling&.method?(node.method_name)
             break unless sibling.arguments? && !sibling.receiver
             break unless in_same_section?(sibling, node)
+            break unless node.first_argument.str_type? && sibling.first_argument.str_type?
 
-            node.first_argument.source < sibling.first_argument.source
+            node.first_argument.value < sibling.first_argument.value
           end
         end
 

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

@@ -3,9 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for uses of rescue in its modifier form.
-      #
-      # The cop to check `rescue` in its modifier form is added for following
+      # Checks for uses of `rescue` in its modifier form is added for following
       # reasons:
       #
       # * The syntax of modifier form `rescue` can be misleading because it