casperjs 1.0.0.RC1 → 1.0.0

data/casperjs.gemspec

@@ -1,8 +1,10 @@
+# by hannyu
 
+CASPERJS_VERSION = File.read("package.json")[/version.*:.*"(.*?)"/,1].gsub(/[\-_\+]/,".")
 
 Gem::Specification.new do |s|
   s.name                = "casperjs"
-  s.version             = "1.0.0.RC1"
+  s.version             = CASPERJS_VERSION
   s.homepage            = "http://casperjs.org/"
   s.authors             = ["Nicolas Perriault", ]
   s.email               = ["nperriault@gmail.com",]
@@ -10,12 +12,13 @@ Gem::Specification.new do |s|
 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.has_rdoc            = false
   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", 
+  s.files               = Dir["*.md", "package.json", "casperjs.gemspec",
+                            "bin/*", "batchbin/*", "rpm/*",
                             "docs/**/*", "modules/**/*", "samples/**/*", "tests/**/*"]
   s.bindir              = "rubybin"
   s.executables         = [ "casperjs" ]
   s.license             = "MIT"
-  s.requirements        = [ "PhantomJS v1.5" ]
+  s.requirements        = [ "PhantomJS v1.7" ]
 end

data/modules/casper.js

@@ -28,12 +28,14 @@
  *
  */
 
-/*global CasperError console exports phantom require*/
+/*global CasperError console exports phantom require __utils__*/
 
 var colorizer = require('colorizer');
 var events = require('events');
 var fs = require('fs');
+var http = require('http');
 var mouse = require('mouse');
+var pagestack = require('pagestack');
 var qs = require('querystring');
 var tester = require('tester');
 var utils = require('utils');
@@ -74,6 +76,7 @@ exports.selectXPath = selectXPath;
  */
 var Casper = function Casper(options) {
     "use strict";
+    /*jshint maxstatements:40*/
     // init & checks
     if (!(this instanceof Casper)) {
         return new Casper(options);
@@ -94,16 +97,25 @@ var Casper = function Casper(options) {
         onResourceReceived:  null,
         onResourceRequested: null,
         onStepComplete:      null,
-        onStepTimeout:       null,
-        onTimeout:           null,
+        onStepTimeout:       function _onStepTimeout(timeout, stepNum) {
+            this.die("Maximum step execution timeout exceeded for step " + stepNum);
+        },
+        onTimeout:           function _onTimeout(timeout) {
+            this.die(f("Script timeout of %dms reached, exiting.", timeout));
+        },
+        onWaitTimeout:       function _onWaitTimeout(timeout) {
+            this.die(f("Wait timeout of %dms expired, exiting.", timeout));
+        },
         page:                null,
         pageSettings:        {
             localToRemoteUrlAccessEnabled: true,
             userAgent:                     defaultUserAgent
         },
+        remoteScripts:       [],
         stepTimeout:         null,
         timeout:             null,
-        verbose:             false
+        verbose:             false,
+        waitTimeout:         5000
     };
     // options
     this.options = utils.mergeObjects(this.defaults, options);
@@ -111,11 +123,12 @@ var Casper = function Casper(options) {
     this.checker = null;
     this.cli = phantom.casperArgs;
     this.colorizer = this.getColorizer();
+    this.currentResponse = undefined;
     this.currentUrl = 'about:blank';
-    this.currentHTTPStatus = 0;
-    this.defaultWaitTimeout = 5000;
+    this.currentHTTPStatus = null;
     this.history = [];
     this.loadInProgress = false;
+    this.navigationRequested = false;
     this.logFormats = {};
     this.logLevels = ["debug", "info", "warning", "error"];
     this.logStyles = {
@@ -127,6 +140,7 @@ var Casper = function Casper(options) {
     this.mouse = mouse.create(this);
     this.page = null;
     this.pendingWait = false;
+    this.popups = pagestack.create();
     this.requestUrl = 'about:blank';
     this.resources = [];
     this.result = {
@@ -143,12 +157,14 @@ var Casper = function Casper(options) {
     this.initErrorHandler();
 
     this.on('error', function(msg, backtrace) {
+        if (msg === this.test.SKIP_MESSAGE) {
+            return;
+        }
         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));
@@ -183,6 +199,7 @@ utils.inherits(Casper, events.EventEmitter);
  */
 Casper.prototype.back = function back() {
     "use strict";
+    this.checkStarted();
     return this.then(function _step() {
         this.emit('back');
         this.evaluate(function _evaluate() {
@@ -192,7 +209,7 @@ Casper.prototype.back = function back() {
 };
 
 /**
- * Encodes a resource using the base64 algorithm synchroneously using
+ * Encodes a resource using the base64 algorithm synchronously using
  * client-side XMLHttpRequest.
  *
  * NOTE: we cannot use window.btoa() for some strange reasons here.
@@ -205,8 +222,8 @@ Casper.prototype.back = function back() {
 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 });
+        return __utils__.getBase64(url, method, data);
+    }, url, method, data);
 };
 
 /**
@@ -221,9 +238,8 @@ Casper.prototype.base64encode = function base64encode(url, method, data) {
  */
 Casper.prototype.capture = function capture(targetFile, clipRect) {
     "use strict";
-    if (!this.started) {
-        throw new CasperError("Casper not started, can't capture()");
-    }
+    /*jshint maxstatements:20*/
+    this.checkStarted();
     var previousClipRect;
     targetFile = fs.absolute(targetFile);
     if (clipRect) {
@@ -261,16 +277,9 @@ Casper.prototype.capture = function capture(targetFile, clipRect) {
  */
 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'];
+    /*jshint maxstatements:20*/
+    this.checkStarted();
+    var base64, previousClipRect, formats = ['bmp', 'jpg', 'jpeg', 'png', 'ppm', 'tiff', 'xbm', 'xpm'];
     if (formats.indexOf(format.toLowerCase()) === -1) {
         throw new CasperError(f('Unsupported format "%s"', format));
     }
@@ -315,7 +324,7 @@ Casper.prototype.captureSelector = function captureSelector(targetFile, selector
  */
 Casper.prototype.checkStep = function checkStep(self, onComplete) {
     "use strict";
-    if (self.pendingWait || self.loadInProgress) {
+    if (self.pendingWait || self.loadInProgress || self.navigationRequested) {
         return;
     }
     var step = self.steps[self.step++];
@@ -325,6 +334,7 @@ Casper.prototype.checkStep = function checkStep(self, onComplete) {
         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.step -= 1;
         self.emit('run.complete');
         if (utils.isFunction(onComplete)) {
             onComplete.call(self, self);
@@ -335,6 +345,20 @@ Casper.prototype.checkStep = function checkStep(self, onComplete) {
     }
 };
 
+/**
+ * Checks if this instance is started.
+ *
+ * @return Boolean
+ * @throws CasperError
+ */
+Casper.prototype.checkStarted = function checkStarted() {
+    "use strict";
+    if (!this.started) {
+        throw new CasperError(f("Casper is not started, can't execute `%s()`",
+                                checkStarted.caller.name));
+    }
+};
+
 /**
  * Clears the current page execution environment context. Useful to avoid
  * having previously loaded DOM contents being still active (refs #34).
@@ -346,6 +370,7 @@ Casper.prototype.checkStep = function checkStep(self, onComplete) {
  */
 Casper.prototype.clear = function clear() {
     "use strict";
+    this.checkStarted();
     this.page.content = '';
     return this;
 };
@@ -361,7 +386,12 @@ Casper.prototype.clear = function clear() {
  */
 Casper.prototype.click = function click(selector) {
     "use strict";
-    return this.mouseEvent('click', selector);
+    this.checkStarted();
+    var success = this.mouseEvent('click', selector);
+    this.evaluate(function(selector) {
+        document.querySelector(selector).focus();
+    }, selector);
+    return success;
 };
 
 /**
@@ -374,12 +404,39 @@ Casper.prototype.click = function click(selector) {
  */
 Casper.prototype.clickLabel = function clickLabel(label, tag) {
     "use strict";
+    this.checkStarted();
     tag = tag || "*";
     var escapedLabel = label.toString().replace(/"/g, '\\"');
     var selector = selectXPath(f('//%s[text()="%s"]', tag, escapedLabel));
     return this.click(selector);
 };
 
+/**
+ * Configures HTTP authentication parameters. Will try parsing auth credentials from
+ * the passed location first, then check for configured settings if any.
+ *
+ * @param  String  location  Requested url
+ * @param  Object  settings  Request settings
+ * @return Casper
+ */
+Casper.prototype.configureHttpAuth = function configureHttpAuth(location, settings) {
+    "use strict";
+    var username, password, httpAuthMatch = location.match(/^https?:\/\/(.+):(.+)@/i);
+    this.checkStarted();
+    if (httpAuthMatch) {
+        this.page.settings.userName = httpAuthMatch[1];
+        this.page.settings.password = httpAuthMatch[2];
+    } else if (utils.isObject(settings) && settings.username) {
+        this.page.settings.userName = settings.username;
+        this.page.settings.password = settings.password;
+    } else {
+        return;
+    }
+    this.emit('http.auth', username, password);
+    this.log("Setting HTTP authentication for user " + username, "info");
+    return this;
+};
+
 /**
  * Creates a step definition.
  *
@@ -400,12 +457,14 @@ Casper.prototype.createStep = function createStep(fn, options) {
 /**
  * Logs the HTML code of the current page.
  *
+ * @param  String   selector  A DOM CSS3/XPath selector (optional)
+ * @param  Boolean  outer     Whether to fetch outer HTML contents (default: false)
  * @return Casper
  */
-Casper.prototype.debugHTML = function debugHTML() {
+Casper.prototype.debugHTML = function debugHTML(selector, outer) {
     "use strict";
-    this.echo(this.page.content);
-    return this;
+    this.checkStarted();
+    return this.echo(this.getHTML(selector, outer));
 };
 
 /**
@@ -415,6 +474,7 @@ Casper.prototype.debugHTML = function debugHTML() {
  */
 Casper.prototype.debugPage = function debugPage() {
     "use strict";
+    this.checkStarted();
     this.echo(this.evaluate(function _evaluate() {
         return document.body.textContent || document.body.innerText;
     }));
@@ -436,6 +496,7 @@ Casper.prototype.die = function die(message, status) {
         message = "Suite explicitely interrupted without any message given.";
     }
     this.log(message, "error");
+    this.echo(message, "ERROR");
     this.emit('die', message, status);
     if (utils.isFunction(this.options.onDie)) {
         this.options.onDie.call(this, this, message, status);
@@ -454,7 +515,8 @@ Casper.prototype.die = function die(message, status) {
  */
 Casper.prototype.download = function download(url, targetPath, method, data) {
     "use strict";
-    var cu = require('clientutils').create(this.options);
+    this.checkStarted();
+    var cu = require('clientutils').create(utils.mergeObjects({}, this.options));
     try {
         fs.write(targetPath, cu.decode(this.base64encode(url, method, data)), 'wb');
         this.emit('downloaded.file', targetPath);
@@ -503,7 +565,7 @@ Casper.prototype.echo = function echo(text, style, pad) {
         } catch (e) {
             try {
                 text = utils.serialize(text);
-            } catch (e) {
+            } catch (e2) {
                 text = '';
             }
         }
@@ -522,14 +584,7 @@ Casper.prototype.echo = function echo(text, style, pad) {
  *         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.
+ *     }, 'Bazoonga', 'baz00nga');
  *
  * @param  Function  fn       The function to be evaluated within current page DOM
  * @param  Object    context  Object containing the parameters to inject into the function
@@ -538,12 +593,28 @@ Casper.prototype.echo = function echo(text, style, pad) {
  */
 Casper.prototype.evaluate = function evaluate(fn, context) {
     "use strict";
+    this.checkStarted();
+    // preliminary checks
+    if (!utils.isFunction(fn) && !utils.isString(fn)) { // phantomjs allows functions defs as string
+        throw new CasperError("evaluate() only accepts functions or strings");
+    }
     // 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);
+    // function context
+    if (arguments.length === 1) {
+        return this.page.evaluate(fn);
+    } else if (arguments.length === 2) {
+        // check for closure signature if it matches context
+        if (utils.isObject(context) && eval(fn).length === Object.keys(context).length) {
+            context = utils.objectValues(context);
+        } else {
+            context = [context];
+        }
+    } else {
+        // phantomjs-style signature
+        context = [].slice.call(arguments).slice(1);
+    }
+    return this.page.evaluate.apply(this.page, [fn].concat(context));
 };
 
 /**
@@ -552,12 +623,15 @@ Casper.prototype.evaluate = function evaluate(fn, context) {
  *
  * @param  function  fn       The expression to evaluate
  * @param  String    message  The error message to log
+ * @param  Number  status   An optional exit status code (must be > 0)
+ *
  * @return Casper
  */
-Casper.prototype.evaluateOrDie = function evaluateOrDie(fn, message) {
+Casper.prototype.evaluateOrDie = function evaluateOrDie(fn, message, status) {
     "use strict";
+    this.checkStarted();
     if (!this.evaluate(fn)) {
-        return this.die(message);
+        return this.die(message, status);
     }
     return this;
 };
@@ -571,9 +645,10 @@ Casper.prototype.evaluateOrDie = function evaluateOrDie(fn, message) {
  */
 Casper.prototype.exists = function exists(selector) {
     "use strict";
+    this.checkStarted();
     return this.evaluate(function _evaluate(selector) {
-        return window.__utils__.exists(selector);
-    }, { selector: selector });
+        return __utils__.exists(selector);
+    }, selector);
 };
 
 /**
@@ -586,11 +661,10 @@ 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
+ * Fetches plain text contents contained in the DOM element(s) matching a given CSS3/XPath
  * selector.
  *
  * @param  String  selector  A DOM CSS3/XPath selector
@@ -598,9 +672,10 @@ Casper.prototype.exit = function exit(status) {
  */
 Casper.prototype.fetchText = function fetchText(selector) {
     "use strict";
+    this.checkStarted();
     return this.evaluate(function _evaluate(selector) {
-        return window.__utils__.fetchText(selector);
-    }, { selector: selector });
+        return __utils__.fetchText(selector);
+    }, selector);
 };
 
 /**
@@ -612,35 +687,26 @@ Casper.prototype.fetchText = function fetchText(selector) {
  */
 Casper.prototype.fill = function fill(selector, vals, submit) {
     "use strict";
+    this.checkStarted();
     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
-    });
+       return __utils__.fill(selector, values);
+    }, selector, 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;
-        }
+        throw new CasperError(f('Errors encountered while filling form: %s',
+                              fillResults.errors.join('; ')));
     }
     // 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');
+            this.warn('Filling file upload fields is currently not supported using ' +
+                      'XPath selectors; Please use a CSS selector instead.');
         } else {
             (function _each(self) {
                 fillResults.files.forEach(function _forEach(file) {
@@ -653,17 +719,17 @@ Casper.prototype.fill = function fill(selector, vals, submit) {
     // Form submission?
     if (submit) {
         this.evaluate(function _evaluate(selector) {
-            var form = window.__utils__.findOne(selector);
+            var form = __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');
+            __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 });
+        }, selector);
     }
 };
 
@@ -674,6 +740,7 @@ Casper.prototype.fill = function fill(selector, vals, submit) {
  */
 Casper.prototype.forward = function forward(then) {
     "use strict";
+    this.checkStarted();
     return this.then(function _step() {
         this.emit('forward');
         this.evaluate(function _evaluate() {
@@ -693,6 +760,29 @@ Casper.prototype.getColorizer = function getColorizer() {
     return colorizer.create(this.options.colorizerType || 'Colorizer');
 };
 
+/**
+ * Retrieves current page contents, dealing with exotic other content types than HTML.
+ *
+ * @return String
+ */
+Casper.prototype.getPageContent = function getPageContent() {
+    "use strict";
+    this.checkStarted();
+    var contentType = utils.getPropertyPath(this, 'currentResponse.contentType');
+    if (!utils.isString(contentType)) {
+        return this.page.frameContent;
+    }
+    // for some reason webkit/qtwebkit will always enclose body contents within html tags
+    var sanitizedHtml = this.evaluate(function checkHtml() {
+        if (__utils__.findOne('head').childNodes.length === 0 &&
+            __utils__.findOne('body').childNodes.length === 1 &&
+            __utils__.findOne('body pre[style]')) {
+            return __utils__.findOne('body pre').textContent.trim();
+        }
+    });
+    return sanitizedHtml ? sanitizedHtml : this.page.frameContent;
+};
+
 /**
  * Retrieves current document url.
  *
@@ -700,9 +790,16 @@ Casper.prototype.getColorizer = function getColorizer() {
  */
 Casper.prototype.getCurrentUrl = function getCurrentUrl() {
     "use strict";
-    return decodeURIComponent(this.evaluate(function _evaluate() {
+    this.checkStarted();
+    var url = this.evaluate(function _evaluate() {
         return document.location.href;
-    }));
+    });
+    try {
+        return decodeURIComponent(url);
+    } catch (e) {
+        /*global unescape*/
+        return unescape(url);
+    }
 };
 
 /**
@@ -713,11 +810,13 @@ Casper.prototype.getCurrentUrl = function getCurrentUrl() {
  * @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) {
+Casper.prototype.getElementAttribute =
+Casper.prototype.getElementAttr = function getElementAttr(selector, attribute) {
     "use strict";
+    this.checkStarted();
     return this.evaluate(function _evaluate(selector, attribute) {
         return document.querySelector(selector).getAttribute(attribute);
-    }, { selector: selector, attribute: attribute });
+    }, selector, attribute);
 };
 
 /**
@@ -728,18 +827,70 @@ Casper.prototype.getElementAttribute = Casper.prototype.getElementAttr = functio
  */
 Casper.prototype.getElementBounds = function getElementBounds(selector) {
     "use strict";
+    this.checkStarted();
     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 });
+        return __utils__.getElementBounds(selector);
+    }, selector);
     if (!utils.isClipRect(clipRect)) {
         throw new CasperError('Could not fetch boundaries for element matching selector: ' + selector);
     }
     return clipRect;
 };
 
+/**
+ * Retrieves information about the node matching the provided selector.
+ *
+ * @param  String|Objects  selector  CSS3/XPath selector
+ * @return Object
+ */
+Casper.prototype.getElementInfo = function getElementInfo(selector) {
+    "use strict";
+    this.checkStarted();
+    if (!this.exists(selector)) {
+        throw new CasperError(f("Cannot get informations from %s: element not found.", selector));
+    }
+    return this.evaluate(function(selector) {
+        return __utils__.getElementInfo(selector);
+    }, selector);
+};
+
+/**
+ * Retrieves boundaries for all the DOM elements matching the provided DOM CSS3/XPath selector.
+ *
+ * @param  String  selector  A DOM CSS3/XPath selector
+ * @return Array
+ */
+Casper.prototype.getElementsBounds = function getElementBounds(selector) {
+    "use strict";
+    this.checkStarted();
+    if (!this.exists(selector)) {
+        throw new CasperError("No element matching selector found: " + selector);
+    }
+    return this.evaluate(function _evaluate(selector) {
+        return __utils__.getElementsBounds(selector);
+    }, selector);
+};
+
+/**
+ * Retrieves a given form all of its field values.
+ *
+ * @param  String  selector  A DOM CSS3/XPath selector
+ * @return Object
+ */
+Casper.prototype.getFormValues = function(selector) {
+    "use strict";
+    this.checkStarted();
+    if (!this.exists(selector)) {
+        throw new CasperError(f('Form matching selector "%s" not found', selector));
+    }
+    return this.evaluate(function(selector) {
+        return __utils__.getFormValues(selector);
+    }, selector);
+};
+
 /**
  * Retrieves global variable.
  *
@@ -748,28 +899,50 @@ Casper.prototype.getElementBounds = function getElementBounds(selector) {
  */
 Casper.prototype.getGlobal = function getGlobal(name) {
     "use strict";
+    this.checkStarted();
     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");
+            __utils__.log(message, "error");
             result.error = message;
         }
         return result;
-    }, {'name': name});
-    if (typeof result !== "object") {
+    }, name);
+    if (!utils.isObject(result)) {
         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 HTML code matching the provided CSS3/XPath selector.
+ * Returns the HTML contents for the whole page if no arg is passed.
+ *
+ * @param  String   selector  A DOM CSS3/XPath selector
+ * @param  Boolean  outer     Whether to fetch outer HTML contents (default: false)
+ * @return String
+ */
+Casper.prototype.getHTML = function getHTML(selector, outer) {
+    "use strict";
+    this.checkStarted();
+    if (!selector) {
+        return this.page.frameContent;
+    }
+    if (!this.exists(selector)) {
+        throw new CasperError("No element matching selector found: " + selector);
+    }
+    return this.evaluate(function getSelectorHTML(selector, outer) {
+        var element = __utils__.findOne(selector);
+        return outer ? element.outerHTML : element.innerHTML;
+    }, selector, !!outer);
+};
+
 /**
  * Retrieves current page title, if any.
  *
@@ -777,11 +950,44 @@ Casper.prototype.getGlobal = function getGlobal(name) {
  */
 Casper.prototype.getTitle = function getTitle() {
     "use strict";
+    this.checkStarted();
     return this.evaluate(function _evaluate() {
         return document.title;
     });
 };
 
+/**
+ * Handles received HTTP resource.
+ *
+ * @param  Object  resource  PhantomJS HTTP resource
+ */
+Casper.prototype.handleReceivedResource = function(resource) {
+    "use strict";
+    /*jshint maxstatements:20*/
+    if (resource.stage !== "end") {
+        return;
+    }
+    this.resources.push(resource);
+    if (resource.url !== this.requestUrl) {
+        return;
+    }
+    this.currentHTTPStatus = null;
+    this.currentResponse = undefined;
+    if (utils.isHTTPResource(resource)) {
+        this.emit('page.resource.received', resource);
+        this.currentResponse = resource;
+        this.currentHTTPStatus = resource.status;
+        this.emit('http.status.' + resource.status, resource);
+        if (utils.isObject(this.options.httpStatusHandlers) &&
+            resource.status in this.options.httpStatusHandlers &&
+            utils.isFunction(this.options.httpStatusHandlers[resource.status])) {
+            this.options.httpStatusHandlers[resource.status].call(this, this, resource);
+        }
+    }
+    this.currentUrl = resource.url;
+    this.emit('location.changed', resource.url);
+};
+
 /**
  * Initializes PhantomJS error handler.
  *
@@ -797,14 +1003,42 @@ Casper.prototype.initErrorHandler = function initErrorHandler() {
     };
 };
 
+/**
+ * Injects configured local client scripts.
+ *
+ * @return Casper
+ */
+Casper.prototype.injectClientScripts = function injectClientScripts() {
+    "use strict";
+    this.checkStarted();
+    if (!this.options.clientScripts) {
+        return;
+    }
+    if (utils.isString(this.options.clientScripts)) {
+        this.options.clientScripts = [this.options.clientScripts];
+    }
+    if (!utils.isArray(this.options.clientScripts)) {
+        throw new CasperError("The clientScripts option must be an array");
+    }
+    this.options.clientScripts.forEach(function _forEach(script) {
+        if (this.page.injectJs(script)) {
+            this.log(f('Automatically injected %s client side', script), "debug");
+        } else {
+            this.warn('Failed injecting %s client side', script);
+        }
+    }.bind(this));
+    return this;
+};
+
 /**
  * Injects Client-side utilities in current page context.
  *
  */
 Casper.prototype.injectClientUtils = function injectClientUtils() {
     "use strict";
+    this.checkStarted();
     var clientUtilsInjected = this.page.evaluate(function() {
-        return typeof window.__utils__ === "object";
+        return typeof __utils__ === "object";
     });
     if (true === clientUtilsInjected) {
         return;
@@ -817,17 +1051,44 @@ Casper.prototype.injectClientUtils = function injectClientUtils() {
     }
     // ClientUtils and Casper shares the same options
     // These are not the lines I'm the most proud of in my life, but it works.
+    /*global __options*/
     this.page.evaluate(function() {
-        window.__utils__ = new ClientUtils(__options);
+        window.__utils__ = new window.ClientUtils(__options);
     }.toString().replace('__options', JSON.stringify(this.options)));
 };
 
+/**
+ * Loads and include remote client scripts to current page.
+ *
+ * @return Casper
+ */
+Casper.prototype.includeRemoteScripts = function includeRemoteScripts() {
+    "use strict";
+    var numScripts = this.options.remoteScripts.length, loaded = 0;
+    if (numScripts === 0) {
+        return this;
+    }
+    this.waitStart();
+    this.options.remoteScripts.forEach(function(scriptUrl) {
+        this.log(f("Loading remote script: %s", scriptUrl), "debug");
+        this.page.includeJs(scriptUrl, function() {
+            loaded++;
+            this.log(f("Remote script %s loaded", scriptUrl), "debug");
+            if (loaded === numScripts) {
+                this.log("All remote scripts loaded.", "debug");
+                this.waitDone();
+            }
+        }.bind(this));
+    }.bind(this));
+    return this;
+};
+
 /**
  * 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")
+ * @param  String  space    Space from where the logged event occurred (default: "phantom")
  * @return Casper
  */
 Casper.prototype.log = function log(message, level, space) {
@@ -849,8 +1110,10 @@ Casper.prototype.log = function log(message, level, space) {
     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);
+        message = f('%s [%s] %s',
+                    this.colorizer.colorize(f('[%s]', level), this.logStyles[level]),
+                    space,
+                    message);
     }
     if (this.options.verbose) {
         this.echo(this.filter('log.message', message) || message); // direct output
@@ -872,26 +1135,23 @@ Casper.prototype.log = function log(message, level, space) {
  */
 Casper.prototype.mouseEvent = function mouseEvent(type, selector) {
     "use strict";
+    this.checkStarted();
     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) {
+    if (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;
-        }
+    }, type, selector)) {
+        return true;
     }
-    return true;
+    // fallback onto native QtWebKit mouse events
+    try {
+        return this.mouse.processEvent(type, selector);
+    } catch (e) {
+        this.log(f("Couldn't emulate '%s' event on %s: %s", type, selector, e), "error");
+    }
+    return false;
 };
 
 /**
@@ -901,7 +1161,7 @@ Casper.prototype.mouseEvent = function mouseEvent(type, selector) {
  *
  * - 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'}]
+ * - Object  headers:  Custom request headers object, eg. {'Cache-Control': 'max-age=0'}
  *
  * @param  String  location  The url to open
  * @param  Object  settings  The request settings (optional)
@@ -909,15 +1169,12 @@ Casper.prototype.mouseEvent = function mouseEvent(type, selector) {
  */
 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");
-    }
+    /*jshint maxstatements:30*/
+    var baseCustomHeaders = this.page.customHeaders,
+        customHeaders = settings && settings.headers || {};
+    this.checkStarted();
+    settings = utils.isObject(settings) ? settings : {};
+    settings.method = settings.method || "get";
     // http method
     // taken from https://github.com/ariya/phantomjs/blob/master/src/webpage.cpp#L302
     var methods = ["get", "head", "put", "post", "delete"];
@@ -932,32 +1189,24 @@ Casper.prototype.open = function open(location, settings) {
             throw new CasperError("open(): invalid request settings data value: " + settings.data);
         }
     }
+    // clean location
+    location = utils.cleanUrl(location);
     // current request url
+    this.configureHttpAuth(location, settings);
     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');
-    }
+    // reset resources
+    this.resources = [];
+    // custom headers
+    this.page.customHeaders = utils.mergeObjects(utils.clone(baseCustomHeaders), customHeaders);
+    // perfom request
     this.page.openUrl(this.requestUrl, {
         operation: settings.method,
-        data:      settings.data,
-        headers:   settings.headers
+        data:      settings.data
     }, this.page.settings);
-    this.resources = [];
+    // revert base custom headers
+    this.page.customHeaders = baseCustomHeaders;
     return this;
 };
 
@@ -969,16 +1218,14 @@ Casper.prototype.open = function open(location, settings) {
  */
 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();
+    this.checkStarted();
+    // window.location.reload() is broken under phantomjs
+    this.then(function() {
+        this.open(this.getCurrentUrl());
     });
-    if (then && utils.isFunction(then)) {
+    if (utils.isFunction(then)) {
         this.then(this.createStep(then));
     }
-    return this;
 };
 
 /**
@@ -1006,16 +1253,17 @@ Casper.prototype.repeat = function repeat(times, then) {
  */
 Casper.prototype.resourceExists = function resourceExists(test) {
     "use strict";
+    this.checkStarted();
     var testFn;
     switch (utils.betterTypeOf(test)) {
         case "string":
             testFn = function _testResourceExists_String(res) {
-                return res.url.search(test) !== -1;
+                return res.url.search(test) !== -1 && res.status !== 404;
             };
             break;
         case "regexp":
             testFn = function _testResourceExists_Regexp(res) {
-                return test.test(res.url);
+                return test.test(res.url) && res.status !== 404;
             };
             break;
         case "function":
@@ -1037,9 +1285,9 @@ Casper.prototype.resourceExists = function resourceExists(test) {
  */
 Casper.prototype.run = function run(onComplete, time) {
     "use strict";
+    this.checkStarted();
     if (!this.steps || this.steps.length < 1) {
-        this.log("No steps defined, aborting", "error");
-        return this;
+        throw new CasperError('No steps defined, aborting');
     }
     this.log(f("Running suite: %d step%s", this.steps.length, this.steps.length > 1 ? "s" : ""), "info");
     this.emit('run.start');
@@ -1054,29 +1302,28 @@ Casper.prototype.run = function run(onComplete, time) {
  */
 Casper.prototype.runStep = function runStep(step) {
     "use strict";
+    this.checkStarted();
     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) {
+    if (!skipLog && /^http/.test(this.getCurrentUrl())) {
         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) {
+                if ((self.test.currentSuiteNum + "-" + 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");
+                        self.options.onStepTimeout.call(self, self.options.stepTimeout, stepNum);
                     }
                 }
                 clearInterval(stepTimeoutCheckInterval);
             }
-        }, this.options.stepTimeout, this, new Date().getTime(), this.step);
+        }, this.options.stepTimeout, this, new Date().getTime(), this.test.currentSuiteNum + "-" + this.step);
     }
     this.emit('step.start', step);
-    stepResult = step.call(this, this);
+    stepResult = step.call(this, this.currentResponse);
     if (utils.isFunction(this.options.onStepComplete)) {
         this.options.onStepComplete.call(this, this, stepResult);
     }
@@ -1087,24 +1334,53 @@ Casper.prototype.runStep = function runStep(step) {
 };
 
 /**
- * Sets HTTP authentication parameters.
+ * Sends keys to given element.
  *
- * @param  String   username  The HTTP_AUTH_USER value
- * @param  String   password  The HTTP_AUTH_PW value
+ * @param  String  selector  A DOM CSS3 compatible selector
+ * @param  String  keys      A string representing the sequence of char codes to send
+ * @param  Object  options   Options
  * @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");
+Casper.prototype.sendKeys = function(selector, keys, options) {
+    "use strict";
+    this.checkStarted();
+    options = utils.mergeObjects({
+        eventType: 'keypress'
+    }, options || {});
+    var elemInfos = this.getElementInfo(selector),
+        tag = elemInfos.nodeName.toLowerCase(),
+        type = utils.getPropertyPath(elemInfos, 'attributes.type'),
+        supported = ["color", "date", "datetime", "datetime-local", "email",
+                     "hidden", "month", "number", "password", "range", "search",
+                     "tel", "text", "time", "url", "week"];
+    var isTextInput = false;
+    if (tag === 'textarea' || (tag === 'input' && supported.indexOf(type) !== -1)) {
+        // clicking on the input element brings it focus
+        isTextInput = true;
+        this.click(selector);
     }
-    if (!utils.isString(username) || !utils.isString(password)) {
-        throw new CasperError("Both username and password must be strings");
+    this.page.sendEvent(options.eventType, keys);
+    if (isTextInput) {
+        // remove the focus
+        this.evaluate(function(selector) {
+            __utils__.findOne(selector).blur();
+        }, selector);
     }
+    return this;
+};
+
+/**
+ * Sets current WebPage instance the credentials for HTTP authentication.
+ *
+ * @param  String  username
+ * @param  String  password
+ * @return Casper
+ */
+Casper.prototype.setHttpAuth = function setHttpAuth(username, password) {
+    "use strict";
+    this.checkStarted();
     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;
 };
 
@@ -1117,10 +1393,12 @@ Casper.prototype.setHttpAuth = function setHttpAuth(username, password) {
  */
 Casper.prototype.start = function start(location, then) {
     "use strict";
+    /*jshint maxstatements:30*/
     this.emit('starting');
     this.log('Starting...', "info");
     this.startTime = new Date().getTime();
     this.history = [];
+    this.popups = pagestack.create();
     this.steps = [];
     this.step = 0;
     // Option checks
@@ -1128,13 +1406,8 @@ Casper.prototype.start = function start(location, then) {
         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 = this.mainPage = utils.isWebPage(this.options.page) ? this.options.page : createPage(this);
     }
     this.page.settings = utils.mergeObjects(this.page.settings, this.options.pageSettings);
     if (utils.isClipRect(this.options.clipRect)) {
@@ -1143,27 +1416,43 @@ Casper.prototype.start = function start(location, then) {
     if (utils.isObject(this.options.viewportSize)) {
         this.page.viewportSize = this.options.viewportSize;
     }
-    this.started = true;
-    this.emit('started');
+    // timeout handling
     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));
+                self.options.onTimeout.call(self, self.options.timeout);
             }
         }, this.options.timeout, this);
     }
+    this.started = true;
+    this.emit('started');
     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");
-        }));
+        }, {skipLog: true}));
     }
     return this;
 };
 
+/**
+ * Returns the current status of current instance
+ *
+ * @param  Boolean  asString  Export status object as string
+ * @return Object
+ */
+Casper.prototype.status = function status(asString) {
+    "use strict";
+    var properties = ['currentHTTPStatus', 'loadInProgress', 'navigationRequested',
+                      'options', 'pendingWait', 'requestUrl', 'started', 'step', 'url'];
+    var currentStatus = {};
+    properties.forEach(function(property) {
+        currentStatus[property] = this[property];
+    }.bind(this));
+    return asString === true ? utils.dump(currentStatus) : currentStatus;
+};
+
 /**
  * Schedules the next step in the navigation process.
  *
@@ -1172,9 +1461,7 @@ Casper.prototype.start = function start(location, then) {
  */
 Casper.prototype.then = function then(step) {
     "use strict";
-    if (!this.started) {
-        throw new CasperError("Casper not started; please use Casper#start");
-    }
+    this.checkStarted();
     if (!utils.isFunction(step)) {
         throw new CasperError("You can only define a step as a function");
     }
@@ -1212,6 +1499,7 @@ Casper.prototype.then = function then(step) {
  */
 Casper.prototype.thenClick = function thenClick(selector, then, fallbackToHref) {
     "use strict";
+    this.checkStarted();
     if (arguments.length > 2) {
         this.emit("deprecated", "The thenClick() method does not process the fallbackToHref argument since 0.6");
     }
@@ -1232,8 +1520,10 @@ Casper.prototype.thenClick = function thenClick(selector, then, fallbackToHref)
  */
 Casper.prototype.thenEvaluate = function thenEvaluate(fn, context) {
     "use strict";
+    this.checkStarted();
+    var args = [fn].concat([].slice.call(arguments, 1));
     return this.then(function _step() {
-        this.evaluate(fn, context);
+        this.evaluate.apply(this, args);
     });
 };
 
@@ -1245,10 +1535,15 @@ Casper.prototype.thenEvaluate = function thenEvaluate(fn, context) {
  * @return Casper
  * @see    Casper#open
  */
-Casper.prototype.thenOpen = function thenOpen(location, then) {
+Casper.prototype.thenOpen = function thenOpen(location, settings, then) {
     "use strict";
+    this.checkStarted();
+    if (!(settings && !utils.isFunction(settings))) {
+      then = settings;
+      settings = null;
+    }
     this.then(this.createStep(function _step() {
-        this.open(location);
+        this.open(location, settings);
     }, {
         skipLog: true
     }));
@@ -1268,9 +1563,20 @@ Casper.prototype.thenOpen = function thenOpen(location, then) {
  */
 Casper.prototype.thenOpenAndEvaluate = function thenOpenAndEvaluate(location, fn, context) {
     "use strict";
+    this.checkStarted();
     return this.thenOpen(location).thenEvaluate(fn, context);
 };
 
+/**
+ * Returns a string representation of current instance
+ *
+ * @return String
+ */
+Casper.prototype.toString = function toString() {
+    "use strict";
+    return '[object Casper], currently at ' + this.getCurrentUrl();
+};
+
 /**
  * Sets the user-agent string currently used when requesting urls.
  *
@@ -1279,10 +1585,10 @@ Casper.prototype.thenOpenAndEvaluate = function thenOpenAndEvaluate(location, fn
  */
 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 = agent;
+    if (this.started && this.page) {
+        this.page.settings.userAgent = agent;
     }
-    this.options.pageSettings.userAgent = this.page.settings.userAgent = agent;
     return this;
 };
 
@@ -1295,9 +1601,7 @@ Casper.prototype.userAgent = function userAgent(agent) {
  */
 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");
-    }
+    this.checkStarted();
     if (!utils.isNumber(width) || !utils.isNumber(height) || width <= 0 || height <= 0) {
         throw new CasperError(f("Invalid viewport: %dx%d", width, height));
     }
@@ -1319,9 +1623,10 @@ Casper.prototype.viewport = function viewport(width, height) {
  */
 Casper.prototype.visible = function visible(selector) {
     "use strict";
+    this.checkStarted();
     return this.evaluate(function _evaluate(selector) {
-        return window.__utils__.visible(selector);
-    }, { selector: selector });
+        return __utils__.visible(selector);
+    }, selector);
 };
 
 /**
@@ -1347,6 +1652,7 @@ Casper.prototype.warn = function warn(message) {
  */
 Casper.prototype.wait = function wait(timeout, then) {
     "use strict";
+    this.checkStarted();
     timeout = ~~timeout;
     if (timeout < 1) {
         this.die("wait() only accepts a positive integer > 0 as a timeout value");
@@ -1389,7 +1695,8 @@ Casper.prototype.waitDone = function waitDone() {
  */
 Casper.prototype.waitFor = function waitFor(testFx, then, onTimeout, timeout) {
     "use strict";
-    timeout = timeout ? timeout : this.defaultWaitTimeout;
+    this.checkStarted();
+    timeout = timeout ? timeout : this.options.waitTimeout;
     if (!utils.isFunction(testFx)) {
         this.die("waitFor() needs a test function");
     }
@@ -1408,11 +1715,11 @@ Casper.prototype.waitFor = function waitFor(testFx, then, onTimeout, timeout) {
                 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");
+                    var onWaitTimeout = onTimeout ? onTimeout : self.options.onWaitTimeout;
+                    if (!utils.isFunction(onWaitTimeout)) {
+                        throw new CasperError('Invalid timeout function, exiting.');
                     }
+                    onWaitTimeout.call(self, timeout);
                 } else {
                     self.log(f("waitFor() finished in %dms.", new Date().getTime() - start), "info");
                     if (then) {
@@ -1425,6 +1732,28 @@ Casper.prototype.waitFor = function waitFor(testFx, then, onTimeout, timeout) {
     });
 };
 
+/**
+ * Waits for a popup page having its url matching the provided pattern to be opened
+ * and loaded.
+ *
+ * @param  String|RegExp  urlPattern  The popup url pattern
+ * @param  Function       then        The next step function (optional)
+ * @param  Function       onTimeout   Function to call on operation timeout (optional)
+ * @param  Number         timeout     Timeout in milliseconds (optional)
+ * @return Casper
+ */
+Casper.prototype.waitForPopup = function waitForPopup(urlPattern, then, onTimeout, timeout) {
+    "use strict";
+    return this.waitFor(function() {
+        try {
+            this.popups.find(urlPattern);
+            return true;
+        } catch (e) {
+            return false;
+        }
+    }, then, onTimeout, timeout);
+};
+
 /**
  * Waits until a given resource is loaded
  *
@@ -1437,7 +1766,8 @@ Casper.prototype.waitFor = function waitFor(testFx, then, onTimeout, timeout) {
  */
 Casper.prototype.waitForResource = function waitForResource(test, then, onTimeout, timeout) {
     "use strict";
-    timeout = timeout ? timeout : this.defaultWaitTimeout;
+    this.checkStarted();
+    timeout = timeout ? timeout : this.options.waitTimeout;
     return this.waitFor(function _check() {
         return this.resourceExists(test);
     }, then, onTimeout, timeout);
@@ -1455,12 +1785,31 @@ Casper.prototype.waitForResource = function waitForResource(test, then, onTimeou
  */
 Casper.prototype.waitForSelector = function waitForSelector(selector, then, onTimeout, timeout) {
     "use strict";
-    timeout = timeout ? timeout : this.defaultWaitTimeout;
+    this.checkStarted();
+    timeout = timeout ? timeout : this.options.waitTimeout;
     return this.waitFor(function _check() {
         return this.exists(selector);
     }, then, onTimeout, timeout);
 };
 
+/**
+ * Waits until the page contains given HTML text.
+ *
+ * @param  String    text       Text to wait for
+ * @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.waitForText = function(text, then, onTimeout, timeout) {
+    "use strict";
+    this.checkStarted();
+    timeout = timeout ? timeout : this.options.waitTimeout;
+    return this.waitFor(function _check() {
+        return this.getPageContent().indexOf(text) !== -1;
+    }, 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.
@@ -1473,7 +1822,8 @@ Casper.prototype.waitForSelector = function waitForSelector(selector, then, onTi
  */
 Casper.prototype.waitWhileSelector = function waitWhileSelector(selector, then, onTimeout, timeout) {
     "use strict";
-    timeout = timeout ? timeout : this.defaultWaitTimeout;
+    this.checkStarted();
+    timeout = timeout ? timeout : this.options.waitTimeout;
     return this.waitFor(function _check() {
         return !this.exists(selector);
     }, then, onTimeout, timeout);
@@ -1491,7 +1841,8 @@ Casper.prototype.waitWhileSelector = function waitWhileSelector(selector, then,
  */
 Casper.prototype.waitUntilVisible = function waitUntilVisible(selector, then, onTimeout, timeout) {
     "use strict";
-    timeout = timeout ? timeout : this.defaultWaitTimeout;
+    this.checkStarted();
+    timeout = timeout ? timeout : this.options.waitTimeout;
     return this.waitFor(function _check() {
         return this.visible(selector);
     }, then, onTimeout, timeout);
@@ -1509,12 +1860,80 @@ Casper.prototype.waitUntilVisible = function waitUntilVisible(selector, then, on
  */
 Casper.prototype.waitWhileVisible = function waitWhileVisible(selector, then, onTimeout, timeout) {
     "use strict";
-    timeout = timeout ? timeout : this.defaultWaitTimeout;
+    this.checkStarted();
+    timeout = timeout ? timeout : this.options.waitTimeout;
     return this.waitFor(function _check() {
         return !this.visible(selector);
     }, then, onTimeout, timeout);
 };
 
+/**
+ * Makes the provided frame page as the currently active one. Note that the
+ * active page will be reverted when finished.
+ *
+ * @param  String|Number    frameInfo  Target frame name or number
+ * @param  Function  then       Next step function
+ * @return Casper
+ */
+Casper.prototype.withFrame = function withFrame(frameInfo, then) {
+    "use strict";
+    this.then(function _step() {
+        if (utils.isNumber(frameInfo)) {
+            if (frameInfo > this.page.childFramesCount() - 1) {
+                throw new CasperError(f('Frame number "%d" is out of bounds.', frameInfo));
+            }
+        } else if (this.page.childFramesName().indexOf(frameInfo) === -1) {
+            throw new CasperError(f('No frame named "%s" was found.', frameInfo));
+        }
+        // make the frame page the currently active one
+        this.page.switchToChildFrame(frameInfo);
+    });
+    try {
+        this.then(then);
+    } catch (e) {
+        // revert to main page on error
+        this.warn("Error while processing frame step: " + e);
+        this.page.switchToMainFrame();
+        throw e;
+    }
+    return this.then(function _step() {
+        // revert to main page
+        this.page.switchToMainFrame();
+    });
+};
+
+/**
+ * Makes the provided frame page as the currently active one. Note that the
+ * active page will be reverted when finished.
+ *
+ * @param  String|RegExp|WebPage  popup  Target frame page information
+ * @param  Function               then   Next step function
+ * @return Casper
+ */
+Casper.prototype.withPopup = function withPopup(popupInfo, then) {
+    "use strict";
+    this.then(function _step() {
+        var popupPage = this.popups.find(popupInfo);
+        if (!utils.isFunction(then)) {
+            throw new CasperError("withPopup() requires a step function.");
+        }
+        // make the popup page the currently active one
+        this.page = popupPage;
+    });
+    try {
+        this.then(then);
+    } catch (e) {
+        // revert to main page on error
+        this.log("error while processing popup step: " + e, "error");
+        this.page = this.mainPage;
+        throw e;
+    }
+    return this.then(function _step() {
+        // revert to main page
+        this.page = this.mainPage;
+    });
+};
+
 /**
  * Changes the current page zoom factor.
  *
@@ -1523,17 +1942,11 @@ Casper.prototype.waitWhileVisible = function waitWhileVisible(selector, then, on
  */
 Casper.prototype.zoom = function zoom(factor) {
     "use strict";
-    if (!this.started) {
-        throw new CasperError("Casper has not been started, can't set zoom factor");
-    }
+    this.checkStarted();
     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");
-    }
+    this.page.zoomFactor = factor;
     return this;
 };
 
@@ -1546,7 +1959,7 @@ Casper.prototype.zoom = function zoom(factor) {
  */
 Casper.extend = function(proto) {
     "use strict";
-    this.warn('Casper.extend() has been deprecated since 0.6; check the docs');
+    this.emit("deprecated", "Casper.extend() has been deprecated since 0.6; check the docs")
     if (!utils.isObject(proto)) {
         throw new CasperError("extends() only accept objects as prototypes");
     }
@@ -1562,6 +1975,7 @@ exports.Casper = Casper;
  * @return WebPage
  */
 function createPage(casper) {
+    /*jshint maxstatements:20*/
     "use strict";
     var page = require('webpage').create();
     page.onAlert = function onAlert(message) {
@@ -1572,24 +1986,35 @@ function createPage(casper) {
         }
     };
     page.onConfirm = function onConfirm(message) {
-        return casper.filter('page.confirm', message) || true;
+        if ('page.confirm' in casper._filters) {
+            return casper.filter('page.confirm', message);
+        }
+        return 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];
+        // client utils casper console message
+        var consoleTest = /^\[casper\.echo\]\s?([\s\S]*)/.exec(msg);
+        if (consoleTest && consoleTest.length === 2) {
+            casper.echo(consoleTest[1]);
+            return; // don't trigger remote.message event for these
+        }
+        // client utils log messages
+        var logLevel = "info",
+            logTest = /^\[casper:(\w+)\]\s?([\s\S]*)/m.exec(msg);
+        if (logTest && logTest.length === 3) {
+            logLevel = logTest[1];
+            msg = logTest[2];
         }
-        casper.log(msg, level, "remote");
+        casper.log(msg, logLevel, "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);
+        casper.emit('page.initialized', page);
         if (utils.isFunction(casper.options.onPageInitialized)) {
-            this.log("Post-configuring WebPage instance", "debug");
+            casper.log("Post-configuring WebPage instance", "debug");
             casper.options.onPageInitialized.call(casper, page);
         }
     };
@@ -1598,6 +2023,7 @@ function createPage(casper) {
         casper.emit('load.started');
     };
     page.onLoadFinished = function onLoadFinished(status) {
+        /*jshint maxstatements:20*/
         if (status !== "success") {
             casper.emit('load.failed', {
                 status:      status,
@@ -1610,25 +2036,15 @@ function createPage(casper) {
             }
             message += ': ' + casper.requestUrl;
             casper.log(message, "warning");
+            casper.navigationRequested = false;
             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);
-                }
-            });
-        }
+        // local client scripts
+        casper.injectClientScripts();
+        // remote client scripts
+        casper.includeRemoteScripts();
         // Client-side utils injection
         casper.injectClientUtils();
         // history
@@ -1639,39 +2055,45 @@ function createPage(casper) {
     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");
+        if(isMainFrame) {
+            casper.navigationRequested  = true;
+        }
         casper.emit('navigation.requested', url, navigationType, navigationLocked, isMainFrame);
     };
+    page.onPageCreated = function onPageCreated(popupPage) {
+        casper.emit('popup.created', popupPage);
+        popupPage.onLoadFinished = function onLoadFinished() {
+            casper.popups.push(popupPage);
+            casper.emit('popup.loaded', popupPage);
+        };
+        popupPage.onClosing = function onClosing(closedPopup) {
+            casper.popups.clean(closedPopup);
+            casper.emit('popup.closed', closedPopup);
+        };
+    };
     page.onPrompt = function onPrompt(message, value) {
         return casper.filter('page.prompt', message, value);
     };
     page.onResourceReceived = function onResourceReceived(resource) {
+        http.augmentResponse(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);
-        }
+        casper.handleReceivedResource(resource);
     };
     page.onResourceRequested = function onResourceRequested(request) {
         casper.emit('resource.requested', request);
+        if (request.url === casper.requestUrl) {
+            casper.emit('page.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.navigationRequested = false;
         casper.emit('url.changed', url);
     };
     casper.emit('page.created', page);