all files / lib/ Resolver.js

100% Statements 34/34
100% Branches 10/10
100% Functions 7/7
100% Lines 34/34
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90                      211×     211× 211×         333× 333× 333×   18× 18×       333×           49× 49×     44×     164×     309×                                 209× 205× 165×     205×   202× 201×     202×      
"use strict";
 
var assert = require('./util').assert;
var ResolutionError = require('./ResolutionError');
 
/**
 * Instances are created internally during calls to {@link Container#use} and {@link RegistrationBuilder#use}.
 *
 * @param {Function} impl The resolver implementation.
 * @param {Array} args The arguments to make available to the resolver implementation.
 * @constructor
 * @classdesc Private to junkie internals.
 */
function Resolver(impl, args) {
  assert.type(impl,
    'function',
    "Resolver must be a function: " + impl);
  this._impl = impl;
  this._args = args || [];
}
 
/** @lends Resolver# */
var R = Resolver.prototype;
 
R.resolve = function(ctx, res, next) {
  var resolverThis = this._createResolverThis();
  try {
    this._impl.call(resolverThis, ctx, res, next);
  } catch (e) {
    res.fail(e);
    return next();
  }
};
 
R._createResolverThis = function() {
  return {
    arg: this.arg.bind(this),
    args: this.args.bind(this)
  };
};
 
R.arg = function(i, failMessage) {
  var val = this._args[i];
  if (!val) {
    throw new ResolutionError(failMessage ||
      ("Resolver " + this._impl.name + " requires argument at index: " + i));
  }
  return val;
};
 
R.args = function() {
  return this._args.slice();
};
 
R.acceptsNextArg = function() {
  return this._impl.length >= 3;
};
 
// Looped requires would be nice, but browserify shits the bed
Resolver.StandardResolvers = Object.freeze({
  assignment: require('./resolver/assignment'),
  caching: require('./resolver/caching'),
  constructor: require('./resolver/constructor'),
  creator: require('./resolver/creator'),
  decorator: require('./resolver/decorator'),
  factory: require('./resolver/factory'),
  factoryMethod: require('./resolver/factoryMethod'),
  field: require('./resolver/field'),
  freezing: require('./resolver/freezing'),
  method: require('./resolver/method'),
  sealing: require('./resolver/sealing')
});
 
Resolver.normalize = function(resolver, args) {
  assert(!!resolver, "resolver must be defined");
  if (typeof resolver === 'string') {
    resolver = Resolver.StandardResolvers[resolver];
  }
 
  assert.type(resolver, [ 'object', 'function' ], "resolver must be a function or object");
 
  if (!(resolver instanceof Resolver)) {
    resolver = new Resolver(resolver, args);
  }
 
  return resolver;
};
 
module.exports = Resolver;