webpack_rails 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4eefc65be79a7423acbb4aee442f794dda650b0a
+  data.tar.gz: fc8ff00a8a7ffb4048e783756c0d35041f7c81f7
+SHA512:
+  metadata.gz: c12944c42e4f37cf0ad6d559a6389553067ce9034590aa93f25929767656542795ae622657f0cda43c9f3a5217f9440a1feca69dfe68e7ff693e72e8c5f37e85
+  data.tar.gz: b737ff3f47506b20307bc35af43cb94e25bea7e61f3cd15473987fcfa3823873e194b297eaf5b3d0831fc1edddc66a4def50ecfd52e6d1fd6a46f84637c56cc6

data/lib/webpack_rails.rb

@@ -0,0 +1,8 @@
+require 'sprockets'
+
+module WebpackRails
+  require_relative './webpack_rails/sprockets_index_webpack'
+  require_relative './webpack_rails/task'
+  require_relative './webpack_rails/processor'
+  require_relative './webpack_rails/engine'
+end

data/lib/webpack_rails/engine.rb

@@ -0,0 +1,12 @@
+require_relative './processor'
+
+module WebpackRails
+  class Engine < ::Rails::Engine
+    initializer :setup_webpack_rails, :after => "sprockets.environment", :group => :all do |app|
+      # where [name].bundle.js files should be
+      app.assets.append_path Rails.root.join('tmp/webpack/bundles')
+      # process 
+      app.assets.register_preprocessor('application/javascript', WebpackRails::Processor)
+    end
+  end
+end

data/lib/webpack_rails/processor.rb

@@ -0,0 +1,24 @@
+require 'tilt'
+
+require_relative './sprockets_index_webpack'
+require_relative './task'
+
+module WebpackRails
+  class Processor < Tilt::Template
+    def prepare
+    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
+
+      result[:modules].map{|m| context.depend_on m}
+
+      bundle_contents = context.pathname.open.read
+      # rewrite $asset_paths in strings
+      bundle_contents.gsub(/['"]\$asset_path\/([^'"]+?)['"]/) {|s| "'#{context.asset_path($1)}'" }
+    end
+  end
+end

data/lib/webpack_rails/sprockets_base_webpack.rb

@@ -0,0 +1,14 @@
+require 'sprockets'
+require_relative './task'
+
+# reopen Sprockets::Base and monkeypatch resolve
+class Sprockets::Base
+  original_resolve = instance_method(:resolve)
+
+  define_method :resolve, ->(logical_path, options = {}, &block) {
+    if logical_path.to_s.include?('.bundle')
+      WebpackRails::Task.run_webpack # ensure output files exist so original_resolve doesn't fail
+    end
+    original_resolve.bind(self).(logical_path, options, &block)
+  }
+end

data/lib/webpack_rails/sprockets_index_webpack.rb

@@ -0,0 +1,15 @@
+require 'sprockets'
+require_relative './task'
+
+# reopen Sprockets::Index and monkeypatch find_asset
+class Sprockets::Index
+  original_find_asset = instance_method(:find_asset)
+
+  define_method :find_asset, ->(path, options = {}) {
+    unless @_webpack_built
+      WebpackRails::Task.run_webpack # ensure output files exist so original_find_asset doesn't fail
+      @_webpack_built = true
+    end
+    original_find_asset.bind(self).(path, options)
+  }
+end

data/lib/webpack_rails/task.rb

@@ -0,0 +1,86 @@
+require 'node_task'
+require 'benchmark'
+require 'fileutils'
+
+module WebpackRails
+  class Task < NodeTask
+    # wraps NodeTask::Error
+    class Error < StandardError
+      def initialize(node_task_error)
+        super(node_task_error.to_s)
+
+        # TODO: expose @js_error from NodeTask::Error
+        js_error = node_task_error.instance_variable_get(:@js_error)
+        set_backtrace(js_error[:stack].split('\n')) if js_error
+      end
+    end
+
+    class << self
+      def root_dir
+        @root_dir ||= defined?(Rails) ? Rails.root.to_s : Dir.pwd
+      end
+
+      def working_dir
+        @working_dir ||= _make_working_dir
+      end
+
+      def webpack_gem_dir
+        @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')
+      end
+
+      def app_node_path
+        @app_node_path ||= File.join(root_dir, 'node_modules')
+      end
+
+      def with_app_node_path
+        prev_node_path = ENV['NODE_PATH']
+        ENV['NODE_PATH'] = app_node_path
+        return_value = nil
+        Dir.chdir(root_dir) do
+          return_value = yield
+        end
+        ENV['NODE_PATH'] = prev_node_path
+        return_value
+      end
+
+      def run_webpack(opts = nil)
+        result = nil
+
+        task_duration = Benchmark.realtime do
+          result = with_app_node_path do
+            begin
+              task = self.new
+              task.run(opts)
+            rescue NodeTask::Error => e
+              raise self::Error.new(e)
+            end
+          end
+        end
+
+        task_duration_ms = task_duration * 1000
+        if defined?(Rails) && task_duration_ms > 10
+          Rails.logger.info("Webpack: #{task_duration_ms.round(0)}ms")
+        end
+
+        result
+      end
+
+      private
+
+      def _make_working_dir
+        # one node_task daemon will be created per unique working dir
+        wd = File.join(root_dir, 'tmp', 'webpack', 'task')
+        FileUtils.mkpath(wd)
+        wd
+      end
+    end
+
+    def initialize
+      super(self.class.webpack_task_script)
+    end
+  end
+end

data/lib/webpack_rails/webpack-task.js

@@ -0,0 +1,87 @@
+var webpack = require('webpack');
+var fs = require('fs');
+var path = require('path');
+
+var logging = true;
+function log(message) {
+  if (logging) fs.appendFile('log/webpack-task.log', message+'\n');
+}
+
+// TODO: add support for multiple builds using multiple webpack configs which 
+// can each be waited upon independently
+var webpackConfig = require(path.resolve('config/webpack.config.js'));
+
+// webpack Compiler.Watching instance
+var watcher = makeWatcher();
+// callbacks which will be called when next build completes
+var currentBuildCallbacks = [];
+// object with property 'stats' for success or 'error' for failure
+var lastBuildResult = null;
+
+function buildComplete(buildResult) {
+  lastBuildResult = buildResult;
+
+  currentBuildCallbacks.forEach(function(callback) {
+    log('async completion callback');
+    callback(buildResult);
+  });
+  currentBuildCallbacks = [];
+
+  fs.writeFile('tmp/webpack/webpack-build-result.json', JSON.stringify(buildResult, null, 2));
+}
+
+function makeWatcher() {
+  return webpack(webpackConfig).watch({
+    aggregateTimeout: 300, // wait so long for more changes
+  }, function(err, stats) {
+    if (err) {
+      buildComplete({
+        error: err,
+      });
+    } else if (stats.hasErrors()) {
+      var errWithDetails = new Error('Webpack build error');
+      errWithDetails.stack = (
+        'Webpack build error:\n' +
+        stats.toJson({errorDetails: true}).errors.join("\n") + ''
+        // err ? '\nOriginal stacktrace:\n' + (err.stack || err) : ''
+      );
+
+      buildComplete({
+        error: errWithDetails,
+      });
+    } else {
+      var statsData = stats.toJson({
+        hash: true,
+        assets: true,
+        modules: true,
+        chunkOrigins: true,
+        cached: true,
+      });
+
+      var modules = statsData.modules.map(function(moduleStats) {
+        var loadersEnd = moduleStats.identifier.lastIndexOf('!')
+        return moduleStats.identifier.slice(loadersEnd == -1 ? 0 : loadersEnd+1)
+      })
+
+      buildComplete({
+        // stats: statsData,
+        modules: modules,
+      });
+    }
+  });
+}
+
+module.exports = function waitForBuild(opts, done) {
+  function sendResults(buildResult) {
+    if (buildResult.error) done(buildResult.error);
+    else done(null, buildResult);
+  }
+
+  log('watcher.running: '+JSON.stringify(watcher.running));
+
+  if (!watcher.running) {
+    sendResults(lastBuildResult);
+  } else {
+    currentBuildCallbacks.push(sendResults);
+  }
+};

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: webpack_rails
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- James Friend
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-08-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: node_task
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+- !ruby/object:Gem::Dependency
+  name: tilt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+description: Much longer explanation of the webpack_rails!
+email: james@jsdf.co
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/webpack_rails.rb
+- lib/webpack_rails/engine.rb
+- lib/webpack_rails/processor.rb
+- lib/webpack_rails/sprockets_base_webpack.rb
+- lib/webpack_rails/sprockets_index_webpack.rb
+- lib/webpack_rails/task.rb
+- lib/webpack_rails/webpack-task.js
+homepage: https://rubygems.org/gems/webpack_rails
+licenses:
+- MIT
+metadata: {}
+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.2.2
+signing_key: 
+specification_version: 4
+summary: This is an webpack_rails!
+test_files: []