rubocop 0.78.0

data/lib/rubocop/cop/force.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # A scaffold for concrete forces.
+    class Force
+      attr_reader :cops
+
+      def self.all
+        @all ||= []
+      end
+
+      def self.inherited(subclass)
+        all << subclass
+      end
+
+      def self.force_name
+        name.split('::').last
+      end
+
+      def initialize(cops)
+        @cops = cops
+      end
+
+      def name
+        self.class.force_name
+      end
+
+      def run_hook(method_name, *args)
+        cops.each do |cop|
+          next unless cop.respond_to?(method_name)
+
+          cop.send(method_name, *args)
+        end
+      end
+
+      def investigate(_processed_source)
+        # Do custom processing and invoke #run_hook at arbitrary timing.
+      end
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gemspec
+      # An attribute assignment method calls 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.
+      #
+      # @example
+      #   # bad
+      #   Gem::Specification.new do |spec|
+      #     spec.name = 'rubocop'
+      #     spec.name = 'rubocop2'
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.name = 'rubocop'
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.requirements << 'libmagick, v6.0'
+      #     spec.requirements << 'A good graphics card'
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.add_runtime_dependency('parallel', '~> 1.10')
+      #     spec.add_runtime_dependency('parser', '>= 2.3.3.1', '< 3.0')
+      #   end
+      class DuplicatedAssignment < Cop
+        include RangeHelp
+
+        MSG = '`%<assignment>s` method calls already given on line '\
+              '%<line_of_first_occurrence>d of the gemspec.'
+
+        def_node_search :gem_specification, <<~PATTERN
+          (block
+            (send
+              (const
+                (const {cbase nil?} :Gem) :Specification) :new)
+            (args
+              (arg $_)) ...)
+        PATTERN
+
+        def_node_search :assignment_method_declarations, <<~PATTERN
+          (send
+            (lvar #match_block_variable_name?) #assignment_method? ...)
+        PATTERN
+
+        def investigate(processed_source)
+          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
+              )
+            end
+          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
+          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)
+            .group_by(&:method_name)
+            .values
+            .select { |nodes| nodes.size > 1 }
+        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)
+          message = format(
+            MSG,
+            assignment: assignment,
+            line_of_first_occurrence: line_of_first_occurrence
+          )
+          add_offense(node, location: offense_location, message: message)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gemspec
+      # Dependencies in the gemspec should be alphabetically sorted.
+      #
+      # @example
+      #   # bad
+      #   spec.add_dependency 'rubocop'
+      #   spec.add_dependency 'rspec'
+      #
+      #   # good
+      #   spec.add_dependency 'rspec'
+      #   spec.add_dependency 'rubocop'
+      #
+      #   # good
+      #   spec.add_dependency 'rubocop'
+      #
+      #   spec.add_dependency 'rspec'
+      #
+      #   # bad
+      #   spec.add_development_dependency 'rubocop'
+      #   spec.add_development_dependency 'rspec'
+      #
+      #   # good
+      #   spec.add_development_dependency 'rspec'
+      #   spec.add_development_dependency 'rubocop'
+      #
+      #   # good
+      #   spec.add_development_dependency 'rubocop'
+      #
+      #   spec.add_development_dependency 'rspec'
+      #
+      #   # bad
+      #   spec.add_runtime_dependency 'rubocop'
+      #   spec.add_runtime_dependency 'rspec'
+      #
+      #   # good
+      #   spec.add_runtime_dependency 'rspec'
+      #   spec.add_runtime_dependency 'rubocop'
+      #
+      #   # good
+      #   spec.add_runtime_dependency 'rubocop'
+      #
+      #   spec.add_runtime_dependency 'rspec'
+      #
+      #   # good only if TreatCommentsAsGroupSeparators is true
+      #   # For code quality
+      #   spec.add_dependency 'rubocop'
+      #   # For tests
+      #   spec.add_dependency 'rspec'
+      class OrderedDependencies < Cop
+        include ConfigurableEnforcedStyle
+        include OrderedGemNode
+
+        MSG = 'Dependencies should be sorted in an alphabetical order within ' \
+              'their section of the gemspec. '\
+              'Dependency `%<previous>s` should appear before `%<current>s`.'
+
+        def investigate(processed_source)
+          return if processed_source.blank?
+
+          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)
+            )
+            unless get_dependency_name(previous) == get_dependency_name(current)
+              next
+            end
+
+            register_offense(previous, current)
+          end
+        end
+
+        def autocorrect(node)
+          OrderedGemCorrector.correct(
+            processed_source,
+            node,
+            previous_declaration(node),
+            treat_comments_as_separators
+          )
+        end
+
+        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
+
+        def_node_search :dependency_declarations, <<~PATTERN
+          (send (lvar _) {:add_dependency :add_runtime_dependency :add_development_dependency} ...)
+        PATTERN
+      end
+    end
+  end
+end

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|
+              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 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