econfig 0.1.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a7e3bc4fa45ea6ef51d0dce442bf13f51d2d4ba4
-  data.tar.gz: d870600bc13249713c6b91ac7e5a92a74cbf1537
+  metadata.gz: 5c5fb4ddc1d04e679fa21343c08f42bbe036033b
+  data.tar.gz: 2bbfcc7f840f8332c6257cc7a97937284c78a607
 SHA512:
-  metadata.gz: b1145170d7baccae21942224722b5c8efd02315133a7d8179c545fdd0f6b0288d11f93412b93c7ff02029b66976bd789fb7e85a2f7d09a301cae27cd6d5ce837
-  data.tar.gz: cee5b2354df7abf3185749e9805873747b241b8264e12e4cc96e4d87c5e457887f6c684ef2874c9ff98b2bec894ff634dff85ffc4fd0fbf754e97f1c3f7a2584
+  metadata.gz: 62fa0da6fb4838ccca0e12f48c2ee9f8b91ce4641554a3b1f2c88315f09b7b68816170e5a10fa1f684cda33e07a28f78d40d7a59d01cf505993d542fb05c5d0d
+  data.tar.gz: 5f00b0e0828f7084f589ecae5d8ba0594555db22a5d6a6d4d4012099438dee17e3620acfa4ef58e42d4ad8d1df0e4687472ac8adb5c1aca43f815cfa6c4714b2

data/README.md

@@ -1,53 +1,48 @@
 # Econfig
 
-Econfig is a gem which allows you to easily configure your Rails applications
+Econfig is a gem which allows you to easily configure your Ruby applications
 in a multitude of ways.
 
 ## Installation
 
-Add this to your gemfile:
+Add this to your Gemfile:
 
 ``` ruby
-gem "econfig", :require => "econfig/rails"
+gem "econfig"
 ```
 
-## Accessing config options
-
-Econfig extends the Rails configuration, you can use it like this:
+If you're using Rails, you'll want to require the Rails extension:
 
 ``` ruby
-MyApp::Application.config.app.aws_access_key
+gem "econfig", require: "econfig/rails"
 ```
 
-Where `MyApp` is the name of your application and `aws_access_key` is whatever
-property you want to access. We recommend you add the shortcut module so you
-can access config options directly:
+## Accessing config options
+
+Extend your main application module with the Econfig shortcut. In Rails, you'll
+want to add this in `config/application.rb`:
 
 ``` ruby
 module MyApp
   extend Econfig::Shortcut
 
-  …
+  class Application < Rails::Application
+    …
+  end
 end
 ```
 
-In `config/application.rb`. This will give you:
+Now you can access configuration like this:
 
 ``` ruby
-MyApp.aws_access_key_id
+MyApp.config.aws_access_key_id
 ```
 
-which is obviously way more convenient. The rest of this README is going to
-assume that you added this shortcut.
-
-## Forcing an option to exist
-
-Sometimes you want the application to crash early when a given config option is
-not set. Just add a bang (!) after the option name, and an error will be thrown
-if it is not set to a value which is present.
+If the key you accessed is not configured, Econfig will raise an error. To
+access optional configuration, which can be nil, use brackets:
 
 ``` ruby
-MyApp.aws_access_key_id!
+MyApp.config[:aws_access_key_id]
 ```
 
 ## Configuring options.
@@ -58,14 +53,16 @@ You can specify configuration through:
 2. Redis
 3. Relational database
 4. YAML files
+5. OSX Keychain
 
-This allows you to set up econfig on most kinds of hosting solutions
+This allows you to set up Econfig on most kinds of hosting solutions
 (EngineYard, Heroku, etc) without any additional effort, and to switch between
-them easily. The options are listed in descending order of preference.
+them easily.
 
 ### ENV variables
 
-Just set an environment variable whose name is the name of the option being accessed uppercased.
+Just set an environment variable whose name is the name of the option being
+accessed uppercased.
 
 For example:
 
@@ -73,14 +70,46 @@ For example:
 AWS_ACCESS_KEY_ID=xyz rails server
 ```
 
+You can now read it like this:
+
+``` ruby
+MyApp.config.aws_access_key_id # => "xyz"
+```
+
 This is especially convenient for Heroku.
 
+### YAML
+
+Add a yaml file to `config/app.yml`. This should have a similar layout to `config/database.yml`:
+
+``` yaml
+development:
+  aws_access_key_id: "xyz"
+  aws_secret_access_key: "xyz"
+production:
+  aws_access_key_id: "xyz"
+  aws_secret_access_key: "xyz"
+```
+
+Econfig also reads configuration from `config/secret.yml` which is the new
+standard for secret configuration parameters in Rails 4.1.
+
 ### Relational database
 
-This needs to be explicitly enabled. In `config/application.rb` add this line:
+This needs to be explicitly enabled. In `config/application.rb` add this code:
+
+``` ruby
+require "econfig/active_record"
+Econfig.backends.insert_after :env, :db, Econfig::ActiveRecord.new
+```
+
+You probably want environment variables to take precendence over configuration
+from ActiveRecord, hence the `insert_after`. If you'd rather have ActiveRecord
+configuration take precendence you can use this instead:
 
 ``` ruby
-Econfig.use_database
+require "econfig/active_record"
+Econfig.backends.unshift :db, Econfig::ActiveRecord.new
 ```
 
 You will also need to create a migration to create the necessary database tables:
@@ -90,41 +119,45 @@ rails generate econfig:migration
 rake db:migrate
 ```
 
-You can now set options by assigning them:
+### Redis
+
+This needs to be explicitly enabled. In `config/application.rb` add this code:
 
 ``` ruby
-MyApp.aws_access_key_id = "xyz"
+require "econfig/redis"
+redis = Redis.new(:host => "myredis.com")
+Econfig.backends.insert_after :env, :redis, Econfig::Redis.new(redis)
 ```
 
-You may not use both Redis and relational database storage at the same time.
+If you wish to namespace your keys in Redis, you can use [redis namespace](http://rubygems.org/gems/redis-namespace).
 
-### Redis
+### OSX Keychain
 
-This needs to be explicitly enabled. In `config/application.rb` add this line:
+For the OSX keychain backend, see [econfig-keychain](https://github.com/elabs/econfig-keychain).
 
-``` ruby
-Econfig.use_redis Redis.new(:host => "myredis.com")
-```
+## Setting values
 
-You can now set options by assigning them:
+You can set options by simply assigning them:
 
 ``` ruby
-MyApp.aws_access_key_id = "xyz"
+MyApp.config[:aws_access_key_id] = "xyz"
 ```
 
-You may not use both Redis and relational database storage at the same time.
+This will set the value in the default write backend, which by default is
+`:memory`. This means that by default, configuration which is set like this is
+not persisted in any way.
 
-### YAML
+If you always want to assign values to a different backend, for example the
+database backend, you can set the default write backend like this:
 
-Add a yaml file to `config/app.yml`. This should have a similar layout to `config/database.yml`:
+``` ruby
+Econfig.default_write_backend = :db
+```
 
-``` yaml
-development:
-  aws_access_key_id: "xyz"
-  aws_secret_access_key: "xyz"
-production:
-  aws_access_key_id: "xyz"
-  aws_secret_access_key: "xyz"
+You can also explicitly supply the backend when setting a configuration value:
+
+``` ruby
+MyApp.config[:db, :aws_access_key_id] = "xyz"
 ```
 
 ## License

data/Rakefile

@@ -1 +1,6 @@
 require "bundler/gem_tasks"
+
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new
+
+task default: :spec

data/econfig.gemspec

@@ -18,6 +18,9 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
+  gem.required_ruby_version = "~> 2.0"
+
+  gem.add_development_dependency "rake"
   gem.add_development_dependency "rspec"
   gem.add_development_dependency "activerecord"
   gem.add_development_dependency "sqlite3"

data/lib/econfig.rb

@@ -1,29 +1,25 @@
+require "forwardable"
 require "econfig/version"
 require "econfig/memory"
 require "econfig/yaml"
 require "econfig/env"
 require "econfig/configuration"
 require "econfig/shortcut"
+require "econfig/backend_collection"
 
 module Econfig
   class NotFound < StandardError; end
   class UninitializedError < StandardError; end
 
   class << self
+    extend Forwardable
+
     attr_accessor :root, :env, :instance
 
-    def use_database
-      require "econfig/active_record"
-      Econfig.instance.backends << Econfig::ActiveRecord.new
-    end
-
-    def use_redis(redis)
-      require "econfig/redis"
-      Econfig.instance.backends << Econfig::Redis.new(redis)
-    end
+    def_delegators :instance, :backends, :default_write_backend, :default_write_backend=
 
     def init
-      Econfig.instance.backends.each do |backend|
+      backends.each do |backend|
         backend.init if backend.respond_to?(:init)
       end
     end
@@ -31,5 +27,9 @@ module Econfig
 end
 
 Econfig.instance = Econfig::Configuration.new
-Econfig.instance.backends << Econfig::ENV.new
-Econfig.instance.backends << Econfig::YAML.new
+
+Econfig.default_write_backend = :memory
+Econfig.backends.use :memory, Econfig::Memory.new
+Econfig.backends.use :env, Econfig::ENV.new
+Econfig.backends.use :secret, Econfig::YAML.new("config/secret.yml")
+Econfig.backends.use :yaml, Econfig::YAML.new("config/app.yml")

data/lib/econfig/backend_collection.rb

@@ -0,0 +1,61 @@
+module Econfig
+  class BackendCollection
+    include Enumerable
+
+    def initialize
+      @backends = []
+    end
+
+    def [](name)
+      pair = @backends.assoc(name)
+      pair.last if pair
+    end
+
+    def each
+      if block_given?
+        @backends.each { |(name, backend)| yield backend }
+      else
+        enum_for { @backends.length }
+      end
+    end
+
+    def push(name, backend)
+      exists‽(name)
+      @backends.push([name, backend])
+    end
+    alias_method :use, :push
+
+    def unshift(name, backend)
+      exists‽(name)
+      @backends.unshift([name, backend])
+    end
+
+    def insert_before(other, name, backend)
+      exists‽(name)
+      @backends.insert(index_of!(other), [name, backend])
+    end
+
+    def insert_after(other, name, backend)
+      exists‽(name)
+      @backends.insert(index_of!(other) + 1, [name, backend])
+    end
+
+    def delete(name)
+      @backends.delete_at(index_of!(name))
+    end
+
+  private
+
+    def exists‽(name)
+      raise KeyError, "#{name} is already set" if index_of(name)
+    end
+
+    def index_of!(name)
+      index_of(name) or raise KeyError, "#{name} is not set"
+    end
+
+    def index_of(name)
+      @backends.index(@backends.assoc(name))
+    end
+  end
+end

data/lib/econfig/configuration.rb

@@ -1,35 +1,44 @@
 module Econfig
   class Configuration
+    attr_accessor :default_write_backend
+
     def backends
-      @backends ||= []
+      @backends ||= BackendCollection.new
     end
 
-    def get(key)
-      backend = backends.find { |backend| backend.get(key) }
-      backend.get(key) if backend
+    def fetch(key)
+      self[key] or raise Econfig::NotFound, "configuration key '#{key}' is not set"
     end
 
-    def get!(key)
-      get(key) or raise Econfig::NotFound, "configuration key '#{key}' is not set"
+    def [](key)
+      backends.each do |backend|
+        value = backend.get(key.to_s)
+        return value if value
+      end
+      nil
     end
 
-    def set(key, value)
-      backend = backends.find { |backend| backend.respond_to?(:set) }
-      backend.set(key, value) if backend
+    def []=(backend_name = default_write_backend, key, value)
+      raise ArgumentError, "no backend given" unless backend_name
+      if backend = backends[backend_name]
+        backend.set(key, value)
+      else
+        raise KeyError, "#{backend_name} is not set"
+      end
     end
 
     def method_missing(name, *args)
-      if name.to_s.end_with?("=")
-        set(name.to_s.sub(/=$/, ""), args.first)
-      elsif name.to_s.end_with?("!")
-        get!(name.to_s.sub(/!$/, ""))
+      if respond_to?(name)
+        raise ArgumentError, "too many arguments (#{args.length} for 0)" if args.length > 0
+        fetch(name)
       else
-        get(name.to_s)
+        super
       end
     end
 
-    def respond_to?(*)
-      true
+    def respond_to_missing?(name, *)
+      name = name.to_s
+      not(name.end_with?("=") or name.end_with?("!") or name.end_with?("?"))
     end
   end
 end

data/lib/econfig/redis.rb

@@ -5,11 +5,11 @@ module Econfig
     end
 
     def get(key)
-      @redis.get("econfig_#{key}")
+      @redis.get(key)
     end
 
     def set(key, value)
-      @redis.set("econfig_#{key}", value)
+      @redis.set(key, value)
     end
   end
 end

data/lib/econfig/shortcut.rb

@@ -1,11 +1,7 @@
 module Econfig
   module Shortcut
-    def method_missing(name, *args)
-      Econfig.instance.send(name, *args)
-    end
-
-    def respond_to?(*)
-      true
+    def config
+      Econfig.instance
     end
   end
 end

data/lib/econfig/version.rb

@@ -1,3 +1,3 @@
 module Econfig
-  VERSION = "0.1.1"
+  VERSION = "1.0.0"
 end

data/lib/econfig/yaml.rb

@@ -1,6 +1,6 @@
 module Econfig
   class YAML
-    def initialize(path="config/app.yml")
+    def initialize(path)
       @path = path
     end
 
@@ -10,8 +10,9 @@ module Econfig
 
     def init
       require "yaml"
+      require "erb"
       if File.exist?(path)
-        @options = ::YAML.load_file(path)[Econfig.env]
+        @options = ::YAML.load(::ERB.new(File.read(path)).result)[Econfig.env]
       else
         @options = {}
       end

data/spec/backend_collection_spec.rb

@@ -0,0 +1,101 @@
+describe Econfig::Configuration do
+  let(:collection) { Econfig::BackendCollection.new }
+  let(:memory) { double("memory") }
+  let(:yaml) { double("yaml") }
+
+  describe "#[]" do
+    it "retrieves a backend" do
+      collection.push :memory, memory
+      collection[:memory].should equal(memory)
+    end
+  end
+
+  describe "#each" do
+    it "can be called without a block to receive an enumerator" do
+      collection.push :memory, memory
+      collection.each.take(1).should eq([memory])
+    end
+  end
+
+  describe "#push" do
+    it "adds a new backend at the bottom" do
+      collection.push :memory, memory
+      collection.push :yaml, yaml
+      collection.to_a.should eq([memory, yaml])
+    end
+
+    it "is aliased as `use`" do
+      collection.use :memory, memory
+      collection.use :yaml, yaml
+      collection.to_a.should eq([memory, yaml])
+    end
+
+    it "raises an error if backend already exist" do
+      collection.push :memory, memory
+      expect { collection.push :memory, yaml }.to raise_error(KeyError, "memory is already set")
+    end
+  end
+
+  describe "#unshift" do
+    it "adds a new backend at the top" do
+      collection.unshift :memory, memory
+      collection.unshift :yaml, yaml
+      collection.to_a.should eq([yaml, memory])
+    end
+
+    it "raises an error if backend already exist" do
+      collection.unshift :memory, memory
+      expect { collection.unshift :memory, yaml }.to raise_error(KeyError, "memory is already set")
+    end
+  end
+
+  describe "#insert_before" do
+    it "adds a new before the given backend" do
+      collection.push :quox, :quox
+      collection.push :baz, :baz
+      collection.push :foo, :foo
+      collection.insert_before :baz, :memory, memory
+      collection.to_a.should eq([:quox, memory, :baz, :foo])
+    end
+
+    it "raises an error if the backend does not exist" do
+      expect { collection.insert_before :baz, :memory, memory }.to raise_error(KeyError, /baz is not set/)
+    end
+
+    it "raises an error if the backend already exists" do
+      collection.push :foo, :foo
+      expect { collection.insert_before :foo, :foo, memory }.to raise_error(KeyError, /foo is already set/)
+    end
+  end
+
+  describe "#insert_after" do
+    it "adds a new after the given backend" do
+      collection.push :quox, :quox
+      collection.push :baz, :baz
+      collection.push :foo, :foo
+      collection.insert_after :baz, :memory, memory
+      collection.to_a.should eq([:quox, :baz, memory, :foo])
+    end
+
+    it "raises an error if the backend does not exist" do
+      expect { collection.insert_after :baz, :memory, memory }.to raise_error(KeyError, /baz is not set/)
+    end
+
+    it "raises an error if the backend already exists" do
+      collection.push :foo, :foo
+      expect { collection.insert_after :foo, :foo, memory }.to raise_error(KeyError, /foo is already set/)
+    end
+  end
+
+  describe "#delete" do
+    it "removes the given backend" do
+      collection.push :memory, memory
+      collection.delete :memory
+      collection[:memory].should be_nil
+    end
+
+    it "raises an error if the backend does not exist" do
+      expect { collection.delete :redis }.to raise_error(KeyError, /redis is not set/)
+    end
+  end
+end

data/spec/config/app.yml

@@ -1,2 +1,3 @@
 test:
   quox: baz
+  envir: '<%= ENV['ECONFIG_EXAMPLE'] %>'

data/spec/configuration_spec.rb

@@ -3,76 +3,109 @@ describe Econfig::Configuration do
   let(:other_backend) { double }
   let(:config) { Econfig::Configuration.new }
 
-  before { config.backends.push(backend, other_backend) }
+  before do
+    config.backends.push(:one, backend)
+    config.backends.push(:other, other_backend)
+  end
 
-  describe "#get" do
+  describe "#[]" do
     it "returns response from first backend" do
       backend.stub(:get).with("foobar").and_return("elephant")
-      config.get("foobar").should == "elephant"
+      config["foobar"].should == "elephant"
     end
 
     it "tries multiple backends until it finds a response" do
       backend.stub(:get).with("foobar").and_return(nil)
       other_backend.stub(:get).with("foobar").and_return("elephant")
-      config.get("foobar").should == "elephant"
+      config["foobar"].should == "elephant"
     end
 
     it "returns nil if the key can't be found in any backend" do
       backend.stub(:get).with("foobar").and_return(nil)
       other_backend.stub(:get).with("foobar").and_return(nil)
-      config.get("foobar").should == nil
+      config["foobar"].should == nil
     end
   end
 
-  describe "#get!" do
+  describe "#[]=" do
+    it "sets response on given backend" do
+      backend.should_receive(:set).with("foobar", "elephant")
+      config[:one, "foobar"] = "elephant"
+    end
+
+    it "sets response on default backend if default backend is set" do
+      config.default_write_backend = :other
+      other_backend.should_receive(:set).with("foobar", "elephant")
+      config["foobar"] = "elephant"
+    end
+
+    it "raises an error if no backend given and no default backend is set" do
+      config.default_write_backend = nil
+      expect { config["foobar"] = "elephant" }.to raise_error(ArgumentError, "no backend given")
+    end
+
+    it "raises an error if the backend does not exist" do
+      expect { config[:does_not_exist, "foobar"] = "elephant" }.to raise_error(KeyError, "does_not_exist is not set")
+    end
+  end
+
+  describe "#fetch" do
     it "returns response from first backend" do
       backend.stub(:get).with("foobar").and_return("elephant")
-      config.get!("foobar").should == "elephant"
+      config.fetch("foobar").should == "elephant"
     end
 
     it "tries multiple backends until it finds a response" do
       backend.stub(:get).with("foobar").and_return(nil)
       other_backend.stub(:get).with("foobar").and_return("elephant")
-      config.get!("foobar").should == "elephant"
+      config.fetch("foobar").should == "elephant"
     end
 
     it "raises error if the key can't be found in any backend" do
       backend.stub(:get).with("foobar").and_return(nil)
       other_backend.stub(:get).with("foobar").and_return(nil)
-      expect { config.get!("foobar") }.to raise_error(Econfig::NotFound)
+      expect { config.fetch("foobar") }.to raise_error(Econfig::NotFound)
     end
   end
 
-  describe "#set" do
-    it "sets response on first backend" do
-      backend.should_receive(:set).with("foobar", "elephant")
-      config.set("foobar", "elephant")
+  describe "#method_missing" do
+    it "calls fetch for normal methods" do
+      backend.stub(:get).with("foobar").and_return("elephant")
+      config.foobar.should == "elephant"
     end
 
-    it "skips backends which don't have a set method" do
-      other_backend.should_receive(:set).with("foobar", "elephant")
-      config.set("foobar", "elephant")
+    it "raises NoMethodError for bang methods" do
+      expect { config.foobar! }.to raise_error(NoMethodError)
+    end
+
+    it "raises NoMethodError for query methods" do
+      expect { config.foobar? }.to raise_error(NoMethodError)
     end
 
-    it "does nothing when no backend has a setter method" do
-      config.set("foobar", "elephant")
+    it "raises NoMethodError for setter methods" do
+      expect { config.foobar = "bar" }.to raise_error(NoMethodError)
+    end
+
+    it "raises an error when giving arguments to a getter" do
+      expect { config.foobar "Hey" }.to raise_error(ArgumentError, "too many arguments (1 for 0)")
     end
   end
 
-  describe "#method_missing" do
-    it "calls get for normal methods" do
-      config.should_receive(:get).with("foobar").and_return("elephant")
-      config.foobar.should == "elephant"
+  describe "#respond_to?" do
+    it "return true for normal methods" do
+      config.should respond_to(:foobar)
+    end
+
+    it "return false for bang methods" do
+      config.should_not respond_to(:foobar!)
     end
 
-    it "calls get! for bang methods" do
-      config.should_receive(:get!).with("foobar").and_return("elephant")
-      config.foobar!.should == "elephant"
+    it "return false for query methods" do
+      config.should_not respond_to(:foobar?)
     end
 
-    it "calls set for assignment methods" do
-      config.should_receive(:set).with("foobar", "elephant")
-      config.foobar = "elephant"
+    it "return false for assignment methods" do
+      config.should_not respond_to(:foobar=)
     end
   end
 end

data/spec/redis_spec.rb

@@ -14,7 +14,7 @@ describe Econfig::Redis do
     end
 
     it "fetches a previously persisted option" do
-      redis.set("econfig_foo", "bar")
+      redis.set("foo", "bar")
       backend.get("foo").should == "bar"
     end
 
@@ -26,7 +26,7 @@ describe Econfig::Redis do
   describe "#set" do
     it "persists keys to database" do
       backend.set("foo", "bar")
-      redis.get("econfig_foo").should == "bar"
+      redis.get("foo").should == "bar"
     end
   end
 end

data/spec/shortcut_spec.rb

@@ -2,15 +2,9 @@ describe Econfig::Shortcut do
   let(:mod) { Module.new }
   before { mod.extend Econfig::Shortcut }
 
-  describe "#method_missing" do
-    it "proxies getters to the Econfig instance" do
-      Econfig.instance.should_receive(:get).with("foobar").and_return("elephant")
-      mod.foobar.should == "elephant"
-    end
-
-    it "proxies bang methods to the Econfig instance" do
-      Econfig.instance.should_receive(:get!).with("foobar").and_return("elephant")
-      mod.foobar!.should == "elephant"
+  describe "#config" do
+    it "should be the econfig instance" do
+      mod.config.should equal(Econfig.instance)
     end
   end
 end

data/spec/yaml_spec.rb

@@ -1,5 +1,5 @@
 describe Econfig::YAML do
-  let(:backend) { Econfig::YAML.new.tap(&:init) }
+  let(:backend) { Econfig::YAML.new("config/app.yml").tap(&:init) }
   describe "#get" do
     it "fetches option from yaml config file" do
       backend.get("quox").should == "baz"
@@ -13,5 +13,19 @@ describe Econfig::YAML do
       backend = Econfig::YAML.new("/does/not/exist").tap(&:init)
       backend.get("does_not_exist").should be_nil
     end
+
+    it "evaluates the YAML config as ERB" do
+      with_env do
+        ENV['ECONFIG_EXAMPLE'] = "onment"
+        backend.get("envir").should == "onment"
+      end
+    end
+
+    def with_env(&block)
+      original = ENV.to_hash
+      yield if block_given?
+    ensure
+      ENV.replace(original)
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: econfig
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Jonas Nicklas
@@ -9,8 +9,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-01 00:00:00.000000000 Z
+date: 2014-05-26 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  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
@@ -85,6 +99,7 @@ files:
 - econfig.gemspec
 - lib/econfig.rb
 - lib/econfig/active_record.rb
+- lib/econfig/backend_collection.rb
 - lib/econfig/configuration.rb
 - lib/econfig/env.rb
 - lib/econfig/memory.rb
@@ -97,6 +112,7 @@ files:
 - lib/generators/econfig/migration/migration_generator.rb
 - lib/generators/econfig/migration/templates/migration.rb
 - spec/active_record_spec.rb
+- spec/backend_collection_spec.rb
 - spec/config/app.yml
 - spec/configuration_spec.rb
 - spec/env_spec.rb
@@ -115,9 +131,9 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - "~>"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -131,6 +147,7 @@ specification_version: 4
 summary: Congifure Ruby apps
 test_files:
 - spec/active_record_spec.rb
+- spec/backend_collection_spec.rb
 - spec/config/app.yml
 - spec/configuration_spec.rb
 - spec/env_spec.rb
@@ -139,3 +156,4 @@ test_files:
 - spec/shortcut_spec.rb
 - spec/spec_helper.rb
 - spec/yaml_spec.rb
+has_rdoc: