resolver.js

var define, requireModule;

(function() {
  var registry = {}, seen = {};

  define = function(name, deps, callback) {
    registry[name] = { deps: deps, callback: callback };
  };

  requireModule = function(name) {
    if (seen[name]) { return seen[name]; }
    seen[name] = {};

    var mod = registry[name];

    if (!mod) {
      mod = registry[name + "/main"];

      if(!mod) {
        throw new Error("Module: '" + name + "' not found.");
      }
    }

    var deps = mod.deps,
        callback = mod.callback,
        reified = [],
        exports;

    for (var i=0, l=deps.length; i<l; i++) {
      if (deps[i] === 'exports') {
        reified.push(exports = {});
      } else {
        reified.push(requireModule(deps[i]));
      }
    }

    var value = callback.apply(this, reified);
    return seen[name] = exports || value;
  };

  define.registry = registry;
  define.seen = seen;
})();

/*
  Some examples of how names are resolved:

  ```
  '# template:post' //=> Ember.TEMPLATES['post']
  '# template:posts/byline' //=> Ember.TEMPLATES['posts/byline']
  '# template:posts.byline' //=> Ember.TEMPLATES['posts/byline']
  '# template:blogPost' //=> Ember.TEMPLATES['blogPost']
                      //   OR
                      //   Ember.TEMPLATES['blog_post']
                      //   OR
                      //   Ember.TEMPLATES['blog-post']
  '# controller:post' //=> post/controllers/main || post/controller
  '? controller:posts.index' //=> posts/controllers/index
  '? controller:blog/post' //=> blog/controllers/post
  '? controller:basic' //=> Ember.Controller
  '# route:post' //=> post/routes/main || post/route
  'route:posts.index' //=> posts/routes/index
  'route:blog/post' //=> blog/routes/post
  'route:basic' //=> Ember.Route
  '# view:post' //=> post/views/main
  'view:posts.index' //=> posts/views/index
  'view:blog/post' //=> blog/views/post
  'view:basic' //=> Ember.View
  'foo:post' //=> post/foos/main || post/foo
  '# route:index' //=> index/route (app/modules/index/route)
  ```
*/
define("resolver",
  [],
  function() {
    "use strict";
  /*
   * This module defines a subclass of Ember.DefaultResolver that adds two
   * important features:
   *
   *  1) The resolver makes the container aware of es6 modules via the AMD
   *     output. The loader's registry is consulted so that classes can be
   *     resolved directly via the module loader, without needing a manual
   *     `import`.
   *  2) is able provide injections to classes that implement `extend`
   *     (as is typical with Ember).
   */

  function classFactory(klass) {
    return {
      create: function (injections) {
        if (typeof klass.extend === "function") {
          return klass.extend(injections);
        } else {
          return klass;
        }
      }
    };
  }

  var dasherize = Ember.String.dasherize;

  function loadModule(name) {
    var module = requireModule(name);

    if (typeof module.create !== "function") {
      module = classFactory(module);
    }

    if (Ember.ENV.LOG_MODULE_RESOLVER){
      Ember.logger.info("hit", name);
    }

    return module;
  }

  function loadTemplateWithName(name){
    var tries = makeNames(null, name, null);
    return tries.reduce(function(template, name){
      return template || Ember.TEMPLATES[name];
    }, null);
  }

/*
 *
 * view:blahDiddyDooDah
 *
 * blah/views/diddy-doo-dah
 * blah-diddy/views/doo-dah
 * blah-diddy-doo/views/dah
 * blah-diddy-doo-dah/views/main
 *
 *  1. dasherize identifier
 *  2. split on '-' and map each component:
 *  3.  -> ['blah', ->'views'<-, 'diddy-doo-dah']
 *      -> ['blah-diddy', ->'views'<-, 'doo-dah']
 *      -> ['blah-diddy-doo', ->'views'<-, 'dah']
 *      Return array with pluralized type inserted at index
 *  3. add dasherized + type + main to array
 *
 *  controller:queuesDeckCard
 *  dasherized: queues-deck-card
 *  ['queues', 'deck', 'card']
 *  ['queues'], ['deck', 'card']
 *  ['queues', 'deck'], ['card']
 *  ['queues', 'deck', 'card']
 *
 */
  function makeName() {
    var args = [].slice.apply(arguments);
    var parts =
      args.map(function(part) {
        if(part instanceof Array) {
          return part.join('-');
        } else {
          return part;
        }
      });
    return _.compact(parts).join('/');
  }

  function makeNames(prefix, name, type) {
    var pluralizedType;

    if(type) {
      pluralizedType = type + "s";
    }

    var dasherized = name.dasherize();
    var parts = dasherized.split("-");

    var tries =
      parts.map(function(part, index) {
        var fulcrum = parts.length - (index + 1);
        var firstPart = _.initial(parts, fulcrum);
        var lastPart = _.rest(parts, index + 1);

        if(lastPart.length > 0) {
          return makeName(prefix, firstPart, pluralizedType, lastPart);
        } else {
          return makeName(prefix, firstPart, pluralizedType, "main");
        }
      });

    tries.push(makeName(prefix, dasherized, type));

    if (Ember.ENV.LOG_MODULE_RESOLVER){
      Debug.log("tries: ", tries);
    }

    return tries;
  }

  function loadModuleWithName(prefix, name, type){
    var names = makeNames(prefix, name, type);
    return tryModuleName(names.shift(), names);
  }

  function tryModuleName(moduleName, names) {

    if(define.registry[moduleName]) {
      return requireModule(moduleName);
    } else if(names.length > 0){
      return tryModuleName(names.shift(), names);
    }
  }

  function resolveTemplate(parsedName){
    var template = loadTemplateWithName(parsedName.name.replace(/\./, "-"));

    if(template) {
      return template;
    } else  {
      return this._super(parsedName);
    }
  }

  function resolveOther(parsedName) {
    var prefix = this.namespace.modulePrefix;
    Ember.assert("module prefix must be defined", prefix);

    var name = parsedName.fullNameWithoutType;

    var module = loadModuleWithName(prefix, name, parsedName.type);
    if(module) {

      if (typeof module.create !== "function") {
        module = classFactory(module);
      }

      return module;

    } else  {
      return this._super(parsedName);
    }
  }

  // Ember.DefaultResolver docs:
  //   https://github.com/emberjs/ember.js/blob/master/packages/ember-application/lib/system/resolver.js
  var Resolver = Ember.DefaultResolver.extend({
    resolveOther: resolveOther,
    resolveTemplate: resolveTemplate,
    generateNames: makeNames
  });

  return Resolver;
});

cool