drnic-culerity 0.2.1

data/.gitignore

@@ -0,0 +1,4 @@
+coverage
+rdoc
+pkg
+tmp

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Alexander Lang
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.textile

@@ -0,0 +1,101 @@
+h2. Introduction
+
+Culerity integrates Cucumber and Celerity in order to test your application's full stack.
+
+Culerity lets you:
+* run Celerity from within Cucumber which allows you to test the full stack of your Rails (or other web) application from Database to in browser JavaScript
+* run your application in any Ruby (like MRI 1.8.6) while Celerity runs in JRuby so you can still use gems/plugins that would not work with JRuby
+* reuse existing Webrat-Style step definitions
+
+h2. Getting Started
+
+The following guide is written for a Rails application (tested with 2.2.2) but Culerity should work with any other Web Framework that is supported by Cucumber.
+
+First download JRuby and unpack it to some location, for example $HOME/jruby. Make sure that the jruby executable is in your path. You can do this by either setting your PATH accordingly...
+
+<pre><code> export PATH=$HOME/jruby/bin:$PATH</code></pre>
+ 
+... or by creating a symlink from your bin directory:
+
+<pre><code> ln -s $HOME/jruby/bin/jruby /usr/bin/jruby</code></pre>
+
+Next install the celerity gem for JRuby:
+
+<pre><code> jruby -S gem install celerity</code></pre>
+
+Now (assuming you have a Rails application set up already) install Culerity as a Rails Plugin:
+
+<pre><code> cd RAILS_ROOT
+ git clone git://github.com/langalex/culerity.git</code></pre>
+
+or as a gem: (definitely preferred)
+
+<pre><code> gem install langalex-culerity --source http://gems.github.com</code></pre>
+ 
+Run the RSpec, Cucumber and Culerity generators:
+
+<pre><code>
+ cd RAILS_ROOT
+ script/generate rspec
+ script/generate cucumber
+ script/generate culerity
+</code></pre>
+ 
+This creates the features folder and a file common_celerity.rb into your application. This file contains step definitions for basic interactions like clicking links or filling out forms.
+
+After you have written a first feature you can run it just like you would run a standard cucumber feature. The only difference is that you have to start a web server (e.g. mongrel) with the test environment enabled beforehand.
+
+NOTE: The default port for this server is 3001. You can change this in features/step_definitions/common_celerity.rb
+
+ 
+<pre><code> script/server -p 3001 -e test
+ cucumber features/my_feature.feature
+</code></pre>
+
+h2. How does it work
+
+While Celerity is based on Java and requires JRuby to run, with Culerity you can still run your tests in your own Ruby Environment. When you run your features a separate JRuby process for Celerity is spawned and all Celerity Commands are redirected to this other process.
+
+h2. Troubleshooting
+
+I get a broken pipe error:
+* make sure JRuby is installed and in your path: running _jruby -v_ should not produce an error
+
+I get _Connection Refused_ errors
+* make sure you have started a server in the test environment that runs on port 3001
+
+My application can't find the data I create in my steps
+* make sure you have disabled transactional fixtures in your env.rb
+
+My database is not cleared automatically between scenarios
+* Rails can't clean the database because you had to disable transactional fixtures - which only work if your test process is the same as your web server process. Hence you have to clean your database manually. A quick way would be:
+
+<pre><code>Before do
+  [User, .... all your models].each do |model|
+    mode.delete_all
+  end
+end
+</code></pre>
+
+I want to test emails but the ActionMailer::Base.deliveries array is always empty.
+* that's because the :test delivery method stores all emails in memory, but now that your test process is not the same as your rails process you don't have access to that array. install the http://github.com/ngty/action_mailer_cache_delivery plugin to access the emails in your rails process via a temporary file
+
+
+h2. Links to Celerity documentation
+
+* "How to select elements":http://celerity.rubyforge.org/yard/Celerity/Container.html
+* "FAQ":http://wiki.github.com/jarib/celerity/faq
+* "Tutorial":http://wiki.github.com/jarib/celerity/getting-started
+* "API docs":http://celerity.rubyforge.org/yard/
+
+h2. Links
+
+* "cucumber":http://github.com/aslakhellesoy/cucumber/wikis
+* "celerity":http://celerity.rubyforge.org
+* "jruby":http://jruby.codehaus.org
+* "rspec":http://rspec.info
+* "htmlunit":http://htmlunit.sourceforge.net/
+
+h2. Contact
+
+Written 2009 by Alexander Lang, contact alex[at]upstream-berlin.com or http://github.com/langalex, released under the MIT license

data/Rakefile

@@ -0,0 +1,42 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+# require 'rcov/rcovtask'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "culerity"
+    s.summary = %Q{Culerity integrates Cucumber and Celerity in order to test your application's full stack.}
+    s.email = "alex@upstream-berlin.com"
+    s.homepage = "http://github.com/langalex/culerity"
+    s.description = "Culerity integrates Cucumber and Celerity in order to test your application's full stack."
+    s.authors = ["Alexander Lang"]
+    s.add_dependency 'cucumber' 
+    s.add_dependency 'rspec' 
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib'
+  t.pattern = 'spec/**/*_spec.rb'
+  t.verbose = false
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Culerity'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+# Rcov::RcovTask.new do |t|
+#   t.libs << 'spec'
+#   t.test_files = FileList['spec/**/*_spec.rb']
+#   t.verbose = true
+# end
+
+task :default => :test

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 2
+:patch: 1

data/culerity.gemspec

@@ -0,0 +1,79 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{culerity}
+  s.version = "0.2.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Alexander Lang"]
+  s.date = %q{2009-08-15}
+  s.description = %q{Culerity integrates Cucumber and Celerity in order to test your application's full stack.}
+  s.email = %q{alex@upstream-berlin.com}
+  s.extra_rdoc_files = [
+    "README.textile"
+  ]
+  s.files = [
+    ".gitignore",
+     "MIT-LICENSE",
+     "README.textile",
+     "Rakefile",
+     "VERSION.yml",
+     "culerity.gemspec",
+     "features/fixtures/sample_feature",
+     "features/installing_culerity.feature",
+     "features/step_definitions/common_steps.rb",
+     "features/step_definitions/culerity_setup_steps.rb",
+     "features/step_definitions/rails_setup_steps.rb",
+     "features/support/common.rb",
+     "features/support/env.rb",
+     "features/support/matchers.rb",
+     "init.rb",
+     "lib/culerity.rb",
+     "lib/culerity/celerity_server.rb",
+     "lib/culerity/remote_browser_proxy.rb",
+     "lib/culerity/remote_object_proxy.rb",
+     "rails/init.rb",
+     "rails_generators/culerity/culerity_generator.rb",
+     "rails_generators/culerity/templates/config/environments/culerity_continuousintegration.rb",
+     "rails_generators/culerity/templates/config/environments/culerity_development.rb",
+     "rails_generators/culerity/templates/features/step_definitions/common_celerity_steps.rb",
+     "rails_generators/culerity/templates/lib/tasks/culerity.rake",
+     "script/console",
+     "script/destroy",
+     "script/generate",
+     "spec/celerity_server_spec.rb",
+     "spec/remote_browser_proxy_spec.rb",
+     "spec/remote_object_proxy_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/langalex/culerity}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Culerity integrates Cucumber and Celerity in order to test your application's full stack.}
+  s.test_files = [
+    "spec/celerity_server_spec.rb",
+     "spec/remote_browser_proxy_spec.rb",
+     "spec/remote_object_proxy_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<cucumber>, [">= 0"])
+      s.add_runtime_dependency(%q<rspec>, [">= 0"])
+    else
+      s.add_dependency(%q<cucumber>, [">= 0"])
+      s.add_dependency(%q<rspec>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<cucumber>, [">= 0"])
+    s.add_dependency(%q<rspec>, [">= 0"])
+  end
+end

data/features/fixtures/sample_feature

@@ -0,0 +1,14 @@
+Feature: Check that default Rails index.html shows information
+  In order to value
+  As a role
+  I want feature
+
+  Scenario: Check javascript runs on static file
+    Given I go to the homepage
+    Then I should not see "Rails version"
+    When I follow "About your application’s environment"
+    And I wait for the AJAX call to finish
+    Then I should see "No route matches"
+  
+  
+  

data/features/installing_culerity.feature

@@ -0,0 +1,41 @@
+Feature: Installing culerity
+  In order to not have to use f@#$ing selenium and receive hate into our lives
+  As a self-respective Rails/JavaScript developer
+  I want to install culerity into my Rails app
+
+  Scenario: Install culerity into a Rails app and check it works
+    Given a Rails app
+    And I run executable "script/generate" with arguments "cucumber"
+    And I delete file "features/step_definitions/webrat_steps.rb"
+    And I copy the project generators into "vendor/generators"
+    And I invoke task "rake db:migrate"
+    When I run executable "script/generate" with arguments "culerity"
+    And I setup load path to local code
+    Then file "features/step_definitions/common_celerity_steps.rb" is created
+    Then file "config/environments/culerity_development.rb" is created
+    Then file "config/environments/culerity_continuousintegration.rb" is created
+    
+    And I run executable "cucumber" with arguments "features/"
+    Then I should see "0 scenarios"
+    And I should see "0 steps"
+    
+    Given I invoke task "rake culerity:rails:start"
+    
+    When I add a feature file to test Rails index.html default file
+    And I run executable "cucumber" with arguments "features/"
+    Then I should see "1 scenario"
+    And I should see "5 steps (5 passed)"
+
+  Scenario: Install culerity and test the rails start + stop tasks
+    Given a Rails app
+    And I run executable "script/generate" with arguments "cucumber"
+    And I delete file "features/step_definitions/webrat_steps.rb"
+    And I copy the project generators into "vendor/generators"
+    And I invoke task "rake db:migrate"
+    When I run executable "script/generate" with arguments "culerity"
+    And I invoke task "rake culerity:rails:start"
+    Then file "tmp/culerity_rails_server.pid" is created
+    And I invoke task "rake culerity:rails:stop"
+    Then file "tmp/culerity_rails_server.pid" is not created
+  
+  

data/features/step_definitions/common_steps.rb

@@ -0,0 +1,171 @@
+Given /^this project is active project folder/ do
+  @active_project_folder = File.expand_path(File.dirname(__FILE__) + "/../..")
+end
+
+Given /^env variable \$([\w_]+) set to "(.*)"/ do |env_var, value|
+  ENV[env_var] = value
+end
+
+Given /I delete (folder|file) "([^\"]*)"/ do |type, folder|
+  in_project_folder { FileUtils.rm_rf folder }
+end
+
+When /^I invoke "(.*)" generator with arguments "(.*)"$/ do |generator, arguments|
+  @stdout = StringIO.new
+  in_project_folder do
+    if Object.const_defined?("APP_ROOT")
+      APP_ROOT.replace(FileUtils.pwd)
+    else 
+      APP_ROOT = FileUtils.pwd
+    end
+    run_generator(generator, arguments.split(' '), SOURCES, :stdout => @stdout)
+  end
+  File.open(File.join(@tmp_root, "generator.out"), "w") do |f|
+    @stdout.rewind
+    f << @stdout.read
+  end
+end
+
+When /^I run executable "(.*)" with arguments "(.*)"/ do |executable, arguments|
+  @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
+  in_project_folder do
+    system "#{executable} #{arguments} > #{@stdout} 2> #{@stdout}"
+  end
+end
+
+When /^I run project executable "(.*)" with arguments "(.*)"/ do |executable, arguments|
+  @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
+  in_project_folder do
+    system "ruby #{executable} #{arguments} > #{@stdout} 2> #{@stdout}"
+  end
+end
+
+When /^I run local executable "(.*)" with arguments "(.*)"/ do |executable, arguments|
+  @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
+  executable = File.expand_path(File.join(File.dirname(__FILE__), "/../../bin", executable))
+  in_project_folder do
+    system "ruby #{executable} #{arguments} > #{@stdout} 2> #{@stdout}"
+  end
+end
+
+When /^I invoke task "rake (.*)"/ do |task|
+  @stdout = File.expand_path(File.join(@tmp_root, "rake.out"))
+  @stderr = File.expand_path(File.join(@tmp_root, "rake.err"))
+  in_project_folder do
+    system "rake #{task} --trace > #{@stdout} 2> #{@stderr}"
+  end
+  File.read(@stderr).should_not =~ /rake aborted!/
+end
+
+Then /^folder "(.*)" (is|is not) created/ do |folder, is|
+  in_project_folder do
+    File.exists?(folder).should(is == 'is' ? be_true : be_false)
+  end
+end
+
+Then /^file "(.*)" (is|is not) created/ do |file, is|
+  in_project_folder do
+    File.exists?(file).should(is == 'is' ? be_true : be_false)
+  end
+end
+
+Then /^file with name matching "(.*)" is created/ do |pattern|
+  in_project_folder do
+    Dir[pattern].should_not be_empty
+  end
+end
+
+Then /^file "(.*)" contents (does|does not) match \/(.*)\// do |file, does, regex|
+  in_project_folder do
+    actual_output = File.read(file)
+    (does == 'does') ?
+      actual_output.should(match(/#{regex}/)) :
+      actual_output.should_not(match(/#{regex}/))
+  end
+end
+
+Then /gem file "(.*)" and generated file "(.*)" should be the same/ do |gem_file, project_file|
+  File.exists?(gem_file).should be_true
+  File.exists?(project_file).should be_true
+  gem_file_contents = File.read(File.dirname(__FILE__) + "/../../#{gem_file}")
+  project_file_contents = File.read(File.join(@active_project_folder, project_file))
+  project_file_contents.should == gem_file_contents
+end
+
+Then /^(does|does not) invoke generator "(.*)"$/ do |does_invoke, generator|
+  actual_output = File.read(@stdout)
+  does_invoke == "does" ?
+    actual_output.should(match(/dependency\s+#{generator}/)) :
+    actual_output.should_not(match(/dependency\s+#{generator}/))
+end
+
+Then /help options "(.*)" and "(.*)" are displayed/ do |opt1, opt2|
+  actual_output = File.read(@stdout)
+  actual_output.should match(/#{opt1}/)
+  actual_output.should match(/#{opt2}/)
+end
+
+Then /^I should see "([^\"]*)"$/ do |text|
+  actual_output = File.read(@stdout)
+  actual_output.should contain(text)
+end
+
+
+Then /^I should see$/ do |text|
+  actual_output = File.read(@stdout)
+  actual_output.should contain(text)
+end
+
+Then /^I should not see$/ do |text|
+  actual_output = File.read(@stdout)
+  actual_output.should_not contain(text)
+end
+
+Then /^I should see exactly$/ do |text|
+  actual_output = File.read(@stdout)
+  actual_output.should == text
+end
+
+Then /^I should see all (\d+) tests pass/ do |expected_test_count|
+  expected = %r{^#{expected_test_count} tests, \d+ assertions, 0 failures, 0 errors}
+  actual_output = File.read(@stdout)
+  actual_output.should match(expected)
+end
+
+Then /^I should see all (\d+) examples pass/ do |expected_test_count|
+  expected = %r{^#{expected_test_count} examples?, 0 failures}
+  actual_output = File.read(@stdout)
+  actual_output.should match(expected)
+end
+
+Then /^yaml file "(.*)" contains (\{.*\})/ do |file, yaml|
+  in_project_folder do
+    yaml = eval yaml
+    YAML.load(File.read(file)).should == yaml
+  end
+end
+
+Then /^Rakefile can display tasks successfully/ do
+  @stdout = File.expand_path(File.join(@tmp_root, "rakefile.out"))
+  in_project_folder do
+    system "rake -T > #{@stdout} 2> #{@stdout}"
+  end
+  actual_output = File.read(@stdout)
+  actual_output.should match(/^rake\s+\w+\s+#\s.*/)
+end
+
+Then /^task "rake (.*)" is executed successfully/ do |task|
+  @stdout.should_not be_nil
+  actual_output = File.read(@stdout)
+  actual_output.should_not match(/^Don't know how to build task '#{task}'/)
+  actual_output.should_not match(/Error/i)
+end
+
+Then /^gem spec key "(.*)" contains \/(.*)\// do |key, regex|
+  in_project_folder do
+    gem_file = Dir["pkg/*.gem"].first
+    gem_spec = Gem::Specification.from_yaml(`gem spec #{gem_file}`)
+    spec_value = gem_spec.send(key.to_sym)
+    spec_value.to_s.should match(/#{regex}/)
+  end
+end

data/features/step_definitions/culerity_setup_steps.rb

@@ -0,0 +1,7 @@
+When /^I setup load path to local code$/ do
+  project_lib_path = File.expand_path(File.dirname(__FILE__) + "/../../lib")
+  in_project_folder do
+    force_local_lib_override(:target => 'features/step_definitions/common_celerity_steps.rb')
+  end
+end
+

data/features/step_definitions/rails_setup_steps.rb

@@ -0,0 +1,36 @@
+Given /^a Rails app$/ do
+  FileUtils.chdir(@tmp_root) do
+    `rails my_project`
+  end
+  @active_project_folder = File.expand_path(File.join(@tmp_root, "my_project"))
+end
+
+Given /^I copy the project generators into "([^\"]*)"$/ do |target_folder|
+  in_project_folder do
+    FileUtils.mkdir_p(target_folder)
+  end
+  `cp -rf #{File.dirname(__FILE__) + "/../../rails_generators/*"} #{File.join(@active_project_folder, target_folder)}`
+end
+
+When /^I add a feature file to test Rails index.html default file$/ do
+  sample_feature = File.expand_path(File.dirname(__FILE__) + "/../fixtures/sample_feature")
+  in_project_folder do
+    `cp -rf #{sample_feature} features/sample.feature`
+  end
+end
+
+Given /^I run the rails server in environment "([^\"]*)"$/ do |environment|
+  in_project_folder do
+    $rails_server ||= IO.popen("script/server -e #{environment} -p 3001", 'r+')
+    File.open("tmp/culerity_rails_server.pid", "w") { |file| file << $rails_server.pid; file.flush }
+  end
+end
+
+After do
+  in_project_folder do
+    Given 'I invoke task "rake culerity:rails:stop"'
+  end
+end
+
+# rake culerity:rails:start [RAILS=culerity_development]
+# rake culerity:rails:stop

data/features/support/common.rb

@@ -0,0 +1,32 @@
+module CommonHelpers
+  def in_tmp_folder(&block)
+    FileUtils.chdir(@tmp_root, &block)
+  end
+
+  def in_project_folder(&block)
+    project_folder = @active_project_folder || @tmp_root
+    FileUtils.chdir(project_folder, &block)
+  end
+
+  def in_home_folder(&block)
+    FileUtils.chdir(@home_path, &block)
+  end
+
+  def force_local_lib_override(options = {})
+    target_path = options[:target_path] || options[:target_file] || options[:target] || 'Rakefile'
+    in_project_folder do
+      contents = File.read(target_path)
+      File.open(target_path, "w+") do |f|
+        f << "$:.unshift('#{@lib_path}')\n"
+        f << contents
+      end
+    end
+  end
+
+  def setup_active_project_folder project_name
+    @active_project_folder = File.join(@tmp_root, project_name)
+    @project_name = project_name
+  end
+end
+
+World(CommonHelpers)

data/features/support/env.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + "/../../lib/culerity"
+
+gem 'cucumber'
+require 'cucumber'
+gem 'rspec'
+require 'spec'
+
+Before do
+  @tmp_root  = File.dirname(__FILE__) + "/../../tmp"
+  @home_path = File.expand_path(File.join(@tmp_root, "home"))
+  @lib_path  = File.expand_path(File.dirname(__FILE__) + "/../../lib")
+  FileUtils.rm_rf   @tmp_root
+  FileUtils.mkdir_p @home_path
+  ENV['HOME'] = @home_path
+end
+
+require 'rubigen'
+require 'rubigen/helpers/generator_test_helper'
+include RubiGen::GeneratorTestHelper
+require 'rails_generator'
+
+SOURCES = Dir[File.dirname(__FILE__) + "/../../generators"].map do |f|
+  RubiGen::PathSource.new(:test, File.expand_path(f))
+end

data/features/support/matchers.rb

@@ -0,0 +1,11 @@
+module Matchers
+  def contain(expected)
+    simple_matcher("contain #{expected.inspect}") do |given, matcher|
+      matcher.failure_message = "expected #{given.inspect} to contain #{expected.inspect}"
+      matcher.negative_failure_message = "expected #{given.inspect} not to contain #{expected.inspect}"
+      given.index expected
+    end
+  end
+end
+
+World(Matchers)

data/init.rb

@@ -0,0 +1 @@
+require 'rails/init'

data/lib/culerity/celerity_server.rb

@@ -0,0 +1,65 @@
+require 'rubygems'
+require 'celerity'
+
+
+module Culerity
+  class CelerityServer
+    
+    def initialize(_in, _out)
+      @proxies = {}
+      @browser_options = {}
+      
+      while(true)
+        call = eval _in.gets.to_s.strip
+        return if call == ["_exit_"]
+        unless call.nil?
+          begin
+            # check if last arg is a block
+            if call.last.is_a?(Proc)
+              # pass as &call[-1]
+              result = target(call.first).send call[1], *call[2..-2], &call[-1]
+            else
+              # just call with args as normal
+              result = target(call.first).send call[1], *call[2..-1]
+            end
+            _out << "[:return, #{proxify result}]\n"
+          rescue => e
+            _out << "[:exception, \"#{e.class.name}\", #{e.message.inspect}, #{e.backtrace.inspect}]\n"
+          end
+        end
+      end
+      
+    end
+    
+    private
+    
+    def configure_browser(options)
+      @browser_options = options
+    end
+    
+    def browser
+      @browser ||= Celerity::Browser.new @browser_options || {}
+    end
+    
+    def target(object_id)
+      if object_id == 'browser'
+        browser
+      elsif object_id == 'celerity'
+        self
+      else
+        @proxies[object_id]
+      end
+    end
+    
+    def proxify(result, in_array = false)
+      if result.is_a?(Array)
+        result.map {|x| proxify(x, true) }.inspect
+      elsif [String, TrueClass, FalseClass, Fixnum, Float, NilClass].include?(result.class)
+        in_array ? result : result.inspect
+      else
+        @proxies[result.object_id] = result
+        "Culerity::RemoteObjectProxy.new(#{result.object_id}, @io)"
+      end
+    end
+  end
+end