poltergeistFork 0.0.1

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

@@ -0,0 +1,423 @@
+# This is injected into each page that is loaded
+
+class PoltergeistAgent
+  # Since this code executes in the sites browser space - copy needed JSON functions
+  # in case user code messes with JSON (early mootools for instance)
+  @.JSON ||= { parse: JSON.parse, stringify: JSON.stringify }
+
+  constructor: ->
+    @elements = []
+    @nodes    = {}
+
+  externalCall: (name, args) ->
+    try
+      { value: this[name].apply(this, args) }
+    catch error
+      { error: { message: error.toString(), stack: error.stack } }
+
+  @stringify: (object) ->
+    try
+      PoltergeistAgent.JSON.stringify object, (key, value) ->
+        if Array.isArray(this[key])
+          return this[key]
+        else
+          return value
+    catch error
+      if error instanceof TypeError
+        '"(cyclic structure)"'
+      else
+        throw error
+
+  # Somehow PhantomJS returns all characters(brackets, etc) properly encoded
+  # except whitespace character in pathname part of the location. This hack
+  # is intended to fix this up.
+  currentUrl: ->
+    window.location.href.replace(/\ /g, '%20')
+
+  find: (method, selector, within = document) ->
+    try
+      if method == "xpath"
+        xpath   = document.evaluate(selector, within, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null)
+        results = (xpath.snapshotItem(i) for i in [0...xpath.snapshotLength])
+      else
+        results = within.querySelectorAll(selector)
+
+      this.register(el) for el in results
+    catch error
+      # DOMException.INVALID_EXPRESSION_ERR is undefined, using pure code
+      if error.code == DOMException.SYNTAX_ERR || error.code == 51
+        throw new PoltergeistAgent.InvalidSelector
+      else
+        throw error
+
+  register: (element) ->
+    @elements.push(element)
+    @elements.length - 1
+
+  documentSize: ->
+    height: document.documentElement.scrollHeight || document.documentElement.clientHeight,
+    width:  document.documentElement.scrollWidth  || document.documentElement.clientWidth
+
+  get: (id) ->
+    @nodes[id] or= new PoltergeistAgent.Node(this, @elements[id])
+
+  nodeCall: (id, name, args) ->
+    node = this.get(id)
+    throw new PoltergeistAgent.ObsoleteNode if node.isObsolete()
+    node[name].apply(node, args)
+
+  beforeUpload: (id) ->
+    this.get(id).setAttribute('_poltergeist_selected', '')
+
+  afterUpload: (id) ->
+    this.get(id).removeAttribute('_poltergeist_selected')
+
+  clearLocalStorage: ->
+    localStorage.clear()
+
+class PoltergeistAgent.ObsoleteNode
+  toString: -> "PoltergeistAgent.ObsoleteNode"
+
+class PoltergeistAgent.InvalidSelector
+  toString: -> "PoltergeistAgent.InvalidSelector"
+
+class PoltergeistAgent.Node
+  @EVENTS = {
+    FOCUS: ['blur', 'focus', 'focusin', 'focusout'],
+    MOUSE: ['click', 'dblclick', 'mousedown', 'mouseenter', 'mouseleave', 'mousemove',
+            'mouseover', 'mouseout', 'mouseup', 'contextmenu'],
+    FORM: ['submit']
+  }
+
+  constructor: (@agent, @element) ->
+
+  parentId: ->
+    @agent.register(@element.parentNode)
+
+  parentIds: ->
+    ids = []
+    parent = @element.parentNode
+    while parent != document
+      ids.push @agent.register(parent)
+      parent = parent.parentNode
+    ids
+
+  find: (method, selector) ->
+    @agent.find(method, selector, @element)
+
+  isObsolete: ->
+    obsolete = (element) =>
+      if (parent = element.parentNode)?
+        if parent == document
+          return false
+        else
+          obsolete parent
+      else
+        return true
+    obsolete @element
+
+  changed: ->
+    event = document.createEvent('HTMLEvents')
+    event.initEvent('change', true, false)
+
+    # In the case of an OPTION tag, the change event should come
+    # from the parent SELECT
+    if @element.nodeName == 'OPTION'
+      element = @element.parentNode
+      element = element.parentNode if element.nodeName == 'OPTGROUP'
+      element
+    else
+      element = @element
+
+    element.dispatchEvent(event)
+
+  input: ->
+    event = document.createEvent('HTMLEvents')
+    event.initEvent('input', true, false)
+    @element.dispatchEvent(event)
+
+  keyupdowned: (eventName, keyCode) ->
+    event = document.createEvent('UIEvents')
+    event.initEvent(eventName, true, true)
+    event.keyCode  = keyCode
+    event.which    = keyCode
+    event.charCode = 0
+    @element.dispatchEvent(event)
+
+  keypressed: (altKey, ctrlKey, shiftKey, metaKey, keyCode, charCode) ->
+    event = document.createEvent('UIEvents')
+    event.initEvent('keypress', true, true)
+    event.window   = @agent.window
+    event.altKey   = altKey
+    event.ctrlKey  = ctrlKey
+    event.shiftKey = shiftKey
+    event.metaKey  = metaKey
+    event.keyCode  = keyCode
+    event.charCode = charCode
+    event.which    = keyCode
+    @element.dispatchEvent(event)
+
+  insideBody: ->
+    @element == document.body ||
+    document.evaluate('ancestor::body', @element, null, XPathResult.BOOLEAN_TYPE, null).booleanValue
+
+  allText: ->
+    @element.textContent
+
+  visibleText: ->
+    if this.isVisible()
+      if @element.nodeName == "TEXTAREA"
+        @element.textContent
+      else
+        @element.innerText || @element.textContent
+
+  deleteText: ->
+    range = document.createRange()
+    range.selectNodeContents(@element)
+    window.getSelection().removeAllRanges()
+    window.getSelection().addRange(range)
+    window.getSelection().deleteFromDocument()
+
+  getProperty: (name) ->
+    @element[name]
+
+  getAttributes: ->
+    attrs = {}
+    for attr in @element.attributes
+      attrs[attr.name] = attr.value.replace("\n","\\n");
+    attrs
+
+  getAttribute: (name) ->
+    if name == 'checked' || name == 'selected'
+      @element[name]
+    else
+      @element.getAttribute(name)
+
+  scrollIntoView: ->
+    @element.scrollIntoViewIfNeeded()
+    #Sometimes scrollIntoViewIfNeeded doesn't seem to work, not really sure why.
+    #Just calling scrollIntoView doesnt work either, however calling scrollIntoView
+    #after scrollIntoViewIfNeeded when element is not in the viewport does appear to work
+    @element.scrollIntoView() unless this.isInViewport()
+
+  value: ->
+    if @element.tagName == 'SELECT' && @element.multiple
+      option.value for option in @element.children when option.selected
+    else
+      @element.value
+
+  set: (value) ->
+    return if @element.readOnly
+
+    if (@element.maxLength >= 0)
+      value = value.substr(0, @element.maxLength)
+
+    this.trigger('focus')
+    @element.value = ''
+
+    if @element.type == 'number'
+      @element.value = value
+    else
+      for char in value
+        keyCode = this.characterToKeyCode(char)
+        this.keyupdowned('keydown', keyCode)
+        @element.value += char
+
+        this.keypressed(false, false, false, false, char.charCodeAt(0), char.charCodeAt(0))
+        this.keyupdowned('keyup', keyCode)
+
+    this.changed()
+    this.input()
+    this.trigger('blur')
+
+  isMultiple: ->
+    @element.multiple
+
+  setAttribute: (name, value) ->
+    @element.setAttribute(name, value)
+
+  removeAttribute: (name) ->
+    @element.removeAttribute(name)
+
+  select: (value) ->
+    if @isDisabled()
+      false
+    else if value == false && !@element.parentNode.multiple
+      false
+    else
+      this.trigger('focus', @element.parentNode)
+
+      @element.selected = value
+      this.changed()
+
+      this.trigger('blur', @element.parentNode)
+      true
+
+  tagName: ->
+    @element.tagName
+
+  isVisible: (element = @element) ->
+    while (element)
+      style = window.getComputedStyle(element)
+      return false if style.display == 'none' or
+                      style.visibility == 'hidden' or
+                      parseFloat(style.opacity) == 0
+      element = element.parentElement
+
+    return true
+
+  isInViewport: ->
+    rect = @element.getBoundingClientRect();
+
+    rect.top >= 0 &&
+    rect.left >= 0 &&
+    rect.bottom <= window.innerHeight &&
+    rect.right <= window.innerWidth
+
+  isDisabled: ->
+    @element.disabled || @element.tagName == 'OPTION' && @element.parentNode.disabled
+
+  path: ->
+    elements = @parentIds().reverse().map((id) => @agent.get(id))
+    elements.push(this)
+    selectors = elements.map (el)->
+      prev_siblings = el.find('xpath', "./preceding-sibling::#{el.tagName()}")
+      "#{el.tagName()}[#{prev_siblings.length + 1}]"
+    "//" + selectors.join('/')
+
+  containsSelection: ->
+    selectedNode = document.getSelection().focusNode
+
+    return false if !selectedNode
+
+    if selectedNode.nodeType == 3
+      selectedNode = selectedNode.parentNode
+
+    @element.contains(selectedNode)
+
+  frameOffset: ->
+    win    = window
+    offset = { top: 0, left: 0 }
+
+    while win.frameElement
+      rect  = win.frameElement.getClientRects()[0]
+      style = win.getComputedStyle(win.frameElement)
+      win   = win.parent
+
+      offset.top  += rect.top + parseInt(style.getPropertyValue("padding-top"), 10)
+      offset.left += rect.left + parseInt(style.getPropertyValue("padding-left"), 10)
+
+    offset
+
+  position: ->
+    # Elements inside an SVG return underfined for getClientRects???
+    rect = @element.getClientRects()[0] || @element.getBoundingClientRect()
+    throw new PoltergeistAgent.ObsoleteNode unless rect
+    frameOffset = this.frameOffset()
+
+    pos = {
+      top:    rect.top    + frameOffset.top,
+      right:  rect.right  + frameOffset.left,
+      left:   rect.left   + frameOffset.left,
+      bottom: rect.bottom + frameOffset.top,
+      width:  rect.width,
+      height: rect.height
+    }
+
+    pos
+
+  trigger: (name, element = @element) ->
+    if Node.EVENTS.MOUSE.indexOf(name) != -1
+      event = document.createEvent('MouseEvent')
+      event.initMouseEvent(
+        name, true, true, window, 0, 0, 0, 0, 0,
+        false, false, false, false, 0, null
+      )
+    else if Node.EVENTS.FOCUS.indexOf(name) != -1
+      event = this.obtainEvent(name)
+    else if Node.EVENTS.FORM.indexOf(name) != -1
+      event = this.obtainEvent(name)
+    else
+      throw "Unknown event"
+
+    element.dispatchEvent(event)
+
+  obtainEvent: (name) ->
+    event = document.createEvent('HTMLEvents')
+    event.initEvent(name, true, true)
+    event
+
+  mouseEventTest: (x, y) ->
+    frameOffset = this.frameOffset()
+
+    x -= frameOffset.left
+    y -= frameOffset.top
+
+    el = origEl = document.elementFromPoint(x, y)
+
+    while el
+      if el == @element
+        return { status: 'success' }
+      else
+        el = el.parentNode
+
+    { status: 'failure', selector: origEl && this.getSelector(origEl) }
+  getSelector: (el) ->
+    selector = if el.tagName != 'HTML' then this.getSelector(el.parentNode) + ' ' else ''
+    selector += el.tagName.toLowerCase()
+    selector += "##{el.id}" if el.id
+
+    #PhantomJS < 2.0 doesn't support classList for SVG elements - so get classes manually
+    classes = el.classList || (el.getAttribute('class')?.trim()?.split(/\s+/)) || []
+    for className in classes when className != ''
+      selector += ".#{className}"
+    selector
+
+  characterToKeyCode: (character) ->
+    code = character.toUpperCase().charCodeAt(0)
+    specialKeys =
+      96: 192  #`
+      45: 189  #-
+      61: 187  #=
+      91: 219  #[
+      93: 221  #]
+      92: 220  #\
+      59: 186  #;
+      39: 222  #'
+      44: 188  #,
+      46: 190  #.
+      47: 191  #/
+      127: 46  #delete
+      126: 192 #~
+      33: 49   #!
+      64: 50   #@
+      35: 51   ##
+      36: 52   #$
+      37: 53   #%
+      94: 54   #^
+      38: 55   #&
+      42: 56   #*
+      40: 57   #(
+      41: 48   #)
+      95: 189  #_
+      43: 187  #+
+      123: 219 #{
+      125: 221 #}
+      124: 220 #|
+      58: 186  #:
+      34: 222  #"
+      60: 188  #<
+      62: 190  #>
+      63: 191 #?
+
+    specialKeys[code] || code
+
+  isDOMEqual: (other_id) ->
+    @element == @agent.get(other_id).element
+
+window.__poltergeist = new PoltergeistAgent
+
+document.addEventListener(
+  'DOMContentLoaded',
+  -> console.log('__DOMContentLoaded')
+)

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

@@ -0,0 +1,497 @@
+class Poltergeist.Browser
+  constructor: (width, height) ->
+    @width      = width || 1024
+    @height     = height || 768
+    @pages      = []
+    @js_errors  = true
+    @_debug     = false
+    @_counter   = 0
+
+    @processed_modal_messages = []
+    @confirm_processes = []
+    @prompt_responses = []
+
+    this.resetPage()
+
+  resetPage: ->
+    [@_counter, @pages] = [0, []]
+
+    if @page?
+      unless @page.closed
+        @page.clearLocalStorage() if @page.currentUrl() != 'about:blank'
+        @page.release()
+      phantom.clearCookies()
+
+    @page = @currentPage = new Poltergeist.WebPage
+    @page.setViewportSize(width: @width, height: @height)
+    @page.handle = "#{@_counter++}"
+    @pages.push(@page)
+
+    @processed_modal_messages = []
+    @confirm_processes = []
+    @prompt_responses = []
+
+
+    @page.native().onAlert = (msg) =>
+      @setModalMessage msg
+      return
+
+    @page.native().onConfirm = (msg) =>
+      process = @confirm_processes.pop()
+      process = true if process == undefined
+      @setModalMessage msg
+      return process
+
+    @page.native().onPrompt = (msg, defaultVal) =>
+      response = @prompt_responses.pop()
+      response = defaultVal if (response == undefined || response == false)
+
+      @setModalMessage msg
+      return response
+
+    @page.onPageCreated = (newPage) =>
+      page = new Poltergeist.WebPage(newPage)
+      page.handle = "#{@_counter++}"
+      @pages.push(page)
+
+    return
+
+  getPageByHandle: (handle) ->
+    @pages.filter((p) -> !p.closed && p.handle == handle)[0]
+
+  runCommand: (command) ->
+    @current_command = command
+    @currentPage.state = 'default'
+    this[command.name].apply(this, command.args)
+
+  debug: (message) ->
+    if @_debug
+      console.log "poltergeist [#{new Date().getTime()}] #{message}"
+
+  setModalMessage: (msg) ->
+    @processed_modal_messages.push(msg)
+    return
+
+  add_extension: (extension) ->
+    @currentPage.injectExtension extension
+    @current_command.sendResponse 'success'
+
+  node: (page_id, id) ->
+    if @currentPage.id == page_id
+      @currentPage.get(id)
+    else
+      throw new Poltergeist.ObsoleteNode
+
+  visit: (url) ->
+
+    @currentPage.state = 'loading'
+    #reset modal processing state when changing page
+    @processed_modal_messages = []
+    @confirm_processes = []
+    @prompt_responses = []
+
+
+    # Prevent firing `page.onInitialized` event twice. Calling currentUrl
+    # method before page is actually opened fires this event for the first time.
+    # The second time will be in the right place after `page.open`
+    prevUrl = if @currentPage.source is null then 'about:blank' else @currentPage.currentUrl()
+
+    @currentPage.open(url)
+
+    if /#/.test(url) && prevUrl.split('#')[0] == url.split('#')[0]
+      # Hash change occurred, so there will be no onLoadFinished
+      @currentPage.state = 'default'
+      @current_command.sendResponse(status: 'success')
+    else
+      command = @current_command
+      @currentPage.waitState 'default', =>
+        if @currentPage.statusCode == null && @currentPage.status == 'fail'
+          command.sendError(new Poltergeist.StatusFailError(url))
+        else
+          command.sendResponse(status: @currentPage.status)
+      return
+
+  current_url: ->
+    @current_command.sendResponse @currentPage.currentUrl()
+
+  status_code: ->
+    @current_command.sendResponse @currentPage.statusCode
+
+  body: ->
+    @current_command.sendResponse @currentPage.content()
+
+  source: ->
+    @current_command.sendResponse @currentPage.source
+
+  title: ->
+    @current_command.sendResponse @currentPage.title()
+
+  find: (method, selector) ->
+    @current_command.sendResponse(page_id: @currentPage.id, ids: @currentPage.find(method, selector))
+
+  find_within: (page_id, id, method, selector) ->
+    @current_command.sendResponse this.node(page_id, id).find(method, selector)
+
+  all_text: (page_id, id) ->
+    @current_command.sendResponse this.node(page_id, id).allText()
+
+  visible_text: (page_id, id) ->
+    @current_command.sendResponse this.node(page_id, id).visibleText()
+
+  delete_text: (page_id, id) ->
+    @current_command.sendResponse this.node(page_id, id).deleteText()
+
+  property: (page_id, id, name) ->
+    @current_command.sendResponse this.node(page_id, id).getProperty(name)
+
+  attribute: (page_id, id, name) ->
+    @current_command.sendResponse this.node(page_id, id).getAttribute(name)
+
+  attributes: (page_id, id, name) ->
+    @current_command.sendResponse this.node(page_id, id).getAttributes()
+
+  parents: (page_id, id) ->
+    @current_command.sendResponse this.node(page_id, id).parentIds()
+
+  value: (page_id, id) ->
+    @current_command.sendResponse this.node(page_id, id).value()
+
+  set: (page_id, id, value) ->
+    this.node(page_id, id).set(value)
+    @current_command.sendResponse(true)
+
+  # PhantomJS only allows us to reference the element by CSS selector, not XPath,
+  # so we have to add an attribute to the element to identify it, then remove it
+  # afterwards.
+  select_file: (page_id, id, value) ->
+    node = this.node(page_id, id)
+
+    @currentPage.beforeUpload(node.id)
+    @currentPage.uploadFile('[_poltergeist_selected]', value)
+    @currentPage.afterUpload(node.id)
+    if phantom.version.major == 2
+      # In phantomjs 2 - uploadFile only fully works if executed within a user action
+      # It does however setup the filenames to be uploaded, so if we then click on the
+      # file input element the filenames will get set
+      @click(page_id, id)
+    else
+      @current_command.sendResponse(true)
+
+  select: (page_id, id, value) ->
+    @current_command.sendResponse this.node(page_id, id).select(value)
+
+  tag_name: (page_id, id) ->
+    @current_command.sendResponse this.node(page_id, id).tagName()
+
+  visible: (page_id, id) ->
+    @current_command.sendResponse this.node(page_id, id).isVisible()
+
+  disabled: (page_id, id) ->
+    @current_command.sendResponse this.node(page_id, id).isDisabled()
+
+  path: (page_id, id) ->
+    @current_command.sendResponse this.node(page_id, id).path()
+
+  evaluate: (script) ->
+    @current_command.sendResponse @currentPage.evaluate("function() { return #{script} }")
+
+  execute: (script) ->
+    @currentPage.execute("function() { #{script} }")
+    @current_command.sendResponse(true)
+
+  frameUrl: (frame_name) ->
+    @currentPage.frameUrl(frame_name)
+
+  pushFrame: (command, name, timeout) ->
+    if Array.isArray(name)
+      frame = this.node(name...)
+      name = frame.getAttribute('name') || frame.getAttribute('id')
+      unless name
+        frame.setAttribute('name', "_random_name_#{new Date().getTime()}")
+        name = frame.getAttribute('name')
+
+    if @frameUrl(name) in @currentPage.blockedUrls()
+      command.sendResponse(true)
+    else if @currentPage.pushFrame(name)
+      if @currentPage.currentUrl() == 'about:blank'
+        @currentPage.state = 'awaiting_frame_load'
+        @currentPage.waitState 'default', =>
+          command.sendResponse(true)
+      else
+        command.sendResponse(true)
+    else
+      if new Date().getTime() < timeout
+        setTimeout((=> @pushFrame(command, name, timeout)), 50)
+      else
+        command.sendError(new Poltergeist.FrameNotFound(name))
+
+  push_frame: (name, timeout = (new Date().getTime()) + 2000) ->
+    @pushFrame(@current_command, name, timeout)
+
+  pop_frame: ->
+    @current_command.sendResponse(@currentPage.popFrame())
+
+  window_handles: ->
+    handles = @pages.filter((p) -> !p.closed).map((p) -> p.handle)
+    @current_command.sendResponse(handles)
+
+  window_handle: (name = null) ->
+    handle = if name
+      page = @pages.filter((p) -> !p.closed && p.windowName() == name)[0]
+      if page then page.handle else null
+    else
+      @currentPage.handle
+
+    @current_command.sendResponse(handle)
+
+  switch_to_window: (handle) ->
+    command = @current_command
+    page = @getPageByHandle(handle)
+    if page
+      if page != @currentPage
+        page.waitState 'default', =>
+          @currentPage = page
+          command.sendResponse(true)
+      else
+        command.sendResponse(true)
+    else
+      throw new Poltergeist.NoSuchWindowError
+
+  open_new_window: ->
+    this.execute 'window.open()'
+    @current_command.sendResponse(true)
+
+  close_window: (handle) ->
+    page = @getPageByHandle(handle)
+    if page
+      page.release()
+      @current_command.sendResponse(true)
+    else
+      @current_command.sendResponse(false)
+
+  mouse_event: (page_id, id, name) ->
+    # Get the node before changing state, in case there is an exception
+    node = this.node(page_id, id)
+    # If the event triggers onNavigationRequested, we will transition to the 'loading'
+    # state and wait for onLoadFinished before sending a response.
+    @currentPage.state = 'mouse_event'
+
+    @last_mouse_event = node.mouseEvent(name)
+
+    command = @current_command
+
+    setTimeout =>
+      # If the state is still the same then navigation event won't happen
+      if @currentPage.state == 'mouse_event'
+        @currentPage.state = 'default'
+        command.sendResponse(position: @last_mouse_event)
+      else
+        @currentPage.waitState 'default', =>
+          command.sendResponse(position: @last_mouse_event)
+    , 5
+
+  click: (page_id, id) ->
+    this.mouse_event page_id, id, 'click'
+
+  right_click: (page_id, id) ->
+    this.mouse_event page_id, id, 'rightclick'
+
+  double_click: (page_id, id) ->
+    this.mouse_event page_id, id, 'doubleclick'
+
+  hover: (page_id, id) ->
+    this.mouse_event page_id, id, 'mousemove'
+
+  click_coordinates: (x, y) ->
+    @currentPage.sendEvent('click', x, y)
+    @current_command.sendResponse(click: { x: x, y: y })
+
+  drag: (page_id, id, other_id) ->
+    this.node(page_id, id).dragTo this.node(page_id, other_id)
+    @current_command.sendResponse(true)
+
+  drag_by: (page_id, id, x, y) ->
+    this.node(page_id, id).dragBy(x, y)
+    @current_command.sendResponse(true)
+
+  trigger: (page_id, id, event) ->
+    this.node(page_id, id).trigger(event)
+    @current_command.sendResponse(event)
+
+  equals: (page_id, id, other_id) ->
+    @current_command.sendResponse this.node(page_id, id).isEqual(this.node(page_id, other_id))
+
+  reset: ->
+    this.resetPage()
+    @current_command.sendResponse(true)
+
+  scroll_to: (left, top) ->
+    @currentPage.setScrollPosition(left: left, top: top)
+    @current_command.sendResponse(true)
+
+  send_keys: (page_id, id, keys) ->
+    target = this.node(page_id, id)
+
+    # Programmatically generated focus doesn't work for `sendKeys`.
+    # That's why we need something more realistic like user behavior.
+    if !target.containsSelection()
+      target.mouseEvent('click')
+
+    for sequence in keys
+      key = if sequence.key? then @currentPage.keyCode(sequence.key) else sequence
+      if sequence.modifier?
+        modifier_keys = @currentPage.keyModifierKeys(sequence.modifier)
+        modifier_code = @currentPage.keyModifierCode(sequence.modifier)
+        @currentPage.sendEvent('keydown', modifier_key) for modifier_key in modifier_keys
+        @currentPage.sendEvent('keypress', key, null, null, modifier_code)
+        @currentPage.sendEvent('keyup', modifier_key) for modifier_key in modifier_keys
+      else
+        @currentPage.sendEvent('keypress', key)
+
+    @current_command.sendResponse(true)
+
+  render_base64: (format, full, selector = null)->
+    this.set_clip_rect(full, selector)
+    encoded_image = @currentPage.renderBase64(format)
+    @current_command.sendResponse(encoded_image)
+
+  render: (path, full, selector = null) ->
+    dimensions = this.set_clip_rect(full, selector)
+    @currentPage.setScrollPosition(left: 0, top: 0)
+    @currentPage.render(path)
+    @currentPage.setScrollPosition(left: dimensions.left, top: dimensions.top)
+    @current_command.sendResponse(true)
+
+  set_clip_rect: (full, selector) ->
+    dimensions = @currentPage.validatedDimensions()
+    [document, viewport] = [dimensions.document, dimensions.viewport]
+
+    rect = if full
+      left: 0, top: 0, width: document.width, height: document.height
+    else
+      if selector?
+        @currentPage.elementBounds(selector)
+      else
+        left: 0, top: 0, width: viewport.width, height: viewport.height
+
+    @currentPage.setClipRect(rect)
+    dimensions
+
+  set_paper_size: (size) ->
+    @currentPage.setPaperSize(size)
+    @current_command.sendResponse(true)
+
+  set_zoom_factor: (zoom_factor) ->
+    @currentPage.setZoomFactor(zoom_factor)
+    @current_command.sendResponse(true)
+
+  resize: (width, height) ->
+    @currentPage.setViewportSize(width: width, height: height)
+    @current_command.sendResponse(true)
+
+  network_traffic: ->
+    @current_command.sendResponse(@currentPage.networkTraffic())
+
+  clear_network_traffic: ->
+    @currentPage.clearNetworkTraffic()
+    @current_command.sendResponse(true)
+
+  get_headers: ->
+    @current_command.sendResponse(@currentPage.getCustomHeaders())
+
+  set_headers: (headers) ->
+    # Workaround for https://code.google.com/p/phantomjs/issues/detail?id=745
+    @currentPage.setUserAgent(headers['User-Agent']) if headers['User-Agent']
+    @currentPage.setCustomHeaders(headers)
+    @current_command.sendResponse(true)
+
+  add_headers: (headers) ->
+    allHeaders = @currentPage.getCustomHeaders()
+    for name, value of headers
+      allHeaders[name] = value
+    this.set_headers(allHeaders)
+
+  add_header: (header, permanent) ->
+    @currentPage.addTempHeader(header) unless permanent
+    this.add_headers(header)
+
+  response_headers: ->
+    @current_command.sendResponse(@currentPage.responseHeaders())
+
+  cookies: ->
+    @current_command.sendResponse(@currentPage.cookies())
+
+  # We're using phantom.addCookie so that cookies can be set
+  # before the first page load has taken place.
+  set_cookie: (cookie) ->
+    phantom.addCookie(cookie)
+    @current_command.sendResponse(true)
+
+  remove_cookie: (name) ->
+    @currentPage.deleteCookie(name)
+    @current_command.sendResponse(true)
+
+  clear_cookies: () ->
+    phantom.clearCookies()
+    @current_command.sendResponse(true)
+
+  cookies_enabled: (flag) ->
+    phantom.cookiesEnabled = flag
+    @current_command.sendResponse(true)
+
+  set_http_auth: (user, password) ->
+    @currentPage.setHttpAuth(user, password)
+    @current_command.sendResponse(true)
+
+  set_js_errors: (value) ->
+    @js_errors = value
+    @current_command.sendResponse(true)
+
+  set_debug: (value) ->
+    @_debug = value
+    @current_command.sendResponse(true)
+
+  exit: ->
+    phantom.exit()
+
+  noop: ->
+    # NOOOOOOP!
+
+  # This command is purely for testing error handling
+  browser_error: ->
+    throw new Error('zomg')
+
+  go_back: ->
+    command = @current_command
+    if @currentPage.canGoBack
+      @currentPage.state = 'loading'
+      @currentPage.goBack()
+      @currentPage.waitState 'default', =>
+        command.sendResponse(true)
+    else
+      command.sendResponse(false)
+
+  go_forward: ->
+    command = @current_command
+    if @currentPage.canGoForward
+      @currentPage.state = 'loading'
+      @currentPage.goForward()
+      @currentPage.waitState 'default', =>
+        command.sendResponse(true)
+    else
+      command.sendResponse(false)
+
+  set_url_blacklist: ->
+    @currentPage.urlBlacklist = Array.prototype.slice.call(arguments)
+    @current_command.sendResponse(true)
+
+  set_confirm_process: (process) ->
+    @confirm_processes.push process
+    @current_command.sendResponse(true)
+
+  set_prompt_response: (response) ->
+    @prompt_responses.push response
+    @current_command.sendResponse(true)
+
+  modal_message: ->
+    @current_command.sendResponse(@processed_modal_messages.shift())