code: function (fullName, property, injectionName) {
        var normalizedName = this.normalize(fullName);
        var normalizedInjectionName = this.normalize(injectionName);
  
        this.validateFullName(injectionName);
  
        if (fullName.indexOf(':') === -1) {
          return this.factoryTypeInjection(normalizedName, property, normalizedInjectionName);
        }
  
        var injections = this._factoryInjections[normalizedName] || (this._factoryInjections[normalizedName] = []);
  
        injections.push({
          property: property,
          fullName: normalizedInjectionName
        });
      }
docs: Defines factory injection rules.
  Similar to regular injection rules, but are run against factories, via
  `Registry#lookupFactory`.
  These rules are used to inject objects onto factories when they
  are looked up.
  Two forms of injections are possible:
  Injecting one fullName on another fullName
  Injecting one fullName on a type
  Example:
  ```javascript
  var registry = new Registry();
  var container = registry.container();
  registry.register('store:main', Store);
  registry.register('store:secondary', OtherStore);
  registry.register('model:user', User);
  registry.register('model:post', Post);
  injecting one fullName on another type
  registry.factoryInjection('model', 'store', 'store:main');
  injecting one fullName on another fullName
  registry.factoryInjection('model:post', 'secondaryStore', 'store:secondary');
  var UserFactory = container.lookupFactory('model:user');
  var PostFactory = container.lookupFactory('model:post');
  var store = container.lookup('store:main');
  UserFactory.store instanceof Store; //=> true
  UserFactory.secondaryStore instanceof OtherStore; //=> false
  PostFactory.store instanceof Store; //=> true
  PostFactory.secondaryStore instanceof OtherStore; //=> true
  and both models share the same source instance
  UserFactory.store === PostFactory.store; //=> true
  ```
  @private
  @method factoryInjection
  @param {String} factoryName
  @param {String} property
  @param {String} injectionName