Merge branch 'feature/options' into develop

* feature/options:
  Closes #46. Add support for babel global options.
  Remove parsing of booleans.

index.js

@@ -1,44 +1,32 @@
-var loaderUtils = require('loader-utils'),
-    babel = require('babel-core'),
-    crypto = require('crypto'),
+var crypto = require('crypto'),
     fs = require('fs'),
-    path = require('path'),
     os = require('os'),
+    path = require('path'),
     zlib = require('zlib'),
-    version = require('./package').version,
-    toBoolean = function (val) {
-        if (val === 'true') { return true; }
-        if (val === 'false') { return false; }
-        return val;
-    };
+    assign = require('object-assign'),
+    babel = require('babel-core'),
+    loaderUtils = require('loader-utils'),
+    version = require('./package').version;
 
 module.exports = function (source, inputSourceMap) {
 
-    var options = loaderUtils.parseQuery(this.query),
+    var queryOptions = loaderUtils.parseQuery(this.query),
         callback = this.async(),
-        result, cacheDirectory;
+        options = assign({}, this.options.babel, queryOptions, {
+            sourceMap: this.sourceMap,
+            inputSourceMap: inputSourceMap,
+            filename: loaderUtils.getRemainingRequest(this),
+        }),
+        result;
 
     if (this.cacheable) {
         this.cacheable();
     }
 
-    // Convert 'true'/'false' to true/false
-    options = Object.keys(options).reduce(function (accumulator, key) {
-        accumulator[key] = toBoolean(options[key]);
-        return accumulator;
-    }, {});
-
-    options.sourceMap = this.sourceMap;
-    options.inputSourceMap = inputSourceMap;
-    options.filename = loaderUtils.getRemainingRequest(this);
-
-    cacheDirectory = options.cacheDirectory;
-    delete options.cacheDirectory;
-
-    if (cacheDirectory === true) cacheDirectory = os.tmpdir();
+    if (options.cacheDirectory === true) options.cacheDirectory = os.tmpdir();
 
-    if (cacheDirectory){
-        cachedTranspile(cacheDirectory, source, options, onResult);
+    if (options.cacheDirectory){
+        cachedTranspile(options.cacheDirectory, source, options, onResult);
     } else {
         onResult(null, transpile(source, options));
     }

test/fixtures/basic.js

@@ -1,4 +1,4 @@
-import test from '../../!./test.js';
+import test from './test.js';
 
 class App {
     constructor(arg='test') {

test/fixtures/experimental.js

@@ -0,0 +1,18 @@
+/*jshint esnext:true*/
+
+let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };
+let n = { x, y, ...z };
+
+// Array comprehensions
+var results = [
+  for(c of customers)
+    if (c.city == "Seattle")
+      { name: c.name, age: c.age }
+]
+
+// Generator comprehensions
+var results = (
+  for(c of customers)
+    if (c.city == "Seattle")
+      { name: c.name, age: c.age }
+)

test/options.test.js

@@ -0,0 +1,120 @@
+var fs = require('fs'),
+    path = require('path'),
+    assign = require('object-assign'),
+    expect = require('expect.js'),
+    mkdirp = require('mkdirp'),
+    rimraf = require('rimraf'),
+    webpack = require('webpack');
+
+describe('Options', function () {
+
+    var outputDir = path.resolve(__dirname, './output'),
+        babelLoader = path.resolve(__dirname, '../'),
+
+        globalConfig = {
+            entry: './test/fixtures/basic.js',
+            output: {
+                path: outputDir,
+                filename: '[id].options.js'
+            },
+            module: {
+                loaders: [
+                    {
+                        test: /\.jsx?/,
+                        loader: babelLoader,
+                        exclude: /node_modules/
+                    }
+                ]
+            }
+        };
+
+    // Clean generated cache files before each test
+    // so that we can call each test with an empty state.
+    beforeEach(function (done) {
+        rimraf(outputDir, function (err) {
+            if (err) { return done(err); }
+            mkdirp(outputDir, done);
+        });
+    });
+
+    it('should interpret options given to the loader', function (done) {
+
+        var config = assign({}, globalConfig, {
+            entry: './test/fixtures/experimental.js',
+            module: {
+                loaders: [{
+                    test: /\.jsx?/,
+                    loader: babelLoader + '?experimental',
+                    exclude: /node_modules/
+                }]
+            }
+        });
+
+        webpack(config, function (err, stats) {
+            expect(err).to.be(null);
+
+            fs.readdir(outputDir, function (err, files) {
+                expect(err).to.be(null);
+                expect(files).to.not.be.empty();
+
+                done();
+            });
+        });
+    });
+
+    it('should interpret options given globally', function (done) {
+
+        var config = assign({}, globalConfig, {
+            entry: './test/fixtures/experimental.js',
+            babel: {
+                experimental: true
+            },
+            module: {
+                loaders: [{
+                    test: /\.jsx?/,
+                    loader: babelLoader,
+                    exclude: /node_modules/
+                }]
+            }
+        });
+
+        webpack(config, function (err, stats) {
+            expect(err).to.be(null);
+
+            fs.readdir(outputDir, function (err, files) {
+                expect(err).to.be(null);
+                expect(files).to.not.be.empty();
+
+                done();
+            });
+        });
+    });
+
+    it('should give priority to loader options', function (done) {
+        var config = assign({}, globalConfig, {
+            entry: './test/fixtures/experimental.js',
+            babel: {
+                experimental: false
+            },
+            module: {
+                loaders: [{
+                    test: /\.jsx?/,
+                    loader: babelLoader + '?experimental',
+                    exclude: /node_modules/
+                }]
+            }
+        });
+
+        webpack(config, function (err, stats) {
+            expect(err).to.be(null);
+
+            fs.readdir(outputDir, function (err, files) {
+                expect(err).to.be(null);
+                expect(files).to.not.be.empty();
+
+                done();
+            });
+        });
+    });
+
+});