rubocop-rspec 1.35.0 → 1.36.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 47216a8696392108804dfd285875acfdec9857df832fb6270120b29161bcd5d6
-  data.tar.gz: 742b3c4e6836a6e7c8aa4d2ca02abd73f09870165f2e10a4eb41ea9d1ef6c859
+  metadata.gz: 5941ed5c040054adc2993a3da2b76e591a9096767e486727191702956bc04430
+  data.tar.gz: 34d3b8460cd36dcf5af8f1cdf918bbd43e43bf5e4c7a5a0fba829eb9c1980cbf
 SHA512:
-  metadata.gz: 488afcabe181b6658b73014730194c4a1bab399e096d2fdb230f2d16bee41afa3d71d285fd764a7a6b766117bd68d6702c54cab33503a18ed3f6501428569ff0
-  data.tar.gz: a8030e59e2f88880b09621a868f18e8af0b44bca6927822f7e07cfcae9668a3e11d91aab7e4450dffa05d7409043a4e2db9b87373ea9b1316d00e924e52668d1
+  metadata.gz: d868ef13a01bdf13ba05eb54a0b39354017184001d44975ef3e1bbcb0d429f2ccac6675429308886cd3246e3ff83bf8f7e5e34b1b8613b9fdbfc879493f459a9
+  data.tar.gz: 05fae5ae2505feabbfdfa8203c57a0bbd6f9b398c33d80d9c848e2ed6fd9fdb78019c699b9f428b26533d3799c78051a5a5ddd5176d07224938f29217ca77e61

data/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 ## Master (Unreleased)
 
+## 1.36.0 (2019-09-27)
+
+* Fix `RSpec/DescribedClass`'s error when `described_class` is used as part of a constant. ([@pirj][])
+* Fix `RSpec/ExampleWording` autocorrect of multi-line docstrings. ([@pirj][])
+* Add `RSpec/ContextMethod` cop, to detect method names in `context`. ([@geniou][])
+* Update RuboCop dependency to 0.68.1 with support for children matching node pattern syntax. ([@pirj][])
+* Add `RSpec/EmptyLineAfterExample` cop to check that there is an empty line after example blocks. ([@pirj][])
+* Fix `Capybara/CurrentPathExpectation` auto-corrector, to include option `ignore_query: true`. ([@onumis][])
+* Fix `RSpec/Focus` detecting mixed array/hash metadata. ([@dgollahon][])
+* Fix `RSpec/Focus` to also detect `pending` examples. ([@dgollahon][])
+
 ## 1.35.0 (2019-08-02)
 
 * Add `RSpec/ImplicitBlockExpectation` cop. ([@pirj][])
@@ -440,3 +451,4 @@ Compatibility release so users can upgrade RuboCop to 0.51.0. No new features.
 [@schmijos]: https://github.com/schmijos
 [@foton]: https://github.com/foton
 [@nc-holodakg]: https://github.com/nc-holodakg
+[@onumis]: https://github.com/onumis

data/config/default.yml

@@ -49,6 +49,11 @@ RSpec/BeforeAfterAll:
   - spec/support/**/*.rb
   StyleGuide: http://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/BeforeAfterAll
 
+RSpec/ContextMethod:
+  Description: "`context` should not be used for specifying methods."
+  Enabled: true
+  StyleGuide: http://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ContextMethod
+
 RSpec/ContextWording:
   Description: Checks that `context` docstring starts with an allowed prefix.
   Enabled: true
@@ -95,6 +100,12 @@ RSpec/EmptyExampleGroup:
   CustomIncludeMethods: []
   StyleGuide: http://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyExampleGroup
 
+RSpec/EmptyLineAfterExample:
+  Description: Checks if there is an empty line after example blocks.
+  Enabled: true
+  AllowConsecutiveOneLiners: true
+  StyleGuide: http://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyLineAfterExample
+
 RSpec/EmptyLineAfterExampleGroup:
   Description: Checks if there is an empty line after example group blocks.
   Enabled: true

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

@@ -78,6 +78,7 @@ module RuboCop
                                'have_no_current_path'
                              end
             corrector.replace(matcher_node.loc.selector, matcher_method)
+            add_ignore_query_options(corrector, node)
           end
 
           def convert_regexp_str_to_literal(corrector, matcher_node, regexp_str)
@@ -85,6 +86,21 @@ module RuboCop
             regexp_expr = Regexp.new(regexp_str).inspect
             corrector.replace(str_node.loc.expression, regexp_expr)
           end
+
+          # `have_current_path` with no options will include the querystring
+          # while `page.current_path` does not.
+          # This ensures the option `ignore_query: true` is added
+          # except when the expectation is a regexp or string
+          def add_ignore_query_options(corrector, node)
+            expectation_node = node.parent.last_argument
+            expectation_last_child = expectation_node.children.last
+            return if %i[regexp str].include?(expectation_last_child.type)
+
+            corrector.insert_after(
+              expectation_last_child.loc.expression,
+              ', ignore_query: true'
+            )
+          end
         end
       end
     end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # `context` should not be used for specifying methods.
+      #
+      # @example
+      #   # bad
+      #   context '#foo_bar' do
+      #     # ...
+      #   end
+      #
+      #   context '.foo_bar' do
+      #     # ...
+      #   end
+      #
+      #   # good
+      #   describe '#foo_bar' do
+      #     # ...
+      #   end
+      #
+      #   describe '.foo_bar' do
+      #     # ...
+      #   end
+      class ContextMethod < Cop
+        MSG = 'Use `describe` for testing methods.'
+
+        def_node_matcher :context_method, <<-PATTERN
+          (block (send #{RSPEC} :context $(str #method_name?) ...) ...)
+        PATTERN
+
+        def on_block(node)
+          context_method(node) do |context|
+            add_offense(context)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.parent.loc.selector, 'describe')
+          end
+        end
+
+        private
+
+        def method_name?(description)
+          description.start_with?('.', '#')
+        end
+      end
+    end
+  end
+end

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

@@ -29,17 +29,17 @@ module RuboCop
           }
         PATTERN
 
-        def_node_matcher :describe_with_metadata, <<-PATTERN
-          (send #{RSPEC} :describe
-            !const
-            ...
-            (hash $...))
+        def_node_matcher :describe_with_rails_metadata?, <<-PATTERN
+          (send #{RSPEC} :describe !const ...
+            (hash <#rails_metadata? ...>)
+          )
         PATTERN
 
         def_node_matcher :rails_metadata?, <<-PATTERN
           (pair
             (sym :type)
-            (sym {:request :feature :system :routing :view}))
+            (sym {:request :feature :system :routing :view})
+          )
         PATTERN
 
         def_node_matcher :shared_group?, SharedGroups::ALL.block_pattern
@@ -47,10 +47,7 @@ module RuboCop
         def on_top_level_describe(node, args)
           return if shared_group?(root_node)
           return if valid_describe?(node)
-
-          describe_with_metadata(node) do |pairs|
-            return if pairs.any?(&method(:rails_metadata?))
-          end
+          return if describe_with_rails_metadata?(node)
 
           add_offense(args.first)
         end

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

@@ -8,7 +8,8 @@ module RuboCop
       # If the first argument of describe is a class, the class is exposed to
       # each example via described_class.
       #
-      # This cop can be configured using the `EnforcedStyle` option
+      # This cop can be configured using the `EnforcedStyle` and `SkipBlocks`
+      # options.
       #
       # @example `EnforcedStyle: described_class`
       #   # bad
@@ -32,6 +33,27 @@ module RuboCop
       #     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 < Cop
         include ConfigurableEnforcedStyle
 
@@ -51,6 +73,10 @@ module RuboCop
           (block (send _ :describe $(const ...) ...) (args) $_)
         PATTERN
 
+        def_node_search :contains_described_class?, <<-PATTERN
+          (send nil? :described_class)
+        PATTERN
+
         def on_block(node)
           # In case the explicit style is used, we need to remember what's
           # being described.
@@ -119,6 +145,8 @@ module RuboCop
 
         def offensive_described_class?(node)
           return unless node.const_type?
+          # E.g. `described_class::CONSTANT`
+          return if contains_described_class?(node)
 
           nearest_described_class, = node.each_ancestor(:block)
             .map { |ancestor| described_constant(ancestor) }.find(&:itself)

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks if there is an empty line after example blocks.
+      #
+      # @example
+      #   # bad
+      #   RSpec.describe Foo do
+      #     it 'does this' do
+      #     end
+      #     it 'does that' do
+      #     end
+      #   end
+      #
+      #   # good
+      #   RSpec.describe Foo do
+      #     it 'does this' do
+      #     end
+      #
+      #     it 'does that' do
+      #     end
+      #   end
+      #
+      #   # fair - it's ok to have non-separated one-liners
+      #   RSpec.describe Foo do
+      #     it { one }
+      #     it { two }
+      #   end
+      #
+      # @example with AllowConsecutiveOneLiners configuration
+      #
+      #   # rubocop.yml
+      #   # RSpec/EmptyLineAfterExample:
+      #   #   AllowConsecutiveOneLiners: false
+      #
+      #   # bad
+      #   RSpec.describe Foo do
+      #     it { one }
+      #     it { two }
+      #   end
+      #
+      class EmptyLineAfterExample < Cop
+        include RuboCop::RSpec::BlankLineSeparation
+
+        MSG = 'Add an empty line after `%<example>s`.'
+
+        def on_block(node)
+          return unless example?(node)
+          return if last_child?(node)
+          return if allowed_one_liner?(node)
+
+          missing_separating_line(node) do |location|
+            add_offense(node,
+                        location: location,
+                        message: format(MSG, example: node.method_name))
+          end
+        end
+
+        def allowed_one_liner?(node)
+          consecutive_one_liner?(node) && allow_consecutive_one_liners?
+        end
+
+        def allow_consecutive_one_liners?
+          cop_config['AllowConsecutiveOneLiners']
+        end
+
+        def consecutive_one_liner?(node)
+          node.line_count == 1 && next_one_line_example?(node)
+        end
+
+        def next_one_line_example?(node)
+          next_sibling = next_sibling(node)
+          return unless next_sibling
+          return unless example?(next_sibling)
+
+          next_sibling.line_count == 1
+        end
+
+        def next_sibling(node)
+          node.parent.children[node.sibling_index + 1]
+        end
+      end
+    end
+  end
+end

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

@@ -53,27 +53,30 @@ module RuboCop
           end
         end
 
-        def autocorrect(range)
-          ->(corrector) { corrector.replace(range, replacement_text(range)) }
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(docstring(node), replacement_text(node))
+          end
         end
 
         private
 
         def add_wording_offense(node, message)
-          expr = node.loc.expression
+          add_offense(node, location: docstring(node), message: message)
+        end
 
-          docstring =
-            Parser::Source::Range.new(
-              expr.source_buffer,
-              expr.begin_pos + 1,
-              expr.end_pos - 1
-            )
+        def docstring(node)
+          expr = node.loc.expression
 
-          add_offense(docstring, location: docstring, message: message)
+          Parser::Source::Range.new(
+            expr.source_buffer,
+            expr.begin_pos + 1,
+            expr.end_pos - 1
+          )
         end
 
-        def replacement_text(range)
-          text = range.source
+        def replacement_text(node)
+          text = text(node)
 
           if text =~ SHOULD_PREFIX
             RuboCop::RSpec::Wording.new(
@@ -86,6 +89,19 @@ module RuboCop
           end
         end
 
+        # Recursive processing is required to process nested dstr nodes
+        # that is the case for \-separated multiline strings with interpolation.
+        def text(node)
+          case node.type
+          when :dstr
+            node.node_parts.map { |child_node| text(child_node) }.join
+          when :str
+            node.value
+          when :begin
+            node.source
+          end
+        end
+
         def custom_transform
           cop_config.fetch('CustomTransform', {})
         end

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

@@ -12,22 +12,22 @@ module RuboCop
       #
       # @example `EnforcedStyle: block`
       #   # bad
-      #   expect(run).to change(Foo, :bar)
+      #   expect { run }.to change(Foo, :bar)
       #
       #   # good
-      #   expect(run).to change { Foo.bar }
+      #   expect { run }.to change { Foo.bar }
       #
       # @example `EnforcedStyle: method_call`
       #   # bad
-      #   expect(run).to change { Foo.bar }
-      #   expect(run).to change { foo.baz }
+      #   expect { run }.to change { Foo.bar }
+      #   expect { run }.to change { foo.baz }
       #
       #   # good
-      #   expect(run).to change(Foo, :bar)
-      #   expect(run).to change(foo, :baz)
+      #   expect { run }.to change(Foo, :bar)
+      #   expect { run }.to change(foo, :baz)
       #   # also good when there are arguments or chained method calls
-      #   expect(run).to change { Foo.bar(:count) }
-      #   expect(run).to change { user.reload.name }
+      #   expect { run }.to change { Foo.bar(:count) }
+      #   expect { run }.to change { user.reload.name }
       #
       class ExpectChange < Cop
         include ConfigurableEnforcedStyle

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

@@ -38,7 +38,7 @@ module RuboCop
           def on_block(node)
             factory_attributes(node).to_a.flatten.each do |attribute|
               next unless offensive_receiver?(attribute.receiver, node)
-              next if proc?(attribute) || association?(attribute)
+              next if proc?(attribute) || association?(attribute.first_argument)
 
               add_offense(attribute)
             end
@@ -72,14 +72,7 @@ module RuboCop
             value_matcher(attribute).to_a.all?(&:block_pass_type?)
           end
 
-          def association?(attribute)
-            argument = attribute.first_argument
-            argument.hash_type? && factory_key?(argument)
-          end
-
-          def factory_key?(hash_node)
-            hash_node.keys.any? { |key| key.sym_type? && key.value == :factory }
-          end
+          def_node_matcher :association?, '(hash <(pair (sym :factory) _) ...>)'
 
           def autocorrect_replacing_parens(node)
             left_braces, right_braces = braces(node)

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

@@ -26,18 +26,16 @@ module RuboCop
           ExampleGroups::GROUPS  +
           ExampleGroups::SKIPPED +
           Examples::EXAMPLES     +
-          Examples::SKIPPED
+          Examples::SKIPPED      +
+          Examples::PENDING
 
         focused = ExampleGroups::FOCUSED + Examples::FOCUSED
 
         FOCUSABLE_SELECTORS = focusable.node_pattern_union
 
-        FOCUS_SYMBOL = s(:sym, :focus)
-        FOCUS_TRUE   = s(:pair, FOCUS_SYMBOL, s(:true))
-
         def_node_matcher :metadata, <<-PATTERN
-          {(send #{RSPEC} #{FOCUSABLE_SELECTORS} ... (hash $...))
-           (send #{RSPEC} #{FOCUSABLE_SELECTORS} $...)}
+          {(send #{RSPEC} #{FOCUSABLE_SELECTORS} <$(sym :focus) ...>)
+           (send #{RSPEC} #{FOCUSABLE_SELECTORS} ... (hash <$(pair (sym :focus) true) ...>))}
         PATTERN
 
         def_node_matcher :focused_block?, focused.send_pattern
@@ -53,10 +51,7 @@ module RuboCop
         def focus_metadata(node, &block)
           yield(node) if focused_block?(node)
 
-          metadata(node) do |matches|
-            matches.grep(FOCUS_SYMBOL, &block)
-            matches.grep(FOCUS_TRUE, &block)
-          end
+          metadata(node, &block)
         end
       end
     end