envconfig 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bab3863c92e99c5ec5099cf70cea3610bff70573
-  data.tar.gz: ab4889f5e57ec968e69132bce59c0c1e1e062059
+  metadata.gz: 4ae15014bb2a42caac46541701ad0eeedecf4945
+  data.tar.gz: 291af5950eae465a0ebe2a411374ddcde9ddff16
 SHA512:
-  metadata.gz: f2635ee6821835730fbe326bd40eebde910429ead9346034740bcfe0d2be969dfdd20a1083692054f5321e315538d9395cd516a1a9cff204073a8770591ef227
-  data.tar.gz: e17b8d96f140dc99061f40f3d5f5e1eb68158fc5ebfa80ae6c692a70f6066c35c7a57637288ee76174ad81e7ddbc4c037a8bb7e0086f0be05cce3998463b2da1
+  metadata.gz: 5d227e3a0307aad586efe1dc3c81ee7f089920fbea191ff6e0f00a9659f7c6c8089745e1fda711d56316e299446b4c307d8eb7db809d1077a6033deaaf02265b
+  data.tar.gz: 9ef22e14457b7fc0297061d0a9a97fb1f1cf1bf45701d8dbb4c5135772cc3082cf1aa2ede4163a99699e9c0e0fc544c3fd76eaff034bc462a7f4b558c8cf5fc4

data/README.md

@@ -17,12 +17,13 @@ POSTMARK_API_KEY="bcca0a78abbaed6533f3c8017b804bda"
 Then envconfig's SMTP configuration will look like this:
 
 ```ruby
-Envconfig.load(ENV).smtp.to_h # =>
+Envconfig.load.smtp.to_h # =>
 {
-  "address" => "smtp.example.org",
-  "port" => 25,
-  "username" => "bcca0a78abbaed6533f3c8017b804bda",
-  "password" => "bcca0a78abbaed6533f3c8017b804bda",
+  port: "25",
+  authentication: :plain,
+  address: "smtp.example.org",
+  user_name: "bcca0a78abbaed6533f3c8017b804bda",
+  password: "bcca0a78abbaed6533f3c8017b804bda"
 }
 ```
 
@@ -41,17 +42,106 @@ or `gem install envconfig`.
 Add `envconfig-rails` to your `Gemfile` and go.
 
 If you're not using Rails, add the base `envconfig` gem, and access the
-normalized configuration directly.
+configuration like this:
+
+```ruby
+Envconfig.load.smtp[:address]  => "example.org"
+Envconfig.load.smtp.to_h  # => {address: "example.org", ...}
+```
 
 
 ## Supported Add-ons
 
+### Database
+
+* Generic (`DATABASE_URL` in `ENV`)
+
+Database example:
+
+```ruby
+ENV["DATABASE_URL"] = "postgres://ab:secret@example.org:1234/db?encoding=utf-8"
+
+Envconfig.load.database.to_h # =>
+{
+  url: "postgres://ab:secret@example.org:1234/db?encoding=utf-8",
+  adapter: "postgresql",
+  database: "db",
+  username: "ab",
+  password: "secret",
+  host: "example.org",
+  port: 1234,
+  encoding: "utf-8"
+}
+
+
+```
+
+
 ### SMTP
 
 * Postmark ([Broadstack](https://broadstack.com/addons/postmark), [Heroku](https://addons.heroku.com/postmark))
 * Mandrill ([Heroku](https://addons.heroku.com/mandrill))
 * SendGrid ([Heroku](https://addons.heroku.com/sendgrid))
-* Custom (`SMTP_HOST`, `SMTP_PORT`, `SMTP_USERNAME`, `SMTP_PASSWORD` in `ENV`)
+* Mailgun ([Heroku](https://address.Heroku.com/mailgun))
+* Generic (`SMTP_HOST`, `SMTP_PORT`, `SMTP_USERNAME`, `SMTP_PASSWORD` in `ENV`)
+
+SMTP example:
+
+```ruby
+ENV["MANDRILL_USERNAME"] = "mandrilluser"
+ENV["MANDRILL_APIKEY"] = SecureRandom.hex
+
+Envconfig.load.smtp.to_h # =>
+{
+  address: "smtp.mandrillapp.com",
+  port: "587",
+  user_name: "mandrilluser",
+  password: "14941007dfdc2af76e2fafe1383cf33b"
+}
+```
+
+### memcached
+
+* MemCachier ([Broadstack](https://broadstack.com/addons/memcachier), [Heroku](https://addons.heroku.com/memcachier))
+
+memcached example:
+
+```ruby
+ENV["MEMCACHIER_SERVERS"] = "a.example.org:11211,b.example.com:11211"
+ENV["MEMCACHIER_USERNAME"] = "memcachieruser"
+ENV["MEMCACHIER_PASSWORD"] = SecureRandom.hex
+
+Envconfig.load.memcached.to_h # =>
+{
+  servers: "a.example.org:11211,b.example.com:11211",
+  username: "memcachieruser",
+  password: "9d1d72d6828ed59bab3d1496da71ba59",
+  server_strings: ["a.example.org:11211", "b.example.com:11211"]
+}
+```
+
+
+### Redis
+
+* openredis ([Heroku](https://addons.heroku.com/openredis))
+* RedisCloud ([Heroku](https://addons.heroku.com/rediscloud))
+* RedisGreen ([Heroku](https://addons.heroku.com/redisgreen))
+* Redis To Go ([Heroku](https://addons.heroku.com/redistogo))
+
+Redis example:
+
+```ruby
+ENV["OPENREDIS_URL"] = "redis://:secrettoken@127.0.0.1:6379"
+
+Envconfig.load.redis.to_h # =>
+{
+  url: "redis://:secrettoken@127.0.0.1:6379",
+  host: "127.0.0.1",
+  port: 6379,
+  user: "",
+  password: "secrettoken",
+}
+```
 
 
 ## Contributing

data/lib/envconfig/database.rb

@@ -0,0 +1,32 @@
+module Envconfig
+  class Database
+
+    include Service
+
+    def self.providers
+      [
+        Generic,
+      ]
+    end
+
+    class Generic
+      include Provider
+      def mapping
+        {url: "DATABASE_URL"}
+      end
+      def filter_config(config)
+        url = UrlParser.new(config[:url])
+        parts = url.extract_as(
+          adapter: ->(u){ (u.scheme || "").sub(/\Apostgres\z/, "postgresql") },
+          database: ->(u){ (u.path || "").split("/")[1] },
+          username: :user,
+          password: :password,
+          host: :host,
+          port: :port,
+        )
+        config.merge!(parts).merge!(url.query_values)
+      end
+    end
+
+  end
+end

data/lib/envconfig/memcached.rb

@@ -0,0 +1,30 @@
+module Envconfig
+  class Memcached
+
+    include Service
+
+    def self.providers
+      [
+        Memcachier,
+      ]
+    end
+
+    class Memcachier
+      include Provider
+      def name; "MemCachier" end
+      def mapping
+        {
+          servers: "MEMCACHIER_SERVERS",
+          username: "MEMCACHIER_USERNAME",
+          password: "MEMCACHIER_PASSWORD",
+        }
+      end
+      def filter_config(hash)
+        hash.merge!(
+          server_strings: hash[:servers].split(",")
+        )
+      end
+    end
+
+  end
+end

data/lib/envconfig/provider.rb

@@ -42,7 +42,12 @@ module Envconfig
 
     # The configuration derived from the environment for this provider.
     def config
-      static.merge(dynamic)
+      filter_config(static.merge(dynamic))
+    end
+
+    # A hook for arbitrary changes to the config hash.
+    def filter_config(config)
+      config
     end
 
     private

data/lib/envconfig/redis.rb

@@ -0,0 +1,61 @@
+require "uri"
+
+module Envconfig
+  class Redis
+
+    include Service
+
+    def self.providers
+      [
+        Openredis,
+        Rediscloud,
+        Redisgreen,
+        Redistogo,
+      ]
+    end
+
+    module ConfigFilter
+      def filter_config(config)
+        url = UrlParser.new(config[:url])
+        config.merge!(url.extract(:host, :port, :user, :password))
+      end
+    end
+
+    class Openredis
+      include Provider
+      include ConfigFilter
+      def name; "openredis" end
+      def mapping
+        {url: "OPENREDIS_URL"}
+      end
+    end
+
+    class Rediscloud
+      include Provider
+      include ConfigFilter
+      def name; "Redis Cloud" end
+      def mapping
+        {url: "REDISCLOUD_URL"}
+      end
+    end
+
+    class Redisgreen
+      include Provider
+      include ConfigFilter
+      def name; "RedisGreen" end
+      def mapping
+        {url: "REDISGREEN_URL"}
+      end
+    end
+
+    class Redistogo
+      include Provider
+      include ConfigFilter
+      def name; "Redis To Go" end
+      def mapping
+        {url: "REDISTOGO_URL"}
+      end
+    end
+
+  end
+end

data/lib/envconfig/smtp.rb

@@ -5,7 +5,8 @@ module Envconfig
 
     def self.providers
       [
-        Custom,
+        Generic,
+        Mailgun,
         Mandrill,
         Postmark,
         Sendgrid,
@@ -13,7 +14,7 @@ module Envconfig
     end
 
     # A custom configuration, for local or self-managed SMTP servers.
-    class Custom
+    class Generic
       include Provider
       def valid?
         mapping.values.any? { |k| env.key?(k) } #any? instead of #all?
@@ -28,6 +29,18 @@ module Envconfig
       end
     end
 
+    class Mailgun
+      include Provider
+      def mapping
+        {
+          port: "MAILGUN_SMTP_PORT",
+          address: "MAILGUN_SMTP_SERVER",
+          user_name: "MAILGUN_SMTP_LOGIN",
+          password: "MAILGUN_SMTP_PASSWORD",
+        }
+      end
+    end
+
     class Mandrill
       include Provider
       def mapping

data/lib/envconfig/url_parser.rb

@@ -0,0 +1,50 @@
+require "uri"
+require "cgi"
+
+module Envconfig
+  class UrlParser
+
+    def initialize(url)
+      @url = url
+    end
+
+    # Extract the given keys verbatim from the URL.
+    # These map to public instance methods on URI.
+    def extract(*keys)
+      keys.inject({}) do |hash, key|
+        hash.merge!(key => parsed_url.public_send(key))
+      end
+    end
+
+    # Extract and rename the given keys.
+    # The mapping keys are the wanted keys, the mapping values
+    # are public instance methods on URI.
+    def extract_as(mapping)
+      mapping.inject({}) do |hash, (key, method)|
+        hash.merge!(key => extract_value(method))
+      end
+    end
+
+    # Query string as hash with symbol keys.
+    def query_values
+      CGI.parse(parsed_url.query || "").inject({}) do |hash, (key, values)|
+        hash.merge!(key.to_sym => values.first)
+      end
+    end
+
+    private
+
+    def parsed_url
+      @_parsed_url ||= URI.parse(@url)
+    end
+
+    def extract_value(method)
+      if method.respond_to?(:call)
+        method.call(parsed_url)
+      else
+        parsed_url.public_send(method)
+      end
+    end
+
+  end
+end

data/lib/envconfig/version.rb

@@ -1,3 +1,3 @@
 module Envconfig
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/lib/envconfig.rb

@@ -1,11 +1,17 @@
-require "envconfig/provider"
 require "envconfig/service"
+require "envconfig/provider"
+require "envconfig/url_parser"
+
+require "envconfig/database"
+require "envconfig/memcached"
+require "envconfig/redis"
 require "envconfig/smtp"
+
 require "envconfig/version"
 
 module Envconfig
 
-  def self.load(env)
+  def self.load(env = ENV)
     Root.new(env)
   end
 
@@ -13,14 +19,60 @@ module Envconfig
 
     def initialize(env)
       @env = env
+      @_services = {}
+    end
+
+    def to_h
+      [
+        :database,
+        :memcached,
+        :redis,
+        :smtp,
+      ].inject({}) do |hash, service|
+        hash.merge!(service => public_send(service).to_h)
+      end
+    end
+
+    def database
+      service_for(:database, Database)
+    end
+
+    def database?
+      predicate_for(:database)
+    end
+
+    def memcached
+      service_for(:memcached, Memcached)
+    end
+
+    def memcached?
+      predicate_for(:memcached)
+    end
+
+    def redis
+      service_for(:redis, Redis)
+    end
+
+    def redis?
+      predicate_for(:redis)
     end
 
     def smtp
-      @_smtp ||= ::Envconfig::Smtp.new(@env)
+      service_for(:smtp, Smtp)
     end
 
     def smtp?
-      smtp.to_h.any?
+      predicate_for(:smtp)
+    end
+
+    private
+
+    def service_for(name, klass)
+      @_services[name] || klass.new(@env)
+    end
+
+    def predicate_for(name)
+      public_send(name).to_h.any?
     end
 
   end

data/spec/database_spec.rb

@@ -0,0 +1,36 @@
+require "spec_helper"
+
+describe "database configuration" do
+
+  database_url = "postgres://user:pass@example.org:5432/db?a=b&c=d"
+
+  let(:env) { {} }
+  let(:config) { Envconfig.load(env).database }
+
+  context "with nothing relevant in ENV" do
+    it_behaves_like "empty configuration"
+  end
+
+  context "with DATABASE_URL='#{database_url}' in ENV" do
+    before do
+      env["DATABASE_URL"] = database_url
+    end
+
+    {
+      url: database_url,
+      adapter: "postgresql", # transformed like heroku-buildpack-ruby
+      database: "db",
+      username: "user",
+      password: "pass",
+      host: "example.org",
+      port: 5432,
+      a: "b",
+      c: "d",
+    }.each do |key, value|
+      it "sets :#{key} to #{value.inspect}" do
+        expect(config[key]).to eq(value)
+      end
+    end
+  end
+
+end

data/spec/envconfig_spec.rb

@@ -0,0 +1,17 @@
+require "spec_helper"
+
+describe Envconfig do
+
+  it "loads from an ENV-like hash" do
+    result = Envconfig.load({"KEY" => "value"})
+    expect(result.class).to eq(Envconfig::Root)
+  end
+
+  # I don't want to modify or make assumptions about ENV,
+  # but at least test that Envconfig.load() handles zero arguments.
+  it "loads without an argument (defaulting to ENV)" do
+    result = Envconfig.load()
+    expect(result.class).to eq(Envconfig::Root)
+  end
+
+end

data/spec/memcached_spec.rb

@@ -0,0 +1,31 @@
+require "spec_helper"
+
+describe "memcached configuration" do
+
+  let(:env) { {} }
+  subject(:config) { Envconfig.load(env).memcached }
+
+  context "with nothing relevant in ENV" do
+    it_behaves_like "empty configuration"
+  end
+
+  context "with MemCachier in ENV" do
+    before do
+      env["MEMCACHIER_SERVERS"] = "m1.example.org:11211,m2.example.org:11211"
+      env["MEMCACHIER_USERNAME"] = "memcachieruser"
+      env["MEMCACHIER_PASSWORD"] = "memcachierpass"
+    end
+
+    {
+      servers: "m1.example.org:11211,m2.example.org:11211",
+      username: "memcachieruser",
+      password: "memcachierpass",
+      server_strings: ["m1.example.org:11211", "m2.example.org:11211"],
+    }.each do |key, value|
+      it "sets :#{key} to #{value.inspect}" do
+        expect(config[key]).to eq(value)
+      end
+    end
+  end
+
+end

data/spec/redis_spec.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+
+describe "redis configuration" do
+
+  let(:env) { {} }
+  subject(:config) { Envconfig.load(env).redis }
+
+  context "with nothing relevant in ENV" do
+    it_behaves_like "empty configuration"
+  end
+
+  %w{
+    OPENREDIS_URL
+    REDISCLOUD_URL
+    REDISGREEN_URL
+    REDISTOGO_URL
+  }.each do |env_key|
+    it_behaves_like "redis configuration", env_key
+  end
+
+end

data/spec/root_spec.rb

@@ -3,27 +3,120 @@ require "spec_helper"
 describe Envconfig::Root do
 
   let(:env) { {} }
-  subject(:root) { Envconfig.load(env) }
+  subject(:root) { Envconfig::Root.new(env) }
 
   context "with nothing in ENV" do
 
-    describe "#smtp?" do
-      it "is false" do
-        expect(root.smtp?).to eq(false)
+    service_methods = [
+      :database,
+      :memcached,
+      :redis,
+      :smtp,
+    ]
+
+    service_methods.each do |service_method|
+      predicate_method = :"#{service_method}?"
+
+      describe "##{predicate_method}" do
+        it "is false" do
+          expect(root.public_send(predicate_method)).to eq(false)
+        end
       end
-    end
 
-    describe "#smtp" do
-      [:to_h, :provider, :[]].each do |m|
-        it "responds to :#{m}" do
-          expect(root.smtp.respond_to?(m)).to eq(true)
+      describe "##{service_method}" do
+        [:to_h, :provider, :[]].each do |m|
+          it "claims to respond to :#{m}" do
+            expect(root.smtp.respond_to?(m)).to eq(true)
+          end
+        end
+        it "has an empty #to_h result" do
+          expect(root.smtp.to_h).to eq({})
+        end
+        it "responds to #provider with an object with no name" do
+          expect(root.smtp.provider.name).to eq(nil)
         end
       end
-      it "has an empty #to_h result" do
-        expect(root.smtp.to_h).to eq({})
+    end
+
+    describe "#to_h" do
+      it "returns a nested hash of all configuration" do
+        expect(root.to_h).to eq(
+          database: {},
+          memcached: {},
+          redis: {},
+          smtp: {},
+        )
       end
     end
 
   end
 
+  context "with all of the things in ENV" do
+    let(:env) do
+      # Note: actual precedence is defined in the service classes,
+      # generally based on alphabetical sorting.
+      # This example ENV intentionally mixes up the precedence ordering.
+      # e.g. the Redis services match their actual precedence,
+      # but the SMTP services reverse their actual precedence.
+      {
+        "DATABASE_URL" => "postgres://u:p@db.example.org:1234/db",
+        "MEMCACHIER_SERVERS" => "mc.example.org:11211",
+        "MEMCACHIER_USERNAME" => "mcuser",
+        "MEMCACHIER_PASSWORD" => "mcpass",
+        "OPENREDIS_URL" => "redis://:orpass@or.example.org:2345",
+        "REDISTOGO_URL" => "redis://:rtgpass@rtg.example.org:3456",
+        "SENDGRID_USERNAME" => "sguser",
+        "SENDGRID_PASSWORD" => "sgpass",
+        "POSTMARK_SMTP_SERVER" => "pm.example.org",
+        "POSTMARK_API_KEY" => "pmkey",
+      }
+    end
+
+    {
+      database: "Generic",
+      memcached: "MemCachier",
+      redis: "openredis",
+      smtp: "Postmark"
+    }.each do |service, name|
+      it "configures #{service} with #{name}" do
+        expect(root.public_send(service).provider.name).to eq(name)
+      end
+    end
+
+    it "has a giant #to_h" do
+      expect(root.to_h).to eq(
+        database: {
+          url: "postgres://u:p@db.example.org:1234/db",
+          adapter: "postgresql",
+          database: "db",
+          username: "u",
+          password: "p",
+          host: "db.example.org",
+          port: 1234
+        },
+        memcached: {
+          servers: "mc.example.org:11211",
+          username: "mcuser",
+          password: "mcpass",
+          server_strings: ["mc.example.org:11211"]
+        },
+        redis: {
+          url: "redis://:orpass@or.example.org:2345",
+          host: "or.example.org",
+          port: 2345,
+          user: "",
+          password: "orpass"
+        },
+        smtp: {
+          port: "25",
+          authentication: :plain,
+          address: "pm.example.org",
+          user_name: "pmkey",
+          password: "pmkey"
+        }
+      )
+    end
+
+  end
+
 end

data/spec/shared_examples.rb

@@ -0,0 +1,37 @@
+shared_examples "empty configuration" do
+
+  it "returns nil for keys" do
+    [:url, :test].each do |k|
+      expect(config[k]).to eq(nil)
+    end
+  end
+
+  it "responds to #to_h with empty hash" do
+    expect(config.to_h).to eq({})
+  end
+
+  it "has nil provider name" do
+    expect(config.provider.name).to eq(nil)
+  end
+
+end
+
+shared_examples "redis configuration" do |env_key|
+  context "with openredis in ENV" do
+    before do
+      env[env_key] = "redis://:secrettoken@127.0.0.1:1234"
+    end
+
+    {
+      url: "redis://:secrettoken@127.0.0.1:1234",
+      host: "127.0.0.1",
+      port: 1234,
+      user: "",
+      password: "secrettoken",
+    }.each do |key, value|
+      it "sets :#{key} to #{value.inspect}" do
+        expect(config[key]).to eq(value)
+      end
+    end
+  end
+end

data/spec/smtp_spec.rb

@@ -6,16 +6,26 @@ describe "SMTP configuration" do
   subject(:config) { Envconfig.load(env).smtp }
 
   context "with nothing relevant in ENV" do
-    it "returns nil for keys" do
-      [:address, :port, :user_name, :password].each do |k|
-        expect(config[k]).to eq(nil)
-      end
+    it_behaves_like "empty configuration"
+  end
+
+  context "with Mailgun in ENV" do
+    before do
+      env['MAILGUN_SMTP_PORT'] = 2468
+      env['MAILGUN_SMTP_SERVER'] = "mailgun.example.org"
+      env['MAILGUN_SMTP_LOGIN'] = "mailgunuser"
+      env['MAILGUN_SMTP_PASSWORD'] = "a493216c9ced751d6bc38fd6f5c3930b"
     end
-    it "responds to #to_h with empty hash" do
-      expect(config.to_h).to eq({})
+    it "identifies as Mailgun" do
+      expect(config.provider.name).to eq("Mailgun")
     end
-    it "has nil provider name" do
-      expect(config.provider.name).to eq(nil)
+    it "sets port, address, user_name, password" do
+      expect(config.to_h).to eq(
+        address: "mailgun.example.org",
+        port: 2468,
+        user_name: "mailgunuser",
+        password: "a493216c9ced751d6bc38fd6f5c3930b",
+      )
     end
   end
 
@@ -27,7 +37,7 @@ describe "SMTP configuration" do
     it "sets address, port, user_name, password" do
       expect(config.to_h).to eq(
         address: "smtp.mandrillapp.com",
-        port: "25",
+        port: "587",
         user_name: "mandrilluser",
         password: "mandrillkey",
       )

data/spec/spec_helper.rb

@@ -1 +1,3 @@
 require "envconfig"
+
+require "shared_examples"

data/spec/url_parser_spec.rb

@@ -0,0 +1,44 @@
+require "spec_helper"
+
+module Envconfig
+  describe UrlParser do
+
+    let(:url) { "postgres://john:pass@a.example.org:1234/db?a=b&c=d" }
+    subject(:parser) { UrlParser.new(url) }
+
+    describe "#extract" do
+      it "returns hash of requested keys" do
+        expect(parser.extract(:password, :host, :port)).to eq(
+          password: "pass",
+          host: "a.example.org",
+          port: 1234
+        )
+      end
+    end
+
+    describe "#extract_as" do
+      it "returns hash with renamed keys" do
+        result = parser.extract_as(
+          adapter: ->(u){ u.scheme.sub(/\Apostgres\z/, "postgresql") },
+          username: :user,
+          port: :port,
+        )
+        expect(result).to eq(
+          adapter: "postgresql",
+          username: "john",
+          port: 1234,
+        )
+      end
+    end
+
+    describe "#query_values" do
+      it "returns query string as a hash with symbol keys" do
+        expect(parser.query_values).to eq(
+          a: "b",
+          c: "d"
+        )
+      end
+    end
+
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: envconfig
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Paul Annesley
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-15 00:00:00.000000000 Z
+date: 2013-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -70,15 +70,25 @@ files:
 - envconfig.gemspec
 - lib/envconfig-rails.rb
 - lib/envconfig.rb
+- lib/envconfig/database.rb
+- lib/envconfig/memcached.rb
 - lib/envconfig/provider.rb
 - lib/envconfig/railtie.rb
+- lib/envconfig/redis.rb
 - lib/envconfig/service.rb
 - lib/envconfig/smtp.rb
+- lib/envconfig/url_parser.rb
 - lib/envconfig/version.rb
+- spec/database_spec.rb
+- spec/envconfig_spec.rb
+- spec/memcached_spec.rb
 - spec/provider_resolver_spec.rb
+- spec/redis_spec.rb
 - spec/root_spec.rb
+- spec/shared_examples.rb
 - spec/smtp_spec.rb
 - spec/spec_helper.rb
+- spec/url_parser_spec.rb
 homepage: https://github.com/broadstack/envconfig
 licenses:
 - MIT
@@ -104,8 +114,14 @@ signing_key:
 specification_version: 4
 summary: Connect your app to backing services via Broadstack/Heroku-style ENV vars.
 test_files:
+- spec/database_spec.rb
+- spec/envconfig_spec.rb
+- spec/memcached_spec.rb
 - spec/provider_resolver_spec.rb
+- spec/redis_spec.rb
 - spec/root_spec.rb
+- spec/shared_examples.rb
 - spec/smtp_spec.rb
 - spec/spec_helper.rb
+- spec/url_parser_spec.rb
 has_rdoc: