rubocop 1.51.0 → 1.52.1

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/hash_each_methods.rb

@@ -28,6 +28,7 @@ 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
 
@@ -116,28 +117,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_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/method_call_with_args_parentheses/omit_parentheses.rb

@@ -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/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_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_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/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

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

@@ -84,6 +84,7 @@ module RuboCop
           }
         PATTERN
 
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_send(node)
           return unless (block_node = node.block_node)
           return if block_node.body&.begin_type?
@@ -91,11 +92,14 @@ module RuboCop
           return unless (regexp_method_send_node = extract_send_node(block_node))
           return if match_predicate_without_receiver?(regexp_method_send_node)
 
-          opposite = opposite?(regexp_method_send_node)
+          replacement = replacement(regexp_method_send_node, node)
+          return if target_ruby_version <= 2.2 && replacement == 'grep_v'
+
           regexp = find_regexp(regexp_method_send_node, block_node)
 
-          register_offense(node, block_node, regexp, opposite)
+          register_offense(node, block_node, regexp, replacement)
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         private
 
@@ -105,9 +109,15 @@ module RuboCop
           node.hash_type? || creates_hash?(node) || env_const?(node)
         end
 
-        def register_offense(node, block_node, regexp, opposite)
-          method_name = node.method_name.to_sym
-          replacement = opposite ? OPPOSITE_REPLACEMENTS[method_name] : REPLACEMENTS[method_name]
+        def replacement(regexp_method_send_node, node)
+          opposite = opposite?(regexp_method_send_node)
+
+          method_name = node.method_name
+
+          opposite ? OPPOSITE_REPLACEMENTS[method_name] : REPLACEMENTS[method_name]
+        end
+
+        def register_offense(node, block_node, regexp, replacement)
           message = format(MSG, replacement: replacement, original_method: node.method_name)
 
           add_offense(block_node, message: message) do |corrector|

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

@@ -135,7 +135,7 @@ module RuboCop
 
         def disallow_endless_method_style?
           endless_method_config = config.for_cop('Style/EndlessMethod')
-          return false unless endless_method_config['Enabled']
+          return true unless endless_method_config['Enabled']
 
           endless_method_config['EnforcedStyle'] == 'disallow'
         end

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

@@ -186,7 +186,9 @@ module RuboCop
           begin_pos = condition.first_argument.source_range.begin_pos
           return if end_pos > begin_pos
 
-          corrector.replace(range_between(end_pos, begin_pos), '(')
+          range = range_between(end_pos, begin_pos)
+          corrector.remove(range)
+          corrector.insert_after(range, '(')
           corrector.insert_after(condition.last_argument, ')')
         end
 

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

@@ -3,8 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      #
-      # This cop looks for uses of Perl-style global variables.
+      # Looks for uses of Perl-style global variables.
       # Correcting to global variables in the 'English' library
       # will add a require statement to the top of the file if
       # enabled by RequireEnglish config.

data/lib/rubocop/cop/variable_force/assignment.rb

@@ -63,6 +63,18 @@ module RuboCop
           meta_assignment_node.type == MULTIPLE_ASSIGNMENT_TYPE
         end
 
+        def rest_assignment?
+          return false unless meta_assignment_node
+
+          meta_assignment_node.type == REST_ASSIGNMENT_TYPE
+        end
+
+        def for_assignment?
+          return false unless meta_assignment_node
+
+          meta_assignment_node.for_type?
+        end
+
         def operator
           assignment_node = meta_assignment_node || @node
           assignment_node.loc.operator.source
@@ -70,7 +82,10 @@ module RuboCop
 
         def meta_assignment_node
           unless instance_variable_defined?(:@meta_assignment_node)
-            @meta_assignment_node = operator_assignment_node || multiple_assignment_node
+            @meta_assignment_node = operator_assignment_node ||
+                                    multiple_assignment_node ||
+                                    rest_assignment_node ||
+                                    for_assignment_node
           end
 
           @meta_assignment_node
@@ -94,6 +109,19 @@ module RuboCop
 
           grandparent_node
         end
+
+        def rest_assignment_node
+          return nil unless node.parent
+          return nil unless node.parent.type == REST_ASSIGNMENT_TYPE
+
+          node.parent
+        end
+
+        def for_assignment_node
+          return nil unless node.parent&.for_type?
+
+          node.parent
+        end
       end
     end
   end

data/lib/rubocop/cop/variable_force.rb

@@ -40,6 +40,7 @@ module RuboCop
       OPERATOR_ASSIGNMENT_TYPES = (LOGICAL_OPERATOR_ASSIGNMENT_TYPES + [:op_asgn]).freeze
 
       MULTIPLE_ASSIGNMENT_TYPE = :masgn
+      REST_ASSIGNMENT_TYPE = :splat
 
       VARIABLE_REFERENCE_TYPE = :lvar
 

data/lib/rubocop/server/client_command/exec.rb

@@ -18,10 +18,11 @@ module RuboCop
         def run
           ensure_server!
           Cache.status_path.delete if Cache.status_path.file?
+          read_stdin = ARGV.include?('-s') || ARGV.include?('--stdin')
           send_request(
             command: 'exec',
             args: ARGV.dup,
-            body: $stdin.tty? ? '' : $stdin.read
+            body: read_stdin ? $stdin.read : ''
           )
           warn stderr unless stderr.empty?
           status

data/lib/rubocop/version.rb

@@ -3,15 +3,19 @@
 module RuboCop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '1.51.0'
+    STRING = '1.52.1'
 
     MSG = '%<version>s (using Parser %<parser_version>s, ' \
           'rubocop-ast %<rubocop_ast_version>s, ' \
           'running on %<ruby_engine>s %<ruby_version>s)%<server_mode>s [%<ruby_platform>s]'
 
-    CANONICAL_FEATURE_NAMES = { 'Rspec' => 'RSpec', 'Graphql' => 'GraphQL', 'Md' => 'Markdown',
-                                'Thread_safety' => 'ThreadSafety' }.freeze
-    EXTENSION_PATH_NAMES = { 'rubocop-md' => 'markdown' }.freeze
+    CANONICAL_FEATURE_NAMES = {
+      'Rspec' => 'RSpec', 'Graphql' => 'GraphQL', 'Md' => 'Markdown', 'Factory_bot' => 'FactoryBot',
+      'Thread_safety' => 'ThreadSafety'
+    }.freeze
+    EXTENSION_PATH_NAMES = {
+      'rubocop-md' => 'markdown', 'rubocop-factory_bot' => 'factory_bot'
+    }.freeze
 
     # @api private
     def self.version(debug: false, env: nil)

data/lib/rubocop.rb

@@ -69,6 +69,7 @@ require_relative 'rubocop/cop/mixin/alignment'
 require_relative 'rubocop/cop/mixin/allowed_identifiers'
 require_relative 'rubocop/cop/mixin/allowed_methods'
 require_relative 'rubocop/cop/mixin/allowed_pattern'
+require_relative 'rubocop/cop/mixin/allowed_receivers'
 require_relative 'rubocop/cop/mixin/auto_corrector' # rubocop:todo Naming/InclusiveLanguage
 require_relative 'rubocop/cop/mixin/check_assignment'
 require_relative 'rubocop/cop/mixin/check_line_breakable'
@@ -558,15 +559,18 @@ require_relative 'rubocop/cop/style/multiline_in_pattern_then'
 require_relative 'rubocop/cop/style/numbered_parameters'
 require_relative 'rubocop/cop/style/open_struct_use'
 require_relative 'rubocop/cop/style/operator_method_call'
+require_relative 'rubocop/cop/style/redundant_array_constructor'
 require_relative 'rubocop/cop/style/redundant_assignment'
 require_relative 'rubocop/cop/style/redundant_constant_base'
 require_relative 'rubocop/cop/style/redundant_double_splat_hash_braces'
 require_relative 'rubocop/cop/style/redundant_each'
 require_relative 'rubocop/cop/style/redundant_fetch_block'
 require_relative 'rubocop/cop/style/redundant_file_extension_in_require'
+require_relative 'rubocop/cop/style/redundant_filter_chain'
 require_relative 'rubocop/cop/style/redundant_heredoc_delimiter_quotes'
 require_relative 'rubocop/cop/style/redundant_initialize'
 require_relative 'rubocop/cop/style/redundant_line_continuation'
+require_relative 'rubocop/cop/style/redundant_regexp_constructor'
 require_relative 'rubocop/cop/style/redundant_self_assignment'
 require_relative 'rubocop/cop/style/redundant_self_assignment_branch'
 require_relative 'rubocop/cop/style/require_order'