Replace SHA256 with ActiveSupport::Digest and fix deletion logic

Co-authored-by: nhorton <[email protected]>

Author: Copilot

README.md

@@ -14,7 +14,7 @@ This cache store is designed to be committed to version control, making it ideal
 ## Features
 
 - **File-based storage**: Each cache entry is stored as separate `.key` and `.value` files
-- **Hashed filenames**: Uses SHA256 hashing for keys to create consistent, filesystem-safe filenames
+- **Hashed filenames**: Uses ActiveSupport::Digest for keys to create consistent, filesystem-safe filenames
 - **No expiration**: Cache entries do NOT honor expiration parameters - they persist until explicitly deleted
 - **Rails 7.1+ compatible**: Implements the ActiveSupport::Cache::Store interface
 
@@ -94,7 +94,7 @@ value = cache.read("foo---bar---boo-ba")  # => "27"
 
 When a delimiter is configured:
 - The cache key is split by the delimiter into segments
-- Each segment creates a subdirectory named `hash(segment)` using SHA256
+- Each segment creates a subdirectory named `hash(segment)` using ActiveSupport::Digest
 - Each subdirectory contains a `_key_chunk` file with the original segment text
 - The cached value is stored in a `value` file in the final subdirectory
 
@@ -104,7 +104,7 @@ This feature is useful for organizing cache entries hierarchically when keys hav
 
 ### Hashed Keys
 
-Keys are hashed using SHA256 to create filesystem-safe filenames. The original key is preserved in the `.key` file, while the hash is used for the filename:
+Keys are hashed using ActiveSupport::Digest to create filesystem-safe filenames. The original key is preserved in the `.key` file, while the hash is used for the filename:
 
 ```ruby
 cache.write("user:123:profile", { name: "John" })

lib/active_support/cache/source_control_cache_store.rb

@@ -4,7 +4,6 @@
 require "active_support/cache"
 require "active_support/notifications"
 require "active_support/core_ext/object/json"
-require "digest"
 require "fileutils"
 
 module ActiveSupport
@@ -165,13 +164,19 @@ def delete_entry_with_subdirectories(key, **options)
 
         return false unless File.exist?(value_file)
 
-        # Delete the entire directory tree for this key
+        # Delete only the deepest directory containing this specific entry
         chunks = key.to_s.split(@subdirectory_delimiter)
-        first_chunk_hash = hash_chunk(chunks[0])
-        dir_to_delete = File.join(@cache_path, first_chunk_hash)
+        
+        # Build the full path to the final directory
+        current_dir = @cache_path
+        chunks.each do |chunk|
+          chunk_hash = hash_chunk(chunk)
+          current_dir = File.join(current_dir, chunk_hash)
+        end
 
         begin
-          FileUtils.rm_rf(dir_to_delete) if File.exist?(dir_to_delete)
+          # Delete the final directory (containing _key_chunk and value)
+          FileUtils.rm_rf(current_dir) if File.exist?(current_dir)
           true
         rescue StandardError
           false
@@ -181,17 +186,17 @@ def delete_entry_with_subdirectories(key, **options)
       # Generate a hash for the given key
       #
       # @param key [String] The cache key
-      # @return [String] The SHA256 hash of the key
+      # @return [String] The hash of the key
       def hash_key(key)
-        ::Digest::SHA256.hexdigest(key.to_s)
+        ::ActiveSupport::Digest.hexdigest(key.to_s)
       end
 
       # Generate a hash for a key chunk
       #
       # @param chunk [String] A chunk of the cache key
-      # @return [String] The SHA256 hash of the chunk
+      # @return [String] The hash of the chunk
       def hash_chunk(chunk)
-        ::Digest::SHA256.hexdigest(chunk.to_s)
+        ::ActiveSupport::Digest.hexdigest(chunk.to_s)
       end
 
       # Get the path for the key file

spec/source_control_cache_store_spec.rb

@@ -45,7 +45,7 @@
       store.write("my_key", "my_value")
 
       # Calculate the expected hash
-      hash = Digest::SHA256.hexdigest("my_key")
+      hash = ActiveSupport::Digest.hexdigest("my_key")
       key_file = File.join(cache_path, "#{hash}.key")
       value_file = File.join(cache_path, "#{hash}.value")
 
@@ -57,7 +57,7 @@
       original_key = "my_special_key"
       store.write(original_key, "value")
 
-      hash = Digest::SHA256.hexdigest(original_key)
+      hash = ActiveSupport::Digest.hexdigest(original_key)
       key_file = File.join(cache_path, "#{hash}.key")
 
       expect(File.read(key_file)).to eq(original_key)
@@ -82,7 +82,7 @@
 
     it "removes both .key and .value files" do
       store.write("key", "value")
-      hash = Digest::SHA256.hexdigest("key")
+      hash = ActiveSupport::Digest.hexdigest("key")
       key_file = File.join(cache_path, "#{hash}.key")
       value_file = File.join(cache_path, "#{hash}.value")
 
@@ -149,9 +149,9 @@
   end
 
   describe "key hashing" do
-    it "uses SHA256 for hashing keys" do
+    it "uses ActiveSupport::Digest for hashing keys" do
       key = "test_key"
-      expected_hash = Digest::SHA256.hexdigest(key)
+      expected_hash = ActiveSupport::Digest.hexdigest(key)
 
       store.write(key, "value")
 
@@ -215,9 +215,9 @@
       store_with_delimiter.write("foo---bar---boo-ba", "27")
 
       # Calculate expected hashes
-      foo_hash = Digest::SHA256.hexdigest("foo")
-      bar_hash = Digest::SHA256.hexdigest("bar")
-      boo_ba_hash = Digest::SHA256.hexdigest("boo-ba")
+      foo_hash = ActiveSupport::Digest.hexdigest("foo")
+      bar_hash = ActiveSupport::Digest.hexdigest("bar")
+      boo_ba_hash = ActiveSupport::Digest.hexdigest("boo-ba")
 
       # Check that directories exist
       expect(File.directory?(File.join(cache_path_with_delimiter, foo_hash))).to be true
@@ -228,9 +228,9 @@
     it "creates _key_chunk files with correct content" do
       store_with_delimiter.write("foo---bar---boo-ba", "27")
 
-      foo_hash = Digest::SHA256.hexdigest("foo")
-      bar_hash = Digest::SHA256.hexdigest("bar")
-      boo_ba_hash = Digest::SHA256.hexdigest("boo-ba")
+      foo_hash = ActiveSupport::Digest.hexdigest("foo")
+      bar_hash = ActiveSupport::Digest.hexdigest("bar")
+      boo_ba_hash = ActiveSupport::Digest.hexdigest("boo-ba")
 
       # Check _key_chunk files
       foo_chunk_file = File.join(cache_path_with_delimiter, foo_hash, "_key_chunk")
@@ -245,9 +245,9 @@
     it "stores value in the final directory" do
       store_with_delimiter.write("foo---bar---boo-ba", "27")
 
-      foo_hash = Digest::SHA256.hexdigest("foo")
-      bar_hash = Digest::SHA256.hexdigest("bar")
-      boo_ba_hash = Digest::SHA256.hexdigest("boo-ba")
+      foo_hash = ActiveSupport::Digest.hexdigest("foo")
+      bar_hash = ActiveSupport::Digest.hexdigest("bar")
+      boo_ba_hash = ActiveSupport::Digest.hexdigest("boo-ba")
 
       value_file = File.join(cache_path_with_delimiter, foo_hash, bar_hash, boo_ba_hash, "value")
 
@@ -263,7 +263,7 @@
     it "handles single chunk keys (no delimiter present)" do
       store_with_delimiter.write("single_key", "single_value")
 
-      single_hash = Digest::SHA256.hexdigest("single_key")
+      single_hash = ActiveSupport::Digest.hexdigest("single_key")
       value_file = File.join(cache_path_with_delimiter, single_hash, "value")
 
       expect(File.exist?(value_file)).to be true
@@ -314,5 +314,22 @@
       store_with_delimiter.write(key, "deep_value")
       expect(store_with_delimiter.read(key)).to eq("deep_value")
     end
+
+    it "deletes only the specific entry without affecting others with common prefixes" do
+      # Write two keys that share the first chunk
+      store_with_delimiter.write("foo---bar", "value1")
+      store_with_delimiter.write("foo---baz", "value2")
+      
+      # Verify both exist
+      expect(store_with_delimiter.read("foo---bar")).to eq("value1")
+      expect(store_with_delimiter.read("foo---baz")).to eq("value2")
+      
+      # Delete the first one
+      store_with_delimiter.delete("foo---bar")
+      
+      # Verify only the deleted one is gone
+      expect(store_with_delimiter.read("foo---bar")).to be_nil
+      expect(store_with_delimiter.read("foo---baz")).to eq("value2")
+    end
   end
 end