%PDF-
%PDF-
Mini Shell
Mini Shell
/*
* @Author : l.w.kampfer@gmail.com
*/
(function() {
/**
* @define {boolean} Overridden to true by the compiler when --closure_pass
* or --mark_as_compiled is specified.
*/
var COMPILED = false;
/**
* @define {object} 定义命名空间kampfer。
* 所有需要公开的属性和方法都被将绑定在kampfer上。最后将检查全局变量，
* 并把kampfer绑定到全局变量上
*/
var kampfer = {};
/**
* @define {object} 保存一个对全局对象的引用。
* 一般情况下global指向window对象。
*/
kampfer.global = this;
/**
* @define {string} base.js的路径
* 在异步加载js文件的时候,也会作为初始目录使用
*/
kampfer.basePath = '';
/**
* 用于保存所有被隐式声明的命名空间，此对象的属性名就是命名空间的名字
* @type {object}
*/
kampfer.implicitNamespaces = {};
/**
* 判断给定的命名空间是否已经初始化。判断条件如下：
* 1.命名空间没有被隐性的声明（不在_implicitNamespaces中）
* 2.命名空间非空
* 以上两个条件同时满足时，说明命名空间已被注册，方法返回true
* @param ns{string} 命名空间的名字
* @return {boolean} 已经被注册过，则为true；反之为false
* @private
*/
kampfer.isProvided = function(name) {
return !kampfer.implicitNamespaces[name] && !!kampfer.getPropertyByName(name);
};
/**
* 通过名字找到指定对象上的某个属性的值
* @param name{string} 命名空间的名字
* @param obj{object} 目标对象，将在这个对象上查找给定的名字空间。
* @return {*}
*/
kampfer.getPropertyByName = function( name, obj ) {
var namespace = name.split('.'),
cur = obj || kampfer;
for( var part; (part = namespace.shift()); ) {
if( kampfer.isDefAndNotNull( cur[part] ) ) {
cur = cur[part];
} else {
return null;
}
}
return cur;
};
/**
* 根据给定的名字空间创建一个对象结构（object structure），
* 保证已经存在的名字空间不会被覆盖重写。
* @param name{string} 命名空间名字
* @param value{*} 暴露在名字空间最后的对象
* @param objectToExportTo{object} 命名空间的宿主对象。默认为kampfer.global
*/
kampfer.exportPath = function(name, value, objectToExportTo) {
var cur = objectToExportTo || kampfer.global,
namespace = name.split('.');
for( var part; (part = namespace.shift()); ) {
if( !namespace.length && kampfer.isDefAndNotNull(value) ) {
cur[part] = value;
} else if( cur[part] ) {
cur = cur[part];
} else {
cur = cur[part] = {};
}
}
};
/**
* 声明命名空间。此方法将kampfer作为根节点，所有新声明的命名空间都将被绑定在kampfer上。
* 构造新命名空间的过程中可能会产生隐性的命名空间，provide方法将会将隐性的名字空间保存在
* implicitNamespaces属性中。打包程序将通过扫描provide，在deps文件中生成一条关于本文件
* 依赖关系的记录。
* @param name{string} 命名空间的名字。
*/
kampfer.provide = function(name) {
//if(!COMPILED) {
if( kampfer.isProvided(name) ) {
throw Error('Namespace "' + name + '" already declared.');
}
delete kampfer.implicitNamespaces[name];
var namespace = name;
while( (namespace = namespace.substring( 0, namespace.lastIndexOf('.') )) ) {
if( kampfer.getPropertyByName(namespace) ) {
break;
} else {
kampfer.implicitNamespaces[namespace] = true;
}
}
//}
kampfer.exportPath(name, null, kampfer);
};
/**
* 定义文件所依赖的模块。打包程序将通过扫描require，在deps文件中生成一条关于本文件
* 依赖关系的记录。合并程序也会扫描require来合并文件。
* @TODO 将来会配合后台，在服务器端读取require来合并js文件。
* @param name{string} 依赖的模块名
*/
kampfer.require = function(name) {
if( !COMPILED ) {
if ( !name || kampfer.isProvided(name) ) {
return;
}
var path = kampfer._getPathFromDeps(name);
if (path) {
kampfer._included[path] = true;
kampfer._writeScripts();
}
}
};
/**
* 在kampfer上添加js文件依赖关系的记录。
* @param path{string} 文件的储存路径
* @param names{array} 文件定义的模块列表
* @param requires{array} 文件依赖的模块列表
*/
kampfer.addDependency = function( path, provides, requires ) {
if( !COMPILED ) {
var provide, require, deps;
path = path.replace(/\\/g, '/');
deps = kampfer._dependencies;
for( var i = 0; (provide = provides[i]); i++) {
deps.nameToPath[provide] = path;
if (!(path in deps.pathToNames)) {
deps.pathToNames[path] = {};
}
deps.pathToNames[path][provide] = true;
}
for( var j = 0; (require = requires[j]); j++) {
if (!(path in deps.requires)) {
deps.requires[path] = {};
}
deps.requires[path][require] = true;
}
}
};
if(!COMPILED) {
/**
* 通过模块名从kampfer保存的依赖性列表中获得真实文件路径
* @param name{string} 模块的名称
* @return {string} 模块的真实路径地址
* @private
*/
kampfer._getPathFromDeps = function(name) {
if( name in kampfer._dependencies.nameToPath ) {
return kampfer._dependencies.nameToPath[name];
} else {
return null;
}
};
/**
* 决定添加script标签方式，默认使用document.write。
* 记录已经加载的js。
* @param src{string} js的完整路径
* @private
*/
kampfer._importScript = function(src) {
var _importScript = kampfer._writeScriptTag;
if(!kampfer._dependencies.written[src] && _importScript(src)) {
kampfer._dependencies.written[src] = true;
}
};
/**
* 对依赖关系进行拓扑排序，决定js文件正确的输出顺序，并异步的加载js文件
* 详细算法：http://en.wikipedia.org/wiki/Topological_sorting
* @private
*/
kampfer._writeScripts = function() {
var scripts = [],
seenScript = {},
deps = kampfer._dependencies;
function visitNode(path) {
if( path in deps.written ) {
return;
}
// 如果已经访问过次节点
if( path in deps.visited ) {
if( !(path in seenScript) ) {
seenScript[path] = true;
scripts.push(path);
}
return;
}
deps.visited[path] = true;
if (path in deps.requires) {
for (var requireName in deps.requires[path]) {
// 如果依赖的模块已经注册（假设它已经被正确的加载），那么将不会再加载该模块。
if (!kampfer.isProvided(requireName)) {
if (requireName in deps.nameToPath) {
visitNode(deps.nameToPath[requireName]);
} else {
throw Error('Undefined nameToPath for ' + requireName ' in ' + path);
}
}
}
}
if (!(path in seenScript)) {
seenScript[path] = true;
scripts.push(path);
}
}
for( var path in kampfer._included ) {
if( !deps.written[path] ) {
visitNode(path);
}
}
for( var i = 0; i < scripts.length; i++ ) {
if ( scripts[i] ) {
kampfer._importScript( kampfer.basePath + scripts[i] );
} else {
throw Error('Undefined script input');
}
}
};
/**
* 使用document.write的方式输出script标签，异步的引入js
* TODO 改用标准的DOM插入方法来添加script标签，而不使用document.write方法
* @param src{string} js文件的url
* @return {boolean} 成功返回true，失败返回false
* @private
*/
kampfer._writeScriptTag = function(src) {
var doc = kampfer.global.document;
doc.write('<script type="text/javascript" src="' + src + '"></' + 'script>');
return true;
};
kampfer._findBasePath = function() {
var doc = kampfer.global.document,
scripts = doc.getElementsByTagName('script');
for (var i = scripts.length - 1; i >= 0; --i) {
var src = scripts[i].src,
qmark = src.lastIndexOf('?'),
l = (qmark === -1 ? src.length : qmark);
if (src.substr(l - 7, 7) == 'base.js') {
kampfer.basePath = src.substr(0, l - 7);
return;
}
}
};
kampfer._dependencies = {
pathToNames: {}, // 1 to many
nameToPath: {}, // 1 to 1
requires: {}, // 1 to many
visited: {}, // 避免在拓扑排序时循环访问同一个节点。访问过的节点将保存在这里
written: {} // 记录已经被加载到页面的js文件名
};
kampfer._included = {};
kampfer._findBasePath();
kampfer._importScript( kampfer.basePath + 'deps.js' );
}
kampfer.isDef = function(val) {
return val !== undefined;
};
kampfer.isDefAndNotNull = function(val) {
return val != null;
};
var _toString = Object.prototype.toString;
kampfer.type = function(value) {
return value == null ?
String(value) :
_class2type[ _toString.call(value) ] || 'object';
};
kampfer.isArray = function(val) {
return kampfer.type(val) === 'array';
};
kampfer.isObject = function(val) {
return kampfer.type(val) === 'object';
};
kampfer.isEmptyObject = function(val) {
if( kampfer.type(val) !== 'object' ) {
return;
}
for( var name in val ) {
return false;
}
return true;
};
kampfer.isWindow = function(obj) {
if(obj === this.global) {
return true;
}
return false;
};
kampfer.each = function( array, fn, thisObj ) {
for( var i = 0, len = (array && array.length) || 0; i < len; ++i ) {
if( i in array ) {
fn.call( thisObj || kampfer.global, i, array[i], array );
}
}
};
kampfer.extend = function() {
var src, target, name, len, i, deep, copyFrom, copyTo, clone;
i = 1;
len = arguments.length;
deep = false;
target = arguments[0] || {};
if( typeof target === 'boolean' ) {
deep = target;
i = 2;
target = arguments[1] || {};
}
if( i === len ) {
target = this;
--i;
}
for( ; i < len; i++ ) {
src = arguments[i];
if( src !== null ) {
for( name in src ) {
copyFrom = src[name];
copyTo = target[name];
if( copyTo === copyFrom ) {
continue;
}
if( deep && copyFrom && ( kampfer.isArray(copyFrom) ||
kampfer.isObject(copyFrom) ) ) {
if( kampfer.isArray(copyFrom) ) {
clone = copyTo && kampfer.isArray(copyTo) ? copyTo : [];
} else if( kampfer.isObject(copyFrom) ) {
clone = copyTo && kampfer.isObject(copyTo) ? copyTo : {};
}
target[name] = kampfer.extend( deep, clone, copyFrom );
} else if( copyFrom !== undefined ) {
target[name] = copyFrom;
}
}
}
}
return target;
};
kampfer.emptyFn = function() {};
kampfer.now = function() {
return +new Date();
};
kampfer.expando = 'kampfer' + kampfer.now();
var _class2type = {};
kampfer.each( "Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
_class2type[ "[object " + name + "]" ] = name.toLowerCase();
});
if( kampfer.type( kampfer.global.kampfer ) != 'undefined' ) {
kampfer._kampfer = kampfer.global.kampfer;
}
if( kampfer.type( kampfer.global.k ) != 'undefined' ) {
kampfer._k = kampfer.global.k;
}
kampfer.global.kampfer = kampfer.global.k = kampfer;
})();
Zerion Mini Shell 1.0