carrierwave-aws 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eabbf546103220f4d72ac4cb88312212acbd0708
-  data.tar.gz: 94f36bbc4a81f108336a9628f9cb714bb3bb08a6
+  metadata.gz: dbc243216be54ab5f7e5ab0adeda6c6d61beea1e
+  data.tar.gz: ce824a3dbf900b615bfc58c1bb0ebbc6b92d9b6e
 SHA512:
-  metadata.gz: 657e1f08cf52b24282a10e9d4dd46850a22a4944fb0408c33cb5b42e4e36ff1a3b834f9ecac67fb91183ac6ab06f425058d4aaea22219b85c563880cbaa97455
-  data.tar.gz: 785e58e18a6810a419729dc2486b8e9e652f7765cb962402f2bdd76c0163ba60d15d4f3cbb9b7c892b5ab9b84fe8126e2f9cab9396cef4f3d3a21db4b05a4e78
+  metadata.gz: 0bc524f441434927eeed0303ddc4001afbe9d347c25e92fb319ad67545810b62d6e5c4efd4a6782d55253f97c3bfaf85ac43a5e7e7cf30f0382e54357b8dc1da
+  data.tar.gz: d23855a85418360efe6cfcfd837c0cd1668c2bd7299ba65b68885f7099c873fd6c2e11054b5f303f9f5fa602aa09f45302953c6776b838a9369b4fb68865daed

data/.env.sample

@@ -1,3 +1,4 @@
 S3_BUCKET_NAME=BUCKET_NAME
 S3_ACCESS_KEY=YOUR_KEY
 S3_SECRET_ACCESS_KEY=YOUR_KEY
+S3_REGION=BUCKET_REGION

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## Version 0.5.0 2015-01-31
+
+* Change: Nudge the expected AWS-SDK version.
+* Fix `exists?` method of AWS::File (previously it always returned true)
+  [Felix Bünemann]
+* Fix `filename` method of AWS::File for private files and remove url encoding.
+  [Felix Bünemann]
+
 ## Version 0.4.1 2014-03-28
 
 * Fix regression in `aws_read_options` defaulting to `nil` rather than an empty

data/README.md

@@ -37,14 +37,14 @@ the use of `aws_bucket` instead of `fog_directory`, and `aws_acl` instead of
 ```ruby
 CarrierWave.configure do |config|
   config.storage    = :aws
-  config.aws_bucket = ENV['S3_BUCKET_NAME']
+  config.aws_bucket = ENV.fetch('S3_BUCKET_NAME')
   config.aws_acl    = :public_read
   config.asset_host = 'http://example.com'
   config.aws_authenticated_url_expiration = 60 * 60 * 24 * 365
 
   config.aws_credentials = {
-    access_key_id:     ENV['AWS_ACCESS_KEY_ID'],
-    secret_access_key: ENV['AWS_SECRET_ACCESS_KEY']
+    access_key_id:     ENV.fetch('AWS_ACCESS_KEY_ID'),
+    secret_access_key: ENV.fetch('AWS_SECRET_ACCESS_KEY')
   }
 end
 ```
@@ -65,6 +65,23 @@ through `aws-sdk` gem. Browse [Amazon docs](http://docs.aws.amazon.com/AWSRubySD
 for additional info. For example, if you want to turn off SSL for your asset
 URLs, you could simply set `AWS.config(use_ssl: false)`.
 
+### Custom options for AWS URLs
+
+If you have a custom uploader that specifies additional headers for each URL, please try the following example:
+
+```ruby
+  class MyUploader < Carrierwave::Uploader::Base
+    # You can find full list of custom headers in AWS SDK documentation on
+    # AWS::S3::S3Object
+    def download_url(filename)
+      url(response_content_disposition: %Q{attachment; filename="#{filename}"})
+    end
+  end
+```
+
+If you migrate from `fog` you probably have something like `url(query: {'my-header': 'my-value'})`.
+With `carrierwave-aws` the `query` part becomes obsolete, just use a hash of headers.
+
 ## Contributing
 
 In order to run the integration specs you will need to configure some

data/carrierwave-aws.gemspec

@@ -16,8 +16,8 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(spec)/})
   gem.require_paths = ['lib']
 
-  gem.add_dependency 'carrierwave', '>= 0.7'
-  gem.add_dependency 'aws-sdk',     '>= 1.29'
+  gem.add_dependency 'carrierwave', '~> 0.7'
+  gem.add_dependency 'aws-sdk',     '~> 1.58'
 
-  gem.add_development_dependency 'rspec', '~> 2.14'
+  gem.add_development_dependency 'rspec', '~> 3'
 end

data/lib/carrierwave-aws.rb

@@ -1,6 +1,7 @@
 require 'carrierwave'
 require 'carrierwave/aws/version'
 require 'carrierwave/storage/aws'
+require 'carrierwave/storage/aws_file'
 
 class CarrierWave::Uploader::Base
   add_config :aws_attributes

data/lib/carrierwave/aws/version.rb

@@ -1,5 +1,5 @@
 module Carrierwave
   module AWS
-    VERSION = '0.4.1'
+    VERSION = '0.5.0'
   end
 end

data/lib/carrierwave/storage/aws.rb

@@ -12,117 +12,23 @@ module CarrierWave
       end
 
       def store!(file)
-        File.new(uploader, connection, uploader.store_path).tap do |aws_file|
+        AWSFile.new(uploader, connection, uploader.store_path).tap do |aws_file|
           aws_file.store(file)
         end
       end
 
       def retrieve!(identifier)
-        File.new(uploader, connection, uploader.store_path(identifier))
+        AWSFile.new(uploader, connection, uploader.store_path(identifier))
       end
 
       def connection
         @connection ||= begin
-          credentials = uploader.aws_credentials
-          self.class.connection_cache[credentials] ||= ::AWS::S3.new(credentials)
+          self.class.connection_cache[credentials] ||= ::AWS::S3.new(*credentials)
         end
       end
 
-      class File
-        attr_writer :content_type
-        attr_reader :uploader, :connection, :path
-
-        def initialize(uploader, connection, path)
-          @uploader   = uploader
-          @connection = connection
-          @path       = path
-        end
-
-        def attributes
-          file.attributes
-        end
-
-        def content_type
-          @content_type || file.content_type
-        end
-
-        def delete
-          file.delete
-        end
-
-        def extension
-          path.split('.').last
-        end
-
-        def exists?
-          !!file
-        end
-
-        def filename(options = {})
-          if file_url = url(options)
-            file_url.gsub(/.*\/(.*?$)/, '\1')
-          end
-        end
-
-        def read
-          file.read(uploader_read_options)
-        end
-
-        def size
-          file.content_length
-        end
-
-        def store(new_file)
-          @file = bucket.objects[path].write(uploader_write_options(new_file))
-
-          true
-        end
-
-        def to_file
-          file
-        end
-
-        def url(options = {})
-          if uploader.aws_acl != :public_read
-            authenticated_url(options)
-          else
-            public_url
-          end
-        end
-
-        def authenticated_url(options = {})
-          file.url_for(:read, { expires: uploader.aws_authenticated_url_expiration }.merge(options)).to_s
-        end
-
-        def public_url
-          if uploader.asset_host
-            "#{uploader.asset_host}/#{path}"
-          else
-            file.public_url.to_s
-          end
-        end
-
-        def uploader_read_options
-          uploader.aws_read_options || {}
-        end
-
-        def uploader_write_options(new_file)
-          {
-            acl:          uploader.aws_acl,
-            content_type: new_file.content_type,
-            file:         new_file.path
-          }.merge(uploader.aws_attributes || {}).merge(uploader.aws_write_options || {})
-        end
-
-        private
-
-        def bucket
-          @bucket ||= connection.buckets[uploader.aws_bucket]
-        end
-
-        def file
-          @file ||= bucket.objects[path]
-        end
+      def credentials
+        [uploader.aws_credentials].compact
       end
     end
   end

data/lib/carrierwave/storage/aws_file.rb

@@ -0,0 +1,116 @@
+module CarrierWave
+  module Storage
+    class AWSFile
+      attr_writer :content_type
+      attr_reader :uploader, :connection, :path
+
+      def initialize(uploader, connection, path)
+        @uploader   = uploader
+        @connection = connection
+        @path       = path
+      end
+
+      def attributes
+        file.head.data
+      end
+
+      def content_type
+        @content_type || file.content_type
+      end
+
+      def delete
+        file.delete
+      end
+
+      def extension
+        path.split('.').last
+      end
+
+      def exists?
+        file.exists?
+      end
+
+      def filename(options = {})
+        if file_url = url(options)
+          URI.decode(file_url.split('?').first).gsub(/.*\/(.*?$)/, '\1')
+        end
+      end
+
+      def read
+        file.read(uploader_read_options)
+      end
+
+      def size
+        file.content_length
+      end
+
+      def store(new_file)
+        @file = bucket.objects[path].write(uploader_write_options(new_file))
+
+        true
+      end
+
+      def to_file
+        file
+      end
+
+      def url(options = {})
+        if uploader.aws_acl != :public_read
+          authenticated_url(options)
+        else
+          public_url
+        end
+      end
+
+      def authenticated_url(options = {})
+        file.url_for(:read, { expires: uploader.aws_authenticated_url_expiration }.merge(options)).to_s
+      end
+
+      def public_url
+        if uploader.asset_host
+          "#{uploader.asset_host}/#{path}"
+        else
+          file.public_url.to_s
+        end
+      end
+
+      def copy_to(new_path)
+        file.copy_to(bucket.objects[new_path], uploader_copy_options)
+      end
+
+      def uploader_read_options
+        uploader.aws_read_options || {}
+      end
+
+      def uploader_write_options(new_file)
+        aws_attributes    = uploader.aws_attributes    || {}
+        aws_write_options = uploader.aws_write_options || {}
+
+        { acl:          uploader.aws_acl,
+          content_type: new_file.content_type,
+          file:         new_file.path
+        }.merge(aws_attributes).merge(aws_write_options)
+      end
+
+      def uploader_copy_options
+        aws_write_options = uploader.aws_write_options || {}
+
+        storage_options = aws_write_options.select do |key,_|
+          [:reduced_redundancy, :storage_class, :server_side_encryption].include?(key)
+        end
+
+        { acl: uploader.aws_acl }.merge(storage_options)
+      end
+
+      private
+
+      def bucket
+        @bucket ||= connection.buckets[uploader.aws_bucket]
+      end
+
+      def file
+        @file ||= bucket.objects[path]
+      end
+    end
+  end
+end

data/spec/carrierwave-aws_spec.rb

@@ -2,12 +2,12 @@ require 'spec_helper'
 
 describe CarrierWave::Uploader::Base do
   it 'defines aws specific storage options' do
-    described_class.should respond_to(:aws_attributes)
+    expect(described_class).to respond_to(:aws_attributes)
   end
 
   it 'inserts aws as a known storage engine' do
     described_class.configure do |config|
-      config.storage_engines.should have_key(:aws)
+      expect(config.storage_engines).to have_key(:aws)
     end
   end
 end

data/spec/carrierwave/storage/aws_file_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+describe CarrierWave::Storage::AWSFile do
+  let(:objects)    { { 'files/1/file.txt' => file } }
+  let(:path)       { 'files/1/file.txt' }
+  let(:bucket)     { double(:bucket, objects: objects) }
+  let(:connection) { double(:connection, buckets: { 'example-com' => bucket }) }
+  let(:file)       { double(:file, read: '0101010', content_type: 'content/type', path: '/file/path') }
+
+  let(:uploader) do
+    double(:uploader,
+      aws_bucket: 'example-com',
+      aws_acl: :public_read,
+      aws_attributes: {},
+      asset_host: nil,
+      aws_read_options: { encryption_key: 'abc' },
+      aws_write_options: { encryption_key: 'def' }
+    )
+  end
+
+  subject(:aws_file) do
+    CarrierWave::Storage::AWSFile.new(uploader, connection, path)
+  end
+
+  describe '#exists?' do
+    it 'checks if the remote file object exists' do
+      expect(file).to receive(:exists?).and_return(true)
+
+      aws_file.exists?
+    end
+  end
+
+  describe '#read' do
+    it 'reads from the remote file object' do
+      expect(aws_file.read).to eq('0101010')
+    end
+  end
+
+  describe '#uploader_write_options' do
+    it 'includes acl, content_type, file, aws_attributes, and aws_write_options' do
+      expect(aws_file.uploader_write_options(file)).to eq(
+        acl:            :public_read,
+        content_type:   'content/type',
+        file:           '/file/path',
+        encryption_key: 'def'
+      )
+    end
+
+    it 'works if aws_attributes is nil' do
+      allow(uploader).to receive(:aws_attributes) { nil }
+
+      expect {
+        aws_file.uploader_write_options(file)
+      }.to_not raise_error
+    end
+
+    it 'works if aws_write_options is nil' do
+      allow(uploader).to receive(:aws_write_options) { nil }
+
+      expect {
+        aws_file.uploader_write_options(file)
+      }.to_not raise_error
+    end
+  end
+
+  describe '#uploader_read_options' do
+    it 'includes aws_read_options' do
+      expect(aws_file.uploader_read_options).to eq(encryption_key: 'abc')
+    end
+
+    it 'ensures that read options are a hash' do
+      allow(uploader).to receive(:aws_read_options) { nil }
+
+      expect(aws_file.uploader_read_options).to eq({})
+    end
+  end
+
+  describe '#to_file' do
+    it 'returns the internal file instance' do
+      expect(aws_file.to_file).to be(file)
+    end
+  end
+
+  describe '#authenticated_url' do
+    it 'requests a url for reading with the configured expiration' do
+      allow(uploader).to receive(:aws_authenticated_url_expiration) { 60 }
+
+      expect(file).to receive(:url_for).with(:read, expires: 60)
+
+      aws_file.authenticated_url
+    end
+
+    it 'requests a url for reading with custom options' do
+      allow(uploader).to receive(:aws_authenticated_url_expiration) { 60 }
+
+      expect(file).to receive(:url_for).with(:read, hash_including(response_content_disposition: 'attachment'))
+
+      aws_file.authenticated_url(response_content_disposition: 'attachment')
+    end
+  end
+
+  describe '#url' do
+    it 'requests a public url if acl is public readable' do
+      allow(uploader).to receive(:aws_acl) { :public_read }
+
+      expect(file).to receive(:public_url)
+
+      aws_file.url
+    end
+
+    it 'requests an authenticated url if acl is not public readable' do
+      allow(uploader).to receive(:aws_acl) { :private }
+      allow(uploader).to receive(:aws_authenticated_url_expiration) { 60 }
+
+      expect(file).to receive(:url_for)
+
+      aws_file.url
+    end
+
+    it 'uses the asset_host and file path if asset_host is set' do
+      allow(uploader).to receive(:aws_acl) { :public_read }
+      allow(uploader).to receive(:asset_host) { 'http://example.com' }
+
+      expect(aws_file.url).to eq('http://example.com/files/1/file.txt')
+    end
+  end
+
+  describe '#filename' do
+    it 'returns the filename from the url' do
+      expect(aws_file).to receive(:url).and_return('http://example.com/files/1/file%201.txt?foo=bar/baz.txt')
+
+      expect(aws_file.filename).to eq('file 1.txt')
+    end
+  end
+end

data/spec/carrierwave/storage/aws_spec.rb

@@ -13,119 +13,20 @@ describe CarrierWave::Storage::AWS do
   end
 
   describe '#connection' do
-    it 'instantiates a new connection' do
-      AWS::S3.should_receive(:new).with(credentials)
+    it 'instantiates a new connection with credentials' do
+      expect(AWS::S3).to receive(:new).with(credentials)
 
       storage.connection
     end
 
-    it 'caches connections by credentials' do
-      AWS::S3.should_receive(:new).with(credentials).and_return(double)
-
-      storage.connection.should === storage.connection
-    end
-  end
-end
-
-describe CarrierWave::Storage::AWS::File do
-  let(:objects)    { { 'files/1/file.txt' => file } }
-  let(:bucket)     { double(:bucket, objects: objects) }
-  let(:connection) { double(:connection, buckets: { 'example-com' => bucket }) }
-  let(:file)       { double(:file, read: '0101010', content_type: 'content/type', path: '/file/path') }
-  let(:uploader)   { double(:uploader, aws_bucket: 'example-com', aws_acl: :public_read, aws_attributes: {}, asset_host: nil, aws_read_options: { encryption_key: 'abc' }, aws_write_options: { encryption_key: 'def' }) }
-  let(:path)       { 'files/1/file.txt' }
-
-  subject(:aws_file) do
-    CarrierWave::Storage::AWS::File.new(uploader, connection, path)
-  end
-
-  describe '#read' do
-    it 'reads from the remote file object' do
-      aws_file.read.should == '0101010'
-    end
-  end
-
-  describe '#uploader_write_options' do
-    it 'includes acl, content_type, file, aws_attributes, and aws_write_options' do
-      aws_file.uploader_write_options(file).should == {
-        acl: :public_read,
-        content_type: 'content/type',
-        file: '/file/path',
-        encryption_key: 'def'
-      }
-    end
-
-    it 'works if aws_attributes is nil' do
-      uploader.stub(:aws_attributes) { nil }
-      expect {
-        aws_file.uploader_write_options(file)
-      }.to_not raise_error
-    end
-
-    it 'works if aws_write_options is nil' do
-      uploader.stub(:aws_write_options) { nil }
-      expect {
-        aws_file.uploader_write_options(file)
-      }.to_not raise_error
-    end
-  end
-
-  describe '#uploader_read_options' do
-    it 'includes aws_read_options' do
-      aws_file.uploader_read_options.should == { encryption_key: 'abc' }
-    end
-
-    it 'ensures that read options are a hash' do
-      uploader.stub(:aws_read_options) { nil }
-      aws_file.uploader_read_options.should == {}
-    end
-  end
+    it 'instantiates a new connection without any credentials' do
+      allow(uploader).to receive(:aws_credentials) { nil }
 
-  describe '#to_file' do
-    it 'returns the internal file instance' do
-      aws_file.to_file.should be(file)
+      expect { storage.connection }.not_to raise_exception
     end
-  end
 
-  describe '#authenticated_url' do
-    it 'requests a url for reading with the configured expiration' do
-      uploader.stub(aws_authenticated_url_expiration: 60)
-
-      file.should_receive(:url_for).with(:read, expires: 60)
-
-      aws_file.authenticated_url
-    end
-
-    it 'requests a url for reading with custom options' do
-      uploader.stub(aws_authenticated_url_expiration: 60)
-
-      file.should_receive(:url_for).with(:read, hash_including(response_content_disposition: 'attachment'))
-
-      aws_file.authenticated_url(response_content_disposition: 'attachment')
-    end
-  end
-
-  describe '#url' do
-    it 'requests a public url if acl is public readable' do
-      uploader.stub(aws_acl: :public_read)
-      file.should_receive(:public_url)
-
-      aws_file.url
-    end
-
-    it 'requests an authenticated url if acl is not public readable' do
-      uploader.stub(aws_acl: :private, aws_authenticated_url_expiration: 60)
-
-      file.should_receive(:url_for)
-
-      aws_file.url
-    end
-
-    it 'uses the asset_host and file path if asset_host is set' do
-      uploader.stub(aws_acl: :public_read)
-      uploader.stub(asset_host: 'http://example.com')
-
-      aws_file.url.should eql 'http://example.com/files/1/file.txt'
+    it 'caches connections by credentials' do
+      expect(storage.connection).to eq(storage.connection)
     end
   end
 end

data/spec/features/copying_files_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe 'Copying Files', type: :feature do
+  it 'copies an existing file to the specified path' do
+    uploader = Class.new(CarrierWave::Uploader::Base) do
+      def filename; 'image.png'; end
+    end
+
+    image    = File.open('spec/fixtures/image.png', 'r')
+    original = uploader.new
+
+    original.store!(image)
+    original.retrieve_from_store!('image.png')
+
+    original.file.copy_to('uploads/image2.png')
+
+    copy = uploader.new
+    copy.retrieve_from_store!('image2.png')
+
+    original_attributes = original.file.attributes
+    original_attributes.reject! { |k,v| k == :last_modified }
+
+    copy_attributes = copy.file.attributes
+    copy_attributes.reject! { |k,v| k == :last_modified }
+
+    expect(copy_attributes).to eq(original_attributes)
+
+    image.close
+    original.file.delete
+    copy.file.delete
+  end
+end
+

data/spec/features/querying_files_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe 'Querying Files', type: :feature do
+  it 'retrieves the attributes for a stored file' do
+    uploader = Class.new(CarrierWave::Uploader::Base) do
+      def filename; 'image.png'; end
+    end
+
+    image    = File.open('spec/fixtures/image.png', 'r')
+    instance = uploader.new
+
+    instance.store!(image)
+    instance.retrieve_from_store!('image.png')
+
+    expect(instance.file.attributes).to include(
+      :meta,
+      :restore_in_progress,
+      :content_type,
+      :etag,
+      :accept_ranges,
+      :last_modified,
+      :content_length
+    )
+
+    image.close
+    instance.file.delete
+  end
+
+  it 'checks if a remote file exists' do
+    uploader = Class.new(CarrierWave::Uploader::Base) do
+      def filename; 'image.png'; end
+    end
+
+    image    = File.open('spec/fixtures/image.png', 'r')
+    instance = uploader.new
+
+    instance.store!(image)
+    instance.retrieve_from_store!('image.png')
+
+    expect(instance.file.exists?).to be true
+
+    instance.file.delete
+
+    expect(instance.file.exists?).to be false
+
+    image.close
+  end
+end

data/spec/features/storing_files_spec.rb

@@ -1,33 +1,21 @@
 require 'spec_helper'
 
-if ENV['S3_BUCKET_NAME']
-  describe 'Storing Files' do
-    before(:all) do
-      CarrierWave.configure do |config|
-        config.storage    = :aws
-        config.aws_bucket = ENV['S3_BUCKET_NAME']
-        config.aws_acl    = :public_read
-
-        config.aws_credentials = {
-          access_key_id:     ENV['S3_ACCESS_KEY'],
-          secret_access_key: ENV['S3_SECRET_ACCESS_KEY']
-        }
-      end
+describe 'Storing Files', type: :feature do
+  it 'uploads the file to the configured bucket' do
+    uploader = Class.new(CarrierWave::Uploader::Base) do
+      def filename; 'image.png'; end
     end
 
-    it 'uploads the file to the configured bucket' do
-      uploader = Class.new(CarrierWave::Uploader::Base) do
-        def filename; 'image.png'; end
-      end
+    image    = File.open('spec/fixtures/image.png', 'r')
+    instance = uploader.new
 
-      image    = File.open('spec/fixtures/image.png', 'r')
-      instance = uploader.new
+    instance.store!(image)
+    instance.retrieve_from_store!('image.png')
 
-      instance.store!(image)
-      instance.retrieve_from_store!('image.png')
+    expect(instance.file.size).to be_nonzero
+    expect(image.size).to eq(instance.file.size)
 
-      expect(instance.file.size).to be_nonzero
-      expect(image.size).to eq(instance.file.size)
-    end
+    image.close
+    instance.file.delete
   end
 end

data/spec/spec_helper.rb

@@ -1,4 +1,3 @@
-require 'rspec'
 require 'carrierwave'
 require 'carrierwave-aws'
 
@@ -12,10 +11,34 @@ def source_environment_file!
 end
 
 RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
+  source_environment_file!
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
   config.filter_run :focus
-  config.order = 'random'
+  config.filter_run_excluding type: :feature unless ENV.key?('S3_BUCKET_NAME')
   config.run_all_when_everything_filtered = true
+  config.order = :random
 
-  source_environment_file!
+  if config.files_to_run.one?
+    config.default_formatter = 'doc'
+  end
+
+  Kernel.srand config.seed
+
+  config.before(:all, type: :feature) do
+    CarrierWave.configure do |config|
+      config.storage    = :aws
+      config.aws_bucket = ENV['S3_BUCKET_NAME']
+      config.aws_acl    = :public_read
+
+      config.aws_credentials = {
+        access_key_id:     ENV['S3_ACCESS_KEY'],
+        secret_access_key: ENV['S3_SECRET_ACCESS_KEY'],
+        region:            ENV['S3_REGION']
+      }
+    end
+  end
 end

metadata

@@ -1,57 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: carrierwave-aws
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Parker Selbert
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-28 00:00:00.000000000 Z
+date: 2015-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: carrierwave
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.7'
 - !ruby/object:Gem::Dependency
   name: aws-sdk
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.29'
+        version: '1.58'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.29'
+        version: '1.58'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.14'
+        version: '3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.14'
+        version: '3'
 description: Use aws-sdk for S3 support in CarrierWave
 email:
 - parker@sorentwo.com
@@ -72,8 +72,12 @@ files:
 - lib/carrierwave-aws.rb
 - lib/carrierwave/aws/version.rb
 - lib/carrierwave/storage/aws.rb
+- lib/carrierwave/storage/aws_file.rb
 - spec/carrierwave-aws_spec.rb
+- spec/carrierwave/storage/aws_file_spec.rb
 - spec/carrierwave/storage/aws_spec.rb
+- spec/features/copying_files_spec.rb
+- spec/features/querying_files_spec.rb
 - spec/features/storing_files_spec.rb
 - spec/fixtures/image.png
 - spec/spec_helper.rb
@@ -96,13 +100,16 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: A slimmer alternative to using Fog for S3 support in CarrierWave
 test_files:
 - spec/carrierwave-aws_spec.rb
+- spec/carrierwave/storage/aws_file_spec.rb
 - spec/carrierwave/storage/aws_spec.rb
+- spec/features/copying_files_spec.rb
+- spec/features/querying_files_spec.rb
 - spec/features/storing_files_spec.rb
 - spec/fixtures/image.png
 - spec/spec_helper.rb