Abstract manifest into own class

Author: zcei

lib/propshaft/assembly.rb

@@ -1,3 +1,4 @@
+require "propshaft/manifest"
 require "propshaft/load_path"
 require "propshaft/resolver/dynamic"
 require "propshaft/resolver/static"

lib/propshaft/asset.rb

@@ -46,7 +46,7 @@ def integrity(hash_algorithm:)
       when "sha512"
         512
       else
-        raise(Error.new("Subresource Integrity hash algorithm must be one of SHA2 family (sha256, sha384, sha512)"))
+        raise(StandardError.new("Subresource Integrity hash algorithm must be one of SHA2 family (sha256, sha384, sha512)"))
       end
 
     [hash_algorithm, Digest::SHA2.new(bitlen).base64digest(content)].join("-")

lib/propshaft/load_path.rb

@@ -1,3 +1,4 @@
+require "propshaft/manifest"
 require "propshaft/asset"
 
 class Propshaft::LoadPath
@@ -11,10 +12,10 @@ def execute_if_updated
     end
   end
 
-  attr_reader :paths, :compilers, :version
+  attr_reader :paths, :compilers, :version, :integrity_hash_algorithm
 
   def initialize(paths = [], compilers:, version: nil, file_watcher: nil, integrity_hash_algorithm: nil)
-    @paths, @compilers, @version = dedup(paths), compilers, version, integrity_hash_algorithm
+    @paths, @compilers, @version, @integrity_hash_algorithm = dedup(paths), compilers, version, integrity_hash_algorithm
     @file_watcher = file_watcher || NullFileWatcher
   end
 
@@ -41,17 +42,8 @@ def asset_paths_by_glob(glob)
   end
 
   def manifest
-    Hash.new.tap do |manifest|
-      assets.each do |asset|
-        manifest[asset.logical_path.to_s] = if @integrity_hash_algorithm.nil?
-          asset.digested_path.to_s
-        else
-          {
-            digested_path: asset.digested_path.to_s,
-            integrity: asset.integrity(hash_algorithm: @integrity_hash_algorithm)
-          }
-        end
-      end
+    Propshaft::Manifest.new(integrity_hash_algorithm:).tap do |manifest|
+      assets.each { |asset| manifest.push_asset(asset) }
     end
   end
 

lib/propshaft/manifest.rb

@@ -0,0 +1,75 @@
+module Propshaft
+  class Manifest
+    class ManifestEntry
+      attr_reader :logical_path, :digested_path, :integrity
+      def initialize(logical_path:, digested_path:, integrity:)
+        @logical_path = logical_path
+        @digested_path = digested_path
+        @integrity = integrity
+      end
+
+      def to_h
+        { digested_path:, integrity: }
+      end
+    end
+
+    def initialize(integrity_hash_algorithm: nil)
+      @integrity_hash_algorithm = integrity_hash_algorithm
+      @entries = {}
+    end
+
+    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
+
+    def push(entry)
+      @entries[entry.logical_path] = entry
+    end
+
+    def <<(asset)
+      push(asset)
+    end
+
+    def [](logical_path)
+      @entries[logical_path]
+    end
+
+    def to_json
+      Hash.new.tap do |serialized_manifest|
+        @entries.values.each do |manifest_entry|
+          serialized_manifest[manifest_entry.logical_path] = manifest_entry.to_h
+        end
+      end.to_json
+    end
+
+    class << self
+      def from_path(manifest_path)
+        JSON.parse(manifest_path.read, symbolize_names: false).tap do |serialized_manifest|
+          Manifest.new.tap do |manifest|
+            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:, integrity:
+              )
+
+              manifest.push(entry)
+            end
+          end
+        end
+      end
+    end
+  end
+end

lib/propshaft/resolver/static.rb

@@ -19,12 +19,12 @@ def read(logical_path, encoding: "ASCII-8BIT")
     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 = parsed_manifest[logical_path]
+        entry = manifest[logical_path]
 
         if entry.is_a?(String)
           return entry

test/propshaft/asset_test.rb

@@ -51,6 +51,23 @@ class Propshaft::AssetTest < ActiveSupport::TestCase
       find_asset("file-is-a-sourcemap.js.map").digested_path.to_s
   end
 
+  test "integrity" do
+    assert_equal "sha256-+C/K/0dPvIdSC8rl/NDS8zqPp08R0VH+hKMM4D8tNJs=",
+      find_asset("one.txt").integrity(hash_algorithm: "sha256").to_s
+
+    assert_equal "sha384-LdS8l2QTAF8bD8WPb8QSQv0skTWHhmcnS2XU5LBkVQneGzqIqnDRskQtJvi7ADMe",
+      find_asset("one.txt").integrity(hash_algorithm: "sha384").to_s
+
+    assert_equal "sha512-wzPP7om24750PjHXRlgiDOhILPd4V2AbLRxomBudQaTDI1eYZkM5j8pSH/ylSSUxiGqXR3F6lgVCbsmXkqKrEg==",
+      find_asset("one.txt").integrity(hash_algorithm: "sha512").to_s
+
+    exception = assert_raises StandardError do
+      find_asset("one.txt").integrity(hash_algorithm: "md5")
+    end
+
+    assert_equal "Subresource Integrity hash algorithm must be one of SHA2 family (sha256, sha384, sha512)", exception.message
+  end
+
   test "value object equality" do
     assert_equal find_asset("one.txt"), find_asset("one.txt")
   end

test/propshaft/load_path_test.rb

@@ -31,16 +31,16 @@ class Propshaft::LoadPathTest < ActiveSupport::TestCase
 
   test "manifest" do
     @load_path.manifest.tap do |manifest|
-      assert_equal "one-f2e1ec14.txt", manifest["one.txt"]
-      assert_equal "nested/three-6c2b86a0.txt", manifest["nested/three.txt"]
+      assert_equal "one-f2e1ec14.txt", manifest["one.txt"].digested_path.to_s
+      assert_equal "nested/three-6c2b86a0.txt", manifest["nested/three.txt"].digested_path.to_s
     end
   end
 
   test "manifest with version" do
     @load_path = Propshaft::LoadPath.new(@load_path.paths, version: "1", compilers: Propshaft::Compilers.new(nil))
     @load_path.manifest.tap do |manifest|
-      assert_equal "one-c9373b68.txt", manifest["one.txt"]
-      assert_equal "nested/three-a41a5d38.txt", manifest["nested/three.txt"]
+      assert_equal "one-c9373b68.txt", manifest["one.txt"].digested_path.to_s
+      assert_equal "nested/three-a41a5d38.txt", manifest["nested/three.txt"].digested_path.to_s
     end
   end
 

test/propshaft/manifest_test.rb

@@ -0,0 +1,50 @@
+require "test_helper"
+require "propshaft/manifest"
+
+class Propshaft::ManifestTest < ActiveSupport::TestCase
+  test "serializes to the extensible manifest format with integrity hash value" do
+    manifest = create_manifest("sha384")
+    parsed_manifest = JSON.parse(manifest.to_json)
+
+    manifest_entry = parsed_manifest["one.txt"]
+    assert_equal "one-f2e1ec14.txt", manifest_entry["digested_path"]
+    assert_equal "sha384-LdS8l2QTAF8bD8WPb8QSQv0skTWHhmcnS2XU5LBkVQneGzqIqnDRskQtJvi7ADMe", manifest_entry["integrity"]
+
+    manifest_entry = parsed_manifest["another.css"]
+    assert_equal "another-c464b1ee.css", manifest_entry["digested_path"]
+    assert_equal "sha384-RZLbo+FZ8rnE9ct6dNqDcgIYo7DBk/GaB4nCMnNsj6HWp0ePV8q8qky9Qemdpuwl", manifest_entry["integrity"]
+  end
+
+  test "serializes to the extensible manifest format without integrity hash algorithm" do
+    manifest = create_manifest
+    parsed_manifest = JSON.parse(manifest.to_json)
+
+    manifest_entry = parsed_manifest["one.txt"]
+    assert_equal "one-f2e1ec14.txt", manifest_entry["digested_path"]
+    assert_nil manifest_entry["integrity"]
+
+    manifest_entry = parsed_manifest["another.css"]
+    assert_equal "another-c464b1ee.css", manifest_entry["digested_path"]
+    assert_nil manifest_entry["integrity"]
+  end
+
+  private
+    def create_manifest(integrity_hash_algorithm = nil)
+      Propshaft::Manifest.new(integrity_hash_algorithm:).tap do |manifest|
+        manifest.push_asset(find_asset("one.txt"))
+        manifest.push_asset(find_asset("another.css"))
+      end
+    end
+
+    def find_asset(logical_path)
+      root_path = Pathname.new("#{__dir__}/../fixtures/assets/first_path")
+      path = root_path.join(logical_path)
+
+      assembly = Propshaft::Assembly.new(ActiveSupport::OrderedOptions.new.tap { |config|
+        config.paths = [ root_path ]
+        config.compilers = [[ "text/css", Propshaft::Compiler::CssAssetUrls ]]
+      })
+
+      Propshaft::Asset.new(path, logical_path: logical_path, load_path: assembly.load_path)
+    end
+end

test/propshaft/processor_test.rb

@@ -17,7 +17,7 @@ class Propshaft::ProcessorTest < ActiveSupport::TestCase
   test "manifest is written" do
     processed do |processor|
       assert_equal "one-f2e1ec14.txt",
-         JSON.parse(processor.output_path.join(".manifest.json").read)["one.txt"]
+         JSON.parse(processor.output_path.join(".manifest.json").read)["one.txt"]["digested_path"]
     end
   end