traceur-rb 0.0.1 → 0.0.2

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

@@ -0,0 +1,78 @@
+// 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) {
+        writeFile(this.sourceMappingURL(filename), 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, undefined, 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/vendor/node_modules/traceur/src/node/System.js

@@ -16,14 +16,41 @@
 
 var fs = require('fs');
 var traceur = require('./traceur.js');
-var nodeLoader = require('./nodeLoader.js');
 var path = require('path');
-var reporter = new traceur.util.ErrorReporter();
-var LoaderHooks = traceur.runtime.LoaderHooks;
+
+var nodeLoader = require('./nodeLoader.js');
 var url = (path.resolve('./') + '/').replace(/\\/g, '/');
-var loaderHooks = new LoaderHooks(reporter, url, nodeLoader);
 
-var System = new traceur.runtime.TraceurLoader(loaderHooks);
+
+var LoaderCompiler = traceur.runtime.LoaderCompiler;
+var NodeLoaderCompiler = function() {
+  LoaderCompiler.call(this);
+};
+
+NodeLoaderCompiler.prototype = {
+  __proto__: LoaderCompiler.prototype,
+  evaluateCodeUnit: function(codeUnit) {
+    var result = module._compile(codeUnit.metadata.transcoded,
+        codeUnit.address || codeUnit.normalizedName);
+    codeUnit.metadata.transformedTree = null;
+    return result;
+  }
+};
+
+var System = new traceur.runtime.TraceurLoader(nodeLoader, url,
+    new NodeLoaderCompiler());
+
+require('source-map-support').install({
+  retrieveSourceMap: function(filename) {
+    var map = System.getSourceMap(filename);
+    if (map) {
+      return {
+        url: filename,
+        map: map
+      };
+    }
+  }
+});
 
 Reflect.global.System = System;
 System.map = System.semverMap(System.version);

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

@@ -21,104 +21,39 @@
 
 var path = require('path');
 var traceur = require('./traceur.js');
-var AttachModuleNameTransformer =
-    traceur.codegeneration.module.AttachModuleNameTransformer;
-var ErrorReporter = traceur.util.CollectingErrorReporter;
-var FromOptionsTransformer = traceur.codegeneration.FromOptionsTransformer;
-var PureES6Transformer = traceur.codegeneration.PureES6Transformer;
-var Parser = traceur.syntax.Parser;
-var SourceFile = traceur.syntax.SourceFile;
-var SourceMapGenerator = traceur.outputgeneration.SourceMapGenerator;
-var TreeWriter = traceur.outputgeneration.TreeWriter;
-var traceurOptions = traceur.options;
 
-function merge(dest) {
-  var src, i;
-  for (i = 1; i < arguments.length; i++) {
-    src = arguments[i];
-    Object.keys(src).forEach(function(key) {
-      dest[key] = src[key];
-    });
-  }
+var NodeCompilerModule = require('./NodeCompiler.js');
+var NodeCompiler = NodeCompilerModule.NodeCompiler;
 
-  return dest;
+var recursiveModuleCompile = require('./recursiveModuleCompile.js');
+var compileAllJsFilesInDir = require('./compileAllJsFilesInDir.js');
+
+var Compiler = traceur.Compiler;
+
+function compile(src, options, sourceName, outputName) {
+  sourceName = sourceName || '<compile-source>';
+  outputName = outputName || '<compile-output>';
+  return new NodeCompiler(Compiler.commonJSOptions(options)).
+      compile(src, sourceName, outputName);
 }
 
 // The absolute path to traceur-runtime.js -- the file that should be executed
 // if you want to run Traceur-compiled scripts when the compiler isn't present.
-var RUNTIME_PATH = path.join(__dirname, '../../bin/traceur-runtime.js');
-
-/**
- * Compile ES6 source code with Traceur.
- *
- * TODO(vojta): Support source maps.
- *
- * @param  {string} content ES6 source code.
- * @param  {Object=} options Traceur options.
- * @return {string} Transpiled ES5 code.
- */
-function compile(content, options) {
-  options = merge({
-    outputLanguage: 'es5',
-    modules: 'commonjs',
-    filename: '<unknown file>',
-    sourceMap: false,
-    cwd: process.cwd(),
-    moduleName: false
-  }, options || {});
-
-  var moduleName = options.moduleName;
-
-  traceurOptions.reset();
-  merge(traceurOptions, options);
-
-  var errorReporter = new ErrorReporter();
-  var sourceFile = new SourceFile(options.filename, content);
-  var parser = new Parser(sourceFile, errorReporter);
-  var tree = parser.parseModule();
-  var transformer;
-  if (moduleName === true || options.modules == 'register' || options.modules == 'inline') {
-    moduleName = options.filename.replace(/\.js$/, '');
-    moduleName = path.relative(options.cwd, moduleName).replace(/\\/g,'/');
-  }
-  if (moduleName) {
-    transformer = new AttachModuleNameTransformer(moduleName);
-    tree = transformer.transformAny(tree);
-  }
-
-  if (options.outputLanguage.toLowerCase() === 'es6') {
-    transformer = new PureES6Transformer(errorReporter);
-  } else {
-    transformer = new FromOptionsTransformer(errorReporter);
-  }
-
-  var transformedTree = transformer.transform(tree);
-
-  if (errorReporter.hadError()) {
-    return {
-      js: null,
-      errors: errorReporter.errors,
-      sourceMap: null
-    };
-  }
-
-  var treeWriterOptions = {};
-
-  if (options.sourceMap) {
-    treeWriterOptions.sourceMapGenerator = new SourceMapGenerator({
-      file: options.filename,
-      sourceRoot: null
-    });
-  }
-
-  return {
-    js: TreeWriter.write(transformedTree, treeWriterOptions),
-    errors: errorReporter.errors,
-    sourceMap: treeWriterOptions.sourceMap || null
-  };
-};
+var RUNTIME_PATH = path.join(__dirname, '../../bin/traceur-runtime.js').replace(/\\/g, '/');
 
 // extend traceur module
-module.exports = Object.create(traceur);
-module.exports.compile = compile;
-module.exports.RUNTIME_PATH = RUNTIME_PATH;
+module.exports = {
+  __proto__: traceur,
+  recursiveModuleCompileToSingleFile:
+      recursiveModuleCompile.recursiveModuleCompileToSingleFile,
+  forEachRecursiveModuleCompile:
+      recursiveModuleCompile.forEachRecursiveModuleCompile,
+  compileAllJsFilesInDir:
+    compileAllJsFilesInDir.compileAllJsFilesInDir,
+  NodeCompiler: NodeCompiler,
+  compile: compile,
+  commonJSOptions: Compiler.commonJSOptions,
+  amdOptions: Compiler.amdOptions,
+  closureOptions: Compiler.closureOptions,
+  RUNTIME_PATH: RUNTIME_PATH
+};

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

@@ -15,6 +15,7 @@
 'use strict';
 
 var path = require('path');
+var glob = require('glob');
 var commandLine;
 var cmdName = path.basename(process.argv[1]);
 try {
@@ -26,7 +27,7 @@ try {
 }
 commandLine.setMaxListeners(100);
 
-var traceur = require('./traceur.js');
+var traceurAPI = require('./api.js');
 var interpret = require('./interpreter.js');
 
 // The System object requires traceur, but we want it set for everything that
@@ -42,14 +43,15 @@ 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('--sourcemap', 'Generate source maps');
-commandLine.on('sourcemap', function() {
-  commandLine.sourceMaps = traceur.options.sourceMaps = true;
-});
-
 commandLine.option('--longhelp', 'Show all known options');
 commandLine.on('longhelp', function() {
   commandLine.help();
@@ -95,7 +97,8 @@ commandLine.on('--help', function() {
   console.log('');
 });
 
-traceur.options.addOptions(commandLine);
+var commandOptions = new traceurAPI.util.CommandOptions();
+traceurAPI.util.addOptions(commandLine, commandOptions);
 
 commandLine.usage('[options] [files]');
 
@@ -106,8 +109,17 @@ commandLine.command('*').action(function() {
     }
   });
 
+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;
+
+// Set the global options for back compat, but try to use options by argument.
+traceurAPI.options.setFromObject(commandOptions);
+
 if (!shouldExit && !rootSources.length) {
   // TODO: Start trepl
   console.error('\n  Error: At least one input file is needed');
@@ -115,27 +127,80 @@ if (!shouldExit && !rootSources.length) {
   process.exit(1);
 }
 
-var compiler = require('./compiler.js');
-var compileToSingleFile = compiler.compileToSingleFile;
-var compileToDirectory = compiler.compileToDirectory;
 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 isSingleFileCompile = /\.js$/.test(out);
-    if (isSingleFileCompile)
-      compileToSingleFile(out, rootSources, commandLine.sourceMaps);
-    else
-      compileToDirectory(out, rootSources, commandLine.sourceMaps);
+    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');
-    var compileAllJsFilesInDir =
-        require('./compile-single-file.js').compileAllJsFilesInDir;
-    compileAllJsFilesInDir(dir, rootSources[0].name, true);
+    traceurAPI.compileAllJsFilesInDir(dir, rootSources[0].name, commandOptions);
   } else {
     rootSources.forEach(function(obj) {
-      interpret(path.resolve(obj.name));
+      interpret(path.resolve(obj.name), commandOptions);
     });
   }
 }

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

@@ -0,0 +1,40 @@
+// 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 glob = require('glob');
+var path = require('path');
+var NodeCompiler = require('./NodeCompiler.js').NodeCompiler;
+
+function compileAllJsFilesInDir(inputDir, outputDir, options) {
+  inputDir = path.normalize(inputDir).replace(/\\/g, '/');
+  outputDir = path.normalize(outputDir).replace(/\\/g, '/');
+  glob(inputDir + '/**/*.js', {}, function (er, files) {
+    if (er)
+      throw new Error('While scanning ' + inputDir + ': ' + er);
+
+    files.forEach(function(inputFilePath) {
+      var outputFilePath = inputFilePath.replace(inputDir, outputDir);
+      var compiler = new NodeCompiler(options);
+      compiler.compileSingleFile(inputFilePath, outputFilePath, function(err) {
+        throw new Error('While reading ' + inputFilePath + ': ' + err);
+      });
+    });
+  });
+}
+
+module.exports = {
+  compileAllJsFilesInDir: compileAllJsFilesInDir
+};