shakapacker 6.2.0 → 6.3.0

data/lib/tasks/webpacker/compile.rake

@@ -33,10 +33,7 @@ namespace :webpacker do
   end
 end
 
-# Compile packs after we've compiled all other assets during precompilation
-skip_webpacker_precompile = %w(no false n f).include?(ENV["WEBPACKER_PRECOMPILE"])
-
-unless skip_webpacker_precompile
+if Webpacker.config.webpacker_precompile?
   if Rake::Task.task_defined?("assets:precompile")
     enhance_assets_precompile
   else

data/lib/webpacker/base_strategy.rb

@@ -0,0 +1,24 @@
+module Webpacker
+  class BaseStrategy
+    def initialize
+      @config = Webpacker.config
+    end
+
+    def after_compile_hook
+      nil
+    end
+
+    private
+
+      attr_reader :config
+
+      def default_watched_paths
+        [
+          *config.additional_paths.map { |path| "#{path}{,/**/*}" },
+          "#{config.source_path}{,/**/*}",
+          "yarn.lock", "package.json",
+          "config/webpack{,/**/*}"
+        ].freeze
+      end
+  end
+end

data/lib/webpacker/compiler.rb

@@ -1,18 +1,13 @@
 require "open3"
-require "digest/sha1"
+require "webpacker/compiler_strategy"
 
 class Webpacker::Compiler
-  # Additional paths that test compiler needs to watch
-  # Webpacker::Compiler.watched_paths << 'bower_components'
-  #
-  # Deprecated. Use additional_paths in the YAML configuration instead.
-  cattr_accessor(:watched_paths) { [] }
-
   # Additional environment variables that the compiler is being run with
   # Webpacker::Compiler.env['FRONTEND_API_KEY'] = 'your_secret_key'
   cattr_accessor(:env) { {} }
 
-  delegate :config, :logger, to: :webpacker
+  delegate :config, :logger, :strategy, to: :webpacker
+  delegate :fresh?, :stale?, :after_compile_hook, to: :strategy
 
   def initialize(webpacker)
     @webpacker = webpacker
@@ -21,11 +16,7 @@ class Webpacker::Compiler
   def compile
     if stale?
       run_webpack.tap do |success|
-        # We used to only record the digest on success
-        # However, the output file is still written on error, meaning that the digest should still be updated.
-        # If it's not, you can end up in a situation where a recompile doesn't take place when it should.
-        # See https://github.com/rails/webpacker/issues/2113
-        record_compilation_digest
+        after_compile_hook
       end
     else
       logger.debug "Everything's up-to-date. Nothing to do"
@@ -33,50 +24,9 @@ class Webpacker::Compiler
     end
   end
 
-  # Returns true if all the compiled packs are up to date with the underlying asset files.
-  def fresh?
-    last_compilation_digest&.== watched_files_digest
-  end
-
-  # Returns true if the compiled packs are out of date with the underlying asset files.
-  def stale?
-    !fresh?
-  end
-
   private
     attr_reader :webpacker
 
-    def last_compilation_digest
-      compilation_digest_path.read if compilation_digest_path.exist? && config.manifest_path.exist?
-    rescue Errno::ENOENT, Errno::ENOTDIR
-    end
-
-    def watched_files_digest
-      if Rails.env.development?
-        warn <<~MSG.strip
-          Webpacker::Compiler - Slow setup for development
-
-          Prepare JS assets with either:
-          1. Running `bin/webpacker-dev-server`
-          2. Set `compile` to false in webpacker.yml and run `bin/webpacker -w`
-        MSG
-      end
-
-      warn "Webpacker::Compiler.watched_paths has been deprecated. Set additional_paths in webpacker.yml instead." unless watched_paths.empty?
-      root_path = Pathname.new(File.expand_path(config.root_path))
-      expanded_paths = [*default_watched_paths, *watched_paths].map do |path|
-        root_path.join(path)
-      end
-      files = Dir[*expanded_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
-
-    def record_compilation_digest
-      config.cache_path.mkpath
-      compilation_digest_path.write(watched_files_digest)
-    end
-
     def optionalRubyRunner
       bin_webpack_path = config.root_path.join("bin/webpacker")
       first_line = File.readlines(bin_webpack_path).first.chomp
@@ -107,19 +57,6 @@ class Webpacker::Compiler
       status.success?
     end
 
-    def default_watched_paths
-      [
-        *config.additional_paths,
-        "#{config.source_path}/**/*",
-        "yarn.lock", "package.json",
-        "config/webpack/**/*"
-      ].freeze
-    end
-
-    def compilation_digest_path
-      config.cache_path.join("last-compilation-digest-#{webpacker.env}")
-    end
-
     def webpack_env
       return env unless defined?(ActionController::Base)
 

data/lib/webpacker/compiler_strategy.rb

@@ -0,0 +1,20 @@
+require "webpacker/mtime_strategy"
+require "webpacker/digest_strategy"
+
+module Webpacker
+  class CompilerStrategy
+    def self.from_config
+      strategy_from_config = Webpacker.config.compiler_strategy
+
+      case strategy_from_config
+      when "mtime"
+        Webpacker::MtimeStrategy.new
+      when "digest"
+        Webpacker::DigestStrategy.new
+      else
+        raise "Unknown strategy '#{strategy_from_config}'. " \
+              "Available options are 'mtime' and 'digest'."
+      end
+    end
+  end
+end

data/lib/webpacker/configuration.rb

@@ -27,6 +27,12 @@ class Webpacker::Configuration
     fetch(:ensure_consistent_versioning)
   end
 
+  def webpacker_precompile?
+    # ENV of false takes precedence
+    return false if %w(no false n f).include?(ENV["WEBPACKER_PRECOMPILE"])
+    return %w(yes true t).include?(ENV["WEBPACKER_PRECOMPILE"]) || fetch(:webpacker_precompile)
+  end
+
   def source_path
     root_path.join(fetch(:source_path))
   end
@@ -47,6 +53,10 @@ class Webpacker::Configuration
     end
   end
 
+  def public_manifest_path
+    manifest_path
+  end
+
   def public_path
     root_path.join(fetch(:public_root_path))
   end
@@ -75,6 +85,10 @@ class Webpacker::Configuration
     fetch(:webpack_compile_output)
   end
 
+  def compiler_strategy
+    fetch(:compiler_strategy)
+  end
+
   def fetch(key)
     data.fetch(key, defaults[key])
   end

data/lib/webpacker/digest_strategy.rb

@@ -0,0 +1,59 @@
+require "digest/sha1"
+require "webpacker/base_strategy"
+
+module Webpacker
+  class DigestStrategy < BaseStrategy
+    # Returns true if all the compiled packs are up to date with the underlying asset files.
+    def fresh?
+      last_compilation_digest&.== watched_files_digest
+    end
+
+    # Returns true if the compiled packs are out of date with the underlying asset files.
+    def stale?
+      !fresh?
+    end
+
+    def after_compile_hook
+      # We used to only record the digest on success
+      # However, the output file is still written on error, meaning that the digest should still be updated.
+      # If it's not, you can end up in a situation where a recompile doesn't take place when it should.
+      # See https://github.com/rails/webpacker/issues/2113
+      record_compilation_digest
+    end
+
+    private
+
+      def last_compilation_digest
+        compilation_digest_path.read if compilation_digest_path.exist? && config.manifest_path.exist?
+      rescue Errno::ENOENT, Errno::ENOTDIR
+      end
+
+      def watched_files_digest
+        if Rails.env.development?
+          warn <<~MSG.strip
+          Webpacker::Compiler - Slow setup for development
+          Prepare JS assets with either:
+          1. Running `bin/webpacker-dev-server`
+          2. Set `compile` to false in webpacker.yml and run `bin/webpacker -w`
+        MSG
+        end
+
+        root_path = Pathname.new(File.expand_path(config.root_path))
+        expanded_paths = [*default_watched_paths].map do |path|
+          root_path.join(path)
+        end
+        files = Dir[*expanded_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
+
+      def record_compilation_digest
+        config.cache_path.mkpath
+        compilation_digest_path.write(watched_files_digest)
+      end
+
+      def compilation_digest_path
+        config.cache_path.join("last-compilation-digest-#{Webpacker.env}")
+      end
+  end
+end

data/lib/webpacker/helper.rb

@@ -101,9 +101,17 @@ module Webpacker::Helper
       "Please refer to https://github.com/shakacode/shakapacker/blob/master/README.md#usage for the usage guide"
     end
 
+    append_javascript_pack_tag(*names, defer: defer)
+    non_deferred = sources_from_manifest_entrypoints(javascript_pack_tag_queue[:non_deferred], type: :javascript)
+    deferred = sources_from_manifest_entrypoints(javascript_pack_tag_queue[:deferred], type: :javascript) - non_deferred
+
     @javascript_pack_tag_loaded = true
 
-    javascript_include_tag(*sources_from_manifest_entrypoints(names, type: :javascript), **options.tap { |o| o[:defer] = defer })
+    capture do
+      concat javascript_include_tag(*deferred, **options.tap { |o| o[:defer] = true })
+      concat "\n" if non_deferred.any? && deferred.any?
+      concat javascript_include_tag(*non_deferred, **options.tap { |o| o[:defer] = false })
+    end
   end
 
   # Creates a link tag, for preloading, that references a given Webpacker asset.
@@ -153,8 +161,25 @@ module Webpacker::Helper
     stylesheet_link_tag(*sources_from_manifest_entrypoints(names, type: :stylesheet), **options)
   end
 
+  def append_javascript_pack_tag(*names, defer: true)
+    if @javascript_pack_tag_loaded
+      raise "You can only call append_javascript_pack_tag before javascript_pack_tag helper. " \
+      "Please refer to https://github.com/shakacode/shakapacker/blob/master/README.md#usage for the usage guide"
+    end
+
+    hash_key = defer ? :deferred : :non_deferred
+    javascript_pack_tag_queue[hash_key] |= names
+  end
+
   private
 
+    def javascript_pack_tag_queue
+      @javascript_pack_tag_queue ||= {
+        deferred: [],
+        non_deferred: []
+      }
+    end
+
     def sources_from_manifest_entrypoints(names, type:)
       names.map { |name| current_webpacker_instance.manifest.lookup_pack_with_chunks!(name.to_s, type: type) }.flatten.uniq
     end

data/lib/webpacker/instance.rb

@@ -19,6 +19,10 @@ class Webpacker::Instance
     )
   end
 
+  def strategy
+    @strategy ||= Webpacker::CompilerStrategy.from_config
+  end
+
   def compiler
     @compiler ||= Webpacker::Compiler.new self
   end

data/lib/webpacker/manifest.rb

@@ -104,12 +104,12 @@ class Webpacker::Manifest
 
     def missing_file_from_manifest_error(bundle_name)
       <<-MSG
-Webpacker can't find #{bundle_name} in #{config.manifest_path}. Possible causes:
+Shakapacker can't find #{bundle_name} in #{config.manifest_path}. Possible causes:
 1. You forgot to install node packages (try `yarn install`) or are running an incompatible version of Node
 2. Your app has code with a non-standard extension (like a `.jsx` file) but the extension is not in the `extensions` config in `config/webpacker.yml`
 3. You have set compile: false (see `config/webpacker.yml`) for this environment
    (unless you are using the `bin/webpacker -w` or the `bin/webpacker-dev-server`, in which case maybe you aren't running the dev server in the background?)
-4. webpack has not yet re-run to reflect updates.
+4. webpack has not yet FINISHED running to reflect updates.
 5. You have misconfigured Webpacker's `config/webpacker.yml` file.
 6. Your webpack configuration is not creating a manifest.
 

data/lib/webpacker/mtime_strategy.rb

@@ -0,0 +1,40 @@
+require "webpacker/base_strategy"
+
+module Webpacker
+  class MtimeStrategy < BaseStrategy
+    # Returns true if manifest file mtime is newer than the timestamp of the last modified watched file
+    def fresh?
+      manifest_mtime > latest_modified_timestamp
+    end
+
+    # Returns true if manifest file mtime is older than the timestamp of the last modified watched file
+    def stale?
+      !fresh?
+    end
+
+    private
+
+      def manifest_mtime
+        config.manifest_path.exist? ? File.mtime(config.manifest_path).to_i : 0
+      end
+
+      def latest_modified_timestamp
+        if Rails.env.development?
+          warn <<~MSG.strip
+          Webpacker::Compiler - Slow setup for development
+
+          Prepare JS assets with either:
+          1. Running `bin/webpacker-dev-server`
+          2. Set `compile` to false in webpacker.yml and run `bin/webpacker -w`
+        MSG
+        end
+
+        root_path = Pathname.new(File.expand_path(config.root_path))
+        expanded_paths = [*default_watched_paths].map do |path|
+          root_path.join(path)
+        end
+        latest_modified = Dir[*expanded_paths].max_by { |f| File.mtime(f) }
+        File.mtime(latest_modified).to_i
+      end
+  end
+end

data/lib/webpacker/version.rb

@@ -1,4 +1,4 @@
 module Webpacker
   # Change the version in package.json too, please!
-  VERSION = "6.2.0".freeze
+  VERSION = "6.3.0".freeze
 end

data/package/babel/preset.js

@@ -25,7 +25,6 @@ module.exports = function config(api) {
           corejs: '3.8',
           modules: 'auto',
           bugfixes: true,
-          loose: true,
           exclude: ['transform-typeof-symbol']
         }
       ],

data/package/rules/file.js

@@ -1,4 +1,4 @@
-const { dirname, join } = require('path')
+const { dirname } = require('path')
 const { source_path: sourcePath } = require('../config')
 
 module.exports = {
@@ -12,7 +12,7 @@ module.exports = {
         .split('/')
         .slice(1)
 
-      const foldersWithStatic = join('static', ...folders)
+      const foldersWithStatic = ['static', ...folders].join('/')
       return `${foldersWithStatic}/[name]-[hash][ext][query]`
     }
   }

data/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shakapacker",
-  "version": "6.2.0",
+  "version": "6.3.0",
   "description": "Use webpack to manage app-like JavaScript modules in Rails",
   "main": "package/index.js",
   "files": [
@@ -12,16 +12,17 @@
     "yarn": ">=1 <4"
   },
   "peerDependencies": {
-    "@babel/core": "^7.15.5",
-    "@babel/plugin-transform-runtime": "^7.15.0",
-    "@babel/preset-env": "^7.15.6",
-    "@babel/runtime": "^7.15.4",
-    "babel-loader": "^8.2.2",
+    "@babel/core": "^7.17.9",
+    "@babel/plugin-transform-runtime": "^7.17.0",
+    "@babel/preset-env": "^7.16.11",
+    "@babel/runtime": "^7.17.9",
+    "babel-loader": "^8.2.4",
     "compression-webpack-plugin": "^9.0.0",
-    "terser-webpack-plugin": "^5.2.4",
-    "webpack": "^5.53.0",
+    "terser-webpack-plugin": "^5.3.1",
+    "webpack": "^5.72.0",
     "webpack-assets-manifest": "^5.0.6",
-    "webpack-cli": "^4.8.0",
+    "webpack-cli": "^4.9.2",
+    "webpack-dev-server": "^4.9.0",
     "webpack-merge": "^5.8.0"
   },
   "dependencies": {
@@ -30,7 +31,7 @@
     "path-complete-extname": "^1.0.0"
   },
   "devDependencies": {
-    "babel-loader": "^8.2.2",
+    "babel-loader": "^8.2.4",
     "compression-webpack-plugin": "^9.0.0",
     "esbuild-loader": "^2.18.0",
     "eslint": "^7.32.0",
@@ -41,7 +42,7 @@
     "eslint-plugin-react": "^7.26.0",
     "jest": "^27.2.1",
     "swc-loader": "^0.1.15",
-    "webpack": "^5.53.0",
+    "webpack": "^5.72.0",
     "webpack-assets-manifest": "^5.0.6",
     "webpack-merge": "^5.8.0"
   },

data/test/compiler_strategy_test.rb

@@ -0,0 +1,27 @@
+require "test_helper"
+
+class CompilerStrategyTest < Minitest::Test
+  def test_mtime_strategy_returned
+    Webpacker.config.stub :compiler_strategy, "mtime" do
+      assert_instance_of Webpacker::MtimeStrategy, Webpacker::CompilerStrategy.from_config
+    end
+  end
+
+  def test_digest_strategy_returned
+    Webpacker.config.stub :compiler_strategy, "digest" do
+      assert_instance_of Webpacker::DigestStrategy, Webpacker::CompilerStrategy.from_config
+    end
+  end
+
+  def test_raise_on_unknown_strategy
+    Webpacker.config.stub :compiler_strategy, "other" do
+      error = assert_raises do
+        Webpacker::CompilerStrategy.from_config
+      end
+
+      assert_equal \
+        "Unknown strategy 'other'. Available options are 'mtime' and 'digest'.",
+        error.message
+    end
+  end
+end

data/test/compiler_test.rb

@@ -1,20 +1,6 @@
 require "test_helper"
 
 class CompilerTest < Minitest::Test
-  def remove_compilation_digest_path
-    Webpacker.compiler.send(:compilation_digest_path).tap do |path|
-      path.delete if path.exist?
-    end
-  end
-
-  def setup
-    remove_compilation_digest_path
-  end
-
-  def teardown
-    remove_compilation_digest_path
-  end
-
   def test_custom_environment_variables
     assert_nil Webpacker.compiler.send(:webpack_env)["FOO"]
     Webpacker.compiler.env["FOO"] = "BAR"
@@ -23,37 +9,43 @@ class CompilerTest < Minitest::Test
     Webpacker.compiler.env = {}
   end
 
-  def test_freshness
-    assert Webpacker.compiler.stale?
-    assert !Webpacker.compiler.fresh?
+  def test_compile_true_when_fresh
+    mock = Minitest::Mock.new
+    mock.expect(:stale?, false)
+    Webpacker.compiler.stub(:strategy, mock) do
+      assert Webpacker.compiler.compile
+    end
+    assert_mock mock
   end
 
-  def test_compile
-    assert !Webpacker.compiler.compile
-  end
+  def test_after_compile_hook_called_on_success
+    mock = Minitest::Mock.new
+    mock.expect(:stale?, true)
+    mock.expect(:after_compile_hook, nil)
 
-  def test_freshness_on_compile_success
     status = OpenStruct.new(success?: true)
 
-    assert Webpacker.compiler.stale?
-    Open3.stub :capture3, [:sterr, :stdout, status] do
-      Webpacker.compiler.compile
-      assert Webpacker.compiler.fresh?
+    Webpacker.compiler.stub(:strategy, mock) do
+      Open3.stub :capture3, [:sterr, :stdout, status] do
+        Webpacker.compiler.compile
+      end
     end
+    assert_mock mock
   end
 
-  def test_freshness_on_compile_fail
+  def test_after_compile_hook_called_on_failure
+    mock = Minitest::Mock.new
+    mock.expect(:stale?, true)
+    mock.expect(:after_compile_hook, nil)
+
     status = OpenStruct.new(success?: false)
 
-    assert Webpacker.compiler.stale?
-    Open3.stub :capture3, [:sterr, :stdout, status] do
-      Webpacker.compiler.compile
-      assert Webpacker.compiler.fresh?
+    Webpacker.compiler.stub(:strategy, mock) do
+      Open3.stub :capture3, [:sterr, :stdout, status] do
+        Webpacker.compiler.compile
+      end
     end
-  end
-
-  def test_compilation_digest_path
-    assert_equal Webpacker.compiler.send(:compilation_digest_path).basename.to_s, "last-compilation-digest-#{Webpacker.env}"
+    assert_mock mock
   end
 
   def test_external_env_variables

data/test/configuration_test.rb

@@ -28,28 +28,33 @@ class ConfigurationTest < Webpacker::Test
     public_output_path = File.expand_path File.join(File.dirname(__FILE__), "test_app/public/packs").to_s
     assert_equal @config.public_output_path.to_s, public_output_path
 
-    @config = Webpacker::Configuration.new(
+    @public_root_config = Webpacker::Configuration.new(
       root_path: @config.root_path,
       config_path: Pathname.new(File.expand_path("./test_app/config/webpacker_public_root.yml", __dir__)),
       env: "production"
     )
 
     public_output_path = File.expand_path File.join(File.dirname(__FILE__), "public/packs").to_s
-    assert_equal @config.public_output_path.to_s, public_output_path
+    assert_equal @public_root_config.public_output_path.to_s, public_output_path
+  end
+
+  def test_public_manifest_path
+    public_manifest_path = File.expand_path File.join(File.dirname(__FILE__), "test_app/public/packs", "manifest.json").to_s
+    assert_equal @config.public_manifest_path.to_s, public_manifest_path
   end
 
   def test_manifest_path
     manifest_path = File.expand_path File.join(File.dirname(__FILE__), "test_app/public/packs", "manifest.json").to_s
     assert_equal @config.manifest_path.to_s, manifest_path
 
-    @config = Webpacker::Configuration.new(
+    @manifest_config = Webpacker::Configuration.new(
       root_path: @config.root_path,
       config_path: Pathname.new(File.expand_path("./test_app/config/webpacker_manifest_path.yml", __dir__)),
       env: "production"
     )
 
     manifest_path = File.expand_path File.join(File.dirname(__FILE__), "test_app/app/packs", "manifest.json").to_s
-    assert_equal @config.manifest_path.to_s, manifest_path
+    assert_equal @manifest_config.manifest_path.to_s, manifest_path
   end
 
   def test_cache_path
@@ -95,5 +100,25 @@ class ConfigurationTest < Webpacker::Test
     with_rails_env("test") do
       refute Webpacker.config.ensure_consistent_versioning?
     end
+
+    def test_webpacker_precompile
+      assert @config.webpacker_precompile
+
+      ENV["WEBPACKER_PRECOMPILE"] = "false"
+
+      refute Webpacker.config.webpacker_precompile?
+
+      ENV["WEBPACKER_PRECOMPILE"] = "yes"
+
+      assert Webpacker.config.webpacker_precompile?
+
+      @no_precompile_config = Webpacker::Configuration.new(
+        root_path: @config.root_path,
+        config_path: Pathname.new(File.expand_path("./test_app/config/webpacker_no_precompile.yml", __dir__)),
+        env: "production"
+      )
+
+      refute @no_precompile_config.webpacker_precompile
+    end
   end
 end

data/test/digest_strategy_test.rb

@@ -0,0 +1,33 @@
+require "test_helper"
+
+class DigestStrategyTest < Minitest::Test
+  def remove_compilation_digest_path
+    @digest_strategy.send(:compilation_digest_path).tap do |path|
+      path.delete if path.exist?
+    end
+  end
+
+  def setup
+    @digest_strategy = Webpacker::DigestStrategy.new
+    remove_compilation_digest_path
+  end
+
+  def teardown
+    remove_compilation_digest_path
+  end
+
+  def test_freshness
+    assert @digest_strategy.stale?
+    assert !@digest_strategy.fresh?
+  end
+
+  def test_freshness_after_compilation_hook
+    @digest_strategy.after_compile_hook
+    assert @digest_strategy.fresh?
+    assert !@digest_strategy.stale?
+  end
+
+  def test_compilation_digest_path
+    assert_equal @digest_strategy.send(:compilation_digest_path).basename.to_s, "last-compilation-digest-#{Webpacker.env}"
+  end
+end