1
0

amberc.js 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745
  1. #!/usr/bin/env node
  2. /**
  3. * This is a "compiler" for Amber code.
  4. * Create and run it the following way:
  5. * var amberc = new AmberC();
  6. * amberc.main();
  7. *
  8. * Execute the JS file without arguments or with -h / --help for help.
  9. */
  10. /**
  11. * Map the async filter function onto array and evaluate callback, once all have finished.
  12. * Taken from: http://howtonode.org/control-flow-part-iii
  13. */
  14. function map(array, filter, callback) {
  15. var counter = array.length;
  16. var new_array = [];
  17. array.forEach(function (item, index) {
  18. filter(item, function (err, result) {
  19. if (err) { callback(err); return; }
  20. new_array[index] = result;
  21. counter--;
  22. if (counter === 0) {
  23. callback(null, new_array);
  24. }
  25. });
  26. });
  27. }
  28. /**
  29. * Always evaluates the callback parameter.
  30. * Used by Combo blocks to always call the next function,
  31. * even if all of the other functions did not run.
  32. */
  33. function always_resolve(callback) {
  34. callback();
  35. }
  36. /**
  37. * Combine several async functions and evaluate callback once all of them have finished.
  38. * Taken from: http://howtonode.org/control-flow
  39. */
  40. function Combo(callback) {
  41. this.callback = callback;
  42. this.items = 0;
  43. this.results = [];
  44. }
  45. Combo.prototype = {
  46. add: function () {
  47. var self = this,
  48. id = this.items;
  49. this.items++;
  50. return function () {
  51. self.check(id, arguments);
  52. };
  53. },
  54. check: function (id, arguments) {
  55. this.results[id] = Array.prototype.slice.call(arguments);
  56. this.items--;
  57. if (this.items == 0) {
  58. this.callback.apply(this, this.results);
  59. }
  60. }
  61. };
  62. var path = require('path'),
  63. util = require('util'),
  64. fs = require('fs'),
  65. exec = require('child_process').exec;
  66. console.time('Compile Time');
  67. function AmberC() {}
  68. /**
  69. * Default values.
  70. */
  71. var createDefaults = function(){
  72. // Get Amber root directory from the location of this script so that
  73. // we can find the st and js directories etc.
  74. var amber_dir = path.join(path.dirname(process.argv[1]), '..');
  75. amber_dir = path.normalize(amber_dir);
  76. var kernel_libraries = ['boot', 'Kernel-Objects', 'Kernel-Classes', 'Kernel-Methods', 'Kernel-Collections', 'Kernel-Exceptions', 'Kernel-Transcript', 'Kernel-Announcements'];
  77. var compiler_libs = ['parser', 'Compiler', 'Compiler-Exceptions'];//, 'Compiler-Core', 'Compiler-AST', 'Compiler-IR', 'Compiler-Inlining', 'Compiler-Semantic'];
  78. return {
  79. 'amber_dir': amber_dir,
  80. 'smalltalk': {}, // the evaluated compiler will be stored in this variable (see create_compiler)
  81. 'base': kernel_libraries,
  82. 'compiler_libraries': kernel_libraries.concat(compiler_libs),
  83. 'load': [],
  84. 'init': path.join(amber_dir, 'js', 'init.js'),
  85. 'main': undefined,
  86. 'mainfile': undefined,
  87. 'closure': false,
  88. 'closure_parts': false,
  89. 'closure_full': false,
  90. 'closure_options': '',
  91. 'closure_jar': path.resolve(path.join(process.env['HOME'], 'compiler.jar')),
  92. 'suffix': '',
  93. 'loadsuffix': '',
  94. 'suffix_used': '',
  95. 'deploy': false,
  96. 'libraries': [],
  97. 'compile': [],
  98. 'compiled_categories': [],
  99. 'compiled': [],
  100. 'program': undefined
  101. };
  102. };
  103. /**
  104. * Main function for executing the compiler.
  105. */
  106. AmberC.prototype.main = function(parameters) {
  107. var options = parameters || process.argv.slice(2);
  108. if (1 > options.length) {
  109. this.usage();
  110. } else {
  111. this.defaults = createDefaults();
  112. this.handle_options(options);
  113. }
  114. };
  115. /**
  116. * Process given program options and update defaults values.
  117. * Followed by check_for_closure_compiler() and then collect_files().
  118. */
  119. AmberC.prototype.handle_options = function(optionsArray) {
  120. var stFiles = [];
  121. var jsFiles = [];
  122. var programName = [];
  123. var currentItem = optionsArray.shift();
  124. var defaults = this.defaults;
  125. while(undefined !== currentItem) {
  126. switch(currentItem) {
  127. case '-l':
  128. defaults.load.push.apply(defaults.load, optionsArray.shift().split(','));
  129. break;
  130. case '-i':
  131. defaults.init = optionsArray.shift();
  132. break;
  133. case '-m':
  134. defaults.main = optionsArray.shift();
  135. break;
  136. case '-M':
  137. defaults.mainfile = optionsArray.shift();
  138. break;
  139. case '-o':
  140. defaults.closure = true;
  141. defaults.closure_parts = true;
  142. break;
  143. case '-O':
  144. defaults.closure = true;
  145. defaults.closure_full = true;
  146. break;
  147. case '-A':
  148. defaults.closure = true;
  149. defaults.closure_options = defaults.closure_options + ' --compilation_level ADVANCED_OPTIMIZATIONS';
  150. defaults.closure_full = true;
  151. break;
  152. case '-d':
  153. defaults.deploy = true;
  154. break;
  155. case '-s':
  156. defaults.suffix = optionsArray.shift();
  157. defaults.suffix_used = defaults.suffix;
  158. break;
  159. case '-S':
  160. defaults.loadsuffix = optionsArray.shift();
  161. defaults.suffix_used = defaults.suffix;
  162. break;
  163. case '-h':
  164. case '--help':
  165. case '?':
  166. this.usage();
  167. break;
  168. default:
  169. var fileSuffix = path.extname(currentItem);
  170. switch (fileSuffix) {
  171. case '.st':
  172. stFiles.push(currentItem);
  173. break;
  174. case '.js':
  175. jsFiles.push(currentItem);
  176. break;
  177. default:
  178. // Will end up being the last non js/st argument
  179. programName.push(currentItem);
  180. break;
  181. };
  182. };
  183. currentItem = optionsArray.shift();
  184. }
  185. if(1 < programName.length) {
  186. throw new Error('More than one name for ProgramName given: ' + programName);
  187. } else {
  188. defaults.program = programName[0];
  189. }
  190. var self = this;
  191. this.check_for_closure_compiler(function(){
  192. self.collect_files(stFiles, jsFiles)
  193. });
  194. };
  195. /**
  196. * Print usage options and exit.
  197. */
  198. AmberC.prototype.usage = function() {
  199. console.log('Usage: $0 [-l lib1,lib2...] [-i init_file] [-m main_class] [-M main_file]');
  200. console.log(' [-o] [-O|-A] [-d] [-s suffix] [-S suffix] [file1 [file2 ...]] [Program]');
  201. console.log('');
  202. console.log(' amberc compiles Amber files - either separately or into a complete runnable');
  203. console.log(' program. If no .st files are listed only a linking stage is performed.');
  204. console.log(' Files listed will be handled using the following rules:');
  205. console.log('');
  206. console.log(' *.js');
  207. console.log(' Files are linked (concatenated) in listed order.');
  208. console.log(' If not found we look in $AMBER/js/');
  209. console.log('');
  210. console.log(' *.st');
  211. console.log(' Files are compiled into .js files before concatenation.');
  212. console.log(' If not found we look in $AMBER/st/.');
  213. console.log('');
  214. console.log(' NOTE: Each file is currently considered to be a fileout of a single class');
  215. console.log(' category of the same name as the file!');
  216. console.log('');
  217. console.log(' If no Program is specified each given .st file will be compiled into');
  218. console.log(' a .js file. Otherwise a <Program>.js file is linked together based on');
  219. console.log(' the options:');
  220. console.log('');
  221. console.log(' -l library1,library2');
  222. console.log(' Additionally add listed JavaScript libraries (no spaces or .js) in listed order.');
  223. console.log('');
  224. console.log(' -i init_file');
  225. console.log(' Add library initializer <init_file> instead of default $AMBER/js/init.js ');
  226. console.log('');
  227. console.log(' -m main_class');
  228. console.log(' Add at end a call to #main in class <main_class>.');
  229. console.log('');
  230. console.log(' -M main_file');
  231. console.log(' Add at end javascript file <main_file> acting as main.');
  232. console.log('');
  233. console.log(' -o');
  234. console.log(' Optimize each .js file using the Google closure compiler.');
  235. console.log(' Using Closure compiler found at ~/compiler.jar');
  236. console.log('');
  237. console.log(' -O');
  238. console.log(' Optimize final <Program>.js using the Google closure compiler.');
  239. console.log(' Using Closure compiler found at ~/compiler.jar');
  240. console.log('');
  241. console.log(' -A Same as -O but use --compilation_level ADVANCED_OPTIMIZATIONS');
  242. console.log('');
  243. console.log(' -d');
  244. console.log(' Additionally export code for deploy - stripped from source etc.');
  245. console.log(' Uses suffix ".deploy.js" in addition to any explicit given suffic using -s.');
  246. console.log('');
  247. console.log(' -s suffix');
  248. console.log(' Add <suffix> to compiled js files so that File.st is compiled into');
  249. console.log(' File.<suffix>.js.');
  250. console.log('');
  251. console.log(' -S suffix');
  252. console.log(' Use <suffix> for all libraries accessed using -L or -l. This makes it possible');
  253. console.log(' to have multiple flavors of Amber and libraries in the same place.');
  254. console.log('');
  255. console.log('');
  256. console.log(' Example invocations:');
  257. console.log('');
  258. console.log(' Just compile Kernel-Objects.st to Kernel-Objects.js:');
  259. console.log('');
  260. console.log(' amberc Kernel-Objects.st');
  261. console.log('');
  262. console.log(' Compile Hello.st to Hello.js and create complete program called');
  263. console.log(' Program.js and adding a call to class method #main in class Hello:');
  264. console.log('');
  265. console.log(' amberc -m Hello Hello.st Program');
  266. console.log('');
  267. console.log(' Compile two .st files into corresponding .js files,');
  268. console.log(' and link with specific myboot.js, myKernel.js, myinit.js');
  269. console.log(' and main.js and create complete program called Program.js:');
  270. console.log('');
  271. console.log(' amberc -M main.js myinit.js myboot.js myKernel.js Cat1.st Cat2.st Program');
  272. process.exit();
  273. };
  274. /**
  275. * Checks if the java executable exists and afterwards,
  276. * if compiler.jar exists at the path stored in defaults.closure_jar.
  277. * All closure related entries are set to false upon failure.
  278. *
  279. * callback gets called in any case.
  280. */
  281. AmberC.prototype.check_for_closure_compiler = function(callback) {
  282. var defaults = this.defaults;
  283. if (defaults.closure) {
  284. exec('which java', function(error, stdout, stderr) {
  285. // stdout contains path to java executable
  286. if (null !== error) {
  287. console.warn('java is not installed and is needed for -O, -A or -o (Closure compiler).');
  288. defaults.closure = false;
  289. defaults.closure_parts = false;
  290. defaults.closure_full = false;
  291. callback();
  292. return;
  293. }
  294. path.exists(defaults.closure_jar, function(exists) {
  295. if (!exists) {
  296. console.warn('Can not find Closure compiler at: ' + defaults.closure_jar);
  297. defaults.closure = false;
  298. defaults.closure_parts = false;
  299. defaults.closure_full = false;
  300. callback();
  301. return;
  302. }
  303. });
  304. });
  305. } else {
  306. callback();
  307. }
  308. };
  309. /**
  310. * Check if the file given as parameter exists in the local directory or in $AMBER/js/.
  311. * '.js' is appended first.
  312. *
  313. * @param filename name of a file without '.js' prefix
  314. * @param callback gets called on success with path to .js file as parameter
  315. */
  316. AmberC.prototype.resolve_js = function(filename, callback) {
  317. var jsFile = filename + this.defaults.loadsuffix + '.js';
  318. var amberJsFile = path.join(this.defaults.amber_dir, 'js', jsFile);
  319. console.log('Resolving: ' + jsFile);
  320. path.exists(jsFile, function(exists) {
  321. if (exists) {
  322. callback(jsFile);
  323. } else {
  324. path.exists(amberJsFile, function(exists) {
  325. if (exists) {
  326. callback(amberJsFile);
  327. } else {
  328. throw(new Error('JavaScript file not found: ' + jsFile));
  329. }
  330. });
  331. }
  332. });
  333. };
  334. /**
  335. * Collect libraries and Smalltalk files looking
  336. * both locally and in $AMBER/js and $AMBER/st.
  337. * Followed by resolve_libraries().
  338. */
  339. AmberC.prototype.collect_files = function(stFiles, jsFiles) {
  340. var self = this;
  341. var collected_files = new Combo(function() {
  342. self.resolve_libraries();
  343. });
  344. this.collect_st_files(stFiles, collected_files.add());
  345. this.collect_js_files(jsFiles, collected_files.add());
  346. };
  347. /**
  348. * Resolve st files given by stFiles and add them to defaults.compile.
  349. * Respective categories get added to defaults.compile_categories.
  350. * callback is evaluated afterwards.
  351. */
  352. AmberC.prototype.collect_st_files = function(stFiles, callback) {
  353. var defaults = this.defaults;
  354. var collected_st_files = new Combo(function() {
  355. Array.prototype.slice.call(arguments).forEach(function(data) {
  356. if (undefined !== data[0]) {
  357. var stFile = data[0];
  358. var stCategory = data[1];
  359. defaults.compile.push(stFile);
  360. defaults.compiled_categories.push(stCategory);
  361. defaults.compiled.push(stCategory + defaults.suffix_used + '.js');
  362. }
  363. });
  364. callback();
  365. });
  366. stFiles.forEach(function(stFile) {
  367. var _callback = collected_st_files.add();
  368. console.log('Checking: ' + stFile);
  369. var category = path.basename(stFile, '.st');
  370. var amberStFile = path.join(defaults.amber_dir, 'st', stFile);
  371. path.exists(stFile, function(exists) {
  372. if (exists) {
  373. _callback(stFile, category);
  374. } else {
  375. path.exists(amberJsFile, function(exists) {
  376. if (exists) {
  377. _callback(amberStFile, category);
  378. } else {
  379. throw(new Error('JavaScript file not found: ' + jsFile));
  380. }
  381. });
  382. }
  383. });
  384. });
  385. always_resolve(collected_st_files.add());
  386. };
  387. /**
  388. * Resolve js files given by jsFiles and add them to defaults.libraries.
  389. * callback is evaluated afterwards.
  390. */
  391. AmberC.prototype.collect_js_files = function(jsFiles, callback) {
  392. var self = this;
  393. var collected_js_files = new Combo(function() {
  394. Array.prototype.slice.call(arguments).forEach(function(file) {
  395. if (undefined !== file[0]) {
  396. self.defaults.libraries.push(file[0]);
  397. }
  398. });
  399. callback();
  400. });
  401. jsFiles.forEach(function(jsFile) {
  402. self.resolve_js(currentFile, collected_js_files.add());
  403. });
  404. always_resolve(collected_js_files.add());
  405. };
  406. /**
  407. * Resolve kernel and compiler files.
  408. * Followed by resolve_init().
  409. */
  410. AmberC.prototype.resolve_libraries = function() {
  411. // Resolve libraries listed in defaults.base
  412. var self = this;
  413. var all_resolved = new Combo(function(resolved_library_files, resolved_compiler_files) {
  414. self.resolve_init(resolved_compiler_files[0]);
  415. });
  416. this.resolve_kernel(all_resolved.add());
  417. this.resolve_compiler(all_resolved.add());
  418. };
  419. /**
  420. * Resolve .js files needed by kernel
  421. * callback is evaluated afterwards.
  422. */
  423. AmberC.prototype.resolve_kernel = function(callback) {
  424. var self = this;
  425. var kernel_files = this.defaults.base.concat(this.defaults.load);
  426. var kernel_resolved = new Combo(function() {
  427. Array.prototype.slice.call(arguments).forEach(function(file) {
  428. if (undefined !== file[0]) {
  429. self.defaults.libraries.push(file[0]);
  430. }
  431. });
  432. callback(null);
  433. });
  434. kernel_files.forEach(function(file) {
  435. self.resolve_js(file, kernel_resolved.add());
  436. });
  437. always_resolve(kernel_resolved.add());
  438. };
  439. /**
  440. * Resolve .js files needed by compiler.
  441. * callback is evaluated afterwards with resolved files as argument.
  442. */
  443. AmberC.prototype.resolve_compiler = function(callback) {
  444. // Resolve compiler libraries
  445. var compiler_files = this.defaults.compiler_libraries.concat(this.defaults.load);
  446. var compiler_resolved = new Combo(function() {
  447. var compilerFiles = [];
  448. Array.prototype.slice.call(arguments).forEach(function(file) {
  449. if (undefined !== file[0]) {
  450. compilerFiles.push(file[0]);
  451. }
  452. });
  453. callback(compilerFiles);
  454. });
  455. var self = this
  456. compiler_files.forEach(function(file) {
  457. self.resolve_js(file, compiler_resolved.add());
  458. });
  459. always_resolve(compiler_resolved.add());
  460. };
  461. /**
  462. * Resolves default.init and adds it to compilerFiles.
  463. * Followed by create_compiler().
  464. */
  465. AmberC.prototype.resolve_init = function(compilerFiles) {
  466. // check and add init.js
  467. var initFile = this.defaults.init;
  468. if ('.js' !== path.extname(initFile)) {
  469. initFile = resolve_js(initFile);
  470. this.defaults.init = initFile;
  471. }
  472. compilerFiles.push(initFile);
  473. this.create_compiler(compilerFiles);
  474. };
  475. /**
  476. * Read all .js files needed by compiler and eval() them.
  477. * The finished Compiler gets stored in defaults.smalltalk.
  478. * Followed by compile().
  479. */
  480. AmberC.prototype.create_compiler = function(compilerFilesArray) {
  481. var self = this;
  482. var compiler_files = new Combo(function() {
  483. var content = '(function() {';
  484. Array.prototype.slice.call(arguments).forEach(function(data) {
  485. // data is an array where index 0 is the error code and index 1 contains the data
  486. content += data[1];
  487. });
  488. content = content + 'return smalltalk;})();';
  489. self.defaults.smalltalk = eval(content);
  490. console.log('Compiler loaded');
  491. self.compile();
  492. });
  493. compilerFilesArray.forEach(function(file) {
  494. console.log('Loading file: ' + file);
  495. fs.readFile(file, compiler_files.add());
  496. });
  497. };
  498. /**
  499. * Compile all given .st files by importing them.
  500. * Followed by category_export().
  501. */
  502. AmberC.prototype.compile = function() {
  503. console.log('Compiling collected .st files')
  504. // import .st files
  505. var self = this;
  506. var imports = new Combo(function() {
  507. Array.prototype.slice.call(arguments).forEach(function(code) {
  508. // get element 0 of code since all return values are stored inside an array by Combo
  509. self.defaults.smalltalk.Importer._new()._import_(code[0]._stream());
  510. });
  511. self.category_export();
  512. });
  513. this.defaults.compile.forEach(function(stFile) {
  514. var callback = imports.add();
  515. if (/\.st/.test(stFile)) {
  516. console.log('Importing: ' + stFile);
  517. fs.readFile(stFile, 'utf8', function(err, data) {
  518. if (!err)
  519. callback(data);
  520. else
  521. throw new Error('Could not import: ' + stFile);
  522. });
  523. }
  524. });
  525. };
  526. /**
  527. * Export compiled categories to JavaScript files.
  528. * Followed by verify().
  529. */
  530. AmberC.prototype.category_export = function() {
  531. var defaults = this.defaults;
  532. var self = this;
  533. // export categories as .js
  534. map(defaults.compiled_categories, function(category, callback) {
  535. var jsFile = category + defaults.suffix_used + '.js';
  536. var jsFileDeploy = category + defaults.suffix_used + '.deploy.js';
  537. console.log('Exporting ' + (defaults.deploy ? '(debug + deploy)' : '(debug)')
  538. + ' category ' + category + ' as ' + jsFile
  539. + (defaults.deploy ? ' and ' + jsFileDeploy : ''));
  540. fs.writeFile(jsFile, defaults.smalltalk.Exporter._new()._exportPackage_(category), function(err) {
  541. if (defaults.deploy) {
  542. fs.writeFile(jsFileDeploy, defaults.smalltalk.StrippedExporter._new()._exportPackage_(category), callback);
  543. } else {
  544. callback(null, null);
  545. }
  546. });
  547. }, function(err, result){
  548. self.verify();
  549. });
  550. };
  551. /**
  552. * Verify if all .st files have been compiled.
  553. * Followed by compose_js_files() and optimize().
  554. */
  555. AmberC.prototype.verify = function() {
  556. console.log('Verifying if all .st files were compiled');
  557. var self = this;
  558. map(this.defaults.compiled, function(file, callback) {
  559. path.exists(file, function(exists) {
  560. if (exists)
  561. callback(null, null);
  562. else
  563. throw(new Error('Compilation failed of: ' + file));
  564. });
  565. }, function(err, result) {
  566. self.compose_js_files();
  567. self.optimize();
  568. });
  569. };
  570. /**
  571. * Synchronous function.
  572. * Concatenates compiled JavaScript files into one file in the correct order.
  573. * The name of the produced file is given by defaults.program (set by the last commandline option).
  574. */
  575. AmberC.prototype.compose_js_files = function() {
  576. var defaults = this.defaults;
  577. if (undefined !== defaults.program) {
  578. return;
  579. }
  580. var program_files = [];
  581. if (undefined !== defaults.libraries) {
  582. console.log('Collecting libraries: ' + defaults.libraries);
  583. program_files.push.apply(program_files, defaults.libraries);
  584. }
  585. if (undefined !== defaults.compiled) {
  586. console.log('Collecting compiled files: ' + defaults.compiled);
  587. program_files.push.apply(program_files, defaults.compiled);
  588. }
  589. if (undefined !== defaults.init) {
  590. console.log('Adding initializer ' + defaults.init);
  591. program_files.push(defaults.init);
  592. }
  593. console.log('Writing program file: %s.js', defaults.program);
  594. var fileStream = fs.createWriteStream(defaults.program + '.js');
  595. fileStream.on('error', function(error) {
  596. console.log(error);
  597. });
  598. program_files.forEach(function(file) {
  599. console.log('Checking : ' + file);
  600. if(path.existsSync(file)) {
  601. fileStream.write(fs.readFileSync(file));
  602. } else {
  603. throw(new Error('Can not find file ' + file));
  604. }
  605. });
  606. if (undefined !== defaults.main) {
  607. console.log('Adding call to: %s>>main', defaults.main);
  608. fileStream.write('smalltalk.' + defaults.main + '._main()');
  609. }
  610. if (undefined !== defaults.mainfile && path.existsSync(defaults.mainfile)) {
  611. console.log('Adding main file: ' + defaults.mainfile);
  612. fileStream.write(fs.readFileSync(defaults.mainfile));
  613. }
  614. fileStream.end();
  615. console.log('Done.');
  616. };
  617. /**
  618. * Optimize created JavaScript files with Google Closure compiler depending
  619. * on the flags: defaults.closure_parts, defaults.closure_full.
  620. */
  621. AmberC.prototype.optimize = function() {
  622. var defaults = this.defaults;
  623. var self = this;
  624. var optimization_done = new Combo(function() {
  625. console.timeEnd('Compile Time');
  626. });
  627. if (defaults.closure_parts) {
  628. console.log('Compiling all js files using Google closure compiler.');
  629. var allJsFiles = defaults.compiled.concat(defaults.libraries);
  630. allJsFiles.forEach(function(file) {
  631. var minifiedName = path.basename(file, '.js') + '.min.js';
  632. self.closure_compile(file, minifiedName, optimization_done.add());
  633. });
  634. }
  635. if (defaults.closure_full) {
  636. console.log('Compiling ' + defaults.program + '.js file using Google closure compiler.');
  637. self.closure_compile(defaults.program + '.js', defaults.program + '.min.js', optimization_done.add());
  638. }
  639. always_resolve(optimization_done.add());
  640. };
  641. /**
  642. * Compile sourceFile into minifiedFile with Google Closure compiler.
  643. * callback gets executed once finished.
  644. */
  645. AmberC.prototype.closure_compile = function(sourceFile, minifiedFile, callback) {
  646. // exec is asynchronous
  647. var self = this;
  648. exec(
  649. 'java -jar ' +
  650. self.defaults.closure_jar + ' ' +
  651. self.defaults.closure_options +
  652. ' --js '+ sourceFile +
  653. ' --js_output_file '+ minifiedFile,
  654. function (error, stdout, stderr) {
  655. if (error) {
  656. console.log(stderr);
  657. } else {
  658. console.log(stdout);
  659. console.log('Minified: '+ minifiedFile);
  660. }
  661. callback();
  662. }
  663. );
  664. };
  665. module.exports = new AmberC();
  666. var amberc = new AmberC();
  667. amberc.main();