remote_files 1.2.2 → 1.3.0

data/lib/remote_files/configuration.rb

@@ -0,0 +1,123 @@
+require 'remote_files/fog_store'
+
+module RemoteFiles
+  class Configuration
+    attr_reader :name
+
+    def initialize(name, config = {})
+      @name       = name
+      @stores     = []
+      @stores_map = {}
+      from_hash(config)
+    end
+
+    def clear
+      @stores.clear
+      @stores_map.clear
+    end
+
+    def from_hash(hash)
+      hash.each do |store_identifier, config|
+        #symbolize_keys!
+        cfg = {}
+        config.each { |name, value| cfg[name.to_sym] = config[name] }
+        config = cfg
+
+        #camelize
+        type = config[:type].gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase } + 'Store'
+
+        klass = RemoteFiles.const_get(type) rescue nil
+        unless klass
+          require "remote_files/#{config[:type]}_store"
+          klass = RemoteFiles.const_get(type)
+        end
+
+        config.delete(:type)
+
+        add_store(store_identifier.to_sym, :class => klass, :primary => !!config.delete(:primary)) do |store|
+          config.each do |name, value|
+            store[name] = value
+          end
+        end
+      end
+
+      self
+    end
+
+    def 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 stores
+      raise "You need to configure add stores to the #{name} RemoteFiles configuration" if @stores.empty?
+      @stores
+    end
+
+    def lookup_store(store_identifier)
+      @stores_map[store_identifier]
+    end
+
+    def primary_store
+      stores.first
+    end
+
+    def 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 store!(file)
+      store_once!(file) unless file.stored?
+
+      RemoteFiles.synchronize_stores(file) unless file.stored_everywhere?
+
+      true
+    end
+
+    def delete!(file)
+      file.stored_in.each do |store_identifier|
+        store = lookup_store(store_identifier)
+        store.delete!(file.identifier)
+      end
+    end
+
+    def 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 file_from_url(url)
+      stores.each do |store|
+        file = store.file_from_url(url)
+        return file if file
+      end
+    end
+  end
+end

data/lib/remote_files/file.rb

@@ -1,27 +1,26 @@
 module RemoteFiles
   class File
-    attr_reader :content, :content_type, :identifier, :stored_in
+    attr_reader :content, :content_type, :identifier, :stored_in, :configuration
 
     def initialize(identifier, options = {})
-      @identifier   = identifier
-      @stored_in    = options[:stored_in] || []
-      @content      = options.delete(:content)
-      @content_type = options[:content_type]
-      @options      = options
+      @identifier    = identifier
+      @stored_in     = options[:stored_in] || []
+      @content       = options.delete(:content)
+      @content_type  = options[:content_type]
+      @configuration = RemoteFiles::CONFIGURATIONS[options[:configuration] || :default]
+      @options       = options
     end
 
     def self.from_url(url)
-      RemoteFiles.stores.each do |store|
-        file = store.file_from_url(url)
-        return file if file
-      end
+      RemoteFiles.default_configuration.file_from_url(url)
     end
 
     def options
       @options.merge(
-        :identifier   => identifier,
-        :stored_in    => stored_in,
-        :content_type => content_type
+        :identifier    => identifier,
+        :stored_in     => stored_in,
+        :content_type  => content_type,
+        :configuration => configuration.name
       )
     end
 
@@ -34,17 +33,17 @@ module RemoteFiles
     end
 
     def missing_stores
-      RemoteFiles.stores.map(&:identifier) - @stored_in
+      configuration.stores.map(&:identifier) - @stored_in
     end
 
     def url(store_identifier = nil)
-      store = store_identifier ? RemoteFiles.lookup_store(store_identifier) : RemoteFiles.primary_store
+      store = store_identifier ? configuration.lookup_store(store_identifier) : configuration.primary_store
       return nil unless store
       store.url(identifier)
     end
 
     def current_url
-      prioritized_stores = RemoteFiles.stores.map(&:identifier) & @stored_in
+      prioritized_stores = configuration.stores.map(&:identifier) & @stored_in
 
       return nil if prioritized_stores.empty?
 
@@ -52,19 +51,19 @@ module RemoteFiles
     end
 
     def store!
-      RemoteFiles.store!(self)
+      configuration.store!(self)
     end
 
     def store_once!
-      RemoteFiles.store_once!(self)
+      configuration.store_once!(self)
     end
 
     def synchronize!
-      RemoteFiles.synchronize!(self)
+      configuration.synchronize!(self)
     end
 
     def delete!
-      RemoteFiles.delete!(self)
+      configuration.delete!(self)
     end
 
     def delete

data/lib/remote_files/fog_store.rb

@@ -4,14 +4,14 @@ require 'fog'
 module RemoteFiles
   class FogStore < AbstractStore
     def store!(file)
-      sucess = directory.files.create(
+      success = directory.files.create(
         :body         => file.content,
         :content_type => file.content_type,
         :key          => file.identifier,
         :public       => options[:public]
       )
 
-      raise RemoteFiles::Error unless sucess
+      raise RemoteFiles::Error unless success
 
       true
     rescue Fog::Errors::Error, Excon::Errors::Error

data/lib/remote_files/memory_store.rb

@@ -12,8 +12,10 @@ module RemoteFiles
     end
 
     def self.clear!
-      RemoteFiles.stores.each do |store|
-        store.clear! if store.is_a?(RemoteFiles::MemoryStore)
+      RemoteFiles::CONFIGURATIONS.values.each do |config|
+        config.stores.each do |store|
+          store.clear! if store.is_a?(RemoteFiles::MemoryStore)
+        end
       end
     end
 

data/lib/remote_files/version.rb

@@ -1,3 +1,3 @@
 module RemoteFiles
-  VERSION = '1.2.2'
+  VERSION = '1.3.0'
 end

data/lib/remote_files.rb

@@ -1,107 +1,43 @@
 require 'remote_files/version'
-require 'remote_files/fog_store'
+require 'remote_files/configuration'
 require 'remote_files/file'
 
 module RemoteFiles
   class Error < StandardError; end
   class NotFoundError < Error; end
 
-  STORES_MAP = {}
-  STORES = []
+  CONFIGURATIONS = Hash.new do |configs, name|
+    name = name.to_sym
+    configs[name] = Configuration.new(name)
+  end
 
-  def self.add_store(store_identifier, options = {}, &block)
-    store = (options[:class] || FogStore).new(store_identifier)
-    block.call(store) if block_given?
+  def self.default_configuration
+    CONFIGURATIONS[:default]
+  end
 
-    if options[:primary]
-      STORES.unshift(store)
-    else
-      STORES << store
+  def self.configure(name, hash = {})
+    if name.is_a?(Hash)
+      hash = name
+      name = :default
     end
 
-    STORES_MAP[store_identifier] = store
+    CONFIGURATIONS[name].from_hash(hash)
   end
 
-  def self.configure(hash)
-    hash.each do |store_identifier, config|
-      #symbolize_keys!
-      cfg = {}
-      config.each { |name, value| cfg[name.to_sym] = config[name] }
-      config = cfg
-
-      #camelize
-      type = config[:type].gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase } + 'Store'
-
-      klass = RemoteFiles.const_get(type) rescue nil
-      unless klass
-        require "remote_files/#{config[:type]}_store"
-        klass = RemoteFiles.const_get(type)
-      end
-
-      config.delete(:type)
-
-      add_store(store_identifier.to_sym, :class => klass, :primary => !!config.delete(:primary)) do |store|
-        config.each do |name, value|
-          store[name] = value
-        end
-      end
-    end
+  def self.add_store(store_identifier, options = {}, &block)
+    default_configuration.add_store(store_identifier, options, &block)
   end
 
   def self.stores
-    raise "You need to configure add stores to RemoteFiles using 'RemoteFiles.add_store'" if STORES.empty?
-    STORES
+    default_configuration.stores
   end
 
   def self.lookup_store(store_identifier)
-    STORES_MAP[store_identifier]
+    default_configuration.lookup_store(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.delete!(file)
-    file.stored_in.each do |store_identifier|
-      store = lookup_store(store_identifier)
-      store.delete!(file.identifier)
-    end
-  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
+    default_configuration.primary_store
   end
 
   def self.synchronize_stores(file = nil, &block)

data/test/configuration_test.rb

@@ -0,0 +1,178 @@
+require_relative 'test_helper'
+require 'remote_files/mock_store'
+
+describe RemoteFiles::Configuration do
+  before do
+    @configuration = RemoteFiles.configure(:test)
+    @file = RemoteFiles::File.new('file', :configuration => :test, :content => 'content', :content_type => 'text/plain')
+    @mock_store1 = @configuration.add_store(:mock1, :class => RemoteFiles::MockStore)
+    @mock_store2 = @configuration.add_store(:mock2, :class => RemoteFiles::MockStore)
+  end
+
+  describe '::add_store' do
+    describe 'when adding a non-primary store' do
+      before { @non_primary_store = @configuration.add_store(:primary) }
+
+      it 'should add it to the tail of the list of stores' do
+        @configuration.stores.must_equal([@mock_store1, @mock_store2, @non_primary_store])
+      end
+    end
+
+    describe 'when adding a promary store' do
+      before { @primary_store = @configuration.add_store(:primary, :primary => true) }
+
+      it 'should add it to the head of the list of stores' do
+        @configuration.stores.must_equal([@primary_store, @mock_store1, @mock_store2])
+      end
+    end
+  end
+
+  describe '::primary_store' do
+    before do
+      @primary_store1 = @configuration.add_store(:primary1, :primary => true)
+      @primary_store2 = @configuration.add_store(:primary2, :primary => true)
+    end
+
+    it 'should return the head of the list of stores' do
+      @configuration.primary_store.must_equal(@primary_store2)
+    end
+  end
+
+  describe '::lookup_store' do
+    before do
+      @primary_store = @configuration.add_store(:primary, :primary => true)
+    end
+
+    it 'should find the store my identifier' do
+      @configuration.lookup_store(:mock1).must_equal(@mock_store1)
+      @configuration.lookup_store(:mock2).must_equal(@mock_store2)
+      @configuration.lookup_store(:primary).must_equal(@primary_store)
+      @configuration.lookup_store(:unknown).must_be_nil
+    end
+  end
+
+  describe '::store_once!' do
+
+    describe 'when the first store succeeds' do
+      before { @configuration.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)
+        @configuration.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 { @configuration.store_once!(@file) }.must_raise(RemoteFiles::Error)
+      end
+    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
+        @configuration.expects(:store_once!).never
+        @configuration.store!(@file)
+      end
+
+      it 'should synchronize the stores' do
+        RemoteFiles.expects(:synchronize_stores).with(@file)
+        @configuration.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
+        @configuration.expects(:store_once!).never
+        @configuration.store!(@file)
+      end
+
+      it 'should not synchronize the stores' do
+        RemoteFiles.expects(:synchronize_stores).never
+        @configuration.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
+        @file.configuration.expects(:store_once!).with(@file)
+        @configuration.store!(@file)
+      end
+
+      it 'should synchronize the stores' do
+        RemoteFiles.expects(:synchronize_stores).with(@file)
+        @configuration.store!(@file)
+      end
+    end
+  end
+
+  describe '::delete!' do
+    it 'should delete the file from all the stores' do
+      @file.stored_in.replace([:mock1, :mock2])
+      @mock_store1.expects(:delete!).with(@file.identifier)
+      @mock_store2.expects(:delete!).with(@file.identifier)
+      @configuration.delete!(@file)
+    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)
+
+        @configuration.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)
+
+        @configuration.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
+
+        @configuration.synchronize!(@file)
+      end
+    end
+  end
+
+end

data/test/remote_files_test.rb

@@ -1,90 +1,6 @@
 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 = []
@@ -101,93 +17,4 @@ describe RemoteFiles do
     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 '::delete!' do
-    it 'should delete the file from all the stores' do
-      @file.stored_in.replace([:mock1, :mock2])
-      @mock_store1.expects(:delete!).with(@file.identifier)
-      @mock_store2.expects(:delete!).with(@file.identifier)
-      RemoteFiles.delete!(@file)
-    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

@@ -17,7 +17,8 @@ describe RemoteFiles::ResqueJob do
         :identifier => 'identifier',
         :content_type => 'text/plain',
         :stored_in => [:s3],
-        :foo => :bar
+        :foo => :bar,
+        :configuration => :default
       )
 
       RemoteFiles.synchronize_stores(file)

data/test/test_helper.rb

@@ -15,8 +15,9 @@ MiniTest::Spec.class_eval do
   before do
     Fog::Mock.reset
 
-    RemoteFiles::STORES.clear
-    RemoteFiles::STORES_MAP.clear
+    RemoteFiles::CONFIGURATIONS.values.each do |conf|
+      conf.clear
+    end
 
     $syncs = []
     RemoteFiles.synchronize_stores do |file|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: remote_files
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 1.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-12 00:00:00.000000000 Z
+date: 2012-09-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fog
@@ -48,17 +48,17 @@ dependencies:
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.4.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.4.0
 - !ruby/object:Gem::Dependency
   name: debugger
   requirement: !ruby/object:Gem::Requirement
@@ -116,6 +116,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/remote_files/abstract_store.rb
+- lib/remote_files/configuration.rb
 - lib/remote_files/file.rb
 - lib/remote_files/file_store.rb
 - lib/remote_files/fog_store.rb
@@ -124,6 +125,7 @@ files:
 - lib/remote_files/resque_job.rb
 - lib/remote_files/version.rb
 - lib/remote_files.rb
+- test/configuration_test.rb
 - test/file_store_test.rb
 - test/file_test.rb
 - test/fog_store_test.rb
@@ -146,7 +148,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3219444270301945371
+      hash: -1536087519966001179
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -155,7 +157,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3219444270301945371
+      hash: -1536087519966001179
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24
@@ -165,6 +167,7 @@ summary: The purpose of the library is to implement a simple interface for uploa
   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/configuration_test.rb
 - test/file_store_test.rb
 - test/file_test.rb
 - test/fog_store_test.rb