imseng-capybara-webkit 0.12.1

data/lib/capybara/driver/webkit/browser.rb

@@ -0,0 +1,164 @@
+require 'json'
+
+class Capybara::Driver::Webkit
+  class Browser
+    def initialize(connection)
+      @connection = connection
+    end
+
+    def visit(url)
+      command "Visit", url
+    end
+
+    def header(key, value)
+      command("Header", key, value)
+    end
+
+    def find(query)
+      command("Find", query).split(",")
+    end
+
+    def reset!
+      command("Reset")
+    end
+
+    def body
+      command("Body")
+    end
+
+    def source
+      command("Source")
+    end
+
+    def status_code
+      command("Status").to_i
+    end
+
+    def console_messages
+      command("ConsoleMessages").split("\n").map do |messages|
+        parts = messages.split("|", 3)
+        { :source => parts.first, :line_number => Integer(parts[1]), :message => parts.last }
+      end
+    end
+
+    def error_messages
+      console_messages.select do |message|
+        message[:message] =~ /Error:/
+      end
+    end
+
+    def response_headers
+      Hash[command("Headers").split("\n").map { |header| header.split(": ") }]
+    end
+
+    def url
+      command("Url")
+    end
+
+    def requested_url
+      command("RequestedUrl")
+    end
+
+    def current_url
+      command("CurrentUrl")
+    end
+
+    def frame_focus(frame_id_or_index=nil)
+      if frame_id_or_index.is_a? Fixnum
+        command("FrameFocus", "", frame_id_or_index.to_s)
+      elsif frame_id_or_index
+        command("FrameFocus", frame_id_or_index)
+      else
+        command("FrameFocus")
+      end
+    end
+
+    def ignore_ssl_errors
+      command("IgnoreSslErrors")
+    end
+
+    def command(name, *args)
+      @connection.puts name
+      @connection.puts args.size
+      args.each do |arg|
+        @connection.puts arg.to_s.bytesize
+        @connection.print arg.to_s
+      end
+      check
+      read_response
+    end
+
+    def evaluate_script(script)
+      json = command('Evaluate', script)
+      JSON.parse("[#{json}]").first
+    end
+
+    def execute_script(script)
+      command('Execute', script)
+    end
+
+    def render(path, width, height)
+      command "Render", path, width, height
+    end
+
+    def set_cookie(cookie)
+      command "SetCookie", cookie
+    end
+
+    def clear_cookies
+      command "ClearCookies"
+    end
+
+    def get_cookies
+      command("GetCookies").lines.map{ |line| line.strip }.select{ |line| !line.empty? }
+    end
+
+    def set_proxy(options = {})
+      options = default_proxy_options.merge(options)
+      command("SetProxy", options[:host], options[:port], options[:user], options[:pass])
+    end
+
+    def clear_proxy
+      command("SetProxy")
+    end
+
+    def resize_window(width, height)
+      command("ResizeWindow", width.to_i, height.to_i)
+    end
+
+    private
+
+    def check
+      result = @connection.gets
+      result.strip! if result
+
+      if result.nil?
+        raise WebkitNoResponseError, "No response received from the server."
+      elsif result != 'ok' 
+        raise WebkitInvalidResponseError, read_response
+      end
+
+      result
+    end
+
+    def read_response
+      response_length = @connection.gets.to_i
+      if response_length > 0
+        response = @connection.read(response_length)
+        response.force_encoding("UTF-8") if response.respond_to?(:force_encoding)
+        response
+      else
+        ""
+      end
+    end
+
+    def default_proxy_options
+      {
+        :host => "localhost",
+        :port => "0",
+        :user => "",
+        :pass => ""
+      }
+    end
+  end
+end

data/lib/capybara/driver/webkit/connection.rb

@@ -0,0 +1,120 @@
+require 'socket'
+require 'timeout'
+require 'thread'
+
+class Capybara::Driver::Webkit
+  class Connection
+    WEBKIT_SERVER_START_TIMEOUT = 15
+
+    attr_reader :port
+
+    def initialize(options = {})
+      @socket_class = options[:socket_class] || TCPSocket
+      @stdout       = options.has_key?(:stdout) ?
+                        options[:stdout] :
+                        $stdout
+      start_server
+      connect
+    end
+
+    def puts(string)
+      @socket.puts string
+    end
+
+    def print(string)
+      @socket.print string
+    end
+
+    def gets
+      @socket.gets
+    end
+
+    def read(length)
+      @socket.read(length)
+    end
+
+    private
+
+    def start_server
+      pipe = fork_server
+      @port = discover_port(pipe)
+      @stdout_thread = Thread.new do
+        Thread.current.abort_on_exception = true
+        forward_stdout(pipe)
+      end
+    end
+
+    def fork_server
+      server_path = File.expand_path("../../../../../bin/webkit_server", __FILE__)
+      pipe, @pid = server_pipe_and_pid(server_path)
+      register_shutdown_hook
+      pipe
+    end
+
+    def kill_process(pid)
+      if RUBY_PLATFORM =~ /mingw32/
+        Process.kill(9, pid)
+      else
+        Process.kill("INT", pid)
+      end
+    end
+
+    def register_shutdown_hook
+      @owner_pid = Process.pid
+      at_exit do
+        if Process.pid == @owner_pid
+          kill_process(@pid)
+        end
+      end
+    end
+
+    def server_pipe_and_pid(server_path)
+      cmdline = [server_path]
+      pipe = IO.popen(cmdline.join(" "))
+      [pipe, pipe.pid]
+    end
+
+    def discover_port(read_pipe)
+      return unless IO.select([read_pipe], nil, nil, WEBKIT_SERVER_START_TIMEOUT)
+      ((read_pipe.first || '').match(/listening on port: (\d+)/) || [])[1].to_i
+    end
+
+    def forward_stdout(pipe)
+      while pipe_readable?(pipe)
+        line = pipe.readline
+        if @stdout
+          @stdout.write(line)
+          @stdout.flush
+        end
+      end
+    rescue EOFError
+    end
+
+    def connect
+      Timeout.timeout(5) do
+        while @socket.nil?
+          attempt_connect
+        end
+      end
+    end
+
+    def attempt_connect
+      @socket = @socket_class.open("127.0.0.1", @port)
+    rescue Errno::ECONNREFUSED
+    end
+
+    if !defined?(RUBY_ENGINE) || (RUBY_ENGINE == "ruby" && RUBY_VERSION <= "1.8")
+      # please note the use of IO::select() here, as it is used specifically to
+      # preserve correct signal handling behavior in ruby 1.8.
+      # https://github.com/thibaudgg/rb-fsevent/commit/d1a868bf8dc72dbca102bedbadff76c7e6c2dc21
+      # https://github.com/thibaudgg/rb-fsevent/blob/1ca42b987596f350ee7b19d8f8210b7b6ae8766b/ext/fsevent/fsevent_watch.c#L171
+      def pipe_readable?(pipe)
+        IO.select([pipe])
+      end
+    else
+      def pipe_readable?(pipe)
+        !pipe.eof?
+      end
+    end
+  end
+end

data/lib/capybara/driver/webkit/cookie_jar.rb

@@ -0,0 +1,55 @@
+require 'webrick'
+
+# A simple cookie jar implementation.
+# Does not take special cookie attributes
+# into account like expire, max-age, httponly, secure
+class Capybara::Driver::Webkit::CookieJar
+  attr_reader :browser
+
+  def initialize(browser)
+    @browser = browser
+  end
+
+  def [](*args)
+    cookie = find(*args)
+    cookie && cookie.value
+  end
+
+  def find(name, domain = nil, path = "/")
+    # we are sorting by path size because more specific paths take
+    # precendence
+    cookies.sort_by { |c| -c.path.size }.find { |c|
+      c.name.downcase == name.downcase &&
+      (!domain || valid_domain?(c, domain)) &&
+      (!path   || valid_path?(c, path))
+    }
+  end
+
+ protected
+
+  def valid_domain?(cookie, domain)
+    ends_with?(("." + domain).downcase,
+               normalize_domain(cookie.domain).downcase)
+  end
+
+  def normalize_domain(domain)
+    domain = "." + domain unless domain[0,1] == "."
+    domain
+  end
+
+  def valid_path?(cookie, path)
+    starts_with?(path, cookie.path)
+  end
+
+  def ends_with?(str, suffix)
+    str[-suffix.size..-1] == suffix
+  end
+
+  def starts_with?(str, prefix)
+    str[0, prefix.size] == prefix
+  end
+
+  def cookies
+    browser.get_cookies.map { |c| WEBrick::Cookie.parse_set_cookie(c) }
+  end
+end

data/lib/capybara/driver/webkit/node.rb

@@ -0,0 +1,118 @@
+class Capybara::Driver::Webkit
+  class Node < Capybara::Driver::Node
+    NBSP = "\xC2\xA0"
+    NBSP.force_encoding("UTF-8") if NBSP.respond_to?(:force_encoding)
+
+    def text
+      invoke("text").gsub(NBSP, ' ').gsub(/\s+/u, ' ').strip
+    end
+
+    def [](name)
+      value = invoke("attribute", name)
+      if name == 'checked' || name == 'disabled'
+        value == 'true'
+      else
+        value
+      end
+    end
+
+    def value
+      if multiple_select?
+        self.find(".//option").select(&:selected?).map(&:value)
+      else
+        invoke "value"
+      end
+    end
+
+    def set(value)
+      invoke "set", value
+    end
+
+    def select_option
+      invoke "selectOption"
+    end
+
+    def unselect_option
+      select = find("ancestor::select").first
+      if select.multiple_select?
+        invoke "unselectOption"
+      else
+        raise Capybara::UnselectNotAllowed
+      end
+    end
+
+    def click
+      invoke "click"
+    end
+
+    def drag_to(element)
+      invoke 'dragTo', element.native
+    end
+
+    def tag_name
+      invoke "tagName"
+    end
+
+    def visible?
+      invoke("visible") == "true"
+    end
+
+    def selected?
+      invoke("selected") == "true"
+    end
+
+    def checked?
+      self['checked']
+    end
+
+    def disabled?
+      self['disabled']
+    end
+
+    def path
+      invoke "path"
+    end
+
+    def submit(opts = {})
+      invoke "submit"
+    end
+
+    def trigger(event)
+      invoke "trigger", event
+    end
+
+    def find(xpath)
+      invoke("findWithin", xpath).split(',').map do |native|
+        self.class.new(driver, native)
+      end
+    end
+
+    def invoke(name, *args)
+      if allow_unattached_nodes? || attached?
+        browser.command "Node", name, native, *args
+      else
+        raise Capybara::Driver::Webkit::NodeNotAttachedError
+      end
+    end
+
+    def allow_unattached_nodes?
+      !automatic_reload?
+    end
+
+    def automatic_reload?
+      Capybara.respond_to?(:automatic_reload) && Capybara.automatic_reload
+    end
+
+    def attached?
+      browser.command("Node", "isAttached", native) == "true"
+    end
+
+    def browser
+      driver.browser
+    end
+
+    def multiple_select?
+      self.tag_name == "select" && self["multiple"] == "multiple"
+    end
+  end
+end

data/lib/capybara/driver/webkit/socket_debugger.rb

@@ -0,0 +1,43 @@
+# Wraps the TCP socket and prints data sent and received. Used for debugging
+# the wire protocol. You can use this by passing a :socket_class to Browser.
+class Capybara::Driver::Webkit
+  class SocketDebugger
+    def self.open(host, port)
+      real_socket = TCPSocket.open(host, port)
+      new(real_socket)
+    end
+
+    def initialize(socket)
+      @socket = socket
+    end
+
+    def read(length)
+      received @socket.read(length)
+    end
+
+    def puts(line)
+      sent line
+      @socket.puts(line)
+    end
+
+    def print(content)
+      sent content
+      @socket.print(content)
+    end
+
+    def gets
+      received @socket.gets
+    end
+
+    private
+
+    def sent(content)
+      Kernel.puts " >> " + content.to_s
+    end
+
+    def received(content)
+      Kernel.puts " << " + content.to_s
+      content
+    end
+  end
+end

data/lib/capybara/driver/webkit/version.rb

@@ -0,0 +1,7 @@
+module Capybara
+  module Driver
+    class Webkit
+      VERSION = '0.12.1'.freeze
+    end
+  end
+end

data/lib/capybara/driver/webkit.rb

@@ -0,0 +1,136 @@
+require "capybara"
+require "capybara/driver/webkit/version"
+require "capybara/driver/webkit/node"
+require "capybara/driver/webkit/connection"
+require "capybara/driver/webkit/browser"
+require "capybara/driver/webkit/socket_debugger"
+require "capybara/driver/webkit/cookie_jar"
+
+class Capybara::Driver::Webkit
+  class WebkitInvalidResponseError < StandardError
+  end
+
+  class WebkitNoResponseError < StandardError
+  end
+
+  class NodeNotAttachedError < Capybara::ElementNotFound
+  end
+
+  attr_reader :browser
+
+  def initialize(app, options={})
+    @app = app
+    @options = options
+    @rack_server = Capybara::Server.new(@app)
+    @rack_server.boot if Capybara.run_server
+    @browser = options[:browser] || Browser.new(Connection.new(options))
+    @browser.ignore_ssl_errors if options[:ignore_ssl_errors]
+  end
+
+  def current_url
+    browser.current_url
+  end
+
+  def requested_url
+    browser.requested_url
+  end
+
+  def visit(path)
+    browser.visit(url(path))
+  end
+
+  def find(query)
+    browser.find(query).map { |native| Node.new(self, native) }
+  end
+
+  def source
+    browser.source
+  end
+
+  def body
+    browser.body
+  end
+
+  def header(key, value)
+    browser.header(key, value)
+  end
+
+  def execute_script(script)
+    value = browser.execute_script script
+    value.empty? ? nil : value
+  end
+
+  def evaluate_script(script)
+    browser.evaluate_script script
+  end
+
+  def console_messages
+    browser.console_messages
+  end
+
+  def error_messages
+    browser.error_messages
+  end
+
+  def response_headers
+    browser.response_headers
+  end
+
+  def status_code
+    browser.status_code
+  end
+
+  def resize_window(width, height)
+    browser.resize_window(width, height)
+  end
+
+  def within_frame(frame_id_or_index)
+    browser.frame_focus(frame_id_or_index)
+    begin
+      yield
+    ensure
+      browser.frame_focus
+    end
+  end
+
+  def within_window(handle)
+    raise Capybara::NotSupportedByDriverError
+  end
+
+  def wait?
+    true
+  end
+
+  def wait_until(*args)
+  end
+
+  def reset!
+    browser.reset!
+  end
+
+  def has_shortcircuit_timeout?
+    false
+  end
+
+  def render(path, options={})
+    options[:width]  ||= 1000
+    options[:height] ||= 10
+
+    browser.render path, options[:width], options[:height]
+  end
+
+  def server_port
+    @rack_server.port
+  end
+
+  def cookies
+    @cookie_jar ||= CookieJar.new(browser)
+  end
+
+  private
+
+  def url(path)
+    @rack_server.url(path)
+  end
+end
+

data/lib/capybara/webkit/matchers.rb

@@ -0,0 +1,37 @@
+module Capybara
+  module Webkit
+    module RspecMatchers
+      RSpec::Matchers.define :have_errors do |expected|
+        match do |actual|
+          actual = resolve(actual)
+          actual.error_messages.any?
+        end
+
+        failure_message_for_should do |actual|
+          "Expected Javascript errors, but there were none."
+        end
+        
+        failure_message_for_should_not do |actual|
+          actual = resolve(actual)
+          "Expected no Javascript errors, got:\n#{error_messages_for(actual)}"
+        end
+
+        def error_messages_for(obj)
+          obj.error_messages.map do |m|
+            "  - #{m[:message]}"
+          end.join("\n")
+        end
+
+        def resolve(actual)
+          if actual.respond_to? :page
+            actual.page.driver
+          elsif actual.respond_to? :driver
+            actual.driver
+          else
+            actual
+          end
+        end
+      end
+    end
+  end
+end

data/lib/capybara/webkit.rb

@@ -0,0 +1,13 @@
+require "capybara"
+require "capybara/driver/webkit"
+
+Capybara.register_driver :webkit do |app|
+  Capybara::Driver::Webkit.new(app)
+end
+
+Capybara.register_driver :webkit_debug do |app|
+  connection = Capybara::Driver::Webkit::Connection.new(
+    :socket_class => Capybara::Driver::Webkit::SocketDebugger)
+  browser = Capybara::Driver::Webkit::Browser.new(connection)
+  Capybara::Driver::Webkit.new(app, :browser => browser)
+end

data/lib/capybara-webkit.rb

@@ -0,0 +1 @@
+require "capybara/webkit"