capybara 2.0.3 → 2.1.0

data/lib/capybara/query.rb

@@ -1,16 +1,13 @@
 module Capybara
   class Query
-    attr_accessor :selector, :locator, :options, :xpath, :find, :negative
+    attr_accessor :selector, :locator, :options, :expression, :find, :negative
 
-    VALID_KEYS = [:text, :visible, :between, :count, :maximum, :minimum]
+    VALID_KEYS = [:text, :visible, :between, :count, :maximum, :minimum, :exact, :match, :wait]
+    VALID_MATCH = [:first, :smart, :prefer_exact, :one]
 
     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]
@@ -20,8 +17,12 @@ module Capybara
       end
       @selector ||= Selector.all[Capybara.default_selector]
 
-      @xpath = @selector.call(@locator).to_s
+      # for compatibility with Capybara 2.0
+      if Capybara.exact_options and @selector == Selector.all[:option]
+        @options[:exact] = true
+      end
 
+      @expression = @selector.call(@locator)
       assert_valid_keys!
     end
 
@@ -35,34 +36,76 @@ module Capybara
     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)
+      if options[:text]
+        regexp = options[:text].is_a?(Regexp) ? options[:text] : Regexp.escape(options[:text].to_s)
+        return false if not node.text(visible).match(regexp)
+      end
+      case visible
+        when :visible then return false unless node.visible?
+        when :hidden then return false if node.visible?
+      end
+      selector.custom_filters.each do |name, filter|
+        if options.has_key?(name)
+          return false unless filter.matches?(node, options[name])
+        elsif filter.default?
+          return false unless filter.matches?(node, filter.default)
         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
+    end
+
+    def visible
+      if options.has_key?(:visible)
+        case @options[:visible]
+          when true then :visible
+          when false then :all
+          else @options[:visible]
+        end
+      else
+        if Capybara.ignore_hidden_elements
+          :visible
+        else
+          :all
         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
+    def wait
+      if options.has_key?(:wait)
+        @options[:wait] or 0
       else
-        count > 0
+        Capybara.default_wait_time
       end
     end
 
+    def exact?
+      if options.has_key?(:exact)
+        @options[:exact]
+      else
+        Capybara.exact
+      end
+    end
+
+    def match
+      if options.has_key?(:match)
+        @options[:match]
+      else
+        Capybara.match
+      end
+    end
+
+    def xpath(exact=nil)
+      exact = self.exact? if exact == nil
+      if @expression.respond_to?(:to_xpath) and exact
+        @expression.to_xpath(:exact)
+      else
+        @expression.to_s
+      end
+    end
+
+    def css
+      @expression
+    end
+
   private
 
     def assert_valid_keys!
@@ -73,6 +116,9 @@ module Capybara
         valid_names = valid_keys.map(&:inspect).join(", ")
         raise ArgumentError, "invalid keys #{invalid_names}, should be one of #{valid_names}"
       end
+      unless VALID_MATCH.include?(match)
+        raise ArgumentError, "invalid option #{match.inspect} for :match, should be one of #{VALID_MATCH.map(&:inspect).join(", ")}"
+      end
     end
   end
 end

data/lib/capybara/rack_test/browser.rb

@@ -80,8 +80,12 @@ class Capybara::RackTest::Browser
     @dom ||= Nokogiri::HTML(html)
   end
 
-  def find(selector)
-    dom.xpath(selector).map { |node| Capybara::RackTest::Node.new(self, node) }
+  def find(format, selector)
+    if format==:css
+      dom.css(selector, Capybara::RackTest::CSSHandlers.new)
+    else
+      dom.xpath(selector)
+    end.map { |node| Capybara::RackTest::Node.new(self, node) }
   end
 
   def html
@@ -89,7 +93,11 @@ class Capybara::RackTest::Browser
   rescue Rack::Test::Error
     ""
   end
-
+  
+  def title
+    dom.xpath("//title").text
+  end
+  
 protected
 
   def build_rack_mock_session

data/lib/capybara/rack_test/css_handlers.rb

@@ -0,0 +1,8 @@
+class Capybara::RackTest::CSSHandlers
+  def disabled list
+    list.find_all { |node| node.has_attribute? 'disabled' }
+  end        
+  def enabled list
+    list.find_all { |node| !node.has_attribute? 'disabled' }
+  end
+end

data/lib/capybara/rack_test/driver.rb

@@ -62,10 +62,14 @@ class Capybara::RackTest::Driver < Capybara::Driver::Base
     response.status
   end
 
-  def find(selector)
-    browser.find(selector)
+  def find_xpath(selector)
+    browser.find(:xpath, selector)
   end
-
+  
+  def find_css(selector)
+    browser.find(:css,selector)
+  end
+  
   def html
     browser.html
   end
@@ -73,6 +77,10 @@ class Capybara::RackTest::Driver < Capybara::Driver::Base
   def dom
     browser.dom
   end
+  
+  def title
+    browser.title
+  end
 
   def reset!
     @browser = nil

data/lib/capybara/rack_test/form.rb

@@ -17,7 +17,14 @@ class Capybara::RackTest::Form < Capybara::RackTest::Node
   def params(button)
     params = {}
 
-    native.xpath("(.//input|.//select|.//textarea)[not(@disabled)]").map do |field|
+    form_element_types=[:input, :select, :textarea]
+    form_elements_xpath=XPath.generate do |x| 
+      xpath=x.descendant(*form_element_types).where(~x.attr(:form))
+      xpath=xpath.union(x.anywhere(*form_element_types).where(x.attr(:form) == native[:id])) if native[:id]
+      xpath.where(~x.attr(:disabled))
+    end.to_s
+    
+    native.xpath(form_elements_xpath).map do |field|
       case field.name
       when 'input'
         if %w(radio checkbox).include? field['type']

data/lib/capybara/rack_test/node.rb

@@ -1,5 +1,9 @@
 class Capybara::RackTest::Node < Capybara::Driver::Node
-  def text
+  def all_text
+    Capybara::Helpers.normalize_whitespace(native.text)
+  end
+
+  def visible_text
     Capybara::Helpers.normalize_whitespace(unnormalized_text)
   end
 
@@ -15,42 +19,21 @@ class Capybara::RackTest::Node < Capybara::Driver::Node
     if (Array === value) && !self[:multiple]
       raise ArgumentError.new "Value cannot be an Array when 'multiple' attribute is not present. Not a #{value.class}"
     end
-    if tag_name == 'input' and type == 'radio'
-      other_radios_xpath = XPath.generate { |x| x.anywhere(:input)[x.attr(:name).equals(self[:name])] }.to_s
-      driver.dom.xpath(other_radios_xpath).each { |node| node.remove_attribute("checked") }
-      native['checked'] = 'checked'
-    elsif tag_name == 'input' and type == 'checkbox'
-      if value && !native['checked']
-        native['checked'] = 'checked'
-      elsif !value && native['checked']
-        native.remove_attribute('checked')
-      end
-    elsif tag_name == 'input'
-      if (type == 'text' || type == 'password') && self[:maxlength] &&
-        !self[:maxlength].empty?
-        # Browser behavior for maxlength="0" is inconsistent, so we stick with
-        # Firefox, allowing no input
-        value = value[0...self[:maxlength].to_i]
-      end
-      if Array === value #Assert multiple attribute is present
-        value.each do |v|
-          new_native = native.clone
-          new_native.remove_attribute('value')
-          native.add_next_sibling(new_native)
-          new_native['value'] = v.to_s
-        end
-        native.remove
-      else
-        native['value'] = value.to_s
-      end
-    elsif tag_name == "textarea"
-      native.content = value.to_s
+
+    if radio?
+      set_radio(value)
+    elsif checkbox?
+      set_checkbox(value)
+    elsif input_field?
+      set_input(value)
+    elsif textarea?
+      native.content = value.to_s unless self[:readonly]
     end
   end
 
   def select_option
     if select_node['multiple'] != 'multiple'
-      select_node.find(".//option[@selected]").each { |node| node.native.remove_attribute("selected") }
+      select_node.find_xpath(".//option[@selected]").each { |node| node.native.remove_attribute("selected") }
     end
     native["selected"] = 'selected'
   end
@@ -89,14 +72,26 @@ class Capybara::RackTest::Node < Capybara::Driver::Node
     string_node.selected?
   end
 
+  def disabled?
+    if %w(option optgroup).include? tag_name
+      string_node.disabled? || find_xpath("parent::*")[0].disabled?
+    else
+      string_node.disabled?
+    end
+  end
+
   def path
     native.path
   end
 
-  def find(locator)
+  def find_xpath(locator)
     native.xpath(locator).map { |n| self.class.new(driver, n) }
   end
 
+  def find_css(locator)
+    native.css(locator, Capybara::RackTest::CSSHandlers.new).map { |n| self.class.new(driver, n) }
+  end
+
   def ==(other)
     native == other.native
   end
@@ -125,7 +120,7 @@ private
 
   # a reference to the select node if this is an option node
   def select_node
-    find('./ancestor::select').first
+    find_xpath('./ancestor::select').first
   end
 
   def type
@@ -133,6 +128,67 @@ private
   end
 
   def form
-    native.ancestors('form').first
+    if native[:form]
+      native.xpath("//form[@id='#{native[:form]}']").first
+    else
+      native.ancestors('form').first
+    end
+  end
+
+  def set_radio(value)
+    other_radios_xpath = XPath.generate { |x| x.anywhere(:input)[x.attr(:name).equals(self[:name])] }.to_s
+    driver.dom.xpath(other_radios_xpath).each { |node| node.remove_attribute("checked") }
+    native['checked'] = 'checked'
+  end
+
+  def set_checkbox(value)
+    if value && !native['checked']
+      native['checked'] = 'checked'
+    elsif !value && native['checked']
+      native.remove_attribute('checked')
+    end
+  end
+
+  def set_input(value)
+    if text_or_password? && attribute_is_not_blank?(:maxlength)
+      # Browser behavior for maxlength="0" is inconsistent, so we stick with
+      # Firefox, allowing no input
+      value = value.to_s[0...self[:maxlength].to_i]
+    end
+    if Array === value #Assert multiple attribute is present
+      value.each do |v|
+        new_native = native.clone
+        new_native.remove_attribute('value')
+        native.add_next_sibling(new_native)
+        new_native['value'] = v.to_s
+      end
+      native.remove
+    else
+      native['value'] = value.to_s unless self[:readonly]
+    end
+  end
+
+  def attribute_is_not_blank?(attribute)
+    self[attribute] && !self[attribute].empty?
+  end
+
+  def checkbox?
+    input_field? && type == 'checkbox'
+  end
+
+  def input_field?
+    tag_name == 'input'
+  end
+
+  def radio?
+    input_field? && type == 'radio'
+  end
+
+  def textarea?
+    tag_name == "textarea"
+  end
+
+  def text_or_password?
+    input_field? && (type == 'text' || type == 'password')
   end
 end

data/lib/capybara/rails.rb

@@ -12,7 +12,6 @@ Capybara.app = Rack::Builder.new do
   end
 end.to_app
 
-Capybara.asset_root = Rails.root.join('public')
 Capybara.save_and_open_page_path = Rails.root.join('tmp/capybara')
 
 # Override default rack_test driver to respect data-method attributes.

data/lib/capybara/result.rb

@@ -1,6 +1,23 @@
 require 'forwardable'
 
 module Capybara
+
+  ##
+  # A {Capybara::Result} represents a collection of {Capybara::Element} on the page. It is possible to interact with this
+  # collection similar to an Array because it implements Enumerable and offers the following Array methods through delegation:
+  #
+  # * []
+  # * each()
+  # * at()
+  # * size()
+  # * count()
+  # * length()
+  # * first()
+  # * last()
+  # * empty?()
+  #
+  # @see Capybara::Element
+  #
   class Result
     include Enumerable
     extend Forwardable
@@ -15,36 +32,13 @@ module Capybara
     def_delegators :@result, :each, :[], :at, :size, :count, :length, :first, :last, :empty?
 
     def matches_count?
-      @query.matches_count?(@result.size)
-    end
-
-    def find!
-      raise find_error if @result.size != 1
-      @result.first
-    end
-
-    def find_error
-      if @result.size == 0
-        Capybara::ElementNotFound.new("Unable to find #{@query.description}")
-      elsif @result.size > 1
-        Capybara::Ambiguous.new("Ambiguous match, found #{size} elements matching #{@query.description}")
-      end
+      Capybara::Helpers.matches_count?(@result.size, @query.options)
     end
 
     def failure_message
-      message = if @query.options[:count]
-        "expected #{@query.description} to be found #{@query.options[:count]} #{declension("time", "times", @query.options[:count])}"
-      elsif @query.options[:between]
-        "expected #{@query.description} to be found between #{@query.options[:between].first} and #{@query.options[:between].last} times"
-      elsif @query.options[:maximum]
-        "expected #{@query.description} to be found at most #{@query.options[:maximum]} #{declension("time", "times", @query.options[:maximum])}"
-      elsif @query.options[:minimum]
-        "expected #{@query.description} to be found at least #{@query.options[:minimum]} #{declension("time", "times", @query.options[:minimum])}"
-      else
-        "expected to find #{@query.description}"
-      end
+      message = Capybara::Helpers.failure_message(@query.description, @query.options)
       if count > 0
-        message << ", found #{count} #{declension("match", "matches")}: " << @result.map(&:text).map(&:inspect).join(", ")
+        message << ", found #{count} #{Capybara::Helpers.declension("match", "matches", count)}: " << @result.map(&:text).map(&:inspect).join(", ")
       else
         message << " but there were no matches"
       end
@@ -56,17 +50,7 @@ module Capybara
     end
 
     def negative_failure_message
-      "expected not to find #{@query.description}, but there #{declension("was", "were")} #{count} #{declension("match", "matches")}"
-    end
-
-  private
-
-    def declension(singular, plural, count=count)
-      if count == 1
-        singular
-      else
-        plural
-      end
+      failure_message.sub(/(to be found|to find)/, 'not \1')
     end
   end
 end

data/lib/capybara/rspec/matchers.rb

@@ -1,6 +1,16 @@
 module Capybara
   module RSpecMatchers
-    class HaveSelector
+    class Matcher
+      def wrap(actual)
+        if actual.respond_to?("has_selector?")
+          actual
+        else
+          Capybara.string(actual.to_s)
+        end
+      end
+    end
+
+    class HaveSelector < Matcher
       def initialize(*args)
         @args = args
       end
@@ -17,59 +27,77 @@ module Capybara
         "have #{query.description}"
       end
 
-      def wrap(actual)
-        if actual.respond_to?("has_selector?")
-          actual
-        else
-          Capybara.string(actual.to_s)
-        end
-      end
-
       def query
         @query ||= Capybara::Query.new(*@args)
       end
     end
 
-    class HaveText
-      attr_reader :text
+    class HaveText < Matcher
+      attr_reader :type, :content, :options
 
-      def initialize(text)
-        @text = text
+      def initialize(*args)
+        @type = args.shift if args.first.is_a?(Symbol)
+        @content = args.shift
+        @options = (args.first.is_a?(Hash))? args.first : {}
       end
 
       def matches?(actual)
         @actual = wrap(actual)
-        @actual.has_text?(text)
+        @actual.has_text?(type, content, options)
       end
 
       def does_not_match?(actual)
         @actual = wrap(actual)
-        @actual.has_no_text?(text)
+        @actual.has_no_text?(type, content, options)
       end
 
       def failure_message_for_should
-        "expected there to be text #{format(text)} in #{format(@actual.text)}"
+        message = Capybara::Helpers.failure_message(description, options)
+        message << " in #{format(@actual.text(type))}"
+        message
       end
 
       def failure_message_for_should_not
-        "expected there not to be text #{format(text)} in #{format(@actual.text)}"
+        failure_message_for_should.sub(/(to find)/, 'not \1')
       end
 
       def description
-        "have text #{format(text)}"
+        "text #{format(content)}"
       end
 
-      def wrap(actual)
-        if actual.respond_to?("has_selector?")
-          actual
-        else
-          Capybara.string(actual.to_s)
-        end
+      def format(content)
+        content = Capybara::Helpers.normalize_whitespace(content) unless content.is_a? Regexp
+        content.inspect
+      end
+    end
+
+    class HaveTitle < Matcher
+      attr_reader :title
+
+      def initialize(title)
+        @title = title
       end
 
-      def format(text)
-        text = Capybara::Helpers.normalize_whitespace(text) unless text.is_a? Regexp
-        text.inspect
+      def matches?(actual)
+        @actual = wrap(actual)
+        @actual.has_title?(title)
+      end
+
+      def does_not_match?(actual)
+        @actual = wrap(actual)
+        @actual.has_no_title?(title)
+      end
+
+      def failure_message_for_should
+        "expected there to be title #{title.inspect} in #{@actual.title.inspect}"
+      end
+
+      def failure_message_for_should_not
+        "expected there not to be title #{title.inspect} in #{@actual.title.inspect}"
+      end
+
+      def description
+        "have title #{title.inspect}"
       end
     end
 
@@ -85,12 +113,13 @@ module Capybara
       HaveSelector.new(:css, css, options)
     end
 
-    def have_content(text)
-      HaveText.new(text)
+    def have_text(*args)
+      HaveText.new(*args)
     end
+    alias_method :have_content, :have_text
 
-    def have_text(text)
-      HaveText.new(text)
+    def have_title(title)
+      HaveTitle.new(title)
     end
 
     def have_link(locator, options={})