rubocop-grantbirki 1.75.2

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+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
+      # 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.
+      #
+      # @example
+      #
+      #   # bad
+      #   Gem::Specification.new do |spec|
+      #     if RUBY_VERSION >= '3.0'
+      #       spec.add_dependency 'gem_a'
+      #     else
+      #       spec.add_dependency 'gem_b'
+      #     end
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.add_dependency 'gem_a'
+      #   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)'
+
+        def on_const(node)
+          return unless gem_spec_with_ruby_version?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        def gem_spec_with_ruby_version?(node)
+          gem_specification(processed_source.ast) && ruby_version?(node)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    class Generator
+      # A class that injects a require directive into the root RuboCop file.
+      # It looks for other directives that require files in the same (cop)
+      # namespace and injects the provided one in alpha
+      class ConfigurationInjector
+        TEMPLATE = <<~YAML
+          %<badge>s:
+            Description: 'TODO: Write a description of the cop.'
+            Enabled: pending
+            VersionAdded: '%<version_added>s'
+        YAML
+
+        def initialize(configuration_file_path:, badge:, version_added: '<<next>>')
+          @configuration_file_path = configuration_file_path
+          @badge = badge
+          @version_added = version_added
+          @output = output
+        end
+
+        def inject
+          target_line = find_target_line
+          if target_line
+            configuration_entries.insert(target_line, "#{new_configuration_entry}\n")
+          else
+            configuration_entries.push("\n#{new_configuration_entry}")
+          end
+
+          File.write(configuration_file_path, configuration_entries.join)
+
+          yield if block_given?
+        end
+
+        private
+
+        attr_reader :configuration_file_path, :badge, :version_added, :output
+
+        def configuration_entries
+          @configuration_entries ||= File.readlines(configuration_file_path)
+        end
+
+        def new_configuration_entry
+          format(TEMPLATE, badge: badge, version_added: version_added)
+        end
+
+        def find_target_line
+          configuration_entries.find.with_index do |line, index|
+            next unless cop_name_line?(line)
+
+            return index if badge.to_s < line
+          end
+
+          nil
+        end
+
+        def cop_name_line?(yaml)
+          !/^[\s#]/.match?(yaml)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    class Generator
+      # A class that injects a require directive into the root RuboCop file.
+      # It looks for other directives that require files in the same (cop)
+      # namespace and injects the provided one in alpha
+      class RequireFileInjector
+        REQUIRE_PATH = /require_relative ['"](.+)['"]/.freeze
+
+        def initialize(source_path:, root_file_path:, output: $stdout)
+          @source_path = Pathname(source_path)
+          @root_file_path = Pathname(root_file_path)
+          @require_entries = File.readlines(root_file_path)
+          @output = output
+        end
+
+        def inject
+          return if require_exists? || !target_line
+
+          File.write(root_file_path, updated_directives)
+          require = injectable_require_directive.chomp
+          output.puts "[modify] #{root_file_path} - `#{require}` was injected."
+        end
+
+        private
+
+        attr_reader :require_entries, :root_file_path, :source_path, :output
+
+        def require_exists?
+          require_entries.any?(injectable_require_directive)
+        end
+
+        def updated_directives
+          require_entries.insert(target_line, injectable_require_directive).join
+        end
+
+        def target_line
+          @target_line ||= begin
+            in_the_same_department = false
+            inject_parts = require_path_fragments(injectable_require_directive)
+
+            require_entries.find.with_index do |entry, index|
+              current_entry_parts = require_path_fragments(entry)
+
+              if inject_parts[0..-2] == current_entry_parts[0..-2]
+                in_the_same_department = true
+
+                break index if inject_parts.last < current_entry_parts.last
+              elsif in_the_same_department
+                break index
+              end
+            end || require_entries.size
+          end
+        end
+
+        def require_path_fragments(require_directive)
+          path = require_directive.match(REQUIRE_PATH)
+
+          path ? path.captures.first.split('/') : []
+        end
+
+        def injectable_require_directive
+          "require_relative '#{require_path}'\n"
+        end
+
+        def require_path
+          path = source_path.relative_path_from(root_file_path.dirname)
+          path.to_s.delete_suffix('.rb')
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/generator.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Source and spec generator for new cops
+    #
+    # This generator will take a cop name and generate a source file
+    # and spec file when given a valid qualified cop name.
+    # @api private
+    class Generator
+      SOURCE_TEMPLATE = <<~RUBY
+        # frozen_string_literal: true
+
+        module RuboCop
+          module Cop
+            module %<department>s
+              # TODO: Write cop description and example of bad / good code. For every
+              # `SupportedStyle` and unique configuration, there needs to be examples.
+              # Examples must have valid Ruby syntax. Do not use upticks.
+              #
+              # @safety
+              #   Delete this section if the cop is not unsafe (`Safe: false` or
+              #   `SafeAutoCorrect: false`), or use it to explain how the cop is
+              #   unsafe.
+              #
+              # @example EnforcedStyle: bar (default)
+              #   # Description of the `bar` style.
+              #
+              #   # bad
+              #   bad_bar_method
+              #
+              #   # bad
+              #   bad_bar_method(args)
+              #
+              #   # good
+              #   good_bar_method
+              #
+              #   # good
+              #   good_bar_method(args)
+              #
+              # @example EnforcedStyle: foo
+              #   # Description of the `foo` style.
+              #
+              #   # bad
+              #   bad_foo_method
+              #
+              #   # bad
+              #   bad_foo_method(args)
+              #
+              #   # good
+              #   good_foo_method
+              #
+              #   # good
+              #   good_foo_method(args)
+              #
+              class %<cop_name>s < Base
+                # TODO: Implement the cop in here.
+                #
+                # In many cases, you can use a node matcher for matching node pattern.
+                # See https://github.com/rubocop/rubocop-ast/blob/master/lib/rubocop/ast/node_pattern.rb
+                #
+                # 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
+
+                # Called on every `send` node (method call) while walking the AST.
+                # TODO: remove this method if inspecting `send` nodes is unneeded for your cop.
+                # By default, this is aliased to `on_csend` as well to handle method calls
+                # with safe navigation, remove the alias if this is unnecessary.
+                # If kept, ensure your tests cover safe navigation as well!
+                def on_send(node)
+                  return unless bad_method?(node)
+
+                  add_offense(node)
+                end
+                alias on_csend on_send
+              end
+            end
+          end
+        end
+      RUBY
+
+      SPEC_TEMPLATE = <<~SPEC
+        # frozen_string_literal: true
+
+        RSpec.describe RuboCop::Cop::%<department>s::%<cop_name>s, :config do
+          let(:config) { RuboCop::Config.new }
+
+          # TODO: Write test code
+          #
+          # For example
+          it 'registers an offense when using `#bad_method`' do
+            expect_offense(<<~RUBY)
+              bad_method
+              ^^^^^^^^^^ Use `#good_method` instead of `#bad_method`.
+            RUBY
+          end
+
+          it 'does not register an offense when using `#good_method`' do
+            expect_no_offenses(<<~RUBY)
+              good_method
+            RUBY
+          end
+        end
+      SPEC
+
+      CONFIGURATION_ADDED_MESSAGE =
+        '[modify] A configuration for the cop is added into ' \
+        '%<configuration_file_path>s.'
+
+      def initialize(name, output: $stdout)
+        @badge = Badge.parse(name)
+        @output = output
+        return if badge.qualified?
+
+        raise ArgumentError, 'Specify a cop name with Department/Name style'
+      end
+
+      def write_source
+        write_unless_file_exists(source_path, generated_source)
+      end
+
+      def write_spec
+        write_unless_file_exists(spec_path, generated_spec)
+      end
+
+      def inject_require(root_file_path: 'lib/rubocop.rb')
+        RequireFileInjector.new(source_path: source_path, root_file_path: root_file_path).inject
+      end
+
+      def inject_config(config_file_path: 'config/default.yml',
+                        version_added: '<<next>>')
+        injector =
+          ConfigurationInjector.new(configuration_file_path: config_file_path,
+                                    badge: badge,
+                                    version_added: version_added)
+
+        injector.inject do # rubocop:disable Lint/UnexpectedBlockArity
+          output.puts(format(CONFIGURATION_ADDED_MESSAGE,
+                             configuration_file_path: config_file_path))
+        end
+      end
+
+      def todo
+        <<~TODO
+          Do 4 steps:
+            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"
+            4. Run `bundle exec rake changelog:new` to generate a changelog entry
+               for your new cop.
+        TODO
+      end
+
+      private
+
+      attr_reader :badge, :output
+
+      def write_unless_file_exists(path, contents)
+        if File.exist?(path)
+          warn "rake new_cop: #{path} already exists!"
+          exit!
+        end
+
+        dir = File.dirname(path)
+        FileUtils.mkdir_p(dir)
+
+        File.write(path, contents)
+        output.puts "[create] #{path}"
+      end
+
+      def generated_source
+        generate(SOURCE_TEMPLATE)
+      end
+
+      def generated_spec
+        generate(SPEC_TEMPLATE)
+      end
+
+      def generate(template)
+        format(template, department: badge.department.to_s.gsub('/', '::'),
+                         cop_name: badge.cop_name)
+      end
+
+      def spec_path
+        File.join(
+          'spec',
+          'rubocop',
+          'cop',
+          snake_case(badge.department.to_s),
+          "#{snake_case(badge.cop_name.to_s)}_spec.rb"
+        )
+      end
+
+      def source_path
+        File.join(
+          'lib',
+          'rubocop',
+          'cop',
+          snake_case(badge.department.to_s),
+          "#{snake_case(badge.cop_name.to_s)}.rb"
+        )
+      end
+
+      def snake_case(camel_case_string)
+        camel_case_string
+          .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
+  end
+end

data/lib/rubocop/cop/ignored_node.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Handles adding and checking ignored nodes.
+    module IgnoredNode
+      def ignore_node(node)
+        ignored_nodes << node
+      end
+
+      def part_of_ignored_node?(node)
+        ignored_nodes.map(&:loc).any? do |ignored_loc|
+          next false if ignored_loc.expression.begin_pos > node.source_range.begin_pos
+
+          ignored_end_pos = if ignored_loc.respond_to?(:heredoc_body)
+                              ignored_loc.heredoc_end.end_pos
+                            else
+                              ignored_loc.expression.end_pos
+                            end
+          ignored_end_pos >= node.source_range.end_pos
+        end
+      end
+
+      def ignored_node?(node)
+        # Same object found in array?
+        ignored_nodes.any? { |n| n.equal?(node) }
+      end
+
+      private
+
+      def ignored_nodes
+        @ignored_nodes ||= []
+      end
+    end
+  end
+end

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

@@ -0,0 +1,118 @@
+# 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
+      #
+      #   # bad
+      #   #
+      #   # Checks ...
+      #   class SomeCop < Base
+      #     ...
+      #   end
+      #
+      #   # good
+      #   # Checks ...
+      #   class SomeCop < Base
+      #     ...
+      #   end
+      #
+      class CopDescription < Base
+        extend AutoCorrector
+
+        MSG_STARTS_WITH_WRONG_WORD =
+          'Description should be started with %<suggestion>s instead of `This cop ...`.'
+        MSG_STARTS_WITH_EMPTY_COMMENT_LINE =
+          'Description should not start with an empty comment line.'
+
+        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
+        EMPTY_COMMENT_LINE_REGEX = /\A\s*#\s*\n\z/.freeze
+
+        def on_class(node)
+          return unless (module_node = node.parent) && node.parent_class
+
+          description_beginning = first_comment_line(module_node)
+          return unless description_beginning
+
+          if description_beginning.match?(EMPTY_COMMENT_LINE_REGEX)
+            register_offense_for_empty_comment_line(module_node, description_beginning)
+          else
+            start_with_subject = description_beginning.match(COP_DESC_OFFENSE_REGEX)
+            return unless start_with_subject
+
+            register_offense_for_wrong_word(module_node, description_beginning, start_with_subject)
+          end
+        end
+
+        private
+
+        def register_offense_for_empty_comment_line(module_node, description_beginning)
+          range = range(module_node, description_beginning)
+          add_offense(range, message: MSG_STARTS_WITH_EMPTY_COMMENT_LINE) do |corrector|
+            corrector.remove(range)
+          end
+        end
+
+        def register_offense_for_wrong_word(module_node, description_beginning, 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_STARTS_WITH_WRONG_WORD, 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
+
+        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.source_range.source_buffer
+
+          begin_pos = node.source_range.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.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.source.index(body)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Use `config.cop_enabled?('Department/CopName')` instead of
+      # traversing the config hash.
+      #
+      # @example
+      #   # `for_cop(...)['Enabled']
+      #
+      #   # bad
+      #   config.for_cop('Department/CopName')['Enabled']
+      #
+      #   # good
+      #   config.cop_enabled?('Department/CopName')
+      #
+      # @example
+      #   # when keeping a cop's config in a local and then checking the `Enabled` key
+      #
+      #   # bad
+      #   cop_config = config.for_cop('Department/CopName')
+      #   cop_config['Enabled'] && cop_config['Foo']
+      #
+      #   # good
+      #   config.for_enabled_cop('Department/CopName')['Foo']
+      #
+      class CopEnabled < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<replacement>s` instead of `%<source>s`.'
+        MSG_HASH = 'Consider replacing uses of `%<hash_name>s` with `config.for_enabled_cop`.'
+
+        RESTRICT_ON_SEND = [:[]].freeze
+
+        # @!method for_cop_enabled?(node)
+        def_node_matcher :for_cop_enabled?, <<~PATTERN
+          (send
+            (send
+              ${(send nil? :config) (ivar :@config)} :for_cop
+              $(str _)) :[]
+            (str "Enabled"))
+        PATTERN
+
+        # @!method config_enabled_lookup?(node)
+        def_node_matcher :config_enabled_lookup?, <<~PATTERN
+          (send
+            {(lvar $_) (ivar $_) (send nil? $_)} :[]
+            (str "Enabled"))
+        PATTERN
+
+        def on_send(node)
+          if (config_var, cop_name = for_cop_enabled?(node))
+            handle_for_cop(node, config_var, cop_name)
+          elsif (config_var = config_enabled_lookup?(node))
+            return unless config_var.end_with?('_config')
+
+            handle_hash(node, config_var)
+          end
+        end
+
+        private
+
+        def handle_for_cop(node, config_var, cop_name)
+          source = node.source
+          quote = cop_name.loc.begin.source
+          cop_name = cop_name.value
+
+          replacement = "#{config_var.source}.cop_enabled?(#{quote}#{cop_name}#{quote})"
+          message = format(MSG, source: source, replacement: replacement)
+
+          add_offense(node, message: message) do |corrector|
+            corrector.replace(node, replacement)
+          end
+        end
+
+        def handle_hash(node, config_var)
+          message = format(MSG_HASH, hash_name: config_var)
+
+          add_offense(node, message: message)
+        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