capybara 1.1.4 → 2.0.0.beta2

data/lib/capybara/node/base.rb

@@ -33,29 +33,19 @@ module Capybara
         @base = base
       end
 
+      # overridden in subclasses, e.g. Capybara::Node::Element
       def reload
         self
       end
 
-      def without_wait
-        orig = @wait_disabled
-        @wait_disabled = true
-        yield
-      ensure
-        @wait_disabled = orig
-      end
-
-    protected
-
-      def wait_until(seconds=Capybara.default_wait_time)
+      def synchronize(seconds=Capybara.default_wait_time)
         start_time = Time.now
 
         begin
           yield
         rescue => e
-          raise e if @wait_disabled
           raise e unless driver.wait?
-          raise e unless (driver.respond_to?(:invalid_element_errors) and driver.invalid_element_errors.include?(e.class)) or e.is_a?(Capybara::ElementNotFound)
+          raise e unless driver.invalid_element_errors.include?(e.class) or e.is_a?(Capybara::ElementNotFound)
           raise e if (Time.now - start_time) >= seconds
           sleep(0.05)
           raise Capybara::FrozenInTime, "time appears to be frozen, Capybara does not work with libraries which freeze time, consider using time travelling instead" if Time.now == start_time
@@ -64,6 +54,8 @@ module Capybara
         end
       end
 
+    protected
+
       def driver
         session.driver
       end

data/lib/capybara/node/element.rb

@@ -22,10 +22,10 @@ module Capybara
     #
     class Element < Base
 
-      def initialize(session, base, parent, selector)
+      def initialize(session, base, parent, query)
         super(session, base)
         @parent = parent
-        @selector = selector
+        @query = query
       end
 
       def allow_reload!
@@ -37,7 +37,7 @@ module Capybara
       # @return [Object]    The native element from the driver, this allows access to driver specific methods
       #
       def native
-        wait_until { base.native }
+        synchronize { base.native }
       end
 
       ##
@@ -45,7 +45,7 @@ module Capybara
       # @return [String]    The text of the element
       #
       def text
-        wait_until { base.text }
+        synchronize { base.text }
       end
 
       ##
@@ -58,7 +58,7 @@ module Capybara
       # @return [String]               The value of the attribute
       #
       def [](attribute)
-        wait_until { base[attribute] }
+        synchronize { base[attribute] }
       end
 
       ##
@@ -66,7 +66,7 @@ module Capybara
       # @return [String]    The value of the form element
       #
       def value
-        wait_until { base.value }
+        synchronize { base.value }
       end
 
       ##
@@ -76,7 +76,7 @@ module Capybara
       # @param [String] value    The new value
       #
       def set(value)
-        wait_until { base.set(value) }
+        synchronize { base.set(value) }
       end
 
       ##
@@ -84,7 +84,7 @@ module Capybara
       # Select this node if is an option element inside a select tag
       #
       def select_option
-        wait_until { base.select_option }
+        synchronize { base.select_option }
       end
 
       ##
@@ -92,7 +92,7 @@ module Capybara
       # Unselect this node if is an option element inside a multiple select tag
       #
       def unselect_option
-        wait_until { base.unselect_option }
+        synchronize { base.unselect_option }
       end
 
       ##
@@ -100,7 +100,7 @@ module Capybara
       # Click the Element
       #
       def click
-        wait_until { base.click }
+        synchronize { base.click }
       end
 
       ##
@@ -108,7 +108,7 @@ module Capybara
       # @return [String]      The tag name of the element
       #
       def tag_name
-        wait_until { base.tag_name }
+        synchronize { base.tag_name }
       end
 
       ##
@@ -119,7 +119,7 @@ module Capybara
       # @return [Boolean]     Whether the element is visible
       #
       def visible?
-        wait_until { base.visible? }
+        synchronize { base.visible? }
       end
 
       ##
@@ -129,7 +129,7 @@ module Capybara
       # @return [Boolean]     Whether the element is checked
       #
       def checked?
-        wait_until { base.checked? }
+        synchronize { base.checked? }
       end
 
       ##
@@ -139,7 +139,7 @@ module Capybara
       # @return [Boolean]     Whether the element is selected
       #
       def selected?
-        wait_until { base.selected? }
+        synchronize { base.selected? }
       end
 
       ##
@@ -149,7 +149,7 @@ module Capybara
       # @return [String]      An XPath expression
       #
       def path
-        wait_until { base.path }
+        synchronize { base.path }
       end
 
       ##
@@ -160,7 +160,7 @@ module Capybara
       # @param [String] event       The name of the event to trigger
       #
       def trigger(event)
-        wait_until { base.trigger(event) }
+        synchronize { base.trigger(event) }
       end
 
       ##
@@ -174,24 +174,24 @@ module Capybara
       # @param [Capybara::Element] node     The element to drag to
       #
       def drag_to(node)
-        wait_until { base.drag_to(node.base) }
+        synchronize { base.drag_to(node.base) }
       end
 
       def find(*args)
-        wait_until { super }
+        synchronize { super }
       end
 
       def first(*args)
-        wait_until { super }
+        synchronize { super }
       end
 
       def all(*args)
-        wait_until { super }
+        synchronize { super }
       end
 
       def reload
         if @allow_reload
-          reloaded = parent.reload.first(@selector.name, @selector.locator, @selector.options)
+          reloaded = parent.reload.first(@query.name, @query.locator, @query.options)
           @base = reloaded.base if reloaded
         end
         self

data/lib/capybara/node/finders.rb

@@ -24,7 +24,7 @@ module Capybara
       # @raise  [Capybara::ElementNotFound]   If the element can't be found before time expires
       #
       def find(*args)
-        wait_until { first(*args) or raise_find_error(*args) }.tap(&:allow_reload!)
+        synchronize { all(*args).find! }.tap(&:allow_reload!)
       end
 
       ##
@@ -35,7 +35,7 @@ module Capybara
       # @return [Capybara::Element]   The found element
       #
       def find_field(locator)
-        find(:xpath, XPath::HTML.field(locator))
+        find(:field, locator)
       end
       alias_method :field_labeled, :find_field
 
@@ -47,7 +47,7 @@ module Capybara
       # @return [Capybara::Element]   The found element
       #
       def find_link(locator)
-        find(:xpath, XPath::HTML.link(locator))
+        find(:link, locator)
       end
 
       ##
@@ -58,18 +58,18 @@ module Capybara
       # @return [Capybara::Element]   The found element
       #
       def find_button(locator)
-        find(:xpath, XPath::HTML.button(locator))
+        find(:button, locator)
       end
 
       ##
       #
       # Find a element on the page, given its id.
       #
-      # @param [String] locator       Which element to find
+      # @param [String] id            Which element to find
       # @return [Capybara::Element]   The found element
       #
       def find_by_id(id)
-        find(:css, "##{id}")
+        find(:id, id)
       end
 
       ##
@@ -99,20 +99,23 @@ module Capybara
       #     page.all('a', :text => 'Home')
       #     page.all('#menu li', :visible => true)
       #
-      # @param [:css, :xpath, String] kind_or_locator     Either the kind of selector or the selector itself
-      # @param [String] locator                           The selector
-      # @param [Hash{Symbol => Object}] options           Additional options
-      # @option options [String, Regexp] text             Only find elements which contain this text or match this regexp
-      # @option options [Boolean] visible                 Only find elements that are visible on the page
-      # @return [Capybara::Element]                       The found elements
+      # @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] visible          Only find elements that are visible on the page. Setting this to false
+      #                                              (the default, unless Capybara.ignore_hidden_elements = true), finds
+      #                                              invisible _and_ visible elements.
+      # @return [Array[Capybara::Element]]           The found elements
       #
       def all(*args)
-        selector = Capybara::Selector.normalize(*args)
-        options = extract_normalized_options(args)
-
-        selector.xpaths.
-          map    { |path| find_in_base(selector, path) }.flatten.
-          select { |node| node.without_wait { matches_options(node, options) } }
+        query = Capybara::Query.new(*args)
+        elements = synchronize do
+          base.find(query.xpath).map do |node|
+            Capybara::Node::Element.new(session, node, self, query)
+          end
+        end
+        Capybara::Result.new(elements, query)
       end
 
       ##
@@ -120,79 +123,14 @@ module Capybara
       # Find the first element on the page matching the given selector
       # and options, or nil if no element matches.
       #
-      # When only the first matching element is needed, this method can
-      # be faster than all(*args).first.
-      #
-      # @param [:css, :xpath, String] kind_or_locator     Either the kind of selector or the selector itself
-      # @param [String] locator                           The selector
-      # @param [Hash{Symbol => Object}] options           Additional options; see {all}
-      # @return Capybara::Element                         The found element
+      # @overload first([kind], locator, options)
+      #   @param [:css, :xpath] kind                 The type of selector
+      #   @param [String] locator                    The selector
+      #   @param [Hash] options                      Additional options; see {all}
+      # @return [Capybara::Element]                  The found element or nil
       #
       def first(*args)
-        selector = Capybara::Selector.normalize(*args)
-        options = extract_normalized_options(args)
-        found_elements = []
-
-        selector.xpaths.each do |path|
-          find_in_base(selector, path).each do |node|
-            node.without_wait do
-              if matches_options(node, options)
-                found_elements << node
-                return found_elements.last if not Capybara.prefer_visible_elements or node.visible?
-              end
-            end
-          end
-        end
-        found_elements.first
-      end
-
-    protected
-
-      def raise_find_error(*args)
-        options = extract_normalized_options(args)
-        normalized = Capybara::Selector.normalize(*args)
-        message = options[:message] || "Unable to find #{normalized.name} #{normalized.locator.inspect}"
-        message = normalized.failure_message.call(self, normalized) if normalized.failure_message
-        raise Capybara::ElementNotFound, message
-      end
-
-      def find_in_base(selector, xpath)
-        base.find(xpath).map do |node|
-          Capybara::Node::Element.new(session, node, self, selector)
-        end
-      end
-
-      def extract_normalized_options(args)
-        options = if args.last.is_a?(Hash) then args.pop.dup else {} end
-
-        if text = options[:text]
-          options[:text] = Regexp.escape(text) unless text.kind_of?(Regexp)
-        end
-
-        if !options.has_key?(:visible)
-          options[:visible] = Capybara.ignore_hidden_elements
-        end
-
-        if selected = options[:selected]
-          options[:selected] = [selected].flatten
-        end
-
-        options
-      end
-
-      def matches_options(node, options)
-        return false if options[:text]      and not node.text.match(options[:text])
-        return false if options[:visible]   and not node.visible?
-        return false if options[:with]      and not node.value == options[:with]
-        return false if options[:checked]   and not node.checked?
-        return false if options[:unchecked] and node.checked?
-        return false if options[:selected]  and not has_selected_options?(node, options[:selected])
-        true
-      end
-
-      def has_selected_options?(node, expected)
-        actual = node.all(:xpath, './/option').select { |option| option.selected? }.map { |option| option.text }
-        (expected - actual).empty?
+        all(*args).first
       end
     end
   end

data/lib/capybara/node/matchers.rb

@@ -33,29 +33,19 @@ module Capybara
       # @return [Boolean]                         If the expression exists
       #
       def has_selector?(*args)
-        options = if args.last.is_a?(Hash) then args.last else {} end
-        wait_until do
-          results = all(*args)
-
-          case
-          when results.empty?
-            false
-          when options[:between]
-            options[:between] === results.size
-          when options[:count]
-            options[:count].to_i == results.size
-          when options[:maximum]
-            options[:maximum].to_i >= results.size
-          when options[:minimum]
-            options[:minimum].to_i <= results.size
-          else
-            results.size > 0
-          end or raise ExpectationNotMet
-        end
+        assert_selector(*args)
       rescue Capybara::ExpectationNotMet
         return false
       end
 
+      def assert_selector(*args)
+        synchronize do
+          result = all(*args)
+          result.matches_count? or raise Capybara::ExpectationNotMet, result.failure_message
+        end
+        return true
+      end
+
       ##
       #
       # Checks if a given selector is not on the page or current node.
@@ -65,29 +55,19 @@ module Capybara
       # @return [Boolean]
       #
       def has_no_selector?(*args)
-        options = if args.last.is_a?(Hash) then args.last else {} end
-        wait_until do
-          results = all(*args)
-
-          case
-          when results.empty?
-            true
-          when options[:between]
-            not(options[:between] === results.size)
-          when options[:count]
-            not(options[:count].to_i == results.size)
-          when options[:maximum]
-            not(options[:maximum].to_i >= results.size)
-          when options[:minimum]
-            not(options[:minimum].to_i <= results.size)
-          else
-            results.empty?
-          end or raise ExpectationNotMet
-        end
+        assert_no_selector(*args)
       rescue Capybara::ExpectationNotMet
         return false
       end
 
+      def assert_no_selector(*args)
+        synchronize do
+          result = all(*args)
+          result.matches_count? and raise Capybara::ExpectationNotMet, result.negative_failure_message
+        end
+        return true
+      end
+
       ##
       #
       # Checks if a given XPath expression is on the page or current node.
@@ -157,7 +137,7 @@ module Capybara
       # @return [Boolean]                         If the selector exists
       #
       def has_css?(path, options={})
-        has_xpath?(XPath.css(path), options)
+        has_selector?(:css, path, options)
       end
 
       ##
@@ -169,7 +149,7 @@ module Capybara
       # @return [Boolean]
       #
       def has_no_css?(path, options={})
-        has_no_xpath?(XPath.css(path), options)
+        has_no_selector?(:css, path, options)
       end
 
       ##
@@ -177,24 +157,48 @@ module Capybara
       # Checks if the page or current node has the given text content,
       # ignoring any HTML tags and normalizing whitespace.
       #
+      # Unlike has_content this only matches displayable text and specifically
+      # excludes text contained within non-display nodes such as script or head tags.
+      #
       # @param [String] content       The text to check for
       # @return [Boolean]             Whether it exists
       #
-      def has_content?(content)
-        has_xpath?(XPath::HTML.content(content))
+      def has_text?(content)
+        normalized_content = normalize_whitespace(content)
+
+        synchronize do
+          normalize_whitespace(text).match(escape_regexp(normalized_content)) or
+          raise ExpectationNotMet
+        end
+        return true
+      rescue Capybara::ExpectationNotMet
+        return false
       end
+      alias_method :has_content?, :has_text?
 
       ##
       #
       # Checks if the page or current node does not have the given text
       # content, ignoring any HTML tags and normalizing whitespace.
       #
+      # Unlike has_content this only matches displayable text and specifically
+      # excludes text contained within non-display nodes such as script or head tags.
+      #
       # @param [String] content       The text to check for
       # @return [Boolean]             Whether it exists
       #
-      def has_no_content?(content)
-        has_no_xpath?(XPath::HTML.content(content))
+      def has_no_text?(content)
+        normalized_content = normalize_whitespace(content)
+
+        synchronize do
+          !normalize_whitespace(text).match(escape_regexp(normalized_content)) or
+          raise ExpectationNotMet
+        end
+        return true
+      rescue Capybara::ExpectationNotMet
+        return false
       end
+      alias_method :has_no_content?, :has_no_text?
 
       ##
       #
@@ -207,7 +211,7 @@ module Capybara
       # @return [Boolean]                 Whether it exists
       #
       def has_link?(locator, options={})
-        has_xpath?(XPath::HTML.link(locator, options))
+        has_selector?(:link, locator, options)
       end
 
       ##
@@ -219,7 +223,7 @@ module Capybara
       # @return [Boolean]            Whether it doesn't exist
       #
       def has_no_link?(locator, options={})
-        has_no_xpath?(XPath::HTML.link(locator, options))
+        has_no_selector?(:link, locator, options)
       end
 
       ##
@@ -231,7 +235,7 @@ module Capybara
       # @return [Boolean]            Whether it exists
       #
       def has_button?(locator)
-        has_xpath?(XPath::HTML.button(locator))
+        has_selector?(:button, locator)
       end
 
       ##
@@ -243,7 +247,7 @@ module Capybara
       # @return [Boolean]            Whether it doesn't exist
       #
       def has_no_button?(locator)
-        has_no_xpath?(XPath::HTML.button(locator))
+        has_no_selector?(:button, locator)
       end
 
       ##
@@ -257,13 +261,17 @@ module Capybara
       #
       #     page.has_field?('Name', :with => 'Jonas')
       #
+      # It is also possible to filter by the field type attribute:
+      #
+      #     page.has_field?('Email', :type => 'email')
+      #
       # @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
       #
       def has_field?(locator, options={})
-        options, with = split_options(options, :with)
-        has_xpath?(XPath::HTML.field(locator, options), with)
+        has_selector?(:field, locator, options)
       end
 
       ##
@@ -273,11 +281,11 @@ module Capybara
       #
       # @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
       #
       def has_no_field?(locator, options={})
-        options, with = split_options(options, :with)
-        has_no_xpath?(XPath::HTML.field(locator, options), with)
+        has_no_selector?(:field, locator, options)
       end
 
       ##
@@ -290,7 +298,7 @@ module Capybara
       # @return [Boolean]                 Whether it exists
       #
       def has_checked_field?(locator)
-        has_xpath?(XPath::HTML.field(locator), :checked => true)
+        has_selector?(:field, locator, :checked => true)
       end
 
       ##
@@ -303,7 +311,7 @@ module Capybara
       # @return [Boolean]                 Whether it doesn't exists
       #
       def has_no_checked_field?(locator)
-        has_no_xpath?(XPath::HTML.field(locator), :checked => true)
+        has_no_selector?(:field, locator, :checked => true)
       end
 
       ##
@@ -316,7 +324,7 @@ module Capybara
       # @return [Boolean]                 Whether it exists
       #
       def has_unchecked_field?(locator)
-        has_xpath?(XPath::HTML.field(locator), :unchecked => true)
+        has_selector?(:field, locator, :unchecked => true)
       end
 
       ##
@@ -329,7 +337,7 @@ module Capybara
       # @return [Boolean]                 Whether it doesn't exists
       #
       def has_no_unchecked_field?(locator)
-        has_no_xpath?(XPath::HTML.field(locator), :unchecked => true)
+        has_no_selector?(:field, locator, :unchecked => true)
       end
 
       ##
@@ -345,19 +353,23 @@ module Capybara
       #
       #     page.has_select?('Language', :selected => ['English', 'German'])
       #
-      # It's also possible to check if a given set of options exists for
+      # It's also possible to check if the exact set of options exists for
       # this select box:
       #
-      #     page.has_select?('Language', :options => ['English', 'German'])
+      #     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'])
       #
       # @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
       #
       def has_select?(locator, options={})
-        options, selected = split_options(options, :selected)
-        has_xpath?(XPath::HTML.select(locator, options), selected)
+        has_selector?(:select, locator, options)
       end
 
       ##
@@ -369,8 +381,7 @@ module Capybara
       # @return [Boolean]     Whether it doesn't exist
       #
       def has_no_select?(locator, options={})
-        options, selected = split_options(options, :selected)
-        has_no_xpath?(XPath::HTML.select(locator, options), selected)
+        has_no_selector?(:select, locator, options)
       end
 
       ##
@@ -387,11 +398,10 @@ module Capybara
       # and the text needs to match exactly.
       #
       # @param [String] locator                        The id or caption of a table
-      # @option options [Array[Array[String]]] :rows   A set of rows the table should contain
       # @return [Boolean]                              Whether it exist
       #
       def has_table?(locator, options={})
-        has_xpath?(XPath::HTML.table(locator, options))
+        has_selector?(:table, locator, options)
       end
 
       ##
@@ -403,14 +413,42 @@ module Capybara
       # @return [Boolean]       Whether it doesn't exist
       #
       def has_no_table?(locator, options={})
-        has_no_xpath?(XPath::HTML.table(locator, options))
+        has_no_selector?(:table, locator, options)
       end
 
-      protected
+      def ==(other)
+        if other.respond_to?(:native)
+          self.eql?(other) or native == other.native
+        else
+          self.eql?(other)
+        end
+      end
+
+    private
+
+      ##
+      #
+      # Normalizes whitespace space by stripping leading and trailing
+      # whitespace and replacing sequences of whitespace characters
+      # with a single space.
+      #
+      # @param [String] text     Text to normalize
+      # @return [String]         Normalized text
+      #
+      def normalize_whitespace(text)
+        text.is_a?(Regexp) ? text : text.gsub(/\s+/, ' ').strip
+      end
 
-      def split_options(options, key)
-        options = options.dup
-        [options, if options.has_key?(key) then {key => options.delete(key)} else {} end]
+      ##
+      #
+      # Escapes any characters that would have special meaning in a regexp
+      # if text is not a regexp
+      #
+      # @param [String] text Text to escape
+      # @return [String]     Escaped text
+      #
+      def escape_regexp(text)
+        text.is_a?(Regexp) ? text : Regexp.escape(text)
       end
     end
   end