rubocop 0.75.1

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

@@ -0,0 +1,55 @@
+# 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 >= '2.5'
+      #       spec.add_runtime_dependency 'gem_a'
+      #     else
+      #       spec.add_runtime_dependency 'gem_b'
+      #     end
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.add_runtime_dependency 'gem_a'
+      #   end
+      #
+      class RubyVersionGlobalsUsage < Cop
+        MSG = 'Do not use `RUBY_VERSION` in gemspec file.'
+
+        def_node_matcher :ruby_version?, '(const nil? :RUBY_VERSION)'
+
+        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)
+
+          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.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.
+    class Generator
+      # Note: RDoc 5.1.0 or lower has the following issue.
+      # https://github.com/rubocop-hq/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}/, '')
+        # frozen_string_literal: true
+
+        # TODO: when finished, run `rake generate_cops_documentation` to update the docs
+        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.
+              #
+              # @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 < Cop
+                # TODO: Implement the cop in here.
+                #
+                # In many cases, you can use a node matcher for matching node pattern.
+                # See https://github.com/rubocop-hq/rubocop/blob/master/lib/rubocop/node_pattern.rb
+                #
+                # For example
+                MSG = 'Use `#good_method` instead of `#bad_method`.'
+
+                def_node_matcher :bad_method?, <<~PATTERN
+                  (send nil? :bad_method ...)
+                PATTERN
+
+                def on_send(node)
+                  return unless bad_method?(node)
+
+                  add_offense(node)
+                end
+              end
+            end
+          end
+        end
+      RUBY
+
+      SPEC_TEMPLATE = <<~SPEC
+        # frozen_string_literal: true
+
+        RSpec.describe RuboCop::Cop::%<department>s::%<cop_name>s do
+          subject(:cop) { described_class.new(config) }
+
+          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 = <<~MESSAGE
+        [modify] A configuration for the cop is added into %<configuration_file_path>s.
+                 If you want to disable the cop by default, set `Enabled` option to false.
+      MESSAGE
+
+      def initialize(name, github_user, output: $stdout)
+        @badge = Badge.parse(name)
+        @github_user = github_user
+        @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')
+        injector =
+          ConfigurationInjector.new(configuration_file_path: config_file_path,
+                                    badge: badge,
+                                    version_added: bump_minor_version)
+
+        injector.inject do
+          output.puts(format(CONFIGURATION_ADDED_MESSAGE,
+                             configuration_file_path: config_file_path))
+        end
+      end
+
+      def todo
+        <<~TODO
+          Do 3 steps:
+            1. Add an entry to the "New features" section in CHANGELOG.md,
+               e.g. "Add new `#{badge}` cop. ([@#{github_user}][])"
+            2. Modify the description of #{badge} in config/default.yml
+            3. Implement your new cop in the generated file!
+        TODO
+      end
+
+      private
+
+      attr_reader :badge, :github_user, :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) unless File.exist?(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, 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)
+        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')
+          .downcase
+      end
+
+      def bump_minor_version
+        versions = RuboCop::Version::STRING.split('.')
+
+        "#{versions[0]}.#{versions[1].succ}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# 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: true
+            VersionAdded: '%<version_added>s'
+        YAML
+
+        def initialize(configuration_file_path:, badge:, version_added:)
+          @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(find_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)
+          yaml !~ /^[\s#]/
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# 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? do |entry|
+            entry == injectable_require_directive
+          end
+        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_directove)
+          path = require_directove.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.sub('.rb', '')
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/ignored_node.rb

@@ -0,0 +1,38 @@
+# 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|
+          if ignored_loc.expression.begin_pos > node.source_range.begin_pos
+            next false
+          end
+
+          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