rubocop 1.53.0 → 1.90.0

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

@@ -10,8 +10,10 @@ module RuboCop
         COMMA_REGEXP = /(?<=\))\s*,/.freeze
 
         def correct(corrector, node)
-          corrector.remove(node.loc.begin)
-          corrector.remove(node.loc.end)
+          buffer = node.source_range.source_buffer
+          corrector.remove(range_with_surrounding_space(range: node.loc.begin, buffer: buffer,
+                                                        side: :right, whitespace: true))
+          remove_close_paren(corrector, node, buffer)
           handle_orphaned_comma(corrector, node)
 
           return unless ternary_condition?(node) && next_char_is_question_mark?(node)
@@ -21,8 +23,40 @@ module RuboCop
 
         private
 
+        # When the line above `)` ends with a comment and a chained call follows `)`,
+        # crossing the newline would pull the chain into the comment. Preserve the newline.
+        def remove_close_paren(corrector, node, buffer)
+          newlines = !comment_above_close_paren_swallows_chain?(node, buffer)
+          corrector.remove(range_with_surrounding_space(range: node.loc.end, buffer: buffer,
+                                                        side: :left, newlines: newlines))
+        end
+
+        def comment_above_close_paren_swallows_chain?(node, buffer)
+          last_child = node.children.last
+          return false unless last_child
+
+          body_end = last_child.source_range.end_pos
+          close_paren_begin = node.loc.end.begin_pos
+          return false if body_end >= close_paren_begin
+
+          source_between = buffer.source[body_end...close_paren_begin]
+          return false unless source_between.match?(/#[^\n]*\n/)
+
+          chained_after_close_paren?(node)
+        end
+
+        def chained_after_close_paren?(node)
+          close_paren = node.loc.end
+          line_text = close_paren.source_line
+          after_paren = line_text[(close_paren.column + 1)..]
+          return false if after_paren.nil?
+
+          trimmed = after_paren.lstrip
+          !trimmed.empty? && !trimmed.start_with?('#')
+        end
+
         def ternary_condition?(node)
-          node.parent&.if_type? && node.parent&.ternary?
+          node.parent&.if_type? && node.parent.ternary?
         end
 
         def next_char_is_question_mark?(node)

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

@@ -94,6 +94,16 @@ module RuboCop
       end
 
       def substitute_escaped_delimiters(content, delimiters)
+        if delimiters.first != delimiters.last
+          # With different delimiters (eg. `[]`, `()`), if there are the same
+          # number of each, escaping is not necessary
+          delimiter_counts = delimiters.to_h do |delimiter|
+            [delimiter, content.count(delimiter)]
+          end
+
+          return content if delimiter_counts[delimiters.first] == delimiter_counts[delimiters.last]
+        end
+
         delimiters.each { |delim| content.gsub!(delim, "\\#{delim}") }
       end
 

data/lib/rubocop/cop/correctors.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop # rubocop:disable Style/Documentation
+    # Autoloads corrector classes used by cops. Classes are autoloaded to reduce the number of
+    # required classes because they're referenced only when autocorrection is performed.
+
+    # rubocop:disable Layout/LineLength
+    autoload :AlignmentCorrector, 'rubocop/cop/correctors/alignment_corrector'
+    autoload :ConditionCorrector, 'rubocop/cop/correctors/condition_corrector'
+    autoload :EachToForCorrector, 'rubocop/cop/correctors/each_to_for_corrector'
+    autoload :EmptyLineCorrector, 'rubocop/cop/correctors/empty_line_corrector'
+    autoload :ForToEachCorrector, 'rubocop/cop/correctors/for_to_each_corrector'
+    autoload :IfThenCorrector, 'rubocop/cop/correctors/if_then_corrector'
+    autoload :LambdaLiteralToMethodCorrector, 'rubocop/cop/correctors/lambda_literal_to_method_corrector'
+    autoload :LineBreakCorrector, 'rubocop/cop/correctors/line_break_corrector'
+    autoload :MultilineLiteralBraceCorrector, 'rubocop/cop/correctors/multiline_literal_brace_corrector'
+    autoload :OrderedGemCorrector, 'rubocop/cop/correctors/ordered_gem_corrector'
+    autoload :ParenthesesCorrector, 'rubocop/cop/correctors/parentheses_corrector'
+    autoload :PercentLiteralCorrector, 'rubocop/cop/correctors/percent_literal_corrector'
+    autoload :PunctuationCorrector, 'rubocop/cop/correctors/punctuation_corrector'
+    autoload :RequireLibraryCorrector, 'rubocop/cop/correctors/require_library_corrector'
+    autoload :SpaceCorrector, 'rubocop/cop/correctors/space_corrector'
+    autoload :StringLiteralCorrector, 'rubocop/cop/correctors/string_literal_corrector'
+    autoload :UnusedArgCorrector, 'rubocop/cop/correctors/unused_arg_corrector'
+    # rubocop:enable Layout/LineLength
+  end
+end

data/lib/rubocop/cop/documentation.rb

@@ -16,24 +16,50 @@ module RuboCop
         base = department_to_basename(cop_class.department)
         fragment = cop_class.cop_name.downcase.gsub(/[^a-z]/, '')
         base_url = base_url_for(cop_class, config)
+        extension = extension_for(cop_class, config)
 
-        "#{base_url}/#{base}.html##{fragment}"
+        "#{base_url}/#{base}#{extension}##{fragment}" if base_url
       end
 
       # @api private
       def base_url_for(cop_class, config)
-        return default_base_url unless config
+        if config
+          department_name = cop_class.department.to_s
+          url = config.for_department(department_name)['DocumentationBaseURL']
+          return url if url
+        end
 
-        department_name = cop_class.department.to_s
+        default_base_url if builtin?(cop_class)
+      end
+
+      # @api private
+      def extension_for(cop_class, config)
+        if config
+          department_name = cop_class.department
+          extension = config.for_department(department_name)['DocumentationExtension']
+          return extension if extension
+        end
 
-        config.for_department(department_name)['DocumentationBaseURL'] ||
-          config.for_all_cops['DocumentationBaseURL']
+        default_extension
       end
 
       # @api private
       def default_base_url
         'https://docs.rubocop.org/rubocop'
       end
+
+      # @api private
+      def default_extension
+        '.html'
+      end
+
+      # @api private
+      def builtin?(cop_class)
+        return false unless (name = cop_class.name)
+
+        path, _line = Module.const_source_location(name)
+        path.start_with?(__dir__)
+      end
     end
   end
 end

data/lib/rubocop/cop/exclude_limit.rb

@@ -4,16 +4,42 @@ module RuboCop
   # Allows specified configuration options to have an exclude limit
   # ie. a maximum value tracked that it can be used by `--auto-gen-config`.
   module ExcludeLimit
+    class << self
+      attr_accessor :tmp_dir
+
+      # Reads the aggregated exclude limit values for a cop from tmp files.
+      # Returns a hash like { 'Max' => 81 } or an empty hash if no values were written.
+      def read_limits(cop_name)
+        cop_dir = cop_dir_for(cop_name)
+        return {} unless cop_dir&.directory?
+
+        limits = {}
+        cop_dir.children.each do |filepath|
+          next unless filepath.file?
+
+          values = filepath.readlines.map(&:to_i)
+          limits[filepath.basename.to_s] = values.max unless values.empty?
+        end
+        limits
+      end
+
+      # Returns the tmp directory path for a given cop, or nil if tmp_dir is not set.
+      def cop_dir_for(cop_name)
+        tmp_dir&.join(cop_name.tr('/', '-'))
+      end
+    end
+
     # Sets up a configuration option to have an exclude limit tracked.
     # The parameter name given is transformed into a method name (eg. `Max`
     # becomes `self.max=` and `MinDigits` becomes `self.min_digits=`).
     def exclude_limit(parameter_name, method_name: transform(parameter_name))
-      define_method("#{method_name}=") do |value|
-        cfg = config_to_allow_offenses
-        cfg[:exclude_limit] ||= {}
-        current_max = cfg[:exclude_limit][parameter_name]
-        value = [current_max, value].max if current_max
-        cfg[:exclude_limit][parameter_name] = value
+      define_method(:"#{method_name}=") do |value|
+        cop_dir = RuboCop::ExcludeLimit.cop_dir_for(self.class.badge.to_s)
+        return unless cop_dir
+
+        cop_dir.mkpath
+        filepath = cop_dir.join(parameter_name)
+        filepath.write("#{value}\n", mode: 'a')
       end
     end
 

data/lib/rubocop/cop/force.rb

@@ -4,6 +4,16 @@ module RuboCop
   module Cop
     # A scaffold for concrete forces.
     class Force
+      # @api private
+      class HookError < StandardError
+        attr_reader :joining_cop
+
+        def initialize(joining_cop)
+          super
+          @joining_cop = joining_cop
+        end
+      end
+
       attr_reader :cops
 
       def self.all
@@ -32,6 +42,8 @@ module RuboCop
           next unless cop.respond_to?(method_name)
 
           cop.public_send(method_name, *args)
+        rescue StandardError
+          raise HookError, cop
         end
       end
 

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gemspec
+      # Prefer `add_dependency` over `add_runtime_dependency` as the latter is
+      # considered soft-deprecated.
+      #
+      # @example
+      #
+      #   # bad
+      #   Gem::Specification.new do |spec|
+      #     spec.add_runtime_dependency('rubocop')
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.add_dependency('rubocop')
+      #   end
+      #
+      class AddRuntimeDependency < Base
+        extend AutoCorrector
+
+        MSG = 'Use `add_dependency` instead of `add_runtime_dependency`.'
+
+        RESTRICT_ON_SEND = %i[add_runtime_dependency].freeze
+
+        def on_send(node)
+          return if !node.receiver || node.arguments.empty?
+
+          add_offense(node.loc.selector) do |corrector|
+            corrector.replace(node.loc.selector, 'add_dependency')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gemspec
+      # Use consistent style for Gemspec attributes assignment.
+      #
+      # @example
+      #
+      #   # bad
+      #   # This example uses two styles for assignment of metadata attribute.
+      #   Gem::Specification.new do |spec|
+      #     spec.metadata = { 'key' => 'value' }
+      #     spec.metadata['another-key'] = 'another-value'
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.metadata['key'] = 'value'
+      #     spec.metadata['another-key'] = 'another-value'
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.metadata = { 'key' => 'value', 'another-key' => 'another-value' }
+      #   end
+      #
+      #   # bad
+      #   # This example uses two styles for assignment of authors attribute.
+      #   Gem::Specification.new do |spec|
+      #     spec.authors = %w[author-0 author-1]
+      #     spec.authors[2] = 'author-2'
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.authors = %w[author-0 author-1 author-2]
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.authors[0] = 'author-0'
+      #     spec.authors[1] = 'author-1'
+      #     spec.authors[2] = 'author-2'
+      #   end
+      #
+      #   # good
+      #   # This example uses consistent assignment per attribute,
+      #   # even though two different styles are used overall.
+      #   Gem::Specification.new do |spec|
+      #     spec.metadata = { 'key' => 'value' }
+      #     spec.authors[0] = 'author-0'
+      #     spec.authors[1] = 'author-1'
+      #     spec.authors[2] = 'author-2'
+      #   end
+      #
+      class AttributeAssignment < Base
+        include GemspecHelp
+
+        MSG = 'Use consistent style for Gemspec attributes assignment.'
+
+        def on_new_investigation
+          return if processed_source.blank?
+
+          assignments = source_assignments(processed_source.ast)
+          indexed_assignments = source_indexed_assignments(processed_source.ast)
+
+          assignments.keys.intersection(indexed_assignments.keys).each do |attribute|
+            indexed_assignments[attribute].each do |node|
+              add_offense(node)
+            end
+          end
+        end
+
+        private
+
+        def source_assignments(ast)
+          assignment_method_declarations(ast)
+            .select(&:assignment_method?)
+            .group_by(&:method_name)
+            .transform_keys { |method_name| method_name.to_s.delete_suffix('=').to_sym }
+        end
+
+        def source_indexed_assignments(ast)
+          indexed_assignment_method_declarations(ast)
+            .group_by { |node| node.children.first.method_name }
+        end
+      end
+    end
+  end
+end

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

@@ -101,13 +101,11 @@ module RuboCop
           Array(cop_config['AllowedGems'])
         end
 
-        def message(range)
-          gem_specification = range.source
-
+        def message(_range)
           if required_style?
-            format(REQUIRED_MSG, gem_specification: gem_specification)
+            REQUIRED_MSG
           elsif forbidden_style?
-            format(FORBIDDEN_MSG, gem_specification: gem_specification)
+            FORBIDDEN_MSG
           end
         end
 

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

@@ -43,7 +43,7 @@ module RuboCop
         def on_block(block_node)
           return unless gem_specification(block_node)
 
-          block_parameter = block_node.arguments.first.source
+          block_parameter = block_node.first_argument.source
 
           assignment = block_node.descendants.detect do |node|
             use_deprecated_attributes?(node, block_parameter)
@@ -62,10 +62,9 @@ module RuboCop
 
         def node_and_method_name(node, attribute)
           if node.op_asgn_type?
-            lhs, _op, _rhs = *node
-            [lhs, attribute]
+            [node.lhs, attribute]
           else
-            [node, "#{attribute}=".to_sym]
+            [node, :"#{attribute}="]
           end
         end
 

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

@@ -95,7 +95,7 @@ module RuboCop
         private
 
         def forbidden_gem?(gem_name)
-          !cop_config['AllowedGems'].include?(gem_name)
+          !Array(cop_config['AllowedGems']).include?(gem_name)
         end
 
         def message(_range)

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

@@ -3,13 +3,14 @@
 module RuboCop
   module Cop
     module Gemspec
-      # An attribute assignment method calls should be listed only once
+      # An attribute assignment method call should be listed only once
       # in a gemspec.
       #
-      # Assigning to an attribute with the same name using `spec.foo =` will be
-      # an unintended usage. On the other hand, duplication of methods such
-      # as `spec.requirements`, `spec.add_runtime_dependency`, and others are
-      # permitted because it is the intended use of appending values.
+      # Assigning to an attribute with the same name using `spec.foo =` or
+      # `spec.attribute#[]=` will be an unintended usage. On the other hand,
+      # duplication of methods such as `spec.requirements`,
+      # `spec.add_runtime_dependency`, and others are permitted because it is
+      # the intended use of appending values.
       #
       # @example
       #   # bad
@@ -31,9 +32,21 @@ module RuboCop
       #
       #   # good
       #   Gem::Specification.new do |spec|
-      #     spec.add_runtime_dependency('parallel', '~> 1.10')
-      #     spec.add_runtime_dependency('parser', '>= 2.3.3.1', '< 3.0')
+      #     spec.add_dependency('parallel', '~> 1.10')
+      #     spec.add_dependency('parser', '>= 2.3.3.1', '< 3.0')
       #   end
+      #
+      #   # bad
+      #   Gem::Specification.new do |spec|
+      #     spec.metadata["key"] = "value"
+      #     spec.metadata["key"] = "value"
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.metadata["key"] = "value"
+      #   end
+      #
       class DuplicatedAssignment < Base
         include RangeHelp
         include GemspecHelp
@@ -41,15 +54,16 @@ module RuboCop
         MSG = '`%<assignment>s` method calls already given on line ' \
               '%<line_of_first_occurrence>d of the gemspec.'
 
-        # @!method assignment_method_declarations(node)
-        def_node_search :assignment_method_declarations, <<~PATTERN
-          (send
-            (lvar #match_block_variable_name?) _ ...)
-        PATTERN
-
         def on_new_investigation
           return if processed_source.blank?
 
+          process_assignment_method_nodes
+          process_indexed_assignment_method_nodes
+        end
+
+        private
+
+        def process_assignment_method_nodes
           duplicated_assignment_method_nodes.each do |nodes|
             nodes[1..].each do |node|
               register_offense(node, node.method_name, nodes.first.first_line)
@@ -57,22 +71,40 @@ module RuboCop
           end
         end
 
-        private
-
-        def match_block_variable_name?(receiver_name)
-          gem_specification(processed_source.ast) do |block_variable_name|
-            return block_variable_name == receiver_name
+        def process_indexed_assignment_method_nodes
+          duplicated_indexed_assignment_method_nodes.each do |nodes|
+            nodes[1..].each do |node|
+              assignment = "#{node.children.first.method_name}[#{node.first_argument.source}]="
+              register_offense(node, assignment, nodes.first.first_line)
+            end
           end
         end
 
         def duplicated_assignment_method_nodes
           assignment_method_declarations(processed_source.ast)
             .select(&:assignment_method?)
-            .group_by(&:method_name)
+            .group_by { |node| [enclosing_specification(node), node.method_name] }
             .values
             .select { |nodes| nodes.size > 1 }
         end
 
+        def duplicated_indexed_assignment_method_nodes
+          indexed_assignment_method_declarations(processed_source.ast)
+            .group_by { |node| indexed_assignment_key(node) }
+            .values
+            .select { |nodes| nodes.size > 1 }
+        end
+
+        def indexed_assignment_key(node)
+          [enclosing_specification(node), node.children.first.method_name, node.first_argument]
+        end
+
+        # Assignments in separate `Gem::Specification.new` blocks are not duplicates of
+        # one another, so the enclosing specification is part of the grouping key.
+        def enclosing_specification(node)
+          node.each_ancestor(:block).find { |block| gem_specification?(block) }
+        end
+
         def register_offense(node, assignment, line_of_first_occurrence)
           line_range = node.loc.column...node.loc.last_column
           offense_location = source_range(processed_source.buffer, node.first_line, line_range)

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

@@ -45,7 +45,15 @@ module RuboCop
       #
       #   spec.add_runtime_dependency 'rspec'
       #
-      #   # good only if TreatCommentsAsGroupSeparators is true
+      # @example TreatCommentsAsGroupSeparators: true (default)
+      #   # good
+      #   # For code quality
+      #   spec.add_dependency 'rubocop'
+      #   # For tests
+      #   spec.add_dependency 'rspec'
+      #
+      # @example TreatCommentsAsGroupSeparators: false
+      #   # bad
       #   # For code quality
       #   spec.add_dependency 'rubocop'
       #   # For tests
@@ -61,9 +69,8 @@ module RuboCop
         def on_new_investigation
           return if processed_source.blank?
 
-          dependency_declarations(processed_source.ast)
-            .each_cons(2) do |previous, current|
-            next unless consecutive_lines(previous, current)
+          dependency_declarations(processed_source.ast).each_cons(2) do |previous, current|
+            next unless consecutive_lines?(previous, current)
             next unless case_insensitive_out_of_order?(gem_name(current), gem_name(previous))
             next unless get_dependency_name(previous) == get_dependency_name(current)
 

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

@@ -6,7 +6,7 @@ module RuboCop
       # Requires a gemspec to have `rubygems_mfa_required` metadata set.
       #
       # This setting tells RubyGems that MFA (Multi-Factor Authentication) is
-      # required for accounts to be able perform privileged operations, such as
+      # required for accounts to be able to perform privileged operations, such as
       # (see RubyGems' documentation for the full list of privileged
       # operations):
       #
@@ -70,13 +70,21 @@ module RuboCop
         def_node_matcher :metadata, <<~PATTERN
           `{
             (send _ :metadata= $_)
-            (send (send _ :metadata) :[]= (str "rubygems_mfa_required") $_)
+            (send (send _ :metadata) :[]= {(str "rubygems_mfa_required") (sym :rubygems_mfa_required)} $_)
+          }
+        PATTERN
+
+        # @!method metadata_assignment(node)
+        def_node_search :metadata_assignment, <<~PATTERN
+          `{
+            (send _ :metadata= _)
+            (send (send _ :metadata) :[]= {str sym} _)
           }
         PATTERN
 
         # @!method rubygems_mfa_required(node)
         def_node_search :rubygems_mfa_required, <<~PATTERN
-          (pair (str "rubygems_mfa_required") $_)
+          (pair {(str "rubygems_mfa_required") (sym :rubygems_mfa_required)} $_)
         PATTERN
 
         # @!method true_string?(node)
@@ -84,7 +92,7 @@ module RuboCop
           (str "true")
         PATTERN
 
-        def on_block(node) # rubocop:disable Metrics/MethodLength, InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable Metrics/MethodLength, InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
           gem_specification(node) do |block_var|
             metadata_value = metadata(node)
             mfa_value = mfa_value(metadata_value)
@@ -131,9 +139,18 @@ module RuboCop
         end
 
         def insert_mfa_required(corrector, node, block_var)
-          corrector.insert_before(node.loc.end, <<~RUBY)
+          require_mfa_directive = <<~RUBY.strip
             #{block_var}.metadata['rubygems_mfa_required'] = 'true'
           RUBY
+
+          # Scope the search to the current spec block. Searching the whole file
+          # would, for a second `Gem::Specification.new` block, insert the directive
+          # into the first block, leaving this block uncorrected and looping forever.
+          if (last_assignment = metadata_assignment(node).to_a.last)
+            corrector.insert_after(last_assignment, "\n#{require_mfa_directive}")
+          else
+            corrector.insert_before(node.loc.end, "#{require_mfa_directive}\n")
+          end
         end
 
         def change_value(corrector, value)

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

@@ -53,8 +53,6 @@ module RuboCop
       #     spec.required_ruby_version = '~> 2.5'
       #   end
       class RequiredRubyVersion < Base
-        include RangeHelp
-
         RESTRICT_ON_SEND = %i[required_ruby_version=].freeze
         NOT_EQUAL_MSG = '`required_ruby_version` and `TargetRubyVersion` ' \
                         '(%<target_ruby_version>s, which may be specified in ' \
@@ -76,7 +74,9 @@ module RuboCop
         PATTERN
 
         def on_new_investigation
-          add_global_offense(MISSING_MSG) unless required_ruby_version?(processed_source.ast)
+          return if processed_source.ast && required_ruby_version?(processed_source.ast)
+
+          add_global_offense(MISSING_MSG)
         end
 
         def on_send(node)
@@ -110,6 +110,8 @@ module RuboCop
             end
           end
 
+          return unless required_ruby_version
+
           required_ruby_version.str_content.scan(/\d/).first(2).join('.')
         end