rubocop 0.51.0 → 0.87.0

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gemspec
+      # Checks that `required_ruby_version` of gemspec and `TargetRubyVersion`
+      # of .rubocop.yml are equal.
+      # Thereby, RuboCop to perform static analysis working on the version
+      # required by gemspec.
+      #
+      # @example
+      #   # When `TargetRubyVersion` of .rubocop.yml is `2.5`.
+      #
+      #   # bad
+      #   Gem::Specification.new do |spec|
+      #     spec.required_ruby_version = '>= 2.4.0'
+      #   end
+      #
+      #   # bad
+      #   Gem::Specification.new do |spec|
+      #     spec.required_ruby_version = '>= 2.6.0'
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.required_ruby_version = '>= 2.5.0'
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.required_ruby_version = '>= 2.5'
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.required_ruby_version = ['>= 2.5.0', '< 2.7.0']
+      #   end
+      class RequiredRubyVersion < Cop
+        MSG = '`required_ruby_version` (%<required_ruby_version>s, ' \
+              'declared in %<gemspec_filename>s) and `TargetRubyVersion` ' \
+              '(%<target_ruby_version>s, which may be specified in ' \
+              '.rubocop.yml) should be equal.'
+
+        def_node_search :required_ruby_version, <<~PATTERN
+          (send _ :required_ruby_version= ${(str _) (array (str _))})
+        PATTERN
+
+        def investigate(processed_source)
+          required_ruby_version(processed_source.ast) do |version|
+            ruby_version = extract_ruby_version(version)
+
+            return if ruby_version == target_ruby_version.to_s
+
+            add_offense(
+              processed_source.ast,
+              location: version.loc.expression,
+              message: message(ruby_version, target_ruby_version)
+            )
+          end
+        end
+
+        private
+
+        def extract_ruby_version(required_ruby_version)
+          if required_ruby_version.array_type?
+            required_ruby_version = required_ruby_version.children.detect do |v|
+              /[>=]/.match?(v.str_content)
+            end
+          end
+
+          required_ruby_version.str_content.match(/(\d\.\d)/)[1]
+        end
+
+        def message(required_ruby_version, target_ruby_version)
+          format(
+            MSG,
+            required_ruby_version: required_ruby_version,
+            gemspec_filename: File.basename(processed_source.file_path),
+            target_ruby_version: target_ruby_version
+          )
+        end
+      end
+    end
+  end
+end

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 {cbase 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/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: pending
+            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(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,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/generator.rb

@@ -7,42 +7,69 @@ module RuboCop
     # This generator will take a cop name and generate a source file
     # and spec file when given a valid qualified cop name.
     class Generator
-      SOURCE_TEMPLATE = <<-RUBY.strip_indent
+      # 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.
+              # 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.
               #
-              # @example
               #   # bad
-              #   bad_method()
+              #   bad_bar_method
               #
               #   # bad
-              #   bad_method(args)
+              #   bad_bar_method(args)
               #
               #   # good
-              #   good_method()
+              #   good_bar_method
               #
               #   # good
-              #   good_method(args)
-              class %<cop_name>s < Cop
-                # TODO: Implement the cop into here.
+              #   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/bbatsov/rubocop/blob/master/lib/rubocop/node_pattern.rb
+                # See https://github.com/rubocop-hq/rubocop-ast/blob/master/lib/rubocop/node_pattern.rb
                 #
                 # For example
-                MSG = 'Message of %<cop_name>s'.freeze
+                MSG = 'Use `#good_method` instead of `#bad_method`.'
 
-                def_node_matcher :bad_method?, <<-PATTERN
-                  (send nil :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
@@ -51,34 +78,40 @@ module RuboCop
         end
       RUBY
 
-      SPEC_TEMPLATE = <<-SPEC.strip_indent
+      SPEC_TEMPLATE = <<~SPEC
         # frozen_string_literal: true
 
-        describe RuboCop::Cop::%<department>s::%<cop_name>s do
-          let(:config) { RuboCop::Config.new }
+        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.strip_indent)
+            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.strip_indent)
+            expect_no_offenses(<<~RUBY)
               good_method
             RUBY
           end
         end
       SPEC
 
-      def initialize(name)
-        @badge = Badge.parse(name)
+      CONFIGURATION_ADDED_MESSAGE =
+        '[modify] A configuration for the cop is added into ' \
+          '%<configuration_file_path>s.'
 
+      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'
@@ -92,29 +125,39 @@ module RuboCop
         write_unless_file_exists(spec_path, generated_spec)
       end
 
-      def inject_require
-        RequireFileInjector.new(require_path).inject
+      def inject_require(root_file_path: 'lib/rubocop.rb')
+        RequireFileInjector.new(
+          source_path: source_path,
+          root_file_path: root_file_path
+        ).inject
       end
 
-      def todo
-        <<-TODO.strip_indent
-          Files created:
-            - #{source_path}
-            - #{spec_path}
-          File modified:
-            - `require_relative '#{require_path}'` added into lib/rubocop.rb
+      def inject_config(config_file_path: 'config/default.yml',
+                        version_added: bump_minor_version)
+        injector =
+          ConfigurationInjector.new(configuration_file_path: config_file_path,
+                                    badge: badge,
+                                    version_added: version_added)
 
+        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. ([@your_id][])"
-            2. Add an entry into config/enabled.yml or config/disabled.yml
+               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
+      attr_reader :badge, :github_user, :output
 
       def write_unless_file_exists(path, contents)
         if File.exist?(path)
@@ -126,6 +169,7 @@ module RuboCop
         FileUtils.mkdir_p(dir) unless File.exist?(dir)
 
         File.write(path, contents)
+        output.puts "[create] #{path}"
       end
 
       def generated_source
@@ -140,10 +184,6 @@ module RuboCop
         format(template, department: badge.department, cop_name: badge.cop_name)
       end
 
-      def require_path
-        source_path.sub('lib/', '').sub('.rb', '')
-      end
-
       def spec_path
         File.join(
           'spec',
@@ -165,76 +205,18 @@ 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')
           .downcase
       end
 
-      # 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 ['"](.+)['"]/
+      def bump_minor_version
+        versions = RuboCop::Version::STRING.split('.')
 
-        def initialize(require_path)
-          @require_path    = require_path
-          @require_entries = File.readlines(rubocop_root_file_path)
-        end
-
-        def inject
-          return if require_exists? || !target_line
-
-          File.write(rubocop_root_file_path, updated_directives)
-        end
-
-        private
-
-        attr_reader :require_path, :require_entries
-
-        def rubocop_root_file_path
-          File.join('lib', 'rubocop.rb')
-        end
-
-        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
-          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
+        "#{versions[0]}.#{versions[1].succ}"
       end
     end
   end

data/lib/rubocop/cop/ignored_node.rb

@@ -10,9 +10,7 @@ module RuboCop
 
       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
+          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

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks that method names are checked using `method?` method.
+      #
+      # @example
+      #   # bad
+      #   node.method_name == :do_something
+      #
+      #   # good
+      #   node.method?(:do_something)
+      #
+      class MethodNameEqual < Cop
+        include RangeHelp
+
+        MSG = 'Use `method?(%<method_name>s)` instead of ' \
+              '`method_name == %<method_name>s`.'
+
+        def_node_matcher :method_name?, <<~PATTERN
+          (send
+            $(send
+              (...) :method_name) :==
+            $...)
+        PATTERN
+
+        def on_send(node)
+          method_name?(node) do |method_name_node, method_name_arg|
+            message = format(MSG, method_name: method_name_arg.first.source)
+
+            range = range(method_name_node, node)
+
+            add_offense(node, location: range, message: message)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            method_name?(node) do |method_name_node, method_name_arg|
+              corrector.replace(
+                range(method_name_node, node),
+                "method?(#{method_name_arg.first.source})"
+              )
+            end
+          end
+        end
+
+        private
+
+        def range(method_name_node, node)
+          range_between(
+            method_name_node.loc.selector.begin_pos, node.source_range.end_pos
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks that node destructuring is using the node extensions.
+      #
+      # @example Using splat expansion
+      #
+      #   # bad
+      #   _receiver, method_name, _arguments = send_node.children
+      #
+      #   # bad
+      #   _receiver, method_name, _arguments = *send_node
+      #
+      #   # good
+      #   method_name = send_node.method_name
+      class NodeDestructuring < Cop
+        MSG = 'Use the methods provided with the node extensions instead ' \
+              'of manually destructuring nodes.'
+
+        def_node_matcher :node_variable?, <<~PATTERN
+          {(lvar [#node_suffix? _]) (send nil? [#node_suffix? _])}
+        PATTERN
+
+        def_node_matcher :node_destructuring?, <<~PATTERN
+          {(masgn (mlhs ...) {(send #node_variable? :children) (array (splat #node_variable?))})}
+        PATTERN
+
+        def on_masgn(node)
+          node_destructuring?(node) do
+            add_offense(node)
+          end
+        end
+
+        private
+
+        def node_suffix?(method_name)
+          method_name.to_s.end_with?('node')
+        end
+      end
+    end
+  end
+end