sprockets-commoner 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7be0d75114fb75a73b272d1493290b864cce8455
+  data.tar.gz: 3c98183d4ecfc9ab3824ece0acf091255f9df219
+SHA512:
+  metadata.gz: 6985592443fef03121a57c8a8e1f3c37e684a2fedb0561014f8c242f2629fccf6dc2f3c30789494b4a41eececaccde49424a40b858b7a7e11ad3c204093da44e
+  data.tar.gz: 16d3679cb215ca29fd2c8b1513cfb09704096ab31cf368ad42e5a7c8b6a41bbd13e3344ddfc0bbd89ee9f38119428f257ba3b4ab9749dec58dd896c2d3cf9307

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+node_modules
+npm-debug.log

data/.nvmrc

@@ -0,0 +1 @@
+v5.8.0

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at bouke@shopify.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/README.md

@@ -0,0 +1,205 @@
+# Sprockets::Commoner
+
+`Sprockets::Commoner` is a gem that enables JavaScript package and Babel transformation in Sprockets.
+
+## Features
+
+* Compile JavaScript modules into a single bundle.
+* Run Babel transforms.
+* Easy setup. We adhere to the Rails Way™ and don't require any additional configuration for the simplest and most common set ups.
+* Integrate tightly into Sprockets/Rails. You can use any of Sprockets' features like ERB inside your files without having to jump through crazy hoops.
+* Designed to emit code that compresses incredibly well. The code generated will be smaller than webpack or browserify.
+* Use `process.env` inside your JavaScript. This will also run on anything in `node_modules` (e.g. Babel), to ensure dependencies are also compressed optimally.
+* Automatic deduplication of Babel helpers. No need to use `babel-runtime`, as commoner will automatically detect which helpers are used and share them between modules in a way that compressed very well.
+
+## Setup
+
+### Requirements
+
+1. Ruby v2+.
+2. Rails/Any other application that uses Sprockets.
+2. NPM v3+. We only support version 3 because commoner doesn't do any sort of deduplication of dependencies, so you could end up with a huge bundle if you don't want out. We only test against version 3, so you will definitely run into issues when running version 2.
+3. We recommend and support version 4+ of Node.js.
+
+### 10-second simple set up
+
+To get started, let's begin with the simplest possible set up: just enabling resolving of `require`.
+
+1. Add `sprockets-commoner` to Gemfile, run `bundle install`, and restart your Rails server.
+1. Add package.json with `babel-core` version 6 and any packages you want. For the example, we'll use the excellent [lodash](https://lodash.com) library. `npm install -S babel-core@6 lodash`
+1. `require` your client-side JavaScript packages from `application.js`!
+```
+var _ = require('lodash');
+
+console.log(_.map([1, 2, 3], function(n) { return n * 3; }));
+```
+
+### Enabling Babel transforms
+
+1. Install any Babel plugins or presets you want to use. We'll use the default ES2015 preset; `npm install babel-preset-es2015`.
+1. Add a `.babelrc` with you required configuration. We just need to do `echo '{presets: ["es2015"]}' > .babelrc`.
+1. Use any feature you want! For example, let's use `import` and arrow functions in our `application.js`:
+
+```
+import {map} from 'lodash';
+
+console.log(map([1, 2, 3], (n) => n * 3));
+```
+
+### Advanced configuration
+
+#### Fine-tuned selection of files to process
+
+By default, commoner will process any file under the application root directory. If you want more fine-tuned control over which files to process, you can specify which paths to include or exclude. To do so, you will need to re-register the Sprockets processor. For example:
+
+```
+# In config/initializers/sprockets_commoner.rb
+Rails.application.config.assets.configure do |env|
+  env.unregister_postprocessor('application/javascript', Sprockets::Commoner::Processor)
+  env.register_postprocessor('application/javascript', Sprockets::Commoner::Processor.new(
+    env.root,
+    # include, exclude, and babel_exclude patterns can be path prefixes or regexes.
+    # Explicitely list paths to include. The default is `[env.root]`
+    include: ['app/assets/javascripts/subdirectory'],
+    # List files to ignore and not process require calls or apply any Babel transforms to. Default is empty.
+    exclude: [/ignored/],
+    # Anything listed in babel_exclude has its require calls resolved, but no transforms listed in .babelrcs applied.
+    # Default is [/node_modules/]
+    babel_exclude: [/node_modules/]
+  ))
+end
+```
+
+## Testing with Teaspoon
+
+Teaspoon is not compatible with commoner by default. Under `test/demo` you can find a demo Rails application, containing a setup with Teaspoon. The key change is a custom boot partial and JavaScript file, found under `spec/javascripts/fixtures/teaspoon/suite`. Simply copy those two files under `fixtures/teaspoon/suite` in your JavaScript tests, make necessary changes to `boot.js.erb` to point to your test files, and you should be good to go.
+
+## CoffeeScript interoperability
+
+Commoner is designed from the start to facilitate a transition from CoffeeScript to ES2015.
+
+### Importing CoffeeScript files
+
+Any JavaScript file can `require` a CoffeeScript file, which will cause that CoffeeScript file to be scanned for a global variable reference and the `require` call to be replaced with a reference.
+If we have the following two files:
+
+```
+# file.coffee
+class window.ImportantClass
+```
+
+```
+// main.js
+var klass = require('./file');
+
+new klass();
+```
+
+Then the second file will just be compiled down to `new window.ImportantClass()`. Importing global references works for global assignments and class definitions.
+
+### Expose
+
+We have added a custom directive that makes it very easy to expose an ES2015 module to the global namespace so it can be used by CoffeeScript files or any other code. For example:
+
+```
+'expose window.MyClass`;
+
+export default class MyClass {}
+```
+
+`expose` will use the default export if available, otherwise the whole module namespace will be assigned to the global variable. For example:
+
+```
+// constants.js
+'expose window.Constants';
+
+export const A = 1;
+export const B = 2;
+export const C = 3;
+```
+
+This will make `window.Constants` equal `{A: 1, B: 2, C: 3}`.
+
+## Methodology
+
+Commoner registers a postprocessor that takes any `application/javascript` file and passes it through Babel.
+
+### `require` support
+
+`Sprockets::Commoner` enables support for `require()` by replacing `require` function calls with variable references. It does this by assigning every file a unique identifier based on their filename. For example, if the file you're referencing is located at `<root>/node_modules/package/index.js` it will get the name `__commoner_module__node_modules$package$index_js`. Any file that then `require`s this specific file will have that `require` call replaced with the identifier.
+reference.
+
+The Babel plugin also communicates back any files that were required to make sure they are included by Sprockets. `Sprockets::Commoner` depends on the topological ordering that Sprockets does to make sure any module that is needed is instantiated before it is used.
+
+### Example
+
+After the regular Babel plugins are done doing their thing, `babel-plugin-commoner-internal` kicks in, which is commoner's plugin that does the actual resolving. This plugin does the following things:
+
+* It finds any `require` calls and rewires them to variable references (as detailed in [`require` support](#require-support))
+* It wraps the module in a function and supplies it with `module` and `exports`. The end value of `module.exports` gets assigned to the module identifier, which is referenced by other files (as specified in '`require` support') Example:
+
+```
+var __commoner_module__node_modules$package$index_js = __commoner_initialize_module__(function (module, exports) {
+  exports.default = 123;
+});
+```
+* If these is an expose directive at the top of the file, it assigns `module.exports` to the specified variable. For example, if the top of the file contains `'expose window.Whatever';` it will assign `exports.default` if there is a default, otherwise it just assigns `exports`. Therefore if our file has `expose window.Whatever` and no default, it will get `window.Whatever = exports;` appended to it.
+
+#### Bundling
+
+After all the files have been transformed, there is a bundle step which combines all of the processed JavaScript modules together. It then prepends an initializer function and all the Babel helpers (which are shared between all modules).
+
+For example, if we have the following two files:
+
+```
+// module.js
+export default function a() {
+  return 1;
+};
+```
+
+```
+// application.js
+import a from './module';
+
+a();
+```
+
+We will end up with the following (browser-runnable) file:
+
+```
+!function() {
+var __commoner_initialize_module__ = function(f) {
+  var module = {exports: {}};
+  f.call(module.exports, module, module.exports);
+  return module.exports;
+};
+var global = window;
+var __commoner_helper__interopRequireDefault = function (obj) {
+  return obj && obj.__esModule ? obj : {
+    default: obj
+  };
+};
+var __commoner_module__app$assets$javascripts$module_js = __commoner_initialize_module__(function (module, exports) {
+  "use strict";
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.default = a;
+  function a() {
+    return 1;
+  };
+});
+var __commoner_module__app$assets$javascripts$application_js = __commoner_initialize_module__(function (module, exports) {
+  'use strict';
+
+  var _module2 = __commoner_helper__interopRequireDefault(__commoner_module__app$assets$javascripts$module_js);
+
+  (0, _module2.default)();
+});
+}();
+```
+
+This file is meant to be compressed, and does incredibly well when processed by UglifyJS.
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :spec

data/circle.yml

@@ -0,0 +1,13 @@
+machine:
+  node:
+    version: v5.7.0
+  ruby:
+    version: 2.2.2
+
+dependencies:
+  override:
+    - script/setup
+
+test:
+  override:
+    - script/test

data/js/babel-plugin-sprockets-commoner-internal/.gitignore

@@ -0,0 +1,2 @@
+/node_modules
+npm-debug.log

data/js/babel-plugin-sprockets-commoner-internal/README.md

@@ -0,0 +1,24 @@
+# babel-plugin-commoner
+
+## Usage
+
+`babel-plugin-commoner` should be included in your `.babelrc` by adding `commoner`. You can't install it through npm, but this directory is automatically added to the path by the Sprockets plugin.
+
+## Options
+
+* `globals`: A mapping of module name to global variable name, which will ovveride any import of that package with a global variable reference.
+
+## Example
+
+```json
+{
+  presets: ["es2015"],
+  plugins: [
+    ["commoner", {
+      globals: {
+        "jquery": "$"
+      }
+    }]
+  ]
+}
+```

data/js/babel-plugin-sprockets-commoner-internal/index.js

@@ -0,0 +1,265 @@
+'use strict';
+if (typeof Object.assign != 'function') {
+  (function () {
+    Object.assign = function (target) {
+      'use strict';
+      if (target === undefined || target === null) {
+        throw new TypeError('Cannot convert undefined or null to object');
+      }
+
+      var output = Object(target);
+      for (var index = 1; index < arguments.length; index++) {
+        var source = arguments[index];
+        if (source !== undefined && source !== null) {
+          for (var nextKey in source) {
+            if (source.hasOwnProperty(nextKey)) {
+              output[nextKey] = source[nextKey];
+            }
+          }
+        }
+      }
+      return output;
+    };
+  })();
+}
+
+var fs = require('fs');
+var dirname = require('path').dirname;
+var resolve = require('browser-resolve').sync;
+
+module.exports = function (context) {
+  var t = context.types;
+  var exposeTemplate = context.template("$0 = exports['default'] != null ? exports['default'] : exports;");
+
+  var opts = null;
+  var rootRegex = null;
+  var identifierRegex = null;
+
+  function createIdentifierRegex() {
+    var globals = ['window'].concat(opts.globalNamespaces).map(function(namespace) {
+      return namespace + '\\.';
+    });
+
+    // Construct regex with prefixes which denote globals (like window.Something, @Something, or anything else in opts.globalNamespaces)
+    var globalObject = '(?:@|' + globals.join('|') + ')';
+    var validIdentifier = '[a-zA-Z][_a-zA-Z0-9]*';
+    // Look for identifiers that look like 'window.Something' or 'Shopify.Something'
+    var validAssignment = '(' + globalObject + validIdentifier + '(?:\\.' + validIdentifier + ')*)';
+    // Look for 'window.Something =' or 'class window.Something'
+    return '^(?:(?:' + validAssignment + '\\s*=)|(?:class ' + validAssignment + '))';
+  }
+
+  /*
+   * BIGGEST HACK OF __ALL_TIME__
+   * If we're requiring a CoffeeScript file, we're going to be assuming that we're assigning to the global namespace in that file.
+   * so, use a RegExp to find out that variable definition. (yep)
+   */
+  function findDeclarationInCoffeeFile(path) {
+    var contents = fs.readFileSync(path);
+    var identifiers = [];
+
+    for (var regexp = new RegExp(identifierRegex, 'gm'), find = regexp.exec(contents); find != null; find = regexp.exec(contents)) {
+      identifiers.push(find[1] || find[2]);
+    }
+
+    if (identifiers.length === 0) {
+      throw new Error('No identifiers found in ' + path);
+    } else if (identifiers.length > 1) {
+      throw new Error('Multiple identifiers found in ' + path);
+    }
+
+    return identifiers[0].replace(/^@/, 'window.');
+  }
+
+  function isRequire(path) {
+    return path.isCallExpression() && path.get('callee').isIdentifier({ name: 'require' }) && !path.scope.hasBinding('require');
+  }
+
+  // Get the target path from a require call
+  function requireTarget(path) {
+    var evaluate = path.get('arguments')[0].evaluate();
+    if (!evaluate.confident || path.node.arguments.length !== 1) {
+      return null;
+    }
+
+    var target = evaluate.value;
+    if (typeof target !== 'string') {
+      throw new Error('Invalid require call, string expected');
+    }
+    return target;
+  }
+
+  // Find any 'expose <name>' directive and get back the value of '<name>'
+  function findExpose(directives) {
+    var result = void 0;
+    for (var i = 0; i < directives.length; i++) {
+      if (result = /^expose ([A-Za-z\.]+)$/.exec(directives[i].value.value)) {
+        directives.splice(i, 1);
+        return result[1];
+      }
+    }
+    return null;
+  }
+
+
+  // Transform a path into a variable name
+  function pathToIdentifier(path) {
+    var escapedPath = path.replace(rootRegex, '').replace(/[^a-zA-Z0-9_]/g, function (match) {
+      if (match === '/') {
+        return '$';
+      } else {
+        return '_';
+      }
+    });
+    return '__commoner_module__' + escapedPath;
+  }
+
+  function resolveTarget(file, path) {
+    var name = void 0;
+    if (opts.globals != null && (name = opts.globals[path]) != null) {
+      return name;
+    } else {
+      var resolvedPath = resolve(path, opts);
+      file.metadata.required.push(resolvedPath);
+
+      // Check if the path is under sourceRoot
+      var root = file.opts.sourceRoot;
+      if (!rootRegex.test(resolvedPath)) {
+        throw new Error("Cannot find module '" + path + "' from '" + dirname(file.opts.filename) + "' under '" + root + "'");
+      }
+
+      if (/\.coffee$/.test(resolvedPath)) {
+        // If it's a coffee script file, look for global variable assignments
+        return findDeclarationInCoffeeFile(resolvedPath);
+      } else {
+        // Otherwise we just look for the module by referencing its Special Identifier™
+        return pathToIdentifier(resolvedPath);
+      }
+    }
+  }
+
+  var callRewriter = {
+    VariableDeclarator: function VariableDeclarator(path, state) {
+      var init = path.get('init');
+      if (!isRequire(init)) {
+        return;
+      }
+      var binding = path.scope.getBinding(path.node.id.name);
+      if (!binding.constant) {
+        return;
+      }
+
+      var target = requireTarget(init);
+      if (target == null) {
+        return;
+      }
+
+      var name = resolveTarget(state.file, target);
+      path.scope.rename(name);
+      path.scope.rename(path.node.id.name, name);
+      path.remove();
+    },
+    CallExpression: function CallExpression(path, state) {
+      if (!isRequire(path)) {
+        return;
+      }
+
+      var target = requireTarget(path);
+      if (target == null) {
+        return;
+      }
+
+      var replacement = resolveTarget(state.file, target);
+      switch (path.parent.type) {
+        case "ExpressionStatement":
+          // We just need to know there's a dependency, we can remove it then
+          path.remove();
+          break;
+        default:
+          // Otherwise we just look for the module by referencing its Special Identifier™
+          path.replaceWith(t.identifier(replacement));
+          break;
+      }
+    }
+  };
+
+  return {
+    pre: function pre(file) {
+      if (file.metadata.required == null) {
+        file.metadata.required = [];
+      }
+    },
+
+    visitor: {
+      MemberExpression: function MemberExpression(path) {
+        if (path.get("object").matchesPattern("process.env")) {
+          var key = path.toComputedKey();
+          if (t.isStringLiteral(key)) {
+            path.replaceWith(t.valueToNode(process.env[key.value]));
+          }
+        }
+      },
+      UnaryExpression: function UnaryExpression(path) {
+        if (!path.node.operator === 'typeof') {
+          return;
+        }
+
+        var argument = path.get('argument');
+        if (!path.get('argument').isIdentifier()) {
+          return;
+        }
+
+        var name = path.node.argument.name;
+        if (name !== 'module' && name !== 'exports') {
+          return;
+        }
+
+        if (path.scope.hasBinding(name)) {
+          return;
+        }
+
+        path.replaceWith(t.stringLiteral('object'));
+      },
+      Program: {
+        exit: function exit(path, state) {
+          // Get options from commoner-options and merge them with the options
+          // that were passed to this plugin in .babelrc
+          opts = {
+            globalNamespaces: [],
+            // We can get these from Sprockets
+            extensions: ['.js', '.json', '.coffee', '.js.erb', '.coffee.erb']
+          };
+
+          // Look for the sprockets-commoner plugin for extra options
+          state.file.opts.plugins.map(function (plugin) {
+            return plugin[1];
+          }).filter(function (opts) {
+            return opts != null && opts.__commoner_options;
+          }).forEach(function (plugin) {
+            return Object.assign(opts, plugin);
+          });
+
+          Object.assign(opts, state.opts, { basedir: dirname(state.file.opts.filename) });
+          rootRegex = new RegExp('^' + state.file.opts.sourceRoot + '/');
+          identifierRegex = createIdentifierRegex();
+
+          // Signal back to Sprockets that we're rewiring
+          state.file.metadata.commonerEnabled = true;
+
+          var node = path.node;
+          var identifier = pathToIdentifier(state.file.opts.filename);
+          var expose = findExpose(node.directives);
+          if (expose != null) {
+            node.body.push(exposeTemplate(t.identifier(expose)));
+          }
+
+          // Transform module to a variable assignment.
+          // This variable is then referenced by any dependant children.
+          node.body = [t.variableDeclaration('var', [t.variableDeclarator(t.identifier(identifier), t.callExpression(t.identifier('__commoner_initialize_module__'), [t.functionExpression(null, [t.identifier('module'), t.identifier('exports')], t.blockStatement(node.body, node.directives))]))])];
+          node.directives = [];
+          path.traverse(callRewriter, state);
+        }
+      }
+    }
+  };
+};

data/js/babel-plugin-sprockets-commoner-internal/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "babel-plugin-sprockets-commoner-internal",
+  "private": true,
+  "description": "Find require calls and resolve the library they're calling.",
+  "scripts": {
+    "test": "NODE_ENV=test mocha"
+  },
+  "devDependencies": {
+    "babel-core": "^6.2.1",
+    "babel-plugin-transform-es2015-arrow-functions": "^6.5.2",
+    "babel-plugin-transform-es2015-modules-commonjs": "^6.2.1",
+    "mocha": "^2.3.4"
+  }
+}

data/js/babel-plugin-sprockets-commoner/README.md

@@ -0,0 +1,3 @@
+# commoner-options
+
+This is a dummy Babel plugin that's just used to receive options from Sprockets.

data/js/babel-plugin-sprockets-commoner/index.js

@@ -0,0 +1,7 @@
+module.exports = function () {
+  return {
+    pre: function pre() {
+      this.opts.__commoner_options = true;
+    }
+  };
+};

data/js/babel-plugin-sprockets-commoner/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "babel-plugin-commoner-options",
+  "description": "A bogus plugin used for receiving options from Sprockets",
+  "private": true
+}

data/lib/sprockets/commoner.rb

@@ -0,0 +1,15 @@
+require 'sprockets'
+require 'sprockets/commoner/processor'
+require 'sprockets/commoner/bundle'
+
+module Sprockets
+  module Commoner
+  end
+
+  register_postprocessor 'application/javascript', ::Sprockets::Commoner::Processor
+  register_bundle_metadata_reducer 'application/javascript', :commoner_enabled, false, :|
+  register_bundle_metadata_reducer 'application/javascript', :commoner_used_helpers, Set.new, :+
+  register_bundle_processor 'application/javascript', ::Sprockets::Commoner::Bundle
+end
+
+require 'sprockets/commoner/railtie' if defined?(Rails)

data/lib/sprockets/commoner/bundle.rb

@@ -0,0 +1,57 @@
+require 'schmooze'
+
+module Sprockets
+  module Commoner
+    class Bundle < Schmooze::Base
+      dependencies generator: 'babel-generator.default',
+        babelHelpers: 'babel-helpers',
+        t: 'babel-types'
+
+      method :generate_helpers, <<-JS
+function(helpers) {
+  if (helpers.length === 0) {
+    return '';
+  }
+  var declaration = t.variableDeclaration('var',
+    helpers.map(function(helper) {
+      return t.variableDeclarator(t.identifier('__commoner_helper__' + helper), babelHelpers.get(helper));
+    })
+  );
+  return generator(declaration).code;
+}
+JS
+
+      PRELUDE = <<-JS.freeze
+!function() {
+var __commoner_initialize_module__ = function(f) {
+  var module = {exports: {}};
+  f.call(module.exports, module, module.exports);
+  return module.exports;
+};
+var global = window;
+JS
+
+      OUTRO = <<-JS.freeze
+
+}();
+JS
+      def self.instance(env)
+        @instance ||= new(env.root)
+      end
+
+      def self.call(input)
+        instance(input[:environment]).call(input)
+      end
+
+      def call(input)
+        return unless input[:metadata][:commoner_enabled]
+
+        used_helpers = input[:metadata][:commoner_used_helpers]
+        helpers = generate_helpers(used_helpers.to_a)
+        {
+          data: "#{PRELUDE}#{helpers}\n#{input[:data]}#{OUTRO}"
+        }
+      end
+    end
+  end
+end

data/lib/sprockets/commoner/processor.rb

@@ -0,0 +1,174 @@
+require 'schmooze'
+require 'open3'
+
+module Sprockets
+  module Commoner
+    class Processor < Schmooze::Base
+      BABELRC_FILE = '.babelrc'.freeze
+      PACKAGE_JSON = 'package.json'.freeze
+      JS_PACKAGE_PATH = File.expand_path('../../../js', __dir__)
+      ALLOWED_EXTENSIONS = /\.js(?:\.erb)?\z/
+
+      dependencies babel: 'babel-core', commoner: 'babel-plugin-sprockets-commoner-internal'
+
+      method :version, 'function() { return [process.version, babel.version]; }'
+      method :transform, %q{function(code, opts, commonerOpts) {
+  try {
+    var file = new babel.File(opts);
+
+    // The actual helpers are generated in bundle.rb
+    file.set("helperGenerator", function(name) { return babel.types.identifier('__commoner_helper__' + name); });
+
+    var commonerPlugin = babel.OptionManager.normalisePlugin(commoner);
+    file.buildPluginsForOptions({plugins: [[commonerPlugin, commonerOpts]]});
+
+    return file.wrap(code, function () {
+      file.addCode(code);
+      file.parseCode(code);
+      return file.transform();
+    });
+  } catch (err) {
+    if (err.codeFrame != null) {
+      err.message += "\n";
+      err.message += err.codeFrame;
+    }
+    throw err;
+  }
+}}
+      def self.instance(env)
+        @instance ||= new(env.root)
+      end
+
+      def self.call(input)
+        instance(input[:environment]).call(input)
+      end
+
+      attr_reader :include, :exclude, :babel_exclude
+      def initialize(root, include: [root], exclude: [], babel_exclude: [/node_modules/])
+        @include = include.map {|path| expand_to_root(path, root) }
+        @exclude = exclude.map {|path| expand_to_root(path, root) }
+        @babel_exclude = babel_exclude.map {|path| expand_to_root(path, root) }
+        super(root, 'NODE_PATH' => JS_PACKAGE_PATH)
+      end
+
+      def call(input)
+        @cache_key ||= [
+          self.class.name,
+          version,
+          VERSION,
+        ].freeze
+
+        filename = input[:filename]
+
+        return unless should_process?(filename)
+
+        @env = input[:environment]
+        @required = input[:metadata][:required].to_a
+        insertion_index = @required.index(input[:uri]) || -1
+        @dependencies = Set.new(input[:metadata][:dependencies])
+
+
+        babel_config = babelrc_data(filename)
+
+        result = input[:cache].fetch([filename, @cache_key, input[:data], babel_config]) do
+          transform(input[:data], options(input), paths: @env.paths)
+        end
+
+        if result['metadata'].has_key?('required')
+          result['metadata']['required'].each do |r|
+            asset = resolve(r, accept: input[:content_type], pipeline: :self)
+            @required.insert(insertion_index, asset)
+          end
+        end
+
+        {
+          data: result['code'],
+          dependencies: @dependencies,
+          required: Set.new(@required),
+
+          commoner_used_helpers: Set.new(input[:metadata][:commoner_used_helpers]) + result['metadata']['usedHelpers'],
+          commoner_enabled: input[:metadata][:commoner_enabled] | result['metadata']['commonerEnabled'],
+        }
+      end
+
+      private
+        def expand_to_root(path, root)
+          if path.is_a?(String)
+            File.expand_path(path, root)
+          else
+            path
+          end
+        end
+
+        def should_process?(filename)
+          return false unless ALLOWED_EXTENSIONS =~ filename
+          return false unless self.include.empty? || match_any?(self.include, filename)
+          return false if match_any?(self.exclude, filename)
+          true
+        end
+
+        def match_any?(patterns, filename)
+          patterns.any? { |pattern| pattern_match(pattern, filename) }
+        end
+
+        def pattern_match(pattern, filename)
+          if pattern.is_a?(String)
+            filename.start_with?(pattern)
+          else
+            pattern === filename
+          end
+        end
+
+        def babelrc_data(filename)
+          while filename != (filename = File.dirname(filename))
+            begin
+              name = File.join(filename, BABELRC_FILE)
+              data = File.read(name)
+              depend_on_file(name)
+              return data
+            rescue Errno::ENOENT
+              name = File.join(filename, PACKAGE_JSON)
+              data = package_babel_data(name)
+              if data
+                depend_on_file(name)
+                return JSON.dump(data)
+              else
+                nil
+              end
+            end
+          end
+          return nil
+        end
+
+        def package_babel_data(filename)
+          return JSON.parse(File.read(filename))['babel']
+        rescue Errno::ENOENT
+          return nil
+        end
+
+        def options(input)
+          # TODO(bouk): Fix sourcemaps. Sourcemaps are only available in Sprockets v4
+          {
+            'ast' => false,
+            'babelrc' => !match_any?(self.babel_exclude, input[:filename]),
+            'filename' => input[:filename],
+            'filenameRelative' => PathUtils.split_subpath(input[:load_path], input[:filename]),
+            'moduleRoot' => nil,
+            'sourceRoot' => @env.root,
+          }
+        end
+
+        def resolve(path, **kargs)
+          uri, deps = @env.resolve!(path, load_paths: [@env.root], **kargs)
+          @dependencies.merge(deps)
+          uri
+        end
+
+        def depend_on_file(path)
+          uri, deps = @env.resolve!(path, load_paths: [@env.root])
+          @dependencies.merge(deps)
+          uri
+        end
+    end
+  end
+end

data/lib/sprockets/commoner/railtie.rb

@@ -0,0 +1,11 @@
+module Sprockets
+  module Commoner
+    class Railtie < ::Rails::Railtie
+      initializer 'sprockets-commoner' do
+        # We need to disable debugging because otherwise Rails will include each file individually, while we need everything to be bundled up together into a single file.
+        config.assets.debug = false
+        config.assets.paths << 'node_modules'
+      end
+    end
+  end
+end

data/lib/sprockets/commoner/version.rb

@@ -0,0 +1,5 @@
+module Sprockets
+  module Commoner
+    VERSION = '0.1.0'
+  end
+end

data/sprockets-commoner.gemspec

@@ -0,0 +1,37 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sprockets/commoner/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sprockets-commoner"
+  spec.version       = Sprockets::Commoner::VERSION
+  spec.authors       = ["Bouke van der Bijl"]
+  spec.homepage      = 'https://github.com/Shopify/sprockets-commoner'
+  spec.email         = ["bouke@shopify.com"]
+  spec.license       = 'MIT'
+
+  spec.summary       = %q{Use Babel in Sprockets to compile modules for the browser}
+  spec.description   = %q{Sprockets::Commoner uses Node.JS to compile ES2015+ files to ES5 using Babel directly from NPM, without vendoring it.}
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|script|js\/babel-plugin-sprockets-commoner-internal\/test)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.add_dependency "sprockets", ">= 3", "< 4"
+  spec.add_dependency "schmooze", "~> 0.1.5"
+
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "coffee-script", "~> 2.4"
+  spec.add_development_dependency "uglifier", "~> 2.7"
+  spec.add_development_dependency "pry", "~> 0.10"
+end

metadata

@@ -0,0 +1,185 @@
+--- !ruby/object:Gem::Specification
+name: sprockets-commoner
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Bouke van der Bijl
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-05-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sprockets
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
+- !ruby/object:Gem::Dependency
+  name: schmooze
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.5
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: coffee-script
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: uglifier
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+description: Sprockets::Commoner uses Node.JS to compile ES2015+ files to ES5 using
+  Babel directly from NPM, without vendoring it.
+email:
+- bouke@shopify.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".nvmrc"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- README.md
+- Rakefile
+- circle.yml
+- js/babel-plugin-sprockets-commoner-internal/.gitignore
+- js/babel-plugin-sprockets-commoner-internal/README.md
+- js/babel-plugin-sprockets-commoner-internal/index.js
+- js/babel-plugin-sprockets-commoner-internal/node_modules/browser-resolve/LICENSE
+- js/babel-plugin-sprockets-commoner-internal/node_modules/browser-resolve/README.md
+- js/babel-plugin-sprockets-commoner-internal/node_modules/browser-resolve/empty.js
+- js/babel-plugin-sprockets-commoner-internal/node_modules/browser-resolve/index.js
+- js/babel-plugin-sprockets-commoner-internal/node_modules/browser-resolve/package.json
+- js/babel-plugin-sprockets-commoner-internal/node_modules/resolve/LICENSE
+- js/babel-plugin-sprockets-commoner-internal/node_modules/resolve/README.md
+- js/babel-plugin-sprockets-commoner-internal/node_modules/resolve/index.js
+- js/babel-plugin-sprockets-commoner-internal/node_modules/resolve/lib/async.js
+- js/babel-plugin-sprockets-commoner-internal/node_modules/resolve/lib/caller.js
+- js/babel-plugin-sprockets-commoner-internal/node_modules/resolve/lib/core.js
+- js/babel-plugin-sprockets-commoner-internal/node_modules/resolve/lib/core.json
+- js/babel-plugin-sprockets-commoner-internal/node_modules/resolve/lib/node-modules-paths.js
+- js/babel-plugin-sprockets-commoner-internal/node_modules/resolve/lib/sync.js
+- js/babel-plugin-sprockets-commoner-internal/node_modules/resolve/package.json
+- js/babel-plugin-sprockets-commoner-internal/package.json
+- js/babel-plugin-sprockets-commoner/README.md
+- js/babel-plugin-sprockets-commoner/index.js
+- js/babel-plugin-sprockets-commoner/package.json
+- lib/sprockets/commoner.rb
+- lib/sprockets/commoner/bundle.rb
+- lib/sprockets/commoner/processor.rb
+- lib/sprockets/commoner/railtie.rb
+- lib/sprockets/commoner/version.rb
+- sprockets-commoner.gemspec
+homepage: https://github.com/Shopify/sprockets-commoner
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Use Babel in Sprockets to compile modules for the browser
+test_files: []