capybara 2.13.0 → 2.18.0

data/lib/capybara/node/element.rb

@@ -55,7 +55,7 @@ module Capybara
       # @return [String]              The text of the element
       #
       def text(type=nil)
-        type ||= :all unless Capybara.ignore_hidden_elements or Capybara.visible_text_only
+        type ||= :all unless session_options.ignore_hidden_elements or session_options.visible_text_only
         synchronize do
           if type == :all
             base.all_text
@@ -371,9 +371,15 @@ module Capybara
       end
 
       def inspect
-        %(#<Capybara::Node::Element tag="#{tag_name}" path="#{path}">)
+        %(#<Capybara::Node::Element tag="#{base.tag_name}" path="#{base.path}">)
       rescue NotSupportedByDriverError
-        %(#<Capybara::Node::Element tag="#{tag_name}">)
+        %(#<Capybara::Node::Element tag="#{base.tag_name}">)
+      rescue => e
+        if session.driver.invalid_element_errors.any? { |et| e.is_a?(et)}
+          %(Obsolete #<Capybara::Node::Element>)
+        else
+          raise
+        end
       end
     end
   end

data/lib/capybara/node/finders.rb

@@ -29,22 +29,71 @@ module Capybara
       # @raise  [Capybara::ElementNotFound]    If the element can't be found before time expires
       #
       def find(*args, &optional_filter_block)
-        query = Capybara::Queries::SelectorQuery.new(*args, &optional_filter_block)
-        synchronize(query.wait) do
-          if (query.match == :smart or query.match == :prefer_exact) and query.supports_exact?
-            result = query.resolve_for(self, true)
-            result = query.resolve_for(self, false) if result.empty? && !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.empty?
-            raise Capybara::ElementNotFound.new("Unable to find #{query.description}")
-          end
-          result.first
-        end.tap(&:allow_reload!)
+        if args.last.is_a? Hash
+          args.last[:session_options] = session_options
+        else
+          args.push(session_options: session_options)
+        end
+        synced_resolve Capybara::Queries::SelectorQuery.new(*args, &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+.
+      #
+      #     element.ancestor('#foo').find('.bar')
+      #     element.ancestor(:xpath, './/div[contains(., "bar")]')
+      #     element.ancestor('ul', text: 'Quox').click_link('Delete')
+      #
+      # @param (see Capybara::Node::Finders#find)
+      #
+      # @!macro waiting_behavior
+      #
+      # @option options [Boolean] match        The matching strategy to use.
+      #
+      # @return [Capybara::Node::Element]      The found element
+      # @raise  [Capybara::ElementNotFound]    If the element can't be found before time expires
+      #
+      def ancestor(*args, &optional_filter_block)
+        if args.last.is_a? Hash
+          args.last[:session_options] = session_options
+        else
+          args.push(session_options: session_options)
+        end
+        synced_resolve Capybara::Queries::AncestorQuery.new(*args, &optional_filter_block)
+      end
+
+      ##
+      #
+      # 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 Capybara::Node::Finders#find)
+      #
+      # @macro waiting_behavior
+      #
+      # @option options [Boolean] match        The matching strategy to use.
+      #
+      # @return [Capybara::Node::Element]      The found element
+      # @raise  [Capybara::ElementNotFound]    If the element can't be found before time expires
+      #
+      def sibling(*args, &optional_filter_block)
+        if args.last.is_a? Hash
+          args.last[:session_options] = session_options
+        else
+          args.push(session_options: session_options)
+        end
+        synced_resolve Capybara::Queries::SiblingQuery.new(*args, &optional_filter_block)
       end
 
       ##
@@ -122,7 +171,7 @@ module Capybara
       #   @option options [String] id                 Match buttons with the id 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>] class    Match links that match the class(es) provided
+      #   @option options [String, Array<String>] class    Match buttons that match the class(es) provided
       # @return [Capybara::Node::Element]   The found element
       #
       def find_button(locator=nil, options={}, &optional_filter_block)
@@ -208,6 +257,11 @@ module Capybara
       # @return [Capybara::Result]                   A collection of found elements
       #
       def all(*args, &optional_filter_block)
+        if args.last.is_a? Hash
+          args.last[:session_options] = session_options
+        else
+          args.push(session_options: session_options)
+        end
         query = Capybara::Queries::SelectorQuery.new(*args, &optional_filter_block)
         synchronize(query.wait) do
           result = query.resolve_for(self)
@@ -233,7 +287,7 @@ module Capybara
       # @return [Capybara::Node::Element]            The found element or nil
       #
       def first(*args, &optional_filter_block)
-        if Capybara.wait_on_first_by_default
+        if session_options.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
@@ -242,6 +296,26 @@ module Capybara
         nil
       end
 
+      private
+
+      def synced_resolve(query)
+        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.empty? && query.supports_exact? && !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.empty?
+            raise Capybara::ElementNotFound.new("Unable to find #{query.description}")
+          end
+          result.first
+        end.tap(&:allow_reload!)
+      end
     end
   end
 end

data/lib/capybara/node/matchers.rb

@@ -114,8 +114,8 @@ module Capybara
       #
       def assert_all_of_selectors(*args, &optional_filter_block)
         options = if args.last.is_a?(Hash) then args.pop.dup else {} end
-        selector = if args.first.is_a?(Symbol) then args.shift else Capybara.default_selector end
-        wait = options.fetch(:wait, Capybara.default_max_wait_time)
+        selector = if args.first.is_a?(Symbol) then args.shift else session_options.default_selector end
+        wait = options.fetch(:wait, session_options.default_max_wait_time)
         synchronize(wait) do
           args.each do |locator|
             assert_selector(selector, locator, options, &optional_filter_block)
@@ -140,8 +140,8 @@ module Capybara
       #
       def assert_none_of_selectors(*args, &optional_filter_block)
         options = if args.last.is_a?(Hash) then args.pop.dup else {} end
-        selector = if args.first.is_a?(Symbol) then args.shift else Capybara.default_selector end
-        wait = options.fetch(:wait, Capybara.default_max_wait_time)
+        selector = if args.first.is_a?(Symbol) then args.shift else session_options.default_selector end
+        wait = options.fetch(:wait, session_options.default_max_wait_time)
         synchronize(wait) do
           args.each do |locator|
             assert_no_selector(selector, locator, options, &optional_filter_block)
@@ -432,11 +432,12 @@ module Capybara
       #
       #     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=nil, options={}, &optional_filter_block)
         locator, options = nil, locator if locator.is_a? Hash
@@ -680,6 +681,7 @@ module Capybara
     private
 
       def _verify_selector_result(query_args, optional_filter_block, &result_block)
+        _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)
@@ -689,6 +691,7 @@ module Capybara
       end
 
       def _verify_match_result(query_args, optional_filter_block, &result_block)
+        _set_query_session_options(query_args)
         query = Capybara::Queries::MatchQuery.new(*query_args, &optional_filter_block)
         synchronize(query.wait) do
           result = query.resolve_for(self.query_scope)
@@ -698,6 +701,7 @@ module Capybara
       end
 
       def _verify_text(query_args)
+        _set_query_session_options(query_args)
         query = Capybara::Queries::TextQuery.new(*query_args)
         synchronize(query.wait) do
           count = query.resolve_for(self)
@@ -706,6 +710,14 @@ module Capybara
         return true
       end
 
+      def _set_query_session_options(query_args)
+        if query_args.last.is_a? Hash
+          query_args.last[:session_options] = session_options
+        else
+          query_args.push(session_options: session_options)
+        end
+        query_args
+      end
     end
   end
 end

data/lib/capybara/node/simple.rb

@@ -173,6 +173,11 @@ module Capybara
       def find_xpath(xpath)
         native.xpath(xpath)
       end
+
+      # @api private
+      def session_options
+        Capybara.session_options
+      end
     end
   end
 end

data/lib/capybara/queries/ancestor_query.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+module Capybara
+  module Queries
+    class AncestorQuery < MatchQuery
+      # @api private
+      def resolve_for(node, exact = nil)
+        @child_node = node
+        node.synchronize do
+          match_results = super(node.session.current_scope, exact)
+          node.all(:xpath, XPath.ancestor) do |el|
+            match_results.include?(el)
+          end
+        end
+      end
+
+      def description
+        desc = super
+        if @child_node && (child_query = @child_node.instance_variable_get(:@query))
+          desc += " that is an ancestor of #{child_query.description}"
+        end
+        desc
+      end
+    end
+  end
+end

data/lib/capybara/queries/base_query.rb

@@ -6,13 +6,22 @@ module Capybara
       COUNT_KEYS = [:count, :minimum, :maximum, :between]
 
       attr_reader :options
+      attr_writer :session_options
+
+      def initialize(options)
+        @session_options = options.delete(:session_options)
+      end
+
+      def session_options
+        @session_options || Capybara.session_options
+      end
 
       def wait
-        self.class.wait(options)
+        self.class.wait(options, session_options.default_max_wait_time)
       end
 
-      def self.wait(options)
-        options.fetch(:wait, Capybara.default_max_wait_time) || 0
+      def self.wait(options, default=Capybara.default_max_wait_time)
+        options.fetch(:wait, default) || 0
       end
 
       ##

data/lib/capybara/queries/current_path_query.rb

@@ -6,28 +6,32 @@ module Capybara
   module Queries
     class CurrentPathQuery < BaseQuery
       def initialize(expected_path, options = {})
+        super(options)
         @expected_path = expected_path
+        warn "DEPRECATED: The :only_path option is deprecated in favor of the :ignore_query option" if options.has_key?(:only_path)
+
         @options = {
-          url: false,
-          only_path: false }.merge(options)
+          url: !@expected_path.is_a?(Regexp) && !::Addressable::URI.parse(@expected_path || "").hostname.nil?,
+          only_path: false,
+          ignore_query: false }.merge(options)
         assert_valid_keys
       end
 
       def resolves_for?(session)
+        uri = ::Addressable::URI.parse(session.current_url)
+        uri.query = nil if uri && options[:ignore_query]
         @actual_path = if options[:url]
-          session.current_url
+          uri.to_s
         else
-          uri = ::Addressable::URI.parse(session.current_url)
-
           if options[:only_path]
-            uri.path unless uri.nil? # Ensure the parsed url isn't nil.
+            uri && uri.path
           else
-            uri.request_uri unless uri.nil? # Ensure the parsed url isn't nil.
+            uri && uri.request_uri
           end
         end
 
         if @expected_path.is_a? Regexp
-          @actual_path.match(@expected_path)
+          @actual_path.to_s.match(@expected_path)
         else
           ::Addressable::URI.parse(@expected_path) == ::Addressable::URI.parse(@actual_path)
         end
@@ -49,7 +53,7 @@ module Capybara
       end
 
       def valid_keys
-        [:wait, :url, :only_path]
+        [:wait, :url, :only_path, :ignore_query]
       end
 
       def assert_valid_keys

data/lib/capybara/queries/selector_query.rb

@@ -8,29 +8,31 @@ module Capybara
       VALID_MATCH = [:first, :smart, :prefer_exact, :one]
 
       def initialize(*args, &filter_block)
+        @resolved_node = nil
         @options = if args.last.is_a?(Hash) then args.pop.dup else {} end
+        super(@options)
+
         @filter_block = filter_block
 
         if args[0].is_a?(Symbol)
           @selector = Selector.all.fetch(args.shift) do |selector_type|
-            warn "Unknown selector type (:#{selector_type}), defaulting to :#{Capybara.default_selector} - This will raise an exception in a future version of Capybara"
-            nil
+            raise ArgumentError, "Unknown selector type (:#{selector_type})"
           end
           @locator = args.shift
         else
           @selector = Selector.all.values.find { |s| s.match?(args[0]) }
           @locator = args.shift
         end
-        @selector ||= Selector.all[Capybara.default_selector]
+        @selector ||= Selector.all[session_options.default_selector]
 
-        warn "Unused parameters passed to #{self.class.name} : #{args.to_s}" unless args.empty?
+        warn "Unused parameters passed to #{self.class.name} : #{args}" unless args.empty?
 
         # for compatibility with Capybara 2.0
-        if Capybara.exact_options and @selector == Selector.all[:option]
+        if session_options.exact_options and @selector == Selector.all[:option]
           @options[:exact] = true
         end
 
-        @expression = @selector.call(@locator, @options)
+        @expression = @selector.call(@locator, @options.merge(enable_aria_label: session_options.enable_aria_label))
 
         warn_exact_usage
 
@@ -41,13 +43,17 @@ module Capybara
       def label; selector.label or selector.name; end
 
       def description
-        @description = String.new("#{label} #{locator.inspect}")
+        @description = String.new()
+        @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 id #{options[:id]}" if options[:id]
-        @description << " with classes #{Array(options[:class]).join(',')}]" if options[:class]
+        @description << " with classes [#{Array(options[:class]).join(',')}]" if options[:class]
         @description << selector.description(options)
         @description << " that also matches the custom filter block" if @filter_block
+        @description << " within #{@resolved_node.inspect}" if describe_within?
         @description
       end
 
@@ -79,7 +85,7 @@ module Capybara
           when :hidden then return false if node.visible?
         end
 
-        res = query_filters.all? do |name, filter|
+        res = node_filters.all? do |name, filter|
           if options.has_key?(name)
             filter.matches?(node, options[name])
           elsif filter.default?
@@ -89,12 +95,20 @@ module Capybara
           end
         end
 
-        res &&= Capybara.using_wait_time(0){ @filter_block.call(node)} unless @filter_block.nil?
+        res &&= if node.respond_to?(:session)
+          node.session.using_wait_time(0){ @filter_block.call(node) }
+        else
+          @filter_block.call(node)
+        end unless @filter_block.nil?
+
         res
+
+      rescue *(node.respond_to?(:session) ? node.session.driver.invalid_element_errors : [])
+        return false
       end
 
       def visible
-        case (vis = options.fetch(:visible){ @selector.default_visibility })
+        case (vis = options.fetch(:visible){ @selector.default_visibility(session_options.ignore_hidden_elements) })
           when true then :visible
           when false then :all
           else vis
@@ -103,29 +117,31 @@ module Capybara
 
       def exact?
         return false if !supports_exact?
-        options.fetch(:exact, Capybara.exact)
+        options.fetch(:exact, session_options.exact)
       end
 
       def match
-        options.fetch(:match, Capybara.match)
+        options.fetch(:match, session_options.match)
       end
 
       def xpath(exact=nil)
         exact = self.exact? if exact.nil?
-        expr = if @expression.respond_to?(:to_xpath) and exact
-          @expression.to_xpath(:exact)
+        expr = apply_expression_filters(@expression)
+        expr = if expr.respond_to?(:to_xpath) and exact
+          expr.to_xpath(:exact)
         else
-          @expression.to_s
+          expr.to_s
         end
         filtered_xpath(expr)
       end
 
       def css
-        filtered_css(@expression)
+        filtered_css(apply_expression_filters(@expression))
       end
 
       # @api private
       def resolve_for(node, exact = nil)
+        @resolved_node = node
         node.synchronize do
           children = if selector.format == :css
             node.find_css(self.css)
@@ -153,16 +169,22 @@ module Capybara
         VALID_KEYS + custom_keys
       end
 
-      def query_filters
+      def node_filters
         if options.has_key?(:filter_set)
-          Capybara::Selector::FilterSet.all[options[:filter_set]].filters
+          ::Capybara::Selector::FilterSet.all[options[:filter_set]].node_filters
         else
-          @selector.custom_filters
+          @selector.node_filters
         end
       end
 
+      def expression_filters
+        filters = @selector.expression_filters
+        filters.merge ::Capybara::Selector::FilterSet.all[options[:filter_set]].expression_filters if options.has_key?(:filter_set)
+        filters
+      end
+
       def custom_keys
-        @custom_keys ||= query_filters.keys + @selector.expression_filters
+        @custom_keys ||= node_filters.keys + expression_filters.keys
       end
 
       def assert_valid_keys
@@ -198,14 +220,31 @@ module Capybara
         expr
       end
 
+      def apply_expression_filters(expr)
+        expression_filters.inject(expr) do |memo, (name, ef)|
+          if options.has_key?(name)
+            ef.apply_filter(memo, options[name])
+          elsif ef.default?
+            ef.apply_filter(memo, ef.default)
+          else
+            memo
+          end
+        end
+      end
+
       def warn_exact_usage
         if options.has_key?(:exact) && !supports_exact?
-          warn "The :exact option only has an effect on queries using the XPath#is method. Using it with the query \"#{expression.to_s}\" has no effect."
+          warn "The :exact option only has an effect on queries using the XPath#is method. Using it with the query \"#{expression}\" has no effect."
         end
       end
 
       def exact_text
-        options.fetch(:exact_text, Capybara.exact_text)
+        options.fetch(:exact_text, session_options.exact_text)
+      end
+
+      def describe_within?
+        @resolved_node && !(@resolved_node.is_a?(::Capybara::Node::Document) ||
+                            (@resolved_node.is_a?(::Capybara::Node::Simple) && @resolved_node.path == '/'))
       end
     end
   end

data/lib/capybara/queries/sibling_query.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+module Capybara
+  module Queries
+    class SiblingQuery < MatchQuery
+      # @api private
+      def resolve_for(node, exact = nil)
+        @sibling_node = node
+        node.synchronize do
+          match_results = super(node.session.current_scope, exact)
+          node.all(:xpath, XPath.preceding_sibling.union(XPath.following_sibling)) do |el|
+            match_results.include?(el)
+          end
+        end
+      end
+
+      def description
+        desc = super
+        if @sibling_node && (sibling_query = @sibling_node.instance_variable_get(:@query))
+          desc += " that is a sibling of #{sibling_query.description}"
+        end
+        desc
+      end
+    end
+  end
+end

data/lib/capybara/queries/text_query.rb

@@ -5,13 +5,18 @@ module Capybara
     class TextQuery < BaseQuery
       def initialize(*args)
         @type = (args.first.is_a?(Symbol) || args.first.nil?) ? args.shift : nil
-        @type = (Capybara.ignore_hidden_elements or Capybara.visible_text_only) ? :visible : :all if @type.nil?
-        @expected_text, @options = args
+        # @type = (Capybara.ignore_hidden_elements or Capybara.visible_text_only) ? :visible : :all if @type.nil?
+        @options = if args.last.is_a?(Hash) then args.pop.dup else {} end
+        super(@options)
+
+        @type = (session_options.ignore_hidden_elements or session_options.visible_text_only) ? :visible : :all if @type.nil?
+
+        @expected_text = args.shift
         unless @expected_text.is_a?(Regexp)
           @expected_text = Capybara::Helpers.normalize_whitespace(@expected_text)
         end
-        @options ||= {}
         @search_regexp = Capybara::Helpers.to_regexp(@expected_text, nil, exact?)
+        warn "Unused parameters passed to #{self.class.name} : #{args}" unless args.empty?
         assert_valid_keys
       end
 
@@ -40,7 +45,7 @@ module Capybara
       private
 
       def exact?
-        options.fetch(:exact, Capybara.exact_text)
+        options.fetch(:exact, session_options.exact_text)
       end
 
       def build_message(report_on_invisible)
@@ -65,7 +70,7 @@ module Capybara
             invisible_text = text(@node, :all)
             invisible_count = invisible_text.scan(@search_regexp).size
             if invisible_count != @count
-              details_message << ". it was found #{invisible_count} #{Capybara::Helpers.declension("time", "times", invisible_count)} including non-visible text"
+              details_message << "it was found #{invisible_count} #{Capybara::Helpers.declension("time", "times", invisible_count)} including non-visible text"
             end
           rescue
             # An error getting the non-visible text (if element goes out of scope) should not affect the response

data/lib/capybara/queries/title_query.rb

@@ -6,6 +6,7 @@ module Capybara
       def initialize(expected_title, options = {})
         @expected_title = expected_title
         @options = options
+        super(@options)
         unless @expected_title.is_a?(Regexp)
           @expected_title = Capybara::Helpers.normalize_whitespace(@expected_title)
         end

data/lib/capybara/rack_test/browser.rb

@@ -22,6 +22,11 @@ class Capybara::RackTest::Browser
     process_and_follow_redirects(:get, path, attributes)
   end
 
+  def refresh
+    reset_cache!
+    request(last_request.fullpath, last_request.env)
+  end
+
   def submit(method, path, attributes)
     path = request_path if not path or path.empty?
     process_and_follow_redirects(method, path, attributes, {'HTTP_REFERER' => current_url})
@@ -45,10 +50,13 @@ class Capybara::RackTest::Browser
   def process(method, path, attributes = {}, env = {})
     new_uri = URI.parse(path)
     method.downcase! unless method.is_a? Symbol
-
-    new_uri.path = request_path if path.start_with?("?")
-    new_uri.path = "/" if new_uri.path.empty?
-    new_uri.path = request_path.sub(%r(/[^/]*$), '/') + new_uri.path unless new_uri.path.start_with?('/')
+    if path.empty?
+      new_uri.path = request_path
+    else
+      new_uri.path = request_path if path.start_with?("?")
+      new_uri.path = "/" if new_uri.path.empty?
+      new_uri.path = request_path.sub(%r(/[^/]*$), '/') + new_uri.path unless new_uri.path.start_with?('/')
+    end
     new_uri.scheme ||= @current_scheme
     new_uri.host ||= @current_host
     new_uri.port ||= @current_port unless new_uri.default_port == @current_port
@@ -68,7 +76,7 @@ class Capybara::RackTest::Browser
   end
 
   def reset_host!
-    uri = URI.parse(Capybara.app_host || Capybara.default_host)
+    uri = URI.parse(driver.session_options.app_host || driver.session_options.default_host)
     @current_scheme = uri.scheme
     @current_host = uri.host
     @current_port = uri.port