/**

 * @depend ../sinon.js

 * @depend spy.js

 */

/*jslint eqeqeq: false, onevar: false*/

/*global module, require, sinon*/

/**

 * Stub functions

 *

 * @author Christian Johansen (christian@cjohansen.no)

 * @license BSD

 *

 * Copyright (c) 2010-2011 Christian Johansen

 */

"use strict";



(function (sinon) {

    var commonJSModule = typeof module == "object" && typeof require == "function";



    if (!sinon && commonJSModule) {

        sinon = require("../sinon");

    }



    if (!sinon) {

        return;

    }



    function stub(object, property, func) {

        if (!!func && typeof func != "function") {

            throw new TypeError("Custom stub should be function");

        }



        var wrapper;



        if (func) {

            wrapper = sinon.spy && sinon.spy.create ? sinon.spy.create(func) : func;

        } else {

            wrapper = stub.create();

        }



        if (!object && !property) {

            return sinon.stub.create();

        }



        if (!property && !!object && typeof object == "object") {

            for (var prop in object) {

                if (typeof object[prop] === "function") {

                    stub(object, prop);

                }

            }



            return object;

        }



        return sinon.wrapMethod(object, property, wrapper);

    }



    function getCallback(stub, args) {

        if (stub.callArgAt < 0) {

            for (var i = 0, l = args.length; i < l; ++i) {

                if (!stub.callArgProp && typeof args[i] == "function") {

                    return args[i];

                }



                if (stub.callArgProp && args[i] &&

                    typeof args[i][stub.callArgProp] == "function") {

                    return args[i][stub.callArgProp];

                }

            }



            return null;

        }



        return args[stub.callArgAt];

    }



    var join = Array.prototype.join;



    function getCallbackError(stub, func, args) {

        if (stub.callArgAt < 0) {

            var msg;



            if (stub.callArgProp) {

                msg = sinon.functionName(stub) +

                    " expected to yield to '" + stub.callArgProp +

                    "', but no object with such a property was passed."

            } else {

                msg = sinon.functionName(stub) +

                            " expected to yield, but no callback was passed."

            }



            if (args.length > 0) {

                msg += " Received [" + join.call(args, ", ") + "]";

            }



            return msg;

        }



        return "argument at index " + stub.callArgAt + " is not a function: " + func;

    }



    var nextTick = (function () {

        if (typeof process === "object" && typeof process.nextTick === "function") {

            return process.nextTick;

        } else if (typeof msSetImmediate === "function") {

            return msSetImmediate.bind(window);

        } else if (typeof setImmediate === "function") {

            return setImmediate;

        } else {

            return function (callback) {

                setTimeout(callback, 0);

            };

        }

    })();



    function callCallback(stub, args) {

        if (typeof stub.callArgAt == "number") {

            var func = getCallback(stub, args);



            if (typeof func != "function") {

                throw new TypeError(getCallbackError(stub, func, args));

            }



            if (stub.callbackAsync) {

                nextTick(function() {

                    func.apply(stub.callbackContext, stub.callbackArguments);

                });

            } else {

                func.apply(stub.callbackContext, stub.callbackArguments);

            }

        }

    }



    var uuid = 0;



    sinon.extend(stub, (function () {

        var slice = Array.prototype.slice, proto;



        function throwsException(error, message) {

            if (typeof error == "string") {

                this.exception = new Error(message || "");

                this.exception.name = error;

            } else if (!error) {

                this.exception = new Error("Error");

            } else {

                this.exception = error;

            }



            return this;

        }



        proto = {

            create: function create() {

                var functionStub = function () {



                    callCallback(functionStub, arguments);



                    if (functionStub.exception) {

                        throw functionStub.exception;

                    } else if (typeof functionStub.returnArgAt == 'number') {

                        return arguments[functionStub.returnArgAt];

                    } else if (functionStub.returnThis) {

                        return this;

                    }

                    return functionStub.returnValue;

                };



                functionStub.id = "stub#" + uuid++;

                var orig = functionStub;

                functionStub = sinon.spy.create(functionStub);

                functionStub.func = orig;



                sinon.extend(functionStub, stub);

                functionStub._create = sinon.stub.create;

                functionStub.displayName = "stub";

                functionStub.toString = sinon.functionToString;



                return functionStub;

            },



            returns: function returns(value) {

                this.returnValue = value;



                return this;

            },



            returnsArg: function returnsArg(pos) {

                if (typeof pos != "number") {

                    throw new TypeError("argument index is not number");

                }



                this.returnArgAt = pos;



                return this;

            },



            returnsThis: function returnsThis() {

                this.returnThis = true;



                return this;

            },



            "throws": throwsException,

            throwsException: throwsException,



            callsArg: function callsArg(pos) {

                if (typeof pos != "number") {

                    throw new TypeError("argument index is not number");

                }



                this.callArgAt = pos;

                this.callbackArguments = [];



                return this;

            },



            callsArgOn: function callsArgOn(pos, context) {

                if (typeof pos != "number") {

                    throw new TypeError("argument index is not number");

                }

                if (typeof context != "object") {

                    throw new TypeError("argument context is not an object");

                }



                this.callArgAt = pos;

                this.callbackArguments = [];

                this.callbackContext = context;



                return this;

            },



            callsArgWith: function callsArgWith(pos) {

                if (typeof pos != "number") {

                    throw new TypeError("argument index is not number");

                }



                this.callArgAt = pos;

                this.callbackArguments = slice.call(arguments, 1);



                return this;

            },



            callsArgOnWith: function callsArgWith(pos, context) {

                if (typeof pos != "number") {

                    throw new TypeError("argument index is not number");

                }

                if (typeof context != "object") {

                    throw new TypeError("argument context is not an object");

                }



                this.callArgAt = pos;

                this.callbackArguments = slice.call(arguments, 2);

                this.callbackContext = context;



                return this;

            },



            yields: function () {

                this.callArgAt = -1;

                this.callbackArguments = slice.call(arguments, 0);



                return this;

            },



            yieldsOn: function (context) {

                if (typeof context != "object") {

                    throw new TypeError("argument context is not an object");

                }



                this.callArgAt = -1;

                this.callbackArguments = slice.call(arguments, 1);

                this.callbackContext = context;



                return this;

            },



            yieldsTo: function (prop) {

                this.callArgAt = -1;

                this.callArgProp = prop;

                this.callbackArguments = slice.call(arguments, 1);



                return this;

            },



            yieldsToOn: function (prop, context) {

                if (typeof context != "object") {

                    throw new TypeError("argument context is not an object");

                }



                this.callArgAt = -1;

                this.callArgProp = prop;

                this.callbackArguments = slice.call(arguments, 2);

                this.callbackContext = context;



                return this;

            }

        };

        

        // create asynchronous versions of callsArg* and yields* methods

        for (var method in proto) {

            if (proto.hasOwnProperty(method) && method.match(/^(callsArg|yields)/)) {

                proto[method + 'Async'] = (function (syncFnName) {

                    return function () {

                        this.callbackAsync = true;

                        return this[syncFnName].apply(this, arguments);

                    };

                })(method);

            }

        }

        

        return proto;

        

    }()));



    if (commonJSModule) {

        module.exports = stub;

    } else {

        sinon.stub = stub;

    }

}(typeof sinon == "object" && sinon || null));