rubocop 1.24.1 → 1.25.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a2e7d2cbe48c6ff81a071b353132db29ed017af57a32bcd142038e2e551f3a5b
-  data.tar.gz: 8ae72a3ce8b6ab13b4d451bbdb1dbcdf54f898711a3009dae81450a49fb037e0
+  metadata.gz: 0e565e6065561954dc1aa6db221e2f6cf7753a96b40bf863a571243a2b567d84
+  data.tar.gz: e489fdb8174dcc6f755ae18bf57091188808e3649db33ae0c282c507b0ec4f54
 SHA512:
-  metadata.gz: d868781732056622d0f5157a50553c0b521f81f2ca14d2ede65b4c7372ef0e3b89be5146db8664fac5b28a39c82be52fc297a43d8280647b1b7426ce9ee87337
-  data.tar.gz: e3d8f4dc8ab53859197eb3f05c62290cf72ba11c7e742869d619d6c4564e28f5c0fc70e4e15f90fc4f9bfe2d46cafdeedde8aa16d982adfc7d6eb482f7d20093
+  metadata.gz: 2c01d7352515c439403d4f479583d4099f4ac339ab8a26503ad6b6fd90db54d5a4bcddd6fc2d2e48f3de8faf2928f0f0930c938a5b22a7cfe1759199f68e873a
+  data.tar.gz: 3075cb42f837c728c31a936ddf1a61ba5d6aafcae9a984a97d05a519089ef7b9c4ff164cf9e3d45e1cd0ab6505a2348f4870bb6c0044e011c45eae04de123e45

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2012-21 Bozhidar Batsov
+Copyright (c) 2012-22 Bozhidar Batsov
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -53,7 +53,7 @@ To prevent an unwanted RuboCop update you might want to use a conservative versi
 in your `Gemfile`:
 
 ```rb
-gem 'rubocop', '~> 1.24', require: false
+gem 'rubocop', '~> 1.25', require: false
 ```
 
 See [our versioning policy](https://docs.rubocop.org/rubocop/versioning.html) for further details.
@@ -244,5 +244,5 @@ RuboCop's changelog is available [here](CHANGELOG.md).
 
 ## Copyright
 
-Copyright (c) 2012-2021 Bozhidar Batsov. See [LICENSE.txt](LICENSE.txt) for
+Copyright (c) 2012-2022 Bozhidar Batsov. See [LICENSE.txt](LICENSE.txt) for
 further details.

data/config/default.yml

@@ -2496,6 +2496,7 @@ Naming/BlockForwarding:
   SupportedStyles:
     - anonymous
     - explicit
+  BlockForwardingName: block
 
 Naming/BlockParameterName:
   Description: >-
@@ -3698,6 +3699,8 @@ Style/HashSyntax:
     - always
     # forces use of explicit hash literal value.
     - never
+    # accepts both shorthand and explicit use of hash literal value.
+    - either
   # Force hashes that have a symbol value to use hash rockets
   UseHashRocketsWithSymbolValues: false
   # Do not suggest { a?: 1 } over { :a? => 1 } in ruby19 style

data/lib/rubocop/cop/gemspec/required_ruby_version.rb

@@ -68,8 +68,11 @@ module RuboCop
 
         # @!method defined_ruby_version(node)
         def_node_matcher :defined_ruby_version, <<~PATTERN
-          {$(str _) $(array (str _) (str _))
-            (send (const (const nil? :Gem) :Requirement) :new $(str _))}
+          {
+            $(str _)
+            $(array (str _) (str _))
+            (send (const (const nil? :Gem) :Requirement) :new $str+)
+          }
         PATTERN
 
         def on_new_investigation
@@ -97,7 +100,11 @@ module RuboCop
         def extract_ruby_version(required_ruby_version)
           return unless required_ruby_version
 
-          if required_ruby_version.array_type?
+          if required_ruby_version.is_a?(Array)
+            required_ruby_version = required_ruby_version.detect do |v|
+              /[>=]/.match?(v.str_content)
+            end
+          elsif required_ruby_version.array_type?
             required_ruby_version = required_ruby_version.children.detect do |v|
               /[>=]/.match?(v.str_content)
             end

data/lib/rubocop/cop/generator.rb

@@ -182,7 +182,8 @@ module RuboCop
       end
 
       def generate(template)
-        format(template, department: badge.department, cop_name: badge.cop_name)
+        format(template, department: badge.department.to_s.gsub('/', '::'),
+                         cop_name: badge.cop_name)
       end
 
       def spec_path
@@ -209,8 +210,8 @@ module RuboCop
         return 'rspec' if camel_case_string == 'RSpec'
 
         camel_case_string
-          .gsub(/([^A-Z])([A-Z]+)/, '\1_\2')
-          .gsub(/([A-Z])([A-Z][^A-Z\d]+)/, '\1_\2')
+          .gsub(%r{([^A-Z/])([A-Z]+)}, '\1_\2')
+          .gsub(%r{([A-Z])([A-Z][^A-Z\d/]+)}, '\1_\2')
           .downcase
       end
     end

data/lib/rubocop/cop/layout/argument_alignment.rb

@@ -53,23 +53,50 @@ module RuboCop
                            'following the first line of a multi-line method call.'
 
         def on_send(node)
-          first_arg = node.first_argument
-          return if !multiple_arguments?(node, first_arg) || (node.send_type? && node.method?(:[]=))
+          return if !multiple_arguments?(node) || (node.send_type? && node.method?(:[]=))
 
-          if first_arg.hash_type? && !first_arg.braces?
-            pairs = first_arg.pairs
-            check_alignment(pairs, base_column(node, pairs.first))
-          else
-            check_alignment(node.arguments, base_column(node, first_arg))
-          end
+          items = flattened_arguments(node)
+
+          check_alignment(items, base_column(node, items.first))
         end
+
         alias on_csend on_send
 
         private
 
-        def multiple_arguments?(node, first_argument)
+        def flattened_arguments(node)
+          if fixed_indentation?
+            arguments_with_last_arg_pairs(node)
+          else
+            arguments_or_first_arg_pairs(node)
+          end
+        end
+
+        def arguments_with_last_arg_pairs(node)
+          items = node.arguments[0..-2]
+          last_arg = node.arguments.last
+
+          if last_arg.hash_type? && !last_arg.braces?
+            items += last_arg.pairs
+          else
+            items << last_arg
+          end
+          items
+        end
+
+        def arguments_or_first_arg_pairs(node)
+          first_arg = node.first_argument
+          if first_arg.hash_type? && !first_arg.braces?
+            first_arg.pairs
+          else
+            node.arguments
+          end
+        end
+
+        def multiple_arguments?(node)
           return true if node.arguments.size >= 2
 
+          first_argument = node.first_argument
           first_argument&.hash_type? && first_argument.pairs.count >= 2
         end
 

data/lib/rubocop/cop/lint/ambiguous_regexp_literal.rb

@@ -30,7 +30,11 @@ module RuboCop
 
         def on_new_investigation
           processed_source.diagnostics.each do |diagnostic|
-            next unless diagnostic.reason == :ambiguous_literal
+            if target_ruby_version >= 3.0
+              next unless diagnostic.reason == :ambiguous_regexp
+            else
+              next unless diagnostic.reason == :ambiguous_literal
+            end
 
             offense_node = find_offense_node_by(diagnostic)
 

data/lib/rubocop/cop/lint/incompatible_io_select_with_fiber_scheduler.rb

@@ -33,11 +33,12 @@ module RuboCop
         # @!method io_select(node)
         def_node_matcher :io_select, <<~PATTERN
           (send
-            (const {nil? cbase} :IO) :select $_ $_ {(array) nil} $...)
+            (const {nil? cbase} :IO) :select $...)
         PATTERN
 
         def on_send(node)
-          return unless (read, write, timeout = io_select(node))
+          read, write, _excepts, timeout = *io_select(node)
+          return unless read
           return unless scheduler_compatible?(read, write) || scheduler_compatible?(write, read)
 
           preferred = preferred_method(read, write, timeout)
@@ -51,13 +52,13 @@ module RuboCop
         private
 
         def scheduler_compatible?(io1, io2)
-          return false unless io1.array_type? && io1.values.size == 1
+          return false unless io1&.array_type? && io1.values.size == 1
 
-          io2.array_type? ? io2.values.empty? : io2.nil_type?
+          io2&.array_type? ? io2.values.empty? : (io2.nil? || io2.nil_type?)
         end
 
         def preferred_method(read, write, timeout)
-          timeout_argument = timeout.empty? ? '' : "(#{timeout[0].source})"
+          timeout_argument = timeout.nil? ? '' : "(#{timeout.source})"
 
           if read.array_type? && read.values[0]
             "#{read.values[0].source}.wait_readable#{timeout_argument}"

data/lib/rubocop/cop/mixin/hash_shorthand_syntax.rb

@@ -8,7 +8,7 @@ module RuboCop
       EXPLICIT_HASH_VALUE_MSG = 'Explicit the hash value.'
 
       def on_pair(node)
-        return if target_ruby_version <= 3.0
+        return if target_ruby_version <= 3.0 || enforced_shorthand_syntax == 'either'
 
         hash_key_source = node.key.source
 
@@ -46,10 +46,22 @@ module RuboCop
 
       def without_parentheses_call_expr_follows?(node)
         return false unless (ancestor = node.parent.parent)
-        return false unless (right_sibling = ancestor.right_sibling)
 
-        ancestor.respond_to?(:parenthesized?) && !ancestor.parenthesized? &&
-          right_sibling.respond_to?(:parenthesized?) && !right_sibling.parenthesized?
+        right_sibling = ancestor.right_sibling
+
+        return true if right_sibling.nil? && without_parentheses?(ancestor)
+        return false unless right_sibling
+        return true if node_with_block_and_arguments?(right_sibling)
+
+        without_parentheses?(ancestor) && without_parentheses?(right_sibling)
+      end
+
+      def without_parentheses?(node)
+        node.respond_to?(:parenthesized?) && !node.parenthesized?
+      end
+
+      def node_with_block_and_arguments?(node)
+        node.respond_to?(:block_type?) && node.block_type? && node.children&.first&.arguments?
       end
     end
   end

data/lib/rubocop/cop/naming/block_forwarding.rb

@@ -9,6 +9,9 @@ module RuboCop
       # by `do_something(&)`.
       #
       # It also supports the opposite style by alternative `explicit` option.
+      # You can specify the block variable name for auto-correction with `BlockForwardingName`.
+      # The default variable name is `block`. If the name is already in use, it will not be
+      # auto-corrected.
       #
       # @example EnforcedStyle: anonymous (default)
       #
@@ -50,12 +53,13 @@ module RuboCop
           last_argument = node.arguments.last
           return if expected_block_forwarding_style?(node, last_argument)
 
-          register_offense(last_argument)
+          register_offense(last_argument, node)
 
           node.each_descendant(:block_pass) do |block_pass_node|
-            next if block_pass_node.children.first&.sym_type?
+            next if block_pass_node.children.first&.sym_type? ||
+                    last_argument.source != block_pass_node.source
 
-            register_offense(block_pass_node)
+            register_offense(block_pass_node, node)
           end
         end
         alias on_defs on_def
@@ -66,7 +70,7 @@ module RuboCop
           if style == :anonymous
             !explicit_block_argument?(last_argument) ||
               use_kwarg_in_method_definition?(node) ||
-              use_block_argument_as_local_variable?(node, last_argument)
+              use_block_argument_as_local_variable?(node, last_argument.source[1..-1])
           else
             !anonymous_block_argument?(last_argument)
           end
@@ -84,22 +88,32 @@ module RuboCop
           node.blockarg_type? && !node.name.nil?
         end
 
+        def register_offense(block_argument, node)
+          add_offense(block_argument, message: format(MSG, style: style)) do |corrector|
+            if style == :anonymous
+              corrector.replace(block_argument, '&')
+
+              arguments = block_argument.parent
+
+              add_parentheses(arguments, corrector) unless arguments.parenthesized_call?
+            else
+              unless use_block_argument_as_local_variable?(node, block_forwarding_name)
+                corrector.replace(block_argument, "&#{block_forwarding_name}")
+              end
+            end
+          end
+        end
+
         def use_block_argument_as_local_variable?(node, last_argument)
           return if node.body.nil?
 
           node.body.each_descendant(:lvar).any? do |lvar|
-            !lvar.parent.block_pass_type? && lvar.source == last_argument.source[1..-1]
+            !lvar.parent.block_pass_type? && lvar.source == last_argument
           end
         end
 
-        def register_offense(block_argument)
-          add_offense(block_argument, message: format(MSG, style: style)) do |corrector|
-            corrector.replace(block_argument, '&')
-
-            arguments = block_argument.parent
-
-            add_parentheses(arguments, corrector) unless arguments.parenthesized_call?
-          end
+        def block_forwarding_name
+          cop_config.fetch('BlockForwardingName', 'block')
         end
       end
     end

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

@@ -41,7 +41,7 @@ module RuboCop
 
         # @!method reject_method_with_block_pass?(node)
         def_node_matcher :reject_method_with_block_pass?, <<~PATTERN
-          (send _ {:reject :reject!}
+          (send !nil? {:reject :reject!}
             (block_pass
               (sym :nil?)))
         PATTERN
@@ -50,7 +50,7 @@ module RuboCop
         def_node_matcher :reject_method?, <<~PATTERN
           (block
             (send
-              _ {:reject :reject!})
+              !nil? {:reject :reject!})
             $(args ...)
             (send
               $(lvar _) :nil?))
@@ -60,7 +60,7 @@ module RuboCop
         def_node_matcher :select_method?, <<~PATTERN
           (block
             (send
-              _ {:select :select!})
+              !nil? {:select :select!})
             $(args ...)
             (send
               (send

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

@@ -23,6 +23,12 @@ module RuboCop
       # It can enforce either the use of the explicit hash value syntax or
       # the use of Ruby 3.1's hash value shorthand syntax.
       #
+      # The supported styles are:
+      #
+      # * 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
+      #
       # @example EnforcedStyle: ruby19 (default)
       #   # bad
       #   {:a => 2}
@@ -75,6 +81,14 @@ module RuboCop
       #   # good
       #   {foo: foo, bar: bar}
       #
+      # @example EnforcedShorthandSyntax: either
+      #
+      #   # good
+      #   {foo: foo, bar: bar}
+      #
+      #   # good
+      #   {foo:, bar:}
+      #
       class HashSyntax < Base
         include ConfigurableEnforcedStyle
         include HashShorthandSyntax

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

@@ -36,7 +36,7 @@ module RuboCop
       #   # good (but potentially an unsafe correction)
       #   foo.do_something?
       #
-      # @example AllowedMethods: ['nonzero?']
+      # @example AllowedMethods: ['nonzero?'] (default)
       #   # good
       #   num.nonzero? ? true : false
       #

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

@@ -51,11 +51,12 @@ module RuboCop
           # Require hash value omission be enclosed in parentheses to prevent the following issue:
           # https://bugs.ruby-lang.org/issues/18396.
           def require_parentheses_for_hash_value_omission?(node)
-            return unless (last_argument = node.last_argument)
+            return false unless (last_argument = node.last_argument)
 
-            return false unless (right_sibling = node.right_sibling)
+            next_line = node.parent&.assignment? ? node.parent.right_sibling : node.right_sibling
+            return false unless next_line
 
-            last_argument.hash_type? && last_argument.pairs.last&.value_omission? && right_sibling
+            last_argument.hash_type? && last_argument.pairs.last&.value_omission? && next_line
           end
 
           def syntax_like_method_call?(node)

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

@@ -47,7 +47,7 @@ module RuboCop
       # allowed when forwarding arguments with the triple-dot syntax introduced
       # in Ruby 2.7 as omitting them starts an endless range.
       # And Ruby 3.1's hash omission syntax has a case that requires parentheses
-      # because the issue https://bugs.ruby-lang.org/issues/18396.
+      # because of the following issue: https://bugs.ruby-lang.org/issues/18396.
       #
       # @example EnforcedStyle: require_parentheses (default)
       #

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

@@ -91,11 +91,12 @@ module RuboCop
           second.int_type? ? second.to_a.first : :unknown
         end
 
-        def range_size(range_node) # rubocop:todo Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def range_size(range_node)
           vals = range_node.to_a
-          return :unknown unless vals.all?(&:int_type?)
+          return :unknown unless vals.all? { |val| val.nil? || val.int_type? }
 
-          low, high = vals.map { |val| val.children[0] }
+          low, high = vals.map { |val| val.nil? ? 0 : val.children[0] }
           return :unknown unless low.zero? && high >= 0
 
           case range_node.type
@@ -105,6 +106,7 @@ module RuboCop
             (low..high).size
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def source_range(shuffle_node, node)
           Parser::Source::Range.new(shuffle_node.source_range.source_buffer,

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

@@ -67,7 +67,10 @@ module RuboCop
         MSG_COMPLEX = '%<command>s parentheses for ternary expressions with complex conditions.'
 
         def on_if(node)
-          return if only_closing_parenthesis_is_last_line?(node.condition)
+          condition = node.condition
+
+          return if only_closing_parenthesis_is_last_line?(condition)
+          return if condition_as_parenthesized_one_line_pattern_matching?(condition)
           return unless node.ternary? && !infinite_loop? && offense?(node)
 
           message = message(node)
@@ -77,11 +80,22 @@ module RuboCop
           end
         end
 
+        private
+
         def only_closing_parenthesis_is_last_line?(condition)
           condition.source.split("\n").last == ')'
         end
 
-        private
+        def condition_as_parenthesized_one_line_pattern_matching?(condition)
+          return false unless condition.parenthesized_call?
+          return false unless (first_child = condition.children.first)
+
+          if target_ruby_version >= 3.0
+            first_child.match_pattern_p_type?
+          else
+            first_child.match_pattern_type? # For Ruby 2.7's one line pattern matching AST.
+          end
+        end
 
         def autocorrect(corrector, node)
           condition = node.condition

data/lib/rubocop/version.rb

@@ -3,7 +3,7 @@
 module RuboCop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '1.24.1'
+    STRING = '1.25.0'
 
     MSG = '%<version>s (using Parser %<parser_version>s, '\
           'rubocop-ast %<rubocop_ast_version>s, ' \

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop
 version: !ruby/object:Gem::Version
-  version: 1.24.1
+  version: 1.25.0
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-12-31 00:00:00.000000000 Z
+date: 2022-01-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parallel
@@ -32,14 +32,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.0.0
+        version: 3.1.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.0.0
+        version: 3.1.0.0
 - !ruby/object:Gem::Dependency
   name: rainbow
   requirement: !ruby/object:Gem::Requirement
@@ -911,7 +911,7 @@ metadata:
   homepage_uri: https://rubocop.org/
   changelog_uri: https://github.com/rubocop/rubocop/blob/master/CHANGELOG.md
   source_code_uri: https://github.com/rubocop/rubocop/
-  documentation_uri: https://docs.rubocop.org/rubocop/1.24/
+  documentation_uri: https://docs.rubocop.org/rubocop/1.25/
   bug_tracker_uri: https://github.com/rubocop/rubocop/issues
   rubygems_mfa_required: 'true'
 post_install_message: