middleman-s3_sync 4.6.5 → 4.8.0

data/middleman-s3_sync.gemspec

@@ -13,28 +13,31 @@ Gem::Specification.new do |gem|
   gem.homepage      = "http://github.com/fredjean/middleman-s3_sync"
   gem.license       = 'MIT'
 
+  gem.required_ruby_version = '>= 3.0'
+
   gem.files         = `git ls-files`.split($/)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_runtime_dependency 'middleman-core'
-  gem.add_runtime_dependency 'middleman-cli'
-  gem.add_runtime_dependency 'aws-sdk-s3', '>= 1.187.0'
-  gem.add_runtime_dependency 'aws-sdk-cloudfront'
-  gem.add_runtime_dependency 'parallel'
-  gem.add_runtime_dependency 'ruby-progressbar'
-  gem.add_runtime_dependency 'ansi', '~> 1.5.0'
-  gem.add_runtime_dependency 'mime-types', '~> 3.1'
-  gem.add_runtime_dependency 'nokogiri', '>= 1.18.4'
+  # Runtime dependencies
+  gem.add_runtime_dependency 'middleman-core', '~> 4.4'
+  gem.add_runtime_dependency 'middleman-cli', '~> 4.4'
+  gem.add_runtime_dependency 'aws-sdk-s3', '~> 1.187', '>= 1.187.0'
+  gem.add_runtime_dependency 'aws-sdk-cloudfront', '~> 1.0'
+  gem.add_runtime_dependency 'parallel', '~> 1.20'
+  gem.add_runtime_dependency 'ruby-progressbar', '~> 1.11'
+  gem.add_runtime_dependency 'ansi', '~> 1.5'
+  gem.add_runtime_dependency 'mime-types', '~> 3.4'
+  gem.add_runtime_dependency 'nokogiri', '~> 1.18', '>= 1.18.4'
 
-  gem.add_development_dependency 'rake'
-  gem.add_development_dependency 'pry'
-  gem.add_development_dependency 'pry-byebug'
-  gem.add_development_dependency 'rspec'
-  gem.add_development_dependency 'rspec-support'
-  gem.add_development_dependency 'rspec-its'
-  gem.add_development_dependency 'rspec-mocks'
-  gem.add_development_dependency 'timerizer'
-  gem.add_development_dependency 'webrick'
+  # Development dependencies
+  gem.add_development_dependency 'rake', '~> 13.0'
+  gem.add_development_dependency 'pry', '~> 0.14'
+  gem.add_development_dependency 'pry-byebug', '~> 3.10'
+  gem.add_development_dependency 'rspec', '~> 3.12'
+  gem.add_development_dependency 'rspec-support', '~> 3.12'
+  gem.add_development_dependency 'rspec-its', '~> 2.0'
+  gem.add_development_dependency 'rspec-mocks', '~> 3.12'
+  gem.add_development_dependency 'webrick', '~> 1.8'
 end

data/spec/aws_sdk_parameters_spec.rb

@@ -87,6 +87,60 @@ describe 'AWS SDK Parameter Validation' do
         }.to raise_error('S3 requires `index_document` if `error_document` is specified')
       end
     end
+
+    context 'when routing_rules are set' do
+      before do
+        options.routing_rules = [
+          {
+            condition: { key_prefix_equals: 'docs/' },
+            redirect: { replace_key_prefix_with: 'documents/' }
+          },
+          {
+            condition: { http_error_code_returned_equals: '404' },
+            redirect: { host_name: 'example.com', replace_key_with: 'error.html' }
+          }
+        ]
+      end
+
+      it 'includes routing_rules in website configuration' do
+        expect(s3_client).to receive(:put_bucket_website) do |params|
+          expect(params[:website_configuration]).to have_key(:routing_rules)
+          rules = params[:website_configuration][:routing_rules]
+          expect(rules).to be_an(Array)
+          expect(rules.length).to eq(2)
+          
+          # First rule
+          expect(rules[0][:condition][:key_prefix_equals]).to eq('docs/')
+          expect(rules[0][:redirect][:replace_key_prefix_with]).to eq('documents/')
+          
+          # Second rule
+          expect(rules[1][:condition][:http_error_code_returned_equals]).to eq('404')
+          expect(rules[1][:redirect][:host_name]).to eq('example.com')
+          expect(rules[1][:redirect][:replace_key_with]).to eq('error.html')
+        end
+
+        Middleman::S3Sync.send(:update_bucket_website)
+      end
+    end
+
+    context 'when routing_rules are set without index_document' do
+      before do
+        options.index_document = nil
+        options.error_document = nil
+        options.routing_rules = [
+          {
+            condition: { key_prefix_equals: 'old/' },
+            redirect: { replace_key_prefix_with: 'new/' }
+          }
+        ]
+      end
+
+      it 'raises an error because S3 requires index_document if routing_rules are specified' do
+        expect {
+          Middleman::S3Sync.send(:update_bucket_website)
+        }.to raise_error('S3 requires `index_document` if `routing_rules` are specified')
+      end
+    end
   end
 
   describe 'put_bucket_versioning parameters' do
@@ -425,6 +479,48 @@ describe 'AWS SDK Parameter Validation' do
       end
     end
 
+    context 'when a caching policy with only max_age is in effect' do
+      before do
+        policy = Middleman::S3Sync::BrowserCachePolicy.new(max_age: 31536000, public: true, immutable: true)
+        allow(Middleman::S3Sync).to receive(:caching_policy_for).and_return(policy)
+      end
+
+      it 'sets cache_control but omits expires' do
+        attributes = resource.to_h
+
+        expect(attributes[:cache_control]).to eq('max-age=31536000, public, immutable')
+        expect(attributes).not_to have_key(:expires)
+      end
+    end
+
+    context 'when a caching policy with only expires is in effect' do
+      before do
+        policy = Middleman::S3Sync::BrowserCachePolicy.new(expires: Time.utc(2030, 1, 1))
+        allow(Middleman::S3Sync).to receive(:caching_policy_for).and_return(policy)
+      end
+
+      it 'sets expires but omits cache_control' do
+        attributes = resource.to_h
+
+        expect(attributes[:expires]).to eq(CGI.rfc1123_date(Time.utc(2030, 1, 1)))
+        expect(attributes).not_to have_key(:cache_control)
+      end
+    end
+
+    context 'when a caching policy sets both max_age and expires' do
+      before do
+        policy = Middleman::S3Sync::BrowserCachePolicy.new(max_age: 300, expires: Time.utc(2030, 1, 1))
+        allow(Middleman::S3Sync).to receive(:caching_policy_for).and_return(policy)
+      end
+
+      it 'emits cache_control and suppresses the redundant expires' do
+        attributes = resource.to_h
+
+        expect(attributes[:cache_control]).to eq('max-age=300')
+        expect(attributes).not_to have_key(:expires)
+      end
+    end
+
     context 'when resource has a redirect' do
       let(:mm_resource) do
         double(

data/spec/caching_policy_spec.rb

@@ -17,6 +17,7 @@ describe Middleman::S3Sync::BrowserCachePolicy do
       expect(policy.to_s).to_not match /no-store/
       expect(policy.to_s).to_not match /must-revalidate/
       expect(policy.to_s).to_not match /proxy-revalidate/
+      expect(policy.to_s).to_not match /immutable/
       expect(policy.expires).to eq nil
     end
 
@@ -62,6 +63,19 @@ describe Middleman::S3Sync::BrowserCachePolicy do
       its(:to_s) { is_expected.to match /proxy-revalidate/ }
     end
 
+    context "setting the immutable flag" do
+      let(:options) { { immutable: true } }
+      its(:to_s) { is_expected.to match /immutable/ }
+    end
+
+    context "combining max_age, public, and immutable for hashed assets" do
+      let(:options) { { max_age: 31536000, public: true, immutable: true } }
+
+      it "emits the directives in policy order" do
+        expect(policy.to_s).to eq "max-age=31536000, public, immutable"
+      end
+    end
+
     context "divide caching policiies with a comma and a space" do
       let(:options) { { :max_age => 300, :public => true } }
 
@@ -74,9 +88,20 @@ describe Middleman::S3Sync::BrowserCachePolicy do
     end
 
     context "set the expiration date" do
-      let(:options) { { expires: 1.years.from_now } }
+      let(:expires_at) { Time.utc(2030, 1, 1) }
+      let(:options) { { expires: expires_at } }
+
+      its(:expires) { is_expected.to eq CGI.rfc1123_date(expires_at) }
+    end
+
+    context "max_age suppresses the Expires header" do
+      let(:options) { { max_age: 300, expires: Time.utc(2030, 1, 1) } }
+
+      it "still emits max-age in cache_control" do
+        expect(policy.to_s).to match /max-age=300/
+      end
 
-      its(:expires) { is_expected.to eq CGI.rfc1123_date(1.year.from_now )}
+      its(:expires) { is_expected.to be_nil }
     end
   end
 end

data/spec/resource_spec.rb

@@ -182,6 +182,212 @@ describe Middleman::S3Sync::Resource do
     end
   end
 
+  context 'content type detection' do
+    context 'when mm_resource provides content_type' do
+      subject(:resource) { Middleman::S3Sync::Resource.new(mm_resource, nil) }
+
+      let(:mm_resource) {
+        double(
+          destination_path: 'path/to/file.html',
+          content_type: 'text/html'
+        )
+      }
+
+      before do
+        allow(File).to receive(:exist?).with('build/path/to/file.html').and_return(true)
+        allow(File).to receive(:read).with('build/path/to/file.html').and_return('content')
+      end
+
+      it 'uses the content_type from mm_resource' do
+        expect(resource.content_type).to eq 'text/html'
+      end
+    end
+
+    context 'when mm_resource is nil (orphan file)' do
+      subject(:resource) { Middleman::S3Sync::Resource.new(nil, remote) }
+
+      let(:remote) { mock_s3_object('path/to/file.webp') }
+
+      before do
+        resource.full_s3_resource = remote
+        allow(File).to receive(:exist?).with('build/path/to/file.webp').and_return(true)
+        allow(File).to receive(:read).with('build/path/to/file.webp').and_return('content')
+      end
+
+      it 'falls back to mime-types for known extensions' do
+        expect(resource.content_type).to eq 'image/webp'
+      end
+    end
+
+    context 'when mm_resource has nil content_type' do
+      subject(:resource) { Middleman::S3Sync::Resource.new(mm_resource, nil) }
+
+      let(:mm_resource) {
+        double(
+          destination_path: 'path/to/image.svg',
+          content_type: nil
+        )
+      }
+
+      before do
+        allow(File).to receive(:exist?).with('build/path/to/image.svg').and_return(true)
+        allow(File).to receive(:read).with('build/path/to/image.svg').and_return('content')
+      end
+
+      it 'falls back to mime-types' do
+        expect(resource.content_type).to eq 'image/svg+xml'
+      end
+    end
+
+    context 'when content_types option is set' do
+      subject(:resource) { Middleman::S3Sync::Resource.new(mm_resource, nil) }
+
+      let(:mm_resource) {
+        double(
+          destination_path: 'path/to/data.custom',
+          content_type: nil
+        )
+      }
+
+      before do
+        allow(File).to receive(:exist?).with('build/path/to/data.custom').and_return(true)
+        allow(File).to receive(:read).with('build/path/to/data.custom').and_return('content')
+        options.content_types = { 'path/to/data.custom' => 'application/x-custom' }
+      end
+
+      it 'uses content_types option by path' do
+        expect(resource.content_type).to eq 'application/x-custom'
+      end
+    end
+
+    context 'when content_types option uses local_path key' do
+      subject(:resource) { Middleman::S3Sync::Resource.new(mm_resource, nil) }
+
+      let(:mm_resource) {
+        double(
+          destination_path: 'path/to/data.custom',
+          content_type: nil
+        )
+      }
+
+      before do
+        allow(File).to receive(:exist?).with('build/path/to/data.custom').and_return(true)
+        allow(File).to receive(:read).with('build/path/to/data.custom').and_return('content')
+        options.content_types = { 'build/path/to/data.custom' => 'application/x-custom-local' }
+      end
+
+      it 'uses content_types option by local_path' do
+        expect(resource.content_type).to eq 'application/x-custom-local'
+      end
+    end
+
+    context 'when extension is unknown' do
+      subject(:resource) { Middleman::S3Sync::Resource.new(mm_resource, nil) }
+
+      let(:mm_resource) {
+        double(
+          destination_path: 'path/to/file.unknownext123',
+          content_type: nil
+        )
+      }
+
+      before do
+        allow(File).to receive(:exist?).with('build/path/to/file.unknownext123').and_return(true)
+        allow(File).to receive(:read).with('build/path/to/file.unknownext123').and_return('content')
+      end
+
+      it 'defaults to application/octet-stream' do
+        expect(resource.content_type).to eq 'application/octet-stream'
+      end
+    end
+  end
+
+  context 'a resource with explicit path (orphan file)' do
+    subject(:resource) { Middleman::S3Sync::Resource.new(nil, nil, path: 'orphan/file.webp') }
+
+    before do
+      allow(File).to receive(:exist?).with('build/orphan/file.webp').and_return(true)
+      allow(File).to receive(:exist?).with('build/orphan/file.webp.gz').and_return(false)
+      allow(File).to receive(:read).with('build/orphan/file.webp').and_return('content')
+      allow(File).to receive(:directory?).with('build/orphan/file.webp').and_return(false)
+      
+      # Mock the bucket to return NotFound for head request (file doesn't exist on S3)
+      mock_object = instance_double(Aws::S3::Object)
+      allow(mock_object).to receive(:head).and_raise(Aws::S3::Errors::NotFound.new(nil, 'Not Found'))
+      allow(bucket).to receive(:object).with('orphan/file.webp').and_return(mock_object)
+    end
+
+    its(:path) { is_expected.to eq 'orphan/file.webp' }
+    its(:local_path) { is_expected.to eq 'build/orphan/file.webp' }
+    its(:status) { is_expected.to eq :new }
+
+    it 'detects content type via mime-types' do
+      expect(resource.content_type).to eq 'image/webp'
+    end
+  end
+
+  context 'redirect preservation' do
+    context 'remote-only redirect (no local file)' do
+      subject(:resource) { Middleman::S3Sync::Resource.new(nil, remote) }
+
+      let(:remote) do
+        double(
+          key: 'old-page.html',
+          metadata: {},
+          etag: '"abc123"',
+          content_encoding: nil,
+          cache_control: nil,
+          website_redirect_location: '/new-page.html'
+        )
+      end
+
+      before do
+        allow(File).to receive(:exist?).with('build/old-page.html').and_return(false)
+        resource.full_s3_resource = remote
+      end
+
+      it 'detects as a redirect' do
+        expect(resource.redirect?).to be true
+      end
+
+      its(:status) { is_expected.to eq :ignored }
+
+      it 'is not marked for deletion' do
+        expect(resource.to_delete?).to be false
+      end
+    end
+
+    context 'remote file without redirect (no local file)' do
+      subject(:resource) { Middleman::S3Sync::Resource.new(nil, remote) }
+
+      let(:remote) do
+        double(
+          key: 'deleted-page.html',
+          metadata: {},
+          etag: '"abc123"',
+          content_encoding: nil,
+          cache_control: nil,
+          website_redirect_location: nil
+        )
+      end
+
+      before do
+        allow(File).to receive(:exist?).with('build/deleted-page.html').and_return(false)
+        resource.full_s3_resource = remote
+      end
+
+      it 'is not a redirect' do
+        expect(resource.redirect?).to be_falsey
+      end
+
+      its(:status) { is_expected.to eq :deleted }
+
+      it 'is marked for deletion' do
+        expect(resource.to_delete?).to be true
+      end
+    end
+  end
+
   context 'An ignored resource' do
     context "that is local" do