railpack 1.2.9 → 1.2.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fe05b41d6d14b07c685da85ad0d3f7f89f15964372a0caa370d9774e990936a4
-  data.tar.gz: 35f84323f06c0132e245a5b6db03d852374be0887a52131273bf098c9d8cdf72
+  metadata.gz: b2255e81346b6fe1ed60e139f49f747e24c13589cc70771e39e2ede97780b081
+  data.tar.gz: 0065d985425006c7f084214bbaa7c44d1423367c95e47bb879f02b21a9274fce
 SHA512:
-  metadata.gz: '006682248e46a9b3e75e80a87eb6d5add2a8faa5e7df3eb2dea9a310266e72f82dc521a329519fa415dd5f5d42aaf9f7ca8be3ce0e0323486cbab8d8291662ca'
-  data.tar.gz: b7edcd749a26210d6a5d7ea29e0d8a544f154f8f28d0f9b9beb0d8e1b14ec8f5dffe64162fc7eb0fde210f081722872f2b05b95f099c937a763196dfa756a98a
+  metadata.gz: 37f8ef74dce0b9d689f95f20c49ed7b997e90e5aa8dbe657652bb8e1a4cb5bd709cf2acc53cfb199bb042443d1992a80605a19cf9d74be1ab96a8cc41e6b55ca
+  data.tar.gz: bc795780c31ab2b7e815eaf4e878c9f3ac4d222a88df601422420b6ef73de3c21a47eb07a6ba2cdae5f46cd218ba25445adbaa95b978b4e024cec9d97bef2f97

data/lib/railpack/manager.rb

@@ -88,9 +88,9 @@ module Railpack
     end
 
     # Rails asset pipeline integration
-    def self.enhance_assets_precompile(*tasks)
+    def self.enhance_assets_precompile(*tasks, &block)
       if defined?(Rake::Task) && Rake::Task.task_defined?("assets:precompile")
-        Rake::Task["assets:precompile"].enhance(tasks)
+        Rake::Task["assets:precompile"].enhance(tasks, &block)
       end
     end
 
@@ -150,8 +150,8 @@ module Railpack
       # Check for Propshaft (Rails 7+ default)
       if defined?(Propshaft) || (defined?(Rails) && Rails.version.to_f >= 7.0)
         :propshaft
-      # Check for Sprockets
-      elsif defined?(Sprockets)
+      # Check for Sprockets (only if Rails < 7)
+      elsif defined?(Sprockets) && defined?(Rails) && Rails.version.to_f < 7.0
         :sprockets
       else
         # Default to Propshaft for modern Rails or when no Rails is detected
@@ -172,7 +172,7 @@ module Railpack
         logical_path = relative_path
         manifest[logical_path] = {
           'logical_path' => logical_path,
-          'pathname' => Pathname.new(relative_path),
+          'pathname' => relative_path,
           'digest' => Digest::MD5.file(file).hexdigest
         }
       end

data/lib/railpack/version.rb

@@ -1,3 +1,3 @@
 module Railpack
-  VERSION = "1.2.9"
+  VERSION = "1.2.11"
 end

data/lib/railpack.rb

@@ -16,7 +16,7 @@ module Railpack
     attr_writer :logger
 
     def logger
-      @logger ||= Logger.new($stdout)
+      @logger ||= defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger ? Rails.logger : Logger.new($stdout)
     end
 
     def config

data/test/manager_test.rb

@@ -13,6 +13,9 @@ class ManagerTest < Minitest::Test
     if defined?(Rails) && Rails.respond_to?(:root)
       @original_rails_root = Rails.singleton_class.instance_method(:root)
     end
+
+    # Clear cached logger to avoid interference between tests
+    Railpack.instance_variable_set(:@logger, nil)
   end
 
   def teardown
@@ -86,6 +89,11 @@ class ManagerTest < Minitest::Test
     config = { 'outdir' => outdir }
     manager = Railpack::Manager.new
 
+    # Force Propshaft detection for this test
+    def manager.detect_asset_pipeline
+      :propshaft
+    end
+
     manager.send(:generate_asset_manifest, config)
 
     manifest_path = File.join(outdir, '.manifest.json')
@@ -94,8 +102,10 @@ class ManagerTest < Minitest::Test
     manifest = JSON.parse(File.read(manifest_path))
     assert manifest.key?('application.js')
     assert manifest.key?('application.css')
-    assert manifest['application.js']['logical_path'] == 'application.js'
-    assert manifest['application.js']['pathname'].end_with?('application.js')
+    assert_equal 'application.js', manifest['application.js']['logical_path']
+    pathname = manifest['application.js']['pathname']
+    assert pathname.is_a?(String) || pathname.respond_to?(:to_s)
+    assert pathname.to_s.end_with?('application.js')
     assert manifest['application.js']['digest']
   end
 

data/test/propshaft_test.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require 'tempfile'
+require 'fileutils'
+require 'pathname'
+require 'json'
+require 'railpack'
+
+class PropshaftTest < Minitest::Test
+  def setup
+    @temp_dir = Dir.mktmpdir
+
+    # Clear cached logger to avoid interference between tests
+    Railpack.instance_variable_set(:@logger, nil)
+  end
+
+  def teardown
+    FileUtils.remove_entry(@temp_dir) if @temp_dir && Dir.exist?(@temp_dir)
+  end
+
+  def test_propshaft_manifest_generation_basic
+    outdir = File.join(@temp_dir, 'builds')
+    FileUtils.mkdir_p(outdir)
+
+    # Create fake built assets
+    File.write(File.join(outdir, 'application.js'), 'console.log("app");')
+    File.write(File.join(outdir, 'application.css'), 'body { color: blue; }')
+    File.write(File.join(outdir, 'vendor.js'), 'console.log("vendor");')
+
+    config = { 'outdir' => outdir }
+    manager = Railpack::Manager.new
+
+    # Force Propshaft detection
+    def manager.detect_asset_pipeline
+      :propshaft
+    end
+
+    manager.send(:generate_asset_manifest, config)
+
+    manifest_path = File.join(outdir, '.manifest.json')
+    assert File.exist?(manifest_path)
+
+    manifest = JSON.parse(File.read(manifest_path))
+
+    # Check application assets
+    assert manifest.key?('application.js')
+    assert manifest.key?('application.css')
+
+    # Check manifest structure
+    js_entry = manifest['application.js']
+    assert_equal 'application.js', js_entry['logical_path']
+    assert js_entry['pathname'].end_with?('application.js')
+    assert js_entry['digest']
+    assert_match(/\A[a-f0-9]+\z/, js_entry['digest'])
+  end
+
+  def test_propshaft_manifest_generation_with_subdirectories
+    outdir = File.join(@temp_dir, 'builds')
+    FileUtils.mkdir_p(outdir)
+
+    # Create assets in subdirectories
+    js_dir = File.join(outdir, 'javascripts')
+    css_dir = File.join(outdir, 'stylesheets')
+    FileUtils.mkdir_p([js_dir, css_dir])
+
+    File.write(File.join(js_dir, 'application.js'), 'console.log("app");')
+    File.write(File.join(css_dir, 'application.css'), 'body { color: blue; }')
+
+    config = { 'outdir' => outdir }
+    manager = Railpack::Manager.new
+
+    def manager.detect_asset_pipeline
+      :propshaft
+    end
+
+    manager.send(:generate_asset_manifest, config)
+
+    manifest_path = File.join(outdir, '.manifest.json')
+    assert File.exist?(manifest_path)
+
+    manifest = JSON.parse(File.read(manifest_path))
+
+    # Should find assets in subdirectories with full relative paths as keys
+    assert manifest.key?('javascripts/application.js')
+    assert manifest.key?('stylesheets/application.css')
+
+    # Check paths are relative
+    js_entry = manifest['javascripts/application.js']
+    assert_equal 'javascripts/application.js', js_entry['pathname'].to_s
+    assert_equal 'javascripts/application.js', js_entry['logical_path']
+  end
+
+  def test_propshaft_manifest_generation_empty_directory
+    outdir = File.join(@temp_dir, 'empty_builds')
+    FileUtils.mkdir_p(outdir)
+
+    config = { 'outdir' => outdir }
+    manager = Railpack::Manager.new
+
+    def manager.detect_asset_pipeline
+      :propshaft
+    end
+
+    manager.send(:generate_asset_manifest, config)
+
+    manifest_path = File.join(outdir, '.manifest.json')
+    assert File.exist?(manifest_path)
+
+    manifest = JSON.parse(File.read(manifest_path))
+    assert_empty manifest
+  end
+
+  def test_propshaft_manifest_generation_digest_calculation
+    outdir = File.join(@temp_dir, 'builds')
+    FileUtils.mkdir_p(outdir)
+
+    content = 'console.log("test content");'
+    File.write(File.join(outdir, 'test.js'), content)
+
+    config = { 'outdir' => outdir }
+    manager = Railpack::Manager.new
+
+    def manager.detect_asset_pipeline
+      :propshaft
+    end
+
+    manager.send(:generate_asset_manifest, config)
+
+    manifest_path = File.join(outdir, '.manifest.json')
+    manifest = JSON.parse(File.read(manifest_path))
+
+    # Verify digest matches file content
+    expected_digest = Digest::MD5.hexdigest(content)
+    assert_equal expected_digest, manifest['test.js']['digest']
+  end
+
+  def test_propshaft_manifest_generation_multiple_assets
+    outdir = File.join(@temp_dir, 'builds')
+    FileUtils.mkdir_p(outdir)
+
+    # Create multiple assets
+    assets = {
+      'application.js' => 'console.log("app");',
+      'application.css' => 'body { color: red; }',
+      'vendor.js' => 'console.log("vendor");',
+      'admin.css' => '.admin { display: none; }'
+    }
+
+    assets.each do |filename, content|
+      File.write(File.join(outdir, filename), content)
+    end
+
+    config = { 'outdir' => outdir }
+    manager = Railpack::Manager.new
+
+    def manager.detect_asset_pipeline
+      :propshaft
+    end
+
+    manager.send(:generate_asset_manifest, config)
+
+    manifest_path = File.join(outdir, '.manifest.json')
+    manifest = JSON.parse(File.read(manifest_path))
+
+    # Check all assets are included
+    assert_equal assets.keys.sort, manifest.keys.sort
+
+    # Verify each asset has correct structure
+    assets.each do |filename, content|
+      entry = manifest[filename]
+      assert_equal filename, entry['logical_path']
+      assert entry['pathname'].end_with?(filename)
+      assert_equal Digest::MD5.hexdigest(content), entry['digest']
+    end
+  end
+
+  def test_propshaft_manifest_generation_with_source_maps
+    outdir = File.join(@temp_dir, 'builds')
+    FileUtils.mkdir_p(outdir)
+
+    # Create JS with source map
+    File.write(File.join(outdir, 'application.js'), 'console.log("app");')
+    File.write(File.join(outdir, 'application.js.map'), '{"version":3,"sources":[]}')
+
+    config = { 'outdir' => outdir }
+    manager = Railpack::Manager.new
+
+    def manager.detect_asset_pipeline
+      :propshaft
+    end
+
+    manager.send(:generate_asset_manifest, config)
+
+    manifest_path = File.join(outdir, '.manifest.json')
+    manifest = JSON.parse(File.read(manifest_path))
+
+    # Source maps should not be included in manifest
+    assert manifest.key?('application.js')
+    refute manifest.key?('application.js.map')
+  end
+
+  def test_propshaft_manifest_overwrites_existing
+    outdir = File.join(@temp_dir, 'builds')
+    FileUtils.mkdir_p(outdir)
+
+    # Create existing manifest
+    existing_manifest = { 'old.js' => { 'logical_path' => 'old.js' } }
+    manifest_path = File.join(outdir, '.manifest.json')
+    File.write(manifest_path, JSON.pretty_generate(existing_manifest))
+
+    # Create new assets
+    File.write(File.join(outdir, 'application.js'), 'console.log("new");')
+
+    config = { 'outdir' => outdir }
+    manager = Railpack::Manager.new
+
+    def manager.detect_asset_pipeline
+      :propshaft
+    end
+
+    manager.send(:generate_asset_manifest, config)
+
+    # Manifest should be overwritten
+    new_manifest = JSON.parse(File.read(manifest_path))
+    refute new_manifest.key?('old.js')
+    assert new_manifest.key?('application.js')
+  end
+end

data/test/rails_integration_test.rb

@@ -0,0 +1,265 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require 'tempfile'
+require 'fileutils'
+require 'pathname'
+require 'json'
+require 'railpack'
+
+class RailsIntegrationTest < Minitest::Test
+  def setup
+    @temp_dir = Dir.mktmpdir
+    @original_rails = nil
+    @original_propshaft = nil
+    @original_sprockets = nil
+
+    # Store original constants
+    @original_rails = Object.const_get(:Rails) if defined?(Rails)
+    @original_propshaft = Object.const_get(:Propshaft) if defined?(Propshaft)
+    @original_sprockets = Object.const_get(:Sprockets) if defined?(Sprockets)
+
+    # Clear cached logger to avoid interference between tests
+    Railpack.instance_variable_set(:@logger, nil)
+  end
+
+  def teardown
+    FileUtils.remove_entry(@temp_dir) if @temp_dir && Dir.exist?(@temp_dir)
+
+    # Clean up any constants we created
+    Object.send(:remove_const, :Rails) if defined?(Rails) && Rails.name.nil?
+    Object.send(:remove_const, :Propshaft) if defined?(Propshaft) && Propshaft.name.nil?
+    Object.send(:remove_const, :Sprockets) if defined?(Sprockets) && Sprockets.name.nil?
+
+    # Restore original constants
+    Object.const_set(:Rails, @original_rails) if @original_rails
+    Object.const_set(:Propshaft, @original_propshaft) if @original_propshaft
+    Object.const_set(:Sprockets, @original_sprockets) if @original_sprockets
+  end
+
+  def test_asset_pipeline_detection_rails_7_propshaft
+    # Mock Rails 7 with Propshaft
+    rails_mock = Module.new
+    rails_mock.define_singleton_method(:version) { '7.0.0' }
+    Object.const_set(:Rails, rails_mock)
+
+    Object.const_set(:Propshaft, Module.new)
+
+    manager = Railpack::Manager.new
+    pipeline = manager.send(:detect_asset_pipeline)
+
+    assert_equal :propshaft, pipeline
+  ensure
+    Object.send(:remove_const, :Propshaft) if defined?(Propshaft)
+  end
+
+  def test_asset_pipeline_detection_rails_6_sprockets
+    # Mock Rails 6 with Sprockets
+    rails_mock = Module.new
+    rails_mock.define_singleton_method(:version) { '6.1.0' }
+    Object.const_set(:Rails, rails_mock)
+
+    Object.const_set(:Sprockets, Module.new)
+
+    manager = Railpack::Manager.new
+    pipeline = manager.send(:detect_asset_pipeline)
+
+    assert_equal :sprockets, pipeline
+  ensure
+    Object.send(:remove_const, :Sprockets) if defined?(Sprockets)
+  end
+
+  def test_asset_pipeline_detection_rails_8_no_constants
+    # Mock Rails 8 without Propshaft/Sprockets constants
+    rails_mock = Module.new
+    rails_mock.define_singleton_method(:version) { '8.0.0' }
+    Object.const_set(:Rails, rails_mock)
+
+    manager = Railpack::Manager.new
+    pipeline = manager.send(:detect_asset_pipeline)
+
+    # Should default to Propshaft for modern Rails
+    assert_equal :propshaft, pipeline
+  end
+
+  def test_asset_pipeline_detection_legacy_rails_no_constants
+    # Mock Rails 5 without Propshaft/Sprockets constants
+    rails_mock = Module.new
+    rails_mock.define_singleton_method(:version) { '5.2.0' }
+    Object.const_set(:Rails, rails_mock)
+
+    # Ensure Sprockets is not defined for this test
+    if defined?(Sprockets)
+      Object.send(:remove_const, :Sprockets)
+    end
+
+    manager = Railpack::Manager.new
+    pipeline = manager.send(:detect_asset_pipeline)
+
+    # Should default to Propshaft (could be enhanced to detect Sprockets differently)
+    assert_equal :propshaft, pipeline
+  end
+
+  def test_asset_pipeline_detection_no_rails
+    # Remove Rails constant
+    Object.send(:remove_const, :Rails) if defined?(Rails)
+
+    manager = Railpack::Manager.new
+    pipeline = manager.send(:detect_asset_pipeline)
+
+    # Should default to Propshaft
+    assert_equal :propshaft, pipeline
+  end
+
+  def test_rails_asset_precompile_enhancement
+    # Test that the enhancement method exists and can be called
+    assert_respond_to Railpack::Manager, :enhance_assets_precompile
+    assert_respond_to Railpack::Manager, :enhance
+
+    # Test that it doesn't raise an error when Rake is not available
+    begin
+      Railpack::Manager.enhance_assets_precompile do
+        # Mock task
+      end
+      assert true # If we get here, no exception was raised
+    rescue
+      flunk "enhance_assets_precompile should not raise an error when Rake is not available"
+    end
+  end
+
+  def test_rails_rake_task_integration
+    skip "Skipping Rake integration test due to complex mocking requirements"
+  end
+
+  def test_rails_config_integration
+    # Test that Railpack config works with Rails.root
+    temp_dir = @temp_dir
+    rails_mock = Class.new do
+      define_singleton_method(:root) { Pathname.new(temp_dir) }
+      define_singleton_method(:env) { 'development' }
+    end
+
+    Object.const_set(:Rails, rails_mock)
+
+    # Create a mock railpack.yml
+    config_dir = File.join(@temp_dir, 'config')
+    FileUtils.mkdir_p(config_dir)
+    config_content = {
+      'default' => {
+        'bundler' => 'bun',
+        'target' => 'browser',
+        'format' => 'esm'
+      }
+    }
+    File.write(File.join(config_dir, 'railpack.yml'), config_content.to_yaml)
+
+    # Test config loading
+    config = Railpack::Config.new.for_environment
+    assert_equal 'bun', config['bundler']
+    assert_equal 'browser', config['target']
+    assert_equal 'esm', config['format']
+  end
+
+  def test_rails_logger_integration
+    # Test that Railpack uses Rails logger when available
+    rails_mock = Module.new
+    logger_mock = Minitest::Mock.new
+    logger_mock.expect(:debug, nil, ['Test message'])
+    logger_mock.expect(:info, nil, ['Info message'])
+    logger_mock.expect(:warn, nil, ['Warning message'])
+
+    rails_mock.define_singleton_method(:logger) { logger_mock }
+    Object.const_set(:Rails, rails_mock)
+
+    # Clear cached logger to force re-evaluation
+    Railpack.instance_variable_set(:@logger, nil)
+
+    # Test logger delegation
+    Railpack.logger.debug 'Test message'
+    Railpack.logger.info 'Info message'
+    Railpack.logger.warn 'Warning message'
+
+    logger_mock.verify
+  end
+
+  def test_rails_environment_detection
+    # Test Rails.env integration
+    rails_mock = Module.new
+    rails_mock.define_singleton_method(:env) { 'production' }
+    Object.const_set(:Rails, rails_mock)
+
+    config_instance = Railpack::Config.new
+    config = config_instance.for_environment
+    # Production config should have minify: true
+    assert_equal true, config['minify']
+    assert_equal false, config['sourcemap']
+  end
+
+  def test_rails_root_config_loading
+    # Test that config loads from Rails.root/config/railpack.yml
+    temp_dir = @temp_dir
+    rails_mock = Class.new do
+      define_singleton_method(:root) { Pathname.new(temp_dir) }
+      define_singleton_method(:env) { 'development' }
+    end
+    Object.const_set(:Rails, rails_mock)
+
+    # Create config file
+    config_dir = File.join(@temp_dir, 'config')
+    FileUtils.mkdir_p(config_dir)
+
+    custom_config = {
+      'default' => {
+        'bundler' => 'esbuild',
+        'minify' => true,
+        'sourcemap' => false
+      }
+    }
+
+    File.write(File.join(config_dir, 'railpack.yml'), custom_config.to_yaml)
+
+    # Test that config is loaded
+    config = Railpack::Config.new.for_environment('development')
+    assert_equal 'esbuild', config['bundler']
+    assert_equal true, config['minify']
+    assert_equal false, config['sourcemap']
+  end
+
+  def test_rails_asset_manifest_generation_integration
+    # Test full integration of manifest generation with Rails-like setup
+    rails_mock = Module.new
+    rails_mock.define_singleton_method(:version) { '7.0.0' }
+    rails_mock.define_singleton_method(:root) { Pathname.new(@temp_dir) }
+    Object.const_set(:Rails, rails_mock)
+
+    Object.const_set(:Propshaft, Module.new)
+
+    # Create Rails-like build directory
+    builds_dir = File.join(@temp_dir, 'app/assets/builds')
+    FileUtils.mkdir_p(builds_dir)
+
+    # Create assets like Rails would
+    File.write(File.join(builds_dir, 'application.js'), '// Rails application.js')
+    File.write(File.join(builds_dir, 'application.css'), '/* Rails application.css */')
+
+    config = { 'outdir' => builds_dir }
+    manager = Railpack::Manager.new
+
+    # This should automatically detect Propshaft and generate manifest
+    manager.send(:generate_asset_manifest, config)
+
+    # Should have generated Propshaft manifest
+    manifest_path = File.join(builds_dir, '.manifest.json')
+    assert File.exist?(manifest_path)
+
+    manifest = JSON.parse(File.read(manifest_path))
+    assert manifest.key?('application.js')
+    assert manifest.key?('application.css')
+  ensure
+    Object.send(:remove_const, :Propshaft) if defined?(Propshaft)
+  end
+
+  def test_rails_sprockets_manifest_generation_integration
+    skip "Skipping Sprockets manifest integration test due to Rails mocking issues"
+  end
+end

data/test/sprockets_test.rb

@@ -0,0 +1,313 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require 'tempfile'
+require 'fileutils'
+require 'pathname'
+require 'json'
+require 'railpack'
+
+class SprocketsTest < Minitest::Test
+  def setup
+    @temp_dir = Dir.mktmpdir
+
+    # Clear cached logger to avoid interference between tests
+    Railpack.instance_variable_set(:@logger, nil)
+  end
+
+  def teardown
+    FileUtils.remove_entry(@temp_dir) if @temp_dir && Dir.exist?(@temp_dir)
+  end
+
+  def test_sprockets_manifest_generation_basic
+    outdir = File.join(@temp_dir, 'builds')
+    FileUtils.mkdir_p(outdir)
+
+    # Create fake built assets
+    File.write(File.join(outdir, 'application.js'), 'console.log("app");')
+    File.write(File.join(outdir, 'application.css'), 'body { color: blue; }')
+
+    config = { 'outdir' => outdir }
+    manager = Railpack::Manager.new
+
+    # Force Sprockets detection
+    def manager.detect_asset_pipeline
+      :sprockets
+    end
+
+    manager.send(:generate_asset_manifest, config)
+
+    # Find the generated manifest file
+    manifest_files = Dir.glob("#{outdir}/.sprockets-manifest-*.json")
+    assert_equal 1, manifest_files.size
+
+    manifest_path = manifest_files.first
+    assert File.exist?(manifest_path)
+
+    manifest = JSON.parse(File.read(manifest_path))
+
+    # Check Sprockets manifest structure
+    assert manifest.key?('files')
+    assert manifest.key?('assets')
+
+    # Check assets mapping
+    assert manifest['assets'].key?('application.js')
+    assert manifest['assets'].key?('application.css')
+
+    # Check file entries exist
+    js_digest_key = manifest['assets']['application.js']
+    css_digest_key = manifest['assets']['application.css']
+
+    assert manifest['files'].key?(js_digest_key)
+    assert manifest['files'].key?(css_digest_key)
+  end
+
+  def test_sprockets_manifest_generation_file_structure
+    outdir = File.join(@temp_dir, 'builds')
+    FileUtils.mkdir_p(outdir)
+
+    content = 'console.log("test");'
+    File.write(File.join(outdir, 'application.js'), content)
+
+    config = { 'outdir' => outdir }
+    manager = Railpack::Manager.new
+
+    def manager.detect_asset_pipeline
+      :sprockets
+    end
+
+    manager.send(:generate_asset_manifest, config)
+
+    manifest_files = Dir.glob("#{outdir}/.sprockets-manifest-*.json")
+    manifest = JSON.parse(File.read(manifest_files.first))
+
+    digest_key = manifest['assets']['application.js']
+    file_entry = manifest['files'][digest_key]
+
+    # Check file entry structure
+    assert_equal 'application.js', file_entry['logical_path']
+    assert_equal 'application.js', file_entry['pathname']
+    assert_equal Digest::MD5.hexdigest(content), file_entry['digest']
+    assert_equal File.size(File.join(outdir, 'application.js')), file_entry['size']
+    assert file_entry['mtime'].is_a?(String)
+  end
+
+  def test_sprockets_manifest_generation_digest_filename
+    outdir = File.join(@temp_dir, 'builds')
+    FileUtils.mkdir_p(outdir)
+
+    File.write(File.join(outdir, 'application.js'), 'console.log("app");')
+
+    config = { 'outdir' => outdir }
+    manager = Railpack::Manager.new
+
+    def manager.detect_asset_pipeline
+      :sprockets
+    end
+
+    manager.send(:generate_asset_manifest, config)
+
+    manifest_files = Dir.glob("#{outdir}/.sprockets-manifest-*.json")
+    manifest = JSON.parse(File.read(manifest_files.first))
+
+    digest_key = manifest['assets']['application.js']
+
+    # Digest key should be in format: digest-filename
+    expected_digest = Digest::MD5.hexdigest('console.log("app");')
+    assert digest_key.start_with?(expected_digest)
+    assert digest_key.include?('-application.js')
+  end
+
+  def test_sprockets_manifest_generation_multiple_assets
+    outdir = File.join(@temp_dir, 'builds')
+    FileUtils.mkdir_p(outdir)
+
+    # Create multiple assets
+    assets = {
+      'application.js' => 'console.log("app");',
+      'application.css' => 'body { color: red; }',
+      'vendor.js' => 'console.log("vendor");',
+      'admin.css' => '.admin { display: none; }'
+    }
+
+    assets.each do |filename, content|
+      File.write(File.join(outdir, filename), content)
+    end
+
+    config = { 'outdir' => outdir }
+    manager = Railpack::Manager.new
+
+    def manager.detect_asset_pipeline
+      :sprockets
+    end
+
+    manager.send(:generate_asset_manifest, config)
+
+    manifest_files = Dir.glob("#{outdir}/.sprockets-manifest-*.json")
+    manifest = JSON.parse(File.read(manifest_files.first))
+
+    # Check application assets are in the assets mapping
+    assert manifest['assets'].key?('application.js')
+    assert manifest['assets'].key?('application.css')
+
+    # Check all assets are in the files
+    assets.each do |filename, content|
+      # Find the file entry by checking all files
+      found = false
+      manifest['files'].each do |digest_key, file_entry|
+        if file_entry['logical_path'] == filename
+          found = true
+          assert_equal Digest::MD5.hexdigest(content), file_entry['digest']
+          break
+        end
+      end
+      assert found, "Asset #{filename} not found in manifest files"
+    end
+  end
+
+  def test_sprockets_manifest_generation_empty_directory
+    outdir = File.join(@temp_dir, 'empty_builds')
+    FileUtils.mkdir_p(outdir)
+
+    config = { 'outdir' => outdir }
+    manager = Railpack::Manager.new
+
+    def manager.detect_asset_pipeline
+      :sprockets
+    end
+
+    manager.send(:generate_asset_manifest, config)
+
+    manifest_files = Dir.glob("#{outdir}/.sprockets-manifest-*.json")
+    assert_equal 1, manifest_files.size
+
+    manifest = JSON.parse(File.read(manifest_files.first))
+
+    # Empty directory should have empty manifest
+    assert_empty manifest['files']
+    assert_empty manifest['assets']
+  end
+
+  def test_sprockets_manifest_generation_with_subdirectories
+    outdir = File.join(@temp_dir, 'builds')
+    FileUtils.mkdir_p(outdir)
+
+    # Create assets in subdirectories
+    js_dir = File.join(outdir, 'javascripts')
+    css_dir = File.join(outdir, 'stylesheets')
+    FileUtils.mkdir_p([js_dir, css_dir])
+
+    File.write(File.join(js_dir, 'application.js'), 'console.log("app");')
+    File.write(File.join(css_dir, 'application.css'), 'body { color: blue; }')
+
+    config = { 'outdir' => outdir }
+    manager = Railpack::Manager.new
+
+    def manager.detect_asset_pipeline
+      :sprockets
+    end
+
+    manager.send(:generate_asset_manifest, config)
+
+    manifest_files = Dir.glob("#{outdir}/.sprockets-manifest-*.json")
+    manifest = JSON.parse(File.read(manifest_files.first))
+
+    # Should find assets in subdirectories
+    assert manifest['assets'].key?('application.js')
+    assert manifest['assets'].key?('application.css')
+
+    # Check paths include subdirectories
+    js_digest_key = manifest['assets']['application.js']
+    css_digest_key = manifest['assets']['application.css']
+
+    assert manifest['files'][js_digest_key]['pathname'].include?('javascripts/application.js')
+    assert manifest['files'][css_digest_key]['pathname'].include?('stylesheets/application.css')
+  end
+
+  def test_sprockets_manifest_filename_uniqueness
+    outdir1 = File.join(@temp_dir, 'builds1')
+    outdir2 = File.join(@temp_dir, 'builds2')
+    FileUtils.mkdir_p([outdir1, outdir2])
+
+    # Create same assets in different directories
+    File.write(File.join(outdir1, 'application.js'), 'console.log("app");')
+    File.write(File.join(outdir2, 'application.js'), 'console.log("app");')
+
+    # Generate manifests
+    [outdir1, outdir2].each do |outdir|
+      config = { 'outdir' => outdir }
+      manager = Railpack::Manager.new
+
+      def manager.detect_asset_pipeline
+        :sprockets
+      end
+
+      manager.send(:generate_asset_manifest, config)
+    end
+
+    # Manifest filenames should be different (based on directory path digest)
+    manifest_files1 = Dir.glob("#{outdir1}/.sprockets-manifest-*.json")
+    manifest_files2 = Dir.glob("#{outdir2}/.sprockets-manifest-*.json")
+
+    assert_equal 1, manifest_files1.size
+    assert_equal 1, manifest_files2.size
+
+    # Filenames should be different
+    refute_equal File.basename(manifest_files1.first), File.basename(manifest_files2.first)
+  end
+
+  def test_sprockets_manifest_excludes_source_maps
+    outdir = File.join(@temp_dir, 'builds')
+    FileUtils.mkdir_p(outdir)
+
+    # Create JS with source map
+    File.write(File.join(outdir, 'application.js'), 'console.log("app");')
+    File.write(File.join(outdir, 'application.js.map'), '{"version":3,"sources":[]}')
+
+    config = { 'outdir' => outdir }
+    manager = Railpack::Manager.new
+
+    def manager.detect_asset_pipeline
+      :sprockets
+    end
+
+    manager.send(:generate_asset_manifest, config)
+
+    manifest_files = Dir.glob("#{outdir}/.sprockets-manifest-*.json")
+    manifest = JSON.parse(File.read(manifest_files.first))
+
+    # Source maps should not be included in assets
+    assert manifest['assets'].key?('application.js')
+    refute manifest['assets'].key?('application.js.map')
+  end
+
+  def test_sprockets_manifest_mtime_format
+    outdir = File.join(@temp_dir, 'builds')
+    FileUtils.mkdir_p(outdir)
+
+    file_path = File.join(outdir, 'application.js')
+    File.write(file_path, 'console.log("app");')
+
+    config = { 'outdir' => outdir }
+    manager = Railpack::Manager.new
+
+    def manager.detect_asset_pipeline
+      :sprockets
+    end
+
+    manager.send(:generate_asset_manifest, config)
+
+    manifest_files = Dir.glob("#{outdir}/.sprockets-manifest-*.json")
+    manifest = JSON.parse(File.read(manifest_files.first))
+
+    digest_key = manifest['assets']['application.js']
+    mtime_str = manifest['files'][digest_key]['mtime']
+
+    # Should be ISO8601 format
+    assert_match(/\A\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/, mtime_str)
+
+    # Should match actual file mtime
+    expected_mtime = File.mtime(file_path).iso8601
+    assert_equal expected_mtime, mtime_str
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: railpack
 version: !ruby/object:Gem::Version
-  version: 1.2.9
+  version: 1.2.11
 platform: ruby
 authors:
 - 21tycoons LLC
@@ -51,7 +51,10 @@ files:
 - test/bundler_test.rb
 - test/config_test.rb
 - test/manager_test.rb
+- test/propshaft_test.rb
 - test/railpack_test.rb
+- test/rails_integration_test.rb
+- test/sprockets_test.rb
 homepage: https://github.com/21tycoons/railpack
 licenses:
 - MIT