poltergeist 0.1.0

data/lib/capybara/poltergeist/client/web_page.coffee

@@ -0,0 +1,102 @@
+class Poltergeist.WebPage
+  @CALLBACKS = ['onAlert', 'onConsoleMessage', 'onLoadFinished', 'onInitialized',
+                'onLoadStarted', 'onResourceRequested', 'onResourceReceived']
+  @DELEGATES = ['open', 'sendEvent', 'uploadFile', 'release', 'render']
+  @COMMANDS  = ['currentUrl', 'find', 'nodeCall', 'pushFrame', 'popFrame', 'documentSize']
+
+  constructor: ->
+    @native  = require('webpage').create()
+    @nodes   = {}
+    @_source = ""
+
+    for callback in WebPage.CALLBACKS
+      this.bindCallback(callback)
+
+    this.injectAgent()
+
+  for command in @COMMANDS
+    do (command) =>
+      this.prototype[command] =
+        (arguments...) -> this.runCommand(command, arguments)
+
+  for delegate in @DELEGATES
+    do (delegate) =>
+      this.prototype[delegate] =
+        -> @native[delegate].apply(@native, arguments)
+
+  onInitializedNative: ->
+    @_source = null
+    this.injectAgent()
+    this.setScrollPosition({ left: 0, top: 0})
+
+  injectAgent: ->
+    if this.evaluate(-> typeof __poltergeist) == "undefined"
+      @native.injectJs('agent.js')
+
+  onConsoleMessageNative: (message) ->
+    if message == '__DOMContentLoaded'
+      @_source = @native.content
+      false
+
+  onLoadFinishedNative: ->
+    @_source or= @native.content
+
+  onConsoleMessage: (message) ->
+    console.log(message)
+
+  content: ->
+    @native.content
+
+  source: ->
+    @_source
+
+  viewportSize: ->
+    @native.viewportSize
+
+  scrollPosition: ->
+    @native.scrollPosition
+
+  setScrollPosition: (pos) ->
+    @native.scrollPosition = pos
+
+  viewport: ->
+    scroll = this.scrollPosition()
+    size   = this.viewportSize()
+
+    top:    scroll.top,  bottom: scroll.top + size.height,
+    left:   scroll.left, right:  scroll.left + size.width,
+    width:  size.width,  height: size.height
+
+  get: (id) ->
+    @nodes[id] or= new Poltergeist.Node(this, id)
+
+  evaluate: (fn, args...) ->
+    @native.evaluate("function() { return #{this.stringifyCall(fn, args)} }")
+
+  execute: (fn, args...) ->
+    @native.evaluate("function() { #{this.stringifyCall(fn, args)} }")
+
+  stringifyCall: (fn, args) ->
+    if args.length == 0
+      "(#{fn.toString()})()"
+    else
+      # The JSON.stringify happens twice because the second time we are essentially
+      # escaping the string.
+      "(#{fn.toString()}).apply(this, JSON.parse(#{JSON.stringify(JSON.stringify(args))}))"
+
+  # For some reason phantomjs seems to have trouble with doing 'fat arrow' binding here,
+  # hence the 'that' closure.
+  bindCallback: (name) ->
+    that = this
+    @native[name] = ->
+      if that[name + 'Native']? # For internal callbacks
+        result = that[name + 'Native'].apply(that, arguments)
+
+      if result != false && that[name]? # For externally set callbacks
+        that[name].apply(that, arguments)
+
+  runCommand: (name, arguments) ->
+    this.evaluate(
+      (name, arguments) -> __poltergeist[name].apply(__poltergeist, arguments),
+      name, arguments
+    )

data/lib/capybara/poltergeist/client.rb

@@ -0,0 +1,57 @@
+require 'open3'
+
+module Capybara::Poltergeist
+  class Client
+    PHANTOM_SCRIPT = File.expand_path('../client/compiled/main.js', __FILE__)
+
+    attr_reader :pid, :port, :path
+
+    def initialize(port, path = nil)
+      @port = port
+      @path = path || 'phantomjs'
+
+      start
+      at_exit { stop }
+    end
+
+    def start
+      @pid = Process.fork do
+        Open3.popen3("#{path} #{PHANTOM_SCRIPT} #{port}") do |stdin, stdout, stderr|
+          loop do
+            select = IO.select([stdout, stderr])
+            stream = select.first.first
+
+            break if stream.eof?
+
+            if stream == stdout
+              STDOUT.puts stdout.readline
+            elsif stream == stderr
+              line = stderr.readline
+
+              # QtWebkit seems to throw this error all the time when using WebSockets, but
+              # it doesn't appear to actually stop anything working, so filter it out.
+              #
+              # This isn't the nicest solution I know :( Hopefully it will be fixed in
+              # QtWebkit (if you search for this string, you'll see it's been reported in
+              # various places).
+              unless line.include?('WebCore::SocketStreamHandlePrivate::socketSentData()')
+                STDERR.puts line
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def stop
+      Process.kill('TERM', pid)
+    rescue Errno::ESRCH
+      # Bovvered, I ain't
+    end
+
+    def restart
+      stop
+      start
+    end
+  end
+end

data/lib/capybara/poltergeist/driver.rb

@@ -0,0 +1,85 @@
+module Capybara::Poltergeist
+  class Driver < Capybara::Driver::Base
+    attr_reader :app, :server, :browser, :options
+
+    def initialize(app, options = {})
+      @app     = app
+      @options = options
+      @server  = Capybara::Server.new(app)
+      @browser = nil
+
+      @server.boot if Capybara.run_server
+    end
+
+    def browser
+      @browser ||= Browser.new(
+        :logger    => logger,
+        :phantomjs => options[:phantomjs]
+      )
+    end
+
+    def restart
+      browser.restart
+    end
+
+    # logger should be an object that responds to puts, or nil
+    def logger
+      options[:logger] || (options[:debug] && STDERR)
+    end
+
+    def visit(path, attributes = {})
+      browser.visit(url(path), attributes)
+    end
+
+    def current_url
+      browser.current_url
+    end
+
+    def body
+      browser.body
+    end
+
+    def source
+      browser.source
+    end
+
+    def find(selector)
+      browser.find(selector).map { |node| Capybara::Poltergeist::Node.new(self, node) }
+    end
+
+    def evaluate_script(script)
+      browser.evaluate(script)
+    end
+
+    def execute_script(script)
+      browser.execute(script)
+      nil
+    end
+
+    def within_frame(id, &block)
+      browser.within_frame(id, &block)
+    end
+
+    def reset!
+      browser.reset
+    end
+
+    def render(path)
+      browser.render(path)
+    end
+
+    def wait?
+      true
+    end
+
+    def invalid_element_errors
+      [Capybara::Poltergeist::ObsoleteNode]
+    end
+
+    private
+
+    def url(path)
+      server.url(path)
+    end
+  end
+end

data/lib/capybara/poltergeist/errors.rb

@@ -0,0 +1,26 @@
+module Capybara
+  module Poltergeist
+    class Error < StandardError
+    end
+
+    class BrowserError < Error
+      attr_reader :text
+
+      def initialize(text)
+        @text = text
+      end
+
+      def message
+        "Received error from PhantomJS client: #{text}"
+      end
+    end
+
+    class ObsoleteNode < Error
+      attr_reader :node
+
+      def initialize(node)
+        @node = node
+      end
+    end
+  end
+end

data/lib/capybara/poltergeist/node.rb

@@ -0,0 +1,92 @@
+module Capybara::Poltergeist
+  class Node < Capybara::Driver::Node
+    alias id native
+
+    def browser
+      driver.browser
+    end
+
+    def command(name, *args)
+      browser.send(name, id, *args)
+    rescue BrowserError => error
+      if error.text == 'Poltergeist.ObsoleteNode'
+        raise ObsoleteNode.new(self)
+      else
+        raise error
+      end
+    end
+
+    def find(selector)
+      browser.find(selector, id).map { |node| self.class.new(driver, node) }
+    end
+
+    def text
+      command :text
+    end
+
+    def [](name)
+      command :attribute, name
+    end
+
+    def value
+      command :value
+    end
+
+    def set(value)
+      if tag_name == 'input'
+        type = self[:type]
+
+        if type == 'radio'
+          click
+        elsif type == 'checkbox'
+          if value && !checked? || !value && checked?
+            click
+          end
+        elsif type == 'file'
+          command :select_file, value
+        else
+          command :set, value
+        end
+      elsif tag_name == 'textarea'
+        command :set, value
+      end
+    end
+
+    def select_option
+      command :select, true
+    end
+
+    def unselect_option
+      command(:select, false) or
+      raise(Capybara::UnselectNotAllowed, "Cannot unselect option from single select box.")
+    end
+
+    def tag_name
+      @tag_name ||= command(:tag_name)
+    end
+
+    def visible?
+      command :visible?
+    end
+
+    def checked?
+      self[:checked]
+    end
+
+    def selected?
+      self[:selected]
+    end
+
+    def click
+      command :click
+    end
+
+    def drag_to(other)
+      command :drag, other.id
+    end
+
+    def trigger(event)
+      command :trigger, event
+    end
+  end
+end

data/lib/capybara/poltergeist/server.rb

@@ -0,0 +1,35 @@
+module Capybara::Poltergeist
+  class Server
+    attr_reader :port
+
+    def initialize
+      @port = find_available_port
+      start
+    end
+
+    def start
+      server_manager.start(port)
+    end
+
+    def restart
+      server_manager.restart(port)
+    end
+
+    def send(message)
+      server_manager.send(port, message)
+    end
+
+    private
+
+    def server_manager
+      ServerManager.instance
+    end
+
+    def find_available_port
+      server = TCPServer.new('127.0.0.1', 0)
+      server.addr[1]
+    ensure
+      server.close if server
+    end
+  end
+end

data/lib/capybara/poltergeist/server_manager.rb

@@ -0,0 +1,118 @@
+require 'em-websocket'
+require 'timeout'
+require 'singleton'
+
+module Capybara::Poltergeist
+  # The reason for the lolzy thread code is because the EM reactor blocks the thread, so
+  # we have to put it in its own thread.
+  #
+  # The reason we are using EM, is because it has a WebSocket library. If there's a decent
+  # WebSocket library that doesn't require an event loop, we can use that.
+  class ServerManager
+    include Singleton
+
+    TIMEOUT = 30
+
+    class TimeoutError < StandardError
+      def initialize(message)
+        super "Server timed out waiting for response to #{@message}"
+      end
+    end
+
+    attr_reader :sockets
+
+    def initialize
+      @instruction = nil
+      @response    = nil
+      @sockets     = {}
+      @waiting     = false
+
+      @main   = Thread.current
+      @thread = Thread.new { start_event_loop }
+      @thread.abort_on_exception = true
+    end
+
+    def start(port)
+      thread_execute { start_websocket_server(port) }
+    end
+
+    # This isn't a 'proper' restart. It's more like 'wait for the client to connect again'.
+    def restart(port)
+      sockets[port] = nil
+      @thread.run
+    end
+
+    def send(port, message)
+      @message = nil
+
+      Timeout.timeout(TIMEOUT, TimeoutError.new(message)) do
+        # Ensure there is a socket before trying to send a message on it.
+        Thread.pass until sockets[port]
+
+        # Send the message
+        thread_execute { sockets[port].send(message) }
+
+        # Wait for the response message
+        Thread.pass until @message
+      end
+
+      @message
+    end
+
+    def thread_execute(&instruction)
+      # Ensure that the thread is waiting for an instruction before we wake it up
+      # to receive the instruction
+      Thread.pass until @waiting
+
+      @instruction = instruction
+      @waiting     = false
+
+      # Bring the EM thread out of its sleep so that it can execute the instruction.
+      @thread.run
+    end
+
+    def start_event_loop
+      EM.run { await_instruction }
+    end
+
+    def start_websocket_server(port)
+      EventMachine.start_server('127.0.0.1', port, EventMachine::WebSocket::Connection, {}) do |socket|
+        socket.onopen do
+          connection_opened(port, socket)
+        end
+
+        socket.onmessage do |message|
+          message_received(message)
+        end
+      end
+    end
+
+    def connection_opened(port, socket)
+      sockets[port] = socket
+      await_instruction
+    end
+
+    def message_received(message)
+      @message = message
+      await_instruction
+    end
+
+    # Stop the thread so that it can be manually scheduled by the parent once there is
+    # something to do
+    def await_instruction
+      # Sleep this thread. The main thread will wake us up when there is an instruction
+      # to perform.
+      @waiting = true
+      Thread.stop
+
+      # Main thread has woken us up, so execute the current instruction.
+      if @instruction
+        @instruction.call
+        @instruction = nil
+      end
+
+      # Continue execution of the thread until a socket callback fires, which will
+      # trigger then method again and send us back to sleep.
+    end
+  end
+end

data/lib/capybara/poltergeist/version.rb

@@ -0,0 +1,5 @@
+module Capybara
+  module Poltergeist
+    VERSION = "0.1.0"
+  end
+end

data/lib/capybara/poltergeist.rb

@@ -0,0 +1,20 @@
+require 'capybara'
+
+module Capybara
+  module Poltergeist
+    autoload :Driver,        'capybara/poltergeist/driver'
+    autoload :Browser,       'capybara/poltergeist/browser'
+    autoload :Node,          'capybara/poltergeist/node'
+    autoload :ServerManager, 'capybara/poltergeist/server_manager'
+    autoload :Server,        'capybara/poltergeist/server'
+    autoload :Client,        'capybara/poltergeist/client'
+
+    autoload :Error,        'capybara/poltergeist/errors'
+    autoload :BrowserError, 'capybara/poltergeist/errors'
+    autoload :ObsoleteNode, 'capybara/poltergeist/errors'
+  end
+end
+
+Capybara.register_driver :poltergeist do |app|
+  Capybara::Poltergeist::Driver.new(app)
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: poltergeist
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Jon Leighton
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-27 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: capybara
+  requirement: &20250700 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *20250700
+- !ruby/object:Gem::Dependency
+  name: em-websocket
+  requirement: &20220020 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: *20220020
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: &20216800 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: *20216800
+description: PhantomJS driver for Capybara
+email:
+- j@jonathanleighton.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/capybara/poltergeist.rb
+- lib/capybara/poltergeist/client.rb
+- lib/capybara/poltergeist/server.rb
+- lib/capybara/poltergeist/browser.rb
+- lib/capybara/poltergeist/errors.rb
+- lib/capybara/poltergeist/version.rb
+- lib/capybara/poltergeist/driver.rb
+- lib/capybara/poltergeist/client/connection.coffee
+- lib/capybara/poltergeist/client/node.coffee
+- lib/capybara/poltergeist/client/compiled/agent.js
+- lib/capybara/poltergeist/client/compiled/browser.js
+- lib/capybara/poltergeist/client/compiled/main.js
+- lib/capybara/poltergeist/client/compiled/node.js
+- lib/capybara/poltergeist/client/compiled/connection.js
+- lib/capybara/poltergeist/client/compiled/web_page.js
+- lib/capybara/poltergeist/client/main.coffee
+- lib/capybara/poltergeist/client/web_page.coffee
+- lib/capybara/poltergeist/client/browser.coffee
+- lib/capybara/poltergeist/client/agent.coffee
+- lib/capybara/poltergeist/server_manager.rb
+- lib/capybara/poltergeist/node.rb
+- LICENSE
+- README.md
+- CHANGELOG.md
+homepage: http://github.com/jonleighton/poltergeist
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: PhantomJS driver for Capybara
+test_files: []