capybara 2.7.0 → 3.35.3

data/lib/capybara/node/finders.rb

@@ -1,108 +1,179 @@
 # frozen_string_literal: true
+
 module Capybara
   module Node
     module Finders
-
       ##
       #
-      # Find an {Capybara::Node::Element} based on the given arguments. +find+ will raise an error if the element
+      # Find an {Capybara::Node::Element} based on the given arguments. {#find} will raise an error if the element
       # is not found.
       #
-      # @!macro waiting_behavior
-      #   If the driver is capable of executing JavaScript, +$0+ will wait for a set amount of time
-      #   and continuously retry finding the element until either the element is found or the time
-      #   expires. The length of time +find+ will wait is controlled through {Capybara.default_max_wait_time}
-      #   and defaults to 2 seconds.
-      #   @option options [false, Numeric] wait (Capybara.default_max_wait_time) Maximum time to wait for matching element to appear.
+      #     page.find('#foo').find('.bar')
+      #     page.find(:xpath, './/div[contains(., "bar")]')
+      #     page.find('li', text: 'Quox').click_link('Delete')
       #
-      # +find+ takes the same options as +all+.
+      # @param (see #all)
       #
-      #     page.find('#foo').find('.bar')
-      #     page.find(:xpath, '//div[contains(., "bar")]')
-      #     page.find('li', :text => 'Quox').click_link('Delete')
+      # @macro waiting_behavior
+      #
+      # @!macro system_filters
+      #   @option options [String, Regexp] text      Only find elements which contain this text or match this regexp
+      #   @option options [String, Boolean] exact_text
+      #     When String the elements contained text must match exactly, when Boolean controls whether the `text` option must match exactly.
+      #     Defaults to {Capybara.configure exact_text}.
+      #   @option options [Boolean] normalize_ws
+      #     Whether the `text`/`exact_text` options are compared against elment text with whitespace normalized or as returned by the driver.
+      #     Defaults to {Capybara.configure default_normalize_ws}.
+      #   @option options [Boolean, Symbol] visible
+      #     Only find elements with the specified visibility. Defaults to behavior indicated by {Capybara.configure ignore_hidden_elements}.
+      #       * true - only finds visible elements.
+      #       * false - finds invisible _and_ visible elements.
+      #       * :all - same as false; finds visible and invisible elements.
+      #       * :hidden - only finds invisible elements.
+      #       * :visible - same as true; only finds visible elements.
+      #   @option options [Boolean] obscured  Only find elements with the specified obscured state:
+      #                                       * true - only find elements whose centerpoint is not in the viewport or is obscured by another non-descendant element.
+      #                                       * false - only find elements whose centerpoint is in the viewport and is not obscured by other non-descendant elements.
+      #   @option options [String, Regexp]  id           Only find elements with an id that matches the value passed
+      #   @option options [String, Array<String>, Regexp] class  Only find elements with matching class/classes.
+      #                                            * Absence of a class can be checked by prefixing the class name with `!`
+      #                                            * If you need to check for existence of a class name that starts with `!` then prefix with `!!`
+      #
+      #                                                class:['a', '!b', '!!!c'] # limit to elements with class 'a' and '!c' but not class 'b'
+      #
+      #   @option options [String, Regexp, Hash] style  Only find elements with matching style. String and Regexp will be checked against text of the elements `style` attribute, while a Hash will be compared against the elements full style
+      #   @option options [Boolean] exact            Control whether `is` expressions in the given XPath match exactly or partially. Defaults to {Capybara.configure exact}.
+      #   @option options [Symbol] match        The matching strategy to use. Defaults to {Capybara.configure match}.
+      #
+      # @return [Capybara::Node::Element]      The found element
+      # @raise  [Capybara::ElementNotFound]    If the element can't be found before time expires
       #
-      # @param (see Capybara::Node::Finders#all)
+      def find(*args, **options, &optional_filter_block)
+        options[:session_options] = session_options
+        synced_resolve Capybara::Queries::SelectorQuery.new(*args, **options, &optional_filter_block)
+      end
+
+      ##
+      #
+      # Find an {Capybara::Node::Element} based on the given arguments that is also an ancestor of the element called on.
+      # {#ancestor} will raise an error if the element is not found.
+      #
+      # {#ancestor} takes the same options as {#find}.
       #
-      # @option options [Boolean] match        The matching strategy to use.
+      #     element.ancestor('#foo').find('.bar')
+      #     element.ancestor(:xpath, './/div[contains(., "bar")]')
+      #     element.ancestor('ul', text: 'Quox').click_link('Delete')
+      #
+      # @param (see #find)
+      #
+      # @macro waiting_behavior
       #
       # @return [Capybara::Node::Element]      The found element
       # @raise  [Capybara::ElementNotFound]    If the element can't be found before time expires
       #
-      def find(*args)
-        query = Capybara::Queries::SelectorQuery.new(*args)
-        synchronize(query.wait) do
-          if query.match == :smart or query.match == :prefer_exact
-            result = query.resolve_for(self, true)
-            result = query.resolve_for(self, false) if result.size == 0 && !query.exact?
-          else
-            result = query.resolve_for(self)
-          end
-          if query.match == :one or query.match == :smart and result.size > 1
-            raise Capybara::Ambiguous.new("Ambiguous match, found #{result.size} elements matching #{query.description}")
-          end
-          if result.size == 0
-            raise Capybara::ElementNotFound.new("Unable to find #{query.description}")
-          end
-          result.first
-        end.tap(&:allow_reload!)
+      def ancestor(*args, **options, &optional_filter_block)
+        options[:session_options] = session_options
+        synced_resolve Capybara::Queries::AncestorQuery.new(*args, **options, &optional_filter_block)
       end
 
       ##
       #
-      # Find a form field on the page. The field can be found by its name, id or label text.
+      # Find an {Capybara::Node::Element} based on the given arguments that is also a sibling of the element called on.
+      # {#sibling} will raise an error if the element is not found.
+      #
+      # {#sibling} takes the same options as {#find}.
+      #
+      #     element.sibling('#foo').find('.bar')
+      #     element.sibling(:xpath, './/div[contains(., "bar")]')
+      #     element.sibling('ul', text: 'Quox').click_link('Delete')
+      #
+      # @param (see #find)
       #
       # @macro waiting_behavior
       #
-      # @param [String] locator             Which field to find
-      #
-      # @option options [Boolean] checked  Match checked field?
-      # @option options [Boolean] unchecked   Match unchecked field?
-      # @option options [Boolean, Symbol] disabled (false)  Match disabled field?
-      #                                                     * true - only finds a disabled field
-      #                                                     * false - only finds an enabled field
-      #                                                     * :all - finds either an enabled or disabled field
-      # @option options [Boolean] readonly Match readonly field?
-      # @option options [String] with   Value of field to match on
-      # @option options [String] type   Type of field to match on
+      # @return [Capybara::Node::Element]      The found element
+      # @raise  [Capybara::ElementNotFound]    If the element can't be found before time expires
+      #
+      def sibling(*args, **options, &optional_filter_block)
+        options[:session_options] = session_options
+        synced_resolve Capybara::Queries::SiblingQuery.new(*args, **options, &optional_filter_block)
+      end
+
+      ##
+      #
+      # Find a form field on the page. The field can be found by its name, id or label text.
+      #
+      # @overload find_field([locator], **options)
+      #   @param [String] locator             name, id, {Capybara.configure test_id} attribute, placeholder or text of associated label element
+      #
+      #   @macro waiting_behavior
+      #
+      #
+      #   @option options [Boolean] checked       Match checked field?
+      #   @option options [Boolean] unchecked     Match unchecked field?
+      #   @option options [Boolean, Symbol] disabled (false)  Match disabled field?
+      #                                                       * true - only finds a disabled field
+      #                                                       * false - only finds an enabled field
+      #                                                       * :all - finds either an enabled or disabled field
+      #   @option options [Boolean] readonly      Match readonly field?
+      #   @option options [String, Regexp] with   Value of field to match on
+      #   @option options [String] type           Type of field to match on
+      #   @option options [Boolean] multiple      Match fields that can have multiple values?
+      #   @option options [String, Regexp] id     Match fields that match the id attribute
+      #   @option options [String] name           Match fields that match the name attribute
+      #   @option options [String] placeholder    Match fields that match the placeholder attribute
+      #   @option options [String, Array<String>, Regexp] class Match fields that match the class(es) passed
       # @return [Capybara::Node::Element]   The found element
       #
-      def find_field(locator, options={})
-        find(:field, locator, options)
+      def find_field(locator = nil, **options, &optional_filter_block)
+        find(:field, locator, **options, &optional_filter_block)
       end
-      alias_method :field_labeled, :find_field
 
       ##
       #
       # Find a link on the page. The link can be found by its id or text.
       #
-      # @macro waiting_behavior
+      # @overload find_link([locator], **options)
+      #   @param [String] locator            id, {Capybara.configure test_id} attribute, title, text, or alt of enclosed img element
+      #
+      #   @macro waiting_behavior
       #
-      # @param [String] locator             Which link to find
-      # @option options [String,Regexp] href        Value to match against the links href
+      #   @option options [String,Regexp,nil] href    Value to match against the links href, if `nil` finds link placeholders (`<a>` elements with no href attribute), if `false` ignores the href
+      #   @option options [String, Regexp] id         Match links with the id provided
+      #   @option options [String] title              Match links with the title provided
+      #   @option options [String] alt                Match links with a contained img element whose alt matches
+      #   @option options [String, Array<String>, Regexp] class    Match links that match the class(es) provided
       # @return [Capybara::Node::Element]   The found element
       #
-      def find_link(locator, options={})
-        find(:link, locator, options)
+      def find_link(locator = nil, **options, &optional_filter_block)
+        find(:link, locator, **options, &optional_filter_block)
       end
 
       ##
       #
       # Find a button on the page.
-      # This can be any \<input> element of type submit, reset, image, button or it can be a
-      # \<button> element. All buttons can be found by their id, value, or title. \<button> elements can also be found
-      # by their text content, and image \<input> elements by their alt attribute
-
-      # @macro waiting_behavior
-      #
-      # @param [String] locator             Which button to find
-      # @option options [Boolean, Symbol] disabled (false)  Match disabled button?
-      #                                                     * true - only finds a disabled button
-      #                                                     * false - only finds an enabled button
-      #                                                     * :all - finds either an enabled or disabled button
+      # This can be any `<input>` element of type submit, reset, image, button or it can be a
+      # `<button>` element. All buttons can be found by their id, name, {Capybara.configure test_id} attribute, value, or title.
+      # `<button>` elements can also be found by their text content, and image `<input>` elements by their alt attribute.
+      #
+      # @overload find_button([locator], **options)
+      #   @param [String] locator            id, name, {Capybara.configure test_id} attribute, value, title, text content, alt of image
+      #
+      #   @macro waiting_behavior
+      #
+      #   @option options [Boolean, Symbol] disabled (false)  Match disabled button?
+      #                                                       * true - only finds a disabled button
+      #                                                       * false - only finds an enabled button
+      #                                                       * :all - finds either an enabled or disabled button
+      #   @option options [String, Regexp] id                 Match buttons with the id provided
+      #   @option options [String] name                       Match buttons with the name provided
+      #   @option options [String] title                      Match buttons with the title provided
+      #   @option options [String] value                      Match buttons with the value provided
+      #   @option options [String, Array<String>, Regexp] class    Match buttons that match the class(es) provided
       # @return [Capybara::Node::Element]   The found element
       #
-      def find_button(locator, options={})
-        find(:button, locator, options)
+      def find_button(locator = nil, **options, &optional_filter_block)
+        find(:button, locator, **options, &optional_filter_block)
       end
 
       ##
@@ -111,15 +182,16 @@ module Capybara
       #
       # @macro waiting_behavior
       #
-      # @param [String] id                  Which element to find
+      # @param [String] id                  id of element
       #
       # @return [Capybara::Node::Element]   The found element
       #
-      def find_by_id(id, options={})
-        find(:id, id, options)
+      def find_by_id(id, **options, &optional_filter_block)
+        find(:id, id, **options, &optional_filter_block)
       end
 
       ##
+      # @!method all([kind = Capybara.default_selector], locator = nil, **options)
       #
       # Find all elements on the page matching the given selector
       # and options.
@@ -129,60 +201,68 @@ module Capybara
       # following statements are equivalent:
       #
       #     page.all(:css, 'a#person_123')
-      #     page.all(:xpath, '//a[@id="person_123"]')
-      #
+      #     page.all(:xpath, './/a[@id="person_123"]')
       #
       # If the type of selector is left out, Capybara uses
-      # {Capybara.default_selector}. It's set to :css by default.
+      # {Capybara.configure default_selector}. It's set to `:css` by default.
       #
       #     page.all("a#person_123")
       #
       #     Capybara.default_selector = :xpath
-      #     page.all('//a[@id="person_123"]')
+      #     page.all('.//a[@id="person_123"]')
       #
       # The set of found elements can further be restricted by specifying
       # options. It's possible to select elements by their text or visibility:
       #
-      #     page.all('a', :text => 'Home')
-      #     page.all('#menu li', :visible => true)
-      #
-      # By default if no elements are found, an empty array is returned;
-      # however, expectations can be set on the number of elements to be found which
-      # will trigger Capybara's waiting behavior for the expectations to match.The
-      # expectations can be set using
+      #     page.all('a', text: 'Home')
+      #     page.all('#menu li', visible: true)
       #
-      #     page.assert_selector('p#foo', :count => 4)
-      #     page.assert_selector('p#foo', :maximum => 10)
-      #     page.assert_selector('p#foo', :minimum => 1)
-      #     page.assert_selector('p#foo', :between => 1..10)
+      # By default Capybara's waiting behavior will wait up to {Capybara.configure default_max_wait_time}
+      # seconds for matching elements to be available and then return an empty result if none
+      # are available. It is possible to set expectations on the number of results located and
+      # Capybara will raise an exception if the number of elements located don't satisfy the
+      # specified conditions. The expectations can be set using:
       #
-      # See {Capybara::Helpers#matches_count?} for additional information about
-      # count matching.
+      #     page.assert_selector('p#foo', count: 4)
+      #     page.assert_selector('p#foo', maximum: 10)
+      #     page.assert_selector('p#foo', minimum: 1)
+      #     page.assert_selector('p#foo', between: 1..10)
       #
-      # @overload all([kind], locator, options)
-      #   @param [:css, :xpath] kind                 The type of selector
-      #   @param [String] locator                    The selector
-      #   @option options [String, Regexp] text      Only find elements which contain this text or match this regexp
-      #   @option options [Boolean, Symbol] visible  Only find elements with the specified visibility:
-      #                                              * true - only finds visible elements.
-      #                                              * false - finds invisible _and_ visible elements.
-      #                                              * :all - same as false; finds visible and invisible elements.
-      #                                              * :hidden - only finds invisible elements.
-      #                                              * :visible - same as true; only finds visible elements.
-      #   @option options [Integer] count            Exact number of matches that are expected to be found
-      #   @option options [Integer] maximum          Maximum number of matches that are expected to be found
-      #   @option options [Integer] minimum          Minimum number of matches that are expected to be found
-      #   @option options [Range]   between          Number of matches found must be within the given range
-      #   @option options [Boolean] exact            Control whether `is` expressions in the given XPath match exactly or partially
-      #   @option options [Integer] wait (Capybara.default_max_wait_time)  The time to wait for element count expectations to become true
+      # @param [Symbol] kind                       Optional selector type (:css, :xpath, :field, etc.). Defaults to {Capybara.configure default_selector}.
+      # @param [String] locator                    The locator for the specified selector
+      # @macro system_filters
+      # @macro waiting_behavior
+      # @option options [Integer] count            Exact number of matches that are expected to be found
+      # @option options [Integer] maximum          Maximum number of matches that are expected to be found
+      # @option options [Integer] minimum          Minimum number of matches that are expected to be found
+      # @option options [Range]   between          Number of matches found must be within the given range
+      # @option options [Boolean] allow_reload     Beta feature - May be removed in any version.
+      #   When `true` allows elements to be reloaded if they become stale. This is an advanced behavior and should only be used
+      #   if you fully understand the potential ramifications. The results can be confusing on dynamic pages. Defaults to `false`
+      # @overload all([kind = Capybara.default_selector], locator = nil, **options)
+      # @overload all([kind = Capybara.default_selector], locator = nil, **options, &filter_block)
+      #   @yieldparam element [Capybara::Node::Element]  The element being considered for inclusion in the results
+      #   @yieldreturn [Boolean]                     Should the element be considered in the results?
       # @return [Capybara::Result]                   A collection of found elements
-      #
-      def all(*args)
-        query = Capybara::Queries::SelectorQuery.new(*args)
-        synchronize(query.wait) do
-          result = query.resolve_for(self)
-          raise Capybara::ExpectationNotMet, result.failure_message unless result.matches_count?
-          result
+      # @raise [Capybara::ExpectationNotMet]         The number of elements found doesn't match the specified conditions
+      def all(*args, allow_reload: false, **options, &optional_filter_block)
+        minimum_specified = options_include_minimum?(options)
+        options = { minimum: 1 }.merge(options) unless minimum_specified
+        options[:session_options] = session_options
+        query = Capybara::Queries::SelectorQuery.new(*args, **options, &optional_filter_block)
+        result = nil
+        begin
+          synchronize(query.wait) do
+            result = query.resolve_for(self)
+            result.allow_reload! if allow_reload
+            raise Capybara::ExpectationNotMet, result.failure_message unless result.matches_count?
+
+            result
+          end
+        rescue Capybara::ExpectationNotMet
+          raise if minimum_specified || (result.compare_count == 1)
+
+          Result.new([], nil)
         end
       end
       alias_method :find_all, :all
@@ -190,26 +270,56 @@ module Capybara
       ##
       #
       # Find the first element on the page matching the given selector
-      # and options, or nil if no element matches.  By default no waiting
-      # behavior occurs, however if {Capybara.wait_on_first_by_default} is set to true
-      # it will trigger Capybara's waiting behavior for a minimum of 1 matching element to be found and
-      # return the first.  Waiting behavior can also be triggered by passing in any of the count
-      # expectation options.
+      # and options. By default {#first} will wait up to {Capybara.configure default_max_wait_time}
+      # seconds for matching elements to appear and then raise an error if no matching
+      # element is found, or `nil` if the provided count options allow for empty results.
       #
       # @overload first([kind], locator, options)
-      #   @param [:css, :xpath] kind                 The type of selector
+      #   @param [Symbol] kind                       The type of selector
       #   @param [String] locator                    The selector
       #   @param [Hash] options                      Additional options; see {#all}
       # @return [Capybara::Node::Element]            The found element or nil
+      # @raise  [Capybara::ElementNotFound]          If element(s) matching the provided options can't be found before time expires
       #
-      def first(*args)
-        if Capybara.wait_on_first_by_default
-          options = if args.last.is_a?(Hash) then args.pop.dup else {} end
-          args.push({minimum: 1}.merge(options))
-        end
-        all(*args).first
-      rescue Capybara::ExpectationNotMet
-        nil
+      def first(*args, **options, &optional_filter_block)
+        options = { minimum: 1 }.merge(options) unless options_include_minimum?(options)
+        all(*args, **options, &optional_filter_block).first
+      end
+
+    private
+
+      def synced_resolve(query)
+        synchronize(query.wait) do
+          if prefer_exact?(query)
+            result = query.resolve_for(self, true)
+            result = query.resolve_for(self, false) if result.empty? && query.supports_exact? && !query.exact?
+          else
+            result = query.resolve_for(self)
+          end
+
+          if ambiguous?(query, result)
+            raise Capybara::Ambiguous, "Ambiguous match, found #{result.size} elements matching #{query.applied_description}"
+          end
+          raise Capybara::ElementNotFound, "Unable to find #{query.applied_description}" if result.empty?
+
+          result.first
+        end.tap(&:allow_reload!)
+      end
+
+      def ambiguous?(query, result)
+        %i[one smart].include?(query.match) && (result.size > 1)
+      end
+
+      def prefer_exact?(query)
+        %i[smart prefer_exact].include?(query.match)
+      end
+
+      def options_include_minimum?(opts)
+        %i[count minimum between].any? { |key| opts.key?(key) }
+      end
+
+      def parent
+        first(:xpath, './parent::*', minimum: 0)
       end
     end
   end

data/lib/capybara/node/matchers.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
+
 module Capybara
   module Node
     module Matchers
-
       ##
       #
-      # Checks if a given selector is on the page or current node.
+      # Checks if a given selector is on the page or a descendant of the current node.
       #
       #     page.has_selector?('p#foo')
       #     page.has_selector?(:xpath, './/p[@id="foo"]')
@@ -14,81 +14,68 @@ module Capybara
       # By default it will check if the expression occurs at least once,
       # but a different number can be specified.
       #
-      #     page.has_selector?('p.foo', :count => 4)
+      #     page.has_selector?('p.foo', count: 4)
       #
       # This will check if the expression occurs exactly 4 times.
       #
       # It also accepts all options that {Capybara::Node::Finders#all} accepts,
-      # such as :text and :visible.
+      # such as `:text` and `:visible`.
       #
-      #     page.has_selector?('li', :text => 'Horse', :visible => true)
+      #     page.has_selector?('li', text: 'Horse', visible: true)
       #
-      # has_selector? can also accept XPath expressions generated by the
+      # {#has_selector?} can also accept XPath expressions generated by the
       # XPath gem:
       #
       #     page.has_selector?(:xpath, XPath.descendant(:p))
       #
       # @param (see Capybara::Node::Finders#all)
-      # @param args
-      # @option args [Integer] :count (nil)     Number of times the text should occur
-      # @option args [Integer] :minimum (nil)   Minimum number of times the text should occur
-      # @option args [Integer] :maximum (nil)   Maximum number of times the text should occur
-      # @option args [Range]   :between (nil)   Range of times that should contain number of times text occurs
+      # @option options [Integer] :count (nil)     Number of matching elements that should exist
+      # @option options [Integer] :minimum (nil)   Minimum number of matching elements that should exist
+      # @option options [Integer] :maximum (nil)   Maximum number of matching elements that should exist
+      # @option options [Range]   :between (nil)   Range of number of matching elements that should exist
       # @return [Boolean]                       If the expression exists
       #
-      def has_selector?(*args)
-        assert_selector(*args)
-      rescue Capybara::ExpectationNotMet
-        return false
+      def has_selector?(*args, **options, &optional_filter_block)
+        make_predicate(options) { assert_selector(*args, options, &optional_filter_block) }
       end
 
       ##
       #
-      # Checks if a given selector is not on the page or current node.
-      # Usage is identical to Capybara::Node::Matchers#has_selector?
+      # Checks if a given selector is not on the page or a descendant of the current node.
+      # Usage is identical to {#has_selector?}.
       #
-      # @param (see Capybara::Node::Finders#has_selector?)
+      # @param (see #has_selector?)
       # @return [Boolean]
       #
-      def has_no_selector?(*args)
-        assert_no_selector(*args)
-      rescue Capybara::ExpectationNotMet
-        return false
+      def has_no_selector?(*args, **options, &optional_filter_block)
+        make_predicate(options) { assert_no_selector(*args, options, &optional_filter_block) }
       end
 
       ##
       #
-      # Checks if the current node matches given selector
-      # Usage is identical to Capybara::Node::Matchers#has_selector?
+      # Checks if a an element has the specified CSS styles.
       #
-      # @param (see Capybara::Node::Finders#has_selector?)
-      # @return [Boolean]
+      #     element.matches_style?( 'color' => 'rgb(0,0,255)', 'font-size' => /px/ )
       #
-      def matches_selector?(*args)
-        assert_matches_selector(*args)
-      rescue Capybara::ExpectationNotMet
-        return false
+      # @param styles [Hash]
+      # @return [Boolean]                       If the styles match
+      #
+      def matches_style?(styles = nil, **options)
+        styles, options = options, {} if styles.nil?
+        make_predicate(options) { assert_matches_style(styles, **options) }
       end
 
-
       ##
+      # @deprecated Use {#matches_style?} instead.
       #
-      # Checks if the current node does not match given selector
-      # Usage is identical to Capybara::Node::Matchers#has_selector?
-      #
-      # @param (see Capybara::Node::Finders#has_selector?)
-      # @return [Boolean]
-      #
-      def not_matches_selector?(*args)
-        assert_not_matches_selector(*args)
-      rescue Capybara::ExpectationNotMet
-        return false
+      def has_style?(styles = nil, **options)
+        Capybara::Helpers.warn "DEPRECATED: has_style? is deprecated, please use matches_style? : #{Capybara::Helpers.filter_backtrace(caller)}"
+        matches_style?(styles, **options)
       end
 
-
       ##
       #
-      # Asserts that a given selector is on the page or current node.
+      # Asserts that a given selector is on the page or a descendant of the current node.
       #
       #     page.assert_selector('p#foo')
       #     page.assert_selector(:xpath, './/p[@id="foo"]')
@@ -97,20 +84,20 @@ module Capybara
       # By default it will check if the expression occurs at least once,
       # but a different number can be specified.
       #
-      #     page.assert_selector('p#foo', :count => 4)
+      #     page.assert_selector('p#foo', count: 4)
       #
       # This will check if the expression occurs exactly 4 times. See
       # {Capybara::Node::Finders#all} for other available result size options.
       #
-      # If a :count of 0 is specified, it will behave like {#assert_no_selector};
+      # If a `:count` of 0 is specified, it will behave like {#assert_no_selector};
       # however, use of that method is preferred over this one.
       #
       # It also accepts all options that {Capybara::Node::Finders#all} accepts,
-      # such as :text and :visible.
+      # such as `:text` and `:visible`.
       #
-      #     page.assert_selector('li', :text => 'Horse', :visible => true)
+      #     page.assert_selector('li', text: 'Horse', visible: true)
       #
-      # `assert_selector` can also accept XPath expressions generated by the
+      # {#assert_selector} can also accept XPath expressions generated by the
       # XPath gem:
       #
       #     page.assert_selector(:xpath, XPath.descendant(:p))
@@ -119,105 +106,157 @@ module Capybara
       # @option options [Integer] :count (nil)    Number of times the expression should occur
       # @raise [Capybara::ExpectationNotMet]      If the selector does not exist
       #
-      def assert_selector(*args)
-        query = Capybara::Queries::SelectorQuery.new(*args)
-        synchronize(query.wait) do
-          result = query.resolve_for(self)
-          matches_count = Capybara::Helpers.matches_count?(result.size, query.options)
-          unless matches_count && ((result.size > 0) || Capybara::Helpers.expects_none?(query.options))
+      def assert_selector(*args, &optional_filter_block)
+        _verify_selector_result(args, optional_filter_block) do |result, query|
+          unless result.matches_count? && (result.any? || query.expects_none?)
             raise Capybara::ExpectationNotMet, result.failure_message
           end
         end
-        return true
       end
 
       ##
       #
-      # Asserts that a given selector is not on the page or current node.
-      # Usage is identical to Capybara::Node::Matchers#assert_selector
-      #
-      # Query options such as :count, :minimum, :maximum, and :between are
-      # considered to be an integral part of the selector. This will return
-      # true, for example, if a page contains 4 anchors but the query expects 5:
+      # Asserts that an element has the specified CSS styles.
       #
-      #     page.assert_no_selector('a', :minimum => 1) # Found, raises Capybara::ExpectationNotMet
-      #     page.assert_no_selector('a', :count => 4)   # Found, raises Capybara::ExpectationNotMet
-      #     page.assert_no_selector('a', :count => 5)   # Not Found, returns true
+      #     element.assert_matches_style( 'color' => 'rgb(0,0,255)', 'font-size' => /px/ )
       #
-      # @param (see Capybara::Node::Finders#assert_selector)
-      # @raise [Capybara::ExpectationNotMet]      If the selector exists
+      # @param styles [Hash]
+      # @raise [Capybara::ExpectationNotMet]    If the element doesn't have the specified styles
       #
-      def assert_no_selector(*args)
-        query = Capybara::Queries::SelectorQuery.new(*args)
+      def assert_matches_style(styles = nil, **options)
+        styles, options = options, {} if styles.nil?
+        query_args, query_opts = _set_query_session_options(styles, options)
+        query = Capybara::Queries::StyleQuery.new(*query_args, **query_opts)
         synchronize(query.wait) do
-          result = query.resolve_for(self)
-          matches_count = Capybara::Helpers.matches_count?(result.size, query.options)
-          if matches_count && ((result.size > 0) || Capybara::Helpers.expects_none?(query.options))
-            raise Capybara::ExpectationNotMet, result.negative_failure_message
-          end
+          raise Capybara::ExpectationNotMet, query.failure_message unless query.resolves_for?(self)
         end
-        return true
+        true
       end
-      alias_method :refute_selector, :assert_no_selector
 
       ##
+      # @deprecated Use {#assert_matches_style} instead.
       #
-      # Asserts that the current_node matches a given selector
+      def assert_style(styles = nil, **options)
+        warn 'assert_style is deprecated, please use assert_matches_style instead'
+        assert_matches_style(styles, **options)
+      end
+
+      # Asserts that all of the provided selectors are present on the given page
+      # or descendants of the current node.  If options are provided, the assertion
+      # will check that each locator is present with those options as well (other than `:wait`).
       #
-      #     node.assert_matches_selector('p#foo')
-      #     node.assert_matches_selector(:xpath, '//p[@id="foo"]')
-      #     node.assert_matches_selector(:foo)
+      #     page.assert_all_of_selectors(:custom, 'Tom', 'Joe', visible: all)
+      #     page.assert_all_of_selectors(:css, '#my_div', 'a.not_clicked')
       #
-      # It also accepts all options that {Capybara::Node::Finders#all} accepts,
-      # such as :text and :visible.
+      # It accepts all options that {Capybara::Node::Finders#all} accepts,
+      # such as `:text` and `:visible`.
       #
-      #     node.assert_matches_selector('li', :text => 'Horse', :visible => true)
+      # The `:wait` option applies to all of the selectors as a group, so all of the locators must be present
+      # within `:wait` (defaults to {Capybara.configure default_max_wait_time}) seconds.
       #
-      # @param (see Capybara::Node::Finders#all)
-      # @raise [Capybara::ExpectationNotMet]      If the selector does not match
+      # @overload assert_all_of_selectors([kind = Capybara.default_selector], *locators, **options)
       #
-      def assert_matches_selector(*args)
-        query = Capybara::Queries::MatchQuery.new(*args)
-        synchronize(query.wait) do
-          result = query.resolve_for(self.parent)
-          unless result.include? self
-            raise Capybara::ExpectationNotMet, "Item does not match the provided selector"
+      def assert_all_of_selectors(*args, **options, &optional_filter_block)
+        _verify_multiple(*args, **options) do |selector, locator, opts|
+          assert_selector(selector, locator, opts, &optional_filter_block)
+        end
+      end
+
+      # Asserts that none of the provided selectors are present on the given page
+      # or descendants of the current node. If options are provided, the assertion
+      # will check that each locator is not present with those options as well (other than `:wait`).
+      #
+      #     page.assert_none_of_selectors(:custom, 'Tom', 'Joe', visible: all)
+      #     page.assert_none_of_selectors(:css, '#my_div', 'a.not_clicked')
+      #
+      # It accepts all options that {Capybara::Node::Finders#all} accepts,
+      # such as `:text` and `:visible`.
+      #
+      # The `:wait` option applies to all of the selectors as a group, so none of the locators must be present
+      # within `:wait` (defaults to {Capybara.configure default_max_wait_time}) seconds.
+      #
+      # @overload assert_none_of_selectors([kind = Capybara.default_selector], *locators, **options)
+      #
+      def assert_none_of_selectors(*args, **options, &optional_filter_block)
+        _verify_multiple(*args, **options) do |selector, locator, opts|
+          assert_no_selector(selector, locator, opts, &optional_filter_block)
+        end
+      end
+
+      # Asserts that any of the provided selectors are present on the given page
+      # or descendants of the current node. If options are provided, the assertion
+      # will check that each locator is present with those options as well (other than `:wait`).
+      #
+      #     page.assert_any_of_selectors(:custom, 'Tom', 'Joe', visible: all)
+      #     page.assert_any_of_selectors(:css, '#my_div', 'a.not_clicked')
+      #
+      # It accepts all options that {Capybara::Node::Finders#all} accepts,
+      # such as `:text` and `:visible`.
+      #
+      # The `:wait` option applies to all of the selectors as a group, so any of the locators must be present
+      # within `:wait` (defaults to {Capybara.configure default_max_wait_time}) seconds.
+      #
+      # @overload assert_any_of_selectors([kind = Capybara.default_selector], *locators, **options)
+      #
+      def assert_any_of_selectors(*args, wait: nil, **options, &optional_filter_block)
+        wait = session_options.default_max_wait_time if wait.nil?
+        selector = extract_selector(args)
+        synchronize(wait) do
+          res = args.map do |locator|
+            assert_selector(selector, locator, options, &optional_filter_block)
+            break nil
+          rescue Capybara::ExpectationNotMet => e
+            e.message
           end
+          raise Capybara::ExpectationNotMet, res.join(' or ') if res
+
+          true
         end
-        return true
       end
 
-      def assert_not_matches_selector(*args)
-        query = Capybara::Queries::MatchQuery.new(*args)
-        synchronize(query.wait) do
-          result = query.resolve_for(self.parent)
-          if result.include? self
-            raise Capybara::ExpectationNotMet, 'Item matched the provided selector'
+      ##
+      #
+      # Asserts that a given selector is not on the page or a descendant of the current node.
+      # Usage is identical to {#assert_selector}.
+      #
+      # Query options such as `:count`, `:minimum`, `:maximum`, and `:between` are
+      # considered to be an integral part of the selector. This will return
+      # `true`, for example, if a page contains 4 anchors but the query expects 5:
+      #
+      #     page.assert_no_selector('a', minimum: 1) # Found, raises Capybara::ExpectationNotMet
+      #     page.assert_no_selector('a', count: 4)   # Found, raises Capybara::ExpectationNotMet
+      #     page.assert_no_selector('a', count: 5)   # Not Found, returns true
+      #
+      # @param (see #assert_selector)
+      # @raise [Capybara::ExpectationNotMet]      If the selector exists
+      #
+      def assert_no_selector(*args, &optional_filter_block)
+        _verify_selector_result(args, optional_filter_block) do |result, query|
+          if result.matches_count? && (!result.empty? || query.expects_none?)
+            raise Capybara::ExpectationNotMet, result.negative_failure_message
           end
         end
-        return true
       end
-      alias_method :refute_matches_selector, :assert_not_matches_selector
 
       ##
       #
-      # Checks if a given XPath expression is on the page or current node.
+      # Checks if a given XPath expression is on the page or a descendant of the current node.
       #
       #     page.has_xpath?('.//p[@id="foo"]')
       #
       # By default it will check if the expression occurs at least once,
       # but a different number can be specified.
       #
-      #     page.has_xpath?('.//p[@id="foo"]', :count => 4)
+      #     page.has_xpath?('.//p[@id="foo"]', count: 4)
       #
       # This will check if the expression occurs exactly 4 times.
       #
       # It also accepts all options that {Capybara::Node::Finders#all} accepts,
-      # such as :text and :visible.
+      # such as `:text` and `:visible`.
       #
-      #     page.has_xpath?('.//li', :text => 'Horse', :visible => true)
+      #     page.has_xpath?('.//li', text: 'Horse', visible: true)
       #
-      # has_xpath? can also accept XPath expressions generate by the
+      # {#has_xpath?} can also accept XPath expressions generated by the
       # XPath gem:
       #
       #     xpath = XPath.generate { |x| x.descendant(:p) }
@@ -228,59 +267,59 @@ module Capybara
       # @option options [Integer] :count (nil)    Number of times the expression should occur
       # @return [Boolean]                         If the expression exists
       #
-      def has_xpath?(path, options={})
-        has_selector?(:xpath, path, options)
+      def has_xpath?(path, **options, &optional_filter_block)
+        has_selector?(:xpath, path, **options, &optional_filter_block)
       end
 
       ##
       #
-      # Checks if a given XPath expression is not on the page or current node.
-      # Usage is identical to Capybara::Node::Matchers#has_xpath?
+      # Checks if a given XPath expression is not on the page or a descendant of the current node.
+      # Usage is identical to {#has_xpath?}.
       #
-      # @param (see Capybara::Node::Finders#has_xpath?)
+      # @param (see #has_xpath?)
       # @return [Boolean]
       #
-      def has_no_xpath?(path, options={})
-        has_no_selector?(:xpath, path, options)
+      def has_no_xpath?(path, **options, &optional_filter_block)
+        has_no_selector?(:xpath, path, **options, &optional_filter_block)
       end
 
       ##
       #
-      # Checks if a given CSS selector is on the page or current node.
+      # Checks if a given CSS selector is on the page or a descendant of the current node.
       #
       #     page.has_css?('p#foo')
       #
       # By default it will check if the selector occurs at least once,
       # but a different number can be specified.
       #
-      #     page.has_css?('p#foo', :count => 4)
+      #     page.has_css?('p#foo', count: 4)
       #
       # This will check if the selector occurs exactly 4 times.
       #
       # It also accepts all options that {Capybara::Node::Finders#all} accepts,
-      # such as :text and :visible.
+      # such as `:text` and `:visible`.
       #
-      #     page.has_css?('li', :text => 'Horse', :visible => true)
+      #     page.has_css?('li', text: 'Horse', visible: true)
       #
       # @param [String] path                      A CSS selector
       # @param options                            (see Capybara::Node::Finders#all)
       # @option options [Integer] :count (nil)    Number of times the selector should occur
       # @return [Boolean]                         If the selector exists
       #
-      def has_css?(path, options={})
-        has_selector?(:css, path, options)
+      def has_css?(path, **options, &optional_filter_block)
+        has_selector?(:css, path, **options, &optional_filter_block)
       end
 
       ##
       #
-      # Checks if a given CSS selector is not on the page or current node.
-      # Usage is identical to Capybara::Node::Matchers#has_css?
+      # Checks if a given CSS selector is not on the page or a descendant of the current node.
+      # Usage is identical to {#has_css?}.
       #
-      # @param (see Capybara::Node::Finders#has_css?)
+      # @param (see #has_css?)
       # @return [Boolean]
       #
-      def has_no_css?(path, options={})
-        has_no_selector?(:css, path, options)
+      def has_no_css?(path, **options, &optional_filter_block)
+        has_no_selector?(:css, path, **options, &optional_filter_block)
       end
 
       ##
@@ -289,12 +328,11 @@ module Capybara
       # text or id.
       #
       # @param [String] locator           The text or id of a link to check for
-      # @param options
       # @option options [String, Regexp] :href    The value the href attribute must be
       # @return [Boolean]                 Whether it exists
       #
-      def has_link?(locator, options={})
-        has_selector?(:link, locator, options)
+      def has_link?(locator = nil, **options, &optional_filter_block)
+        has_selector?(:link, locator, **options, &optional_filter_block)
       end
 
       ##
@@ -302,11 +340,11 @@ module Capybara
       # Checks if the page or current node has no link with the given
       # text or id.
       #
-      # @param (see Capybara::Node::Finders#has_link?)
+      # @param (see #has_link?)
       # @return [Boolean]            Whether it doesn't exist
       #
-      def has_no_link?(locator, options={})
-        has_no_selector?(:link, locator, options)
+      def has_no_link?(locator = nil, **options, &optional_filter_block)
+        has_no_selector?(:link, locator, **options, &optional_filter_block)
       end
 
       ##
@@ -317,8 +355,8 @@ module Capybara
       # @param [String] locator      The text, value or id of a button to check for
       # @return [Boolean]            Whether it exists
       #
-      def has_button?(locator, options={})
-        has_selector?(:button, locator, options)
+      def has_button?(locator = nil, **options, &optional_filter_block)
+        has_selector?(:button, locator, **options, &optional_filter_block)
       end
 
       ##
@@ -329,8 +367,8 @@ module Capybara
       # @param [String] locator      The text, value or id of a button to check for
       # @return [Boolean]            Whether it doesn't exist
       #
-      def has_no_button?(locator, options={})
-        has_no_selector?(:button, locator, options)
+      def has_no_button?(locator = nil, **options, &optional_filter_block)
+        has_no_selector?(:button, locator, **options, &optional_filter_block)
       end
 
       ##
@@ -339,90 +377,90 @@ module Capybara
       # label, name or id.
       #
       # For text fields and other textual fields, such as textareas and
-      # HTML5 email/url/etc. fields, it's possible to specify a :with
+      # HTML5 email/url/etc. fields, it's possible to specify a `:with`
       # option to specify the text the field should contain:
       #
-      #     page.has_field?('Name', :with => 'Jonas')
+      #     page.has_field?('Name', with: 'Jonas')
       #
       # It is also possible to filter by the field type attribute:
       #
-      #     page.has_field?('Email', :type => 'email')
+      #     page.has_field?('Email', type: 'email')
       #
-      # Note: 'textarea' and 'select' are valid type values, matching the associated tag names.
+      # NOTE: 'textarea' and 'select' are valid type values, matching the associated tag names.
       #
-      # @param [String] locator           The label, name or id of a field to check for
-      # @option options [String] :with    The text content of the field
-      # @option options [String] :type    The type attribute of the field
-      # @return [Boolean]                 Whether it exists
+      # @param [String] locator                  The label, name or id of a field to check for
+      # @option options [String, Regexp] :with   The text content of the field or a Regexp to match
+      # @option options [String] :type           The type attribute of the field
+      # @return [Boolean]                        Whether it exists
       #
-      def has_field?(locator, options={})
-        has_selector?(:field, locator, options)
+      def has_field?(locator = nil, **options, &optional_filter_block)
+        has_selector?(:field, locator, **options, &optional_filter_block)
       end
 
       ##
       #
       # Checks if the page or current node has no form field with the given
-      # label, name or id. See {Capybara::Node::Matchers#has_field?}.
+      # label, name or id. See {#has_field?}.
       #
-      # @param [String] locator           The label, name or id of a field to check for
-      # @option options [String] :with    The text content of the field
-      # @option options [String] :type    The type attribute of the field
-      # @return [Boolean]                 Whether it doesn't exist
+      # @param [String] locator                  The label, name or id of a field to check for
+      # @option options [String, Regexp] :with   The text content of the field or a Regexp to match
+      # @option options [String] :type           The type attribute of the field
+      # @return [Boolean]                        Whether it doesn't exist
       #
-      def has_no_field?(locator, options={})
-        has_no_selector?(:field, locator, options)
+      def has_no_field?(locator = nil, **options, &optional_filter_block)
+        has_no_selector?(:field, locator, **options, &optional_filter_block)
       end
 
       ##
       #
       # Checks if the page or current node has a radio button or
-      # checkbox with the given label, value or id, that is currently
+      # checkbox with the given label, value, id, or {Capybara.configure test_id} attribute that is currently
       # checked.
       #
       # @param [String] locator           The label, name or id of a checked field
       # @return [Boolean]                 Whether it exists
       #
-      def has_checked_field?(locator, options={})
-        has_selector?(:field, locator, options.merge(:checked => true))
+      def has_checked_field?(locator = nil, **options, &optional_filter_block)
+        has_selector?(:field, locator, **options.merge(checked: true), &optional_filter_block)
       end
 
       ##
       #
       # Checks if the page or current node has no radio button or
-      # checkbox with the given label, value or id, that is currently
+      # checkbox with the given label, value or id, or {Capybara.configure test_id} attribute that is currently
       # checked.
       #
       # @param [String] locator           The label, name or id of a checked field
       # @return [Boolean]                 Whether it doesn't exist
       #
-      def has_no_checked_field?(locator, options={})
-        has_no_selector?(:field, locator, options.merge(:checked => true))
+      def has_no_checked_field?(locator = nil, **options, &optional_filter_block)
+        has_no_selector?(:field, locator, **options.merge(checked: true), &optional_filter_block)
       end
 
       ##
       #
       # Checks if the page or current node has a radio button or
-      # checkbox with the given label, value or id, that is currently
+      # checkbox with the given label, value or id, or {Capybara.configure test_id} attribute that is currently
       # unchecked.
       #
       # @param [String] locator           The label, name or id of an unchecked field
       # @return [Boolean]                 Whether it exists
       #
-      def has_unchecked_field?(locator, options={})
-        has_selector?(:field, locator, options.merge(:unchecked => true))
+      def has_unchecked_field?(locator = nil, **options, &optional_filter_block)
+        has_selector?(:field, locator, **options.merge(unchecked: true), &optional_filter_block)
       end
 
       ##
       #
       # Checks if the page or current node has no radio button or
-      # checkbox with the given label, value or id, that is currently
+      # checkbox with the given label, value or id, or {Capybara.configure test_id} attribute that is currently
       # unchecked.
       #
       # @param [String] locator           The label, name or id of an unchecked field
       # @return [Boolean]                 Whether it doesn't exist
       #
-      def has_no_unchecked_field?(locator, options={})
-        has_no_selector?(:field, locator, options.merge(:unchecked => true))
+      def has_no_unchecked_field?(locator = nil, **options, &optional_filter_block)
+        has_no_selector?(:field, locator, **options.merge(unchecked: true), &optional_filter_block)
       end
 
       ##
@@ -432,41 +470,42 @@ module Capybara
       #
       # It can be specified which option should currently be selected:
       #
-      #     page.has_select?('Language', :selected => 'German')
+      #     page.has_select?('Language', selected: 'German')
       #
       # For multiple select boxes, several options may be specified:
       #
-      #     page.has_select?('Language', :selected => ['English', 'German'])
+      #     page.has_select?('Language', selected: ['English', 'German'])
       #
       # It's also possible to check if the exact set of options exists for
       # this select box:
       #
-      #     page.has_select?('Language', :options => ['English', 'German', 'Spanish'])
+      #     page.has_select?('Language', options: ['English', 'German', 'Spanish'])
       #
       # You can also check for a partial set of options:
       #
-      #     page.has_select?('Language', :with_options => ['English', 'German'])
+      #     page.has_select?('Language', with_options: ['English', 'German'])
       #
-      # @param [String] locator                      The label, name or id of a select box
-      # @option options [Array] :options             Options which should be contained in this select box
-      # @option options [Array] :with_options        Partial set of options which should be contained in this select box
-      # @option options [String, Array] :selected    Options which should be selected
-      # @return [Boolean]                            Whether it exists
+      # @param [String] locator                         The label, name or id of a select box
+      # @option options [Array] :options                Options which should be contained in this select box
+      # @option options [Array] :with_options           Partial set of options which should be contained in this select box
+      # @option options [String, Array] :selected       Options which should be selected
+      # @option options [String, Array] :with_selected  Partial set of options which should minimally be selected
+      # @return [Boolean]                               Whether it exists
       #
-      def has_select?(locator, options={})
-        has_selector?(:select, locator, options)
+      def has_select?(locator = nil, **options, &optional_filter_block)
+        has_selector?(:select, locator, **options, &optional_filter_block)
       end
 
       ##
       #
       # Checks if the page or current node has no select field with the
-      # given label, name or id. See {Capybara::Node::Matchers#has_select?}.
+      # given label, name or id. See {#has_select?}.
       #
-      # @param (see Capybara::Node::Matchers#has_select?)
+      # @param (see #has_select?)
       # @return [Boolean]     Whether it doesn't exist
       #
-      def has_no_select?(locator, options={})
-        has_no_selector?(:select, locator, options)
+      def has_no_select?(locator = nil, **options, &optional_filter_block)
+        has_no_selector?(:select, locator, **options, &optional_filter_block)
       end
 
       ##
@@ -476,23 +515,134 @@ module Capybara
       #
       #    page.has_table?('People')
       #
-      # @param [String] locator                        The id or caption of a table
-      # @return [Boolean]                              Whether it exist
-      #
-      def has_table?(locator, options={})
-        has_selector?(:table, locator, options)
+      # @param [String] locator  The id or caption of a table
+      # @option options [Array<Array<String>>] :rows
+      #   Text which should be contained in the tables `<td>` elements organized by row (`<td>` visibility is not considered)
+      # @option options [Array<Array<String>>, Array<Hash<String,String>>] :with_rows
+      #   Partial set of text which should be contained in the tables `<td>` elements organized by row (`<td>` visibility is not considered)
+      # @option options [Array<Array<String>>] :cols
+      #   Text which should be contained in the tables `<td>` elements organized by column (`<td>` visibility is not considered)
+      # @option options [Array<Array<String>>, Array<Hash<String,String>>] :with_cols
+      #   Partial set of text which should be contained in the tables `<td>` elements organized by column (`<td>` visibility is not considered)
+      # @return [Boolean]        Whether it exists
+      #
+      def has_table?(locator = nil, **options, &optional_filter_block)
+        has_selector?(:table, locator, **options, &optional_filter_block)
       end
 
       ##
       #
       # Checks if the page or current node has no table with the given id
-      # or caption. See {Capybara::Node::Matchers#has_table?}.
+      # or caption. See {#has_table?}.
       #
-      # @param (see Capybara::Node::Matchers#has_table?)
+      # @param (see #has_table?)
       # @return [Boolean]       Whether it doesn't exist
       #
-      def has_no_table?(locator, options={})
-        has_no_selector?(:table, locator, options)
+      def has_no_table?(locator = nil, **options, &optional_filter_block)
+        has_no_selector?(:table, locator, **options, &optional_filter_block)
+      end
+
+      ##
+      #
+      # Asserts that the current node matches a given selector.
+      #
+      #     node.assert_matches_selector('p#foo')
+      #     node.assert_matches_selector(:xpath, '//p[@id="foo"]')
+      #     node.assert_matches_selector(:foo)
+      #
+      # It also accepts all options that {Capybara::Node::Finders#all} accepts,
+      # such as `:text` and `:visible`.
+      #
+      #     node.assert_matches_selector('li', text: 'Horse', visible: true)
+      #
+      # @param (see Capybara::Node::Finders#all)
+      # @raise [Capybara::ExpectationNotMet]      If the selector does not match
+      #
+      def assert_matches_selector(*args, &optional_filter_block)
+        _verify_match_result(args, optional_filter_block) do |result|
+          raise Capybara::ExpectationNotMet, 'Item does not match the provided selector' unless result.include? self
+        end
+      end
+
+      ##
+      #
+      # Asserts that the current node does not match a given selector.
+      # Usage is identical to {#assert_matches_selector}.
+      #
+      # @param (see #assert_matches_selector)
+      # @raise [Capybara::ExpectationNotMet]      If the selector matches
+      #
+      def assert_not_matches_selector(*args, &optional_filter_block)
+        _verify_match_result(args, optional_filter_block) do |result|
+          raise Capybara::ExpectationNotMet, 'Item matched the provided selector' if result.include? self
+        end
+      end
+
+      ##
+      #
+      # Checks if the current node matches given selector.
+      #
+      # @param (see #has_selector?)
+      # @return [Boolean]
+      #
+      def matches_selector?(*args, **options, &optional_filter_block)
+        make_predicate(options) { assert_matches_selector(*args, options, &optional_filter_block) }
+      end
+
+      ##
+      #
+      # Checks if the current node matches given XPath expression.
+      #
+      # @param [String, XPath::Expression] xpath The XPath expression to match against the current code
+      # @return [Boolean]
+      #
+      def matches_xpath?(xpath, **options, &optional_filter_block)
+        matches_selector?(:xpath, xpath, **options, &optional_filter_block)
+      end
+
+      ##
+      #
+      # Checks if the current node matches given CSS selector.
+      #
+      # @param [String] css The CSS selector to match against the current code
+      # @return [Boolean]
+      #
+      def matches_css?(css, **options, &optional_filter_block)
+        matches_selector?(:css, css, **options, &optional_filter_block)
+      end
+
+      ##
+      #
+      # Checks if the current node does not match given selector.
+      # Usage is identical to {#has_selector?}.
+      #
+      # @param (see #has_selector?)
+      # @return [Boolean]
+      #
+      def not_matches_selector?(*args, **options, &optional_filter_block)
+        make_predicate(options) { assert_not_matches_selector(*args, options, &optional_filter_block) }
+      end
+
+      ##
+      #
+      # Checks if the current node does not match given XPath expression.
+      #
+      # @param [String, XPath::Expression] xpath The XPath expression to match against the current code
+      # @return [Boolean]
+      #
+      def not_matches_xpath?(xpath, **options, &optional_filter_block)
+        not_matches_selector?(:xpath, xpath, **options, &optional_filter_block)
+      end
+
+      ##
+      #
+      # Checks if the current node does not match given CSS selector.
+      #
+      # @param [String] css The CSS selector to match against the current code
+      # @return [Boolean]
+      #
+      def not_matches_css?(css, **options, &optional_filter_block)
+        not_matches_selector?(:css, css, **options, &optional_filter_block)
       end
 
       ##
@@ -500,34 +650,34 @@ module Capybara
       # ignoring any HTML tags.
       #
       # @!macro text_query_params
-      #   @overload $0(type, text, options = {})
-      #     @param [:all, :visible] type               Whether to check for only visible or all text
+      #   @overload $0(type, text, **options)
+      #     @param [:all, :visible] type               Whether to check for only visible or all text. If this parameter is missing or nil then we use the value of {Capybara.configure ignore_hidden_elements}, which defaults to `true`, corresponding to `:visible`.
       #     @param [String, Regexp] text               The string/regexp to check for. If it's a string, text is expected to include it. If it's a regexp, text is expected to match it.
       #     @option options [Integer] :count (nil)     Number of times the text is expected to occur
       #     @option options [Integer] :minimum (nil)   Minimum number of times the text is expected to occur
       #     @option options [Integer] :maximum (nil)   Maximum number of times the text is expected to occur
       #     @option options [Range]   :between (nil)   Range of times that is expected to contain number of times text occurs
-      #     @option options [Numeric] :wait (Capybara.default_max_wait_time)      Maximum time that Capybara will wait for text to eq/match given string/regexp argument
-      #   @overload $0(text, options = {})
+      #     @option options [Numeric] :wait            Maximum time that Capybara will wait for text to eq/match given string/regexp argument. Defaults to {Capybara.configure default_max_wait_time}.
+      #     @option options [Boolean] :exact           Whether text must be an exact match or just substring. Defaults to {Capybara.configure exact_text}.
+      #     @option options [Boolean] :normalize_ws (false) When `true` replace all whitespace with standard spaces and collapse consecutive whitespace to a single space
+      #   @overload $0(text, **options)
       #     @param [String, Regexp] text               The string/regexp to check for. If it's a string, text is expected to include it. If it's a regexp, text is expected to match it.
       #     @option options [Integer] :count (nil)     Number of times the text is expected to occur
       #     @option options [Integer] :minimum (nil)   Minimum number of times the text is expected to occur
       #     @option options [Integer] :maximum (nil)   Maximum number of times the text is expected to occur
       #     @option options [Range]   :between (nil)   Range of times that is expected to contain number of times text occurs
-      #     @option options [Numeric] :wait (Capybara.default_max_wait_time)      Maximum time that Capybara will wait for text to eq/match given string/regexp argument
+      #     @option options [Numeric] :wait            Maximum time that Capybara will wait for text to eq/match given string/regexp argument. Defaults to {Capybara.configure default_max_wait_time}.
+      #     @option options [Boolean] :exact           Whether text must be an exact match or just substring. Defaults to {Capybara.configure exact_text}.
+      #     @option options [Boolean] :normalize_ws (false) When `true` replace all whitespace with standard spaces and collapse consecutive whitespace to a single space
       # @raise [Capybara::ExpectationNotMet] if the assertion hasn't succeeded during wait time
       # @return [true]
       #
-      def assert_text(*args)
-        query = Capybara::Queries::TextQuery.new(*args)
-        synchronize(query.wait) do
-          count = query.resolve_for(self)
-          matches_count = Capybara::Helpers.matches_count?(count, query.options)
-          unless matches_count && ((count > 0) || Capybara::Helpers.expects_none?(query.options))
+      def assert_text(type_or_text, *args, **opts)
+        _verify_text(type_or_text, *args, **opts) do |count, query|
+          unless query.matches_count?(count) && (count.positive? || query.expects_none?)
             raise Capybara::ExpectationNotMet, query.failure_message
           end
         end
-        return true
       end
 
       ##
@@ -538,26 +688,18 @@ module Capybara
       # @raise [Capybara::ExpectationNotMet] if the assertion hasn't succeeded during wait time
       # @return [true]
       #
-      def assert_no_text(*args)
-        query = Capybara::Queries::TextQuery.new(*args)
-        synchronize(query.wait) do
-          count = query.resolve_for(self)
-          matches_count = Capybara::Helpers.matches_count?(count, query.options)
-          if matches_count && ((count > 0) || Capybara::Helpers.expects_none?(query.options))
+      def assert_no_text(type_or_text, *args, **opts)
+        _verify_text(type_or_text, *args, **opts) do |count, query|
+          if query.matches_count?(count) && (count.positive? || query.expects_none?)
             raise Capybara::ExpectationNotMet, query.negative_failure_message
           end
         end
-        return true
       end
 
       ##
       # Checks if the page or current node has the given text content,
       # ignoring any HTML tags.
       #
-      # Whitespaces are normalized in both node's text and passed text parameter.
-      # Note that whitespace isn't normalized in passed regexp as normalizing whitespace
-      # in regexp isn't easy and doesn't seem to be worth it.
-      #
       # By default it will check if the text occurs at least once,
       # but a different number can be specified.
       #
@@ -568,10 +710,8 @@ module Capybara
       # @macro text_query_params
       # @return [Boolean]                            Whether it exists
       #
-      def has_text?(*args)
-        assert_text(*args)
-      rescue Capybara::ExpectationNotMet
-        return false
+      def has_text?(*args, **options)
+        make_predicate(options) { assert_text(*args, **options) }
       end
       alias_method :has_content?, :has_text?
 
@@ -582,15 +722,161 @@ module Capybara
       # @macro text_query_params
       # @return [Boolean]  Whether it doesn't exist
       #
-      def has_no_text?(*args)
-        assert_no_text(*args)
-      rescue Capybara::ExpectationNotMet
-        return false
+      def has_no_text?(*args, **options)
+        make_predicate(options) { assert_no_text(*args, **options) }
       end
       alias_method :has_no_content?, :has_no_text?
 
+      ##
+      #
+      # Asserts that a given selector matches an ancestor of the current node.
+      #
+      #     element.assert_ancestor('p#foo')
+      #
+      # Accepts the same options as {#assert_selector}
+      #
+      # @param (see Capybara::Node::Finders#find)
+      # @raise [Capybara::ExpectationNotMet]      If the selector does not exist
+      #
+      def assert_ancestor(*args, &optional_filter_block)
+        _verify_selector_result(args, optional_filter_block, Capybara::Queries::AncestorQuery) do |result, query|
+          unless result.matches_count? && (result.any? || query.expects_none?)
+            raise Capybara::ExpectationNotMet, result.failure_message
+          end
+        end
+      end
+
+      def assert_no_ancestor(*args, &optional_filter_block)
+        _verify_selector_result(args, optional_filter_block, Capybara::Queries::AncestorQuery) do |result, query|
+          if result.matches_count? && (!result.empty? || query.expects_none?)
+            raise Capybara::ExpectationNotMet, result.negative_failure_message
+          end
+        end
+      end
+
+      ##
+      #
+      # Predicate version of {#assert_ancestor}
+      #
+      def has_ancestor?(*args, **options, &optional_filter_block)
+        make_predicate(options) { assert_ancestor(*args, options, &optional_filter_block) }
+      end
+
+      ##
+      #
+      # Predicate version of {#assert_no_ancestor}
+      #
+      def has_no_ancestor?(*args, **options, &optional_filter_block)
+        make_predicate(options) { assert_no_ancestor(*args, options, &optional_filter_block) }
+      end
+
+      ##
+      #
+      # Asserts that a given selector matches a sibling of the current node.
+      #
+      #     element.assert_sibling('p#foo')
+      #
+      # Accepts the same options as {#assert_selector}
+      #
+      # @param (see Capybara::Node::Finders#find)
+      # @raise [Capybara::ExpectationNotMet]      If the selector does not exist
+      #
+      def assert_sibling(*args, &optional_filter_block)
+        _verify_selector_result(args, optional_filter_block, Capybara::Queries::SiblingQuery) do |result, query|
+          unless result.matches_count? && (result.any? || query.expects_none?)
+            raise Capybara::ExpectationNotMet, result.failure_message
+          end
+        end
+      end
+
+      def assert_no_sibling(*args, &optional_filter_block)
+        _verify_selector_result(args, optional_filter_block, Capybara::Queries::SiblingQuery) do |result, query|
+          if result.matches_count? && (!result.empty? || query.expects_none?)
+            raise Capybara::ExpectationNotMet, result.negative_failure_message
+          end
+        end
+      end
+
+      ##
+      #
+      # Predicate version of {#assert_sibling}
+      #
+      def has_sibling?(*args, **options, &optional_filter_block)
+        make_predicate(options) { assert_sibling(*args, options, &optional_filter_block) }
+      end
+
+      ##
+      #
+      # Predicate version of {#assert_no_sibling}
+      #
+      def has_no_sibling?(*args, **options, &optional_filter_block)
+        make_predicate(options) { assert_no_sibling(*args, options, &optional_filter_block) }
+      end
+
       def ==(other)
-        self.eql?(other) || (other.respond_to?(:base) && base == other.base)
+        eql?(other) || (other.respond_to?(:base) && base == other.base)
+      end
+
+    private
+
+      def extract_selector(args)
+        args.first.is_a?(Symbol) ? args.shift : session_options.default_selector
+      end
+
+      def _verify_multiple(*args, wait: nil, **options)
+        wait = session_options.default_max_wait_time if wait.nil?
+        selector = extract_selector(args)
+        synchronize(wait) do
+          args.each { |locator| yield(selector, locator, options) }
+        end
+      end
+
+      def _verify_selector_result(query_args, optional_filter_block, query_type = Capybara::Queries::SelectorQuery)
+        # query_args, query_opts = if query_args[0].is_a? Symbol
+        #   a,o = _set_query_session_options(*query_args.slice(2..))
+        #   [query_args.slice(0..1).concat(a), o]
+        # else
+        #   _set_query_session_options(*query_args)
+        # end
+        query_args, query_opts = _set_query_session_options(*query_args)
+        query = query_type.new(*query_args, **query_opts, &optional_filter_block)
+        synchronize(query.wait) do
+          yield query.resolve_for(self), query
+        end
+        true
+      end
+
+      def _verify_match_result(query_args, optional_filter_block)
+        query_args, query_opts = _set_query_session_options(*query_args)
+        query = Capybara::Queries::MatchQuery.new(*query_args, **query_opts, &optional_filter_block)
+        synchronize(query.wait) do
+          yield query.resolve_for(parent || session&.document || query_scope)
+        end
+        true
+      end
+
+      def _verify_text(type = nil, expected_text, **query_options) # rubocop:disable Style/OptionalArguments
+        query_options[:session_options] = session_options
+        query = Capybara::Queries::TextQuery.new(type, expected_text, **query_options)
+        synchronize(query.wait) do
+          yield query.resolve_for(self), query
+        end
+        true
+      end
+
+      def _set_query_session_options(*query_args)
+        query_args, query_options = query_args.dup, {}
+        # query_options = query_args.pop if query_options.empty? && query_args.last.is_a?(Hash)
+        query_options = query_args.pop if query_args.last.is_a?(Hash)
+        query_options[:session_options] = session_options
+        [query_args, query_options]
+      end
+
+      def make_predicate(options)
+        options[:wait] = 0 unless options.key?(:wait) || session_options.predicates_wait
+        yield
+      rescue Capybara::ExpectationNotMet
+        false
       end
     end
   end