thin layer on top of when.js

variadic.js

(function(buster, when, apply) {

var assert, refute, fail, sentinel;

assert = buster.assert;
refute = buster.refute;
fail = buster.assertions.fail;

sentinel = {};

function fakeResolved(val) {
	return {
		then: function(callback) {
			return fakeResolved(callback ? callback(val) : val);
		}
	};
}

function fakeRejected(reason) {
	return {
		then: function(callback, errback) {
			return errback ? fakeResolved(errback(reason)) : fakeRejected(reason);
		}
	};
}

var variadic = (function(){
  function variadic() {
    var args = [].slice.apply(arguments);
    return variadic.resolve.apply(null, args);
  }

  var defer = function() {
    var defer = when.defer();
    var dfd = when.defer();
    var resolve = defer.resolve;
    var then = defer.promise.then;

    defer.promise.then = function(cb, eb, pb) {
      return then(apply(cb), eb, pb);
    };

    dfd.then(resolve, defer.reject, dfd.progess);

    defer.resolve = function(){
      var args = [].slice.apply(arguments);
      if (args.length == 1 && args[0] instanceof Array) {
        args = args[0];
      }

      return dfd.resolve(args);
    };

    return defer;
  };

  var resolve = function() {
    var args = [].slice.apply(arguments);
    var defer = variadic.defer();
    defer.resolve.apply(null, args);
    return defer.promise;
  };

  variadic.defer = defer;
  variadic.resolve = resolve;
  return variadic;
})();

buster.testCase('when.defer.multiargs', {

	'resolve': {
    'variadic resolve': function(done){
      variadic.resolve(1,2).then(function(a,b){
        assert.equals(a, 1);
        assert.equals(b, 2);
      }).always(done);
    },

    'chained variadic resolve': function(done) {
      variadic.resolve([1,2])
        .then(function(a,b) {
          assert.equals(a, 1);
          assert.equals(b, 2);
          return variadic.resolve(a,b);
        }, fail)
        .then(function(a,b) {
          assert.equals(a, 1);
          assert.equals(b, 2);
        }, fail)
        .always(done);
    },
    'should resolve promise multiargs': function(done) {
      var d = variadic.defer();
      d.promise.then(
        function(a,b) {
          assert.equals(a, 1);
          assert.equals(b, 2);
        },
        fail
      ).always(done);

      d.resolve([1,2]);
    },
    'should resolve a multiargs': function(done) {
      var d = variadic.defer();
      d.promise.then(
        function(a,b){
          assert.equals(a, 1);
          assert.equals(b, 2);
        },
        fail
      ).always(done);
      d.resolve(1,2);
    },

    'should 1': function(done) {
      var d = variadic.defer();
      d.promise.then(
        function(a,b) {
          assert.equals(a, 3);
          assert.equals(b, 4);
        },
        fail
      ).always(done);

      d.resolve(3,4);
    },
    'should chain then': function(done) {
      var d = variadic.defer();
      var e = d.promise
        .then(function(a,b) {
          assert.equals(a, 1);
          assert.equals(b, 2);
          return variadic.resolve(a,b);
        }, fail)
        .then(function(a,b) {
          assert.equals(a, 1);
          assert.equals(b, 2);
        }, fail)
        .always(done);
      d.resolve(1,2);
    },

    'should be mixed args': function(done) {
      var d = variadic.defer();
      d.promise
        .then(
          function(a,b) {
            assert.equals(a[0], 1);
            assert.equals(a[1], 2);
            assert.equals(b, 3);
          },
          fail
        ).always(done);
      d.resolve([1,2], 3);
    },
    'variadic when': function(done){
      variadic(1,2)
        .then(function(a,b){
          assert.equals(a, 1);
          assert.equals(b, 2);
          return variadic.resolve(a * 2, b * 3);
        })
        .then(function(a,b){
          assert.equals(a, 2);
          assert.equals(b, 6);
        })
        .always(done);
    }
  }
});

})(
	this.buster || require('buster'),
	this.when   || require('..'),
  this.when_apply || require('../apply')
);