rubocop 1.22.0 → 1.45.1

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gemspec
+      # Enforce that development dependencies for a gem are specified in
+      # `Gemfile`, rather than in the `gemspec` using
+      # `add_development_dependency`. Alternatively, using `EnforcedStyle:
+      # gemspec`, enforce that all dependencies are specified in `gemspec`,
+      # rather than in `Gemfile`.
+      #
+      # @example EnforcedStyle: Gemfile (default)
+      #   # Specify runtime dependencies in your gemspec,
+      #   # but all other dependencies in your Gemfile.
+      #
+      #   # bad
+      #   # example.gemspec
+      #   s.add_development_dependency "foo"
+      #
+      #   # good
+      #   # Gemfile
+      #   gem "foo"
+      #
+      #   # good
+      #   # gems.rb
+      #   gem "foo"
+      #
+      #   # good (with AllowedGems: ["bar"])
+      #   # example.gemspec
+      #   s.add_development_dependency "bar"
+      #
+      # @example EnforcedStyle: gems.rb
+      #   # Specify runtime dependencies in your gemspec,
+      #   # but all other dependencies in your Gemfile.
+      #   #
+      #   # Identical to `EnforcedStyle: Gemfile`, but with a different error message.
+      #   # Rely on Bundler/GemFilename to enforce the use of `Gemfile` vs `gems.rb`.
+      #
+      #   # bad
+      #   # example.gemspec
+      #   s.add_development_dependency "foo"
+      #
+      #   # good
+      #   # Gemfile
+      #   gem "foo"
+      #
+      #   # good
+      #   # gems.rb
+      #   gem "foo"
+      #
+      #   # good (with AllowedGems: ["bar"])
+      #   # example.gemspec
+      #   s.add_development_dependency "bar"
+      #
+      # @example EnforcedStyle: gemspec
+      #   # Specify all dependencies in your gemspec.
+      #
+      #   # bad
+      #   # Gemfile
+      #   gem "foo"
+      #
+      #   # good
+      #   # example.gemspec
+      #   s.add_development_dependency "foo"
+      #
+      #   # good (with AllowedGems: ["bar"])
+      #   # Gemfile
+      #   gem "bar"
+      #
+      class DevelopmentDependencies < Base
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Specify development dependencies in %<preferred>s.'
+        RESTRICT_ON_SEND = %i[add_development_dependency gem].freeze
+
+        # @!method add_development_dependency?(node)
+        def_node_matcher :add_development_dependency?, <<~PATTERN
+          (send _ :add_development_dependency (str #forbidden_gem? ...))
+        PATTERN
+
+        # @!method gem?(node)
+        def_node_matcher :gem?, <<~PATTERN
+          (send _ :gem (str #forbidden_gem? ...))
+        PATTERN
+
+        def on_send(node)
+          case style
+          when :Gemfile, :'gems.rb'
+            add_offense(node) if add_development_dependency?(node)
+          when :gemspec
+            add_offense(node) if gem?(node)
+          end
+        end
+
+        private
+
+        def forbidden_gem?(gem_name)
+          !cop_config['AllowedGems'].include?(gem_name)
+        end
+
+        def message(_range)
+          format(MSG, preferred: style)
+        end
+      end
+    end
+  end
+end

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

@@ -36,36 +36,23 @@ module RuboCop
       #   end
       class DuplicatedAssignment < Base
         include RangeHelp
+        include GemspecHelp
 
-        MSG = '`%<assignment>s` method calls already given on line '\
+        MSG = '`%<assignment>s` method calls already given on line ' \
               '%<line_of_first_occurrence>d of the gemspec.'
 
-        # @!method gem_specification(node)
-        def_node_search :gem_specification, <<~PATTERN
-          (block
-            (send
-              (const
-                (const {cbase nil?} :Gem) :Specification) :new)
-            (args
-              (arg $_)) ...)
-        PATTERN
-
         # @!method assignment_method_declarations(node)
         def_node_search :assignment_method_declarations, <<~PATTERN
           (send
-            (lvar #match_block_variable_name?) #assignment_method? ...)
+            (lvar #match_block_variable_name?) _ ...)
         PATTERN
 
         def on_new_investigation
           return if processed_source.blank?
 
           duplicated_assignment_method_nodes.each do |nodes|
-            nodes[1..-1].each do |node|
-              register_offense(
-                node,
-                node.method_name,
-                nodes.first.first_line
-              )
+            nodes[1..].each do |node|
+              register_offense(node, node.method_name, nodes.first.first_line)
             end
           end
         end
@@ -78,12 +65,9 @@ module RuboCop
           end
         end
 
-        def assignment_method?(method_name)
-          method_name.to_s.end_with?('=')
-        end
-
         def duplicated_assignment_method_nodes
           assignment_method_declarations(processed_source.ast)
+            .select(&:assignment_method?)
             .group_by(&:method_name)
             .values
             .select { |nodes| nodes.size > 1 }

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

@@ -55,7 +55,7 @@ module RuboCop
         include OrderedGemNode
 
         MSG = 'Dependencies should be sorted in an alphabetical order within ' \
-              'their section of the gemspec. '\
+              'their section of the gemspec. ' \
               'Dependency `%<previous>s` should appear before `%<current>s`.'
 
         def on_new_investigation

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

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gemspec
+      # 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
+      # (see RubyGems' documentation for the full list of privileged
+      # operations):
+      #
+      # * `gem push`
+      # * `gem yank`
+      # * `gem owner --add/remove`
+      # * adding or removing owners using gem ownership page
+      #
+      # This helps make your gem more secure, as users can be more
+      # confident that gem updates were pushed by maintainers.
+      #
+      # @example
+      #   # bad
+      #   Gem::Specification.new do |spec|
+      #     # no `rubygems_mfa_required` metadata specified
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.metadata = {
+      #       'rubygems_mfa_required' => 'true'
+      #     }
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.metadata['rubygems_mfa_required'] = 'true'
+      #   end
+      #
+      #   # bad
+      #   Gem::Specification.new do |spec|
+      #     spec.metadata = {
+      #       'rubygems_mfa_required' => 'false'
+      #     }
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.metadata = {
+      #       'rubygems_mfa_required' => 'true'
+      #     }
+      #   end
+      #
+      #   # bad
+      #   Gem::Specification.new do |spec|
+      #     spec.metadata['rubygems_mfa_required'] = 'false'
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.metadata['rubygems_mfa_required'] = 'true'
+      #   end
+      #
+      class RequireMFA < Base
+        include GemspecHelp
+        extend AutoCorrector
+
+        MSG = "`metadata['rubygems_mfa_required']` must be set to `'true'`."
+
+        # @!method metadata(node)
+        def_node_matcher :metadata, <<~PATTERN
+          `{
+            (send _ :metadata= $_)
+            (send (send _ :metadata) :[]= (str "rubygems_mfa_required") $_)
+          }
+        PATTERN
+
+        # @!method rubygems_mfa_required(node)
+        def_node_search :rubygems_mfa_required, <<~PATTERN
+          (pair (str "rubygems_mfa_required") $_)
+        PATTERN
+
+        # @!method true_string?(node)
+        def_node_matcher :true_string?, <<~PATTERN
+          (str "true")
+        PATTERN
+
+        def on_block(node) # rubocop:disable Metrics/MethodLength, InternalAffairs/NumblockHandler
+          gem_specification(node) do |block_var|
+            metadata_value = metadata(node)
+            mfa_value = mfa_value(metadata_value)
+
+            if mfa_value
+              unless true_string?(mfa_value)
+                add_offense(mfa_value) do |corrector|
+                  change_value(corrector, mfa_value)
+                end
+              end
+            else
+              add_offense(node) do |corrector|
+                autocorrect(corrector, node, block_var, metadata_value)
+              end
+            end
+          end
+        end
+
+        private
+
+        def mfa_value(metadata_value)
+          return unless metadata_value
+          return metadata_value if metadata_value.str_type?
+
+          rubygems_mfa_required(metadata_value).first
+        end
+
+        def autocorrect(corrector, node, block_var, metadata)
+          if metadata
+            return unless metadata.hash_type?
+
+            correct_metadata(corrector, metadata)
+          else
+            insert_mfa_required(corrector, node, block_var)
+          end
+        end
+
+        def correct_metadata(corrector, metadata)
+          if metadata.pairs.any?
+            corrector.insert_after(metadata.pairs.last, ",\n'rubygems_mfa_required' => 'true'")
+          else
+            corrector.insert_before(metadata.loc.end, "'rubygems_mfa_required' => 'true'")
+          end
+        end
+
+        def insert_mfa_required(corrector, node, block_var)
+          corrector.insert_before(node.loc.end, <<~RUBY)
+            #{block_var}.metadata['rubygems_mfa_required'] = 'true'
+          RUBY
+        end
+
+        def change_value(corrector, value)
+          corrector.replace(value, "'true'")
+        end
+      end
+    end
+  end
+end

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

@@ -3,10 +3,11 @@
 module RuboCop
   module Cop
     module Gemspec
-      # Checks that `required_ruby_version` of gemspec is specified and
-      # equal to `TargetRubyVersion` of .rubocop.yml.
-      # Thereby, RuboCop to perform static analysis working on the version
-      # required by gemspec.
+      # Checks that `required_ruby_version` in a gemspec file is set to a valid
+      # value (non-blank) and matches `TargetRubyVersion` as set in RuboCop's
+      # configuration for the gem.
+      #
+      # This ensures that RuboCop is using the same Ruby version as the gem.
       #
       # @example
       #   # When `TargetRubyVersion` of .rubocop.yml is `2.5`.
@@ -26,6 +27,11 @@ module RuboCop
       #     spec.required_ruby_version = '>= 2.6.0'
       #   end
       #
+      #   # bad
+      #   Gem::Specification.new do |spec|
+      #     spec.required_ruby_version = ''
+      #   end
+      #
       #   # good
       #   Gem::Specification.new do |spec|
       #     spec.required_ruby_version = '>= 2.5.0'
@@ -49,48 +55,56 @@ module RuboCop
       class RequiredRubyVersion < Base
         include RangeHelp
 
-        NOT_EQUAL_MSG = '`required_ruby_version` (%<required_ruby_version>s, ' \
-                        'declared in %<gemspec_filename>s) and `TargetRubyVersion` ' \
+        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 ' \
                         '.rubocop.yml) should be equal.'
         MISSING_MSG = '`required_ruby_version` should be specified.'
 
-        # @!method required_ruby_version(node)
-        def_node_search :required_ruby_version, <<~PATTERN
-          (send _ :required_ruby_version= $_)
+        # @!method required_ruby_version?(node)
+        def_node_search :required_ruby_version?, <<~PATTERN
+          (send _ :required_ruby_version= _)
         PATTERN
 
         # @!method defined_ruby_version(node)
         def_node_matcher :defined_ruby_version, <<~PATTERN
-          {$(str _) $(array (str _) (str _))
-            (send (const (const nil? :Gem) :Requirement) :new $(str _))}
+          {
+            $(str _)
+            $(array (str _) (str _))
+            (send (const (const nil? :Gem) :Requirement) :new $str+)
+          }
         PATTERN
 
-        # rubocop:disable Metrics/AbcSize
         def on_new_investigation
-          version_def = required_ruby_version(processed_source.ast).first
+          add_global_offense(MISSING_MSG) unless required_ruby_version?(processed_source.ast)
+        end
 
-          if version_def
-            ruby_version = extract_ruby_version(defined_ruby_version(version_def))
-            return if !ruby_version || ruby_version == target_ruby_version.to_s
+        def on_send(node)
+          version_def = node.first_argument
+          return if dynamic_version?(version_def)
 
-            add_offense(
-              version_def.loc.expression,
-              message: not_equal_message(ruby_version, target_ruby_version)
-            )
-          else
-            range = source_range(processed_source.buffer, 1, 0)
-            add_offense(range, message: MISSING_MSG)
-          end
+          ruby_version = extract_ruby_version(defined_ruby_version(version_def))
+          return if ruby_version == target_ruby_version.to_s
+
+          add_offense(version_def, message: not_equal_message(ruby_version, target_ruby_version))
         end
-        # rubocop:enable Metrics/AbcSize
 
         private
 
+        def dynamic_version?(node)
+          (node.send_type? && !node.receiver) ||
+            node.variable? ||
+            node.each_descendant(:send, *RuboCop::AST::Node::VARIABLES).any?
+        end
+
         def extract_ruby_version(required_ruby_version)
           return unless required_ruby_version
 
-          if required_ruby_version.array_type?
+          if required_ruby_version.is_a?(Array)
+            required_ruby_version = required_ruby_version.detect do |v|
+              /[>=]/.match?(v.str_content)
+            end
+          elsif required_ruby_version.array_type?
             required_ruby_version = required_ruby_version.children.detect do |v|
               /[>=]/.match?(v.str_content)
             end

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

@@ -13,7 +13,7 @@ module RuboCop
       #
       #   # bad
       #   Gem::Specification.new do |spec|
-      #     if RUBY_VERSION >= '2.5'
+      #     if RUBY_VERSION >= '3.0'
       #       spec.add_runtime_dependency 'gem_a'
       #     else
       #       spec.add_runtime_dependency 'gem_b'
@@ -26,20 +26,13 @@ module RuboCop
       #   end
       #
       class RubyVersionGlobalsUsage < Base
+        include GemspecHelp
+
         MSG = 'Do not use `RUBY_VERSION` in gemspec file.'
 
         # @!method ruby_version?(node)
         def_node_matcher :ruby_version?, '(const {cbase nil?} :RUBY_VERSION)'
 
-        # @!method gem_specification?(node)
-        def_node_search :gem_specification?, <<~PATTERN
-          (block
-            (send
-              (const
-                (const {cbase nil?} :Gem) :Specification) :new)
-            ...)
-        PATTERN
-
         def on_const(node)
           return unless gem_spec_with_ruby_version?(node)
 
@@ -49,7 +42,7 @@ module RuboCop
         private
 
         def gem_spec_with_ruby_version?(node)
-          gem_specification?(processed_source.ast) && ruby_version?(node)
+          gem_specification(processed_source.ast) && ruby_version?(node)
         end
       end
     end

data/lib/rubocop/cop/generator/require_file_injector.rb

@@ -55,8 +55,8 @@ module RuboCop
           end
         end
 
-        def require_path_fragments(require_directove)
-          path = require_directove.match(REQUIRE_PATH)
+        def require_path_fragments(require_directive)
+          path = require_directive.match(REQUIRE_PATH)
 
           path ? path.captures.first.split('/') : []
         end

data/lib/rubocop/cop/generator.rb

@@ -8,13 +8,7 @@ module RuboCop
     # and spec file when given a valid qualified cop name.
     # @api private
     class Generator
-      # NOTE: RDoc 5.1.0 or lower has the following issue.
-      # https://github.com/rubocop/rubocop/issues/7043
-      #
-      # The following `String#gsub` can be replaced with
-      # squiggly heredoc when RuboCop supports Ruby 2.5 or higher
-      # (RDoc 6.0 or higher).
-      SOURCE_TEMPLATE = <<-RUBY.gsub(/^ {8}/, '')
+      SOURCE_TEMPLATE = <<~RUBY
         # frozen_string_literal: true
 
         module RuboCop
@@ -68,6 +62,11 @@ module RuboCop
                 # For example
                 MSG = 'Use `#good_method` instead of `#bad_method`.'
 
+                # TODO: Don't call `on_send` unless the method name is in this list
+                # If you don't need `on_send` in the cop you created, remove it.
+                RESTRICT_ON_SEND = %%i[bad_method].freeze
+
+                # @!method bad_method?(node)
                 def_node_matcher :bad_method?, <<~PATTERN
                   (send nil? :bad_method ...)
                 PATTERN
@@ -150,7 +149,7 @@ module RuboCop
             1. Modify the description of #{badge} in config/default.yml
             2. Implement your new cop in the generated file!
             3. Commit your new cop with a message such as
-               e.g. "Add new `#{badge}` cop."
+               e.g. "Add new `#{badge}` cop"
             4. Run `bundle exec rake changelog:new` to generate a changelog entry
                for your new cop.
         TODO
@@ -167,7 +166,7 @@ module RuboCop
         end
 
         dir = File.dirname(path)
-        FileUtils.mkdir_p(dir) unless File.exist?(dir)
+        FileUtils.mkdir_p(dir)
 
         File.write(path, contents)
         output.puts "[create] #{path}"
@@ -182,7 +181,8 @@ module RuboCop
       end
 
       def generate(template)
-        format(template, department: badge.department, cop_name: badge.cop_name)
+        format(template, department: badge.department.to_s.gsub('/', '::'),
+                         cop_name: badge.cop_name)
       end
 
       def spec_path
@@ -206,11 +206,10 @@ module RuboCop
       end
 
       def snake_case(camel_case_string)
-        return 'rspec' if camel_case_string == 'RSpec'
-
         camel_case_string
-          .gsub(/([^A-Z])([A-Z]+)/, '\1_\2')
-          .gsub(/([A-Z])([A-Z][^A-Z\d]+)/, '\1_\2')
+          .gsub('RSpec', 'Rspec')
+          .gsub(%r{([^A-Z/])([A-Z]+)}, '\1_\2')
+          .gsub(%r{([A-Z])([A-Z][^A-Z\d/]+)}, '\1_\2')
           .downcase
       end
     end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Enforces the cop description to start with a word such as verb.
+      #
+      # @example
+      #   # bad
+      #   # This cop checks ....
+      #   class SomeCop < Base
+      #     ....
+      #   end
+      #
+      #   # good
+      #   # Checks ...
+      #   class SomeCop < Base
+      #     ...
+      #   end
+      #
+      class CopDescription < Base
+        extend AutoCorrector
+
+        MSG = 'Description should be started with %<suggestion>s instead of `This cop ...`.'
+
+        SPECIAL_WORDS = %w[is can could should will would must may].freeze
+        COP_DESC_OFFENSE_REGEX = \
+          /^\s+# This cop (?<special>#{SPECIAL_WORDS.join('|')})?\s*(?<word>.+?) .*/.freeze
+        REPLACEMENT_REGEX = /^\s+# This cop (#{SPECIAL_WORDS.join('|')})?\s*(.+?) /.freeze
+
+        # rubocop:disable Metrics/CyclomaticComplexity
+        def on_class(node)
+          return unless (module_node = node.parent) && node.parent_class
+
+          description_beginning = first_comment_line(module_node)
+          return unless description_beginning
+
+          start_with_subject = description_beginning.match(COP_DESC_OFFENSE_REGEX)
+          return unless start_with_subject
+
+          suggestion = start_with_subject['word']&.capitalize
+          range = range(module_node, description_beginning)
+          suggestion_for_message = suggestion_for_message(suggestion, start_with_subject)
+          message = format(MSG, suggestion: suggestion_for_message)
+
+          add_offense(range, message: message) do |corrector|
+            if suggestion && !start_with_subject['special']
+              replace_with_suggestion(corrector, range, suggestion, description_beginning)
+            end
+          end
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+
+        private
+
+        def replace_with_suggestion(corrector, range, suggestion, description_beginning)
+          replacement = description_beginning.gsub(REPLACEMENT_REGEX, "#{suggestion} ")
+          corrector.replace(range, replacement)
+        end
+
+        def range(node, comment_line)
+          source_buffer = node.loc.expression.source_buffer
+
+          begin_pos = node.loc.expression.begin_pos
+          begin_pos += comment_index(node, comment_line)
+          end_pos = begin_pos + comment_body(comment_line).length
+
+          Parser::Source::Range.new(source_buffer, begin_pos, end_pos)
+        end
+
+        def suggestion_for_message(suggestion, match_data)
+          if suggestion && !match_data['special']
+            "`#{suggestion}`"
+          else
+            'a word such as verb'
+          end
+        end
+
+        def first_comment_line(node)
+          node.loc.expression.source.lines.find { |line| comment_line?(line) }
+        end
+
+        def comment_body(comment_line)
+          comment_line.gsub(/^\s*# /, '')
+        end
+
+        def comment_index(node, comment_line)
+          body = comment_body(comment_line)
+          node.loc.expression.source.index(body)
+        end
+
+        def relevant_file?(file)
+          file.match?(%r{/cop/.*\.rb\z})
+        end
+      end
+    end
+  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/empty_line_between_expect_offense_and_correction.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module InternalAffairs
-      # This cop checks whether `expect_offense` and correction expectation methods
+      # Checks whether `expect_offense` and correction expectation methods
       # (i.e. `expect_correction` and `expect_no_corrections`) are separated by empty line.
       #
       # @example