265 lines
8.5 KiB
JavaScript
265 lines
8.5 KiB
JavaScript
/*************************************************************************
|
|
## require - Node.js-style module loading in ScriptCraft
|
|
|
|
Node.js is a server-side javascript environment with an excellent
|
|
module loading system based on CommonJS. Modules in Node.js are really
|
|
simple. Each module is in its own javascript file and all variables
|
|
and functions within the file are private to that file/module only.
|
|
There is a very concise explanation of CommonJS modules at...
|
|
|
|
[http://wiki.commonjs.org/wiki/Modules/1.1.1.][cjsmodules]
|
|
|
|
Node.js also has good documentation on [Modules][njsmod].
|
|
|
|
If you want to export a variable or function you use the module.export
|
|
property.
|
|
|
|
For example imagine you have 3 files program.js, inc.js and math.js ...
|
|
|
|
### math.js
|
|
|
|
exports.add = function(a,b){
|
|
return a + b;
|
|
}
|
|
|
|
### inc.js
|
|
|
|
var math = require('./math');
|
|
exports.increment = function(n){
|
|
return math.add(n, 1);
|
|
}
|
|
|
|
### program.js
|
|
|
|
var inc = require('./inc').increment;
|
|
var a = 7;
|
|
a = inc(a);
|
|
print(a);
|
|
|
|
You can see from the above sample code that programs can use modules
|
|
and modules themeselves can use other modules. Modules have full
|
|
control over what functions and properties they want to provide to
|
|
others.
|
|
|
|
### Important
|
|
|
|
Although ScriptCraft now supports Node.js style modules, it does not
|
|
support node modules. Node.js and Rhino are two very different
|
|
Javascript environments. ScriptCraft uses Rhino Javascript, not
|
|
Node.js. Standard Node.js modules such as `'fs'` are not available in ScriptCraft.
|
|
|
|
Modules can be loaded using relative or absolute paths. Per the CommonJS
|
|
module specification, the '.js' suffix is optional.
|
|
|
|
[cjsmodules]: http://wiki.commonjs.org/wiki/Modules/1.1.1.
|
|
|
|
***/
|
|
(function (logger, evaluator, verbose, rootDir, modulePaths) {
|
|
|
|
if (verbose){
|
|
logger.info("Setting up 'require' module system. Root Directory: " + rootDir);
|
|
logger.info("Module paths: " + JSON.stringify(modulePaths));
|
|
}
|
|
|
|
var File = java.io.File;
|
|
|
|
var readModuleFromDirectory = function(dir){
|
|
|
|
// look for a package.json file
|
|
var pkgJsonFile = new File(dir, './package.json');
|
|
if (pkgJsonFile.exists()){
|
|
var pkg = load(pkgJsonFile);
|
|
var mainFile = new File(dir, pkg.main);
|
|
if (mainFile.exists()){
|
|
return mainFile;
|
|
} else {
|
|
return null;
|
|
}
|
|
}else{
|
|
// look for an index.js file
|
|
var indexJsFile = new File(dir + './index.js');
|
|
if (indexJsFile.exists()){
|
|
return indexJsFile;
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
};
|
|
|
|
var fileExists = function(file) {
|
|
if (file.isDirectory()){
|
|
return readModuleFromDirectory(file);
|
|
}else {
|
|
return file;
|
|
}
|
|
};
|
|
|
|
var _canonize = function(file){
|
|
return "" + file.canonicalPath.replaceAll("\\\\","/");
|
|
};
|
|
|
|
var resolveModuleToFile = function(moduleName, parentDir) {
|
|
/**********************************************************************
|
|
### module name resolution
|
|
|
|
When resolving module names to file paths, ScriptCraft uses the following rules...
|
|
|
|
1. if the module does not begin with './' or '/' then ...
|
|
|
|
1.1 Look in the 'scriptcraft/lib' directory. If it's not there then...
|
|
1.2 Look in the 'scriptcraft/modules' directory. If it's not there then
|
|
Throw an Error.
|
|
|
|
2. If the module begins with './' or '/' then ...
|
|
|
|
2.1 if the module begins with './' then it's treated as a file path. File paths are
|
|
always relative to the module from which the require() call is being made.
|
|
|
|
2.2 If the module begins with '/' then it's treated as an absolute path.
|
|
|
|
If the module does not have a '.js' suffix, and a file with the same name and a .js sufix exists,
|
|
then the file will be loaded.
|
|
|
|
3. If the module name resolves to a directory then...
|
|
|
|
3.1 look for a package.json file in the directory and load the `main` property e.g.
|
|
|
|
// package.json located in './some-library/'
|
|
{
|
|
"main": './some-lib.js',
|
|
"name": 'some-library'
|
|
}
|
|
|
|
3.2 if no package.json file exists then look for an index.js file in the directory
|
|
|
|
***/
|
|
var file = new File(moduleName);
|
|
|
|
if (file.exists()){
|
|
return fileExists(file);
|
|
}
|
|
if (moduleName.match(/^[^\.\/]/)){
|
|
// it's a module named like so ... 'events' , 'net/http'
|
|
//
|
|
var resolvedFile;
|
|
for (var i = 0;i < modulePaths.length; i++){
|
|
resolvedFile = new File(modulePaths[i] + moduleName);
|
|
if (resolvedFile.exists()){
|
|
return fileExists(resolvedFile);
|
|
}else{
|
|
// try appending a .js to the end
|
|
resolvedFile = new File(modulePaths[i] + moduleName + '.js');
|
|
if (resolvedFile.exists())
|
|
return resolvedFile;
|
|
}
|
|
if (verbose){
|
|
logger.info("Module " + moduleName + " not found in " + modulePaths[i]);
|
|
}
|
|
}
|
|
} else {
|
|
// it's of the form ./path
|
|
file = new File(parentDir, moduleName);
|
|
if (file.exists()){
|
|
return fileExists(file);
|
|
}else {
|
|
|
|
// try appending a .js to the end
|
|
var pathWithJSExt = file.canonicalPath + '.js';
|
|
file = new File( parentDir, pathWithJSExt);
|
|
if (file.exists())
|
|
return file;
|
|
else{
|
|
file = new File(pathWithJSExt);
|
|
if (file.exists())
|
|
return file;
|
|
}
|
|
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
/*
|
|
wph 20131215 Experimental
|
|
*/
|
|
var _loadedModules = {};
|
|
|
|
var _require = function(parentFile, path)
|
|
{
|
|
var file = resolveModuleToFile(path, parentFile);
|
|
if (!file){
|
|
var errMsg = '' + java.lang.String.format("require() failed to find matching file for module '%s' " +
|
|
"in working directory '%s' ", [path, parentFile.canonicalPath]);
|
|
if (! ( (''+path).match(/^\./) )){
|
|
errMsg = errMsg + ' and not found in paths ' + JSON.stringify(modulePaths);
|
|
}
|
|
logger.warning(errMsg);
|
|
throw new Error(errMsg);
|
|
}
|
|
var canonizedFilename = _canonize(file);
|
|
|
|
var moduleInfo = _loadedModules[canonizedFilename];
|
|
if (moduleInfo){
|
|
return moduleInfo;
|
|
}
|
|
if (verbose){
|
|
logger.info("loading module " + canonizedFilename);
|
|
}
|
|
var reader = new java.io.FileReader(file);
|
|
var br = new java.io.BufferedReader(reader);
|
|
var code = "";
|
|
var r = null;
|
|
while ((r = br.readLine()) !== null)
|
|
code += r + "\n";
|
|
|
|
var head = "(function(exports,module,require,__filename,__dirname){ ";
|
|
|
|
moduleInfo = {
|
|
loaded: false,
|
|
id: canonizedFilename,
|
|
exports: {},
|
|
require: _requireClosure(file.parentFile)
|
|
};
|
|
var tail = "})";
|
|
code = head + code + tail;
|
|
|
|
_loadedModules[canonizedFilename] = moduleInfo;
|
|
var compiledWrapper = null;
|
|
try {
|
|
compiledWrapper = evaluator.eval(code);
|
|
}catch (e){
|
|
logger.severe("Error:" + e + " while evaluating module " + canonizedFilename);
|
|
throw e;
|
|
}
|
|
var __dirname = "" + file.parentFile.canonicalPath;
|
|
var parameters = [
|
|
moduleInfo.exports, /* exports */
|
|
moduleInfo, /* module */
|
|
moduleInfo.require, /* require */
|
|
canonizedFilename, /* __filename */
|
|
__dirname /* __dirname */
|
|
];
|
|
try {
|
|
compiledWrapper
|
|
.apply(moduleInfo.exports, /* this */
|
|
parameters);
|
|
} catch (e){
|
|
logger.severe('Error:' + e + ' while executing module ' + canonizedFilename);
|
|
throw e;
|
|
}
|
|
if (verbose)
|
|
logger.info("loaded module " + canonizedFilename);
|
|
|
|
moduleInfo.loaded = true;
|
|
return moduleInfo;
|
|
};
|
|
|
|
var _requireClosure = function(parent){
|
|
return function(path){
|
|
var module = _require(parent, path);
|
|
return module.exports;
|
|
};
|
|
};
|
|
return _requireClosure(new java.io.File(rootDir));
|
|
})
|
|
|