traceur-rb 0.0.2 → 0.0.4

data/node_modules/traceur/src/node/NodeCompiler.js

@@ -0,0 +1,81 @@
+// Copyright 2014 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.
+
+// Node.js API
+//
+// This is what you get when you `require('traceur')`.
+// It's suppose to be used by custom scripts or tools such as Grunt or Karma.
+
+'use strict';
+
+var path = require('path');
+var fs = require('fs');
+var util = require('./file-util.js');
+var writeFile = util.writeFile;
+var traceur = require('./traceur.js');
+
+var Compiler = traceur.Compiler;
+
+function NodeCompiler(options, sourceRoot) {
+  sourceRoot = sourceRoot || process.cwd();
+  Compiler.call(this, options, sourceRoot);
+}
+
+NodeCompiler.prototype = {
+  __proto__: Compiler.prototype,
+
+  writeTreeToFile: function(tree, filename) {
+    filename = this.normalize(filename);
+    var compiledCode = this.write(tree, filename);
+    if (this.options_.sourceMaps === 'file') {
+      var sourcemap = this.getSourceMap();
+      if (sourcemap) {
+        var mapName = this.sourceMappingURL(filename);
+        // Write the map file next to the output file.
+        mapName = path.resolve(path.dirname(filename), mapName);
+        writeFile(mapName, sourcemap);
+      }
+    }
+
+    writeFile(filename, compiledCode);
+  },
+
+  compileSingleFile: function(inputFilePath, outputFilePath, errback) {
+    inputFilePath = this.normalize(inputFilePath);
+    outputFilePath = this.normalize(outputFilePath);
+    fs.readFile(inputFilePath, function(err, contents) {
+      if (err) {
+        errback(err);
+        return;
+      }
+
+      var parsed = this.parse(contents.toString(), inputFilePath);
+      this.writeTreeToFile(this.transform(parsed, inputFilePath),
+                           outputFilePath);
+    }.bind(this));
+  },
+
+  sourceMappingURL: function(filename) {
+    if (this.options_.sourceMaps === 'inline') {
+      var base64sm = new Buffer(this.getSourceMap()).toString('base64');
+      return 'data:application/json;base64,' + base64sm;
+    }
+    return Compiler.prototype.sourceMappingURL.call(this, filename);
+  }
+};
+
+
+module.exports = {
+  NodeCompiler: NodeCompiler
+};

data/node_modules/traceur/src/node/command.js

@@ -0,0 +1,203 @@
+// 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 path = require('path');
+var glob = require('glob');
+var commandLine;
+var cmdName = path.basename(process.argv[1]);
+try {
+  commandLine = new (require('commander').Command)(cmdName);
+} catch (ex) {
+  console.error('Commander.js is required for this to work. To install it ' +
+                'run:\n\n  npm install commander\n');
+  process.exit(1);
+}
+commandLine.setMaxListeners(100);
+
+var traceurAPI = require('./api.js');
+var interpret = require('./interpreter.js');
+
+// The System object requires traceur, but we want it set for everything that
+// follows. The module sets global.System as a side-effect.
+require('./System.js');
+
+var rootSources = [];
+commandLine.option('--script <fileName>', 'Parse as Script', function(fileName) {
+  rootSources.push({name: fileName, type: 'script'});
+});
+
+commandLine.option('--module <fileName>', 'Parse as Module', function(fileName) {
+   rootSources.push({name: fileName, type: 'module'});
+});
+
+commandLine.option('--inline <fileName>', 'Parse as Module, format \'inline\'',
+  function(fileName) {
+   rootSources.push({name: fileName, type: 'module', format: 'inline'});
+  }
+);
+
+commandLine.option('--out <FILE>', 'Compile all input files into a single file');
+commandLine.option('--dir <INDIR> <OUTDIR>', 'Compile an input directory of modules into an output directory');
+
+commandLine.option('--longhelp', 'Show all known options');
+commandLine.on('longhelp', function() {
+  commandLine.help();
+  process.exit();
+});
+
+// Caling process.exit when there is still characters to be flushed to stdout
+// makes Windows drop those characters. We therefor wait until the buffer is
+// empty before really exiting.
+// Since this makes exiting async we need to manually keep track
+var shouldExit = false;
+
+function processExit() {
+  shouldExit = true;
+  var draining = 0;
+  function exit() {
+    if (!draining--)
+      process.exit();
+  }
+  if (process.stdout.bufferSize) {
+    draining += 1;
+    process.stdout.once('drain', exit);
+  }
+  if (process.stderr.bufferSize) {
+    draining += 1;
+    process.stderr.once('drain', exit);
+  }
+  exit();
+}
+
+commandLine.option('-v, --version', 'Show version and exit');
+commandLine.on('version', function() {
+  process.stdout.write(System.version.split('@')[1]);
+  processExit();
+});
+
+commandLine.on('--help', function() {
+  console.log('  Examples:');
+  console.log('');
+  console.log('    $ %s a.js [args]', cmdName);
+  console.log('    $ %s --out compiled.js b.js c.js', cmdName);
+  console.log('    $ %s --dir indir outdir', cmdName);
+  console.log('');
+});
+
+var commandOptions = new traceurAPI.util.CommandOptions();
+traceurAPI.util.addOptions(commandLine, commandOptions);
+
+commandLine.usage('[options] [files]');
+
+commandLine.command('*').action(function() {
+    // The callback seems to receive a "command" at the end of arguments
+    for (var i = 0; i < arguments.length - 1; i++) {
+      rootSources.push({name: arguments[i], type: 'module'});
+    }
+  });
+
+commandLine.sourceMaps = false;
+commandLine.parse(process.argv);
+
+// commanderjs sets self[name]=defaultValue if the argument is null.
+// To support --source-maps a legacy boolean we need to transfer the
+// the self value here.
+commandOptions.sourceMaps = commandLine.sourceMaps;
+
+if (!shouldExit && !rootSources.length) {
+  // TODO: Start trepl
+  console.error('\n  Error: At least one input file is needed');
+  commandLine.help();
+  process.exit(1);
+}
+
+var out = commandLine.out;
+var dir = commandLine.dir;
+
+function compileAll(out, sources, options) {
+  var isSingleFileCompile = /\.js$/.test(out);
+  if (!isSingleFileCompile) {
+    traceurAPI.forEachRecursiveModuleCompile(out, sources, options);
+  } else {
+    traceurAPI.recursiveModuleCompileToSingleFile(out, sources, options).then(function() {
+      process.exit(0);
+    }).catch(function(err) {
+      var errors = err.errors || [err];
+      errors.forEach(function(err) {
+        console.error(err.stack || err);
+      });
+      process.exit(1);
+    });
+  }
+}
+
+function globSources(sourcesToGlob, cb) {
+  var processedCount = 0;
+  var globbedSources = [];
+  sourcesToGlob.forEach(function(item) {
+    glob(item.name, {}, function(err, matches) {
+      if (err)
+        throw new Error('While scanning ' + item.name + ': ' + err);
+      for (var i = matches.length - 1; i >= 0; i--) {
+        var globbedSource = {
+          name: matches[i],
+          type: item.type,
+          format: item.format
+        };
+        globbedSources.push(globbedSource);
+      }
+      processedCount++;
+      if (processedCount === sourcesToGlob.length) {
+        cb(null, globbedSources);
+      }
+    });
+  });
+}
+
+if (!shouldExit) {
+  if (out) {
+    var sourcesToGlob = [];
+    var processedSources = [];
+
+    for (var i = 0; i < rootSources.length; i++) {
+      if (glob.hasMagic(rootSources[i].name)) {
+        sourcesToGlob.push(rootSources[i]);
+      } else {
+        processedSources.push(rootSources[i]);
+      }
+    }
+    if (!sourcesToGlob.length) {
+      compileAll(out, processedSources, commandOptions);
+    } else {
+      globSources(sourcesToGlob, function(err, globbedSources) {
+        processedSources.push.apply(processedSources, globbedSources);
+        if (processedSources.length) {
+          compileAll(out, processedSources, commandOptions);
+        } else {
+          process.exit(0);
+        }
+      });
+    }
+  } else if (dir) {
+    if (rootSources.length !== 1)
+      throw new Error('Compile all in directory requires exactly one input filename');
+    traceurAPI.compileAllJsFilesInDir(dir, rootSources[0].name, commandOptions);
+  } else {
+    rootSources.forEach(function(obj) {
+      interpret(path.resolve(obj.name), commandOptions);
+    });
+  }
+}

data/node_modules/traceur/src/node/interpreter.js

@@ -0,0 +1,37 @@
+// 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 traceur = require('./traceur.js');
+var nodeLoader = require('./nodeLoader.js');
+
+function interpret(filename, options) {
+  // Interpret the filename argument as a platform-independent,
+  // normalized module name.
+  var moduleName = filename.replace(/\\/g, '/');
+  var metadata = {
+    traceurOptions: options,
+    outputName: filename
+  };
+
+  System.import(moduleName, {metadata: metadata}).
+    catch(function(err) {
+      console.error(err.stack || err + '');
+      process.exit(1);
+    });
+}
+
+module.exports = interpret;

data/node_modules/traceur/src/node/recursiveModuleCompile.js

@@ -0,0 +1,171 @@
+// 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 Promise = require('rsvp').Promise;
+var nodeLoader = require('./nodeLoader.js');
+var util = require('./file-util.js');
+var normalizePath = util.normalizePath;
+var mkdirRecursive = util.mkdirRecursive;
+var NodeCompiler = require('./NodeCompiler.js').NodeCompiler;
+
+var cwd = process.cwd();
+
+function revertCwd() {
+  process.chdir(cwd);
+}
+
+function recursiveModuleCompileToSingleFile(outputFile, includes, options) {
+  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;
+  });
+
+  options.bundle = includes.length > 1;
+  var compiler = new NodeCompiler(options);
+
+  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;
+  });
+
+  return recursiveModuleCompile(resolvedIncludes, options)
+      .then(function(tree) {
+        compiler.writeTreeToFile(tree, resolvedOutputFile);
+      }).then(revertCwd, function(err) {
+        revertCwd();
+        throw err;
+      });
+}
+
+function forEachRecursiveModuleCompile(outputDir, includes, options) {
+  var outputDir = path.resolve(outputDir);
+  var compiler = new NodeCompiler(options);
+
+  Promise.all(includes.map(function(input) {
+    return recursiveModuleCompile([input], options).then(function(tree) {
+      var outputFileName = path.join(outputDir, input.name);
+      compiler.writeTreeToFile(tree, outputFileName);
+    });
+  })).then(function() {
+    process.exit(0);
+  }, function() {
+    process.exit(1);
+  });
+}
+
+var TraceurLoader = traceur.runtime.TraceurLoader;
+var InlineLoaderCompiler = traceur.runtime.InlineLoaderCompiler;
+var Options = traceur.util.Options;
+
+/**
+ * Chains .then() calls along a list after applying a function. The function
+ * is not called on a value in the list until the promise generated by calling
+ * the function on the previous value in the list completes.
+ *
+ * @param {Array.<T>} list
+ * @param {function(T): Promise<?>} f A function applied to each item on the
+ *     list.
+ * @return {Promise<?>} A promise where each promise f(v), for each v in the
+ *     list has completed.
+ */
+function sequencePromises(list, f) {
+  var result = Promise.resolve();
+  list.forEach(function (item) {
+    result = result.then(function() { return f(item); });
+  });
+  return result;
+}
+
+/**
+ * Compiles the files in "fileNamesAndTypes" along with any associated modules,
+ * into a single js file, in module dependency order.
+ *
+ * @param {Array.<Object>} fileNamesAndTypes The list of {name, type}
+ *     to compile and concat; type is 'module' or 'script'
+ * @param {Object} options A container for misc options. 'depTarget' is the
+ *     only currently available option, which results in the dependencies for
+ *     'fileNamesAndTypes' being printed to stdout, with 'depTarget' as the target.
+ * @param {Function} callback Callback used to return the result. A null result
+ *     indicates that recursiveModuleCompile has returned successfully from a
+ *     non-compile request.
+ * @param {Function} errback Callback used to return errors.
+ */
+function recursiveModuleCompile(fileNamesAndTypes, options) {
+  var depTarget = options && options.depTarget;
+  var referrerName = options && options.referrer;
+
+  var basePath = path.resolve('./') + '/';
+  basePath = basePath.replace(/\\/g, '/');
+
+  var elements = [];
+  var loaderCompiler = new InlineLoaderCompiler(elements);
+
+  var loader = new TraceurLoader(nodeLoader, basePath, loaderCompiler);
+
+  function appendEvaluateModule(name) {
+    var normalizedName =
+        traceur.ModuleStore.normalize(name, referrerName);
+    // Create tree for System.get('normalizedName');
+    var moduleModule = traceur.codegeneration.module;
+    var tree = moduleModule.createModuleEvaluationStatement(normalizedName);
+    elements.push(tree);
+  }
+
+  function loadInput(input) {
+    var doEvaluateModule = false;
+    var loadFunction = loader.import;
+    var name = input.name;
+
+    var optionsCopy = new Options(options); // Give each load a copy of options.
+
+    if (input.type === 'script') {
+      loadFunction = loader.loadAsScript;
+    } else if (optionsCopy.modules === 'register') {
+      doEvaluateModule = true;
+    }
+
+    var loadOptions = {
+      referrerName: referrerName,
+      metadata: {traceurOptions: optionsCopy}
+    };
+
+    return loadFunction.call(loader, name, loadOptions).then(function() {
+      if (doEvaluateModule) {
+        appendEvaluateModule(name);
+      }
+    });
+  }
+
+  return sequencePromises(fileNamesAndTypes, loadInput).then(function() {
+    if (depTarget) {
+      return null;
+    } else {
+      return loaderCompiler.toTree();
+    }
+  });
+}
+
+exports.recursiveModuleCompileToSingleFile = recursiveModuleCompileToSingleFile;
+exports.forEachRecursiveModuleCompile = forEachRecursiveModuleCompile;