ensure query strings are built correctly for mechanize

[#182 state:resolved]

.gitignore

@@ -11,4 +11,8 @@ log
 *.swp
 results
 test_apps
-*.tmproj
+*.tmproj
+*.log
+*.pid
+bin
+vendor/gems

Gemfile

@@ -0,0 +1,13 @@
+gem "rake",             "0.8.7"
+gem "rspec",            "1.2.9"
+gem "diff-lcs",         "1.1.2"
+gem "rack",             "1.0.1"
+gem "nokogiri",         "1.4.0"
+gem "merb-core",        "1.0.15"
+gem "selenium-client",  "1.2.17"
+gem "mechanize",        "0.9.3"
+gem "rails",            "2.3.4"
+gem "launchy",          "0.3.3"
+gem "rack-test",        "0.5.2"
+gem "sinatra",          "0.9.4"
+gem "mongrel",          "1.1.5"

History.txt

@@ -1,3 +1,216 @@
+== 0.7.1 / 2010-04-26
+
+* Minor enhancements
+
+  * Move verbose selenium output that can clutter build output behind setting
+  * Added application_port_for_selenium to webrat configuration. The use case is when you want to test through a web server sitting in front of your application server. (Luke Melia)
+  * New webrat configuration option selenium_firefox_profile which is passed to selenium server
+  * Allow submit_form to select by CSS too (Damian Janowski)
+
+* Bug fixes
+
+  * Fix that current_url wasn't reflecting redirects in Mechanize [#332] (Emrys Ingersoll)
+  * Fix attach_file with nested params [#341] (Álvaro Gil)
+  * Fix that a 304 was considered a redirect (Larry Marburger)
+  * Fix selection of LABEL elements in Selenium mode under IE [#317] (Damian Janowski, Noah Davis)
+  * Fix have_xpath not matching negative expectation in the block [#182] (Luismi Cavallé)
+
+== 0.7.0 / 2010-01-17
+
+* Major enhancements
+
+  * Upgrade bundled Selenium server JAR to 2.0a1 (Henry Poydar and Jake Scruggs)
+
+* Minor enhancements
+
+  * Save and open page directory specified via configuration, defaults to tmp dir otherwise current dir (Noah Davis)
+
+* Bug fixes
+
+  * Added missing dependency "rack-test" to gemspec (LH #339) (Noah Davis)
+  * Removed save_and_open_page's rewriting of static asset paths before saving (was not actually working) (Noah Davis)
+  * Make "should contain" ignore extra whitespace when doing string comparisons (Noah Davis)
+  * Make selenium matchers handle negative match more consistently with positive match (Luke Melia)
+   
+== 0.6.0 / 2009-11-28
+
+REMOVED: Support for Hpricot + REXML as an alternative to Nokogiri.
+
+  Hpricot and REXML were difficult to work with, REXML is terribly slow,
+  and Nokogiri is recommended even by the author of Hpricot (_why). Now
+  that Nokogiri works on JRuby, Webrat is going to use it as its sole
+  XML backend.
+
+CHANGED: Due to a reorganization, if you're currently requiring "webrat/rspec-rails",
+  please change your code to require "webrat/integrations/rspec-rails"
+
+* Minor enhancements
+
+  * Support Rails 2.3.4 JavaScript form authenticity tokens in simulated mode (Jonathan Weiss)
+  * When a timeout occurs in wait_for, include the HTML from Selenium in the exception
+  * Update the Merb support to be based directly on Rack (Simon Rozet)
+  * Support multiple select fields (Kieran P)
+  * When locating select options, always match against text, not HTML
+
+* Bug fixes
+
+  * Remove newlines from HTTP Basic authentication credentials (Michael Klett)
+  * Require nokogiri form rspec-rails.rb (David Chelimsky)
+  * Fix logger issue when running inside Cucumber (Damian Janowski)
+  * Fix various issues related to submitting values with HTML entities (Kieran P)
+  * Call #to_i on the :count option in matchers (Michael Christenson II)
+  * Fix bug where multiline param values were getting truncated
+
+== 0.5.3 / 2009-08-27
+
+* Minor enhancements
+
+  * Remove unnecessary requires which are to the wrong paths on Edge Rails
+
+== 0.5.1 / 2009-08-18
+
+* Minor enhancements
+
+  * Base Webrat::MIME on Rack::Mime (Simon Rozet)
+  * Support file uploads in Rack mode (Simon Rozet)
+
+* Bug fixes
+
+  * Fix bug in Webrat::Methods preventing Selenium mode from working [#277]
+
+== 0.5.0 / 2009-08-12
+
+* Major enhancements
+
+  * Depreacate :rack_test and :sinatra in favor of :rack, which uses Rack::Test (Simon Rozet)
+
+* Minor enhancements
+
+  * Don't require rubygems at runtime (Simon Rozet)
+
+== 0.4.5 / 2009-08-10
+
+* Major enhancements
+
+  * Ruby 1.9 compatibility (Michael Fellinger, Jakub Kuźma)
+  * Improve performance (~2x) on JRuby by supporting Nokogiri
+  * Added support for external app servers in selenium mode (basically don't start one) (Mike Gaffney)
+  * Added support for uploading files for Merb (Ryan Carver)
+
+* Minor enhancements
+
+  * Upgrade to selenium-client to 1.2.16 (Brian Landau)
+  * Upgrade selenium-server.jar to 1.0.1 (Brian Landau)
+  * Make redirect detection work in the face of rational maths (like when ruby-units is active) (Piers Cawley)
+  * Use Launchy to handle opening pages in the browser with cross-platform compatibility (Bryan Helmkamp)
+  * Added support for field_labeled_locators ending in non word characters
+    lh 148 (Zach Dennis)
+  * Filled in tests on click link lh 195 (diabolo)
+  * Added current_url to selenium session lh 215 (Luke Amdor)
+  * Added silence spec to selenium lh 238 (Martin Gamsjaeger aka snusnu)
+  * Added ability to configure the browser startup timeout for selenium lh 242 (Mike Gaffney, Mark Dodwell)
+  * Added delegation for field_named lh194 (pivotal labs)
+  * Added fix to keep from escaping field values in mechanize mode lh256 (jish)
+  * Adding fixes for click button/link and made the integration specs pass for the same in selenium lh254 (Ldiehl, Matthias Marschall)
+  * Adding clicking link by id in selenium mode lh221 (larrytheliquid)
+  * Adding fix for have_selector and have_xpath in descendent blocks lh234 (Thomas Jack)
+  * Adding fix for fields with labels with special characters (Thomas Jack, Mike Gaffney, Bryan Hemlkamp)
+  * Deprecated current_page lh50 (Mike Gaffney)
+  * Fixed issue with redirects and multiple hosts lh168 (Mutwin Kraus)
+
+* Bug fixes
+
+  * Wait for application servers socket on 0.0.0.0 instead of the application_address
+  * Translate CSS and image paths with single quotes in save_and_open_page (Erin Staniland)
+
+== 0.4.4 / 2009-04-06
+
+* Major enhancements
+
+  * Make selenium process management code more robust and informative
+
+* Minor enhancements
+
+  * Add support for Rails javascript post links (Mark Menard)
+  * Upgrade selenium-client dependency to 1.2.14, and update for new waiting
+    API (Balint Erdi)
+  * Change default app environment from "selenium" to "test"
+
+* Bug fixes
+
+  * Don't create a new instance of WWW::Mechanize for each request
+    (Mark Menard)
+  * Select fields with duplicate selected options sent an incorrect value (Noah Davis)
+
+== 0.4.3 / 2009-03-17
+
+* Minor enhancements
+
+  * Support Rails 2.3. Use Rack::Utils to parse params (Matthew Ford)
+  * Support for "modular" Sinatra app style (Simon Rozet)
+  * Initial Merb and Sinatra compatibility for Selenium mode (Corey Donohoe)
+  * When faced with a label with no for attribute, that contains a hidden field
+    and another field, as can be the case in Rails 2.3's checkbox view,
+    webrat now locates the non-hidden field. (Luke Melia)
+  * Add application_framework config for Selenium mode to determine how to
+    start and stop the app server (Corey Donohoe)
+
+* Bug fixes
+
+  * Fix following of absolute redirect URL in Sinatra (Simon Rozet)
+
+== 0.4.2 / 2009-02-24
+
+* Major enhancements
+
+  * Significant improvements to have_selector. It now supports specifying
+    attributes in a hash and :count and :content options. See
+    have_selector_spec.rb for more.
+  * Add the same functionality mentioned above to have_xpath
+
+* Minor enhancements
+
+  * Squeeze extra whitespace out of failures messages from contain
+    matcher
+  * Detect infinite redirects and raise a Webrat::InfiniteRedirectError
+    (Daniel Lucraft)
+
+* Bug fixes
+
+  * Properly quote single and double quotes strings in XPath
+  * Fix warning caused by Nokogiri deprecating CSS::Parser.parse
+    (Aaron Patterson)
+  * Accept do/end blocks in matchers. [#157] (Peter Jaros)
+  * Quote --chdir option to mongrel_rails to support RAILS_ROOTs with spaces
+    (T.J. VanSlyke)
+
+== 0.4.1 / 2009-01-31
+
+* Minor enhancements
+
+  * Support Sinatra 0.9 (Harry Vangberg)
+  * Update query param parsing to work with latest Edge Rails
+  * Added #redirected_to method to easily check where an external redirect was
+    redirected to (Adam Greene)
+  * Recognize input tags with type button (Lena Herrmann)
+  * Add uncheck method to Selenium mode (Lee Bankewitz)
+
+* Bug fixes
+
+  * Make requests to a Rails app using a full URL instead of a relative path. This change
+    is helpful for Rails apps that use subdomains. (John Hwang and Zach Dennis)
+  * Follow redirects that are on the same domain but a different subdomain
+    (Adam Greene)
+  * rescue from Webrat::TimeoutError in selenium matchers which allows NegativeMatchers
+    to behave correctly (Noah Davis)
+  * Switch to using selenium.click instead of .check when checking a checkbox
+    (Noah Davis)
+  * Create tmp/pids directory if directory does not exist. (Amos King and Mike Gaffney)
+  * Setup deprecated writers for the selenium_environment= and selenium_port= config
+  * Ensure the previous pages params aren't passed through redirect (Daniel Lucraft and
+    Bryan Helmkamp)
+  * Labels should only search for fields within the current scope (Kyle Hargraves)
+
 == 0.4.0 / 2009-01-18
 
 * _IMPORTANT_ Breaking change:
@@ -68,7 +281,7 @@
   * Added save_and_open_screengrab for Selenium mode (Luke Melia)
 
 * Bug fixes
-  
+
   * field_labeled should disregard labels without matching fields (Kyle Hargraves)
   * Fixed bug where Scope was creating a new DOM rather than re-using the existing DOM.
     [#105] (Zach Dennis)

Rakefile

@@ -1,93 +1,67 @@
-# require 'rubygems'
+begin
-require "rake/gempackagetask"
+  require 'spec/rake/spectask'
-require 'rake/rdoctask'
+rescue LoadError
-require "rake/clean"
+  desc "Run specs"
-require 'spec'
+  task(:spec) { $stderr.puts '`gem install rspec` to run specs' }
-require 'spec/rake/spectask'
+else
-require 'spec/rake/verify_rcov'
+  desc "Run API and Core specs"
-require File.expand_path('./lib/webrat.rb')
+  Spec::Rake::SpecTask.new do |t|
+    t.spec_opts = ['--options', "\"#{File.dirname(__FILE__)}/spec/spec.opts\""]
+    t.spec_files = FileList['spec/public/**/*_spec.rb'] + FileList['spec/private/**/*_spec.rb']
+  end
 
-##############################################################################
+  desc "Run all specs in spec directory with RCov"
-# Package && release
+  Spec::Rake::SpecTask.new(:rcov) do |t|
-##############################################################################
+    t.spec_opts = ['--options', "\"#{File.dirname(__FILE__)}/spec/spec.opts\""]
-spec = Gem::Specification.new do |s|
+    t.spec_files = FileList['spec/public/**/*_spec.rb'] + FileList['spec/private/**/*_spec.rb']
-  s.name         = "webrat"
+    t.rcov = true
-  s.version      = Webrat::VERSION
+    t.rcov_opts = lambda do
-  s.platform     = Gem::Platform::RUBY
+      IO.readlines(File.dirname(__FILE__) + "/spec/rcov.opts").map {|l| l.chomp.split " "}.flatten
-  s.author       = "Bryan Helmkamp"
+    end
-  s.email        = "bryan" + "@" + "brynary.com"
-  s.homepage     = "http://github.com/brynary/webrat"
-  s.summary      = "Webrat. Ruby Acceptance Testing for Web applications"
-  s.bindir       = "bin"
-  s.description  = s.summary
-  s.require_path = "lib"
-  s.files        = %w(History.txt install.rb MIT-LICENSE.txt README.rdoc Rakefile) + Dir["lib/**/*"] + Dir["vendor/**/*"]
-
-  # rdoc
-  s.has_rdoc         = true
-  s.extra_rdoc_files = %w(README.rdoc MIT-LICENSE.txt)
-
-  # Dependencies
-  s.add_dependency "nokogiri", ">= 1.1.0"
-
-  s.rubyforge_project = "webrat"
-end
-
-Rake::GemPackageTask.new(spec) do |package|
-  package.gem_spec = spec
-end
-
-desc 'Show information about the gem.'
-task :debug_gem do
-  puts spec.to_ruby
-end
-
-CLEAN.include ["pkg", "*.gem", "doc", "ri", "coverage"]
-
-desc "Upload rdoc to brynary.com"
-task :publish_rdoc => :docs do
-  sh "scp -r doc/ brynary.com:/apps/uploads/webrat"
-end
-
-desc "Run API and Core specs"
-Spec::Rake::SpecTask.new do |t|
-  t.spec_opts = ['--options', "\"#{File.dirname(__FILE__)}/spec/spec.opts\""]
-  t.spec_files = FileList['spec/public/**/*_spec.rb'] + FileList['spec/private/**/*_spec.rb']
-end
-
-desc "Run all specs in spec directory with RCov"
-Spec::Rake::SpecTask.new(:rcov) do |t|
-  t.spec_opts = ['--options', "\"#{File.dirname(__FILE__)}/spec/spec.opts\""]
-  t.spec_files = FileList['spec/public/**/*_spec.rb'] + FileList['spec/private/**/*_spec.rb']
-  t.rcov = true
-  t.rcov_opts = lambda do
-    IO.readlines(File.dirname(__FILE__) + "/spec/rcov.opts").map {|l| l.chomp.split " "}.flatten
   end
 end
 
-RCov::VerifyTask.new(:verify_rcov => :rcov) do |t|
+desc "Run everything against multiruby"
-  t.threshold = 96.2 # Make sure you have rcov 0.7 or higher!
+task :multiruby do
-end
+  result = system "multiruby -S rake spec"
+  raise "Multiruby tests failed" unless result
+  result = system "jruby -S rake spec"
+  raise "JRuby tests failed" unless result
 
-desc 'Install the package as a gem.'
+  Dir.chdir "spec/integration/rails" do
-task :install_gem => [:clean, :package] do
+    result = system "multiruby -S rake test_unit:rails"
-  gem_filename = Dir['pkg/*.gem'].first
+    raise "Rails integration tests failed" unless result
-  sh "sudo gem install --local #{gem_filename}"
-end
 
-desc "Delete generated RDoc"
+    result = system "jruby -S rake test_unit:rails"
-task :clobber_docs do
+    raise "Rails integration tests failed" unless result
-  FileUtils.rm_rf("doc")
+  end
-end
 
-desc "Generate RDoc"
+  Dir.chdir "spec/integration/merb" do
-task :docs => :clobber_docs do
+    result = system "multiruby -S rake spec"
-  system "hanna --title 'Webrat #{Webrat::VERSION} API Documentation'"
+    raise "Merb integration tests failed" unless result
-end
 
-desc "Run specs using jruby"
+    result = system "jruby -S rake spec"
-task "spec:jruby" do
+    raise "Rails integration tests failed" unless result
-  system "jruby -S rake spec"
+  end
+
+  Dir.chdir "spec/integration/sinatra" do
+    result = system "multiruby -S rake test"
+    raise "Sinatra integration tests failed" unless result
+
+    result = system "jruby -S rake test"
+    raise "Sinatra integration tests failed" unless result
+  end
+
+  Dir.chdir "spec/integration/rack" do
+    result = system "multiruby -S rake test"
+    raise "Rack integration tests failed" unless result
+
+    result = system "jruby -S rake test"
+    raise "Rack integration tests failed" unless result
+  end
+
+  puts
+  puts "Multiruby OK!"
 end
 
 desc "Run each spec in isolation to test for dependency issues"
@@ -99,27 +73,38 @@ task :spec_deps do
   end
 end
 
-task :prepare do
-  system "ln -s ../../../../.. ./spec/integration/rails/vendor/plugins/webrat"
-end
-
 namespace :spec do
   desc "Run the integration specs"
-  task :integration => ["integration:rails", "integration:merb", "integration:sinatra"]
+  task :integration => [
+    "integration:rack",
+    "integration:sinatra",
+    "integration:merb",
+    "integration:mechanize",
+    "integration:rails:webrat",
+    "integration:rails:selenium",
+  ]
 
   namespace :integration do
-    desc "Run the Rails integration specs"
+    namespace :rails do
-    task :rails do
+      task :selenium do
-      Dir.chdir "spec/integration/rails" do
+        Dir.chdir "spec/integration/rails" do
-        result = system "rake test:integration"
+          result = system "rake -rubygems test_unit:selenium"
-        raise "Rails integration tests failed" unless result
+          raise "Rails integration tests failed" unless result
+        end
+      end
+
+      task :webrat do
+        Dir.chdir "spec/integration/rails" do
+          result = system "rake -rubygems test_unit:rails"
+          raise "Rails integration tests failed" unless result
+        end
       end
     end
 
     desc "Run the Merb integration specs"
     task :merb do
       Dir.chdir "spec/integration/merb" do
-        result = system "rake spec"
+        result = system "rake -rubygems spec"
         raise "Merb integration tests failed" unless result
       end
     end
@@ -127,13 +112,32 @@ namespace :spec do
     desc "Run the Sinatra integration specs"
     task :sinatra do
       Dir.chdir "spec/integration/sinatra" do
-        result = system "rake test"
+        result = system "rake -rubygems test"
-        raise "Sinatra tntegration tests failed" unless result
+        raise "Sinatra integration tests failed" unless result
+      end
+    end
+
+    desc "Run the Sinatra integration specs"
+    task :rack do
+      Dir.chdir "spec/integration/rack" do
+        result = system "rake -rubygems test"
+        raise "Rack integration tests failed" unless result
+      end
+    end
+
+    desc "Run the Mechanize integration specs"
+    task :mechanize do
+      Dir.chdir "spec/integration/mechanize" do
+        result = system "rake -rubygems spec"
+        raise "Mechanize integration tests failed" unless result
       end
     end
   end
 end
 
-task :default => :spec
+desc 'Removes trailing whitespace'
+task :whitespace do
+  sh %{find . -name '*.rb' -exec sed -i '' 's/ *$//g' {} \\;}
+end
 
-task :precommit => ["spec", "spec:jruby", "spec:integration"]
+task :default => :spec

Thorfile

@@ -0,0 +1,118 @@
+module GemHelpers
+
+  def generate_gemspec
+    $LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), "lib")))
+    require "webrat"
+
+    Gem::Specification.new do |s|
+      s.name      = "webrat"
+      s.version   = Webrat::VERSION
+      s.author    = "Bryan Helmkamp"
+      s.email     = "bryan@brynary.com"
+      s.homepage  = "http://github.com/brynary/webrat"
+      s.summary   = "Ruby Acceptance Testing for Web applications"
+      s.description  = <<-EOS.strip
+Webrat lets you quickly write expressive and robust acceptance tests
+for a Ruby web application. It supports simulating a browser inside
+a Ruby process to avoid the performance hit and browser dependency of
+Selenium or Watir, but the same API can also be used to drive real
+Selenium tests when necessary (eg. for testing AJAX interactions).
+Most Ruby web frameworks and testing frameworks are supported.
+      EOS
+      s.rubyforge_project = "webrat"
+
+      require "git"
+      repo = Git.open(".")
+
+      s.files      = normalize_files(repo.ls_files.keys - repo.lib.ignored_files)
+      s.test_files = normalize_files(Dir['spec/**/*.rb'] - repo.lib.ignored_files)
+
+      s.has_rdoc = true
+      s.extra_rdoc_files = %w[README.rdoc MIT-LICENSE.txt History.txt]
+
+      s.add_dependency "nokogiri", ">= 1.2.0"
+      s.add_dependency "rack", ">= 1.0"
+      s.add_dependency "rack-test", ">= 0.5.3"
+    end
+  end
+
+  def normalize_files(array)
+    # only keep files, no directories, and sort
+    array.select do |path|
+      File.file?(path)
+    end.sort
+  end
+
+  # Adds extra space when outputting an array. This helps create better version
+  # control diffs, because otherwise it is all on the same line.
+  def prettyify_array(gemspec_ruby, array_name)
+    gemspec_ruby.gsub(/s\.#{array_name.to_s} = \[.+?\]/) do |match|
+      leadin, files = match[0..-2].split("[")
+      leadin + "[\n    #{files.split(",").join(",\n   ")}\n  ]"
+    end
+  end
+
+  def read_gemspec
+    @read_gemspec ||= eval(File.read("webrat.gemspec"))
+  end
+
+  def sh(command)
+    puts command
+    system command
+  end
+end
+
+class Default < Thor
+  include GemHelpers
+
+  desc "gemspec", "Regenerate webrat.gemspec"
+  def gemspec
+    File.open("webrat.gemspec", "w") do |file|
+      gemspec_ruby = generate_gemspec.to_ruby
+      gemspec_ruby = prettyify_array(gemspec_ruby, :files)
+      gemspec_ruby = prettyify_array(gemspec_ruby, :test_files)
+      gemspec_ruby = prettyify_array(gemspec_ruby, :extra_rdoc_files)
+
+      file.write gemspec_ruby
+    end
+
+    puts "Wrote gemspec to webrat.gemspec"
+    read_gemspec.validate
+  end
+
+  desc "build", "Build a webrat gem"
+  def build
+    sh "gem build webrat.gemspec"
+    FileUtils.mkdir_p "pkg"
+    FileUtils.mv read_gemspec.file_name, "pkg"
+  end
+
+  desc "install", "Install the latest built gem"
+  def install
+    sh "gem install --local pkg/#{read_gemspec.file_name}"
+  end
+
+  desc "release", "Release the current branch to GitHub and Gemcutter"
+  def release
+    gemspec
+    build
+    Release.new.tag
+    Release.new.gem
+  end
+end
+
+class Release < Thor
+  include GemHelpers
+
+  desc "tag", "Tag the gem on the origin server"
+  def tag
+    release_tag = "v#{read_gemspec.version}"
+    sh "git tag -a #{release_tag} -m 'Tagging #{release_tag}'"
+    sh "git push origin #{release_tag}"
+  end
+
+  desc "gem", "Push the gem to Gemcutter"
+  def gem
+    sh "gem push pkg/#{read_gemspec.file_name}"
+  end
+end

lib/webrat.rb

@@ -1,34 +1,18 @@
-require "rubygems"
+require "rack"
-
+require "nokogiri"
-$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__))) unless $LOAD_PATH.include?(File.expand_path(File.dirname(__FILE__)))
 
 module Webrat
+  VERSION = "0.7.2.pre"
+
+  autoload :MechanizeAdapter, "webrat/adapters/mechanize"
+  autoload :MerbAdapter, "webrat/adapters/merb"
+  autoload :RackAdapter, "webrat/adapters/rack"
+  autoload :RailsAdapter, "webrat/adapters/rails"
+  autoload :SinatraAdapter, "webrat/adapters/sinatra"
+
   # The common base class for all exceptions raised by Webrat.
   class WebratError < StandardError
   end
-
-  VERSION = '0.4.0'
-
-  def self.require_xml
-    gem "nokogiri", ">= 1.0.6"
-    
-    if on_java?
-      # We need Nokogiri's CSS to XPath support, even if using REXML and Hpricot for parsing and searching
-      require "nokogiri/css"
-      require "hpricot"
-      require "rexml/document"
-    else
-      require "nokogiri"
-      require "webrat/core/xml/nokogiri"
-    end
-  end
-  
-  def self.on_java?
-    RUBY_PLATFORM =~ /java/
-  end
-  
 end
 
-Webrat.require_xml
-
 require "webrat/core"

lib/webrat/adapters/mechanize.rb

@@ -1,32 +1,44 @@
 require "mechanize"
 
 module Webrat #:nodoc:
-  class MechanizeSession < Session #:nodoc:
+  class MechanizeAdapter #:nodoc:
-    
+    extend Forwardable
+
+    Mechanize = WWW::Mechanize if defined?(WWW::Mechanize)
+
     attr_accessor :response
     alias :page :response
-    
+
+    def initialize(*args)
+    end
+
     def request_page(url, http_method, data) #:nodoc:
       super(absolute_url(url), http_method, data)
     end
-    
+
     def get(url, data, headers_argument_not_used = nil)
       @response = mechanize.get(url, data)
     end
 
     def post(url, data, headers_argument_not_used = nil)
       post_data = data.inject({}) do |memo, param|
-        case param.last
+        case param
         when Hash
-          param.last.each {|attribute, value| memo["#{param.first}[#{attribute}]"] = value }
+          param.each {|attribute, value| memo[attribute] = value }
-        else
+          memo
-          memo[param.first] = param.last
+        when Array
+          case param.last
+          when Hash
+            param.last.each {|attribute, value| memo["#{param.first}[#{attribute}]"] = value }
+          else
+            memo[param.first] = param.last
+          end
+          memo
         end
-        memo
       end
       @response = mechanize.post(url, post_data)
     end
-    
+
     def response_body
       @response.content
     end
@@ -34,13 +46,21 @@ module Webrat #:nodoc:
     def response_code
       @response.code.to_i
     end
-    
+
+    def response_headers
+      @response.header
+    end
+
     def mechanize
-      @mechanize = WWW::Mechanize.new
+      @mechanize ||= begin
+        mechanize = Mechanize.new
+        mechanize.redirect_ok = false
+        mechanize
+      end
     end
 
     def_delegators :mechanize, :basic_auth
-    
+
     def absolute_url(url) #:nodoc:
       current_host, current_path = split_current_url
       if url =~ Regexp.new('^https?://')
@@ -53,13 +73,13 @@ module Webrat #:nodoc:
         url
       end
     end
-    
+
     private
       def split_current_url
         current_url =~ Regexp.new('^(https?://[^/]+)(/.*)?')
         [Regexp.last_match(1), Regexp.last_match(2)]
       end
-      
+
       def absolute_path(current_path, url)
         levels_up = url.split('/').find_all { |x| x == '..' }.size
         ancestor = if current_path.nil?
@@ -67,7 +87,7 @@ module Webrat #:nodoc:
         else
           current_path.split("/")[0..(-1 - levels_up)].join("/")
         end
-        descendent = url.split("/")[levels_up..-1]
+        descendent = url.split("/")[levels_up..-1].join
         "#{ancestor}/#{descendent}"
       end
   end

lib/webrat/adapters/merb.rb

@@ -0,0 +1,11 @@
+require "webrat/integrations/merb"
+
+module Webrat
+  class MerbAdapter < RackAdapter #:nodoc:
+    def initialize(context=nil)
+      app = context.respond_to?(:app) ?
+        context.app : Merb::Rack::Application.new
+      super(Rack::Test::Session.new(Rack::MockSession.new(app, "www.example.com")))
+    end
+  end
+end

lib/webrat/adapters/rack.rb

@@ -0,0 +1,29 @@
+require "rack/test"
+
+module Webrat
+  class RackAdapter
+    extend Forwardable
+
+    def_delegators :@session, :get, :post, :put, :delete
+
+    def initialize(session) #:nodoc:
+      @session = session
+    end
+
+    def response_body
+      response.body
+    end
+
+    def response_code
+      response.status
+    end
+
+    def response_headers
+      response.headers
+    end
+
+    def response
+      @session.last_response
+    end
+  end
+end

lib/webrat/adapters/rails.rb

@@ -1,34 +1,14 @@
-require "webrat"
+require "webrat/integrations/rails"
-
-require "action_controller"
-require "action_controller/integration"
 require "action_controller/record_identifier"
 
 module Webrat
-  class RailsSession < Session #:nodoc:
+  class RailsAdapter #:nodoc:
     include ActionController::RecordIdentifier
-    
-    # The Rails version of within supports passing in a model and Webrat
-    # will apply a scope based on Rails' dom_id for that model.
-    #
-    # Example:
-    #   within User.last do
-    #     click_link "Delete"
-    #   end
-    def within(selector_or_object, &block)
-      if selector_or_object.is_a?(String)
-        super
-      else
-        super('#' + dom_id(selector_or_object), &block)
-      end
-    end
-    
-    def doc_root
-      File.expand_path(File.join(RAILS_ROOT, 'public'))
-    end
 
-    def saved_page_dir
+    attr_reader :integration_session
-      File.expand_path(File.join(RAILS_ROOT, "tmp"))
+
+    def initialize(session)
+      @integration_session = session
     end
 
     def get(url, data, headers = nil)
@@ -55,16 +35,16 @@ module Webrat
       response.code.to_i
     end
 
+    def response_headers
+      response.headers
+    end
+
     def xml_content_type?
       response.headers["Content-Type"].to_s =~ /xml/
     end
 
   protected
 
-    def integration_session
-      @context
-    end
-
     def do_request(http_method, url, data, headers) #:nodoc:
       update_protocol(url)
       integration_session.send(http_method, normalize_url(url), data, headers)
@@ -73,11 +53,13 @@ module Webrat
     # remove protocol, host and anchor
     def normalize_url(href) #:nodoc:
       uri = URI.parse(href)
-      normalized_url = uri.path
+      normalized_url = []
-      if uri.query
+      normalized_url << "#{uri.scheme}://" if uri.scheme
-        normalized_url += "?" + uri.query
+      normalized_url << uri.host if uri.host
-      end
+      normalized_url << ":#{uri.port}" if uri.port && ![80,443].include?(uri.port)
-      normalized_url
+      normalized_url << uri.path if uri.path
+      normalized_url << "?#{uri.query}" if uri.query
+      normalized_url.join
     end
 
     def update_protocol(href) #:nodoc:
@@ -91,13 +73,5 @@ module Webrat
     def response #:nodoc:
       integration_session.response
     end
-
-  end
-end
-
-module ActionController #:nodoc:
-  IntegrationTest.class_eval do
-    include Webrat::Methods
-    include Webrat::Matchers
   end
 end

lib/webrat/adapters/sinatra.rb

@@ -0,0 +1,9 @@
+module Webrat
+  class SinatraAdapter < RackAdapter
+    def initialize(context)
+      app = context.respond_to?(:app) ? context.app : Sinatra::Application
+
+      super(Rack::Test::Session.new(Rack::MockSession.new(app, "www.example.com")))
+    end
+  end
+end

lib/webrat/core.rb

@@ -1,6 +1,5 @@
 require "webrat/core/configuration"
 require "webrat/core/xml"
-require "webrat/core/xml/nokogiri"
 require "webrat/core/logging"
 require "webrat/core/elements/form"
 require "webrat/core/scope"

lib/webrat/core/configuration.rb

@@ -1,4 +1,5 @@
 require "webrat/core_extensions/deprecate"
+require "pathname"
 
 module Webrat
 
@@ -16,26 +17,38 @@ module Webrat
   # Webrat can be configured using the Webrat.configure method. For example:
   #
   #   Webrat.configure do |config|
-  #     config.parse_with_nokogiri = false
+  #     config.mode = :sinatra
   #   end
   class Configuration
 
-    # Should XHTML be parsed with Nokogiri? Defaults to true, except on JRuby. When false, Hpricot and REXML are used
-    attr_writer :parse_with_nokogiri
-
     # Webrat's mode, set automatically when requiring webrat/rails, webrat/merb, etc.
     attr_reader :mode # :nodoc:
 
     # Save and open pages with error status codes (500-599) in a browser? Defualts to true.
     attr_writer :open_error_files
 
-    # Which rails environment should the selenium tests be run in? Defaults to selenium.
+    # Save and open page storage directory, defaults to "tmp" under current directory if exists, otherwise current directory
+    attr_accessor :saved_pages_dir
+
+    # Which rails environment should the selenium tests be run in? Defaults to test.
     attr_accessor :application_environment
     webrat_deprecate :selenium_environment, :application_environment
+    webrat_deprecate :selenium_environment=, :application_environment=
 
     # Which port is the application running on for selenium testing? Defaults to 3001.
     attr_accessor :application_port
     webrat_deprecate :selenium_port, :application_port
+    webrat_deprecate :selenium_port=, :application_port=
+
+    # Which port should selenium use to access the application. Defaults to application_port
+    attr_writer :application_port_for_selenium
+    
+    def application_port_for_selenium
+      @application_port_for_selenium || self.application_port
+    end
+
+    # Which underlying app framework we're testing with selenium
+    attr_accessor :application_framework
 
     # Which server the application is running on for selenium testing? Defaults to localhost
     attr_accessor :application_address
@@ -49,20 +62,36 @@ module Webrat
     # Set the key that Selenium uses to determine the browser running. Default *firefox
     attr_accessor :selenium_browser_key
 
+    # Set the timeout for waiting for the browser process to start
+    attr_accessor :selenium_browser_startup_timeout
+
+    # Set the firefox profile for selenium to use
+    attr_accessor :selenium_firefox_profile
+
+    # How many redirects to the same URL should be halted as an infinite redirect
+    # loop? Defaults to 10
+    attr_accessor :infinite_redirect_limit
+
+    # Print out the full HTML on wait failure
+    # Defaults to false
+    attr_accessor :selenium_verbose_output
+
     def initialize # :nodoc:
       self.open_error_files = true
-      self.parse_with_nokogiri = !Webrat.on_java?
+      self.application_environment = :test
-      self.application_environment = :selenium
       self.application_port = 3001
       self.application_address = 'localhost'
+      self.application_framework = :rails
       self.selenium_server_port = 4444
+      self.infinite_redirect_limit = 10
       self.selenium_browser_key = '*firefox'
-    end
+      self.selenium_browser_startup_timeout = 5
+      self.selenium_verbose_output = false
 
-    def parse_with_nokogiri? #:nodoc:
+      tmp_dir = Pathname.new(Dir.pwd).join("tmp")
-      @parse_with_nokogiri ? true : false
+      self.saved_pages_dir = tmp_dir.exist? ? tmp_dir : Dir.pwd
     end
-
+    
     def open_error_files? #:nodoc:
       @open_error_files ? true : false
     end
@@ -71,17 +100,15 @@ module Webrat
     # :rails, :selenium, :rack, :sinatra, :mechanize, :merb
     def mode=(mode)
       @mode = mode.to_sym
-      
+
-      # This is a temporary hack to support backwards compatibility
+      begin
-      # with Merb 1.0.8 until it's updated to use the new Webrat.configure
+        require("webrat/integrations/#{mode}")
-      # syntax
+      rescue LoadError
-      if @mode == :merb
+        # Only some modes have integration code that needs to
-        require("webrat/merb_session")
+        # be loaded, so this is OK
-      else
-        require("webrat/#{mode}")
       end
     end
 
   end
 
-end
+end

lib/webrat/core/elements/area.rb

@@ -2,21 +2,21 @@ require "webrat/core/elements/element"
 
 module Webrat
   class Area < Element #:nodoc:
-    
+
     def self.xpath_search
-      ".//area"
+      [".//area"]
     end
-    
+
     def click(method = nil, options = {})
       @session.request_page(absolute_href, :get, {})
     end
-    
+
   protected
-    
+
     def href
-      Webrat::XML.attribute(@element, "href")
+      @element["href"]
     end
-   
+
     def absolute_href
       if href =~ /^\?/
         "#{@session.current_url}#{href}"
@@ -26,6 +26,6 @@ module Webrat
         href
       end
     end
-    
+
   end
-end
+end

lib/webrat/core/elements/element.rb

@@ -1,33 +1,33 @@
 module Webrat
-  
+
   class Element # :nodoc:
-    
+
     def self.load_all(session, dom)
-      Webrat::XML.xpath_search(dom, xpath_search).map do |element| 
+      dom.xpath(*xpath_search).map do |element|
         load(session, element)
       end
     end
-    
+
     def self.load(session, element)
       return nil if element.nil?
-      session.elements[Webrat::XML.xpath_to(element)] ||= self.new(session, element)
+      session.elements[element.path] ||= self.new(session, element)
     end
-    
+
     attr_reader :element
-    
+
     def initialize(session, element)
       @session  = session
       @element  = element
     end
-    
+
     def path
-      Webrat::XML.xpath_to(@element)
+      @element.path
     end
-    
+
     def inspect
       "#<#{self.class} @element=#{element.inspect}>"
     end
-    
+
   end
-  
+
-end
+end

lib/webrat/core/elements/field.rb

@@ -1,6 +1,7 @@
 require "cgi"
+require "digest/md5"
 require "webrat/core_extensions/blank"
-require "webrat/core_extensions/nil_to_param"
+require "webrat/core_extensions/nil_to_query_string"
 
 require "webrat/core/elements/element"
 
@@ -8,36 +9,45 @@ module Webrat
   # Raised when Webrat is asked to manipulate a disabled form field
   class DisabledFieldError < WebratError
   end
-  
+
   class Field < Element #:nodoc:
     attr_reader :value
-    
+
     def self.xpath_search
-      [".//button", ".//input", ".//textarea", ".//select"]
+      ".//button|.//input|.//textarea|.//select"
     end
-    
+
+    def self.xpath_search_excluding_hidden
+      [".//button", ".//input[ @type != 'hidden']", ".//textarea", ".//select"]
+    end
+
     def self.field_classes
       @field_classes || []
     end
-    
+
     def self.inherited(klass)
       @field_classes ||= []
       @field_classes << klass
       # raise args.inspect
     end
-    
+
     def self.load(session, element)
       return nil if element.nil?
-      session.elements[Webrat::XML.xpath_to(element)] ||= field_class(element).new(session, element)
+      session.elements[element.path] ||= field_class(element).new(session, element)
     end
-    
+
     def self.field_class(element)
       case element.name
       when "button"   then ButtonField
-      when "select"   then SelectField
+      when "select"
+        if element.attributes["multiple"].nil?
+          SelectField
+        else
+          MultipleSelectField
+        end
       when "textarea" then TextareaField
       else
-        case Webrat::XML.attribute(element, "type")
+        case element["type"]
         when "checkbox" then CheckboxField
         when "hidden"   then HiddenField
         when "radio"    then RadioField
@@ -45,12 +55,13 @@ module Webrat
         when "file"     then FileField
         when "reset"    then ResetField
         when "submit"   then ButtonField
+        when "button"   then ButtonField
         when "image"    then ButtonField
         else  TextField
         end
       end
     end
-    
+
     def initialize(*args)
       super
       @value = default_value
@@ -60,82 +71,86 @@ module Webrat
       return nil if labels.empty?
       labels.first.text
     end
-    
+
     def id
-      Webrat::XML.attribute(@element, "id")
+      @element["id"]
     end
 
     def disabled?
-      @element.attributes.has_key?("disabled") && Webrat::XML.attribute(@element, "disabled") != 'false'
+      @element.attributes.has_key?("disabled") && @element["disabled"] != 'false'
     end
-    
+
     def raise_error_if_disabled
       return unless disabled?
       raise DisabledFieldError.new("Cannot interact with disabled form element (#{self})")
     end
-        
+
-    def to_param
+    def to_query_string
       return nil if disabled?
-      
+
-      case Webrat.configuration.mode
+      query_string = case Webrat.configuration.mode
-      when :rails
+      when :rails, :merb, :rack, :sinatra
-        rails_request_parser.parse_query_parameters("#{name}=#{escaped_value}")
+        build_query_string
-      when :merb
+      when :mechanize
-        ::Merb::Parse.query("#{name}=#{escaped_value}")
+        build_query_string(false)
-      else
-        { name => escaped_value }
       end
+
+      query_string
     end
-    
+
     def set(value)
       @value = value
     end
-    
+
     def unset
       @value = default_value
     end
-    
+
   protected
-  
+
-    def rails_request_parser
-      if defined?(ActionController::RequestParser) # For Rails > 2.2
-        ActionController::RequestParser
-      else
-        ActionController::AbstractRequest
-      end
-    end
-  
     def form
       Form.load(@session, form_element)
     end
-    
+
     def form_element
       parent = @element.parent
-      
+
       while parent.respond_to?(:parent)
         return parent if parent.name == 'form'
         parent = parent.parent
       end
     end
-    
+
     def name
-      Webrat::XML.attribute(@element, "name")
+      @element["name"]
     end
-    
+
+    def build_query_string(escape_value=true)
+      if @value.is_a?(Array)
+        @value.collect {|value| "#{name}=#{ escape_value ? escape(value) : value }" }.join("&")
+      else
+        "#{name}=#{ escape_value ? escape(value) : value }"
+      end
+    end
+
+    def escape(value)
+      CGI.escape(value.to_s)
+    end
+
     def escaped_value
       CGI.escape(@value.to_s)
     end
-    
+
     def labels
       @labels ||= label_elements.map do |element|
         Label.load(@session, element)
       end
     end
-    
+
     def label_elements
       return @label_elements unless @label_elements.nil?
       @label_elements = []
-    
+
       parent = @element.parent
       while parent.respond_to?(:parent)
         if parent.name == 'label'
@@ -144,42 +159,26 @@ module Webrat
         end
         parent = parent.parent
       end
-    
+
       unless id.blank?
-        @label_elements += Webrat::XML.xpath_search(form.element, ".//label[@for = '#{id}']")
+        @label_elements += form.element.xpath(".//label[@for = '#{id}']")
       end
-    
+
       @label_elements
     end
-    
+
     def default_value
-      Webrat::XML.attribute(@element, "value")
+      @element["value"]
-    end
-    
-    def replace_param_value(params, oval, nval)
-      output = Hash.new
-      params.each do |key, value|
-        case value
-        when Hash
-          value = replace_param_value(value, oval, nval)
-        when Array
-          value = value.map { |o| o == oval ? nval : oval }
-        when oval
-          value = nval
-        end
-        output[key] = value
-      end
-      output
     end
   end
-  
+
   class ButtonField < Field #:nodoc:
 
     def self.xpath_search
-      [".//button", ".//input[@type = 'submit']", ".//input[@type = 'image']"]
+      [".//button", ".//input[@type = 'submit']", ".//input[@type = 'button']", ".//input[@type = 'image']"]
     end
-    
+
-    def to_param
+    def to_query_string
       return nil if @value.nil?
       super
     end
@@ -190,7 +189,7 @@ module Webrat
 
     def click
       raise_error_if_disabled
-      set(Webrat::XML.attribute(@element, "value")) unless Webrat::XML.attribute(@element, "name").blank?
+      set(@element["value"]) unless @element["name"].blank?
       form.submit
     end
 
@@ -201,14 +200,14 @@ module Webrat
     def self.xpath_search
       ".//input[@type = 'hidden']"
     end
-    
+
-    def to_param
+    def to_query_string
       if collection_name?
         super
       else
         checkbox_with_same_name = form.field_named(name, CheckboxField)
 
-        if checkbox_with_same_name.to_param.blank?
+        if checkbox_with_same_name.to_query_string.blank?
           super
         else
           nil
@@ -229,19 +228,19 @@ module Webrat
     def self.xpath_search
       ".//input[@type = 'checkbox']"
     end
-    
+
-    def to_param
+    def to_query_string
       return nil if @value.nil?
       super
     end
 
     def check
       raise_error_if_disabled
-      set(Webrat::XML.attribute(@element, "value") || "on")
+      set(@element["value"] || "on")
     end
-    
+
     def checked?
-      Webrat::XML.attribute(@element, "checked") == "checked"
+      @element["checked"] == "checked"
     end
 
     def uncheck
@@ -252,8 +251,8 @@ module Webrat
   protected
 
     def default_value
-      if Webrat::XML.attribute(@element, "checked") == "checked"
+      if @element["checked"] == "checked"
-        Webrat::XML.attribute(@element, "value") || "on"
+        @element["value"] || "on"
       else
         nil
       end
@@ -262,11 +261,11 @@ module Webrat
   end
 
   class PasswordField < Field #:nodoc:
-    
+
     def self.xpath_search
       ".//input[@type = 'password']"
     end
-    
+
   end
 
   class RadioField < Field #:nodoc:
@@ -274,34 +273,34 @@ module Webrat
     def self.xpath_search
       ".//input[@type = 'radio']"
     end
-    
+
-    def to_param
+    def to_query_string
       return nil if @value.nil?
       super
     end
-    
+
     def choose
       raise_error_if_disabled
       other_options.each do |option|
         option.set(nil)
       end
-      
+
-      set(Webrat::XML.attribute(@element, "value") || "on")
+      set(@element["value"] || "on")
     end
-    
+
     def checked?
-      Webrat::XML.attribute(@element, "checked") == "checked"
+      @element["checked"] == "checked"
     end
-    
+
   protected
 
     def other_options
       form.fields.select { |f| f.name == name }
     end
-    
+
     def default_value
-      if Webrat::XML.attribute(@element, "checked") == "checked"
+      if @element["checked"] == "checked"
-        Webrat::XML.attribute(@element, "value") || "on"
+        @element["value"] || "on"
       else
         nil
       end
@@ -314,43 +313,50 @@ module Webrat
     def self.xpath_search
       ".//textarea"
     end
-    
+
   protected
 
     def default_value
-      Webrat::XML.inner_html(@element)
+      @element.inner_html
     end
 
   end
-  
+
   class FileField < Field #:nodoc:
-    
+
     def self.xpath_search
       ".//input[@type = 'file']"
     end
-    
+
     attr_accessor :content_type
 
     def set(value, content_type = nil)
+      @original_value = @value
+      @content_type ||= content_type
       super(value)
-      @content_type = content_type
     end
 
-    def to_param
+    def digest_value
-      if @value.nil?
+      @value ? Digest::MD5.hexdigest(self.object_id.to_s) : ""
-        super
-      else
-        replace_param_value(super, @value, test_uploaded_file)
-      end
     end
-    
+
-  protected
+    def to_query_string
-  
+      @value.nil? ? set("") : set(digest_value)
+      super
+    end
+
     def test_uploaded_file
-      if content_type
+      return "" if @original_value.blank?
-        ActionController::TestUploadedFile.new(@value, content_type)
+
-      else
+      case Webrat.configuration.mode
-        ActionController::TestUploadedFile.new(@value)
+      when :rails
+        if content_type
+          ActionController::TestUploadedFile.new(@original_value, content_type)
+        else
+          ActionController::TestUploadedFile.new(@original_value)
+        end
+      when :rack, :merb
+        Rack::Test::UploadedFile.new(@original_value, content_type)
       end
     end
 
@@ -364,31 +370,69 @@ module Webrat
 
   class ResetField < Field #:nodoc:
     def self.xpath_search
-      ".//input[@type = 'reset']"
+      [".//input[@type = 'reset']"]
     end
   end
 
   class SelectField < Field #:nodoc:
 
     def self.xpath_search
-      ".//select"
+      [".//select[not(@multiple)]"]
     end
 
     def options
       @options ||= SelectOption.load_all(@session, @element)
     end
-    
+
+    def unset(value)
+      @value = nil
+    end
+
   protected
 
     def default_value
-      selected_options = Webrat::XML.xpath_search(@element, ".//option[@selected = 'selected']")
+      selected_options = @element.xpath(".//option[@selected = 'selected']")
-      selected_options = Webrat::XML.xpath_search(@element, ".//option[position() = 1]") if selected_options.empty? 
+      selected_options = @element.xpath(".//option[position() = 1]") if selected_options.empty?
-      
+
       selected_options.map do |option|
         return "" if option.nil?
-        Webrat::XML.attribute(option, "value") || Webrat::XML.inner_html(option)
+        option["value"] || option.inner_html
-      end
+      end.uniq.first
     end
 
   end
+
+  class MultipleSelectField < Field #:nodoc:
+
+    def self.xpath_search
+      [".//select[@multiple='multiple']"]
+    end
+
+    def options
+      @options ||= SelectOption.load_all(@session, @element)
+    end
+
+    def set(value)
+      @value << value
+    end
+
+    def unset(value)
+      @value.delete(value)
+    end
+
+  protected
+
+    # Overwrite SelectField definition because we don't want to select the first option
+    # (mutliples don't select the first option unlike their non multiple versions)
+    def default_value
+      selected_options = @element.xpath(".//option[@selected = 'selected']")
+
+      selected_options.map do |option|
+        return "" if option.nil?
+        option["value"] || option.inner_html
+      end.uniq
+    end
+
+  end
+
 end

lib/webrat/core/elements/form.rb

@@ -7,29 +7,29 @@ require "webrat/core/locators/field_named_locator"
 module Webrat
   class Form < Element #:nodoc:
     attr_reader :element
-    
+
     def self.xpath_search
-      ".//form"
+      [".//form"]
     end
 
     def fields
       @fields ||= Field.load_all(@session, @element)
     end
-    
+
     def submit
       @session.request_page(form_action, form_method, params)
     end
-    
+
     def field_named(name, *field_types)
       Webrat::Locators::FieldNamedLocator.new(@session, dom, name, *field_types).locate
     end
-    
+
   protected
-  
+
     def dom
-      Webrat::XML.xpath_at(@session.dom, path)
+      @session.dom.xpath(path).first
     end
-    
+
     def fields_by_type(field_types)
       if field_types.any?
         fields.select { |f| field_types.include?(f.class) }
@@ -37,67 +37,91 @@ module Webrat
         fields
       end
     end
-    
+
+    # iterate over all form fields to build a request querystring to get params from it,
+    # for file_field we made a work around to pass a digest as value to later replace it
+    # in params hash with the real file.
     def params
-      all_params = {}
+      query_string = []
-      
+      replaces = {}
+
       fields.each do |field|
-        next if field.to_param.nil?
+        next if field.to_query_string.nil?
-        merge(all_params, field.to_param)
+        replaces.merge!({field.digest_value => field.test_uploaded_file}) if field.is_a?(FileField)
+        query_string << field.to_query_string
       end
-      
+
-      all_params
+      query_params = self.class.query_string_to_params(query_string.join('&'))
+
+      query_params = self.class.replace_params_values(query_params, replaces)
+
+      self.class.unescape_params(query_params)
     end
-    
+
     def form_method
-      Webrat::XML.attribute(@element, "method").blank? ? :get : Webrat::XML.attribute(@element, "method").downcase
+      @element["method"].blank? ? :get : @element["method"].downcase
     end
-    
+
     def form_action
-      Webrat::XML.attribute(@element, "action").blank? ? @session.current_url : Webrat::XML.attribute(@element, "action")
+      @element["action"].blank? ? @session.current_url : @element["action"]
     end
-    
+
-    def merge(all_params, new_param)
+    def self.replace_param_value(params, oval, nval)
-      new_param.each do |key, value|
+      output = Hash.new
-        case all_params[key]
+      params.each do |key, value|
-        when *hash_classes
+        case value
-          merge_hash_values(all_params[key], value)
+        when Hash
+          value = replace_param_value(value, oval, nval)
         when Array
-          all_params[key] += value
+          value = value.map { |o| o == oval ? nval : ( o.is_a?(Hash) ? replace_param_value(o, oval, nval) : o) }
-        else
+        when oval
-          all_params[key] = value
+          value = nval
         end
+        output[key] = value
+      end
+      output
+    end
+
+    def self.replace_params_values(params, values)
+      values.each do |key, value|
+        params = replace_param_value(params, key, value)
+      end
+      params
+    end
+
+    def self.unescape_params(params)
+      case params.class.name
+      when 'Hash', 'Mash'
+        params.each { |key,value| params[key] = unescape_params(value) }
+        params
+      when 'Array'
+        params.collect { |value| unescape_params(value) }
+      else
+        params.is_a?(String) ? CGI.unescapeHTML(params) : params
       end
     end
-  
+
-    def merge_hash_values(a, b) # :nodoc:
+    def self.query_string_to_params(query_string)
-      a.keys.each do |k|
-        if b.has_key?(k)
-          case [a[k], b[k]].map{|value| value.class}
-          when *hash_classes.zip(hash_classes)
-            a[k] = merge_hash_values(a[k], b[k])
-            b.delete(k)
-          when [Array, Array]
-            a[k] += b[k]
-            b.delete(k)
-          end
-        end
-      end
-      a.merge!(b)
-    end
-    
-    def hash_classes
-      klasses = [Hash]
-      
       case Webrat.configuration.mode
       when :rails
-        klasses << HashWithIndifferentAccess
+        parse_rails_request_params(query_string)
       when :merb
-        klasses << Mash
+        ::Merb::Parse.query(query_string)
+      when :rack, :sinatra
+        Rack::Utils.parse_nested_query(query_string)
+      else
+        Hash[query_string.split('&').map {|query| [ query.split('=').first, query.split('=').last ]}]
+      end
+    end
+
+    def self.parse_rails_request_params(query_string)
+      if defined?(ActionController::AbstractRequest)
+        ActionController::AbstractRequest.parse_query_parameters(query_string)
+      elsif defined?(ActionController::UrlEncodedPairParser)
+        ActionController::UrlEncodedPairParser.parse_query_parameters(query_string)
+      else
+        Rack::Utils.parse_nested_query(query_string)
       end
-      
-      klasses
     end
-    
   end
 end

lib/webrat/core/elements/label.rb

@@ -2,30 +2,30 @@ require "webrat/core/elements/element"
 
 module Webrat
   class Label < Element #:nodoc:
-    
+
     attr_reader :element
-    
+
     def self.xpath_search
-      ".//label"
+      [".//label"]
     end
 
     def for_id
-      Webrat::XML.attribute(@element, "for")
+      @element["for"]
     end
-    
+
     def field
       Field.load(@session, field_element)
     end
-    
+
   protected
-  
+
     def field_element
       if for_id.blank?
-        Webrat::XML.xpath_at(@element, *Field.xpath_search)
+        @element.xpath(*Field.xpath_search_excluding_hidden).first
       else
-        Webrat::XML.css_search(@session.dom, "#" + for_id).first
+        @session.current_dom.css("#" + for_id).first
       end
     end
-    
+
   end
 end

lib/webrat/core/elements/link.rb

@@ -1,43 +1,44 @@
-require "webrat/core_extensions/blank"
+require "English"
 
+require "webrat/core_extensions/blank"
 require "webrat/core/elements/element"
 
 module Webrat
   class Link < Element #:nodoc:
-    
+
     def self.xpath_search
-      ".//a[@href]"
+      [".//a[@href]"]
     end
-    
+
     def click(options = {})
       method = options[:method] || http_method
       return if href =~ /^#/ && method == :get
-      
+
       options[:javascript] = true if options[:javascript].nil?
-      
+
       if options[:javascript]
         @session.request_page(absolute_href, method, data)
       else
         @session.request_page(absolute_href, :get, {})
       end
     end
-    
+
   protected
-  
+
     def id
-      Webrat::XML.attribute(@element, "id")
+      @element["id"]
     end
-  
+
     def data
       authenticity_token.blank? ? {} : {"authenticity_token" => authenticity_token}
     end
 
     def title
-      Webrat::XML.attribute(@element, "title")
+      @element["title"]
     end
 
     def href
-      Webrat::XML.attribute(@element, "href")
+      @element["href"]
     end
 
     def absolute_href
@@ -49,17 +50,17 @@ module Webrat
         href
       end
     end
-    
+
     def authenticity_token
       return unless onclick && onclick.include?("s.setAttribute('name', 'authenticity_token');") &&
-        onclick =~ /s\.setAttribute\('value', '([a-f0-9]{40})'\);/
+        ( onclick =~ /s\.setAttribute\('value', '([a-f0-9]{40})'\);/ || onclick =~ /s\.setAttribute\('value', '(.{44})'\);/ )
       $LAST_MATCH_INFO.captures.first
     end
-    
+
     def onclick
-      Webrat::XML.attribute(@element, "onclick")
+      @element["onclick"]
     end
-    
+
     def http_method
       if !onclick.blank? && onclick.include?("f.submit()")
         http_method_from_js_form
@@ -81,10 +82,12 @@ module Webrat
         :delete
       elsif onclick.include?("m.setAttribute('value', 'put')")
         :put
+      elsif onclick.include?("m.setAttribute('value', 'post')")
+        :post
       else
         raise Webrat::WebratError.new("No HTTP method for _method param in #{onclick.inspect}")
       end
     end
-    
+
   end
 end

lib/webrat/core/elements/select_option.rb

@@ -2,34 +2,47 @@ require "webrat/core/elements/element"
 
 module Webrat
   class SelectOption < Element #:nodoc:
-    
+
     def self.xpath_search
-      ".//option"
+      [".//option"]
     end
-    
+
     def choose
       select.raise_error_if_disabled
       select.set(value)
     end
-    
+
+    def unchoose
+      select.raise_error_if_disabled
+      select.unset(value)
+    end
+
+    def inner_text
+      @element.inner_text
+    end
+
   protected
-    
+
     def select
       SelectField.load(@session, select_element)
     end
-    
+
     def select_element
       parent = @element.parent
-      
+
       while parent.respond_to?(:parent)
         return parent if parent.name == 'select'
         parent = parent.parent
       end
     end
-    
+
     def value
-      Webrat::XML.attribute(@element, "value") || Webrat::XML.inner_html(@element)
+      @element["value"] || @element.inner_html
     end
-    
+
+    def label
+      @element.inner_html
+    end
+
   end
-end
+end

lib/webrat/core/locators.rb

@@ -11,10 +11,10 @@ require "webrat/core/locators/form_locator"
 
 module Webrat
   module Locators
-    
+
     def field_by_xpath(xpath)
-      Field.load(@session, Webrat::XML.xpath_at(dom, xpath))
+      Field.load(@session, dom.xpath(xpath).first)
     end
-    
+
   end
 end

lib/webrat/core/locators/area_locator.rb

@@ -2,37 +2,37 @@ require "webrat/core/locators/locator"
 
 module Webrat
   module Locators
-    
+
     class AreaLocator < Locator # :nodoc:
-      
+
       def locate
         Area.load(@session, area_element)
       end
-  
+
       def area_element
         area_elements.detect do |area_element|
-          Webrat::XML.attribute(area_element, "title") =~ matcher ||
+          area_element["title"] =~ matcher ||
-          Webrat::XML.attribute(area_element, "id") =~ matcher
+          area_element["id"] =~ matcher
         end
       end
-  
+
       def matcher
         /#{Regexp.escape(@value.to_s)}/i
       end
-  
+
       def area_elements
-        Webrat::XML.xpath_search(@dom, Area.xpath_search)
+        @dom.xpath(*Area.xpath_search)
       end
-  
+
       def error_message
         "Could not find area with name #{@value}"
       end
-      
+
     end
-    
+
     def find_area(id_or_title) #:nodoc:
       AreaLocator.new(@session, dom, id_or_title).locate!
     end
-    
+
   end
-end
+end

lib/webrat/core/locators/button_locator.rb

@@ -2,13 +2,13 @@ require "webrat/core/locators/locator"
 
 module Webrat
   module Locators
-    
+
     class ButtonLocator < Locator # :nodoc:
-  
+
       def locate
         ButtonField.load(@session, button_element)
       end
-  
+
       def button_element
         button_elements.detect do |element|
           @value.nil?             ||
@@ -18,37 +18,37 @@ module Webrat
           matches_alt?(element)
         end
       end
-  
+
       def matches_id?(element)
-        (@value.is_a?(Regexp) && Webrat::XML.attribute(element, "id") =~ @value) ||
+        (@value.is_a?(Regexp) && element["id"] =~ @value) ||
-        (!@value.is_a?(Regexp) && Webrat::XML.attribute(element, "id") == @value.to_s)
+        (!@value.is_a?(Regexp) && element["id"] == @value.to_s)
       end
-  
+
       def matches_value?(element)
-        Webrat::XML.attribute(element, "value") =~ /^\W*#{Regexp.escape(@value.to_s)}/i
+        element["value"] =~ /^\W*#{Regexp.escape(@value.to_s)}/i
       end
-  
+
       def matches_html?(element)
-        Webrat::XML.inner_html(element) =~ /#{Regexp.escape(@value.to_s)}/i
+        element.inner_html =~ /#{Regexp.escape(@value.to_s)}/i
       end
-  
+
       def matches_alt?(element)
-        Webrat::XML.attribute(element, "alt") =~ /^\W*#{Regexp.escape(@value.to_s)}/i
+        element["alt"] =~ /^\W*#{Regexp.escape(@value.to_s)}/i
       end
-  
+
       def button_elements
-        Webrat::XML.xpath_search(@dom, *ButtonField.xpath_search)
+        @dom.xpath(*ButtonField.xpath_search)
       end
-  
+
       def error_message
         "Could not find button #{@value.inspect}"
       end
-      
+
     end
-    
+
     def find_button(value) #:nodoc:
       ButtonLocator.new(@session, dom, value).locate!
     end
-    
+
   end
-end
+end

lib/webrat/core/locators/field_by_id_locator.rb

@@ -2,36 +2,36 @@ require "webrat/core/locators/locator"
 
 module Webrat
   module Locators
-    
+
     class FieldByIdLocator < Locator # :nodoc:
-  
+
       def locate
         Field.load(@session, field_element)
       end
-  
+
       def field_element
         field_elements.detect do |field_element|
           if @value.is_a?(Regexp)
-            Webrat::XML.attribute(field_element, "id") =~ @value
+            field_element["id"] =~ @value
           else
-            Webrat::XML.attribute(field_element, "id") == @value.to_s
+            field_element["id"] == @value.to_s
           end
         end
       end
-  
+
       def field_elements
-        Webrat::XML.xpath_search(@dom, *Field.xpath_search)
+        @dom.xpath(*Field.xpath_search)
       end
 
       def error_message
         "Could not find field with id #{@value.inspect}"
       end
-      
+
     end
-    
+
     def field_with_id(id, *field_types)
       FieldByIdLocator.new(@session, dom, id, *field_types).locate!
     end
-    
+
   end
-end
+end

lib/webrat/core/locators/field_labeled_locator.rb

@@ -3,13 +3,13 @@ require "webrat/core/locators/locator"
 
 module Webrat
   module Locators
-    
+
     class FieldLabeledLocator < Locator # :nodoc:
-  
+
       def locate
         matching_labels.any? && matching_labels.detect_mapped { |label| label.field }
       end
-      
+
       def matching_labels
         matching_label_elements.sort_by do |label_element|
           text(label_element).length
@@ -17,31 +17,31 @@ module Webrat
           Label.load(@session, label_element)
         end
       end
-      
+
       def matching_label_elements
         label_elements.select do |label_element|
-          text(label_element) =~ /^\W*#{Regexp.escape(@value.to_s)}\b/i
+          text(label_element) =~ /^\W*#{Regexp.escape(@value.to_s)}(\b|\Z)/i
         end
       end
-      
+
       def label_elements
-        Webrat::XML.xpath_search(@dom, Label.xpath_search)
+        @dom.xpath(*Label.xpath_search)
       end
-  
+
       def error_message
         "Could not find field labeled #{@value.inspect}"
       end
-      
+
       def text(element)
-        str = Webrat::XML.all_inner_text(element)
+        str = element.inner_text
         str.gsub!("\n","")
         str.strip!
         str.squeeze!(" ")
         str
       end
-      
+
     end
-    
+
     # Locates a form field based on a <tt>label</tt> element in the HTML source.
     # This can be useful in order to verify that a field is pre-filled with the
     # correct value.
@@ -51,6 +51,6 @@ module Webrat
     def field_labeled(label, *field_types)
       FieldLabeledLocator.new(@session, dom, label, *field_types).locate!
     end
-    
+
   end
 end

lib/webrat/core/locators/field_locator.rb

@@ -2,24 +2,24 @@ require "webrat/core/locators/locator"
 
 module Webrat
   module Locators
-    
+
     class FieldLocator < Locator # :nodoc:
-  
+
       def locate
         FieldByIdLocator.new(@session, @dom, @value).locate   ||
         FieldNamedLocator.new(@session, @dom, @value, *@field_types).locate   ||
         FieldLabeledLocator.new(@session, @dom, @value, *@field_types).locate
       end
-      
+
       def error_message
         "Could not find field: #{@value.inspect}"
       end
-      
+
     end
-    
+
     def field(*args) # :nodoc:
       FieldLocator.new(@session, dom, *args).locate!
     end
-    
+
   end
-end
+end

lib/webrat/core/locators/field_named_locator.rb

@@ -2,40 +2,40 @@ require "webrat/core/locators/locator"
 
 module Webrat
   module Locators
-    
+
     class FieldNamedLocator < Locator # :nodoc:
-  
+
       def locate
         Field.load(@session, field_element)
       end
-  
+
       def field_element
         field_elements.detect do |field_element|
-          Webrat::XML.attribute(field_element, "name") == @value.to_s
+          field_element["name"] == @value.to_s
         end
       end
-  
+
       def field_elements
-        Webrat::XML.xpath_search(@dom, *xpath_searches)
+        @dom.xpath(*xpath_searches)
       end
-  
+
       def xpath_searches
         if @field_types.any?
           @field_types.map { |field_type| field_type.xpath_search }.flatten
         else
-          Array(Field.xpath_search)
+          Field.xpath_search
         end
       end
-  
+
       def error_message
         "Could not find field named #{@value.inspect}"
       end
-      
+
     end
-    
+
     def field_named(name, *field_types)
       FieldNamedLocator.new(@session, dom, name, *field_types).locate!
     end
-    
+
   end
-end
+end

lib/webrat/core/locators/form_locator.rb

@@ -2,18 +2,18 @@ require "webrat/core/locators/locator"
 
 module Webrat
   module Locators
-    
+
     class FormLocator < Locator # :nodoc:
-  
+
       def locate
         Form.load(@session, form_element)
       end
-      
+
       def form_element
-        Webrat::XML.css_at(@dom, "#" + @value)
+        @dom.css("#" + @value).first || @dom.css(@value).first
       end
-      
+
     end
-    
+
   end
-end
+end

lib/webrat/core/locators/label_locator.rb

@@ -3,32 +3,32 @@ require "webrat/core/locators/locator"
 
 module Webrat
   module Locators
-    
+
     class LabelLocator < Locator # :nodoc:
-  
+
       def locate
         Label.load(@session, label_element)
       end
-      
+
       def label_element
         label_elements.detect do |label_element|
-          text(label_element) =~ /^\W*#{Regexp.escape(@value.to_s)}\b/i
+          text(label_element) =~ /^\W*#{Regexp.escape(@value.to_s)}(\b|\Z)/i
         end
       end
-  
+
       def label_elements
-        Webrat::XML.xpath_search(@dom, Label.xpath_search)
+        @dom.xpath(*Label.xpath_search)
       end
-      
+
       def text(label_element)
-        str = Webrat::XML.all_inner_text(label_element)
+        str = label_element.inner_text
         str.gsub!("\n","")
         str.strip!
         str.squeeze!(" ")
         str
       end
-      
+
     end
-    
+
   end
-end
+end

lib/webrat/core/locators/link_locator.rb

@@ -2,24 +2,24 @@ require "webrat/core/locators/locator"
 
 module Webrat
   module Locators
-    
+
     class LinkLocator < Locator # :nodoc:
-  
+
       def locate
         Link.load(@session, link_element)
       end
-  
+
       def link_element
-        matching_links.min { |a, b| Webrat::XML.all_inner_text(a).length <=> Webrat::XML.all_inner_text(b).length }
+        matching_links.min { |a, b| a.inner_text.length <=> b.inner_text.length }
       end
-  
+
       def matching_links
         @matching_links ||= link_elements.select do |link_element|
           matches_text?(link_element) ||
           matches_id?(link_element)
         end
       end
-  
+
       def matches_text?(link)
         if @value.is_a?(Regexp)
           matcher = @value
@@ -27,40 +27,48 @@ module Webrat
           matcher = /#{Regexp.escape(@value.to_s)}/i
         end
 
-        replace_nbsp(Webrat::XML.all_inner_text(link)) =~ matcher ||
+        replace_nbsp(link.inner_text) =~ matcher ||
-        replace_nbsp_ref(Webrat::XML.inner_html(link)) =~ matcher ||
+        replace_nbsp_ref(link.inner_html) =~ matcher ||
-        Webrat::XML.attribute(link, "title")=~ matcher
+        link["title"] =~ matcher
       end
 
       def matches_id?(link)
         if @value.is_a?(Regexp)
-          (Webrat::XML.attribute(link, "id") =~ @value) ? true : false
+          link["id"] =~ @value ? true : false
         else
-          (Webrat::XML.attribute(link, "id") == @value) ? true : false
+          link["id"] == @value ? true : false
         end
       end
-  
+
       def link_elements
-        Webrat::XML.xpath_search(@dom, *Link.xpath_search)
+        @dom.xpath(*Link.xpath_search)
       end
-  
+
       def replace_nbsp(str)
-        str.gsub([0xA0].pack('U'), ' ')
+        if str.respond_to?(:valid_encoding?)
+          if str.valid_encoding?
+            str.gsub(/\xc2\xa0/u, ' ')
+          else
+            str.force_encoding('UTF-8').gsub(/\xc2\xa0/u, ' ')
+          end
+        else
+          str.gsub(/\xc2\xa0/u, ' ')
+        end
       end
 
       def replace_nbsp_ref(str)
         str.gsub('&#xA0;',' ').gsub('&nbsp;', ' ')
       end
-  
+
       def error_message
         "Could not find link with text or title or id #{@value.inspect}"
       end
-      
+
     end
-    
+
     def find_link(text_or_title_or_id) #:nodoc:
       LinkLocator.new(@session, dom, text_or_title_or_id).locate!
     end
-    
+
   end
-end
+end

lib/webrat/core/locators/locator.rb

@@ -1,6 +1,6 @@
 module Webrat
   module Locators
-  
+
     class Locator # :nodoc:
 
       def initialize(session, dom, value, *field_types)
@@ -9,12 +9,12 @@ module Webrat
         @value = value
         @field_types = field_types
       end
-  
+
       def locate!
         locate || raise(NotFoundError.new(error_message))
       end
-      
+
     end
-    
+
   end
-end
+end

lib/webrat/core/locators/select_option_locator.rb

@@ -3,44 +3,44 @@ require "webrat/core/locators/locator"
 
 module Webrat
   module Locators
-    
+
     class SelectOptionLocator < Locator # :nodoc:
-  
+
       def initialize(session, dom, option_text, id_or_name_or_label)
         @session = session
         @dom = dom
         @option_text = option_text
         @id_or_name_or_label = id_or_name_or_label
       end
-      
+
       def locate
         if @id_or_name_or_label
           field = FieldLocator.new(@session, @dom, @id_or_name_or_label, SelectField).locate!
-          
+
           field.options.detect do |o|
             if @option_text.is_a?(Regexp)
-              Webrat::XML.inner_html(o.element) =~ @option_text
+              o.element.inner_text =~ @option_text
             else
-              Webrat::XML.inner_html(o.element) == @option_text.to_s
+              o.inner_text == @option_text.to_s
             end
           end
         else
           option_element = option_elements.detect do |o|
             if @option_text.is_a?(Regexp)
-              Webrat::XML.inner_html(o) =~ @option_text
+              o.inner_text =~ @option_text
             else
-              Webrat::XML.inner_html(o) == @option_text.to_s
+              o.inner_text == @option_text.to_s
             end
           end
-          
+
           SelectOption.load(@session, option_element)
         end
       end
-      
+
       def option_elements
-        Webrat::XML.xpath_search(@dom, *SelectOption.xpath_search)
+        @dom.xpath(*SelectOption.xpath_search)
       end
-      
+
       def error_message
         if @id_or_name_or_label
           "The '#{@option_text}' option was not found in the #{@id_or_name_or_label.inspect} select box"
@@ -48,12 +48,12 @@ module Webrat
           "Could not find option #{@option_text.inspect}"
         end
       end
-  
+
     end
-    
+
     def select_option(option_text, id_or_name_or_label = nil) #:nodoc:
       SelectOptionLocator.new(@session, dom, option_text, id_or_name_or_label).locate!
     end
-    
+
   end
-end
+end

lib/webrat/core/logging.rb

@@ -1,6 +1,8 @@
+require "logger"
+
 module Webrat
   module Logging #:nodoc:
-    
+
     def debug_log(message) # :nodoc:
       return unless logger
       logger.debug message
@@ -11,11 +13,11 @@ module Webrat
       when :rails
         defined?(RAILS_DEFAULT_LOGGER) ? RAILS_DEFAULT_LOGGER : nil
       when :merb
-        Merb.logger
+        ::Merb.logger
       else
-        nil
+        @logger ||= ::Logger.new("webrat.log")
       end
     end
-  
+
   end
-end
+end

lib/webrat/core/matchers/have_content.rb

@@ -1,40 +1,39 @@
 module Webrat
   module Matchers
-  
+
     class HasContent #:nodoc:
       def initialize(content)
         @content = content
       end
-      
+
       def matches?(stringlike)
-        if Webrat.configuration.parse_with_nokogiri?
+        @document = Webrat::XML.document(stringlike)
-          @document = Webrat.nokogiri_document(stringlike)
+        @element = @document.inner_text
-        else
+
-          @document = Webrat.hpricot_document(stringlike)
-        end
-        
-        @element = Webrat::XML.inner_text(@document)
-      
         case @content
         when String
-          @element.include?(@content)
+          @element.gsub(/\s+/, ' ').include?(@content)
         when Regexp
           @element.match(@content)
         end
       end
-      
+
       # ==== Returns
       # String:: The failure message.
       def failure_message
-        "expected the following element's content to #{content_message}:\n#{@element}"
+        "expected the following element's content to #{content_message}:\n#{squeeze_space(@element)}"
       end
 
       # ==== Returns
       # String:: The failure message to be displayed in negative matches.
       def negative_failure_message
-        "expected the following element's content to not #{content_message}:\n#{@element}"
+        "expected the following element's content to not #{content_message}:\n#{squeeze_space(@element)}"
       end
-    
+
+      def squeeze_space(inner_text)
+        inner_text.gsub(/^\s*$/, "").squeeze("\n")
+      end
+
       def content_message
         case @content
         when String
@@ -44,26 +43,26 @@ module Webrat
         end
       end
     end
-    
+
     # Matches the contents of an HTML document with
     # whatever string is supplied
     def contain(content)
       HasContent.new(content)
     end
-    
+
     # Asserts that the body of the response contain
     # the supplied string or regexp
     def assert_contain(content)
       hc = HasContent.new(content)
       assert hc.matches?(response_body), hc.failure_message
     end
-    
+
     # Asserts that the body of the response
     # does not contain the supplied string or regepx
     def assert_not_contain(content)
       hc = HasContent.new(content)
       assert !hc.matches?(response_body), hc.negative_failure_message
     end
-    
+
   end
-end
+end

lib/webrat/core/matchers/have_selector.rb

@@ -1,26 +1,48 @@
+require "webrat/core/matchers/have_xpath"
+
 module Webrat
   module Matchers
-    
-    class HaveSelector < HaveXpath #:nodoc:
 
+    class HaveSelector < HaveXpath #:nodoc:
       # ==== Returns
       # String:: The failure message.
       def failure_message
-        "expected following text to match selector #{@expected}:\n#{@document}"
+        "expected following output to contain a #{tag_inspect} tag:\n#{@document}"
       end
-    
+
       # ==== Returns
       # String:: The failure message to be displayed in negative matches.
       def negative_failure_message
-        "expected following text to not match selector #{@expected}:\n#{@document}"
+        "expected following output to omit a #{tag_inspect}:\n#{@document}"
       end
-    
+
+      def tag_inspect
+        options = @options.dup
+        count = options.delete(:count)
+        content = options.delete(:content)
+
+        html = "<#{@expected}"
+        options.each do |k,v|
+          html << " #{k}='#{v}'"
+        end
+
+        if content
+          html << ">#{content}</#{@expected}>"
+        else
+          html << "/>"
+        end
+
+        html
+      end
+
       def query
-        Nokogiri::CSS::Parser.parse(*super).map { |ast| ast.to_xpath }
+        Nokogiri::CSS.parse(@expected.to_s).map do |ast|
+          ast.to_xpath
+        end.first
       end
-  
+
     end
-    
+
     # Matches HTML content against a CSS 3 selector.
     #
     # ==== Parameters
@@ -28,25 +50,25 @@ module Webrat
     #
     # ==== Returns
     # HaveSelector:: A new have selector matcher.
-    def have_selector(expected, &block)
+    def have_selector(name, attributes = {}, &block)
-      HaveSelector.new(expected, &block)
+      HaveSelector.new(name, attributes, &block)
     end
     alias_method :match_selector, :have_selector
-    
+
-    
+
     # Asserts that the body of the response contains
     # the supplied selector
-    def assert_have_selector(expected)
+    def assert_have_selector(name, attributes = {}, &block)
-      hs = HaveSelector.new(expected)
+      matcher = HaveSelector.new(name, attributes, &block)
-      assert hs.matches?(response_body), hs.failure_message
+      assert matcher.matches?(response_body), matcher.failure_message
     end
-    
+
     # Asserts that the body of the response
     # does not contain the supplied string or regepx
-    def assert_have_no_selector(expected)
+    def assert_have_no_selector(name, attributes = {}, &block)
-      hs = HaveSelector.new(expected)
+      matcher = HaveSelector.new(name, attributes, &block)
-      assert !hs.matches?(response_body), hs.negative_failure_message
+      assert !matcher.matches?(response_body), matcher.negative_failure_message
     end
-    
+
   end
-end
+end

lib/webrat/core/matchers/have_tag.rb

@@ -1,71 +1,21 @@
+require "webrat/core/matchers/have_selector"
+
 module Webrat
-  
   module HaveTagMatcher
 
-    class HaveTag < ::Webrat::Matchers::HaveSelector #:nodoc:
+    def have_tag(*args, &block)
-      # ==== Returns
+      have_selector(*args, &block)
-      # String:: The failure message.
-      def failure_message
-        "expected following output to contain a #{tag_inspect} tag:\n#{@document}"
-      end
-
-      # ==== Returns
-      # String:: The failure message to be displayed in negative matches.
-      def negative_failure_message
-        "expected following output to omit a #{tag_inspect}:\n#{@document}"
-      end
-
-      def tag_inspect
-        options = @expected.last.dup
-        content = options.delete(:content)
-
-        html = "<#{@expected.first}"
-        options.each do |k,v|
-          html << " #{k}='#{v}'"
-        end
-
-        if content
-          html << ">#{content}</#{@expected.first}>"
-        else
-          html << "/>"
-        end
-
-        html
-      end
-
-      def query
-        options  = @expected.last.dup
-        selector = @expected.first.to_s
-
-        selector << ":contains('#{options.delete(:content)}')" if options[:content]
-
-        options.each do |key, value|
-          selector << "[#{key}='#{value}']"
-        end
-
-        Nokogiri::CSS::Parser.parse(selector).map { |ast| ast.to_xpath }
-      end
     end
 
-    def have_tag(name, attributes = {}, &block)
-      HaveTag.new([name, attributes], &block)
-    end
-    
     alias_method :match_tag, :have_tag
-    
+
-    # Asserts that the body of the response contains
+    def assert_have_tag(*args, &block)
-    # the supplied tag with the associated selectors
+      assert_have_selector(*args, &block)
-    def assert_have_tag(name, attributes = {})
-      ht = HaveTag.new([name, attributes])
-      assert ht.matches?(response_body), ht.failure_message
     end
-    
+
-    # Asserts that the body of the response
+    def assert_have_no_tag(*args, &block)
-    # does not contain the supplied string or regepx
+      assert_have_no_selector(*args, &block)
-    def assert_have_no_tag(name, attributes = {})
-      ht = HaveTag.new([name, attributes])
-      assert !ht.matches?(response_body), ht.negative_failure_message
     end
 
   end
-end
+end

lib/webrat/core/matchers/have_xpath.rb

@@ -1,59 +1,73 @@
-require "webrat/core/xml/nokogiri"
+require "webrat/core/xml"
-require "webrat/core/xml/rexml"
 
 module Webrat
   module Matchers
-    
+
     class HaveXpath #:nodoc:
-      def initialize(expected, &block)
+      def initialize(expected, options = {}, &block)
         @expected = expected
+        @options  = options
         @block    = block
       end
-    
+
-      def matches?(stringlike)
+      def matches?(stringlike, &block)
-        if Webrat.configuration.parse_with_nokogiri?
+        @block ||= block
-          matches_nokogiri?(stringlike)
+        matched = matches(stringlike)
+
+        @block.call(matched) if @block
+
+        if @options[:count]
+          matched.size == @options[:count].to_i
         else
-          matches_rexml?(stringlike)
+          matched.any?
         end
       end
-    
-      def matches_rexml?(stringlike)
-        if REXML::Node === stringlike || Array === stringlike
-          @query = query.map { |q| q.gsub(%r'//', './') }
-        else
-          @query = query
-        end
 
-        @document = Webrat.rexml_document(stringlike)
+      def matches(stringlike)
-
+        nokogiri_matches(stringlike)
-        matched = @query.map do |q|
-          if @document.is_a?(Array)
-            @document.map { |d| REXML::XPath.match(d, q) }
-          else
-            REXML::XPath.match(@document, q)
-          end
-        end.flatten.compact
-
-        matched.any? && (!@block || @block.call(matched))
       end
-    
+
-      def matches_nokogiri?(stringlike)
+      def nokogiri_matches(stringlike)
         if Nokogiri::XML::NodeSet === stringlike
-          @query = query.map { |q| q.gsub(%r'//', './') }
+          @query = query.gsub(%r'^//', './/')
         else
           @query = query
         end
-        
+
+        add_options_conditions_to(@query)
+
         @document = Webrat::XML.document(stringlike)
-        matched = @document.xpath(*@query)
+        @document.xpath(*@query)
-        matched.any? && (!@block || @block.call(matched))
       end
-      
+
+      def add_options_conditions_to(query)
+        add_attributes_conditions_to(query)
+        add_content_condition_to(query)
+      end
+
+      def add_attributes_conditions_to(query)
+        attribute_conditions = []
+
+        @options.each do |key, value|
+          next if [:content, :count].include?(key)
+          attribute_conditions << "@#{key} = #{xpath_escape(value)}"
+        end
+
+        if attribute_conditions.any?
+          query << "[#{attribute_conditions.join(' and ')}]"
+        end
+      end
+
+      def add_content_condition_to(query)
+        if @options[:content]
+          query << "[contains(., #{xpath_escape(@options[:content])})]"
+        end
+      end
+
       def query
-        [@expected].flatten.compact
+        @expected
       end
-    
+
       # ==== Returns
       # String:: The failure message.
       def failure_message
@@ -64,9 +78,26 @@ module Webrat
       # String:: The failure message to be displayed in negative matches.
       def negative_failure_message
         "expected following text to not match xpath #{@expected}:\n#{@document}"
-      end    
+      end
+
+    protected
+
+      def xpath_escape(string)
+        if string.include?("'") && string.include?('"')
+          parts = string.split("'").map do |part|
+            "'#{part}'"
+          end
+
+          "concat(" + parts.join(", \"'\", ") + ")"
+        elsif string.include?("'")
+          "\"#{string}\""
+        else
+          "'#{string}'"
+        end
+      end
+
     end
-    
+
     # Matches HTML content against an XPath query
     #
     # ==== Parameters
@@ -74,20 +105,20 @@ module Webrat
     #
     # ==== Returns
     # HaveXpath:: A new have xpath matcher.
-    def have_xpath(expected, &block)
+    def have_xpath(expected, options = {}, &block)
-      HaveXpath.new(expected, &block)
+      HaveXpath.new(expected, options, &block)
     end
     alias_method :match_xpath, :have_xpath
-    
+
-    def assert_have_xpath(expected, &block)
+    def assert_have_xpath(expected, options = {}, &block)
-      hs = HaveXpath.new(expected, &block)
+      hs = HaveXpath.new(expected, options, &block)
       assert hs.matches?(response_body), hs.failure_message
     end
-    
+
-    def assert_have_no_xpath(expected, &block)
+    def assert_have_no_xpath(expected, options = {}, &block)
-      hs = HaveXpath.new(expected, &block)
+      hs = HaveXpath.new(expected, options, &block)
       assert !hs.matches?(response_body), hs.negative_failure_message
     end
-    
+
   end
-end
+end

lib/webrat/core/methods.rb

@@ -3,22 +3,26 @@ module Webrat
 
     def self.delegate_to_session(*meths)
       meths.each do |meth|
-        self.class_eval <<-RUBY
+        self.class_eval(<<-RUBY, __FILE__, __LINE__)
           def #{meth}(*args, &blk)
             webrat_session.#{meth}(*args, &blk)
           end
         RUBY
       end
     end
-    
+
     def webrat
       webrat_session
     end
-    
+
     def webrat_session
-      @_webrat_session ||= ::Webrat.session_class.new(self)
+      @_webrat_session ||= begin
+        session = Webrat.session_class.new
+        session.adapter = Webrat.adapter_class.new(self) if session.respond_to?(:adapter=)
+        session
+      end
     end
-    
+
     # all of these methods delegate to the @session, which should
     # be created transparently.
     #
@@ -31,10 +35,11 @@ module Webrat
       :header, :http_accept, :basic_auth,
       :save_and_open_page,
       :fills_in, :fill_in,
-      :checks, :check, 
+      :checks, :check,
       :unchecks, :uncheck,
       :chooses, :choose,
       :selects, :select,
+      :unselects, :unselect,
       :attaches_file, :attach_file,
       :current_page,
       :current_url,
@@ -47,15 +52,13 @@ module Webrat
       :select_option,
       :set_hidden_field, :submit_form,
       :request_page, :current_dom,
-      :response_body, 
+      :response_body,
       :selects_date, :selects_time, :selects_datetime,
       :select_date, :select_time, :select_datetime,
       :field_by_xpath,
       :field_with_id,
       :selenium,
-      :simulate, :automate
+      :simulate, :automate,
-      
+      :field_named
-      
-    
   end
-end
+end

lib/webrat/core/mime.rb

@@ -1,29 +1,18 @@
 module Webrat #:nodoc:
   module MIME #:nodoc:
-    
+    MIME_TYPES = Rack::Mime::MIME_TYPES.dup.merge(
-    def self.mime_type(string_or_symbol) #:nodoc:
+      ".multipart_form"   => "multipart/form-data",
-      if string_or_symbol.is_a?(String)
+      ".url_encoded_form" => "application/x-www-form-urlencoded"
-        string_or_symbol
+    ).freeze
-      else
+
-        case string_or_symbol
+    def mime_type(type)
-        when :text              then "text/plain"
+      return type if type.nil? || type.to_s.include?("/")
-        when :html              then "text/html"
+      type = ".#{type}" unless type.to_s[0] == ?.
-        when :js                then "text/javascript"
+      MIME_TYPES.fetch(type) { |invalid_type|
-        when :css               then "text/css"
+        raise ArgumentError.new("Invalid Mime type: #{invalid_type}")
-        when :ics               then "text/calendar"
+      }
-        when :csv               then "text/csv"
-        when :xml               then "application/xml"
-        when :rss               then "application/rss+xml"
-        when :atom              then "application/atom+xml"
-        when :yaml              then "application/x-yaml"
-        when :multipart_form    then "multipart/form-data"
-        when :url_encoded_form  then "application/x-www-form-urlencoded"
-        when :json              then "application/json"
-        else
-          raise ArgumentError.new("Invalid Mime type: #{string_or_symbol.inspect}")
-        end
-      end
     end
-    
+
+    module_function :mime_type
   end
-end
+end

lib/webrat/core/save_and_open_page.rb

@@ -2,49 +2,27 @@ module Webrat
   module SaveAndOpenPage
     # Saves the page out to RAILS_ROOT/tmp/ and opens it in the default
     # web browser if on OS X. Useful for debugging.
-    # 
+    #
     # Example:
     #   save_and_open_page
     def save_and_open_page
-      return unless File.exist?(saved_page_dir)
+      return unless File.exist?(Webrat.configuration.saved_pages_dir)
+
+      filename = "#{Webrat.configuration.saved_pages_dir}/webrat-#{Time.now.to_i}.html"
 
-      filename = "#{saved_page_dir}/webrat-#{Time.now.to_i}.html"
-      
       File.open(filename, "w") do |f|
-        f.write rewrite_css_and_image_references(response_body)
+        f.write response_body
       end
 
       open_in_browser(filename)
     end
-    
-    def open_in_browser(path) # :nodoc
-      platform = ruby_platform
-      if platform =~ /cygwin/ || platform =~ /win32/
-        `rundll32 url.dll,FileProtocolHandler #{path.gsub("/", "\\\\")}`
-      elsif platform =~ /darwin/
-        `open #{path}`
-      end
-    end
-    
-    def rewrite_css_and_image_references(response_html) # :nodoc:
-      return response_html unless doc_root
-      response_html.gsub(/"\/(stylesheets|images)/, doc_root + '/\1')
-    end
-    
-    def saved_page_dir #:nodoc:
-      File.expand_path(".")
-    end
-    
-    def doc_root #:nodoc:
-      nil
-    end
-  
-  private
 
-    # accessor for testing
+    def open_in_browser(path) # :nodoc
-    def ruby_platform
+      require "launchy"
-      RUBY_PLATFORM
+      Launchy::Browser.run(path)
+    rescue LoadError
+      warn "Sorry, you need to install launchy to open pages: `gem install launchy`"
     end
-    
+
   end
-end
+end

lib/webrat/core/scope.rb

@@ -6,36 +6,37 @@ module Webrat
   # An HTML element (link, button, field, etc.) that Webrat expected was not found on the page
   class NotFoundError < WebratError
   end
-  
+
   class Scope
     include Logging
     include Locators
-    
+
     def self.from_page(session, response, response_body) #:nodoc:
       new(session) do
         @response = response
         @response_body = response_body
       end
     end
-    
+
     def self.from_scope(session, scope, selector) #:nodoc:
       new(session) do
         @scope = scope
         @selector = selector
       end
     end
-    
+
     attr_reader :session
-    
+
     def initialize(session, &block) #:nodoc:
+      @selector, @dom = nil
       @session = session
       instance_eval(&block) if block_given?
-      
+
       if @selector && scoped_dom.nil?
         raise Webrat::NotFoundError.new("The scope was not found on the page: #{@selector.inspect}")
       end
     end
-    
+
     # Verifies an input field or textarea exists on the current page, and stores a value for
     # it which will be sent when the form is submitted.
     #
@@ -53,7 +54,7 @@ module Webrat
     end
 
     webrat_deprecate :fills_in, :fill_in
-    
+
     # Verifies that a hidden field exists on the current page and sets
     # the value to that given by the <tt>:to</tt> option.
     #
@@ -63,7 +64,7 @@ module Webrat
       field = locate_field(field_locator, HiddenField)
       field.set(options[:to])
     end
-    
+
     # Verifies that an input checkbox exists on the current page and marks it
     # as checked, so that the value will be submitted with the form.
     #
@@ -74,7 +75,7 @@ module Webrat
     end
 
     webrat_deprecate :checks, :check
-    
+
     # Verifies that an input checkbox exists on the current page and marks it
     # as unchecked, so that the value will not be submitted with the form.
     #
@@ -85,7 +86,7 @@ module Webrat
     end
 
     webrat_deprecate :unchecks, :uncheck
-    
+
     # Verifies that an input radio button exists on the current page and marks it
     # as checked, so that the value will be submitted with the form.
     #
@@ -96,7 +97,7 @@ module Webrat
     end
 
     webrat_deprecate :chooses, :choose
-    
+
     # Verifies that a an option element exists on the current page with the specified
     # text. You can optionally restrict the search to a specific select list by
     # assigning <tt>options[:from]</tt> the value of the select list's name or
@@ -111,7 +112,22 @@ module Webrat
     end
 
     webrat_deprecate :selects, :select
-    
+
+    # Verifies that a an option element exists on the current page with the specified
+    # text. You can optionally restrict the search to a specific select list by
+    # assigning <tt>options[:from]</tt> the value of the select list's name or
+    # a label. Remove the option's value before the form is submitted.
+    #
+    # Examples:
+    #   unselect "January"
+    #   unselect "February", :from => "event_month"
+    #   unselect "February", :from => "Event Month"
+    def unselect(option_text, options={})
+      select_option(option_text, options[:from]).unchoose
+    end
+
+    webrat_deprecate :unselects, :unselect
+
     DATE_TIME_SUFFIXES = {
       :year   => '1i',
       :month  => '2i',
@@ -120,9 +136,9 @@ module Webrat
       :minute => '5i'
     }
 
-    # Verifies that date elements (year, month, day) exist on the current page 
+    # Verifies that date elements (year, month, day) exist on the current page
     # with the specified values. You can optionally restrict the search to a specific
-    # date's elements by assigning <tt>options[:from]</tt> the value of the date's 
+    # date's elements by assigning <tt>options[:from]</tt> the value of the date's
     # label. Selects all the date elements with date provided.  The date provided may
     # be a string or a Date/Time object.
     #
@@ -136,15 +152,15 @@ module Webrat
     #   select_date Date.parse("December 25, 2000"), :from => "Event"
     #   select_date "April 26, 1982", :id_prefix => 'birthday'
     def select_date(date_to_select, options ={})
-      date = date_to_select.is_a?(Date) || date_to_select.is_a?(Time) ? 
+      date = date_to_select.is_a?(Date) || date_to_select.is_a?(Time) ?
-                date_to_select : Date.parse(date_to_select) 
+                date_to_select : Date.parse(date_to_select)
-      
+
       id_prefix = locate_id_prefix(options) do
         year_field = FieldByIdLocator.new(@session, dom, /(.*?)_#{DATE_TIME_SUFFIXES[:year]}$/).locate
         raise NotFoundError.new("No date fields were found") unless year_field && year_field.id =~ /(.*?)_1i/
         $1
       end
-        
+
       select date.year, :from => "#{id_prefix}_#{DATE_TIME_SUFFIXES[:year]}"
       select date.strftime('%B'), :from => "#{id_prefix}_#{DATE_TIME_SUFFIXES[:month]}"
       select date.day, :from => "#{id_prefix}_#{DATE_TIME_SUFFIXES[:day]}"
@@ -152,9 +168,9 @@ module Webrat
 
     webrat_deprecate :selects_date, :select_date
 
-    # Verifies that time elements (hour, minute) exist on the current page 
+    # Verifies that time elements (hour, minute) exist on the current page
     # with the specified values. You can optionally restrict the search to a specific
-    # time's elements by assigning <tt>options[:from]</tt> the value of the time's 
+    # time's elements by assigning <tt>options[:from]</tt> the value of the time's
     # label. Selects all the time elements with date provided.  The time provided may
     # be a string or a Time object.
     #
@@ -164,28 +180,28 @@ module Webrat
     #
     # Note: Just like Rails' time_select helper this assumes the form is using
     # 24 hour select boxes, and not 12 hours with AM/PM.
-    # 
+    #
     # Examples:
     #   select_time "9:30"
     #   select_date "3:30PM", :from => "Party Time"
     #   select_date Time.parse("10:00PM"), :from => "Event"
     #   select_date "10:30AM", :id_prefix => 'meeting'
     def select_time(time_to_select, options ={})
-      time = time_to_select.is_a?(Time) ? time_to_select : Time.parse(time_to_select) 
+      time = time_to_select.is_a?(Time) ? time_to_select : Time.parse(time_to_select)
 
       id_prefix = locate_id_prefix(options) do
         hour_field = FieldByIdLocator.new(@session, dom, /(.*?)_#{DATE_TIME_SUFFIXES[:hour]}$/).locate
         raise NotFoundError.new("No time fields were found") unless hour_field && hour_field.id =~ /(.*?)_4i/
         $1
       end
-        
+
       select time.hour.to_s.rjust(2,'0'), :from => "#{id_prefix}_#{DATE_TIME_SUFFIXES[:hour]}"
       select time.min.to_s.rjust(2,'0'), :from => "#{id_prefix}_#{DATE_TIME_SUFFIXES[:minute]}"
     end
 
     webrat_deprecate :selects_time, :select_time
-   
+
-    # Verifies and selects all the date and time elements on the current page. 
+    # Verifies and selects all the date and time elements on the current page.
     # See #select_time and #select_date for more details and available options.
     #
     # Examples:
@@ -194,23 +210,23 @@ module Webrat
     #   select_datetime Time.parse("December 25, 2000 15:30"), :from => "Event"
     #   select_datetime "April 26, 1982 5:50PM", :id_prefix => 'birthday'
     def select_datetime(time_to_select, options ={})
-      time = time_to_select.is_a?(Time) ? time_to_select : Time.parse(time_to_select) 
+      time = time_to_select.is_a?(Time) ? time_to_select : Time.parse(time_to_select)
-      
+
       options[:id_prefix] ||= (options[:from] ? FieldByIdLocator.new(@session, dom, options[:from]).locate : nil)
-      
+
       select_date time, options
       select_time time, options
     end
 
     webrat_deprecate :selects_datetime, :select_datetime
-    
+
     # Verifies that an input file field exists on the current page and sets
     # its value to the given +file+, so that the file will be uploaded
     # along with the form. An optional <tt>content_type</tt> may be given.
     #
     # Example:
-    #   attaches_file "Resume", "/path/to/the/resume.txt"
+    #   attach_file "Resume", "/path/to/the/resume.txt"
-    #   attaches_file "Photo", "/path/to/the/image.png", "image/png"
+    #   attach_file "Photo", "/path/to/the/image.png", "image/png"
     def attach_file(field_locator, path, content_type = nil)
       locate_field(field_locator, FileField).set(path, content_type)
     end
@@ -229,13 +245,13 @@ module Webrat
     def click_area(area_name)
       find_area(area_name).click
     end
-    
+
     webrat_deprecate :clicks_area, :click_area
-    
+
     # Issues a request for the URL pointed to by a link on the current page,
     # follows any redirects, and verifies the final page load was successful.
-    # 
+    #
-    # click_link has very basic support for detecting Rails-generated 
+    # click_link has very basic support for detecting Rails-generated
     # JavaScript onclick handlers for PUT, POST and DELETE links, as well as
     # CSRF authenticity tokens if they are present.
     #
@@ -243,15 +259,15 @@ module Webrat
     #
     # Passing a :method in the options hash overrides the HTTP method used
     # for making the link request
-    # 
+    #
     # It will try to find links by (in order of precedence):
     #   innerHTML, with simple &nbsp; handling
     #   title
     #   id
-    #    
+    #
     # innerHTML and title are matchable by text subtring or Regexp
     # id is matchable by full text equality or Regexp
-    # 
+    #
     # Example:
     #   click_link "Sign up"
     #   click_link "Sign up", :javascript => false
@@ -261,7 +277,7 @@ module Webrat
     end
 
     webrat_deprecate :clicks_link, :click_link
-    
+
     # Verifies that a submit button exists for the form, then submits the form, follows
     # any redirects, and verifies the final page was successful.
     #
@@ -288,38 +304,38 @@ module Webrat
     def submit_form(id)
       FormLocator.new(@session, dom, id).locate.submit
     end
-    
+
     def dom # :nodoc:
       return @dom if @dom
-      
+
       if @selector
         @dom = scoped_dom
       else
         @dom = page_dom
       end
-      
+
       return @dom
     end
-    
+
   protected
-    
+
     def page_dom #:nodoc:
       return @response.dom if @response.respond_to?(:dom)
-      
+
       if @session.xml_content_type?
         dom = Webrat::XML.xml_document(@response_body)
       else
         dom = Webrat::XML.html_document(@response_body)
       end
-      
+
-      Webrat.define_dom_method(@response, dom)
+      Webrat::XML.define_dom_method(@response, dom)
       return dom
     end
-    
+
     def scoped_dom
-      Webrat::XML.css_at(@scope.dom, @selector)
+      @scope.dom.css(@selector).first
     end
-    
+
     def locate_field(field_locator, *field_types) #:nodoc:
       if field_locator.is_a?(Field)
         field_locator
@@ -327,10 +343,10 @@ module Webrat
         field(field_locator, *field_types)
       end
     end
-    
+
     def locate_id_prefix(options, &location_strategy) #:nodoc:
       return options[:id_prefix] if options[:id_prefix]
-      
+
       if options[:from]
         if (label = LabelLocator.new(@session, dom, options[:from]).locate)
           label.for_id
@@ -341,10 +357,10 @@ module Webrat
         yield
       end
     end
-    
+
     def forms #:nodoc:
       @forms ||= Form.load_all(@session, dom)
     end
-    
+
   end
 end

lib/webrat/core/session.rb

@@ -9,20 +9,34 @@ module Webrat
   class PageLoadError < WebratError
   end
 
+  class InfiniteRedirectError < WebratError
+  end
+
   def self.session_class
+    if Webrat.configuration.mode == :selenium
+      SeleniumSession
+    else
+      Session
+    end
+  end
+
+  def self.adapter_class
     case Webrat.configuration.mode
     when :rails
-      RailsSession
+      RailsAdapter
     when :merb
-      MerbSession
+      MerbAdapter
-    when :selenium
-      SeleniumSession
     when :rack
-      RackSession
+      RackAdapter
+    when :rack_test
+      warn("The :rack_test mode is deprecated. Please use :rack instead")
+      require "webrat/rack"
+      RackAdapter
     when :sinatra
-      SinatraSession
+      warn("The :sinatra mode is deprecated. Please use :rack instead")
+      SinatraAdapter
     when :mechanize
-      MechanizeSession
+      MechanizeAdapter
     else
       raise WebratError.new(<<-STR)
 Unknown Webrat mode: #{Webrat.configuration.mode.inspect}
@@ -45,16 +59,23 @@ For example:
     extend Forwardable
     include Logging
     include SaveAndOpenPage
+
+    attr_accessor :adapter
+
     attr_reader :current_url
     attr_reader :elements
 
-    def initialize(context = nil) #:nodoc:
+    def_delegators :@adapter, :response, :response_code, :response_body, :response_headers,
+      :response_body=, :response_code=,
+      :get, :post, :put, :delete
+
+    def initialize(adapter = nil)
+      @adapter         = adapter
       @http_method     = :get
       @data            = {}
       @default_headers = {}
       @custom_headers  = {}
-      @context         = context
+      @current_url     = nil
-
       reset
     end
 
@@ -64,6 +85,7 @@ For example:
 
     # For backwards compatibility -- removing in 1.0
     def current_page #:nodoc:
+      warn "current_page is deprecated and will be going away in the next release. Use current_url instead."
       page = OpenStruct.new
       page.url = @current_url
       page.http_method = @http_method
@@ -71,10 +93,6 @@ For example:
       page
     end
 
-    def doc_root #:nodoc:
-      nil
-    end
-    
     def header(key, value)
       @custom_headers[key] = value
     end
@@ -84,7 +102,7 @@ For example:
     end
 
     def basic_auth(user, pass)
-      encoded_login = ["#{user}:#{pass}"].pack("m*")
+      encoded_login = ["#{user}:#{pass}"].pack("m*").gsub(/\n/, '')
       header('HTTP_AUTHORIZATION', "Basic #{encoded_login}")
     end
 
@@ -97,11 +115,8 @@ For example:
       h['HTTP_REFERER'] = @current_url if @current_url
 
       debug_log "REQUESTING PAGE: #{http_method.to_s.upcase} #{url} with #{data.inspect} and HTTP headers #{h.inspect}"
-      if h.empty?
+
-        send "#{http_method}", url, data || {}
+      process_request(http_method, url, data, h)
-      else
-        send "#{http_method}", url, data || {}, h
-      end
 
       save_and_open_page if exception_caught? && Webrat.configuration.open_error_files?
       raise PageLoadError.new("Page load was not successful (Code: #{response_code.inspect}):\n#{formatted_error}") unless success_code?
@@ -112,21 +127,49 @@ For example:
       @http_method  = http_method
       @data         = data
 
-      request_page(response_location, :get, data) if internal_redirect?
+      if internal_redirect?
+        check_for_infinite_redirects
+        request_page(response_location, :get, {})
+      end
 
       return response
     end
 
+    def check_for_infinite_redirects
+      if current_url == response_location
+        @_identical_redirect_count ||= 0
+        @_identical_redirect_count += 1
+      end
+
+      if infinite_redirect_limit_exceeded?
+        raise InfiniteRedirectError.new("#{Webrat.configuration.infinite_redirect_limit} redirects to the same URL (#{current_url.inspect})")
+      end
+    end
+
+    def infinite_redirect_limit_exceeded?
+       Webrat.configuration.infinite_redirect_limit &&
+       (@_identical_redirect_count || 0) > Webrat.configuration.infinite_redirect_limit
+    end
+
     def success_code? #:nodoc:
       (200..499).include?(response_code)
     end
 
     def redirect? #:nodoc:
-      response_code / 100 == 3
+      [301, 302, 303, 307].include?(response_code)
     end
 
-    def internal_redirect? #:nodoc:
+    def internal_redirect?
-      redirect? && current_host == response_location_host
+      return false unless redirect?
+      #should keep internal_redirects if the subdomain changes
+      current_host_domain = current_host.split('.')[-2..-1].join('.') rescue current_host
+      response_location_host_domain = response_location_host.split('.')[-2..-1].join('.') rescue response_location_host
+      current_host_domain == response_location_host_domain
+    end
+
+    #easy helper to pull out where we were redirected to
+    def redirected_to
+      redirect? ? response_location : nil
     end
 
     def exception_caught? #:nodoc:
@@ -214,6 +257,7 @@ For example:
     def_delegators :current_scope, :uncheck,            :unchecks
     def_delegators :current_scope, :choose,             :chooses
     def_delegators :current_scope, :select,             :selects
+    def_delegators :current_scope, :unselect,           :unselects
     def_delegators :current_scope, :select_datetime,    :selects_datetime
     def_delegators :current_scope, :select_date,        :selects_date
     def_delegators :current_scope, :select_time,        :selects_time
@@ -225,15 +269,24 @@ For example:
     def_delegators :current_scope, :field_by_xpath
     def_delegators :current_scope, :field_with_id
     def_delegators :current_scope, :select_option
+    def_delegators :current_scope, :field_named
 
   private
 
+    def process_request(http_method, url, data, headers)
+      if headers.empty?
+        send "#{http_method}", url, data || {}
+      else
+        send "#{http_method}", url, data || {}, headers
+      end
+    end
+
     def response_location
-      response.headers["Location"]
+      response_headers['Location']
     end
 
     def current_host
-      URI.parse(current_url).host || "www.example.com"
+      URI.parse(current_url).host || @custom_headers["Host"] || "www.example.com"
     end
 
     def response_location_host
@@ -245,6 +298,6 @@ For example:
       @_scopes      = nil
       @_page_scope  = nil
     end
-    
+
   end
 end

lib/webrat/core/xml.rb

@@ -1,115 +1,72 @@
-require "webrat/core/xml/nokogiri"
+require "webrat/core_extensions/meta_class"
-require "webrat/core/xml/hpricot"
-require "webrat/core/xml/rexml"
 
 module Webrat #:nodoc:
   module XML #:nodoc:
-    
+
     def self.document(stringlike) #:nodoc:
-      if Webrat.configuration.parse_with_nokogiri?
+      return stringlike.dom if stringlike.respond_to?(:dom)
-        Webrat.nokogiri_document(stringlike)
+
+      if Nokogiri::HTML::Document === stringlike
+        stringlike
+      elsif Nokogiri::XML::NodeSet === stringlike
+        stringlike
+      elsif stringlike.respond_to?(:body)
+        Nokogiri::HTML(stringlike.body.to_s)
       else
-        Webrat.rexml_document(Webrat.hpricot_document(stringlike).to_html)
+        Nokogiri::HTML(stringlike.to_s)
-      end
-    end
-    
-    def self.html_document(stringlike) #:nodoc:
-      if Webrat.configuration.parse_with_nokogiri?
-        Webrat.html_nokogiri_document(stringlike)
-      else
-        Webrat.rexml_document(Webrat.hpricot_document(stringlike).to_html)
-      end
-    end
-    
-    def self.xml_document(stringlike) #:nodoc:
-      if Webrat.configuration.parse_with_nokogiri?
-        Webrat.xml_nokogiri_document(stringlike)
-      else
-        Webrat.rexml_document(Webrat.hpricot_document(stringlike).to_html)
       end
     end
 
-    def self.to_html(element)
+    def self.html_document(stringlike) #:nodoc:
-      if Webrat.configuration.parse_with_nokogiri?
+      return stringlike.dom if stringlike.respond_to?(:dom)
-        element.to_html
+
+      if Nokogiri::HTML::Document === stringlike
+        stringlike
+      elsif Nokogiri::XML::NodeSet === stringlike
+        stringlike
+      elsif stringlike.respond_to?(:body)
+        Nokogiri::HTML(stringlike.body.to_s)
       else
-        element.to_s
+        Nokogiri::HTML(stringlike.to_s)
       end
     end
-    
+
-    def self.inner_html(element)
+    def self.xml_document(stringlike) #:nodoc:
-      if Webrat.configuration.parse_with_nokogiri?
+      return stringlike.dom if stringlike.respond_to?(:dom)
-        element.inner_html
+
+      if Nokogiri::HTML::Document === stringlike
+        stringlike
+      elsif Nokogiri::XML::NodeSet === stringlike
+        stringlike
+      elsif stringlike.respond_to?(:body)
+        Nokogiri::XML(stringlike.body.to_s)
       else
-        element.text
+        Nokogiri::XML(stringlike.to_s)
       end
     end
-    
+
-    def self.all_inner_text(element)
+    def self.define_dom_method(object, dom) #:nodoc:
-      if Webrat.configuration.parse_with_nokogiri?
+      object.meta_class.send(:define_method, :dom) do
-        element.inner_text
+        dom
-      else
-        Hpricot(element.to_s).children.first.inner_text
       end
     end
-    
+
-    def self.inner_text(element)
-      if Webrat.configuration.parse_with_nokogiri?
-        element.inner_text
-      else
-        if defined?(Hpricot::Doc) && element.is_a?(Hpricot::Doc)
-          element.inner_text
-        else
-          element.text
-        end
-      end
-    end
-    
-    def self.xpath_to(element)
-      if Webrat.configuration.parse_with_nokogiri?
-        element.path
-      else
-        element.xpath
-      end
-    end
-    
-    def self.attribute(element, attribute_name)
-      return element[attribute_name] if element.is_a?(Hash)
-      
-      if Webrat.configuration.parse_with_nokogiri?
-        element[attribute_name]
-      else
-        element.attributes[attribute_name]
-      end
-    end
-    
-    def self.xpath_at(*args)
-      xpath_search(*args).first
-    end
-    
-    def self.css_at(*args)
-      css_search(*args).first
-    end
-    
-    def self.xpath_search(element, *searches)
-      searches.flatten.map do |search|
-        if Webrat.configuration.parse_with_nokogiri?
-          element.xpath(search)
-        else
-          REXML::XPath.match(element, search)
-        end
-      end.flatten.compact
-    end
-    
-    def self.css_search(element, *searches) #:nodoc:
-      xpath_search(element, css_to_xpath(*searches))
-    end
-    
-    def self.css_to_xpath(*selectors)
-      selectors.map do |rule|
-        Nokogiri::CSS.xpath_for(rule, :prefix => ".//")
-      end.flatten.uniq
-    end
-    
   end
-end
+end
+
+module Nokogiri #:nodoc:
+  module CSS #:nodoc:
+    class XPathVisitor #:nodoc:
+
+      def visit_pseudo_class_text(node) #:nodoc:
+        "@type='text'"
+      end
+
+      def visit_pseudo_class_password(node) #:nodoc:
+        "@type='password'"
+      end
+
+    end
+  end
+end
+

lib/webrat/core/xml/hpricot.rb

@@ -1,19 +0,0 @@
-module Webrat
-  
-  def self.hpricot_document(stringlike)
-    return stringlike.dom if stringlike.respond_to?(:dom)
-
-    if Hpricot::Doc === stringlike
-      stringlike
-    elsif Hpricot::Elements === stringlike
-      stringlike
-    elsif StringIO === stringlike
-      Hpricot(stringlike.string)
-    elsif stringlike.respond_to?(:body)
-      Hpricot(stringlike.body.to_s)
-    else
-      Hpricot(stringlike.to_s)
-    end
-  end
-  
-end

lib/webrat/core/xml/nokogiri.rb

@@ -1,76 +0,0 @@
-require "webrat/core_extensions/meta_class"
-
-module Webrat
-  
-  def self.nokogiri_document(stringlike) #:nodoc:
-    return stringlike.dom if stringlike.respond_to?(:dom)
-    
-    if Nokogiri::HTML::Document === stringlike
-      stringlike
-    elsif Nokogiri::XML::NodeSet === stringlike
-      stringlike
-    elsif StringIO === stringlike
-      Nokogiri::HTML(stringlike.string)
-    elsif stringlike.respond_to?(:body)
-      Nokogiri::HTML(stringlike.body.to_s)
-    else
-      Nokogiri::HTML(stringlike.to_s)
-    end
-  end
-  
-  def self.html_nokogiri_document(stringlike) #:nodoc:
-    return stringlike.dom if stringlike.respond_to?(:dom)
-    
-    if Nokogiri::HTML::Document === stringlike
-      stringlike
-    elsif Nokogiri::XML::NodeSet === stringlike
-      stringlike
-    elsif StringIO === stringlike
-      Nokogiri::HTML(stringlike.string)
-    elsif stringlike.respond_to?(:body)
-      Nokogiri::HTML(stringlike.body.to_s)
-    else
-      Nokogiri::HTML(stringlike.to_s)
-    end
-  end
-  
-  def self.xml_nokogiri_document(stringlike) #:nodoc:
-    return stringlike.dom if stringlike.respond_to?(:dom)
-    
-    if Nokogiri::HTML::Document === stringlike
-      stringlike
-    elsif Nokogiri::XML::NodeSet === stringlike
-      stringlike
-    elsif StringIO === stringlike
-      Nokogiri::XML(stringlike.string)
-    elsif stringlike.respond_to?(:body)
-      Nokogiri::XML(stringlike.body.to_s)
-    else
-      Nokogiri::XML(stringlike.to_s)
-    end
-  end
-  
-  def self.define_dom_method(object, dom) #:nodoc:
-    object.meta_class.send(:define_method, :dom) do
-      dom
-    end
-  end
-  
-end
-
-
-module Nokogiri #:nodoc:
-  module CSS #:nodoc:
-    class XPathVisitor #:nodoc:
-      
-      def visit_pseudo_class_text(node) #:nodoc:
-        "@type='text'"
-      end
-
-      def visit_pseudo_class_password(node) #:nodoc:
-        "@type='password'"
-      end
-      
-    end
-  end
-end

lib/webrat/core/xml/rexml.rb

@@ -1,24 +0,0 @@
-module Webrat
-  
-  def self.rexml_document(stringlike)
-    stringlike = stringlike.body.to_s if stringlike.respond_to?(:body)
-
-    case stringlike
-    when REXML::Document
-      stringlike.root
-    when REXML::Node, Array
-      stringlike
-    else
-      begin
-        REXML::Document.new(stringlike.to_s).root
-      rescue REXML::ParseException => e
-        if e.message.include?("second root element")
-          REXML::Document.new("<fake-root-element>#{stringlike}</fake-root-element>").root
-        else
-          raise e
-        end
-      end
-    end
-  end
-  
-end

lib/webrat/core_extensions/blank.rb

@@ -12,7 +12,7 @@ class Object #:nodoc:
   def blank?
     respond_to?(:empty?) ? empty? : !self
   end
-    
+
   # An object is present if it's not blank.
   def present?
     !blank?

lib/webrat/core_extensions/deprecate.rb

@@ -5,4 +5,4 @@ class Module #:nodoc:
       __send__(new_method_name, *args)
     end
   end
-end
+end

lib/webrat/core_extensions/detect_mapped.rb

@@ -1,12 +1,12 @@
 class Array #:nodoc:
-  
+
   def detect_mapped
     each do |element|
       result = yield element
       return result if result
     end
-    
+
     return nil
   end
-  
+
-end
+end

lib/webrat/core_extensions/hash_with_indifferent_access.rb

@@ -1,131 +0,0 @@
-# This class has dubious semantics and we only have it so that
-# people can write params[:key] instead of params['key']
-# and they get the same value for both keys.
-class HashWithIndifferentAccess < Hash #:nodoc:
-  def initialize(constructor = {})
-    if constructor.is_a?(Hash)
-      super()
-      update(constructor)
-    else
-      super(constructor)
-    end
-  end
-
-  def default(key = nil)
-    if key.is_a?(Symbol) && include?(key = key.to_s)
-      self[key]
-    else
-      super
-    end
-  end
-
-  alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
-  alias_method :regular_update, :update unless method_defined?(:regular_update)
-
-  #
-  # Assigns a new value to the hash.
-  #
-  # Example:
-  #
-  #   hash = HashWithIndifferentAccess.new
-  #   hash[:key] = "value"
-  #
-  def []=(key, value)
-    regular_writer(convert_key(key), convert_value(value))
-  end
-
-  # 
-  # Updates the instantized hash with values from the second.
-  # 
-  # Example:
-  # 
-  #   >> hash_1 = HashWithIndifferentAccess.new
-  #   => {}
-  # 
-  #   >> hash_1[:key] = "value"
-  #   => "value"
-  # 
-  #   >> hash_2 = HashWithIndifferentAccess.new
-  #   => {}
-  # 
-  #   >> hash_2[:key] = "New Value!"
-  #   => "New Value!"
-  # 
-  #   >> hash_1.update(hash_2)
-  #   => {"key"=>"New Value!"}
-  # 
-  def update(other_hash)
-    other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
-    self
-  end
-
-  alias_method :merge!, :update
-
-  # Checks the hash for a key matching the argument passed in
-  def key?(key)
-    super(convert_key(key))
-  end
-
-  alias_method :include?, :key?
-  alias_method :has_key?, :key?
-  alias_method :member?, :key?
-
-  # Fetches the value for the specified key, same as doing hash[key]
-  def fetch(key, *extras)
-    super(convert_key(key), *extras)
-  end
-
-  # Returns an array of the values at the specified indicies. 
-  def values_at(*indices)
-    indices.collect {|key| self[convert_key(key)]}
-  end
-
-  # Returns an exact copy of the hash.
-  def dup
-    HashWithIndifferentAccess.new(self)
-  end
-
-  # Merges the instantized and the specified hashes together, giving precedence to the values from the second hash
-  # Does not overwrite the existing hash.
-  def merge(hash)
-    self.dup.update(hash)
-  end
-
-  # Removes a specified key from the hash.
-  def delete(key)
-    super(convert_key(key))
-  end
-
-  def stringify_keys!; self end
-  def symbolize_keys!; self end
-  def to_options!; self end
-
-  # Convert to a Hash with String keys.
-  def to_hash
-    Hash.new(default).merge(self)
-  end
-
-  protected
-    def convert_key(key)
-      key.kind_of?(Symbol) ? key.to_s : key
-    end
-
-    def convert_value(value)
-      case value
-      when Hash
-        value.with_indifferent_access
-      when Array
-        value.collect { |e| e.is_a?(Hash) ? e.with_indifferent_access : e }
-      else
-        value
-      end
-    end
-end
-
-class Hash #:nodoc:
-  def with_indifferent_access
-    hash = HashWithIndifferentAccess.new(self)
-    hash.default = self.default
-    hash
-  end
-end

lib/webrat/core_extensions/meta_class.rb

@@ -3,4 +3,4 @@ class ::Object #:nodoc:
     class << self; self end
   end
 end
-    
+

lib/webrat/core_extensions/nil_to_query_string.rb

@@ -1,5 +1,5 @@
 class NilClass #:nodoc:
-  def to_param
+  def to_query_string
     nil
   end
 end

lib/webrat/core_extensions/tcp_socket.rb

@@ -0,0 +1,27 @@
+class TCPSocket
+
+  def self.wait_for_service_with_timeout(options)
+    start_time = Time.now
+
+    until listening_service?(options)
+      verbose_wait
+
+      if options[:timeout] && (Time.now > start_time + options[:timeout])
+        raise SocketError.new("Socket did not open within #{options[:timeout]} seconds")
+      end
+    end
+  end
+
+  def self.wait_for_service_termination_with_timeout(options)
+    start_time = Time.now
+
+    while listening_service?(options)
+      verbose_wait
+
+      if options[:timeout] && (Time.now > start_time + options[:timeout])
+        raise SocketError.new("Socket did not terminate within #{options[:timeout]} seconds")
+      end
+    end
+  end
+
+end

lib/webrat/integrations/merb.rb

@@ -0,0 +1,10 @@
+module Merb #:nodoc:
+  module Test #:nodoc:
+    module RequestHelper #:nodoc:
+      def request(uri, env = {})
+        @_webrat_session ||= Webrat::MerbAdapter.new
+        @_webrat_session.response = @_webrat_session.request(uri, env)
+      end
+    end
+  end
+end

lib/webrat/integrations/rails.rb

@@ -0,0 +1,25 @@
+require "action_controller"
+require "action_controller/integration"
+
+module ActionController #:nodoc:
+  IntegrationTest.class_eval do
+    include Webrat::Methods
+    include Webrat::Matchers
+
+    # The Rails version of within supports passing in a model and Webrat
+    # will apply a scope based on Rails' dom_id for that model.
+    #
+    # Example:
+    #   within User.last do
+    #     click_link "Delete"
+    #   end
+    def within(selector_or_object, &block)
+      if selector_or_object.is_a?(String)
+        super
+      else
+        super('#' + RecordIdentifier.dom_id(selector_or_object), &block)
+      end
+    end
+
+  end
+end

lib/webrat/integrations/rspec-rails.rb

@@ -0,0 +1,11 @@
+# Supports using the matchers in controller, helper, and view specs if you're
+# using rspec-rails. Just add a require statement to spec/spec_helper.rb or env.rb:
+#
+#   require 'webrat/integrations/rspec-rails'
+#
+require "nokogiri"
+require "webrat/core/matchers"
+
+Spec::Runner.configure do |config|
+  config.include(Webrat::Matchers, :type => [:controller, :helper, :view])
+end

lib/webrat/integrations/selenium.rb

@@ -0,0 +1,11 @@
+require "webrat/selenium"
+
+if defined?(ActionController::IntegrationTest)
+  module ActionController #:nodoc:
+    IntegrationTest.class_eval do
+      include Webrat::Methods
+      include Webrat::Selenium::Methods
+      include Webrat::Selenium::Matchers
+    end
+  end
+end

lib/webrat/merb.rb

@@ -6,4 +6,4 @@ require "webrat"
 
 Webrat.configure do |config|
   config.mode = :merb
-end
+end

lib/webrat/merb_session.rb

@@ -1,65 +0,0 @@
-require "webrat"
-
-require "cgi"
-gem "extlib"
-require "extlib"
-require "merb-core"
-
-HashWithIndifferentAccess = Mash
-
-module Webrat
-  class MerbSession < Session #:nodoc:
-    include Merb::Test::MakeRequest
-    
-    attr_accessor :response
-    
-    def get(url, data, headers = nil)
-      do_request(url, data, headers, "GET")
-    end
-  
-    def post(url, data, headers = nil)
-      do_request(url, data, headers, "POST")
-    end
-  
-    def put(url, data, headers = nil)
-      do_request(url, data, headers, "PUT")
-    end
-  
-    def delete(url, data, headers = nil)
-      do_request(url, data, headers, "DELETE")
-    end
-    
-    def response_body
-      @response.body.to_s
-    end
-    
-    def response_code
-      @response.status
-    end
-    
-    def do_request(url, data, headers, method)
-      @response = request(url, 
-        :params => (data && data.any?) ? data : nil, 
-        :headers => headers,
-        :method => method)
-    end
-
-  end
-end
-
-module Merb #:nodoc:
-  module Test #:nodoc:
-    module RequestHelper #:nodoc:
-      def request(uri, env = {})
-        @_webrat_session ||= Webrat::MerbSession.new
-        @_webrat_session.response = @_webrat_session.request(uri, env)
-      end
-    end
-  end
-end
-
-class Merb::Test::RspecStory #:nodoc:
-  def browser
-    @browser ||= Webrat::MerbSession.new
-  end
-end

lib/webrat/rack.rb

@@ -1,24 +0,0 @@
-require 'webrat'
-
-class CGIMethods #:nodoc:
-  def self.parse_query_parameters(params)
-    hash = {}
-    params.split('&').each do |p|
-      pair = p.split('=')
-      hash[pair[0]] = pair[1]
-    end
-    hash
-  end
-end
-
-module Webrat
-  class RackSession < Session #:nodoc:
-    def response_body
-      @response.body
-    end
-
-    def response_code
-      @response.status
-    end
-  end
-end

lib/webrat/rspec-rails.rb

@@ -1,13 +1,2 @@
-# Supports using the matchers in controller, helper, and view specs if you're
+warn("Requiring 'webrat/rspec-rails' is deprecated. Please require 'webrat/integrations/rspec-rails' instead")
-# using rspec-rails. Just add a require statement to spec/spec_helper.rb or env.rb:
+require "webrat/integrations/rspec-rails"
-# 
-#   require 'webrat/rspec-rails'
-#
-require "webrat/core/matchers"
-
-Spec::Runner.configure do |config|
-  # rspec should support :type => [:controller, :helper, :view] - but until it does ...
-  config.include(Webrat::Matchers, :type => :controller)
-  config.include(Webrat::Matchers, :type => :helper)
-  config.include(Webrat::Matchers, :type => :view)
-end

lib/webrat/selenium.rb

@@ -1,41 +1,11 @@
 require "webrat"
-gem "selenium-client", ">=1.2.9"
 require "selenium/client"
+require "webrat/selenium/silence_stream"
 require "webrat/selenium/selenium_session"
 require "webrat/selenium/matchers"
+require "webrat/core_extensions/tcp_socket"
 
 module Webrat
-
-  def self.with_selenium_server #:nodoc:
-    start_selenium_server
-    yield
-    stop_selenium_server
-  end
-
-  def self.start_selenium_server #:nodoc:
-    unless Webrat.configuration.selenium_server_address
-      remote_control = ::Selenium::RemoteControl::RemoteControl.new("0.0.0.0", Webrat.configuration.selenium_server_port, 5)
-      remote_control.jar_file = File.expand_path(__FILE__ + "../../../../vendor/selenium-server.jar")
-      remote_control.start :background => true
-    end
-    TCPSocket.wait_for_service :host => (Webrat.configuration.selenium_server_address || "0.0.0.0"), :port => Webrat.configuration.selenium_server_port
-  end
-
-  def self.stop_selenium_server #:nodoc:
-    ::Selenium::RemoteControl::RemoteControl.new("0.0.0.0", Webrat.configuration.selenium_server_port, 5).stop unless Webrat.configuration.selenium_server_address
-  end
-
-  def self.start_app_server #:nodoc:
-    pid_file = File.expand_path(RAILS_ROOT + "/tmp/pids/mongrel_selenium.pid")
-    system("mongrel_rails start -d --chdir=#{RAILS_ROOT} --port=#{Webrat.configuration.application_port} --environment=#{Webrat.configuration.application_environment} --pid #{pid_file} &")
-    TCPSocket.wait_for_service :host => Webrat.configuration.application_address, :port => Webrat.configuration.application_port.to_i
-  end
-
-  def self.stop_app_server #:nodoc:
-    pid_file = File.expand_path(RAILS_ROOT + "/tmp/pids/mongrel_selenium.pid")
-    system "mongrel_rails stop -c #{RAILS_ROOT} --pid #{pid_file}"
-  end
-
   # To use Webrat's Selenium support, you'll need the selenium-client gem installed.
   # Activate it with (for example, in your <tt>env.rb</tt>):
   #
@@ -55,11 +25,25 @@ module Webrat
   #     selenium.dragdrop("id=photo_123", "+350, 0")
   #   end
   #
-  # == Auto-starting of the mongrel and java server
+  # == Choosing the underlying framework to test
+  #
+  # Webrat assumes you're using rails by default but it can also work with sinatra
+  # and merb.  To take advantage of this you can use the configuration block to
+  # set the application_framework variable.
+  #   require "webrat"
+  #
+  #   Webrat.configure do |config|
+  #     config.mode = :selenium
+  #     config.application_port = 4567
+  #     config.application_framework = :sinatra  # could also be :merb
+  #   end
+  #
+  # == Auto-starting of the appserver and java server
   #
   # Webrat will automatically start the Selenium Java server process and an instance
   # of Mongrel when a test is run. The Mongrel will run in the "selenium" environment
-  # instead of "test", so ensure you've got that defined, and will run on port 3001.
+  # instead of "test", so ensure you've got that defined, and will run on port
+  # Webrat.configuration.application_port.
   #
   # == Waiting
   #
@@ -84,11 +68,3 @@ module Webrat
     end
   end
 end
-
-module ActionController #:nodoc:
-  IntegrationTest.class_eval do
-    include Webrat::Methods
-    include Webrat::Selenium::Methods
-    include Webrat::Selenium::Matchers
-  end
-end

lib/webrat/selenium/application_server_factory.rb

@@ -0,0 +1,40 @@
+module Webrat
+  module Selenium
+
+    class ApplicationServerFactory
+
+      def self.app_server_instance
+        case Webrat.configuration.application_framework
+        when :sinatra
+          require "webrat/selenium/application_servers/sinatra"
+          return Webrat::Selenium::ApplicationServers::Sinatra.new
+        when :merb
+          require "webrat/selenium/application_servers/merb"
+          return Webrat::Selenium::ApplicationServers::Merb.new
+        when :rails
+          require "webrat/selenium/application_servers/rails"
+          return Webrat::Selenium::ApplicationServers::Rails.new
+        when :external
+          require "webrat/selenium/application_servers/external"
+          return Webrat::Selenium::ApplicationServers::External.new
+        else
+          raise WebratError.new(<<-STR)
+Unknown Webrat application_framework: #{Webrat.configuration.application_framework.inspect}
+
+Please ensure you have a Webrat configuration block that specifies an application_framework
+in your test_helper.rb, spec_helper.rb, or env.rb (for Cucumber).
+
+For example:
+
+  Webrat.configure do |config|
+    # ...
+    config.application_framework = :rails
+  end
+      STR
+        end
+      end
+
+    end
+
+  end
+end

lib/webrat/selenium/application_servers.rb

@@ -0,0 +1,5 @@
+require "webrat/selenium/application_servers/base"
+require "webrat/selenium/application_servers/sinatra"
+require "webrat/selenium/application_servers/merb"
+require "webrat/selenium/application_servers/rails"
+require "webrat/selenium/application_servers/external"

lib/webrat/selenium/application_servers/base.rb

@@ -0,0 +1,46 @@
+require "webrat/selenium/silence_stream"
+
+module Webrat
+  module Selenium
+    module ApplicationServers
+      class Base
+        include Webrat::Selenium::SilenceStream
+
+        def boot
+          start
+          wait
+          stop_at_exit
+        end
+
+        def stop_at_exit
+          at_exit do
+            stop
+          end
+        end
+
+        def wait
+          $stderr.print "==> Waiting for #{Webrat.configuration.application_framework} application server on port #{Webrat.configuration.application_port}... "
+          wait_for_socket
+          $stderr.print "Ready!\n"
+        end
+
+        def wait_for_socket
+          silence_stream(STDOUT) do
+            TCPSocket.wait_for_service_with_timeout \
+              :host     => "0.0.0.0",
+              :port     => Webrat.configuration.application_port.to_i,
+              :timeout  => 30 # seconds
+          end
+          rescue SocketError
+          fail
+        end
+
+        def prepare_pid_file(file_path, pid_file_name)
+          FileUtils.mkdir_p File.expand_path(file_path)
+          File.expand_path("#{file_path}/#{pid_file_name}")
+        end
+
+      end
+    end
+  end
+end

lib/webrat/selenium/application_servers/external.rb

@@ -0,0 +1,26 @@
+require "webrat/selenium/application_servers/base"
+
+module Webrat
+  module Selenium
+    module ApplicationServers
+      class External < Webrat::Selenium::ApplicationServers::Base
+        def start
+          warn "Webrat Ignoring Start Of Application Server Due to External Mode"
+        end
+
+        def stop
+        end
+
+        def fail
+        end
+
+        def pid_file
+        end
+
+        def wait
+        end
+
+      end
+    end
+  end
+end

lib/webrat/selenium/application_servers/merb.rb

@@ -0,0 +1,50 @@
+require "webrat/selenium/application_servers/base"
+
+module Webrat
+  module Selenium
+    module ApplicationServers
+      class Merb < Webrat::Selenium::ApplicationServers::Base
+
+        def start
+          system start_command
+        end
+
+        def stop
+          silence_stream(STDOUT) do
+            pid = File.read(pid_file)
+            system("kill -9 #{pid}")
+            FileUtils.rm_f pid_file
+          end
+        end
+
+        def fail
+          $stderr.puts
+          $stderr.puts
+          $stderr.puts "==> Failed to boot the Merb application server... exiting!"
+          $stderr.puts
+          $stderr.puts "Verify you can start a Merb server on port #{Webrat.configuration.application_port} with the following command:"
+          $stderr.puts
+          $stderr.puts "    #{start_command}"
+          exit
+        end
+
+        def pid_file
+        "log/merb.#{Webrat.configuration.application_port}.pid"
+        end
+
+        def start_command
+        "#{merb_command} -d -p #{Webrat.configuration.application_port} -e #{Webrat.configuration.application_environment}"
+        end
+
+        def merb_command
+          if File.exist?('bin/merb')
+            merb_cmd = 'bin/merb'
+          else
+            merb_cmd = 'merb'
+          end
+        end
+
+      end
+    end
+  end
+end

lib/webrat/selenium/application_servers/rails.rb

@@ -0,0 +1,44 @@
+require "webrat/selenium/application_servers/base"
+
+module Webrat
+  module Selenium
+    module ApplicationServers
+      class Rails < Webrat::Selenium::ApplicationServers::Base
+
+        def start
+          system start_command
+        end
+
+        def stop
+          silence_stream(STDOUT) do
+            system stop_command
+          end
+        end
+
+        def fail
+          $stderr.puts
+          $stderr.puts
+          $stderr.puts "==> Failed to boot the Rails application server... exiting!"
+          $stderr.puts
+          $stderr.puts "Verify you can start a Rails server on port #{Webrat.configuration.application_port} with the following command:"
+          $stderr.puts
+          $stderr.puts "    #{start_command}"
+          exit
+        end
+
+        def pid_file
+          prepare_pid_file("#{RAILS_ROOT}/tmp/pids", "mongrel_selenium.pid")
+        end
+
+        def start_command
+        "mongrel_rails start -d --chdir='#{RAILS_ROOT}' --port=#{Webrat.configuration.application_port} --environment=#{Webrat.configuration.application_environment} --pid #{pid_file} &"
+        end
+
+        def stop_command
+        "mongrel_rails stop -c #{RAILS_ROOT} --pid #{pid_file}"
+        end
+
+      end
+    end
+  end
+end

lib/webrat/selenium/application_servers/sinatra.rb

@@ -0,0 +1,37 @@
+require "webrat/selenium/application_servers/base"
+
+module Webrat
+  module Selenium
+    module ApplicationServers
+      class Sinatra < Webrat::Selenium::ApplicationServers::Base
+
+        def start
+          fork do
+            File.open('rack.pid', 'w') { |fp| fp.write Process.pid }
+            exec 'rackup', File.expand_path(Dir.pwd + '/config.ru'), '-p', Webrat.configuration.application_port.to_s
+          end
+        end
+
+        def stop
+          silence_stream(STDOUT) do
+            pid = File.read(pid_file)
+            system("kill -9 #{pid}")
+            FileUtils.rm_f pid_file
+          end
+        end
+
+        def fail
+          $stderr.puts
+          $stderr.puts
+          $stderr.puts "==> Failed to boot the Sinatra application server... exiting!"
+          exit
+        end
+
+        def pid_file
+          prepare_pid_file(Dir.pwd, 'rack.pid')
+        end
+
+      end
+    end
+  end
+end

lib/webrat/selenium/location_strategy_javascript/button.js

@@ -1,12 +1,19 @@
 if (locator == '*') {
   return selenium.browserbot.locationStrategies['xpath'].call(this, "//input[@type='submit']", inDocument, inWindow)
 }
+var buttons = inDocument.getElementsByTagName('button');
 var inputs = inDocument.getElementsByTagName('input');
-return $A(inputs).find(function(candidate){
+var result = $A(inputs).concat($A(buttons)).find(function(candidate){
-  inputType = candidate.getAttribute('type');
+	var type = candidate.getAttribute('type');
-  if (inputType == 'submit' || inputType == 'image') {
+	if (type == 'submit' || type == 'image'  || type == 'button') {
-    var buttonText = $F(candidate);
+		var matches_id = PatternMatcher.matches(locator, candidate.id);
-    return (PatternMatcher.matches(locator, buttonText));
+		var matches_value = PatternMatcher.matches(locator, candidate.value);
-  }
+		var matches_html = PatternMatcher.matches(locator, candidate.innerHTML);
-  return false;
+		var matches_alt = PatternMatcher.matches(locator, candidate.alt);
+		if (matches_id || matches_value || matches_html || matches_alt) {
+			return true;
+		}
+	}
+	return false;
 });
+return result;

lib/webrat/selenium/location_strategy_javascript/label.js

@@ -1,16 +1,48 @@
+// Credit to: http://simonwillison.net/2006/Jan/20/escape/
+RegExp.escape = function(text) {
+  if (!arguments.callee.sRE) {
+    var specials = [
+      '/', '.', '*', '+', '?', '|',
+      '(', ')', '[', ']', '{', '}', '\\'
+    ];
+    arguments.callee.sRE = new RegExp(
+      '(\\' + specials.join('|\\') + ')', 'g'
+    );
+  }
+  return text.replace(arguments.callee.sRE, '\\$1');
+};
+
 var allLabels = inDocument.getElementsByTagName("label");
+var regExp = new RegExp('^\\W*' + RegExp.escape(locator) + '(\\b|$)', 'i');
+
 var candidateLabels = $A(allLabels).select(function(candidateLabel){
-  var regExp = new RegExp('^' + locator + '\\b', 'i');
   var labelText = getText(candidateLabel).strip();
   return (labelText.search(regExp) >= 0);
 });
+
 if (candidateLabels.length == 0) {
-  return null;      
+  return null;
 }
-candidateLabels = candidateLabels.sortBy(function(s) { return s.length * -1; }); //reverse length sort
+
+//reverse length sort
+candidateLabels = candidateLabels.sortBy(function(s) {
+  return s.length * -1;
+});
+
 var locatedLabel = candidateLabels.first();
-var labelFor = locatedLabel.getAttribute('for');
+var labelFor = null;
-if ((labelFor == null) && (locatedLabel.hasChildNodes())) {
+
-  return locatedLabel.firstChild; //TODO: should find the first form field, not just any node
+if (locatedLabel.getAttribute('for')) {
+  labelFor = locatedLabel.getAttribute('for');
+} else if (locatedLabel.attributes['for']) { // IE
+  labelFor = locatedLabel.attributes['for'].nodeValue;
 }
+
+if ((labelFor == null) && (locatedLabel.hasChildNodes())) {
+  return locatedLabel.getElementsByTagName('button')[0]
+    || locatedLabel.getElementsByTagName('input')[0]
+    || locatedLabel.getElementsByTagName('textarea')[0]
+    || locatedLabel.getElementsByTagName('select')[0];
+}
+
 return selenium.browserbot.locationStrategies['id'].call(this, labelFor, inDocument, inWindow);

lib/webrat/selenium/location_strategy_javascript/webrat.js

@@ -1,4 +1,5 @@
 var locationStrategies = selenium.browserbot.locationStrategies;
+
 return locationStrategies['id'].call(this, locator, inDocument, inWindow)
         || locationStrategies['name'].call(this, locator, inDocument, inWindow)
         || locationStrategies['label'].call(this, locator, inDocument, inWindow)

lib/webrat/selenium/location_strategy_javascript/webratlink.js

@@ -1,9 +1,32 @@
 var links = inDocument.getElementsByTagName('a');
+
 var candidateLinks = $A(links).select(function(candidateLink) {
-  return PatternMatcher.matches(locator, getText(candidateLink));
+  var textMatched = false;
+  var titleMatched = false;
+  var idMatched = false;
+
+  if (getText(candidateLink).toLowerCase().indexOf(locator.toLowerCase()) != -1) {
+    textMatched = true;
+  }
+
+  if (candidateLink.title.toLowerCase().indexOf(locator.toLowerCase()) != -1) {
+    titleMatched = true;
+  }
+
+  if (candidateLink.id.toLowerCase().indexOf(locator.toLowerCase()) != -1) {
+    idMatched = true;
+  }
+
+  return textMatched || idMatched || titleMatched;
 });
+
 if (candidateLinks.length == 0) {
   return null;
 }
-candidateLinks = candidateLinks.sortBy(function(s) { return s.length * -1; }); //reverse length sort
+
+//reverse length sort
+candidateLinks = candidateLinks.sortBy(function(s) {
+  return s.length * -1;
+});
+
 return candidateLinks.first();

lib/webrat/selenium/matchers.rb

@@ -1,146 +1,4 @@
-module Webrat
+require "webrat/selenium/matchers/have_xpath"
-  module Selenium
+require "webrat/selenium/matchers/have_selector"
-    module Matchers
+# require "webrat/selenium/matchers/have_tag"
-
+require "webrat/selenium/matchers/have_content"
-      class HaveXpath
-        def initialize(expected)
-          @expected = expected
-        end
-        
-        def matches?(response)
-          response.session.wait_for do
-            response.selenium.is_element_present("xpath=#{@expected}")
-          end
-        end
-
-        # ==== Returns
-        # String:: The failure message.
-        def failure_message
-          "expected following text to match xpath #{@expected}:\n#{@document}"
-        end
-
-        # ==== Returns
-        # String:: The failure message to be displayed in negative matches.
-        def negative_failure_message
-          "expected following text to not match xpath #{@expected}:\n#{@document}"
-        end
-      end
-      
-      def have_xpath(xpath)
-        HaveXpath.new(xpath)
-      end
-      
-      def assert_have_xpath(expected)
-        hs = HaveXpath.new(expected)
-        assert hs.matches?(response), hs.failure_message
-      end
-
-      def assert_have_no_xpath(expected)
-        hs = HaveXpath.new(expected)
-        assert !hs.matches?(response), hs.negative_failure_message
-      end
-      
-      class HaveSelector
-        def initialize(expected)
-          @expected = expected
-        end
-        
-        def matches?(response)
-          response.session.wait_for do
-            response.selenium.is_element_present("css=#{@expected}")
-          end
-        end
-
-        # ==== Returns
-        # String:: The failure message.
-        def failure_message
-          "expected following text to match selector #{@expected}:\n#{@document}"
-        end
-
-        # ==== Returns
-        # String:: The failure message to be displayed in negative matches.
-        def negative_failure_message
-          "expected following text to not match selector #{@expected}:\n#{@document}"
-        end
-      end
-      
-      def have_selector(content)
-        HaveSelector.new(content)
-      end
-      
-      # Asserts that the body of the response contains
-      # the supplied selector
-      def assert_have_selector(expected)
-        hs = HaveSelector.new(expected)
-        assert hs.matches?(response), hs.failure_message
-      end
-
-      # Asserts that the body of the response
-      # does not contain the supplied string or regepx
-      def assert_have_no_selector(expected)
-        hs = HaveSelector.new(expected)
-        assert !hs.matches?(response), hs.negative_failure_message
-      end
-      
-      class HasContent #:nodoc:
-        def initialize(content)
-          @content = content
-        end
-        
-        def matches?(response)
-          if @content.is_a?(Regexp)
-            text_finder = "regexp:#{@content.source}"
-          else
-            text_finder = @content
-          end
-          
-          response.session.wait_for do
-            response.selenium.is_text_present(text_finder)
-          end
-        end
-
-        # ==== Returns
-        # String:: The failure message.
-        def failure_message
-          "expected the following element's content to #{content_message}:\n#{@element}"
-        end
-
-        # ==== Returns
-        # String:: The failure message to be displayed in negative matches.
-        def negative_failure_message
-          "expected the following element's content to not #{content_message}:\n#{@element}"
-        end
-
-        def content_message
-          case @content
-          when String
-            "include \"#{@content}\""
-          when Regexp
-            "match #{@content.inspect}"
-          end
-        end
-      end
-
-      # Matches the contents of an HTML document with
-      # whatever string is supplied
-      def contain(content)
-        HasContent.new(content)
-      end
-      
-      # Asserts that the body of the response contain
-      # the supplied string or regexp
-      def assert_contain(content)
-        hc = HasContent.new(content)
-       assert hc.matches?(response), hc.failure_message
-      end
-
-      # Asserts that the body of the response
-      # does not contain the supplied string or regepx
-      def assert_not_contain(content)
-        hc = HasContent.new(content)
-        assert !hc.matches?(response), hc.negative_failure_message
-      end
-      
-    end
-  end
-end

lib/webrat/selenium/matchers/have_content.rb

@@ -0,0 +1,78 @@
+module Webrat
+  module Selenium
+    module Matchers
+      class HasContent #:nodoc:
+        def initialize(content)
+          @content = content
+        end
+
+        def matches?(response)
+          response.session.wait_for do
+            response.selenium.is_text_present(text_finder)
+          end
+        rescue Webrat::TimeoutError => e
+          @error_message = e.message
+          false
+        end
+
+        def does_not_match?(response)
+          response.session.wait_for do
+            !response.selenium.is_text_present(text_finder)
+          end
+        rescue Webrat::TimeoutError => e
+          @error_message = e.message
+          false
+        end
+
+        # ==== Returns
+        # String:: The failure message.
+        def failure_message
+          "expected the response to #{content_message}:\n#{@error_message}"
+        end
+
+        # ==== Returns
+        # String:: The failure message to be displayed in negative matches.
+        def negative_failure_message
+          "expected the response to not #{content_message}"
+        end
+
+        def content_message
+          case @content
+          when String
+            "include \"#{@content}\""
+          when Regexp
+            "match #{@content.inspect}"
+          end
+        end
+
+        def text_finder
+          if @content.is_a?(Regexp)
+            "regexp:#{@content.source}"
+          else
+            @content
+          end
+        end
+      end
+
+      # Matches the contents of an HTML document with
+      # whatever string is supplied
+      def contain(content)
+        HasContent.new(content)
+      end
+
+      # Asserts that the body of the response contain
+      # the supplied string or regexp
+      def assert_contain(content)
+        hc = HasContent.new(content)
+        assert hc.matches?(response), hc.failure_message
+      end
+
+      # Asserts that the body of the response
+      # does not contain the supplied string or regepx
+      def assert_not_contain(content)
+        hc = HasContent.new(content)
+        assert !hc.matches?(response), hc.negative_failure_message
+      end
+    end
+  end
+end

lib/webrat/selenium/matchers/have_selector.rb

@@ -0,0 +1,57 @@
+module Webrat
+  module Selenium
+    module Matchers
+      class HaveSelector
+        def initialize(expected)
+          @expected = expected
+        end
+
+        def matches?(response)
+          response.session.wait_for do
+            response.selenium.is_element_present("css=#{@expected}")
+          end
+          rescue Webrat::TimeoutError
+            false
+        end
+
+        def does_not_match?(response)
+          response.session.wait_for do
+            !response.selenium.is_element_present("css=#{@expected}")
+          end
+          rescue Webrat::TimeoutError
+            false
+        end
+
+        # ==== Returns
+        # String:: The failure message.
+        def failure_message
+          "expected following text to match selector #{@expected}:\n#{@document}"
+        end
+
+        # ==== Returns
+        # String:: The failure message to be displayed in negative matches.
+        def negative_failure_message
+          "expected following text to not match selector #{@expected}:\n#{@document}"
+        end
+      end
+
+      def have_selector(content)
+        HaveSelector.new(content)
+      end
+
+      # Asserts that the body of the response contains
+      # the supplied selector
+      def assert_have_selector(expected)
+        hs = HaveSelector.new(expected)
+        assert hs.matches?(response), hs.failure_message
+      end
+
+      # Asserts that the body of the response
+      # does not contain the supplied string or regepx
+      def assert_have_no_selector(expected)
+        hs = HaveSelector.new(expected)
+        assert !hs.matches?(response), hs.negative_failure_message
+      end
+    end
+  end
+end

lib/webrat/selenium/matchers/have_tag.rb

@@ -0,0 +1,72 @@
+module Webrat
+  module Selenium
+    module Matchers
+
+      class HaveTag < HaveSelector #:nodoc:
+        # ==== Returns
+        # String:: The failure message.
+        def failure_message
+          "expected following output to contain a #{tag_inspect} tag:\n#{@document}"
+        end
+
+        # ==== Returns
+        # String:: The failure message to be displayed in negative matches.
+        def negative_failure_message
+          "expected following output to omit a #{tag_inspect}:\n#{@document}"
+        end
+
+        def tag_inspect
+          options = @expected.last.dup
+          content = options.delete(:content)
+
+          html = "<#{@expected.first}"
+          options.each do |k,v|
+            html << " #{k}='#{v}'"
+          end
+
+          if content
+            html << ">#{content}</#{@expected.first}>"
+          else
+            html << "/>"
+          end
+
+          html
+        end
+
+        def query
+          options  = @expected.last.dup
+          selector = @expected.first.to_s
+
+          selector << ":contains('#{options.delete(:content)}')" if options[:content]
+
+          options.each do |key, value|
+            selector << "[#{key}='#{value}']"
+          end
+
+          Nokogiri::CSS.parse(selector).map { |ast| ast.to_xpath }
+        end
+      end
+
+      def have_tag(name, attributes = {}, &block)
+        HaveTag.new([name, attributes], &block)
+      end
+
+      alias_method :match_tag, :have_tag
+
+      # Asserts that the body of the response contains
+      # the supplied tag with the associated selectors
+      def assert_have_tag(name, attributes = {})
+        ht = HaveTag.new([name, attributes])
+        assert ht.matches?(response), ht.failure_message
+      end
+
+      # Asserts that the body of the response
+      # does not contain the supplied string or regepx
+      def assert_have_no_tag(name, attributes = {})
+        ht = HaveTag.new([name, attributes])
+        assert !ht.matches?(response), ht.negative_failure_message
+      end
+
+    end
+  end
+end

lib/webrat/selenium/matchers/have_xpath.rb

@@ -0,0 +1,53 @@
+module Webrat
+  module Selenium
+    module Matchers
+      class HaveXpath
+        def initialize(expected)
+          @expected = expected
+        end
+
+        def matches?(response)
+          response.session.wait_for do
+            response.selenium.is_element_present("xpath=#{@expected}")
+          end
+          rescue Webrat::TimeoutError
+            false
+        end
+
+        def does_not_match?(response)
+          response.session.wait_for do
+            !response.selenium.is_element_present("xpath=#{@expected}")
+          end
+          rescue Webrat::TimeoutError
+            false
+        end
+
+        # ==== Returns
+        # String:: The failure message.
+        def failure_message
+          "expected following text to match xpath #{@expected}:\n#{@document}"
+        end
+
+        # ==== Returns
+        # String:: The failure message to be displayed in negative matches.
+        def negative_failure_message
+          "expected following text to not match xpath #{@expected}:\n#{@document}"
+        end
+      end
+
+      def have_xpath(xpath)
+        HaveXpath.new(xpath)
+      end
+
+      def assert_have_xpath(expected)
+        hs = HaveXpath.new(expected)
+        assert hs.matches?(response), hs.failure_message
+      end
+
+      def assert_have_no_xpath(expected)
+        hs = HaveXpath.new(expected)
+        assert !hs.matches?(response), hs.negative_failure_message
+      end
+    end
+  end
+end

lib/webrat/selenium/selenium_rc_server.rb

@@ -0,0 +1,89 @@
+module Webrat
+  module Selenium
+
+    class SeleniumRCServer
+
+      include Webrat::Selenium::SilenceStream
+
+      def self.boot
+        new.boot
+      end
+
+      def boot
+        return if selenium_grid?
+
+        start
+        wait
+        stop_at_exit
+      end
+
+      def start
+        silence_stream(STDOUT) do
+          remote_control.start :background => true
+        end
+      end
+
+      def stop_at_exit
+        at_exit do
+          stop
+        end
+      end
+
+      def remote_control
+        return @remote_control if @remote_control
+        server_options = { :timeout => Webrat.configuration.selenium_browser_startup_timeout }
+        server_options[:firefox_profile] = Webrat.configuration.selenium_firefox_profile if Webrat.configuration.selenium_firefox_profile
+
+        @remote_control = ::Selenium::RemoteControl::RemoteControl.new("0.0.0.0",
+                                                                       Webrat.configuration.selenium_server_port,
+                                                                       server_options)
+
+        @remote_control.jar_file = jar_path
+
+        return @remote_control
+      end
+
+      def jar_path
+        File.expand_path(__FILE__ + "../../../../../vendor/selenium-server.jar")
+      end
+
+      def selenium_grid?
+        Webrat.configuration.selenium_server_address
+      end
+
+      def wait
+        $stderr.print "==> Waiting for Selenium RC server on port #{Webrat.configuration.selenium_server_port}... "
+        wait_for_socket
+        $stderr.print "Ready!\n"
+      rescue SocketError
+        fail
+      end
+
+      def wait_for_socket
+        silence_stream(STDOUT) do
+          TCPSocket.wait_for_service_with_timeout \
+            :host     => (Webrat.configuration.selenium_server_address || "0.0.0.0"),
+            :port     => Webrat.configuration.selenium_server_port,
+            :timeout  => 45 # seconds
+        end
+      end
+
+      def fail
+        $stderr.puts
+        $stderr.puts
+        $stderr.puts "==> Failed to boot the Selenium RC server... exiting!"
+        exit
+      end
+
+      def stop
+        silence_stream(STDOUT) do
+          ::Selenium::RemoteControl::RemoteControl.new("0.0.0.0",
+                                                       Webrat.configuration.selenium_server_port,
+                                                       :timeout => 5).stop
+        end
+      end
+
+    end
+
+  end
+end

lib/webrat/selenium/selenium_session.rb

@@ -1,4 +1,14 @@
 require "webrat/core/save_and_open_page"
+require "webrat/selenium/selenium_rc_server"
+require "webrat/selenium/application_server_factory"
+require "webrat/selenium/application_servers/base"
+
+begin
+  require "selenium"
+rescue LoadError => e
+  e.message << " (You may need to install the selenium-rc gem)"
+  raise e
+end
 
 module Webrat
   class TimeoutError < WebratError
@@ -20,6 +30,7 @@ module Webrat
 
   class SeleniumSession
     include Webrat::SaveAndOpenPage
+    include Webrat::Selenium::SilenceStream
 
     def initialize(*args) # :nodoc:
     end
@@ -38,8 +49,8 @@ module Webrat
     webrat_deprecate :visits, :visit
 
     def fill_in(field_identifier, options)
-      locator = "webrat=#{Regexp.escape(field_identifier)}"
+      locator = "webrat=#{field_identifier}"
-      selenium.wait_for_element locator, 5
+      selenium.wait_for_element locator, :timeout_in_seconds => 5
       selenium.type(locator, "#{options[:with]}")
     end
 
@@ -53,6 +64,10 @@ module Webrat
       selenium.get_html_source
     end
 
+    def current_url
+      selenium.location
+    end
+
     def click_button(button_text_or_regexp = nil, options = {})
       if button_text_or_regexp.is_a?(Hash) && options == {}
         pattern, options = nil, button_text_or_regexp
@@ -62,16 +77,21 @@ module Webrat
       pattern ||= '*'
       locator = "button=#{pattern}"
 
-      selenium.wait_for_element locator, 5
+      selenium.wait_for_element locator, :timeout_in_seconds => 5
       selenium.click locator
     end
 
     webrat_deprecate :clicks_button, :click_button
 
     def click_link(link_text_or_regexp, options = {})
-      pattern = adjust_if_regexp(link_text_or_regexp)
+      if link_text_or_regexp.is_a?(Regexp)
+        pattern = "evalregex:#{link_text_or_regexp.inspect}"
+      else
+        pattern = link_text_or_regexp.to_s
+      end
+
       locator = "webratlink=#{pattern}"
-      selenium.wait_for_element locator, 5
+      selenium.wait_for_element locator, :timeout_in_seconds => 5
       selenium.click locator
     end
 
@@ -79,7 +99,7 @@ module Webrat
 
     def click_link_within(selector, link_text, options = {})
       locator = "webratlinkwithin=#{selector}|#{link_text}"
-      selenium.wait_for_element locator, 5
+      selenium.wait_for_element locator, :timeout_in_seconds => 5
       selenium.click locator
     end
 
@@ -94,7 +114,7 @@ module Webrat
         select_locator = "webratselectwithoption=#{option_text}"
       end
 
-      selenium.wait_for_element select_locator, 5
+      selenium.wait_for_element select_locator, :timeout_in_seconds => 5
       selenium.select(select_locator, option_text)
     end
 
@@ -102,7 +122,7 @@ module Webrat
 
     def choose(label_text)
       locator = "webrat=#{label_text}"
-      selenium.wait_for_element locator, 5
+      selenium.wait_for_element locator, :timeout_in_seconds => 5
       selenium.click locator
     end
 
@@ -110,9 +130,10 @@ module Webrat
 
     def check(label_text)
       locator = "webrat=#{label_text}"
-      selenium.wait_for_element locator, 5
+      selenium.wait_for_element locator, :timeout_in_seconds => 5
-      selenium.check locator
+      selenium.click locator
     end
+    alias_method :uncheck, :check
 
     webrat_deprecate :checks, :check
 
@@ -142,8 +163,10 @@ module Webrat
 
         begin
           value = yield
-        rescue ::Spec::Expectations::ExpectationNotMetError, ::Selenium::CommandError, Webrat::WebratError
+        rescue Exception => e
-          value = nil
+          unless is_ignorable_wait_for_exception?(e)
+            raise e
+          end
         end
 
         return value if value
@@ -151,7 +174,19 @@ module Webrat
         sleep 0.25
       end
 
-      raise Webrat::TimeoutError.new(message + " (after #{timeout} sec)")
+      error_message = "#{message} (after #{timeout} sec)"
+      
+      if $browser && Webrat.configuration.selenium_verbose_output
+        error_message += <<-EOS
+
+
+HTML of the page was:
+
+#{selenium.get_html_source}"
+EOS
+      end
+
+      raise Webrat::TimeoutError.new(error_message)
       true
     end
 
@@ -165,29 +200,34 @@ module Webrat
 
 
     def save_and_open_screengrab
-      return unless File.exist?(saved_page_dir)
+      return unless File.exist?(Webrat.configuration.saved_pages_dir)
 
-      filename = "#{saved_page_dir}/webrat-#{Time.now.to_i}.png"
+      filename = "#{Webrat.configuration.saved_pages_dir}/webrat-#{Time.now.to_i}.png"
 
       if $browser.chrome_backend?
         $browser.capture_entire_page_screenshot(filename, '')
       else
         $browser.capture_screenshot(filename)
       end
-        open_in_browser(filename)
+      open_in_browser(filename)
+
     end
 
-  protected
+    protected
+    def is_ignorable_wait_for_exception?(exception) #:nodoc:
+      if defined?(::Spec::Expectations::ExpectationNotMetError)
+        return true if exception.class == ::Spec::Expectations::ExpectationNotMetError
+      end
+      return true if [::Selenium::CommandError, Webrat::WebratError].include?(exception.class)
+      return false
+    end
 
     def setup #:nodoc:
-      silence_stream(STDOUT) do
+      Webrat::Selenium::SeleniumRCServer.boot
-        Webrat.start_selenium_server
+      Webrat::Selenium::ApplicationServerFactory.app_server_instance.boot
-        Webrat.start_app_server
-      end
 
       create_browser
       $browser.start
-      teardown_at_exit
 
       extend_selenium
       define_location_strategies
@@ -197,16 +237,12 @@ module Webrat
 
     def create_browser
       $browser = ::Selenium::Client::Driver.new(Webrat.configuration.selenium_server_address || "localhost",
-          Webrat.configuration.selenium_server_port, Webrat.configuration.selenium_browser_key, "http://#{Webrat.configuration.application_address}:#{Webrat.configuration.application_port}")
+      Webrat.configuration.selenium_server_port, Webrat.configuration.selenium_browser_key, "http://#{Webrat.configuration.application_address}:#{Webrat.configuration.application_port_for_selenium}")
       $browser.set_speed(0) unless Webrat.configuration.selenium_server_address
-    end
 
-    def teardown_at_exit #:nodoc:
       at_exit do
         silence_stream(STDOUT) do
           $browser.stop
-          Webrat.stop_app_server
-          Webrat.stop_selenium_server
         end
       end
     end
@@ -233,4 +269,4 @@ module Webrat
       end
     end
   end
-end
+end

lib/webrat/selenium/silence_stream.rb

@@ -0,0 +1,18 @@
+module Webrat
+  module Selenium
+    module SilenceStream
+      # active_support already defines silence_stream, no need to do that again if it's already present.
+      # http://github.com/rails/rails/blob/master/activesupport/lib/active_support/core_ext/kernel/reporting.rb
+      unless Kernel.respond_to?(:silence_stream)
+        def silence_stream(stream)
+          old_stream = stream.dup
+          stream.reopen(RUBY_PLATFORM =~ /mswin/ ? 'NUL:' : '/dev/null')
+          stream.sync = true
+          yield
+        ensure
+          stream.reopen(old_stream)
+        end
+      end
+    end
+  end
+end

lib/webrat/sinatra.rb

@@ -1,29 +0,0 @@
-require 'webrat/rack'
-require 'sinatra'
-require 'sinatra/test/methods'
-
-class Sinatra::Application
-  # Override this to prevent Sinatra from barfing on the options passed from RSpec
-  def self.load_default_options_from_command_line!
-  end
-end
-
-disable :run
-disable :reload
-
-module Webrat
-  class SinatraSession < RackSession #:nodoc:
-    include Sinatra::Test::Methods
-
-    attr_reader :request, :response
-
-    %w(get head post put delete).each do |verb|
-      define_method(verb) do |*args| # (path, data, headers = nil)
-        path, data, headers = *args
-        data = data.inject({}) {|data, (key,value)| data[key] = Rack::Utils.unescape(value); data }
-        params = data.merge(:env => headers || {})
-        self.__send__("#{verb}_it", path, params)
-      end
-    end
-  end
-end

spec/fakes/test_adapter.rb

@@ -1,14 +1,13 @@
 module Webrat #:nodoc:
-  def self.session_class #:nodoc:
+  def self.adapter_class #:nodoc:
-    TestSession
+    TestAdapter
   end
 
-  class TestSession < Session #:nodoc:
+  class TestAdapter #:nodoc:
     attr_accessor :response_body
     attr_writer :response_code
 
-    def doc_root
+    def initialize(*args)
-      File.expand_path(File.join(".", "public"))
     end
 
     def response
@@ -16,7 +15,7 @@ module Webrat #:nodoc:
     end
 
     def response_code
-      @response_code || 200
+      @response_code ||= 200
     end
 
     def get(url, data, headers = nil)
@@ -31,4 +30,4 @@ module Webrat #:nodoc:
     def delete(url, data, headers = nil)
     end
   end
-end
+end

spec/integration/mechanize/Rakefile

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'spec/rake/spectask'
+
+Spec::Rake::SpecTask.new do |t|
+  t.spec_opts = ['--color']
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end

spec/integration/mechanize/config.ru

@@ -0,0 +1,2 @@
+require "sample_app"
+run SampleApp

spec/integration/mechanize/sample_app.rb

@@ -0,0 +1,35 @@
+require "sinatra/base"
+
+class SampleApp < Sinatra::Default
+  get "/" do
+    "Hello World"
+  end
+
+  get "/internal_redirect" do
+    redirect URI.join(request.url, "redirected").to_s
+  end
+
+  get "/external_redirect" do
+    redirect "http://example.tst/"
+  end
+
+  get "/redirected" do
+    "Redirected"
+  end
+
+  get "/form" do
+    <<-EOS
+    <html>
+      <form action="/form" method="post">
+        <input type="hidden" name="_method" value="put" />
+        <label for="email">Email:</label> <input type="text" id="email" name="email" /></label>
+        <input type="submit" value="Add" />
+      </form>
+    </html>
+    EOS
+  end
+
+  put "/form" do
+    "Welcome #{params[:email]}"
+  end
+end

spec/integration/mechanize/spec/mechanize_spec.rb

@@ -0,0 +1,30 @@
+require File.dirname(__FILE__) + "/spec_helper"
+
+describe "Webrat's Mechanize mode" do
+  it "should work" do
+    response = visit("http://localhost:9292/")
+    response.should contain("Hello World")
+  end
+
+  it "should follow redirects" do
+    response = visit("http://localhost:9292/internal_redirect")
+    response.should contain("Redirected")
+  end
+
+  it "should follow links"
+
+  it "should submit forms" do
+    visit "http://localhost:9292/form"
+    fill_in "Email", :with => "albert@example.com"
+    response = click_button "Add"
+
+    response.should contain("Welcome albert@example.com")
+  end
+
+  it "should not follow external redirects" do
+    pending do
+      response = visit("http://localhost:9292/external_redirect")
+      response.should contain("Foo")
+    end
+  end
+end

spec/integration/mechanize/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+require "rubygems"
+require "spec"
+
+$LOAD_PATH.unshift File.dirname(__FILE__) + "/../../../../lib"
+require "webrat"
+
+Webrat.configure do |config|
+  config.mode = :mechanize
+end
+
+Spec::Runner.configure do |config|
+  config.include Webrat::Methods
+  config.include Webrat::Matchers
+
+  config.before :suite do
+    if File.exists?("rack.pid")
+      Process.kill("TERM", File.read("rack.pid").to_i)
+    end
+
+    system "rackup --daemonize --pid rack.pid config.ru"
+  end
+
+  config.after :suite do
+    if File.exists?("rack.pid")
+      Process.kill("TERM", File.read("rack.pid").to_i)
+    end
+  end
+end
+

spec/integration/merb/app/controllers/application.rb

@@ -1,2 +1,2 @@
 class Application < Merb::Controller
-end
+end

spec/integration/merb/app/controllers/exceptions.rb

@@ -1,5 +1,5 @@
 class Exceptions < Merb::Controller
-  
+
   # handle NotFound exceptions (404)
   def not_found
     render :format => :html
@@ -10,4 +10,4 @@ class Exceptions < Merb::Controller
     render :format => :html
   end
 
-end
+end

spec/integration/merb/app/controllers/testing.rb

@@ -1,18 +1,27 @@
 class Testing < Application
-  
+
   def show_form
     render
   end
-  
+
+  def upload
+    case request.method
+    when :get then render
+    when :post then
+      uploaded_file = params[:uploaded_file]
+      render [uploaded_file[:filename], uploaded_file[:tempfile].class.name].inspect
+    end
+  end
+
   def submit_form
   end
-  
+
   def internal_redirect
     redirect "/"
   end
-  
+
   def external_redirect
     redirect "http://google.com"
   end
-  
+
-end
+end

spec/integration/merb/app/views/testing/upload.html.erb

@@ -0,0 +1,9 @@
+<h1>Webrat Form</h1>
+
+<form action="/upload" method="post">
+  <label>
+    File
+    <input type="file" name="uploaded_file" />
+  </label>
+  <input type="submit" value="Upload">
+</form>

spec/integration/merb/config/init.rb

@@ -1,25 +1,25 @@
 # Go to http://wiki.merbivore.com/pages/init-rb
- 
+
 # Specify a specific version of a dependency
 # dependency "RedCloth", "> 3.0"
 
 #  use_orm :none
 use_test :rspec
 use_template_engine :erb
- 
+
 Merb::Config.use do |c|
   c[:use_mutex] = false
   c[:session_store] = 'cookie'  # can also be 'memory', 'memcache', 'container', 'datamapper
-  
+
   # cookie session store configuration
   c[:session_secret_key]  = 'adb9ea7a0e94b5513503f58623a393c5efe18851'  # required for cookie session store
   c[:session_id_key] = '_merb_session_id' # cookie session id key, defaults to "_session_id"
 end
- 
+
 Merb::BootLoader.before_app_loads do
   # This will get executed after dependencies have been loaded but before your app's classes have loaded.
 end
- 
+
 Merb::BootLoader.after_app_loads do
   # This will get executed after your app's classes have been loaded.
-end
+end

spec/integration/merb/config/rack.rb

@@ -8,4 +8,4 @@ end
 use Merb::Rack::Static, Merb.dir_for(:public)
 
 # this is our main merb application
-run Merb::Rack::Application.new
+run Merb::Rack::Application.new

spec/integration/merb/config/router.rb

@@ -10,7 +10,7 @@
 #
 #   match("/books/:book_id/:action").
 #     to(:controller => "books")
-#   
+#
 # Or, use placeholders in the "to" results for more complicated routing, e.g.:
 #
 #   match("/admin/:module/:controller/:action/:id").
@@ -28,6 +28,7 @@
 Merb.logger.info("Compiling routes...")
 Merb::Router.prepare do
   match("/").to(:controller => "testing", :action => "show_form")
+  match("/upload").to(:controller => "testing", :action => "upload")
   match("/internal_redirect").to(:controller => "testing", :action => "internal_redirect")
   match("/external_redirect").to(:controller => "testing", :action => "external_redirect")
-end
+end

spec/integration/merb/spec/spec_helper.rb

@@ -1,5 +1,7 @@
 require "rubygems"
 
+$LOAD_PATH.unshift File.dirname(__FILE__) + "/../../../../lib"
+
 # Add the local gems dir if found within the app root; any dependencies loaded
 # hereafter will try to load from the local gems before loading system gems.
 if (local_gem_dir = File.join(File.dirname(__FILE__), '..', 'gems')) && $BUNDLE.nil?
@@ -21,4 +23,4 @@ end
 
 Webrat.configure do |config|
   config.mode = :merb
-end
+end

spec/integration/merb/spec/webrat_spec.rb

@@ -19,7 +19,7 @@ describe "Webrat" do
     response.status.should == 200
     response.should contain("Webrat Form")
   end
-  
+
   it "should check the value of a field" do
     visit "/"
     field_labeled("Prefilled").value.should == "text"
@@ -29,4 +29,11 @@ describe "Webrat" do
     response = visit "/external_redirect"
     response.status.should == 302
   end
-end
+
+  it "should upload files" do
+    visit "/upload"
+    attach_file "File", __FILE__
+    response = click_button "Upload"
+    response.should contain(%(["webrat_spec.rb", "Tempfile"]))
+  end
+end

spec/integration/merb/tasks/merb.thor/app_script.rb

@@ -12,9 +12,9 @@ if File.directory?(gems_dir)
   Gem.clear_paths
   Gem.path.replace([File.expand_path(gems_dir)])
   ENV["PATH"] = "#{File.dirname(__FILE__)}:#{ENV["PATH"]}"
-  
+
   gem_file = File.join(gems_dir, "specifications", "<%= spec.name %>-*.gemspec")
-  
+
   if local_gem = Dir[gem_file].last
     version = File.basename(local_gem)[/-([\.\d]+)\.gemspec$/, 1]
   end
@@ -28,4 +28,4 @@ if ARGV.first =~ /^_(.*)_$/ and Gem::Version.correct? $1 then
 end
 
 gem '<%= @spec.name %>', version
-load '<%= bin_file_name %>'
+load '<%= bin_file_name %>'

spec/integration/merb/tasks/merb.thor/common.rb

@@ -7,21 +7,21 @@ module Gem
   BUNDLED_SPECS = File.join(Dir.pwd, "gems", "specifications")
   MAIN_INDEX = Gem::SourceIndex.from_gems_in(BUNDLED_SPECS)
   FALLBACK_INDEX = Gem::SourceIndex.from_installed_gems
-  
+
   def self.source_index
     MultiSourceIndex.new
   end
-  
+
   def self.searcher
     MultiPathSearcher.new
   end
-  
+
   class ArbitrarySearcher < GemPathSearcher
     def initialize(source_index)
       @source_index = source_index
       super()
     end
-    
+
     def init_gemspecs
       @source_index.map { |_, spec| spec }.sort { |a,b|
         (a.name <=> b.name).nonzero? || (b.version <=> a.version)
@@ -34,31 +34,31 @@ module Gem
       @main_searcher = ArbitrarySearcher.new(MAIN_INDEX)
       @fallback_searcher = ArbitrarySearcher.new(FALLBACK_INDEX)
     end
-    
+
     def find(path)
       try = @main_searcher.find(path)
       return try if try
       @fallback_searcher.find(path)
     end
-    
+
     def find_all(path)
       try = @main_searcher.find_all(path)
       return try unless try.empty?
       @fallback_searcher.find_all(path)
     end
   end
-  
+
   class MultiSourceIndex
     def search(*args)
       try = MAIN_INDEX.search(*args)
       return try unless try.empty?
       FALLBACK_INDEX.search(*args)
     end
-    
+
     def find_name(*args)
       try = MAIN_INDEX.find_name(*args)
       return try unless try.empty?
       FALLBACK_INDEX.find_name(*args)
     end
   end
-end
+end

spec/integration/merb/tasks/merb.thor/gem_ext.rb

@@ -2,12 +2,12 @@ require "erb"
 
 Gem.pre_install_hooks.push(proc do |installer|
   $INSTALLING << installer.spec
-  
+
   unless File.file?(installer.bin_dir / "common.rb")
     FileUtils.mkdir_p(installer.bin_dir)
     FileUtils.cp(File.dirname(__FILE__) / "common.rb", installer.bin_dir / "common.rb")
   end
-  
+
   include ColorfulMessages
   name = installer.spec.name
   if $GEMS && versions = ($GEMS.assoc(name) || [])[1]
@@ -25,19 +25,19 @@ end)
 
 class ::Gem::Uninstaller
   def self._with_silent_ui
-    
+
-    ui = Gem::DefaultUserInteraction.ui 
+    ui = Gem::DefaultUserInteraction.ui
     def ui.say(str)
       puts "- #{str}"
     end
-    
+
     yield
-    
+
     class << Gem::DefaultUserInteraction.ui
       remove_method :say
-    end 
+    end
   end
-  
+
   def self._uninstall(source_index, name, op, version)
     unless source_index.find_name(name, "#{op} #{version}").empty?
       uninstaller = Gem::Uninstaller.new(
@@ -50,7 +50,7 @@ class ::Gem::Uninstaller
       _with_silent_ui { uninstaller.uninstall }
     end
   end
-  
+
   def self._uninstall_others(source_index, name, version)
     _uninstall(source_index, name, "<", version)
     _uninstall(source_index, name, ">", version)
@@ -67,14 +67,14 @@ end)
 
 class ::Gem::DependencyInstaller
   alias old_fg find_gems_with_sources
-  
+
   def find_gems_with_sources(dep)
     if @source_index.any? { |_, installed_spec|
       installed_spec.satisfies_requirement?(dep)
     }
       return []
     end
-    
+
     old_fg(dep)
   end
 end
@@ -83,9 +83,9 @@ class ::Gem::SpecFetcher
   alias old_fetch fetch
   def fetch(dependency, all = false, matching_platform = true)
     idx = Gem::SourceIndex.from_installed_gems
-    
+
     dep = idx.search(dependency).sort.last
-    
+
     if dep
       file = dep.loaded_from.dup
       file.gsub!(/specifications/, "cache")
@@ -121,4 +121,4 @@ class ::Gem::Specification
     end
     specs + specs.map {|s| s.recursive_dependencies(self, index)}.flatten.uniq
   end
-end
+end