rubocop-rspec 1.10.0 → 1.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: afa52f47ad386fe20a2a338ff9da7c6a032c385b
-  data.tar.gz: 07143368c4d5e201d12bfba8379e5c2c79bcba99
+  metadata.gz: fda044631502561746af13188e9d7217ef83f8fb
+  data.tar.gz: d021f893b44704291ff69433019a9798b50fe82e
 SHA512:
-  metadata.gz: 89dfa9c530533694d03d670112ae870f9ba626875bcff32bb9ab4c708f393e99e1e4eb5562adb5ad2e8231c5366594fabbd431a8ec758ec856491fa747f84b66
-  data.tar.gz: 9517b60ae000d18800f11bb8e579d5889883eff511975ce4ff77a56e72cc0450e9f998b93694c3c90d9e47c9546aebb0fe8296fdbcfa4048e16cfddfc7fda5b1
+  metadata.gz: 8d804e069e562fa9af39669b2f39b6d8fa81e1ce4778bba2dfbf999dd1afc583475e1bd3d296e1ce79cf40bf04ad42d09468d9b4b0eb6dd10fced565e7e970b3
+  data.tar.gz: 8d14f57b6eb8437b68a7f92acea42a687a7515e1793da6d11485e3c97140571b6741697fad84e6763be1f31fad1d897b88e8dd5131d0286e92fe05cd4c77717a

data/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## Master (unreleased)
 
+## 1.11.0 (2017-02-16)
+
+* Add `AroundBlock` cop. ([@Darhazer][])
+* Add `EnforcedStyle` configuration for `RSpec/DescribedClass` cop. ([@Darhazer][])
+* Fix false positive for `RSpec/RepeatedExample` cop. ([@redross][])
+
 ## 1.10.0 (2017-01-15)
 
 * Fix false negative for `RSpec/MessageSpies` cop. ([@onk][])
@@ -172,3 +178,5 @@
 [@jeffreyc]: https://github.com/jeffreyc
 [@clupprich]: https://github.com/clupprich
 [@onk]: https://github.com/onk
+[@Darhazer]: https://github.com/Darhazer
+[@redross]: https://github.com/redross

data/config/default.yml

@@ -9,6 +9,10 @@ RSpec/AnyInstance:
   Description: Check that instances are not being stubbed globally.
   Enabled: true
 
+RSpec/AroundBlock:
+  Description: Checks that around blocks actually run the test.
+  Enabled: true
+
 RSpec/BeEql:
   Description: Check for expectations where `be(...)` can replace `eql(...)`.
   Enabled: true
@@ -21,6 +25,10 @@ RSpec/DescribedClass:
   Description: Checks that tests use `described_class`.
   SkipBlocks: false
   Enabled: true
+  EnforcedStyle: described_class
+  SupportedStyles:
+  - described_class
+  - explicit
 
 RSpec/DescribeMethod:
   Description: Checks that the second argument to `describe` specifies a method.

data/lib/rubocop-rspec.rb

@@ -21,6 +21,7 @@ RuboCop::RSpec::Inject.defaults!
 
 # cops
 require 'rubocop/cop/rspec/any_instance'
+require 'rubocop/cop/rspec/around_block'
 require 'rubocop/cop/rspec/be_eql'
 require 'rubocop/cop/rspec/describe_class'
 require 'rubocop/cop/rspec/describe_method'

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

@@ -0,0 +1,78 @@
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks that around blocks actually run the test.
+      #
+      # @example
+      #   # bad
+      #   around do
+      #     some_method
+      #   end
+      #
+      #   around do |test|
+      #     some_method
+      #   end
+      #
+      #   # good
+      #   around do |test|
+      #     some_method
+      #     test.call
+      #   end
+      #
+      #   around do |test|
+      #     some_method
+      #     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
+
+        def_node_matcher :scoped_hook, <<-PATTERN
+        (block (send nil :around (sym {:each :example})) $(args ...) ...)
+        PATTERN
+
+        def_node_matcher :unscoped_hook, <<-PATTERN
+        (block (send nil :around) $(args ...) ...)
+        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))
+            end
+          end
+        end
+
+        private
+
+        def missing_parameters(node)
+          yield if node.children[0].nil?
+        end
+
+        def unused_parameters(node)
+          first_arg = node.children[0]
+          param, _methods, _args = *first_arg
+          start = node.parent
+
+          find_arg_usage(start) do |name|
+            return if param == name
+          end
+
+          yield first_arg, param
+        end
+
+        def hook(node, &block)
+          scoped_hook(node, &block) || unscoped_hook(node, &block)
+        end
+      end
+    end
+  end
+end

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

@@ -34,8 +34,6 @@ module RuboCop
       # coerce objects for comparison.
       #
       class BeEql < Cop
-        include RuboCop::Cop::ConfigurableEnforcedStyle
-
         MSG = 'Prefer `be` over `eql`'.freeze
 
         def_node_matcher :eql_type_with_identity, <<-PATTERN

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

@@ -6,10 +6,11 @@ module RuboCop
       # Checks that tests use `described_class`.
       #
       # If the first argument of describe is a class, the class is exposed to
-      # each example via described_class - this should be used instead of
-      # repeating the class.
+      # each example via described_class.
       #
-      # @example
+      # This cop can be configured using the `EnforcedStyle` option
+      #
+      # @example `EnforcedStyle: described_class`
       #   # bad
       #   describe MyClass do
       #     subject { MyClass.do_something }
@@ -19,11 +20,24 @@ module RuboCop
       #   describe MyClass do
       #     subject { described_class.do_something }
       #   end
+      #
+      # @example `EnforcedStyle: explicit`
+      #   # bad
+      #   describe MyClass do
+      #     subject { described_class.do_something }
+      #   end
+      #
+      #   # good
+      #   describe MyClass do
+      #     subject { MyClass.do_something }
+      #   end
+      #
       class DescribedClass < Cop
         include RuboCop::RSpec::TopLevelDescribe
+        include RuboCop::Cop::ConfigurableEnforcedStyle
 
         DESCRIBED_CLASS = 'described_class'.freeze
-        MSG             = "Use `#{DESCRIBED_CLASS}` 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 ...) ...)
@@ -38,27 +52,44 @@ module RuboCop
           describe, described_class, body = described_constant(node)
           return unless top_level_describe?(describe)
 
-          find_constant_usage(body, described_class) do |match|
-            add_offense(match, :expression, format(MSG, match.const_name))
+          # in case we explicit style is used, this cop needs to remember what's
+          # being described, so to replace described_class with the constant
+          @described_class = described_class
+
+          find_usage(body) do |match|
+            add_offense(match, :expression, message(match.const_name))
           end
         end
 
         def autocorrect(node)
+          replacement = if style == :described_class
+                          DESCRIBED_CLASS
+                        else
+                          @described_class.const_name
+                        end
           lambda do |corrector|
-            corrector.replace(node.loc.expression, DESCRIBED_CLASS)
+            corrector.replace(node.loc.expression, replacement)
           end
         end
 
         private
 
-        def find_constant_usage(node, described_class, &block)
-          yield(node) if node.eql?(described_class)
+        def find_usage(node, &block)
+          yield(node) if offensive?(node)
 
           return unless node.is_a?(Parser::AST::Node)
           return if scope_change?(node) || node.const_type?
 
           node.children.each do |child|
-            find_constant_usage(child, described_class, &block)
+            find_usage(child, &block)
+          end
+        end
+
+        def message(offense)
+          if style == :described_class
+            format(MSG, DESCRIBED_CLASS, offense)
+          else
+            format(MSG, @described_class.const_name, DESCRIBED_CLASS)
           end
         end
 
@@ -75,6 +106,15 @@ module RuboCop
         def skip_blocks?
           cop_config['SkipBlocks'].equal?(true)
         end
+
+        def offensive?(node)
+          if style == :described_class
+            node.eql?(@described_class)
+          else
+            _receiver, method_name, *_args = *node
+            method_name == :described_class
+          end
+        end
       end
     end
   end

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

@@ -29,12 +29,22 @@ module RuboCop
         def repeated_examples(node)
           RuboCop::RSpec::ExampleGroup.new(node)
             .examples
-            .group_by { |example| [example.metadata, example.implementation] }
+            .group_by { |example| example_signature(example) }
             .values
             .reject(&:one?)
             .flatten
             .map(&:to_node)
         end
+
+        def example_signature(example)
+          key_parts = [example.metadata, example.implementation]
+
+          if example.definition.method_name == :its
+            key_parts << example.definition.method_args
+          end
+
+          key_parts
+        end
       end
     end
   end

data/lib/rubocop/rspec/version.rb

@@ -4,7 +4,7 @@ module RuboCop
   module RSpec
     # Version information for the RSpec RuboCop plugin.
     module Version
-      STRING = '1.10.0'.freeze
+      STRING = '1.11.0'.freeze
     end
   end
 end

data/spec/rubocop/cop/rspec/around_block_spec.rb

@@ -0,0 +1,30 @@
+describe RuboCop::Cop::RSpec::AroundBlock do
+  subject(:cop) { described_class.new }
+
+  it 'finds `around` block without block arguments' do
+    expect_violation(<<-RUBY)
+      around do
+      ^^^^^^^^^ Test object should be passed to around block
+        do_something
+      end
+    RUBY
+  end
+
+  it 'finds `around` block with unused argument' do
+    expect_violation(<<-RUBY)
+      around do |test|
+                 ^^^^ You should call `test.call` or `test.run`
+        do_something
+      end
+    RUBY
+  end
+
+  it 'checks the first argument of the block' do
+    expect_violation(<<-RUBY)
+      around do |test, unused|
+                 ^^^^ You should call `test.call` or `test.run`
+        unused.run
+      end
+    RUBY
+  end
+end

data/spec/rubocop/cop/rspec/described_class_spec.rb

@@ -1,6 +1,10 @@
 describe RuboCop::Cop::RSpec::DescribedClass, :config do
   subject(:cop) { described_class.new(config) }
 
+  let(:cop_config) do
+    { 'EnforcedStyle' => enforced_style }
+  end
+
   shared_examples 'SkipBlocks enabled' do
     it 'does not flag violations within non-rspec blocks' do
       expect_violation(<<-RUBY)
@@ -69,141 +73,225 @@ describe RuboCop::Cop::RSpec::DescribedClass, :config do
     include_examples 'SkipBlocks disabled'
   end
 
-  it 'checks for the use of the described class' do
-    expect_violation(<<-RUBY)
-      describe MyClass do
-        include MyClass
-                ^^^^^^^ Use `described_class` instead of `MyClass`
+  context 'when EnforcedStyle is :described_class' do
+    let(:enforced_style) { :described_class }
 
-        subject { MyClass.do_something }
+    it 'checks for the use of the described class' do
+      expect_violation(<<-RUBY)
+        describe MyClass do
+          include MyClass
                   ^^^^^^^ Use `described_class` instead of `MyClass`
 
-        before { MyClass.do_something }
-                 ^^^^^^^ Use `described_class` instead of `MyClass`
-      end
-    RUBY
-  end
+          subject { MyClass.do_something }
+                    ^^^^^^^ Use `described_class` instead of `MyClass`
 
-  it 'ignores described class as string' do
-    expect_no_violations(<<-RUBY)
-      describe MyClass do
-        subject { "MyClass" }
-      end
-    RUBY
-  end
-
-  it 'ignores describe that do not reference to a class' do
-    expect_no_violations(<<-RUBY)
-      describe "MyClass" do
-        subject { "MyClass" }
-      end
-    RUBY
-  end
+          before { MyClass.do_something }
+                   ^^^^^^^ Use `described_class` instead of `MyClass`
+        end
+      RUBY
+    end
 
-  it 'ignores class if the scope is changing' do
-    expect_no_violations(<<-RUBY)
-      describe MyClass do
-        Class.new  { foo = MyClass }
-        Module.new { bar = MyClass }
+    it 'ignores described class as string' do
+      expect_no_violations(<<-RUBY)
+        describe MyClass do
+          subject { "MyClass" }
+        end
+      RUBY
+    end
 
-        def method
-          include MyClass
+    it 'ignores describe that do not reference to a class' do
+      expect_no_violations(<<-RUBY)
+        describe "MyClass" do
+          subject { "MyClass" }
         end
+      RUBY
+    end
 
-        class OtherClass
-          include MyClass
+    it 'ignores class if the scope is changing' do
+      expect_no_violations(<<-RUBY)
+        describe MyClass do
+          Class.new  { foo = MyClass }
+          Module.new { bar = MyClass }
+
+          def method
+            include MyClass
+          end
+
+          class OtherClass
+            include MyClass
+          end
+
+          module MyModle
+            include MyClass
+          end
         end
+      RUBY
+    end
 
-        module MyModle
-          include MyClass
+    it 'only takes class from top level describes' do
+      expect_violation(<<-RUBY)
+        describe MyClass do
+          describe MyClass::Foo do
+            subject { MyClass::Foo }
+
+            let(:foo) { MyClass }
+                        ^^^^^^^ Use `described_class` instead of `MyClass`
+          end
         end
-      end
-    RUBY
-  end
+      RUBY
+    end
 
-  it 'only takes class from top level describes' do
-    expect_violation(<<-RUBY)
-      describe MyClass do
-        describe MyClass::Foo do
-          subject { MyClass::Foo }
+    it 'ignores subclasses' do
+      expect_no_violations(<<-RUBY)
+        describe MyClass do
+          subject { MyClass::SubClass }
+        end
+      RUBY
+    end
 
+    it 'ignores if namespace is not matching' do
+      expect_no_violations(<<-RUBY)
+        describe MyNamespace::MyClass do
+          subject { ::MyClass }
           let(:foo) { MyClass }
-                      ^^^^^^^ Use `described_class` instead of `MyClass`
         end
-      end
-    RUBY
-  end
-
-  it 'ignores subclasses' do
-    expect_no_violations(<<-RUBY)
-      describe MyClass do
-        subject { MyClass::SubClass }
-      end
-    RUBY
-  end
+      RUBY
+    end
 
-  it 'ignores if namespace is not matching' do
-    expect_no_violations(<<-RUBY)
-      describe MyNamespace::MyClass do
-        subject { ::MyClass }
-        let(:foo) { MyClass }
-      end
-    RUBY
-  end
+    it 'checks for the use of described class with namespace' do
+      expect_violation(<<-RUBY)
+        describe MyNamespace::MyClass do
+          subject { MyNamespace::MyClass }
+                    ^^^^^^^^^^^^^^^^^^^^ Use `described_class` instead of `MyNamespace::MyClass`
+        end
+      RUBY
+    end
 
-  it 'checks for the use of described class with namespace' do
-    expect_violation(<<-RUBY)
-      describe MyNamespace::MyClass do
-        subject { MyNamespace::MyClass }
-                  ^^^^^^^^^^^^^^^^^^^^ Use `described_class` instead of `MyNamespace::MyClass`
-      end
-    RUBY
-  end
+    it 'does not flag violations within a class scope change' do
+      expect_no_violations(<<-RUBY)
+        describe MyNamespace::MyClass do
+          before do
+            class Foo
+              thing = MyNamespace::MyClass.new
+            end
+          end
+        end
+      RUBY
+    end
 
-  it 'does not flag violations within a class scope change' do
-    expect_no_violations(<<-RUBY)
-      describe MyNamespace::MyClass do
-        before do
-          class Foo
-            thing = MyNamespace::MyClass.new
+    it 'does not flag violations within a hook scope change' do
+      expect_no_violations(<<-RUBY)
+        describe do
+          before do
+            MyNamespace::MyClass.new
           end
         end
-      end
-    RUBY
-  end
+      RUBY
+    end
+
+    it 'checks for the use of described class with module' do
+      skip
 
-  it 'does not flag violations within a hook scope change' do
-    expect_no_violations(<<-RUBY)
-      describe do
-        before do
-          MyNamespace::MyClass.new
+      expect_violation(<<-RUBY)
+        module MyNamespace
+          describe MyClass do
+            subject { MyNamespace::MyClass }
+                      ^^^^^^^^^^^^^^^^^^^^ Use `described_class` instead of `MyNamespace::MyClass`
+          end
         end
-      end
-    RUBY
+      RUBY
+    end
+
+    include_examples 'autocorrect',
+                     'describe(Foo) { include Foo }',
+                     'describe(Foo) { include described_class }'
+
+    include_examples 'autocorrect',
+                     'describe(Foo) { subject { Foo.do_action } }',
+                     'describe(Foo) { subject { described_class.do_action } }'
+
+    include_examples 'autocorrect',
+                     'describe(Foo) { before { Foo.do_action } }',
+                     'describe(Foo) { before { described_class.do_action } }'
   end
 
-  it 'checks for the use of described class with module' do
-    skip
+  context 'when EnforcedStyle is :explicit' do
+    let(:enforced_style) { :explicit }
 
-    expect_violation(<<-RUBY)
-      module MyNamespace
+    it 'checks for the use of the described_class' do
+      expect_violation(<<-RUBY)
         describe MyClass do
-          subject { MyNamespace::MyClass }
-                    ^^^^^^^^^^^^^^^^^^^^ Use `described_class` instead of `MyNamespace::MyClass`
+          include described_class
+                  ^^^^^^^^^^^^^^^ Use `MyClass` instead of `described_class`
+
+          subject { described_class.do_something }
+                    ^^^^^^^^^^^^^^^ Use `MyClass` instead of `described_class`
+
+          before { described_class.do_something }
+                   ^^^^^^^^^^^^^^^ Use `MyClass` instead of `described_class`
         end
-      end
-    RUBY
-  end
+      RUBY
+    end
 
-  include_examples 'autocorrect',
-                   'describe(Foo) { include Foo }',
-                   'describe(Foo) { include described_class }'
+    it 'ignores described_class as string' do
+      expect_no_violations(<<-RUBY)
+        describe MyClass do
+          subject { "described_class" }
+        end
+      RUBY
+    end
 
-  include_examples 'autocorrect',
-                   'describe(Foo) { subject { Foo.do_something } }',
-                   'describe(Foo) { subject { described_class.do_something } }'
+    it 'ignores describe that do not reference to a class' do
+      expect_no_violations(<<-RUBY)
+        describe "MyClass" do
+          subject { described_class }
+        end
+      RUBY
+    end
 
-  include_examples 'autocorrect',
-                   'describe(Foo) { before { Foo.do_something } }',
-                   'describe(Foo) { before { described_class.do_something } }'
+    it 'does not flag violations within a class scope change' do
+      expect_no_violations(<<-RUBY)
+        describe MyNamespace::MyClass do
+          before do
+            class Foo
+              thing = described_class.new
+            end
+          end
+        end
+      RUBY
+    end
+
+    it 'does not flag violations within a hook scope change' do
+      expect_no_violations(<<-RUBY)
+        describe do
+          before do
+            described_class.new
+          end
+        end
+      RUBY
+    end
+
+    include_examples 'autocorrect',
+                     'describe(Foo) { include described_class }',
+                     'describe(Foo) { include Foo }'
+
+    include_examples 'autocorrect',
+                     'describe(Foo) { subject { described_class.do_action } }',
+                     'describe(Foo) { subject { Foo.do_action } }'
+
+    include_examples 'autocorrect',
+                     'describe(Foo) { before { described_class.do_action } }',
+                     'describe(Foo) { before { Foo.do_action } }'
+
+    original = <<-RUBY
+      describe(Foo) { include described_class }
+      describe(Bar) { include described_class }
+    RUBY
+    corrected = <<-RUBY
+      describe(Foo) { include Foo }
+      describe(Bar) { include Bar }
+    RUBY
+
+    include_examples 'autocorrect', original, corrected
+  end
 end

data/spec/rubocop/cop/rspec/repeated_example_spec.rb

@@ -47,6 +47,15 @@ describe RuboCop::Cop::RSpec::RepeatedExample do
     RUBY
   end
 
+  it 'does not flag examples when different its arguments are used' do
+    expect_no_violations(<<-RUBY)
+      describe 'doing x' do
+        its(:x) { is_expected.to be_present }
+        its(:y) { is_expected.to be_present }
+      end
+    RUBY
+  end
+
   it 'does not flag repeated examples in different scopes' do
     expect_no_violations(<<-RUBY)
       describe 'doing x' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-rspec
 version: !ruby/object:Gem::Version
-  version: 1.10.0
+  version: 1.11.0
 platform: ruby
 authors:
 - John Backus
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-16 00:00:00.000000000 Z
+date: 2017-02-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -145,6 +145,7 @@ files:
 - config/default.yml
 - lib/rubocop-rspec.rb
 - lib/rubocop/cop/rspec/any_instance.rb
+- lib/rubocop/cop/rspec/around_block.rb
 - lib/rubocop/cop/rspec/be_eql.rb
 - lib/rubocop/cop/rspec/cop.rb
 - lib/rubocop/cop/rspec/describe_class.rb
@@ -196,6 +197,7 @@ files:
 - spec/project/default_config_spec.rb
 - spec/project/project_requires_spec.rb
 - spec/rubocop/cop/rspec/any_instance_spec.rb
+- spec/rubocop/cop/rspec/around_block_spec.rb
 - spec/rubocop/cop/rspec/be_eql_spec.rb
 - spec/rubocop/cop/rspec/cop_spec.rb
 - spec/rubocop/cop/rspec/describe_class_spec.rb
@@ -269,6 +271,7 @@ test_files:
 - spec/project/default_config_spec.rb
 - spec/project/project_requires_spec.rb
 - spec/rubocop/cop/rspec/any_instance_spec.rb
+- spec/rubocop/cop/rspec/around_block_spec.rb
 - spec/rubocop/cop/rspec/be_eql_spec.rb
 - spec/rubocop/cop/rspec/cop_spec.rb
 - spec/rubocop/cop/rspec/describe_class_spec.rb