Constructor passed an object with dependencies instead of as parameters about electrolyte HOT 4 OPEN

I decided to look at this again. It seems like it would be a fairly trivial change if you're up for API breakage. Simply adjust Component.prototype.create to:

Component.prototype.create = function(container) {
  debug('create %s', this.id);

  var source = container._sources[this._sid];
  var loaded = this.loaded;

  if (!this.loaded) {
    var deps = this.dependencies
      , args = {};
    for (var i = 0, len = deps.length; i < len; ++i) {
      var inst = container.create(deps[i], this);
      if (source) {
        if (typeof source.fn.scope == 'function') {
          inst = source.fn.scope(deps[i], inst, { prefix: source.prefix, options: source.options });
        }
      }
      args[deps[i]] = inst;
    }
  }
  var i = this.instantiate.apply(this, [args]);

  if (!loaded && container._expose) {
    container._expose.call(container, this.id, i, this.singleton)
  }

  return i;
}

Note that args is no longer an array, but an object. As the dependencies are instantiated, they're added to the args object as the value of a property named after the dependency name.

As I am writing this post, I have realized that dependency names with a path could be a problem. I'm not sure how to handle that scenario.

from electrolyte.

You'd also run into sticky issues with dependencies like "users/db" and "music/db" where there are two objects named the same thing (with different paths).

Honestly, I'm not really a fan of the object idea. It seems like it'll have a lot of edge cases that'll get messy, and if your constructor signature is that big to make this a problem, you probably have a class that is too complicated itself.

from electrolyte.

I agree. I wasn't really trying to solve a constructor with too many dependencies problem. More this pattern:

var foo;
var bar;

// implementation

exports = module.exports = function($foo, $bar) {
  foo = $foo;
  bar = $bar;

  return something;
}

exports['@require'] = [ 'foo', 'bar' ];

The overly long constructor being resolved was just a nice side effect.

However, I don't see how "users/db" and "music/db" would conflict. You'd be passing in an object like:

{
  "users/db": {},
  "music/db": {}
}

The ugliness there is in accessing those fields.

from electrolyte.

This is an example of how I deal with it:

class Foo {
  constructor(args) {
    this._settings = args.settings;
    this._bar = args.bar
  }
}
module.exports['@require'] = [
  'config/settings',
  'components/bar'
]
module.exports = (settings, bar) => {
  return new Foo({
    settings: settings,
    bar: bar
  });
};

from electrolyte.