minipack 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f8946e76b71b48eccb31e56408075341276eddbc8c1d8a3bc75a4c1969f7a327
+  data.tar.gz: 26418d01d9e406d37330eae60558ebe3b0a304d90c5fa312ab4b3b2924075193
+SHA512:
+  metadata.gz: b3bbac2192c9098b951b16f5f48541b0aeb9a9fdd1aa16a26016fcd20c4fe02134e062277e474f0156348395966e56932d7503c0894a78aa38cf842e191b25e3
+  data.tar.gz: c7ea1f6a21823b101e91c11266819141824af89d819ea73bb63e9c52c0f8ca5c9406a7bfa880b255144dbd5cc4cfc2ccd24ffe5394869507de4c16341a15ee36

data/CHANGELOG.md

@@ -0,0 +1,46 @@
+# 0.3.0 / 2019-06-01
+
+The project was renamed to Minipack from WebpackManifest since v0.3.0. Please refer to [the migration guide](docs/migrate_from_webpack_manifest.md') from WebpackManifest.
+
+## Breaking changes
+
+* Rename the project as Minipack.
+
+## Enhancements:
+
+* pre-build in test (#11)
+* Enable to set default value through config_attr (#16)
+
+# 0.2.4 / 2019-03-25
+
+## Enhancements:
+
+* Added `javascript_bundles_with_chunks_tag` and `stylesheet_bundles_with_chunks_tag` helpers, which creates html tags for a pack and all the dependent chunks, when using splitChunks. (#7)
+
+# 0.2.3 / 2018-11-18
+
+* Support passing symbols to helper methods (#5) by @jmortlock
+
+# 0.2.2 / 2018-11-05
+
+## Enhancements
+
+* Support reading manifest.json from an uri (#4)
+
+# 0.2.1 / 2018-10-18
+
+* Improve exceptional case handling
+
+# 0.2.0 / 2018-10-18
+
+## Enhancements
+
+* Multiple manifest files support
+
+## Breaking changes
+
+* Changed internal and public APIs
+
+# 0.1.0 / 2018-10-17
+
+Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Nobuhiro Nikushi
+
+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,312 @@
+# Minipack [![Build Status](https://travis-ci.org/nikushi/minipack.svg?branch=master)](https://travis-ci.org/nikushi/minipack) [![Gem Version](https://badge.fury.io/rb/minipack.svg)](https://badge.fury.io/rb/minipack)
+
+Minipack, a gem for minimalists, which can integrates Rails with [webpack](https://webpack.js.org/). It is an alternative to [Webpacker](https://github.com/rails/).
+
+Minipack provides view helpers through a manifest, which resolve paths of assets build by a webpack configured by you as you like.
+
+**Note:** Before Minipack v0.3.0, it was called WebpackManifest. Please refer to [the migration guide](docs/migrate_from_webpack_manifest.md') from WebpackManifest.
+
+## Features
+
+* Rails view helpers to resolve paths to assets which are built by webpack according to a manifest file.
+* Multiple manifest files support
+* Pre-build assets before running tests
+
+## Pre configuration
+
+Unlike Webpacker, Minipack itself does not offer generating webpack configuration, DSL for setup, or scaffolding. So first you need to set up webpack in your favorite way.
+
+Also, Minipack expects that webpack emits a manifest file. So please install [webpack-manifest-plugin](https://www.npmjs.com/package/webpack-manifest-plugin) and set it up accordingly.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'minipack'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install minipack
+
+## Configuration
+
+After installed, configure your Rails app below as a new file `config/initializers/minipack.rb`.
+
+```rb
+Minipack.configuration do |c|
+  # By default c.cache is set to `false`, which means an application always parses a
+  # manifest.json. In development, you should set cache false usually.
+  # Instead, setting it `true` which caches the manifest in memory is recommended basically.
+  c.cache = !Rails.env.development?
+
+  # Register a path to a manifest file here. Right now you have to specify an absolute path.
+  c.manifest = Rails.root.join('public', 'assets', 'manifest.json')
+
+  # The base directory for the frontend system. By default, it will be
+  # `Rails.root`.
+  # c.base_path = Rails.root
+  #
+  # Suppose you want to change the root directory for the frontend system such as `frontend`.
+  # Note that a base_path can be a relative path from `Rails.root`.
+  # c.base_path = 'frontend'
+
+  # You can invokes a command to build assets in node from Minipack.
+  #
+  # When running tests, the lazy compilation is cached until a cache key, based
+  # on file checksum under your tracked paths, is changed. You can configure
+  # which paths are tracked by adding new paths to `build_cache_key`. Each path
+  # can be a relative path from the `base_dir`.
+  #
+  # The value will be as follows by default:
+  # c.build_cache_key = [
+  #   'package.json', 'package-lock.json', 'yarn.lock', 'webpack.config.js',
+  #   'webpackfile.js', 'config/webpack.config.js', 'config/webpackfile.js',
+  #   'app/javascripts/**/*',
+  # ]
+  #
+  # You can override it.
+  # c.build_cache_key = ['package.json', 'package-lock.json', 'config/webpack.config.js', 'src/**/*'] 
+  #
+  # Or you can add files in addition to the defaults:
+  # c.build_cache_key << 'src/**/*'
+
+  # A command to to build assets. The command you specify is executed under the `base_dir`.
+  # c.build_command = 'node_modules/.bin/webpack'
+  #
+  # You may want to customize it with options:
+  # c.build_command = 'node_modules/.bin/webpack --config config/webpack.config.js --mode production'
+  #
+  # You are also able to specify npm run script.
+  # c.build_command = 'npm run build'
+
+  # A full package installation command, with it's arguments and options. The command is executed under the `base_path`.
+  # c.pkg_install_command = 'npm install'
+  #
+  # If you prefer `yarn`:
+  # c.pkg_install_command = 'yarn install'
+end
+```
+
+## Usage
+
+### Rails view helpers
+
+#### `asset_bundle_path`
+
+This is a wrapper of [asset_path](https://api.rubyonrails.org/classes/ActionView/Helpers/AssetUrlHelper.html#method-i-asset_path). You can set any options of `asset_path`.
+
+A given entry point name is resolved according to definition of manifest.
+
+```ruby
+asset_bundle_path 'calendar.css'
+  # => "/assets/web/pack/calendar-1016838bab065ae1e122.css"
+
+asset_bundle_path 'icon/favicon.ico'
+  # => "/assets/web/pack/icon/favicon-1016838bab065ae1e122.ico"
+```
+
+#### `javascript_bundle_tag`
+
+This is a wrapper of [javascript_include_tag](https://api.rubyonrails.org/classes/ActionView/Helpers/AssetTagHelper.html#method-i-javascript_include_tag). You can set any options of `javascript_include_tag`.
+
+Given entry point name is resolved according to definition of manifest.
+
+```ruby
+javascript_bundle_tag 'calendar', 'data-turbolinks-track': 'reload'
+  # => <script src="/assets/web/pack/calendar-1016838bab065ae1e314.js"
+  #     data-turbolinks-track="reload"></script>
+
+javascript_bundle_tag 'orders/app'
+  # => <script src="/assets/web/pack/orders/app-1016838bab065ae1e314.js"></script>
+```
+
+#### `stylesheet_bundle_tag`
+
+This is a wrapper of [stylesheet_link_tag](https://api.rubyonrails.org/classes/ActionView/Helpers/AssetTagHelper.html#method-i-stylesheet_link_tag). You can set any options of `stylesheet_link_tag`.
+
+A given entry point name is resolved according to definition of manifest.
+
+```ruby
+stylesheet_bundle_tag 'calendar', 'data-turbolinks-track': 'reload'
+  # => <link rel="stylesheet" media="screen"
+  #     href="/assets/web/pack/calendar-1016838bab065ae1e122.css"
+  #     data-turbolinks-track="reload" />
+
+stylesheet_bundle_tag 'orders/style'
+  # => <link rel="stylesheet" media="screen"
+  #    href="/assets/web/pack/orders/style-1016838bab065ae1e122.css" />
+```
+
+#### `image_bundle_tag`
+
+This is a wrapper of [image_tag](https://api.rubyonrails.org/classes/ActionView/Helpers/AssetTagHelper.html#method-i-image_tag). You can set any options of `image_tag`.
+
+A given entry point name is resolved according to definition of manifest.
+
+```ruby
+image_bundle_tag 'icon.png'
+  # => <img src="/assets/pack/icon-1016838bab065ae1e314.png" />
+
+image_bundle_tag "icon.png", size: "16x10", alt: "Edit Entry"
+  # => <img src="/assets/pack/icon-1016838bab065ae1e314.png" width="16"
+        height="10" alt="Edit Entry" />
+```
+
+
+#### `javascript_bundles_with_chunks_tag` and `stylesheet_bundles_with_chunks_tag`
+
+**Experimental** These are the helpers, which are similar to Webpacker, to support `splitChunks` feature introduced since Webpack 4.
+
+For the full configuration options of splitChunks, see the Webpack's [documentation](https://webpack.js.org/plugins/split-chunks-plugin/).
+
+Then use the `javascript_bundles_with_chunks_tag` and `stylesheet_bundles_with_chunks_tag` helpers to include all
+the transpiled packs with the chunks in your view, which creates html tags for all the chunks.
+
+```
+<%= javascript_bundles_with_chunks_tag 'calendar', 'map', 'data-turbolinks-track': 'reload' %>
+
+<!-- Creates the following: -->
+<script src="/packs/vendor-16838bab065ae1e314.js" data-turbolinks-track="reload"></script>
+<script src="/packs/calendar~runtime-16838bab065ae1e314.js" data-turbolinks-track="reload"></script>
+<script src="/packs/calendar-1016838bab065ae1e314.js" data-turbolinks-track="reload"></script>
+<script src="/packs/map~runtime-16838bab065ae1e314.js" data-turbolinks-track="reload"></script>
+<script src="/packs/map-16838bab065ae1e314.js" data-turbolinks-track="reload"></script>
+```
+
+**Important:** Pass all your pack names to the helper otherwise you will get duplicated chunks on the page.
+
+```
+<%# DO %>
+<%= javascript_bundles_with_chunks_tag 'calendar', 'map' %>
+
+<%# DON'T %>
+<%= javascript_bundles_with_chunks_tag 'calendar' %>
+<%= javascript_bundles_with_chunks_tag 'map' %>
+```
+
+**Important:** Also, these helpers do not work with `webpack-manifest-plugin` npm because it has no support to generate a manifest with a set of of chunk entries https://github.com/danethurber/webpack-manifest-plugin/issues/133. Instead, [webpack-assets-manifest](https://github.com/webdeveric/webpack-assets-manifest) npm supports. Please change the plugin for manifest file generation if you wish to enable `splitChunks` feature.
+
+```
+const WebpackAssetsManifest = require('webpack-assets-manifest');
+
+module.exports = {
+  // ...
+  plugins: [
+    new WebpackAssetsManifest({
+      entrypoints: true, // Please set this as true
+    })
+  ],
+  // ...
+}
+```
+
+## Advanced Configuration
+
+### Hot Module Replacement in development
+
+Optionally you can integrate the gem with [webpack-dev-server](https://github.com/webpack/webpack-dev-server) to enable live reloading by setting an manifest url served by webpack-dev-server, instead of a local file path. This should be used for development only.
+
+Note that Minipack itself does not launches webpack-dev-server, so it must be started along with Rails server by yourself.
+
+```rb
+Minipack.configuration do |c|
+  c.cache = !Rails.env.development?
+
+  c.manifest = if Rails.env.development?
+                 'http://localhost:8080/packs/manifest.json'
+               else
+                 Rails.root.join('public', 'assets', 'manifest.json')
+               end
+end
+```
+
+### Multiple manifest files support
+
+This is optional. You can register multiple manifest files for the view helpers. This feature must be useful if your Rails project serves for several sites, then asset bundling process is isolated every site.
+
+For example, your project serve for two sites, `shop` and `admin` from each individual manifest file. You can register each as
+
+```rb
+# In config/initializers/minipack.rb
+
+Minipack.configuration do |c|
+  c.cache = !Rails.env.development?
+
+  # In order for Raild to handle multiple manifests, you must call `c.add` instead
+  # of `c.manifest=`. Note that the first registered one(e.g. `shop` in this
+  # example) is recognized as a default manifest.
+  c.add :shop do |co|
+    co.manifest = Rails.root.join('public', 'assets', 'manifest-shop.json')
+    co.base_path = Rails.root.join('frontend/shop')
+  end
+
+  c.add :admin do |co|
+    co.manifest = Rails.root.join('public', 'assets', 'manifest-admin.json')
+    co.base_path = Rails.root.join('frontend/admin')
+    # You can customize all configurable parameters per site.
+    co.build_cache_key << 'javascripts/**/*'
+    co.build_command = 'yarn install'
+  end
+end
+```
+
+Then you can resolve a path with view helpers by passing `manifest:` option.
+
+```
+# This resolves a path by shop's manifest json.
+javascript_bundle_tag('item_group_editor', manifest: :shop)
+
+# This resolves a path by admin's manifest json.
+asset_bundle_tag('favicon.ico', manifest: :admin)
+
+# This resolves a path by shop's manifest json implicitly because the first one is marked as a default.
+javascript_bundle_tag('item_group_editor')
+```
+
+## Building assets before running tests
+
+To pre-build assets before runngin tests, add the following line (typically to your spec_helper.rb file):
+
+```rb
+require 'minipack/rspec'
+```
+
+## TODO
+
+* Provides configuration generator for Rails initializers
+
+## Acknowledgement
+
+Special thanks to [@f_subal](https://twitter.com/f_subal) and his awesome blog [post](https://inside.pixiv.blog/subal/4615)(japanese).
+
+## Alternatives
+
+* [ed-mare/minipack_plugin](https://github.com/ed-mare/minipack_plugin)
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+**v0.3.x-trunk**
+
+`v0.3.x-trunk` is the current active development branch. Please send pull requests to v0.3.x-trunk if you want any features.
+
+**v0.2.x-trunk**
+
+v0.2.x-trunk is made from the latest released version v0.2.4. I will not intend to actively maintain v0.2.x anymore, except security fixes or bug fixes.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/nikushi/minipack.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/minipack/command_runner.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'open3'
+
+module Minipack
+    class CommandRunner
+      class UnsuccessfulError < StandardError; end
+
+      def initialize(env, command, chdir: '.', logger: nil, watcher: nil)
+        @env = env
+        @command = command
+        @chdir = chdir
+        @logger = logger || Logger.new(nil)
+        @watcher = watcher
+      end
+
+      def run
+        run!
+      rescue UnsuccessfulError
+        false
+      end
+
+      def run!
+        @logger.info "Start executing #{@command}, within #{@chdir}"
+
+        return run_command if @watcher.nil?
+
+        if @watcher.stale?
+          run_command.tap do |success|
+            @watcher.record_digest if success
+          end
+        else
+          @logger.info 'Skipped because no file changes'
+          true
+        end
+      end
+
+      private
+
+      def run_command
+        stdout, stderr, status = Open3.capture3(
+          @env,
+          @command,
+          chdir: @chdir,
+        )
+
+        if status.success?
+          @logger.info "Executed successfully"
+          @logger.error "#{stderr}" unless stderr.empty?
+        else
+          @logger.error "Failed to execute:\n#{stderr}"
+        end
+
+        status.success? || raise(UnsuccessfulError, "Failed to execute #{@command}, exit:#{status.exitstatus}, stdout:#{stdout}, stderr:#{stderr}")
+      end
+    end
+end
+ 

data/lib/minipack/commands/base.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Minipack
+  module Commands
+    class Base
+      class << self
+        def call(*args)
+          new(*args).call
+        end
+      end
+    end
+  end
+end

data/lib/minipack/commands/build.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Minipack
+  module Commands
+    class Build < Base
+      def initialize(logger: nil)
+        @logger = logger
+      end
+
+      def call
+        Minipack.configuration.leaves.each do |c|
+          # Note: someone wants pre_build hook?
+          build(c)
+          # Note: someone wants post_build hook?
+         end
+        true
+      end
+
+      private
+
+      def build(c)
+        watcher = FileChangeWatcher.new(c.resolved_build_cache_key, File.join(c.cache_path, "last-build-digest-#{c.id}-#{::Rails.env}"))
+        CommandRunner.new(
+          {},
+          c.build_command,
+          chdir: c.resolved_base_path,
+          logger: @logger,
+          watcher: watcher,
+        ).run!
+      end
+    end
+  end
+end

data/lib/minipack/commands/pkg_install.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Minipack
+  module Commands
+    class PkgInstall < Base
+      PKG_INSTALL_CACHE_KEY = ['package.json', 'package-lock.json', 'yarn.lock'].freeze
+
+      def initialize(logger: nil)
+        @logger = logger
+      end
+
+      def call
+        Minipack.configuration.leaves.each do |c|
+          # Note: someone wants pre_pkg_install hook?
+          pkg_install(c)
+          # Note: someone wants post_pkg_install hook?
+         end
+        true
+      end
+
+      private
+
+      def pkg_install(c)
+        pkg_install_cache_key = PKG_INSTALL_CACHE_KEY.map { |f| File.expand_path(f, c.resolved_base_path) }
+        watcher = FileChangeWatcher.new(pkg_install_cache_key, File.join(c.cache_path, "last-installation-digest-#{c.id}-#{::Rails.env}"))
+        CommandRunner.new(
+          {},
+          c.pkg_install_command,
+          chdir: c.resolved_base_path,
+          logger: @logger,
+          watcher: watcher,
+        ).run!
+      end
+    end
+  end
+end

data/lib/minipack/configuration.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module Minipack
+    # 1-level or 2-levels configuration system. With the typical single site usecase,
+    # only the root instance exists as a singleton. If you manage more then one site,
+    # each configuration is stored at the 2nd level of the configuration tree.
+    class Configuration
+      class Collection
+        include Enumerable
+        class NotFoundError < StandardError; end
+
+        def initialize(configs = [])
+          @configs = configs.map(&:id).zip(configs).to_h
+        end
+
+        def find(id)
+          @configs[id] || raise(NotFoundError, "collection not found by #{id}")
+        end
+
+        def each
+          @configs.values.each { |c| yield c }
+        end
+      end
+
+      class Error < StandardError; end
+
+      ROOT_DEFAULT_ID = :''
+      BUILD_CACHE_KEY_DEFAULT = [
+        'package.json',
+        'package-lock.json',
+        'yarn.lock',
+        'webpack.config.js',
+        'webpackfile.js',
+        'config/webpack.config.js',
+        'config/webpackfile.js',
+        'app/javascripts/**/*',
+      ].freeze
+
+      class << self
+        def config_attr(prop, default: nil)
+          define_method(prop) do
+            @config.fetch(prop) do
+              @parent ? @parent.public_send(prop) : default
+            end
+          end
+
+          define_method("#{prop}=".to_sym) do |v|
+            @config[prop] = v
+          end
+        end
+      end
+
+      # Private
+      config_attr :root_path
+      config_attr :id, default: ROOT_DEFAULT_ID
+
+      config_attr :cache, default: false
+
+      # The base directory of the frontend.
+      config_attr :base_path
+
+      config_attr :manifest
+
+      # The lazy compilation is cached until a file is change under the tracked paths.
+      config_attr :build_cache_key, default: BUILD_CACHE_KEY_DEFAULT.dup
+
+      # Let me leave this line for remember the indea of pre build hooks
+      # config_attr :pre_build_hooks, default: []
+
+      # The command for bundling assets
+      config_attr :build_command, default: 'node_modules/.bin/webpack'
+
+      # Let me leave this line to remember the indea of post build hooks
+      # config_attr :post_build_hooks, default: []
+
+      # Let me leave this line to remember the indea of pre pkg install hooks
+      # config_attr :pre_pkg_install_hooks, default: []
+
+      # The command for installation of npm packages
+      config_attr :pkg_install_command, default: 'npm install'
+
+      # Let me leave this line for remember the indea of post pkg install hooks
+      # config_attr :post_install_hooks, default: []
+
+      # Initializes a new instance of Configuration class.
+      #
+      # @param [Configuration,nil] parent refenrece to the parent configuration instance.
+      def initialize(parent = nil)
+        @parent = parent
+        # Only a root instance can have children, which are sub configurations each site.
+        @children = {}
+        @config = {}
+      end
+
+      # Register a sub configuration with a site name, with a manifest file
+      # optionally. You can configure per site.
+      #
+      # @param [Symbol] id uniq name of the site
+      # @param [String] path path of the manifest file
+      # @yieldparam [Configuration] config a sub configuration instance is sent to the block
+      def add(id, path = nil)
+        raise Error, 'Defining a sub configuration under a sub is not allowed' if leaf?
+
+        id = id.to_sym
+        config = self.class.new(self)
+        config.id = id
+        config.manifest = path unless path.nil?
+
+        # Link the root to the child
+        @children[id] = config
+
+        # The sub configuration can be configured within a block
+        yield config if block_given?
+
+        config
+      end
+
+      def children
+        Collection.new(@children.values)
+      end
+
+      # Return scoped leaf nodes in self and children. This method is useful
+      # to get the concrete(enabled, or active) configuration instances.
+      # Each leaf inherit parameters from parent, so leaves always become
+      # active.
+      def leaves
+        col = @children.empty? ? [self] : @children.values
+        Collection.new(col)
+      end
+
+      # TODO: This will be moved to Minipack.manifests in the future.
+      def manifests
+        raise Error, 'Calling #manifests is only allowed from a root' unless root?
+
+        repo = ManifestRepository.new
+        #  Determine if a single manifest mode or multiple manifests(multiple site) mode
+        targets =  @children.empty? ? [self] : @children.values
+        targets.each do |config|
+          repo.add(config.id, config.manifest, cache: config.cache)
+        end
+        repo
+      end
+
+      # Resolve base_path as an absolute path
+      #
+      # @return [String]
+      def resolved_base_path
+        File.expand_path(base_path || '.', root_path)
+      end
+
+      # Resolve build_cache_key as absolute paths
+      #
+      # @return [Array<String>]
+      def resolved_build_cache_key
+        base = resolved_base_path
+        build_cache_key.map { |path| File.expand_path(path, base) }
+      end
+
+      # @return [String]
+      def cache_path
+        File.join(root_path, 'tmp', 'cache', 'minipack')
+      end
+
+      private
+
+      def root?
+        @parent.nil?
+      end
+
+      def leaf?
+        !root?
+      end
+    end
+ end

data/lib/minipack/file_change_watcher.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "digest/sha1"
+require 'pathname'
+
+module Minipack
+    class FileChangeWatcher
+      # @param [Array<Pathname>] watched_paths
+      # @param [Pathname] digest_store_path
+      def initialize(watched_paths, digest_store_path)
+        @watched_paths = watched_paths
+        @digest_store_path = Pathname.new(digest_store_path)
+      end
+
+      # Returns true if all watched files are up to date
+      def fresh?
+        watched_files_digest == last_stored_digest
+      end
+
+      # Returns true if the watched files are out of date
+      def stale?
+        !fresh?
+      end
+
+      def record_digest
+        @digest_store_path.dirname.mkpath
+        @digest_store_path.write(watched_files_digest)
+      end
+
+      private
+
+      def last_stored_digest
+        @digest_store_path.read if @digest_store_path.exist?
+      rescue Errno::ENOENT, Errno::ENOTDIR
+      end
+
+      def watched_files_digest
+        files = Dir[*@watched_paths].reject { |f| File.directory?(f) }
+        file_ids = files.sort.map { |f| "#{File.basename(f)}/#{Digest::SHA1.file(f).hexdigest}" }
+        Digest::SHA1.hexdigest(file_ids.join("/"))
+      end
+    end
+end
+ 

data/lib/minipack/helper.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'action_view'
+
+module Minipack::Helper
+  # Example:
+  #
+  #   <%= asset_bundle_path 'calendar.css' %> # => "/assets/web/pack/calendar-1016838bab065ae1e122.css"
+  #   <%= asset_bundle_path 'icon/favicon.ico' %> # => "/assets/web/pack/icon/favicon-1016838bab065ae1e122.ico"
+  def asset_bundle_path(name, manifest: nil, **options)
+    manifest = get_manifest_by_key(manifest)
+    asset_path(manifest.lookup!(name.to_s), **options)
+  end
+
+  # Example:
+  #
+  #   <%= javascript_bundle_tag 'calendar', 'data-turbolinks-track': 'reload' %> # =>
+  #   <script src="/assets/web/pack/calendar-1016838bab065ae1e314.js" data-turbolinks-track="reload"></script>
+  #
+  #   <%= javascript_bundle_tag 'orders/app'  %> # =>
+  #   <script src="/assets/web/pack/orders/app-1016838bab065ae1e314.js"></script>
+  def javascript_bundle_tag(*names, manifest: nil, **options)
+    javascript_include_tag(*sources_from_manifest(names, 'js', key: manifest), **options)
+  end
+
+  # Creates script tags that references the js chunks from entrypoints when using split chunks API.
+  # See: https://webpack.js.org/plugins/split-chunks-plugin/
+  # Example:
+  #
+  #   <%= javascript_bundles_with_chunks_tag 'calendar', 'map', 'data-turbolinks-track': 'reload' %> # =>
+  #   <script src="/packs/vendor-16838bab065ae1e314.chunk.js" data-turbolinks-track="reload"></script>
+  #   <script src="/packs/calendar~runtime-16838bab065ae1e314.chunk.js" data-turbolinks-track="reload"></script>
+  #   <script src="/packs/calendar-1016838bab065ae1e314.chunk.js" data-turbolinks-track="reload"></script>
+  #   <script src="/packs/map~runtime-16838bab065ae1e314.chunk.js" data-turbolinks-track="reload"></script>
+  #   <script src="/packs/map-16838bab065ae1e314.chunk.js" data-turbolinks-track="reload"></script>
+  # DO:
+  # <%= javascript_bundles_with_chunks_tag 'calendar', 'map' %>
+  # DON'T:
+  # <%= javascript_bundles_with_chunks_tag 'calendar' %>
+  # <%= javascript_bundles_with_chunks_tag 'map' %>
+  def javascript_bundles_with_chunks_tag(*names, manifest: nil, **options)
+    javascript_include_tag(*sources_from_manifest_entrypoints(names, 'js', key: manifest), **options)
+  end
+
+  # Examples:
+  #
+  #   <%= stylesheet_bundle_tag 'calendar', 'data-turbolinks-track': 'reload' %> # =>
+  #   <link rel="stylesheet" media="screen"
+  #    href="/assets/web/pack/calendar-1016838bab065ae1e122.css" data-turbolinks-track="reload" />
+  #
+  #   <%= stylesheet_bundle_tag 'orders/style' %> # =>
+  #   <link rel="stylesheet" media="screen"
+  #    href="/assets/web/pack/orders/style-1016838bab065ae1e122.css" />
+  def stylesheet_bundle_tag(*names, manifest: nil, **options)
+    stylesheet_link_tag(*sources_from_manifest(names, 'css', key: manifest), **options)
+  end
+
+  # Creates link tags that references the css chunks from entrypoints when using split chunks API.
+  # See: https://webpack.js.org/plugins/split-chunks-plugin/
+  # Example:
+  #
+  #   <%= stylesheet_bundles_with_chunks_tag 'calendar', 'map' %> # =>
+  #   <link rel="stylesheet" media="screen" href="/packs/3-8c7ce31a.chunk.css" />
+  #   <link rel="stylesheet" media="screen" href="/packs/calendar-8c7ce31a.chunk.css" />
+  #   <link rel="stylesheet" media="screen" href="/packs/map-8c7ce31a.chunk.css" />
+  # DO:
+  # <%= stylesheet_bundles_with_chunks_tag 'calendar', 'map' %>
+  # DON'T:
+  # <%= stylesheet_bundles_with_chunks_tag 'calendar' %>
+  # <%= stylesheet_bundles_with_chunks_tag 'map' %>
+  def stylesheet_bundles_with_chunks_tag(*names, manifest: nil, **options)
+    stylesheet_link_tag(*sources_from_manifest_entrypoints(names, 'css', key: manifest), **options)
+  end
+
+  # Examples:
+  #
+  #   <%= image_bundle_tag 'icon.png'
+  #   <img src="/assets/pack/icon-1016838bab065ae1e314.png" />
+  #
+  #   <%= image_bundle_tag "icon.png", size: "16x10", alt: "Edit Entry"
+  #   <img src="/assets/pack/icon-1016838bab065ae1e314.png" width="16" height="10" alt="Edit Entry" />
+  def image_bundle_tag(name, manifest: nil, **options)
+    manifest = get_manifest_by_key(manifest)
+    image_tag(manifest.lookup!(name.to_s), **options)
+  end
+
+  private
+
+  def sources_from_manifest(names, ext, key: nil)
+    manifest = get_manifest_by_key(key)
+    names.map { |name| manifest.lookup!(name.to_s + '.' + ext) }
+  end
+
+  def sources_from_manifest_entrypoints(names, type, key: nil)
+    manifest = get_manifest_by_key(key)
+    names.map { |name| manifest.lookup_pack_with_chunks!(name, type: type) }.flatten.uniq
+  end
+
+  def get_manifest_by_key(key = nil)
+    repository = Minipack.configuration.manifests
+    key.nil? ? repository.default : repository.get(key)
+  end
+end

data/lib/minipack/manifest.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'open-uri'
+require 'uri'
+
+module Minipack
+  class Manifest
+    class MissingEntryError < StandardError; end
+    class FileNotFoundError < StandardError; end
+
+    attr_reader :path
+    attr_writer :cache
+
+    def initialize(path, cache: false)
+      @path = path.to_s
+      @cache = cache
+    end
+
+    def lookup_pack_with_chunks!(name, type: nil)
+      manifest_pack_type = manifest_type(name, type)
+      manifest_pack_name = manifest_name(name, manifest_pack_type)
+      find('entrypoints')&.dig(manifest_pack_name, manifest_pack_type) || handle_missing_entry(name)
+    end
+
+    def lookup!(name)
+      find(name) || handle_missing_entry(name)
+    end
+
+    def find(name)
+      data[name.to_s]
+    end
+
+    def assets
+      data.values
+    end
+
+    def cache_enabled?
+      @cache
+    end
+
+    private
+
+    def data
+      if cache_enabled?
+        @data ||= load_data
+      else
+        load_data
+      end
+    end
+
+    def load_data
+      u = URI.parse(@path)
+      data = nil
+      if u.scheme == 'file' || u.path == @path  # file path
+        raise(FileNotFoundError, "#{@path}: no such manifest found") unless File.exist?(@path)
+        data = File.read(@path)
+      else
+        # http url
+        data = u.read
+      end
+      JSON.parse(data)
+    end
+
+    # The `manifest_name` method strips of the file extension of the name, because in the
+    # manifest hash the entrypoints are defined by their pack name without the extension.
+    # When the user provides a name with a file extension, we want to try to strip it off.
+    def manifest_name(name, pack_type)
+      return name if File.extname(name.to_s).empty?
+      File.basename(name, '.' + pack_type)
+    end
+
+    def manifest_type(name, pack_type)
+      return File.extname(name)[1..-1] if pack_type.nil?
+      pack_type.to_s
+    end
+
+    def handle_missing_entry(name)
+      raise MissingEntryError, <<~MSG
+        Can not find #{name} in #{@path}.
+        Your manifest contains:
+        #{JSON.pretty_generate(@data)}
+      MSG
+    end
+  end
+end

data/lib/minipack/manifest_repository.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Minipack
+    class ManifestRepository
+      class NotFoundError < StandardError; end
+
+      attr_accessor :default
+
+      def initialize
+        @manifests = {}
+        @default = nil # a pointer to a default manifest
+      end
+
+      def all_manifests
+        @manifests.values
+      end
+
+      # @private
+      def add(key, path, **options)
+        manifest = Minipack::Manifest.new(path, options)
+        # Mark a first one as a default
+        @default = manifest if @manifests.empty?
+        @manifests[key.to_sym] = manifest
+      end
+
+      def get(key)
+        @manifests[key.to_sym] || raise(NotFoundError, "manifest associated with #{key} not found")
+      end
+    end
+end

data/lib/minipack/railtie.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'rails'
+
+module Minipack
+    class Railtie < ::Rails::Railtie
+      initializer "minipack.set_defaults" do
+        Minipack.configuration.root_path = ::Rails.root.to_s
+        Minipack.configuration.base_path = ::Rails.root.to_s
+      end
+    end
+end

data/lib/minipack/rspec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+RSpec.configure do |c|
+  c.before :suite do
+    logger = Logger.new(STDOUT).tap do |l|
+      l.formatter = proc { |severity, datetime, progname, msg| "#{msg}\n" }
+    end
+    Minipack::Commands::PkgInstall.call(logger: logger)
+    Minipack::Commands::Build.call(logger: logger)
+  end
+end

data/lib/minipack/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Minipack
+  VERSION = "0.3.0"
+end

data/lib/minipack.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module Minipack
+  require 'minipack/manifest'
+  require 'minipack/configuration'
+  require 'minipack/helper'
+  require 'minipack/manifest_repository'
+  require 'minipack/file_change_watcher'
+  require 'minipack/command_runner'
+  require 'minipack/railtie'
+  require 'minipack/commands/base'
+  require 'minipack/commands/build'
+  require 'minipack/commands/pkg_install'
+  require "minipack/version"
+
+  class << self
+    def configuration(&block)
+      @configuration ||= Configuration.new
+      yield @configuration if block_given?
+      @configuration
+    end
+    attr_writer :configuration
+  end
+end
+
+require 'active_support/lazy_load_hooks'
+ActiveSupport.on_load :action_view do
+  ::ActionView::Base.send :include, Minipack::Helper
+end
+
+# To keep backward compatibility
+require_relative 'webpack_manifest'

data/lib/webpack_manifest.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# @deprecated Use Minipack instead
+module WebpackManifest
+  module Rails
+    class << self
+      # @deprecated Use Minipack.configuration API instead
+      def configuration(&block)
+        ActiveSupport::Deprecation.warn('WebpackManifest::Rails.configuration was deprecated. Use Minipack.configuration instead.')
+        Minipack.configuration(&block)
+      end
+
+      # @deprecated Use Minipack.configuration= API instead
+      def configuration=(c)
+        ActiveSupport::Deprecation.warn('WebpackManifest::Rails.configuration= was deprecated. Use Minipack.configuration= instead.')
+        Minipack.configuration = c
+      end
+    end
+  end
+end

data/minipack.gemspec

@@ -0,0 +1,32 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "minipack/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "minipack"
+  spec.version       = Minipack::VERSION
+  spec.authors       = ["Nobuhiro Nikushi"]
+  spec.email         = ["deneb.ge@gmail.com"]
+
+  spec.summary       = "Minipack is a gem for minimalists that integrates Rails and webpack without Webpcker"
+  spec.description   = spec.summary
+  spec.homepage      = "https://github.com/nikushi/minipack"
+  spec.license       = "MIT"
+  spec.files         = Dir['lib/**/*.rb'] + %w[
+    CHANGELOG.md
+    LICENSE.txt
+    README.md
+    Rakefile
+    minipack.gemspec
+  ]
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '>= 2.0.0'
+
+  spec.add_dependency 'actionview'
+  spec.add_dependency "railties", ">= 4.2"
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: minipack
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Nobuhiro Nikushi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-06-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: actionview
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Minipack is a gem for minimalists that integrates Rails and webpack without
+  Webpcker
+email:
+- deneb.ge@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/minipack.rb
+- lib/minipack/command_runner.rb
+- lib/minipack/commands/base.rb
+- lib/minipack/commands/build.rb
+- lib/minipack/commands/pkg_install.rb
+- lib/minipack/configuration.rb
+- lib/minipack/file_change_watcher.rb
+- lib/minipack/helper.rb
+- lib/minipack/manifest.rb
+- lib/minipack/manifest_repository.rb
+- lib/minipack/railtie.rb
+- lib/minipack/rspec.rb
+- lib/minipack/version.rb
+- lib/webpack_manifest.rb
+- minipack.gemspec
+homepage: https://github.com/nikushi/minipack
+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.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Minipack is a gem for minimalists that integrates Rails and webpack without
+  Webpcker
+test_files: []