webpack_rails 0.3.0 → 1.0.0

data/lib/webpack_rails/node_modules/xtend/immutable.js

@@ -0,0 +1,17 @@
+module.exports = extend
+
+function extend() {
+    var target = {}
+
+    for (var i = 0; i < arguments.length; i++) {
+        var source = arguments[i]
+
+        for (var key in source) {
+            if (source.hasOwnProperty(key)) {
+                target[key] = source[key]
+            }
+        }
+    }
+
+    return target
+}

data/lib/webpack_rails/node_modules/xtend/mutable.js

@@ -0,0 +1,15 @@
+module.exports = extend
+
+function extend(target) {
+    for (var i = 1; i < arguments.length; i++) {
+        var source = arguments[i]
+
+        for (var key in source) {
+            if (source.hasOwnProperty(key)) {
+                target[key] = source[key]
+            }
+        }
+    }
+
+    return target
+}

data/lib/webpack_rails/node_modules/xtend/package.json

@@ -0,0 +1,88 @@
+{
+  "name": "xtend",
+  "version": "4.0.0",
+  "description": "extend like a boss",
+  "keywords": [
+    "extend",
+    "merge",
+    "options",
+    "opts",
+    "object",
+    "array"
+  ],
+  "author": {
+    "name": "Raynos",
+    "email": "raynos2@gmail.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/Raynos/xtend.git"
+  },
+  "main": "immutable",
+  "scripts": {
+    "test": "node test"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "tape": "~1.1.0"
+  },
+  "homepage": "https://github.com/Raynos/xtend",
+  "contributors": [
+    {
+      "name": "Jake Verbaten"
+    },
+    {
+      "name": "Matt Esch"
+    }
+  ],
+  "bugs": {
+    "url": "https://github.com/Raynos/xtend/issues",
+    "email": "raynos2@gmail.com"
+  },
+  "licenses": [
+    {
+      "type": "MIT",
+      "url": "http://github.com/raynos/xtend/raw/master/LICENSE"
+    }
+  ],
+  "testling": {
+    "files": "test.js",
+    "browsers": [
+      "ie/7..latest",
+      "firefox/16..latest",
+      "firefox/nightly",
+      "chrome/22..latest",
+      "chrome/canary",
+      "opera/12..latest",
+      "opera/next",
+      "safari/5.1..latest",
+      "ipad/6.0..latest",
+      "iphone/6.0..latest"
+    ]
+  },
+  "engines": {
+    "node": ">=0.4"
+  },
+  "gitHead": "94a95d76154103290533b2c55ffa0fe4be16bfef",
+  "_id": "xtend@4.0.0",
+  "_shasum": "8bc36ff87aedbe7ce9eaf0bca36b2354a743840f",
+  "_from": "xtend@>=4.0.0 <5.0.0",
+  "_npmVersion": "1.4.15",
+  "_npmUser": {
+    "name": "raynos",
+    "email": "raynos2@gmail.com"
+  },
+  "maintainers": [
+    {
+      "name": "raynos",
+      "email": "raynos2@gmail.com"
+    }
+  ],
+  "dist": {
+    "shasum": "8bc36ff87aedbe7ce9eaf0bca36b2354a743840f",
+    "tarball": "http://registry.npmjs.org/xtend/-/xtend-4.0.0.tgz"
+  },
+  "directories": {},
+  "_resolved": "http://registry.npmjs.org/xtend/-/xtend-4.0.0.tgz",
+  "readme": "ERROR: No README data found!"
+}

data/lib/webpack_rails/node_modules/xtend/test.js

@@ -0,0 +1,63 @@
+var test = require("tape")
+var extend = require("./")
+var mutableExtend = require("./mutable")
+
+test("merge", function(assert) {
+    var a = { a: "foo" }
+    var b = { b: "bar" }
+
+    assert.deepEqual(extend(a, b), { a: "foo", b: "bar" })
+    assert.end()
+})
+
+test("replace", function(assert) {
+    var a = { a: "foo" }
+    var b = { a: "bar" }
+
+    assert.deepEqual(extend(a, b), { a: "bar" })
+    assert.end()
+})
+
+test("undefined", function(assert) {
+    var a = { a: undefined }
+    var b = { b: "foo" }
+
+    assert.deepEqual(extend(a, b), { a: undefined, b: "foo" })
+    assert.deepEqual(extend(b, a), { a: undefined, b: "foo" })
+    assert.end()
+})
+
+test("handle 0", function(assert) {
+    var a = { a: "default" }
+    var b = { a: 0 }
+
+    assert.deepEqual(extend(a, b), { a: 0 })
+    assert.deepEqual(extend(b, a), { a: "default" })
+    assert.end()
+})
+
+test("is immutable", function (assert) {
+    var record = {}
+
+    extend(record, { foo: "bar" })
+    assert.equal(record.foo, undefined)
+    assert.end()
+})
+
+test("null as argument", function (assert) {
+    var a = { foo: "bar" }
+    var b = null
+    var c = void 0
+
+    assert.deepEqual(extend(b, a, c), { foo: "bar" })
+    assert.end()
+})
+
+test("mutable", function (assert) {
+    var a = { foo: "bar" }
+
+    mutableExtend(a, { bar: "baz" })
+
+    assert.equal(a.bar, "baz")
+    assert.end()
+})

data/lib/webpack_rails/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "webpack_rails",
+  "version": "1.0.0",
+  "description": "",
+  "main": "webpack-dev-server.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "cors": "^2.7.1",
+    "express": "^4.13.3",
+    "is-array": "^1.0.1",
+    "is-object": "^1.0.1",
+    "is-string": "^1.0.4",
+    "js-string-escape": "^1.0.0",
+    "strip-ansi": "^3.0.0",
+    "webpack-hot-middleware": "^2.4.1",
+    "xtend": "^4.0.0"
+  }
+}

data/lib/webpack_rails/processor.rb

@@ -1,24 +1,43 @@
 require 'tilt'
 
-require_relative './sprockets_index_webpack'
-require_relative './task'
-
 module WebpackRails
   class Processor < Tilt::Template
+    def self.configure(webpack_task_config)
+      Class.new(Processor) do
+        self.config = webpack_task_config
+      end
+    end
+
+    def self.config=(new_config)
+      @config = new_config
+    end
+
+    def self.config
+      @config
+    end
+
     def prepare
     end
 
+    def rewrite_asset_paths(contents, context)
+      contents.gsub(/['"]\$asset_path\/([^'"]+?)['"]/) {|s| "'#{context.asset_path($1)}'" }
+    end
+
     def evaluate(context, locals)
       return data unless context.pathname.to_s.include?('.bundle')
 
-      # wait til webpack is done before loading
-      result = WebpackRails::Task.run_webpack
+      file_contents = nil
+      if self.class.config[:watch]
+        result = WebpackRails::Task.run_webpack(self.class.config)
+
+        result[:modules].map{|m| context.depend_on m}
 
-      result[:modules].map{|m| context.depend_on m}
+        file_contents = context.pathname.open.read # reload file contents after build
+      else
+        file_contents = data
+      end
 
-      bundle_contents = context.pathname.open.read
-      # rewrite $asset_paths in strings
-      bundle_contents.gsub(/['"]\$asset_path\/([^'"]+?)['"]/) {|s| "'#{context.asset_path($1)}'" }
+      rewrite_asset_paths(file_contents, context)
     end
   end
 end

data/lib/webpack_rails/require_directive_processor.rb

@@ -0,0 +1,51 @@
+require 'tilt'
+
+module WebpackRails
+  class RequireDirectiveProcessor < Tilt::Template
+    DIRECTIVE_PATTERN = /^.*?=\s*webpack_require\s+(.*?)\s*$/
+
+    def self.configure(webpack_task_config)
+      Class.new(RequireDirectiveProcessor) do
+        self.config = webpack_task_config
+      end
+    end
+
+    def self.config=(new_config)
+      @config = new_config
+    end
+
+    def self.config
+      @config
+    end
+
+    def prepare
+    end
+
+    def config
+      self.class.config
+    end
+
+    def dev_server_base_url
+      "#{config[:protocol]}://#{config[:host]}:#{config[:port]}"
+    end
+
+    def process_require(context, locals, bundle_filename)
+      if config[:dev_server]
+        if bundle_filename.end_with? '.js'
+          return %{document.write('<script src="#{dev_server_base_url}/#{bundle_filename}"></script>');}
+        end
+        return ''
+      end
+
+      # will be handled by normal sprockets require
+      context.require_asset(bundle_filename)
+      return ''
+    end
+
+    def evaluate(context, locals)
+      data.gsub(DIRECTIVE_PATTERN) do |match_text|
+        process_require(context, locals, $1)
+      end
+    end
+  end
+end

data/lib/webpack_rails/sprockets_environment.rb

@@ -0,0 +1,45 @@
+require 'sprockets'
+require 'sprockets/webpack_index'
+require 'webpack_rails/require_directive_processor'
+require 'webpack_rails/processor'
+
+module WebpackRails
+  class SprocketsEnvironment
+    DEFAULT_WEBPACK_TASK_CONFIG = {
+      dev_server: false,
+      protocol: 'http',
+      host: 'localhost',
+      port: 9876,
+    }
+
+    module EnvironmentWebpackInstanceMethods
+      def webpack_task_config=(new_webpack_task_config)
+        @webpack_task_config = new_webpack_task_config
+      end
+
+      def webpack_task_config
+        @webpack_task_config.merge(DEFAULT_WEBPACK_TASK_CONFIG).merge(@webpack_task_config)
+      end
+
+      def install_webpack_task_processors!
+        file_processor = WebpackRails::Processor.configure(webpack_task_config)
+        require_directive_processor = WebpackRails::RequireDirectiveProcessor.configure(webpack_task_config)
+
+        register_preprocessor 'application/javascript', file_processor
+        register_preprocessor 'text/css', file_processor
+        register_preprocessor 'application/javascript', require_directive_processor
+        register_preprocessor 'text/css', require_directive_processor
+      end
+
+      def index
+        Sprockets::WebpackIndex.new(self)
+      end
+    end
+
+    def self.enhance!(env, webpack_task_config)
+      env.extend(EnvironmentWebpackInstanceMethods)
+      env.webpack_task_config = webpack_task_config
+      env.install_webpack_task_processors!
+    end
+  end
+end

data/lib/webpack_rails/task.rb

@@ -28,8 +28,24 @@ module WebpackRails
         @webpack_gem_dir ||= File.dirname(File.expand_path(__FILE__))
       end
 
-      def webpack_task_script
-        @webpack_task_script ||= File.join(webpack_gem_dir, 'webpack-task.js')
+      def webpack_task_watch_script
+        @webpack_task_watch_script ||= File.join(webpack_gem_dir, 'webpack-task-watch.js')
+      end
+
+      def webpack_task_dev_server_script
+        @webpack_task_dev_server_script ||= File.join(webpack_gem_dir, 'webpack-task-dev-server.js')
+      end
+
+      def webpack_task_script(opts)
+        return webpack_task_watch_script if opts[:watch]
+        return webpack_task_dev_server_script if opts[:dev_server]
+        fail "can't determine which task to run"
+      end
+
+      def webpack_task_opts(opts)
+        opts.merge(
+          webpack_config_file: opts[:webpack_config_file] ? opts[:webpack_config_file].to_s : nil,
+        )
       end
 
       def app_node_path
@@ -47,26 +63,42 @@ module WebpackRails
         return_value
       end
 
-      def build_result
-        begin
-          JSON.parse(File.open(File.join(working_dir, 'webpack-build-result.json')).read)
-        rescue Errno::ENOENT => e
-          {modules: []}
+      # TODO: move to NodeTask
+      def alive?
+        current_pid = nil
+        alive = false
+        if @controller
+          begin
+            current_pid = @controller.pid
+          rescue Errno::ENOENT
+          end
+        end
+        if current_pid
+          begin
+            Process.getpgid(current_pid)
+            alive = true
+          rescue Errno::ESRCH
+          end
         end
+        alive
       end
 
-      def run_webpack(opts = nil)
-        result = nil
-        if ENV['DISABLE_WEBPACK']
-          return build_result
+      def build_once(webpack_task_config)
+        WebpackRails::Task.with_app_node_path do
+          webpack_cmd_script = `#{WebpackRails::Task.node_command} -e "process.stdout.write(require.resolve('webpack/bin/webpack.js'))"`
+          system "#{WebpackRails::Task.node_command} #{webpack_cmd_script} --config #{webpack_task_config[:webpack_config_file]}"
         end
+      end
 
+      def run_webpack(opts = {})
+        return if ENV['DISABLE_WEBPACK']
+
+        result = nil
         task_duration = Benchmark.realtime do
-          result = with_app_node_path do
+          with_app_node_path do
             begin
-              task = self.new
-              task.run(opts)
-              build_result
+              task = self.new(webpack_task_script(opts))
+              result = task.run(webpack_task_opts(opts))
             rescue NodeTask::Error => e
               raise self::Error.new(e)
             end
@@ -74,10 +106,11 @@ module WebpackRails
         end
 
         task_duration_ms = task_duration * 1000
-        if defined?(Rails) && task_duration_ms > 10
-          Rails.logger.info("Webpack: #{task_duration_ms.round(0)}ms")
+        if defined?(Rails) && result
+          if opts[:dev_server] && result[:started]
+            Rails.logger.info("Started webpack-dev-server in #{task_duration_ms.round(0)}ms")
+          end
         end
-
         result
       end
 
@@ -90,9 +123,5 @@ module WebpackRails
         wd
       end
     end
-
-    def initialize
-      super(self.class.webpack_task_script)
-    end
   end
 end

data/lib/webpack_rails/webpack-task-dev-server.js

@@ -0,0 +1,122 @@
+var fs = require('fs');
+var path = require('path');
+var xtend = require('xtend');
+var isArray = require('is-array');
+var isString = require('is-string');
+var isObject = require('is-object');
+var express = require('express');
+var cors = require('cors');
+
+// these modules are expected to be installed by the gem consumer (eg. the app)
+var webpackDevMiddleware = require('webpack-dev-middleware');
+var webpackHotMiddleware = require('webpack-hot-middleware');
+var webpack = require('webpack');
+
+var ErrorMessagePlugin = require('./ErrorMessagePlugin');
+
+var loggingToFile = Boolean(process.env.WEBPACK_TASK_LOGGING);
+
+process.on('exit', function(code) {
+  log(process.pid+' About to exit with code:', code);
+});
+
+var server = null;
+module.exports = function waitForServer(opts, done) {
+  if (server) {
+    log('webpack already running');
+    return done(null, {started: false});
+  }
+
+  log('starting webpack');
+  runWebpackDevServer(opts, function(err, createdServer) {
+    if (err) {
+      logErr(err);
+      done(err);
+    }
+
+    server = createdServer;
+    log('server started succesfully');
+    done(null, {started: true});
+  });
+};
+
+function runWebpackDevServer(opts, done) {
+  opts = opts || {};
+  opts.protocol = opts.protocol || 'http';
+  opts.host = opts.host || 'localhost';
+  opts.port = opts.port || 9876;
+  opts.webpack_config_file = opts.webpack_config_file || path.resolve('./config/webpack.config.js');
+
+  var devServerConfig;
+  try {
+    devServerConfig = makeDevServerConfig(opts);
+  } catch (err) {
+    done(err);
+  }
+
+  // create webpack compiler instance
+  var compiler = webpack(devServerConfig);
+
+  // create express app
+  var app = express();
+  app.use(cors({credentials: true, origin: true}));
+
+  app.use(webpackDevMiddleware(compiler, {
+    publicPath: devServerConfig.output.publicPath,
+  }));
+
+  app.use(webpackHotMiddleware(compiler));
+
+  // spawn server
+  var server = app.listen(opts.port, opts.host, function() {
+    log('pid '+process.pid+' listening on '+opts.host+':'+opts.port);
+    done(null, server);
+  });
+
+  return server;
+}
+
+function makeDevServerConfig(opts) {
+  var config = require(opts.webpack_config_file);
+  var publicUrl = opts.protocol+'://'+opts.host+':'+opts.port;
+
+  // extend webpack config
+  var devServerConfig = xtend(config, {
+    output: xtend(config.output || {}, {
+      publicPath: publicUrl+'/',
+      path: path.resolve(config.output.path),
+    }),
+    plugins: (config.plugins || []).concat([
+      new webpack.optimize.OccurenceOrderPlugin(),
+       // https://webpack.github.io/docs/webpack-dev-server.html#hot-module-replacement
+      new webpack.HotModuleReplacementPlugin(),
+      new ErrorMessagePlugin(),
+    ]),
+  });
+
+  // inject webpack-dev-server & hot module reload clients into each bundle
+  var devServerClientScripts = [
+      require.resolve('webpack-hot-middleware/client')+'?path='+publicUrl+'/__webpack_hmr',
+  ];
+
+  if (isArray(devServerConfig.entry) || isString(devServerConfig.entry)) {
+    devServerConfig.entry = devServerClientScripts.concat(devServerConfig.entry);
+  } else if (isObject(devServerConfig.entry)) {
+    devServerConfig.entry = {};
+    Object.keys(config.entry).forEach(function(key) {
+      devServerConfig.entry[key] = devServerClientScripts.concat(config.entry[key]);
+    });
+  } else {
+    throw new Error("couldn't add hot reload client to config.entry");
+  }
+
+  return devServerConfig;
+}
+
+function log(message) {
+  if (loggingToFile) fs.appendFileSync('log/webpack-task.log', new Date()+' -- '+message+'\n');
+}
+
+function logErr(err) {
+  log(err.toString()+' -- '+JSON.stringify(err.stack));  
+}

data/lib/webpack_rails/webpack.rake

@@ -8,12 +8,12 @@ namespace :webpack do
     end
   end
 
-  task :before_assets_precompile do
-    # with production config, sprockets index isn't updated correctly by the
-    # find_asset monkey patch. instead, we just run it before precompiling assets
-    WebpackRails::Task.run_webpack
+  task :build_once => :environment do
+    WebpackRails::Task.build_once(Rails.application.config.webpack_rails)
   end
 end
 
 # runs before every 'rake assets:precompile'
-Rake::Task['assets:precompile'].enhance(['webpack:before_assets_precompile'])
+# with production config, sprockets index isn't updated correctly by the
+# find_asset monkey patch. instead, we just run it before precompiling assets
+Rake::Task['assets:precompile'].enhance(['webpack:build_once'])

data/lib/webpack_rails.rb

@@ -1,7 +1,5 @@
-require 'sprockets'
-
 module WebpackRails
-  require_relative './webpack_rails/sprockets_index_webpack'
+  require_relative './webpack_rails/require_directive_processor'
   require_relative './webpack_rails/task'
   require_relative './webpack_rails/processor'
   require_relative './webpack_rails/engine'