rubocop-rspec 1.8.0 → 1.9.0

data/lib/rubocop/cop/rspec/message_expectation.rb

@@ -25,7 +25,7 @@ module RuboCop
       #   expect(foo).to receive(:bar)
       #
       class MessageExpectation < Cop
-        include RuboCop::RSpec::SpecOnly, ConfigurableEnforcedStyle
+        include ConfigurableEnforcedStyle
 
         MSG = 'Prefer `%s` for setting message expectations.'.freeze
 

data/lib/rubocop/cop/rspec/message_spies.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks that message expectations are set using spies.
+      #
+      # This cop can be configured in your configuration using the
+      # `EnforcedStyle` option and supports `--auto-gen-config`.
+      #
+      # @example `EnforcedStyle: have_received`
+      #
+      #   # bad
+      #   expect(foo).to receive(:bar)
+      #
+      #   # good
+      #   expect(foo).to have_received(:bar)
+      #
+      # @example `EnforcedStyle: receive`
+      #
+      #   # bad
+      #   expect(foo).to have_received(:bar)
+      #
+      #   # good
+      #   expect(foo).to receive(:bar)
+      #
+      class MessageSpies < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG_RECEIVE = 'Prefer `receive` for setting message ' \
+          'expectations.'.freeze
+        MSG_HAVE_RECEIVED = 'Prefer `have_received` for setting message ' \
+          'expectations. Setup `%s` as a spy using `allow` or `instance_spy`.'
+          .freeze
+
+        SUPPORTED_STYLES = %w(have_received receive).freeze
+
+        def_node_matcher :message_expectation, %(
+          (send (send nil :expect (send nil $_)) :to ...)
+        )
+
+        def_node_search :receive_message, %(
+          $(send nil {:receive :have_received} ...)
+        )
+
+        def on_send(node)
+          receive_message_matcher(node) do |receiver, message_matcher|
+            return correct_style_detected if preferred_style?(message_matcher)
+
+            add_offense(message_matcher, :selector, error_message(receiver)) do
+              opposite_style_detected
+            end
+          end
+        end
+
+        private
+
+        def receive_message_matcher(node)
+          return unless (receiver = message_expectation(node))
+
+          receive_message(node) { |match| yield(receiver, match) }
+        end
+
+        def preferred_style?(expectation)
+          expectation.method_name.equal?(style)
+        end
+
+        def error_message(receiver)
+          case style
+          when :receive
+            MSG_RECEIVE
+          when :have_received
+            MSG_HAVE_RECEIVED % receiver
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rspec/multiple_describes.rb

@@ -23,8 +23,7 @@ module RuboCop
       #     end
       #   end
       class MultipleDescribes < Cop
-        include RuboCop::RSpec::SpecOnly,
-                RuboCop::RSpec::TopLevelDescribe
+        include RuboCop::RSpec::TopLevelDescribe
 
         MSG = 'Do not use multiple top level describes - ' \
               'try to nest them.'.freeze

data/lib/rubocop/cop/rspec/multiple_expectations.rb

@@ -46,15 +46,11 @@ module RuboCop
       #   end
       #
       class MultipleExpectations < Cop
-        include RuboCop::RSpec::SpecOnly,
-                RuboCop::RSpec::Language,
-                ConfigurableMax
+        include ConfigurableMax
 
         MSG = 'Too many expectations.'.freeze
 
-        def_node_matcher :example?, <<-PATTERN
-          (block (send _ {#{Examples::ALL.to_node_pattern}} ...) ...)
-        PATTERN
+        def_node_matcher :example?, Examples::ALL.block_pattern
 
         def_node_search :expect, '(send _ :expect ...)'
 

data/lib/rubocop/cop/rspec/named_subject.rb

@@ -38,8 +38,6 @@ module RuboCop
       #     it { should be_valid }
       #   end
       class NamedSubject < Cop
-        include RuboCop::RSpec::SpecOnly
-
         MSG = 'Name your test subject if '\
               'you need to reference it explicitly.'.freeze
 

data/lib/rubocop/cop/rspec/nested_groups.rb

@@ -85,15 +85,11 @@ module RuboCop
       #   end
       #
       class NestedGroups < Cop
-        include RuboCop::RSpec::SpecOnly,
-                RuboCop::RSpec::TopLevelDescribe,
-                RuboCop::RSpec::Language
+        include RuboCop::RSpec::TopLevelDescribe
 
         MSG = 'Maximum example group nesting exceeded'.freeze
 
-        def_node_search :find_contexts, <<-PATTERN
-          (block (send nil {#{ExampleGroups::ALL.to_node_pattern}} ...) (args) ...)
-        PATTERN
+        def_node_search :find_contexts, ExampleGroups::ALL.block_pattern
 
         def on_block(node)
           describe, = described_constant(node)

data/lib/rubocop/cop/rspec/not_to_not.rb

@@ -14,8 +14,7 @@ module RuboCop
       #     expect(false).not_to be_true
       #   end
       class NotToNot < Cop
-        include RuboCop::RSpec::SpecOnly,
-                RuboCop::Cop::ConfigurableEnforcedStyle
+        include RuboCop::Cop::ConfigurableEnforcedStyle
 
         MSG = 'Prefer `%s` over `%s`'.freeze
 

data/lib/rubocop/cop/rspec/repeated_description.rb

@@ -0,0 +1,59 @@
+module RuboCop
+  module Cop
+    module RSpec
+      # Check for repeated description strings in example groups.
+      #
+      # @example
+      #
+      #     # bad
+      #     RSpec.describe User do
+      #       it 'is valid' do
+      #         # ...
+      #       end
+      #
+      #       it 'is valid' do
+      #         # ...
+      #       end
+      #     end
+      #
+      #     # good
+      #     RSpec.describe User do
+      #       it 'is valid when first and last name are present' do
+      #         # ...
+      #       end
+      #
+      #       it 'is valid when last name only is present' do
+      #         # ...
+      #       end
+      #     end
+      #
+      class RepeatedDescription < Cop
+        MSG = "Don't repeat descriptions within an example group.".freeze
+
+        def on_block(node)
+          return unless example_group?(node)
+
+          repeated_descriptions(node).each do |repeated_description|
+            add_offense(repeated_description, :expression)
+          end
+        end
+
+        private
+
+        # Select examples in the current scope with repeated description strings
+        def repeated_descriptions(node)
+          grouped_examples =
+            RuboCop::RSpec::ExampleGroup.new(node)
+              .examples
+              .group_by(&:doc_string)
+
+          grouped_examples
+            .select { |description, group| description && group.size > 1 }
+            .values
+            .flatten
+            .map(&:definition)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rspec/single_argument_message_chain.rb

@@ -0,0 +1,48 @@
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks that chains of messages contain more than one element.
+      #
+      # @example
+      #   # bad
+      #   allow(foo).to receive_message_chain(:bar).and_return(42)
+      #
+      #   # good
+      #   allow(foo).to receive(:bar).and_return(42)
+      #
+      #   # also good
+      #   allow(foo).to receive(:bar, :baz)
+      #   allow(foo).to receive("bar.baz")
+      #
+      class SingleArgumentMessageChain < Cop
+        MESSAGE = 'Use `%<recommended_method>s` instead of calling ' \
+          '`%<called_method>s` with a single argument'.freeze
+
+        def on_send(node)
+          _receiver, method_name, *args = *node
+          return unless Matchers::MESSAGE_CHAIN.include?(method_name)
+          return if args.size > 1
+          return if multi_argument_string?(args)
+
+          add_offense(node, :selector, message(method_name))
+        end
+
+        private
+
+        def multi_argument_string?(args)
+          args.size == 1 &&
+            args.first.type == :str &&
+            args.first.children.first.include?('.')
+        end
+
+        def message(method)
+          if method == :receive_message_chain
+            MESSAGE % { recommended_method: :receive, called_method: method }
+          else
+            MESSAGE % { recommended_method: :stub, called_method: method }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rspec/subject_stub.rb

@@ -18,10 +18,7 @@ module RuboCop
       #   end
       #
       class SubjectStub < Cop
-        include RuboCop::RSpec::SpecOnly,
-                RuboCop::RSpec::TopLevelDescribe,
-                RuboCop::RSpec::Language,
-                RuboCop::RSpec::Language::NodePattern
+        include RuboCop::RSpec::TopLevelDescribe
 
         MSG = 'Do not stub your test subject.'.freeze
 

data/lib/rubocop/cop/rspec/verified_doubles.rb

@@ -18,8 +18,6 @@ module RuboCop
       #     widget = instance_double("Widget")
       #   end
       class VerifiedDoubles < Cop
-        include RuboCop::RSpec::SpecOnly
-
         MSG = 'Prefer using verifying doubles over normal doubles.'.freeze
 
         def_node_matcher :unverified_double, <<-PATTERN

data/lib/rubocop/rspec.rb

@@ -5,6 +5,6 @@ module RuboCop
     CONFIG_DEFAULT = PROJECT_ROOT.join('config', 'default.yml').freeze
     CONFIG         = YAML.load(CONFIG_DEFAULT.read).freeze
 
-    private_constant(*constants(false))
+    private_constant(:CONFIG_DEFAULT, :PROJECT_ROOT)
   end
 end

data/lib/rubocop/rspec/description_extractor.rb

@@ -2,34 +2,71 @@ module RuboCop
   module RSpec
     # Extracts cop descriptions from YARD docstrings
     class DescriptionExtractor
-      COP_NAMESPACE = 'RuboCop::Cop::RSpec'.freeze
-      COP_FORMAT    = 'RSpec/%s'.freeze
-
       def initialize(yardocs)
-        @yardocs = yardocs
+        @code_objects = yardocs.map(&CodeObject.public_method(:new))
       end
 
       def to_h
-        cop_documentation.each_with_object({}) do |(name, docstring), config|
-          config[format(COP_FORMAT, name)] = {
-            'Description' => docstring.split("\n\n").first.to_s
-          }
-        end
+        code_objects
+          .select(&:rspec_cop?)
+          .map(&:configuration)
+          .reduce(:merge)
       end
 
       private
 
-      def cop_documentation
-        yardocs
-          .select(&method(:cop?))
-          .map { |doc| [doc.name, doc.docstring] }
-      end
+      attr_reader :code_objects
 
-      def cop?(doc)
-        doc.type.equal?(:class) && doc.to_s.start_with?(COP_NAMESPACE)
-      end
+      # Decorator of a YARD code object for working with documented rspec cops
+      class CodeObject
+        COP_NAMESPACE = 'RuboCop::Cop::RSpec'.freeze
+
+        def initialize(yardoc)
+          @yardoc = yardoc
+        end
+
+        # Test if the YARD code object documents a concrete rspec cop class
+        #
+        # @return [Boolean]
+        def rspec_cop?
+          class_documentation? && rspec_cop_namespace? && !abstract?
+        end
+
+        # Configuration for the documented cop that would live in default.yml
+        #
+        # @return [Hash]
+        def configuration
+          { cop_name => { 'Description' => description } }
+        end
+
+        private
+
+        def cop_name
+          Object.const_get(documented_constant).cop_name
+        end
+
+        def description
+          yardoc.docstring.split("\n\n").first.to_s
+        end
+
+        def class_documentation?
+          yardoc.type.equal?(:class)
+        end
+
+        def rspec_cop_namespace?
+          documented_constant.start_with?(COP_NAMESPACE)
+        end
+
+        def documented_constant
+          yardoc.to_s
+        end
 
-      attr_reader :yardocs
+        def abstract?
+          yardoc.tags.any? { |tag| tag.tag_name.eql?('abstract') }
+        end
+
+        attr_reader :yardoc
+      end
     end
   end
 end

data/lib/rubocop/rspec/example.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module RSpec
+    # Wrapper for RSpec examples
+    class Example
+      extend RuboCop::NodePattern::Macros
+
+      def_node_matcher :extract_doc_string,     '(send _ _ $str ...)'
+      def_node_matcher :extract_metadata,       '(send _ _ _ $...)'
+      def_node_matcher :extract_implementation, '(block send args $_)'
+
+      def initialize(node)
+        @node = node
+      end
+
+      def doc_string
+        extract_doc_string(definition)
+      end
+
+      def metadata
+        extract_metadata(definition)
+      end
+
+      def implementation
+        extract_implementation(node)
+      end
+
+      def eql?(other)
+        node.eql?(other.node)
+      end
+
+      alias == eql?
+
+      def hash
+        [self.class, node].hash
+      end
+
+      def to_node
+        node
+      end
+
+      def definition
+        if node.send_type?
+          node
+        else
+          node.children.first
+        end
+      end
+
+      protected
+
+      attr_reader :node
+    end
+  end
+end