rubocop-rspec 1.12.0 → 1.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 48bfb61579b01b4044eeca76aa125c026ac18630
-  data.tar.gz: 240d2ce3b483174eae7c4049fcc65f8301bf48a1
+  metadata.gz: 94ad662f54f32cf6cbde51f8c2fdd788fa44e989
+  data.tar.gz: d0c3723b84a23c6589aa10d9f379b7d56b332bcc
 SHA512:
-  metadata.gz: 09f351caba55c9c7ad8710e286fec4b9f087028a64a886c4edf25d69b3147ecedebd5e7eeacec52a81285e14c3cd46cf615fbfef3c15a542fe6cd6c6a9d28a0c
-  data.tar.gz: 120152a6271b3eb853a9e8c4b19716667b401f732a712c045ebada5df7371c3a843e49d5a8a83cb5197fd7a9bbf4a12e6ef245fdf9df9cd26155a849cdcdeffc
+  metadata.gz: fbc83814064a1e25163689e9da12bcfcac4c8f0849c62fe34adb13b6fa7a569f8a37a627bd04fe067f28bec140c4d8f89c9b2bed537b21eaafdeac9ad32c8663
+  data.tar.gz: cf26853505de97b2ba385add43eb5cbf71cac5395c9f773208f93d4bd02b9650e023ee9a27b4c0f23e0ee7909370d8c8060fa05fa2299aa639ba3837054cdfb1

data/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## Master (Unreleased)
 
+## 1.13.0 (2017-03-07)
+
+* Add repeated 'it' detection to `RSpec/ExampleWording` cop. ([@dgollahon][])
+* Add [observed_nesting/max_nesting] info to `RSpec/NestedGroups` messages. ([@dgollahon][])
+* Add `RSpec/ItBehavesLike` cop. ([@dgollahon][])
+* Add `RSpec/SharedContext` cop. ([@Darhazer][])
+* `Rspec/MultipleExpectations`: Count aggregate_failures block as single expectation. ([@Darhazer][])
+* Fix `ExpectActual` cop flagging `rspec-rails` routing specs. ([@backus][])
+* Fix `FilePath` cop not registering offenses for files like `spec/blog/user.rb` when it should be `spec/blog/user_spec.rb`. ([@backus][])
+
 ## 1.12.0 (2017-02-21)
 
 * Add `RSpec/InstanceSpy` cop. ([@Darhazer][])
@@ -186,3 +196,4 @@
 [@Darhazer]: https://github.com/Darhazer
 [@redross]: https://github.com/redross
 [@cfabianski]: https://github.com/cfabianski
+[@dgollahon]: https://github.com/dgollahon

data/config/default.yml

@@ -53,7 +53,7 @@ RSpec/ExampleLength:
   Max: 5
 
 RSpec/ExampleWording:
-  Description: Checks that example descriptions do not start with "should".
+  Description: Checks for common mistakes in example descriptions.
   Enabled: true
   CustomTransform:
     be: is
@@ -64,6 +64,8 @@ RSpec/ExampleWording:
 RSpec/ExpectActual:
   Description: Checks for `expect(...)` calls containing literal values.
   Enabled: true
+  Exclude:
+  - spec/routing/**/*
 
 RSpec/ExpectOutput:
   Description: Checks for opportunities to use `expect { ... }.to output`.
@@ -107,6 +109,14 @@ RSpec/InstanceVariable:
   AssignmentOnly: false
   Enabled: true
 
+RSpec/ItBehavesLike:
+  Description: Checks that only one `it_behaves_like` style is used.
+  Enabled: true
+  EnforcedStyle: it_behaves_like
+  SupportedStyles:
+  - it_behaves_like
+  - it_should_behave_like
+
 RSpec/LeadingSubject:
   Description: Checks for `subject` definitions that come after `let` definitions.
   Enabled: true
@@ -169,6 +179,10 @@ RSpec/RepeatedExample:
   Enabled: true
   Description: Check for repeated examples within example groups.
 
+RSpec/SharedContext:
+  Description: Checks for proper shared_context and shared_examples usage.
+  Enabled: true
+
 RSpec/SingleArgumentMessageChain:
   Description: Checks that chains of messages contain more than one element.
   Enabled: true

data/lib/rubocop-rspec.rb

@@ -38,6 +38,7 @@ require 'rubocop/cop/rspec/hook_argument'
 require 'rubocop/cop/rspec/implicit_expect'
 require 'rubocop/cop/rspec/instance_spy'
 require 'rubocop/cop/rspec/instance_variable'
+require 'rubocop/cop/rspec/it_behaves_like'
 require 'rubocop/cop/rspec/leading_subject'
 require 'rubocop/cop/rspec/let_setup'
 require 'rubocop/cop/rspec/message_chain'
@@ -51,6 +52,7 @@ require 'rubocop/cop/rspec/not_to_not'
 require 'rubocop/cop/rspec/repeated_description'
 require 'rubocop/cop/rspec/repeated_example'
 require 'rubocop/cop/rspec/scattered_setup'
+require 'rubocop/cop/rspec/shared_context'
 require 'rubocop/cop/rspec/single_argument_message_chain'
 require 'rubocop/cop/rspec/subject_stub'
 require 'rubocop/cop/rspec/verified_doubles'

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

@@ -21,19 +21,16 @@ module RuboCop
       #     end
       #   end
       class AnyInstance < Cop
-        MESSAGE = 'Avoid stubbing using `%{method}`'.freeze
+        MSG = 'Avoid stubbing using `%{method}`.'.freeze
 
-        ANY_INSTANCE_METHODS = [
-          :any_instance,
-          :allow_any_instance_of,
-          :expect_any_instance_of
-        ].freeze
+        def_node_matcher :disallowed_stub, <<-PATTERN
+          (send _ ${:any_instance :allow_any_instance_of :expect_any_instance_of} ...)
+        PATTERN
 
         def on_send(node)
-          _receiver, method_name, *_args = *node
-          return unless ANY_INSTANCE_METHODS.include?(method_name)
-
-          add_offense(node, :expression, format(MESSAGE, method: method_name))
+          disallowed_stub(node) do |method|
+            add_offense(node, :expression, format(MSG, method: method))
+          end
         end
       end
     end

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

@@ -24,53 +24,42 @@ module RuboCop
       #     test.run
       #   end
       class AroundBlock < Cop
-        MSG_NO_ARG = 'Test object should be passed to around block'.freeze
-        MSG_UNUSED_ARG = 'You should call `%<arg>s.call` ' \
-                          'or `%<arg>s.run`'.freeze
+        MSG_NO_ARG     = 'Test object should be passed to around block.'.freeze
+        MSG_UNUSED_ARG = 'You should call `%<arg>s.call` '\
+                         'or `%<arg>s.run`.'.freeze
 
-        def_node_matcher :scoped_hook, <<-PATTERN
-        (block (send nil :around (sym {:each :example})) $(args ...) ...)
+        def_node_matcher :hook, <<-PATTERN
+          (block {(send nil :around) (send nil :around sym)} (args $...) ...)
         PATTERN
 
-        def_node_matcher :unscoped_hook, <<-PATTERN
-        (block (send nil :around) $(args ...) ...)
+        def_node_search :find_arg_usage, <<-PATTERN
+          {(send $... {:call :run}) (send _ _ $...) (yield $...) (block-pass $...)}
         PATTERN
 
-        def_node_search :find_arg_usage, '(lvar $_)'
-
         def on_block(node)
-          hook(node) do |parameters|
-            missing_parameters(parameters) do
-              add_offense(node, :expression, MSG_NO_ARG)
-              return
-            end
-
-            unused_parameters(parameters) do |param, name|
-              add_offense(param, :expression, format(MSG_UNUSED_ARG, arg: name))
+          hook(node) do |(example_proxy)|
+            if example_proxy.nil?
+              add_no_arg_offense(node)
+            else
+              check_for_unused_proxy(node, example_proxy)
             end
           end
         end
 
         private
 
-        def missing_parameters(node)
-          yield if node.children[0].nil?
+        def add_no_arg_offense(node)
+          add_offense(node, :expression, MSG_NO_ARG)
         end
 
-        def unused_parameters(node)
-          first_arg = node.children[0]
-          param, _methods, _args = *first_arg
-          start = node.parent
+        def check_for_unused_proxy(block, proxy)
+          name, = *proxy
 
-          find_arg_usage(start) do |name|
-            return if param == name
+          find_arg_usage(block) do |usage|
+            return if usage.include?(s(:lvar, name))
           end
 
-          yield first_arg, param
-        end
-
-        def hook(node, &block)
-          scoped_hook(node, &block) || unscoped_hook(node, &block)
+          add_offense(proxy, :expression, format(MSG_UNUSED_ARG, arg: name))
         end
       end
     end

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

@@ -34,22 +34,18 @@ module RuboCop
       # coerce objects for comparison.
       #
       class BeEql < Cop
-        MSG = 'Prefer `be` over `eql`'.freeze
+        MSG = 'Prefer `be` over `eql`.'.freeze
 
         def_node_matcher :eql_type_with_identity, <<-PATTERN
           (send _ :to $(send nil :eql {true false int float sym nil_type?}))
         PATTERN
 
         def on_send(node)
-          eql_type_with_identity(node) do |eql|
-            add_offense(eql, :selector, MSG)
-          end
+          eql_type_with_identity(node) { |eql| add_offense(eql, :selector) }
         end
 
         def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.loc.selector, 'be')
-          end
+          ->(corrector) { corrector.replace(node.loc.selector, 'be') }
         end
       end
     end

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

@@ -24,25 +24,19 @@ module RuboCop
       #     after(:each) { Widget.delete_all }
       #   end
       class BeforeAfterAll < Cop
-        MESSAGE = 'Beware of using `before/after(:all)` as it may cause state '\
-          'to leak between tests. If you are using rspec-rails, and '\
-          '`use_transactional_fixtures` is enabled, then records created in '\
-          '`before(:all)` are not rolled back.'.freeze
+        MSG = 'Beware of using `%<hook>s` as it may cause state to leak '\
+              'between tests. If you are using `rspec-rails`, and '\
+              '`use_transactional_fixtures` is enabled, then records created '\
+              'in `%<hook>s` are not automatically rolled back.'.freeze
 
-        BEFORE_AFTER_METHODS = [
-          :before,
-          :after
-        ].freeze
-
-        ALL_PAIR = s(:sym, :all)
-        CONTEXT_PAIR = s(:sym, :context)
+        def_node_matcher :before_or_after_all, <<-PATTERN
+          $(send _ {:before :after} (sym {:all :context}))
+        PATTERN
 
         def on_send(node)
-          _receiver, method_name, *args = *node
-          return unless BEFORE_AFTER_METHODS.include?(method_name)
-          return unless args.include?(ALL_PAIR) || args.include?(CONTEXT_PAIR)
-
-          add_offense(node, :expression, MESSAGE)
+          before_or_after_all(node) do |hook|
+            add_offense(node, :expression, format(MSG, hook: hook.source))
+          end
         end
       end
     end

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

@@ -44,11 +44,15 @@ module RuboCop
         end
 
         def relevant_file?(file)
-          rspec_pattern =~ file && super
+          relevant_rubocop_rspec_file?(file) && super
         end
 
         private
 
+        def relevant_rubocop_rspec_file?(file)
+          rspec_pattern =~ file
+        end
+
         def rspec_pattern
           Regexp.union(rspec_pattern_config.map(&Regexp.public_method(:new)))
         end

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

@@ -23,20 +23,20 @@ module RuboCop
               'the class or module being tested.'.freeze
 
         def_node_matcher :valid_describe?, <<-PATTERN
-        {(send {(const nil :RSpec) nil} :describe const ...) (send nil :describe)}
+          {(send {(const nil :RSpec) nil} :describe const ...) (send nil :describe)}
         PATTERN
 
         def_node_matcher :describe_with_metadata, <<-PATTERN
-        (send {(const nil :RSpec) nil} :describe
-          !const
-          ...
-          (hash $...))
+          (send {(const nil :RSpec) nil} :describe
+            !const
+            ...
+            (hash $...))
         PATTERN
 
         def_node_matcher :rails_metadata?, <<-PATTERN
-        (pair
-          (sym :type)
-          (sym {:request :feature :routing :view}))
+          (pair
+            (sym :type)
+            (sym {:request :feature :routing :view}))
         PATTERN
 
         def_node_matcher :shared_group?, <<-PATTERN

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

@@ -20,15 +20,16 @@ module RuboCop
         include RuboCop::RSpec::TopLevelDescribe,
                 RuboCop::RSpec::Util
 
-        MESSAGE = 'The second argument to describe should be the method ' \
-                  "being tested. '#instance' or '.class'".freeze
-        METHOD_STRING_MATCHER = /^[\#\.].+/
+        MSG = 'The second argument to describe should be the method '\
+              "being tested. '#instance' or '.class'.".freeze
+
+        METHOD_STRING_MATCHER = /\A[\#\.].+/
 
         def on_top_level_describe(_node, (_, second_arg))
-          return unless second_arg && second_arg.type.equal?(:str)
+          return unless second_arg && second_arg.str_type?
           return if METHOD_STRING_MATCHER =~ one(second_arg.children)
 
-          add_offense(second_arg, :expression, MESSAGE)
+          add_offense(second_arg, :expression)
         end
       end
     end

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

@@ -34,10 +34,10 @@ module RuboCop
       #
       class DescribedClass < Cop
         include RuboCop::RSpec::TopLevelDescribe
-        include RuboCop::Cop::ConfigurableEnforcedStyle
+        include ConfigurableEnforcedStyle
 
         DESCRIBED_CLASS = 'described_class'.freeze
-        MSG             = 'Use `%s` instead of `%s`'.freeze
+        MSG             = 'Use `%s` instead of `%s`.'.freeze
 
         def_node_matcher :common_instance_exec_closure?, <<-PATTERN
           (block (send (const nil {:Class :Module}) :new ...) ...)

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

@@ -28,29 +28,26 @@ module RuboCop
       class ExampleLength < Cop
         include CodeLength
 
-        EXAMPLE_BLOCKS = RuboCop::RSpec::Language::Examples::ALL
+        MSG = 'Example has too many lines [%d/%d].'.freeze
 
         def on_block(node)
-          method, _args, _body = *node
-          _receiver, method_name, _object = *method
-          return unless EXAMPLE_BLOCKS.include?(method_name)
+          return unless example?(node)
 
           length = code_length(node)
 
           return unless length > max_length
+
           add_offense(node, :expression, message(length))
         end
 
         private
 
         def code_length(node)
-          lines = node.source.lines[1..-2]
-
-          lines.count { |line| !irrelevant_line(line) }
+          node.source.lines[1..-2].count { |line| !irrelevant_line(line) }
         end
 
         def message(length)
-          format('Example has too many lines. [%d/%d]', length, max_length)
+          format(MSG, length, max_length)
         end
       end
     end

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

@@ -3,7 +3,9 @@
 module RuboCop
   module Cop
     module RSpec
-      # Checks that example descriptions do not start with "should".
+      # Checks for common mistakes in example descriptions.
+      #
+      # This cop will correct docstrings that begin with 'should' and 'it'.
       #
       # @see http://betterspecs.org/#should
       #
@@ -18,42 +20,74 @@ module RuboCop
       #   # good
       #   it 'finds nothing' do
       #   end
+      #
+      # @example
+      #   # bad
+      #   it 'it does things' do
+      #   end
+      #
+      #   # good
+      #   it 'does things' do
+      #   end
       class ExampleWording < Cop
-        MSG = 'Do not use should when describing your tests.'.freeze
+        MSG_SHOULD = 'Do not use should when describing your tests.'.freeze
+        MSG_IT     = "Do not repeat 'it' when describing your tests.".freeze
 
-        def on_block(node) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength,Metrics/LineLength
-          method, = *node
-          _, method_name, *args = *method
+        SHOULD_PREFIX = 'should'.freeze
+        IT_PREFIX     = 'it '.freeze
 
-          return unless method_name.equal?(:it)
+        def_node_matcher(
+          :it_description,
+          '(block (send _ :it $(str $_) ...) ...)'
+        )
 
-          arguments = args.first.to_a
-          message = arguments.first.to_s
-          return unless message.downcase.start_with?('should')
+        def on_block(node)
+          it_description(node) do |description_node, message|
+            text = message.downcase
 
-          arg1 = args.first.loc.expression
-          message = Parser::Source::Range.new(arg1.source_buffer,
-                                              arg1.begin_pos + 1,
-                                              arg1.end_pos - 1)
-
-          add_offense(message, message)
+            if text.start_with?(SHOULD_PREFIX)
+              add_wording_offense(description_node, MSG_SHOULD)
+            elsif text.start_with?(IT_PREFIX)
+              add_wording_offense(description_node, MSG_IT)
+            end
+          end
         end
 
         def autocorrect(range)
           lambda do |corrector|
-            corrector.replace(
-              range,
-              RuboCop::RSpec::Wording.new(
-                range.source,
-                ignore: ignored_words,
-                replace: custom_transform
-              ).rewrite
-            )
+            corrector.replace(range, replacement_text(range))
           end
         end
 
         private
 
+        def add_wording_offense(node, message)
+          expr = node.loc.expression
+
+          docstring =
+            Parser::Source::Range.new(
+              expr.source_buffer,
+              expr.begin_pos + 1,
+              expr.end_pos - 1
+            )
+
+          add_offense(docstring, docstring, message)
+        end
+
+        def replacement_text(range)
+          text = range.source
+
+          if text.start_with?('should')
+            RuboCop::RSpec::Wording.new(
+              text,
+              ignore:  ignored_words,
+              replace: custom_transform
+            ).rewrite
+          elsif text.start_with?(IT_PREFIX)
+            text.sub(IT_PREFIX, '')
+          end
+        end
+
         def custom_transform
           cop_config.fetch('CustomTransform', {})
         end