capybara 1.1.4 → 2.0.0

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,29 +47,29 @@ module Capybara
       # @return [Capybara::Element]   The found element
       #
       def find_link(locator)
-        find(:xpath, XPath::HTML.link(locator))
+        find(:link, locator)
       end
 
       ##
       #
-      # Find a button on the page. The link can be found by its id, name or value.
+      # Find a button on the page. The button can be found by its id, name or value.
       #
       # @param [String] locator       Which button to find
       # @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

@@ -25,33 +25,14 @@ module Capybara
       # has_selector? can also accept XPath expressions generated by the
       # XPath gem:
       #
-      #     xpath = XPath.generate { |x| x.descendant(:p) }
-      #     page.has_selector?(:xpath, xpath)
+      #     page.has_selector?(:xpath, XPath.descendant(:p))
       #
       # @param (see Capybara::Node::Finders#all)
       # @option options [Integer] :count (nil)    Number of times the expression should occur
       # @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
@@ -65,29 +46,64 @@ 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
 
+      ##
+      #
+      # Asserts that a given selector is on the page or current node.
+      #
+      #     page.assert_selector('p#foo')
+      #     page.assert_selector(:xpath, './/p[@id="foo"]')
+      #     page.assert_selector(:foo)
+      #
+      # 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)
+      #
+      # 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.
+      #
+      #     page.assert_selector('li', :text => 'Horse', :visible => true)
+      #
+      # {assert_selector} can also accept XPath expressions generated by the
+      # XPath gem:
+      #
+      #     page.assert_selector(:xpath, XPath.descendant(:p))
+      #
+      # @param (see Capybara::Node::Finders#all)
+      # @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)
+        synchronize do
+          result = all(*args)
+          result.matches_count? or raise Capybara::ExpectationNotMet, result.failure_message
+        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
+      #
+      # @param (see Capybara::Node::Finders#assert_selector)
+      # @raise [Capybara::ExpectationNotMet]      If the selector exists
+      #
+      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 +173,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 +185,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 +193,46 @@ module Capybara
       # Checks if the page or current node has the given text content,
       # ignoring any HTML tags and normalizing whitespace.
       #
+      # 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)
+        synchronize do
+          unless Capybara::Helpers.normalize_whitespace(text).match(Capybara::Helpers.to_regexp(content))
+            raise ExpectationNotMet
+          end
+        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.
       #
+      # 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
+      # @return [Boolean]             Whether it doesn't exist
       #
-      def has_no_content?(content)
-        has_no_xpath?(XPath::HTML.content(content))
+      def has_no_text?(content)
+        synchronize do
+          if Capybara::Helpers.normalize_whitespace(text).match(Capybara::Helpers.to_regexp(content))
+            raise ExpectationNotMet
+          end
+        end
+        return true
+      rescue Capybara::ExpectationNotMet
+        return false
       end
+      alias_method :has_no_content?, :has_no_text?
 
       ##
       #
@@ -207,7 +245,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 +257,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 +269,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 +281,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 +295,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 +315,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 +332,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 +345,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 +358,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 +371,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 +387,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 +415,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 +432,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,15 +447,19 @@ 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 split_options(options, key)
-        options = options.dup
-        [options, if options.has_key?(key) then {key => options.delete(key)} else {} end]
+      def ==(other)
+        if other.respond_to?(:native)
+          self.eql?(other) or native == other.native
+        else
+          self.eql?(other)
+        end
       end
+
+    private
+
     end
   end
 end

data/lib/capybara/node/simple.rb

@@ -95,7 +95,7 @@ module Capybara
       # @return [Boolean]     Whether the element is visible
       #
       def visible?
-        native.xpath("./ancestor-or-self::*[contains(@style, 'display:none') or contains(@style, 'display: none')]").size == 0
+        native.xpath("./ancestor-or-self::*[contains(@style, 'display:none') or contains(@style, 'display: none') or name()='script' or name()='head']").size == 0
       end
 
       ##
@@ -118,22 +118,24 @@ module Capybara
         native[:selected]
       end
 
-      def allow_reload!
-        # no op
+      def synchronize
+        yield # simple nodes don't need to wait
       end
 
-      def without_wait
-        yield
+      def allow_reload!
+        # no op
       end
 
-    protected
-
-      def find_in_base(selector, xpath)
-        native.xpath(xpath).map { |node| self.class.new(node) }
+      def unsynchronized
+        yield # simple nodes don't need to wait
       end
 
-      def wait_until
-        yield # simple nodes don't need to wait
+      def all(*args)
+        query = Capybara::Query.new(*args)
+        elements = native.xpath(query.xpath).map do |node|
+          self.class.new(node)
+        end
+        Capybara::Result.new(elements, query)
       end
     end
   end

data/lib/capybara/query.rb

@@ -0,0 +1,78 @@
+module Capybara
+  class Query
+    attr_accessor :selector, :locator, :options, :xpath, :find, :negative
+
+    VALID_KEYS = [:text, :visible, :between, :count, :maximum, :minimum]
+
+    def initialize(*args)
+      @options = if args.last.is_a?(Hash) then args.pop.dup else {} end
+
+      unless options.has_key?(:visible)
+        @options[:visible] = Capybara.ignore_hidden_elements
+      end
+
+      if args[0].is_a?(Symbol)
+        @selector = Selector.all[args[0]]
+        @locator = args[1]
+      else
+        @selector = Selector.all.values.find { |s| s.match?(args[0]) }
+        @locator = args[0]
+      end
+      @selector ||= Selector.all[Capybara.default_selector]
+
+      @xpath = @selector.call(@locator).to_s
+
+      assert_valid_keys!
+    end
+
+    def name; selector.name; end
+    def label; selector.label or selector.name; end
+
+    def description
+      @description = "#{label} #{locator.inspect}"
+      @description << " with text #{options[:text].inspect}" if options[:text]
+      @description
+    end
+
+    def matches_filters?(node)
+      node.unsynchronized do
+        if options[:text]
+          regexp = options[:text].is_a?(Regexp) ? options[:text] : Regexp.escape(options[:text])
+          return false if not node.text.match(regexp)
+        end
+        return false if options[:visible] and not node.visible?
+        selector.custom_filters.each do |name, block|
+          return false if options.has_key?(name) and not block.call(node, options[name])
+        end
+        true
+      end
+    end
+
+    def matches_count?(count)
+      case
+      when options[:between]
+        options[:between] === count
+      when options[:count]
+        options[:count].to_i == count
+      when options[:maximum]
+        options[:maximum].to_i >= count
+      when options[:minimum]
+        options[:minimum].to_i <= count
+      else
+        count > 0
+      end
+    end
+
+  private
+
+    def assert_valid_keys!
+      valid_keys = VALID_KEYS + @selector.custom_filters.keys
+      invalid_keys = @options.keys - valid_keys
+      unless invalid_keys.empty?
+        invalid_names = invalid_keys.map(&:inspect).join(", ")
+        valid_names = valid_keys.map(&:inspect).join(", ")
+        raise ArgumentError, "invalid keys #{invalid_names}, should be one of #{valid_names}"
+      end
+    end
+  end
+end