traceur-rails 0.0.1

data/lib/traceur/support/traceur/src/node/compiler.js

@@ -0,0 +1,113 @@
+// Copyright 2013 Traceur Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+'use strict';
+
+var fs = require('fs');
+var path = require('path');
+
+var traceur = require('./traceur.js');
+
+var inlineAndCompile = require('./inline-module.js').inlineAndCompile;
+var util = require('./file-util.js');
+var writeFile = util.writeFile;
+var mkdirRecursive = util.mkdirRecursive;
+var normalizePath = util.normalizePath;
+
+var ErrorReporter = traceur.util.ErrorReporter;
+var TreeWriter = traceur.outputgeneration.TreeWriter;
+var SourceMapGenerator = traceur.outputgeneration.SourceMapGenerator;
+
+function getSourceMapFileName(name) {
+  return name.replace(/\.js$/, '.map');
+}
+
+function writeTreeToFile(tree, filename, useSourceMaps, opt_sourceRoot) {
+  var options;
+  if (useSourceMaps) {
+    var sourceMapFilePath = getSourceMapFileName(filename);
+    var config = {
+      file: path.basename(filename),
+      sourceRoot: opt_sourceRoot
+    };
+    var sourceMapGenerator = new SourceMapGenerator(config);
+    options = {sourceMapGenerator: sourceMapGenerator};
+  }
+
+  var compiledCode = TreeWriter.write(tree, options);
+  if (useSourceMaps) {
+    compiledCode += '\n//# sourceMappingURL=' +
+        path.basename(sourceMapFilePath) + '\n';
+  }
+  writeFile(filename, compiledCode);
+  if (useSourceMaps)
+    writeFile(sourceMapFilePath, options.sourceMap);
+}
+
+function compileToSingleFile(outputFile, includes, useSourceMaps) {
+  var reporter = new ErrorReporter();
+  var resolvedOutputFile = path.resolve(outputFile);
+  var outputDir = path.dirname(resolvedOutputFile);
+
+  // Resolve includes before changing directory.
+  var resolvedIncludes = includes.map(function(include) {
+    return path.resolve(include);
+  });
+
+  mkdirRecursive(outputDir);
+  process.chdir(outputDir);
+
+  // Make includes relative to output dir so that sourcemap paths are correct.
+  resolvedIncludes = resolvedIncludes.map(function(include) {
+    return normalizePath(path.relative(outputDir, include));
+  });
+
+  inlineAndCompile(resolvedIncludes, traceur.options, reporter, function(tree) {
+    writeTreeToFile(tree, resolvedOutputFile, useSourceMaps);
+    process.exit(0);
+  }, function(err) {
+    process.exit(1);
+  });
+}
+
+function compileToDirectory(outputFile, includes, useSourceMaps) {
+  var reporter = new ErrorReporter();
+  var outputDir = path.resolve(outputFile);
+
+  var current = 0;
+
+  function next() {
+    if (current === includes.length)
+      process.exit(0);
+
+    inlineAndCompile(includes.slice(current, current + 1), traceur.options,
+        reporter,
+        function(tree) {
+          var outputFile = path.join(outputDir, includes[current]);
+          var sourceRoot = path.relative(path.dirname(outputFile), '.');
+          writeTreeToFile(tree, outputFile, useSourceMaps, sourceRoot);
+          current++;
+          next();
+        },
+        function(err) {
+          process.exit(1);
+        });
+  }
+
+  next();
+}
+
+exports.compileToSingleFile = compileToSingleFile;
+exports.compileToDirectory = compileToDirectory;
+exports.writeTreeToFile = writeTreeToFile;

data/lib/traceur/support/traceur/src/node/deferred.js

@@ -0,0 +1,110 @@
+// Copyright 2013 Traceur Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+'use strict';
+
+/**
+ * Wrap a single async function to make the callback optional and hook it to
+ * trigger reject/resolve of the Promise, which it returns (this ignores the
+ * async function's return value). This enables the use of await with the
+ * wrapped function.
+ *
+ * @param {Function} fn Function to wrap.
+ * @param {boolean} firstArg True if the async callback is the first argument.
+ * @return {Function}
+ */
+function wrapFunction(fn, firstArg) {
+  return function() {
+    var resolve, reject;
+    var promise = new Promise(function(res, rej) {
+      resolve = res;
+      reject = rej;
+    });
+
+    var args = [].slice.call(arguments);
+    var originalCallback = args[firstArg ? 0 : args.length - 1];
+
+    function callback(err, value) {
+      if (originalCallback)
+        originalCallback.apply(this, arguments);
+
+      if (err)
+        reject(err);
+      else
+        resolve(value);
+    }
+
+    if (typeof originalCallback !== 'function') {
+      // Callback wasn't provided to the async function, add the custom one.
+      originalCallback = null;
+      if (firstArg)
+        args.unshift(callback);
+      else
+        args.push(callback);
+    } else {
+      // Callback was provided to the async function, replace it.
+      args[firstArg ? 0 : args.length - 1] = callback;
+    }
+
+    fn.apply(this, args);
+
+    return promise;
+  };
+}
+
+/**
+ * Wrap async functions in a module to enable the use of await.
+ * If no function name array is provided, every function with a fnSync
+ * variant will be wrapped.
+ *
+ * @param {string|Object} module The exports of the module or a string that
+ *     will be passed to require to get the module.
+ * @param {Array.<string>} functions Function names to wrap.
+ * @return {object} The module.
+ */
+function wrapModule(module, functions) {
+  if (typeof module === 'string')
+    module = require(module);
+
+  if (!functions) {
+    for (var k in module) {
+      // HACK: wrap all functions with a fnSync variant.
+      if (typeof module[k] === 'function' &&
+          typeof module[k + 'Sync'] === 'function')
+        module[k] = wrapFunction(module[k]);
+    }
+  } else {
+    for (var i = 0, k; i < functions.length; i++) {
+      var k = functions[i];
+      module[k] = wrapFunction(module[k]);
+    }
+  }
+
+  return module;
+}
+
+/**
+ * Wrap async functions in Node.js to enable the use of await.
+ *
+ * @return {void}
+ */
+function wrap() {
+  // TODO: find and wrap everything that needs to be wrapped.
+  wrapModule('fs');
+  process.nextTick = wrapFunction(process.nextTick, true);
+  // FIXME: this would ignore the return value, making it impossible to cancel
+  // the timeout without implementing a cancel method and using it everywhere.
+  //global.setTimeout = wrapFunction(setTimeout, true);
+}
+exports.wrap = wrap;

data/lib/traceur/support/traceur/src/node/file-util.js

@@ -0,0 +1,73 @@
+// Copyright 2013 Traceur Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+var fs = require('fs');
+var path = require('path');
+
+function existsSync(p) {
+  return fs.existsSync ? fs.existsSync(p) : path.existsSync(p);
+}
+
+/**
+ * Recursively makes all directoires, similar to mkdir -p
+ * @param {string} dir
+ */
+function mkdirRecursive(dir) {
+  var parts = path.normalize(dir).split(path.sep);
+  dir = '';
+  for (var i = 0; i < parts.length; i++) {
+    dir += parts[i] + path.sep;
+    if (!existsSync(dir)) {
+      fs.mkdirSync(dir, 0x1FD); // 0775 permissions
+    }
+  }
+}
+
+/**
+ * Removes the common prefix of basedir and filedir from filedir
+ * @param {string} basedir
+ * @param {string} filedir
+ */
+function removeCommonPrefix(basedir, filedir) {
+  var baseparts = basedir.split(path.sep);
+  var fileparts = filedir.split(path.sep);
+
+  var i = 0;
+  while (i < fileparts.length && fileparts[i] === baseparts[i]) {
+    i++;
+  }
+  return fileparts.slice(i).join(path.sep);
+}
+
+function writeFile(filename, contents) {
+  // Compute the output path
+  var outputdir = fs.realpathSync(process.cwd());
+  mkdirRecursive(path.dirname(filename));
+  var filedir = fs.realpathSync(path.dirname(filename));
+  filedir = removeCommonPrefix(outputdir, filedir);
+  outputdir = path.join(outputdir, filedir);
+
+  mkdirRecursive(outputdir);
+  var outputfile = path.join(outputdir, path.basename(filename));
+  fs.writeFileSync(outputfile, contents, 'utf8');
+}
+
+function normalizePath(s) {
+  return path.sep == '\\' ? s.replace(/\\/g, '/') : s;
+}
+
+exports.mkdirRecursive = mkdirRecursive;
+exports.normalizePath = normalizePath;
+exports.removeCommonPrefix = removeCommonPrefix;
+exports.writeFile = writeFile;

data/lib/traceur/support/traceur/src/node/getopt.js

@@ -0,0 +1,147 @@
+// Copyright 2013 Traceur Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+var format = require('util').format;
+
+function addAbbrev(o) {
+  var ks = [''].concat(Object.keys(o).sort()), k, kprev = '';
+  for (var i = ks.length - 1; i > 0; i--) {
+    var ka = k = ks[i], pre = 0;
+
+    // find length of common prefix, clamp to min of 1.
+    while (kprev[pre] === k[pre]) {
+      pre++;
+    }
+    pre = pre || 1;
+
+    // add all unique prefixes for k.
+    while (!o[ka = ka.slice(0, -1)] && ka.length > pre && ka > ks[i - 1]) {
+      o[ka] = o[k];
+    }
+    kprev = k;
+  }
+}
+
+function Getopt(opts) {
+  this.opt = null;
+  this.optarg = null;
+  this.optopt = null;
+  this.optdata = null;
+
+  this.optind = 2;
+  this.nextchar = 0;
+
+  this.opts_ = Object.create(null);
+  for (var i = 0; i < opts.length; i++) {
+    var opt = opts[i], data = null, m;
+    if (Array.isArray(opt)) {
+      data = opt[1] || null;
+      opt = opt[0];
+    }
+    if (!(m = opt.match(/^([\w\-]+)(:{0,2})$/))) {
+      throw new Error('invalid option initializer: ' + opt);
+    }
+    this.opts_[m[1]] = {name: m[1], arg: m[2], data: data};
+  }
+  addAbbrev(this.opts_);
+}
+
+Getopt.prototype = {
+  getopt: function(argv) {
+    var m, arg, optInf;
+    this.opt = this.optarg = this.optopt = this.optdata = null;
+    if (this.optind >= argv.length) {
+      return false;
+    }
+    arg = argv[this.optind];
+    if (!this.nextchar && /^-[^\-]/.test(arg)) {
+      this.nextchar = 1;
+    }
+    if (this.nextchar) {
+      // short opt
+      this.opt = arg[this.nextchar] || null;
+      this.optarg = arg.slice(++this.nextchar) || null;
+    } else if (m = arg.match(/^--([^=]+)(?:=(.*))?$|^--(.+)$/)) {
+      // long opt
+      this.opt = m[1] || m[3];
+      this.optarg = m[2] === undefined ? null : m[2];
+    } else {
+      // free arg
+      this.optind++;
+      this.opt = '=';
+      this.optarg = arg;
+      return true;
+    }
+
+    if (optInf = this.opts_[this.opt]) {
+      this.opt = optInf.name;
+      this.optdata = optInf.data;
+      switch (optInf.arg) {
+        case '':
+          // no arg
+          if (!this.nextchar && this.optarg) {
+            // unexpected arg
+            this.optopt = this.opt;
+            this.opt = '!';
+            break;
+          }
+          this.optarg = null;
+          break;
+        case ':':
+          // required arg
+          if (this.optarg === null) {
+            if (++this.optind >= argv.length) {
+              // missing arg
+              this.optopt = this.opt;
+              this.opt = ':';
+              break;
+            }
+            this.optarg = argv[this.optind];
+          }
+          // fall through
+        case '::':
+          // optional arg
+          this.nextchar = 0;
+          break;
+      }
+    } else {
+      // unknown opt
+      this.optopt = this.opt;
+      this.opt = '?';
+    }
+
+    this.optind += !(this.nextchar %= arg.length);
+
+    return true;
+  },
+  message: function() {
+    switch (this.opt) {
+      case ':':
+        return format('missing argument for \'%s\'.', this.optopt);
+      case '?':
+        return format('unknown option \'%s\'.', this.optopt);
+      case '!':
+        return format('\'%s\' does not take an argument.', this.optopt);
+      case '=':
+        return format('optarg \'%s\'.', this.optarg);
+      default:
+        if (this.optarg === null)
+          return format('opt \'%s\'.', this.opt);
+        else
+          return format('opt \'%s\', optarg \'%s\'.', this.opt, this.optarg);
+    }
+  }
+}
+
+exports.Getopt = Getopt;

data/lib/traceur/support/traceur/src/node/inline-module.js

@@ -0,0 +1,150 @@
+// Copyright 2012 Traceur Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+'use strict';
+
+var fs = require('fs');
+var path = require('path');
+var nodeLoader = require('./nodeLoader.js');
+var normalizePath = require('./file-util.js').normalizePath;
+
+var TraceurLoader = traceur.runtime.TraceurLoader;
+var LoaderHooks = traceur.runtime.LoaderHooks;
+var Script = traceur.syntax.trees.Script;
+var SourceFile = traceur.syntax.SourceFile
+var moduleStore = traceur.runtime.ModuleStore;
+
+/**
+ * @param {ErrorReporter} reporter
+ * @param {Array.<ParseTree>} elements
+ * @param {string|undefined} depTarget A valid depTarget means dependency
+ *     printing was requested.
+ */
+function InlineLoaderHooks(reporter, url, elements, depTarget) {
+  LoaderHooks.call(this, reporter, url,
+      nodeLoader,  // Load modules using node fs.
+      moduleStore);  // Look up modules in our static module store
+  this.dirname = url;
+  this.elements = elements;
+  this.depTarget = depTarget && normalizePath(path.relative('.', depTarget));
+  this.codeUnitList = [];
+}
+
+InlineLoaderHooks.prototype = {
+  __proto__: LoaderHooks.prototype,
+
+  evaluateCodeUnit: function(codeUnit) {
+    if (this.depTarget) {
+      console.log('%s: %s', this.depTarget,
+                  normalizePath(path.relative(path.join(__dirname, '../..'),
+                  codeUnit.url)));
+    }
+    // Don't eval. Instead append the trees to the output.
+    var tree = codeUnit.metadata.transformedTree;
+    this.elements.push.apply(this.elements, tree.scriptItemList);
+  },
+
+};
+
+function allLoaded(url, reporter, elements) {
+  return new Script(null, elements);
+}
+
+/**
+ * Compiles the files in "filenames" along with any associated modules, into a
+ * single js file, in proper module dependency order.
+ *
+ * @param {Array.<string>} filenames The list of files to compile and concat.
+ * @param {Object} options A container for misc options. 'depTarget' is the
+ *     only currently available option, which results in the dependencies for
+ *     'filenames' being printed to stdout, with 'depTarget' as the target.
+ * @param {ErrorReporter} reporter
+ * @param {Function} callback Callback used to return the result. A null result
+ *     indicates that inlineAndCompile has returned successfully from a
+ *     non-compile request.
+ * @param {Function} errback Callback used to return errors.
+ */
+function inlineAndCompile(filenames, options, reporter, callback, errback) {
+
+  var depTarget = options && options.depTarget;
+  var referrerName = options && options.referrer;
+
+  var basePath;
+  if (referrerName) {
+    // The compile occurs two directories down from current directory,
+    // in src/node.  Thus the names will appear as eg ../src/x.
+    // We want something like referrerName/src/x. So we need to give
+    // the normalize() the 'package' or root name with src/node append
+    // to represent the referrer from here.
+    referrerName = referrerName && referrerName + 'src/node';
+    // The basePath will replace options.referrer in our final filename.
+    // Since we are in src/node, we need to back up two directories.
+    basePath = path.join(__dirname, '../../');
+  } else {
+    basePath = path.resolve('./') + '/';
+  }
+  basePath = basePath.replace(/\\/g, '/');
+
+  var scriptsCount = options.scripts.length;
+
+  var loadCount = 0;
+  var elements = [];
+  var hooks = new InlineLoaderHooks(reporter, basePath, elements, depTarget);
+  var loader = new TraceurLoader(hooks);
+
+  function appendEvaluateModule(name, referrerName) {
+    var normalizedName =
+        traceur.ModuleStore.normalize(name, referrerName);
+    // Create tree for System.get('normalizedName');
+    var tree =
+        traceur.codegeneration.module.createModuleEvaluationStatement(normalizedName);
+    elements.push(tree);
+  }
+
+  function loadNext() {
+    var loadAsScript = scriptsCount && (loadCount < scriptsCount);
+    var doEvaluateModule = false;
+    var loadFunction = loader.import;
+    var name = filenames[loadCount];
+    if (loadAsScript) {
+      loadFunction = loader.loadAsScript;
+    } else {
+      name = name.replace(/\.js$/,'');
+      if (options.modules !== 'inline' && options.modules !== 'instantiate')
+        doEvaluateModule = true;
+    }
+    var loadOptions = {referrerName: referrerName};
+    var codeUnit = loadFunction.call(loader, name, loadOptions).then(
+        function() {
+          if (doEvaluateModule)
+            appendEvaluateModule(name, referrerName);
+          loadCount++;
+          if (loadCount < filenames.length) {
+            loadNext();
+          } else if (depTarget) {
+            callback(null);
+          } else {
+            var tree = allLoaded(basePath, reporter, elements);
+            callback(tree);
+          }
+        }, function(err) {
+          errback(err);
+        }).catch(function(ex) {
+          console.error('Internal error ' + (ex.stack || ex));
+        });
+  }
+
+  loadNext();
+}
+exports.inlineAndCompile = inlineAndCompile;