rubocop 1.9.1 → 1.12.0

data/lib/rubocop/cop/bundler/duplicated_gem.rb

@@ -30,7 +30,7 @@ module RuboCop
       #   if Dir.exist?(local)
       #     gem 'rubocop', path: local
       #   elsif ENV['RUBOCOP_VERSION'] == 'master'
-      #     gem 'rubocop', git: 'https://github.com/rubocop-hq/rubocop.git'
+      #     gem 'rubocop', git: 'https://github.com/rubocop/rubocop.git'
       #   else
       #     gem 'rubocop', '~> 0.90.0'
       #   end
@@ -57,6 +57,7 @@ module RuboCop
 
         private
 
+        # @!method gem_declarations(node)
         def_node_search :gem_declarations, '(send nil? :gem str ...)'
 
         def duplicated_gem_nodes

data/lib/rubocop/cop/bundler/gem_comment.rb

@@ -66,6 +66,7 @@ module RuboCop
         VERSION_SPECIFIERS_OPTION = 'version_specifiers'
         RESTRICT_ON_SEND = %i[gem].freeze
 
+        # @!method gem_declaration?(node)
         def_node_matcher :gem_declaration?, '(send nil? :gem str ...)'
 
         def on_send(node)

data/lib/rubocop/cop/bundler/insecure_protocol_source.rb

@@ -36,6 +36,7 @@ module RuboCop
 
         RESTRICT_ON_SEND = %i[source].freeze
 
+        # @!method insecure_protocol_source?(node)
         def_node_matcher :insecure_protocol_source?, <<~PATTERN
           (send nil? :source
             $(sym ${:gemcutter :rubygems :rubyforge}))

data/lib/rubocop/cop/bundler/ordered_gems.rb

@@ -64,6 +64,7 @@ module RuboCop
           declarations.to_a[node_index - 1]
         end
 
+        # @!method gem_declarations(node)
         def_node_search :gem_declarations, <<~PATTERN
           (:send nil? :gem str ...)
         PATTERN

data/lib/rubocop/cop/correctors/alignment_corrector.rb

@@ -12,7 +12,7 @@ module RuboCop
       class << self
         attr_reader :processed_source
 
-        def correct(processed_source, node, column_delta)
+        def correct(corrector, processed_source, node, column_delta)
           return unless node
 
           @processed_source = processed_source
@@ -21,11 +21,8 @@ module RuboCop
 
           taboo_ranges = inside_string_ranges(node)
 
-          lambda do |corrector|
-            each_line(expr) do |line_begin_pos|
-              autocorrect_line(corrector, line_begin_pos, expr, column_delta,
-                               taboo_ranges)
-            end
+          each_line(expr) do |line_begin_pos|
+            autocorrect_line(corrector, line_begin_pos, expr, column_delta, taboo_ranges)
           end
         end
 

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gemspec
+      # This cop checks that `date =` is not used in gemspec file.
+      # It is set automatically when the gem is packaged.
+      #
+      # @example
+      #
+      #   # bad
+      #   Gem::Specification.new do |spec|
+      #     s.name = 'your_cool_gem_name'
+      #     spec.date = Time.now.strftime('%Y-%m-%d')
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     s.name = 'your_cool_gem_name'
+      #   end
+      #
+      class DateAssignment < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Do not use `date =` in gemspec, it is set automatically when the gem is packaged.'
+
+        # @!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
+
+          date_assignment = block_node.descendants.detect do |node|
+            node.send_type? && node.receiver&.source == block_parameter && node.method?(:date=)
+          end
+
+          return unless date_assignment
+
+          add_offense(date_assignment) do |corrector|
+            range = range_by_whole_lines(date_assignment.source_range, include_final_newline: true)
+
+            corrector.remove(range)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -40,6 +40,7 @@ module RuboCop
         MSG = '`%<assignment>s` method calls already given on line '\
               '%<line_of_first_occurrence>d of the gemspec.'
 
+        # @!method gem_specification(node)
         def_node_search :gem_specification, <<~PATTERN
           (block
             (send
@@ -49,6 +50,7 @@ module RuboCop
               (arg $_)) ...)
         PATTERN
 
+        # @!method assignment_method_declarations(node)
         def_node_search :assignment_method_declarations, <<~PATTERN
           (send
             (lvar #match_block_variable_name?) #assignment_method? ...)

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

@@ -95,6 +95,7 @@ module RuboCop
           node.method_name
         end
 
+        # @!method dependency_declarations(node)
         def_node_search :dependency_declarations, <<~PATTERN
           (send (lvar _) {:add_dependency :add_runtime_dependency :add_development_dependency} (str _) ...)
         PATTERN

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

@@ -55,10 +55,12 @@ module RuboCop
                         '.rubocop.yml) should be equal.'
         MISSING_MSG = '`required_ruby_version` should be specified.'
 
+        # @!method required_ruby_version(node)
         def_node_search :required_ruby_version, <<~PATTERN
           (send _ :required_ruby_version= $_)
         PATTERN
 
+        # @!method defined_ruby_version(node)
         def_node_matcher :defined_ruby_version, <<~PATTERN
           {$(str _) $(array (str _) (str _))
             (send (const (const nil? :Gem) :Requirement) :new $(str _))}

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

@@ -28,8 +28,10 @@ module RuboCop
       class RubyVersionGlobalsUsage < Base
         MSG = 'Do not use `RUBY_VERSION` in gemspec file.'
 
+        # @!method ruby_version?(node)
         def_node_matcher :ruby_version?, '(const {cbase nil?} :RUBY_VERSION)'
 
+        # @!method gem_specification?(node)
         def_node_search :gem_specification?, <<~PATTERN
           (block
             (send

data/lib/rubocop/cop/generator.rb

@@ -9,7 +9,7 @@ module RuboCop
     # @api private
     class Generator
       # NOTE: RDoc 5.1.0 or lower has the following issue.
-      # https://github.com/rubocop-hq/rubocop/issues/7043
+      # https://github.com/rubocop/rubocop/issues/7043
       #
       # The following `String#gsub` can be replaced with
       # squiggly heredoc when RuboCop supports Ruby 2.5 or higher
@@ -58,7 +58,7 @@ module RuboCop
                 # 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-ast/blob/master/lib/rubocop/ast/node_pattern.rb
+                # 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`.'

data/lib/rubocop/cop/internal_affairs.rb

@@ -4,6 +4,7 @@ require_relative 'internal_affairs/empty_line_between_expect_offense_and_correct
 require_relative 'internal_affairs/example_description'
 require_relative 'internal_affairs/method_name_equal'
 require_relative 'internal_affairs/node_destructuring'
+require_relative 'internal_affairs/node_matcher_directive'
 require_relative 'internal_affairs/node_type_predicate'
 require_relative 'internal_affairs/offense_location_keyword'
 require_relative 'internal_affairs/redundant_described_class_as_subject'

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

@@ -57,6 +57,7 @@ module RuboCop
           /\b(does not|doesn't) (auto[- ]?)?correct/
         ].freeze
 
+        # @!method offense_example?(node)
         def_node_matcher :offense_example?, <<~PATTERN
           (block
             (send _ {:it :specify} $_description)

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

@@ -20,6 +20,7 @@ module RuboCop
               '`method_name == %<method_name>s`.'
         RESTRICT_ON_SEND = %i[==].freeze
 
+        # @!method method_name?(node)
         def_node_matcher :method_name?, <<~PATTERN
           (send
             $(send

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

@@ -19,10 +19,12 @@ module RuboCop
         MSG = 'Use the methods provided with the node extensions instead ' \
               'of manually destructuring nodes.'
 
+        # @!method node_variable?(node)
         def_node_matcher :node_variable?, <<~PATTERN
           {(lvar [#node_suffix? _]) (send nil? [#node_suffix? _])}
         PATTERN
 
+        # @!method node_destructuring?(node)
         def_node_matcher :node_destructuring?, <<~PATTERN
           {(masgn (mlhs ...) {(send #node_variable? :children) (array (splat #node_variable?))})}
         PATTERN

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

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks that node matcher definitions are tagged with a YARD `@!method`
+      # directive so that editors are able to find the dynamically defined
+      # method.
+      #
+      # @example
+      #  # bad
+      #  def_node_matcher :foo?, <<~PATTERN
+      #    ...
+      #  PATTERN
+      #
+      #  # good
+      #  # @!method foo?(node)
+      #  def_node_matcher :foo?, <<~PATTERN
+      #    ...
+      #  PATTERN
+      #
+      class NodeMatcherDirective < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Preceed `%<method>s` with a `@!method` YARD directive.'
+        MSG_WRONG_NAME = '`@!method` YARD directive has invalid method name, ' \
+          'use `%<expected>s` instead of `%<actual>s`.'
+        MSG_TOO_MANY = 'Multiple `@!method` YARD directives found for this matcher.'
+
+        RESTRICT_ON_SEND = %i[def_node_matcher def_node_search].to_set.freeze
+        REGEXP = /^\s*#\s*@!method\s+(?<method_name>[a-z0-9_]+[?!]?)(?:\((?<args>.*)\))?/.freeze
+
+        # @!method pattern_matcher?(node)
+        def_node_matcher :pattern_matcher?, <<~PATTERN
+          (send _ %RESTRICT_ON_SEND {str sym} {str dstr})
+        PATTERN
+
+        def on_send(node)
+          return if node.arguments.none?
+          return unless valid_method_name?(node)
+
+          actual_name = node.arguments.first.value
+          directives = method_directives(node)
+          return too_many_directives(node) if directives.size > 1
+
+          directive = directives.first
+          return if directive_correct?(directive, actual_name)
+
+          register_offense(node, directive, actual_name)
+        end
+
+        private
+
+        def valid_method_name?(node)
+          node.arguments.first.str_type? || node.arguments.first.sym_type?
+        end
+
+        def method_directives(node)
+          comments = processed_source.ast_with_comments[node]
+
+          comments.map do |comment|
+            match = comment.text.match(REGEXP)
+            next unless match
+
+            { node: comment, method_name: match[:method_name], args: match[:args] }
+          end.compact
+        end
+
+        def too_many_directives(node)
+          add_offense(node, message: MSG_TOO_MANY)
+        end
+
+        def directive_correct?(directive, actual_name)
+          directive && directive[:method_name] == actual_name.to_s
+        end
+
+        def register_offense(node, directive, actual_name)
+          message = formatted_message(directive, actual_name, node.method_name)
+
+          add_offense(node, message: message) do |corrector|
+            if directive
+              correct_directive(corrector, directive, actual_name)
+            else
+              insert_directive(corrector, node, actual_name)
+            end
+          end
+        end
+
+        def formatted_message(directive, actual_name, method_name)
+          if directive
+            format(MSG_WRONG_NAME, expected: actual_name, actual: directive[:method_name])
+          else
+            format(MSG, method: method_name)
+          end
+        end
+
+        def insert_directive(corrector, node, actual_name)
+          # 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
+          )
+          indentation = range.source.match(/^\s*/)[0]
+          directive = "#{indentation}# @!method #{actual_name}(#{arguments.join(', ')})\n"
+          directive = "\n#{directive}" if add_newline?(node)
+
+          corrector.insert_before(range, directive)
+        end
+
+        def pattern_arguments(pattern)
+          arguments = %w[node]
+          max_pattern_var = pattern.scan(/(?<=%)\d+/).map(&:to_i).max
+          max_pattern_var&.times { |i| arguments << "arg#{i + 1}" }
+          arguments
+        end
+
+        def add_newline?(node)
+          # Determine if a blank line should be inserted before the new directive
+          # in order to spread out pattern matchers
+          return if node.sibling_index&.zero?
+          return unless node.parent
+
+          prev_sibling = node.parent.child_nodes[node.sibling_index - 1]
+          return unless prev_sibling && pattern_matcher?(prev_sibling)
+
+          node.loc.line == last_line(prev_sibling) + 1
+        end
+
+        def last_line(node)
+          if node.last_argument.heredoc?
+            node.last_argument.loc.heredoc_end.line
+          else
+            node.loc.last_line
+          end
+        end
+
+        def correct_directive(corrector, directive, actual_name)
+          correct = "@!method #{actual_name}"
+          regexp = /@!method\s+#{Regexp.escape(directive[:method_name])}/
+
+          replacement = directive[:node].text.gsub(regexp, correct)
+          corrector.replace(directive[:node], replacement)
+        end
+      end
+    end
+  end
+end

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

@@ -19,6 +19,7 @@ module RuboCop
         MSG = 'Use `#%<type>s_type?` to check node type.'
         RESTRICT_ON_SEND = %i[==].freeze
 
+        # @!method node_type_check(node)
         def_node_matcher :node_type_check, <<~PATTERN
           (send (send $_ :type) :== (sym $_))
         PATTERN

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

@@ -34,10 +34,12 @@ module RuboCop
 
         private
 
+        # @!method node_type_check(node)
         def_node_matcher :node_type_check, <<~PATTERN
           (send nil? :add_offense $_node $hash)
         PATTERN
 
+        # @!method offending_location_argument(node)
         def_node_matcher :offending_location_argument, <<~PATTERN
           (pair (sym :location) $(send (send $_node :loc) $_keyword))
         PATTERN

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

@@ -21,6 +21,7 @@ module RuboCop
 
         MSG = 'Remove the redundant `subject`%<additional_message>s.'
 
+        # @!method described_class_subject?(node)
         def_node_matcher :described_class_subject?, <<~PATTERN
           (block
             (send nil? :subject

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

@@ -25,6 +25,7 @@ module RuboCop
 
         MSG = 'Remove `let` that is `RuboCop::Config.new` with no arguments%<additional_message>s.'
 
+        # @!method let_rubocop_config_new?(node)
         def_node_matcher :let_rubocop_config_new?, <<~PATTERN
           (block
             (send nil? :let

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

@@ -23,6 +23,7 @@ module RuboCop
         MSG = 'Redundant location argument to `#add_offense`.'
         RESTRICT_ON_SEND = %i[add_offense].freeze
 
+        # @!method redundant_location_argument(node)
         def_node_matcher :redundant_location_argument, <<~PATTERN
           (send nil? :add_offense _
             (hash <$(pair (sym :location) (sym :expression)) ...>)

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

@@ -26,16 +26,19 @@ module RuboCop
         MSG = 'Redundant message argument to `#add_offense`.'
         RESTRICT_ON_SEND = %i[add_offense].freeze
 
+        # @!method node_type_check(node)
         def_node_matcher :node_type_check, <<~PATTERN
           (send nil? :add_offense $_node $hash)
         PATTERN
 
+        # @!method redundant_message_argument(node)
         def_node_matcher :redundant_message_argument, <<~PATTERN
           (pair
             (sym :message)
             ${(const nil? :MSG) (send nil? :message) (send nil? :message _)})
         PATTERN
 
+        # @!method message_method_call(node)
         def_node_matcher :message_method_call, '(send nil? :message $_node)'
 
         def on_send(node)