dragonfly-dreamobjects_data_store 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 415b1f19d21f31b87b000ec7e5f130e32972a249
+  data.tar.gz: b6db7bca0ef9bbd22664f44aaf8212119efd8982
+SHA512:
+  metadata.gz: 2c7e01f6fff175a5fd6d2446f0eae3cd1108c404c3b1e3919ea53ba14ac2537224f94848d029ea2d177f72c6b4e465ecf67bfcb5afa22eea129426ab0cf1eeff
+  data.tar.gz: 6e33035098af475e2be56a66295d1287602254aa817d2509f2d0b77f22a0fbff84faa2785575bc4c151402fef86ee5b2449a95d90b920d13af31ed572fc27a7e

data/.gitignore

@@ -0,0 +1,35 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+.s3_spec.yml

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+gemspec
+
+gem 'pry'

data/Gemfile.lock

@@ -0,0 +1,54 @@
+PATH
+  remote: .
+  specs:
+    dragonfly-dreamobjects_data_store (0.0.1)
+      aws-sdk
+      dragonfly (~> 1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.3.6)
+    aws-sdk (1.59.0)
+      aws-sdk-v1 (= 1.59.0)
+    aws-sdk-v1 (1.59.0)
+      json (~> 1.4)
+      nokogiri (>= 1.4.4)
+    coderay (1.1.0)
+    diff-lcs (1.2.5)
+    dragonfly (1.0.7)
+      addressable (~> 2.3)
+      multi_json (~> 1.0)
+      rack
+    json (1.8.1)
+    method_source (0.8.2)
+    mini_portile (0.6.1)
+    multi_json (1.10.1)
+    nokogiri (1.6.4.1)
+      mini_portile (~> 0.6.0)
+    pry (0.10.1)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rack (1.5.2)
+    rspec (3.1.0)
+      rspec-core (~> 3.1.0)
+      rspec-expectations (~> 3.1.0)
+      rspec-mocks (~> 3.1.0)
+    rspec-core (3.1.7)
+      rspec-support (~> 3.1.0)
+    rspec-expectations (3.1.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.1.0)
+    rspec-mocks (3.1.3)
+      rspec-support (~> 3.1.0)
+    rspec-support (3.1.2)
+    slop (3.6.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  dragonfly-dreamobjects_data_store!
+  pry
+  rspec (~> 3.0)

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Gabriel Rios
+
+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,39 @@
+# Dragonfly::S3DataStore
+
+Dreamobjects data store for use with the [Dragonfly](http://github.com/markevans/dragonfly) gem.
+
+Heavily inspired on [Dragonfly::S3DataStore](http://github.com/markevans/dragonfly-s3_data_storage) gem
+
+## Gemfile
+
+```ruby
+gem 'dragonfly-dreamobjects_data_store'
+```
+
+## Usage
+Configuration (remember the require)
+
+```ruby
+require 'dragonfly/s3_data_store'
+
+Dragonfly.app.configure do
+  # ...
+
+  datastore :dreamobjects,
+    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
+:endpoint  # Dreamobjects Server URL
+```
+

data/Rakefile

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

data/dragonfly-dreamobjects_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/dreamobjects_data_store/version'
+
+Gem::Specification.new do |spec|
+  spec.name        = "dragonfly-dreamobjects_data_store"
+  spec.version     = Dragonfly::DreamobjectsDataStore::VERSION
+  spec.authors     = ["Gabriel Rios"]
+  spec.email       = ["gabrielfalcaorios@gmail.com"]
+  spec.description = %q{Dreamobjects data store for Dragonfly}
+  spec.summary     = %q{Data store for storing Dragonfly content (e.g. images) on S3}
+  spec.homepage    = "https://github.com/gabrielrios/dragonfly-dreamobjects_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 "aws-sdk"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/lib/dragonfly/dreamobjects_data_store.rb

@@ -0,0 +1,71 @@
+require 'aws'
+require 'pry'
+require 'dragonfly'
+
+Dragonfly::App.register_datastore(:dreamobjects) { Dragonfly::DreamobjectsDataStore }
+
+module Dragonfly
+  class DreamobjectsDataStore
+    def initialize(options = {})
+      @bucket_name       = options[:bucket_name]
+      @access_key_id     = options[:access_key_id]
+      @secret_access_key = options[:secret_access_key]
+      @endpoint          = options.fetch(:endpoint, 'objects.dreamhost.com')
+    end
+
+    def write(content, opts={})
+      uid = opts[:path] || generate_uid(content.name || 'file')
+      bucket.objects[uid].write(content.data,
+                                metadata: { json: Serializer.json_encode(content.meta)})
+      uid
+    end
+
+    # # Retrieve the data and meta as a 2-item array
+    def read(uid)
+      object = bucket.objects[uid]
+      data = object.read
+      meta = Serializer.json_decode(object.metadata[:json])
+        [
+          data,     # can be a String, File, Pathname, Tempfile
+          meta      # the same meta Hash that was stored with write
+        ]
+    end
+
+    def destroy(uid)
+      bucket.objects[uid].delete
+    end
+
+    def create_bucket(name)
+      storage.buckets.create(name)
+    end
+
+    private
+    def storage
+      @storage ||= AWS::S3.new(access_key_id: @access_key_id,
+                              secret_access_key: @secret_access_key,
+                              s3_endpoint: @endpoint,
+                              use_ssl: false,
+                              s3_force_path_style: true)
+    end
+
+    def bucket
+      @bucket ||= storage.buckets[@bucket_name]
+    end
+
+    def ensure_configured
+      unless @configured
+        [:bucket_name, :access_key_id, :secret_access_key].each do |attr|
+          if send(attr).nil?
+            raise NotConfigured, "You need to configure #{self.class.name} with #{attr}"
+          end
+        end
+      end
+      @configured = true
+    end
+
+    def generate_uid(name)
+      "#{Time.now.strftime '%Y/%m/%d/%H/%M/%S'}/#{rand(1000)}/#{name.gsub(/[^\w.]+/, '_')}"
+    end
+  end
+end
+

data/lib/dragonfly/dreamobjects_data_store/version.rb

@@ -0,0 +1,5 @@
+module Dragonfly
+  class DreamobjectsDataStore
+    VERSION = "0.0.1"
+  end
+end

data/spec/dreamobjects_data_store_spec.rb

@@ -0,0 +1,343 @@
+require 'spec_helper'
+require 'dragonfly/spec/data_store_examples'
+require 'yaml'
+require 'dragonfly/dreamobjects_data_store'
+
+describe Dragonfly::DreamobjectsDataStore do
+  # To run these tests, put a file ".dreamobjects_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::DreamobjectsDataStore.new(
+        :bucket_name => BUCKET_NAME,
+        :access_key_id => KEY,
+        :secret_access_key => SECRET,
+      )
+      @data_store.create_bucket(BUCKET_NAME)
+    end
+
+  else
+    BUCKET_NAME = 'test-bucket'
+
+    before(:each) do
+      @data_store = Dragonfly::DreamobjectsDataStore.new(
+        :bucket_name => BUCKET_NAME,
+        :access_key_id => 'XXXXXXXXX',
+        :secret_access_key => 'XXXXXXXXX',
+      )
+      @data_store.create_bucket(BUCKET_NAME)
+    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 :dreamobjects
+      end
+      expect(app.datastore).to be_a(Dragonfly::DreamobjectsDataStore)
+    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 == 'dreamobjects.amazonaws.com'
+  #   end
+
+  #   it "should return the correct domain" do
+  #     @data_store.region = 'eu-west-1'
+  #     @data_store.domain.should == 'dreamobjects-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::DreamobjectsDataStore::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::DreamobjectsDataStore::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::DreamobjectsDataStore::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::DreamobjectsDataStore::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::DreamobjectsDataStore::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::DreamobjectsDataStore::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 "root_path" do
+  #   before do
+  #     content.name = "something.png"
+  #     @data_store.root_path = "some/path"
+  #   end
+
+  #   it "stores files in the provided sub directory" do
+  #     @data_store.storage.should_receive(:put_object).with(BUCKET_NAME, /^some\/path\/.*\/something\.png$/, anything, anything)
+  #     @data_store.write(content)
+  #   end
+
+  #   it "finds files in the provided sub directory" do
+  #     mock_response = double("response", body: "", headers: {})
+  #     uid = @data_store.write(content)
+  #     @data_store.storage.should_receive(:get_object).with(BUCKET_NAME, /^some\/path\/.*\/something\.png$/).and_return(mock_response)
+  #     @data_store.read(uid)
+  #   end
+
+  #   it "does not alter the uid" do
+  #     uid = @data_store.write(content)
+  #     uid.should include("something.png")
+  #     uid.should_not include("some/path")
+  #   end
+
+  #   it "destroys files in the provided sub directory" do
+  #     uid = @data_store.write(content)
+  #     @data_store.storage.should_receive(:delete_object).with(BUCKET_NAME, /^some\/path\/.*\/something\.png$/)
+  #     @data_store.destroy(uid)
+  #   end
+
+  #   describe "url_for" do
+  #     before do
+  #       @uid = @data_store.write(content)
+  #     end
+
+  #     it "returns the uid prefixed with the root_path" do
+  #       @data_store.url_for(@uid).should =~ /some\/path\/.*\/something\.png/
+  #     end
+
+  #     it "gives an expiring url" do
+  #       @data_store.url_for(@uid, :expires => 1301476942).should =~ /\/some\/path\/.*\/something\.png\?AWSAccessKeyId=/
+  #     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/dreamobjects'
+  #   end
+
+  #   it "should use the bucket subdomain" do
+  #     @data_store.url_for(@uid).should == "http://#{BUCKET_NAME}.dreamobjects.amazonaws.com/some/path/on/dreamobjects"
+  #   end
+
+  #   it "should use path style if the bucket is not a valid dreamobjects subdomain" do
+  #     bucket_name = BUCKET_NAME.upcase
+  #     @data_store.bucket_name = bucket_name
+  #     @data_store.url_for(@uid).should == "http://dreamobjects.amazonaws.com/#{bucket_name}/some/path/on/dreamobjects"
+  #   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}.dreamobjects.amazonaws.com/some/path/on/dreamobjects"
+  #   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/dreamobjects\?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}.dreamobjects.amazonaws.com/some/path/on/dreamobjects"
+  #   end
+
+  #   it "should allow for always using https" do
+  #     @data_store.url_scheme = 'https'
+  #     @data_store.url_for(@uid).should == "https://#{BUCKET_NAME}.dreamobjects.amazonaws.com/some/path/on/dreamobjects"
+  #   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/dreamobjects"
+  #   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/dreamobjects"
+  #   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
+
+  # describe "fog_storage_options" do
+  #   it "adds options to Fog::Storage object" do
+  #     @data_store.fog_storage_options = {:random_option => 'look at me!'}
+  #     Fog::Storage.should_receive(:new).with do |hash|
+  #       hash[:random_option].should == 'look at me!'
+  #       hash[:aws_access_key_id].should match /\w+/
+  #     end.and_call_original
+  #     @data_store.storage
+  #   end
+  # end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+RSpec.configure do |config|
+  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-dreamobjects_data_store
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Gabriel Rios
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-26 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: aws-sdk
+  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: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Dreamobjects data store for Dragonfly
+email:
+- gabrielfalcaorios@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- dragonfly-dreamobjects_data_store.gemspec
+- lib/dragonfly/dreamobjects_data_store.rb
+- lib/dragonfly/dreamobjects_data_store/version.rb
+- spec/dreamobjects_data_store_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/gabrielrios/dragonfly-dreamobjects_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.2.2
+signing_key: 
+specification_version: 4
+summary: Data store for storing Dragonfly content (e.g. images) on S3
+test_files: []
+has_rdoc: