rubocop-rspec 1.6.0 → 1.7.0

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

@@ -1,8 +1,7 @@
 module RuboCop
   module Cop
     module RSpec
-      # Enforces the usage of the same method on all negative message
-      # expectations.
+      # Checks for consistent method usage for negating expectations.
       #
       # @example
       #   # bad
@@ -15,7 +14,8 @@ module RuboCop
       #     expect(false).not_to be_true
       #   end
       class NotToNot < Cop
-        include RuboCop::Cop::ConfigurableEnforcedStyle
+        include RuboCop::RSpec::SpecOnly,
+                RuboCop::Cop::ConfigurableEnforcedStyle
 
         MSG = 'Prefer `%s` over `%s`'.freeze
 

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

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for stubbed test subjects.
+      #
+      # @see https://robots.thoughtbot.com/don-t-stub-the-system-under-test
+      #
+      # @example
+      #   # bad
+      #   describe Foo do
+      #     subject(:bar) { baz }
+      #
+      #     before do
+      #       allow(bar).to receive(:qux?).and_return(true)
+      #     end
+      #   end
+      #
+      class SubjectStub < Cop
+        include RuboCop::RSpec::SpecOnly,
+                RuboCop::RSpec::TopLevelDescribe,
+                RuboCop::RSpec::Language,
+                RuboCop::RSpec::Language::NodePattern
+
+        MSG = 'Do not stub your test subject.'.freeze
+
+        # @!method subject(node)
+        #   Find a named or unnamed subject definition
+        #
+        #   @example anonymous subject
+        #     subject(parse('subject { foo }').ast) do |name|
+        #       name # => :subject
+        #     end
+        #
+        #   @example named subject
+        #     subject(parse('subject(:thing) { foo }').ast) do |name|
+        #       name # => :thing
+        #     end
+        #
+        #   @param node [RuboCop::Node]
+        #
+        #   @yield [Symbol] subject name
+        def_node_matcher :subject, <<-PATTERN
+        {
+          (block (send nil :subject (sym $_)) args ...)
+          (block (send nil $:subject) args ...)
+        }
+        PATTERN
+
+        # @!method message_expectation?(node, method_name)
+        #   Match `allow` and `expect(...).to receive`
+        #
+        #   @example source that matches
+        #     allow(foo).to  receive(:bar)
+        #     allow(foo).to  receive(:bar).with(1)
+        #     allow(foo).to  receive(:bar).with(1).and_return(2)
+        #     expect(foo).to receive(:bar)
+        #     expect(foo).to receive(:bar).with(1)
+        #     expect(foo).to receive(:bar).with(1).and_return(2)
+        def_node_matcher :message_expectation?, <<-PATTERN
+          {
+            (send nil :allow (send nil %))
+            (send (send nil :expect (send nil %)) :to #receive_message?)
+          }
+        PATTERN
+
+        def_node_search :receive_message?, '(send nil :receive ...)'
+
+        def on_block(node)
+          return unless example_group?(node)
+
+          find_subject_stub(node) { |stub| add_offense(stub, :expression) }
+        end
+
+        private
+
+        # Find subjects within tree and then find (send) nodes for that subject
+        #
+        # @param node [RuboCop::Node] example group
+        #
+        # @yield [RuboCop::Node] message expectations for subject
+        def find_subject_stub(node, &block)
+          find_subject(node) do |subject_name, context|
+            find_subject_expectation(context, subject_name, &block)
+          end
+        end
+
+        # Find a subject message expectation
+        #
+        # @param node [RuboCop::Node]
+        # @param subject_name [Symbol] name of subject
+        #
+        # @yield [RuboCop::Node] message expectation
+        def find_subject_expectation(node, subject_name, &block)
+          # Do not search node if it is an example group with its own subject.
+          return if example_group?(node) && redefines_subject?(node)
+
+          # Yield the current node if it is a message expectation.
+          yield(node) if message_expectation?(node, subject_name)
+
+          # Recurse through node's children looking for a message expectation.
+          node.each_child_node do |child|
+            find_subject_expectation(child, subject_name, &block)
+          end
+        end
+
+        # Check if node's children contain a subject definition
+        #
+        # @param node [RuboCop::Node]
+        #
+        # @return [Boolean]
+        def redefines_subject?(node)
+          node.each_child_node.any? do |child|
+            subject(child) || redefines_subject?(child)
+          end
+        end
+
+        # Find a subject definition
+        #
+        # @param node [RuboCop::Node]
+        # @param parent [RuboCop::Node,nil]
+        #
+        # @yieldparam subject_name [Symbol] name of subject being defined
+        # @yieldparam parent [RuboCop::Node] parent of subject definition
+        def find_subject(node, parent: nil, &block)
+          subject(node) { |name| yield(name, parent) }
+
+          node.each_child_node do |child|
+            find_subject(child, parent: node, &block)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -4,7 +4,8 @@ module RuboCop
   module Cop
     module RSpec
       # Prefer using verifying doubles over normal doubles.
-      # see: https://relishapp.com/rspec/rspec-mocks/docs/verifying-doubles
+      #
+      # @see https://relishapp.com/rspec/rspec-mocks/docs/verifying-doubles
       #
       # @example
       #   # bad
@@ -17,6 +18,8 @@ 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

@@ -0,0 +1,10 @@
+module RuboCop
+  # RuboCop RSpec project namespace
+  module RSpec
+    PROJECT_ROOT   = Pathname.new(__dir__).parent.parent.expand_path.freeze
+    CONFIG_DEFAULT = PROJECT_ROOT.join('config', 'default.yml').freeze
+    CONFIG         = YAML.load(CONFIG_DEFAULT.read).freeze
+
+    private_constant(*constants(false))
+  end
+end

data/lib/rubocop/rspec/config_formatter.rb

@@ -0,0 +1,33 @@
+require 'yaml'
+
+module RuboCop
+  module RSpec
+    # Builds a YAML config file from two config hashes
+    class ConfigFormatter
+      NAMESPACE = 'RSpec'.freeze
+
+      def initialize(config, descriptions)
+        @config       = config
+        @descriptions = descriptions
+      end
+
+      def dump
+        YAML.dump(unified_config).gsub(/^#{NAMESPACE}/, "\n#{NAMESPACE}")
+      end
+
+      private
+
+      def unified_config
+        cops.each_with_object(config.dup) do |cop, unified|
+          unified[cop] = config.fetch(cop).merge(descriptions.fetch(cop))
+        end
+      end
+
+      def cops
+        (descriptions.keys + config.keys).uniq.grep(/\A#{NAMESPACE}/)
+      end
+
+      attr_reader :config, :descriptions
+    end
+  end
+end

data/lib/rubocop/rspec/description_extractor.rb

@@ -0,0 +1,35 @@
+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
+      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
+      end
+
+      private
+
+      def cop_documentation
+        yardocs
+          .select(&method(:cop?))
+          .map { |doc| [doc.name, doc.docstring] }
+      end
+
+      def cop?(doc)
+        doc.type.equal?(:class) && doc.to_s.start_with?(COP_NAMESPACE)
+      end
+
+      attr_reader :yardocs
+    end
+  end
+end

data/lib/rubocop/rspec/inject.rb

@@ -3,15 +3,11 @@ module RuboCop
     # Because RuboCop doesn't yet support plugins, we have to monkey patch in a
     # bit of our configuration.
     module Inject
-      DEFAULT_FILE = File.expand_path(
-        '../../../../config/default.yml', __FILE__
-      )
-
       def self.defaults!
-        path = File.absolute_path(DEFAULT_FILE)
+        path = CONFIG_DEFAULT.to_s
         hash = ConfigLoader.send(:load_yaml_configuration, path)
         config = Config.new(hash, path)
-        puts "configuration from #{DEFAULT_FILE}" if ConfigLoader.debug?
+        puts "configuration from #{path}" if ConfigLoader.debug?
         config = ConfigLoader.merge_with_default(config, path)
         ConfigLoader.instance_variable_set(:@default_configuration, config)
       end

data/lib/rubocop/rspec/language.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module RSpec
+    # RSpec public API methods that are commonly used in cops
+    module Language
+      # Set of method selectors
+      class SelectorSet
+        def initialize(selectors)
+          @selectors = selectors
+        end
+
+        def ==(other)
+          selectors.eql?(other.selectors)
+        end
+
+        def +(other)
+          self.class.new(selectors + other.selectors)
+        end
+
+        def include?(selector)
+          selectors.include?(selector)
+        end
+
+        def to_node_pattern
+          selectors.map(&:inspect).join(' ')
+        end
+
+        protected
+
+        attr_reader :selectors
+      end
+
+      module ExampleGroups
+        GROUPS  = SelectorSet.new(%i(describe context feature example_group))
+        SKIPPED = SelectorSet.new(%i(xdescribe xcontext xfeature))
+        FOCUSED = SelectorSet.new(%i(fdescribe fcontext ffeature))
+
+        ALL = GROUPS + SKIPPED + FOCUSED
+      end
+
+      module SharedGroups
+        ALL = SelectorSet.new(
+          %i(shared_examples shared_context shared_examples_for)
+        )
+      end
+
+      module Examples
+        EXAMPLES = SelectorSet.new(%i(it specify example scenario its))
+        FOCUSED  = SelectorSet.new(%i(fit fspecify fexample fscenario focus))
+        SKIPPED  = SelectorSet.new(%i(xit xspecify xexample xscenario skip))
+        PENDING  = SelectorSet.new(%i(pending))
+
+        ALL = EXAMPLES + FOCUSED + SKIPPED + PENDING
+      end
+
+      module Hooks
+        ALL = SelectorSet.new(%i(after around before))
+      end
+
+      module Helpers
+        ALL = SelectorSet.new(%i(let let!))
+      end
+
+      ALL =
+        ExampleGroups::ALL +
+        SharedGroups::ALL  +
+        Examples::ALL      +
+        Hooks::ALL         +
+        Helpers::ALL
+    end
+  end
+end

data/lib/rubocop/rspec/language/node_pattern.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module RSpec
+    module Language
+      # Common node matchers used for matching against the rspec DSL
+      module NodePattern
+        extend RuboCop::NodePattern::Macros
+
+        def_node_matcher :example_group?, <<-PATTERN
+          (block (send _ {#{ExampleGroups::ALL.to_node_pattern}} ...) ...)
+        PATTERN
+      end
+    end
+  end
+end

data/lib/rubocop/rspec/spec_only.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module RSpec
+    # Mixin for cops that skips non-spec files
+    #
+    # The criteria for whether rubocop-rspec analyzes a certain ruby file
+    # is configured via `AllCops/RSpec`. For example, if you want to
+    # customize your project to scan all files within a `test/` directory
+    # then you could add this to your configuration:
+    #
+    # @example configuring analyzed paths
+    #
+    #   AllCops:
+    #     RSpec:
+    #       Patterns:
+    #       - '_spec.rb$'
+    #       - '(?:^|/)spec/'
+    #
+    # @note this functionality is implemented via this mixin instead of
+    #   a subclass of `RuboCop::Cop::Cop` because the `Cop` class assumes
+    #   that it will be the direct superclass of all cops. For example,
+    #   if the ancestry of a cop looked like this:
+    #
+    #     class RuboCop::RSpec::Cop < RuboCop::Cop::Cop
+    #     end
+    #
+    #     class RuboCop::RSpec::SpecCop < RuboCop::RSpec::Cop
+    #     end
+    #
+    #   then `SpecCop` will fail to be registered on the class instance
+    #   variable of `Cop` which tracks all descendants via `.inherited`.
+    #
+    #   While we could match this behavior and provide a rubocop-rspec Cop
+    #   parent class, it would rely heavily on the implementation details
+    #   of RuboCop itself which is largly private API. This would be
+    #   irresponsible since any patch level release of rubocop could break
+    #   integrations for users of rubocop-rspec
+    #
+    module SpecOnly
+      DEFAULT_CONFIGURATION = CONFIG.fetch('AllCops').fetch('RSpec')
+
+      def relevant_file?(file)
+        rspec_pattern =~ file && super
+      end
+
+      private
+
+      def rspec_pattern
+        Regexp.union(rspec_pattern_config.map(&Regexp.public_method(:new)))
+      end
+
+      def rspec_pattern_config
+        config
+          .for_all_cops
+          .fetch('RSpec', DEFAULT_CONFIGURATION)
+          .fetch('Patterns')
+      end
+    end
+  end
+end

data/lib/rubocop/rspec/top_level_describe.rb

@@ -2,6 +2,12 @@ module RuboCop
   module RSpec
     # Helper methods for top level describe cops
     module TopLevelDescribe
+      extend NodePattern::Macros
+
+      def_node_matcher :described_constant, <<-PATTERN
+        (block $(send _ :describe $(const ...)) (args) $_)
+      PATTERN
+
       def on_send(node)
         return unless respond_to?(:on_top_level_describe)
         return unless top_level_describe?(node)