rubocop-rspec 2.12.0 → 2.13.1

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      module Capybara
+        # Checks if there is a more specific finder offered by Capybara.
+        #
+        # @example
+        #   # bad
+        #   find('#some-id')
+        #   find('[visible][id=some-id]')
+        #
+        #   # good
+        #   find_by_id('some-id')
+        #   find_by_id('some-id', visible: true)
+        #
+        class SpecificFinders < Base
+          extend AutoCorrector
+
+          include RangeHelp
+
+          MSG = 'Prefer `find_by` over `find`.'
+          RESTRICT_ON_SEND = %i[find].freeze
+
+          # @!method find_argument(node)
+          def_node_matcher :find_argument, <<~PATTERN
+            (send _ :find (str $_) ...)
+          PATTERN
+
+          def on_send(node)
+            find_argument(node) do |arg|
+              next if CssSelector.multiple_selectors?(arg)
+
+              on_attr(node, arg) if attribute?(arg)
+              on_id(node, arg) if CssSelector.id?(arg)
+            end
+          end
+
+          private
+
+          def on_attr(node, arg)
+            return unless (id = CssSelector.attributes(arg)['id'])
+
+            register_offense(node, replaced_arguments(arg, id))
+          end
+
+          def on_id(node, arg)
+            register_offense(node, "'#{arg.to_s.delete('#')}'")
+          end
+
+          def attribute?(arg)
+            CssSelector.attribute?(arg) &&
+              CssSelector.common_attributes?(arg)
+          end
+
+          def register_offense(node, arg_replacement)
+            add_offense(offense_range(node)) do |corrector|
+              corrector.replace(node.loc.selector, 'find_by_id')
+              corrector.replace(node.first_argument.loc.expression,
+                                arg_replacement)
+            end
+          end
+
+          def replaced_arguments(arg, id)
+            options = to_options(CssSelector.attributes(arg))
+            options.empty? ? id : "#{id}, #{options}"
+          end
+
+          def to_options(attrs)
+            attrs.each.map do |key, value|
+              next if key == 'id'
+
+              "#{key}: #{value}"
+            end.compact.join(', ')
+          end
+
+          def offense_range(node)
+            range_between(node.loc.selector.begin_pos,
+                          node.loc.end.end_pos)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -12,19 +12,21 @@ module RuboCop
         #   expect(page).to have_selector('button')
         #   expect(page).to have_no_selector('button.cls')
         #   expect(page).to have_css('button')
-        #   expect(page).to have_no_css('a.cls', exact_text: 'foo')
+        #   expect(page).to have_no_css('a.cls', href: 'http://example.com')
         #   expect(page).to have_css('table.cls')
         #   expect(page).to have_css('select')
+        #   expect(page).to have_css('input', exact_text: 'foo')
         #
         #   # good
         #   expect(page).to have_button
         #   expect(page).to have_no_button(class: 'cls')
         #   expect(page).to have_button
-        #   expect(page).to have_no_link('foo', class: 'cls')
+        #   expect(page).to have_no_link('foo', class: 'cls', href: 'http://example.com')
         #   expect(page).to have_table(class: 'cls')
         #   expect(page).to have_select
+        #   expect(page).to have_field('foo')
         #
-        class SpecificMatcher < Base
+        class SpecificMatcher < Base # rubocop:disable Metrics/ClassLength
           MSG = 'Prefer `%<good_matcher>s` over `%<bad_matcher>s`.'
           RESTRICT_ON_SEND = %i[have_selector have_no_selector have_css
                                 have_no_css].freeze
@@ -32,20 +34,57 @@ module RuboCop
             'button' => 'button',
             'a' => 'link',
             'table' => 'table',
-            'select' => 'select'
+            'select' => 'select',
+            'input' => 'field'
           }.freeze
+          SPECIFIC_MATCHER_OPTIONS = {
+            'button' => (
+              CssSelector::COMMON_OPTIONS + %w[disabled name value title type]
+            ).freeze,
+            'link' => (
+              CssSelector::COMMON_OPTIONS + %w[href alt title download]
+            ).freeze,
+            'table' => (
+              CssSelector::COMMON_OPTIONS + %w[
+                caption with_cols cols with_rows rows
+              ]
+            ).freeze,
+            'select' => (
+              CssSelector::COMMON_OPTIONS + %w[
+                disabled name placeholder options enabled_options
+                disabled_options selected with_selected multiple with_options
+              ]
+            ).freeze,
+            'field' => (
+              CssSelector::COMMON_OPTIONS + %w[
+                checked unchecked disabled valid name placeholder
+                validation_message readonly with type multiple
+              ]
+            ).freeze
+          }.freeze
+          SPECIFIC_MATCHER_PSEUDO_CLASSES = %w[
+            not() disabled enabled checked unchecked
+          ].freeze
 
           # @!method first_argument(node)
           def_node_matcher :first_argument, <<-PATTERN
             (send nil? _ (str $_) ... )
           PATTERN
 
+          # @!method option?(node)
+          def_node_search :option?, <<-PATTERN
+            (pair (sym %) _)
+          PATTERN
+
           def on_send(node)
-            return unless (arg = first_argument(node))
-            return unless (matcher = specific_matcher(arg))
-            return if acceptable_pattern?(arg)
+            first_argument(node) do |arg|
+              next unless (matcher = specific_matcher(arg))
+              next if CssSelector.multiple_selectors?(arg)
+              next unless specific_matcher_option?(node, arg, matcher)
+              next unless specific_matcher_pseudo_classes?(arg)
 
-            add_offense(node, message: message(node, matcher))
+              add_offense(node, message: message(node, matcher))
+            end
           end
 
           private
@@ -55,8 +94,50 @@ module RuboCop
             SPECIFIC_MATCHER[splitted_arg]
           end
 
-          def acceptable_pattern?(arg)
-            arg.match?(/\[.+=\w+\]/)
+          def specific_matcher_option?(node, arg, matcher)
+            attrs = CssSelector.attributes(arg).keys
+            return true if attrs.empty?
+            return false unless replaceable_matcher?(node, matcher, attrs)
+
+            attrs.all? do |attr|
+              SPECIFIC_MATCHER_OPTIONS.fetch(matcher, []).include?(attr)
+            end
+          end
+
+          def specific_matcher_pseudo_classes?(arg)
+            CssSelector.pseudo_classes(arg).all? do |pseudo_class|
+              replaceable_pseudo_class?(pseudo_class, arg)
+            end
+          end
+
+          def replaceable_pseudo_class?(pseudo_class, arg)
+            unless SPECIFIC_MATCHER_PSEUDO_CLASSES.include?(pseudo_class)
+              return false
+            end
+
+            case pseudo_class
+            when 'not()' then replaceable_pseudo_class_not?(arg)
+            else true
+            end
+          end
+
+          def replaceable_pseudo_class_not?(arg)
+            arg.scan(/not\(.*?\)/).all? do |not_arg|
+              CssSelector.attributes(not_arg).values.all? do |v|
+                v.is_a?(TrueClass) || v.is_a?(FalseClass)
+              end
+            end
+          end
+
+          def replaceable_matcher?(node, matcher, attrs)
+            case matcher
+            when 'link' then replaceable_to_have_link?(node, attrs)
+            else true
+            end
+          end
+
+          def replaceable_to_have_link?(node, attrs)
+            option?(node, :href) || attrs.include?('href')
           end
 
           def message(node, matcher)

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

@@ -16,7 +16,6 @@ module RuboCop
         # https://www.rubydoc.info/gems/capybara/Capybara%2FNode%2FFinders:all[the documentation].
         #
         # @example
-        #
         #   # bad
         #   expect(page).to have_selector('.foo', visible: false)
         #   expect(page).to have_css('.foo', visible: true)

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

@@ -5,12 +5,20 @@ module RuboCop
     module RSpec
       # Prefer negated matchers over `to change.by(0)`.
       #
-      # @example
+      # In the case of composite expectations, cop suggest using the
+      # negation matchers of `RSpec::Matchers#change`.
+      #
+      # By default the cop does not support autocorrect of
+      # compound expectations, but if you set the
+      # negated matcher for `change`, e.g. `not_change` with
+      # the `NegatedMatcher` option, the cop will perform the autocorrection.
+      #
+      # @example NegatedMatcher: ~ (default)
       #   # bad
       #   expect { run }.to change(Foo, :bar).by(0)
       #   expect { run }.to change { Foo.bar }.by(0)
       #
-      #   # bad - compound expectations
+      #   # bad - compound expectations (does not support autocorrection)
       #   expect { run }
       #     .to change(Foo, :bar).by(0)
       #     .and change(Foo, :baz).by(0)
@@ -31,10 +39,28 @@ module RuboCop
       #     .to not_change { Foo.bar }
       #     .and not_change { Foo.baz }
       #
+      # @example NegatedMatcher: not_change
+      #   # bad (support autocorrection to good case)
+      #   expect { run }
+      #     .to change(Foo, :bar).by(0)
+      #     .and change(Foo, :baz).by(0)
+      #   expect { run }
+      #     .to change { Foo.bar }.by(0)
+      #     .and change { Foo.baz }.by(0)
+      #
+      #   # good
+      #   define_negated_matcher :not_change, :change
+      #   expect { run }
+      #     .to not_change(Foo, :bar)
+      #     .and not_change(Foo, :baz)
+      #   expect { run }
+      #     .to not_change { Foo.bar }
+      #     .and not_change { Foo.baz }
+      #
       class ChangeByZero < Base
         extend AutoCorrector
         MSG = 'Prefer `not_to change` over `to change.by(0)`.'
-        MSG_COMPOUND = 'Prefer negated matchers with compound expectations ' \
+        MSG_COMPOUND = 'Prefer %<preferred>s with compound expectations ' \
                           'over `change.by(0)`.'
         RESTRICT_ON_SEND = %i[change].freeze
 
@@ -55,6 +81,11 @@ module RuboCop
             (int 0))
         PATTERN
 
+        # @!method change_nodes(node)
+        def_node_search :change_nodes, <<-PATTERN
+          $(send nil? :change ...)
+        PATTERN
+
         def on_send(node)
           expect_change_with_arguments(node.parent) do
             check_offense(node.parent)
@@ -70,7 +101,9 @@ module RuboCop
         def check_offense(node)
           expression = node.loc.expression
           if compound_expectations?(node)
-            add_offense(expression, message: MSG_COMPOUND)
+            add_offense(expression, message: message_compound) do |corrector|
+              autocorrect_compound(corrector, node)
+            end
           else
             add_offense(expression) do |corrector|
               autocorrect(corrector, node)
@@ -79,7 +112,7 @@ module RuboCop
         end
 
         def compound_expectations?(node)
-          %i[and or].include?(node.parent.method_name)
+          %i[and or & |].include?(node.parent.method_name)
         end
 
         def autocorrect(corrector, node)
@@ -87,6 +120,28 @@ module RuboCop
           range = node.loc.dot.with(end_pos: node.loc.expression.end_pos)
           corrector.remove(range)
         end
+
+        def autocorrect_compound(corrector, node)
+          return unless negated_matcher
+
+          change_nodes(node) do |change_node|
+            corrector.replace(change_node.loc.selector, negated_matcher)
+            range = node.loc.dot.with(end_pos: node.loc.expression.end_pos)
+            corrector.remove(range)
+          end
+        end
+
+        def negated_matcher
+          cop_config['NegatedMatcher']
+        end
+
+        def message_compound
+          format(MSG_COMPOUND, preferred: preferred_method)
+        end
+
+        def preferred_method
+          negated_matcher ? "`#{negated_matcher}`" : 'negated matchers'
+        end
       end
     end
   end

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Enforces consistent use of `be_a` or `be_kind_of`.
+      #
+      # @example EnforcedStyle: be_a (default)
+      #   # bad
+      #   expect(object).to be_kind_of(String)
+      #   expect(object).to be_a_kind_of(String)
+      #
+      #   # good
+      #   expect(object).to be_a(String)
+      #   expect(object).to be_an(String)
+      #
+      # @example EnforcedStyle: be_kind_of
+      #   # bad
+      #   expect(object).to be_a(String)
+      #   expect(object).to be_an(String)
+      #
+      #   # good
+      #   expect(object).to be_kind_of(String)
+      #   expect(object).to be_a_kind_of(String)
+      #
+      class ClassCheck < Base
+        extend AutoCorrector
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Prefer `%<preferred>s` over `%<current>s`.'
+
+        METHOD_NAMES_FOR_BE_A = ::Set[
+          :be_a,
+          :be_an
+        ].freeze
+
+        METHOD_NAMES_FOR_KIND_OF = ::Set[
+          :be_a_kind_of,
+          :be_kind_of
+        ].freeze
+
+        PREFERRED_METHOD_NAME_BY_STYLE = {
+          be_a: :be_a,
+          be_kind_of: :be_kind_of
+        }.freeze
+
+        RESTRICT_ON_SEND = %i[
+          be_a
+          be_a_kind_of
+          be_an
+          be_kind_of
+        ].freeze
+
+        def on_send(node)
+          return unless offending?(node)
+
+          add_offense(
+            node.loc.selector,
+            message: format_message(node)
+          ) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          corrector.replace(node.loc.selector, preferred_method_name)
+        end
+
+        def format_message(node)
+          format(
+            MSG,
+            current: node.method_name,
+            preferred: preferred_method_name
+          )
+        end
+
+        def offending?(node)
+          !node.receiver && !preferred_method_name?(node.method_name)
+        end
+
+        def preferred_method_name?(method_name)
+          preferred_method_names.include?(method_name)
+        end
+
+        def preferred_method_name
+          PREFERRED_METHOD_NAME_BY_STYLE[style]
+        end
+
+        def preferred_method_names
+          if style == :be_a
+            METHOD_NAMES_FOR_BE_A
+          else
+            METHOD_NAMES_FOR_KIND_OF
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -23,6 +23,7 @@ module RuboCop
       #   describe '.foo_bar' do
       #     # ...
       #   end
+      #
       class ContextMethod < Base
         extend AutoCorrector
 
@@ -33,7 +34,7 @@ module RuboCop
           (block (send #rspec? :context $(str #method_name?) ...) ...)
         PATTERN
 
-        def on_block(node)
+        def on_block(node)  # rubocop:disable InternalAffairs/NumblockHandler
           context_method(node) do |context|
             add_offense(context) do |corrector|
               corrector.replace(node.send_node.loc.selector, 'describe')

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

@@ -14,7 +14,6 @@ module RuboCop
       # @see http://www.betterspecs.org/#contexts
       #
       # @example `Prefixes` configuration
-      #
       #   # .rubocop.yml
       #   # RSpec/ContextWording:
       #   #   Prefixes:
@@ -35,41 +34,73 @@ module RuboCop
       #   context 'when the display name is not present' do
       #     # ...
       #   end
+      #
+      # This cop can be customized allowed context description pattern
+      # with `AllowedPatterns`. By default, there are no checking by pattern.
+      #
+      # @example `AllowedPatterns` configuration
+      #
+      #   # .rubocop.yml
+      #   # RSpec/ContextWording:
+      #   #   AllowedPatterns:
+      #   #     - /とき$/
+      #
+      # @example
+      #   # bad
+      #   context '条件を満たす' do
+      #     # ...
+      #   end
+      #
+      #   # good
+      #   context '条件を満たすとき' do
+      #     # ...
+      #   end
+      #
       class ContextWording < Base
-        MSG = 'Start context description with %<prefixes>s.'
+        include AllowedPattern
+
+        MSG = 'Context description should match %<patterns>s.'
 
         # @!method context_wording(node)
         def_node_matcher :context_wording, <<-PATTERN
-          (block (send #rspec? { :context :shared_context } $(str #bad_prefix?) ...) ...)
+          (block (send #rspec? { :context :shared_context } $(str $_) ...) ...)
         PATTERN
 
-        def on_block(node)
-          context_wording(node) do |context|
-            add_offense(context,
-                        message: format(MSG, prefixes: joined_prefixes))
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          context_wording(node) do |context, description|
+            if bad_pattern?(description)
+              message = format(MSG, patterns: expect_patterns)
+              add_offense(context, message: message)
+            end
           end
         end
 
         private
 
-        def bad_prefix?(description)
-          !prefix_regex.match?(description)
+        def allowed_patterns
+          super + prefix_regexes
         end
 
-        def joined_prefixes
-          quoted = prefixes.map { |prefix| "'#{prefix}'" }
-          return quoted.first if quoted.size == 1
+        def prefix_regexes
+          @prefix_regexes ||= prefixes.map { |pre| /^#{Regexp.escape(pre)}\b/ }
+        end
+
+        def bad_pattern?(description)
+          return false if allowed_patterns.empty?
 
-          quoted << "or #{quoted.pop}"
-          quoted.join(', ')
+          !matches_allowed_pattern?(description)
         end
 
-        def prefixes
-          cop_config['Prefixes'] || []
+        def expect_patterns
+          inspected = allowed_patterns.map(&:inspect)
+          return inspected.first if inspected.size == 1
+
+          inspected << "or #{inspected.pop}"
+          inspected.join(', ')
         end
 
-        def prefix_regex
-          /^#{Regexp.union(prefixes)}\b/
+        def prefixes
+          Array(cop_config.fetch('Prefixes', []))
         end
       end
     end

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

@@ -10,7 +10,6 @@ module RuboCop
       # Ignores Rails and Aruba `type` metadata by default.
       #
       # @example `IgnoredMetadata` configuration
-      #
       #   # .rubocop.yml
       #   # RSpec/DescribeClass:
       #   #   IgnoredMetadata:
@@ -34,6 +33,7 @@ module RuboCop
       #
       #   describe "A feature example", type: :feature do
       #   end
+      #
       class DescribeClass < Base
         include TopLevelGroup
 

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

@@ -16,6 +16,7 @@ module RuboCop
       #
       #   describe MyClass, '.my_class_method' do
       #   end
+      #
       class DescribeMethod < Base
         include TopLevelGroup
 

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

@@ -57,6 +57,7 @@ module RuboCop
       class DescribedClass < Base
         extend AutoCorrector
         include ConfigurableEnforcedStyle
+        include Namespace
 
         DESCRIBED_CLASS = 'described_class'
         MSG             = 'Use `%<replacement>s` instead of `%<src>s`.'
@@ -81,7 +82,7 @@ module RuboCop
         def_node_search :contains_described_class?,
                         '(send nil? :described_class)'
 
-        def on_block(node)
+        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)
@@ -160,7 +161,8 @@ module RuboCop
         end
 
         def full_const_name(node)
-          collapse_namespace(namespace(node), const_name(node))
+          symbolized_namespace = namespace(node).map(&:to_sym)
+          collapse_namespace(symbolized_namespace, const_name(node))
         end
 
         # @param namespace [Array<Symbol>]
@@ -200,18 +202,6 @@ module RuboCop
             [nil, name]
           end
         end
-
-        # @param node [RuboCop::AST::Node]
-        # @return [Array<Symbol>]
-        # @example
-        #   namespace(node) # => [:A, :B, :C]
-        def namespace(node)
-          node
-            .each_ancestor(:class, :module)
-            .reverse_each
-            .flat_map { |ancestor| ancestor.defined_module_name.split('::') }
-            .map(&:to_sym)
-        end
       end
     end
   end

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

@@ -41,6 +41,7 @@ module RuboCop
       #   describe 'display name presence' do
       #     # ...
       #   end
+      #
       class Dialect < Base
         extend AutoCorrector
         include MethodPreference