propshaft 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 963ec537db8637fe43844f1b46e290c600c04b5f8b170c79583d4370dbcefbbf
-  data.tar.gz: c6f48c154b847a715317ba44d041287f82f009ee760b9b9d8e7a319c7f354ff2
+  metadata.gz: 8ea8c536e8ee4cd0229dd706a6689d8e52d13a63533fb1f2d5e19835f3a853f2
+  data.tar.gz: fdd5faee6f39306a3bd12f0d3b008b31554b2576637f14497640dd886d38d865
 SHA512:
-  metadata.gz: 5e08613dd985ef975477b9a1886ffa5def8aef4889c6d4cbfd585d716c711e5806265d52370c819642ebcade755062c08358809823bbb4bc4ecece4892dbe3b5
-  data.tar.gz: 16f7245a2a4c9aa69f066a566e9781a1cb1327141b6daf865fd6917f3b1d5eaec560f5ee1cf8600c484e43f60d3acea55fca4b8262dd8ec88ef714839a57ee61
+  metadata.gz: 684f7db0156395a7376f7f1788576a7f5bbfaef1ccbe44af0fb2bf2ce315c6acdc45e2f5e368df3d580e6e54c741a80d50bd7cb0db6976909662b40a65184f0c
+  data.tar.gz: ad626da00dd0f678abe3d5ea4ce26975c38e02906fdc14de6aa244cdb0902382dd25caf495e9d32e0da3d89ad9b260dce2bdf992a1f925a65fdaeea0494bf355

data/README.md

@@ -16,7 +16,7 @@ With Rails 8, Propshaft is the default asset pipeline for new applications. With
 
 ## Usage
 
-Propshaft makes all the assets from all the paths it's been configured with through `config.assets.paths` available for serving and will copy all of them into `public/assets` when precompiling. This is unlike Sprockets, which did not copy over assets that hadn't been explicitly included in one of the bundled assets. 
+Propshaft makes all the assets from all the paths it's been configured with through `config.assets.paths` available for serving and will copy all of them into `public/assets` when precompiling. This is unlike Sprockets, which did not copy over assets that hadn't been explicitly included in one of the bundled assets.
 
 You can however exempt directories that have been added through the `config.assets.excluded_paths`. This is useful if you're for example using `app/assets/stylesheets` exclusively as a set of inputs to a compiler like Dart Sass for Rails, and you don't want these input files to be part of the load path. (Remember you need to add full paths, like `Rails.root.join("app/assets/stylesheets")`).
 
@@ -50,9 +50,55 @@ export default class extends Controller {
 
 If you need to put multiple files that refer to each other through Propshaft, like a JavaScript file and its source map, you have to digest these files in advance to retain stable file names. Propshaft looks for the specific pattern of `-[digest].digested.js` as the postfix to any asset file as an indication that the file has already been digested.
 
+## Subresource Integrity (SRI)
+
+Propshaft supports Subresource Integrity (SRI) to help protect against malicious modifications of assets. SRI allows browsers to verify that resources fetched from CDNs or other sources haven't been tampered with by checking cryptographic hashes.
+
+### Enabling SRI
+
+To enable SRI support, configure the hash algorithm in your Rails application:
+
+```ruby
+config.assets.integrity_hash_algorithm = "sha384"
+```
+
+Valid hash algorithms include:
+- `"sha256"` - SHA-256 (most common)
+- `"sha384"` - SHA-384 (recommended for enhanced security)
+- `"sha512"` - SHA-512 (strongest)
+
+### Using SRI in your views
+
+Once configured, you can enable SRI by passing the `integrity: true` option to asset helpers:
+
+```erb
+<%= stylesheet_link_tag "application", integrity: true %>
+<%= javascript_include_tag "application", integrity: true %>
+```
+
+This generates HTML with integrity hashes:
+
+```html
+<link rel="stylesheet" href="/assets/application-abc123.css"
+      integrity="sha384-xyz789...">
+<script src="/assets/application-def456.js"
+        integrity="sha384-uvw012..."></script>
+```
+
+**Important**: SRI only works in secure contexts (HTTPS) or during local development. The integrity hashes are automatically omitted when serving over HTTP in production for security reasons.
+
+### Bulk stylesheet inclusion with SRI
+
+Propshaft extends `stylesheet_link_tag` with special symbols for bulk inclusion:
+
+```erb
+<%= stylesheet_link_tag :all, integrity: true %>  <!-- All stylesheets -->
+<%= stylesheet_link_tag :app, integrity: true %>  <!-- Only app/assets stylesheets -->
+```
+
 ## Improving performance in development
 
-Before every request Propshaft checks if any asset was updated to decide if a cache sweep is needed. This verification is done using the application's configured file watcher which, by default, is `ActiveSupport::FileUpdateChecker`. 
+Before every request Propshaft checks if any asset was updated to decide if a cache sweep is needed. This verification is done using the application's configured file watcher which, by default, is `ActiveSupport::FileUpdateChecker`.
 
 If you have a lot of assets in your project, you can improve performance by adding the `listen` gem to the development group in your Gemfile, and this line to the `development.rb` environment file:
 

data/lib/propshaft/assembly.rb

@@ -1,3 +1,4 @@
+require "propshaft/manifest"
 require "propshaft/load_path"
 require "propshaft/resolver/dynamic"
 require "propshaft/resolver/static"
@@ -16,7 +17,13 @@ class Propshaft::Assembly
   end
 
   def load_path
-    @load_path ||= Propshaft::LoadPath.new(config.paths, compilers: compilers, version: config.version)
+    @load_path ||= Propshaft::LoadPath.new(
+      config.paths,
+      compilers: compilers,
+      version: config.version,
+      file_watcher: config.file_watcher,
+      integrity_hash_algorithm: config.integrity_hash_algorithm
+    )
   end
 
   def resolver
@@ -47,7 +54,7 @@ class Propshaft::Assembly
 
   def reveal(path_type = :logical_path)
     path_type = path_type.presence_in(%i[ logical_path path ]) || raise(ArgumentError, "Unknown path_type: #{path_type}")
-    
+
     load_path.assets.collect do |asset|
       asset.send(path_type)
     end

data/lib/propshaft/asset.rb

@@ -1,4 +1,5 @@
 require "digest/sha1"
+require "digest/sha2"
 require "action_dispatch/http/mime_type"
 
 class Propshaft::Asset
@@ -17,8 +18,12 @@ class Propshaft::Asset
     @path, @logical_path, @load_path = path, Pathname.new(logical_path), load_path
   end
 
+  def compiled_content
+    @compiled_content ||= load_path.compilers.compile(self)
+  end
+
   def content(encoding: "ASCII-8BIT")
-    File.read(path, encoding: encoding)
+    File.read(path, encoding: encoding, mode: "rb")
   end
 
   def content_type
@@ -33,6 +38,24 @@ class Propshaft::Asset
     @digest ||= Digest::SHA1.hexdigest("#{content_with_compile_references}#{load_path.version}").first(8)
   end
 
+  def integrity(hash_algorithm:)
+    # Following the Subresource Integrity spec draft
+    # https://w3c.github.io/webappsec-subresource-integrity/
+    # allowing only sha256, sha384, and sha512
+    bitlen = case hash_algorithm
+      when "sha256"
+        256
+      when "sha384"
+        384
+      when "sha512"
+        512
+      else
+        raise(StandardError.new("Subresource Integrity hash algorithm must be one of SHA2 family (sha256, sha384, sha512)"))
+      end
+
+    [hash_algorithm, Digest::SHA2.new(bitlen).base64digest(compiled_content)].join("-")
+  end
+
   def digested_path
     if already_digested?
       logical_path

data/lib/propshaft/compiler/css_asset_urls.rb

@@ -3,7 +3,7 @@
 require "propshaft/compiler"
 
 class Propshaft::Compiler::CssAssetUrls < Propshaft::Compiler
-  ASSET_URL_PATTERN = /url\(\s*["']?(?!(?:\#|%23|data|http|\/\/))([^"'\s?#)]+)([#?][^"')]+)?\s*["']?\)/
+  ASSET_URL_PATTERN = /url\(\s*["']?(?!(?:\#|%23|data:|http:|https:|\/\/))([^"'\s?#)]+)([#?][^"')]+)?\s*["']?\)/
 
   def compile(asset, input)
     input.gsub(ASSET_URL_PATTERN) { asset_url resolve_path(asset.logical_path.dirname, $1), asset.logical_path, $2, $1 }

data/lib/propshaft/helper.rb

@@ -1,20 +1,102 @@
 module Propshaft
+  # Helper module that provides asset path resolution and integrity support for Rails applications.
+  #
+  # This module extends Rails' built-in asset helpers with additional functionality:
+  # - Subresource Integrity (SRI) support for enhanced security
+  # - Bulk stylesheet inclusion with :all and :app options
+  # - Asset path resolution with proper error handling
+  #
+  # == Subresource Integrity (SRI) Support
+  #
+  # SRI helps protect against malicious modifications of assets by ensuring that
+  # resources fetched from CDNs or other sources haven't been tampered with.
+  #
+  # SRI is automatically enabled in secure contexts (HTTPS or local development)
+  # when the 'integrity' option is set to true:
+  #
+  #   <%= stylesheet_link_tag "application", integrity: true %>
+  #   <%= javascript_include_tag "application", integrity: true %>
+  #
+  # This will generate integrity hashes and include them in the HTML:
+  #
+  #   <link rel="stylesheet" href="/assets/application-abc123.css"
+  #         integrity="sha256-xyz789...">
+  #   <script src="/assets/application-def456.js"
+  #           integrity="sha256-uvw012..."></script>
+  #
+  # == Bulk Stylesheet Inclusion
+  #
+  # The stylesheet_link_tag helper supports special symbols for bulk inclusion:
+  # - :all - includes all CSS files found in the load path
+  # - :app - includes only CSS files from app/assets/**/*.css
+  #
+  #   <%= stylesheet_link_tag :all %>  # All stylesheets
+  #   <%= stylesheet_link_tag :app %>  # Only app stylesheets
   module Helper
+    # Computes the Subresource Integrity (SRI) hash for the given asset path.
+    #
+    # This method generates a cryptographic hash of the asset content that can be used
+    # to verify the integrity of the resource when it's loaded by the browser.
+    #
+    #   asset_integrity("application.css")
+    #   # => "sha256-xyz789abcdef..."
+    def asset_integrity(path, options = {})
+      path = _path_with_extname(path, options)
+      Rails.application.assets.resolver.integrity(path)
+    end
+
+    # Resolves the full path for an asset, raising an error if not found.
     def compute_asset_path(path, options = {})
       Rails.application.assets.resolver.resolve(path) || raise(MissingAssetError.new(path))
     end
 
-    # Add an option to call `stylesheet_link_tag` with `:all` to include every css file found on the load path
-    # or `:app` to include css files found in `Rails.root("app/assets/**/*.css")`, which will exclude lib/ and plugins.
+    # Enhanced +stylesheet_link_tag+ with integrity support and bulk inclusion options.
+    #
+    # In addition to the standard Rails functionality, this method supports:
+    # * Automatic SRI (Subresource Integrity) hash generation in secure contexts
+    # * Add an option to call +stylesheet_link_tag+ with +:all+ to include every css
+    #   file found on the load path or +:app+ to include css files found in
+    #   <tt>Rails.root("app/assets/**/*.css")</tt>, which will exclude lib/ and plugins.
+    #
+    # ==== Options
+    #
+    # * <tt>:integrity</tt> - Enable SRI hash generation
+    #
+    # ==== Examples
+    #
+    #   stylesheet_link_tag "application", integrity: true
+    #   # => <link rel="stylesheet" href="/assets/application-abc123.css"
+    #   #          integrity="sha256-xyz789...">
+    #
+    #   stylesheet_link_tag :all    # All stylesheets in load path
+    #   stylesheet_link_tag :app    # Only app/assets stylesheets
     def stylesheet_link_tag(*sources, **options)
       case sources.first
       when :all
-        super(*all_stylesheets_paths , **options)
+        sources = all_stylesheets_paths
       when :app
-        super(*app_stylesheets_paths , **options)
-      else
-        super
+        sources = app_stylesheets_paths
       end
+
+      _build_asset_tags(sources, options, :stylesheet) { |source, opts| super(source, opts) }
+    end
+
+    # Enhanced +javascript_include_tag+ with automatic SRI (Subresource Integrity) support.
+    #
+    # This method extends Rails' built-in +javascript_include_tag+ to automatically
+    # generate and include integrity hashes when running in secure contexts.
+    #
+    # ==== Options
+    #
+    # * <tt>:integrity</tt> - Enable SRI hash generation
+    #
+    # ==== Examples
+    #
+    #   javascript_include_tag "application", integrity: true
+    #   # => <script src="/assets/application-abc123.js"
+    #   #           integrity="sha256-xyz789..."></script>
+    def javascript_include_tag(*sources, **options)
+      _build_asset_tags(sources, options, :javascript) { |source, opts| super(source, opts) }
     end
 
     # Returns a sorted and unique array of logical paths for all stylesheets in the load path.
@@ -26,5 +108,50 @@ module Propshaft
     def app_stylesheets_paths
       Rails.application.assets.load_path.asset_paths_by_glob("#{Rails.root.join("app/assets")}/**/*.css")
     end
+
+    private
+      # Core method that builds asset tags with optional integrity support.
+      #
+      # This method handles the common logic for both +stylesheet_link_tag+ and
+      # +javascript_include_tag+, including SRI hash generation and HTML tag creation.
+      def _build_asset_tags(sources, options, asset_type)
+        options = options.stringify_keys
+        integrity = _compute_integrity?(options)
+
+        sources.map { |source|
+          opts = integrity ? options.merge!('integrity' => asset_integrity(source, type: asset_type)) : options
+          yield(source, opts)
+        }.join("\n").html_safe
+      end
+
+      # Determines whether integrity hashes should be computed for assets.
+      #
+      # Integrity is only computed in secure contexts (HTTPS or local development)
+      # and when explicitly requested via the +integrity+ option.
+      def _compute_integrity?(options)
+        if _secure_subresource_integrity_context?
+          case options['integrity']
+          when nil, false, true
+            options.delete('integrity') == true
+          end
+        else
+          options.delete 'integrity'
+          false
+        end
+      end
+
+      # Checks if the current context is secure enough for Subresource Integrity.
+      #
+      # SRI is only beneficial in secure contexts. Returns true when:
+      # * The request is made over HTTPS (SSL), OR
+      # * The request is local (development environment)
+      def _secure_subresource_integrity_context?
+        respond_to?(:request) && self.request && (self.request.local? || self.request.ssl?)
+      end
+
+      # Ensures the asset path includes the appropriate file extension.
+      def _path_with_extname(path, options)
+        "#{path}#{compute_asset_extname(path, options)}"
+      end
   end
 end

data/lib/propshaft/load_path.rb

@@ -1,10 +1,22 @@
+require "propshaft/manifest"
 require "propshaft/asset"
 
 class Propshaft::LoadPath
-  attr_reader :paths, :compilers, :version
+  class NullFileWatcher # :nodoc:
+    def initialize(paths, files_to_watch, &block)
+      @block = block
+    end
+
+    def execute_if_updated
+      @block.call
+    end
+  end
+
+  attr_reader :paths, :compilers, :version, :integrity_hash_algorithm
 
-  def initialize(paths = [], compilers:, version: nil)
-    @paths, @compilers, @version = dedup(paths), compilers, version
+  def initialize(paths = [], compilers:, version: nil, file_watcher: nil, integrity_hash_algorithm: nil)
+    @paths, @compilers, @version, @integrity_hash_algorithm = dedup(paths), compilers, version, integrity_hash_algorithm
+    @file_watcher = file_watcher || NullFileWatcher
   end
 
   def find(asset_name)
@@ -30,10 +42,8 @@ class Propshaft::LoadPath
   end
 
   def manifest
-    Hash.new.tap do |manifest|
-      assets.each do |asset|
-        manifest[asset.logical_path.to_s] = asset.digested_path.to_s
-      end
+    Propshaft::Manifest.new(integrity_hash_algorithm: integrity_hash_algorithm).tap do |manifest|
+      assets.each { |asset| manifest.push_asset(asset) }
     end
   end
 
@@ -46,7 +56,7 @@ class Propshaft::LoadPath
       files_to_watch = Array(paths).collect { |dir| [ dir.to_s, exts_to_watch ] }.to_h
       mutex = Mutex.new
 
-      Rails.application.config.file_watcher.new([], files_to_watch) do
+      @file_watcher.new([], files_to_watch) do
         mutex.synchronize do
           clear_cache
           seed_cache

data/lib/propshaft/manifest.rb

@@ -0,0 +1,170 @@
+module Propshaft
+  # Manages the manifest file that maps logical asset paths to their digested counterparts.
+  #
+  # The manifest is used to track assets that have been processed and digested, storing
+  # their logical paths, digested paths, and optional integrity hashes.
+  class Manifest
+    # Represents a single entry in the asset manifest.
+    #
+    # Each entry contains information about an asset including its logical path
+    # (the original path), digested path (the path with content hash), and
+    # optional integrity hash for security verification.
+    class ManifestEntry
+      attr_reader :logical_path, :digested_path, :integrity
+
+      # Creates a new manifest entry.
+      #
+      # ==== Parameters
+      #
+      # * +logical_path+ - The logical path of the asset
+      # * +digested_path+ - The digested path of the asset
+      # * +integrity+ - The integrity hash of the asset (optional)
+      def initialize(logical_path:, digested_path:, integrity:) # :nodoc:
+        @logical_path = logical_path
+        @digested_path = digested_path
+        @integrity = integrity
+      end
+
+      # Converts the manifest entry to a hash representation.
+      #
+      # Returns a hash containing the +digested_path+ and +integrity+ keys.
+      def to_h
+        { digested_path: digested_path, integrity: integrity}
+      end
+    end
+
+    class << self
+      # Creates a new Manifest instance from a manifest file.
+      #
+      # Reads and parses a manifest file, supporting both the current format
+      # (with +digested_path+ and +integrity+ keys) and the legacy format
+      # (simple string values for backwards compatibility).
+      #
+      # ==== Parameters
+      #
+      # * +manifest_path+ - The path to the manifest file
+      #
+      # ==== Returns
+      #
+      # A new manifest instance populated with entries from the file.
+      def from_path(manifest_path)
+        manifest = Manifest.new
+
+        serialized_manifest = JSON.parse(manifest_path.read, symbolize_names: false)
+
+        serialized_manifest.each_pair do |key, value|
+          # Compatibility mode to be able to
+          # read the old "simple manifest" format
+          digested_path, integrity = if value.is_a?(String)
+            [value, nil]
+          else
+            [value["digested_path"], value["integrity"]]
+          end
+
+          entry = ManifestEntry.new(
+            logical_path: key, digested_path: digested_path, integrity: integrity
+          )
+
+          manifest.push(entry)
+        end
+
+        manifest
+      end
+    end
+
+    # Creates a new Manifest instance.
+    #
+    # ==== Parameters
+    #
+    # * +integrity_hash_algorithm+ - The algorithm to use for generating
+    #   integrity hashes (e.g., 'sha256', 'sha384', 'sha512'). If +nil+, integrity hashes
+    #   will not be generated.
+    def initialize(integrity_hash_algorithm: nil)
+      @integrity_hash_algorithm = integrity_hash_algorithm
+      @entries = {}
+    end
+
+    # Adds an asset to the manifest.
+    #
+    # Creates a manifest entry from the given asset and adds it to the manifest.
+    # The entry will include the asset's logical path, digested path, and optionally
+    # an integrity hash if an integrity hash algorithm is configured.
+    #
+    # ==== Parameters
+    #
+    # * +asset+ - The asset to add to the manifest
+    #
+    # ==== Returns
+    #
+    # The manifest entry that was added.
+    def push_asset(asset)
+      entry = ManifestEntry.new(
+        logical_path: asset.logical_path.to_s,
+        digested_path: asset.digested_path.to_s,
+        integrity: integrity_hash_algorithm && asset.integrity(hash_algorithm: integrity_hash_algorithm)
+      )
+
+      push(entry)
+    end
+
+    # Adds a manifest entry to the manifest.
+    #
+    # ==== Parameters
+    #
+    # * +entry+ - The manifest entry to add
+    #
+    # ==== Returns
+    #
+    # The entry that was added.
+    def push(entry)
+      @entries[entry.logical_path] = entry
+    end
+    alias_method :<<, :push
+
+    # Retrieves a manifest entry by its logical path.
+    #
+    # ==== Parameters
+    #
+    # * +logical_path+ - The logical path of the asset to retrieve
+    #
+    # ==== Returns
+    #
+    # The manifest entry, or +nil+ if not found.
+    def [](logical_path)
+      @entries[logical_path]
+    end
+
+    # Converts the manifest to JSON format.
+    #
+    # The JSON representation maps logical paths to hash representations of
+    # manifest entries, containing +digested_path+ and +integrity+ information.
+    #
+    # ==== Returns
+    #
+    # The JSON representation of the manifest.
+    def to_json
+      @entries.transform_values do |manifest_entry|
+        manifest_entry.to_h
+      end.to_json
+    end
+
+    # Transforms the values of all manifest entries using the given block.
+    #
+    # This method is useful for applying transformations to all manifest entries
+    # while preserving the logical path keys.
+    #
+    # ==== Parameters
+    #
+    # * +block+ - A block that will receive each manifest entry
+    #
+    # ==== Returns
+    #
+    # A new hash with the same keys but transformed values.
+    def transform_values(&block)
+      @entries.transform_values(&block)
+    end
+
+    private
+      attr_reader :integrity_hash_algorithm
+  end
+end

data/lib/propshaft/processor.rb

@@ -54,10 +54,10 @@ class Propshaft::Processor
     def compile_asset(asset)
       File.open(output_path.join(asset.digested_path), "w+") do |file|
         begin
-          file.write compilers.compile(asset)
+          file.write asset.compiled_content
         rescue Encoding::UndefinedConversionError
           # FIXME: Not sure if there's a better way here?
-          file.write compilers.compile(asset).force_encoding("UTF-8")
+          file.write asset.compiled_content.force_encoding("UTF-8")
         end
       end if compilers.compilable?(asset)
     end

data/lib/propshaft/railtie.rb

@@ -35,6 +35,8 @@ module Propshaft
       # Prioritize assets from within the application over assets of the same path from engines/gems.
       config.assets.paths.sort_by!.with_index { |path, i| [path.to_s.start_with?(Rails.root.to_s) ? 0 : 1, i] }
 
+      config.assets.file_watcher ||= app.config.file_watcher
+
       config.assets.relative_url_root ||= app.config.relative_url_root
       config.assets.output_path ||=
         Pathname.new(File.join(app.config.paths["public"].first, app.config.assets.prefix))

data/lib/propshaft/resolver/dynamic.rb

@@ -7,15 +7,28 @@ module Propshaft::Resolver
     end
 
     def resolve(logical_path)
-      if asset = load_path.find(logical_path)
+      if asset = find_asset(logical_path)
         File.join prefix, asset.digested_path
       end
     end
 
+    def integrity(logical_path)
+      hash_algorithm = load_path.integrity_hash_algorithm
+
+      if hash_algorithm && (asset = find_asset(logical_path))
+        asset.integrity(hash_algorithm: hash_algorithm)
+      end
+    end
+
     def read(logical_path, options = {})
       if asset = load_path.find(logical_path)
         asset.content(**options)
       end
     end
+
+    private
+      def find_asset(logical_path)
+        load_path.find(logical_path)
+      end
   end
 end

data/lib/propshaft/resolver/static.rb

@@ -7,20 +7,32 @@ module Propshaft::Resolver
     end
 
     def resolve(logical_path)
-      if asset_path = parsed_manifest[logical_path]
+      if asset_path = digested_path(logical_path)
         File.join prefix, asset_path
       end
     end
 
+    def integrity(logical_path)
+      entry = manifest[logical_path]
+
+      entry&.integrity
+    end
+
     def read(logical_path, encoding: "ASCII-8BIT")
-      if asset_path = parsed_manifest[logical_path]
+      if asset_path = digested_path(logical_path)
         File.read(manifest_path.dirname.join(asset_path), encoding: encoding)
       end
     end
 
     private
-      def parsed_manifest
-        @parsed_manifest ||= JSON.parse(manifest_path.read, symbolize_names: false)
+      def manifest
+        @manifest ||= Propshaft::Manifest.from_path(manifest_path)
+      end
+
+      def digested_path(logical_path)
+        entry = manifest[logical_path]
+
+        entry&.digested_path
       end
   end
 end

data/lib/propshaft/server.rb

@@ -7,10 +7,11 @@ class Propshaft::Server
   end
 
   def call(env)
+    execute_cache_sweeper_if_updated
     path, digest = extract_path_and_digest(env)
 
     if (asset = @assembly.load_path.find(path)) && asset.fresh?(digest)
-      compiled_content = @assembly.compilers.compile(asset)
+      compiled_content = asset.compiled_content
 
       [
         200,
@@ -18,7 +19,7 @@ class Propshaft::Server
           Rack::CONTENT_LENGTH  => compiled_content.length.to_s,
           Rack::CONTENT_TYPE    => asset.content_type.to_s,
           VARY                  => "Accept-Encoding",
-          Rack::ETAG            => asset.digest,
+          Rack::ETAG            => "\"#{asset.digest}\"",
           Rack::CACHE_CONTROL   => "public, max-age=31536000, immutable"
         },
         [ compiled_content ]
@@ -44,4 +45,8 @@ class Propshaft::Server
     else
       VARY = "vary"
     end
+
+    def execute_cache_sweeper_if_updated
+      @assembly.load_path.cache_sweeper.execute_if_updated
+    end
 end

data/lib/propshaft/version.rb

@@ -1,3 +1,3 @@
 module Propshaft
-  VERSION = "1.1.0"
+  VERSION = "1.2.0"
 end

data/lib/propshaft.rb

@@ -10,4 +10,4 @@ end
 require "propshaft/assembly"
 require "propshaft/errors"
 require "propshaft/helper"
-require "propshaft/railtie"
+require "propshaft/railtie" if defined?(Rails::Railtie)

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: propshaft
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - David Heinemeier Hansson
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-09-30 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack
@@ -38,20 +37,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 7.0.0
-- !ruby/object:Gem::Dependency
-  name: railties
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 7.0.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 7.0.0
 - !ruby/object:Gem::Dependency
   name: rack
   requirement: !ruby/object:Gem::Requirement
@@ -66,7 +51,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description:
 email: dhh@hey.com
 executables: []
 extensions: []
@@ -86,6 +70,7 @@ files:
 - lib/propshaft/errors.rb
 - lib/propshaft/helper.rb
 - lib/propshaft/load_path.rb
+- lib/propshaft/manifest.rb
 - lib/propshaft/output_path.rb
 - lib/propshaft/processor.rb
 - lib/propshaft/quiet_assets.rb
@@ -100,7 +85,6 @@ licenses:
 - MIT
 metadata:
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -115,8 +99,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.16
-signing_key:
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Deliver assets for Rails.
 test_files: []