rubocop 1.71.1 → 1.92.0

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

@@ -29,6 +29,10 @@ module RuboCop
         insert_arguments(corrector)
       end
 
+      def replace_delimiters?
+        !block_node.braces? && arg_to_unparenthesized_call?
+      end
+
       private
 
       attr_reader :block_node, :method, :arguments
@@ -77,7 +81,7 @@ module RuboCop
       end
 
       def replace_delimiters(corrector)
-        return if block_node.braces? || !arg_to_unparenthesized_call?
+        return unless replace_delimiters?
 
         corrector.insert_after(block_begin, ' ') unless separating_space?
 
@@ -86,7 +90,13 @@ module RuboCop
       end
 
       def lambda_arg_string
-        arguments.children.map(&:source).join(', ')
+        # Block-local (shadow) arguments are separated from regular arguments by a
+        # `;`; joining everything with `,` would turn them into extra parameters
+        # and change the lambda's arity.
+        regular, shadow = arguments.children.partition { |arg| !arg.shadowarg_type? }
+        arg_string = regular.map { |arg| argument_source(arg) }.join(', ')
+        arg_string += "; #{shadow.map(&:source).join(', ')}" unless shadow.empty?
+        arg_string
       end
 
       def needs_separating_space?
@@ -134,6 +144,23 @@ module RuboCop
       def separating_space?
         block_begin.source_buffer.source[block_begin.begin_pos + 2].match?(/\s/)
       end
+
+      def argument_source(argument)
+        return argument.source unless argument.type?(:optarg, :kwoptarg)
+        return argument.source unless operator_expression?(argument.default_value)
+
+        default_value = argument.default_value
+        name = argument.source_range.begin.join(default_value.source_range.begin).source
+
+        "#{name}(#{default_value.source})"
+      end
+
+      def operator_expression?(node)
+        return true if node.type?(:range, :if, :and, :or)
+        return false unless node.call_type?
+
+        node.operator_method? && !node.method?(:[])
+      end
     end
   end
 end

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

@@ -59,11 +59,7 @@ module RuboCop
       end
 
       def content_if_comment_present(corrector, node)
-        range = range_with_surrounding_space(
-          children(node).last.source_range,
-          side: :right
-        ).end.resize(1)
-        if range.source == '#'
+        if processed_source.comment_at_line(children(node).last.last_line)
           select_content_to_be_inserted_after_last_element(corrector, node)
         else
           node.loc.end.source

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

@@ -18,7 +18,14 @@ module RuboCop
           current_range = declaration_with_comment(node)
           previous_range = declaration_with_comment(previous_declaration)
 
-          ->(corrector) { corrector.swap(current_range, previous_range) }
+          lambda do |corrector|
+            if current_range.source.end_with?("\n")
+              corrector.swap(current_range, previous_range)
+            else
+              corrector.insert_before(previous_range, "#{current_range.source}\n")
+              corrector.remove(current_range)
+            end
+          end
         end
 
         private

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)
@@ -19,8 +21,77 @@ module RuboCop
           corrector.insert_after(node.loc.end, ' ')
         end
 
+        def heredoc_strands_code_after_close_paren?(node)
+          return false unless heredoc_body_before_close_paren?(node)
+
+          after_paren = text_after_close_paren(node)
+
+          !after_paren.empty? && !after_paren.start_with?('.', '&.', ',')
+        end
+
         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.
+        # When a heredoc body comes before `)`, a chained call has to start on the line
+        # after the terminator instead, since the terminator must stay alone on its line.
+        def remove_close_paren(corrector, node, buffer)
+          if heredoc_above_close_paren_swallows_chain?(node)
+            range = range_with_surrounding_space(range: node.loc.end, buffer: buffer, side: :left)
+
+            corrector.replace(range, "\n")
+          else
+            newlines = !comment_above_close_paren_swallows_chain?(node, buffer)
+            range = range_with_surrounding_space(
+              range: node.loc.end, buffer: buffer, side: :left, newlines: newlines
+            )
+
+            corrector.remove(range)
+          end
+        end
+
+        def heredoc_above_close_paren_swallows_chain?(node)
+          return false unless heredoc_body_before_close_paren?(node)
+
+          text_after_close_paren(node).start_with?('.', '&.')
+        end
+
+        def heredoc_body_before_close_paren?(node)
+          return false unless (last_child = node.children.last)
+
+          close_paren_pos = node.loc.end.begin_pos
+
+          last_child.each_node(:any_str).any? do |str_node|
+            str_node.heredoc? && str_node.loc.heredoc_end.end_pos <= close_paren_pos
+          end
+        end
+
+        def text_after_close_paren(node)
+          close_paren = node.loc.end
+
+          close_paren.source_line[(close_paren.column + 1)..].to_s.lstrip
+        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)
+          trimmed = text_after_close_paren(node)
+
+          !trimmed.empty? && !trimmed.start_with?('#')
+        end
+
         def ternary_condition?(node)
           node.parent&.if_type? && node.parent.ternary?
         end

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

@@ -97,8 +97,8 @@ module RuboCop
         if delimiters.first != delimiters.last
           # With different delimiters (eg. `[]`, `()`), if there are the same
           # number of each, escaping is not necessary
-          delimiter_counts = delimiters.each_with_object({}) do |delimiter, counts|
-            counts[delimiter] = content.count(delimiter)
+          delimiter_counts = delimiters.to_h do |delimiter|
+            [delimiter, content.count(delimiter)]
           end
 
           return content if delimiter_counts[delimiters.first] == delimiter_counts[delimiters.last]

data/lib/rubocop/cop/correctors.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop # rubocop:disable Style/Documentation -- a namespace that only autoloads the correctors below
+    # 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 -- the autoload paths do not wrap
+    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

@@ -14,7 +14,7 @@ module RuboCop
       # @api private
       def url_for(cop_class, config = nil)
         base = department_to_basename(cop_class.department)
-        fragment = cop_class.cop_name.downcase.gsub(/[^a-z]/, '')
+        fragment = cop_class.cop_name.downcase.delete('/')
         base_url = base_url_for(cop_class, config)
         extension = extension_for(cop_class, config)
 
@@ -55,10 +55,9 @@ module RuboCop
 
       # @api private
       def builtin?(cop_class)
-        # any custom method will do
-        return false unless (m = cop_class.instance_methods(false).first)
+        return false unless (name = cop_class.name)
 
-        path, _line = cop_class.instance_method(m).source_location
+        path, _line = Module.const_source_location(name)
         path.start_with?(__dir__)
       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
+        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/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

@@ -109,12 +109,6 @@ module RuboCop
           end
         end
 
-        def match_block_variable_name?(receiver_name)
-          gem_specification(processed_source.ast) do |block_variable_name|
-            return block_variable_name == receiver_name
-          end
-        end
-
         def add_dependency_method?(method_name)
           ADD_DEPENDENCY_METHODS.include?(method_name)
         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
@@ -34,6 +35,18 @@ module RuboCop
       #     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

@@ -69,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)
 
@@ -81,12 +80,6 @@ module RuboCop
 
         private
 
-        def previous_declaration(node)
-          declarations = dependency_declarations(processed_source.ast)
-          node_index = declarations.find_index(node)
-          declarations.to_a[node_index - 1]
-        end
-
         def get_dependency_name(node)
           node.method_name
         end

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 -- the gemspec block is matched by its named block variable
           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/ruby_version_globals_usage.rb

@@ -3,11 +3,11 @@
 module RuboCop
   module Cop
     module Gemspec
-      # Checks that `RUBY_VERSION` constant is not used in gemspec.
-      # Using `RUBY_VERSION` is dangerous because value of the
+      # Checks that `RUBY_VERSION` and `Ruby::VERSION` constants are not used in gemspec.
+      # Using `RUBY_VERSION` and `Ruby::VERSION` is dangerous because the value of the
       # constant is determined by `rake release`.
-      # It's possible to have dependency based on ruby version used
-      # to execute `rake release` and not user's ruby version.
+      # It's possible to have a dependency based on the Ruby version used
+      # to execute `rake release` and not the user's Ruby version.
       #
       # @example
       #
@@ -28,15 +28,20 @@ module RuboCop
       class RubyVersionGlobalsUsage < Base
         include GemspecHelp
 
-        MSG = 'Do not use `RUBY_VERSION` in gemspec file.'
+        MSG = 'Do not use `%<ruby_version>s` in gemspec file.'
 
         # @!method ruby_version?(node)
-        def_node_matcher :ruby_version?, '(const {cbase nil?} :RUBY_VERSION)'
+        def_node_matcher :ruby_version?, <<~PATTERN
+          {
+            (const {cbase nil?} :RUBY_VERSION)
+            (const (const {cbase nil?} :Ruby) :VERSION)
+          }
+        PATTERN
 
         def on_const(node)
           return unless gem_spec_with_ruby_version?(node)
 
-          add_offense(node)
+          add_offense(node, message: format(MSG, ruby_version: node.source))
         end
 
         private

data/lib/rubocop/cop/gemspec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Cops for the `Gemspec` department. The department's cops are registered for lazy loading
+    # and their files are loaded on demand.
+    module Gemspec
+      extend LazyLoader
+
+      register_cop :AddRuntimeDependency, "#{__dir__}/gemspec/add_runtime_dependency"
+      register_cop :AttributeAssignment, "#{__dir__}/gemspec/attribute_assignment"
+      register_cop :DependencyVersion, "#{__dir__}/gemspec/dependency_version"
+      register_cop :DeprecatedAttributeAssignment, "#{__dir__}/gemspec/deprecated_attribute_assignment"
+      register_cop :DevelopmentDependencies, "#{__dir__}/gemspec/development_dependencies"
+      register_cop :DuplicatedAssignment, "#{__dir__}/gemspec/duplicated_assignment"
+      register_cop :OrderedDependencies, "#{__dir__}/gemspec/ordered_dependencies"
+      register_cop :RequireMFA, "#{__dir__}/gemspec/require_mfa"
+      register_cop :RequiredRubyVersion, "#{__dir__}/gemspec/required_ruby_version"
+      register_cop :RubyVersionGlobalsUsage, "#{__dir__}/gemspec/ruby_version_globals_usage"
+    end
+  end
+end