capybara 0.2.0 → 0.3.0

data/lib/capybara/dsl.rb

@@ -47,10 +47,13 @@ module Capybara
   end
 
   SESSION_METHODS = [
-    :visit, :body, :click_link, :click_button, :drag, :fill_in, :choose, :has_xpath?, :has_css?,
-    :check, :uncheck, :attach_file, :select, :has_content?, :within, :within_fieldset,
-    :within_table, :save_and_open_page, :find, :find_field, :find_link, :find_button,
-    :field_labeled, :all, :wait_for, :evaluate_script, :click
+    :visit, :current_url, :body, :click_link, :click_button, :drag, :fill_in,
+    :choose, :has_xpath?, :has_no_xpath?, :has_css?, :has_no_css?,
+    :check, :uncheck, :attach_file, :select, :source,
+    :has_content?, :has_no_content?, :within, :within_fieldset, :within_table,
+    :save_and_open_page, :find, :find_field, :find_link, :find_button,
+    :field_labeled, :all, :locate, :evaluate_script,
+    :click, :wait_until
   ]
   SESSION_METHODS.each do |method|
     class_eval <<-RUBY, __FILE__, __LINE__+1

data/lib/capybara/node.rb

@@ -1,40 +1,61 @@
-class Capybara::Node
-  attr_reader :driver, :node
+module Capybara
+  class Node
+    include Searchable
 
-  def initialize(driver, node)
-    @driver = driver
-    @node = node
-  end
+    attr_reader :driver, :node
 
-  def text
-    raise "Not implemented"
-  end
+    def initialize(driver, node)
+      @driver = driver
+      @node = node
+    end
 
-  def [](name)
-    raise "Not implemented"
-  end
+    def text
+      raise NotImplementedError
+    end
 
-  def value
-    self[:value]
-  end
+    def [](name)
+      raise NotImplementedError
+    end
 
-  def set(value)
-    raise "Not implemented"
-  end
+    def value
+      self[:value]
+    end
 
-  def select(option)
-    raise "Not implemented"
-  end
+    def set(value)
+      raise NotImplementedError
+    end
 
-  def click
-    raise "Not implemented"
-  end
+    def select(option)
+      raise NotImplementedError
+    end
 
-  def drag_to(element)
-    raise "Not implemented"
-  end
+    def click
+      raise NotImplementedError
+    end
+
+    def drag_to(element)
+      raise NotImplementedError
+    end
+
+    def tag_name
+      raise NotImplementedError
+    end
+
+    def visible?
+      raise NotImplementedError
+    end
+
+    def path
+      raise NotSupportedByDriverError
+    end
+
+    private
+
+    def all_unfiltered(locator)
+      nodes = XPath.wrap(locator).scope(path).paths.map do |path|
+        driver.find(path)
+      end.flatten
+    end
 
-  def tag_name
-    raise "Not implemented"
   end
 end

data/lib/capybara/rails.rb

@@ -6,6 +6,6 @@ Capybara.app = Rack::Builder.new do
     use Rails::Rack::Static
     run ActionController::Dispatcher.new
   end
-end.to_app 
+end.to_app
 
 Capybara.asset_root = Rails.root.join('public')

data/lib/capybara/save_and_open_page.rb

@@ -23,7 +23,7 @@ module Capybara
 
     def rewrite_css_and_image_references(response_html) # :nodoc:
       return response_html unless Capybara.asset_root
-      response_html.gsub(/("|')\/(stylesheets|images)/, '\1' + Capybara.asset_root + '/\2')
+      response_html.gsub(/("|')\/(stylesheets|images|javascripts)/, '\1' + Capybara.asset_root + '/\2')
     end
   end
 end

data/lib/capybara/searchable.rb

@@ -0,0 +1,45 @@
+module Capybara
+  module Searchable
+    def find(locator, options = {})
+      all(locator, options).first
+    end
+
+    def find_field(locator)
+      find(XPath.field(locator))
+    end
+    alias_method :field_labeled, :find_field
+
+    def find_link(locator)
+      find(XPath.link(locator))
+    end
+
+    def find_button(locator)
+      find(XPath.button(locator))
+    end
+
+    def find_by_id(id)
+      find(Xpath.for_css("##{id}"))
+    end
+
+    def all(locator, options = {})
+      results = all_unfiltered(locator)
+
+      if options[:text]
+        results = results.select { |n| n.text.match(options[:text]) }
+      end
+
+      if options[:visible] == true
+        results.reject! { |n| !n.visible? }
+      end
+
+      results
+    end
+
+    private
+
+    def all_unfiltered(locator)
+      raise "Must be overridden"
+    end
+
+  end
+end

data/lib/capybara/server.rb

@@ -1,7 +1,11 @@
 require 'uri'
 require 'net/http'
 require 'rack'
-require 'rack/handler/mongrel'
+begin
+  require 'rack/handler/mongrel'
+rescue LoadError
+  require 'rack/handler/webrick'
+end
 
 class Capybara::Server
   class Identify
@@ -10,7 +14,7 @@ class Capybara::Server
     end
 
     def call(env)
-      if env["REQUEST_PATH"] == "/__identify__"
+      if env["PATH_INFO"] == "/__identify__"
         [200, {}, @app.object_id.to_s]
       else
         @app.call(env)
@@ -18,7 +22,6 @@ class Capybara::Server
     end
   end
 
-
   attr_reader :app, :port
 
   def initialize(app)
@@ -48,7 +51,11 @@ private
 
     Timeout.timeout(10) do
       Thread.new do
-        Rack::Handler::Mongrel.run Identify.new(@app), :Port => port
+        if defined?(Rack::Handler::Mongrel)
+          Rack::Handler::Mongrel.run(Identify.new(@app), :Port => port)
+        else
+          Rack::Handler::WEBrick.run(Identify.new(@app), :Port => port, :AccessLog => [])
+        end
       end
       Capybara.log "checking if application has booted"
 

data/lib/capybara/session.rb

@@ -1,5 +1,8 @@
+require 'capybara/wait_until'
+
 module Capybara
   class Session
+    include Searchable
 
     attr_reader :mode, :app
 
@@ -12,109 +15,92 @@ module Capybara
       @driver ||= case mode
       when :rack_test
         Capybara::Driver::RackTest.new(app)
-      when :culerity
-        Capybara::Driver::Culerity.new(app)
       when :selenium
         Capybara::Driver::Selenium.new(app)
+      when :celerity
+        Capybara::Driver::Celerity.new(app)
+      when :culerity
+        Capybara::Driver::Culerity.new(app)
       else
         raise Capybara::DriverNotFoundError, "no driver called #{mode} was found"
       end
     end
 
+    def current_url
+      driver.current_url
+    end
+
+    def response_headers
+      driver.response_headers
+    end
+
     def visit(path)
       driver.visit(path)
     end
 
     def click(locator)
-      link = wait_for(XPath.link(locator).button(locator))
-      raise Capybara::ElementNotFound, "no link or button '#{locator}' found" unless link
-      link.click
+      msg = "no link or button '#{locator}' found"
+      locate(XPath.link(locator).button(locator), msg).click
     end
 
     def click_link(locator)
-      link = wait_for(XPath.link(locator))
-      raise Capybara::ElementNotFound, "no link with title, id or text '#{locator}' found" unless link
-      link.click
+      msg = "no link with title, id or text '#{locator}' found"
+      locate(XPath.link(locator), msg).click
     end
 
     def click_button(locator)
-      button = wait_for(XPath.button(locator))
-      raise Capybara::ElementNotFound, "no button with value or id or text '#{locator}' found" unless button
-      button.click
+      msg = "no button with value or id or text '#{locator}' found"
+      locate(XPath.button(locator)).click
     end
 
     def drag(source_locator, target_locator)
-      source = find(source_locator)
-      raise Capybara::ElementNotFound, "drag source '#{source_locator}' not found on page" unless source
-      target = find(target_locator)
-      raise Capybara::ElementNotFound, "drag target '#{target_locator}' not found on page" unless target
+      source = locate(source_locator, "drag source '#{source_locator}' not found on page")
+      target = locate(target_locator, "drag target '#{target_locator}' not found on page")
       source.drag_to(target)
     end
 
     def fill_in(locator, options={})
-      field = wait_for(XPath.fillable_field(locator))
-      raise Capybara::ElementNotFound, "cannot fill in, no text field, text area or password field with id or label '#{locator}' found" unless field
-      field.set(options[:with])
+      msg = "cannot fill in, no text field, text area or password field with id, name, or label '#{locator}' found"
+      locate(XPath.fillable_field(locator), msg).set(options[:with])
     end
 
     def choose(locator)
-      field = wait_for(XPath.radio_button(locator))
-      raise Capybara::ElementNotFound, "cannot choose field, no radio button with id or label '#{locator}' found" unless field
-      field.set(true)
+      msg = "cannot choose field, no radio button with id, name, or label '#{locator}' found"
+      locate(XPath.radio_button(locator), msg).set(true)
     end
 
     def check(locator)
-      field = wait_for(XPath.checkbox(locator))
-      raise Capybara::ElementNotFound, "cannot check field, no checkbox with id or label '#{locator}' found" unless field
-      field.set(true)
+      msg = "cannot check field, no checkbox with id, name, or label '#{locator}' found"
+      locate(XPath.checkbox(locator), msg).set(true)
     end
 
     def uncheck(locator)
-      field = wait_for(XPath.checkbox(locator))
-      raise Capybara::ElementNotFound, "cannot uncheck field, no checkbox with id or label '#{locator}' found" unless field
-      field.set(false)
+      msg = "cannot uncheck field, no checkbox with id, name, or label '#{locator}' found"
+      locate(XPath.checkbox(locator), msg).set(false)
     end
 
     def select(value, options={})
-      field = wait_for(XPath.select(options[:from]))
-      raise Capybara::ElementNotFound, "cannot select option, no select box with id or label '#{options[:from]}' found" unless field
-      field.select(value)
+      msg = "cannot select option, no select box with id, name, or label '#{options[:from]}' found"
+      locate(XPath.select(options[:from]), msg).select(value)
     end
 
     def attach_file(locator, path)
-      field = wait_for(XPath.file_field(locator))
-      raise Capybara::ElementNotFound, "cannot attach file, no file field with id or label '#{locator}' found" unless field
-      field.set(path)
+      msg = "cannot attach file, no file field with id, name, or label '#{locator}' found"
+      locate(XPath.file_field(locator), msg).set(path)
     end
 
     def body
       driver.body
     end
 
-    def has_content?(content)
-      has_xpath?(XPath.content(content).to_s)
-    end
-
-    def has_xpath?(path, options={})
-      results = all(path)
-      if options[:text]
-        results = filter_by_text(results, options[:text])
-      end
-      if options[:count]
-        results.size == options[:count]
-      else
-        results.size > 0
-      end
-    end
-
-    def has_css?(path, options={})
-      has_xpath?(css_to_xpath(path), options)
+    def source
+      driver.source
     end
 
     def within(kind, scope=nil)
       kind, scope = Capybara.default_selector, kind unless scope
-      scope = css_to_xpath(scope) if kind == :css
-      raise Capybara::ElementNotFound, "scope '#{scope}' not found on page" unless wait_for(scope)
+      scope = XPath.from_css(scope) if kind == :css
+      locate(scope, "scope '#{scope}' not found on page")
       scopes.push(scope)
       yield
       scopes.pop
@@ -132,67 +118,81 @@ module Capybara
       end
     end
 
-    def save_and_open_page
-      require 'capybara/save_and_open_page'
-      Capybara::SaveAndOpenPage.save_and_open_page(body)
+    def has_xpath?(path, options={})
+      wait_conditionally_until do
+        results = all(path, options)
+
+        if options[:count]
+          results.size == options[:count]
+        else
+          results.size > 0
+        end
+      end
+    rescue Capybara::TimeoutError
+      return false
     end
 
-    def all(locator)
-      XPath.wrap(locator).scope(current_scope).paths.map do |path|
-        driver.find(path)
-      end.flatten
+    def has_no_xpath?(path, options={})
+      wait_conditionally_until do
+        results = all(path, options)
+
+        if options[:count]
+          results.size != options[:count]
+        else
+          results.empty?
+        end
+      end
+    rescue Capybara::TimeoutError
+      return false
     end
 
-    def find(locator)
-      all(locator).first
+    def has_css?(path, options={})
+      has_xpath?(XPath.from_css(path), options)
     end
-    
-    def wait_for(locator)
-      return find(locator) unless driver.wait?
-      8.times do
-        result = find(locator)
-        return result if result
-        sleep(0.1)
-      end
-      nil
+
+    def has_no_css?(path, options={})
+      has_no_xpath?(XPath.from_css(path), options)
+    end
+
+    def has_content?(content)
+      has_xpath?(XPath.content(content))
+    end
+
+    def has_no_content?(content)
+      has_no_xpath?(XPath.content(content))
     end
 
-    def find_field(locator)
-      find(XPath.field(locator))
+    def save_and_open_page
+      require 'capybara/save_and_open_page'
+      Capybara::SaveAndOpenPage.save_and_open_page(body)
     end
-    alias_method :field_labeled, :find_field
 
-    def find_link(locator)
-      find(XPath.link(locator))
+    #return node identified by locator or raise ElementNotFound(using desc)
+    def locate(locator, fail_msg = nil)
+      node = wait_conditionally_until { find(locator) }
+    ensure
+      raise Capybara::ElementNotFound, fail_msg || "Unable to locate '#{locator}'" unless node
+      return node
     end
 
-    def find_button(locator)
-      find(XPath.button(locator))
+    def wait_until(timeout = Capybara.default_wait_time)
+      WaitUntil.timeout(timeout) { yield }
     end
 
     def evaluate_script(script)
-      begin
-        driver.evaluate_script(script)
-      rescue NoMethodError
-        raise NotSupportedByDriverError
-      end
+      driver.evaluate_script(script)
     end
 
   private
 
-    def css_to_xpath(css)
-      Nokogiri::CSS.xpath_for(css).first
+    def wait_conditionally_until
+      if driver.wait? then wait_until { yield } else yield end
     end
 
-    def filter_by_text(nodes, text)
-      nodes.select do |node|
-        case text
-        when String
-          node.text.include?(text)
-        when Regexp
-          node.text =~ text
-        end
-      end
+    def all_unfiltered(locator)
+      XPath.wrap(locator).scope(current_scope).paths.map do |path|
+        driver.find(path)
+      end.flatten
     end
 
     def current_scope