rubocop 1.26.0 → 1.36.0

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gemspec
+      # Checks that deprecated attribute attributes are not set in a gemspec file.
+      # Removing deprecated attributes allows the user to receive smaller packed gems.
+      #
+      # @example
+      #
+      #   # bad
+      #   Gem::Specification.new do |spec|
+      #     spec.name = 'your_cool_gem_name'
+      #     spec.test_files = Dir.glob('test/**/*')
+      #   end
+      #
+      #   # bad
+      #   Gem::Specification.new do |spec|
+      #     spec.name = 'your_cool_gem_name'
+      #     spec.test_files += Dir.glob('test/**/*')
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.name = 'your_cool_gem_name'
+      #   end
+      #
+      class DeprecatedAttributeAssignment < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Do not set `%<attribute>s` in gemspec.'
+
+        # @!method gem_specification(node)
+        def_node_matcher :gem_specification, <<~PATTERN
+          (block
+            (send
+              (const
+                (const {cbase nil?} :Gem) :Specification) :new)
+            ...)
+        PATTERN
+
+        def on_block(block_node)
+          return unless gem_specification(block_node)
+
+          block_parameter = block_node.arguments.first.source
+
+          assignment = block_node.descendants.detect do |node|
+            use_deprecated_attributes?(node, block_parameter)
+          end
+          return unless assignment
+
+          message = format_message_from
+          add_offense(assignment, message: message) do |corrector|
+            range = range_by_whole_lines(assignment.source_range, include_final_newline: true)
+
+            corrector.remove(range)
+          end
+        end
+
+        private
+
+        def node_and_method_name(node, attribute)
+          if node.op_asgn_type?
+            lhs, _op, _rhs = *node
+            [lhs, attribute]
+          else
+            [node, "#{attribute}=".to_sym]
+          end
+        end
+
+        def use_deprecated_attributes?(node, block_parameter)
+          %i[test_files date specification_version rubygems_version].each do |attribute|
+            node, method_name = node_and_method_name(node, attribute)
+            unless node.send_type? && node.receiver&.source == block_parameter &&
+                   node.method?(method_name)
+              next
+            end
+
+            @attribute = attribute.to_s
+            return true
+          end
+          false
+        end
+
+        def format_message_from
+          format(MSG, attribute: @attribute)
+        end
+      end
+    end
+  end
+end

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

@@ -38,25 +38,21 @@ module RuboCop
         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 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
@@ -69,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

@@ -36,29 +36,29 @@ module RuboCop
       #     spec.metadata['rubygems_mfa_required'] = 'true'
       #   end
       #
-      #  # bad
-      #  Gem::Specification.new do |spec|
-      #    spec.metadata = {
-      #      'rubygems_mfa_required' => 'false'
-      #    }
-      #  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
+      #   # 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
+      #   # 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
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.metadata['rubygems_mfa_required'] = 'true'
+      #   end
       #
       class RequireMFA < Base
         include GemspecHelp
@@ -84,7 +84,7 @@ module RuboCop
           (str "true")
         PATTERN
 
-        def on_block(node) # rubocop:disable Metrics/MethodLength
+        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)

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'

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

@@ -62,6 +62,10 @@ 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 ...)
@@ -162,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}"

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

@@ -0,0 +1,96 @@
+# 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
+
+        def on_class(node)
+          return unless (module_node = node.parent)
+
+          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
+
+        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/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

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module InternalAffairs
-      # This cop enforces the use of `same_line?` instead of location line comparison for equality.
+      # Enforces the use of `same_line?` instead of location line comparison for equality.
       #
       # @example
       #   # bad

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks potentially usage of method identifier predicates
+      # defined in rubocop-ast instead of `method_name.end_with?`.
+      #
+      # @example
+      #   # bad
+      #   node.method_name.to_s.end_with?('=')
+      #
+      #   # good
+      #   node.assignment_method?
+      #
+      #   # bad
+      #   node.method_name.to_s.end_with?('?')
+      #
+      #   # good
+      #   node.predicate_method?
+      #
+      #   # bad
+      #   node.method_name.to_s.end_with?('!')
+      #
+      #   # good
+      #   node.bang_method?
+      #
+      class MethodNameEndWith < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use `%<method_name>s` instead of `%<method_suffix>s`.'
+        SUGGEST_METHOD_FOR_SUFFIX = {
+          '=' => 'assignment_method?',
+          '!' => 'bang_method?',
+          '?' => 'predicate_method?'
+        }.freeze
+
+        # @!method method_name_end_with?(node)
+        def_node_matcher :method_name_end_with?, <<~PATTERN
+          {
+            (call
+              (call
+                $(... :method_name) :to_s) :end_with?
+              $(str {"=" "?" "!"}))
+            (call
+              $(... :method_name) :end_with?
+            $(str {"=" "?" "!"}))
+          }
+        PATTERN
+
+        def on_send(node)
+          method_name_end_with?(node) do |method_name_node, end_with_arg|
+            range = range(method_name_node, node)
+            message = format(
+              MSG,
+              method_name: SUGGEST_METHOD_FOR_SUFFIX[end_with_arg.value],
+              method_suffix: range.source
+            )
+
+            add_offense(range, message: message)
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def range(method_name_node, node)
+          range = if method_name_node.call_type?
+                    method_name_node.loc.selector
+                  else
+                    method_name_node.source_range
+                  end
+
+          range_between(range.begin_pos, node.source_range.end_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -99,11 +99,7 @@ module RuboCop
           # If the pattern matcher uses arguments (`%1`, `%2`, etc.), include them in the directive
           arguments = pattern_arguments(node.arguments[1].source)
 
-          range = range_with_surrounding_space(
-            range: node.loc.expression,
-            side: :left,
-            newlines: false
-          )
+          range = range_with_surrounding_space(node.loc.expression, side: :left, newlines: false)
           indentation = range.source.match(/^\s*/)[0]
           directive = "#{indentation}# @!method #{actual_name}(#{arguments.join(', ')})\n"
           directive = "\n#{directive}" if add_newline?(node)

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks for missing `numblock handlers. The blocks with numbered
+      # arguments introduced in Ruby 2.7 are parsed with a node type of
+      # `numblock` instead of block. Cops that define `block` handlers
+      # need to define `numblock` handlers or disable this cope for them.
+      #
+      # @example
+      #
+      #   # bad
+      #   class BlockRelatedCop < Base
+      #     def on_block(node)
+      #     end
+      #   end
+      #
+      #   # good
+      #   class BlockRelatedCop < Base
+      #     def on_block(node)
+      #     end
+      #
+      #     alias on_numblock on_block
+      #   end
+      #
+      #   class BlockRelatedCop < Base
+      #     def on_block(node)
+      #     end
+      #
+      #     alias_method :on_numblock, :on_block
+      #   end
+      #
+      #   class BlockRelatedCop < Base
+      #     def on_block(node)
+      #     end
+      #
+      #     def on_numblock(node)
+      #     end
+      #   end
+      class NumblockHandler < Base
+        MSG = 'Define on_numblock to handle blocks with numbered arguments.'
+
+        def on_def(node)
+          return unless block_handler?(node)
+          return unless node.parent
+
+          add_offense(node) unless numblock_handler?(node.parent)
+        end
+
+        private
+
+        # @!method block_handler?(node)
+        def_node_matcher :block_handler?, <<~PATTERN
+          (def :on_block (args (arg :node)) ...)
+        PATTERN
+
+        # @!method numblock_handler?(node)
+        def_node_matcher :numblock_handler?, <<~PATTERN
+          {
+            `(def :on_numblock (args (arg :node)) ...)
+            `(alias (sym :on_numblock) (sym :on_block))
+            `(send nil? :alias_method (sym :on_numblock) (sym :on_block))
+          }
+        PATTERN
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module InternalAffairs
-      # This cop checks for redundant `subject(:cop) { described_class.new }`.
+      # Checks for redundant `subject(:cop) { described_class.new }`.
       #
       # @example
       #   # bad

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module InternalAffairs
-      # This cop checks that `let` is `RuboCop::Config.new` with no arguments.
+      # Checks that `let` is `RuboCop::Config.new` with no arguments.
       #
       # @example
       #   # bad

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

@@ -43,7 +43,7 @@ module RuboCop
         private
 
         def offending_range(node)
-          with_space = range_with_surrounding_space(range: node.loc.expression)
+          with_space = range_with_surrounding_space(node.loc.expression)
 
           range_with_surrounding_comma(with_space, :left)
         end

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

@@ -56,7 +56,7 @@ module RuboCop
         private
 
         def offending_range(node)
-          with_space = range_with_surrounding_space(range: node.loc.expression)
+          with_space = range_with_surrounding_space(node.loc.expression)
 
           range_with_surrounding_comma(with_space, :left)
         end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Enforces the use of `node.single_line?` instead of
+      # comparing `first_line` and `last_line` for equality.
+      #
+      # @example
+      #   # bad
+      #   node.loc.first_line == node.loc.last_line
+      #
+      #   # bad
+      #   node.loc.last_line == node.loc.first_line
+      #
+      #   # bad
+      #   node.loc.line == node.loc.last_line
+      #
+      #   # bad
+      #   node.loc.last_line == node.loc.line
+      #
+      #   # bad
+      #   node.first_line == node.last_line
+      #
+      #   # good
+      #   node.single_line?
+      #
+      class SingleLineComparison < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<preferred>s`.'
+        RESTRICT_ON_SEND = %i[== !=].freeze
+
+        # @!method single_line_comparison(node)
+        def_node_matcher :single_line_comparison, <<~PATTERN
+          {
+            (send (send $_receiver {:line :first_line}) {:== :!=} (send _receiver :last_line))
+            (send (send $_receiver :last_line) {:== :!=} (send _receiver {:line :first_line}))
+          }
+        PATTERN
+
+        def on_send(node)
+          return unless (receiver = single_line_comparison(node))
+
+          bang = node.method?(:!=) ? '!' : ''
+          preferred = "#{bang}#{extract_receiver(receiver)}.single_line?"
+
+          add_offense(node, message: format(MSG, preferred: preferred)) do |corrector|
+            corrector.replace(node, preferred)
+          end
+        end
+
+        private
+
+        def extract_receiver(node)
+          node = node.receiver if node.send_type? && %i[loc source_range].include?(node.method_name)
+          node.source
+        end
+      end
+    end
+  end
+end