dragonfly-manta_data_store 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 65a092b8cc5eb180248e34adb26b5d74530d4c6b
+  data.tar.gz: fe49ab770597a4e4f8204c97c4b481b64805d806
+SHA512:
+  metadata.gz: 7f4faa53836bab887f4a7735569624696c01049575a46ff2363e4b15c553c8f8fb933308e3894d76bd6c7e764eef8388c21d5b44498ffc5ee8092da83c24195b
+  data.tar.gz: 78647412fd8213b19818ad51530d3054b29d817a45f865c2e036bec749e1af24f66253ab95778e175770e47a6a6d8b1a2d8e2a48d0b620548f55a41012321953

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,4 @@
+source 'https://rubygems.org'
+gem "pry"
+gem "ruby-manta", :path => "~/onyxrev/ruby-manta"
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Dan Connor
+
+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,75 @@
+# Dragonfly::MantaDataStore
+
+Joyent Manta data store for use with the [Dragonfly](http://github.com/markevans/dragonfly) gem. Inspired by the [S3 Dragonfly gem](https://github.com/markevans/dragonfly-s3_data_store).
+
+## Gemfile
+
+```ruby
+gem 'dragonfly-manta_data_store'
+```
+
+## Usage
+Configuration (remember the require)
+
+```ruby
+require 'dragonfly/manta_data_store'
+
+Dragonfly.app.configure do
+  # ...
+
+  datastore :manta,
+    directory: 'my_images',
+    url: 'https://us-east.manta.joyent.com',
+    user: 'myuser,
+    key: 'actual ASCII ssh key (load from file or ENV)',
+    durability_level: 2
+  # ...
+end
+```
+
+### Available configuration options
+
+```ruby
+:directory         # base directory within your public directory
+:url               # defaults to "https://us-east.manta.joyent.com"
+:user              # your joyent user
+:key               # SSH ASCII key
+:durability_level  # defaults to 2
+:region            # defaults to 'us-east'
+:url_scheme        # defaults to 'http'
+:url_host          # maybe useful for a CDN?
+:root_path         # another base directory on top of :directory (mostly to match the S3 store)
+:storage_headers   # headers to include for all stored objects
+```
+
+### Serving directly from Manta
+
+You can get the Manta 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-manta_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/manta_data_store/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "dragonfly-manta_data_store"
+  spec.version       = Dragonfly::MantaDataStore::VERSION
+  spec.authors       = ["Dan Connor"]
+  spec.email         = ["danconn@danconnor.com"]
+  spec.description   = %q{Manta data store for Dragonfly}
+  spec.summary       = %q{Data store for storing Dragonfly content (e.g. images) on Manta}
+  spec.homepage      = "https://github.com/onyxrev/dragonfly-manta_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 "ruby-manta", "~> 2.0"
+  spec.add_development_dependency "rspec", "~> 2.0"
+end

data/lib/dragonfly/manta_data_store.rb

@@ -0,0 +1,193 @@
+require 'ruby-manta'
+require 'dragonfly'
+
+Dragonfly::App.register_datastore(:manta){ Dragonfly::MantaDataStore }
+
+module Dragonfly
+  class MantaDataStore
+
+    # Exceptions
+    class NotConfigured < RuntimeError; end
+
+    REGIONS = {
+      # default (and only as of now)
+      'us-east' => 'us-east.manta.joyent.com'
+    }
+
+    def initialize(options = {})
+      @directory        = options[:directory]
+      @url              = options[:url]
+      @user             = options[:user]
+      @key              = options[:key]
+      @durability_level = options[:durability_level] || 2
+      @region           = options[:region] || REGIONS.keys.first
+      @url_scheme       = options[:url_scheme] || 'http'
+      @url_host         = options[:url_host]
+      @root_path        = options[:root_path]
+      @storage_headers  = options[:storage_headers] || {}
+    end
+
+    attr_accessor :directory, :url, :user, :key, :durability_level, :region, :url_scheme, :url_host, :root_path, :storage_headers
+
+    def write(content, options = {})
+      ensure_configured
+      ensure_directory
+      store_content(content, options)
+    end
+
+    def read(uid)
+      ensure_configured
+      response, headers = storage.get_object(full_path(uid))
+
+      [ response, headers_to_meta(headers) ]
+    rescue RubyManta::MantaClient::ResourceNotFound => e
+      nil
+    end
+
+    def destroy(uid)
+      storage.delete_object(full_path(uid))
+    rescue => e
+      Dragonfly.warn("#{self.class.name} destroy error: #{e}")
+    end
+
+    def url_for(uid, options = {})
+      scheme = options[:scheme] || url_scheme
+
+      if options[:expires]
+        url_without_scheme = storage.gen_signed_url(options[:expires], :get, full_path(uid))
+      else
+        host = options[:host] || url_host || region_host
+
+        url_without_scheme = "#{host}#{full_path(uid)}"
+      end
+
+      "#{scheme}://#{url_without_scheme}"
+    end
+
+    def storage
+      @storage ||= begin
+        RubyManta::MantaClient.new(url, user, key)
+      end
+    end
+
+    def directory_exists?
+      storage.list_directory(public_directory, :head => true)
+      true
+    rescue RubyManta::MantaClient::UnknownError => e
+      false
+    end
+
+    def domain
+      REGIONS[get_region]
+    end
+
+    private
+
+    def headers_to_meta(headers)
+      begin
+        JSON.parse(headers["m-dragonfly"])
+      rescue => e
+        nil
+      end
+    end
+
+    def meta_to_header(meta = {})
+      { :m_dragonfly => JSON.dump(meta) }
+    end
+
+    def store_content(content, options = {})
+      uid = options[:path] || generate_uid(content.name || 'file')
+
+      headers = {
+        :content_type => content.mime_type
+      }
+
+      headers.merge!(meta_to_header(content.meta))
+      headers.merge!(options[:headers]) if options[:headers]
+
+      path = full_path(uid)
+      mkdir_for_file_path(path)
+
+      content.file do |file|
+        storage.put_object(
+          path,
+          file.read,
+          full_storage_headers(headers)
+        )
+      end
+
+      uid
+    end
+
+    def ensure_configured
+      unless @configured
+        [:directory, :url, :user, :key].each do |attr|
+          raise NotConfigured, "You need to configure #{self.class.name} with #{attr}" if send(attr).nil?
+        end
+
+        @configured = true
+      end
+    end
+
+    def ensure_directory
+      unless @directory_created
+        mkdir(public_directory) unless directory_exists?
+
+        @directory_created = true
+      end
+    end
+
+    def public_directory
+      "/#{@user}/public/#{@directory}"
+    end
+
+    def region_host
+      REGIONS[get_region]
+    end
+
+    def get_region
+      raise "Invalid region #{region} - should be one of #{valid_regions.join(', ')}" unless valid_regions.include?(region)
+      region
+    end
+
+    def generate_uid(name)
+      # S3 was using subdirectories but Manta is ZFS and it can handle up to
+      # 281,474,976,710,656 files in a directory
+      "#{Time.now.strftime '%Y_%m_%d_%H_%M_%S'}_#{rand(1000)}_#{name.gsub(/[^\w.]+/, '_')}"
+    end
+
+    def full_storage_headers(options = {})
+      {
+        "durability_level" => durability_level
+      }.merge(storage_headers).merge(options)
+    end
+
+    def full_path(uid)
+      File.join *[public_directory, root_path, uid].compact
+    end
+
+    def valid_regions
+      REGIONS.keys
+    end
+
+    def mkdir_for_file_path(file_with_path)
+      mkdir_with_intermediates file_with_path.split("/")[0..-2].join("/")
+    end
+
+    def mkdir_with_intermediates(path)
+      path_components = path.split("/")
+
+      path_components.length.times do |index|
+        path_to_make = path_components[0..index].join("/")
+
+        if path_to_make.start_with?(public_directory) and not path_to_make.empty?
+          mkdir path_to_make
+        end
+      end
+    end
+
+    def mkdir(path)
+      storage.put_directory(path)
+    end
+  end
+end

data/lib/dragonfly/manta_data_store/version.rb

@@ -0,0 +1,5 @@
+module Dragonfly
+  class MantaDataStore
+    VERSION = "0.9.0"
+  end
+end

data/spec/manta_data_store_spec.rb

@@ -0,0 +1,290 @@
+require 'spec_helper'
+require 'ruby_manta_stub'
+require 'dragonfly/spec/data_store_examples'
+require 'yaml'
+require 'dragonfly/manta_data_store'
+
+describe Dragonfly::MantaDataStore do
+  # To run these tests, put a file ".manta_spec.yml" in the dragonfly root dir, like this:
+  # user: XXXXXXXXXX
+  # enabled: true
+  #
+  # and load your SSH key as the 'DRAGONFLY_MANTA_STORE_SSH_KEY' ENV variable
+  if File.exist?(file = File.expand_path('../../.manta_spec.yml', __FILE__))
+    config = YAML.load_file(file)
+    KEY = ENV['DRAGONFLY_MANTA_STORE_SSH_KEY']
+    enabled = config['enabled']
+  else
+    enabled = false
+  end
+
+  if enabled
+    # Make sure it's a new directory name
+    DIRECTORY = "dragonfly-test-#{Time.now.to_i.to_s(36)}"
+
+    before(:each) do
+      @data_store = Dragonfly::MantaDataStore.new(
+        :directory => DIRECTORY,
+        :user      => config['user'],
+        :url       => "https://us-east.manta.joyent.com",
+        :key       => KEY
+      )
+    end
+  else
+    DIRECTORY = 'test-directory'
+
+    let!(:fake_client){ RubyMantaStub.new }
+
+    before(:each) do
+      RubyManta::MantaClient.stub(:new).and_return(fake_client)
+
+      @data_store = Dragonfly::MantaDataStore.new(
+        :directory => DIRECTORY,
+        :user      => 'XXXXXXXXX',
+        :url       => "XXXXXXXXX",
+        :key       => 'XXXXXXXXX'
+      )
+
+      fake_client.user   = @data_store.user
+      fake_client.domain = @data_store.domain
+    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 :manta
+      end
+      app.datastore.should be_a(Dragonfly::MantaDataStore)
+    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
+  end
+
+  describe "domain" do
+    it "should default to the us-east" do
+      @data_store.domain.should == 'us-east.manta.joyent.com'
+    end
+
+    it "should return the correct domain" do
+      @data_store.region = 'us-east'
+      @data_store.domain.should == 'us-east.manta.joyent.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 directory name on write" do
+      @data_store.directory = nil
+      proc{ @data_store.write(content) }.should raise_error(Dragonfly::MantaDataStore::NotConfigured)
+    end
+
+    it "should require a key on write" do
+      @data_store.key = nil
+      proc{ @data_store.write(content) }.should raise_error(Dragonfly::MantaDataStore::NotConfigured)
+    end
+
+    it "should require a url on write" do
+      @data_store.url = nil
+      proc{ @data_store.write(content) }.should raise_error(Dragonfly::MantaDataStore::NotConfigured)
+    end
+
+    it "should require a directory on read" do
+      @data_store.directory = nil
+      proc{ @data_store.read('asdf') }.should raise_error(Dragonfly::MantaDataStore::NotConfigured)
+    end
+
+    it "should require a key on read" do
+      @data_store.key = nil
+      proc{ @data_store.read('asdf') }.should raise_error(Dragonfly::MantaDataStore::NotConfigured)
+    end
+
+    it "should require a url on read" do
+      @data_store.url = nil
+      proc{ @data_store.read('asdf') }.should raise_error(Dragonfly::MantaDataStore::NotConfigured)
+    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(/^\/#{@data_store.user}\/public\/#{DIRECTORY}\/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(/^\/#{@data_store.user}\/public\/#{DIRECTORY}\/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(/^\/#{@data_store.user}\/public\/#{DIRECTORY}\/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
+        expires = 1301476942
+        @data_store.url_for(@uid, :expires => expires).should =~ /\/some\/path\/.*_something\.png\?algorithm=rsa-sha1&expires=#{expires}&keyId=%2F#{@data_store.user}%2Fkeys%2F/
+      end
+    end
+
+    describe "autocreating the directory" do
+      it "should create the directory on write if it doesn't exist" do
+        @data_store.directory = "dragonfly-test-blah-blah-#{rand(100000000)}"
+        @data_store.write(content)
+      end
+
+      it "should not try to create the directory on read if it doesn't exist" do
+        @data_store.directory = "dragonfly-test-blah-blah-#{rand(100000000)}"
+        @data_store.send(:storage).should_not_receive(:put_directory)
+        @data_store.read("gungle").should be_nil
+      end
+    end
+  end
+
+  describe "headers" do
+    before(:each) do
+      @data_store.storage_headers = {'x-zomg' => 'biscuithead'}
+    end
+
+    it "should allow configuring globally" do
+      @data_store.storage.should_receive(:put_object).with(anything, anything,
+        hash_including('x-zomg' => 'biscuithead')
+      )
+      @data_store.write(content)
+    end
+
+    it "should allow adding per-store" do
+      @data_store.storage.should_receive(:put_object).with(anything, anything,
+        hash_including('x-zomg' => '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(anything, anything,
+        hash_including('x-zomg' => 'override!')
+      )
+      @data_store.write(content, :headers => {'x-zomg' => '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 "read" do
+    before(:each) do
+      content.add_meta('bitrate' => 35, 'name' => 'danny.boy')
+      uid = @data_store.write(content)
+      stuff, meta = @data_store.read(uid)
+      @retrieved_content = Dragonfly::Content.new(app, stuff, meta)
+    end
+
+    it "should return the stored meta" do
+      @retrieved_content.meta['bitrate'].should == 35
+      @retrieved_content.meta['name'].should == 'danny.boy'
+    end
+  end
+
+  describe "urls for serving directly" do
+    before(:each) do
+      @uid = 'some/path/on/manta'
+    end
+
+    it "should give an expiring url" do
+      expires = 1301476942
+
+      @data_store.url_for(@uid, :expires => expires).should =~
+      %r{^http://#{@data_store.domain}/#{@data_store.user}/public/#{DIRECTORY}/some/path/on/manta\?algorithm=rsa-sha1&expires=#{expires}&keyId=%2F#{@data_store.user}%2Fkeys\.*}
+    end
+
+    it "should allow for using https" do
+      @data_store.url_for(@uid, :scheme => 'https').should =~ /^https:\/\//
+    end
+
+    it "should allow for always using https" do
+      @data_store.url_scheme = 'https'
+      @data_store.url_for(@uid).should =~ /^https:\/\//
+    end
+
+    it "should allow for customizing the host" do
+      @data_store.url_for(@uid, :host => 'customised.domain.com').should == "http://customised.domain.com/#{@data_store.user}/public/#{DIRECTORY}/some/path/on/manta"
+    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}/#{@data_store.user}/public/#{DIRECTORY}/some/path/on/manta"
+    end
+  end
+end

data/spec/ruby_manta_stub.rb

@@ -0,0 +1,53 @@
+require 'cgi'
+
+# just close enough to make the tests pass...
+class RubyMantaStub
+  attr_accessor :user, :domain
+
+  def initialize
+    @store = {}
+    @directories = {}
+  end
+
+  def put_directory(directory)
+    @directories[directory] ||= {}
+  end
+
+  def list_directory(directory, options)
+    raise RubyManta::MantaClient::UnknownError unless @directories[directory]
+
+    @directories[directory]
+  end
+
+  def put_object(path, content, headers)
+    @store[path] = {
+      :headers => headers,
+      :content => content
+    }
+
+    [ path, {} ]
+  end
+
+  def get_object(path)
+    raise RubyManta::MantaClient::ResourceNotFound unless @store[path]
+
+    headers = @store[path][:headers].dup
+    headers["m-dragonfly"] = headers.delete :m_dragonfly
+
+    [ @store[path][:content], headers ]
+  end
+
+  def delete_object(path)
+    @store.delete path
+
+    [ true, {} ]
+  end
+
+  def gen_signed_url(expiry, method, path)
+    fake_key = rand(36**128).to_s(36)
+
+    key_id = CGI.escape("/#{user}/keys/#{fake_key}")
+
+    "#{domain}#{path}?algorithm=rsa-sha1&expires=#{expiry}&keyId=#{key_id}"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+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,100 @@
+--- !ruby/object:Gem::Specification
+name: dragonfly-manta_data_store
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+platform: ruby
+authors:
+- Dan Connor
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-05 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: ruby-manta
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.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: Manta data store for Dragonfly
+email:
+- danconn@danconnor.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- dragonfly-manta_data_store.gemspec
+- lib/dragonfly/manta_data_store.rb
+- lib/dragonfly/manta_data_store/version.rb
+- spec/manta_data_store_spec.rb
+- spec/ruby_manta_stub.rb
+- spec/spec_helper.rb
+homepage: https://github.com/onyxrev/dragonfly-manta_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.4.5
+signing_key: 
+specification_version: 4
+summary: Data store for storing Dragonfly content (e.g. images) on Manta
+test_files:
+- spec/manta_data_store_spec.rb
+- spec/ruby_manta_stub.rb
+- spec/spec_helper.rb