rubocop 1.10.0 → 1.14.0

data/lib/rubocop/cop/corrector.rb

@@ -36,10 +36,7 @@ module RuboCop
       # @param [Integer] size
       def remove_preceding(node_or_range, size)
         range = to_range(node_or_range)
-        to_remove = range.with(
-          begin_pos: range.begin_pos - size,
-          end_pos:   range.begin_pos
-        )
+        to_remove = range.with(begin_pos: range.begin_pos - size, end_pos: range.begin_pos)
         remove(to_remove)
       end
 

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
 
@@ -57,8 +54,7 @@ module RuboCop
         def inside_string_ranges(node)
           return [] unless node.is_a?(Parser::AST::Node)
 
-          node.each_node(:str, :dstr, :xstr).map { |n| inside_string_range(n) }
-              .compact
+          node.each_node(:str, :dstr, :xstr).map { |n| inside_string_range(n) }.compact
         end
 
         def inside_string_range(node)
@@ -79,8 +75,7 @@ module RuboCop
         def delimited_string_literal?(node)
           loc = node.location
 
-          loc.respond_to?(:begin) && loc.begin &&
-            loc.respond_to?(:end) && loc.end
+          loc.respond_to?(:begin) && loc.begin && loc.respond_to?(:end) && loc.end
         end
 
         def block_comment_within?(expr)
@@ -92,8 +87,7 @@ module RuboCop
         def calculate_range(expr, line_begin_pos, column_delta)
           return range_between(line_begin_pos, line_begin_pos) if column_delta.positive?
 
-          starts_with_space =
-            expr.source_buffer.source[line_begin_pos].start_with?(' ')
+          starts_with_space = expr.source_buffer.source[line_begin_pos].start_with?(' ')
 
           if starts_with_space
             range_between(line_begin_pos, line_begin_pos + column_delta.abs)

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

@@ -6,8 +6,7 @@ module RuboCop
     class EachToForCorrector
       extend NodePattern::Macros
 
-      CORRECTION_WITH_ARGUMENTS =
-        'for %<variables>s in %<collection>s do'
+      CORRECTION_WITH_ARGUMENTS = 'for %<variables>s in %<collection>s do'
       CORRECTION_WITHOUT_ARGUMENTS = 'for _ in %<enumerable>s do'
 
       def initialize(block_node)
@@ -30,8 +29,7 @@ module RuboCop
                  collection: collection_node.source,
                  variables: argument_node.children.first.source)
         else
-          format(CORRECTION_WITHOUT_ARGUMENTS,
-                 enumerable: collection_node.source)
+          format(CORRECTION_WITHOUT_ARGUMENTS, enumerable: collection_node.source)
         end
       end
 

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

@@ -23,8 +23,7 @@ module RuboCop
       attr_reader :for_node, :variable_node, :collection_node
 
       def correction
-        format(CORRECTION, collection: collection_source,
-                           argument: variable_node.source)
+        format(CORRECTION, collection: collection_source, argument: variable_node.source)
       end
 
       def collection_source

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

@@ -20,8 +20,7 @@ module RuboCop
 
           break_line_before(range: range, node: node, corrector: corrector,
                             configured_width: configured_width)
-          move_comment(eol_comment: eol_comment, node: node,
-                       corrector: corrector)
+          move_comment(eol_comment: eol_comment, node: node, corrector: corrector)
           remove_semicolon(node, corrector)
         end
 
@@ -29,8 +28,7 @@ module RuboCop
                               indent_steps: 1)
           corrector.insert_before(
             range,
-            "\n#{' ' * (node.loc.keyword.column +
-                          indent_steps * configured_width)}"
+            "\n#{' ' * (node.loc.keyword.column + indent_steps * configured_width)}"
           )
         end
 
@@ -38,8 +36,7 @@ module RuboCop
           return unless eol_comment
 
           text = eol_comment.loc.expression.source
-          corrector.insert_before(node,
-                                  "#{text}\n#{' ' * node.loc.keyword.column}")
+          corrector.insert_before(node, "#{text}\n#{' ' * node.loc.keyword.column}")
           corrector.remove(eol_comment)
         end
 

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

@@ -41,9 +41,7 @@ module RuboCop
       end
 
       def correct_next_line_brace(corrector)
-        corrector.remove(
-          range_with_surrounding_space(range: node.loc.end, side: :left)
-        )
+        corrector.remove(range_with_surrounding_space(range: node.loc.end, side: :left))
 
         corrector.insert_before(
           last_element_range_with_trailing_comma(node).end,

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

@@ -17,9 +17,7 @@ module RuboCop
           current_range = declaration_with_comment(node)
           previous_range = declaration_with_comment(previous_declaration)
 
-          lambda do |corrector|
-            swap_range(corrector, current_range, previous_range)
-          end
+          ->(corrector) do swap_range(corrector, current_range, previous_range) end
         end
 
         private

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

@@ -32,9 +32,7 @@ module RuboCop
       end
 
       def delimiters_for(type)
-        PreferredDelimiters
-          .new(type, config, preferred_delimiters)
-          .delimiters
+        PreferredDelimiters.new(type, config, preferred_delimiters).delimiters
       end
 
       def new_contents(node, escape, delimiters)
@@ -61,11 +59,7 @@ module RuboCop
         base_line_num = node.first_line
         prev_line_num = base_line_num
         node.children.map.with_index do |word_node, index|
-          line_breaks = line_breaks(word_node,
-                                    node.source,
-                                    prev_line_num,
-                                    base_line_num,
-                                    index)
+          line_breaks = line_breaks(word_node, node.source, prev_line_num, base_line_num, index)
           prev_line_num = word_node.last_line
           content = fix_escaped_content(word_node, escape, delimiters)
           line_breaks + content

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

@@ -25,6 +25,7 @@ module RuboCop
 
         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

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? ...)
@@ -89,8 +91,7 @@ module RuboCop
 
         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)
+          offense_location = source_range(processed_source.buffer, node.first_line, line_range)
           message = format(
             MSG,
             assignment: assignment,

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

@@ -64,10 +64,7 @@ module RuboCop
           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)
-            )
+            next unless case_insensitive_out_of_order?(gem_name(current), gem_name(previous))
             next unless get_dependency_name(previous) == get_dependency_name(current)
 
             register_offense(previous, current)
@@ -95,6 +92,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`.'
@@ -124,10 +124,7 @@ module RuboCop
       end
 
       def inject_require(root_file_path: 'lib/rubocop.rb')
-        RequireFileInjector.new(
-          source_path: source_path,
-          root_file_path: root_file_path
-        ).inject
+        RequireFileInjector.new(source_path: source_path, root_file_path: root_file_path).inject
       end
 
       def inject_config(config_file_path: 'config/default.yml',

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

@@ -24,8 +24,7 @@ module RuboCop
         def inject
           target_line = find_target_line
           if target_line
-            configuration_entries.insert(target_line,
-                                         "#{new_configuration_entry}\n")
+            configuration_entries.insert(target_line, "#{new_configuration_entry}\n")
           else
             configuration_entries.push("\n#{new_configuration_entry}")
           end

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

@@ -29,14 +29,11 @@ module RuboCop
         attr_reader :require_entries, :root_file_path, :source_path, :output
 
         def require_exists?
-          require_entries.any? do |entry|
-            entry == injectable_require_directive
-          end
+          require_entries.any?(injectable_require_directive)
         end
 
         def updated_directives
-          require_entries.insert(target_line,
-                                 injectable_require_directive).join
+          require_entries.insert(target_line, injectable_require_directive).join
         end
 
         def target_line

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

@@ -49,14 +49,13 @@ module RuboCop
           /^(does not|doesn't) add (a|an|any )?offense/
         ].freeze
 
-        EXPECT_NO_CORRECTIONS_INCORRECT_DESCRIPTIONS = [
-          /^(auto[- ]?)?correct/
-        ].freeze
+        EXPECT_NO_CORRECTIONS_INCORRECT_DESCRIPTIONS = [/^(auto[- ]?)?correct/].freeze
 
         EXPECT_CORRECTION_INCORRECT_DESCRIPTIONS = [
           /\b(does not|doesn't) (auto[- ]?)?correct/
         ].freeze
 
+        # @!method offense_example?(node)
         def_node_matcher :offense_example?, <<~PATTERN
           (block
             (send _ {:it :specify} $_description)
@@ -79,10 +78,14 @@ module RuboCop
         private
 
         def check_description(description, regexps, message)
-          return unless regexps.any? { |regexp| regexp.match?(description.value) }
+          return unless regexps.any? { |regexp| regexp.match?(string_contents(description)) }
 
           add_offense(description, message: message)
         end
+
+        def string_contents(node)
+          node.str_type? ? node.value : node.source
+        end
       end
     end
   end

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

@@ -16,10 +16,10 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Use `method?(%<method_name>s)` instead of ' \
-              '`method_name == %<method_name>s`.'
+        MSG = 'Use `method?(%<method_name>s)` instead of `method_name == %<method_name>s`.'
         RESTRICT_ON_SEND = %i[==].freeze
 
+        # @!method method_name?(node)
         def_node_matcher :method_name?, <<~PATTERN
           (send
             $(send
@@ -42,9 +42,7 @@ module RuboCop
         private
 
         def range(method_name_node, node)
-          range_between(
-            method_name_node.loc.selector.begin_pos, node.source_range.end_pos
-          )
+          range_between(method_name_node.loc.selector.begin_pos, node.source_range.end_pos)
         end
       end
     end

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

@@ -19,18 +19,18 @@ 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
 
         def on_masgn(node)
-          node_destructuring?(node) do
-            add_offense(node)
-          end
+          node_destructuring?(node) { add_offense(node) }
         end
 
         private

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