rubocop-rspec 1.15.1 → 1.16.0

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks that right braces for adjacent single line lets are aligned.
+      #
+      # @example
+      #
+      #     # bad
+      #     let(:foobar) { blahblah }
+      #     let(:baz)    { bar }
+      #     let(:a)      { b }
+      #
+      #     # good
+      #     let(:foobar) { blahblah }
+      #     let(:baz)    { bar      }
+      #     let(:a)      { b        }
+      #
+      class AlignRightLetBrace < Cop
+        MSG = 'Align right let brace'.freeze
+
+        def self.autocorrect_incompatible_with
+          [Layout::ExtraSpacing]
+        end
+
+        def investigate(_)
+          token_aligner.offending_tokens.each do |let|
+            add_offense(let, :end)
+          end
+        end
+
+        def autocorrect(let)
+          lambda do |corrector|
+            corrector.insert_before(
+              let.loc.end,
+              token_aligner.indent_for(let)
+            )
+          end
+        end
+
+        private
+
+        def token_aligner
+          @token_aligner ||=
+            RuboCop::RSpec::AlignLetBrace.new(processed_source.ast, :end)
+        end
+      end
+    end
+  end
+end

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

@@ -21,7 +21,7 @@ module RuboCop
       #     end
       #   end
       class AnyInstance < Cop
-        MSG = 'Avoid stubbing using `%{method}`.'.freeze
+        MSG = 'Avoid stubbing using `%<method>s`.'.freeze
 
         def_node_matcher :disallowed_stub, <<-PATTERN
           (send _ ${:any_instance :allow_any_instance_of :expect_any_instance_of} ...)

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

@@ -5,9 +5,11 @@ module RuboCop
     # Clone of the the normal RuboCop::Cop::Cop class so we can rewrite
     # the inherited method without breaking functionality
     class WorkaroundCop
-      # Overwrite the cop inherited method to be a noop. Our RSpec::Cop
+      # Remove the cop inherited method to be a noop. Our RSpec::Cop
       # class will invoke the inherited hook instead
-      def self.inherited(*); end
+      class << self
+        remove_method :inherited
+      end
 
       # Special case `Module#<` so that the rspec support rubocop exports
       # is compatible with our subclass

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Do not use `expect` in hooks such as `before`.
+      #
+      # @example
+      #   # bad
+      #   before do
+      #     expect(something).to eq 'foo'
+      #   end
+      #
+      #   # bad
+      #   after do
+      #     expect_any_instance_of(Something).to receive(:foo)
+      #   end
+      #
+      #   # good
+      #   it do
+      #     expect(something).to eq 'foo'
+      #   end
+      class ExpectInHook < Cop
+        MSG = 'Do not use `%<expect>s` in `%<hook>s` hook'.freeze
+        HOOKS = Hooks::ALL.node_pattern_union.freeze
+
+        def_node_matcher :hook, <<-PATTERN
+          (block (send _ $#{HOOKS} ...) _ $!nil)
+        PATTERN
+
+        def_node_search :expect, <<-PATTERN
+          {
+            #{Expectations::ALL.send_pattern}
+            #{Expectations::ALL.block_pattern}
+          }
+        PATTERN
+
+        def on_block(node)
+          hook(node) do |hook_name, body|
+            expect(body) do |expect|
+              method = send_node(expect)
+              add_offense(method, :selector,
+                          message(method, hook_name))
+            end
+          end
+        end
+
+        private
+
+        def message(expect, hook)
+          format(MSG, expect: expect.method_name, hook: hook)
+        end
+
+        def send_node(node)
+          return node if node.send_type?
+          node.children.first
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      module FactoryGirl
+        # Prefer declaring dynamic attribute values in a block.
+        #
+        # @example
+        #   # bad
+        #   kind [:active, :rejected].sample
+        #
+        #   # good
+        #   kind { [:active, :rejected].sample }
+        #
+        #   # bad
+        #   closed_at 1.day.from_now
+        #
+        #   # good
+        #   closed_at { 1.day.from_now }
+        #
+        #   # good
+        #   kind :static
+        #
+        #   # good
+        #   comments_count 0
+        #
+        #   # good
+        #   type User::MAGIC
+        class DynamicAttributeDefinedStatically < Cop
+          MSG = 'Use a block to set a dynamic value to an attribute.'.freeze
+
+          def_node_matcher :dynamic_defined_statically?, <<-PATTERN
+          (send nil _ (send ... ))
+          PATTERN
+
+          def_node_search :factory_attributes, <<-PATTERN
+          (block (send nil {:factory :trait} ...) _ { (begin $...) $(send ...) } )
+          PATTERN
+
+          def on_block(node)
+            return if node.method_name == :trait
+            factory_attributes(node).to_a.flatten.each do |attribute|
+              if dynamic_defined_statically?(attribute)
+                add_offense(attribute, :expression)
+              end
+            end
+          end
+
+          def autocorrect(node)
+            if method_uses_parens?(node.location)
+              autocorrect_replacing_parens(node)
+            else
+              autocorrect_without_parens(node)
+            end
+          end
+
+          private
+
+          def method_uses_parens?(location)
+            return false unless location.begin && location.end
+            location.begin.source == '(' && location.end.source == ')'
+          end
+
+          def autocorrect_replacing_parens(node)
+            lambda do |corrector|
+              corrector.replace(node.location.begin, ' { ')
+              corrector.replace(node.location.end, ' }')
+            end
+          end
+
+          def autocorrect_without_parens(node)
+            lambda do |corrector|
+              arguments = node.descendants.first
+              expression = arguments.location.expression
+              corrector.insert_before(expression, '{ ')
+              corrector.insert_after(expression, ' }')
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -66,10 +66,10 @@ module RuboCop
         HOOKS = Hooks::ALL.node_pattern_union.freeze
 
         def_node_matcher :scoped_hook, <<-PATTERN
-          (block $(send nil #{HOOKS} (sym ${:each :example})) ...)
+          (block $(send _ #{HOOKS} (sym ${:each :example})) ...)
         PATTERN
 
-        def_node_matcher :unscoped_hook, "(block $(send nil #{HOOKS}) ...)"
+        def_node_matcher :unscoped_hook, "(block $(send _ #{HOOKS}) ...)"
 
         def on_block(node)
           hook(node) do |method_send, scope_name|
@@ -82,11 +82,10 @@ module RuboCop
         end
 
         def autocorrect(node)
-          scope = "(#{style.inspect})" unless implicit_style?
-          hook  = "#{node.method_name}#{scope}"
+          scope = implicit_style? ? '' : "(#{style.inspect})"
 
           lambda do |corrector|
-            corrector.replace(node.loc.expression, hook)
+            corrector.replace(argument_range(node), scope)
           end
         end
 
@@ -114,6 +113,13 @@ module RuboCop
         def hook(node, &block)
           scoped_hook(node, &block) || unscoped_hook(node, &block)
         end
+
+        def argument_range(send_node)
+          range_between(
+            send_node.loc.selector.end_pos,
+            send_node.loc.expression.end_pos
+          )
+        end
       end
     end
   end

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

@@ -0,0 +1,42 @@
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks invalid usage for predicate matcher.
+      #
+      # Predicate matcher does not need a question.
+      # This cop checks an unnecessary question in predicate matcher.
+      #
+      # @example
+      #
+      #   # bad
+      #   expect(foo).to be_something?
+      #
+      #   # good
+      #   expect(foo).to be_something
+      class InvalidPredicateMatcher < Cop
+        MSG = 'Omit `?` from `%<matcher>s`.'.freeze
+
+        def_node_matcher :invalid_predicate_matcher?, <<-PATTERN
+          (send (send nil :expect ...) {:to :not_to :to_not} $(send nil #predicate?))
+        PATTERN
+
+        def on_send(node)
+          invalid_predicate_matcher?(node) do |predicate|
+            add_offense(predicate, :expression)
+          end
+        end
+
+        private
+
+        def predicate?(name)
+          name = name.to_s
+          name.start_with?('be_', 'have_') && name.end_with?('?')
+        end
+
+        def message(predicate)
+          format(MSG, matcher: predicate.method_name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for `let` definitions that come after an example.
+      #
+      # @example
+      #   # Bad
+      #   let(:foo) { bar }
+      #
+      #   it 'checks what foo does' do
+      #     expect(foo).to be
+      #   end
+      #
+      #   let(:some) { other }
+      #
+      #   it 'checks what some does' do
+      #     expect(some).to be
+      #   end
+      #
+      #   # Good
+      #   let(:foo) { bar }
+      #   let(:some) { other }
+      #
+      #   it 'checks what foo does' do
+      #     expect(foo).to be
+      #   end
+      #
+      #   it 'checks what some does' do
+      #     expect(some).to be
+      #   end
+      class LetBeforeExamples < Cop
+        MSG = 'Move `let` before the examples in the group.'.freeze
+
+        def_node_matcher :let?, '(block (send nil {:let :let!} ...) ...)'
+        def_node_matcher :example_or_group?, <<-PATTERN
+          {
+            #{(Examples::ALL + ExampleGroups::ALL).block_pattern}
+            #{Includes::EXAMPLES.send_pattern}
+          }
+        PATTERN
+
+        def on_block(node)
+          return unless example_group_with_body?(node)
+
+          _describe, _args, body = *node
+
+          check_let_declarations(body)
+        end
+
+        def check_let_declarations(node)
+          example_found = false
+
+          node.each_child_node do |child|
+            if let?(child)
+              add_offense(child, :expression) if example_found
+            elsif example_or_group?(child)
+              example_found = true
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -48,14 +48,14 @@ module RuboCop
       class MultipleExpectations < Cop
         include ConfigurableMax
 
-        MSG = 'Example has too many expectations [%{total}/%{max}].'.freeze
+        MSG = 'Example has too many expectations [%<total>d/%<max>d].'.freeze
 
         def_node_search :with_aggregated_failures?, '(sym :aggregate_failures)'
         def_node_search :disabled_aggregated_failures?, <<-PATTERN
           (pair (sym :aggregate_failures) (false))
         PATTERN
 
-        def_node_matcher :expect?, '(send _ :expect ...)'
+        def_node_matcher :expect?, Expectations::ALL.send_pattern
         def_node_matcher :aggregate_failures?, <<-PATTERN
           (block (send _ :aggregate_failures ...) ...)
         PATTERN
@@ -84,14 +84,12 @@ module RuboCop
         end
 
         def find_expectation(node, &block)
-          return unless node.is_a?(Parser::AST::Node)
-
           yield if expect?(node) || aggregate_failures?(node)
 
           # do not search inside of aggregate_failures block
           return if aggregate_failures?(node)
 
-          node.children.each do |child|
+          node.each_child_node do |child|
             find_expectation(child, &block)
           end
         end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks if an example group defines `subject` multiple times.
+      #
+      # @example
+      #
+      #   # bad
+      #   describe Foo do
+      #     subject(:user) { User.new }
+      #     subject(:post) { Post.new }
+      #   end
+      #
+      #   # good
+      #   describe Foo do
+      #     let(:user) { User.new }
+      #     subject(:post) { Post.new }
+      #   end
+      #
+      # The autocorrect behavior for this cop depends on the type of
+      # duplication:
+      #
+      #   - If multiple named subjects are defined then this probably indicates
+      #     that the overwritten subjects (all subjects except the last
+      #     definition) are effectively being used to define helpers. In this
+      #     case they are replaced with `let`.
+      #
+      #   - If multiple unnamed subjects are defined though then this can *only*
+      #     be dead code and we remove the overwritten subject definitions.
+      #
+      #   - If subjects are defined with `subject!` then we don't autocorrect.
+      #     This is enough of an edge case that people can just move this to
+      #     a `before` hook on their own
+      class MultipleSubjects < Cop
+        MSG = 'Do not set more than one subject per example group'.freeze
+
+        def_node_matcher :named_subject?, <<-PATTERN
+          (block (send nil :subject $sym) args ...)
+        PATTERN
+
+        def on_block(node)
+          return unless example_group?(node)
+
+          subjects = RuboCop::RSpec::ExampleGroup.new(node).subjects
+
+          subjects[0...-1].each do |subject|
+            add_offense(subject, :expression)
+          end
+        end
+
+        def autocorrect(node)
+          return unless node.method_name.equal?(:subject) # Ignore `subject!`
+
+          if named_subject?(node)
+            rename_autocorrect(node)
+          else
+            remove_autocorrect(node)
+          end
+        end
+
+        private
+
+        def rename_autocorrect(node)
+          lambda do |corrector|
+            send_node, _args, _body = *node
+            corrector.replace(send_node.loc.selector, 'let')
+          end
+        end
+
+        def remove_autocorrect(node)
+          lambda do |corrector|
+            corrector.remove(node.loc.expression)
+          end
+        end
+      end
+    end
+  end
+end