poltergeist-cj 1.5.2

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

@@ -0,0 +1,11 @@
+class Poltergeist.Connection
+  constructor: (@owner, @port) ->
+    @socket = new WebSocket "ws://127.0.0.1:#{@port}/"
+    @socket.onmessage = this.commandReceived
+    @socket.onclose = -> phantom.exit()
+
+  commandReceived: (message) =>
+    @owner.runCommand(JSON.parse(message.data))
+
+  send: (message) ->
+    @socket.send(JSON.stringify(message))

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

@@ -0,0 +1,89 @@
+class Poltergeist
+  constructor: (port, width, height) ->
+    @browser    = new Poltergeist.Browser(this, width, height)
+    @connection = new Poltergeist.Connection(this, port)
+
+    # The QtWebKit bridge doesn't seem to like Function.prototype.bind
+    that = this
+    phantom.onError = (message, stack) -> that.onError(message, stack)
+
+    @running = false
+
+  runCommand: (command) ->
+    @running = true
+
+    try
+      @browser.runCommand(command.name, command.args)
+    catch error
+      if error instanceof Poltergeist.Error
+        this.sendError(error)
+      else
+        this.sendError(new Poltergeist.BrowserError(error.toString(), error.stack))
+
+  sendResponse: (response) ->
+    this.send(response: response)
+
+  sendError: (error) ->
+    this.send(
+      error:
+        name: error.name || 'Generic',
+        args: error.args && error.args() || [error.toString()]
+    )
+
+  send: (data) ->
+    # Prevents more than one response being sent for a single
+    # command. This can happen in some scenarios where an error
+    # is raised but the script can still continue.
+    if @running
+      @connection.send(data)
+      @running = false
+
+# This is necessary because the remote debugger will wrap the
+# script in a function, causing the Poltergeist variable to
+# become local.
+window.Poltergeist = Poltergeist
+
+class Poltergeist.Error
+
+class Poltergeist.ObsoleteNode extends Poltergeist.Error
+  name: "Poltergeist.ObsoleteNode"
+  args: -> []
+  toString: -> this.name
+
+class Poltergeist.InvalidSelector extends Poltergeist.Error
+  constructor: (@method, @selector) ->
+  name: "Poltergeist.InvalidSelector"
+  args: -> [@method, @selector]
+
+class Poltergeist.FrameNotFound extends Poltergeist.Error
+  constructor: (@frameName) ->
+  name: "Poltergeist.FrameNotFound"
+  args: -> [@frameName]
+
+class Poltergeist.MouseEventFailed extends Poltergeist.Error
+  constructor: (@eventName, @selector, @position) ->
+  name: "Poltergeist.MouseEventFailed"
+  args: -> [@eventName, @selector, @position]
+
+class Poltergeist.JavascriptError extends Poltergeist.Error
+  constructor: (@errors) ->
+  name: "Poltergeist.JavascriptError"
+  args: -> [@errors]
+
+class Poltergeist.BrowserError extends Poltergeist.Error
+  constructor: (@message, @stack) ->
+  name: "Poltergeist.BrowserError"
+  args: -> [@message, @stack]
+
+class Poltergeist.StatusFailError extends Poltergeist.Error
+  name: "Poltergeist.StatusFailError"
+  args: -> []
+
+# We're using phantom.libraryPath so that any stack traces
+# report the full path.
+phantom.injectJs("#{phantom.libraryPath}/web_page.js")
+phantom.injectJs("#{phantom.libraryPath}/node.js")
+phantom.injectJs("#{phantom.libraryPath}/connection.js")
+phantom.injectJs("#{phantom.libraryPath}/browser.js")
+
+new Poltergeist(phantom.args[0], phantom.args[1], phantom.args[2])

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

@@ -0,0 +1,57 @@
+# Proxy object for forwarding method calls to the node object inside the page.
+
+class Poltergeist.Node
+  @DELEGATES = ['allText', 'visibleText', 'getAttribute', 'value', 'set', 'setAttribute', 'isObsolete',
+                'removeAttribute', 'isMultiple', 'select', 'tagName', 'find', 'getAttributes',
+                'isVisible', 'position', 'trigger', 'parentId', 'parentIds', 'mouseEventTest',
+                'scrollIntoView', 'isDOMEqual', 'isDisabled', 'deleteText', 'containsSelection']
+
+  constructor: (@page, @id) ->
+
+  parent: ->
+    new Poltergeist.Node(@page, this.parentId())
+
+  for name in @DELEGATES
+    do (name) =>
+      this.prototype[name] = (args...) ->
+        @page.nodeCall(@id, name, args)
+
+  mouseEventPosition: ->
+    viewport = @page.viewportSize()
+    pos      = this.position()
+
+    middle = (start, end, size) ->
+      start + ((Math.min(end, size) - start) / 2)
+
+    {
+      x: middle(pos.left, pos.right,  viewport.width),
+      y: middle(pos.top,  pos.bottom, viewport.height)
+    }
+
+  mouseEvent: (name) ->
+    this.scrollIntoView()
+
+    pos  = this.mouseEventPosition()
+    test = this.mouseEventTest(pos.x, pos.y)
+
+    if test.status == 'success'
+      if name == 'rightclick'
+        @page.mouseEvent('click', pos.x, pos.y, 'right')
+        this.trigger('contextmenu')
+      else
+        @page.mouseEvent(name, pos.x, pos.y)
+      pos
+    else
+      throw new Poltergeist.MouseEventFailed(name, test.selector, pos)
+
+  dragTo: (other) ->
+    this.scrollIntoView()
+
+    position      = this.mouseEventPosition()
+    otherPosition = other.mouseEventPosition()
+
+    @page.mouseEvent('mousedown', position.x,      position.y)
+    @page.mouseEvent('mouseup',   otherPosition.x, otherPosition.y)
+
+  isEqual: (other) ->
+    @page == other.page && this.isDOMEqual(other.id)

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

@@ -0,0 +1,297 @@
+class Poltergeist.WebPage
+  @CALLBACKS = ['onAlert', 'onConsoleMessage', 'onLoadFinished', 'onInitialized',
+                'onLoadStarted', 'onResourceRequested', 'onResourceReceived',
+                'onError', 'onNavigationRequested', 'onUrlChanged', 'onPageCreated']
+
+  @DELEGATES = ['open', 'sendEvent', 'uploadFile', 'release', 'render', 'renderBase64', 'goBack', 'goForward']
+
+  @COMMANDS  = ['currentUrl', 'find', 'nodeCall', 'documentSize', 'beforeUpload', 'afterUpload']
+
+  @EXTENSIONS = []
+
+  constructor: (@native) ->
+    @native or= require('webpage').create()
+
+    @_source         = null
+    @_errors         = []
+    @_networkTraffic = {}
+    @_temp_headers   = {}
+    @frames          = []
+
+    for callback in WebPage.CALLBACKS
+      this.bindCallback(callback)
+
+  for command in @COMMANDS
+    do (command) =>
+      this.prototype[command] =
+        (args...) -> this.runCommand(command, args)
+
+  for delegate in @DELEGATES
+    do (delegate) =>
+      this.prototype[delegate] =
+        -> @native[delegate].apply(@native, arguments)
+
+  onInitializedNative: ->
+    @_source = null
+    @injectAgent()
+    this.removeTempHeaders()
+    this.setScrollPosition(left: 0, top: 0)
+
+  injectAgent: ->
+    if @native.evaluate(-> typeof __poltergeist) == "undefined"
+      @native.injectJs "#{phantom.libraryPath}/agent.js"
+      for extension in WebPage.EXTENSIONS
+        @native.injectJs extension
+
+  injectExtension: (file) ->
+    WebPage.EXTENSIONS.push file
+    @native.injectJs file
+
+  onConsoleMessageNative: (message) ->
+    if message == '__DOMContentLoaded'
+      @_source = @native.content
+      false
+
+  onLoadStartedNative: ->
+    @requestId = @lastRequestId
+
+  onLoadFinishedNative: ->
+    @_source or= @native.content
+
+  onConsoleMessage: (message) ->
+    console.log(message)
+
+  onErrorNative: (message, stack) ->
+    stackString = message
+
+    stack.forEach (frame) ->
+      stackString += "\n"
+      stackString += "    at #{frame.file}:#{frame.line}"
+      stackString += " in #{frame.function}" if frame.function && frame.function != ''
+
+    @_errors.push(message: message, stack: stackString)
+
+  onResourceRequestedNative: (request) ->
+    @lastRequestId = request.id
+
+    if request.url == @redirectURL
+      @redirectURL = null
+      @requestId   = request.id
+
+    @_networkTraffic[request.id] = {
+      request:       request,
+      responseParts: []
+    }
+
+  onResourceReceivedNative: (response) ->
+    @_networkTraffic[response.id]?.responseParts.push(response)
+
+    if @requestId == response.id
+      if response.redirectURL
+        @redirectURL = response.redirectURL
+      else
+        @_statusCode      = response.status
+        @_responseHeaders = response.headers
+
+  setHttpAuth: (user, password) ->
+    @native.settings.userName = user
+    @native.settings.password = password
+
+  networkTraffic: ->
+    @_networkTraffic
+
+  clearNetworkTraffic: ->
+    @_networkTraffic = {}
+
+  content: ->
+    @native.frameContent
+
+  source: ->
+    @_source
+
+  title: ->
+    @native.frameTitle
+
+  errors: ->
+    @_errors
+
+  clearErrors: ->
+    @_errors = []
+
+  statusCode: ->
+    @_statusCode
+
+  responseHeaders: ->
+    headers = {}
+    @_responseHeaders.forEach (item) ->
+      headers[item.name] = item.value
+    headers
+
+  cookies: ->
+    @native.cookies
+
+  deleteCookie: (name) ->
+    @native.deleteCookie(name)
+
+  viewportSize: ->
+    @native.viewportSize
+
+  setViewportSize: (size) ->
+    @native.viewportSize = size
+
+  setZoomFactor: (zoom_factor) ->
+    @native.zoomFactor = zoom_factor
+
+  setPaperSize: (size) ->
+    @native.paperSize = size
+
+  scrollPosition: ->
+    @native.scrollPosition
+
+  setScrollPosition: (pos) ->
+    @native.scrollPosition = pos
+
+  clipRect: ->
+    @native.clipRect
+
+  setClipRect: (rect) ->
+    @native.clipRect = rect
+
+  elementBounds: (selector) ->
+    @native.evaluate(
+      (selector) -> document.querySelector(selector).getBoundingClientRect(),
+      selector
+    )
+
+  setUserAgent: (userAgent) ->
+    @native.settings.userAgent = userAgent
+
+  getCustomHeaders: ->
+    @native.customHeaders
+
+  setCustomHeaders: (headers) ->
+    @native.customHeaders = headers
+
+  addTempHeader: (header) ->
+    for name, value of header
+      @_temp_headers[name] = value
+
+  removeTempHeaders: ->
+    allHeaders = this.getCustomHeaders()
+    for name, value of @_temp_headers
+      delete allHeaders[name]
+    this.setCustomHeaders(allHeaders)
+
+  pushFrame: (name) ->
+    if @native.switchToFrame(name)
+      @frames.push(name)
+      true
+    else
+      false
+
+  pages: ->
+    @native.pagesWindowName
+
+  popFrame: ->
+    @frames.pop()
+    @native.switchToParentFrame()
+
+  getPage: (name) ->
+    page = @native.getPage(name)
+    new Poltergeist.WebPage(page) if page
+
+  dimensions: ->
+    scroll   = this.scrollPosition()
+    viewport = this.viewportSize()
+
+    top:    scroll.top,  bottom: scroll.top  + viewport.height,
+    left:   scroll.left, right:  scroll.left + viewport.width,
+    viewport: viewport
+    document: this.documentSize()
+
+  # A work around for http://code.google.com/p/phantomjs/issues/detail?id=277
+  validatedDimensions: ->
+    dimensions = this.dimensions()
+    document   = dimensions.document
+
+    if dimensions.right > document.width
+      dimensions.left  = Math.max(0, dimensions.left - (dimensions.right - document.width))
+      dimensions.right = document.width
+
+    if dimensions.bottom > document.height
+      dimensions.top    = Math.max(0, dimensions.top - (dimensions.bottom - document.height))
+      dimensions.bottom = document.height
+
+    this.setScrollPosition(left: dimensions.left, top: dimensions.top)
+
+    dimensions
+
+  get: (id) ->
+    new Poltergeist.Node(this, id)
+
+  # Before each mouse event we make sure that the mouse is moved to where the
+  # event will take place. This deals with e.g. :hover changes.
+  mouseEvent: (name, x, y, button = 'left') ->
+    this.sendEvent('mousemove', x, y)
+    this.sendEvent(name, x, y, button)
+
+  evaluate: (fn, args...) ->
+    this.injectAgent()
+    JSON.parse this.sanitize(@native.evaluate("function() { return PoltergeistAgent.stringify(#{this.stringifyCall(fn, args)}) }"))
+
+  sanitize: (potential_string) ->
+    if typeof(potential_string) == "string"
+      # JSON doesn't like \r or \n in strings unless escaped
+      potential_string.replace("\n","\\n").replace("\r","\\r")
+    else
+      potential_string
+
+  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)
+
+  # Any error raised here or inside the evaluate will get reported to
+  # phantom.onError. If result is null, that means there was an error
+  # inside the agent.
+  runCommand: (name, args) ->
+    result = this.evaluate(
+      (name, args) -> __poltergeist.externalCall(name, args),
+      name, args
+    )
+
+    if result != null
+      if result.error?
+        switch result.error.message
+          when 'PoltergeistAgent.ObsoleteNode'
+            throw new Poltergeist.ObsoleteNode
+          when 'PoltergeistAgent.InvalidSelector'
+            [method, selector] = args
+            throw new Poltergeist.InvalidSelector(method, selector)
+          else
+            throw new Poltergeist.BrowserError(result.error.message, result.error.stack)
+      else
+        result.value
+
+  canGoBack: ->
+    @native.canGoBack
+
+  canGoForward: ->
+    @native.canGoForward