remote_files 1.0.0

data/README.md

@@ -0,0 +1,86 @@
+# RemoteFiles
+
+A library for uploading files to multiple remote storage backends like Amazon S3 and Rackspace CloudFiles.
+
+The purpose of the library is to implement a simple interface for uploading files to multiple backends
+and to keep the backends in sync, so that your app will keep working when one backend is down.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'remote_files'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install remote_files
+
+## Configuration
+
+First you configure the storage backends you want:
+
+```ruby
+RemoteFiles.add_store(:s3, :primary => true) do |s3|
+  s3[:provider] = 'AWS'
+
+  s3[:aws_access_key_id]     = AWS_ACCESS_KEY_ID
+  s3[:aws_secret_access_key] = AWS_SECRET_ACCESS_KEY
+
+  s3[:directory] = 'my_s3_bucket'
+end
+
+RemoteFiles.add_store(:cf) do |cf|
+  cf[:provider] = 'Rackspace'
+
+  cf[:rackspace_username] = RACKSPACE_USERNAME
+  cf[:rackspace_api_key]  = RACKSPACE_API_KEY
+
+  cf[:directory] = 'my_cf_container'
+end
+```
+
+By default RemoteFiles will store your files to all stores synchronously. This is probably not what you want,
+so you should tell RemoteFiles how to do it asynchronously:
+
+```ruby
+class RemoteFilesSyncJob
+  def initialize(identifier, stored_in)
+    @file = RemoteFiles::File.new(identifier, :stored_in => stored_in)
+  def
+
+  def work
+    @file.synchronize!
+  end
+end
+
+RemoteFiles.synchronize_stores do |file|
+  MyPreferredJobQueue.enqueue(RemoteFilesSyncJob, file.identifier, file.stored_in)
+end
+```
+
+## Usage
+
+Once everything is configured, you can store files like this:
+
+```ruby
+file = RemoteFiles::File.new(unique_file_name, :content => file_content, :content_type => content_type)
+file.store!
+```
+
+This will store the file on one of the stores and then asynchronously copy the file to the remaining stores.
+`RemoteFiles::File#store!` will raise a `RemoteFiles::Error` if all storage backends are down.
+
+If you just need to store the file in a single store, the you can use `RemoteFiles::File#store_once!`. It will
+behave exactly like `RemoteFiles::File#store!`, but will not asynchronously copy the file to the other stores.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/lib/remote_files/abstract_store.rb

@@ -0,0 +1,21 @@
+module RemoteFiles
+  class AbstractStore
+    attr_reader :identifier
+
+    def initialize(identifier)
+      @identifier = identifier
+    end
+
+    def store!(file)
+      raise "You need to implement #{self.class.name}#store!"
+    end
+
+    def retrieve!(identifier)
+      raise "You need to implement #{self.class.name}#retrieve!"
+    end
+
+    def url(identifier)
+      raise "You need to implement #{self.class.name}#url"
+    end
+  end
+end

data/lib/remote_files/file.rb

@@ -0,0 +1,59 @@
+module RemoteFiles
+  class File
+    attr_reader :content, :content_type, :identifier, :stored_in
+
+    def initialize(identifier, options = {})
+      @identifier   = identifier
+      @stored_in    = options[:stored_in] || []
+      @content      = options.delete(:content)
+      @content_type = options[:content_type]
+      @options      = options
+    end
+
+    def options
+      @options.merge(
+        :identifier   => identifier,
+        :stored_in    => stored_in,
+        :content_type => content_type
+      )
+    end
+
+    def stored?
+      !@stored_in.empty?
+    end
+
+    def stored_everywhere?
+      missing_stores.empty?
+    end
+
+    def missing_stores
+      RemoteFiles.stores.map(&:identifier) - @stored_in
+    end
+
+    def url(store_identifier = nil)
+      store = store_identifier ? RemoteFiles.lookup_store(store_identifier) : RemoteFiles.primary_store
+      return nil unless store
+      store.url(identifier)
+    end
+
+    def current_url
+      prioritized_stores = RemoteFiles.stores.map(&:identifier) & @stored_in
+
+      return nil if prioritized_stores.empty?
+
+      url(prioritized_stores[0])
+    end
+
+    def store!
+      RemoteFiles.store!(self)
+    end
+
+    def store_once!
+      RemoteFiles.store_once!(self)
+    end
+
+    def synchronize!
+      RemoteFiles.synchronize!(self)
+    end
+  end
+end

data/lib/remote_files/fog_store.rb

@@ -0,0 +1,69 @@
+require 'remote_files/abstract_store'
+require 'fog'
+
+module RemoteFiles
+  class FogStore < AbstractStore
+    def store!(file)
+      sucess = directory.files.create(
+        :body         => file.content,
+        :content_type => file.content_type,
+        :key          => file.identifier,
+        :public       => options[:public]
+      )
+
+      raise RemoteFiles::Error unless sucess
+
+      true
+    rescue Fog::Errors::Error, Excon::Errors::Error
+      raise RemoteFiles::Error, $!.message, $!.backtrace
+    end
+
+    def retrieve!(identifier)
+      fog_file = directory.files.get(identifier)
+
+      raise NotFoundError, "#{identifier} not found in #{self.identifier} store" if fog_file.nil?
+
+      File.new(identifier,
+        :content      => fog_file.body,
+        :content_type => fog_file.content_type,
+        :stored_in    => [self.identifier]
+      )
+    rescue Fog::Errors::Error, Excon::Errors::Error
+      raise RemoteFiles::Error, $!.message, $!.backtrace
+    end
+
+    def url(identifier)
+      case options[:provider]
+      when 'AWS'
+        "https://s3.amazonaws.com/#{options[:directory]}/#{Fog::AWS.escape(identifier)}"
+      when 'Rackspace'
+        "https://storage.cloudfiles.com/#{options[:directory]}/#{Fog::Rackspace.escape(identifier, '/')}"
+      else
+        raise "#{self.class.name}#url was not implemented for the #{options[:provider]} provider"
+      end
+    end
+
+    def options
+      @options ||= {}
+    end
+
+    def []=(name, value)
+      options[name] = value
+    end
+
+    def connection
+      connection_options = options.dup
+      connection_options.delete(:directory)
+      connection_options.delete(:public)
+      @connection ||= Fog::Storage.new(connection_options)
+    end
+
+    def directory
+      @directory ||= connection.directories.new(
+        :key    => options[:directory],
+        :public => options[:public]
+      )
+    end
+
+  end
+end

data/lib/remote_files/mock_store.rb

@@ -0,0 +1,25 @@
+module RemoteFiles
+  class MockStore < AbstractStore
+    def data
+      @data ||= {}
+    end
+
+    def store!(file)
+      data[file.identifier] = { :content => file.content, :content_type => file.content_type}
+    end
+
+    def retrieve!(identifier)
+      raise NotFoundError, "#{identifier} not found in #{self.identifier} store" unless data.has_key?(identifier)
+
+      File.new(identifier,
+        :content      => data[identifier][:content],
+        :content_type => data[identifier][:content_type],
+        :stored_in    => [self.identifier]
+      )
+    end
+
+    def url(identifier)
+      "mock://#{self.identifier}/#{identifier}"
+    end
+  end
+end

data/lib/remote_files/resque_job.rb

@@ -0,0 +1,15 @@
+require 'remote_files'
+require 'resque'
+
+module RemoteFiles
+  class ResqueJob
+    def self.perform(options)
+      file = RemoteFiles::File.new(options.delete(:identifier), options)
+      file.synchronize!
+    end
+  end
+
+  synchronize_stores do |file|
+    Resque.enqueue(ResqueJob, file.options)
+  end
+end

data/lib/remote_files/version.rb

@@ -0,0 +1,3 @@
+module RemoteFiles
+  VERSION = '1.0.0'
+end

data/lib/remote_files.rb

@@ -0,0 +1,87 @@
+require 'remote_files/version'
+require 'remote_files/fog_store'
+require 'remote_files/file'
+
+module RemoteFiles
+  class Error < StandardError; end
+  class NotFoundError < Error; end
+
+  STORES_MAP = {}
+  STORES = []
+
+  def self.add_store(store_identifier, options = {}, &block)
+    store = (options[:class] || FogStore).new(store_identifier)
+    block.call(store) if block_given?
+
+    if options[:primary]
+      STORES.unshift(store)
+    else
+      STORES << store
+    end
+
+    STORES_MAP[store_identifier] = store
+  end
+
+  def self.stores
+    raise "You need to configure add stores to RemoteFiles using 'RemoteFiles.add_store'" if STORES.empty?
+    STORES
+  end
+
+  def self.lookup_store(store_identifier)
+    STORES_MAP[store_identifier]
+  end
+
+  def self.primary_store
+    STORES.first
+  end
+
+  def self.store_once!(file)
+    return file.stored_in.first if file.stored?
+
+    exception = nil
+
+    stores.each do |store|
+      begin
+        stored = store.store!(file)
+        file.stored_in << store.identifier
+        break
+      rescue ::RemoteFiles::Error => e
+        exception = e
+      end
+    end
+
+    raise exception unless file.stored?
+
+    file.stored_in.first
+  end
+
+  def self.store!(file)
+    store_once!(file) unless file.stored?
+
+    synchronize_stores(file) unless file.stored_everywhere?
+
+    true
+  end
+
+  def self.synchronize!(file)
+    file.missing_stores.each do |store_identifier|
+      store = lookup_store(store_identifier)
+      store.store!(file)
+      file.stored_in << store.identifier
+    end
+  end
+
+  def self.synchronize_stores(file = nil, &block)
+    if file
+      if @synchronize_stores
+        @synchronize_stores.call(file)
+      else
+        synchronize!(file)
+      end
+    elsif block_given?
+      @synchronize_stores = block
+    else
+      raise "invalid call to RemoteFiles.synchronize_stores"
+    end
+  end
+end

data/test/file_test.rb

@@ -0,0 +1,84 @@
+require_relative 'test_helper'
+
+describe RemoteFiles::File do
+  before do
+    @s3 = RemoteFiles.add_store(:s3, :class => RemoteFiles::MockStore, :primary => true)
+    @cf = RemoteFiles.add_store(:cf, :class => RemoteFiles::MockStore)
+
+    @file = RemoteFiles::File.new('identifier')
+  end
+
+  describe '#stored?' do
+    it 'should return true if the file is stored anywhere' do
+      @file.stored_in << :s3
+      @file.stored?.must_equal(true)
+    end
+
+    it 'should return false if the file is not stored anywhere' do
+      @file.stored_in.clear
+      @file.stored?.must_equal(false)
+    end
+  end
+
+  describe '#stored_everywhere?' do
+    it 'should return false if the file is not stored anywhere' do
+      @file.stored_in.clear
+      @file.stored_everywhere?.must_equal(false)
+    end
+
+    it 'should return false if the file only is stored in some of the stores' do
+      @file.stored_in.replace([:s3])
+      @file.stored_everywhere?.must_equal(false)
+    end
+
+    it 'should return true if the file is stored in all stores' do
+      @file.stored_in.replace([:s3, :cf])
+      @file.stored_everywhere?.must_equal(true)
+    end
+  end
+
+  describe '#missing_stores' do
+    it 'should give an array of store identifiers where the file is not stored' do
+      @file.stored_in.replace([:s3])
+      @file.missing_stores.must_equal([:cf])
+    end
+  end
+
+  describe '#url' do
+    before do
+      @s3.stubs(:url).returns('s3_url')
+      @cf.stubs(:url).returns('cf_url')
+    end
+
+    describe 'with no arguments' do
+      it 'should return the url on the primary store' do
+        @file.url.must_equal('s3_url')
+      end
+    end
+
+    describe 'with a store identifier' do
+      it 'should return the url from that store' do
+        @file.url(:cf).must_equal('cf_url')
+      end
+    end
+  end
+
+  describe 'current_url' do
+    it 'should return the url from the first store where the file is currently stored' do
+      @s3.stubs(:url).returns('s3_url')
+      @cf.stubs(:url).returns('cf_url')
+
+      @file.stored_in.replace([:s3])
+      @file.current_url.must_equal('s3_url')
+
+      @file.stored_in.replace([:cf])
+      @file.current_url.must_equal('cf_url')
+
+      @file.stored_in.replace([:cf, :s3])
+      @file.current_url.must_equal('s3_url')
+
+      @file.stored_in.replace([])
+      @file.current_url.must_be_nil
+    end
+  end
+end

data/test/fog_store_test.rb

@@ -0,0 +1,108 @@
+require_relative 'test_helper'
+
+describe RemoteFiles::FogStore do
+  before do
+    @connection = Fog::Storage.new({
+      :provider              => 'AWS',
+      :aws_access_key_id     => 'access_key_id',
+      :aws_secret_access_key => 'secret_access_key'
+    })
+
+    @directory = @connection.directories.create(:key => 'directory')
+
+    @store = RemoteFiles::FogStore.new(:fog)
+    @store[:provider] = 'AWS'
+    @store[:aws_access_key_id]     = 'access_key_id'
+    @store[:aws_secret_access_key] = 'secret_access_key'
+    @store[:directory] = 'directory'
+    @store[:public]    = true
+  end
+
+  describe 'configuration' do
+    it 'should configure a fog connection' do
+      connection = @store.connection
+
+      connection.must_be_instance_of(Fog::Storage::AWS::Mock)
+    end
+
+    it 'should configure directory' do
+      directory = @store.directory
+
+      directory.must_be_instance_of(Fog::Storage::AWS::Directory)
+
+      directory.key.must_equal('directory')
+    end
+  end
+
+  describe '#store!' do
+    before do
+      @file = RemoteFiles::File.new('identifier', :content_type => 'text/plain', :content => 'content')
+    end
+
+    it 'should store the file in the directory' do
+      @store.store!(@file)
+
+      fog_file = @directory.files.get('identifier')
+
+      fog_file.must_be_instance_of(Fog::Storage::AWS::File)
+      fog_file.content_type.must_equal('text/plain')
+      fog_file.body.must_equal('content')
+    end
+
+    it 'should raise a RemoteFiles::Error when an error happens' do
+      @directory.destroy
+      proc { @store.store!(@file) }.must_raise(RemoteFiles::Error)
+    end
+  end
+
+  describe '#retrieve!' do
+    it 'should return a RemoteFiles::File when found' do
+      @directory.files.create(
+        :body         => 'content',
+        :content_type => 'text/plain',
+        :key          => 'identifier'
+      )
+
+      file = @store.retrieve!('identifier')
+
+      file.must_be_instance_of(RemoteFiles::File)
+      file.content.must_equal('content')
+      file.content_type.must_equal('text/plain')
+    end
+
+    it 'should raise a RemoteFiles::NotFoundError when not found' do
+      proc { @store.retrieve!('identifier') }.must_raise(RemoteFiles::NotFoundError)
+    end
+
+    it 'should raise a RemoteFiles::Error when error' do
+      @directory.destroy
+      proc { @store.retrieve!('identifier') }.must_raise(RemoteFiles::Error)
+    end
+  end
+
+  describe '#url' do
+    describe 'for S3 connections' do
+      before { @store[:provider] = 'AWS' }
+
+      it 'should return an S3 url' do
+        @store.url('identifier').must_equal('https://s3.amazonaws.com/directory/identifier')
+      end
+    end
+
+    describe 'for CloudFiles connections' do
+      before { @store[:provider] = 'Rackspace' }
+
+      it 'should return a CloudFiles url' do
+        @store.url('identifier').must_equal('https://storage.cloudfiles.com/directory/identifier')
+      end
+    end
+
+    describe 'for other connections' do
+      before { @store[:provider] = 'Google' }
+
+      it 'should raise' do
+        proc { @store.url('identifier') }.must_raise(RuntimeError)
+      end
+    end
+  end
+end

data/test/remote_files_test.rb

@@ -0,0 +1,184 @@
+require_relative 'test_helper'
+require 'remote_files/mock_store'
+
+describe RemoteFiles do
+  before do
+    @file = RemoteFiles::File.new('file', :content => 'content', :content_type => 'text/plain')
+    @mock_store1 = RemoteFiles.add_store(:mock1, :class => RemoteFiles::MockStore)
+    @mock_store2 = RemoteFiles.add_store(:mock2, :class => RemoteFiles::MockStore)
+  end
+
+  describe '::add_store' do
+    describe 'when adding a non-primary store' do
+      before { @non_primary_store = RemoteFiles.add_store(:primary) }
+
+      it 'should add it to the tail of the list of stores' do
+        RemoteFiles.stores.must_equal([@mock_store1, @mock_store2, @non_primary_store])
+      end
+    end
+
+    describe 'when adding a promary store' do
+      before { @primary_store = RemoteFiles.add_store(:primary, :primary => true) }
+
+      it 'should add it to the head of the list of stores' do
+        RemoteFiles.stores.must_equal([@primary_store, @mock_store1, @mock_store2])
+      end
+    end
+  end
+
+  describe '::primary_store' do
+    before do
+      @primary_store1 = RemoteFiles.add_store(:primary1, :primary => true)
+      @primary_store2 = RemoteFiles.add_store(:primary2, :primary => true)
+    end
+
+    it 'should return the head of the list of stores' do
+      RemoteFiles.primary_store.must_equal(@primary_store2)
+    end
+  end
+
+  describe '::lookup_store' do
+    before do
+      @primary_store = RemoteFiles.add_store(:primary, :primary => true)
+    end
+
+    it 'should find the store my identifier' do
+      RemoteFiles.lookup_store(:mock1).must_equal(@mock_store1)
+      RemoteFiles.lookup_store(:mock2).must_equal(@mock_store2)
+      RemoteFiles.lookup_store(:primary).must_equal(@primary_store)
+      RemoteFiles.lookup_store(:unknown).must_be_nil
+    end
+  end
+
+  describe '::store_once!' do
+
+    describe 'when the first store succeeds' do
+      before { RemoteFiles.store_once!(@file) }
+
+      it 'should only store the file in the first store' do
+        @mock_store1.data['file'].must_equal(:content => 'content', :content_type => 'text/plain')
+        @mock_store2.data['file'].must_be_nil
+      end
+    end
+
+    describe 'when the first store fails' do
+      before do
+        @mock_store1.expects(:store!).with(@file).raises(RemoteFiles::Error)
+        RemoteFiles.store_once!(@file)
+      end
+
+      it 'should only store the file in the second store' do
+        @mock_store1.data['file'].must_be_nil
+        @mock_store2.data['file'].must_equal(:content => 'content', :content_type => 'text/plain')
+      end
+    end
+
+    describe 'when alls stores fail' do
+      before do
+        @mock_store1.expects(:store!).with(@file).raises(RemoteFiles::Error)
+        @mock_store2.expects(:store!).with(@file).raises(RemoteFiles::Error)
+      end
+
+      it 'should raise a RemoteFiles::Error' do
+        proc { RemoteFiles.store_once!(@file) }.must_raise(RemoteFiles::Error)
+      end
+    end
+  end
+
+  describe '::synchronize_stores' do
+    before do
+      @files = []
+
+      RemoteFiles.synchronize_stores do |file|
+        @files << file
+      end
+    end
+
+    it 'should use the block for store synchronizaation' do
+      file = RemoteFiles::File.new('file')
+      RemoteFiles.synchronize_stores(file)
+      @files.must_equal([file])
+    end
+  end
+
+  describe '::store!' do
+    describe 'when the file is already stored in some stores' do
+      before { @file.stored_in.replace([@mock_store1.identifier]) }
+
+      it 'should not store the file' do
+        RemoteFiles.expects(:store_once!).never
+        RemoteFiles.store!(@file)
+      end
+
+      it 'should synchronize the stores' do
+        RemoteFiles.expects(:synchronize_stores).with(@file)
+        RemoteFiles.store!(@file)
+      end
+    end
+
+    describe 'when the file is stored in all stores' do
+      before { @file.stored_in.replace([@mock_store1.identifier, @mock_store2.identifier]) }
+
+      it 'should not store the file' do
+        RemoteFiles.expects(:store_once!).never
+        RemoteFiles.store!(@file)
+      end
+
+      it 'should not synchronize the stores' do
+        RemoteFiles.expects(:synchronize_stores).never
+        RemoteFiles.store!(@file)
+      end
+
+    end
+
+    describe 'when the file is not stored anywhere' do
+      before { @file.stored_in.replace([]) }
+
+      it 'should store the file once' do
+        RemoteFiles.expects(:store_once!).with(@file)
+        RemoteFiles.store!(@file)
+      end
+
+      it 'should synchronize the stores' do
+        RemoteFiles.expects(:synchronize_stores).with(@file)
+        RemoteFiles.store!(@file)
+      end
+    end
+  end
+
+  describe '::synchronize!' do
+    describe 'when the file is not stored anywhere' do
+      before { @file.stored_in.replace([]) }
+
+      it 'should store the file on all stores' do
+        @mock_store1.expects(:store!).returns(true)
+        @mock_store2.expects(:store!).returns(true)
+
+        RemoteFiles.synchronize!(@file)
+      end
+    end
+
+    describe 'when the file is stored in some stores' do
+      before { @file.stored_in.replace([@mock_store1.identifier]) }
+
+      it 'should store the file in the remaining stores' do
+        @mock_store1.expects(:store!).never
+        @mock_store2.expects(:store!).with(@file).returns(true)
+
+        RemoteFiles.synchronize!(@file)
+      end
+    end
+
+    describe 'when the file is stored everywhere' do
+      before { @file.stored_in.replace([@mock_store1.identifier, @mock_store2.identifier]) }
+
+      it 'should not do anything' do
+        @mock_store1.expects(:store!).never
+        @mock_store2.expects(:store!).never
+
+        RemoteFiles.synchronize!(@file)
+      end
+    end
+  end
+
+end

data/test/resque_job_test.rb

@@ -0,0 +1,46 @@
+require_relative 'test_helper'
+require 'remote_files/resque_job'
+
+describe RemoteFiles::ResqueJob do
+  describe 'loading the implementation file' do
+    before { load 'remote_files/resque_job.rb' }
+
+    it 'should setup the right synchronize_stores hook' do
+      file = RemoteFiles::File.new('identifier',
+        :content_type => 'text/plain',
+        :content => 'content',
+        :stored_in => [:s3],
+        :foo => :bar
+      )
+
+      Resque.expects(:enqueue).with(RemoteFiles::ResqueJob,
+        :identifier => 'identifier',
+        :content_type => 'text/plain',
+        :stored_in => [:s3],
+        :foo => :bar
+      )
+
+      RemoteFiles.synchronize_stores(file)
+    end
+  end
+
+  it 'should call #synchronize! on the reconstructed file' do
+    options = {
+      :identifier => 'identifier',
+      :content_type => 'text/plain',
+      :stored_in => [:s3],
+      :foo => :bar
+    }
+
+    file = stub
+    file.expects(:synchronize!)
+
+    RemoteFiles::File.expects(:new).with('identifier',
+      :content_type => 'text/plain',
+      :stored_in => [:s3],
+      :foo => :bar
+    ).returns(file)
+
+    RemoteFiles::ResqueJob.perform(options)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,26 @@
+require 'bundler/setup'
+
+require 'debugger'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'remote_files'
+
+require 'minitest/autorun'
+
+require 'mocha'
+
+Fog.mock!
+
+MiniTest::Spec.class_eval do
+  before do
+    Fog::Mock.reset
+
+    RemoteFiles::STORES.clear
+    RemoteFiles::STORES_MAP.clear
+
+    $syncs = []
+    RemoteFiles.synchronize_stores do |file|
+      $syncs << {:identifier => file.identifier, :missing_stores => file.missing_stores}
+    end
+  end
+end

metadata

@@ -0,0 +1,168 @@
+--- !ruby/object:Gem::Specification
+name: remote_files
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Mick Staugaard
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: fog
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: debugger
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: resque
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A library for uploading files to multiple remote storage backends like
+  Amazon S3 and Rackspace CloudFiles.
+email:
+- mick@staugaard.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/remote_files/abstract_store.rb
+- lib/remote_files/file.rb
+- lib/remote_files/fog_store.rb
+- lib/remote_files/mock_store.rb
+- lib/remote_files/resque_job.rb
+- lib/remote_files/version.rb
+- lib/remote_files.rb
+- test/file_test.rb
+- test/fog_store_test.rb
+- test/remote_files_test.rb
+- test/resque_job_test.rb
+- test/test_helper.rb
+- README.md
+homepage: https://github.com/staugaard/remote_file
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -3554087706226059699
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -3554087706226059699
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: The purpose of the library is to implement a simple interface for uploading
+  files to multiple backends and to keep the backends in sync, so that your app will
+  keep working when one backend is down.
+test_files:
+- test/file_test.rb
+- test/fog_store_test.rb
+- test/remote_files_test.rb
+- test/resque_job_test.rb
+- test/test_helper.rb