rubocop 1.56.0 → 1.56.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 76532b5c0c7ccf0baff454ad37e17c405e4f827a0c8323ce1a5aab0ee9e78c19
-  data.tar.gz: fe2f7d727d5addd930a762ebe7fb34a38845164fed801744a6802ab91e6ba779
+  metadata.gz: 33c4c853e4bf651034a9ac3faa2f221baa77104521504824e2b4e88b349f01e0
+  data.tar.gz: d49422193353fc79c86b1c8cdfc3465f4abebf56bc01cd95d2c0e150c3f9747a
 SHA512:
-  metadata.gz: ff206ac0d02084dd7014818da655f5f8d718ac1bb4bfc2f781d3c007839096a142236ded54d30084fa7b3e1689205ff7a8bc7ad7eee3ffea2d809e4610d6a1ae
-  data.tar.gz: aaa03f29b7669ffcf6fdcb16b7da4c38a6bc62187eb91d6347e3ada22f396370b6564177eb3a040fd5ddd3eeea9cf8b3ff51943e79c3d0ad410508a75bb3177b
+  metadata.gz: 3bd1f56046aba375e89f62b8c954802636023539111238848c25b37a70ed95a41835198b2dd17ded64223b1f50e98f7e20f0c82aafed0381cad30f0be526b4fc
+  data.tar.gz: e02897c89f4869054ffea56efac2d9983f65bdce40c9254d5806effbda70561bf9c7c4161fa9a7d3269dc229d6d09b3e7c990eef10835f7ec5f2b3c55b32f6cf

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

@@ -5,6 +5,24 @@ module RuboCop
     module Bundler
       # A Gem group, or a set of groups, should be listed only once in a Gemfile.
       #
+      # For example, if the values of `source`, `git`, `platforms`, or `path`
+      # surrounding `group` are different, no offense will be registered:
+      #
+      # [source,ruby]
+      # -----
+      # platforms :ruby do
+      #   group :default do
+      #     gem 'openssl'
+      #   end
+      # end
+      #
+      # platforms :jruby do
+      #   group :default do
+      #     gem 'jruby-openssl'
+      #   end
+      # end
+      # -----
+      #
       # @example
       #   # bad
       #   group :development do
@@ -42,27 +60,35 @@ module RuboCop
 
         MSG = 'Gem group `%<group_name>s` already defined on line ' \
               '%<line_of_first_occurrence>d of the Gemfile.'
+        SOURCE_BLOCK_NAMES = %i[source git platforms path].freeze
+
+        # @!method group_declarations(node)
+        def_node_search :group_declarations, '(send nil? :group ...)'
 
         def on_new_investigation
           return if processed_source.blank?
 
           duplicated_group_nodes.each do |nodes|
             nodes[1..].each do |node|
-              register_offense(node, node.arguments.map(&:value).join(', '), nodes.first.first_line)
+              group_name = node.arguments.map(&:source).join(', ')
+
+              register_offense(node, group_name, nodes.first.first_line)
             end
           end
         end
 
         private
 
-        # @!method group_declarations(node)
-        def_node_search :group_declarations, '(send nil? :group ...)'
-
         def duplicated_group_nodes
-          group_declarations(processed_source.ast)
-            .group_by { |node| node.arguments.map(&:value).map(&:to_s).sort }
-            .values
-            .select { |nodes| nodes.size > 1 }
+          group_declarations = group_declarations(processed_source.ast)
+          group_keys = group_declarations.group_by do |node|
+            source_key = find_source_key(node)
+            group_attributes = group_attributes(node).sort.join
+
+            "#{source_key}#{group_attributes}"
+          end
+
+          group_keys.values.select { |nodes| nodes.size > 1 }
         end
 
         def register_offense(node, group_name, line_of_first_occurrence)
@@ -75,6 +101,26 @@ module RuboCop
           )
           add_offense(offense_location, message: message)
         end
+
+        def find_source_key(node)
+          source_block = node.each_ancestor(:block).find do |block_node|
+            SOURCE_BLOCK_NAMES.include?(block_node.method_name)
+          end
+
+          return unless source_block
+
+          "#{source_block.method_name}#{source_block.send_node.first_argument&.source}"
+        end
+
+        def group_attributes(node)
+          node.arguments.map do |argument|
+            if argument.hash_type?
+              argument.pairs.map(&:source).sort.join(', ')
+            else
+              argument.value.to_s
+            end
+          end
+        end
       end
     end
   end

data/lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb

@@ -14,12 +14,15 @@ module RuboCop
         # Check for unparenthesized args' preceding and trailing whitespaces.
         remove_unparenthesized_whitespace(corrector)
 
-        # Avoid correcting to `lambdado` by inserting whitespace
-        # if none exists before or after the lambda arguments.
-        insert_separating_space(corrector)
+        if block_node.block_type?
+          # Avoid correcting to `lambdado` by inserting whitespace
+          # if none exists before or after the lambda arguments.
+          insert_separating_space(corrector)
+
+          remove_arguments(corrector)
+        end
 
         replace_selector(corrector)
-        remove_arguments(corrector)
 
         replace_delimiters(corrector)
 

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

@@ -57,7 +57,7 @@ module RuboCop
 
         def on_new_investigation
           processed_source.comments.each do |comment|
-            next unless /\A#+[^#\s=+-]/.match?(comment.text)
+            next unless /\A(?!#\+\+|#--)(#+[^#\s=])/.match?(comment.text)
             next if comment.loc.line == 1 && allowed_on_first_line?(comment)
             next if doxygen_comment_style?(comment)
             next if gemfile_ruby_comment?(comment)

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

@@ -109,7 +109,7 @@ module RuboCop
         # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def comment_ranges(comments)
-          comments.map(&:loc).map(&:expression)
+          comments.map(&:source_range)
         end
 
         def last_line(processed_source)

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

@@ -118,7 +118,9 @@ module RuboCop
         end
 
         def comment_within?(node)
-          processed_source.comments.map(&:loc).map(&:line).any? do |comment_line_number|
+          comment_line_numbers = processed_source.comments.map { |comment| comment.loc.line }
+
+          comment_line_numbers.any? do |comment_line_number|
             comment_line_number >= node.first_line && comment_line_number <= node.last_line
           end
         end

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

@@ -57,12 +57,12 @@ module RuboCop
           REMOVE_FORCE_METHODS).freeze
 
         # @!method send_exist_node(node)
-        def_node_search :send_exist_node, <<-PATTERN
+        def_node_search :send_exist_node, <<~PATTERN
           $(send (const nil? {:FileTest :File :Dir :Shell}) {:exist? :exists?} ...)
         PATTERN
 
         # @!method receiver_and_method_name(node)
-        def_node_matcher :receiver_and_method_name, <<-PATTERN
+        def_node_matcher :receiver_and_method_name, <<~PATTERN
           (send (const nil? $_) $_ ...)
         PATTERN
 

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

@@ -96,8 +96,7 @@ module RuboCop
           return_value_node = return_value_node_of_scope(scope)
           return unless assignment.meta_assignment_node.equal?(return_value_node)
 
-          " Use `#{assignment.operator.sub(/=$/, '')}` " \
-            "instead of `#{assignment.operator}`."
+          " Use `#{assignment.operator.delete_suffix('=')}` instead of `#{assignment.operator}`."
         end
 
         def similar_name_message(variable)

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

@@ -136,7 +136,7 @@ module RuboCop
         end
 
         def filename_good?(basename)
-          basename = basename.sub(/^\./, '')
+          basename = basename.delete_prefix('.')
           basename = basename.sub(/\.[^.]+$/, '')
           # special handling for Action Pack Variants file names like
           # some_file.xlsx+mobile.axlsx

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

@@ -80,6 +80,7 @@ module RuboCop
         minimum_target_ruby_version 2.7
 
         FORWARDING_LVAR_TYPES = %i[splat kwsplat block_pass].freeze
+        ADDITIONAL_ARG_TYPES = %i[lvar arg].freeze
 
         FORWARDING_MSG = 'Use shorthand syntax `...` for arguments forwarding.'
         ARGS_MSG = 'Use anonymous positional arguments forwarding (`*`).'
@@ -212,7 +213,7 @@ module RuboCop
         end
 
         def arguments_range(node, first_node)
-          arguments = node.arguments
+          arguments = node.arguments.reject { |arg| ADDITIONAL_ARG_TYPES.include?(arg.type) }
 
           start_node = first_node || arguments.first
 
@@ -279,7 +280,7 @@ module RuboCop
 
             if can_forward_all?
               :all
-            elsif target_ruby_version >= 3.2
+            else
               :rest_or_kwrest
             end
           end
@@ -332,9 +333,9 @@ module RuboCop
           end
 
           def no_post_splat_args?
-            splat_index = arguments.index(forwarded_rest_arg)
-            arg_after_splat = arguments[splat_index + 1]
+            return true unless (splat_index = arguments.index(forwarded_rest_arg))
 
+            arg_after_splat = arguments[splat_index + 1]
             [nil, :hash, :block_pass].include?(arg_after_splat&.type)
           end
 

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

@@ -74,7 +74,7 @@ module RuboCop
           new_arguments =
             node.arguments.map do |arg|
               if arg.percent_literal?
-                arg.children.map(&:value).map(&:inspect)
+                arg.children.map { |child| child.value.inspect }
               else
                 arg.children.map(&:source)
               end

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

@@ -146,7 +146,9 @@ module RuboCop
           end
 
           def call_in_match_pattern?(node)
-            node.parent&.match_pattern_type?
+            return false unless (parent = node.parent)
+
+            parent.match_pattern_type? || parent.match_pattern_p_type?
           end
 
           def hash_literal_in_arguments?(node)

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

@@ -45,7 +45,7 @@ module RuboCop
         MSG = 'Avoid using `OpenStruct`; use `Struct`, `Hash`, a class or test doubles instead.'
 
         # @!method uses_open_struct?(node)
-        def_node_matcher :uses_open_struct?, <<-PATTERN
+        def_node_matcher :uses_open_struct?, <<~PATTERN
           (const {nil? (cbase)} :OpenStruct)
         PATTERN
 

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

@@ -98,7 +98,9 @@ module RuboCop
         end
 
         def like_method_argument_parentheses?(node)
-          node.send_type? && node.arguments.one? && !node.parenthesized? &&
+          return false if !node.send_type? && !node.super_type? && !node.yield_type?
+
+          node.arguments.one? && !node.parenthesized? &&
             !node.arithmetic_operation? && node.first_argument.begin_type?
         end
 

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

@@ -75,6 +75,11 @@ module RuboCop
           add_offense(offense_branch) do |corrector|
             assignment_value = opposite_branch ? opposite_branch.source : 'nil'
             replacement = "#{assignment_value} #{keyword} #{if_node.condition.source}"
+            if opposite_branch.respond_to?(:heredoc?) && opposite_branch.heredoc?
+              replacement += opposite_branch.loc.heredoc_end.with(
+                begin_pos: opposite_branch.source_range.end_pos
+              ).source
+            end
 
             corrector.replace(if_node, replacement)
           end

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

@@ -69,6 +69,8 @@ module RuboCop
 
         def complex_content?(node)
           node.children.any? do |sym|
+            return false if DELIMITERS.include?(sym.source)
+
             content = *sym
             content = content.map { |c| c.is_a?(AST::Node) ? c.source : c }.join
             content_without_delimiter_pairs = content.gsub(/(\[[^\s\[\]]*\])|(\([^\s\(\)]*\))/, '')

data/lib/rubocop/cop/utils/regexp_ranges.rb

@@ -6,27 +6,40 @@ module RuboCop
       # Helper to abstract complexity of building range pairs
       # with octal escape reconstruction (needed for regexp_parser < 2.7).
       class RegexpRanges
-        attr_reader :compound_token, :root
+        attr_reader :root
 
         def initialize(root)
           @root = root
           @compound_token = []
+          @pairs = []
+          @populated = false
+        end
+
+        def compound_token
+          populate_all unless @populated
+
+          @compound_token
         end
 
         def pairs
-          unless @pairs
-            @pairs = []
-            populate(root)
-          end
+          populate_all unless @populated
+
+          @pairs
+        end
+
+        private
+
+        def populate_all
+          populate(@root)
 
           # If either bound is a compound the first one is an escape
           # and that's all we need to work with.
           # If there are any cops that wanted to operate on the compound
           # expression we could wrap it with a facade class.
-          @pairs.map { |pair| pair.map(&:first) }
-        end
+          @pairs.map! { |pair| pair.map(&:first) }
 
-        private
+          @populated = true
+        end
 
         def populate(expr)
           expressions = expr.expressions.to_a
@@ -35,15 +48,15 @@ module RuboCop
             current = expressions.shift
 
             if escaped_octal?(current)
-              compound_token << current
-              compound_token.concat(pop_octal_digits(expressions))
+              @compound_token << current
+              @compound_token.concat(pop_octal_digits(expressions))
               # If we have all the digits we can discard.
             end
 
             next unless current.type == :set
 
             process_set(expressions, current)
-            compound_token.clear
+            @compound_token.clear
           end
         end
 
@@ -64,8 +77,8 @@ module RuboCop
 
         def compose_range(expressions, current)
           range_start, range_end = current.expressions
-          range_start = if compound_token.size.between?(1, 2) && octal_digit?(range_start.text)
-                          compound_token.dup << range_start
+          range_start = if @compound_token.size.between?(1, 2) && octal_digit?(range_start.text)
+                          @compound_token.dup << range_start
                         else
                           [range_start]
                         end

data/lib/rubocop/target_ruby.rb

@@ -155,9 +155,11 @@ module RuboCop
         (send _ :required_ruby_version= $_)
       PATTERN
 
-      # @!method gem_requirement?(node)
-      def_node_matcher :gem_requirement?, <<~PATTERN
-        (send (const(const _ :Gem):Requirement) :new $str)
+      # @!method gem_requirement_versions(node)
+      def_node_matcher :gem_requirement_versions, <<~PATTERN
+        (send (const(const _ :Gem):Requirement) :new
+          {$str+ | (send $str :freeze)+ | (array $str+) | (array (send $str :freeze)+)}
+        )
       PATTERN
 
       def name
@@ -194,10 +196,12 @@ module RuboCop
       end
 
       def version_from_right_hand_side(right_hand_side)
+        gem_requirement_versions = gem_requirement_versions(right_hand_side)
+
         if right_hand_side.array_type?
           version_from_array(right_hand_side)
-        elsif gem_requirement?(right_hand_side)
-          right_hand_side.children.last.value
+        elsif gem_requirement_versions
+          gem_requirement_versions.map(&:value)
         else
           right_hand_side.value
         end

data/lib/rubocop/version.rb

@@ -3,7 +3,7 @@
 module RuboCop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '1.56.0'
+    STRING = '1.56.1'
 
     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.0
+  version: 1.56.1
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-08-09 00:00:00.000000000 Z
+date: 2023-08-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -196,9 +196,9 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '3.0'
-description: |2
-      RuboCop is a Ruby code style checking and code formatting tool.
-      It aims to enforce the community-driven Ruby Style Guide.
+description: |
+  RuboCop is a Ruby code style checking and code formatting tool.
+  It aims to enforce the community-driven Ruby Style Guide.
 email: rubocop@googlegroups.com
 executables:
 - rubocop