rubocop-rspec 1.7.0 → 3.0.2

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

@@ -6,10 +6,14 @@ 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`, `SkipBlocks`
+      # and `OnlyStaticConstants` options.
+      # `OnlyStaticConstants` is only relevant when `EnforcedStyle` is
+      # `described_class`.
+      #
+      # @example `EnforcedStyle: described_class` (default)
       #   # bad
       #   describe MyClass do
       #     subject { MyClass.do_something }
@@ -19,64 +23,207 @@ module RuboCop
       #   describe MyClass do
       #     subject { described_class.do_something }
       #   end
-      class DescribedClass < Cop
-        include RuboCop::RSpec::SpecOnly, RuboCop::RSpec::TopLevelDescribe
-
-        DESCRIBED_CLASS = 'described_class'.freeze
-        MSG             = "Use `#{DESCRIBED_CLASS}` instead of `%s`".freeze
+      #
+      # @example `OnlyStaticConstants: true` (default)
+      #   # good
+      #   describe MyClass do
+      #     subject { MyClass::CONSTANT }
+      #   end
+      #
+      # @example `OnlyStaticConstants: false`
+      #   # bad
+      #   describe MyClass do
+      #     subject { MyClass::CONSTANT }
+      #   end
+      #
+      # @example `EnforcedStyle: explicit`
+      #   # bad
+      #   describe MyClass do
+      #     subject { described_class.do_something }
+      #   end
+      #
+      #   # good
+      #   describe MyClass do
+      #     subject { MyClass.do_something }
+      #   end
+      #
+      # There's a known caveat with rspec-rails's `controller` helper that
+      # runs its block in a different context, and `described_class` is not
+      # available to it. `SkipBlocks` option excludes detection in all
+      # non-RSpec related blocks.
+      #
+      # To narrow down this setting to only a specific directory, it is
+      # possible to use an overriding configuration file local to that
+      # directory.
+      #
+      # @example `SkipBlocks: true`
+      #   # spec/controllers/.rubocop.yml
+      #   # RSpec/DescribedClass:
+      #   #   SkipBlocks: true
+      #
+      #   # acceptable
+      #   describe MyConcern do
+      #     controller(ApplicationController) do
+      #       include MyConcern
+      #     end
+      #   end
+      #
+      class DescribedClass < Base # rubocop:disable Metrics/ClassLength
+        extend AutoCorrector
+        include ConfigurableEnforcedStyle
+        include Namespace
 
-        RSPEC_BLOCK_METHODS = RuboCop::RSpec::Language::ALL.to_node_pattern
+        DESCRIBED_CLASS = 'described_class'
+        MSG             = 'Use `%<replacement>s` instead of `%<src>s`.'
 
-        def_node_matcher :common_instance_exec_closure?, <<-PATTERN
-          (block (send (const nil {:Class :Module}) :new ...) ...)
+        # @!method common_instance_exec_closure?(node)
+        def_node_matcher :common_instance_exec_closure?, <<~PATTERN
+          (block (send (const nil? {:Class :Module :Struct}) :new ...) ...)
         PATTERN
 
-        def_node_matcher :rspec_block?, <<-PATTERN
-          (block (send nil {#{RSPEC_BLOCK_METHODS}} ...) ...)
-        PATTERN
+        # @!method rspec_block?(node)
+        def_node_matcher :rspec_block?,
+                         '({block numblock} (send #rspec? #ALL.all ...) ...)'
 
+        # @!method scope_changing_syntax?(node)
         def_node_matcher :scope_changing_syntax?, '{def class module}'
 
-        def on_block(node)
-          describe, described_class, body = described_constant(node)
-          return unless top_level_describe?(describe)
+        # @!method described_constant(node)
+        def_node_matcher :described_constant, <<~PATTERN
+          (block (send _ :describe $(const ...) ...) (args) $_)
+        PATTERN
+
+        # @!method contains_described_class?(node)
+        def_node_search :contains_described_class?,
+                        '(send nil? :described_class)'
 
-          find_constant_usage(body, described_class) do |match|
-            add_offense(match, :expression, format(MSG, match.const_name))
-          end
-        end
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          # In case the explicit style is used, we need to remember what's
+          # being described.
+          @described_class, body = described_constant(node)
+
+          return unless body
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.loc.expression, DESCRIBED_CLASS)
+          find_usage(body) do |match|
+            msg = message(match.const_name)
+            add_offense(match, message: msg) do |corrector|
+              autocorrect(corrector, match)
+            end
           end
         end
 
         private
 
-        def find_constant_usage(node, described_class, &block)
-          yield(node) if node.eql?(described_class)
+        def autocorrect(corrector, match)
+          replacement = if style == :described_class
+                          DESCRIBED_CLASS
+                        else
+                          @described_class.const_name
+                        end
+
+          corrector.replace(match, replacement)
+        end
+
+        def find_usage(node, &block)
+          yield(node) if offensive?(node)
+          return if scope_change?(node) || allowed?(node)
 
-          return unless node.instance_of?(Node)
-          return if scope_change?(node) || node.const_type?
+          node.each_child_node do |child|
+            find_usage(child, &block)
+          end
+        end
+
+        def allowed?(node)
+          node.const_type? && only_static_constants?
+        end
 
-          node.children.each do |child|
-            find_constant_usage(child, described_class, &block)
+        def message(offense)
+          if style == :described_class
+            format(MSG, replacement: DESCRIBED_CLASS, src: offense)
+          else
+            format(MSG, replacement: @described_class.const_name,
+                        src: DESCRIBED_CLASS)
           end
         end
 
         def scope_change?(node)
-          scope_changing_syntax?(node)          ||
+          scope_changing_syntax?(node) ||
             common_instance_exec_closure?(node) ||
             skippable_block?(node)
         end
 
         def skippable_block?(node)
-          node.block_type? && !rspec_block?(node) && skip_blocks?
+          node.block_type? && !rspec_block?(node) && cop_config['SkipBlocks']
+        end
+
+        def only_static_constants?
+          cop_config.fetch('OnlyStaticConstants', true)
+        end
+
+        def offensive?(node)
+          if style == :described_class
+            offensive_described_class?(node)
+          else
+            node.send_type? && node.method?(:described_class)
+          end
+        end
+
+        def offensive_described_class?(node)
+          return false unless node.const_type?
+
+          # E.g. `described_class::CONSTANT`
+          return false if contains_described_class?(node)
+
+          nearest_described_class, = node.each_ancestor(:block)
+            .map { |ancestor| described_constant(ancestor) }.find(&:itself)
+
+          return false if nearest_described_class.equal?(node)
+
+          full_const_name(nearest_described_class) == full_const_name(node)
+        end
+
+        def full_const_name(node)
+          symbolized_namespace = namespace(node).map(&:to_sym)
+          collapse_namespace(symbolized_namespace, const_name(node))
         end
 
-        def skip_blocks?
-          cop_config['SkipBlocks'].equal?(true)
+        # @param namespace [Array<Symbol>]
+        # @param const [Array<Symbol>]
+        # @return [Array<Symbol>]
+        # @example
+        #   # nil represents base constant
+        #   collapse_namespace([], [:C])                # => [:C]
+        #   collapse_namespace([:A, :B], [:C])          # => [:A, :B, :C]
+        #   collapse_namespace([:A, :B], [:B, :C])      # => [:A, :B, :C]
+        #   collapse_namespace([:A, :B], [nil, :C])     # => [nil, :C]
+        #   collapse_namespace([:A, :B], [nil, :B, :C]) # => [nil, :B, :C]
+        def collapse_namespace(namespace, const)
+          return const if namespace.empty? || const.first.nil?
+
+          start = [0, (namespace.length - const.length)].max
+          max = namespace.length
+          intersection = (start..max).find do |shift|
+            namespace[shift, max - shift] == const[0, max - shift]
+          end
+          [*namespace[0, intersection], *const]
+        end
+
+        # @param node [RuboCop::AST::Node]
+        # @return [Array<Symbol>]
+        # @example
+        #   const_name(s(:const, nil, :C))                # => [:C]
+        #   const_name(s(:const, s(:const, nil, :M), :C)) # => [:M, :C]
+        #   const_name(s(:const, s(:cbase), :C))          # => [nil, :C]
+        def const_name(node)
+          namespace = node.namespace
+          name = node.short_name
+          if !namespace
+            [name]
+          elsif namespace.const_type?
+            [*const_name(namespace), name]
+          elsif %i[lvar cbase send].include?(namespace.type)
+            [nil, name]
+          end
         end
       end
     end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Avoid opening modules and defining specs within them.
+      #
+      # @example
+      #   # bad
+      #   module MyModule
+      #     RSpec.describe MyClass do
+      #       # ...
+      #     end
+      #   end
+      #
+      #   # good
+      #   RSpec.describe MyModule::MyClass do
+      #     # ...
+      #   end
+      #
+      # @see https://github.com/rubocop/rubocop-rspec/issues/735
+      class DescribedClassModuleWrapping < Base
+        MSG = 'Avoid opening modules and defining specs within them.'
+
+        # @!method include_rspec_blocks?(node)
+        def_node_search :include_rspec_blocks?, <<~PATTERN
+          ({block numblock} (send #explicit_rspec? #ExampleGroups.all ...) ...)
+        PATTERN
+
+        def on_module(node)
+          return unless include_rspec_blocks?(node)
+
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Enforces custom RSpec dialects.
+      #
+      # A dialect can be based on the following RSpec methods:
+      #
+      # - describe, context, feature, example_group
+      # - xdescribe, xcontext, xfeature
+      # - fdescribe, fcontext, ffeature
+      # - shared_examples, shared_examples_for, shared_context
+      # - it, specify, example, scenario, its
+      # - fit, fspecify, fexample, fscenario, focus
+      # - xit, xspecify, xexample, xscenario, skip
+      # - pending
+      # - prepend_before, before, append_before,
+      # - around
+      # - prepend_after, after, append_after
+      # - let, let!
+      # - subject, subject!
+      # - expect, is_expected, expect_any_instance_of
+      #
+      # By default all of the RSpec methods and aliases are allowed. By setting
+      # a config like:
+      #
+      #   RSpec/Dialect:
+      #     PreferredMethods:
+      #       context: describe
+      #
+      # If you were previously using the `RSpec/Capybara/FeatureMethods` cop and
+      # want to keep disabling all Capybara-specific methods that have the same
+      # native RSpec method (e.g. are just aliases), use the following config:
+      #
+      #   RSpec/Dialect:
+      #     PreferredMethods:
+      #       background: :before
+      #       scenario:   :it
+      #       xscenario:  :xit
+      #       given:      :let
+      #       given!:     :let!
+      #       feature:    :describe
+      #
+      # You can expect the following behavior:
+      #
+      # @example
+      #   # bad
+      #   context 'display name presence' do
+      #     # ...
+      #   end
+      #
+      #   # good
+      #   describe 'display name presence' do
+      #     # ...
+      #   end
+      #
+      class Dialect < Base
+        extend AutoCorrector
+        include MethodPreference
+
+        MSG = 'Prefer `%<prefer>s` over `%<current>s`.'
+
+        # @!method rspec_method?(node)
+        def_node_matcher :rspec_method?, '(send #rspec? #ALL.all ...)'
+
+        def on_send(node)
+          return unless rspec_method?(node)
+          return unless preferred_methods[node.method_name]
+
+          msg = format(MSG, prefer: preferred_method(node.method_name),
+                            current: node.method_name)
+
+          add_offense(node, message: msg) do |corrector|
+            current = node.loc.selector
+            preferred = preferred_method(current.source)
+
+            corrector.replace(current, preferred)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Avoid duplicated metadata.
+      #
+      # @example
+      #   # bad
+      #   describe 'Something', :a, :a
+      #
+      #   # good
+      #   describe 'Something', :a
+      class DuplicatedMetadata < Base
+        extend AutoCorrector
+
+        include Metadata
+        include RangeHelp
+
+        MSG = 'Avoid duplicated metadata.'
+
+        def on_metadata(symbols, _hash)
+          symbols.each do |symbol|
+            on_metadata_symbol(symbol)
+          end
+        end
+
+        private
+
+        def on_metadata_symbol(node)
+          return unless duplicated?(node)
+
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        def autocorrect(corrector, node)
+          corrector.remove(
+            range_with_surrounding_comma(
+              range_with_surrounding_space(
+                node.source_range,
+                side: :left
+              ),
+              :left
+            )
+          )
+        end
+
+        def duplicated?(node)
+          node.left_siblings.any? do |sibling|
+            sibling.eql?(node)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -5,10 +5,7 @@ module RuboCop
     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) }
@@ -33,66 +30,156 @@ module RuboCop
       #     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
+      #   # good
       #   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
+      #     pending 'will add tests later'
       #   end
       #
-      class EmptyExampleGroup < Cop
-        include RuboCop::RSpec::SpecOnly,
-                RuboCop::RSpec::Language,
-                RuboCop::RSpec::Language::NodePattern
+      class EmptyExampleGroup < Base
+        extend AutoCorrector
+
+        include RangeHelp
+
+        MSG = 'Empty example group detected.'
+
+        # @!method example_group_body(node)
+        #   Match example group blocks and yield their body
+        #
+        #   @example source that matches
+        #     describe 'example group' do
+        #       it { is_expected.to be }
+        #     end
+        #
+        #   @param node [RuboCop::AST::Node]
+        #   @yield [RuboCop::AST::Node] example group body
+        def_node_matcher :example_group_body, <<~PATTERN
+          (block (send #rspec? #ExampleGroups.all ...) args $_)
+        PATTERN
 
-        MSG = 'Empty example group detected.'.freeze
+        # @!method example_or_group_or_include?(node)
+        #   Match examples, example groups and includes
+        #
+        #   @example source that matches
+        #     it { is_expected.to fly }
+        #     describe('non-empty example groups too') { }
+        #     it_behaves_like 'an animal'
+        #     it_behaves_like('a cat') { let(:food) { 'milk' } }
+        #     it_has_root_access
+        #     skip
+        #     it 'will be implemented later'
+        #
+        #   @param node [RuboCop::AST::Node]
+        #   @return [Array<RuboCop::AST::Node>] matching nodes
+        def_node_matcher :example_or_group_or_include?, <<~PATTERN
+          {
+            (block
+              (send #rspec? {#Examples.all #ExampleGroups.all #Includes.all} ...)
+            ...)
+            (send nil? {#Examples.all #Includes.all} ...)
+          }
+        PATTERN
+
+        # @!method examples_inside_block?(node)
+        #   Match examples defined inside a block which is not a hook
+        #
+        #   @example source that matches
+        #     %w(r g b).each do |color|
+        #       it { is_expected.to have_color(color) }
+        #     end
+        #
+        #   @example source that does not match
+        #     before do
+        #       it { is_expected.to fall_into_oblivion }
+        #     end
+        #
+        #   @param node [RuboCop::AST::Node]
+        #   @return [Array<RuboCop::AST::Node>] matching nodes
+        def_node_matcher :examples_inside_block?, <<~PATTERN
+          (block !(send nil? #Hooks.all ...) _ #examples?)
+        PATTERN
+
+        # @!method examples_directly_or_in_block?(node)
+        #   Match examples or examples inside blocks
+        #
+        #   @example source that matches
+        #     it { expect(drink).to be_cold }
+        #     context('when winter') { it { expect(drink).to be_hot } }
+        #     (1..5).each { |divisor| it { is_expected.to divide_by(divisor) } }
+        #
+        #   @param node [RuboCop::AST::Node]
+        #   @return [Array<RuboCop::AST::Node>] matching nodes
+        def_node_matcher :examples_directly_or_in_block?, <<~PATTERN
+          {
+            #example_or_group_or_include?
+            #examples_inside_block?
+          }
+        PATTERN
 
-        def_node_search :contains_example?, <<-PATTERN
+        # @!method examples?(node)
+        #   Matches examples defined in scopes where they could run
+        #
+        #   @example source that matches
+        #     it { expect(myself).to be_run }
+        #     describe { it { i_run_as_well } }
+        #
+        #   @example source that does not match
+        #     before { it { whatever here won't run anyway } }
+        #
+        #   @param node [RuboCop::AST::Node]
+        #   @return [Array<RuboCop::AST::Node>] matching nodes
+        def_node_matcher :examples?, <<~PATTERN
           {
-            (send _ {
-              #{Examples::ALL.to_node_pattern}
-              :it_behaves_like
-              :it_should_behave_like
-              :include_context
-              :include_examples
-            } ...)
-            (send _ #custom_include? ...)
+            #examples_directly_or_in_block?
+            (begin <#examples_directly_or_in_block? ...>)
+            (begin <#examples_in_branches? ...>)
           }
         PATTERN
 
-        def on_block(node)
-          return unless example_group?(node) && !contains_example?(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          return if node.each_ancestor(:def, :defs).any?
+          return if node.each_ancestor(:block).any? { |block| example?(block) }
 
-          add_offense(node.children.first, :expression)
+          example_group_body(node) do |body|
+            next unless offensive?(body)
+
+            add_offense(node.send_node) do |corrector|
+              corrector.remove(removed_range(node))
+            end
+          end
         end
 
         private
 
-        def custom_include?(method_name)
-          custom_include_methods.include?(method_name)
+        def offensive?(body)
+          return true unless body
+          return false if conditionals_with_examples?(body)
+
+          if body.if_type? || body.case_type?
+            !examples_in_branches?(body)
+          else
+            !examples?(body)
+          end
+        end
+
+        def conditionals_with_examples?(body)
+          return false unless body.begin_type? || body.case_type?
+
+          body.each_descendant(:if, :case).any? do |condition_node|
+            examples_in_branches?(condition_node)
+          end
+        end
+
+        def examples_in_branches?(condition_node)
+          return false if !condition_node.if_type? && !condition_node.case_type?
+
+          condition_node.branches.any? { |branch| examples?(branch) }
         end
 
-        def custom_include_methods
-          cop_config
-            .fetch('CustomIncludeMethods', [])
-            .map(&:to_sym)
+        def removed_range(node)
+          range_by_whole_lines(
+            node.source_range,
+            include_final_newline: true
+          )
         end
       end
     end