wnpc
Version:
This README outlines the details of collaborating on this Ember application.
428 lines (335 loc) • 12.4 kB
JavaScript
(function() {
/*globals define registry requirejs */
define("ember/resolver",
[],
function() {
"use strict";
if (typeof requirejs.entries === 'undefined') {
requirejs.entries = requirejs._eak_seen;
}
/*
* 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 _moduleEntries is consulted so that classes can be
* resolved directly via the module loader, without needing a manual
* `import`.
* 2) is able to 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;
}
}
};
}
if (!Object.create && !Object.create(null).hasOwnProperty) {
throw new Error("This browser does not support Object.create(null), please polyfil with es5-sham: http://git.io/yBU2rg");
}
function makeDictionary() {
var cache = Object.create(null);
cache['_dict'] = null;
delete cache['_dict'];
return cache;
}
var underscore = Ember.String.underscore;
var classify = Ember.String.classify;
var get = Ember.get;
function parseName(fullName) {
/*jshint validthis:true */
if (fullName.parsedName === true) { return fullName; }
var nameParts = fullName.split(":"),
type = nameParts[0], fullNameWithoutType = nameParts[1],
name = fullNameWithoutType,
namespace = get(this, 'namespace'),
root = namespace;
return {
parsedName: true,
fullName: fullName,
type: type,
fullNameWithoutType: fullNameWithoutType,
name: name,
root: root,
resolveMethodName: "resolve" + classify(type)
};
}
function chooseModuleName(moduleEntries, moduleName) {
var underscoredModuleName = Ember.String.underscore(moduleName);
if (moduleName !== underscoredModuleName && moduleEntries[moduleName] && moduleEntries[underscoredModuleName]) {
throw new TypeError("Ambiguous module names: `" + moduleName + "` and `" + underscoredModuleName + "`");
}
if (moduleEntries[moduleName]) {
return moduleName;
} else if (moduleEntries[underscoredModuleName]) {
return underscoredModuleName;
} else {
// workaround for dasherized partials:
// something/something/-something => something/something/_something
var partializedModuleName = moduleName.replace(/\/-([^\/]*)$/, '/_$1');
if (moduleEntries[partializedModuleName]) {
Ember.deprecate('Modules should not contain underscores. ' +
'Attempted to lookup "'+moduleName+'" which ' +
'was not found. Please rename "'+partializedModuleName+'" '+
'to "'+moduleName+'" instead.', false);
return partializedModuleName;
} else {
return moduleName;
}
}
}
function resolveOther(parsedName) {
/*jshint validthis:true */
Ember.assert('module prefix must be defined', this.namespace.modulePrefix);
var normalizedModuleName = this.findModuleName(parsedName);
if (normalizedModuleName) {
var module = require(normalizedModuleName, null, null, true /* force sync */);
if (module && module['default']) { module = module['default']; }
if (module === undefined) {
throw new Error(" Expected to find: '" + parsedName.fullName + "' within '" + normalizedModuleName + "' but got 'undefined'. Did you forget to `export default` within '" + normalizedModuleName + "'?");
}
if (this.shouldWrapInClassFactory(module, parsedName)) {
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: resolveOther,
makeToString: function(factory, fullName) {
return '' + this.namespace.modulePrefix + '@' + fullName + ':';
},
parseName: parseName,
shouldWrapInClassFactory: function(module, parsedName){
return false;
},
init: function() {
this._super();
this._normalizeCache = makeDictionary();
},
normalize: function(fullName) {
return this._normalizeCache[fullName] || (this._normalizeCache[fullName] = this._normalize(fullName));
},
_normalize: function(fullName) {
// replace `.` with `/` in order to make nested controllers work in the following cases
// 1. `needs: ['posts/post']`
// 2. `{{render "posts/post"}}`
// 3. `this.render('posts/post')` from Route
var split = fullName.split(':');
if (split.length > 1) {
return split[0] + ':' + Ember.String.dasherize(split[1].replace(/\./g, '/'));
} else {
return fullName;
}
},
podBasedLookupWithPrefix: function(podPrefix, parsedName) {
var fullNameWithoutType = parsedName.fullNameWithoutType;
if (parsedName.type === 'template') {
fullNameWithoutType = fullNameWithoutType.replace(/^components\//, '');
}
return podPrefix + '/' + fullNameWithoutType + '/' + parsedName.type;
},
podBasedModuleName: function(parsedName) {
var podPrefix = this.namespace.podModulePrefix || this.namespace.modulePrefix;
return this.podBasedLookupWithPrefix(podPrefix, parsedName);
},
podBasedComponentsInSubdir: function(parsedName) {
var podPrefix = this.namespace.podModulePrefix || this.namespace.modulePrefix;
podPrefix = podPrefix + '/components';
if (parsedName.type === 'component' || parsedName.fullNameWithoutType.match(/^components/)) {
return this.podBasedLookupWithPrefix(podPrefix, parsedName);
}
},
mainModuleName: function(parsedName) {
// if router:main or adapter:main look for a module with just the type first
var tmpModuleName = this.prefix(parsedName) + '/' + parsedName.type;
if (parsedName.fullNameWithoutType === 'main') {
return tmpModuleName;
}
},
defaultModuleName: function(parsedName) {
return this.prefix(parsedName) + '/' + parsedName.type + 's/' + parsedName.fullNameWithoutType;
},
prefix: function(parsedName) {
var tmpPrefix = this.namespace.modulePrefix;
if (this.namespace[parsedName.type + 'Prefix']) {
tmpPrefix = this.namespace[parsedName.type + 'Prefix'];
}
return tmpPrefix;
},
/**
A listing of functions to test for moduleName's based on the provided
`parsedName`. This allows easy customization of additional module based
lookup patterns.
@property moduleNameLookupPatterns
@returns {Ember.Array}
*/
moduleNameLookupPatterns: Ember.computed(function(){
return Ember.A([
this.podBasedModuleName,
this.podBasedComponentsInSubdir,
this.mainModuleName,
this.defaultModuleName
]);
}),
findModuleName: function(parsedName, loggingDisabled){
var self = this;
var moduleName;
this.get('moduleNameLookupPatterns').find(function(item) {
var moduleEntries = requirejs.entries;
var tmpModuleName = item.call(self, parsedName);
// allow treat all dashed and all underscored as the same thing
// supports components with dashes and other stuff with underscores.
if (tmpModuleName) {
tmpModuleName = chooseModuleName(moduleEntries, tmpModuleName);
}
if (tmpModuleName && moduleEntries[tmpModuleName]) {
if (!loggingDisabled) {
self._logLookup(true, parsedName, tmpModuleName);
}
moduleName = tmpModuleName;
}
if (!loggingDisabled) {
self._logLookup(moduleName, parsedName, tmpModuleName);
}
return moduleName;
});
return moduleName;
},
// used by Ember.DefaultResolver.prototype._logLookup
lookupDescription: function(fullName) {
var parsedName = this.parseName(fullName);
var moduleName = this.findModuleName(parsedName, true);
return moduleName;
},
// only needed until 1.6.0-beta.2 can be required
_logLookup: function(found, parsedName, description) {
if (!Ember.ENV.LOG_MODULE_RESOLVER && !parsedName.root.LOG_RESOLVER) {
return;
}
var symbol, padding;
if (found) { symbol = '[✓]'; }
else { symbol = '[ ]'; }
if (parsedName.fullName.length > 60) {
padding = '.';
} else {
padding = new Array(60 - parsedName.fullName.length).join('.');
}
if (!description) {
description = this.lookupDescription(parsedName);
}
Ember.Logger.info(symbol, parsedName.fullName, padding, description);
}
});
Resolver['default'] = Resolver;
return Resolver;
});
define("resolver",
["ember/resolver"],
function (Resolver) {
Ember.deprecate('Importing/requiring Ember Resolver as "resolver" is deprecated, please use "ember/resolver" instead');
return Resolver;
});
})();
(function() {
/*globals define registry requirejs */
define("ember/container-debug-adapter",
[],
function() {
"use strict";
// Support Ember < 1.5-beta.4
// TODO: Remove this after 1.5.0 is released
if (typeof Ember.ContainerDebugAdapter === 'undefined') {
return null;
}
/*
* This module defines a subclass of Ember.ContainerDebugAdapter that adds two
* important features:
*
* 1) is able provide injections to classes that implement `extend`
* (as is typical with Ember).
*/
var ContainerDebugAdapter = Ember.ContainerDebugAdapter.extend({
/**
The container of the application being debugged.
This property will be injected
on creation.
@property container
@default null
*/
// container: null, LIVES IN PARENT
/**
The resolver instance of the application
being debugged. This property will be injected
on creation.
@property resolver
@default null
*/
// resolver: null, LIVES IN PARENT
/**
Returns true if it is possible to catalog a list of available
classes in the resolver for a given type.
@method canCatalogEntriesByType
@param {string} type The type. e.g. "model", "controller", "route"
@return {boolean} whether a list is available for this type.
*/
canCatalogEntriesByType: function(type) {
return true;
},
/**
Returns the available classes a given type.
@method catalogEntriesByType
@param {string} type The type. e.g. "model", "controller", "route"
@return {Array} An array of classes.
*/
catalogEntriesByType: function(type) {
var entries = requirejs.entries,
module,
types = Ember.A();
var makeToString = function(){
return this.shortname;
};
for(var key in entries) {
if(entries.hasOwnProperty(key) && key.indexOf(type) !== -1)
{
// // TODO return the name instead of the module itself
// module = require(key, null, null, true);
// if (module && module['default']) { module = module['default']; }
// module.shortname = key.split(type +'s/').pop();
// module.toString = makeToString;
// types.push(module);
types.push(key.split(type +'s/').pop());
}
}
return types;
}
});
ContainerDebugAdapter['default'] = ContainerDebugAdapter;
return ContainerDebugAdapter;
});
})();
(function() {
(function() {
"use strict";
Ember.Application.initializer({
name: 'container-debug-adapter',
initialize: function(container) {
var ContainerDebugAdapter = require('ember/container-debug-adapter');
var Resolver = require('ember/resolver');
container.register('container-debug-adapter:main', ContainerDebugAdapter);
}
});
}());
})();
(function() {
})();