celerity 0.0.4 → 0.0.6

data/History.txt

@@ -1,3 +1,36 @@
+== 0.0.6 2009-03-19
+* Support for meta, strong, dl, dt, dd, and em HTML elements.
+* Update to HtmlUnit 2.5-SNAPSHOT.
+* New options for Browser#new: :proxy, :charset, :render, :log_level
+* Methods added:
+  - Browser#add_cookie
+  - Browser#asynchronized
+  - Browser#add_listener
+  - Browser#content_type
+  - Browser#cookies
+  - Browser#debug_web_connection
+  - Browser#focused_element
+  - Browser#io
+  - Browser#remove_cookie
+  - Browser#response_headers
+  - Browser#wait
+  - Browser#xml
+  - Browser#{element,elements}_by_xpath
+  - ClickableElement#{double,right}_click
+  - ElementCollection#{first,last}
+* Methods removed:
+  - Browser#show_*
+* Methods renamed:
+  - SelectList#get_all_contents   => SelectList#options
+  - SelectList#get_selected_items => selected_options
+  - SelectList#clear_selection    => SelectList#clear
+* Add support for finding elements by their corresponding <label>.
+* Recognize buttons of type image, reset, submit.
+* Proxy support (see Browser.new)
+* Lots of refactorings, bug fixes and minor enhancements.
+
+Thanks to Hirobumi Hama, Kamal Fariz Mahyuddin and Thomas Marek for contributions in this release.
+
 == 0.0.4 2008-08-18
 * Minor enhancements
   * Update HtmlUnit to 2.2

data/README.txt

@@ -2,14 +2,11 @@
 
 * http://celerity.rubyforge.org/
 
-== TUTORIAL:
-
-* http://celerity.rubyforge.org/wiki/wiki.pl?GettingStarted
-
 == DESCRIPTION:
 
-Celerity is a JRuby library for easy and fast functional test automation for web applications.
-It is a wrapper around the HtmlUnit Java library and is currently aimed at providing the same API and functionality as Watir.
+Celerity is a JRuby wrapper around HtmlUnit – a headless Java browser with 
+JavaScript support. It provides a simple API for programmatic navigation through
+web applications. Celerity aims at being API compatible with Watir.
 
 == FEATURES:
 
@@ -21,13 +18,18 @@ It is a wrapper around the HtmlUnit Java library and is currently aimed at provi
 	
 == REQUIREMENTS:
 
-* JRuby 1.1 or higher
+* JRuby 1.2.0 or higher
 * Java 6
 
 == INSTALL:
 
-  jruby -S gem install celerity
-
+  `jruby -S gem install celerity`
+  
+  or from GitHub
+  
+  `jruby -S gem install jarib-celerity`
+  
+  
 == EXAMPLE:
 
   require "rubygems"
@@ -39,6 +41,14 @@ It is a wrapper around the HtmlUnit Java library and is currently aimed at provi
   browser.button(:name, 'btnG').click
 
   puts "yay" if browser.text.include? 'celerity.rubyforge.org'
+  
+== SOURCE
+
+The source code is available at http://github.com/jarib/celerity/tree/master 
+
+== WIKI:
+
+* http://github.com/jarib/celerity/wikis
 
 == LICENSE:
 

data/Rakefile

@@ -1,6 +1,12 @@
-begin
+$:.unshift("#{File.dirname(__FILE__)}/lib")
+
+if File.exist?('config') # are we in a git clone
   require 'config/requirements'
   require 'config/hoe' # setup Hoe + all gem configuration
-rescue LoadError
+  Dir['tasks/**/*.rake'].each { |rake| load rake }
+else # in gem dir
+  load 'tasks/jar.rake'
+  load 'tasks/rdoc.rake'
 end
-Dir['tasks/**/*.rake'].each { |rake| load rake }
+
+

data/lib/celerity.rb

@@ -1,60 +1,60 @@
 $:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
-module Celerity
-  Jars = Dir[File.dirname(__FILE__) + '/celerity/htmlunit/*.jar']
-end
+raise "Celerity only works on JRuby at the moment." unless RUBY_PLATFORM =~ /java/
 
-if RUBY_PLATFORM =~ /java/
-  require 'java'
-  JavaString = java.lang.String
-  
-  Celerity::Jars.each { |jar| require(jar) }
+require 'java'
+require "logger"
+require "uri"
+require "pp"
+require "timeout"
+require "time"
+require 'drb'
+require "fileutils"
+require "thread"
 
-  module HtmlUnit
-    include_package 'com.gargoylesoftware.htmlunit'
+module Celerity
+  Log = Logger.new($DEBUG ? $stderr : nil)
+  Log.level = Logger::DEBUG
 
-    module Html
-      include_package 'com.gargoylesoftware.htmlunit.html'
-    end
-  end
-  
-else
-  raise "Celerity only works on JRuby at the moment."
+  INDEX_OFFSET = 1
+  DIR = File.expand_path(File.dirname(__FILE__) + "/celerity")
 end
-  # require "rjb"
-  # Rjb::load(Celerity::Jars.join(";"))
-  # module HtmlUnit
-  #   WebClient      = Rjb::import('com.gargoylesoftware.htmlunit.WebClient')
-  #   BrowserVersion = Rjb::import('com.gargoylesoftware.htmlunit.BrowserVersion')
-  # end
 
+require "celerity/htmlunit"
 require "celerity/version"
 require "celerity/exception"
 require "celerity/clickable_element"
 require "celerity/disabled_element"
-require "celerity/element_collections"
+require "celerity/element_collection"
 require "celerity/collections"
 require "celerity/element_locator"
 require "celerity/identifier"
 require "celerity/container"
 require "celerity/element"
 require "celerity/input_element"
-require "celerity/non_control_elements"
-Dir[File.dirname(__FILE__) + "/celerity/elements/*.rb"].each { |f| require(f) }
-require "celerity/element_map"
+require "celerity/elements/non_control_elements"
+require "celerity/elements/button.rb"
+require "celerity/elements/file_field.rb"
+require "celerity/elements/form.rb"
+require "celerity/elements/frame.rb"
+require "celerity/elements/image.rb"
+require "celerity/elements/label.rb"
+require "celerity/elements/link.rb"
+require "celerity/elements/meta.rb"
+require "celerity/elements/option.rb"
+require "celerity/elements/radio_check.rb"
+require "celerity/elements/select_list.rb"
+require "celerity/elements/table.rb"
+require "celerity/elements/table_elements.rb"
+require "celerity/elements/table_cell.rb"
+require "celerity/elements/table_row.rb"
+require "celerity/elements/text_field.rb"
+require "celerity/util"
+require "celerity/default_viewer"
+require "celerity/listener"
 require "celerity/browser"
-
 require "celerity/watir_compatibility"
 
-require "logger"
-require "uri"
-require "pp"
-require "time"
-
-Log = Logger.new($DEBUG ? $stderr : nil)
-Log.level = Logger::DEBUG
 # undefine deprecated methods to use them for Element attributes
-if ["id", "type"].any? { |meth| Object.instance_methods.include?(meth) }
-  Object.send :undef_method, :id
-  Object.send :undef_method, :type
-end
+Object.send :undef_method, :id   if Object.method_defined? "id"
+Object.send :undef_method, :type if Object.method_defined? "type"

data/lib/celerity/browser.rb

@@ -1,155 +1,492 @@
 module Celerity
   class Browser
     include Container
-    attr_accessor :page, :object
+
+    attr_accessor :page, :object, :charset
     attr_reader :webclient, :viewer
-    
-    # Initialize a browser and goto the given URL
-    # @param uri The URL to go to.
-    # @return Instance of Celerity::Browser.
+
+    #
+    # Initialize a browser and go to the given URL
+    # 
+    # @param [String] uri The URL to go to.
+    # @return [Celerity::Browser] instance.
+    # 
+
     def self.start(uri)
       browser = new
       browser.goto(uri)
       browser
     end
-    
+
+    #
+    # Not implemented. Use ClickableElement#click_and_attach instead.
+    #
+
     def self.attach(*args)
-      raise NotImplementedError, "no popup handling yet"
+      raise NotImplementedError, "use ClickableElement#click_and_attach instead"
     end
-    
+
+    def inspect
+      vars = (instance_variables - %w[@webclient @browser @object])
+      vars = vars.map { |var| "#{var}=#{instance_variable_get(var).inspect}" }.join(" ")
+      '#<%s:0x%s %s>' % [self.class.name, self.hash.to_s(16), vars]
+    end
+
+    #
     # Creates a browser object.
     #
-    # @param [Hash[Symbol, Object]] Options for initial configuration of the browser.
-    # 
-    # @option :browser[:firefox, :internet_explorer] Set the BrowserVersion used by HtmlUnit.
-    #        Defaults to Internet Explorer.
-    # @option :css[true, false, nil] Enable CSS. 
-    #        Disabled by default.
-    # @option :secure_ssl[true, false, nil] Disable secure SSL. 
-    #        Enabled by default.
-    # @option :resynchronize[true, false, nil] Use HtmlUnit::NicelyResynchronizingAjaxController to resynchronize Ajax calls.
-    # @option :javascript_exceptions[true, false, nil] Throw exceptions on script errors. 
-    #        Disabled by default.
-    # @option :status_code_exceptions[true, false, nil]Throw exceptions on failing status codes (404 etc.).
-    #        Disabled by default.
+    # @see Celerity::Container for an introduction to the main API.
+    #
+    # @option opts :log_level [Symbol] (:warning) @see log_level=
+    # @option opts :browser [:firefox, :internet_explorer] (:internet_explorer) Set the BrowserVersion used by HtmlUnit. Defaults to Internet Explorer.
+    # @option opts :css [Boolean] (false) Enable CSS.  Disabled by default.
+    # @option opts :secure_ssl [Boolean] (true)  Disable secure SSL. Enabled by default.
+    # @option opts :resynchronize [Boolean] (false) Use HtmlUnit::NicelyResynchronizingAjaxController to resynchronize Ajax calls.
+    # @option opts :javascript_exceptions [Boolean] (false) Raise exceptions on script errors. Disabled by default.
+    # @option opts :status_code_exceptions [Boolean] (false) Raise exceptions on failing status codes (404 etc.). Disabled by default.
+    # @option opts :render [:html, :xml] (:html) What DOM representation to send to connected viewers.
+    # @option opts :charset [String] ("UTF-8") Specify the charset that webclient will use by default.
+    # @option opts :proxy [String] (nil) Proxy server to use, in address:port format.
     #
     # @return [Celerity::Browser]     An instance of the browser.
+    #
     # @api public
+    #
+
     def initialize(opts = {})
-      raise TypeError, "bad argument: #{opts.inspect}" unless opts.is_a? Hash
-      
-      @opts            = opts
+      unless opts.is_a?(Hash)
+        raise TypeError, "wrong argument type #{opts.class}, expected Hash"
+      end
+
+      unless (render_types = [:html, :xml, nil]).include?(opts[:render])
+        raise ArgumentError, "expected one of #{render_types.inspect} for key :render"
+      end
+
+      @render_type   = opts.delete(:render)    || :html
+      @charset       = opts.delete(:charset)   || "UTF-8"
+      self.log_level = opts.delete(:log_level) || :warning
+
       @last_url, @page = nil
-      @page_container  = self
       @error_checkers  = []
-      
-      self.log_level = :warning
-
-      browser = @opts[:browser] == :firefox ? 
-          ::HtmlUnit::BrowserVersion::FIREFOX_2 : ::HtmlUnit::BrowserVersion::INTERNET_EXPLORER_7_0
-          
-      @webclient = ::HtmlUnit::WebClient.new(browser)
+      @browser         = self # for Container#browser
 
-      configure_webclient
-      find_viewer 
+      setup_webclient(opts)
+      
+      raise ArgumentError, "unknown option #{opts.inspect}" unless opts.empty?
+      find_viewer
     end
-        
+
+    #
     # Goto the given URL
     #
-    # @param [String] the url
-    # @return [String] the url
+    # @param [String] uri The url.
+    # @return [String] The url.
+    #
+
     def goto(uri)
       uri = "http://#{uri}" unless uri =~ %r{://}
-      self.page = @webclient.getPage(uri)
-      uri
+
+      request = HtmlUnit::WebRequestSettings.new(::Java::JavaNet::URL.new(uri))
+      request.setCharset(@charset)
+
+      self.page = @webclient.getPage(request)
+
+      url()
     end
-    
-    # Unsets the current page (mostly for Watir compatibility)
+
+    #
+    # Set the credentials used for basic HTTP authentication. (Celerity only)
+    #
+    # Example:
+    #   browser.credentials = "username:password"
+    #
+    # @param [String] A string with username / password, separated by a colon
+    #
+
+    def credentials=(string)
+      user, pass = string.split(":")
+      dcp = HtmlUnit::DefaultCredentialsProvider.new
+      dcp.addCredentials(user, pass)
+      @webclient.setCredentialsProvider(dcp)
+    end
+
+    #
+    # Unsets the current page / closes all windows
+    #
+
     def close
       @page = nil
+      @webclient.closeAllWindows
     end
 
+    #
     # @return [String] the URL of the current page
+    # 
+
     def url
       assert_exists
-      @page.getWebResponse.getUrl.toString
+      @page.getWebResponse.getRequestUrl.toString
     end
-    
+
+    #
     # @return [String] the title of the current page
+    #
+
     def title
       @page ? @page.getTitleText : ''
     end
 
+    #
     # @return [String] the HTML content of the current page
+    #
+    
     def html
       @page ? @page.getWebResponse.getContentAsString : ''
     end
+    
+    #
+    # @return [String] the XML representation of the DOM
+    #
+    
+    def xml
+      return '' unless @page
+      return @page.asXml if @page.respond_to?(:asXml)
+      return text # fallback to text (for exampel for "plain/text" pages)
+    end
 
+    #
     # @return [String] a text representation of the current page
+    #
+    
     def text
       return '' unless @page
 
       if @page.respond_to?("getContent")
-        @page.getContent  
+        string = @page.getContent.strip
       else
-        # # this has minimal whitespace
-        @page.documentElement.asText
-        
-        # if @opts[:browser] == :firefox
-        #   # # this is what firewatir does - only works with HtmlUnit::BrowserVersion::FIREFOX_2
-        #   res = execute_script("document.body.textContent").getJavaScriptResult 
-        # else
-        #   # this only works with HtmlUnit::BrowserVersion::INTERNET_EXPLORER_*, and isn't identical to Watir's ole_object.innerText
-        #   res = execute_script("document.body.innerText").getJavaScriptResult 
-        # end
+        string = @page.documentElement.asText.strip
       end
+
+      # Celerity::Util.normalize_text(string)
+      string
+    end
+
+    #
+    # @return [Hash] response headers as a hash
+    #
+
+    def response_headers
+      return {} unless @page
+      
+      Hash[*@page.getWebResponse.getResponseHeaders.map { |obj| [obj.name, obj.value] }.flatten]
+    end
+
+    #
+    # @return [String] content-type as in 'text/html'
+    #
+
+    def content_type
+      return '' unless @page
+      
+      @page.getWebResponse.getContentType
     end
 
+    #
+    # @return [IO, nil] page contents as an IO, returns nil if no page is loaded.
+    # 
+    
+    def io
+      return nil unless @page
+      
+      @page.getWebResponse.getContentAsStream.to_io
+    end
+
+    #
     # Check if the current page contains the given text.
     #
     # @param  [String, Regexp] expected_text The text to look for.
-    # @return [Numeric, nil]  The index of the matched text, or nil if it doesn't match.
+    # @return [Numeric, nil]  The index of the matched text, or nil if it isn't found.
+    # @raise  [TypeError]
+    # 
+
     def contains_text(expected_text)
       return nil unless exist?
-      case expected_text
-      when Regexp
-        text() =~ expected_text
-      when String
-        text().index(expected_text)
-      else
-        raise ArgumentError, "Argument must be String or Regexp, but was #{expected_text.inspect}:#{expected_text.class}"
-      end
+      super
+    end
+
+    #
+    # Get the first element found matching the given XPath.
+    #
+    # @param [String] xpath
+    # @return [Celerity::Element] An element subclass (or Element if none is found)
+    #
+    
+    def element_by_xpath(xpath)
+      assert_exists
+      obj = @page.getFirstByXPath(xpath)
+      element_from_dom_node(obj)
+    end
+
+    #
+    # Get all the elements matching the given XPath.
+    #
+    # @param [String] xpath
+    # @return [Array<Celerity::Element>] array of elements
+    #
+    
+    def elements_by_xpath(xpath)
+      assert_exists
+      objects = @page.getByXPath(xpath)
+      # should use an ElementCollection here?
+      objects.map { |o| element_from_dom_node(o) }.compact
     end
 
-    # @return [HtmlUnit::HtmlHtml] the underlying HtmlUnit object.
+    #
+    # @return [HtmlUnit::HtmlHtml] the underlying HtmlUnit document.
+    # 
+    
     def document
       @object
     end
-    
+
+    #
     # Goto the last url - HtmlUnit doesn't have a 'back' functionality, so we only have 1 history item :)
     # @return [String, nil] The url of the resulting page, or nil if none was stored.
+    # 
+
     def back
-      # TODO: this is naive, need capability from HtmlUnit  
+      # TODO: this is naive, need capability from HtmlUnit
       goto(@last_url) if @last_url
     end
-    
+
+    #
+    # Wait for javascript jobs to finish
+    # 
+
+    def wait
+      assert_exists
+      @page.getEnclosingWindow.getJobManager.waitForAllJobsToFinish(10000)
+    end
+
+    #
     # Refresh the current page
+    # 
+
     def refresh
       assert_exists
       self.page = @page.refresh
     end
 
-    # Execute the given JavaScript on the current page
-    # @return [HtmlUnit::ScriptResult]
+    #
+    # Clears all cookies. (Celerity only)
+    # 
+
+    def clear_cookies
+      @webclient.getCookieManager.clearCookies
+    end
+
+    #
+    # Get the cookies for this session. (Celerity only)
+    # 
+    # @return [Hash<domain, Hash<name, value>>] 
+    #
+
+    def cookies
+      result = Hash.new { |hash, key| hash[key] = {} }
+      
+      cookies = @webclient.getCookieManager.getCookies
+      cookies.each do |cookie|
+        result[cookie.getDomain][cookie.getName] = cookie.getValue
+      end
+      
+      result
+    end
+    
+    #
+    # Add a cookie with the given parameters (Celerity only)
+    # 
+    # @param [String] domain
+    # @param [String] name
+    # @param [String] value
+    #
+    # @option opts :path    [String]  ("/") A path 
+    # @option opts :max_age [Fixnum]  (??) A max age
+    # @option opts :secure  [Boolean] (false) 
+    #
+    
+    def add_cookie(domain, name, value, opts = {})
+      path    = opts.delete(:path) || "/"
+      max_age = opts.delete(:max_age) || (Time.now + 60*60*24) # not sure if this is correct
+      secure  = opts.delete(:secure) || false
+
+      raise "unknown option: #{opts.inspect}" unless opts.empty?
+
+      cookie = Cookie.new(domain, name, value, path, max_age, secure)
+      @webclient.getCookieManager.addCookie(cookie)
+    end
+    
+    #
+    # Remove the cookie with the given domain and name (Celerity only)
+    #
+    # @param [String] domain
+    # @param [String] name
+    #
+    
+    def remove_cookie(domain, name)
+      cm = @webclient.getCookieManager
+      cookie = cm.getCookies.find { |c| c.getDomain == domain && c.getName == name }
+      
+      if cookie.nil?
+        raise "no cookie with domain #{domain.inspect} and name #{name.inspect}"
+      end
+      
+      cm.removeCookie(cookie)
+    end
+
+    #
+    # Execute the given JavaScript on the current page.
+    # @return [Object] The resulting Object
+    #
+
     def execute_script(source)
       assert_exists
-      @page.executeJavaScript(source.to_s)
+      @page.executeJavaScript(source.to_s).getJavaScriptResult
     end
 
-    # Add a 'checker' proc that will be run on every page load
+    # experimental - should be removed?
+    def send_keys(keys)
+      keys = keys.gsub(/\s*/, '').scan(/((?:\{[A-Z]+?\})|.)/u).flatten
+      keys.each do |key|
+        element = @page.getFocusedElement
+        case key
+        when "{TAB}"
+          @page.tabToNextElement
+        when /\w/
+          element.type(key)
+        else
+          raise NotImplementedError
+        end
+      end
+    end
+
+    #
+    # Wait until the given block evaluates to true (Celerity only)
+    #
+    # @param [Fixnum] timeout Number of seconds to wait before timing out (default: 30).
+    # @yieldparam [Celerity::Browser] browser The browser instance.
+    # @see Celerity::Browser#resynchronized
+    #
+    
+    def wait_until(timeout = 30, &block)
+      Timeout.timeout(timeout) do
+        until yield(self)
+          refresh_page_from_window
+          sleep 0.1
+        end
+      end
+    end
+
+    #
+    # Wait while the given block evaluates to true (Celerity only)
+    #
+    # @param [Fixnum] timeout Number of seconds to wait before timing out (default: 30).
+    # @yieldparam [Celerity::Browser] browser The browser instance.
+    # @see Celerity::Browser#resynchronized
+    # 
+
+    def wait_while(timeout = 30, &block)
+      Timeout.timeout(timeout) do
+        while yield(self)
+          refresh_page_from_window
+          sleep 0.1
+        end
+      end
+    end
+
+    #
+    # Allows you to temporarily switch to HtmlUnit's NicelyResynchronizingAjaxController to resynchronize ajax calls.
+    #
+    #   @browser.resynchronized do |b|
+    #     b.link(:id, 'trigger_ajax_call').click
+    #   end
+    #
+    # @yieldparam [Celerity::Browser] browser The current browser object.
+    # @see Celerity::Browser#new for how to configure the browser to always use this.
+    #
+
+    def resynchronized(&block)
+      old_controller = @webclient.ajaxController
+      @webclient.setAjaxController(::HtmlUnit::NicelyResynchronizingAjaxController.new)
+      yield self
+      @webclient.setAjaxController(old_controller)
+    end
+    
+    #
+    # Allows you to temporarliy switch to HtmlUnit's default AjaxController, so ajax calls are performed asynchronously.
+    # This is useful if you have created the Browser with :resynchronize => true, but want to switch it off temporarily.
+    # 
+    # @yieldparam [Celerity::Browser] browser The current browser object.
+    # @see Celerity::Browser#new
+    #
+    
+    def asynchronized(&block)
+      old_controller = @webclient.ajaxController
+      @webclient.setAjaxController(::HtmlUnit::AjaxController.new)
+      yield self
+      @webclient.setAjaxController(old_controller)
+    end
+
+    #
+    # Start or stop HtmlUnit's DebuggingWebConnection. (Celerity only)
+    # The output will go to /tmp/«name»
+    #
+    # @param [Boolean] bool start or stop
+    # @param [String]  name required if bool is true
+    # 
+
+    def debug_web_connection(bool, name = nil)
+      if bool
+        raise "no name given" unless name
+        @old_webconnection = @webclient.getWebConnection
+        dwc = HtmlUnit::Util::DebuggingWebConnection.new(@old_webconnection, name)
+        @webclient.setWebConnection(dwc)
+        $stderr.puts "debug-webconnection on"
+      else
+        @webclient.setWebConnection(@old_webconnection) if @old_webconnection
+        $stderr.puts "debug-webconnection off"
+      end
+    end
+
+    #
+    # Add a listener block for one of the available types. (Celerity only)
+    # Types map to HtmlUnit interfaces like this:
+    #
+    #   :status           => StatusHandler
+    #   :alert            => AlertHandler  ( window.alert() )
+    #   :web_window_event => WebWindowListener
+    #   :html_parser      => HTMLParserListener
+    #   :incorrectness    => IncorrectnessListener
+    #   :confirm          => ConfirmHandler ( window.confirm() )
+    #   :prompt           => PromptHandler ( window.prompt() )
+    #
+    #
+    # @param [Symbol] type One of the above symbols.
+    # @param [Proc] block A block to be executed for events of this type.
     # 
-    # @param [Proc] checker the proc to be run (can also be given as a block)
+
+    def add_listener(type, &block)
+      @listener ||= Celerity::Listener.new(@webclient)
+      @listener.add_listener(type, &block)
+    end
+    
+    #
+    # Add a 'checker' proc that will be run on every page load
+    #
+    # @param [Proc] checker The proc to be run (can also be given as a block)
+    # @yieldparam [Celerity::Browser] browser The current browser object.
     # @raise [ArgumentError] if no Proc or block was given.
+    # 
+
     def add_checker(checker = nil, &block)
       if block_given?
         @error_checkers << block
@@ -159,138 +496,186 @@ module Celerity
         raise ArgumentError, "argument must be a Proc or block"
       end
     end
-    
+
+    #
     # Remove the given checker from the list of checkers
-    # @param [Proc] the Proc to disable
+    # @param [Proc] checker The Proc to disable.
+    # 
+
     def disable_checker(checker)
       @error_checkers.delete(checker)
     end
 
+    #
+    # :finest, :finer, :fine, :config, :info, :warning, :severe, or :off, :all
+    # 
+    # @return [Symbol] the current log level
+    # 
+
+    def log_level
+      java.util.logging.Logger.getLogger('com.gargoylesoftware.htmlunit').level.to_s.downcase.to_sym
+    end
+
+    #
     # Set Java log level (default is :warning)
     #
     # @param [Symbol] level :finest, :finer, :fine, :config, :info, :warning, :severe, or :off, :all
+    # 
+
     def log_level=(level)
       java.util.logging.Logger.getLogger('com.gargoylesoftware.htmlunit').level = java.util.logging.Level.const_get(level.to_s.upcase)
     end
-    
-    # @return [Symbol] the current log level
-    def log_level
-      java.util.logging.Logger.getLogger('com.gargoylesoftware.htmlunit').level.to_s.downcase.to_sym
-    end
 
-    # Checks if we have a page currently loaded. 
+    #
+    # Checks if we have a page currently loaded.
     # @return [true, false]
+    #
+
     def exist?
       !!@page
     end
     alias_method :exists?, :exist?
 
-    # Allows you to temporarily switch to HtmlUnit's NicelyResynchronizingAjaxController to resynchronize ajax calls.
     #
-    # Example:
-    #   @browser.resynchroniced do |b|
-    #     b.link(:id, 'load_fancy_ajax_stuff').click
-    #   end
+    # Sets the current page object for the browser
     #
-    # @param [block] &block the block to execute synchronized.
-    def resynchronized(&block)
-      old_controller = @webclient.ajaxController
-      @webclient.setAjaxController(::HtmlUnit::NicelyResynchronizingAjaxController.new)
-      yield self
-      @webclient.setAjaxController(old_controller)
+    # @param [HtmlUnit::HtmlPage] value The page to set.
+    # @api private
+    #
+
+    def page=(value)
+      @last_url = url() if exist?
+      @page = value
+
+      if @page.respond_to?("getDocumentElement")
+        @object = @page.getDocumentElement
+      elsif @page.is_a? HtmlUnit::UnexpectedPage
+        raise UnexpectedPageException, @page.getWebResponse.getContentType
+      end
+
+      render unless @viewer == DefaultViewer
+      run_error_checks
+
+      value
     end
 
-    #--
-    # TODO: could be private?
-    #++
     #
     # Check that we have a @page object.
+    #
+    # @raise [Celerity::Exception::UnknownObjectException] if no page is loaded.
+    # @api private
     # 
-    # @raise UnknownObjectException
-    # @api internal
+    
     def assert_exists
       raise UnknownObjectException, "no page loaded" unless exist?
     end
     
-    #--
-    # TODO: could be private?
-    #++
+    #
+    # Returns the element that currently has the focus (Celerity only)
+    #
+
+    def focused_element
+      element_from_dom_node(page.getFocusedElement())
+    end    
+
+    private
+
+    #
     # Runs the all the checker procs added by +add_checker+
     #
     # @see add_checker
-    # @api internal
+    # @api private
+    # 
+    
     def run_error_checks
-      @error_checkers.each { |e| e.call(self) }
+      @error_checkers.each { |e| e[self] }
     end
     
-    # Set the current page object for the browser
     #
-    # @param [HtmlUnit::HtmlPage] value The page to set.
-    # @api internal
-    def page=(value)
-      @last_url = url() if exist?
-      @page = value
-      
-      if @page.respond_to?("getDocumentElement")
-        @object = @page.getDocumentElement
+    # Configure the webclient according to the options given to #new.
+    # @see initialize
+    #
+
+    def setup_webclient(opts)
+      browser = (opts.delete(:browser) || :internet_explorer).to_sym
+
+      case browser
+      when :firefox
+        browser_version = ::HtmlUnit::BrowserVersion::FIREFOX_2
+      when :internet_explorer, :ie
+        browser_version = ::HtmlUnit::BrowserVersion::INTERNET_EXPLORER_7_0
+      else
+        raise ArgumentError, "unknown browser: #{browser.inspect}"
       end
-      
-      render if @viewer
-      run_error_checks
-      
-      value
-    end
 
-    # Used for #show_links(), #show_divs() etc. (for watir compatibility)
-    def method_missing(meth, *args)
-      return super unless type = meth.to_s[/^show_(.*)$/, 1]
-      puts collection_string(type) rescue super
+      if proxy = opts.delete(:proxy)
+        phost, pport = proxy.split(":")
+        @webclient = ::HtmlUnit::WebClient.new(browser_version, phost, pport.to_i)
+      else
+        @webclient = ::HtmlUnit::WebClient.new(browser_version)  
+      end
+      
+      @webclient.throwExceptionOnScriptError = false unless opts.delete(:javascript_exceptions)
+      @webclient.throwExceptionOnFailingStatusCode = false unless opts.delete(:status_code_exceptions)
+      @webclient.cssEnabled = false unless opts.delete(:css)
+      @webclient.useInsecureSSL = opts.delete(:secure_ssl) == false
+      @webclient.setAjaxController(::HtmlUnit::NicelyResynchronizingAjaxController.new) if opts.delete(:resynchronize)
     end
 
-    private
+    #
+    # This *should* be unneccessary, but sometimes the page we get from the
+    # window is different (ie. a different object) from our current @page
+    # (Used by #wait_while and #wait_until)
+    # 
     
-    # Configure the webclient according to the options given to #new.
-    # @see initialize
-    def configure_webclient
-      @webclient.throwExceptionOnScriptError = false unless @opts[:javascript_exceptions]
-      @webclient.throwExceptionOnFailingStatusCode = false unless @opts[:status_code_exceptions]
-      @webclient.cssEnabled = false unless @opts[:css]
-      @webclient.useInsecureSSL = true if @opts[:secure_ssl] 
-      @webclient.setAjaxController(::HtmlUnit::NicelyResynchronizingAjaxController.new) if @opts[:resynchronize]
-    end
-
-    # Create a string representation of all the elements returned by collection_method
-    # @param [Symbol] collection_method
-    # @return [String] 
-    def collection_string(collection_method)
-      collection = self.send collection_method
-      result = "Found #{collection.size} #{collection_method.downcase}\n"
-      
-      collection.each_with_index do |element, index|
-        result << "#{index+1}: #{element.attribute_string}\n"
+    def refresh_page_from_window
+      new_page = @page.getEnclosingWindow.getEnclosedPage
+
+      if new_page && (new_page != @page)
+        self.page = new_page
+      else
+        Log.debug "unneccessary refresh"
       end
-      
-      result
     end
     
+    #
     # Render the current page on the viewer.
-    # @api internal
+    # @api private
+    # 
+
     def render
-      @viewer.render_html(html, url) 
+      @viewer.render_html(self.send(@render_type), url)
     rescue DRb::DRbConnError, Errno::ECONNREFUSED => e
-      @viewer = nil
-    end    
-    
+      @viewer = DefaultViewer
+    end
+
+    #
     # Check if we have a viewer available on druby://127.0.0.1:6429
-    # @api internal
+    # @api private
+    # 
+
     def find_viewer
-      # FIXME: not ideal
-      require 'drb'
       viewer = DRbObject.new_with_uri("druby://127.0.0.1:6429")
-      @viewer = viewer if viewer.respond_to?(:render_html)
+      if viewer.respond_to?(:render_html)
+        @viewer = viewer
+      else
+        @viewer = DefaultViewer
+      end
     rescue DRb::DRbConnError, Errno::ECONNREFUSED
-      @viewer = nil
+      @viewer = DefaultViewer
     end
+
+    # 
+    # Convert the given HtmlUnit object to a Celerity object
+    # 
     
+    def element_from_dom_node(obj)
+      if element_class = Celerity::Util.htmlunit2celerity(obj.class)
+        element_class.new(self, :object, obj)
+      else
+        Element.new(self, :object, nil)
+      end
+    end
+
   end # Browser
-end # Celerity
+end # Celerity