capybara 3.1.1 → 3.2.0

data/lib/capybara/node/element.rb

@@ -50,18 +50,12 @@ module Capybara
       # ignored. This behaviour can be overridden by passing `:all` to this
       # method.
       #
-      # @param [:all, :visible] type  Whether to return only visible or all text
+      # @param type [:all, :visible]  Whether to return only visible or all text
       # @return [String]              The text of the element
       #
       def text(type = nil)
-        type ||= :all unless session_options.ignore_hidden_elements or session_options.visible_text_only
-        synchronize do
-          if type == :all
-            base.all_text
-          else
-            base.visible_text
-          end
-        end
+        type ||= :all unless session_options.ignore_hidden_elements || session_options.visible_text_only
+        synchronize { type == :all ? base.all_text : base.visible_text }
       end
 
       ##
@@ -90,11 +84,12 @@ module Capybara
       # Set the value of the form element to the given value.
       #
       # @param [String] value    The new value
-      # @param [Hash{}] options  Driver specific options for how to set the value
+      # @param [Hash{}] options  Driver specific options for how to set the value. Take default values from {Capybara#default_set_options}
       #
       # @return [Capybara::Node::Element]  The element
       def set(value, **options)
         raise Capybara::ReadOnlyElementError, "Attempt to set readonly element with value: #{value}" if readonly?
+        options = session_options.default_set_options.to_h.merge(options)
         synchronize { base.set(value, options) }
         self
       end
@@ -125,9 +120,11 @@ module Capybara
       # Click the Element
       #
       # @!macro click_modifiers
-      #   @overload $0(*key_modifiers=[], offset={x: nil, y: nil})
-      #     @param [Array<:alt, :control, :meta, :shift>] *key_modifiers  Keys to be held down when clicking
-      #     @param [Hash] offset                          x and y coordinates to offset the click location from the top left corner of the element.  If not specified will click the middle of the element.
+      #   Both x: and y: must be specified if an offset is wanted, if not specified the click will occur at the middle of the element
+      #   @overload $0(*modifier_keys, **offset)
+      #     @param *modifier_keys [:alt, :control, :meta, :shift] ([]) Keys to be held down when clicking
+      #     @option offset [Integer] x  X coordinate to offset the click location from the top left corner of the element
+      #     @option offset [Integer] y  Y coordinate to offset the click location from the top left corner of the element
       # @return [Capybara::Node::Element]  The element
       def click(*keys, **offset)
         synchronize { base.click(keys, offset) }
@@ -161,7 +158,7 @@ module Capybara
       # Send Keystrokes to the Element
       #
       # @overload send_keys(keys, ...)
-      #   @param [String, Symbol, Array<String,Symbol>] keys
+      #   @param keys [String, Symbol, Array<String,Symbol>]
       #
       # Examples:
       #
@@ -350,12 +347,46 @@ module Capybara
         self
       end
 
+      ##
+      #
+      # Execute the given JS in the context of the element not returning a result. This is useful for scripts that return
+      # complex objects, such as jQuery statements. +execute_script+ should be used over
+      # +evaluate_script+ whenever possible. `this` in the script will refer to the element this is called on.
+      #
+      # @param [String] script   A string of JavaScript to execute
+      # @param args  Optional arguments that will be passed to the script.  Driver support for this is optional and types of objects supported may differ between drivers
+      #
+      def execute_script(script, *args)
+        session.execute_script(<<~JS, self, *args)
+          (function (){
+            #{script}
+          }).apply(arguments[0], Array.prototype.slice.call(arguments,1));
+        JS
+      end
+
+      ##
+      #
+      # Evaluate the given JS in the context of the element and return the result. Be careful when using this with
+      # scripts that return complex objects, such as jQuery statements. +execute_script+ might
+      # be a better alternative. `this` in the script will refer to the element this is called on.
+      #
+      # @param  [String] script   A string of JavaScript to evaluate
+      # @return [Object]          The result of the evaluated JavaScript (may be driver specific)
+      #
+      def evaluate_script(script, *args)
+        session.evaluate_script(<<~JS, self, *args)
+          (function(){
+            return #{script}
+          }).apply(arguments[0], Array.prototype.slice.call(arguments,1));
+        JS
+      end
+
       def reload
         if @allow_reload
           begin
             reloaded = query_scope.reload.first(@query.name, @query.locator, @query.options)
             @base = reloaded.base if reloaded
-          rescue => e
+          rescue StandardError => e
             raise e unless catch_error?(e)
           end
         end
@@ -366,7 +397,7 @@ module Capybara
         %(#<Capybara::Node::Element tag="#{base.tag_name}" path="#{base.path}">)
       rescue NotSupportedByDriverError
         %(#<Capybara::Node::Element tag="#{base.tag_name}">)
-      rescue => e
+      rescue StandardError => e
         raise unless session.driver.invalid_element_errors.any? { |et| e.is_a?(et) }
 
         %(Obsolete #<Capybara::Node::Element>)

data/lib/capybara/node/finders.rb

@@ -55,7 +55,7 @@ module Capybara
       #
       def ancestor(*args, **options, &optional_filter_block)
         options[:session_options] = session_options
-        synced_resolve Capybara::Queries::AncestorQuery.new(*args, **options, &optional_filter_block)
+        synced_resolve Capybara::Queries::AncestorQuery.new(*args, options, &optional_filter_block)
       end
 
       ##
@@ -81,14 +81,14 @@ module Capybara
       #
       def sibling(*args, **options, &optional_filter_block)
         options[:session_options] = session_options
-        synced_resolve Capybara::Queries::SiblingQuery.new(*args, **options, &optional_filter_block)
+        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={})
+      # @overload find_field([locator], **options)
       #   @param [String] locator             name, id, placeholder or text of associated label element
       #
       #   @macro waiting_behavior
@@ -119,7 +119,7 @@ module Capybara
       #
       # Find a link on the page. The link can be found by its id or text.
       #
-      # @overload find_link([locator], options={})
+      # @overload find_link([locator], **options)
       #   @param [String] locator            id, title, text, or alt of enclosed img element
       #
       #   @macro waiting_behavior
@@ -142,10 +142,10 @@ module Capybara
       # \<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
       #
-      # @overload find_button([locator], options={})
+      # @overload find_button([locator], **options)
       #   @param [String] locator            id, value, title, text content, alt of image
       #
-      #   @overload find_button(options={})
+      #   @overload find_button(**options)
       #
       #   @macro waiting_behavior
       #
@@ -178,7 +178,7 @@ module Capybara
       end
 
       ##
-      # @!method all([kind = Capybara.default_selector], locator = nil, options = {})
+      # @!method all([kind = Capybara.default_selector], locator = nil, **options)
       #
       # Find all elements on the page matching the given selector
       # and options.
@@ -235,8 +235,8 @@ module Capybara
       # @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, false] wait (Capybara.default_max_wait_time)  The time to wait for matching elements to become available
-      # @overload all([kind = Capybara.default_selector], locator = nil, options = {})
-      # @overload all([kind = Capybara.default_selector], locator = nil, options = {}, &filter_block)
+      # @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
@@ -245,7 +245,7 @@ module Capybara
         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.push(options), &optional_filter_block)
+        query = Capybara::Queries::SelectorQuery.new(*args, options, &optional_filter_block)
         result = nil
         begin
           synchronize(query.wait) do
@@ -276,7 +276,7 @@ module Capybara
       #
       def first(*args, **options, &optional_filter_block)
         options = { minimum: 1 }.merge(options) unless options_include_minimum?(options)
-        all(*args, **options, &optional_filter_block).first
+        all(*args, options, &optional_filter_block).first
       end
 
     private
@@ -298,11 +298,11 @@ module Capybara
       end
 
       def ambiguous?(query, result)
-        query.match == :one or query.match == :smart and result.size > 1
+        %i[one smart].include?(query.match) && (result.size > 1)
       end
 
       def prefer_exact?(query)
-        query.match == :smart or query.match == :prefer_exact
+        %i[smart prefer_exact].include?(query.match)
       end
 
       def options_include_minimum?(opts)

data/lib/capybara/node/matchers.rb

@@ -91,7 +91,7 @@ module Capybara
       #
       def assert_selector(*args, &optional_filter_block)
         _verify_selector_result(args, optional_filter_block) do |result, query|
-          unless result.matches_count? && (!result.empty? || query.expects_none?)
+          unless result.matches_count? && (result.any? || query.expects_none?)
             raise Capybara::ExpectationNotMet, result.failure_message
           end
         end
@@ -110,11 +110,11 @@ module Capybara
       # 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.default_max_wait_time) seconds.
       #
-      # @overload assert_all_of_selectors([kind = Capybara.default_selector], *locators, options = {})
+      # @overload assert_all_of_selectors([kind = Capybara.default_selector], *locators, **options)
       #
       def assert_all_of_selectors(*args, wait: nil, **options, &optional_filter_block)
         wait = session_options.default_max_wait_time if wait.nil?
-        selector = args.first.is_a?(Symbol) ? args.shift : session_options.default_selector
+        selector = extract_selector(args)
         synchronize(wait) do
           args.each do |locator|
             assert_selector(selector, locator, options, &optional_filter_block)
@@ -135,11 +135,11 @@ module Capybara
       # 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.default_max_wait_time) seconds.
       #
-      # @overload assert_none_of_selectors([kind = Capybara.default_selector], *locators, options = {})
+      # @overload assert_none_of_selectors([kind = Capybara.default_selector], *locators, **options)
       #
       def assert_none_of_selectors(*args, wait: nil, **options, &optional_filter_block)
         wait = session_options.default_max_wait_time if wait.nil?
-        selector = args.first.is_a?(Symbol) ? args.shift : session_options.default_selector
+        selector = extract_selector(args)
         synchronize(wait) do
           args.each do |locator|
             assert_no_selector(selector, locator, options, &optional_filter_block)
@@ -508,7 +508,7 @@ module Capybara
       def matches_selector?(*args, &optional_filter_block)
         assert_matches_selector(*args, &optional_filter_block)
       rescue Capybara::ExpectationNotMet
-        return false
+        false
       end
 
       ##
@@ -544,7 +544,7 @@ module Capybara
       def not_matches_selector?(*args, &optional_filter_block)
         assert_not_matches_selector(*args, &optional_filter_block)
       rescue Capybara::ExpectationNotMet
-        return false
+        false
       end
 
       ##
@@ -574,7 +574,7 @@ module Capybara
       # ignoring any HTML tags.
       #
       # @!macro text_query_params
-      #   @overload $0(type, text, options = {})
+      #   @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.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
@@ -583,7 +583,7 @@ module Capybara
       #     @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 [Boolean] :exact (Capybara.exact_text) Whether text must be an exact match or just substring
-      #   @overload $0(text, options = {})
+      #   @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
@@ -596,7 +596,7 @@ module Capybara
       #
       def assert_text(*args)
         _verify_text(args) do |count, query|
-          unless query.matches_count?(count) && ((count > 0) || query.expects_none?)
+          unless query.matches_count?(count) && (count.positive? || query.expects_none?)
             raise Capybara::ExpectationNotMet, query.failure_message
           end
         end
@@ -612,7 +612,7 @@ module Capybara
       #
       def assert_no_text(*args)
         _verify_text(args) do |count, query|
-          if query.matches_count?(count) && ((count > 0) || query.expects_none?)
+          if query.matches_count?(count) && (count.positive? || query.expects_none?)
             raise Capybara::ExpectationNotMet, query.negative_failure_message
           end
         end
@@ -659,12 +659,15 @@ module Capybara
 
     private
 
+      def extract_selector(args)
+        args.first.is_a?(Symbol) ? args.shift : session_options.default_selector
+      end
+
       def _verify_selector_result(query_args, optional_filter_block)
         query_args = _set_query_session_options(*query_args)
         query = Capybara::Queries::SelectorQuery.new(*query_args, &optional_filter_block)
         synchronize(query.wait) do
-          result = query.resolve_for(self)
-          yield result, query
+          yield query.resolve_for(self), query
         end
         true
       end
@@ -673,8 +676,7 @@ module Capybara
         query_args = _set_query_session_options(*query_args)
         query = Capybara::Queries::MatchQuery.new(*query_args, &optional_filter_block)
         synchronize(query.wait) do
-          result = query.resolve_for(query_scope)
-          yield result
+          yield query.resolve_for(query_scope)
         end
         true
       end
@@ -683,8 +685,7 @@ module Capybara
         query_args = _set_query_session_options(*query_args)
         query = Capybara::Queries::TextQuery.new(*query_args)
         synchronize(query.wait) do
-          count = query.resolve_for(self)
-          yield(count, query)
+          yield query.resolve_for(self), query
         end
         true
       end

data/lib/capybara/node/simple.rb

@@ -45,7 +45,7 @@ module Capybara
         attr_name = name.to_s
         if attr_name == 'value'
           value
-        elsif tag_name == 'input' and native[:type] == 'checkbox' and attr_name == 'checked'
+        elsif (tag_name == 'input') && (native[:type] == 'checkbox') && (attr_name == 'checked')
           native['checked'] == 'checked'
         else
           native[attr_name]
@@ -78,7 +78,7 @@ module Capybara
         if tag_name == 'textarea'
           native['_capybara_raw_value']
         elsif tag_name == 'select'
-          if native['multiple'] == 'multiple'
+          if multiple?
             native.xpath(".//option[@selected='selected']").map { |option| option[:value] || option.content }
           else
             option = native.xpath(".//option[@selected='selected']").first || native.xpath(".//option").first
@@ -139,6 +139,10 @@ module Capybara
         native.has_attribute?('selected')
       end
 
+      def multiple?
+        native.has_attribute?('multiple')
+      end
+
       def synchronize(_seconds = nil)
         yield # simple nodes don't need to wait
       end

data/lib/capybara/queries/ancestor_query.rb

@@ -13,7 +13,7 @@ module Capybara
       end
 
       def description
-        child_query = @child_node && @child_node.instance_variable_get(:@query)
+        child_query = @child_node&.instance_variable_get(:@query)
         desc = super
         desc += " that is an ancestor of #{child_query.description}" if child_query
         desc

data/lib/capybara/queries/base_query.rb

@@ -59,11 +59,11 @@ module Capybara
       # Generates a failure message from the query description and count options.
       #
       def failure_message
-        String.new("expected to find #{description}") << count_message
+        +"expected to find #{description}" << count_message
       end
 
       def negative_failure_message
-        String.new("expected not to find #{description}") << count_message
+        +"expected not to find #{description}" << count_message
       end
 
     private
@@ -73,7 +73,7 @@ module Capybara
       end
 
       def count_message
-        message = "".dup
+        message = +""
         if options[:count]
           message << " #{options[:count]} #{Capybara::Helpers.declension('time', 'times', options[:count])}"
         elsif options[:between]

data/lib/capybara/queries/current_path_query.rb

@@ -19,7 +19,7 @@ module Capybara
       def resolves_for?(session)
         uri = ::Addressable::URI.parse(session.current_url)
         uri.query = nil if uri && options[:ignore_query]
-        @actual_path = options[:url] ? uri.to_s : uri && uri.request_uri
+        @actual_path = options[:url] ? uri.to_s : uri&.request_uri
 
         if @expected_path.is_a? Regexp
           @actual_path.to_s.match(@expected_path)

data/lib/capybara/queries/match_query.rb

@@ -9,6 +9,14 @@ module Capybara
 
     private
 
+      def assert_valid_keys
+        invalid_options = @options.keys & COUNT_KEYS
+        unless invalid_options.empty?
+          raise ArgumentError, "Match queries don't support quantity options. Invalid keys - #{invalid_options.join(', ')}"
+        end
+        super
+      end
+
       def valid_keys
         super - COUNT_KEYS
       end

data/lib/capybara/queries/selector_query.rb

@@ -31,12 +31,12 @@ module Capybara
       def label; selector.label || selector.name; end
 
       def description
-        @description = "".dup
+        @description = +""
         @description << "visible " if visible == :visible
         @description << "non-visible " if visible == :hidden
         @description << "#{label} #{locator.inspect}"
         @description << " with#{' exact' if exact_text == true} text #{options[:text].inspect}" if options[:text]
-        @description << " with exact text #{options[:exact_text]}" if options[:exact_text].is_a?(String)
+        @description << " with exact text #{exact_text}" if exact_text.is_a?(String)
         @description << " with id #{options[:id]}" if options[:id]
         @description << " with classes [#{Array(options[:class]).join(',')}]" if options[:class]
         @description << selector.description(options)
@@ -56,7 +56,7 @@ module Capybara
 
         matches_node_filters?(node) && matches_filter_block?(node)
       rescue *(node.respond_to?(:session) ? node.session.driver.invalid_element_errors : [])
-        return false
+        false
       end
 
       def visible
@@ -126,11 +126,19 @@ module Capybara
       end
 
       def matches_node_filters?(node)
-        node_filters.all? do |name, filter|
-          if options.key?(name)
-            filter.matches?(node, options[name])
+        unapplied_options = options.keys - valid_keys
+
+        node_filters.all? do |filter_name, filter|
+          if filter.matcher?
+            unapplied_options.select { |option_name| filter.handles_option?(option_name) }.all? do |option_name|
+              unapplied_options.delete(option_name)
+              filter.matches?(node, option_name, options[option_name])
+            end
+          elsif options.key?(filter_name)
+            unapplied_options.delete(filter_name)
+            filter.matches?(node, filter_name, options[filter_name])
           elsif filter.default?
-            filter.matches?(node, filter.default)
+            filter.matches?(node, filter_name, filter.default)
           else
             true
           end
@@ -166,43 +174,86 @@ module Capybara
       end
 
       def assert_valid_keys
-        super
-        return if VALID_MATCH.include?(match)
-        raise ArgumentError, "invalid option #{match.inspect} for :match, should be one of #{VALID_MATCH.map(&:inspect).join(', ')}"
+        unless VALID_MATCH.include?(match)
+          raise ArgumentError, "invalid option #{match.inspect} for :match, should be one of #{VALID_MATCH.map(&:inspect).join(', ')}"
+        end
+        unhandled_options = @options.keys - valid_keys
+        unhandled_options -= @options.keys.select do |option_name|
+          expression_filters.any? { |_nmae, ef| ef.handles_option? option_name } ||
+            node_filters.any? { |_name, nf| nf.handles_option? option_name }
+        end
+
+        return if unhandled_options.empty?
+        invalid_names = unhandled_options.map(&:inspect).join(", ")
+        valid_names = valid_keys.map(&:inspect).join(", ")
+        raise ArgumentError, "invalid keys #{invalid_names}, should be one of #{valid_names}"
       end
 
       def filtered_xpath(expr)
-        if options.key?(:id) || options.key?(:class)
-          expr = "(#{expr})"
-          expr = "#{expr}[#{XPath.attr(:id) == options[:id]}]" if options.key?(:id) && !custom_keys.include?(:id)
-          if options.key?(:class) && !custom_keys.include?(:class)
-            class_xpath = Array(options[:class]).map do |klass|
-              XPath.attr(:class).contains_word(klass)
+        if options.key?(:id) && !custom_keys.include?(:id)
+          expr = if options[:id].is_a? XPath::Expression
+            "(#{expr})[#{XPath.attr(:id)[options[:id]]}]"
+          else
+            "(#{expr})[#{XPath.attr(:id) == options[:id]}]"
+          end
+        end
+        if options.key?(:class) && !custom_keys.include?(:class)
+          class_xpath = if options[:class].is_a?(XPath::Expression)
+            XPath.attr(:class)[options[:class]]
+          else
+            Array(options[:class]).map do |klass|
+              if klass.start_with?('!')
+                !XPath.attr(:class).contains_word(klass.slice(1))
+              else
+                XPath.attr(:class).contains_word(klass)
+              end
             end.reduce(:&)
-            expr = "#{expr}[#{class_xpath}]"
           end
+          expr = "(#{expr})[#{class_xpath}]"
         end
         expr
       end
 
       def filtered_css(expr)
-        if options.key?(:id) || options.key?(:class)
-          css_selectors = expr.split(',').map(&:rstrip)
-          expr = css_selectors.map do |sel|
-            sel += "##{Capybara::Selector::CSS.escape(options[:id])}" if options.key?(:id) && !custom_keys.include?(:id)
-            sel += Array(options[:class]).map { |k| ".#{Capybara::Selector::CSS.escape(k)}" }.join if options.key?(:class) && !custom_keys.include?(:class)
-            sel
-          end.join(", ")
+        process_id = options.key?(:id) && !custom_keys.include?(:id)
+        process_class = options.key?(:class) && !custom_keys.include?(:class)
+
+        if process_id && options[:id].is_a?(XPath::Expression)
+          raise ArgumentError, "XPath expressions are not supported for the :id filter with CSS based selectors"
+        end
+        if process_class && options[:class].is_a?(XPath::Expression)
+          raise ArgumentError, "XPath expressions are not supported for the :class filter with CSS based selectors"
         end
+
+        css_selectors = expr.split(',').map(&:rstrip)
+        expr = css_selectors.map do |sel|
+          sel += "##{Capybara::Selector::CSS.escape(options[:id])}" if process_id
+          sel += css_from_classes(Array(options[:class])) if process_class
+          sel
+        end.join(", ")
         expr
       end
 
+      def css_from_classes(classes)
+        classes = classes.group_by { |c| c.start_with? '!' }
+        (classes[false].to_a.map { |c| ".#{Capybara::Selector::CSS.escape(c)}" } +
+         classes[true].to_a.map { |c| ":not(.#{Capybara::Selector::CSS.escape(c.slice(1))})" }).join
+      end
+
       def apply_expression_filters(expr)
+        unapplied_options = options.keys - valid_keys
         expression_filters.inject(expr) do |memo, (name, ef)|
-          if options.key?(name)
-            ef.apply_filter(memo, options[name])
+          if ef.matcher?
+            unapplied_options.select { |option_name| ef.handles_option?(option_name) }.each do |option_name|
+              unapplied_options.delete(option_name)
+              memo = ef.apply_filter(memo, option_name, options[option_name])
+            end
+            memo
+          elsif options.key?(name)
+            unapplied_options.delete(name)
+            ef.apply_filter(memo, name, options[name])
           elsif ef.default?
-            ef.apply_filter(memo, ef.default)
+            ef.apply_filter(memo, name, ef.default)
           else
             memo
           end
@@ -219,25 +270,29 @@ module Capybara
       end
 
       def describe_within?
-        @resolved_node && !(@resolved_node.is_a?(::Capybara::Node::Document) ||
-                            (@resolved_node.is_a?(::Capybara::Node::Simple) && @resolved_node.path == '/'))
+        @resolved_node && !document?(@resolved_node) && !simple_root?(@resolved_node)
       end
 
-      def matches_text_filter(node, text_option)
-        regexp = if text_option.is_a?(Regexp)
-          text_option
-        elsif exact_text == true
-          /\A#{Regexp.escape(text_option.to_s)}\z/
-        else
-          Regexp.escape(text_option.to_s)
-        end
-        text_visible = visible
-        text_visible = :all if text_visible == :hidden
-        node.text(text_visible).match(regexp)
+      def document?(node)
+        node.is_a?(::Capybara::Node::Document)
+      end
+
+      def simple_root?(node)
+        node.is_a?(::Capybara::Node::Simple) && node.path == '/'
+      end
+
+      def matches_text_filter(node, value)
+        return matches_exact_text_filter(node, value) if exact_text == true
+        regexp = value.is_a?(Regexp) ? value : Regexp.escape(value.to_s)
+        matches_text_regexp(node, regexp)
+      end
+
+      def matches_exact_text_filter(node, value)
+        regexp = value.is_a?(Regexp) ? value : /\A#{Regexp.escape(value.to_s)}\z/
+        matches_text_regexp(node, regexp)
       end
 
-      def matches_exact_text_filter(node, exact_text_option)
-        regexp = /\A#{Regexp.escape(exact_text_option)}\z/
+      def matches_text_regexp(node, regexp)
         text_visible = visible
         text_visible = :all if text_visible == :hidden
         node.text(text_visible).match(regexp)