dragonfly-s3_data_store 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: de4b096e174cc3386bcdb840d6f942b94f8cbb6d
+  data.tar.gz: d11b8ef53ce003bf73b24c0db94c70a5fd0e5684
+SHA512:
+  metadata.gz: 19319c9981cf83aed2f8147b568535afbc35de43c405ee2148e283b375870a9dc5d414085ad1b1679934e011988027fc2c20455b1485cb130ada64b16eac0e09
+  data.tar.gz: 81ee661b5d3c8a0fe7d6f39da1e8cd1c4ba59c9b36ed1c6ee9cd0a14008c27d87667870d70e98625b99ba43d5b154a5f2721defbc1bbbda646cc3f2331fd54a8

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.s3_spec.yml
+

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Mark Evans
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,90 @@
+# Dragonfly::S3DataStore
+
+Amazon AWS S3 data store for use with the [Dragonfly](http://github.com/markevans/dragonfly) gem.
+
+## Gemfile
+
+```ruby
+gem 'dragonfly-s3_data_store'
+```
+
+## Usage
+
+In your dragonfly config block (with default options):
+
+```ruby
+Dragonfly.app.configure do
+  # ...
+
+  datastore :s3,
+    bucket_name: 'my-bucket',
+    access_key_id: 'blahblahblah',
+    secret_access_key: 'blublublublu'
+
+  # ...
+end
+```
+
+### Available configuration options
+
+```ruby
+:bucket_name
+:access_key_id
+:secret_access_key
+:region               # default 'us-east-1', see Dragonfly::S3DataStore::REGIONS for options
+:storage_headers      # defaults to {'x-amz-acl' => 'public-read'}, can be overridden per-write - see below
+:url_scheme           # defaults to "http"
+:url_host             # defaults to "<bucket-name>.s3.amazonaws.com"
+:use_iam_profile      # boolean - if true, no need for access_key_id or secret_access_key
+```
+
+### Per-storage options
+```ruby
+Dragonfly.app.store(some_file, path: 'some/path.txt', headers: {'x-amz-acl' => 'public-read-write'})
+```
+
+or
+
+```ruby
+class MyModel
+  dragonfly_accessor :photo do
+    storage_path { "some/path/#{some_instance_method}/#{rand(100)}" }
+    storage_headers { {"x-amz-acl" => "public-read-write"} }
+  end
+end
+```
+
+**BEWARE!!!!** you must make sure the path (which will become the uid for the content) is unique and changes each time the content
+is changed, otherwise you could have caching problems, as the generated urls will be the same for the same uid.
+
+### Serving directly from S3
+
+You can get the S3 url using
+
+```ruby
+Dragonfly.app.remote_url_for('some/uid')
+```
+
+or
+
+```ruby
+my_model.attachment.remote_url
+```
+
+or with an expiring url:
+
+```ruby
+my_model.attachment.remote_url(expires: 3.days.from_now)
+```
+
+or with an https url:
+
+```ruby
+my_model.attachment.remote_url(scheme: 'https')   # also configurable for all urls with 'url_scheme'
+```
+
+or with a custom host:
+
+```ruby
+my_model.attachment.remote_url(host: 'custom.domain')   # also configurable for all urls with 'url_host'
+```

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/dragonfly-s3_data_store.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dragonfly/s3_data_store/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "dragonfly-s3_data_store"
+  spec.version       = Dragonfly::S3DataStore::VERSION
+  spec.authors       = ["Mark Evans"]
+  spec.email         = ["mark@new-bamboo.co.uk"]
+  spec.description   = %q{S3 data store for Dragonfly}
+  spec.summary       = %q{Data store for storing Dragonfly content (e.g. images) on S3}
+  spec.homepage      = "https://github.com/markevans/dragonfly-s3_data_store"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "dragonfly", "~> 1.0"
+  spec.add_runtime_dependency "fog"
+  spec.add_development_dependency "rspec", "~> 2.0"
+end

data/lib/dragonfly/s3_data_store/version.rb

@@ -0,0 +1,5 @@
+module Dragonfly
+  module S3DataStore
+    VERSION = "1.0.0"
+  end
+end

data/lib/dragonfly/s3_data_store.rb

@@ -0,0 +1,164 @@
+require 'fog'
+require 'dragonfly'
+
+Dragonfly::App.register_datastore(:s3){ Dragonfly::S3DataStore }
+
+module Dragonfly
+  class S3DataStore
+
+    # Exceptions
+    class NotConfigured < RuntimeError; end
+
+    REGIONS = {
+      'us-east-1' => 's3.amazonaws.com',  #default
+      'us-west-1' => 's3-us-west-1.amazonaws.com',
+      'us-west-2' => 's3-us-west-2.amazonaws.com',
+      'ap-northeast-1' => 's3-ap-northeast-1.amazonaws.com',
+      'ap-southeast-1' => 's3-ap-southeast-1.amazonaws.com',
+      'eu-west-1' => 's3-eu-west-1.amazonaws.com',
+      'sa-east-1' => 's3-sa-east-1.amazonaws.com',
+      'sa-east-1' => 's3-sa-east-1.amazonaws.com'
+    }
+
+    def initialize(opts={})
+      @bucket_name       = opts[:bucket_name]
+      @access_key_id     = opts[:access_key_id]
+      @secret_access_key = opts[:secret_access_key]
+      @region            = opts[:region]
+      @storage_headers   = opts[:storage_headers] || {'x-amz-acl' => 'public-read'}
+      @url_scheme        = opts[:url_scheme] || 'http'
+      @url_host          = opts[:url_host]
+      @use_iam_profile   = opts[:use_iam_profile]
+    end
+
+    attr_accessor :bucket_name, :access_key_id, :secret_access_key, :region, :storage_headers, :url_scheme, :url_host, :use_iam_profile
+
+    def write(content, opts={})
+      ensure_configured
+      ensure_bucket_initialized
+
+      headers = {'Content-Type' => content.mime_type}
+      headers.merge!(opts[:headers]) if opts[:headers]
+      uid = opts[:path] || generate_uid(content.name || 'file')
+
+      rescuing_socket_errors do
+        content.file do |f|
+          storage.put_object(bucket_name, uid, f, full_storage_headers(headers, content.meta))
+        end
+      end
+
+      uid
+    end
+
+    def read(uid)
+      ensure_configured
+      response = rescuing_socket_errors{ storage.get_object(bucket_name, uid) }
+      [response.body, headers_to_meta(response.headers)]
+    rescue Excon::Errors::NotFound => e
+      nil
+    end
+
+    def destroy(uid)
+      rescuing_socket_errors{ storage.delete_object(bucket_name, uid) }
+    rescue Excon::Errors::NotFound, Excon::Errors::Conflict => e
+      Dragonfly.warn("#{self.class.name} destroy error: #{e}")
+    end
+
+    def url_for(uid, opts={})
+      if opts && opts[:expires]
+        storage.get_object_https_url(bucket_name, uid, opts[:expires])
+      else
+        scheme = opts[:scheme] || url_scheme
+        host   = opts[:host]   || url_host || "#{bucket_name}.s3.amazonaws.com"
+        "#{scheme}://#{host}/#{uid}"
+      end
+    end
+
+    def domain
+      REGIONS[get_region]
+    end
+
+    def storage
+      @storage ||= begin
+        storage = Fog::Storage.new({
+          :provider => 'AWS',
+          :aws_access_key_id => access_key_id,
+          :aws_secret_access_key => secret_access_key,
+          :region => region,
+          :use_iam_profile => use_iam_profile
+        }.reject {|name, option| option.nil?})
+        storage.sync_clock
+        storage
+      end
+    end
+
+    def bucket_exists?
+      rescuing_socket_errors{ storage.get_bucket_location(bucket_name) }
+      true
+    rescue Excon::Errors::NotFound => e
+      false
+    end
+
+    private
+
+    def ensure_configured
+      unless @configured
+        if use_iam_profile
+          raise NotConfigured, "You need to configure #{self.class.name} with bucket_name" if bucket_name.nil?
+        else
+          [:bucket_name, :access_key_id, :secret_access_key].each do |attr|
+            raise NotConfigured, "You need to configure #{self.class.name} with #{attr}" if send(attr).nil?
+          end
+        end
+        @configured = true
+      end
+    end
+
+    def ensure_bucket_initialized
+      unless @bucket_initialized
+        rescuing_socket_errors{ storage.put_bucket(bucket_name, 'LocationConstraint' => region) } unless bucket_exists?
+        @bucket_initialized = true
+      end
+    end
+
+    def get_region
+      reg = region || 'us-east-1'
+      raise "Invalid region #{reg} - should be one of #{valid_regions.join(', ')}" unless valid_regions.include?(reg)
+      reg
+    end
+
+    def generate_uid(name)
+      "#{Time.now.strftime '%Y/%m/%d/%H/%M/%S'}/#{rand(1000)}/#{name.gsub(/[^\w.]+/, '_')}"
+    end
+
+    def full_storage_headers(headers, meta)
+      storage_headers.merge(meta_to_headers(meta)).merge(headers)
+    end
+
+    def headers_to_meta(headers)
+      json = headers['x-amz-meta-json']
+      if json && !json.empty?
+        Serializer.json_decode(json)
+      elsif marshal_data = headers['x-amz-meta-extra']
+        Utils.stringify_keys(Serializer.marshal_b64_decode(marshal_data))
+      end
+    end
+
+    def meta_to_headers(meta)
+      {'x-amz-meta-json' => Serializer.json_encode(meta)}
+    end
+
+    def valid_regions
+      REGIONS.keys
+    end
+
+    def rescuing_socket_errors(&block)
+      yield
+    rescue Excon::Errors::SocketError => e
+      storage.reload
+      yield
+    end
+
+  end
+end
+

data/spec/s3_data_store_spec.rb

@@ -0,0 +1,286 @@
+require 'spec_helper'
+require 'dragonfly/spec/data_store_examples'
+require 'yaml'
+require 'dragonfly/s3_data_store'
+
+describe Dragonfly::S3DataStore do
+
+  # To run these tests, put a file ".s3_spec.yml" in the dragonfly root dir, like this:
+  # key: XXXXXXXXXX
+  # secret: XXXXXXXXXX
+  # enabled: true
+  if File.exist?(file = File.expand_path('../../.s3_spec.yml', __FILE__))
+    config = YAML.load_file(file)
+    KEY = config['key']
+    SECRET = config['secret']
+    enabled = config['enabled']
+  else
+    enabled = false
+  end
+
+  if enabled
+
+    # Make sure it's a new bucket name
+    BUCKET_NAME = "dragonfly-test-#{Time.now.to_i.to_s(36)}"
+
+    before(:each) do
+      @data_store = Dragonfly::S3DataStore.new(
+        :bucket_name => BUCKET_NAME,
+        :access_key_id => KEY,
+        :secret_access_key => SECRET,
+        :region => 'eu-west-1'
+      )
+    end
+
+  else
+
+    BUCKET_NAME = 'test-bucket'
+
+    before(:each) do
+      Fog.mock!
+      @data_store = Dragonfly::S3DataStore.new(
+        :bucket_name => BUCKET_NAME,
+        :access_key_id => 'XXXXXXXXX',
+        :secret_access_key => 'XXXXXXXXX',
+        :region => 'eu-west-1'
+      )
+    end
+
+  end
+
+  it_should_behave_like 'data_store'
+
+  let (:app) { Dragonfly.app }
+  let (:content) { Dragonfly::Content.new(app, "eggheads") }
+  let (:new_content) { Dragonfly::Content.new(app) }
+
+  describe "registering with a symbol" do
+    it "registers a symbol for configuring" do
+      app.configure do
+        datastore :s3
+      end
+      app.datastore.should be_a(Dragonfly::S3DataStore)
+    end
+  end
+
+  describe "write" do
+    it "should use the name from the content if set" do
+      content.name = 'doobie.doo'
+      uid = @data_store.write(content)
+      uid.should =~ /doobie\.doo$/
+      new_content.update(*@data_store.read(uid))
+      new_content.data.should == 'eggheads'
+    end
+
+    it "should work ok with files with funny names" do
+      content.name = "A Picture with many spaces in its name (at 20:00 pm).png"
+      uid = @data_store.write(content)
+      uid.should =~ /A_Picture_with_many_spaces_in_its_name_at_20_00_pm_\.png$/
+      new_content.update(*@data_store.read(uid))
+      new_content.data.should == 'eggheads'
+    end
+
+    it "should allow for setting the path manually" do
+      uid = @data_store.write(content, :path => 'hello/there')
+      uid.should == 'hello/there'
+      new_content.update(*@data_store.read(uid))
+      new_content.data.should == 'eggheads'
+    end
+
+    if enabled # Fog.mock! doesn't act consistently here
+      it "should reset the connection and try again if Fog throws a socket EOFError" do
+        @data_store.storage.should_receive(:put_object).exactly(:once).and_raise(Excon::Errors::SocketError.new(EOFError.new))
+        @data_store.storage.should_receive(:put_object).with(BUCKET_NAME, anything, anything, hash_including)
+        @data_store.write(content)
+      end
+
+      it "should just let it raise if Fog throws a socket EOFError again" do
+        @data_store.storage.should_receive(:put_object).and_raise(Excon::Errors::SocketError.new(EOFError.new))
+        @data_store.storage.should_receive(:put_object).and_raise(Excon::Errors::SocketError.new(EOFError.new))
+        expect{
+          @data_store.write(content)
+        }.to raise_error(Excon::Errors::SocketError)
+      end
+    end
+  end
+
+  describe "domain" do
+    it "should default to the US" do
+      @data_store.region = nil
+      @data_store.domain.should == 's3.amazonaws.com'
+    end
+
+    it "should return the correct domain" do
+      @data_store.region = 'eu-west-1'
+      @data_store.domain.should == 's3-eu-west-1.amazonaws.com'
+    end
+
+    it "does raise an error if an unknown region is given" do
+      @data_store.region = 'latvia-central'
+      lambda{
+        @data_store.domain
+      }.should raise_error
+    end
+  end
+
+  describe "not configuring stuff properly" do
+    it "should require a bucket name on write" do
+      @data_store.bucket_name = nil
+      proc{ @data_store.write(content) }.should raise_error(Dragonfly::S3DataStore::NotConfigured)
+    end
+
+    it "should require an access_key_id on write" do
+      @data_store.access_key_id = nil
+      proc{ @data_store.write(content) }.should raise_error(Dragonfly::S3DataStore::NotConfigured)
+    end
+
+    it "should require a secret access key on write" do
+      @data_store.secret_access_key = nil
+      proc{ @data_store.write(content) }.should raise_error(Dragonfly::S3DataStore::NotConfigured)
+    end
+
+    it "should require a bucket name on read" do
+      @data_store.bucket_name = nil
+      proc{ @data_store.read('asdf') }.should raise_error(Dragonfly::S3DataStore::NotConfigured)
+    end
+
+    it "should require an access_key_id on read" do
+      @data_store.access_key_id = nil
+      proc{ @data_store.read('asdf') }.should raise_error(Dragonfly::S3DataStore::NotConfigured)
+    end
+
+    it "should require a secret access key on read" do
+      @data_store.secret_access_key = nil
+      proc{ @data_store.read('asdf') }.should raise_error(Dragonfly::S3DataStore::NotConfigured)
+    end
+
+    if !enabled #this will fail since the specs are not running on an ec2 instance with an iam role defined
+      it 'should allow missing secret key and access key on write if iam profiles are allowed' do
+        # This is slightly brittle but it's annoying waiting for fog doing stuff
+        @data_store.storage.stub(:get_bucket_location => nil, :put_object => nil)
+
+        @data_store.use_iam_profile = true
+        @data_store.secret_access_key = nil
+        @data_store.access_key_id = nil
+        expect{ @data_store.write(content) }.not_to raise_error
+      end
+    end
+
+  end
+
+  describe "autocreating the bucket" do
+    it "should create the bucket on write if it doesn't exist" do
+      @data_store.bucket_name = "dragonfly-test-blah-blah-#{rand(100000000)}"
+      @data_store.write(content)
+    end
+
+    it "should not try to create the bucket on read if it doesn't exist" do
+      @data_store.bucket_name = "dragonfly-test-blah-blah-#{rand(100000000)}"
+      @data_store.send(:storage).should_not_receive(:put_bucket)
+      @data_store.read("gungle").should be_nil
+    end
+  end
+
+  describe "headers" do
+    before(:each) do
+      @data_store.storage_headers = {'x-amz-foo' => 'biscuithead'}
+    end
+
+    it "should allow configuring globally" do
+      @data_store.storage.should_receive(:put_object).with(BUCKET_NAME, anything, anything,
+        hash_including('x-amz-foo' => 'biscuithead')
+      )
+      @data_store.write(content)
+    end
+
+    it "should allow adding per-store" do
+      @data_store.storage.should_receive(:put_object).with(BUCKET_NAME, anything, anything,
+        hash_including('x-amz-foo' => 'biscuithead', 'hello' => 'there')
+      )
+      @data_store.write(content, :headers => {'hello' => 'there'})
+    end
+
+    it "should let the per-store one take precedence" do
+      @data_store.storage.should_receive(:put_object).with(BUCKET_NAME, anything, anything,
+        hash_including('x-amz-foo' => 'override!')
+      )
+      @data_store.write(content, :headers => {'x-amz-foo' => 'override!'})
+    end
+
+    it "should write setting the content type" do
+      @data_store.storage.should_receive(:put_object) do |_, __, ___, headers|
+        headers['Content-Type'].should == 'image/png'
+      end
+      content.name = 'egg.png'
+      @data_store.write(content)
+    end
+
+    it "allow overriding the content type" do
+      @data_store.storage.should_receive(:put_object) do |_, __, ___, headers|
+        headers['Content-Type'].should == 'text/plain'
+      end
+      content.name = 'egg.png'
+      @data_store.write(content, :headers => {'Content-Type' => 'text/plain'})
+    end
+  end
+
+  describe "urls for serving directly" do
+
+    before(:each) do
+      @uid = 'some/path/on/s3'
+    end
+
+    it "should use the bucket subdomain" do
+      @data_store.url_for(@uid).should == "http://#{BUCKET_NAME}.s3.amazonaws.com/some/path/on/s3"
+    end
+
+    it "should use the bucket subdomain for other regions too" do
+      @data_store.region = 'eu-west-1'
+      @data_store.url_for(@uid).should == "http://#{BUCKET_NAME}.s3.amazonaws.com/some/path/on/s3"
+    end
+
+    it "should give an expiring url" do
+      @data_store.url_for(@uid, :expires => 1301476942).should =~
+        %r{^https://#{BUCKET_NAME}\.#{@data_store.domain}/some/path/on/s3\?AWSAccessKeyId=#{@data_store.access_key_id}&Signature=[\w%]+&Expires=1301476942$}
+    end
+
+    it "should allow for using https" do
+      @data_store.url_for(@uid, :scheme => 'https').should == "https://#{BUCKET_NAME}.s3.amazonaws.com/some/path/on/s3"
+    end
+
+    it "should allow for always using https" do
+      @data_store.url_scheme = 'https'
+      @data_store.url_for(@uid).should == "https://#{BUCKET_NAME}.s3.amazonaws.com/some/path/on/s3"
+    end
+
+    it "should allow for customizing the host" do
+      @data_store.url_for(@uid, :host => 'customised.domain.com/and/path').should == "http://customised.domain.com/and/path/some/path/on/s3"
+    end
+
+    it "should allow the url_host to be customised permanently" do
+      url_host = 'customised.domain.com/and/path'
+      @data_store.url_host = url_host
+      @data_store.url_for(@uid).should == "http://#{url_host}/some/path/on/s3"
+    end
+
+  end
+
+  describe "meta" do
+    it "uses the x-amz-meta-json header for meta" do
+      uid = @data_store.write(content, :headers => {'x-amz-meta-json' => Dragonfly::Serializer.json_encode({'potato' => 44})})
+      c, meta = @data_store.read(uid)
+      meta['potato'].should == 44
+    end
+
+    it "works with the deprecated x-amz-meta-extra header (but stringifies its keys)" do
+      uid = @data_store.write(content, :headers => {
+        'x-amz-meta-extra' => Dragonfly::Serializer.marshal_b64_encode(:some => 'meta', :wo => 4),
+        'x-amz-meta-json' => nil
+      })
+      c, meta = @data_store.read(uid)
+      meta['some'].should == 'meta'
+      meta['wo'].should == 4
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+  config.order = 'random'
+end
+

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: dragonfly-s3_data_store
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Mark Evans
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dragonfly
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: fog
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: S3 data store for Dragonfly
+email:
+- mark@new-bamboo.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- dragonfly-s3_data_store.gemspec
+- lib/dragonfly/s3_data_store.rb
+- lib/dragonfly/s3_data_store/version.rb
+- spec/s3_data_store_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/markevans/dragonfly-s3_data_store
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.11
+signing_key: 
+specification_version: 4
+summary: Data store for storing Dragonfly content (e.g. images) on S3
+test_files:
+- spec/s3_data_store_spec.rb
+- spec/spec_helper.rb