/*
* Copyright (c) 2012, Yahoo! Inc. All rights reserved.
* Copyrights licensed under the New BSD License.
* See the accompanying LICENSE file for terms.
*/
/*jslint anon:true, sloppy:true, nomen:true, stupid:true*/
/*global YUI*/
/**
* @module ResourceStoreAddon
*/
/**
* @class RSAddonUrl
* @extension ResourceStore.server
*/
YUI.add('addon-rs-url', function(Y, NAME) {
var libfs = require('fs'),
libpath = require('path'),
existsSync = libfs.existsSync || libpath.existsSync,
URL_PARTS = ['frameworkName', 'appName', 'prefix'];
function RSAddonUrl() {
RSAddonUrl.superclass.constructor.apply(this, arguments);
}
RSAddonUrl.NS = 'url';
Y.extend(RSAddonUrl, Y.Plugin.Base, {
/**
* This methods is part of Y.Plugin.Base. See documentation for that for details.
* @method initializer
* @param {object} config Configuration object as per Y.Plugin.Base
* @return {nothing}
*/
initializer: function(config) {
var appConfig,
p,
part,
defaults = {};
this.appRoot = config.appRoot;
this.mojitoRoot = config.mojitoRoot;
this.afterHostMethod('preloadResourceVersions', this.preloadResourceVersions, this);
this.onHostEvent('getMojitTypeDetails', this.onGetMojitTypeDetails, this);
appConfig = config.host.getStaticAppConfig();
this.config = appConfig.staticHandling || {};
defaults.frameworkName = 'mojito';
defaults.appName = libpath.basename(this.appRoot);
defaults.prefix = 'static';
for (p = 0; p < URL_PARTS.length; p += 1) {
part = URL_PARTS[p];
if (this.config.hasOwnProperty(part)) {
this.config[part] = this.config[part].replace(/^\//g, '').replace(/\/$/g, '');
} else {
this.config[part] = defaults[part] || '';
}
}
// FUTURE: deprecate appConfig.assumeRollups
this.assumeRollups = this.config.assumeRollups || appConfig.assumeRollups;
},
/**
* Using AOP, this is called after the ResourceStore's version.
* It computes the static handler URL for all resources in all the
* mojits (as well as the mojit itself).
* @method preloadResourceVersions
* @return {nothing}
*/
preloadResourceVersions: function() {
var store = this.get('host'),
mojits,
m,
mojit,
mojitRes,
mojitControllerRess,
packageJson,
mojitIsPublic,
ress,
r,
res,
skip;
mojits = store.listAllMojits();
mojits.push('shared');
for (m = 0; m < mojits.length; m += 1) {
mojit = mojits[m];
mojitRes = store.getResourceVersions({id: 'mojit--' + mojit})[0];
if (mojitRes) {
this._calcResourceURL(mojitRes, mojitRes);
}
// Server-only framework mojits like DaliProxy and HTMLFrameMojit
// should never have URLs associated with them. This never used
// to be an issue until we added the "assumeRollups" feature to
// preload JSON specs for specific mojits during the compile step
// (`mojito compile json`) for Livestand.
if ('shared' !== mojit && 'mojito' === mojitRes.source.pkg.name) {
mojitControllerRess = store.getResourceVersions({mojit: mojit, id: 'controller--controller'});
if (mojitControllerRess.length === 1 &&
mojitControllerRess[0].affinity.affinity === 'server') {
continue;
}
}
mojitIsPublic = false;
if (mojitRes) {
packageJson = libpath.join(mojitRes.source.fs.fullPath, 'package.json');
packageJson = store.config.readConfigJSON(packageJson);
if ('public' === (packageJson.yahoo &&
packageJson.yahoo.mojito &&
packageJson.yahoo.mojito['package'])) {
mojitIsPublic = true;
}
}
ress = store.getResourceVersions({mojit: mojit});
for (r = 0; r < ress.length; r += 1) {
res = ress[r];
skip = false;
if ('config' === res.type) {
skip = true;
}
// This is mainly used during `mojito build html5app`.
// In that situation, the user mainly doesn't want to
// publish each mojit's package.json. However, Livestand
// did need to, so this feature allowed them to opt-in.
if ('config--package' === res.id && mojitIsPublic) {
skip = false;
}
if (skip) {
continue;
}
this._calcResourceURL(res, mojitRes);
}
}
},
/**
* This is called when the ResourceStore fires this event.
* It calculates the `assetsRoot` for the mojit.
* @method onGetMojitTypeDetails
* @param {object} evt The fired event
* @return {nothing}
*/
onGetMojitTypeDetails: function(evt) {
var ress = this.get('host').getResources(evt.args.env, evt.args.ctx, {type: 'mojit', name: evt.args.mojitType});
if (!ress || !ress[0]) {
throw new Error('Unable to compute assets root for mojit "' + evt.mojit.type + '". This usually happens when trying to run a mojit that does not exist.');
}
evt.mojit.assetsRoot = ress[0].url + '/assets';
},
/**
* Calculates the static handler URL for the resource.
* @private
* @method _calcResourceURL
* @param {object} res the resource for which to calculate the URL
* @param {object} mojitRes the resource for the mojit
* @return {nothing}
*/
_calcResourceURL: function(res, mojitRes) {
var fs = res.source.fs,
relativePath = fs.fullPath.substr(fs.rootDir.length + 1),
urlParts = [],
rollupParts = [],
rollupFsPath;
// Don't clobber a URL calculated by another RS addon.
if (res.hasOwnProperty('url')) {
return;
}
if (this.config.prefix) {
urlParts.push(this.config.prefix);
rollupParts.push(this.config.prefix);
}
if ('shared' === res.mojit) {
if ('mojito' === res.source.pkg.name) {
if (this.config.frameworkName) {
urlParts.push(this.config.frameworkName);
}
} else {
if (this.config.appName) {
urlParts.push(this.config.appName);
}
}
// fw resources are also put into the app-level rollup
if (res.yui && res.yui.name) {
if (this.config.appName) {
rollupParts.push(this.config.appName);
}
rollupParts.push('rollup.client.js');
rollupFsPath = libpath.join(this.appRoot, 'rollup.client.js');
}
} else {
if ('mojit' === res.type) {
urlParts.push(res.name);
} else {
urlParts.push(res.mojit);
}
if (res.yui && res.yui.name) {
rollupParts.push(res.mojit);
rollupParts.push('rollup.client.js');
rollupFsPath = libpath.join(mojitRes.source.fs.fullPath, 'rollup.client.js');
}
}
if ('mojit' === res.type) {
if ('shared' !== res.name) {
res.url = '/' + urlParts.join('/');
}
return;
}
urlParts.push(relativePath);
if (rollupFsPath && (this.assumeRollups || existsSync(rollupFsPath))) {
res.url = '/' + rollupParts.join('/');
fs.rollupPath = rollupFsPath;
} else {
res.url = '/' + urlParts.join('/');
}
}
});
Y.namespace('mojito.addons.rs');
Y.mojito.addons.rs.url = RSAddonUrl;
}, '0.0.1', { requires: ['plugin', 'oop']});
