rubocop 1.37.0 → 1.38.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e928a8547def9cafd9cddc36b5a407aef7d46fdf9825941c7906073492d88668
-  data.tar.gz: 3ef9727850f93815ba310b7c3a8cf74e53a0ee18a0fcf6731fd97a3640ffe28d
+  metadata.gz: 1ed47ef39bb205db15249a399d0502f730c2656f712293357651cc0ddd328715
+  data.tar.gz: 5e6411a2b459e0ac426e0ef0d8b8508b9b1693fea0c5b8cb5d82ed23f71d39b9
 SHA512:
-  metadata.gz: f57e5d25375fe47734a6e198924db74b341501762dc8f54277a888788ab821215c96847940cec1af4d90673fe79ab906b451bf25bec90f9c8c080e78efc01111
-  data.tar.gz: 69cafbca956eaa49887596d255f6888057ede94f3621349398de95da5c477201f7bee7eae074ab4750ce0131dcb26d6dfdc77c31f5fcb478d2fc25d5ca73e68c
+  metadata.gz: 5cfd13ac3c283e77e300f87ee923be282740f2763e26c73d21d27b5ae176629d15d8d580d9d326349acf5b71c74e6335689c2192050a818577b9f2e0a6a4484f
+  data.tar.gz: 27f36547ccdf6cc1336e1c44c5e164410f65344cba77fda76ad2db463054adaa93c96a406939b3826412280463a1d6a2940708f4080bc3170999bcc81594ba9d

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.37', require: false
+gem 'rubocop', '~> 1.38', require: false
 ```
 
 See [our versioning policy](https://docs.rubocop.org/rubocop/versioning.html) for further details.

data/config/default.yml

@@ -4696,6 +4696,12 @@ Style/RedundantConditional:
   Enabled: true
   VersionAdded: '0.50'
 
+Style/RedundantEach:
+  Description: 'Checks for redundant `each`.'
+  Enabled: pending
+  Safe: false
+  VersionAdded: '1.38'
+
 Style/RedundantException:
   Description: "Checks for an obsolete RuntimeException argument in raise/fail."
   StyleGuide: '#no-explicit-runtimeerror'

data/lib/rubocop/cli/command/suggest_extensions.rb

@@ -73,7 +73,14 @@ module RuboCop
         def all_extensions
           return [] unless lockfile.dependencies.any?
 
-          extensions = @config_store.for_pwd.for_all_cops['SuggestExtensions'] || {}
+          extensions = @config_store.for_pwd.for_all_cops['SuggestExtensions']
+          case extensions
+          when true
+            extensions = ConfigLoader.default_configuration.for_all_cops['SuggestExtensions']
+          when false, nil
+            extensions = {}
+          end
+
           extensions.select { |_, v| (Array(v) & dependent_gems).any? }.keys
         end
 

data/lib/rubocop/comment_config.rb

@@ -4,10 +4,31 @@ module RuboCop
   # This class parses the special `rubocop:disable` comments in a source
   # and provides a way to check if each cop is enabled at arbitrary line.
   class CommentConfig
+    extend Forwardable
+
+    CONFIG_DISABLED_LINE_RANGE_MIN = -Float::INFINITY
+
+    # This class provides an API compatible with RuboCop::DirectiveComment
+    # to be used for cops that are disabled in the config file
+    class ConfigDisabledCopDirectiveComment
+      attr_reader :text, :loc, :line_number
+
+      Loc = Struct.new(:expression)
+      Expression = Struct.new(:line)
+
+      def initialize(cop_name)
+        @text = "# rubocop:disable #{cop_name}"
+        @line_number = CONFIG_DISABLED_LINE_RANGE_MIN
+        @loc = Loc.new(Expression.new(CONFIG_DISABLED_LINE_RANGE_MIN))
+      end
+    end
+
     CopAnalysis = Struct.new(:line_ranges, :start_line_number)
 
     attr_reader :processed_source
 
+    def_delegators :@processed_source, :config, :registry
+
     def initialize(processed_source)
       @processed_source = processed_source
     end
@@ -25,7 +46,11 @@ module RuboCop
     end
 
     def extra_enabled_comments
-      extra_enabled_comments_with_names(extras: Hash.new { |h, k| h[k] = [] }, names: Hash.new(0))
+      disable_count = Hash.new(0)
+      registry.disabled(config).each do |cop|
+        disable_count[cop.cop_name] += 1
+      end
+      extra_enabled_comments_with_names(extras: Hash.new { |h, k| h[k] = [] }, names: disable_count)
     end
 
     def comment_only_line?(line_number)
@@ -50,6 +75,7 @@ module RuboCop
 
     def analyze # rubocop:todo Metrics/AbcSize
       analyses = Hash.new { |hash, key| hash[key] = CopAnalysis.new([], nil) }
+      inject_disabled_cops_directives(analyses)
 
       each_directive do |directive|
         directive.cop_names.each do |cop_name|
@@ -64,6 +90,15 @@ module RuboCop
       end
     end
 
+    def inject_disabled_cops_directives(analyses)
+      registry.disabled(config).each do |cop|
+        analyses[cop.cop_name] = analyze_cop(
+          analyses[cop.cop_name],
+          DirectiveComment.new(ConfigDisabledCopDirectiveComment.new(cop.cop_name))
+        )
+      end
+    end
+
     def analyze_cop(analysis, directive)
       # Disabling cops after comments like `#=SomeDslDirective` does not related to single line
       if !comment_only_line?(directive.line_number) || directive.single_line?

data/lib/rubocop/cop/commissioner.rb

@@ -159,9 +159,11 @@ module RuboCop
       def with_cop_error_handling(cop, node = nil)
         yield
       rescue StandardError => e
-        raise e if @options[:raise_error]
+        raise e if @options[:raise_error] # For internal testing
 
         err = ErrorWithAnalyzedFileLocation.new(cause: e, node: node, cop: cop)
+        raise err if @options[:raise_cop_error] # From user-input option
+
         @errors << err
       end
     end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks for uses of `create_file` with empty string second argument.
+      #
+      # @example
+      #
+      #   # bad
+      #   create_file(path, '')
+      #
+      #   # good
+      #   create_empty_file(path)
+      #
+      class CreateEmptyFile < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<replacement>s`.'
+        RESTRICT_ON_SEND = %i[create_file].freeze
+
+        def on_send(node)
+          return if node.receiver
+          return unless (argument = node.arguments[1])
+          return unless argument.str_type? && argument.value.empty?
+
+          replacement = "create_empty_file(#{node.first_argument.source})"
+          message = format(MSG, replacement: replacement)
+
+          add_offense(node, message: message) do |corrector|
+            corrector.replace(node, replacement)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Use `RUBY` for heredoc delimiter of example Ruby code.
+      #
+      # Some editors may apply better syntax highlighting by using appropriate language names for
+      # the delimiter.
+      #
+      # @example
+      #  # bad
+      #  expect_offense(<<~CODE)
+      #    example_ruby_code
+      #  CODE
+      #
+      #  # good
+      #  expect_offense(<<~RUBY)
+      #    example_ruby_code
+      #  RUBY
+      class ExampleHeredocDelimiter < Base
+        extend AutoCorrector
+
+        EXPECTED_HEREDOC_DELIMITER = 'RUBY'
+
+        MSG = 'Use `RUBY` for heredoc delimiter of example Ruby code.'
+
+        RESTRICT_ON_SEND = %i[
+          expect_correction
+          expect_no_corrections
+          expect_no_offenses
+          expect_offense
+        ].freeze
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def on_send(node)
+          heredoc_node = heredoc_node_from(node)
+          return unless heredoc_node
+          return if expected_heredoc_delimiter?(heredoc_node)
+          return if expected_heredoc_delimiter_in_body?(heredoc_node)
+
+          add_offense(heredoc_node) do |corrector|
+            autocorrect(corrector, heredoc_node)
+          end
+        end
+
+        private
+
+        # @param corrector [RuboCop::Cop::Corrector]
+        # @param node [RuboCop::AST::StrNode]
+        # @return [void]
+        def autocorrect(corrector, node)
+          [
+            heredoc_openning_delimiter_range_from(node),
+            heredoc_closing_delimiter_range_from(node)
+          ].each do |range|
+            corrector.replace(range, EXPECTED_HEREDOC_DELIMITER)
+          end
+        end
+
+        # @param node [RuboCop::AST::StrNode]
+        # @return [Boolean]
+        def expected_heredoc_delimiter_in_body?(node)
+          node.location.heredoc_body.source.lines.any? do |line|
+            line.strip == EXPECTED_HEREDOC_DELIMITER
+          end
+        end
+
+        # @param node [RuboCop::AST::StrNode]
+        # @return [Boolean]
+        def expected_heredoc_delimiter?(node)
+          heredoc_delimiter_string_from(node) == EXPECTED_HEREDOC_DELIMITER
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [RuboCop::AST::StrNode, nil]
+        def heredoc_node_from(node)
+          return unless node.first_argument.respond_to?(:heredoc?)
+          return unless node.first_argument.heredoc?
+
+          node.first_argument
+        end
+
+        # @param node [RuboCop::AST::StrNode]
+        # @return [String]
+        def heredoc_delimiter_string_from(node)
+          node.source[Heredoc::OPENING_DELIMITER, 2]
+        end
+
+        # @param node [RuboCop::AST::StrNode]
+        # @return [Parser::Source::Range]
+        def heredoc_openning_delimiter_range_from(node)
+          match_data = node.source.match(Heredoc::OPENING_DELIMITER)
+          node.location.expression.begin.adjust(
+            begin_pos: match_data.begin(2),
+            end_pos: match_data.end(2)
+          )
+        end
+
+        # @param node [RuboCop::AST::StrNode]
+        # @return [Parser::Source::Range]
+        def heredoc_closing_delimiter_range_from(node)
+          node.location.heredoc_end.end.adjust(
+            begin_pos: -heredoc_delimiter_string_from(node).length
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
 require_relative 'internal_affairs/cop_description'
+require_relative 'internal_affairs/create_empty_file'
 require_relative 'internal_affairs/empty_line_between_expect_offense_and_correction'
 require_relative 'internal_affairs/example_description'
+require_relative 'internal_affairs/example_heredoc_delimiter'
 require_relative 'internal_affairs/inherit_deprecated_cop_class'
 require_relative 'internal_affairs/location_line_equality_comparison'
 require_relative 'internal_affairs/method_name_end_with'

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

@@ -90,7 +90,7 @@ module RuboCop
           # which lines start inside a string literal?
           return [] if ast.nil?
 
-          ast.each_node(:str, :dstr).each_with_object(Set.new) do |str, ranges|
+          ast.each_node(:str, :dstr).with_object(Set.new) do |str, ranges|
             loc = str.location
 
             if str.heredoc?

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

@@ -92,7 +92,7 @@ module RuboCop
           # which lines start inside a string literal?
           return [] if ast.nil?
 
-          ast.each_node(:str, :dstr).each_with_object(Set.new) do |str, ranges|
+          ast.each_node(:str, :dstr).with_object(Set.new) do |str, ranges|
             loc = str.location
 
             if str.heredoc?

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

@@ -194,6 +194,8 @@ module RuboCop
         end
 
         def range_inside_hash(node)
+          return node.source_range if node.location.begin.nil?
+
           range_between(node.location.begin.end_pos, node.location.end.begin_pos)
         end
 

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

@@ -38,6 +38,8 @@ module RuboCop
       #   # bad
       #   foo[ ]
       #   foo[     ]
+      #   foo[
+      #   ]
       #
       #   # good
       #   foo[]
@@ -49,6 +51,8 @@ module RuboCop
       #   # bad
       #   foo[]
       #   foo[    ]
+      #   foo[
+      #   ]
       #
       #   # good
       #   foo[ ]
@@ -64,8 +68,6 @@ module RuboCop
         RESTRICT_ON_SEND = %i[[] []=].freeze
 
         def on_send(node)
-          return if node.multiline?
-
           tokens = processed_source.tokens_within(node)
           left_token = left_ref_bracket(node, tokens)
           return unless left_token
@@ -76,6 +78,8 @@ module RuboCop
             return empty_offenses(node, left_token, right_token, EMPTY_MSG)
           end
 
+          return if node.multiline?
+
           if style == :no_space
             no_space_offenses(node, left_token, right_token, MSG)
           else

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

@@ -141,7 +141,7 @@ module RuboCop
           if empty_if_branch?(node) && else_branch?(node)
             node.source_range.with(end_pos: node.loc.else.begin_pos)
           elsif node.loc.else
-            node.source_range.with(end_pos: node.loc.else.begin_pos - 1)
+            node.source_range.with(end_pos: node.condition.loc.expression.end_pos)
           elsif all_branches_body_missing?(node)
             if_node = node.ancestors.detect(&:if?)
             node.source_range.with(end_pos: if_node.loc.end.end_pos)

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

@@ -50,9 +50,7 @@ module RuboCop
 
         def on_new_investigation
           each_missing_enable do |cop, line_range|
-            # This has to remain a strict inequality to handle
-            # the case when max_range is Float::INFINITY
-            next if line_range.max - line_range.min < max_range + 2
+            next if acceptable_range?(cop, line_range)
 
             range = source_range(processed_source.buffer, line_range.min, (0..0))
             comment = processed_source.comment_at_line(line_range.begin)
@@ -69,6 +67,23 @@ module RuboCop
           end
         end
 
+        def acceptable_range?(cop, line_range)
+          # This has to remain a strict inequality to handle
+          # the case when max_range is Float::INFINITY
+          return true if line_range.max - line_range.min < max_range + 2
+          # This cop is disabled in the config, it is not expected to be re-enabled
+          return true if line_range.min == CommentConfig::CONFIG_DISABLED_LINE_RANGE_MIN
+
+          cop_class = RuboCop::Cop::Registry.global.find_by_cop_name cop
+          if cop_class &&
+             !processed_source.registry.enabled?(cop_class, config) &&
+             line_range.max == Float::INFINITY
+            return true
+          end
+
+          false
+        end
+
         def max_range
           @max_range ||= cop_config['MaximumRangeSize']
         end

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

@@ -113,6 +113,7 @@ module RuboCop
         def each_line_range(cop, line_ranges)
           line_ranges.each_with_index do |line_range, line_range_index|
             next if ignore_offense?(line_range)
+            next if expected_final_disable?(cop, line_range)
 
             comment = processed_source.comment_at_line(line_range.begin)
             redundant = if all_disabled?(comment)
@@ -179,11 +180,21 @@ module RuboCop
         end
 
         def ignore_offense?(line_range)
+          return true if line_range.min == CommentConfig::CONFIG_DISABLED_LINE_RANGE_MIN
+
           disabled_ranges.any? do |range|
             range.cover?(line_range.min) && range.cover?(line_range.max)
           end
         end
 
+        def expected_final_disable?(cop, line_range)
+          # A cop which is disabled in the config is being re-disabled until end of file
+          cop_class = RuboCop::Cop::Registry.global.find_by_cop_name cop
+          cop_class &&
+            !processed_source.registry.enabled?(cop_class, config) &&
+            line_range.max == Float::INFINITY
+        end
+
         def department_disabled?(cop, comment)
           directive = DirectiveComment.new(comment)
           directive.in_directive_department?(cop) && !directive.overridden_by_department?(cop)

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

@@ -20,6 +20,7 @@ module RuboCop
       #   * 2.5+ ... Add `pp` above
       #   * 2.7+ ... Add `ruby2_keywords` above
       #   * 3.1+ ... Add `fiber` above
+      #   * 3.2+ ... `set`
       #
       # This cop target those features.
       #
@@ -48,7 +49,13 @@ module RuboCop
           return unless redundant_require_statement?(node)
 
           add_offense(node) do |corrector|
-            range = range_with_surrounding_space(node.loc.expression, side: :right)
+            if node.parent.respond_to?(:modifier_form?) && node.parent.modifier_form?
+              corrector.insert_after(node.parent, "\nend")
+
+              range = range_with_surrounding_space(node.loc.expression, side: :right)
+            else
+              range = range_by_whole_lines(node.source_range, include_final_newline: true)
+            end
 
             corrector.remove(range)
           end
@@ -63,7 +70,8 @@ module RuboCop
             (target_ruby_version >= 2.2 && RUBY_22_LOADED_FEATURES.include?(feature_name)) ||
             (target_ruby_version >= 2.5 && feature_name == 'pp') ||
             (target_ruby_version >= 2.7 && feature_name == 'ruby2_keywords') ||
-            (target_ruby_version >= 3.1 && feature_name == 'fiber')
+            (target_ruby_version >= 3.1 && feature_name == 'fiber') ||
+            (target_ruby_version >= 3.2 && feature_name == 'set')
         end
         # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       end

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

@@ -118,14 +118,15 @@ module RuboCop
       end
 
       def offending_empty_no_space?(config, left_token, right_token)
-        config == 'no_space' && !no_space_between?(left_token, right_token)
+        config == 'no_space' && !no_character_between?(left_token, right_token)
       end
 
       def space_between?(left_bracket_token, right_bracket_token)
-        left_bracket_token.end_pos + 1 == right_bracket_token.begin_pos
+        left_bracket_token.end_pos + 1 == right_bracket_token.begin_pos &&
+          processed_source.buffer.source[left_bracket_token.end_pos] == ' '
       end
 
-      def no_space_between?(left_bracket_token, right_bracket_token)
+      def no_character_between?(left_bracket_token, right_bracket_token)
         left_bracket_token.end_pos == right_bracket_token.begin_pos
       end
     end

data/lib/rubocop/cop/registry.rb

@@ -149,16 +149,22 @@ module RuboCop
         @registry.size
       end
 
-      def enabled(config, only = [], only_safe: false)
-        select { |cop| only.include?(cop.cop_name) || enabled?(cop, config, only_safe) }
+      def enabled(config)
+        select { |cop| enabled?(cop, config) }
       end
 
-      def enabled?(cop, config, only_safe)
+      def disabled(config)
+        reject { |cop| enabled?(cop, config) }
+      end
+
+      def enabled?(cop, config)
+        return true if options.fetch(:only, []).include?(cop.cop_name)
+
         cfg = config.for_cop(cop)
 
         cop_enabled = cfg.fetch('Enabled') == true || enabled_pending_cop?(cfg, config)
 
-        if only_safe
+        if options.fetch(:safe, false)
           cop_enabled && cfg.fetch('Safe', true)
         else
           cop_enabled

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

@@ -85,6 +85,8 @@ module RuboCop
 
         RESTRICT_ON_SEND = %i[private protected public module_function].freeze
 
+        ALLOWED_NODE_TYPES = %i[pair block].freeze
+
         # @!method access_modifier_with_symbol?(node)
         def_node_matcher :access_modifier_with_symbol?, <<~PATTERN
           (send nil? {:private :protected :public :module_function} (sym _))
@@ -92,7 +94,7 @@ module RuboCop
 
         def on_send(node)
           return unless node.access_modifier?
-          return if node.parent&.pair_type?
+          return if ALLOWED_NODE_TYPES.include?(node.parent&.type)
           return if allow_modifiers_on_symbols?(node)
 
           if offense?(node)

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

@@ -425,7 +425,7 @@ module RuboCop
           if node.parent.begin_type?
             return_value_used?(node.parent)
           else
-            node.parent.assignment? || node.parent.send_type?
+            node.parent.assignment? || node.parent.call_type?
           end
         end
 

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

@@ -29,7 +29,7 @@ module RuboCop
 
         def offense?(node)
           # we don't register an offense for things like ?\C-\M-d
-          node.loc.begin.is?('?') && node.source.size.between?(2, 3)
+          node.character_literal? && node.source.size.between?(2, 3)
         end
 
         def autocorrect(corrector, node)

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

@@ -8,7 +8,9 @@ module RuboCop
       #
       # @safety
       #   It is unsafe by default because false positives may occur in the
-      #   `nil` check of block arguments to the receiver object.
+      #   `nil` check of block arguments to the receiver object. Additionally,
+      #    we can't know the type of the receiver object for sure, which may
+      #    result in false positives as well.
       #
       #   For example, `[[1, 2], [3, nil]].reject { |first, second| second.nil? }`
       #   and `[[1, 2], [3, nil]].compact` are not compatible. This will work fine
@@ -96,7 +98,9 @@ module RuboCop
         end
 
         def to_enum_method?(node)
-          TO_ENUM_METHODS.include?(node.children.first.method_name)
+          return false unless node.receiver.send_type?
+
+          TO_ENUM_METHODS.include?(node.receiver.method_name)
         end
 
         def good_method_name(node)