rubocop 1.8.0 → 1.11.0

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # This cop checks for redundant `subject(:cop) { described_class.new }`.
+      #
+      # @example
+      #   # bad
+      #   RSpec.describe RuboCop::Cop::Department::Foo do
+      #     subject(:cop) { described_class.new(config) }
+      #   end
+      #
+      #   # good
+      #   RSpec.describe RuboCop::Cop::Department::Foo, :config do
+      #   end
+      #
+      class RedundantDescribedClassAsSubject < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Remove the redundant `subject`%<additional_message>s.'
+
+        # @!method described_class_subject?(node)
+        def_node_matcher :described_class_subject?, <<~PATTERN
+          (block
+            (send nil? :subject
+              (sym :cop))
+            (args)
+            (send
+              (send nil? :described_class) :new
+              $...))
+        PATTERN
+
+        def on_block(node)
+          return unless (described_class_arguments = described_class_subject?(node))
+          return if described_class_arguments.count >= 2
+
+          describe = find_describe_method_node(node)
+
+          unless (exist_config = describe.last_argument.source == ':config')
+            additional_message = ' and specify `:config` in `describe`'
+          end
+
+          message = format(MSG, additional_message: additional_message)
+
+          add_offense(node, message: message) do |corrector|
+            corrector.remove(range_by_whole_lines(node.source_range, include_final_newline: true))
+
+            corrector.insert_after(describe.last_argument, ', :config') unless exist_config
+          end
+        end
+
+        private
+
+        def find_describe_method_node(block_node)
+          block_node.ancestors.find { |node| node.block_type? && node.method?(:describe) }.send_node
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # This cop checks that `let` is `RuboCop::Config.new` with no arguments.
+      #
+      # @example
+      #   # bad
+      #   RSpec.describe RuboCop::Cop::Department::Foo, :config do
+      #     let(:config) { RuboCop::Config.new }
+      #   end
+      #
+      #   # good
+      #   RSpec.describe RuboCop::Cop::Department::Foo, :config do
+      #   end
+      #
+      #   RSpec.describe RuboCop::Cop::Department::Foo, :config do
+      #     let(:config) { RuboCop::Config.new(argument) }
+      #   end
+      #
+      class RedundantLetRuboCopConfigNew < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        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
+              (sym :config))
+            (args)
+            (send
+              (const
+                (const nil? :RuboCop) :Config) :new))
+        PATTERN
+
+        def on_block(node)
+          return unless let_rubocop_config_new?(node)
+
+          describe = find_describe_method_node(node)
+
+          unless (exist_config = describe.last_argument.source == ':config')
+            additional_message = ' and specify `:config` in `describe`'
+          end
+
+          message = format(MSG, additional_message: additional_message)
+
+          add_offense(node, message: message) do |corrector|
+            corrector.remove(range_by_whole_lines(node.source_range, include_final_newline: true))
+
+            corrector.insert_after(describe.last_argument, ', :config') unless exist_config
+          end
+        end
+
+        private
+
+        def find_describe_method_node(block_node)
+          block_node.ancestors.find { |node| node.block_type? && node.method?(:describe) }.send_node
+        end
+      end
+    end
+  end
+end

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)

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

@@ -67,18 +67,22 @@ module RuboCop
           no_acceptable_style! style_detected
         ].freeze
 
+        # @!method correct_style_detected_check(node)
         def_node_matcher :correct_style_detected_check, <<~PATTERN
           (send nil? :correct_style_detected)
         PATTERN
 
+        # @!method negative_style_detected_method_check(node)
         def_node_matcher :negative_style_detected_method_check, <<~PATTERN
           (send nil? /(?:opposite|unexpected|ambiguous|unrecognized)_style_detected|conflicting_styles_detected/ ...)
         PATTERN
 
+        # @!method no_acceptable_style_check(node)
         def_node_matcher :no_acceptable_style_check, <<~PATTERN
           (send nil? :no_acceptable_style!)
         PATTERN
 
+        # @!method style_detected_check(node)
         def_node_matcher :style_detected_check, <<~PATTERN
           (send nil? :style_detected ...)
         PATTERN

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

@@ -16,10 +16,12 @@ module RuboCop
       class UselessMessageAssertion < Base
         MSG = 'Do not specify cop behavior using `described_class::MSG`.'
 
+        # @!method described_class_msg(node)
         def_node_search :described_class_msg, <<~PATTERN
           (const (send nil? :described_class) :MSG)
         PATTERN
 
+        # @!method rspec_expectation_on_msg?(node)
         def_node_matcher :rspec_expectation_on_msg?, <<~PATTERN
           (send (send nil? :expect #contains_described_class_msg?) :to ...)
         PATTERN

data/lib/rubocop/cop/layout/block_alignment.rb

@@ -68,6 +68,7 @@ module RuboCop
 
         MSG = '%<current>s is not aligned with %<prefer>s%<alt_prefer>s.'
 
+        # @!method block_end_align_target?(node, child)
         def_node_matcher :block_end_align_target?, <<~PATTERN
           {assignment?
            splat

data/lib/rubocop/cop/layout/class_structure.rb

@@ -147,6 +147,7 @@ module RuboCop
         MSG = '`%<category>s` is supposed to appear before ' \
               '`%<previous>s`.'
 
+        # @!method dynamic_constant?(node)
         def_node_matcher :dynamic_constant?, <<~PATTERN
           (casgn nil? _ (send ...))
         PATTERN
@@ -213,7 +214,12 @@ module RuboCop
           name = node.method_name.to_s
           category, = categories.find { |_, names| names.include?(name) }
           key = category || name
-          visibility_key = "#{node_visibility(node)}_#{key}"
+          visibility_key =
+            if node.def_modifier?
+              "#{name}_methods"
+            else
+              "#{node_visibility(node)}_#{key}"
+            end
           expected_order.include?(visibility_key) ? visibility_key : key
         end
 
@@ -264,7 +270,7 @@ module RuboCop
 
         def source_range_with_comment(node)
           begin_pos, end_pos =
-            if node.def_type?
+            if node.def_type? && !node.method?(:initialize) || node.send_type? && node.def_modifier?
               start_node = find_visibility_start(node) || node
               end_node = find_visibility_end(node) || node
               [begin_pos_with_comment(start_node),

data/lib/rubocop/cop/layout/empty_line_between_defs.rb

@@ -88,7 +88,7 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Use empty lines between %<type>s definitions.'
+        MSG = 'Expected %<expected>s between %<type>s definitions; found %<actual>d.'
 
         def self.autocorrect_incompatible_with
           [Layout::EmptyLines]
@@ -107,19 +107,21 @@ module RuboCop
         end
 
         def check_defs(nodes)
-          return if blank_lines_between?(*nodes)
+          count = blank_lines_count_between(*nodes)
+
+          return if line_count_allowed?(count)
           return if multiple_blank_lines_groups?(*nodes)
           return if nodes.all?(&:single_line?) &&
                     cop_config['AllowAdjacentOneLineDefs']
 
           correction_node = nodes.last
           location = correction_node.loc.keyword.join(correction_node.loc.name)
-          add_offense(location, message: message(correction_node)) do |corrector|
-            autocorrect(corrector, *nodes)
+          add_offense(location, message: message(correction_node, count: count)) do |corrector|
+            autocorrect(corrector, *nodes, count)
           end
         end
 
-        def autocorrect(corrector, prev_def, node)
+        def autocorrect(corrector, prev_def, node, count)
           # finds position of first newline
           end_pos = end_loc(prev_def).end_pos
           source_buffer = end_loc(prev_def).source_buffer
@@ -128,8 +130,6 @@ module RuboCop
           # Handle the case when multiple one-liners are on the same line.
           newline_pos = end_pos + 1 if newline_pos > node.source_range.begin_pos
 
-          count = blank_lines_count_between(prev_def, node)
-
           if count > maximum_empty_lines
             autocorrect_remove_lines(corrector, newline_pos, count)
           else
@@ -157,14 +157,22 @@ module RuboCop
           cop_config['EmptyLineBetweenModuleDefs'] && node.module_type?
         end
 
-        def message(node)
-          type = case node.type
-                 when :def, :defs
-                   :method
-                 else
-                   node.type
-                 end
-          format(MSG, type: type)
+        def message(node, count: nil)
+          type = node_type(node)
+
+          format(MSG,
+                 type: type,
+                 expected: expected_lines,
+                 actual: count)
+        end
+
+        def expected_lines
+          if allowance_range?
+            "#{minimum_empty_lines..maximum_empty_lines} empty lines"
+          else
+            lines = maximum_empty_lines == 1 ? 'line' : 'lines'
+            "#{maximum_empty_lines} empty #{lines}"
+          end
         end
 
         def multiple_blank_lines_groups?(first_def_node, second_def_node)
@@ -176,8 +184,7 @@ module RuboCop
           blank_start > non_blank_end
         end
 
-        def blank_lines_between?(first_def_node, second_def_node)
-          count = blank_lines_count_between(first_def_node, second_def_node)
+        def line_count_allowed?(count)
           (minimum_empty_lines..maximum_empty_lines).cover?(count)
         end
 
@@ -230,6 +237,19 @@ module RuboCop
 
           corrector.insert_after(where_to_insert, "\n" * difference)
         end
+
+        def node_type(node)
+          case node.type
+          when :def, :defs
+            :method
+          else
+            node.type
+          end
+        end
+
+        def allowance_range?
+          minimum_empty_lines != maximum_empty_lines
+        end
       end
     end
   end