1
0

amberc.js 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345
  1. /**
  2. * This is a "compiler" for Amber code.
  3. * Put the following code into compiler.js:
  4. * var amberc = require('amberc');
  5. * var compiler = new amberc.Compiler('path/to/amber');
  6. * var options = amberc.createDefaults();
  7. * // edit options entries
  8. * compiler.main(options);
  9. */
  10. var path = require('path'),
  11. fs = require('fs'),
  12. Promise = require('es6-promise').Promise,
  13. requirejs = require('requirejs');
  14. /**
  15. * AmberCompiler constructor function.
  16. * amber_dir: points to the location of an amber installation
  17. */
  18. function AmberCompiler(amber_dir) {
  19. if (amber_dir == null || !fs.existsSync(amber_dir)) {
  20. throw new Error('amber_dir needs to be a valid directory');
  21. }
  22. this.amber_dir = amber_dir;
  23. }
  24. /**
  25. * Default values.
  26. */
  27. var createDefaultConfiguration = function () {
  28. return {
  29. paths: {},
  30. configFile: null,
  31. load: [],
  32. stFiles: [],
  33. jsGlobals: [],
  34. amdNamespace: 'amber_core',
  35. compile: [],
  36. compiled: [],
  37. outputDir: undefined,
  38. verbose: false
  39. };
  40. };
  41. /**
  42. * Main function for executing the compiler.
  43. * If check_configuration_ok() returns successfully
  44. * the configuration is used to trigger the following compilation steps.
  45. */
  46. AmberCompiler.prototype.main = function (configuration, finished_callback) {
  47. console.time('Compile Time');
  48. if (configuration.amdNamespace.length === 0) {
  49. configuration.amdNamespace = 'amber_core';
  50. }
  51. console.ambercLog = console.log;
  52. if (false === configuration.verbose) {
  53. console.log = function () {
  54. };
  55. }
  56. // the evaluated compiler will be stored in this variable (see create_compiler)
  57. configuration.core = {};
  58. configuration.globals = {};
  59. configuration.amber_dir = this.amber_dir;
  60. var rjsConfig;
  61. if (configuration.configFile) {
  62. var configSrc = fs.readFileSync(configuration.configFile, "utf8");
  63. rjsConfig = (function () {
  64. var require, requirejs;
  65. requirejs = require = {
  66. config: function (x) {
  67. requirejs = require = x;
  68. }
  69. };
  70. eval(configSrc);
  71. return require;
  72. })();
  73. } else {
  74. rjsConfig = {
  75. paths: configuration.paths
  76. };
  77. }
  78. if (!rjsConfig.paths.amber) {
  79. // TODO remove backward compatibility, prefer 'base'
  80. rjsConfig.paths.amber = path.join(this.amber_dir, 'support');
  81. if (!fs.existsSync(rjsConfig.paths.amber)) {
  82. rjsConfig.paths.amber = path.join(this.amber_dir, 'base');
  83. }
  84. }
  85. if (!rjsConfig.paths.amber_core) rjsConfig.paths.amber_core = path.join(this.amber_dir, 'src');
  86. rjsConfig.paths['text'] = require.resolve('requirejs-text').replace(/\.js$/, "");
  87. rjsConfig.paths['amber/without-imports'] = path.join(__dirname, 'without-imports');
  88. rjsConfig.nodeRequire = require;
  89. rjsConfig.context = "amberc";
  90. configuration.requirejs = requirejs.config(rjsConfig);
  91. check_configuration(configuration)
  92. .then(collect_st_files)
  93. .then(create_compiler)
  94. .then(compile)
  95. .then(category_export)
  96. .then(verify)
  97. .then(function () {
  98. console.timeEnd('Compile Time');
  99. }, function (error) {
  100. console.error(error);
  101. })
  102. .then(function () {
  103. console.log = console.ambercLog;
  104. finished_callback && finished_callback();
  105. });
  106. };
  107. /**
  108. * Check if the passed in configuration object has sufficient/nonconflicting values.
  109. * Returns a Promise which resolves into the configuration object.
  110. */
  111. function check_configuration(configuration) {
  112. return new Promise(function (resolve, reject) {
  113. if (configuration == null) {
  114. reject(Error('AmberCompiler.check_configuration_ok(): missing configuration object'));
  115. }
  116. if (0 === configuration.stFiles.length) {
  117. reject(Error('AmberCompiler.check_configuration_ok(): no files to compile specified in configuration object'));
  118. }
  119. resolve(configuration);
  120. });
  121. }
  122. /**
  123. * Check if the file given as parameter exists in any of the following directories:
  124. * 1. current local directory
  125. * 2. $AMBER/
  126. *
  127. * @param filename name of a .st file
  128. * @param configuration the main amberc configuration object
  129. */
  130. function resolve_st(filename, configuration) {
  131. return resolve_file(filename, [configuration.amber_dir]);
  132. }
  133. /**
  134. * Resolve the location of a file given as parameter filename.
  135. * First check if the file exists at given location,
  136. * then check in each of the directories specified in parameter searchDirectories.
  137. */
  138. function resolve_file(filename, searchDirectories) {
  139. return new Promise(function (resolve, reject) {
  140. console.log('Resolving: ' + filename);
  141. fs.exists(filename, function (exists) {
  142. if (exists) {
  143. resolve(filename);
  144. } else {
  145. var alternativeFile = '';
  146. // check for filename in any of the given searchDirectories
  147. var found = searchDirectories.some(function (directory) {
  148. alternativeFile = path.join(directory, filename);
  149. return fs.existsSync(alternativeFile);
  150. });
  151. if (found) {
  152. resolve(alternativeFile);
  153. } else {
  154. reject(Error('File not found: ' + alternativeFile));
  155. }
  156. }
  157. });
  158. });
  159. }
  160. /**
  161. * Resolve st files given by stFiles and add them to configuration.compile.
  162. * Returns a Promise which resolves into the configuration object.
  163. */
  164. function collect_st_files(configuration) {
  165. return Promise.all(
  166. configuration.stFiles.map(function (stFile) {
  167. return resolve_st(stFile, configuration);
  168. })
  169. )
  170. .then(function (data) {
  171. configuration.compile = configuration.compile.concat(data);
  172. return configuration;
  173. });
  174. }
  175. /**
  176. * Resolve .js files needed by compiler, read and eval() them.
  177. * The finished Compiler gets stored in configuration.{core,globals}.
  178. * Returns a Promise object which resolves into the configuration object.
  179. */
  180. function create_compiler(configuration) {
  181. var include_files = configuration.load;
  182. return new Promise(configuration.requirejs.bind(null, ["amber/lang", "amber_core/Platform-Node"]))
  183. .then(function (boot) {
  184. configuration.core = boot.api;
  185. configuration.globals = boot.globals;
  186. return boot.api.initialize();
  187. })
  188. .then(function () {
  189. var pluginPrefixedLibraries = include_files.map(function (each) {
  190. return 'amber/without-imports!' + each;
  191. });
  192. return new Promise(configuration.requirejs.bind(null, pluginPrefixedLibraries));
  193. })
  194. .then(function () {
  195. // TODO remove deprecated method name
  196. (configuration.globals.Smalltalk._adoptPackageDictionary || configuration.globals.Smalltalk._adoptPackageDescriptors).call(configuration.globals.Smalltalk);
  197. console.log('Compiler loaded');
  198. configuration.jsGlobals.forEach(function (each) {
  199. configuration.globals.Smalltalk._addGlobalJsVariable_(each);
  200. });
  201. return configuration;
  202. });
  203. }
  204. /**
  205. * Compile all given .st files by importing them.
  206. * Returns a Promise object that resolves into the configuration object.
  207. */
  208. function compile(configuration) {
  209. // return function which does the actual work
  210. // and use the compile function to reference the configuration object
  211. return Promise.all(
  212. configuration.compile.map(function (stFile) {
  213. return new Promise(function (resolve, reject) {
  214. if (/\.st/.test(stFile)) {
  215. console.ambercLog('Reading: ' + stFile);
  216. fs.readFile(stFile, 'utf8', function (err, data) {
  217. if (!err)
  218. resolve(data);
  219. else
  220. reject(Error('Could not read: ' + stFile));
  221. });
  222. }
  223. });
  224. })
  225. )
  226. .then(function (fileContents) {
  227. console.log('Compiling collected .st files');
  228. // import/compile content of .st files
  229. return Promise.all(
  230. fileContents.map(function (code) {
  231. return new Promise(function (resolve, reject) {
  232. var importer = configuration.globals.Importer._new();
  233. try {
  234. importer._import_(code._stream());
  235. resolve(true);
  236. } catch (ex) {
  237. reject(Error("Compiler error in section:\n" +
  238. importer._lastSection() + "\n\n" +
  239. "while processing chunk:\n" +
  240. importer._lastChunk() + "\n\n" +
  241. (ex._messageText && ex._messageText() || ex.message || ex))
  242. );
  243. }
  244. });
  245. })
  246. );
  247. })
  248. .then(function () {
  249. return configuration;
  250. });
  251. }
  252. /**
  253. * Export compiled categories to JavaScript files.
  254. * Returns a Promise() that resolves into the configuration object.
  255. */
  256. function category_export(configuration) {
  257. return Promise.all(
  258. configuration.compile.map(function (stFile) {
  259. return new Promise(function (resolve, reject) {
  260. var category = path.basename(stFile, '.st');
  261. var jsFilePath = configuration.outputDir;
  262. if (jsFilePath == null) {
  263. jsFilePath = path.dirname(stFile);
  264. }
  265. var jsFile = category + '.js';
  266. jsFile = path.join(jsFilePath, jsFile);
  267. configuration.compiled.push(jsFile);
  268. var smalltalkGlobals = configuration.globals;
  269. var packageObject = smalltalkGlobals.Package._named_(category);
  270. packageObject._transport()._namespace_(configuration.amdNamespace);
  271. fs.writeFile(jsFile, smalltalkGlobals.String._streamContents_(function (stream) {
  272. smalltalkGlobals.AmdExporter._new()._exportPackage_on_(packageObject, stream);
  273. }), function (err) {
  274. if (err)
  275. reject(err);
  276. else
  277. resolve(true);
  278. });
  279. });
  280. })
  281. )
  282. .then(function () {
  283. return configuration;
  284. });
  285. }
  286. /**
  287. * Verify if all .st files have been compiled.
  288. * Returns a Promise() that resolves into the configuration object.
  289. */
  290. function verify(configuration) {
  291. console.log('Verifying if all .st files were compiled');
  292. return Promise.all(
  293. configuration.compiled.map(function (file) {
  294. return new Promise(function (resolve, reject) {
  295. fs.exists(file, function (exists) {
  296. if (exists)
  297. resolve(true);
  298. else
  299. reject(Error('Compilation failed of: ' + file));
  300. });
  301. });
  302. })
  303. )
  304. .then(function () {
  305. return configuration;
  306. });
  307. }
  308. module.exports.Compiler = AmberCompiler;
  309. module.exports.createDefaultConfiguration = createDefaultConfiguration;