traceur-rb 0.0.1

data/vendor/node_modules/traceur/src/node/compile-single-file.js

@@ -0,0 +1,69 @@
+// 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('q-io/fs');
+var path = require('path');
+var writeTreeToFile = require('./compiler.js').writeTreeToFile;
+
+var traceur = require('./traceur.js');
+var ErrorReporter = traceur.util.ErrorReporter;
+var AttachModuleNameTransformer =
+    traceur.codegeneration.module.AttachModuleNameTransformer;
+var FromOptionsTransformer = traceur.codegeneration.FromOptionsTransformer;
+var Parser = traceur.syntax.Parser;
+var SourceFile = traceur.syntax.SourceFile;
+
+function compileSingleFile(inputFilePath, outputFilePath, anonymousModules) {
+  return fs.read(inputFilePath).then(function(contents) {
+    var reporter = new ErrorReporter();
+    var sourceFile = new SourceFile(inputFilePath, contents);
+    var parser = new Parser(sourceFile, reporter);
+    var tree = parser.parseModule();
+    var moduleName, transformer;
+    if (!anonymousModules) {
+      moduleName = inputFilePath.replace(/\.js$/, '').replace(/\\/g,'/');
+      // Module naming uses ./ to signal relative names.
+      if (moduleName[0] !== '/')
+        moduleName = './' + moduleName;
+      transformer = new AttachModuleNameTransformer(moduleName);
+      tree = transformer.transformAny(tree);
+    }
+    transformer = new FromOptionsTransformer(reporter);
+    var transformed = transformer.transform(tree);
+
+    if (!reporter.hadError()) {
+      writeTreeToFile(transformed, outputFilePath);
+    }
+  });
+}
+
+function onlyJsFiles(path, stat) {
+  return stat.isFile() && /\.js$/.test(path) || false;
+}
+
+function compileAllJsFilesInDir(inputDir, outputDir, anonymousModules) {
+  inputDir = path.normalize(inputDir);
+  outputDir = path.normalize(outputDir);
+  fs.listTree(inputDir, onlyJsFiles).then(function(files) {
+    files.forEach(function(inputFilePath) {
+      var outputFilePath = inputFilePath.replace(inputDir, outputDir);
+      compileSingleFile(inputFilePath, outputFilePath, anonymousModules).done();
+    });
+  }).done();
+}
+
+compileSingleFile.compileAllJsFilesInDir = compileAllJsFilesInDir;
+module.exports = compileSingleFile;

data/vendor/node_modules/traceur/src/node/compiler.js

@@ -0,0 +1,116 @@
+// 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) {
+    include.name = path.resolve(include.name);
+    return include;
+  });
+
+  mkdirRecursive(outputDir);
+  process.chdir(outputDir);
+
+  // Make includes relative to output dir so that sourcemap paths are correct.
+  resolvedIncludes = resolvedIncludes.map(function(include) {
+    include.name = normalizePath(path.relative(outputDir, include.name));
+    return include;
+  });
+
+  inlineAndCompile(resolvedIncludes, traceur.options, reporter, function(tree) {
+    writeTreeToFile(tree, resolvedOutputFile, useSourceMaps);
+    process.exit(0);
+  }, function(err) {
+    console.error(err);
+    process.exit(1);
+  });
+}
+
+function compileToDirectory(outputDir, includes, useSourceMaps) {
+  var reporter = new ErrorReporter();
+  var outputDir = path.resolve(outputDir);
+
+  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].name);
+          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/vendor/node_modules/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/vendor/node_modules/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/vendor/node_modules/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;