/**
* Copyright 2009 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS-IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
// appjetContext.cache_requestCache()._t_start = (new Date()).valueOf();
var _appjethidden_ = {};
var serverhandlers = { tasks: {} };
/*
* @overview
*
* AppJet standard library preamble.
*
* This is run at the beginning of every request, right after all
* native calls are loaded into appjetContext. This file is run
* in the same scope as the app, the global scope, which is also
* accessible from all modules.
*/
//----------------------------------------------------------------
// delete pesky rhino built-in string stuff
//----------------------------------------------------------------
(function() {
// rhino strings come with a bunch of random "html helpers"
// that we don't want
var htmlStuff = ["bold", "italics", "fixed", "strike",
"small", "big", "sub", "fontsize", "fontcolor", "link",
"anchor", "sup", "blink"];
for(var i in htmlStuff) {
delete String.prototype[htmlStuff[i]];
}
})();
//----------------------------------------------------------------
// module implementation
//----------------------------------------------------------------
(function(globalScope) {
//----------------------------------------------------------------
// Utility Functions
//----------------------------------------------------------------
function appjetContext() {
return net.appjet.oui.ExecutionContextUtils.currentContext();
}
function internalError(m) {
throw new Error("AppJet Internal Error: "+m);
}
function apiError(m) {
throw new Error("AppJet API Error: "+m);
}
function newScope() {
var o = new Object();
o.__parent__ = null;
o.__proto__ = globalScope;
return o;
}
_appjethidden_._debugMessage = function(m) {
//java.lang.System.out.println(m);
};
var debug = _appjethidden_._debugMessage;
function copySymbol(srcName, symName, src, dst, dstSymName) {
if (!src.hasOwnProperty(symName)) {
apiError("Import error: module \""+srcName+"\" does not contain the symbol \""+symName+"\".");
}
if (symName.charAt(0) == '_') {
apiError("Import error: cannot import symbol \""+symName+"\" because it is private (begins with _)");
}
debug(" | copying symbol ["+symName+"]");
dst[dstSymName || symName] = src[symName];
}
function copyPublicSymbols(src, dst) {
for (k in src) {
if (src.hasOwnProperty(k) && (k.length > 0) && (k.charAt(0) != '_')) {
copySymbol('', k, src, dst);
}
}
}
// Module import cache... hidden from other scopes.
var moduleObjects = {};
var modulesBeingLoaded = {};
/*--------------------------------------------------------------------------------
* loadModule():
* Evaluates moduleName in its own private scope, then copies its public identifiers
* into a new scope. This new scope is stored in moduleObjects[moduleName] for future use
* by import()s.
*
* If moduleName is currently being loaded (because we are in the middle of another loadModule()
* higher in the call stack), then this function does noething, on the assumption
* that moduleName will eventually be loaded anyway. Therefore, it cannot be assumed that
* moduleName is done being loaded when loadModule() returns, only that it eventually will be
* loaded when all loadModule calls return up the call stack.
*--------------------------------------------------------------------------------*/
function loadModule(moduleName) {
if (modulesBeingLoaded[moduleName]) {
// This is OK. The module will be loaded eventually.
return;
}
if (moduleObjects[moduleName]) {
return;
}
modulesBeingLoaded[moduleName] = true;
try {
debug("loadModule: "+moduleName);
var modulePrivateScope =
Packages.net.appjet.ajstdlib.ajstdlib.runModuleInNewScope(
appjetContext(), moduleName.split('.').join('/'));
if (!modulePrivateScope) {
// moduleName is not a module. This is normal, because when someone calls
// import("foo.bar"), we dont know if bar is a module or an identifier in the foo module.
delete modulesBeingLoaded[moduleName];
return;
}
// Thinking this could be useful:
// modulePrivateScope['__MODULE_NAME__'] = moduleName;
var moduleObj = newScope();
copyPublicSymbols(modulePrivateScope, moduleObj);
moduleObjects[moduleName] = moduleObj;
} finally {
delete modulesBeingLoaded[moduleName];
}
}
/*--------------------------------------------------------------------------------
* importSingleModule():
*
* Takes a single moduleName (like "etherpad.foo.bar.baz") and creates the identifier "baz"
* in dstScope, referencing the module etherpad.foo.bar.baz.
*
* This function is called one or more times by importPath(). Note that importPath() is more like
* the import() function that modules ses.
*--------------------------------------------------------------------------------*/
function importSingleModule(moduleName, dstScope) {
debug("importSingleModule: "+moduleName);
if (typeof(moduleName) != 'string') {
apiError("modules should be referred to with string, not "+typeof(moduleName));
}
var moduleObj = moduleObjects[moduleName]; // public module scope
if (!moduleObj) {
return false;
}
var importedName = moduleName;
if (importedName.indexOf(".") != -1) {
importedName = importedName.split(".").slice(-1)[0];
}
dstScope[importedName] = moduleObj;
return true;
}
/*--------------------------------------------------------------------------------
* importPath():
* takes a modulePath (like "a.b.c.{d,e,f}" or "a.b.*" or just "a.b" or "a") and
* repeatedly calls importSingleModule() as necessary, copying public symbols into dst.
*--------------------------------------------------------------------------------*/
function importPath(modulePath, dst) {
debug("importPath: "+modulePath);
// Two possibilties:
// 1. import the exact module and that's it.
//
// 2. module contains a "." and we need to import up to the
// last ., and then import a name (or set of names) from it.
// first try case 1:
var ok = importSingleModule(modulePath, dst);
if (ok) {
return;
}
if (modulePath.indexOf(".") == -1) {
throw new Error("Module does not exist: "+modulePath);
}
// now try case 2:
var tempDst = newScope();
var moduleName = modulePath.split('.').slice(0, -1).join('.');
var importedName = modulePath.split('.').slice(-1)[0];
var lastName = modulePath.split('.').slice(-2, -1)[0];
ok = importSingleModule(moduleName, tempDst);
if (!ok) {
throw new Error("Neither module exists: "+moduleName+", "+modulePath);
}
if (!tempDst[lastName]) {
internalError("import failed for "+moduleName+"|"+importedName+". This could be an appjet bug.");
}
if (importedName == "*") {
copyPublicSymbols(tempDst[lastName], dst);
} else if (importedName.match(/^\{.*\}$/)) {
importedName.slice(1,-1).split(',').forEach(function(sym) {
if (sym.match(/^.*=>.*$/)) {
copySymbol(moduleName, sym.split("=>")[0], tempDst[lastName], dst, sym.split("=>")[1]);
} else {
copySymbol(moduleName, sym, tempDst[lastName], dst);
}
});
} else {
copySymbol(moduleName, importedName, tempDst[lastName], dst);
}
}
//----------------------------------------------------------------
// scheduling
//----------------------------------------------------------------
var scheduledImports = [];
function scheduleImportPath(p, dst) {
scheduledImports.push([p, dst]);
}
function runScheduledImports() {
scheduledImports.forEach(function(x) {
importPath(x[0], x[1]);
});
}
//----------------------------------------------------------------
// The global import function
//----------------------------------------------------------------
_appjethidden_.importsAllowed = true;
globalScope['import'] = function(path1, path2, etc) {
if (!_appjethidden_.importsAllowed) {
throw Error("Imports are finished. No more imports are allowed.");
}
var dstScope = this;
if (arguments.length < 1) {
apiError("importModule() takes the name of at least one module as an argument.");
}
for (var i = 0; i < arguments.length; i++) {
var path = arguments[i];
debug("scheduling import: "+path);
scheduleImportPath(path, dstScope);
// evaluate all modules in this path.
var parts = path.split('.');
for (var j = 0; j < parts.length; j++) {
var moduleName = parts.slice(0,j+1).join('.');
loadModule(moduleName);
}
}
};
_appjethidden_.finishImports = function() {
debug("Running scheduled imports...");
runScheduledImports();
_appjethidden_.importsAllowed = false;
};
//----------------------------------------------------------------
// jimport
//----------------------------------------------------------------
function _jimportSinglePackage(pname, dstScope) {
//_appjethidden_._debugMessage("_jimportSinglePackage: "+pname);
// TODO: support "*" and "{}" syntax like scala.
var src = Packages;
var srcParent = null;
var localName = pname.split(".").pop();
var soFar = '';
pname.split(".").forEach(function(x) {
soFar += x+'.';
if (!src[x]) {
throw ('Could not find java package/class: '+soFar);
} else {
//_appjethidden_._debugMessage("descenting into "+src+"["+x+"]");
srcParent = src;
src = src[x];
}
});
if (String(src).indexOf('function') == 0) {
// TODO: checking String(src).indexOf('function') is rather brittle.
// is there a cleaner way?
// TODO: this only works on static functions... so make sure
// src[x] is a static function!
dstScope[localName] = function() {
return src.apply(srcParent, Array.prototype.slice.call(arguments));
};
} else {
// importing a regular java class
dstScope[localName] = src;
}
}
/**
* Import a java package over LiveConnect.
*/
globalScope['jimport'] = function() {
var dstScope = this;
for (var i = 0; i < arguments.length; i++) {
var pname = arguments[i].split(".").pop();
_jimportSinglePackage(arguments[i], dstScope);
}
};
//----------------------------------------------------------------
// {appjet, request, response} imported by default
//----------------------------------------------------------------
globalScope['import'].call(globalScope,
"global.appjet.appjet", "global.request.request", "global.response.response");
})(this);
