phantomjs-binaries 1.8.0

data/modules/colorizer.js

@@ -0,0 +1,130 @@
+/*!
+ * Casper is a navigation utility for PhantomJS.
+ *
+ * Documentation: http://casperjs.org/
+ * Repository:    http://github.com/n1k0/casperjs
+ *
+ * Copyright (c) 2011-2012 Nicolas Perriault
+ *
+ * Part of source code is Copyright Joyent, Inc. and other Node contributors.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+/*global exports console require*/
+
+var fs = require('fs');
+var utils = require('utils');
+
+exports.create = function create(type) {
+    "use strict";
+    if (!type) {
+        return;
+    }
+    if (!(type in exports)) {
+        throw new Error(utils.format('Unsupported colorizer type "%s"', type));
+    }
+    return new exports[type]();
+};
+
+/**
+ * This is a port of lime colorizer.
+ * http://trac.symfony-project.org/browser/tools/lime/trunk/lib/lime.php
+ *
+ * (c) Fabien Potencier, Symfony project, MIT license
+ */
+var Colorizer = function Colorizer() {
+    "use strict";
+    var options    = { bold: 1, underscore: 4, blink: 5, reverse: 7, conceal: 8 };
+    var foreground = { black: 30, red: 31, green: 32, yellow: 33, blue: 34, magenta: 35, cyan: 36, white: 37 };
+    var background = { black: 40, red: 41, green: 42, yellow: 43, blue: 44, magenta: 45, cyan: 46, white: 47 };
+    var styles     = {
+        'ERROR':     { bg: 'red', fg: 'white', bold: true },
+        'INFO':      { fg: 'green', bold: true },
+        'TRACE':     { fg: 'green', bold: true },
+        'PARAMETER': { fg: 'cyan' },
+        'COMMENT':   { fg: 'yellow' },
+        'WARNING':   { fg: 'red', bold: true },
+        'GREEN_BAR': { fg: 'white', bg: 'green', bold: true },
+        'RED_BAR':   { fg: 'white', bg: 'red', bold: true },
+        'INFO_BAR':  { bg: 'cyan', fg: 'white', bold: true },
+        'WARN_BAR':  { bg: 'yellow', fg: 'white', bold: true }
+    };
+
+    /**
+     * Adds a style to provided text.
+     *
+     * @param   String  text
+     * @param   String  styleName
+     * @return  String
+     */
+    this.colorize = function colorize(text, styleName, pad) {
+        if (fs.isWindows() || !(styleName in styles)) {
+            return text;
+        }
+        return this.format(text, styles[styleName], pad);
+    };
+
+    /**
+     * Formats a text using a style declaration object.
+     *
+     * @param  String  text
+     * @param  Object  style
+     * @return String
+     */
+    this.format = function format(text, style, pad) {
+        if (fs.isWindows() || !utils.isObject(style)) {
+            return text;
+        }
+        var codes = [];
+        if (style.fg && foreground[style.fg]) {
+            codes.push(foreground[style.fg]);
+        }
+        if (style.bg && background[style.bg]) {
+            codes.push(background[style.bg]);
+        }
+        for (var option in options) {
+            if (style[option] === true) {
+                codes.push(options[option]);
+            }
+        }
+        // pad
+        if (typeof pad === "number" && text.length < pad) {
+            text += new Array(pad - text.length + 1).join(' ');
+        }
+        return "\u001b[" + codes.join(';') + 'm' + text + "\u001b[0m";
+    };
+};
+exports.Colorizer = Colorizer;
+
+/**
+ * Dummy colorizer. Does basically nothing.
+ *
+ */
+var Dummy = function Dummy() {
+    "use strict";
+    this.colorize = function colorize(text, styleName, pad) {
+        return text;
+    };
+    this.format = function format(text, style, pad){
+        return text;
+    };
+};
+exports.Dummy = Dummy;

data/modules/events.js

@@ -0,0 +1,259 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+/*global CasperError*/
+
+var isArray = Array.isArray;
+
+function EventEmitter() {
+  this._filters = {};
+}
+exports.EventEmitter = EventEmitter;
+
+// By default EventEmitters will print a warning if more than
+// 10 listeners are added to it. This is a useful default which
+// helps finding memory leaks.
+//
+// Obviously not all Emitters should be limited to 10. This function allows
+// that to be increased. Set to zero for unlimited.
+var defaultMaxListeners = 10;
+EventEmitter.prototype.setMaxListeners = function(n) {
+  if (!this._events) this._events = {};
+  this._maxListeners = n;
+};
+
+
+EventEmitter.prototype.emit = function() {
+  var type = arguments[0];
+  // If there is no 'error' event listener then throw.
+  if (type === 'error') {
+    if (!this._events || !this._events.error ||
+        (isArray(this._events.error) && !this._events.error.length))
+    {
+      if (arguments[1] instanceof Error) {
+        throw arguments[1]; // Unhandled 'error' event
+      } else {
+        throw new CasperError("Uncaught, unspecified 'error' event.");
+      }
+    }
+  }
+
+  if (!this._events) return false;
+  var handler = this._events[type];
+  if (!handler) return false;
+
+  if (typeof handler == 'function') {
+    switch (arguments.length) {
+      // fast cases
+      case 1:
+        handler.call(this);
+        break;
+      case 2:
+        handler.call(this, arguments[1]);
+        break;
+      case 3:
+        handler.call(this, arguments[1], arguments[2]);
+        break;
+      // slower
+      default:
+        var l = arguments.length;
+        var args = new Array(l - 1);
+        for (var i = 1; i < l; i++) args[i - 1] = arguments[i];
+        handler.apply(this, args);
+    }
+    return true;
+
+  } else if (isArray(handler)) {
+    var l = arguments.length;
+    var args = new Array(l - 1);
+    for (var i = 1; i < l; i++) args[i - 1] = arguments[i];
+
+    var listeners = handler.slice();
+    for (var i = 0, l = listeners.length; i < l; i++) {
+      listeners[i].apply(this, args);
+    }
+    return true;
+
+  } else {
+    return false;
+  }
+};
+
+// EventEmitter is defined in src/node_events.cc
+// EventEmitter.prototype.emit() is also defined there.
+EventEmitter.prototype.addListener = function(type, listener) {
+  if ('function' !== typeof listener) {
+    throw new CasperError('addListener only takes instances of Function');
+  }
+
+  if (!this._events) this._events = {};
+
+  // To avoid recursion in the case that type == "newListeners"! Before
+  // adding it to the listeners, first emit "newListeners".
+  this.emit('newListener', type, listener);
+
+  if (!this._events[type]) {
+    // Optimize the case of one listener. Don't need the extra array object.
+    this._events[type] = listener;
+  } else if (isArray(this._events[type])) {
+
+    // If we've already got an array, just append.
+    this._events[type].push(listener);
+
+    // Check for listener leak
+    if (!this._events[type].warned) {
+      var m;
+      if (this._maxListeners !== undefined) {
+        m = this._maxListeners;
+      } else {
+        m = defaultMaxListeners;
+      }
+
+      if (m && m > 0 && this._events[type].length > m) {
+        this._events[type].warned = true;
+        console.error('(node) warning: possible EventEmitter memory ' +
+                      'leak detected. %d listeners added. ' +
+                      'Use emitter.setMaxListeners() to increase limit.',
+                      this._events[type].length);
+        console.trace();
+      }
+    }
+  } else {
+    // Adding the second element, need to change to array.
+    this._events[type] = [this._events[type], listener];
+  }
+
+  return this;
+};
+
+EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+
+EventEmitter.prototype.once = function(type, listener) {
+  if ('function' !== typeof listener) {
+    throw new CasperError('.once only takes instances of Function');
+  }
+
+  var self = this;
+  function g() {
+    self.removeListener(type, g);
+    listener.apply(this, arguments);
+  };
+
+  g.listener = listener;
+  self.on(type, g);
+
+  return this;
+};
+
+EventEmitter.prototype.removeListener = function(type, listener) {
+  if ('function' !== typeof listener) {
+    throw new CasperError('removeListener only takes instances of Function');
+  }
+
+  // does not use listeners(), so no side effect of creating _events[type]
+  if (!this._events || !this._events[type]) return this;
+
+  var list = this._events[type];
+
+  if (isArray(list)) {
+    var position = -1;
+    for (var i = 0, length = list.length; i < length; i++) {
+      if (list[i] === listener ||
+          (list[i].listener && list[i].listener === listener))
+      {
+        position = i;
+        break;
+      }
+    }
+
+    if (position < 0) return this;
+    list.splice(position, 1);
+    if (list.length == 0)
+      delete this._events[type];
+  } else if (list === listener ||
+             (list.listener && list.listener === listener))
+  {
+    delete this._events[type];
+  }
+
+  return this;
+};
+
+EventEmitter.prototype.removeAllListeners = function(type) {
+  if (arguments.length === 0) {
+    this._events = {};
+    return this;
+  }
+
+  // does not use listeners(), so no side effect of creating _events[type]
+  if (type && this._events && this._events[type]) this._events[type] = null;
+  return this;
+};
+
+EventEmitter.prototype.listeners = function(type) {
+  if (!this._events) this._events = {};
+  if (!this._events[type]) this._events[type] = [];
+  if (!isArray(this._events[type])) {
+    this._events[type] = [this._events[type]];
+  }
+  return this._events[type];
+};
+
+// Added for CasperJS: filters a value attached to an event
+EventEmitter.prototype.filter = function() {
+  var type = arguments[0];
+  if (!this._filters) {
+    this._filters = {};
+    return;
+  }
+
+  var filter = this._filters[type];
+  if (typeof filter !== 'function') {
+    return;
+  }
+  return filter.apply(this, Array.prototype.splice.call(arguments, 1));
+};
+
+EventEmitter.prototype.removeAllFilters = function(type) {
+  if (arguments.length === 0) {
+    this._filters = {};
+    return this;
+  }
+  if (type && this._filters && this._filters[type]) {
+    this._filters[type] = null;
+  }
+  return this;
+};
+
+EventEmitter.prototype.setFilter = function(type, filterFn) {
+  if (!this._filters) {
+    this._filters = {};
+  }
+  if ('function' !== typeof filterFn) {
+    throw new CasperError('setFilter only takes instances of Function');
+  }
+  if (!this._filters[type]) {
+    this._filters[type] = filterFn;
+    return true;
+  }
+  // TODO: process multiple filters? in which order? disallow?
+  return false;
+};

data/modules/http.js

@@ -0,0 +1,70 @@
+/*!
+ * Casper is a navigation utility for PhantomJS.
+ *
+ * Documentation: http://casperjs.org/
+ * Repository:    http://github.com/n1k0/casperjs
+ *
+ * Copyright (c) 2011-2012 Nicolas Perriault
+ *
+ * Part of source code is Copyright Joyent, Inc. and other Node contributors.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+var utils = require('utils');
+
+/*
+ * Building an Array subclass
+ */
+function responseHeaders(){}
+responseHeaders.prototype = [];
+
+/**
+ * Retrieves a given header based on its name
+ *
+ * @param   String  name    A case-insensitive response header name
+ * @return  mixed   A header string or `null` if not found
+ */
+responseHeaders.prototype.get = function get(name){
+    "use strict";
+    var headerValue = null;
+    name = name.toLowerCase();
+    this.some(function(header){
+        if (header.name.toLowerCase() === name){
+            headerValue = header.value;
+            return true;
+        }
+    });
+    return headerValue;
+};
+
+/**
+ * Augment the response with proper prototypes
+ *
+ * @param mixed response    Phantom response or undefined (generally with local files)
+ */
+exports.augmentResponse = function(response) {
+    "use strict";
+    /*jshint proto:true*/
+    if (!utils.isHTTPResource(response)) {
+        return;
+    }
+    response.headers.__proto__ = responseHeaders.prototype;
+};

data/modules/mouse.js

@@ -0,0 +1,109 @@
+/*!
+ * Casper is a navigation utility for PhantomJS.
+ *
+ * Documentation: http://casperjs.org/
+ * Repository:    http://github.com/n1k0/casperjs
+ *
+ * Copyright (c) 2011-2012 Nicolas Perriault
+ *
+ * Part of source code is Copyright Joyent, Inc. and other Node contributors.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+/*global CasperError exports require*/
+
+var utils = require('utils');
+
+exports.create = function create(casper) {
+    "use strict";
+    return new Mouse(casper);
+};
+
+var Mouse = function Mouse(casper) {
+    "use strict";
+    if (!utils.isCasperObject(casper)) {
+        throw new CasperError('Mouse() needs a Casper instance');
+    }
+
+    var slice = Array.prototype.slice;
+
+    var nativeEvents = ['mouseup', 'mousedown', 'click', 'mousemove'];
+    var emulatedEvents = ['mouseover', 'mouseout'];
+    var supportedEvents = nativeEvents.concat(emulatedEvents);
+
+    function computeCenter(selector) {
+        var bounds = casper.getElementBounds(selector);
+        if (utils.isClipRect(bounds)) {
+            var x = Math.round(bounds.left + bounds.width / 2);
+            var y = Math.round(bounds.top  + bounds.height / 2);
+            return [x, y];
+        }
+    }
+
+    function processEvent(type, args) {
+        if (!utils.isString(type) || supportedEvents.indexOf(type) === -1) {
+            throw new CasperError('Mouse.processEvent(): Unsupported mouse event type: ' + type);
+        }
+        if (emulatedEvents.indexOf(type) > -1) {
+            casper.log("Mouse.processEvent(): no native fallback for type " + type, "warning");
+        }
+        args = slice.call(args); // cast Arguments -> Array
+        casper.emit('mouse.' + type.replace('mouse', ''), args);
+        switch (args.length) {
+            case 0:
+                throw new CasperError('Mouse.processEvent(): Too few arguments');
+            case 1:
+                // selector
+                casper.page.sendEvent.apply(casper.page, [type].concat(computeCenter(args[0])));
+                break;
+            case 2:
+                // coordinates
+                if (!utils.isNumber(args[0]) || !utils.isNumber(args[1])) {
+                    throw new CasperError('Mouse.processEvent(): No valid coordinates passed: ' + args);
+                }
+                casper.page.sendEvent(type, args[0], args[1]);
+                break;
+            default:
+                throw new CasperError('Mouse.processEvent(): Too many arguments');
+        }
+    }
+
+    this.processEvent = function() {
+        processEvent(arguments[0], slice.call(arguments, 1));
+    };
+
+    this.click = function click() {
+        processEvent('click', arguments);
+    };
+
+    this.down = function down() {
+        processEvent('mousedown', arguments);
+    };
+
+    this.move = function move() {
+        processEvent('mousemove', arguments);
+    };
+
+    this.up = function up() {
+        processEvent('mouseup', arguments);
+    };
+};
+exports.Mouse = Mouse;