poltergeist 0.1.0

data/lib/capybara/poltergeist/client/compiled/agent.js

@@ -0,0 +1,198 @@
+var PoltergeistAgent;
+var __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
+PoltergeistAgent = (function() {
+  function PoltergeistAgent() {
+    this.elements = [];
+    this.nodes = {};
+    this.windows = [];
+    this.pushWindow(window);
+  }
+  PoltergeistAgent.prototype.pushWindow = function(new_window) {
+    this.windows.push(new_window);
+    this.window = new_window;
+    return this.document = this.window.document;
+  };
+  PoltergeistAgent.prototype.popWindow = function() {
+    this.windows.pop();
+    this.window = this.windows[this.windows.length - 1];
+    return this.document = this.window.document;
+  };
+  PoltergeistAgent.prototype.pushFrame = function(id) {
+    return this.pushWindow(this.document.getElementById(id).contentWindow);
+  };
+  PoltergeistAgent.prototype.popFrame = function() {
+    return this.popWindow();
+  };
+  PoltergeistAgent.prototype.currentUrl = function() {
+    return window.location.toString();
+  };
+  PoltergeistAgent.prototype.find = function(selector, id) {
+    var context, i, ids, results, _ref;
+    context = id != null ? this.elements[id] : this.document;
+    results = this.document.evaluate(selector, context, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
+    ids = [];
+    for (i = 0, _ref = results.snapshotLength; 0 <= _ref ? i < _ref : i > _ref; 0 <= _ref ? i++ : i--) {
+      ids.push(this.register(results.snapshotItem(i)));
+    }
+    return ids;
+  };
+  PoltergeistAgent.prototype.register = function(element) {
+    this.elements.push(element);
+    return this.elements.length - 1;
+  };
+  PoltergeistAgent.prototype.documentSize = function() {
+    return {
+      height: this.document.documentElement.scrollHeight,
+      width: this.document.documentElement.scrollWidth
+    };
+  };
+  PoltergeistAgent.prototype.get = function(id) {
+    var _base;
+    return (_base = this.nodes)[id] || (_base[id] = new PoltergeistAgent.Node(this, this.elements[id]));
+  };
+  PoltergeistAgent.prototype.nodeCall = function(id, name, arguments) {
+    var node;
+    node = this.get(id);
+    return node[name].apply(node, arguments);
+  };
+  return PoltergeistAgent;
+})();
+PoltergeistAgent.Node = (function() {
+  Node.EVENTS = {
+    FOCUS: ['blur', 'focus', 'focusin', 'focusout'],
+    MOUSE: ['click', 'dblclick', 'mousedown', 'mouseenter', 'mouseleave', 'mousemove', 'mouseover', 'mouseout', 'mouseup']
+  };
+  function Node(agent, element) {
+    this.agent = agent;
+    this.element = element;
+  }
+  Node.prototype.parentId = function() {
+    return this.agent.register(this.element.parentNode);
+  };
+  Node.prototype.isObsolete = function() {
+    var obsolete;
+    obsolete = __bind(function(element) {
+      if (element.parentNode != null) {
+        if (element.parentNode === this.agent.document) {
+          return false;
+        } else {
+          return obsolete(element.parentNode);
+        }
+      } else {
+        return true;
+      }
+    }, this);
+    return obsolete(this.element);
+  };
+  Node.prototype.changed = function() {
+    var event;
+    event = document.createEvent('HTMLEvents');
+    event.initEvent("change", true, false);
+    return this.element.dispatchEvent(event);
+  };
+  Node.prototype.text = function() {
+    return this.element.textContent;
+  };
+  Node.prototype.getAttribute = function(name) {
+    if (name === 'checked' || name === 'selected') {
+      return this.element[name];
+    } else {
+      return this.element.getAttribute(name);
+    }
+  };
+  Node.prototype.value = function() {
+    var option, _i, _len, _ref, _results;
+    if (this.element.tagName === 'SELECT' && this.element.multiple) {
+      _ref = this.element.children;
+      _results = [];
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        option = _ref[_i];
+        if (option.selected) {
+          _results.push(option.value);
+        }
+      }
+      return _results;
+    } else {
+      return this.element.value;
+    }
+  };
+  Node.prototype.set = function(value) {
+    if (this.element.maxLength >= 0) {
+      value = value.substr(0, this.element.maxLength);
+    }
+    this.element.value = value;
+    return this.changed();
+  };
+  Node.prototype.isMultiple = function() {
+    return this.element.multiple;
+  };
+  Node.prototype.setAttribute = function(name, value) {
+    return this.element.setAttribute(name, value);
+  };
+  Node.prototype.removeAttribute = function(name) {
+    return this.element.removeAttribute(name);
+  };
+  Node.prototype.select = function(value) {
+    if (value === false && !this.element.parentNode.multiple) {
+      return false;
+    } else {
+      this.element.selected = value;
+      this.changed();
+      return true;
+    }
+  };
+  Node.prototype.tagName = function() {
+    return this.element.tagName;
+  };
+  Node.prototype.elementVisible = function(element) {};
+  Node.prototype.isVisible = function(id) {
+    var visible;
+    visible = function(element) {
+      if (this.window.getComputedStyle(element).display === 'none') {
+        return false;
+      } else if (element.parentElement) {
+        return visible(element.parentElement);
+      } else {
+        return true;
+      }
+    };
+    return visible(this.element);
+  };
+  Node.prototype.position = function(id) {
+    var pos;
+    pos = function(element) {
+      var parentPos, x, y;
+      x = element.offsetLeft;
+      y = element.offsetTop;
+      if (element.offsetParent) {
+        parentPos = pos(element.offsetParent);
+        x += parentPos.x;
+        y += parentPos.y;
+      }
+      return {
+        x: x,
+        y: y
+      };
+    };
+    return pos(this.element);
+  };
+  Node.prototype.trigger = function(name) {
+    var event;
+    if (Node.EVENTS.MOUSE.indexOf(name) !== -1) {
+      event = document.createEvent('MouseEvent');
+      event.initMouseEvent(name, true, true, this.agent.window, 0, 0, 0, 0, 0, false, false, false, false, 0, null);
+    } else if (Node.EVENTS.FOCUS.indexOf(name) !== -1) {
+      event = document.createEvent('HTMLEvents');
+      event.initEvent(name, true, true);
+    } else {
+      throw "Unknown event";
+    }
+    return this.element.dispatchEvent(event);
+  };
+  return Node;
+})();
+window.__poltergeist = new PoltergeistAgent;
+document.addEventListener('DOMContentLoaded', function() {
+  return console.log('__DOMContentLoaded');
+});
+true;

data/lib/capybara/poltergeist/client/compiled/browser.js

@@ -0,0 +1,117 @@
+var __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
+Poltergeist.Browser = (function() {
+  function Browser(owner) {
+    this.owner = owner;
+    this.awaiting_response = false;
+    this.resetPage();
+  }
+  Browser.prototype.resetPage = function() {
+    if (this.page != null) {
+      this.page.release();
+    }
+    this.page = new Poltergeist.WebPage;
+    return this.page.onLoadFinished = __bind(function(status) {
+      if (this.awaiting_response) {
+        this.owner.sendResponse(status);
+        return this.awaiting_response = false;
+      }
+    }, this);
+  };
+  Browser.prototype.visit = function(url) {
+    this.awaiting_response = true;
+    return this.page.open(url);
+  };
+  Browser.prototype.current_url = function() {
+    return this.owner.sendResponse(this.page.currentUrl());
+  };
+  Browser.prototype.body = function() {
+    return this.owner.sendResponse(this.page.content());
+  };
+  Browser.prototype.source = function() {
+    return this.owner.sendResponse(this.page.source());
+  };
+  Browser.prototype.find = function(selector, id) {
+    return this.owner.sendResponse(this.page.find(selector, id));
+  };
+  Browser.prototype.text = function(id) {
+    return this.owner.sendResponse(this.page.get(id).text());
+  };
+  Browser.prototype.attribute = function(id, name) {
+    return this.owner.sendResponse(this.page.get(id).getAttribute(name));
+  };
+  Browser.prototype.value = function(id) {
+    return this.owner.sendResponse(this.page.get(id).value());
+  };
+  Browser.prototype.set = function(id, value) {
+    this.page.get(id).set(value);
+    return this.owner.sendResponse(true);
+  };
+  Browser.prototype.select_file = function(id, value) {
+    var element, multiple;
+    element = this.page.get(id);
+    multiple = element.isMultiple();
+    if (multiple) {
+      element.removeAttribute('multiple');
+    }
+    element.setAttribute('_poltergeist_selected', '');
+    this.page.uploadFile('[_poltergeist_selected]', value);
+    element.removeAttribute('_poltergeist_selected');
+    if (multiple) {
+      element.setAttribute('multiple', 'multiple');
+    }
+    return this.owner.sendResponse(true);
+  };
+  Browser.prototype.select = function(id, value) {
+    return this.owner.sendResponse(this.page.get(id).select(value));
+  };
+  Browser.prototype.tag_name = function(id) {
+    return this.owner.sendResponse(this.page.get(id).tagName());
+  };
+  Browser.prototype.visible = function(id) {
+    return this.owner.sendResponse(this.page.get(id).isVisible());
+  };
+  Browser.prototype.evaluate = function(script) {
+    return this.owner.sendResponse(this.page.evaluate("function() { return " + script + " }"));
+  };
+  Browser.prototype.execute = function(script) {
+    this.page.execute("function() { return " + script + " }");
+    return this.owner.sendResponse(true);
+  };
+  Browser.prototype.push_frame = function(id) {
+    this.page.pushFrame(id);
+    return this.owner.sendResponse(true);
+  };
+  Browser.prototype.pop_frame = function() {
+    this.page.popFrame();
+    return this.owner.sendResponse(true);
+  };
+  Browser.prototype.click = function(id) {
+    this.page.onLoadStarted = __bind(function() {
+      return this.awaiting_response = true;
+    }, this);
+    this.page.get(id).click();
+    return setTimeout(__bind(function() {
+      this.page.onLoadStarted = null;
+      if (!this.awaiting_response) {
+        return this.owner.sendResponse(true);
+      }
+    }, this), 0);
+  };
+  Browser.prototype.drag = function(id, other_id) {
+    this.page.get(id).dragTo(this.page.get(other_id));
+    return this.owner.sendResponse(true);
+  };
+  Browser.prototype.trigger = function(id, event) {
+    this.page.get(id).trigger(event);
+    return this.owner.sendResponse(event);
+  };
+  Browser.prototype.reset = function() {
+    this.resetPage();
+    return this.owner.sendResponse(true);
+  };
+  Browser.prototype.render = function(path) {
+    this.page.render(path);
+    return this.owner.sendResponse(true);
+  };
+  return Browser;
+})();

data/lib/capybara/poltergeist/client/compiled/connection.js

@@ -0,0 +1,20 @@
+var __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
+Poltergeist.Connection = (function() {
+  function Connection(owner, port) {
+    this.owner = owner;
+    this.port = port;
+    this.commandReceived = __bind(this.commandReceived, this);
+    this.socket = new WebSocket("ws://127.0.0.1:" + this.port + "/");
+    this.socket.onmessage = this.commandReceived;
+    this.socket.onclose = function() {
+      return phantom.exit();
+    };
+  }
+  Connection.prototype.commandReceived = function(message) {
+    return this.owner.runCommand(JSON.parse(message.data));
+  };
+  Connection.prototype.send = function(message) {
+    return this.socket.send(JSON.stringify(message));
+  };
+  return Connection;
+})();

data/lib/capybara/poltergeist/client/compiled/main.js

@@ -0,0 +1,38 @@
+var Poltergeist;
+if (phantom.version.major < 1 || phantom.version.minor < 3) {
+  console.log("Poltergeist requires a PhantomJS version of at least 1.3");
+  phantom.exit(1);
+}
+Poltergeist = (function() {
+  function Poltergeist(port) {
+    this.browser = new Poltergeist.Browser(this);
+    this.connection = new Poltergeist.Connection(this, port);
+  }
+  Poltergeist.prototype.runCommand = function(command) {
+    try {
+      return this.browser[command.name].apply(this.browser, command.args);
+    } catch (error) {
+      return this.connection.send({
+        error: error.toString()
+      });
+    }
+  };
+  Poltergeist.prototype.sendResponse = function(response) {
+    return this.connection.send({
+      response: response
+    });
+  };
+  return Poltergeist;
+})();
+Poltergeist.ObsoleteNode = (function() {
+  function ObsoleteNode() {}
+  ObsoleteNode.prototype.toString = function() {
+    return "Poltergeist.ObsoleteNode";
+  };
+  return ObsoleteNode;
+})();
+phantom.injectJs('web_page.js');
+phantom.injectJs('node.js');
+phantom.injectJs('connection.js');
+phantom.injectJs('browser.js');
+new Poltergeist(phantom.args[0]);

data/lib/capybara/poltergeist/client/compiled/node.js

@@ -0,0 +1,74 @@
+var __slice = Array.prototype.slice, __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
+Poltergeist.Node = (function() {
+  var name, _fn, _i, _len, _ref;
+  Node.DELEGATES = ['text', 'getAttribute', 'value', 'set', 'setAttribute', 'removeAttribute', 'isMultiple', 'select', 'tagName', 'isVisible', 'position', 'trigger', 'parentId'];
+  function Node(page, id) {
+    this.page = page;
+    this.id = id;
+  }
+  Node.prototype.parent = function() {
+    return new Poltergeist.Node(this.page, this.parentId());
+  };
+  Node.prototype.isObsolete = function() {
+    return this.page.nodeCall(this.id, 'isObsolete');
+  };
+  _ref = Node.DELEGATES;
+  _fn = __bind(function(name) {
+    return this.prototype[name] = function() {
+      var arguments, _ref2;
+      _ref2 = arguments, arguments = 1 <= _ref2.length ? __slice.call(_ref2, 0) : [];
+      if (this.isObsolete()) {
+        throw new Poltergeist.ObsoleteNode;
+      } else {
+        return this.page.nodeCall(this.id, name, arguments);
+      }
+    };
+  }, Node);
+  for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+    name = _ref[_i];
+    _fn(name);
+  }
+  Node.prototype.scrollIntoView = function() {
+    var pos, scroll, size, viewport, _ref2, _ref3;
+    viewport = this.page.viewport();
+    size = this.page.documentSize();
+    pos = this.position();
+    scroll = {
+      left: viewport.left,
+      top: viewport.top
+    };
+    if (!((viewport.left <= (_ref2 = pos.x) && _ref2 < viewport.right))) {
+      scroll.left = Math.min(pos.x, size.width - viewport.width);
+    }
+    if (!((viewport.top <= (_ref3 = pos.y) && _ref3 < viewport.bottom))) {
+      scroll.top = Math.min(pos.y, size.height - viewport.height);
+    }
+    if (scroll.left !== viewport.left || scroll.top !== viewport.top) {
+      this.page.setScrollPosition(scroll);
+    }
+    return {
+      position: this.relativePosition(pos, scroll),
+      scroll: scroll
+    };
+  };
+  Node.prototype.relativePosition = function(position, scroll) {
+    return {
+      x: position.x - scroll.left,
+      y: position.y - scroll.top
+    };
+  };
+  Node.prototype.click = function() {
+    var position;
+    position = this.scrollIntoView().position;
+    return this.page.sendEvent('click', position.x, position.y);
+  };
+  Node.prototype.dragTo = function(other) {
+    var otherPosition, position, scroll, _ref2;
+    _ref2 = this.scrollIntoView(), position = _ref2.position, scroll = _ref2.scroll;
+    otherPosition = this.relativePosition(other.position(), scroll);
+    this.page.sendEvent('mousedown', position.x, position.y);
+    this.page.sendEvent('mousemove', otherPosition.x, otherPosition.y);
+    return this.page.sendEvent('mouseup', otherPosition.x, otherPosition.y);
+  };
+  return Node;
+}).call(this);

data/lib/capybara/poltergeist/client/compiled/web_page.js

@@ -0,0 +1,136 @@
+var __slice = Array.prototype.slice, __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
+Poltergeist.WebPage = (function() {
+  var command, delegate, _fn, _fn2, _i, _j, _len, _len2, _ref, _ref2;
+  WebPage.CALLBACKS = ['onAlert', 'onConsoleMessage', 'onLoadFinished', 'onInitialized', 'onLoadStarted', 'onResourceRequested', 'onResourceReceived'];
+  WebPage.DELEGATES = ['open', 'sendEvent', 'uploadFile', 'release', 'render'];
+  WebPage.COMMANDS = ['currentUrl', 'find', 'nodeCall', 'pushFrame', 'popFrame', 'documentSize'];
+  function WebPage() {
+    var callback, _i, _len, _ref;
+    this["native"] = require('webpage').create();
+    this.nodes = {};
+    this._source = "";
+    _ref = WebPage.CALLBACKS;
+    for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+      callback = _ref[_i];
+      this.bindCallback(callback);
+    }
+    this.injectAgent();
+  }
+  _ref = WebPage.COMMANDS;
+  _fn = __bind(function(command) {
+    return this.prototype[command] = function() {
+      var arguments, _ref2;
+      _ref2 = arguments, arguments = 1 <= _ref2.length ? __slice.call(_ref2, 0) : [];
+      return this.runCommand(command, arguments);
+    };
+  }, WebPage);
+  for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+    command = _ref[_i];
+    _fn(command);
+  }
+  _ref2 = WebPage.DELEGATES;
+  _fn2 = __bind(function(delegate) {
+    return this.prototype[delegate] = function() {
+      return this["native"][delegate].apply(this["native"], arguments);
+    };
+  }, WebPage);
+  for (_j = 0, _len2 = _ref2.length; _j < _len2; _j++) {
+    delegate = _ref2[_j];
+    _fn2(delegate);
+  }
+  WebPage.prototype.onInitializedNative = function() {
+    this._source = null;
+    this.injectAgent();
+    return this.setScrollPosition({
+      left: 0,
+      top: 0
+    });
+  };
+  WebPage.prototype.injectAgent = function() {
+    if (this.evaluate(function() {
+      return typeof __poltergeist;
+    }) === "undefined") {
+      return this["native"].injectJs('agent.js');
+    }
+  };
+  WebPage.prototype.onConsoleMessageNative = function(message) {
+    if (message === '__DOMContentLoaded') {
+      this._source = this["native"].content;
+      return false;
+    }
+  };
+  WebPage.prototype.onLoadFinishedNative = function() {
+    return this._source || (this._source = this["native"].content);
+  };
+  WebPage.prototype.onConsoleMessage = function(message) {
+    return console.log(message);
+  };
+  WebPage.prototype.content = function() {
+    return this["native"].content;
+  };
+  WebPage.prototype.source = function() {
+    return this._source;
+  };
+  WebPage.prototype.viewportSize = function() {
+    return this["native"].viewportSize;
+  };
+  WebPage.prototype.scrollPosition = function() {
+    return this["native"].scrollPosition;
+  };
+  WebPage.prototype.setScrollPosition = function(pos) {
+    return this["native"].scrollPosition = pos;
+  };
+  WebPage.prototype.viewport = function() {
+    var scroll, size;
+    scroll = this.scrollPosition();
+    size = this.viewportSize();
+    return {
+      top: scroll.top,
+      bottom: scroll.top + size.height,
+      left: scroll.left,
+      right: scroll.left + size.width,
+      width: size.width,
+      height: size.height
+    };
+  };
+  WebPage.prototype.get = function(id) {
+    var _base;
+    return (_base = this.nodes)[id] || (_base[id] = new Poltergeist.Node(this, id));
+  };
+  WebPage.prototype.evaluate = function() {
+    var args, fn;
+    fn = arguments[0], args = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
+    return this["native"].evaluate("function() { return " + (this.stringifyCall(fn, args)) + " }");
+  };
+  WebPage.prototype.execute = function() {
+    var args, fn;
+    fn = arguments[0], args = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
+    return this["native"].evaluate("function() { " + (this.stringifyCall(fn, args)) + " }");
+  };
+  WebPage.prototype.stringifyCall = function(fn, args) {
+    if (args.length === 0) {
+      return "(" + (fn.toString()) + ")()";
+    } else {
+      return "(" + (fn.toString()) + ").apply(this, JSON.parse(" + (JSON.stringify(JSON.stringify(args))) + "))";
+    }
+  };
+  WebPage.prototype.bindCallback = function(name) {
+    var that;
+    that = this;
+    return this["native"][name] = function() {
+      var result;
+      if (that[name + 'Native'] != null) {
+        result = that[name + 'Native'].apply(that, arguments);
+      }
+      if (result !== false && (that[name] != null)) {
+        return that[name].apply(that, arguments);
+      }
+    };
+  };
+  WebPage.prototype.runCommand = function(name, arguments) {
+    return this.evaluate(function(name, arguments) {
+      return __poltergeist[name].apply(__poltergeist, arguments);
+    }, name, arguments);
+  };
+  return WebPage;
+}).call(this);

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,27 @@
+if phantom.version.major < 1 || phantom.version.minor < 3
+  console.log "Poltergeist requires a PhantomJS version of at least 1.3"
+  phantom.exit(1)
+
+class Poltergeist
+  constructor: (port) ->
+    @browser    = new Poltergeist.Browser(this)
+    @connection = new Poltergeist.Connection(this, port)
+
+  runCommand: (command) ->
+    try
+      @browser[command.name].apply(@browser, command.args)
+    catch error
+      @connection.send({ error: error.toString() })
+
+  sendResponse: (response) ->
+    @connection.send({ response: response })
+
+class Poltergeist.ObsoleteNode
+  toString: -> "Poltergeist.ObsoleteNode"
+
+phantom.injectJs('web_page.js')
+phantom.injectJs('node.js')
+phantom.injectJs('connection.js')
+phantom.injectJs('browser.js')
+
+new Poltergeist(phantom.args[0])

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

@@ -0,0 +1,56 @@
+# Proxy object for forwarding method calls to the node object inside the page.
+
+class Poltergeist.Node
+  @DELEGATES = ['text', 'getAttribute', 'value', 'set', 'setAttribute', 'removeAttribute',
+                'isMultiple', 'select', 'tagName', 'isVisible', 'position', 'trigger', 'parentId']
+
+  constructor: (@page, @id) ->
+
+  parent: ->
+    new Poltergeist.Node(@page, this.parentId())
+
+  isObsolete: ->
+    @page.nodeCall(@id, 'isObsolete')
+
+  for name in @DELEGATES
+    do (name) =>
+      this.prototype[name] = (arguments...) ->
+        if this.isObsolete()
+          throw new Poltergeist.ObsoleteNode
+        else
+          @page.nodeCall(@id, name, arguments)
+
+  scrollIntoView: ->
+    viewport = @page.viewport()
+    size     = @page.documentSize()
+    pos      = this.position()
+
+    scroll = { left: viewport.left, top: viewport.top }
+
+    unless viewport.left <= pos.x < viewport.right
+      scroll.left = Math.min(pos.x, size.width - viewport.width)
+
+    unless viewport.top <= pos.y < viewport.bottom
+      scroll.top = Math.min(pos.y, size.height - viewport.height)
+
+    if scroll.left != viewport.left || scroll.top != viewport.top
+      @page.setScrollPosition(scroll)
+
+    position: this.relativePosition(pos, scroll),
+    scroll:   scroll
+
+  relativePosition: (position, scroll) ->
+    x: position.x - scroll.left
+    y: position.y - scroll.top
+
+  click: ->
+    position = this.scrollIntoView().position
+    @page.sendEvent('click', position.x, position.y)
+
+  dragTo: (other) ->
+    { position, scroll } = this.scrollIntoView()
+    otherPosition        = this.relativePosition(other.position(), scroll)
+
+    @page.sendEvent('mousedown', position.x,      position.y)
+    @page.sendEvent('mousemove', otherPosition.x, otherPosition.y)
+    @page.sendEvent('mouseup',   otherPosition.x, otherPosition.y)