middleman-s3_sync 4.6.4 → 4.6.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e6b576cfe91e75975edadd71f0cfd319e84772edecd882aabe2e3c8c06c90082
-  data.tar.gz: 86bc102e074f9b47980e4cbf93060babd7f7b8a5117cbf35b60ea78ba7476ff0
+  metadata.gz: ae6310b6bdcb35bb9bdeb6b35b5a5471321cd2aa31e2301cb2b85bb40f06c6d8
+  data.tar.gz: d0a22baf1a2f20e5e2ea4ffa0a727042ad42b8d0234ee058925a83c85557705a
 SHA512:
-  metadata.gz: 20b465799e297cff4e8085ba9c9e25637a25a3a77242d862f1d2b93291dd6112c32835fc91eb8fd92d0e4cd11df6676c034330d804e4556b5fc0ba4c2312215e
-  data.tar.gz: 36a4b96fa0c6831047a90ef4140c598bfab3eb5279fffa09adeee5e23673cb30a811806019ea63de16d1c52383b9a644a2ed6cf0bf400ccd1e9eaade616ae00a
+  metadata.gz: 133e5c9a90cd90800cb4c63e443a529b5ea7d0c3d2f803972b58b0ccc01a0af4c0188932f7d0bb3030e42d157c7722f3e8e2cc8c0757c9d5207075fe016653ad
+  data.tar.gz: 0d1438c52b583df33a8bce0ac0faab99d13675470092c70facd356508e096c55fdfc4d64e4bb2a58bdc03ba3cda88afcc7b378f3f5f58374939bd678b46f1de2

data/Changelog.md

@@ -2,6 +2,18 @@
 
 The gem that tries really hard not to push files to S3.
 
+## v4.6.5
+- Performance and stability improvements
+  - Thread-safe invalidation path tracking (use Set + mutex) when running in parallel
+  - Cache CloudFront client (with reset hook for tests)
+  - Single-pass resource categorization (reduce multiple iterations over resources)
+  - Batch S3 deletes via delete_objects (up to 1000 keys/request)
+  - Stream file uploads to reduce memory; compute MD5s in a single read when possible
+  - Optimize CloudFront path deduplication to O(n × path_depth)
+  - CLI/extension: support option writers (e.g., verbose=, dry_run=) to fix NoMethodError
+- Tests: add coverage for CloudFront, batch delete, and streaming uploads
+- No breaking changes; default behavior preserved
+
 ## v4.6.4
 * Remove map gem dependency and replace with native Ruby implementation
 * Add IndifferentHash class to provide string/symbol indifferent access without external dependencies

data/WARP.md

@@ -100,6 +100,10 @@ The gem determines what to do with each file by comparing:
 - **`config.rb`**: Middleman configuration with `activate :s3_sync` block
 - **Environment Variables**: AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_BUCKET, etc.
 
+## Development Rules
+
+**All changes must be accompanied with unit tests.** This is non-negotiable for maintaining code quality and preventing regressions.
+
 ## Common Development Patterns
 
 When adding new functionality:
@@ -109,4 +113,4 @@ When adding new functionality:
 4. Add comprehensive specs following existing patterns
 5. Update README.md with new configuration options
 
-The codebase emphasizes security (credential handling), efficiency (parallel operations), and reliability (comprehensive error handling and dry-run support).
+The codebase emphasizes security (credential handling), efficiency (parallel operations), and reliability (comprehensive error handling and dry-run support).

data/lib/middleman/s3_sync/cloudfront.rb

@@ -1,5 +1,6 @@
 require 'aws-sdk-cloudfront'
 require 'securerandom'
+require 'set'
 
 module Middleman
   module S3Sync
@@ -101,25 +102,42 @@ module Middleman
           # Sort paths to ensure wildcards come before specific files
           sorted_paths = paths.sort
           result = []
+          # Use a Set for O(1) lookup of wildcard prefixes
+          wildcard_prefixes = Set.new
           
           sorted_paths.each do |path|
-            # Check if this path is already covered by a wildcard we've added
-            is_redundant = result.any? do |existing_path|
-              if existing_path.end_with?('/*')
-                # Check if current path is under this wildcard
-                wildcard_prefix = existing_path[0..-3] # Remove /*
-                path.start_with?(wildcard_prefix + '/')
-              else
-                false
+            # Check if this path is covered by any existing wildcard prefix
+            # by checking all parent directories of this path
+            is_redundant = path_covered_by_wildcard?(path, wildcard_prefixes)
+            
+            unless is_redundant
+              result << path
+              # If this is a wildcard path, add its prefix for future lookups
+              if path.end_with?('/*')
+                wildcard_prefixes.add(path[0..-3]) # Remove /*
               end
             end
-            
-            result << path unless is_redundant
           end
           
           result
         end
 
+        # Check if a path is covered by any wildcard prefix in O(path_depth) time
+        def path_covered_by_wildcard?(path, wildcard_prefixes)
+          return false if wildcard_prefixes.empty?
+          
+          # Check each parent directory of the path
+          segments = path.split('/')
+          current_path = ''
+          
+          segments[0..-2].each do |segment|  # Exclude the last segment
+            current_path = current_path.empty? ? segment : "#{current_path}/#{segment}"
+            return true if wildcard_prefixes.include?(current_path)
+          end
+          
+          false
+        end
+
         def create_invalidation_with_retry(paths, options)
           max_retries = options.cloudfront_invalidation_max_retries || 5
           retries = 0
@@ -161,24 +179,30 @@ module Middleman
         end
 
         def cloudfront_client(options)
-          client_options = {
-            region: 'us-east-1' # CloudFront is always in us-east-1
-          }
-
-          # Use the same credentials as S3 if available
-          if options.aws_access_key_id && options.aws_secret_access_key
-            client_options.merge!({
-              access_key_id: options.aws_access_key_id,
-              secret_access_key: options.aws_secret_access_key
-            })
-
-            # If using an assumed role
-            client_options.merge!({
-              session_token: options.aws_session_token
-            }) if options.aws_session_token
+          @cloudfront_client ||= begin
+            client_options = {
+              region: 'us-east-1' # CloudFront is always in us-east-1
+            }
+
+            # Use the same credentials as S3 if available
+            if options.aws_access_key_id && options.aws_secret_access_key
+              client_options.merge!({
+                access_key_id: options.aws_access_key_id,
+                secret_access_key: options.aws_secret_access_key
+              })
+
+              # If using an assumed role
+              client_options.merge!({
+                session_token: options.aws_session_token
+              }) if options.aws_session_token
+            end
+
+            Aws::CloudFront::Client.new(client_options)
           end
+        end
 
-          Aws::CloudFront::Client.new(client_options)
+        def reset_cloudfront_client!
+          @cloudfront_client = nil
         end
 
         def wait_for_invalidations(invalidation_ids, options)

data/lib/middleman/s3_sync/resource.rb

@@ -116,20 +116,25 @@ module Middleman
 
       def upload!
         object = bucket.object(remote_path.sub(/^\//, ''))
-        upload_options = build_upload_options
-
-        begin
-          object.put(upload_options)
-        rescue Aws::S3::Errors::AccessControlListNotSupported => e
-          # Bucket has ACLs disabled - retry without ACL
-          if upload_options.key?(:acl)
-            say_status "#{ANSI.yellow{"Note"}} Bucket does not support ACLs, retrying without ACL parameter"
-            # Automatically disable ACLs for this bucket going forward
-            options.acl = ''
-            upload_options.delete(:acl)
-            retry
-          else
-            raise e
+        
+        # Use streaming upload for memory efficiency with large files
+        File.open(local_path, 'rb') do |file|
+          upload_options = build_upload_options_for_stream(file)
+          
+          begin
+            object.put(upload_options)
+          rescue Aws::S3::Errors::AccessControlListNotSupported => e
+            # Bucket has ACLs disabled - retry without ACL
+            if upload_options.key?(:acl)
+              say_status "#{ANSI.yellow{"Note"}} Bucket does not support ACLs, retrying without ACL parameter"
+              # Automatically disable ACLs for this bucket going forward
+              options.acl = ''
+              upload_options.delete(:acl)
+              file.rewind  # Reset file position for retry
+              retry
+            else
+              raise e
+            end
           end
         end
       end
@@ -278,12 +283,24 @@ module Middleman
       end
 
       def local_object_md5
-        @local_object_md5 ||= Digest::MD5.hexdigest(File.read(local_path))
+        @local_object_md5 ||= begin
+          # When not gzipped, compute both MD5s in single read to avoid redundant I/O
+          if !gzipped && local_path == original_path
+            compute_md5s_single_read
+            @local_object_md5
+          else
+            Digest::MD5.hexdigest(File.read(local_path))
+          end
+        end
       end
 
       def local_content_md5
         @local_content_md5 ||= begin
-          if File.exist?(original_path)
+          # When not gzipped, compute both MD5s in single read to avoid redundant I/O
+          if !gzipped && local_path == original_path
+            compute_md5s_single_read
+            @local_content_md5
+          elsif File.exist?(original_path)
             Digest::MD5.hexdigest(File.read(original_path))
           else
             nil
@@ -291,6 +308,16 @@ module Middleman
         end
       end
 
+      # Compute both MD5s from a single file read when they're the same file
+      def compute_md5s_single_read
+        return if @md5s_computed
+        content = File.read(local_path)
+        md5 = Digest::MD5.hexdigest(content)
+        @local_object_md5 = md5
+        @local_content_md5 = md5
+        @md5s_computed = true
+      end
+
       def original_path
         gzipped ? local_path.gsub(/\.gz$/, '') : local_path
       end
@@ -314,9 +341,10 @@ module Middleman
 
       protected
       
-      def build_upload_options
+      # Build upload options with a file stream as the body
+      def build_upload_options_for_stream(file_stream)
         upload_options = {
-          body: local_content,
+          body: file_stream,
           content_type: content_type
         }
         # Only add ACL if enabled (not for buckets with ACLs disabled)

data/lib/middleman/s3_sync/version.rb

@@ -1,5 +1,5 @@
 module Middleman
   module S3Sync
-    VERSION = "4.6.4"
+    VERSION = "4.6.5"
   end
 end

data/lib/middleman/s3_sync.rb

@@ -11,6 +11,7 @@ require 'middleman/redirect'
 require 'parallel'
 require 'ruby-progressbar'
 require 'thread'
+require 'set'
 
 module Middleman
   module S3Sync
@@ -20,6 +21,7 @@ module Middleman
 
       @@bucket_lock = Mutex.new
       @@bucket_files_lock = Mutex.new
+      @@invalidation_paths_lock = Mutex.new
 
       attr_accessor :s3_sync_options
       attr_accessor :mm_resources
@@ -28,11 +30,12 @@ module Middleman
       THREADS_COUNT = 8
       
       # Track paths that were changed during sync for CloudFront invalidation
-      attr_accessor :invalidation_paths
+      # Using a Set for O(1) lookups
+      attr_reader :invalidation_paths
 
       def sync()
         @app ||= ::Middleman::Application.new
-        @invalidation_paths = []
+        @invalidation_paths = Set.new
 
         say_status "Let's see if there's work to be done..."
         unless work_to_be_done?
@@ -58,7 +61,7 @@ module Middleman
         
         # Invalidate CloudFront cache if requested
         if s3_sync_options.cloudfront_invalidate
-          CloudFront.invalidate(@invalidation_paths, s3_sync_options)
+          CloudFront.invalidate(@invalidation_paths.to_a, s3_sync_options)
         end
       end
 
@@ -77,10 +80,12 @@ module Middleman
       end
       
       def add_invalidation_path(path)
-        @invalidation_paths ||= []
-        # Normalize path for CloudFront (ensure it starts with /)
-        normalized_path = path.start_with?('/') ? path : "/#{path}"
-        @invalidation_paths << normalized_path unless @invalidation_paths.include?(normalized_path)
+        @@invalidation_paths_lock.synchronize do
+          @invalidation_paths ||= Set.new
+          # Normalize path for CloudFront (ensure it starts with /)
+          normalized_path = path.start_with?('/') ? path : "/#{path}"
+          @invalidation_paths.add(normalized_path)
+        end
       end
 
       def remote_only_paths
@@ -204,10 +209,22 @@ module Middleman
       end
 
       def delete_resources
-        Parallel.map(files_to_delete, in_threads: THREADS_COUNT) do |resource|
-          resource.destroy!
+        resources = files_to_delete
+        return if resources.empty?
+
+        # Print status messages for all resources being deleted
+        resources.each do |resource|
+          say_status "#{ANSI.red{"Deleting"}} #{resource.remote_path}"
           add_invalidation_path(resource.path)
         end
+
+        # Batch delete using S3's delete_objects API (up to 1000 objects per request)
+        unless s3_sync_options.dry_run
+          resources.each_slice(1000) do |batch|
+            objects_to_delete = batch.map { |r| { key: r.remote_path.sub(/^\//, '') } }
+            bucket.delete_objects(delete: { objects: objects_to_delete })
+          end
+        end
       end
 
       def ignore_resources
@@ -224,24 +241,41 @@ module Middleman
         !(files_to_create.empty? && files_to_update.empty? && files_to_delete.empty?)
       end
 
+      # Single-pass categorization of resources by status
+      # Avoids multiple iterations over s3_sync_resources
+      def categorized_resources
+        @categorized_resources ||= begin
+          result = { create: [], update: [], delete: [], ignore: [] }
+          s3_sync_resources.values.each do |resource|
+            case
+            when resource.to_create? then result[:create] << resource
+            when resource.to_update? then result[:update] << resource
+            when resource.to_delete? then result[:delete] << resource
+            when resource.to_ignore? then result[:ignore] << resource
+            end
+          end
+          result
+        end
+      end
+
       def files_to_delete
         if s3_sync_options.delete
-          s3_sync_resources.values.select { |r| r.to_delete? }
+          categorized_resources[:delete]
         else
           []
         end
       end
 
       def files_to_create
-        s3_sync_resources.values.select { |r| r.to_create? }
+        categorized_resources[:create]
       end
 
       def files_to_update
-        s3_sync_resources.values.select { |r| r.to_update? }
+        categorized_resources[:update]
       end
 
       def files_to_ignore
-        s3_sync_resources.values.select { |r| r.to_ignore? }
+        categorized_resources[:ignore]
       end
 
       def build_dir

data/lib/middleman-s3_sync/extension.rb

@@ -87,16 +87,30 @@ module Middleman
       true
     end
 
-    # Delegate option readers to the options object
+    # Delegate option readers and writers to the options object
     def method_missing(method, *args, &block)
-      if options.respond_to?(method)
-        options.send(method, *args, &block)
-      else
-        super
+      method_str = method.to_s
+      
+      # Handle setter methods (e.g., verbose=)
+      if method_str.end_with?('=')
+        option_name = method_str.chomp('=').to_sym
+        if options.respond_to?(option_name)
+          options[option_name] = args.first
+          return args.first
+        end
+      elsif options.respond_to?(method)
+        return options.send(method, *args, &block)
       end
+      
+      super
     end
 
     def respond_to_missing?(method, include_private = false)
+      method_str = method.to_s
+      if method_str.end_with?('=')
+        option_name = method_str.chomp('=').to_sym
+        return options.respond_to?(option_name)
+      end
       options.respond_to?(method) || super
     end
 

data/spec/aws_sdk_parameters_spec.rb

@@ -128,14 +128,17 @@ describe 'AWS SDK Parameter Validation' do
       allow(File).to receive(:exist?).with('build/test/file.html.gz').and_return(false)
       allow(File).to receive(:read).with('build/test/file.html').and_return('test content')
       allow(File).to receive(:directory?).with('build/test/file.html').and_return(false)
+      # Stub File.open to return a StringIO for streaming upload tests
+      allow(File).to receive(:open).with('build/test/file.html', 'rb').and_yield(StringIO.new('test content'))
       allow(s3_object).to receive(:head).and_return(nil)
       options.dry_run = false
     end
 
     it 'uses correct metadata key format' do
       expect(s3_object).to receive(:put) do |upload_options|
-        # Verify basic parameters
-        expect(upload_options[:body]).to eq('test content')
+        # Verify body is a readable IO object (for streaming)
+        expect(upload_options[:body]).to respond_to(:read)
+        expect(upload_options[:body].read).to eq('test content')
         expect(upload_options[:content_type]).to eq('text/html')
         expect(upload_options[:acl]).to eq('public-read')
         
@@ -160,7 +163,7 @@ describe 'AWS SDK Parameter Validation' do
       it 'does not include acl parameter in upload' do
         expect(s3_object).to receive(:put) do |upload_options|
           expect(upload_options).not_to have_key(:acl)
-          expect(upload_options[:body]).to eq('test content')
+          expect(upload_options[:body]).to respond_to(:read)
           expect(upload_options[:content_type]).to eq('text/html')
         end
 
@@ -176,7 +179,7 @@ describe 'AWS SDK Parameter Validation' do
       it 'does not include acl parameter in upload' do
         expect(s3_object).to receive(:put) do |upload_options|
           expect(upload_options).not_to have_key(:acl)
-          expect(upload_options[:body]).to eq('test content')
+          expect(upload_options[:body]).to respond_to(:read)
           expect(upload_options[:content_type]).to eq('text/html')
         end
 
@@ -192,6 +195,10 @@ describe 'AWS SDK Parameter Validation' do
 
       it 'automatically retries without ACL when AccessControlListNotSupported error occurs' do
         call_count = 0
+        # Use a reusable StringIO that can be rewound
+        file_io = StringIO.new('test content')
+        allow(File).to receive(:open).with('build/test/file.html', 'rb').and_yield(file_io)
+        
         expect(s3_object).to receive(:put).twice do |upload_options|
           call_count += 1
           if call_count == 1
@@ -201,7 +208,7 @@ describe 'AWS SDK Parameter Validation' do
           else
             # Second call should not include ACL
             expect(upload_options).not_to have_key(:acl)
-            expect(upload_options[:body]).to eq('test content')
+            expect(upload_options[:body]).to respond_to(:read)
             expect(upload_options[:content_type]).to eq('text/html')
           end
         end
@@ -219,7 +226,7 @@ describe 'AWS SDK Parameter Validation' do
             expect(upload_options[:acl]).to eq('public-read')
             raise Aws::S3::Errors::AccessControlListNotSupported.new(nil, 'The bucket does not allow ACLs')
           else
-            # Second call should succeed without ACL
+            # Subsequent calls should succeed without ACL
             expect(upload_options).not_to have_key(:acl)
             true
           end
@@ -241,6 +248,7 @@ describe 'AWS SDK Parameter Validation' do
         allow(File).to receive(:read).with('build/test/file.html.gz').and_return('gzipped content')
         allow(File).to receive(:exist?).with('build/test/file.html').and_return(true)
         allow(File).to receive(:read).with('build/test/file.html').and_return('original content')
+        allow(File).to receive(:open).with('build/test/file.html.gz', 'rb').and_yield(StringIO.new('gzipped content'))
         
         # Mock the HEAD response to avoid calling it during redirect?
         head_response = double(
@@ -305,6 +313,7 @@ describe 'AWS SDK Parameter Validation' do
         allow(File).to receive(:exist?).with('build/redirect/file.html').and_return(true)
         allow(File).to receive(:exist?).with('build/redirect/file.html.gz').and_return(false)
         allow(File).to receive(:read).with('build/redirect/file.html').and_return('redirect content')
+        allow(File).to receive(:open).with('build/redirect/file.html', 'rb').and_yield(StringIO.new('redirect content'))
         allow(File).to receive(:directory?).with('build/redirect/file.html').and_return(false)
         allow(s3_object).to receive(:head).and_return(nil)
         allow(resource).to receive(:redirect?).and_return(true)
@@ -478,6 +487,7 @@ describe 'AWS SDK Parameter Validation' do
       allow(File).to receive(:exist?).with('build/test/file.html').and_return(true)
       allow(File).to receive(:exist?).with('build/test/file.html.gz').and_return(false)
       allow(File).to receive(:read).with('build/test/file.html').and_return('test content')
+      allow(File).to receive(:open).with('build/test/file.html', 'rb').and_yield(StringIO.new('test content'))
       allow(File).to receive(:directory?).with('build/test/file.html').and_return(false)
       allow(s3_object).to receive(:head).and_return(nil)
       options.dry_run = false

data/spec/cloudfront_spec.rb

@@ -27,6 +27,8 @@ describe Middleman::S3Sync::CloudFront do
 
   before do
     allow(described_class).to receive(:say_status)
+    # Reset cached CloudFront client between tests to prevent double leakage
+    described_class.send(:reset_cloudfront_client!)
   end
 
   describe '.invalidate' do

data/spec/indifferent_hash_spec.rb

@@ -0,0 +1,278 @@
+require 'spec_helper'
+
+describe Middleman::S3Sync::IndifferentHash do
+  let(:hash) { described_class.new }
+
+  describe 'string-indifferent key access' do
+    it 'allows setting and retrieving values using string keys' do
+      hash['foo'] = 'bar'
+      expect(hash['foo']).to eq('bar')
+    end
+
+    it 'retrieves string key values using symbol keys' do
+      hash['foo'] = 'bar'
+      expect(hash[:foo]).to eq('bar')
+    end
+
+    it 'normalizes string keys on retrieval' do
+      hash['foo'] = 'value1'
+      hash['foo'] = 'value2'
+      expect(hash['foo']).to eq('value2')
+      expect(hash.keys.count).to eq(1)
+    end
+  end
+
+  describe 'symbol-indifferent key access' do
+    it 'allows setting and retrieving values using symbol keys' do
+      hash[:foo] = 'bar'
+      expect(hash[:foo]).to eq('bar')
+    end
+
+    it 'retrieves symbol key values using string keys' do
+      hash[:foo] = 'bar'
+      expect(hash['foo']).to eq('bar')
+    end
+
+    it 'normalizes symbol keys to strings' do
+      hash[:foo] = 'value1'
+      hash['foo'] = 'value2'
+      expect(hash[:foo]).to eq('value2')
+      expect(hash.keys.count).to eq(1)
+    end
+
+    it 'stores keys as strings internally' do
+      hash[:foo] = 'bar'
+      expect(hash.keys).to eq(['foo'])
+    end
+  end
+
+  describe 'dot notation access' do
+    it 'allows accessing values using dot notation' do
+      hash[:foo] = 'bar'
+      expect(hash.foo).to eq('bar')
+    end
+
+    it 'allows setting values using dot notation' do
+      hash.foo = 'baz'
+      expect(hash[:foo]).to eq('baz')
+    end
+
+    it 'works with string keys' do
+      hash['foo'] = 'bar'
+      expect(hash.foo).to eq('bar')
+    end
+
+    it 'raises NoMethodError for non-existent keys' do
+      expect { hash.nonexistent_key }.to raise_error(NoMethodError)
+    end
+
+    it 'supports respond_to? for existing keys' do
+      hash[:foo] = 'bar'
+      expect(hash).to respond_to(:foo)
+      expect(hash).to respond_to(:foo=)
+    end
+
+    it 'returns false for respond_to? on non-existent keys' do
+      expect(hash).not_to respond_to(:nonexistent)
+    end
+  end
+
+  describe 'nested hashes with indifferent access' do
+    it 'handles nested hash values' do
+      hash[:outer] = { inner: 'value' }
+      expect(hash[:outer]).to eq({ inner: 'value' })
+    end
+
+    it 'allows nested IndifferentHash instances' do
+      inner = described_class.new
+      inner[:foo] = 'bar'
+      hash[:outer] = inner
+      
+      expect(hash[:outer][:foo]).to eq('bar')
+      expect(hash[:outer].foo).to eq('bar')
+    end
+
+    it 'supports multiple levels of nesting' do
+      inner = described_class.new
+      inner[:level2] = 'deep'
+      hash[:level1] = inner
+      
+      expect(hash['level1']['level2']).to eq('deep')
+      expect(hash[:level1][:level2]).to eq('deep')
+    end
+  end
+
+  describe 'Hash method compatibility' do
+    describe '#has_key?' do
+      it 'works with string keys' do
+        hash['foo'] = 'bar'
+        expect(hash.has_key?('foo')).to be true
+        expect(hash.has_key?(:foo)).to be true
+      end
+
+      it 'works with symbol keys' do
+        hash[:foo] = 'bar'
+        expect(hash.has_key?('foo')).to be true
+        expect(hash.has_key?(:foo)).to be true
+      end
+
+      it 'returns false for non-existent keys' do
+        expect(hash.has_key?('nonexistent')).to be false
+        expect(hash.has_key?(:nonexistent)).to be false
+      end
+    end
+
+    describe '#key?' do
+      it 'is aliased to has_key?' do
+        hash[:foo] = 'bar'
+        expect(hash.key?('foo')).to be true
+        expect(hash.key?(:foo)).to be true
+      end
+    end
+
+    describe '#include?' do
+      it 'is aliased to has_key?' do
+        hash[:foo] = 'bar'
+        expect(hash.include?('foo')).to be true
+        expect(hash.include?(:foo)).to be true
+      end
+    end
+
+    describe '#fetch' do
+      it 'fetches values with string keys' do
+        hash['foo'] = 'bar'
+        expect(hash.fetch('foo')).to eq('bar')
+        expect(hash.fetch(:foo)).to eq('bar')
+      end
+
+      it 'fetches values with symbol keys' do
+        hash[:foo] = 'bar'
+        expect(hash.fetch('foo')).to eq('bar')
+        expect(hash.fetch(:foo)).to eq('bar')
+      end
+
+      it 'returns default value for missing keys' do
+        expect(hash.fetch('missing', 'default')).to eq('default')
+        expect(hash.fetch(:missing, 'default')).to eq('default')
+      end
+
+      it 'calls block for missing keys' do
+        result = hash.fetch('missing') { |key| "Key #{key} not found" }
+        expect(result).to eq('Key missing not found')
+      end
+
+      it 'raises KeyError when key is missing without default' do
+        expect { hash.fetch('missing') }.to raise_error(KeyError)
+        expect { hash.fetch(:missing) }.to raise_error(KeyError)
+      end
+    end
+  end
+
+  describe '.from_hash' do
+    it 'creates an IndifferentHash from a regular hash' do
+      regular_hash = { 'foo' => 'bar', 'baz' => 'qux' }
+      result = described_class.from_hash(regular_hash)
+      
+      expect(result).to be_a(described_class)
+      expect(result['foo']).to eq('bar')
+      expect(result[:foo]).to eq('bar')
+      expect(result['baz']).to eq('qux')
+      expect(result[:baz]).to eq('qux')
+    end
+
+    it 'handles hashes with symbol keys' do
+      regular_hash = { foo: 'bar', baz: 'qux' }
+      result = described_class.from_hash(regular_hash)
+      
+      expect(result[:foo]).to eq('bar')
+      expect(result['foo']).to eq('bar')
+    end
+
+    it 'handles empty hashes' do
+      result = described_class.from_hash({})
+      expect(result).to be_a(described_class)
+      expect(result).to be_empty
+    end
+
+    it 'handles mixed string and symbol keys' do
+      regular_hash = { 'string_key' => 'value1', :symbol_key => 'value2' }
+      result = described_class.from_hash(regular_hash)
+      
+      expect(result['string_key']).to eq('value1')
+      expect(result[:string_key]).to eq('value1')
+      expect(result['symbol_key']).to eq('value2')
+      expect(result[:symbol_key]).to eq('value2')
+    end
+  end
+
+  describe 'map gem API compatibility' do
+    # These tests ensure no breaking changes compared to the map gem
+    
+    it 'supports basic key-value storage' do
+      hash[:key] = 'value'
+      expect(hash[:key]).to eq('value')
+      expect(hash['key']).to eq('value')
+    end
+
+    it 'supports dot notation like map gem' do
+      hash.max_age = 3600
+      expect(hash.max_age).to eq(3600)
+      expect(hash[:max_age]).to eq(3600)
+    end
+
+    it 'supports fetch with default values' do
+      expect(hash.fetch(:missing, 'default')).to eq('default')
+    end
+
+    it 'supports has_key? checks' do
+      hash[:present] = 'value'
+      expect(hash.has_key?(:present)).to be true
+      expect(hash.has_key?('present')).to be true
+      expect(hash.has_key?(:absent)).to be false
+    end
+
+    it 'maintains Hash inheritance' do
+      expect(hash).to be_a(Hash)
+    end
+
+    it 'supports standard Hash operations' do
+      hash[:a] = 1
+      hash[:b] = 2
+      
+      expect(hash.keys.sort).to eq(['a', 'b'])
+      expect(hash.values.sort).to eq([1, 2])
+      expect(hash.size).to eq(2)
+    end
+
+    it 'supports iteration' do
+      hash[:a] = 1
+      hash[:b] = 2
+      
+      result = []
+      hash.each { |k, v| result << [k, v] }
+      expect(result).to contain_exactly(['a', 1], ['b', 2])
+    end
+
+    context 'usage in BrowserCachePolicy' do
+      it 'supports caching policy access patterns' do
+        # Mimics how BrowserCachePolicy uses the hash
+        hash[:max_age] = 3600
+        hash[:s_maxage] = 7200
+        hash[:public] = true
+        hash[:no_cache] = false
+        
+        expect(hash.has_key?(:max_age)).to be true
+        expect(hash.has_key?('s_maxage')).to be true
+        expect(hash.fetch(:public, false)).to be true
+        expect(hash.fetch(:private, false)).to be false
+        expect(hash.fetch('must_revalidate', false)).to be false
+      end
+
+      it 'supports mixed string and symbol key access like in caching_policy.rb' do
+        hash[:max_age] = 3600
+        expect(hash['max_age']).to eq(3600)
+        expect(hash.max_age).to eq(3600)
+      end
+    end
+  end
+end

data/spec/s3_sync_integration_spec.rb

@@ -36,7 +36,7 @@ describe 'S3Sync CloudFront Integration' do
   describe 'CloudFront invalidation integration' do
     it 'calls CloudFront invalidation after sync operations' do
       # Reset invalidation paths for this test
-      Middleman::S3Sync.instance_variable_set(:@invalidation_paths, [])
+      Middleman::S3Sync.instance_variable_set(:@invalidation_paths, Set.new)
       
       expect(Middleman::S3Sync::CloudFront).to receive(:invalidate).with(
         [], # Initially empty, gets populated during resource operations
@@ -104,7 +104,7 @@ describe 'S3Sync CloudFront Integration' do
   describe 'path tracking during resource operations' do
     before do
       # Reset invalidation paths before each path tracking test
-      Middleman::S3Sync.instance_variable_set(:@invalidation_paths, [])
+      Middleman::S3Sync.instance_variable_set(:@invalidation_paths, Set.new)
     end
 
     it 'adds paths to invalidation list when resources are processed' do
@@ -126,7 +126,73 @@ describe 'S3Sync CloudFront Integration' do
       Middleman::S3Sync.add_invalidation_path('/same/path.html')
       Middleman::S3Sync.add_invalidation_path('/same/path.html')
       
-      expect(Middleman::S3Sync.invalidation_paths.count('/same/path.html')).to eq(1)
+      # Set automatically handles uniqueness - verify it contains exactly one occurrence
+      expect(Middleman::S3Sync.invalidation_paths.to_a.count('/same/path.html')).to eq(1)
     end
   end
-end
+
+  describe 'batch delete operations' do
+    let(:bucket) { double('bucket') }
+    let(:resource1) { double('resource1', path: 'file1.html', remote_path: 'file1.html') }
+    let(:resource2) { double('resource2', path: 'file2.html', remote_path: 'file2.html') }
+    let(:resource3) { double('resource3', path: 'file3.html', remote_path: 'file3.html') }
+
+    before do
+      # Remove the stub for delete_resources so we test the actual implementation
+      allow(Middleman::S3Sync).to receive(:delete_resources).and_call_original
+      allow(Middleman::S3Sync).to receive(:say_status)
+      allow(Middleman::S3Sync).to receive(:bucket).and_return(bucket)
+      allow(Middleman::S3Sync).to receive(:s3_sync_options).and_return(s3_sync_options)
+      Middleman::S3Sync.instance_variable_set(:@invalidation_paths, Set.new)
+      Middleman::S3Sync.instance_variable_set(:@categorized_resources, nil)
+    end
+
+    it 'uses batch delete_objects API instead of individual deletes' do
+      allow(Middleman::S3Sync).to receive(:files_to_delete).and_return([resource1, resource2, resource3])
+      
+      expect(bucket).to receive(:delete_objects).with(
+        delete: {
+          objects: [
+            { key: 'file1.html' },
+            { key: 'file2.html' },
+            { key: 'file3.html' }
+          ]
+        }
+      )
+
+      Middleman::S3Sync.send(:delete_resources)
+    end
+
+    it 'adds invalidation paths for all deleted resources' do
+      allow(Middleman::S3Sync).to receive(:files_to_delete).and_return([resource1, resource2])
+      allow(bucket).to receive(:delete_objects)
+
+      Middleman::S3Sync.send(:delete_resources)
+
+      expect(Middleman::S3Sync.invalidation_paths).to include('/file1.html')
+      expect(Middleman::S3Sync.invalidation_paths).to include('/file2.html')
+    end
+
+    it 'does not call delete_objects during dry run' do
+      dry_run_options = double(
+        dry_run: true,
+        delete: true,
+        bucket: 'test-bucket'
+      )
+      allow(Middleman::S3Sync).to receive(:s3_sync_options).and_return(dry_run_options)
+      allow(Middleman::S3Sync).to receive(:files_to_delete).and_return([resource1])
+
+      expect(bucket).not_to receive(:delete_objects)
+
+      Middleman::S3Sync.send(:delete_resources)
+    end
+
+    it 'does nothing when there are no files to delete' do
+      allow(Middleman::S3Sync).to receive(:files_to_delete).and_return([])
+
+      expect(bucket).not_to receive(:delete_objects)
+
+      Middleman::S3Sync.send(:delete_resources)
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: middleman-s3_sync
 version: !ruby/object:Gem::Version
-  version: 4.6.4
+  version: 4.6.5
 platform: ruby
 authors:
 - Frederic Jean
 - Will Koehler
 bindir: bin
 cert_chain: []
-date: 2026-01-03 00:00:00.000000000 Z
+date: 2026-02-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: middleman-core
@@ -299,6 +299,7 @@ files:
 - spec/caching_policy_spec.rb
 - spec/cloudfront_spec.rb
 - spec/extension_spec.rb
+- spec/indifferent_hash_spec.rb
 - spec/options_spec.rb
 - spec/resource_spec.rb
 - spec/s3_sync_integration_spec.rb
@@ -329,6 +330,7 @@ test_files:
 - spec/caching_policy_spec.rb
 - spec/cloudfront_spec.rb
 - spec/extension_spec.rb
+- spec/indifferent_hash_spec.rb
 - spec/options_spec.rb
 - spec/resource_spec.rb
 - spec/s3_sync_integration_spec.rb