webpacked 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2ce3d51fcf3507e85c3cbf4d1fcc7c69c87cb4e7
+  data.tar.gz: bf49978a1f8e89013bb85c874ad1bfc33a098898
+SHA512:
+  metadata.gz: 2c4a063a8c24b5dbe279bc6cc147eb527120a650dc1182bdc1625b0fcae431348f1988630ee93708d688bd9a054707ba0dd9df1e7db0f4ec0d42fb1d0249d579
+  data.tar.gz: 045b0f5f1f83a426f9546f926ee6902b366b9cef4f8d06968e4b87effebb91c86859620e12dc0514ed6468af912d33fcc490435d96140f6f04e4267292c88e38

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2016 Darkside73
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,157 @@
+[![Build Status](https://travis-ci.org/Darkside73/webpacked.svg?branch=master)](https://travis-ci.org/Darkside73/webpacked) [![Gem Version](https://badge.fury.io/rb/webpacked.svg)](http://badge.fury.io/rb/webpacked)
+
+# webpacked
+
+**webpacked** helps you to integrate Webpack in to a Ruby on Rails application.
+
+It can be used alongside sprockets but normaly you no need sprockets at all now: webpack replaces sprockets completely.
+Using **webpacked** and webpack itself means that Javascript is a first-class citizen: you should use `npm` to manage packages (no more gemified Javascript libraries!).
+
+In development mode assets are served via [webpack-dev-server](http://webpack.github.io/docs/webpack-dev-server.html) that brings a cool hot module reloading feature to your workflow. Webpack's manifest file is generated using [assets-webpack-plugin](https://github.com/kossnocorp/assets-webpack-plugin).
+
+Also **webpacked** offers deploy automation within capistrano task (see detailed instructions bellow).
+
+## Requirements
+
+  1. Node.js > 4
+  1. NPM > 3
+
+## Installation
+
+  1. Add `webpacked` to your Gemfile
+  1. Run `bundle install` to install the gem
+  1. Run `bin/rails generate webpacked:install` to get required files in your application, install NPM packages and foreman gem if you wish so
+  1. Run `foreman start` (if you've decided to install it) to start `webpack-dev-server` and `rails server` at the same time
+
+## Usage
+
+### Webpack configuration
+
+Webpack configs are divided into on three files:
+
+  1. `frontend/base.config.js` contains common setup for all environments
+  1. `frontend/development.config.js` contains setup specific for development
+  1. `frontend/production.config.js` includes production optimizations
+
+Follow comments in these files and webpack official docs to conclude what meets you requirements.
+
+Environment is defined via `NODE_ENV` variable and initialized in`frontend/main.config.js`. Normally you don't need to manual set up `NODE_ENV` unless you want to add another environment for your frontend application.
+
+In development mode webpack-dev-server starts using `npm run dev:server` command or simply `foreman start`. Internally it uses `frontend/dev-server.js`.
+
+Just in case there are a bunch other preconfigured NPM commands shipped (you can find them in the `package.json`):
+
+  * `npm run build:dev` runs webpack build for development environment
+  * `npm run build:production` same for production environment
+
+### View helpers
+
+To add webpacked assets in to your application, use following helpers:
+
+```erb
+<% # layout.html.erb  %>
+<!DOCTYPE html>
+<html>
+  <head>
+    <%= webpacked_css_tags 'application' %>
+  </head>
+  <body>
+    <%= webpacked_js_tags 'application' %>
+  </body>
+</html>
+```
+
+Where `'application'` is a one of the your entry points in webpack config.
+
+NOTE: if you using [common chunks optimization](https://webpack.github.io/docs/code-splitting.html#split-app-and-vendor-code) (it is so indeed in production most likely), these helpers may produce additional CSS/Javascript include tag for that common bundle.
+
+You should not concern about including any extra scripts to get hot module reloading works: it integrates transparently through a same webpack manifest file.
+
+### Controller helper
+
+**webpacked** offers an optional approach to link entry points with Rails application. The idea is in mapping *controllers* to entry points. Consider the following code:
+
+```ruby
+class ApplicationController < ActionController::Base
+  include Webpacked::ControllerHelper
+  webpacked_entry "application"
+end
+
+class FooController < ApplicationController
+  webpacked_entry "foo"
+end
+
+class BarController < ApplicationController
+  webpacked_entry "bar"
+end
+```
+
+```erb
+<%= webpacked_css_tags webpacked_entry_name %>
+<%= webpacked_js_tags webpacked_entry_name %>
+```
+
+In the example above the decision which entry point to use comes in controllers instead views. Therefore in layout we can use a common `webpacked_entry_name` helper method. Notice that `webpacked_entry` in `ApplicationController` will be used if concrete controller does not define its own entry.
+
+### Alternative ways
+
+If you don't like none of the mentioned above, you can use more generic helpers to access webpack manifest:
+
+  * `asset_tag(entry, kind)` return include tags for entry point `entry`; `kind` could be `:js` or `:css`
+  * `webpacked_asset_path(entry, kind = nil)` return only assets path for given entry
+
+Be aware that common entry point is not included by these methods. So if you use common chunks optimization do not forget to include `common` (or whatever name you pick) entry point manually.
+
+### Rails configuration and other assumptions
+
+Gem exposes a few configuration options:
+
+  * `webpacked.enabled` default to `true`; you probably want to disable webpacked in test environment, so helpers will not fail if manifest does not exist
+  * `webpacked.manifest_path` default to `webpack-assets.json`
+  * `webpacked.load_manifest_on_initialize` default to `false`; if `true` then parse manifest on application bootstrap
+  * `webpacked.common_entry_name` default to `common` (if you've changes this, you need to change it in webpack config as well)
+  * `webpacked.bin` default to `node_modules/.bin/webpack`
+  * `webpacked.config` default to `frontend/main.config.js`
+  * `webpacked.dev_server` enabled only in development mode
+  * webpack-dev-server starts on port 3500 on localhost via HTTP (use `WEBPACK_DEV_HOST` and `WEBPACK_DEV_PORT` env variables to change it)
+  * assets compiled to `public/assets/webpack`; you can change it in webpack config (and `deploy.rb` if capistrano webpacked task used)
+
+## Capistrano deployment
+
+### Installation and usage
+
+To deploy generated assets add `require "capistrano/webpacked"` to your `Capfile`. The `deploy:webpacked:build` task will run automaticaly as after `deploy:updated` hook.
+
+Also you need to set up the `:assets_roles` in `deploy.rb` so **webpacked** to run its tasks.
+
+What under hood? The task makes diff of files and folders (specified in `:webpacked_dependencies` option) in current release against previous release and decides whether to run production webpack build. If there is no diff then simply a manifest copied from previous release path. If some of dependencies were changed then production build starts *locally* and assets synchronized via `rsync` over SSH.
+
+NOTE: scince webpack build runs locally, you should pay an extra attention to your working copy condition: current branch, not published commits, not commited changes, etc.
+
+Additionally there are some extra tasks exposed (they are used by `deploy:webpacked:build` internally):
+
+  * `deploy:webpacked:build_force` unconditionally invokes production build on local machine
+  * `deploy:webpacked:sync` synchronize assets under `:webpacked_release_output_path` with remote server
+
+### Configuration
+
+There are following options available to set up (example values are defaults in fact):
+
+  * `set :webpacked_dependencies, %w(frontend npm-shrinkwrap.json)` webpacked build will perform if one of these will be changed
+  * `set :webpacked_manifest_path, "webpack-assets.json"` same as `Rails.configuration.webpacked.manifest_path`
+  * `set :webpacked_deploy_manifest_path, "webpack-assets-deploy.json"` used for production manifest only; choose another path to not clash with local dev manifest
+  * `set :webpacked_local_output_path, "public/#{fetch(:assets_prefix)}/webpack"` where webpack generates its assets
+  * `set :webpacked_release_output_path, "public/#{fetch(:assets_prefix)}/webpack"` where webpack assets are stored on the deploy server (started from `shared_path`)
+
+## TODO
+
+  * deploy with remote webpack build performing
+
+## Contributing
+
+Pull requests, issues and discussion are welcomed
+
+## Thanks
+
+* Marketplacer team for their [webpack-rails](https://github.com/mipearson/webpack-rails) gem which guides this implementation in some way ;)
+* Contributors of [capistrano-faster-assets](https://github.com/capistrano-plugins/capistrano-faster-assets) gem for conditionally assets compile idea

data/Rakefile

@@ -0,0 +1,24 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new
+RSpec::Core::RakeTask.new(:spec)
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Webpacked'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+require 'bundler/gem_tasks'
+
+task default: [:spec, :rubocop]

data/lib/capistrano/tasks/webpacked.rake

@@ -0,0 +1,82 @@
+# based on capistrano-faster-assets gem
+
+class WebpackedBuildRequired < StandardError; end
+
+namespace :deploy do
+  namespace :webpacked do
+    OPTIONS = lambda do |option|
+      {
+        dependencies:         fetch(:webpacked_dependencies)        || %w(frontend npm-shrinkwrap.json),
+        manifest_path:        fetch(:webpacked_manifest_path)       || 'webpack-assets.json',
+        deploy_manifest_path: fetch(:webpacked_local_manifest_path) || 'webpack-assets-deploy.json',
+        local_output_path:    fetch(:webpacked_local_output_path)   || "public/#{fetch(:assets_prefix)}/webpack",
+        release_output_path:  fetch(:webpacked_release_output_path) || "public/#{fetch(:assets_prefix)}/webpack"
+      }.fetch(option)
+    end
+
+    desc 'Webpack build assets'
+    task :build do
+      on roles(fetch(:assets_roles)) do
+        with rails_env: fetch(:rails_env) do
+          begin
+            latest_release = capture(:ls, '-xr', releases_path).split[1]
+            raise WebpackedBuildRequired unless latest_release
+            latest_release_path = releases_path.join(latest_release)
+
+            OPTIONS.(:dependencies).each do |dep|
+              release = release_path.join(dep)
+              latest = latest_release_path.join(dep)
+              # skip if both directories/files do not exist
+              next if [release, latest].map { |d| test "test -e #{d}" }.uniq == [false]
+              # execute raises if there is a diff
+              begin
+                execute(:diff, '-Nqr', release, latest)
+              rescue SSHKit::Runner::ExecuteError
+                raise WebpackedBuildRequired
+              end
+            end
+
+            info 'Skipping webpack build, no diff found'
+
+            execute(
+              :cp,
+              latest_release_path.join(OPTIONS.(:manifest_path)),
+              release_path.join(OPTIONS.(:manifest_path))
+            )
+          rescue WebpackedBuildRequired
+            invoke 'deploy:webpacked:build_force'
+          end
+        end
+      end
+    end
+    after 'deploy:updated', 'deploy:webpacked:build'
+
+    task :build_force do
+      run_locally do
+        info 'Create webpack local build'
+        `RAILS_ENV=#{fetch(:rails_env)} npm run build:production`
+        invoke 'deploy:webpacked:sync'
+      end
+    end
+
+    desc 'Sync locally compiled assets with current release path'
+
+    task :sync do
+      on roles(fetch(:assets_roles)) do
+        info 'Sync assets...'
+        upload!(
+          OPTIONS.(:deploy_manifest_path),
+          release_path.join(OPTIONS.(:manifest_path))
+        )
+        execute(:mkdir, '-p', shared_path.join(OPTIONS.(:release_output_path)))
+      end
+      roles(fetch(:assets_roles)).each do |host|
+        run_locally do
+          local_output_path = fetch(:webpacked_local_output_path)
+          release_output_path = shared_path.join(OPTIONS.(:release_output_path))
+          `rsync -avzr --delete #{local_output_path} #{host.user}@#{host.hostname}:#{release_output_path.parent}`
+        end
+      end
+    end
+  end
+end

data/lib/capistrano/webpacked.rb

@@ -0,0 +1 @@
+load File.expand_path('../tasks/webpacked.rake', __FILE__)

data/lib/generators/webpacked/USAGE

@@ -0,0 +1,14 @@
+Description:
+  Install basic configs for webpacked integration
+
+Example:
+  bin/rails generate webpacked:install
+
+  This will create:
+    frontend/app
+    frontend/lib
+    frontend/base.config.js
+    frontend/development.config.js
+    frontend/main.config.js
+    frontend/production.config.js
+    frontend/dev-server.js

data/lib/generators/webpacked/install_generator.rb

@@ -0,0 +1,53 @@
+module Webpacked
+  # :nodoc:
+  class InstallGenerator < Rails::Generators::Base
+    source_root File.expand_path('../templates', __FILE__)
+
+    def use_foreman
+      if yes?('Would you like to use foreman to start webpack-dev-server and rails server at same time?')
+        gem 'foreman'
+        copy_file 'Procfile'
+        run 'bundle install' if yes?("Run 'bundle install' for you?")
+      end
+    end
+
+    def copy_frontend_dir
+      directory 'frontend'
+    end
+
+    def prepare_package_json
+      get 'package.json' do |content|
+        content.gsub!(/\{\{(.+?)\}\}/) do
+          Rails.configuration.webpacked.send(Regexp.last_match(1))
+        end
+        create_file 'package.json', content
+      end
+    end
+
+    def add_to_gitignore
+      append_to_file '.gitignore' do
+        <<-EOF.strip_heredoc
+        # Added by webpacked
+        /node_modules
+        /public/assets/webpacked
+        EOF
+      end
+    end
+
+    def run_npm_install
+      run 'npm install' if yes?("Run 'npm install' for you?")
+    end
+
+    def whats_next
+      puts <<-EOF.strip_heredoc
+        Base webpacked setup completed. Now you can:
+          1. Include 'Webpacked::ControllerHelper' into 'ApplicationController'
+             and set up entry points for your controllers via 'webpacked_entry' class method
+          2. Add the webpacked helpers into your layout instead of regular Rails helpers
+          3. Run 'npm run dev:server' to start webpack-dev-server or 'foreman start' to start it alongside rails server
+        See https://github.com/Darkside73/webpacked for more info.
+        Thanks for using webpacked gem ;)
+      EOF
+    end
+  end
+end

data/lib/generators/webpacked/templates/Procfile

@@ -0,0 +1,2 @@
+rails: bin/rails s -p 3000
+webpack: sh -c 'npm run dev:server'

data/lib/generators/webpacked/templates/frontend/app/base-entry.js

@@ -0,0 +1 @@
+console.log("Hello from webpacked!")

data/lib/generators/webpacked/templates/frontend/base.config.js

@@ -0,0 +1,57 @@
+const path = require('path')
+const webpack = require('webpack')
+
+module.exports = {
+  context: __dirname,
+  output: {
+    // where to generate webpack assets
+    path: path.join(__dirname, '..', 'public', 'assets', 'webpack'),
+    filename: 'bundle-[name].js'
+  },
+  entry: {
+    application: ['./app/base-entry'],
+  },
+  resolve: {
+    // Default extensions to require file without extension
+    extensions: ['', '.js'],
+    modulesDirectories: [ 'node_modules' ],
+    alias: {
+      // Handy shortcut: use absolute path `require(~lib/mylib)` from any place
+      lib: path.join(__dirname, 'lib'),
+    }
+  },
+  module: {
+    // Loaders with identical settings for both
+    // development and production environments
+    loaders: [
+
+      // Use ES6 syntax (highly recommended!)
+      // (run `npm install babel-loader babel-core babel-preset-es2015 --save-dev`)
+      // {
+      //   test: /\.js$/,
+      //   include: [ path.resolve(__dirname + 'frontend/app') ],
+      //   loader: 'babel?presets[]=es2015'
+      // },
+
+      // Use Coffescript
+      // { test: /\.coffee$/, loader: 'coffee-loader' },
+
+      // Use Vue.js framework (run `npm install vue vue-loader --save-dev`)
+      // { test: /\.vue$/, loader: 'vue' },
+
+      // Makes `$` and `jQuery` available globally
+      // { test: require.resolve('jquery'), loader: 'expose?$!expose?jQuery' }
+    ],
+  },
+  plugins: [
+    // new webpack.ProvidePlugin({
+    //   $: 'jquery',
+    //   jQuery: 'jquery',
+    // }),
+
+    // Use `__RAILS_ENV__` variable in your Javascript code
+    // new webpack.DefinePlugin({
+    //   __RAILS_ENV__: JSON.stringify(process.env.RAILS_ENV || 'production'),
+    // })
+  ]
+}

data/lib/generators/webpacked/templates/frontend/dev-server.js

@@ -0,0 +1,41 @@
+const webpack = require('webpack')
+const WebpackDevServer = require('webpack-dev-server')
+const config = require('./main.config')
+const webpackDevHost = process.env.WEBPACK_DEV_HOST || 'localhost'
+const webpackDevPort = process.env.WEBPACK_DEV_PORT || 3500
+
+config.output.publicPath = `http://${webpackDevHost}:${webpackDevPort}/assets/`;
+for (var entryName in config.entry) {
+  config.entry[entryName].push(
+    `webpack-dev-server/client?http://${webpackDevHost}:${webpackDevPort}`,
+    'webpack/hot/only-dev-server'
+  )
+}
+
+config.plugins.push(
+  new webpack.optimize.OccurenceOrderPlugin(),
+  new webpack.HotModuleReplacementPlugin(),
+  new webpack.NoErrorsPlugin()
+)
+
+new WebpackDevServer(webpack(config), {
+  publicPath: config.output.publicPath,
+  hot: true,
+  inline: true,
+  historyApiFallback: true,
+  quiet: false,
+  noInfo: false,
+  lazy: false,
+  stats: {
+    colors: true,
+    hash: false,
+    version: false,
+    chunks: false,
+    children: false,
+  }
+}).listen(webpackDevPort, webpackDevHost, function (err, result) {
+  if (err) console.log(err)
+  console.log(
+    `=> 🔥  Webpack development server is running on port ${webpackDevPort}`
+  )
+})

data/lib/generators/webpacked/templates/frontend/development.config.js

@@ -0,0 +1,32 @@
+const AssetsPlugin = require('assets-webpack-plugin')
+
+module.exports = {
+  debug: true,
+  displayErrorDetails: true,
+  outputPathinfo: true,
+  devtool: 'eval-source-map',
+  output: {
+    devtoolModuleFilenameTemplate: '[resourcePath]',
+    devtoolFallbackModuleFilenameTemplate: '[resourcePath]?[hash]'
+  },
+  module: {
+    loaders: [
+      { test: /\.css$/, loader: 'style!css?sourceMap' },
+      // {
+      //   test: /\.scss$/,
+      //   loader: 'style!css?sourceMap!resolve-url!sass?sourceMap'
+      // },
+      {
+        test: /\.(png|jpg|gif)$/,
+        loader: 'url?name=[path][name].[ext]&limit=8192'
+      },
+      {
+        test: /\.(ttf|eot|svg|woff(2)?)(\?.+)?$/,
+        loader: 'file?name=[path][name].[ext]'
+      },
+    ]
+  },
+  plugins: [
+    new AssetsPlugin({ prettyPrint: true }),
+  ]
+}

data/lib/generators/webpacked/templates/frontend/main.config.js

@@ -0,0 +1,9 @@
+const webpack = require('webpack')
+const merge = require('webpack-merge')
+
+const env = process.env.NODE_ENV || 'development'
+
+module.exports = merge(
+  require('./base.config.js'),
+  require(`./${env}.config.js`)
+)

data/lib/generators/webpacked/templates/frontend/production.config.js

@@ -0,0 +1,67 @@
+const path = require('path')
+const webpack = require('webpack')
+const CleanPlugin = require('clean-webpack-plugin')
+const ExtractTextPlugin = require("extract-text-webpack-plugin")
+// const CompressionPlugin = require("compression-webpack-plugin")
+const AssetsPlugin = require('assets-webpack-plugin')
+
+module.exports = {
+  output: {
+    filename: './bundle-[name]-[chunkhash].js',
+    chunkFilename: 'bundle-[name]-[chunkhash].js',
+    publicPath: '/assets/webpack/'
+  },
+  module: {
+    loaders: [
+      {
+        test: /\.css$/,
+        loader: ExtractTextPlugin.extract("style-loader", "css?minimize")
+      },
+      // {
+      //   test: /\.scss$/,
+      //   loader: ExtractTextPlugin.extract(
+      //     "style-loader", "css?minimize!resolve-url!sass?sourceMap"
+      //   )
+      // },
+      { test: /\.(png|jpg|gif)$/, loader: 'url?limit=8192' },
+      {
+        test: /\.(ttf|eot|svg|woff(2)?)(\?.+)?$/,
+        loader: 'file'
+      },
+    ]
+  },
+  plugins: [
+    // Creates separate manifest for production
+    new AssetsPlugin({
+      prettyPrint: true, filename: 'webpack-assets-deploy.json'
+    }),
+
+    // Extacts CSS to stanalone file
+    new ExtractTextPlugin("bundle-[name]-[chunkhash].css", {
+      allChunks: true
+    }),
+
+    new CleanPlugin(
+      path.join('public', 'assets', 'webpack'),
+      { root: path.join(process.cwd()) }
+    ),
+
+    // Some webpack built-in optimizations
+    // Fill free to switch off if don't need some of it
+    new webpack.optimize.CommonsChunkPlugin('common', 'bundle-[name]-[hash].js'),
+    new webpack.optimize.DedupePlugin(),
+    new webpack.optimize.OccurenceOrderPlugin(),
+
+    //Enables Javascript source code uglifying
+    // new webpack.optimize.UglifyJsPlugin({
+    //   mangle: true,
+    //   compress: {
+    //     warnings: false
+    //   }
+    // }),
+
+    // Enables gzip compression for Javascript and CSS assets
+    // (remember to uncomment corresponding `require` on top of this file)
+    // new CompressionPlugin({ test: /\.js$|\.css$/ }),
+  ]
+}

data/lib/generators/webpacked/templates/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "your-app-name",
+  "version": "1.0.0",
+  "description": "",
+  "devDependencies": {
+    "assets-webpack-plugin": "^3.2.0",
+    "clean-webpack-plugin": "^0.1.6",
+    "css-loader": "^0.23.1",
+    "exports-loader": "^0.6.2",
+    "expose-loader": "^0.7.1",
+    "extract-text-webpack-plugin": "^1.0.0",
+    "file-loader": "^0.8.5",
+    "style-loader": "^0.13.0",
+    "url-loader": "^0.5.7",
+    "webpack": "^1.12.9",
+    "webpack-dev-server": "^1.14.0",
+    "webpack-hot-middleware": "^2.6.0",
+    "webpack-merge": "^0.6.0"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build:dev": "{{bin}} -v --config {{config}} --display-chunks --debug",
+    "build:production": "NODE_ENV=production {{bin}} -v --config {{config}} --display-chunks",
+    "dev:server": "node frontend/dev-server.js"
+  },
+  "author": "",
+  "license": "ISC"
+}

data/lib/webpacked/controller_helper.rb

@@ -0,0 +1,18 @@
+module Webpacked
+  # Mixin for Rails controllers
+  module ControllerHelper
+    extend ActiveSupport::Concern
+
+    # :nodoc:
+    module ClassMethods
+      # Mix in controller's class method to set up an entry point name
+      # and reveal +webpacked_entry_name+ helper to get this name in view
+      def webpacked_entry(name)
+        helper_method :webpacked_entry_name
+        cattr_accessor :webpacked_entry_name
+
+        self.webpacked_entry_name = name
+      end
+    end
+  end
+end

data/lib/webpacked/helper.rb

@@ -0,0 +1,42 @@
+module Webpacked
+  # Add new view helpers
+  module Helper
+    # Return +javascript_include_tag+ for entry point.
+    # Also common Javascript file could be included
+    def webpacked_js_tags(entry)
+      webpacked_tags entry, :js
+    end
+
+    # Return +stylesheet_link_tag+ for entry point.
+    # Also common CSS file could be included
+    def webpacked_css_tags(entry)
+      webpacked_tags entry, :css
+    end
+
+    # Return include tags for entry point by given asset kind.
+    # Also common file could be included
+    def webpacked_tags(entry, kind)
+      common_entry = ::Rails.configuration.webpacked.common_entry_name
+      common_bundle = asset_tag(common_entry, kind)
+      page_bundle   = asset_tag(entry, kind)
+      common_bundle ? common_bundle + page_bundle : page_bundle
+    end
+
+    # Return include tags for entry point by given asset kind.
+    # No extra common file included even if it exists
+    def asset_tag(entry, kind)
+      path = webpacked_asset_path(entry, kind)
+      if path
+        case kind
+        when :js  then javascript_include_tag path
+        when :css then stylesheet_link_tag    path
+        end
+      end
+    end
+
+    # Alias for Webpacked::Manifest.asset_paths
+    def webpacked_asset_path(entry, kind = nil)
+      Webpacked::Manifest.asset_paths(entry, kind)
+    end
+  end
+end

data/lib/webpacked/manifest.rb

@@ -0,0 +1,80 @@
+module Webpacked
+  # Webpack manifest loading, caching and entry point retrieval
+  class Manifest
+    ASSET_KINDS = [:js, :css]
+
+    # Raised if webpack manifest not readable for whatever reason
+    class LoadError < StandardError
+    end
+
+    # Raised if something but +:js+ or +:css+ passed as asset kind
+    class UnknownAssetKindError < StandardError
+      def initialize(kind)
+        super "Unknown asset kind: #{kind}"
+      end
+    end
+
+    # Raised if an entry point does not exist in the webpack manifest
+    class EntryMissingError < StandardError
+      def initialize(entry)
+        super "Entry point is missed: #{entry}"
+      end
+    end
+
+    class << self
+      # Load manifest from file and cache it if +Rails.configuration.webpacked.dev_server+ set to +false+.
+      # Return entry point asset path for +:js+ or +:css+ kind or both if +kind+ skipped
+      def asset_paths(entry, kind = nil)
+        validate_asset_kind(kind)
+        if Rails.configuration.webpacked.dev_server
+          @manifest = load_manifest!
+        else
+          @manifest ||= load_manifest!
+        end
+        validate_entry(entry)
+
+        return @manifest[entry] unless kind
+        return @manifest[entry][kind] if @manifest[entry]
+      end
+
+      # Force to load manifest from file
+      def load_manifest!
+        manifest_path = Rails.configuration.webpacked.manifest_path
+        manifest_path = Rails.root.join(manifest_path)
+        manifest = {}
+        if File.exist?(manifest_path)
+          manifest = JSON.parse(File.read manifest_path).with_indifferent_access
+          clean_asset_paths(manifest)
+        elsif Rails.configuration.webpacked.enabled
+          raise LoadError, "File #{manifest_path} not found"
+        end
+        manifest
+      end
+
+      private
+
+      def validate_asset_kind(kind)
+        return unless kind
+        raise UnknownAssetKindError, kind unless ASSET_KINDS.include?(kind)
+      end
+
+      def validate_entry(entry)
+        unless entry == Rails.configuration.webpacked.common_entry_name
+          raise EntryMissingError, entry unless @manifest[entry]
+        end
+      end
+
+      def clean_asset_paths(manifest)
+        manifest.each do |entry, assets|
+          assets.each do |kind, asset_path|
+            manifest[entry][kind] = if asset_path =~ %r{(http[s]?)://}i
+              asset_path
+            else
+              Pathname.new(asset_path).cleanpath.to_s
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/webpacked/rails.rb

@@ -0,0 +1,2 @@
+require 'webpacked/version'
+require 'webpacked/railtie' if defined? ::Rails::Railtie

data/lib/webpacked/railtie.rb

@@ -0,0 +1,30 @@
+require 'rails'
+require 'rails/railtie'
+require 'webpacked/manifest'
+require 'webpacked/helper'
+require 'webpacked/controller_helper'
+
+module Webpacked
+  # :nodoc:
+  class Railtie < ::Rails::Railtie
+    config.webpacked = ActiveSupport::OrderedOptions.new
+
+    config.webpacked.enabled = true
+    config.webpacked.manifest_path = 'webpack-assets.json'
+    config.webpacked.load_manifest_on_initialize = false
+    config.webpacked.common_entry_name = 'common'
+    config.webpacked.bin = 'node_modules/.bin/webpack'
+    config.webpacked.config = 'frontend/main.config.js'
+    config.webpacked.dev_server = Rails.env.development?
+
+    initializer 'webpacked.load_manifest' do
+      Webpacked::Manifest.load_manifest! if Rails.configuration.webpacked.load_manifest_on_initialize
+    end
+
+    config.after_initialize do
+      ActiveSupport.on_load(:action_view) do
+        include Webpacked::Helper
+      end
+    end
+  end
+end

data/lib/webpacked/version.rb

@@ -0,0 +1,3 @@
+module Webpacked
+  VERSION = '0.1.0'
+end

data/lib/webpacked.rb

@@ -0,0 +1 @@
+require 'webpacked/rails'

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: webpacked
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andrey Garbuz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-08-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ready for production gem to use webpack and hot reload within Rails application
+email:
+- andrey.garbuz@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/capistrano/tasks/webpacked.rake
+- lib/capistrano/webpacked.rb
+- lib/generators/webpacked/USAGE
+- lib/generators/webpacked/install_generator.rb
+- lib/generators/webpacked/templates/Procfile
+- lib/generators/webpacked/templates/frontend/app/base-entry.js
+- lib/generators/webpacked/templates/frontend/base.config.js
+- lib/generators/webpacked/templates/frontend/dev-server.js
+- lib/generators/webpacked/templates/frontend/development.config.js
+- lib/generators/webpacked/templates/frontend/main.config.js
+- lib/generators/webpacked/templates/frontend/production.config.js
+- lib/generators/webpacked/templates/package.json
+- lib/webpacked.rb
+- lib/webpacked/controller_helper.rb
+- lib/webpacked/helper.rb
+- lib/webpacked/manifest.rb
+- lib/webpacked/rails.rb
+- lib/webpacked/railtie.rb
+- lib/webpacked/version.rb
+homepage: https://github.com/Darkside73/webpacked
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.2.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.6
+signing_key: 
+specification_version: 4
+summary: Easy webpack and Rails integration
+test_files: []