casperjs 1.0.0.RC1

data/bin/usage.txt

@@ -0,0 +1,10 @@
+
+Usage: casperjs [options] script.[js|coffee] [script argument [script argument ...]]
+       casperjs [options] test [test path [test path ...]]
+
+Options:
+
+--help      Prints this help
+--version   Prints out CasperJS version
+
+Read the docs http://casperjs.org/

data/casperjs.gemspec

@@ -0,0 +1,21 @@
+
+
+Gem::Specification.new do |s|
+  s.name                = "casperjs"
+  s.version             = "1.0.0.RC1"
+  s.homepage            = "http://casperjs.org/"
+  s.authors             = ["Nicolas Perriault", ]
+  s.email               = ["nperriault@gmail.com",]
+  s.description         = "CasperJS is a navigation scripting & testing utility for [PhantomJS](http://www.phantomjs.org/).
+It eases the process of defining a full navigation scenario and provides useful
+high-level functions, methods & syntaxic sugar for doing common tasks."
+  s.summary             = "Navigation scripting & testing utility for PhantomJS"
+  s.extra_rdoc_files    = ["LICENSE.md", "README.md"]
+  s.files               = Dir["LICENSE.md", "README.md", "CHANGELOG.md", "package.json", "casperjs.gemspec", 
+                            "bin/bootstrap.js", "bin/usage.txt", "bin/casperjs_python", 
+                            "docs/**/*", "modules/**/*", "samples/**/*", "tests/**/*"]
+  s.bindir              = "rubybin"
+  s.executables         = [ "casperjs" ]
+  s.license             = "MIT"
+  s.requirements        = [ "PhantomJS v1.5" ]
+end

data/modules/casper.js

@@ -0,0 +1,1679 @@
+/*!
+ * 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 exports phantom require*/
+
+var colorizer = require('colorizer');
+var events = require('events');
+var fs = require('fs');
+var mouse = require('mouse');
+var qs = require('querystring');
+var tester = require('tester');
+var utils = require('utils');
+var f = utils.format;
+
+
+var defaultUserAgent = phantom.defaultPageSettings.userAgent
+    .replace('PhantomJS', f("CasperJS/%s", phantom.casperVersion) + '+Phantomjs');
+
+exports.create = function create(options) {
+    "use strict";
+    return new Casper(options);
+};
+
+/**
+ * Shortcut to build an XPath selector object.
+ *
+ * @param  String  expression  The XPath expression
+ * @return Object
+ * @see    http://casperjs.org/selectors.html
+ */
+function selectXPath(expression) {
+    "use strict";
+    return {
+        type: 'xpath',
+        path: expression,
+        toString: function() {
+            return this.type + ' selector: ' + this.path;
+        }
+    };
+}
+exports.selectXPath = selectXPath;
+
+/**
+ * Main Casper object.
+ *
+ * @param  Object  options  Casper options
+ */
+var Casper = function Casper(options) {
+    "use strict";
+    // init & checks
+    if (!(this instanceof Casper)) {
+        return new Casper(options);
+    }
+    // default options
+    this.defaults = {
+        clientScripts:       [],
+        colorizerType:       'Colorizer',
+        exitOnError:         true,
+        logLevel:            "error",
+        httpStatusHandlers:  {},
+        safeLogs:            true,
+        onAlert:             null,
+        onDie:               null,
+        onError:             null,
+        onLoadError:         null,
+        onPageInitialized:   null,
+        onResourceReceived:  null,
+        onResourceRequested: null,
+        onStepComplete:      null,
+        onStepTimeout:       null,
+        onTimeout:           null,
+        page:                null,
+        pageSettings:        {
+            localToRemoteUrlAccessEnabled: true,
+            userAgent:                     defaultUserAgent
+        },
+        stepTimeout:         null,
+        timeout:             null,
+        verbose:             false
+    };
+    // options
+    this.options = utils.mergeObjects(this.defaults, options);
+    // properties
+    this.checker = null;
+    this.cli = phantom.casperArgs;
+    this.colorizer = this.getColorizer();
+    this.currentUrl = 'about:blank';
+    this.currentHTTPStatus = 0;
+    this.defaultWaitTimeout = 5000;
+    this.history = [];
+    this.loadInProgress = false;
+    this.logFormats = {};
+    this.logLevels = ["debug", "info", "warning", "error"];
+    this.logStyles = {
+        debug:   'INFO',
+        info:    'PARAMETER',
+        warning: 'COMMENT',
+        error:   'ERROR'
+    };
+    this.mouse = mouse.create(this);
+    this.page = null;
+    this.pendingWait = false;
+    this.requestUrl = 'about:blank';
+    this.resources = [];
+    this.result = {
+        log:    [],
+        status: "success",
+        time:   0
+    };
+    this.started = false;
+    this.step = -1;
+    this.steps = [];
+    this.test = tester.create(this);
+
+    // init phantomjs error handler
+    this.initErrorHandler();
+
+    this.on('error', function(msg, backtrace) {
+        var c = this.getColorizer();
+        var match = /^(.*): __mod_error(.*):: (.*)/.exec(msg);
+        var notices = [];
+        if (match && match.length === 4) {
+            notices.push('  in module ' + match[2]);
+            notices.push('  NOTICE: errors within modules cannot be backtraced yet.');
+            msg = match[3];
+        }
+        console.error(c.colorize(msg, 'RED_BAR', 80));
+        notices.forEach(function(notice) {
+            console.error(c.colorize(notice, 'COMMENT'));
+        });
+        backtrace.forEach(function(item) {
+            var message = fs.absolute(item.file) + ":" + c.colorize(item.line, "COMMENT");
+            if (item['function']) {
+                message += " in " + c.colorize(item['function'], "PARAMETER");
+            }
+            console.error("  " + message);
+        });
+    });
+
+    // deprecated feature event handler
+    this.on('deprecated', function onDeprecated(message) {
+        this.warn('[deprecated] ' + message);
+    });
+
+    // dispatching an event when instance has been constructed
+    this.emit('init');
+};
+
+// Casper class is an EventEmitter
+utils.inherits(Casper, events.EventEmitter);
+
+/**
+ * Go a step back in browser's history
+ *
+ * @return Casper
+ */
+Casper.prototype.back = function back() {
+    "use strict";
+    return this.then(function _step() {
+        this.emit('back');
+        this.evaluate(function _evaluate() {
+            history.back();
+        });
+    });
+};
+
+/**
+ * Encodes a resource using the base64 algorithm synchroneously using
+ * client-side XMLHttpRequest.
+ *
+ * NOTE: we cannot use window.btoa() for some strange reasons here.
+ *
+ * @param  String  url     The url to download
+ * @param  String  method  The method to use, optional: default GET
+ * @param  String  data    The data to send, optional
+ * @return string          Base64 encoded result
+ */
+Casper.prototype.base64encode = function base64encode(url, method, data) {
+    "use strict";
+    return this.evaluate(function _evaluate(url, method, data) {
+        return window.__utils__.getBase64(url, method, data);
+    }, { url: url, method: method, data: data });
+};
+
+/**
+ * Proxy method for WebPage#render. Adds a clipRect parameter for
+ * automatically set page clipRect setting values and sets it back once
+ * done. If the cliprect parameter is omitted, the full page viewport
+ * area will be rendered.
+ *
+ * @param  String  targetFile  A target filename
+ * @param  mixed   clipRect    An optional clipRect object (optional)
+ * @return Casper
+ */
+Casper.prototype.capture = function capture(targetFile, clipRect) {
+    "use strict";
+    if (!this.started) {
+        throw new CasperError("Casper not started, can't capture()");
+    }
+    var previousClipRect;
+    targetFile = fs.absolute(targetFile);
+    if (clipRect) {
+        if (!utils.isClipRect(clipRect)) {
+            throw new CasperError("clipRect must be a valid ClipRect object.");
+        }
+        previousClipRect = this.page.clipRect;
+        this.page.clipRect = clipRect;
+        this.log(f("Capturing page to %s with clipRect %s", targetFile, JSON.stringify(clipRect)), "debug");
+    } else {
+        this.log(f("Capturing page to %s", targetFile), "debug");
+    }
+    if (!this.page.render(this.filter('capture.target_filename', targetFile) || targetFile)) {
+        this.log(f("Failed to save screenshot to %s; please check permissions", targetFile), "error");
+    } else {
+        this.log(f("Capture saved to %s", targetFile), "info");
+        this.emit('capture.saved', targetFile);
+    }
+    if (previousClipRect) {
+        this.page.clipRect = previousClipRect;
+    }
+    return this;
+};
+
+/**
+ * Returns a Base64 representation of a binary image capture of the current
+ * page, or an area within the page, in a given format.
+ *
+ * Supported image formats are `bmp`, `jpg`, `jpeg`, `png`, `ppm`, `tiff`,
+ * `xbm` and `xpm`.
+ *
+ * @param  String                   format    The image format
+ * @param  String|Object|undefined  selector  DOM CSS3/XPath selector or clipRect object (optional)
+ * @return Casper
+ */
+Casper.prototype.captureBase64 = function captureBase64(format, area) {
+    "use strict";
+    if (!this.started) {
+        throw new CasperError("Casper not started, can't captureBase64()");
+    }
+    if (!('renderBase64' in this.page)) {
+        this.warn('captureBase64() requires PhantomJS >= 1.6');
+        return;
+    }
+    var base64;
+    var previousClipRect;
+    var formats = ['bmp', 'jpg', 'jpeg', 'png', 'ppm', 'tiff', 'xbm', 'xpm'];
+    if (formats.indexOf(format.toLowerCase()) === -1) {
+        throw new CasperError(f('Unsupported format "%s"', format));
+    }
+    if (utils.isClipRect(area)) {
+        // if area is a clipRect object
+        this.log(f("Capturing base64 %s representation of %s", format, utils.serialize(area)), "debug");
+        previousClipRect = this.page.clipRect;
+        this.page.clipRect = area;
+        base64 = this.page.renderBase64(format);
+    } else if (utils.isValidSelector(area)) {
+        // if area is a selector string or object
+        this.log(f("Capturing base64 %s representation of %s", format, area), "debug");
+        base64 = this.captureBase64(format, this.getElementBounds(area));
+    } else {
+        // whole page capture
+        this.log(f("Capturing base64 %s representation of page", format), "debug");
+        base64 = this.page.renderBase64(format);
+    }
+    if (previousClipRect) {
+        this.page.clipRect = previousClipRect;
+    }
+    return base64;
+};
+
+/**
+ * Captures the page area matching the provided selector.
+ *
+ * @param  String  targetFile  Target destination file path.
+ * @param  String  selector    DOM CSS3/XPath selector
+ * @return Casper
+ */
+Casper.prototype.captureSelector = function captureSelector(targetFile, selector) {
+    "use strict";
+    return this.capture(targetFile, this.getElementBounds(selector));
+};
+
+/**
+ * Checks for any further navigation step to process.
+ *
+ * @param  Casper    self        A self reference
+ * @param  function  onComplete  An options callback to apply on completion
+ */
+Casper.prototype.checkStep = function checkStep(self, onComplete) {
+    "use strict";
+    if (self.pendingWait || self.loadInProgress) {
+        return;
+    }
+    var step = self.steps[self.step++];
+    if (utils.isFunction(step)) {
+        self.runStep(step);
+    } else {
+        self.result.time = new Date().getTime() - self.startTime;
+        self.log(f("Done %s steps in %dms", self.steps.length, self.result.time), "info");
+        clearInterval(self.checker);
+        self.emit('run.complete');
+        if (utils.isFunction(onComplete)) {
+            onComplete.call(self, self);
+        } else {
+            // default behavior is to exit
+            self.exit();
+        }
+    }
+};
+
+/**
+ * Clears the current page execution environment context. Useful to avoid
+ * having previously loaded DOM contents being still active (refs #34).
+ *
+ * Think of it as a way to stop javascript execution within the remote DOM
+ * environment.
+ *
+ * @return Casper
+ */
+Casper.prototype.clear = function clear() {
+    "use strict";
+    this.page.content = '';
+    return this;
+};
+
+/**
+ * Emulates a click on the element from the provided selector using the mouse
+ * pointer, if possible.
+ *
+ * In case of success, `true` is returned, `false` otherwise.
+ *
+ * @param  String   selector  A DOM CSS3 compatible selector
+ * @return Boolean
+ */
+Casper.prototype.click = function click(selector) {
+    "use strict";
+    return this.mouseEvent('click', selector);
+};
+
+/**
+ * Emulates a click on the element having `label` as innerText. The first
+ * element matching this label will be selected, so use with caution.
+ *
+ * @param  String   label  Element innerText value
+ * @param  String   tag    An element tag name (eg. `a` or `button`) (optional)
+ * @return Boolean
+ */
+Casper.prototype.clickLabel = function clickLabel(label, tag) {
+    "use strict";
+    tag = tag || "*";
+    var escapedLabel = label.toString().replace(/"/g, '\\"');
+    var selector = selectXPath(f('//%s[text()="%s"]', tag, escapedLabel));
+    return this.click(selector);
+};
+
+/**
+ * Creates a step definition.
+ *
+ * @param  Function  fn       The step function to call
+ * @param  Object    options  Step options
+ * @return Function  The final step function
+ */
+Casper.prototype.createStep = function createStep(fn, options) {
+    "use strict";
+    if (!utils.isFunction(fn)) {
+        throw new CasperError("createStep(): a step definition must be a function");
+    }
+    fn.options = utils.isObject(options) ? options : {};
+    this.emit('step.created', fn);
+    return fn;
+};
+
+/**
+ * Logs the HTML code of the current page.
+ *
+ * @return Casper
+ */
+Casper.prototype.debugHTML = function debugHTML() {
+    "use strict";
+    this.echo(this.page.content);
+    return this;
+};
+
+/**
+ * Logs the textual contents of the current page.
+ *
+ * @return Casper
+ */
+Casper.prototype.debugPage = function debugPage() {
+    "use strict";
+    this.echo(this.evaluate(function _evaluate() {
+        return document.body.textContent || document.body.innerText;
+    }));
+    return this;
+};
+
+/**
+ * Exit phantom on failure, with a logged error message.
+ *
+ * @param  String  message  An optional error message
+ * @param  Number  status   An optional exit status code (must be > 0)
+ * @return Casper
+ */
+Casper.prototype.die = function die(message, status) {
+    "use strict";
+    this.result.status = "error";
+    this.result.time = new Date().getTime() - this.startTime;
+    if (!utils.isString(message) || !message.length) {
+        message = "Suite explicitely interrupted without any message given.";
+    }
+    this.log(message, "error");
+    this.emit('die', message, status);
+    if (utils.isFunction(this.options.onDie)) {
+        this.options.onDie.call(this, this, message, status);
+    }
+    return this.exit(~~status > 0 ? ~~status : 1);
+};
+
+/**
+ * Downloads a resource and saves it on the filesystem.
+ *
+ * @param  String  url         The url of the resource to download
+ * @param  String  targetPath  The destination file path
+ * @param  String  method      The HTTP method to use (default: GET)
+ * @param  String  data        Optional data to pass performing the request
+ * @return Casper
+ */
+Casper.prototype.download = function download(url, targetPath, method, data) {
+    "use strict";
+    var cu = require('clientutils').create(this.options);
+    try {
+        fs.write(targetPath, cu.decode(this.base64encode(url, method, data)), 'wb');
+        this.emit('downloaded.file', targetPath);
+        this.log(f("Downloaded and saved resource in %s", targetPath));
+    } catch (e) {
+        this.log(f("Error while downloading %s to %s: %s", url, targetPath, e), "error");
+    }
+    return this;
+};
+
+/**
+ * Iterates over the values of a provided array and execute a callback
+ * for @ item.
+ *
+ * @param  Array     array
+ * @param  Function  fn     Callback: function(self, item, index)
+ * @return Casper
+ */
+Casper.prototype.each = function each(array, fn) {
+    "use strict";
+    if (!utils.isArray(array)) {
+        this.log("each() only works with arrays", "error");
+        return this;
+    }
+    (function _each(self) {
+        array.forEach(function _forEach(item, i) {
+            fn.call(self, self, item, i);
+        });
+    })(this);
+    return this;
+};
+
+/**
+ * Prints something to stdout.
+ *
+ * @param  String  text   A string to echo to stdout
+ * @param  String  style  An optional style name
+ * @param  Number  pad    An optional pad value
+ * @return Casper
+ */
+Casper.prototype.echo = function echo(text, style, pad) {
+    "use strict";
+    if (!utils.isString(text)) {
+        try {
+            text = text.toString();
+        } catch (e) {
+            try {
+                text = utils.serialize(text);
+            } catch (e) {
+                text = '';
+            }
+        }
+    }
+    var message = style ? this.colorizer.colorize(text, style, pad) : text;
+    console.log(this.filter('echo.message', message) || message);
+    return this;
+};
+
+/**
+ * Evaluates an expression in the page context, a bit like what
+ * WebPage#evaluate does, but the passed function can also accept
+ * parameters if a context Object is also passed:
+ *
+ *     casper.evaluate(function(username, password) {
+ *         document.querySelector('#username').value = username;
+ *         document.querySelector('#password').value = password;
+ *         document.querySelector('#submit').click();
+ *     }, {
+ *         username: 'Bazoonga',
+ *         password: 'baz00nga'
+ *     })
+ *
+ * FIXME: waiting for a patch of PhantomJS to allow direct passing of
+ * arguments to the function.
+ * TODO: don't forget to keep this backward compatible.
+ *
+ * @param  Function  fn       The function to be evaluated within current page DOM
+ * @param  Object    context  Object containing the parameters to inject into the function
+ * @return mixed
+ * @see    WebPage#evaluate
+ */
+Casper.prototype.evaluate = function evaluate(fn, context) {
+    "use strict";
+    // ensure client utils are always injected
+    this.injectClientUtils();
+    // function processing
+    context = utils.isObject(context) ? context : {};
+    var newFn = require('injector').create(fn).process(context);
+    return this.page.evaluate(newFn);
+};
+
+/**
+ * Evaluates an expression within the current page DOM and die() if it
+ * returns false.
+ *
+ * @param  function  fn       The expression to evaluate
+ * @param  String    message  The error message to log
+ * @return Casper
+ */
+Casper.prototype.evaluateOrDie = function evaluateOrDie(fn, message) {
+    "use strict";
+    if (!this.evaluate(fn)) {
+        return this.die(message);
+    }
+    return this;
+};
+
+/**
+ * Checks if an element matching the provided DOM CSS3/XPath selector exists in
+ * current page DOM.
+ *
+ * @param  String  selector  A DOM CSS3/XPath selector
+ * @return Boolean
+ */
+Casper.prototype.exists = function exists(selector) {
+    "use strict";
+    return this.evaluate(function _evaluate(selector) {
+        return window.__utils__.exists(selector);
+    }, { selector: selector });
+};
+
+/**
+ * Exits phantom.
+ *
+ * @param  Number  status  Status
+ * @return Casper
+ */
+Casper.prototype.exit = function exit(status) {
+    "use strict";
+    this.emit('exit', status);
+    phantom.exit(status);
+    return this;
+};
+
+/**
+ * Fetches innerText within the element(s) matching a given CSS3
+ * selector.
+ *
+ * @param  String  selector  A DOM CSS3/XPath selector
+ * @return String
+ */
+Casper.prototype.fetchText = function fetchText(selector) {
+    "use strict";
+    return this.evaluate(function _evaluate(selector) {
+        return window.__utils__.fetchText(selector);
+    }, { selector: selector });
+};
+
+/**
+ * Fills a form with provided field values.
+ *
+ * @param  String  selector  A DOM CSS3/XPath selector to the target form to fill
+ * @param  Object  vals      Field values
+ * @param  Boolean submit    Submit the form?
+ */
+Casper.prototype.fill = function fill(selector, vals, submit) {
+    "use strict";
+    submit = submit === true ? submit : false;
+    if (!utils.isObject(vals)) {
+        throw new CasperError("Form values must be provided as an object");
+    }
+    this.emit('fill', selector, vals, submit);
+    var fillResults = this.evaluate(function _evaluate(selector, values) {
+       return window.__utils__.fill(selector, values);
+    }, {
+        selector: selector,
+        values:   vals
+    });
+    if (!fillResults) {
+        throw new CasperError("Unable to fill form");
+    } else if (fillResults.errors.length > 0) {
+        (function _each(self){
+            fillResults.errors.forEach(function _forEach(error) {
+                self.log("form error: " + error, "error");
+            });
+        })(this);
+        if (submit) {
+            this.log("Errors encountered while filling form; submission aborted", "warning");
+            submit = false;
+        }
+    }
+    // File uploads
+    if (fillResults.files && fillResults.files.length > 0) {
+        if (utils.isObject(selector) && selector.type === 'xpath') {
+            this.echo('⚠  Filling file upload fields is currently not supported using', 'COMMENT');
+            this.echo('   XPath selectors; Please use a CSS selector instead.', 'COMMENT');
+        } else {
+            (function _each(self) {
+                fillResults.files.forEach(function _forEach(file) {
+                    var fileFieldSelector = [selector, 'input[name="' + file.name + '"]'].join(' ');
+                    self.page.uploadFile(fileFieldSelector, file.path);
+                });
+            })(this);
+        }
+    }
+    // Form submission?
+    if (submit) {
+        this.evaluate(function _evaluate(selector) {
+            var form = window.__utils__.findOne(selector);
+            var method = (form.getAttribute('method') || "GET").toUpperCase();
+            var action = form.getAttribute('action') || "unknown";
+            window.__utils__.log('submitting form to ' + action + ', HTTP ' + method, 'info');
+            if (typeof form.submit === "function") {
+                form.submit();
+            } else {
+                // http://www.spiration.co.uk/post/1232/Submit-is-not-a-function
+                form.submit.click();
+            }
+        }, { selector: selector });
+    }
+};
+
+/**
+ * Go a step forward in browser's history
+ *
+ * @return Casper
+ */
+Casper.prototype.forward = function forward(then) {
+    "use strict";
+    return this.then(function _step() {
+        this.emit('forward');
+        this.evaluate(function _evaluate() {
+            history.forward();
+        });
+    });
+};
+
+/**
+ * Creates a new Colorizer instance. Sets `Casper.options.type` to change the
+ * colorizer type name (see the `colorizer` module).
+ *
+ * @return Object
+ */
+Casper.prototype.getColorizer = function getColorizer() {
+    "use strict";
+    return colorizer.create(this.options.colorizerType || 'Colorizer');
+};
+
+/**
+ * Retrieves current document url.
+ *
+ * @return String
+ */
+Casper.prototype.getCurrentUrl = function getCurrentUrl() {
+    "use strict";
+    return decodeURIComponent(this.evaluate(function _evaluate() {
+        return document.location.href;
+    }));
+};
+
+/**
+ * Retrieves the value of an attribute on the first element matching the provided
+ * DOM CSS3/XPath selector.
+ *
+ * @param  String  selector   A DOM CSS3/XPath selector
+ * @param  String  attribute  The attribute name to lookup
+ * @return String  The requested DOM element attribute value
+ */
+Casper.prototype.getElementAttribute = Casper.prototype.getElementAttr = function getElementAttr(selector, attribute) {
+    "use strict";
+    return this.evaluate(function _evaluate(selector, attribute) {
+        return document.querySelector(selector).getAttribute(attribute);
+    }, { selector: selector, attribute: attribute });
+};
+
+/**
+ * Retrieves boundaries for a DOM element matching the provided DOM CSS3/XPath selector.
+ *
+ * @param  String  selector  A DOM CSS3/XPath selector
+ * @return Object
+ */
+Casper.prototype.getElementBounds = function getElementBounds(selector) {
+    "use strict";
+    if (!this.exists(selector)) {
+        throw new CasperError("No element matching selector found: " + selector);
+    }
+    var clipRect = this.evaluate(function _evaluate(selector) {
+        return window.__utils__.getElementBounds(selector);
+    }, { selector: selector });
+    if (!utils.isClipRect(clipRect)) {
+        throw new CasperError('Could not fetch boundaries for element matching selector: ' + selector);
+    }
+    return clipRect;
+};
+
+/**
+ * Retrieves global variable.
+ *
+ * @param  String  name  The name of the global variable to retrieve
+ * @return mixed
+ */
+Casper.prototype.getGlobal = function getGlobal(name) {
+    "use strict";
+    var result = this.evaluate(function _evaluate(name) {
+        var result = {};
+        try {
+            result.value = JSON.stringify(window[name]);
+        } catch (e) {
+            var message = f("Unable to JSON encode window.%s: %s", name, e);
+            window.__utils__.log(message, "error");
+            result.error = message;
+        }
+        return result;
+    }, {'name': name});
+    if (typeof result !== "object") {
+        throw new CasperError(f('Could not retrieve global value for "%s"', name));
+    } else if ('error' in result) {
+        throw new CasperError(result.error);
+    } else if (utils.isString(result.value)) {
+        return JSON.parse(result.value);
+    } else {
+        return undefined;
+    }
+};
+
+/**
+ * Retrieves current page title, if any.
+ *
+ * @return String
+ */
+Casper.prototype.getTitle = function getTitle() {
+    "use strict";
+    return this.evaluate(function _evaluate() {
+        return document.title;
+    });
+};
+
+/**
+ * Initializes PhantomJS error handler.
+ *
+ */
+Casper.prototype.initErrorHandler = function initErrorHandler() {
+    "use strict";
+    var casper = this;
+    phantom.onError = function phantom_onError(msg, backtrace) {
+        casper.emit('error', msg, backtrace);
+        if (casper.options.exitOnError === true) {
+            casper.exit(1);
+        }
+    };
+};
+
+/**
+ * Injects Client-side utilities in current page context.
+ *
+ */
+Casper.prototype.injectClientUtils = function injectClientUtils() {
+    "use strict";
+    var clientUtilsInjected = this.page.evaluate(function() {
+        return typeof window.__utils__ === "object";
+    });
+    if (true === clientUtilsInjected) {
+        return;
+    }
+    var clientUtilsPath = require('fs').pathJoin(phantom.casperPath, 'modules', 'clientutils.js');
+    if (true === this.page.injectJs(clientUtilsPath)) {
+        this.log("Successfully injected Casper client-side utilities", "debug");
+    } else {
+        this.warn("Failed to inject Casper client-side utilities");
+    }
+    // ClientUtils and Casper shares the same options
+    // These are not the lines I'm the most proud of in my life, but it works.
+    this.page.evaluate(function() {
+        window.__utils__ = new ClientUtils(__options);
+    }.toString().replace('__options', JSON.stringify(this.options)));
+};
+
+/**
+ * Logs a message.
+ *
+ * @param  String  message  The message to log
+ * @param  String  level    The log message level (from Casper.logLevels property)
+ * @param  String  space    Space from where the logged event occured (default: "phantom")
+ * @return Casper
+ */
+Casper.prototype.log = function log(message, level, space) {
+    "use strict";
+    level = level && this.logLevels.indexOf(level) > -1 ? level : "debug";
+    space = space ? space : "phantom";
+    if (level === "error" && utils.isFunction(this.options.onError)) {
+        this.options.onError.call(this, this, message, space);
+    }
+    if (this.logLevels.indexOf(level) < this.logLevels.indexOf(this.options.logLevel)) {
+        return this; // skip logging
+    }
+    var entry = {
+        level:   level,
+        space:   space,
+        message: message,
+        date:    new Date().toString()
+    };
+    if (level in this.logFormats && utils.isFunction(this.logFormats[level])) {
+        message = this.logFormats[level](message, level, space);
+    } else {
+        var levelStr = this.colorizer.colorize(f('[%s]', level), this.logStyles[level]);
+        message = f('%s [%s] %s', levelStr, space, message);
+    }
+    if (this.options.verbose) {
+        this.echo(this.filter('log.message', message) || message); // direct output
+    }
+    this.result.log.push(entry);
+    this.emit('log', entry);
+    return this;
+};
+
+/**
+ * Emulates an event on the element from the provided selector using the mouse
+ * pointer, if possible.
+ *
+ * In case of success, `true` is returned, `false` otherwise.
+ *
+ * @param  String   type      Type of event to emulate
+ * @param  String   selector  A DOM CSS3 compatible selector
+ * @return Boolean
+ */
+Casper.prototype.mouseEvent = function mouseEvent(type, selector) {
+    "use strict";
+    this.log("Mouse event '" + type + "' on selector: " + selector, "debug");
+    if (!this.exists(selector)) {
+        throw new CasperError(f("Cannot dispatch %s event on nonexistent selector: %s", type, selector));
+    }
+    var eventSuccess = this.evaluate(function(type, selector) {
+        return window.__utils__.mouseEvent(type, selector);
+    }, {
+        type: type,
+        selector: selector
+    });
+    if (!eventSuccess) {
+        // fallback onto native QtWebKit mouse events
+        try {
+            this.mouse.processEvent(type, selector);
+        } catch (e) {
+            this.log(f("Couldn't emulate '%s' event on %s: %s", type, selector, e), "error");
+            return false;
+        }
+    }
+    return true;
+};
+
+/**
+ * Performs an HTTP request, with optional settings.
+ *
+ * Available settings are:
+ *
+ * - String  method:   The HTTP method to use
+ * - Object  data:     The data to use to perform the request, eg. {foo: 'bar'}
+ * - Array   headers:  An array of request headers, eg. [{'Cache-Control': 'max-age=0'}]
+ *
+ * @param  String  location  The url to open
+ * @param  Object  settings  The request settings (optional)
+ * @return Casper
+ */
+Casper.prototype.open = function open(location, settings) {
+    "use strict";
+    // settings validation
+    if (!settings) {
+        settings = {
+            method: "get"
+        };
+    }
+    if (!utils.isObject(settings)) {
+        throw new CasperError("open(): request settings must be an Object");
+    }
+    // http method
+    // taken from https://github.com/ariya/phantomjs/blob/master/src/webpage.cpp#L302
+    var methods = ["get", "head", "put", "post", "delete"];
+    if (settings.method && (!utils.isString(settings.method) || methods.indexOf(settings.method) === -1)) {
+        throw new CasperError("open(): settings.method must be part of " + methods.join(', '));
+    }
+    // http data
+    if (settings.data) {
+        if (utils.isObject(settings.data)) { // query object
+            settings.data = qs.encode(settings.data);
+        } else if (!utils.isString(settings.data)) {
+            throw new CasperError("open(): invalid request settings data value: " + settings.data);
+        }
+    }
+    // current request url
+    this.requestUrl = this.filter('open.location', location) || location;
+    // http auth
+    if (settings.username && settings.password) {
+        this.setHttpAuth(settings.username, settings.password);
+    } else {
+        var httpAuthMatch = location.match(/^https?:\/\/(.+):(.+)@/i);
+        if (httpAuthMatch) {
+            var httpAuth = {
+                username: httpAuthMatch[1],
+                password: httpAuthMatch[2]
+            };
+            this.setHttpAuth(httpAuth.username, httpAuth.password);
+        }
+    }
+    this.emit('open', this.requestUrl, settings);
+    this.log(f('opening url: %s, HTTP %s', this.requestUrl, settings.method.toUpperCase()), "debug");
+    if ('headers' in settings && phantom.version.minor < 6) {
+        this.warn('Custom headers in outgoing requests are supported in PhantomJS >= 1.6');
+    }
+    this.page.openUrl(this.requestUrl, {
+        operation: settings.method,
+        data:      settings.data,
+        headers:   settings.headers
+    }, this.page.settings);
+    this.resources = [];
+    return this;
+};
+
+/**
+ * Reloads current page.
+ *
+ * @param  Function  then  a next step function
+ * @return Casper
+ */
+Casper.prototype.reload = function reload(then) {
+    "use strict";
+    if (!this.started) {
+        throw new CasperError("Casper not started, can't reload()");
+    }
+    this.evaluate(function() {
+        window.location.reload();
+    });
+    if (then && utils.isFunction(then)) {
+        this.then(this.createStep(then));
+    }
+    return this;
+};
+
+/**
+ * Repeats a step a given number of times.
+ *
+ * @param  Number    times  Number of times to repeat step
+ * @aram   function  then   The step closure
+ * @return Casper
+ * @see    Casper#then
+ */
+Casper.prototype.repeat = function repeat(times, then) {
+    "use strict";
+    for (var i = 0; i < times; i++) {
+        this.then(then);
+    }
+    return this;
+};
+
+/**
+ * Checks if a given resource was loaded by the remote page.
+ *
+ * @param  Function/String/RegExp  test  A test function, string or regular expression.
+ *                                       In case a string is passed, url matching will be tested.
+ * @return Boolean
+ */
+Casper.prototype.resourceExists = function resourceExists(test) {
+    "use strict";
+    var testFn;
+    switch (utils.betterTypeOf(test)) {
+        case "string":
+            testFn = function _testResourceExists_String(res) {
+                return res.url.search(test) !== -1;
+            };
+            break;
+        case "regexp":
+            testFn = function _testResourceExists_Regexp(res) {
+                return test.test(res.url);
+            };
+            break;
+        case "function":
+            testFn = test;
+            testFn.name = "_testResourceExists_Function";
+            break;
+        default:
+            throw new CasperError("Invalid type");
+    }
+    return this.resources.some(testFn);
+};
+
+/**
+ * Runs the whole suite of steps.
+ *
+ * @param  function  onComplete  an optional callback
+ * @param  Number    time        an optional amount of milliseconds for interval checking
+ * @return Casper
+ */
+Casper.prototype.run = function run(onComplete, time) {
+    "use strict";
+    if (!this.steps || this.steps.length < 1) {
+        this.log("No steps defined, aborting", "error");
+        return this;
+    }
+    this.log(f("Running suite: %d step%s", this.steps.length, this.steps.length > 1 ? "s" : ""), "info");
+    this.emit('run.start');
+    this.checker = setInterval(this.checkStep, (time ? time: 100), this, onComplete);
+    return this;
+};
+
+/**
+ * Runs a step.
+ *
+ * @param  Function  step
+ */
+Casper.prototype.runStep = function runStep(step) {
+    "use strict";
+    var skipLog = utils.isObject(step.options) && step.options.skipLog === true;
+    var stepInfo = f("Step %d/%d", this.step, this.steps.length);
+    var stepResult;
+    if (!skipLog) {
+        this.log(stepInfo + f(' %s (HTTP %d)', this.getCurrentUrl(), this.currentHTTPStatus), "info");
+    }
+    if (utils.isNumber(this.options.stepTimeout) && this.options.stepTimeout > 0) {
+        var stepTimeoutCheckInterval = setInterval(function _check(self, start, stepNum) {
+            if (new Date().getTime() - start > self.options.stepTimeout) {
+                if (self.step === stepNum) {
+                    self.emit('step.timeout');
+                    if (utils.isFunction(self.options.onStepTimeout)) {
+                        self.options.onStepTimeout.call(self, self);
+                    } else {
+                        self.die("Maximum step execution timeout exceeded for step " + stepNum, "error");
+                    }
+                }
+                clearInterval(stepTimeoutCheckInterval);
+            }
+        }, this.options.stepTimeout, this, new Date().getTime(), this.step);
+    }
+    this.emit('step.start', step);
+    stepResult = step.call(this, this);
+    if (utils.isFunction(this.options.onStepComplete)) {
+        this.options.onStepComplete.call(this, this, stepResult);
+    }
+    if (!skipLog) {
+        this.emit('step.complete', stepResult);
+        this.log(stepInfo + f(": done in %dms.", new Date().getTime() - this.startTime), "info");
+    }
+};
+
+/**
+ * Sets HTTP authentication parameters.
+ *
+ * @param  String   username  The HTTP_AUTH_USER value
+ * @param  String   password  The HTTP_AUTH_PW value
+ * @return Casper
+ */
+Casper.prototype.setHttpAuth = function setHttpAuth(username, password) {
+    "use strict";
+    if (!this.started) {
+        throw new CasperError("Casper must be started in order to use the setHttpAuth() method");
+    }
+    if (!utils.isString(username) || !utils.isString(password)) {
+        throw new CasperError("Both username and password must be strings");
+    }
+    this.page.settings.userName = username;
+    this.page.settings.password = password;
+    this.emit('http.auth', username, password);
+    this.log("Setting HTTP authentication for user " + username, "info");
+    return this;
+};
+
+/**
+ * Configures and starts Casper.
+ *
+ * @param  String   location  An optional location to open on start
+ * @param  function then      Next step function to execute on page loaded (optional)
+ * @return Casper
+ */
+Casper.prototype.start = function start(location, then) {
+    "use strict";
+    this.emit('starting');
+    this.log('Starting...', "info");
+    this.startTime = new Date().getTime();
+    this.history = [];
+    this.steps = [];
+    this.step = 0;
+    // Option checks
+    if (this.logLevels.indexOf(this.options.logLevel) < 0) {
+        this.log(f("Unknown log level '%d', defaulting to 'warning'", this.options.logLevel), "warning");
+        this.options.logLevel = "warning";
+    }
+    // WebPage
+    if (!utils.isWebPage(this.page)) {
+        if (utils.isWebPage(this.options.page)) {
+            this.page = this.options.page;
+        } else {
+            this.page = createPage(this);
+        }
+    }
+    this.page.settings = utils.mergeObjects(this.page.settings, this.options.pageSettings);
+    if (utils.isClipRect(this.options.clipRect)) {
+        this.page.clipRect = this.options.clipRect;
+    }
+    if (utils.isObject(this.options.viewportSize)) {
+        this.page.viewportSize = this.options.viewportSize;
+    }
+    this.started = true;
+    this.emit('started');
+    if (utils.isNumber(this.options.timeout) && this.options.timeout > 0) {
+        this.log(f("Execution timeout set to %dms", this.options.timeout), "info");
+        setTimeout(function _check(self) {
+            self.emit('timeout');
+            if (utils.isFunction(self.options.onTimeout)) {
+                self.options.onTimeout.call(self, self);
+            } else {
+                self.die(f("Timeout of %dms exceeded, exiting.", self.options.timeout));
+            }
+        }, this.options.timeout, this);
+    }
+    if (utils.isString(location) && location.length > 0) {
+        return this.thenOpen(location, utils.isFunction(then) ? then : this.createStep(function _step() {
+            this.log("start page is loaded", "debug");
+        }));
+    }
+    return this;
+};
+
+/**
+ * Schedules the next step in the navigation process.
+ *
+ * @param  function  step  A function to be called as a step
+ * @return Casper
+ */
+Casper.prototype.then = function then(step) {
+    "use strict";
+    if (!this.started) {
+        throw new CasperError("Casper not started; please use Casper#start");
+    }
+    if (!utils.isFunction(step)) {
+        throw new CasperError("You can only define a step as a function");
+    }
+    // check if casper is running
+    if (this.checker === null) {
+        // append step to the end of the queue
+        step.level = 0;
+        this.steps.push(step);
+    } else {
+        // insert substep a level deeper
+        try {
+            step.level = this.steps[this.step - 1].level + 1;
+        } catch (e) {
+            step.level = 0;
+        }
+        var insertIndex = this.step;
+        while (this.steps[insertIndex] && step.level === this.steps[insertIndex].level) {
+            insertIndex++;
+        }
+        this.steps.splice(insertIndex, 0, step);
+    }
+    this.emit('step.added', step);
+    return this;
+};
+
+/**
+ * Adds a new navigation step for clicking on a provided link selector
+ * and execute an optional next step.
+ *
+ * @param  String   selector        A DOM CSS3 compatible selector
+ * @param  Function then            Next step function to execute on page loaded (optional)
+ * @return Casper
+ * @see    Casper#click
+ * @see    Casper#then
+ */
+Casper.prototype.thenClick = function thenClick(selector, then, fallbackToHref) {
+    "use strict";
+    if (arguments.length > 2) {
+        this.emit("deprecated", "The thenClick() method does not process the fallbackToHref argument since 0.6");
+    }
+    this.then(function _step() {
+        this.click(selector);
+    });
+    return utils.isFunction(then) ? this.then(then) : this;
+};
+
+/**
+ * Adds a new navigation step to perform code evaluation within the
+ * current retrieved page DOM.
+ *
+ * @param  function  fn       The function to be evaluated within current page DOM
+ * @param  object    context  Optional function parameters context
+ * @return Casper
+ * @see    Casper#evaluate
+ */
+Casper.prototype.thenEvaluate = function thenEvaluate(fn, context) {
+    "use strict";
+    return this.then(function _step() {
+        this.evaluate(fn, context);
+    });
+};
+
+/**
+ * Adds a new navigation step for opening the provided location.
+ *
+ * @param  String   location  The URL to load
+ * @param  function then      Next step function to execute on page loaded (optional)
+ * @return Casper
+ * @see    Casper#open
+ */
+Casper.prototype.thenOpen = function thenOpen(location, then) {
+    "use strict";
+    this.then(this.createStep(function _step() {
+        this.open(location);
+    }, {
+        skipLog: true
+    }));
+    return utils.isFunction(then) ? this.then(then) : this;
+};
+
+/**
+ * Adds a new navigation step for opening and evaluate an expression
+ * against the DOM retrieved from the provided location.
+ *
+ * @param  String    location  The url to open
+ * @param  function  fn        The function to be evaluated within current page DOM
+ * @param  object    context   Optional function parameters context
+ * @return Casper
+ * @see    Casper#evaluate
+ * @see    Casper#open
+ */
+Casper.prototype.thenOpenAndEvaluate = function thenOpenAndEvaluate(location, fn, context) {
+    "use strict";
+    return this.thenOpen(location).thenEvaluate(fn, context);
+};
+
+/**
+ * Sets the user-agent string currently used when requesting urls.
+ *
+ * @param  String  userAgent  User agent string
+ * @return String
+ */
+Casper.prototype.userAgent = function userAgent(agent) {
+    "use strict";
+    if (!this.started) {
+        throw new CasperError("Casper not started, can't set userAgent");
+    }
+    this.options.pageSettings.userAgent = this.page.settings.userAgent = agent;
+    return this;
+};
+
+/**
+ * Changes the current viewport size.
+ *
+ * @param  Number  width   The viewport width, in pixels
+ * @param  Number  height  The viewport height, in pixels
+ * @return Casper
+ */
+Casper.prototype.viewport = function viewport(width, height) {
+    "use strict";
+    if (!this.started) {
+        throw new CasperError("Casper must be started in order to set viewport at runtime");
+    }
+    if (!utils.isNumber(width) || !utils.isNumber(height) || width <= 0 || height <= 0) {
+        throw new CasperError(f("Invalid viewport: %dx%d", width, height));
+    }
+    this.page.viewportSize = {
+        width: width,
+        height: height
+    };
+    this.emit('viewport.changed', [width, height]);
+    return this;
+};
+
+/**
+ * Checks if an element matching the provided DOM CSS3/XPath selector is visible
+ * current page DOM by checking that offsetWidth and offsetHeight are
+ * both non-zero.
+ *
+ * @param  String  selector  A DOM CSS3/XPath selector
+ * @return Boolean
+ */
+Casper.prototype.visible = function visible(selector) {
+    "use strict";
+    return this.evaluate(function _evaluate(selector) {
+        return window.__utils__.visible(selector);
+    }, { selector: selector });
+};
+
+/**
+ * Displays a warning message onto the console and logs the event.
+ *
+ * @param  String  message
+ * @return Casper
+ */
+Casper.prototype.warn = function warn(message) {
+    "use strict";
+    this.log(message, "warning", "phantom");
+    var formatted = f.apply(null, ["⚠  " + message].concat([].slice.call(arguments, 1)));
+    return this.echo(formatted, 'COMMENT');
+};
+
+/**
+ * Adds a new step that will wait for a given amount of time (expressed
+ * in milliseconds) before processing an optional next one.
+ *
+ * @param  Number    timeout  The max amount of time to wait, in milliseconds
+ * @param  Function  then     Next step to process (optional)
+ * @return Casper
+ */
+Casper.prototype.wait = function wait(timeout, then) {
+    "use strict";
+    timeout = ~~timeout;
+    if (timeout < 1) {
+        this.die("wait() only accepts a positive integer > 0 as a timeout value");
+    }
+    if (then && !utils.isFunction(then)) {
+        this.die("wait() a step definition must be a function");
+    }
+    return this.then(function _step() {
+        this.waitStart();
+        setTimeout(function _check(self) {
+          self.log(f("wait() finished waiting for %dms.", timeout), "info");
+          if (then) {
+            then.call(self, self);
+          }
+          self.waitDone();
+        }, timeout, this);
+    });
+};
+
+Casper.prototype.waitStart = function waitStart() {
+    "use strict";
+    this.emit('wait.start');
+    this.pendingWait = true;
+};
+
+Casper.prototype.waitDone = function waitDone() {
+    "use strict";
+    this.emit('wait.done');
+    this.pendingWait = false;
+};
+
+/**
+ * Waits until a function returns true to process a next step.
+ *
+ * @param  Function  testFx     A function to be evaluated for returning condition satisfecit
+ * @param  Function  then       The next step to perform (optional)
+ * @param  Function  onTimeout  A callback function to call on timeout (optional)
+ * @param  Number    timeout    The max amount of time to wait, in milliseconds (optional)
+ * @return Casper
+ */
+Casper.prototype.waitFor = function waitFor(testFx, then, onTimeout, timeout) {
+    "use strict";
+    timeout = timeout ? timeout : this.defaultWaitTimeout;
+    if (!utils.isFunction(testFx)) {
+        this.die("waitFor() needs a test function");
+    }
+    if (then && !utils.isFunction(then)) {
+        this.die("waitFor() next step definition must be a function");
+    }
+    return this.then(function _step() {
+        this.waitStart();
+        var start = new Date().getTime();
+        var condition = false;
+        var interval = setInterval(function _check(self, testFx, timeout, onTimeout) {
+            if ((new Date().getTime() - start < timeout) && !condition) {
+                condition = testFx.call(self, self);
+            } else {
+                self.waitDone();
+                if (!condition) {
+                    self.log("Casper.waitFor() timeout", "warning");
+                    self.emit('waitFor.timeout');
+                    if (utils.isFunction(onTimeout)) {
+                        onTimeout.call(self, self);
+                    } else {
+                        self.die(f("Timeout of %dms expired, exiting.", timeout), "error");
+                    }
+                } else {
+                    self.log(f("waitFor() finished in %dms.", new Date().getTime() - start), "info");
+                    if (then) {
+                        self.then(then);
+                    }
+                }
+                clearInterval(interval);
+            }
+        }, 100, this, testFx, timeout, onTimeout);
+    });
+};
+
+/**
+ * Waits until a given resource is loaded
+ *
+ * @param  String/Function  test       A function to test if the resource exists.
+ *                                     A string will be matched against the resources url.
+ * @param  Function         then       The next step to perform (optional)
+ * @param  Function         onTimeout  A callback function to call on timeout (optional)
+ * @param  Number           timeout    The max amount of time to wait, in milliseconds (optional)
+ * @return Casper
+ */
+Casper.prototype.waitForResource = function waitForResource(test, then, onTimeout, timeout) {
+    "use strict";
+    timeout = timeout ? timeout : this.defaultWaitTimeout;
+    return this.waitFor(function _check() {
+        return this.resourceExists(test);
+    }, then, onTimeout, timeout);
+};
+
+/**
+ * Waits until an element matching the provided DOM CSS3/XPath selector exists in
+ * remote DOM to process a next step.
+ *
+ * @param  String    selector   A DOM CSS3/XPath selector
+ * @param  Function  then       The next step to perform (optional)
+ * @param  Function  onTimeout  A callback function to call on timeout (optional)
+ * @param  Number    timeout    The max amount of time to wait, in milliseconds (optional)
+ * @return Casper
+ */
+Casper.prototype.waitForSelector = function waitForSelector(selector, then, onTimeout, timeout) {
+    "use strict";
+    timeout = timeout ? timeout : this.defaultWaitTimeout;
+    return this.waitFor(function _check() {
+        return this.exists(selector);
+    }, then, onTimeout, timeout);
+};
+
+/**
+ * Waits until an element matching the provided DOM CSS3/XPath selector does not
+ * exist in the remote DOM to process a next step.
+ *
+ * @param  String    selector   A DOM CSS3/XPath selector
+ * @param  Function  then       The next step to perform (optional)
+ * @param  Function  onTimeout  A callback function to call on timeout (optional)
+ * @param  Number    timeout    The max amount of time to wait, in milliseconds (optional)
+ * @return Casper
+ */
+Casper.prototype.waitWhileSelector = function waitWhileSelector(selector, then, onTimeout, timeout) {
+    "use strict";
+    timeout = timeout ? timeout : this.defaultWaitTimeout;
+    return this.waitFor(function _check() {
+        return !this.exists(selector);
+    }, then, onTimeout, timeout);
+};
+
+/**
+ * Waits until an element matching the provided DOM CSS3/XPath selector is
+ * visible in the remote DOM to process a next step.
+ *
+ * @param  String    selector   A DOM CSS3/XPath selector
+ * @param  Function  then       The next step to perform (optional)
+ * @param  Function  onTimeout  A callback function to call on timeout (optional)
+ * @param  Number    timeout    The max amount of time to wait, in milliseconds (optional)
+ * @return Casper
+ */
+Casper.prototype.waitUntilVisible = function waitUntilVisible(selector, then, onTimeout, timeout) {
+    "use strict";
+    timeout = timeout ? timeout : this.defaultWaitTimeout;
+    return this.waitFor(function _check() {
+        return this.visible(selector);
+    }, then, onTimeout, timeout);
+};
+
+/**
+ * Waits until an element matching the provided DOM CSS3/XPath selector is no
+ * longer visible in remote DOM to process a next step.
+ *
+ * @param  String    selector   A DOM CSS3/XPath selector
+ * @param  Function  then       The next step to perform (optional)
+ * @param  Function  onTimeout  A callback function to call on timeout (optional)
+ * @param  Number    timeout    The max amount of time to wait, in milliseconds (optional)
+ * @return Casper
+ */
+Casper.prototype.waitWhileVisible = function waitWhileVisible(selector, then, onTimeout, timeout) {
+    "use strict";
+    timeout = timeout ? timeout : this.defaultWaitTimeout;
+    return this.waitFor(function _check() {
+        return !this.visible(selector);
+    }, then, onTimeout, timeout);
+};
+
+/**
+ * Changes the current page zoom factor.
+ *
+ * @param  Number  factor  The zoom factor
+ * @return Casper
+ */
+Casper.prototype.zoom = function zoom(factor) {
+    "use strict";
+    if (!this.started) {
+        throw new CasperError("Casper has not been started, can't set zoom factor");
+    }
+    if (!utils.isNumber(factor) || factor <= 0) {
+        throw new CasperError("Invalid zoom factor: " + factor);
+    }
+    if ('zoomFactor' in this.page) {
+        this.page.zoomFactor = factor;
+    } else {
+        this.warn("zoom() requires PhantomJS >= 1.6");
+    }
+    return this;
+};
+
+/**
+ * Extends Casper's prototype with provided one.
+ *
+ * @param  Object  proto  Prototype methods to add to Casper
+ * @deprecated
+ * @since 0.6
+ */
+Casper.extend = function(proto) {
+    "use strict";
+    this.warn('Casper.extend() has been deprecated since 0.6; check the docs');
+    if (!utils.isObject(proto)) {
+        throw new CasperError("extends() only accept objects as prototypes");
+    }
+    utils.mergeObjects(Casper.prototype, proto);
+};
+
+exports.Casper = Casper;
+
+/**
+ * Creates a new WebPage instance for Casper use.
+ *
+ * @param  Casper  casper  A Casper instance
+ * @return WebPage
+ */
+function createPage(casper) {
+    "use strict";
+    var page = require('webpage').create();
+    page.onAlert = function onAlert(message) {
+        casper.log('[alert] ' + message, "info", "remote");
+        casper.emit('remote.alert', message);
+        if (utils.isFunction(casper.options.onAlert)) {
+            casper.options.onAlert.call(casper, casper, message);
+        }
+    };
+    page.onConfirm = function onConfirm(message) {
+        return casper.filter('page.confirm', message) || true;
+    };
+    page.onConsoleMessage = function onConsoleMessage(msg) {
+        var level = "info", test = /^\[casper:(\w+)\]\s?(.*)/.exec(msg);
+        if (test && test.length === 3) {
+            level = test[1];
+            msg = test[2];
+        }
+        casper.log(msg, level, "remote");
+        casper.emit('remote.message', msg);
+    };
+    page.onError = function onError(msg, trace) {
+        casper.emit('page.error', msg, trace);
+    };
+    page.onInitialized = function onInitialized() {
+        casper.emit('page.initialized', this);
+        if (utils.isFunction(casper.options.onPageInitialized)) {
+            this.log("Post-configuring WebPage instance", "debug");
+            casper.options.onPageInitialized.call(casper, page);
+        }
+    };
+    page.onLoadStarted = function onLoadStarted() {
+        casper.loadInProgress = true;
+        casper.emit('load.started');
+    };
+    page.onLoadFinished = function onLoadFinished(status) {
+        if (status !== "success") {
+            casper.emit('load.failed', {
+                status:      status,
+                http_status: casper.currentHTTPStatus,
+                url:         casper.requestUrl
+            });
+            var message = 'Loading resource failed with status=' + status;
+            if (casper.currentHTTPStatus) {
+                message += f(' (HTTP %d)', casper.currentHTTPStatus);
+            }
+            message += ': ' + casper.requestUrl;
+            casper.log(message, "warning");
+            if (utils.isFunction(casper.options.onLoadError)) {
+                casper.options.onLoadError.call(casper, casper, casper.requestUrl, status);
+            }
+        }
+        if (casper.options.clientScripts) {
+            if (utils.isString(casper.options.clientScripts)) {
+                casper.options.clientScripts = [casper.options.clientScripts];
+            }
+            if (!utils.isArray(casper.options.clientScripts)) {
+                throw new CasperError("The clientScripts option must be an array");
+            }
+            casper.options.clientScripts.forEach(function _forEach(script) {
+                if (casper.page.injectJs(script)) {
+                    casper.log(f('Automatically injected %s client side', script), "debug");
+                } else {
+                    casper.warn('Failed injecting %s client side', script);
+                }
+            });
+        }
+        // Client-side utils injection
+        casper.injectClientUtils();
+        // history
+        casper.history.push(casper.getCurrentUrl());
+        casper.emit('load.finished', status);
+        casper.loadInProgress = false;
+    };
+    page.onNavigationRequested = function onNavigationRequested(url, navigationType, navigationLocked, isMainFrame) {
+        casper.log(f('Navigation requested: url=%s, type=%s, lock=%s, isMainFrame=%s',
+                     url, navigationType, navigationLocked, isMainFrame), "debug");
+        casper.emit('navigation.requested', url, navigationType, navigationLocked, isMainFrame);
+    };
+    page.onPrompt = function onPrompt(message, value) {
+        return casper.filter('page.prompt', message, value);
+    };
+    page.onResourceReceived = function onResourceReceived(resource) {
+        casper.emit('resource.received', resource);
+        if (utils.isFunction(casper.options.onResourceReceived)) {
+            casper.options.onResourceReceived.call(casper, casper, resource);
+        }
+        if (resource.stage === "end") {
+            casper.resources.push(resource);
+        }
+        if (resource.url === casper.requestUrl && resource.stage === "end") {
+            casper.currentHTTPStatus = resource.status;
+            casper.emit('http.status.' + resource.status, resource);
+            if (utils.isObject(casper.options.httpStatusHandlers) &&
+                resource.status in casper.options.httpStatusHandlers &&
+                utils.isFunction(casper.options.httpStatusHandlers[resource.status])) {
+                casper.options.httpStatusHandlers[resource.status].call(casper, casper, resource);
+            }
+            casper.currentUrl = resource.url;
+            casper.emit('location.changed', resource.url);
+        }
+    };
+    page.onResourceRequested = function onResourceRequested(request) {
+        casper.emit('resource.requested', request);
+        if (utils.isFunction(casper.options.onResourceRequested)) {
+            casper.options.onResourceRequested.call(casper, casper, request);
+        }
+    };
+    page.onUrlChanged = function onUrlChanged(url) {
+        casper.log(f('url changed to "%s"', url), "debug");
+        casper.emit('url.changed', url);
+    };
+    casper.emit('page.created', page);
+    return page;
+}