otherinbox-capybara-webkit 0.12.0

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.0'.freeze
+    end
+  end
+end

data/lib/capybara/webkit.rb

@@ -0,0 +1,11 @@
+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|
+  browser = Capybara::Driver::Webkit::Browser.new(:socket_class => Capybara::Driver::Webkit::SocketDebugger)
+  Capybara::Driver::Webkit.new(app, :browser => browser)
+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_builder.rb

@@ -0,0 +1,68 @@
+require "fileutils"
+require "rbconfig"
+
+module CapybaraWebkitBuilder
+  extend self
+
+  def make_bin
+    ENV['MAKE'] || 'make'
+  end
+
+  def qmake_bin
+    ENV['QMAKE'] || 'qmake'
+  end
+
+  def spec
+    ENV['SPEC'] || os_spec
+  end
+
+  def os_spec
+    case RbConfig::CONFIG['host_os']
+    when /linux/
+      "linux-g++"
+    when /freebsd/
+      "freebsd-g++"
+    when /mingw32/
+      "win32-g++"
+    else
+      "macx-g++"
+    end
+  end
+
+  def makefile
+    system("#{qmake_bin} -spec #{spec}")
+  end
+
+  def qmake
+    system("#{make_bin} qmake")
+  end
+
+  def path_to_binary
+    case RUBY_PLATFORM
+    when /mingw32/
+      "src/debug/webkit_server.exe"
+    else
+      "src/webkit_server"
+    end
+  end
+
+  def build
+    system(make_bin) or return false
+
+    FileUtils.mkdir("bin") unless File.directory?("bin")
+    FileUtils.cp(path_to_binary, "bin", :preserve => true)
+  end
+
+  def clean
+    File.open("Makefile", "w") do |file|
+      file.print "all:\n\t@echo ok\ninstall:\n\t@echo ok"
+    end
+  end
+
+  def build_all
+    makefile &&
+    qmake &&
+    build &&
+    clean
+  end
+end