casperjs 1.0.0.RC1

data/modules/colorizer.js

@@ -0,0 +1,129 @@
+/*!
+ * 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 }
+    };
+
+    /**
+     * 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,247 @@
+// 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 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.");
+      }
+      return false;
+    }
+  }
+
+  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.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/injector.js

@@ -0,0 +1,93 @@
+/*!
+ * 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 console encodeURIComponent escape exports require*/
+
+var utils = require('utils');
+
+exports.create = function create(fn) {
+    "use strict";
+    return new FunctionArgsInjector(fn);
+};
+
+/**
+ * Function argument injector.
+ *
+ * FIXME: use new Function() instead of eval()
+ */
+var FunctionArgsInjector = function FunctionArgsInjector(fn) {
+    "use strict";
+    if (!utils.isFunction(fn)) {
+        throw new CasperError("FunctionArgsInjector() can only process functions");
+    }
+    this.fn = fn;
+
+    this.extract = function extract(fn) {
+        var match = /^function\s?(\w+)?\s?\((.*)\)\s?\{([\s\S]*)\}/i.exec(fn.toString().trim());
+        if (match && match.length > 1) {
+            var args = match[2].split(',').map(function _map(arg) {
+                return arg.replace(new RegExp(/\/\*+.*\*\//ig), "").trim();
+            }).filter(function _filter(arg) {
+                return arg;
+            }) || [];
+            return {
+                name: match[1] ? match[1].trim() : null,
+                args: args,
+                body: match[3] ? match[3].trim() : ''
+            };
+        }
+    };
+
+    this.process = function process(values) {
+        var fnObj = this.extract(this.fn);
+        if (!utils.isObject(fnObj)) {
+            throw new CasperError("Unable to process function " + this.fn.toString());
+        }
+        var inject = this.getArgsInjectionString(fnObj.args, values);
+        var newFn = new Function([inject, fnObj.body].join('\n'));
+        newFn.name = fnObj.name || '';
+        return newFn;
+    };
+
+    this.getArgsInjectionString = function getArgsInjectionString(args, values) {
+        values = typeof values === "object" ? values : {};
+        var jsonValues = escape(encodeURIComponent(JSON.stringify(values)));
+        var inject = [
+            'var __casper_params__ = JSON.parse(decodeURIComponent(unescape(\'' + jsonValues + '\')));'
+        ];
+        args.forEach(function _forEach(arg) {
+            if (arg in values) {
+                inject.push('var ' + arg + '=__casper_params__["' + arg + '"];');
+            }
+        });
+        return inject.join('\n') + '\n';
+    };
+};
+exports.FunctionArgsInjector = FunctionArgsInjector;