rubocop 1.56.2 → 1.56.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 061c4fd159baec4f143f014ae432ec3607b0846cb46b3a4566a224922b6c5c7b
-  data.tar.gz: 943c45cc27dbbb861f6b2a910216a016c06e2ace63824c30a7ad922caabfed59
+  metadata.gz: 19e42173e0ae7c2aec912c3dbd560db4189c426d6ba0f051694c6c5c11a913e1
+  data.tar.gz: c1511a9611875e3d38869837d31840687e6c2004a6e7c27c19630a04b7f064fd
 SHA512:
-  metadata.gz: 5d5900ca290d826af3658c1d481a7778b44a4d57455d69c96c603bac7679c4b275cd192339e683e6ba020201e0dbb23ee3e64f9fbc953cc5bf4832ce1c293bbb
-  data.tar.gz: dfc761f98d05680a21093ce5092b933ff8534f7b7ed5f7c46ec52586673db9ad60b495e896b429499d151c6af827a30d1e67c2e1bf397f9a7947b1c0bff836ab
+  metadata.gz: 97f5377116914b0f45233a7ed193ae08c2a4e12f0bdd0739f3129b4a36fd13eee1a38a6f4486e5de602b00486c37fe271db2bcfd1fbe4289430ea61644edaef6
+  data.tar.gz: d194d95290db68e6431b49d0dbad8559c657704fa283643057470d584f316c512f5d95681f07fda3f4f57f157b86add28fa135a60452944a0a6c6f8758659b13

data/config/default.yml

@@ -4130,12 +4130,6 @@ Style/InvertibleUnlessCondition:
     :none?: :any?
     :even?: :odd?
     :odd?: :even?
-    # `ActiveSupport` defines some common inverse methods. They are listed below,
-    # and not enabled by default.
-    # :present?: :blank?
-    # :blank?: :present?
-    # :include?: :exclude?
-    # :exclude?: :include?
 
 Style/IpAddresses:
   Description: "Don't include literal IP addresses in code."

data/lib/rubocop/cop/bundler/duplicated_group.rb

@@ -117,7 +117,7 @@ module RuboCop
             if argument.hash_type?
               argument.pairs.map(&:source).sort.join(', ')
             else
-              argument.value.to_s
+              argument.respond_to?(:value) ? argument.value.to_s : argument.source
             end
           end
         end

data/lib/rubocop/cop/internal_affairs/redundant_method_dispatch_node.rb

@@ -14,6 +14,12 @@ module RuboCop
       #   node.method_name
       #
       #   # bad
+      #   node.send_node.method?(:method_name)
+      #
+      #   # good
+      #   node.method?(:method_name)
+      #
+      #   # bad
       #   node.send_node.receiver
       #
       #   # good
@@ -24,11 +30,14 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Remove the redundant `send_node`.'
-        RESTRICT_ON_SEND = %i[method_name receiver].freeze
+        RESTRICT_ON_SEND = %i[method_name method? receiver].freeze
 
         # @!method dispatch_method(node)
         def_node_matcher :dispatch_method, <<~PATTERN
-          (send $(send _ :send_node) _)
+          {
+            (send $(send _ :send_node) {:method_name :receiver})
+            (send $(send _ :send_node) :method? _)
+          }
         PATTERN
 
         def on_send(node)

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

@@ -3,7 +3,23 @@
 module RuboCop
   module Cop
     module Layout
-      # Enforces empty line after guard clause
+      # Enforces empty line after guard clause.
+      #
+      # This cop allows `# :nocov:` directive after guard clause because
+      # SimpleCov excludes code from the coverage report by wrapping it in `# :nocov:`:
+      #
+      # [source,ruby]
+      # ----
+      # def foo
+      #   # :nocov:
+      #   return if condition
+      #   # :nocov:
+      #   bar
+      # end
+      # ----
+      #
+      # Refer to SimpleCov's documentation for more details:
+      # https://github.com/simplecov-ruby/simplecov#ignoringskipping-code
       #
       # @example
       #
@@ -42,19 +58,22 @@ module RuboCop
 
         MSG = 'Add empty line after guard clause.'
         END_OF_HEREDOC_LINE = 1
+        SIMPLE_DIRECTIVE_COMMENT_PATTERN = /\A# *:nocov:\z/.freeze
 
         def on_if(node)
           return if correct_style?(node)
           return if multiple_statements_on_line?(node)
 
           if node.modifier_form? && (heredoc_node = last_heredoc_argument(node))
-            return if next_line_empty_or_enable_directive_comment?(heredoc_line(node, heredoc_node))
+            if next_line_empty_or_allowed_directive_comment?(heredoc_line(node, heredoc_node))
+              return
+            end
 
             add_offense(heredoc_node.loc.heredoc_end) do |corrector|
               autocorrect(corrector, heredoc_node)
             end
           else
-            return if next_line_empty_or_enable_directive_comment?(node.last_line)
+            return if next_line_empty_or_allowed_directive_comment?(node.last_line)
 
             add_offense(offense_location(node)) { |corrector| autocorrect(corrector, node) }
           end
@@ -70,7 +89,7 @@ module RuboCop
                        end
 
           next_line = node_range.last_line + 1
-          if next_line_enable_directive_comment?(next_line)
+          if next_line_allowed_directive_comment?(next_line)
             node_range = processed_source.comment_at_line(next_line)
           end
 
@@ -88,21 +107,21 @@ module RuboCop
           node.if_branch&.guard_clause?
         end
 
-        def next_line_empty_or_enable_directive_comment?(line)
+        def next_line_empty_or_allowed_directive_comment?(line)
           return true if next_line_empty?(line)
 
           next_line = line + 1
-          next_line_enable_directive_comment?(next_line) && next_line_empty?(next_line)
+          next_line_allowed_directive_comment?(next_line) && next_line_empty?(next_line)
         end
 
         def next_line_empty?(line)
           processed_source[line].blank?
         end
 
-        def next_line_enable_directive_comment?(line)
+        def next_line_allowed_directive_comment?(line)
           return false unless (comment = processed_source.comment_at_line(line))
 
-          DirectiveComment.new(comment).enabled?
+          DirectiveComment.new(comment).enabled? || simplecov_directive_comment?(comment)
         end
 
         def next_line_rescue_or_ensure?(node)
@@ -175,6 +194,12 @@ module RuboCop
 
           parent.begin_type? && parent.single_line?
         end
+
+        # SimpleCov excludes code from the coverage report by wrapping it in `# :nocov:`:
+        # https://github.com/simplecov-ruby/simplecov#ignoringskipping-code
+        def simplecov_directive_comment?(comment)
+          SIMPLE_DIRECTIVE_COMMENT_PATTERN.match?(comment.text)
+        end
       end
     end
   end

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

@@ -25,6 +25,9 @@ module RuboCop
         include Alignment
         include Heredoc
         extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.3
 
         TYPE_MSG = 'Use %<indentation_width>d spaces for indentation in a ' \
                    'heredoc by using `<<~` instead of `%<current_indent_type>s`.'

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

@@ -108,7 +108,7 @@ module RuboCop
           !comment_within?(node) &&
             node.each_descendant(:if, :case, :kwbegin, :def, :defs).none? &&
             node.each_descendant(:dstr, :str).none? { |n| n.heredoc? || n.value.include?("\n") } &&
-            node.each_descendant(:begin).none? { |b| !b.single_line? }
+            node.each_descendant(:begin, :sym).none? { |b| !b.single_line? }
         end
 
         def convertible_block?(node)

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

@@ -31,7 +31,7 @@ module RuboCop
         private
 
         def whitespace_after_operator?(node)
-          node.receiver.loc.column - node.loc.column > 1
+          node.receiver.source_range.begin_pos - node.source_range.begin_pos > 1
         end
       end
     end

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

@@ -7,12 +7,18 @@ module RuboCop
       # scope.
       # The basic idea for this cop was from the warning of `ruby -cw`:
       #
-      #   assigned but unused variable - foo
+      # [source,console]
+      # ----
+      # assigned but unused variable - foo
+      # ----
       #
       # Currently this cop has advanced logic that detects unreferenced
       # reassignments and properly handles varied cases such as branch, loop,
       # rescue, ensure, etc.
       #
+      # NOTE: Given the assignment `foo = 1, bar = 2`, removing unused variables
+      # can lead to a syntax error, so this case is not autocorrected.
+      #
       # @safety
       #   This cop's autocorrection is unsafe because removing assignment from
       #   operator assignment can cause NameError if this assignment has been used to declare
@@ -51,25 +57,24 @@ module RuboCop
           scope.variables.each_value { |variable| check_for_unused_assignments(variable) }
         end
 
+        # rubocop:disable Metrics/AbcSize
         def check_for_unused_assignments(variable)
           return if variable.should_be_unused?
 
           variable.assignments.each do |assignment|
-            next if assignment.used?
+            next if assignment.used? || part_of_ignored_node?(assignment.node)
 
             message = message_for_useless_assignment(assignment)
+            range = offense_range(assignment)
 
-            location = if assignment.regexp_named_capture?
-                         assignment.node.children.first.source_range
-                       else
-                         assignment.node.loc.name
-                       end
-
-            add_offense(location, message: message) do |corrector|
-              autocorrect(corrector, assignment)
+            add_offense(range, message: message) do |corrector|
+              autocorrect(corrector, assignment) unless sequential_assignment?(assignment.node)
             end
+
+            ignore_node(assignment.node) if chained_assignment?(assignment.node)
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         def message_for_useless_assignment(assignment)
           variable = assignment.variable
@@ -77,6 +82,28 @@ module RuboCop
           format(MSG, variable: variable.name) + message_specification(assignment, variable).to_s
         end
 
+        def offense_range(assignment)
+          if assignment.regexp_named_capture?
+            assignment.node.children.first.source_range
+          else
+            assignment.node.loc.name
+          end
+        end
+
+        def sequential_assignment?(node)
+          if node.lvasgn_type? && node.expression&.array_type? &&
+             node.each_descendant.any?(&:assignment?)
+            return true
+          end
+          return false unless node.parent
+
+          sequential_assignment?(node.parent)
+        end
+
+        def chained_assignment?(node)
+          node.respond_to?(:expression) && node.expression&.lvasgn_type?
+        end
+
         def message_specification(assignment, variable)
           if assignment.multiple_assignment?
             multiple_assignment_message(variable.name)

data/lib/rubocop/cop/metrics/method_length.rb

@@ -54,7 +54,7 @@ module RuboCop
         alias on_defs on_def
 
         def on_block(node)
-          return unless node.send_node.method?(:define_method)
+          return unless node.method?(:define_method)
 
           check_code_length(node)
         end

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

@@ -75,7 +75,7 @@ module RuboCop
       end
 
       def aligned_token?(range, line)
-        aligned_words?(range, line) || aligned_dot?(range, line) || aligned_assignment?(range, line)
+        aligned_words?(range, line) || aligned_assignment?(range, line)
       end
 
       def aligned_operator?(range, line)
@@ -83,13 +83,11 @@ module RuboCop
       end
 
       def aligned_words?(range, line)
-        /\s\S/.match?(line[range.column - 1, 2])
-      end
-
-      def aligned_dot?(range, line)
-        char = line[range.column]
+        left_edge = range.column
+        return true if /\s\S/.match?(line[left_edge - 1, 2])
 
-        char == '.' && char == range.source[0]
+        token = range.source
+        token == line[left_edge, token.length]
       end
 
       def aligned_assignment?(range, line)

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

@@ -116,11 +116,11 @@ module RuboCop
         end
 
         def only_forwards_all?(send_classifications)
-          send_classifications.each_value.all? { |c, _, _| c == :all }
+          send_classifications.all? { |_, c, _, _| c == :all }
         end
 
         def add_forward_all_offenses(node, send_classifications, forwardable_args)
-          send_classifications.each do |send_node, (_c, forward_rest, _forward_kwrest)|
+          send_classifications.each do |send_node, _c, forward_rest, _forward_kwrest|
             register_forward_all_offense(send_node, send_node, forward_rest)
           end
 
@@ -133,7 +133,7 @@ module RuboCop
 
           rest_arg, kwrest_arg, _block_arg = *forwardable_args
 
-          send_classifications.each do |send_node, (_c, forward_rest, forward_kwrest)|
+          send_classifications.each do |send_node, _c, forward_rest, forward_kwrest|
             if forward_rest
               register_forward_args_offense(def_node.arguments, rest_arg)
               register_forward_args_offense(send_node, forward_rest)
@@ -157,7 +157,7 @@ module RuboCop
         end
 
         def classify_send_nodes(def_node, send_nodes, referenced_lvars, forwardable_args)
-          send_nodes.to_h do |send_node|
+          send_nodes.filter_map do |send_node|
             classification_and_forwards = classification_and_forwards(
               def_node,
               send_node,
@@ -165,8 +165,10 @@ module RuboCop
               forwardable_args
             )
 
-            [send_node, classification_and_forwards]
-          end.compact
+            next unless classification_and_forwards
+
+            [send_node, *classification_and_forwards]
+          end
         end
 
         def classification_and_forwards(def_node, send_node, referenced_lvars, forwardable_args)

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

@@ -11,6 +11,15 @@ module RuboCop
       # The `array1.intersect?(array2)` method is faster than
       # `(array1 & array2).any?` and is more readable.
       #
+      # In cases like the following, compatibility is not ensured,
+      # so it will not be detected when using block argument.
+      #
+      # [source,ruby]
+      # ----
+      # ([1] & [1,2]).any? { |x| false }    # => false
+      # [1].intersect?([1,2]) { |x| false } # => true
+      # ----
+      #
       # @safety
       #   This cop cannot guarantee that `array1` and `array2` are
       #   actually arrays while method `intersect?` is for arrays only.
@@ -68,16 +77,15 @@ module RuboCop
         RESTRICT_ON_SEND = (STRAIGHT_METHODS + NEGATED_METHODS).freeze
 
         def on_send(node)
+          return if (parent = node.parent) && (parent.block_type? || parent.numblock_type?)
           return unless (receiver, argument, method_name = bad_intersection_check?(node))
 
           message = message(receiver.source, argument.source, method_name)
 
           add_offense(node, message: message) do |corrector|
-            if straight?(method_name)
-              corrector.replace(node, "#{receiver.source}.intersect?(#{argument.source})")
-            else
-              corrector.replace(node, "!#{receiver.source}.intersect?(#{argument.source})")
-            end
+            bang = straight?(method_name) ? '' : '!'
+
+            corrector.replace(node, "#{bang}#{receiver.source}.intersect?(#{argument.source})")
           end
         end
 

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

@@ -93,8 +93,9 @@ module RuboCop
         end
 
         def same_collection_looping_block?(node, sibling)
-          (sibling&.block_type? || sibling&.numblock_type?) &&
-            sibling.send_node.method?(node.method_name) &&
+          return false if sibling.nil? || (!sibling.block_type? && !sibling.numblock_type?)
+
+          sibling.method?(node.method_name) &&
             sibling.receiver == node.receiver &&
             sibling.send_node.arguments == node.send_node.arguments
         end

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

@@ -40,9 +40,13 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Do not use empty `case` condition, instead use an `if` expression.'
+        NOT_SUPPORTED_PARENT_TYPES = %i[return break next send csend].freeze
 
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_case(case_node)
-          return if case_node.condition
+          if case_node.condition || NOT_SUPPORTED_PARENT_TYPES.include?(case_node.parent&.type)
+            return
+          end
 
           branch_bodies = [*case_node.when_branches.map(&:body), case_node.else_branch].compact
 
@@ -52,6 +56,7 @@ module RuboCop
 
           add_offense(case_node.loc.keyword) { |corrector| autocorrect(corrector, case_node) }
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         private
 

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

@@ -39,7 +39,7 @@ module RuboCop
 
         MSG_IF = 'Avoid multi-line ternary operators, use `if` or `unless` instead.'
         MSG_SINGLE_LINE = 'Avoid multi-line ternary operators, use single-line instead.'
-        SINGLE_LINE_TYPES = %i[return break next send].freeze
+        SINGLE_LINE_TYPES = %i[return break next send csend].freeze
 
         def on_if(node)
           return unless offense?(node)

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

@@ -173,7 +173,9 @@ module RuboCop
         end
 
         def correct_for_comment(corrector, node, if_branch)
-          comments = processed_source.ast_with_comments[if_branch]
+          comments = processed_source.ast_with_comments[if_branch].select do |comment|
+            comment.loc.line < if_branch.condition.first_line
+          end
           comment_text = comments.map(&:text).join("\n") << "\n"
 
           corrector.insert_before(node.loc.keyword, comment_text) unless comments.empty?

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

@@ -50,6 +50,14 @@ module RuboCop
         PERCENT_MSG = 'Use `%i` or `%I` for an array of symbols.'
         ARRAY_MSG = 'Use %<prefer>s for an array of symbols.'
         DELIMITERS = ['[', ']', '(', ')'].freeze
+        SPECIAL_GVARS = %w[
+          $! $" $$ $& $' $* $+ $, $/ $; $: $. $< $= $> $? $@ $\\ $_ $` $~ $0
+          $-0 $-F $-I $-K $-W $-a $-d $-i $-l $-p $-v $-w
+        ].freeze
+        REDEFINABLE_OPERATORS = %w(
+          | ^ & <=> == === =~ > >= < <= << >>
+          + - * / % ** ~ +@ -@ [] []= ` ! != !~
+        ).freeze
 
         class << self
           attr_accessor :largest_brackets
@@ -109,15 +117,6 @@ module RuboCop
         end
 
         def symbol_without_quote?(string)
-          special_gvars = %w[
-            $! $" $$ $& $' $* $+ $, $/ $; $: $. $< $= $> $? $@ $\\ $_ $` $~ $0
-            $-0 $-F $-I $-K $-W $-a $-d $-i $-l $-p $-v $-w
-          ]
-          redefinable_operators = %w(
-            | ^ & <=> == === =~ > >= < <= << >>
-            + - * / % ** ~ +@ -@ [] []= ` ! != !~
-          )
-
           # method name
           /\A[a-zA-Z_]\w*[!?]?\z/.match?(string) ||
             # instance / class variable
@@ -125,8 +124,8 @@ module RuboCop
             # global variable
             /\A\$[1-9]\d*\z/.match?(string) ||
             /\A\$[a-zA-Z_]\w*\z/.match?(string) ||
-            special_gvars.include?(string) ||
-            redefinable_operators.include?(string)
+            SPECIAL_GVARS.include?(string) ||
+            REDEFINABLE_OPERATORS.include?(string)
         end
       end
     end

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

@@ -19,22 +19,23 @@ module RuboCop
       #   differently on different classes, and are not guaranteed to
       #   have the same result if reversed.
       #
-      # @example SupportedOperators: ['*', '+', '&'']
+      # @example SupportedOperators: ['*', '+', '&', '|', '^'] (default)
       #   # bad
-      #   1 + x
       #   10 * y
+      #   1 + x
       #   1 & z
+      #   1 | x
+      #   1 ^ x
       #   1 + CONST
       #
       #   # good
-      #   60 * 24
-      #   x + 1
       #   y * 10
+      #   x + 1
       #   z & 1
+      #   x | 1
+      #   x ^ 1
       #   CONST + 1
-      #
-      #   # good
-      #   1 | x
+      #   60 * 24
       #
       class YodaExpression < Base
         extend AutoCorrector

data/lib/rubocop/file_finder.rb

@@ -6,12 +6,8 @@ module RuboCop
   # Common methods for finding files.
   # @api private
   module FileFinder
-    def self.root_level=(level)
-      @root_level = level
-    end
-
-    def self.root_level?(path, stop_dir)
-      (@root_level || stop_dir) == path.to_s
+    class << self
+      attr_accessor :root_level
     end
 
     def find_file_upwards(filename, start_dir, stop_dir = nil)
@@ -34,7 +30,8 @@ module RuboCop
         file = dir + filename
         yield(file.to_s) if file.exist?
 
-        break if FileFinder.root_level?(dir, stop_dir)
+        dir = dir.to_s
+        break if dir == stop_dir || dir == FileFinder.root_level
       end
     end
   end

data/lib/rubocop/rspec/shared_contexts.rb

@@ -11,6 +11,8 @@ RSpec.shared_context 'isolated environment' do # rubocop:disable Metrics/BlockLe
       # Make sure to expand all symlinks in the path first. Otherwise we may
       # get mismatched pathnames when loading config files later on.
       tmpdir = File.realpath(tmpdir)
+      # Make upwards search for .rubocop.yml files stop at this directory.
+      RuboCop::FileFinder.root_level = tmpdir
 
       virtual_home = File.expand_path(File.join(tmpdir, 'home'))
       Dir.mkdir(virtual_home)
@@ -21,9 +23,6 @@ RSpec.shared_context 'isolated environment' do # rubocop:disable Metrics/BlockLe
       root = example.metadata[:root]
       working_dir = root ? File.join(base_dir, 'work', root) : File.join(base_dir, 'work')
 
-      # Make upwards search for .rubocop.yml files stop at this directory.
-      RuboCop::FileFinder.root_level = working_dir
-
       begin
         FileUtils.mkdir_p(working_dir)
 

data/lib/rubocop/version.rb

@@ -3,7 +3,7 @@
 module RuboCop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '1.56.2'
+    STRING = '1.56.3'
 
     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.56.2
+  version: 1.56.3
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-08-29 00:00:00.000000000 Z
+date: 2023-09-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64