undead 0.1.1 → 0.2.0

data/lib/undead/client/compiled/cmd.js

@@ -0,0 +1,31 @@
+Poltergeist.Cmd = (function() {
+  function Cmd(owner, id, name, args) {
+    this.owner = owner;
+    this.id = id;
+    this.name = name;
+    this.args = args;
+  }
+
+  Cmd.prototype.sendResponse = function(response) {
+    var errors;
+    errors = this.browser.currentPage.errors;
+    this.browser.currentPage.clearErrors();
+    if (errors.length > 0 && this.browser.js_errors) {
+      return this.sendError(new Poltergeist.JavascriptError(errors));
+    } else {
+      return this.owner.sendResponse(this.id, response);
+    }
+  };
+
+  Cmd.prototype.sendError = function(errors) {
+    return this.owner.sendError(this.id, errors);
+  };
+
+  Cmd.prototype.run = function(browser) {
+    this.browser = browser;
+    return this.browser.runCommand(this);
+  };
+
+  return Cmd;
+
+})();

data/lib/undead/client/compiled/connection.js

@@ -0,0 +1,25 @@
+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/undead/client/compiled/main.js

@@ -0,0 +1,229 @@
+var Poltergeist, system,
+  extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+  hasProp = {}.hasOwnProperty;
+
+Poltergeist = (function() {
+  function Poltergeist(port, width, height) {
+    var that;
+    this.browser = new Poltergeist.Browser(width, height);
+    this.connection = new Poltergeist.Connection(this, port);
+    that = this;
+    phantom.onError = function(message, stack) {
+      return that.onError(message, stack);
+    };
+    this.running = false;
+  }
+
+  Poltergeist.prototype.runCommand = function(command) {
+    var error, error1;
+    this.running = true;
+    command = new Poltergeist.Cmd(this, command.id, command.name, command.args);
+    try {
+      return command.run(this.browser);
+    } catch (error1) {
+      error = error1;
+      if (error instanceof Poltergeist.Error) {
+        return this.sendError(command.id, error);
+      } else {
+        return this.sendError(command.id, new Poltergeist.BrowserError(error.toString(), error.stack));
+      }
+    }
+  };
+
+  Poltergeist.prototype.sendResponse = function(command_id, response) {
+    return this.send({
+      command_id: command_id,
+      response: response
+    });
+  };
+
+  Poltergeist.prototype.sendError = function(command_id, error) {
+    return this.send({
+      command_id: command_id,
+      error: {
+        name: error.name || 'Generic',
+        args: error.args && error.args() || [error.toString()]
+      }
+    });
+  };
+
+  Poltergeist.prototype.send = function(data) {
+    if (this.running) {
+      this.connection.send(data);
+      this.running = false;
+      return true;
+    }
+    return false;
+  };
+
+  return Poltergeist;
+
+})();
+
+window.Poltergeist = Poltergeist;
+
+Poltergeist.Error = (function() {
+  function Error() {}
+
+  return Error;
+
+})();
+
+Poltergeist.ObsoleteNode = (function(superClass) {
+  extend(ObsoleteNode, superClass);
+
+  function ObsoleteNode() {
+    return ObsoleteNode.__super__.constructor.apply(this, arguments);
+  }
+
+  ObsoleteNode.prototype.name = "Poltergeist.ObsoleteNode";
+
+  ObsoleteNode.prototype.args = function() {
+    return [];
+  };
+
+  ObsoleteNode.prototype.toString = function() {
+    return this.name;
+  };
+
+  return ObsoleteNode;
+
+})(Poltergeist.Error);
+
+Poltergeist.InvalidSelector = (function(superClass) {
+  extend(InvalidSelector, superClass);
+
+  function InvalidSelector(method, selector) {
+    this.method = method;
+    this.selector = selector;
+  }
+
+  InvalidSelector.prototype.name = "Poltergeist.InvalidSelector";
+
+  InvalidSelector.prototype.args = function() {
+    return [this.method, this.selector];
+  };
+
+  return InvalidSelector;
+
+})(Poltergeist.Error);
+
+Poltergeist.FrameNotFound = (function(superClass) {
+  extend(FrameNotFound, superClass);
+
+  function FrameNotFound(frameName) {
+    this.frameName = frameName;
+  }
+
+  FrameNotFound.prototype.name = "Poltergeist.FrameNotFound";
+
+  FrameNotFound.prototype.args = function() {
+    return [this.frameName];
+  };
+
+  return FrameNotFound;
+
+})(Poltergeist.Error);
+
+Poltergeist.MouseEventFailed = (function(superClass) {
+  extend(MouseEventFailed, superClass);
+
+  function MouseEventFailed(eventName, selector, position) {
+    this.eventName = eventName;
+    this.selector = selector;
+    this.position = position;
+  }
+
+  MouseEventFailed.prototype.name = "Poltergeist.MouseEventFailed";
+
+  MouseEventFailed.prototype.args = function() {
+    return [this.eventName, this.selector, this.position];
+  };
+
+  return MouseEventFailed;
+
+})(Poltergeist.Error);
+
+Poltergeist.JavascriptError = (function(superClass) {
+  extend(JavascriptError, superClass);
+
+  function JavascriptError(errors) {
+    this.errors = errors;
+  }
+
+  JavascriptError.prototype.name = "Poltergeist.JavascriptError";
+
+  JavascriptError.prototype.args = function() {
+    return [this.errors];
+  };
+
+  return JavascriptError;
+
+})(Poltergeist.Error);
+
+Poltergeist.BrowserError = (function(superClass) {
+  extend(BrowserError, superClass);
+
+  function BrowserError(message1, stack1) {
+    this.message = message1;
+    this.stack = stack1;
+  }
+
+  BrowserError.prototype.name = "Poltergeist.BrowserError";
+
+  BrowserError.prototype.args = function() {
+    return [this.message, this.stack];
+  };
+
+  return BrowserError;
+
+})(Poltergeist.Error);
+
+Poltergeist.StatusFailError = (function(superClass) {
+  extend(StatusFailError, superClass);
+
+  function StatusFailError(url, details) {
+    this.url = url;
+    this.details = details;
+  }
+
+  StatusFailError.prototype.name = "Poltergeist.StatusFailError";
+
+  StatusFailError.prototype.args = function() {
+    return [this.url, this.details];
+  };
+
+  return StatusFailError;
+
+})(Poltergeist.Error);
+
+Poltergeist.NoSuchWindowError = (function(superClass) {
+  extend(NoSuchWindowError, superClass);
+
+  function NoSuchWindowError() {
+    return NoSuchWindowError.__super__.constructor.apply(this, arguments);
+  }
+
+  NoSuchWindowError.prototype.name = "Poltergeist.NoSuchWindowError";
+
+  NoSuchWindowError.prototype.args = function() {
+    return [];
+  };
+
+  return NoSuchWindowError;
+
+})(Poltergeist.Error);
+
+phantom.injectJs(phantom.libraryPath + "/web_page.js");
+
+phantom.injectJs(phantom.libraryPath + "/node.js");
+
+phantom.injectJs(phantom.libraryPath + "/connection.js");
+
+phantom.injectJs(phantom.libraryPath + "/cmd.js");
+
+phantom.injectJs(phantom.libraryPath + "/browser.js");
+
+system = require('system');
+
+new Poltergeist(system.args[1], system.args[2], system.args[3]);

data/lib/undead/client/compiled/node.js

@@ -0,0 +1,187 @@
+var slice = [].slice;
+
+Poltergeist.Node = (function() {
+  var fn, j, len, name, ref;
+
+  Node.DELEGATES = ['allText', 'visibleText', 'getAttribute', 'value', 'set', 'setAttribute', 'isObsolete', 'removeAttribute', 'isMultiple', 'select', 'tagName', 'find', 'getAttributes', 'isVisible', 'isInViewport', 'position', 'trigger', 'parentId', 'parentIds', 'mouseEventTest', 'scrollIntoView', 'isDOMEqual', 'isDisabled', 'deleteText', 'containsSelection', 'path', 'getProperty'];
+
+  function Node(page, id) {
+    this.page = page;
+    this.id = id;
+  }
+
+  Node.prototype.parent = function() {
+    return new Poltergeist.Node(this.page, this.parentId());
+  };
+
+  ref = Node.DELEGATES;
+  fn = function(name) {
+    return Node.prototype[name] = function() {
+      var args;
+      args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
+      return this.page.nodeCall(this.id, name, args);
+    };
+  };
+  for (j = 0, len = ref.length; j < len; j++) {
+    name = ref[j];
+    fn(name);
+  }
+
+  Node.prototype.mouseEventPosition = function() {
+    var area_offset, image, middle, pos, res, viewport;
+    viewport = this.page.viewportSize();
+    if (image = this._getAreaImage()) {
+      pos = image.position();
+      if (area_offset = this._getAreaOffsetRect()) {
+        pos.left = pos.left + area_offset.x;
+        pos.right = pos.left + area_offset.width;
+        pos.top = pos.top + area_offset.y;
+        pos.bottom = pos.top + area_offset.height;
+      }
+    } else {
+      pos = this.position();
+    }
+    middle = function(start, end, size) {
+      return start + ((Math.min(end, size) - start) / 2);
+    };
+    return res = {
+      x: middle(pos.left, pos.right, viewport.width),
+      y: middle(pos.top, pos.bottom, viewport.height)
+    };
+  };
+
+  Node.prototype.mouseEvent = function(name) {
+    var area_image, pos, test;
+    if (area_image = this._getAreaImage()) {
+      area_image.scrollIntoView();
+    } else {
+      this.scrollIntoView();
+    }
+    pos = this.mouseEventPosition();
+    test = this.mouseEventTest(pos.x, pos.y);
+    if (test.status === 'success') {
+      if (name === 'rightclick') {
+        this.page.mouseEvent('click', pos.x, pos.y, 'right');
+        this.trigger('contextmenu');
+      } else {
+        this.page.mouseEvent(name, pos.x, pos.y);
+      }
+      return pos;
+    } else {
+      throw new Poltergeist.MouseEventFailed(name, test.selector, pos);
+    }
+  };
+
+  Node.prototype.dragTo = function(other) {
+    var otherPosition, position;
+    this.scrollIntoView();
+    position = this.mouseEventPosition();
+    otherPosition = other.mouseEventPosition();
+    this.page.mouseEvent('mousedown', position.x, position.y);
+    return this.page.mouseEvent('mouseup', otherPosition.x, otherPosition.y);
+  };
+
+  Node.prototype.dragBy = function(x, y) {
+    var final_pos, position;
+    this.scrollIntoView();
+    position = this.mouseEventPosition();
+    final_pos = {
+      x: position.x + x,
+      y: position.y + y
+    };
+    this.page.mouseEvent('mousedown', position.x, position.y);
+    return this.page.mouseEvent('mouseup', final_pos.x, final_pos.y);
+  };
+
+  Node.prototype.isEqual = function(other) {
+    return this.page === other.page && this.isDOMEqual(other.id);
+  };
+
+  Node.prototype._getAreaOffsetRect = function() {
+    var centerX, centerY, coord, coords, i, maxX, maxY, minX, minY, radius, rect, shape, x, xs, y, ys;
+    shape = this.getAttribute('shape').toLowerCase();
+    coords = (function() {
+      var k, len1, ref1, results;
+      ref1 = this.getAttribute('coords').split(',');
+      results = [];
+      for (k = 0, len1 = ref1.length; k < len1; k++) {
+        coord = ref1[k];
+        results.push(parseInt(coord, 10));
+      }
+      return results;
+    }).call(this);
+    return rect = (function() {
+      switch (shape) {
+        case 'rect':
+        case 'rectangle':
+          x = coords[0], y = coords[1];
+          return {
+            x: x,
+            y: y,
+            width: coords[2] - x,
+            height: coords[3] - y
+          };
+        case 'circ':
+        case 'circle':
+          centerX = coords[0], centerY = coords[1], radius = coords[2];
+          return {
+            x: centerX - radius,
+            y: centerY - radius,
+            width: 2 * radius,
+            height: 2 * radius
+          };
+        case 'poly':
+        case 'polygon':
+          xs = (function() {
+            var k, ref1, results;
+            results = [];
+            for (i = k = 0, ref1 = coords.length; k < ref1; i = k += 2) {
+              results.push(coords[i]);
+            }
+            return results;
+          })();
+          ys = (function() {
+            var k, ref1, results;
+            results = [];
+            for (i = k = 1, ref1 = coords.length; k < ref1; i = k += 2) {
+              results.push(coords[i]);
+            }
+            return results;
+          })();
+          minX = Math.min.apply(Math, xs);
+          maxX = Math.max.apply(Math, xs);
+          minY = Math.min.apply(Math, ys);
+          maxY = Math.max.apply(Math, ys);
+          return {
+            x: minX,
+            y: minY,
+            width: maxX - minX,
+            height: maxY - minY
+          };
+      }
+    })();
+  };
+
+  Node.prototype._getAreaImage = function() {
+    var image_node_id, map, mapName;
+    if ('area' === this.tagName().toLowerCase()) {
+      map = this.parent();
+      if (map.tagName().toLowerCase() !== 'map') {
+        throw new Error('the area is not within a map');
+      }
+      mapName = map.getAttribute('name');
+      if (mapName == null) {
+        throw new Error("area's parent map must have a name");
+      }
+      mapName = '#' + mapName.toLowerCase();
+      image_node_id = this.page.find('css', "img[usemap='" + mapName + "']")[0];
+      if (image_node_id == null) {
+        throw new Error("no image matches the map");
+      }
+      return this.page.get(image_node_id);
+    }
+  };
+
+  return Node;
+
+})();