766 lines
24 KiB
JavaScript
Executable file
766 lines
24 KiB
JavaScript
Executable file
#!/usr/bin/env node
|
|
/* ***** BEGIN LICENSE BLOCK *****
|
|
* Distributed under the BSD license:
|
|
*
|
|
* Copyright (c) 2010, Ajax.org B.V.
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* * Neither the name of Ajax.org B.V. nor the
|
|
* names of its contributors may be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL AJAX.ORG B.V. BE LIABLE FOR ANY
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
* ***** END LICENSE BLOCK ***** */
|
|
|
|
var fs = require("fs");
|
|
var path = require("path");
|
|
if (!fs.existsSync)
|
|
fs.existsSync = path.existsSync;
|
|
else
|
|
path.existsSync = fs.existsSync;
|
|
var copy = require('dryice').copy;
|
|
|
|
var ACE_HOME = __dirname;
|
|
var BUILD_DIR = ACE_HOME + "/build";
|
|
|
|
function main(args) {
|
|
if (args.indexOf("updateModes") !== -1) {
|
|
return updateModes();
|
|
}
|
|
var type = "minimal";
|
|
args = args.map(function(x) {
|
|
if (x[0] == "-" && x[1] != "-")
|
|
return "-" + x;
|
|
return x;
|
|
});
|
|
|
|
if (args[2] && (args[2][0] != "-" || args[2].indexOf("h") != -1))
|
|
type = args[2];
|
|
|
|
var i = args.indexOf("--target");
|
|
if (i != -1 && args[i+1])
|
|
BUILD_DIR = args[i+1];
|
|
|
|
if (args.indexOf("--h") == -1) {
|
|
if (type == "minimal") {
|
|
buildAce({
|
|
compress: args.indexOf("--m") != -1,
|
|
noconflict: args.indexOf("--nc") != -1,
|
|
shrinkwrap: args.indexOf("--s") != -1
|
|
});
|
|
} else if (type == "normal") {
|
|
ace();
|
|
} else if (type == "demo") {
|
|
demo();
|
|
} else if (type == "bm") {
|
|
bookmarklet();
|
|
} else if (type == "full") {
|
|
demo(ace());
|
|
bookmarklet();
|
|
} else if (type == "highlighter") {
|
|
var project = buildAce({
|
|
coreOnly: true,
|
|
exportModule: "ace/ext/static_highlight",
|
|
requires: ["ace/ext/static_highlight", "ace/theme/textmate"],
|
|
readFilters: [copy.filter.moduleDefines, function(a) {
|
|
console.log(a.substring(0, 2500))
|
|
return a
|
|
}]
|
|
})
|
|
copy({
|
|
source: project.result,
|
|
filter: getWriteFilters(project.options, "main"),
|
|
dest: BUILD_DIR + "/static_highlight.js"
|
|
});
|
|
}
|
|
}
|
|
|
|
console.log("--- Ace Dryice Build Tool ---");
|
|
console.log("");
|
|
console.log("Options:");
|
|
console.log(" minimal Places necessary Ace files out in build dir; uses configuration flags below [default]");
|
|
console.log(" normal Runs four Ace builds--minimal, minimal-noconflict, minimal-min, and minimal-noconflict-min");
|
|
console.log(" demo Runs demo build of Ace");
|
|
console.log(" bm Runs bookmarklet build of Ace");
|
|
console.log(" full all of above");
|
|
console.log(" highlighter ");
|
|
console.log("args:");
|
|
console.log(" --target ./path path to build folder");
|
|
console.log("flags:");
|
|
console.log(" --h print this help");
|
|
console.log(" --m minify");
|
|
console.log(" --nc namespace require");
|
|
console.log(" --s shrinkwrap (combines all output files into one)");
|
|
console.log("");
|
|
if (BUILD_DIR)
|
|
console.log(" output generated in " + type + __dirname + "/" + BUILD_DIR)
|
|
}
|
|
|
|
function bookmarklet() {
|
|
var targetDir = BUILD_DIR + "/textarea";
|
|
copy({
|
|
source: "build_support/editor_textarea.html",
|
|
dest: targetDir + '/editor.html'
|
|
});
|
|
copy({
|
|
source: "build_support/style.css",
|
|
dest: targetDir + '/style.css'
|
|
});
|
|
|
|
buildAce({
|
|
targetDir: targetDir + "/src",
|
|
ns: "__ace_shadowed__",
|
|
exportModule: "ace/ext/textarea",
|
|
compress: false,
|
|
noconflict: true,
|
|
suffix: "",
|
|
name: "ace-bookmarklet",
|
|
workers: [],
|
|
keybindings: []
|
|
});
|
|
}
|
|
|
|
function ace() {
|
|
console.log('# ace ---------');
|
|
|
|
// uncompressed
|
|
var project = buildAce({
|
|
compress: false,
|
|
noconflict: false
|
|
});
|
|
buildAce({
|
|
compress: false,
|
|
noconflict: true
|
|
});
|
|
|
|
// compressed
|
|
buildAce({
|
|
compress: true,
|
|
noconflict: false
|
|
});
|
|
buildAce({
|
|
compress: true,
|
|
noconflict: true
|
|
});
|
|
|
|
console.log('# ace License | Readme | Changelog ---------');
|
|
|
|
copy({
|
|
source: ACE_HOME + "/build_support/editor.html",
|
|
dest: BUILD_DIR + "/editor.html"
|
|
});
|
|
copy({
|
|
source: ACE_HOME + "/LICENSE",
|
|
dest: BUILD_DIR + "/LICENSE"
|
|
});
|
|
copy({
|
|
source: ACE_HOME + "/ChangeLog.txt",
|
|
dest: BUILD_DIR + "/ChangeLog.txt"
|
|
});
|
|
|
|
return project;
|
|
}
|
|
|
|
function demo(project) {
|
|
project = project || buildAce({
|
|
compress: false,
|
|
noconflict: false,
|
|
coreOnly: true
|
|
});
|
|
console.log('# kitchen sink ---------');
|
|
|
|
var version, ref;
|
|
try {
|
|
version = JSON.parse(fs.readFileSync(ACE_HOME + "/package.json")).version;
|
|
ref = fs.readFileSync(ACE_HOME + "/.git-ref").toString();
|
|
} catch(e) {
|
|
ref = "";
|
|
version = "";
|
|
}
|
|
|
|
function changeComments(data) {
|
|
return (data
|
|
.replace(/<!\-\-DEVEL[\d\D]*?DEVEL\-\->/g, "")
|
|
.replace(/PACKAGE\-\->|<!\-\-PACKAGE/g, "")
|
|
.replace(/\/\*DEVEL[\d\D]*?DEVEL\*\//g, "")
|
|
.replace(/PACKAGE\*\/|\/\*PACKAGE/g, "")
|
|
.replace("%version%", version)
|
|
.replace("%commit%", ref)
|
|
);
|
|
};
|
|
|
|
function fixDocPaths(data) {
|
|
return data.replace(/"(demo|build)\//g, "\"");
|
|
}
|
|
|
|
copy({
|
|
source: ACE_HOME + "/kitchen-sink.html",
|
|
dest: BUILD_DIR + "/kitchen-sink.html",
|
|
filter: [changeComments, fixDocPaths]
|
|
});
|
|
|
|
copy({
|
|
source: ACE_HOME + "/demo/kitchen-sink/styles.css",
|
|
dest: BUILD_DIR + "/kitchen-sink/styles.css",
|
|
filter: [ changeComments ]
|
|
});
|
|
|
|
fs.readdirSync(ACE_HOME +"/demo/kitchen-sink/docs/").forEach(function(x) {
|
|
copy({
|
|
source: ACE_HOME +"/demo/kitchen-sink/docs/" + x,
|
|
dest: BUILD_DIR + "/kitchen-sink/docs/" + x
|
|
});
|
|
});
|
|
|
|
var demo = copy.createDataObject();
|
|
|
|
project.assumeAllFilesLoaded();
|
|
copy({
|
|
source: [{
|
|
project: cloneProject(project),
|
|
require: [ "kitchen-sink/demo" ]
|
|
}],
|
|
filter: getWriteFilters({filters:[fixDocPaths]}, "demo"),
|
|
dest: demo
|
|
});
|
|
|
|
copy({
|
|
source: demo,
|
|
dest: BUILD_DIR + "/kitchen-sink/demo.js",
|
|
});
|
|
|
|
copyFileSync(ACE_HOME + "/demo/kitchen-sink/logo.png", BUILD_DIR + "/kitchen-sink/logo.png");
|
|
|
|
fs.readdirSync(ACE_HOME + "/demo/").forEach(function(x) {
|
|
if (/\s|requirejs/.test(x) || !/\.(js|html)$/.test(x))
|
|
return;
|
|
copy({
|
|
source: ACE_HOME +"/demo/" + x,
|
|
dest: BUILD_DIR + "/demo/" + x,
|
|
filter: [function(source) {
|
|
if (/\.(js)$/.test(x))
|
|
return source;
|
|
var removeRequireJS
|
|
source = source.replace(/<script src="kitchen-sink\/require.js"[\s\S]+?require\(\[([^\]]+).*/, function(e, m){
|
|
removeRequireJS = true;
|
|
var scripts = m.split(/,\s*/);
|
|
var result = [];
|
|
function comment(str) {result.push("<!-- " + str + " -->")};
|
|
function script(str) {result.push('<script src="../src/' + str + '.js"></script>')}
|
|
scripts.forEach(function(s) {
|
|
s = s.replace(/"/g, "");
|
|
if (s == "ace/ace") {
|
|
comment("load ace")
|
|
script("ace")
|
|
} else {
|
|
var extName = s.match(/[^/]*$/)[0];
|
|
comment("load ace " + extName + " extension");
|
|
script("ext-" + extName);
|
|
}
|
|
});
|
|
result.push("<script>")
|
|
return result.join("\n");
|
|
});
|
|
if (removeRequireJS)
|
|
source = source.replace(/\s*\}\);?\s*(<\/script>)/, "\n$1");
|
|
source = source.replace(/"\.\.\/build\//g, function(e) {
|
|
console.log(e); return '"../';
|
|
});
|
|
return source;
|
|
}]
|
|
});
|
|
});
|
|
}
|
|
|
|
function jsFileList(path, filter) {
|
|
path = ACE_HOME + "/" + path;
|
|
if (!filter)
|
|
filter = /_test/;
|
|
|
|
return fs.readdirSync(path).map(function(x) {
|
|
if (x.slice(-3) == ".js" && !filter.test(x) && !/\s/.test(x))
|
|
return x.slice(0, -3);
|
|
}).filter(function(x){ return !!x });
|
|
}
|
|
|
|
function workers(path) {
|
|
return jsFileList(path).map(function(x) {
|
|
if (x.slice(-7) == "_worker")
|
|
return x.slice(0, -7);
|
|
}).filter(function(x) { return !!x; });
|
|
}
|
|
function modeList() {
|
|
return jsFileList("lib/ace/mode", /_highlight_rules|_test|_worker|xml_util|_outdent|behaviour|completions/)
|
|
}
|
|
|
|
function addSuffix(options) {
|
|
if (options.suffix == null) {
|
|
options.suffix = "";
|
|
if (options.compress)
|
|
options.suffix += "-min";
|
|
if (options.noconflict)
|
|
options.suffix += "-noconflict";
|
|
}
|
|
}
|
|
|
|
function getWriteFilters(options, projectType, main) {
|
|
var filters = [
|
|
copy.filter.moduleDefines,
|
|
removeUseStrict,
|
|
removeLicenceComments,
|
|
inlineTextModules
|
|
];
|
|
|
|
if (options.filters)
|
|
filters = filters.concat(options.filters);
|
|
|
|
if (options.noconflict)
|
|
filters.push(namespace(options.ns));
|
|
|
|
if (options.exportModule && projectType == "main" || projectType == "ext") {
|
|
filters.push(exportAce(options.ns, options.exportModule,
|
|
options.noconflict ? options.ns : "", projectType == "ext" && main));
|
|
}
|
|
|
|
if (options.compress)
|
|
filters.push(copy.filter.uglifyjs);
|
|
|
|
// copy.filter.uglifyjs.options.ascii_only = true; doesn't work with some uglify.js versions
|
|
filters.push(function(text) {
|
|
var text = text.replace(/[\x00-\x08\x0b\x0c\x0e\x19\x80-\uffff]/g, function(c) {
|
|
c = c.charCodeAt(0).toString(16);
|
|
if (c.length == 1)
|
|
return "\\x0" + c;
|
|
if (c.length == 2)
|
|
return "\\x" + c;
|
|
if (c.length == 3)
|
|
return "\\u0" + c;
|
|
return "\\u" + c;
|
|
});
|
|
return text;
|
|
});
|
|
|
|
return filters;
|
|
}
|
|
|
|
var buildAce = function(options) {
|
|
var aceProject = {
|
|
roots: [ACE_HOME + '/lib', ACE_HOME + '/demo'],
|
|
textPluginPattern: /^ace\/requirejs\/text!/
|
|
};
|
|
|
|
var defaults = {
|
|
targetDir: BUILD_DIR + "/src",
|
|
ns: "ace",
|
|
exportModule: "ace/ace",
|
|
requires: null,
|
|
compress: false,
|
|
noconflict: false,
|
|
suffix: null,
|
|
name: "ace",
|
|
modes: modeList(),
|
|
themes: jsFileList("lib/ace/theme"),
|
|
extensions: jsFileList("lib/ace/ext"),
|
|
workers: workers("lib/ace/mode"),
|
|
keybindings: ["vim", "emacs"],
|
|
readFilters: [copy.filter.moduleDefines]
|
|
};
|
|
|
|
for(var key in defaults)
|
|
if (!options.hasOwnProperty(key))
|
|
options[key] = defaults[key];
|
|
|
|
addSuffix(options);
|
|
|
|
if (!options.requires)
|
|
options.requires = [options.exportModule];
|
|
|
|
var targetDir = options.targetDir + options.suffix;
|
|
var name = options.name;
|
|
|
|
var project = copy.createCommonJsProject(aceProject);
|
|
project.options = options;
|
|
var ace = copy.createDataObject();
|
|
copy({
|
|
source: [ACE_HOME + "/build_support/mini_require.js"],
|
|
dest: ace
|
|
});
|
|
copy({
|
|
source: [{
|
|
project: project,
|
|
require: options.requires
|
|
}],
|
|
filter: options.readFilters,
|
|
dest: ace
|
|
});
|
|
|
|
if (options.coreOnly) {
|
|
project.result = ace;
|
|
return project;
|
|
}
|
|
copy({
|
|
source: ace,
|
|
filter: getWriteFilters(options, "main"),
|
|
dest: targetDir + '/' + name + ".js"
|
|
});
|
|
|
|
console.log('# ace extensions ---------');
|
|
|
|
project.assumeAllFilesLoaded();
|
|
options.extensions.forEach(function(ext) {
|
|
console.log("extensions " + ext);
|
|
copy({
|
|
source: [{
|
|
project: cloneProject(project),
|
|
require: [ 'ace/ext/' + ext ]
|
|
}],
|
|
filter: getWriteFilters(options, "ext", 'ace/ext/' + ext),
|
|
dest: targetDir + "/ext-" + ext + ".js"
|
|
});
|
|
});
|
|
|
|
console.log('# ace modes ---------');
|
|
|
|
project.assumeAllFilesLoaded();
|
|
options.modes.forEach(function(mode) {
|
|
console.log("mode " + mode);
|
|
addSnippetFile(mode, project, targetDir, options);
|
|
copy({
|
|
source: [{
|
|
project: cloneProject(project),
|
|
require: [ 'ace/mode/' + mode ]
|
|
}],
|
|
filter: getWriteFilters(options, "mode"),
|
|
dest: targetDir + "/mode-" + mode + ".js"
|
|
});
|
|
});
|
|
|
|
console.log('# ace themes ---------');
|
|
|
|
project.assumeAllFilesLoaded();
|
|
delete project.ignoredModules["ace/theme/textmate"];
|
|
delete project.ignoredModules["ace/requirejs/text!ace/theme/textmate.css"];
|
|
|
|
options.themes.forEach(function(theme) {
|
|
console.log("theme " + theme);
|
|
copy({
|
|
source: [{
|
|
project: cloneProject(project),
|
|
require: ["ace/theme/" + theme]
|
|
}],
|
|
filter: getWriteFilters(options, "theme"),
|
|
dest: targetDir + "/theme-" + theme.replace("_theme", "") + ".js"
|
|
});
|
|
});
|
|
|
|
// generateThemesModule(options.themes);
|
|
|
|
console.log('# ace key bindings ---------');
|
|
|
|
// copy key bindings
|
|
project.assumeAllFilesLoaded();
|
|
options.keybindings.forEach(function(keybinding) {
|
|
copy({
|
|
source: [{
|
|
project: cloneProject(project),
|
|
require: [ 'ace/keyboard/' + keybinding ]
|
|
}],
|
|
filter: getWriteFilters(options, "keybinding"),
|
|
dest: targetDir + "/keybinding-" + keybinding + ".js"
|
|
});
|
|
});
|
|
|
|
console.log('# ace worker ---------');
|
|
|
|
options.workers.forEach(function(mode) {
|
|
console.log("worker for " + mode + " mode");
|
|
var worker = copy.createDataObject();
|
|
var workerProject = copy.createCommonJsProject({
|
|
roots: [ ACE_HOME + '/lib' ],
|
|
textPluginPattern: /^ace\/requirejs\/text!/
|
|
});
|
|
copy({
|
|
source: [{
|
|
project: workerProject,
|
|
require: [
|
|
'ace/worker/worker',
|
|
'ace/mode/' + mode + '_worker'
|
|
]
|
|
}],
|
|
filter: getWriteFilters(options, "worker"),
|
|
dest: worker
|
|
});
|
|
copy({
|
|
source: [
|
|
worker
|
|
],
|
|
filter: options.compress ? [copy.filter.uglifyjs] : [],
|
|
dest: targetDir + "/worker-" + mode + ".js"
|
|
});
|
|
});
|
|
|
|
|
|
if (options.shrinkwrap) {
|
|
console.log('# combining files into one ---------');
|
|
copy({
|
|
source: { root:targetDir, exclude:/(^|\\|\/)worker\-[^\\\/]*\.js$/ },
|
|
dest: BUILD_DIR + '/ace-min.js'
|
|
});
|
|
}
|
|
|
|
return project;
|
|
};
|
|
|
|
// silence annoying messages from dryice
|
|
var buildAce = function(fn) {
|
|
return function() {
|
|
var log = console.log
|
|
console.log = function() {
|
|
if (typeof arguments[0] == "string" && /Ignoring requirement/.test(arguments[0]))
|
|
return;
|
|
log.apply(console, arguments);
|
|
}
|
|
var ret = fn.apply(null, arguments);
|
|
console.log = log;
|
|
return ret;
|
|
}
|
|
}(buildAce);
|
|
|
|
var addSnippetFile = function(modeName, project, targetDir, options) {
|
|
var snippetFilePath = ACE_HOME + "/lib/ace/snippets/" + modeName;
|
|
if (!fs.existsSync(snippetFilePath + ".js")) {
|
|
copy({
|
|
source: ACE_HOME + "/tool/snippets.tmpl.js",
|
|
dest: snippetFilePath + ".js",
|
|
filter: [
|
|
function(t) {return t.replace(/%modeName%/g, modeName);}
|
|
]
|
|
});
|
|
}
|
|
if (!fs.existsSync(snippetFilePath + ".snippets")) {
|
|
fs.writeFileSync(snippetFilePath + ".snippets", "")
|
|
}
|
|
copy({
|
|
source: [{
|
|
project: cloneProject(project),
|
|
require: [ 'ace/snippets/' + modeName ]
|
|
}],
|
|
filter: getWriteFilters(options, "mode"),
|
|
dest: targetDir + "/snippets/" + modeName + ".js"
|
|
});
|
|
}
|
|
|
|
var textModules = {}
|
|
var detectTextModules = function(input, source) {
|
|
if (!source)
|
|
throw new Error('Missing filename for text module');
|
|
|
|
if (typeof input !== 'string')
|
|
input = input.toString();
|
|
|
|
var module = source.isLocation ? source.path : source;
|
|
|
|
input = input.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
|
|
if (/\.css$/.test(module)) {
|
|
// remove unnecessary whitespace from css
|
|
input = input.replace(/\n\s+/g, "\n");
|
|
input = '"' + input.replace(/\r?\n/g, '\\\n') + '"';
|
|
} else {
|
|
// but don't break other files!
|
|
input = '"' + input.replace(/\r?\n/g, '\\n\\\n') + '"';
|
|
}
|
|
textModules[module] = input;
|
|
|
|
return "";
|
|
};
|
|
detectTextModules.onRead = true;
|
|
copy.filter.addDefines = detectTextModules;
|
|
|
|
function inlineTextModules(text) {
|
|
var deps = [];
|
|
return text.replace(/, *['"]ace\/requirejs\/text!(.*?)['"]| require\(['"](?:ace|[.\/]+)\/requirejs\/text!(.*?)['"]\)/g, function(_, dep, call) {
|
|
if (dep) {
|
|
deps.push(dep);
|
|
return "";
|
|
} else if (call) {
|
|
deps.some(function(d) {
|
|
if (d.split("/").pop() == call.split("/").pop()) {
|
|
dep = d;
|
|
return true;
|
|
}
|
|
});
|
|
|
|
call = textModules[dep];
|
|
if (call)
|
|
return " " + call;
|
|
}
|
|
});
|
|
}
|
|
|
|
var CommonJsProject = copy.createCommonJsProject({roots:[]}).constructor;
|
|
CommonJsProject.prototype.getCurrentModules = function() {
|
|
function isDep(child, parent) {
|
|
if (!modules[parent])
|
|
return false;
|
|
var deps = modules[parent].deps;
|
|
if (deps[child]) return true;
|
|
return Object.keys(deps).some(function(x) {
|
|
return isDep(child, x)
|
|
});
|
|
}
|
|
var depMap = {}, modules = this.currentModules;
|
|
return Object.keys(this.currentModules).map(function(moduleName) {
|
|
module = modules[moduleName];
|
|
module.id = moduleName;
|
|
module.isSpecial = !/define\(\'[^']*',/.test(module.source);
|
|
return module;
|
|
}).sort(function(a, b) {
|
|
if (a.isSpecial) return -1;
|
|
if (b.isSpecial) return 1;
|
|
if (isDep(a.id, b.id)) return -1;
|
|
if (isDep(b.id, a.id)) return 1;
|
|
return Object.keys(a.deps).length - Object.keys(b.deps).length || a.id.localeCompare(b.id)
|
|
});
|
|
};
|
|
|
|
// TODO: replace with project.clone once it is fixed in dryice
|
|
function cloneProject(project) {
|
|
var clone = copy.createCommonJsProject({
|
|
roots: project.roots,
|
|
ignores: project.ignoreRequires,
|
|
textPluginPattern: project.textPluginPattern
|
|
});
|
|
|
|
Object.keys(project.currentModules).forEach(function(module) {
|
|
clone.currentModules[module] = project.currentModules[module];
|
|
});
|
|
|
|
Object.keys(project.ignoredModules).forEach(function(module) {
|
|
clone.ignoredModules[module] = project.ignoredModules[module];
|
|
});
|
|
|
|
return clone;
|
|
}
|
|
|
|
function copyFileSync(srcFile, destFile) {
|
|
var BUF_LENGTH = 64*1024;
|
|
var buf = new Buffer(BUF_LENGTH);
|
|
var bytesRead = BUF_LENGTH;
|
|
var pos = 0;
|
|
var fdr = fs.openSync(srcFile, 'r');
|
|
var fdw = fs.openSync(destFile, 'w');
|
|
|
|
while (bytesRead === BUF_LENGTH) {
|
|
bytesRead = fs.readSync(fdr, buf, 0, BUF_LENGTH, pos);
|
|
fs.writeSync(fdw, buf, 0, bytesRead);
|
|
pos += bytesRead;
|
|
}
|
|
|
|
fs.closeSync(fdr);
|
|
fs.closeSync(fdw);
|
|
}
|
|
|
|
function quoteString(str) {
|
|
return '"' + str.replace(/\\/, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\\n") + '"';
|
|
}
|
|
|
|
function removeUseStrict(text) {
|
|
return text.replace(/['"]use strict['"];/g, "");
|
|
}
|
|
|
|
function removeLicenceComments(text) {
|
|
return text.replace(/(?:(;)|\n)\s*\/\*[\d\D]*?\*\/|\n\s*\/\/.*/g, "$1");
|
|
}
|
|
|
|
function namespace(ns) {
|
|
return function(text) {
|
|
text = text
|
|
.toString()
|
|
.replace('var ACE_NAMESPACE = "";', 'var ACE_NAMESPACE = "' + ns +'";')
|
|
.replace(/(\.define)|\bdefine\(/g, function(_, a) {
|
|
return a || ns + ".define("
|
|
});
|
|
|
|
return text;
|
|
};
|
|
}
|
|
|
|
function exportAce(ns, module, requireBase, extModule) {
|
|
requireBase = requireBase || "window";
|
|
module = module || "ace/ace";
|
|
return function(text) {
|
|
var template = function() {
|
|
(function() {
|
|
REQUIRE_NS.require(["MODULE"], function(a) {
|
|
a && a.config.init(true);
|
|
if (!window.NS)
|
|
window.NS = a;
|
|
for (var key in a) if (a.hasOwnProperty(key))
|
|
NS[key] = a[key];
|
|
});
|
|
})();
|
|
};
|
|
|
|
if (extModule) {
|
|
module = extModule;
|
|
template = function() {
|
|
(function() {
|
|
REQUIRE_NS.require(["MODULE"], function() {});
|
|
})();
|
|
};
|
|
}
|
|
|
|
text = text.replace(/function init\(packaged\) {/, "init(true);$&\n");
|
|
|
|
return (text + ";" + template
|
|
.toString()
|
|
.replace(/MODULE/g, module)
|
|
.replace(/REQUIRE_NS/g, requireBase)
|
|
.replace(/NS/g, ns)
|
|
.slice(13, -1)
|
|
);
|
|
};
|
|
}
|
|
|
|
function updateModes() {
|
|
modeList().forEach(function(m) {
|
|
var filepath = __dirname + "/lib/ace/mode/" + m + ".js"
|
|
var source = fs.readFileSync(filepath, "utf8");
|
|
if (!/this.\$id\s*=\s*"/.test(source))
|
|
source = source.replace(/\n([ \t]*)(\}\).call\(\w*Mode.prototype\))/, '\n$1 this.$id = "";\n$1$2');
|
|
|
|
source = source.replace(/(this.\$id\s*=\s*)"[^"]*"/, '$1"ace/mode/' + m + '"');
|
|
fs.writeFileSync(filepath, source, "utf8")
|
|
})
|
|
}
|
|
|
|
function generateThemesModule(themes) {
|
|
var themelist = [
|
|
'define(function(require, exports, module) {',
|
|
'\n\nmodule.exports.themes = ' + JSON.stringify(themes, null, ' '),
|
|
';\n\n});'
|
|
].join('');
|
|
fs.writeFileSync(__dirname + '/lib/ace/ext/themelist_utils/themes.js', themelist, 'utf8');
|
|
}
|
|
|
|
if (!module.parent)
|
|
main(process.argv);
|
|
else
|
|
exports.buildAce = buildAce;
|