rubocop-rspec 1.6.0 → 1.7.0

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks if an example group does not include any tests.
+      #
+      # This cop is configurable using the `CustomIncludeMethods` option
+      #
+      # @example usage
+      #
+      #   # bad
+      #   describe Bacon do
+      #     let(:bacon)      { Bacon.new(chunkiness) }
+      #     let(:chunkiness) { false                 }
+      #
+      #     context 'extra chunky' do   # flagged by rubocop
+      #       let(:chunkiness) { true }
+      #     end
+      #
+      #     it 'is chunky' do
+      #       expect(bacon.chunky?).to be_truthy
+      #     end
+      #   end
+      #
+      #   # good
+      #   describe Bacon do
+      #     let(:bacon)      { Bacon.new(chunkiness) }
+      #     let(:chunkiness) { false                 }
+      #
+      #     it 'is chunky' do
+      #       expect(bacon.chunky?).to be_truthy
+      #     end
+      #   end
+      #
+      # @example configuration
+      #
+      #   # .rubocop.yml
+      #   RSpec/EmptyExampleGroup:
+      #     CustomIncludeMethods:
+      #     - include_tests
+      #
+      #   # spec_helper.rb
+      #   RSpec.configure do |config|
+      #     config.alias_it_behaves_like_to(:include_tests)
+      #   end
+      #
+      #   # bacon_spec.rb
+      #   describe Bacon do
+      #     let(:bacon)      { Bacon.new(chunkiness) }
+      #     let(:chunkiness) { false                 }
+      #
+      #     context 'extra chunky' do   # not flagged by rubocop
+      #       let(:chunkiness) { true }
+      #
+      #       include_tests 'shared tests'
+      #     end
+      #   end
+      #
+      class EmptyExampleGroup < Cop
+        include RuboCop::RSpec::SpecOnly,
+                RuboCop::RSpec::Language,
+                RuboCop::RSpec::Language::NodePattern
+
+        MSG = 'Empty example group detected.'.freeze
+
+        def_node_search :contains_example?, <<-PATTERN
+          {
+            (send _ {
+              #{Examples::ALL.to_node_pattern}
+              :it_behaves_like
+              :it_should_behave_like
+              :include_context
+              :include_examples
+            } ...)
+            (send _ #custom_include? ...)
+          }
+        PATTERN
+
+        def on_block(node)
+          return unless example_group?(node) && !contains_example?(node)
+
+          add_offense(node.children.first, :expression)
+        end
+
+        private
+
+        def custom_include?(method_name)
+          custom_include_methods.include?(method_name)
+        end
+
+        def custom_include_methods
+          cop_config
+            .fetch('CustomIncludeMethods', [])
+            .map(&:to_sym)
+        end
+      end
+    end
+  end
+end

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

@@ -3,6 +3,8 @@
 module RuboCop
   module Cop
     module RSpec
+      # Checks for long examples.
+      #
       # A long example is usually more difficult to understand. Consider
       # extracting out some behaviour, e.g. with a `let` block, or a helper
       # method.
@@ -24,8 +26,9 @@ module RuboCop
       #     expect(result).to be(true)
       #   end
       class ExampleLength < Cop
-        include CodeLength
-        EXAMPLE_BLOCKS = [:it, :specify].freeze
+        include RuboCop::RSpec::SpecOnly, CodeLength
+
+        EXAMPLE_BLOCKS = RuboCop::RSpec::Language::Examples::ALL
 
         def on_block(node)
           method, _args, _body = *node

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

@@ -3,8 +3,9 @@
 module RuboCop
   module Cop
     module RSpec
-      # Do not use should when describing your tests.
-      # see: http://betterspecs.org/#should
+      # Checks that example descriptions do not start with "should".
+      #
+      # @see http://betterspecs.org/#should
       #
       # The autocorrect is experimental - use with care! It can be configured
       # with CustomTransform (e.g. have => has) and IgnoredWords (e.g. only).
@@ -18,6 +19,8 @@ module RuboCop
       #   it 'finds nothing' do
       #   end
       class ExampleWording < Cop
+        include RuboCop::RSpec::SpecOnly
+
         MSG = 'Do not use should when describing your tests.'.freeze
 
         def on_block(node) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength,Metrics/LineLength

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for `expect(...)` calls containing literal values.
+      #
+      # @example
+      #   # bad
+      #   expect(5).to eq(price)
+      #   expect(/foo/).to eq(pattern)
+      #   expect("John").to eq(name)
+      #
+      #   # good
+      #   expect(price).to eq(5)
+      #   expect(pattern).to eq(/foo/)
+      #   expect(name).to eq("John")
+      #
+      class ExpectActual < Cop
+        include RuboCop::RSpec::SpecOnly
+
+        MSG = 'Provide the actual you are testing to `expect(...)`'.freeze
+
+        SIMPLE_LITERALS = %i(
+          true
+          false
+          nil
+          int
+          float
+          str
+          sym
+          complex
+          rational
+          regopt
+        ).freeze
+
+        COMPLEX_LITERALS = %i(
+          array
+          hash
+          pair
+          irange
+          erange
+          regexp
+        ).freeze
+
+        def_node_matcher :expect, '(send _ :expect $_)'
+
+        def on_send(node)
+          expect_literal(node) do |argument|
+            add_offense(argument, :expression)
+          end
+        end
+
+        private
+
+        # This is not implement using a NodePattern because it seems
+        # to not be able to match against an explicit (nil) sexp
+        def expect_literal(node)
+          return unless (argument = expect(node))
+
+          yield(argument) if literal?(argument)
+        end
+
+        def literal?(node)
+          simple_literal?(node) || complex_literal?(node)
+        end
+
+        def simple_literal?(node)
+          SIMPLE_LITERALS.include?(node.type)
+        end
+
+        def complex_literal?(node)
+          COMPLEX_LITERALS.include?(node.type) &&
+            node.each_child_node.all?(&method(:literal?))
+        end
+      end
+    end
+  end
+end

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

@@ -3,6 +3,8 @@
 module RuboCop
   module Cop
     module RSpec
+      # Checks that spec file paths are consistent with the test subject.
+      #
       # Checks the path of the spec file and enforces that it reflects the
       # described class/module and its optionally called out method.
       #
@@ -15,7 +17,7 @@ module RuboCop
       #   my_class_method_spec.rb  # describe MyClass, '#method'
       #   my_class_spec.rb         # describe MyClass
       class FilePath < Cop
-        include RuboCop::RSpec::TopLevelDescribe
+        include RuboCop::RSpec::SpecOnly, RuboCop::RSpec::TopLevelDescribe
 
         MESSAGE = 'Spec path should end with `%s`'.freeze
         METHOD_STRING_MATCHER = /^[\#\.].+/

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module RSpec
-      # Checks if test is focused.
+      # Checks if examples are focused.
       #
       # @example
       #   # bad
@@ -20,36 +20,20 @@ module RuboCop
       #   describe MyClass do
       #   end
       class Focus < Cop
+        include RuboCop::RSpec::SpecOnly, RuboCop::RSpec::Language
+
         MSG = 'Focused spec found.'.freeze
 
-        FOCUSABLE_SELECTORS = '
-          :context
-          :describe
-          :example
-          :example_group
-          :feature
-          :it
-          :scenario
-          :specify
-          :xcontext
-          :xdescribe
-          :xexample
-          :xfeature
-          :xit
-          :xscenario
-          :xspecify
-        '.freeze
+        focusable =
+          ExampleGroups::GROUPS  +
+          ExampleGroups::SKIPPED +
+          Examples::EXAMPLES     +
+          Examples::SKIPPED
+
+        focused = ExampleGroups::FOCUSED + Examples::FOCUSED
 
-        FOCUSING_SELECTORS = '
-          :fcontext
-          :fdescribe
-          :fexample
-          :ffeature
-          :fit
-          :focus
-          :fscenario
-          :fspecify
-        '.freeze
+        FOCUSABLE_SELECTORS = focusable.to_node_pattern
+        FOCUSING_SELECTORS  = focused.to_node_pattern
 
         FOCUS_SYMBOL = s(:sym, :focus)
         FOCUS_TRUE   = s(:pair, FOCUS_SYMBOL, s(:true))

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

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks the arguments passed to `before`, `around`, and `after`.
+      #
+      # This cop checks for consistent style when specifying RSpec
+      # hooks which run for each example. There are three supported
+      # styles: "implicit", "each", and "example." All styles have
+      # the same behavior.
+      #
+      # @example when configuration is `EnforcedStyle: implicit`
+      #   # bad
+      #   before(:each) do
+      #     ...
+      #   end
+      #
+      #   # bad
+      #   before(:example) do
+      #     ...
+      #   end
+      #
+      #   # good
+      #   before do
+      #     ...
+      #   end
+      #
+      # @example when configuration is `EnforcedStyle: each`
+      #   # bad
+      #   before(:example) do
+      #     ...
+      #   end
+      #
+      #   # good
+      #   before do
+      #     ...
+      #   end
+      #
+      #   # good
+      #   before(:each) do
+      #     ...
+      #   end
+      #
+      # @example when configuration is `EnforcedStyle: example`
+      #   # bad
+      #   before(:each) do
+      #     ...
+      #   end
+      #
+      #   # bad
+      #   before do
+      #     ...
+      #   end
+      #
+      #   # good
+      #   before(:example) do
+      #     ...
+      #   end
+      class HookArgument < RuboCop::Cop::Cop
+        include RuboCop::RSpec::Language,
+                RuboCop::RSpec::SpecOnly,
+                ConfigurableEnforcedStyle
+
+        IMPLICIT_MSG = 'Omit the default `%p` argument for RSpec hooks.'.freeze
+        EXPLICIT_MSG = 'Use `%p` for RSpec hooks.'.freeze
+
+        HOOKS = "{#{Hooks::ALL.to_node_pattern}}".freeze
+
+        def_node_matcher :scoped_hook, <<-PATTERN
+        (block $(send nil #{HOOKS} (sym ${:each :example})) ...)
+        PATTERN
+
+        def_node_matcher :unscoped_hook, "(block $(send nil #{HOOKS}) ...)"
+
+        def on_block(node)
+          hook(node) do |method_send, scope_name|
+            return correct_style_detected if scope_name.equal?(style)
+            return check_implicit(method_send) unless scope_name
+
+            style_detected(scope_name)
+            add_offense(method_send, :expression, explicit_message(scope_name))
+          end
+        end
+
+        def autocorrect(node)
+          scope = "(#{style.inspect})" unless implicit_style?
+          hook  = "#{node.method_name}#{scope}"
+
+          lambda do |corrector|
+            corrector.replace(node.loc.expression, hook)
+          end
+        end
+
+        private
+
+        def check_implicit(method_send)
+          style_detected(:implicit)
+          return if implicit_style?
+
+          add_offense(method_send, :selector, format(EXPLICIT_MSG, style))
+        end
+
+        def explicit_message(scope)
+          if implicit_style?
+            format(IMPLICIT_MSG, scope)
+          else
+            format(EXPLICIT_MSG, style)
+          end
+        end
+
+        def implicit_style?
+          style.equal?(:implicit)
+        end
+
+        def hook(node, &block)
+          scoped_hook(node, &block) || unscoped_hook(node, &block)
+        end
+      end
+    end
+  end
+end

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

@@ -3,8 +3,12 @@
 module RuboCop
   module Cop
     module RSpec
-      # When you have to assign a variable instead of using an instance
-      # variable, use let.
+      # Checks for instance variable usage in specs.
+      #
+      # This cop can be configured with the option `AssignmentOnly` which
+      # will configure the cop to only register offenses on instance
+      # variable usage if the instance variable is also assigned within
+      # the spec
       #
       # @example
       #   # bad
@@ -18,22 +22,59 @@ module RuboCop
       #     let(:foo) { [] }
       #     it { expect(foo).to be_empty }
       #   end
+      #
+      # @example with AssignmentOnly configuration
+      #
+      #   # rubocop.yml
+      #   RSpec/InstanceVariable:
+      #     AssignmentOnly: false
+      #
+      #   # bad
+      #   describe MyClass do
+      #     before { @foo = [] }
+      #     it { expect(@foo).to be_empty }
+      #   end
+      #
+      #   # allowed
+      #   describe MyClass do
+      #     it { expect(@foo).to be_empty }
+      #   end
+      #
+      #   # good
+      #   describe MyClass do
+      #     let(:foo) { [] }
+      #     it { expect(foo).to be_empty }
+      #   end
+      #
       class InstanceVariable < Cop
+        include RuboCop::RSpec::SpecOnly, RuboCop::RSpec::Language
+
         MESSAGE = 'Use `let` instead of an instance variable'.freeze
-        EXAMPLE_GROUP_METHODS = [
-          :example_group, :describe, :context, :xdescribe, :xcontext,
-          :fdescribe, :fcontext, :shared_examples, :shared_context,
-          :share_examples_for, :shared_examples_for, :feature
-        ].freeze
+
+        EXAMPLE_GROUP_METHODS = ExampleGroups::ALL + SharedGroups::ALL
+
+        def_node_matcher :spec_group?, <<-PATTERN
+          (block (send _ {#{EXAMPLE_GROUP_METHODS.to_node_pattern}} ...) ...)
+        PATTERN
+
+        def_node_search :ivar_usage, '$(ivar $_)'
+
+        def_node_search :ivar_assigned?, '(ivasgn % ...)'
 
         def on_block(node)
-          method, _args, _body = *node
-          _receiver, method_name, _object = *method
-          @in_spec = true if EXAMPLE_GROUP_METHODS.include?(method_name)
+          return unless spec_group?(node)
+
+          ivar_usage(node) do |ivar, name|
+            return if assignment_only? && !ivar_assigned?(node, name)
+
+            add_offense(ivar, :expression, MESSAGE)
+          end
         end
 
-        def on_ivar(node)
-          add_offense(node, :expression, MESSAGE) if @in_spec
+        private
+
+        def assignment_only?
+          cop_config['AssignmentOnly']
         end
       end
     end