assiette 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1267863146e1fa5c134f47f1cf797123609d8466690d3a39d9603fe9c35787ef
-  data.tar.gz: fcfbe591ac7de77fddb85bfe0d3b2cee0838ef30ac596aef612712b37294511a
+  metadata.gz: 4f24fbf1362c382584825ebb9ea4adf6b0abf0e24ad0b00c0792810b469152be
+  data.tar.gz: 747cafe7a7af67efec260a8ff506eecb390b69225fd8aebf7ff52122175f7a4f
 SHA512:
-  metadata.gz: d525c3fb1891574eac36d5b42ac82d5426b7a60e870a8001f4115edc15f32935e5559623a08ad849a6e580917788c25e16d39d64274deec47aa4291c3b399d8a
-  data.tar.gz: 3b35f41fec398a1ed00d3b18f2bec5167d14cd0af451d8cc838fa4f5957c21bf8d349e8fcc0a15d54ceeb788a9c78c0bb30e754baf44350c51961cf4e0836d53
+  metadata.gz: df6146e2288d39315cd1d045e1af7c7b75e07fc89022d3288c7d52f544e01f4be7bdc1ee5a5a9fcf49d788cf967419801a7259e8477a57f3b3274a59475db1ad
+  data.tar.gz: d29c94ba6524db67f1c8f85a024c1648a9e1ea9ccf60078528ebcf24b1fbfd818181ce3c379b061519bfbd53a75ede042a15fda3734c47baddb7832cde3d4fd3

data/lib/assiette/asset_handler.rb

@@ -1,10 +1,6 @@
 # frozen_string_literal: true
 
-require "digest/sha1"
-require "digest/sha2"
-require "base64"
 require "pathname"
-require_relative "version_tag"
 
 module Assiette
   class AssetHandler
@@ -19,13 +15,28 @@ module Assiette
 
     JS_EXTENSIONS = %w[.js .mjs].to_set.freeze
 
+    attr_reader :dependency_graph
+
     def initialize(root:, additional_directory_mappings: {})
       @mappings = build_mappings(root, additional_directory_mappings)
-      @integrity_cache = {}
-      @integrity_mutex = Mutex.new
-      @modules_cache = nil
-      @modules_mutex = Mutex.new
-      @modules_version = nil
+      @dependency_graph = DependencyGraph.new(self)
+    end
+
+    # Yields (url_path, abs_path) for every file with a recognized extension.
+    def each_mapped_file
+      @mappings.each do |prefix, root|
+        CONTENT_TYPES.each_key do |ext|
+          Dir[File.join(root, "**/*#{ext}")].each do |abs|
+            relative = Pathname.new(abs).relative_path_from(root).to_s
+            url_path = if prefix.empty?
+              relative
+            else
+              "#{prefix}/#{relative}"
+            end
+            yield url_path, abs
+          end
+        end
+      end
     end
 
     def resolve_file(path)
@@ -51,40 +62,25 @@ module Assiette
     def absolute_asset_url_path(path, script_name = "")
       clean = path.sub(%r{\A/}, "")
       return nil unless resolve_file(clean)
-      "#{script_name}/#{clean}?v=#{Assiette.version_tag}"
+      hash = @dependency_graph.tree_sha(clean) || "00000000"
+      "#{script_name}/#{clean}?s=#{hash}"
     end
 
     def asset_integrity(path)
-      version_tag = Assiette.version_tag
-      @integrity_mutex.synchronize do
-        if @integrity_version != version_tag
-          @integrity_cache = {}
-          @integrity_version = version_tag
-        end
-        return @integrity_cache[path] if @integrity_cache.key?(path)
-
-        clean = path.sub(%r{\A/}, "")
-        @integrity_cache[path] = compute_integrity(clean, version_tag)
-      end
+      clean = path.sub(%r{\A/}, "")
+      return nil unless resolve_file(clean)
+      @dependency_graph.tree_integrity(clean)
     end
 
     def js_modules
-      version_tag = Assiette.version_tag
-      @modules_mutex.synchronize do
-        return @modules_cache if @modules_version == version_tag
-
-        @modules_cache = @mappings.flat_map { |prefix, root|
-          Dir[File.join(root, "**/*.{js,mjs}")].filter_map { |abs|
-            next unless File.foreach(abs).any? { |line| line.match?(/\A\s*(import|export)\s/) }
-            relative = Pathname.new(abs).relative_path_from(root).to_s
-            mod_path = "/#{"#{prefix}/" unless prefix.empty?}#{relative}".squeeze("/")
-            {path: mod_path, integrity: asset_integrity(mod_path)}
-          }
-        }.uniq { |m| m[:path] }.sort_by { |m| m[:path] }
-
-        @modules_version = version_tag
-        @modules_cache
-      end
+      @mappings.flat_map { |prefix, root|
+        Dir[File.join(root, "**/*.{js,mjs}")].filter_map { |abs|
+          next unless File.foreach(abs).any? { |line| line.match?(/\A\s*(import|export)\s/) }
+          relative = Pathname.new(abs).relative_path_from(root).to_s
+          mod_path = "/#{"#{prefix}/" unless prefix.empty?}#{relative}".squeeze("/")
+          {path: mod_path, integrity: asset_integrity(mod_path)}
+        }
+      }.uniq { |m| m[:path] }.sort_by { |m| m[:path] }
     end
 
     private
@@ -97,19 +93,5 @@ module Assiette
       end
       mappings
     end
-
-    def compute_integrity(clean, version_tag)
-      file_path = resolve_file(clean)
-      return nil unless file_path
-
-      raw = File.read(file_path)
-      ext = File.extname(clean)
-      served = case ext
-      when ".js", ".mjs" then Rewriter.rewrite_js_imports(raw, version_tag)
-      when ".css" then Rewriter.rewrite_css_urls(raw, version_tag)
-      else raw
-      end
-      "sha256-#{Base64.strict_encode64(Digest::SHA256.digest(served))}"
-    end
   end
 end

data/lib/assiette/dependency_graph.rb

@@ -0,0 +1,310 @@
+# frozen_string_literal: true
+
+require "digest/sha2"
+require "base64"
+require "pathname"
+
+module Assiette
+  class DependencyGraph
+    # Per-file node in the dependency graph.
+    class Asset
+      attr_reader :url_path
+      attr_accessor :abs_path, :mtime, :digest, :deps, :dependents
+
+      def initialize(url_path:, abs_path:, mtime:)
+        @url_path = url_path.freeze
+        @abs_path = abs_path
+        @mtime = mtime
+        @digest = nil
+        @deps = []
+        @dependents = Set.new
+      end
+
+      # 8-char hex hash for ?s= cache-busting query params.
+      def checksum_tag
+        digest&.unpack1("H8")
+      end
+
+      # SRI integrity string for integrity= attributes.
+      def sri_integrity
+        return nil unless digest
+        "sha256-#{Base64.strict_encode64(digest)}"
+      end
+
+      # Whether this asset's file has changed since last scan.
+      def stale?
+        File.mtime(abs_path) != mtime
+      rescue Errno::ENOENT
+        true
+      end
+
+      # Whether the file no longer exists on disk.
+      def deleted?
+        !File.exist?(abs_path.to_s)
+      end
+    end
+
+    def initialize(handler)
+      @handler = handler
+      @mutex = Mutex.new
+      @assets = {}
+    end
+
+    # Returns the Asset for a url_path, or nil.
+    def [](url_path)
+      @mutex.synchronize do
+        ensure_asset!(url_path)
+      end
+    end
+
+    # Returns the 8-char hex content hash for a URL path.
+    def tree_sha(url_path)
+      self[url_path]&.checksum_tag
+    end
+
+    # Returns the SRI integrity string for a URL path.
+    def tree_integrity(url_path)
+      self[url_path]&.sri_integrity
+    end
+
+    # Resolves a relative import path to a URL path.
+    def resolve_import_for(from_url_path, relative_path)
+      if relative_path.start_with?("/")
+        relative_path.sub(%r{\A/}, "")
+      else
+        dir = File.dirname(from_url_path)
+        File.expand_path(relative_path, "/#{dir}").sub(%r{\A/}, "")
+      end
+    end
+
+    # Rewrites content with per-dependency hashes. Thread-safe.
+    def rewrite_content(url_path, raw_content)
+      @mutex.synchronize do
+        ensure_asset!(url_path)
+        rewrite_content_internal(url_path, raw_content)
+      end
+    end
+
+    # Forces a full rebuild on next access.
+    def invalidate!
+      @mutex.synchronize do
+        @assets = {}
+      end
+    end
+
+    private
+
+    # Lazily resolve a single asset and its transitive dependencies.
+    # Returns the Asset or nil if the file doesn't exist.
+    def ensure_asset!(url_path)
+      @resolving = Set.new
+      @checked = Set.new
+      @cycle_groups = []
+      asset = resolve_asset!(url_path)
+      # Process any cycles detected during resolution
+      @cycle_groups.each { |scc| compute_cycle_digests(scc) }
+      @resolving = nil
+      @checked = nil
+      @cycle_groups = nil
+      asset
+    end
+
+    # Recursive resolution. Detects cycles via @resolving set.
+    # @checked prevents re-verifying the same asset within one ensure_asset! call.
+    # Returns the Asset or nil. Also returns whether anything changed downstream.
+    def resolve_asset!(url_path)
+      # Already verified fresh in this ensure_asset! call
+      return @assets[url_path] if @checked.include?(url_path)
+
+      existing = @assets[url_path]
+      if existing
+        if existing.deleted?
+          remove_asset!(url_path)
+          return nil
+        end
+
+        if existing.stale?
+          rescan_asset!(existing)
+          @checked << url_path
+          return existing
+        end
+
+        # Not stale itself — but deps might be. Check them recursively.
+        @checked << url_path
+        old_dep_digests = existing.deps.map { |dp| @assets[dp]&.digest }
+        existing.deps.each { |dp| resolve_asset!(dp) }
+        new_dep_digests = existing.deps.map { |dp| @assets[dp]&.digest }
+
+        if old_dep_digests != new_dep_digests
+          compute_digest_for(url_path)
+        end
+
+        return existing
+      end
+
+      # Resolve url_path to an absolute path
+      abs_path = @handler.resolve_file(url_path)
+      return nil unless abs_path
+
+      # Cycle detection
+      unless @resolving.add?(url_path)
+        return @assets[url_path]
+      end
+
+      # Create the asset node
+      asset = @assets[url_path] = Asset.new(
+        url_path: url_path,
+        abs_path: abs_path,
+        mtime: File.mtime(abs_path)
+      )
+      asset.deps = parse_deps(url_path, File.read(abs_path))
+
+      # Recursively resolve dependencies
+      in_cycle = false
+      asset.deps.each do |dep_path|
+        if @resolving.include?(dep_path) && !@assets[dep_path]&.digest
+          in_cycle = true
+        end
+        dep = resolve_asset!(dep_path)
+        dep.dependents << url_path if dep
+      end
+
+      if in_cycle || asset.deps.any? { |dp| @resolving.include?(dp) && !@assets[dp]&.digest }
+        scc = collect_cycle(url_path)
+        @cycle_groups << scc unless scc.empty?
+      else
+        compute_digest_for(url_path)
+      end
+
+      @checked << url_path
+      @resolving.delete(url_path)
+      asset
+    end
+
+    # Collect strongly connected component members starting from url_path.
+    def collect_cycle(url_path)
+      visited = Set.new
+      stack = [url_path]
+      members = Set.new
+
+      while (node = stack.pop)
+        next unless visited.add?(node)
+        asset = @assets[node]
+        next unless asset
+        members << node if @resolving.include?(node)
+        asset.deps.each do |dep|
+          stack << dep if @resolving.include?(dep)
+        end
+      end
+
+      members.to_a
+    end
+
+    # Re-read a stale asset, re-parse deps, recursively ensure deps fresh, recompute digest.
+    def rescan_asset!(asset)
+      url_path = asset.url_path
+      asset.mtime = File.mtime(asset.abs_path)
+
+      # Remove old reverse links
+      asset.deps.each do |dep_path|
+        dep = @assets[dep_path]
+        dep&.dependents&.delete(url_path)
+      end
+
+      # Re-parse imports
+      raw = File.read(asset.abs_path)
+      asset.deps = parse_deps(url_path, raw)
+
+      # Recursively ensure deps are fresh
+      asset.deps.each do |dep_path|
+        dep = resolve_asset!(dep_path)
+        dep.dependents << url_path if dep
+      end
+
+      # Recompute digest
+      compute_digest_for(url_path)
+
+      # Propagate to dependents already in the graph
+      propagate_to_dependents!(asset)
+    end
+
+    # Recompute digests for all transitive dependents of an asset.
+    def propagate_to_dependents!(asset)
+      queue = asset.dependents.to_a
+      visited = Set.new
+      while (dep_url = queue.shift)
+        next unless visited.add?(dep_url)
+        dep_asset = @assets[dep_url]
+        next unless dep_asset
+        compute_digest_for(dep_url)
+        queue.concat(dep_asset.dependents.to_a)
+      end
+    end
+
+    def parse_deps(url_path, raw)
+      ext = File.extname(url_path)
+      import_paths = case ext
+      when ".js", ".mjs", ".es" then Rewriter.extract_js_imports(raw)
+      when ".css" then Rewriter.extract_css_urls(raw)
+      else []
+      end
+      import_paths.map { |p| resolve_import_for(url_path, p) }
+    end
+
+    def compute_digest_for(url_path)
+      asset = @assets[url_path]
+      return unless asset
+
+      raw = File.read(asset.abs_path)
+      if asset.deps.empty?
+        asset.digest = Digest::SHA256.digest(raw)
+      else
+        rewritten = rewrite_content_internal(url_path, raw)
+        asset.digest = Digest::SHA256.digest(rewritten)
+      end
+    end
+
+    # For cyclic dependencies: hash all members' raw contents together.
+    def compute_cycle_digests(scc)
+      combined = scc.sort.filter_map { |url_path|
+        asset = @assets[url_path]
+        next unless asset
+        File.read(asset.abs_path)
+      }.join("\0")
+
+      digest = Digest::SHA256.digest(combined)
+      scc.each do |url_path|
+        asset = @assets[url_path]
+        asset.digest = digest if asset
+      end
+    end
+
+    def rewrite_content_internal(url_path, raw_content)
+      ext = File.extname(url_path)
+      case ext
+      when ".js", ".mjs", ".es"
+        Rewriter.rewrite_js_imports(raw_content) do |import_path|
+          resolved = resolve_import_for(url_path, import_path)
+          @assets[resolved]&.checksum_tag || "00000000"
+        end
+      when ".css"
+        Rewriter.rewrite_css_urls(raw_content) do |ref_path|
+          resolved = resolve_import_for(url_path, ref_path)
+          @assets[resolved]&.checksum_tag || "00000000"
+        end
+      else
+        raw_content
+      end
+    end
+
+    def remove_asset!(url_path)
+      asset = @assets.delete(url_path)
+      return unless asset
+
+      asset.deps.each do |dep_path|
+        dep = @assets[dep_path]
+        dep&.dependents&.delete(url_path)
+      end
+    end
+  end
+end

data/lib/assiette/rewriter.rb

@@ -15,16 +15,37 @@ module Assiette
 
     module_function
 
-    def rewrite_js_imports(source, version_tag)
+    # Rewrites JS imports with per-import hashes via a block.
+    # The block receives the import path and must return the hash for that import.
+    def rewrite_js_imports(source, &block)
       source.gsub(JS_IMPORT_RE) do
-        "#{$1}#{$2}?v=#{version_tag}#{$1}"
+        quote = $1
+        path = $2
+        hash = yield(path)
+        "#{quote}#{path}?s=#{hash}#{quote}"
       end
     end
 
-    def rewrite_css_urls(source, version_tag)
+    # Rewrites CSS url() references with per-url hashes via a block.
+    # The block receives the url path and must return the hash for that url.
+    def rewrite_css_urls(source, &block)
       source.gsub(CSS_URL_RE) do
-        "url(#{$1}#{$2}?v=#{version_tag}#{$3})"
+        open = $1
+        path = $2
+        close = $3
+        hash = yield(path)
+        "url(#{open}#{path}?s=#{hash}#{close})"
       end
     end
+
+    # Returns an array of import paths found in JS source.
+    def extract_js_imports(source)
+      source.scan(JS_IMPORT_RE).map { |m| m[1] }
+    end
+
+    # Returns an array of url() paths found in CSS source.
+    def extract_css_urls(source)
+      source.scan(CSS_URL_RE).map { |m| m[1] }
+    end
   end
 end

data/lib/assiette/server.rb

@@ -37,24 +37,17 @@ module Assiette
       file_path = @handler.resolve_file(path_info)
       return unless file_path
 
-      raw_bytes = File.binread(file_path)
-
-      # ETag from raw bytes for stability
-      etag = %("#{Digest::SHA1.hexdigest(raw_bytes)}")
+      # Use the dependency graph's content hash for the ETag — it reflects
+      # the file's own content plus all its transitive dependencies, and is
+      # already computed as part of serving. This lets us short-circuit with
+      # a 304 before reading the file for rewriting.
+      etag = %("#{@handler.dependency_graph.tree_sha(path_info) || "0"}")
       if env["HTTP_IF_NONE_MATCH"] == etag
         return [304, {"etag" => etag, "cache-control" => CACHE_CONTROL}, []]
       end
 
-      query = Rack::Utils.parse_query(env["QUERY_STRING"])
-      tag = query["v"].to_s.empty? ? Assiette.version_tag : query["v"]
-
-      body = if AssetHandler::JS_EXTENSIONS.include?(extension)
-        Rewriter.rewrite_js_imports(raw_bytes, tag)
-      elsif extension == ".css"
-        Rewriter.rewrite_css_urls(raw_bytes, tag)
-      else
-        raw_bytes
-      end
+      raw_bytes = File.binread(file_path)
+      body = @handler.dependency_graph.rewrite_content(path_info, raw_bytes)
 
       headers = {
         "content-type" => content_type,

data/lib/assiette/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Assiette
-  VERSION = "0.3.1"
+  VERSION = "0.4.0"
 end

data/lib/assiette.rb

@@ -5,6 +5,7 @@ require_relative "assiette/version"
 module Assiette
   autoload :Rewriter, File.expand_path("assiette/rewriter", __dir__)
   autoload :AssetHandler, File.expand_path("assiette/asset_handler", __dir__)
+  autoload :DependencyGraph, File.expand_path("assiette/dependency_graph", __dir__)
   autoload :Server, File.expand_path("assiette/server", __dir__)
   autoload :Helpers, File.expand_path("assiette/helpers", __dir__)
   autoload :RailsAssetUrlHelper, File.expand_path("assiette/rails_asset_url_helper", __dir__)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: assiette
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Julik Tarkhanov
@@ -35,13 +35,13 @@ files:
 - Rakefile
 - lib/assiette.rb
 - lib/assiette/asset_handler.rb
+- lib/assiette/dependency_graph.rb
 - lib/assiette/helpers.rb
 - lib/assiette/rails_asset_url_helper.rb
 - lib/assiette/railtie.rb
 - lib/assiette/rewriter.rb
 - lib/assiette/server.rb
 - lib/assiette/version.rb
-- lib/assiette/version_tag.rb
 - lib/generators/assiette/install/install_generator.rb
 - lib/generators/assiette/install/templates/initializer.rb.tt
 homepage: https://github.com/julik/assiette

data/lib/assiette/version_tag.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require "digest/sha1"
-
-module Assiette
-  # Computes a short version tag for cache busting.
-  # In development: timestamp for instant invalidation on each request
-  # In production: derived from APP_REVISION env var or Gemfile.lock digest
-  def self.version_tag
-    @version_tag ||= compute_version_tag
-  end
-
-  def self.reset_version_tag!
-    @version_tag = nil
-  end
-
-  def self.compute_version_tag
-    if Rails.env.development?
-      Time.now.utc.strftime("%Y%m%d%H%M%S")
-    elsif (app_revision = ENV["APP_REVISION"]).present?
-      Digest::SHA1.hexdigest(app_revision)[0, 4]
-    else
-      gemfile_lock_path = Rails.root.join("Gemfile.lock")
-      if gemfile_lock_path.exist?
-        Digest::SHA1.file(gemfile_lock_path).hexdigest[0, 4]
-      else
-        (Time.now.utc.to_i / 300).to_s(16)
-      end
-    end
-  end
-
-  private_class_method :compute_version_tag
-end