propshaft 0.7.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a149fdc0fb45487422a71e21df47105ee0071e23f752f596f54cd98400bc99e2
-  data.tar.gz: 9dcd99aa258a91aa99ac46f1da9379712d836f06c42cd8ce9e6df8b020cc94c6
+  metadata.gz: 0cec588585c21b06e765dbf70ac6f0d3a4b9ad2826c8a11120553a8db0931559
+  data.tar.gz: dde9f2d2a7095731ea93585e237421b73adc4acc71218ef574e566468796d1eb
 SHA512:
-  metadata.gz: 79779f26c1d121049451c5a8d7545e9fbfbcdd2b01a966f89fa0a23aa2b140ea2932828bd4c1b9edbab8be106366f8f92f9daa91bfa1c7af2207619a6fcce9fe
-  data.tar.gz: 7f609b53f85ef6bdeb53972c11d9a54301cd974c7d5573d5d93fbeb043daed863e08407bb95b45d7c8a55a122770dcb5f9f8b2d55f6830c2adbb5465281613ad
+  metadata.gz: c372a207074f656261b8be407d224780678fd68e6caf645323c898ca06cb04f4cc0e1b2ab2ac2d59179162bb3a6c1e137297635aef8c49d1a0e4b3d279e609c6
+  data.tar.gz: 80c3963e4963ae52b19793b8de066a173b1227a5b6ea1d1ff4420f88b1939a09f2a476fd55e52a4a18fe688c53bc0862756700723557a108d052441ade893259

data/README.md

@@ -49,7 +49,7 @@ But for greenfield apps using the default import-map approach, Propshaft can als
 
 ## Will Propshaft replace Sprockets as the Rails default?
 
-Most likely, but Sprockets need to be supported as well for a long time to come. Plenty of apps and gems were built on Sprocket features, and they won't be migrating soon. Still working out the compatibility story. This is very much alpha software at the moment.
+Most likely, but Sprockets needs to be supported as well for a long time to come. Plenty of apps and gems were built on Sprocket features, and they won't be migrating soon. Still working out the compatibility story. This is very much beta software at the moment.
 
 
 ## License

data/lib/propshaft/assembly.rb

@@ -4,8 +4,8 @@ require "propshaft/resolver/static"
 require "propshaft/server"
 require "propshaft/processor"
 require "propshaft/compilers"
-require "propshaft/compilers/css_asset_urls"
-require "propshaft/compilers/source_mapping_urls"
+require "propshaft/compiler/css_asset_urls"
+require "propshaft/compiler/source_mapping_urls"
 
 class Propshaft::Assembly
   attr_reader :config
@@ -15,7 +15,7 @@ class Propshaft::Assembly
   end
 
   def load_path
-    @load_path ||= Propshaft::LoadPath.new(config.paths, version: config.version)
+    @load_path ||= Propshaft::LoadPath.new(config.paths, compilers: compilers, version: config.version)
   end
 
   def resolver

data/lib/propshaft/asset.rb

@@ -2,15 +2,10 @@ require "digest/sha1"
 require "action_dispatch/http/mime_type"
 
 class Propshaft::Asset
-  PREDIGESTED_REGEX = /-([0-9a-zA-Z]{7,128}\.digested)/
+  attr_reader :path, :logical_path, :load_path
 
-  attr_reader :path, :logical_path, :version
-
-  def initialize(path, logical_path:, version: nil)
-    @path         = path
-    @digest       = logical_path.to_s[PREDIGESTED_REGEX, 1]
-    @logical_path = Pathname.new(@digest ? logical_path.sub("-#{@digest}", "") : logical_path)
-    @version      = version
+  def initialize(path, logical_path:, load_path:)
+    @path, @logical_path, @load_path = path, Pathname.new(logical_path), load_path
   end
 
   def content
@@ -26,18 +21,31 @@ class Propshaft::Asset
   end
 
   def digest
-    @digest ||= Digest::SHA1.hexdigest("#{content}#{version}")
+    @digest ||= Digest::SHA1.hexdigest("#{content_with_compile_references}#{load_path.version}").first(8)
   end
 
   def digested_path
-    logical_path.sub(/\.(\w+)$/) { |ext| "-#{digest}#{ext}" }
+    if already_digested?
+      logical_path
+    else
+      logical_path.sub(/\.(\w+(\.map)?)$/) { |ext| "-#{digest}#{ext}" }
+    end
   end
 
   def fresh?(digest)
-    self.digest == digest
+    self.digest == digest || already_digested?
   end
 
   def ==(other_asset)
     logical_path.hash == other_asset.logical_path.hash
   end
+
+  private
+    def content_with_compile_references
+      content + load_path.find_referenced_by(self).collect(&:content).join
+    end
+
+    def already_digested?
+      logical_path.to_s =~ /-([0-9a-zA-Z_-]{7,128})\.digested/
+    end
 end

data/lib/propshaft/{compilers → compiler}/css_asset_urls.rb

@@ -1,17 +1,25 @@
 # frozen_string_literal: true
 
-class Propshaft::Compilers::CssAssetUrls
-  attr_reader :assembly, :url_prefix
+require "propshaft/compiler"
 
+class Propshaft::Compiler::CssAssetUrls < Propshaft::Compiler
   ASSET_URL_PATTERN = /url\(\s*["']?(?!(?:\#|%23|data|http|\/\/))([^"'\s?#)]+)([#?][^"')]+)?\s*["']?\)/
 
-  def initialize(assembly)
-    @assembly   = assembly
-    @url_prefix = File.join(assembly.config.host.to_s, assembly.config.prefix.to_s).chomp("/")
+  def compile(asset, input)
+    input.gsub(ASSET_URL_PATTERN) { asset_url resolve_path(asset.logical_path.dirname, $1), asset.logical_path, $2, $1 }
   end
 
-  def compile(logical_path, input)
-    input.gsub(ASSET_URL_PATTERN) { asset_url resolve_path(logical_path.dirname, $1), logical_path, $2, $1 }
+  def referenced_by(asset, references: Set.new)
+    asset.content.scan(ASSET_URL_PATTERN).each do |referenced_asset_url, _|
+      referenced_asset = load_path.find(resolve_path(asset.logical_path.dirname, referenced_asset_url))
+
+      if referenced_asset && references.exclude?(referenced_asset)
+        references << referenced_asset
+        references.merge referenced_by(referenced_asset, references: references)
+      end
+    end
+
+    references
   end
 
   private
@@ -26,7 +34,7 @@ class Propshaft::Compilers::CssAssetUrls
     end
 
     def asset_url(resolved_path, logical_path, fingerprint, pattern)
-      if asset = assembly.load_path.find(resolved_path)
+      if asset = load_path.find(resolved_path)
         %[url("#{url_prefix}/#{asset.digested_path}#{fingerprint}")]
       else
         Propshaft.logger.warn "Unable to resolve '#{pattern}' for missing asset '#{resolved_path}' in #{logical_path}"

data/lib/propshaft/compiler/source_mapping_urls.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "propshaft/compiler"
+
+class Propshaft::Compiler::SourceMappingUrls < Propshaft::Compiler
+  SOURCE_MAPPING_PATTERN = %r{(//|/\*)# sourceMappingURL=(.+\.map)(\s*?\*\/)?\s*?\Z}
+
+  def compile(asset, input)
+    input.gsub(SOURCE_MAPPING_PATTERN) { source_mapping_url(asset.logical_path, asset_path($2, asset.logical_path), $1, $3) }
+  end
+
+  private
+    def asset_path(source_mapping_url, logical_path)
+      source_mapping_url.gsub!(/^(.+\/)?#{url_prefix}\//, "")
+
+      if logical_path.dirname.to_s == "."
+        source_mapping_url
+      else
+        logical_path.dirname.join(source_mapping_url).to_s
+      end
+    end
+
+    def source_mapping_url(logical_path, resolved_path, comment_start, comment_end)
+      if asset = load_path.find(resolved_path)
+        "#{comment_start}# sourceMappingURL=#{url_prefix}/#{asset.digested_path}#{comment_end}"
+      else
+        Propshaft.logger.warn "Removed sourceMappingURL comment for missing asset '#{resolved_path}' from #{logical_path}"
+        "#{comment_start}#{comment_end}"
+      end
+    end
+end

data/lib/propshaft/compiler.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# Base compiler from which other compilers can inherit
+class Propshaft::Compiler
+  attr_reader :assembly
+  delegate :config, :load_path, to: :assembly
+
+  def initialize(assembly)
+    @assembly = assembly
+  end
+
+  # Override this in a specific compiler
+  def compile(asset, input)
+    raise NotImplementedError
+  end
+
+  def referenced_by(asset)
+    Set.new
+  end
+
+  private
+    def url_prefix
+      @url_prefix ||= File.join(config.relative_url_root.to_s, config.prefix.to_s).chomp("/")
+    end
+end

data/lib/propshaft/compilers.rb

@@ -23,11 +23,21 @@ class Propshaft::Compilers
     if relevant_registrations = registrations[asset.content_type.to_s]
       asset.content.dup.tap do |input|
         relevant_registrations.each do |compiler|
-          input.replace compiler.new(assembly).compile(asset.logical_path, input)
+          input.replace compiler.new(assembly).compile(asset, input)
         end
       end
     else
       asset.content
     end
   end
+
+  def referenced_by(asset)
+    Set.new.tap do |references|
+      if relevant_registrations = registrations[asset.content_type.to_s]
+        relevant_registrations.each do |compiler|
+          references.merge compiler.new(assembly).referenced_by(asset)
+        end
+      end
+    end
+  end
 end

data/lib/propshaft/helper.rb

@@ -3,5 +3,28 @@ module Propshaft
     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.
+    def stylesheet_link_tag(*sources, **options)
+      case sources.first
+      when :all
+        super(*all_stylesheets_paths , **options)
+      when :app
+        super(*app_stylesheets_paths , **options)
+      else
+        super
+      end
+    end
+
+    # Returns a sorted and unique array of logical paths for all stylesheets in the load path.
+    def all_stylesheets_paths
+      Rails.application.assets.load_path.asset_paths_by_type("css")
+    end
+
+    # Returns a sorted and unique array of logical paths for all stylesheets in app/assets/**/*.css.
+    def app_stylesheets_paths
+      Rails.application.assets.load_path.asset_paths_by_glob("#{Rails.root.join("app/assets")}/**/*.css")
+    end
   end
 end

data/lib/propshaft/load_path.rb

@@ -1,23 +1,32 @@
 require "propshaft/asset"
 
 class Propshaft::LoadPath
-  attr_reader :paths, :version
+  attr_reader :paths, :compilers, :version
 
-  def initialize(paths = [], version: nil)
-    @paths   = dedup(paths)
-    @version = version
+  def initialize(paths = [], compilers:, version: nil)
+    @paths, @compilers, @version = dedup(paths), compilers, version
   end
 
   def find(asset_name)
     assets_by_path[asset_name]
   end
 
-  def assets(content_types: nil)
-    if content_types
-      assets_by_path.values.select { |asset| asset.content_type.in?(content_types) }
-    else
-      assets_by_path.values
-    end
+  def find_referenced_by(asset)
+    compilers.referenced_by(asset).delete(self)
+  end
+
+  def assets
+    assets_by_path.values
+  end
+
+  def asset_paths_by_type(content_type)
+    (@cached_asset_paths_by_type ||= Hash.new)[content_type] ||=
+      extract_logical_paths_from(assets.select { |a| a.content_type == Mime::EXTENSION_LOOKUP[content_type] })
+  end
+
+  def asset_paths_by_glob(glob)
+    (@cached_asset_paths_by_glob ||= Hash.new)[glob] ||=
+      extract_logical_paths_from(assets.select { |a| a.path.fnmatch?(glob) })
   end
 
   def manifest
@@ -35,9 +44,13 @@ class Propshaft::LoadPath
     @cache_sweeper ||= begin
       exts_to_watch  = Mime::EXTENSION_LOOKUP.map(&:first)
       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
-        clear_cache
+        mutex.synchronize do
+          clear_cache
+          seed_cache
+        end
       end
     end
   end
@@ -48,8 +61,7 @@ class Propshaft::LoadPath
         paths.each do |path|
           without_dotfiles(all_files_from_tree(path)).each do |file|
             logical_path = file.relative_path_from(path)
-            asset = Propshaft::Asset.new(file, logical_path: logical_path, version: version)
-            mapped[asset.logical_path.to_s] ||= asset
+            mapped[logical_path.to_s] ||= Propshaft::Asset.new(file, logical_path: logical_path, load_path: self)
           end if path.exist?
         end
       end
@@ -59,12 +71,22 @@ class Propshaft::LoadPath
       path.children.flat_map { |child| child.directory? ? all_files_from_tree(child) : child }
     end
 
+    def extract_logical_paths_from(assets)
+      assets.collect { |asset| asset.logical_path.to_s }.sort
+    end
+
     def without_dotfiles(files)
       files.reject { |file| file.basename.to_s.starts_with?(".") }
     end
 
     def clear_cache
       @cached_assets_by_path = nil
+      @cached_asset_paths_by_type = nil
+      @cached_asset_paths_by_glob = nil
+    end
+
+    def seed_cache
+      assets_by_path
     end
 
     def dedup(paths)

data/lib/propshaft/output_path.rb

@@ -42,7 +42,7 @@ class Propshaft::OutputPath
       modified_at = [ 0, Time.now - mtime ].max
       modified_at < expires_at || limit < count
     end
-
+  
     def remove(path)
       FileUtils.rm(@path.join(path))
       Propshaft.logger.info "Removed #{path}"

data/lib/propshaft/processor.rb

@@ -20,8 +20,8 @@ class Propshaft::Processor
     FileUtils.rm_r(output_path) if File.exist?(output_path)
   end
 
-  def clean
-    Propshaft::OutputPath.new(output_path, load_path.manifest).clean(2, 1.hour)
+  def clean(count)
+    Propshaft::OutputPath.new(output_path, load_path.manifest).clean(count, 1.hour)
   end
 
   private

data/lib/propshaft/railtie.rb

@@ -11,13 +11,13 @@ module Propshaft
     config.assets.prefix         = "/assets"
     config.assets.quiet          = false
     config.assets.compilers      = [
-      [ "text/css", Propshaft::Compilers::CssAssetUrls ],
-      [ "text/css", Propshaft::Compilers::SourceMappingUrls ],
-      [ "text/javascript", Propshaft::Compilers::SourceMappingUrls ]
+      [ "text/css", Propshaft::Compiler::CssAssetUrls ],
+      [ "text/css", Propshaft::Compiler::SourceMappingUrls ],
+      [ "text/javascript", Propshaft::Compiler::SourceMappingUrls ]
     ]
     config.assets.sweep_cache = Rails.env.development?
     config.assets.server = Rails.env.development? || Rails.env.test?
-    config.assets.host = nil
+    config.assets.relative_url_root = nil
 
     # Register propshaft initializer to copy the assets path in all the Rails Engines.
     # This makes possible for us to keep all `assets` config in this Railtie, but still
@@ -31,7 +31,7 @@ module Propshaft
     end
 
     config.after_initialize do |app|
-      config.assets.host = app.config.asset_host
+      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/railties/assets.rake

@@ -4,7 +4,7 @@ namespace :assets do
     Rails.application.assets.processor.process
     if Rails.env.development?
       puts "Warning: You are precompiling assets in development. Rails will not " \
-        "serve any changed assets until you delete public/assets/.manifest.json"
+        "serve any changed assets until you delete public#{Rails.application.config.assets.prefix}/.manifest.json"
     end
   end
 
@@ -14,8 +14,9 @@ namespace :assets do
   end
 
   desc "Removes old files in config.assets.output_path"
-  task clean: :environment do
-    Rails.application.assets.processor.clean
+  task :clean, [:count] => [:environment] do |_, args|
+    count = args.fetch(:count, 2)
+    Rails.application.assets.processor.clean(count.to_i)
   end
 
   desc "Print all the assets available in config.assets.paths"

data/lib/propshaft/server.rb

@@ -1,4 +1,5 @@
 require "rack/utils"
+require "rack/version"
 
 class Propshaft::Server
   def initialize(assembly)
@@ -14,16 +15,16 @@ class Propshaft::Server
       [
         200,
         {
-          "content-length"  => compiled_content.length.to_s,
-          "content-type"    => asset.content_type.to_s,
-          "accept-encoding" => "vary",
-          "etag"            => asset.digest,
-          "cache-control"   => "public, max-age=31536000, immutable"
+          Rack::CONTENT_LENGTH  => compiled_content.length.to_s,
+          Rack::CONTENT_TYPE    => asset.content_type.to_s,
+          VARY                  => "Accept-Encoding",
+          Rack::ETAG            => asset.digest,
+          Rack::CACHE_CONTROL   => "public, max-age=31536000, immutable"
         },
         [ compiled_content ]
       ]
     else
-      [ 404, { "content-type" => "text/plain", "content-length" => "9" }, [ "Not found" ] ]
+      [ 404, { Rack::CONTENT_TYPE => "text/plain", Rack::CONTENT_LENGTH => "9" }, [ "Not found" ] ]
     end
   end
 
@@ -34,9 +35,15 @@ class Propshaft::Server
   private
     def extract_path_and_digest(env)
       full_path = Rack::Utils.unescape(env["PATH_INFO"].to_s.sub(/^\//, ""))
-      digest    = full_path[/-([0-9a-zA-Z]{7,128}(?:\.digested)?)\.[^.]+\z/, 1]
+      digest    = full_path[/-([0-9a-zA-Z]{7,128})\.(?!digested)[^.]+\z/, 1]
       path      = digest ? full_path.sub("-#{digest}", "") : full_path
 
       [ path, digest ]
     end
+
+    if Gem::Version.new(Rack::RELEASE) < Gem::Version.new("3")
+      VARY = "Vary"
+    else
+      VARY = "vary"
+    end
 end

data/lib/propshaft/version.rb

@@ -1,3 +1,3 @@
 module Propshaft
-  VERSION = "0.7.0"
+  VERSION = "0.9.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: propshaft
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.9.0
 platform: ruby
 authors:
 - David Heinemeier Hansson
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-03-04 00:00:00.000000000 Z
+date: 2024-05-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack
@@ -78,9 +78,10 @@ files:
 - lib/propshaft.rb
 - lib/propshaft/assembly.rb
 - lib/propshaft/asset.rb
+- lib/propshaft/compiler.rb
+- lib/propshaft/compiler/css_asset_urls.rb
+- lib/propshaft/compiler/source_mapping_urls.rb
 - lib/propshaft/compilers.rb
-- lib/propshaft/compilers/css_asset_urls.rb
-- lib/propshaft/compilers/source_mapping_urls.rb
 - lib/propshaft/errors.rb
 - lib/propshaft/helper.rb
 - lib/propshaft/load_path.rb
@@ -113,7 +114,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.6
+rubygems_version: 3.5.10
 signing_key:
 specification_version: 4
 summary: Deliver assets for Rails.

data/lib/propshaft/compilers/source_mapping_urls.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-class Propshaft::Compilers::SourceMappingUrls
-  attr_reader :assembly
-
-  SOURCE_MAPPING_PATTERN = %r{^(//|/\*)# sourceMappingURL=(.+\.map)}
-
-  def initialize(assembly)
-    @assembly = assembly
-  end
-
-  def compile(logical_path, input)
-    input.gsub(SOURCE_MAPPING_PATTERN) { source_mapping_url(asset_path($2, logical_path), $1) }
-  end
-
-  private
-    def asset_path(source_mapping_url, logical_path)
-      if logical_path.dirname.to_s == "."
-        source_mapping_url
-      else
-        logical_path.dirname.join(source_mapping_url).to_s
-      end
-    end
-
-    def source_mapping_url(resolved_path, comment)
-      if asset = assembly.load_path.find(resolved_path)
-        "#{comment}# sourceMappingURL=#{assembly.config.prefix}/#{asset.digested_path}"
-      else
-        Propshaft.logger.warn "Removed sourceMappingURL comment for missing asset '#{resolved_path}' from #{resolved_path}"
-        nil
-      end
-    end
-end