pr0d1r2-capybara 0.3.7

data/lib/capybara/driver/selenium_driver.rb

@@ -0,0 +1,161 @@
+require 'selenium-webdriver'
+
+class Capybara::Driver::Selenium < Capybara::Driver::Base
+  class Node < Capybara::Node
+    def text
+      node.text
+    end
+
+    def [](name)
+      if name == :value
+        node.value
+      else
+        node.attribute(name.to_s)
+      end
+    rescue Selenium::WebDriver::Error::WebDriverError
+      nil
+    end
+
+    def value
+      if tag_name == "select" and self[:multiple]
+        node.find_elements(:xpath, ".//option").select { |n| n.selected? }.map { |n| n.text }
+      else
+        super
+      end
+    end
+
+    def set(value)
+      if tag_name == 'textarea' or (tag_name == 'input' and %w(text password hidden file).include?(type))
+        node.clear
+        node.send_keys(value.to_s)
+      elsif tag_name == 'input' and type == 'radio'
+        node.click
+      elsif tag_name == 'input' and type == 'checkbox'
+        node.click if node.attribute('checked') != value
+      end
+    end
+
+    def select(option)
+      option_node = node.find_element(:xpath, ".//option[text()=#{Capybara::XPath.escape(option)}]") || node.find_element(:xpath, ".//option[contains(.,#{Capybara::XPath.escape(option)})]")
+      option_node.select
+    rescue 
+      options = node.find_elements(:xpath, "//option").map { |o| "'#{o.text}'" }.join(', ')
+      raise Capybara::OptionNotFound, "No such option '#{option}' in this select box. Available options: #{options}"
+    end
+
+    def unselect(option)
+      if node['multiple'] != 'multiple'
+        raise Capybara::UnselectNotAllowed, "Cannot unselect option '#{option}' from single select box."
+      end
+
+      begin
+        option_node = node.find_element(:xpath, ".//option[text()=#{Capybara::XPath.escape(option)}]") || node.find_element(:xpath, ".//option[contains(.,#{Capybara::XPath.escape(option)})]")
+        option_node.clear
+      rescue
+        options = node.find_elements(:xpath, "//option").map { |o| "'#{o.text}'" }.join(', ')
+        raise Capybara::OptionNotFound, "No such option '#{option}' in this select box. Available options: #{options}"
+      end
+    end
+
+    def click
+      node.click
+    end
+
+    def drag_to(element)
+      node.drag_and_drop_on(element.node)
+    end
+
+    def tag_name
+      node.tag_name
+    end
+
+    def visible?
+        begin
+            node.displayed? and node.displayed? != "false"
+        rescue Selenium::WebDriver::Error::WebDriverError
+            # rescues the inevitable "Selenium::WebDriver::Error::WebDriverError: element is obsolete" if you check to see if an element that has been removed from the DOM is visible
+            return false
+        end
+    end
+    
+    def trigger(event)
+    end
+
+  private
+
+    def all_unfiltered(locator)
+      node.find_elements(:xpath, locator).map { |n| self.class.new(driver, n) }
+    end
+
+    def type
+      self[:type]
+    end
+
+  end
+
+  attr_reader :app, :rack_server
+
+  def self.driver
+    unless @driver
+      @driver = Selenium::WebDriver.for :firefox
+      at_exit do
+        @driver.quit
+      end
+    end
+    @driver
+  end
+
+  def initialize(app)
+    @app = app
+    @rack_server = Capybara::Server.new(@app)
+    @rack_server.boot if Capybara.run_server
+  end
+
+  def visit(path)
+    browser.navigate.to(url(path))
+  end
+
+  def source
+    browser.page_source
+  end
+
+  def body
+    browser.page_source
+  end
+
+  def current_url
+    browser.current_url
+  end
+
+  def find(selector)
+    browser.find_elements(:xpath, selector).map { |node| Node.new(self, node) }
+  end
+
+  def wait?; true; end
+
+  def evaluate_script(script)
+    browser.execute_script "return #{script}"
+  end
+
+  def browser
+    self.class.driver
+  end
+
+  def cleanup!
+    browser.manage.delete_all_cookies
+  end
+
+  def within_frame(frame_id)
+    old_window = browser.window_handle
+    browser.switch_to.frame(frame_id)
+    yield
+    browser.switch_to.window old_window
+  end
+
+private
+
+  def url(path)
+    rack_server.url(path)
+  end
+
+end

data/lib/capybara/dsl.rb

@@ -0,0 +1,60 @@
+require 'capybara'
+
+module Capybara
+  class << self
+    attr_writer :default_driver, :current_driver, :javascript_driver
+
+    attr_accessor :app
+
+    def default_driver
+      @default_driver || :rack_test
+    end
+
+    def current_driver
+      @current_driver || default_driver
+    end
+    alias_method :mode, :current_driver
+
+    def javascript_driver
+      @javascript_driver || :selenium
+    end
+
+    def use_default_driver
+      @current_driver = nil
+    end
+
+    def current_session
+      session_pool["#{current_driver}#{app.object_id}"] ||= Capybara::Session.new(current_driver, app)
+    end
+
+    def current_session?
+      session_pool.has_key?("#{current_driver}#{app.object_id}")
+    end
+
+    def reset_sessions!
+      session_pool.each { |mode, session| session.cleanup! }
+      @session_pool = nil
+    end
+
+  private
+
+    def session_pool
+      @session_pool ||= {}
+    end
+  end
+
+  extend(self)
+
+  def page
+    Capybara.current_session
+  end
+
+  Session::DSL_METHODS.each do |method|
+    class_eval <<-RUBY, __FILE__, __LINE__+1
+      def #{method}(*args, &block)
+        page.#{method}(*args, &block)
+      end
+    RUBY
+  end
+
+end

data/lib/capybara/node.rb

@@ -0,0 +1,60 @@
+module Capybara
+  class Node
+    include Searchable
+
+    attr_reader :driver, :node
+
+    def initialize(driver, node)
+      @driver = driver
+      @node = node
+    end
+
+    def text
+      raise NotImplementedError
+    end
+
+    def [](name)
+      raise NotImplementedError
+    end
+
+    def value
+      self[:value]
+    end
+
+    def set(value)
+      raise NotImplementedError
+    end
+
+    def select(option)
+      raise NotImplementedError
+    end
+
+    def unselect(option)
+      raise NotImplementedError
+    end
+
+    def click
+      raise NotImplementedError
+    end
+
+    def drag_to(element)
+      raise NotImplementedError
+    end
+
+    def tag_name
+      raise NotImplementedError
+    end
+
+    def visible?
+      raise NotImplementedError
+    end
+
+    def path
+      raise NotSupportedByDriverError
+    end
+    
+    def trigger(event)
+      raise NotSupportedByDriverError
+    end
+  end
+end

data/lib/capybara/rails.rb

@@ -0,0 +1,17 @@
+require 'capybara'
+require 'capybara/dsl'
+
+Capybara.app = Rack::Builder.new do
+  map "/" do
+    if Rails.version.to_f >= 3.0
+      ActionDispatch::Static
+      run Rails.application  
+    else # Rails 2
+      use Rails::Rack::Static
+      run ActionController::Dispatcher.new
+    end
+  end
+end.to_app
+
+Capybara.asset_root = Rails.root.join('public')
+

data/lib/capybara/save_and_open_page.rb

@@ -0,0 +1,33 @@
+module Capybara
+  module SaveAndOpenPage
+    extend(self)
+
+    def save_and_open_page(html)
+      name="capybara-#{Time.new.strftime("%Y%m%d%H%M%S")}.html"
+
+      FileUtils.touch(name) unless File.exist?(name)
+
+      tempfile = File.new(name,'w')
+      tempfile.write(rewrite_css_and_image_references(html))
+      tempfile.close
+
+      open_in_browser(tempfile.path)
+    end
+
+    def open_in_browser(path) # :nodoc
+      require "launchy"
+      Launchy::Browser.run(path)
+    rescue LoadError
+      warn "Sorry, you need to install launchy to open pages: `gem install launchy`"
+    end
+
+    def rewrite_css_and_image_references(response_html) # :nodoc:
+      return response_html unless Capybara.asset_root
+      directories = Dir.new(Capybara.asset_root).entries.inject([]) do |list, name|
+        list << name if File.directory?(name) and not name.to_s =~ /^\./
+        list
+      end
+      response_html.gsub(/("|')\/(#{directories.join('|')})/, '\1' + Capybara.asset_root.to_s + '/\2')
+    end
+  end
+end

data/lib/capybara/searchable.rb

@@ -0,0 +1,54 @@
+module Capybara
+  module Searchable
+    def find(*args)
+      all(*args).first
+    end
+
+    def find_field(locator)
+      find(:xpath, XPath.field(locator))
+    end
+    alias_method :field_labeled, :find_field
+
+    def find_link(locator)
+      find(:xpath, XPath.link(locator))
+    end
+
+    def find_button(locator)
+      find(:xpath, XPath.button(locator))
+    end
+
+    def find_by_id(id)
+      find(:css, "##{id}")
+    end
+
+    def all(*args)
+      options = if args.last.is_a?(Hash) then args.pop else {} end
+      if args[1].nil?
+        kind, locator = Capybara.default_selector, args.first
+      else
+        kind, locator = args
+      end
+      locator = XPath.from_css(locator) if kind == :css
+
+      results = all_unfiltered(locator)
+
+      if options[:text]
+        options[:text] = Regexp.escape(options[:text]) unless options[:text].kind_of?(Regexp)
+        results = results.select { |n| n.text.match(options[:text]) }
+      end
+
+      if options[:visible] or Capybara.ignore_hidden_elements
+        results = results.select { |n| n.visible? }
+      end
+
+      results
+    end
+
+    private
+
+    def all_unfiltered(locator)
+      raise "Must be overridden"
+    end
+
+  end
+end

data/lib/capybara/server.rb

@@ -0,0 +1,114 @@
+require 'uri'
+require 'net/http'
+require 'rack'
+
+class Capybara::Server
+  class Identify
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      if env["PATH_INFO"] == "/__identify__"
+        [200, {}, @app.object_id.to_s]
+      else
+        @app.call(env)
+      end
+    end
+  end
+
+  attr_reader :app, :port
+
+  def initialize(app)
+    @app = app
+  end
+
+  def host
+    "localhost" 
+  end
+
+  def url(path)
+    if path =~ /^http/
+      path
+    else
+      (Capybara.app_host || "http://#{host}:#{port}") + path.to_s
+    end
+  end
+
+  def responsive?
+    is_running_on_port?(port)
+  end
+
+  def handler
+    begin
+      require 'rack/handler/thin'
+      Rack::Handler::Thin
+    rescue LoadError
+      begin
+        require 'rack/handler/mongrel'
+        Rack::Handler::Mongrel
+      rescue LoadError
+        require 'rack/handler/webrick'
+        Rack::Handler::WEBrick
+      end
+    end
+  end
+
+  def boot
+    return self unless @app
+    find_available_port
+    Capybara.log "application has already booted" and return self if responsive?
+    Capybara.log "booting Rack applicartion on port #{port}"
+
+    Thread.new do
+      handler.run(Identify.new(@app), :Port => port, :AccessLog => [])
+    end
+    Capybara.log "checking if application has booted"
+
+    Capybara::WaitUntil.timeout(10) do
+      if responsive?
+        Capybara.log("application has booted")
+        true
+      else
+        sleep 0.5
+        false
+      end
+    end
+    self
+  rescue Timeout::Error
+    Capybara.log "Rack application timed out during boot"
+    exit
+  end
+
+private
+
+  def find_available_port
+    @port = 9887
+    @port += 1 while is_port_open?(@port) and not is_running_on_port?(@port)
+  end
+
+  def is_running_on_port?(tested_port)
+    res = Net::HTTP.start(host, tested_port) { |http| http.get('/__identify__') }
+
+    if res.is_a?(Net::HTTPSuccess) or res.is_a?(Net::HTTPRedirection)
+      return res.body == @app.object_id.to_s
+    end
+  rescue Errno::ECONNREFUSED, Errno::EBADF
+    return false
+  end
+
+  def is_port_open?(tested_port)
+    Timeout::timeout(1) do
+      begin
+        s = TCPSocket.new(host, tested_port)
+        s.close
+        return true
+      rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+        return false
+      end
+    end
+  rescue Timeout::Error
+    return false
+  end
+
+end