config-factory 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a1f210944b382bc0260157f164e45025db904802
-  data.tar.gz: 9d0d655fbb1a219b3bb22ce320b2fd0480dde335
+  metadata.gz: 6a2b88cc897a3961acfe0506efeae2215de462b8
+  data.tar.gz: 0478ac34202073124995fd797b082bbcfa609551
 SHA512:
-  metadata.gz: 2bd33c114f0cbcb09f70f8aacf9b9ffff28757a20a5d8039e0888d0f8575887d9d2c282c34d703fa39d77aa786c9d01b5a76d623004ce55cf2588231f0364f94
-  data.tar.gz: 7526b42e798652f771d0c094ee574ecab591811bfadd26b5446d333fcd5e62f7e22107cb50c672270ba754a590954d65fe20a9340703cb3f6ebb380359064c76
+  metadata.gz: ac4f9910a57c0cdb78c9052f773cbef06ca811f881af87418103a2861ad5c9c17db8687f9cba42cdc465cb3092e713443ee039cae30705860e0f487692660d94
+  data.tar.gz: 971e76011a0ff96b3607392261bb88f48e708e0745406c7a28067932e8553bbd354690b396177e46a3040be0aa35837c20c96867d4322491f07305d59676a666

data/CHANGES.md

@@ -1,6 +1,11 @@
+## 0.0.8 (4 April 2016)
+
+- Support looking up implementation classes based on an argument
+  filter
+
 ## 0.0.7 (31 March 2016)
 
-- Support direct instantiation of concrete config classes without
+- Support direct instantiation of implementation classes without
   product keys
 
 ## 0.0.6 (16 March 2016)

data/README.md

@@ -9,122 +9,297 @@ A gem for creating configuration classes using the
 [Abstract Factory](https://web.archive.org/web/20111109224959/http://www.informit.com/articles/article.aspx?p=1398599),
 pattern, with run-time configuration provided by hashes or YAML files.
 
-## Example
+- [Factory lookup patterns](#factory-lookup-patterns)
+  - [Looking up concrete factory classes based on a key value](#looking-up-concrete-factory-classes-based-on-a-key-value)
+  - [Finding concrete factory classes based on an argument filter](#finding-concrete-factory-classes-based-on-an-argument-filter)
+  - [Instantiating implementations directly](#instantiating-implementations-directly)
+- [Environments](#environments)
+  - [Multiple environments](#multiple-environments)
+  - [Single environment](#single-environment)
 
-The abstract configuration factory declares a `key`, which is used to look up the concrete
-config class for a given configuration. Concrete implementations register themselves with a
-DSL method named after the `key` value.
+## Factory lookup patterns
 
-In the example below, the `SourceConfig` abstract factory declares the key `:protocol`; the
-concrete classes `OAISourceConfig` and `ResyncSourceConfig` register themselves with
-`protocol: 'OAI'` and `protocol: 'Resync'`, respectively. `SourceConfig.for_environment()`
-will then look for a `protocol:` line in the configuration file to determine which
-registered concrete class to instantiate.
+### Looking up concrete factory classes based on a key value
+
+In the basic use case, an abstract factory class defines a configuration key:
 
 ```ruby
 class SourceConfig
   include Config::Factory
-  key :protocol
+  key :protocol            # <- configuration key
 end
+```
 
-class OAISourceConfig < SourceConfig
-  protocol 'OAI'
+This creates a corresponding DSL method (here `:protocol`), which implementation 
+classes use to register themselves.
 
+```ruby
+class OAISourceConfig < SourceConfig
+  protocol 'OAI'           # <- registers OAISourceConfig as implementation
+                           #    for the "OAI" protocol
   def initialize(oai_base_url:, metadata_prefix:, set: nil, seconds_granularity: false)
+    # ...
   end
 end
 
 class ResyncSourceConfig < SourceConfig
-  protocol 'Resync'
-
+  protocol 'Resync'        # <- registers ResyncSourceConfig as implementation
+                           #    for the "Resync" protocol
   def initialize(capability_list_url:)
+    # ...
   end
 end
 ```
 
-### Single-environment example
-
-Configuration file:
+At run time, `SourceConfig` finds the `protocol:` key in the configuration, and 
+based on the value `'OAI'`, instantiates an `OAISourceConfig`, passing the remaining
+arguments to the `OAISourceConfig` initializer.
 
 ```YAML
 source:
-  protocol: OAI
+  protocol: OAI           # <- indicates we want an OAISourceConfig
+
+  # these arguments will be passed to the OAISourceConfig initializer
   oai_base_url: http://oai.example.org/oai
   metadata_prefix: some_prefix
   set: some_set
   seconds_granularity: true
 ```
 
-Loading:
-
 ```ruby
-environment = Environment.load_file('spec/data/single-environment.yml')
-# => #<Config::Factory::Environment:0x007fe8d3883240 @name=:production, @configs={"source"=>{"protocol"=>"OAI", "oai_base_url"=>"http://oai.example.org/oai", "metadata_prefix"=>"some_prefix", "set"=>"some_set", "seconds_granularity"=>true}}> 
-source_config = SourceConfig.for_environment(environment, :source)
-# => #<OAISourceConfig:0x007fe8d38b3990 @oai_base_url="http://oai.example.org/oai", @metadata_prefix="some_prefix", @set="some_set", @seconds_granularity=true> 
+config = YAML.load_file('config.yml')
+SourceConfig.build_from(config, :source)
+# => #<OAISourceConfig:0x007fc8f14a58f0>
 ```
 
-### Multiple-environment example
+### Finding concrete factory classes based on an argument filter
+
+In some cases (e.g., compatibility with existing configuration files), it may
+be necessary to have the implementation class examine the entire configuration
+hash to determine whether it can support a given configuration.
+
+```ruby
+class PersistenceConfig
+  include Config::Factory
+  # note no configuration key given
+end
+
+class DBPersistenceConfig < PersistenceConfig
+  attr_reader :connection_info
 
-Configuration file:
+  # Applies if we find 'adapter:' in the config file
+  can_build_if { |config| config.key?(:adapter) }
+
+  def initialize(connection_info)
+    @connection_info = connection_info
+  end
+end
+
+class XMLPersistenceConfig < PersistenceConfig
+  attr_reader :connection_info
+
+  # Applies if we find 'path:' in the config file
+  # and its value ends in '.xml'
+  can_build_if do |config|
+    config[:path] && config[:path].end_with?('.xml')
+  end
+
+  def initialize(connection_info)
+    @connection_info = connection_info
+  end
+end
+```
+
+This configuration will build a `DBPersistenceConfig`:
 
 ```YAML
-test:
-  source:
-    protocol: Resync
-    capability_list_url: http://localhost:8888/capabilitylist.xml
+persistence:
+  adapter: sqlite3
+  database: db/development.sqlite3
+  pool: 5
+  timeout: 5000
+```
 
-production:
-  source:
-    protocol: OAI
-    oai_base_url: http://oai.example.org/oai
-    metadata_prefix: some_prefix
-    set: some_set
-    seconds_granularity: true
+```ruby
+config = YAML.load_file('config.yml')
+PersistenceConfig.build_from(config, :persistence)
+# => #<DBPersistenceConfig:0x007fc8f14c4d18>
 ```
 
-Loading:
+Whereas this configuration will build an `XMLConfig`:
+
+```YAML
+persistence:
+  path: config/persistence.xml
+```
 
 ```ruby
-environments = Environments.load_file('spec/data/multiple_environments.yml')
-# => {:test=>#<Config::Factory::Environment:0x007fe8d3863dc8 @name=:test, @configs={"source"=>{"protocol"=>"Resync", "capability_list_url"=>"http://localhost:8888/capabilitylist.xml"}}>, :production=>#<Config::Factory::Environment:0x007fe8d3863be8 @name=:production, @configs={"source"=>{"protocol"=>"OAI", "oai_base_url"=>"http://oai.example.org/oai", "metadata_prefix"=>"some_prefix", "set"=>"some_set", "seconds_granularity"=>true}}>} 
-test_env = environments[:test]
-# => #<Config::Factory::Environment:0x007fe8d383a400 @name=:test, @configs={"source"=>{"protocol"=>"Resync", "capability_list_url"=>"http://localhost:8888/capabilitylist.xml"}}> 
-source_config = SourceConfig.for_environment(test_env, :source)
-# => #<ResyncSourceConfig:0x007fe8d48180c0 @capability_list_url="http://localhost:8888/capabilitylist.xml"> 
+config = YAML.load_file('config.yml')
+PersistenceConfig.build_from(config, :persistence)
+# => #<XMLPersistenceConfig:0x007fc8f14ed420>
 ```
 
-## Config classes with only one implementation
+### Instantiating implementations directly
 
-`config-factory` also supports instantiating concrete configuration classes directly.
-In this case, we simply don't declare a `key` for the class, and the configuration hash
-will be passed directly to the initializer of the concrete class.
+Finally, you may have a mix of abstract and concrete factories, so that some factories
+don't need any lookup and can just be instantiated directly.
 
 ```ruby
-class DBConfig
+class SolrConfig
   include Config::Factory
 
-  def initialize(connection_info)
-    @connection_info = connection_info
+  def initialize(url:, proxy: nil, open_timeout: 60, read_timeout: 120)
+    # ...
   end
 end
 ```
 
 ```YAML
+solr:
+  url: http://solr.example.org/
+  proxy: http://foo:bar@proxy.example.com/
+  open_timeout: 120
+  read_timeout: 300
+```
+
+```ruby
+config = YAML.load_file('config.yml')
+SolrConfig.build_from(config, :solr)
+# => #<SolrConfig:0x007fc8f1504f08>
+```
+
+## Environments
+
+The YAML examples above each show only the configuration for a single factory. However,
+`Config::Factory` also supports a structured configuration file with configurations for
+multiple factories, optionally organized into environments.
+
+### Multiple environments
+
+The `Environments.load_file()` method loads a multi-environment config file as a hash
+of `Environment` instances.
+
+```ruby
+envs = Environments.load_file('config.yml')
+# => {:defaults=>#<Environment:0x007f8e9a578818>,
+#     :development=>#<Environment:0x007f8e9a578728>,
+#     :test=>#<Environment:0x007f8e9a578660>,
+#     :production=>#<Environment:0x007f8e9a578520>}
+test = envs[:test]
+# => #<Environment:0x007f8e9a578660>
+```
+
+The `AbstractFactory.for_environment()` method takes an environment instance and a 
+configuration section name.
+
+```ruby
+source = SourceConfig.for_environment(test, :source)
+# => #<ResyncSourceConfig:0x007f8e9a54a878>
+index = IndexConfig.for_environment(test, :index)
+# => #<SolrConfig:0x007f8e9a5383a8>
+persistence = PersistenceConfig.for_environment(test, :persistence)
+# => #<DBConfig:0x007f8e9a5019e8>
+```
+
+The configuration file for the examples above. Note that standard YAML features such
+as references are supported.
+
+```YAML
+defaults: &defaults
+  source:
+    protocol: OAI
+    oai_base_url: http://oai.example.org/oai
+    metadata_prefix: some_prefix
+    set: some_set
+    seconds_granularity: true
+  index:
+    adapter: solr
+    url: http://solr.example.org/
+    proxy: http://foo:bar@proxy.example.com/
+    open_timeout: 120
+    read_timeout: 300
+
+development:
+  <<: *defaults
+  persistence:
+    adapter: mysql2
+    encoding: utf8
+    pool: 5
+    database: example_dev
+    host: mysql-dev.example.org
+    port: 3306
+  index:
+    adapter: solr
+    url: http://solr-dev.example.org/
+    proxy: http://foo:bar@proxy.example.com/
+    open_timeout: 120
+    read_timeout: 300
+
 test:
-  db:
+  persistence:
     adapter: sqlite3
     database: ':memory:'
     pool: 5
     timeout: 5000
+  source:
+    protocol: Resync
+    capability_list_url: http://localhost:8888/capabilitylist.xml
+  index:
+    adapter: solr
+    url: http://localhost:8000/solr/
 
 production:
-  db:
+  <<: *defaults
+  persistence:
     adapter: mysql2
-    host: mydb.example.org
-    database: myapp
-    username: myuser
-    password: blank
-    port: 3306
     encoding: utf8
+    pool: 5
+    database: example_prod
+    host: mysql.example.org
+    port: 3306
 ```
+
+The `Environments` module supports arbitrary environment names, but the standard ones
+are `:defaults`, `:development`, `:test`, `:stage`, `:staging,` and `:production`. The
+`Environments.load_file` method will warn if none of these are present, as this might
+indicate loading a single-environment config file as multiple by mistake.
+
+### Single environment
+
+For a single-environment config file, use the `load_file()` method on the `Environment`
+class itself (not the `Environments` module, plural):
+
+```ruby
+env = Environment.load_file('config.yml')
+# => #<Environment:0x007f8e9a49b1c0>
+persistence = PersistenceConfig.for_environment(env, :persistence)
+# => #<DBConfig:0x007f8e9a45abe8>
+source = SourceConfig.for_environment(env, :source)
+# => #<OAISourceConfig:0x007f8e9a482fa8>
+index = IndexConfig.for_environment(env, :index)
+# => #<SolrConfig:0x007f8e9a4438a8>
+```
+
+```YAML
+persistence:
+  adapter: mysql2
+  encoding: utf8
+  pool: 5
+  database: example_prod
+  host: mysql-dev.example.org
+  port: 3306
+source:
+  protocol: OAI
+  oai_base_url: http://oai.example.org/oai
+  metadata_prefix: some_prefix
+  set: some_set
+  seconds_granularity: true
+index:
+  adapter: solr
+  url: http://solr.example.org/
+  proxy: http://foo:bar@proxy.example.com/
+  open_timeout: 120
+  read_timeout: 300
+```
+
+By default, a single environment uses the environment name `:production`.

data/lib/config/factory/abstract_factory.rb

@@ -5,16 +5,24 @@ module Config
     end
 
     module AbstractFactory
-      attr_reader :product_key
+      attr_reader :impl_key
 
       def key(k)
-        @product_key = k
-        registry = products
+        @impl_key = k
+        registry = impls_by_key
         define_singleton_method(k) do |v|
           registry[v] = self
         end
       end
 
+      def self.extended(mod)
+        filter_registry = {}
+        mod.define_singleton_method(:can_build_if) do |&block|
+          filter_registry[self] = block
+        end
+        mod.define_singleton_method(:filters_by_impl_class) { filter_registry }
+      end
+
       def for_environment(env, config_name)
         arg_hash = env.args_for(config_name)
         fail ArgumentError, "no #{self} arguments found for config #{config_name} in environment #{env}" unless arg_hash
@@ -26,22 +34,31 @@ module Config
         for_environment(env, config_name)
       end
 
-      def build_from(arg_hash)
+      def build_from(arg_hash, section_name = nil)
         fail ArgumentError, "nil argument hash passed to #{self}.build_from" unless arg_hash
         args = deep_symbolize_keys(arg_hash)
-        product_class = find_product_class(args)
-        product_class.new(args)
+        args = args[section_name] if section_name
+        impl_class = find_impl_class(args)
+        impl_class.new(args)
       end
 
       private
 
-      def find_product_class(args)
-        return self unless product_key
-        fail ArgumentError, "product key #{product_key} not found in argument hash #{args}" unless args.key?(product_key)
-        key_value = args.delete(product_key)
-        product_class = products[key_value]
-        fail ArgumentError, "No #{name} product class found for #{product_key}: #{key_value}" unless product_class
-        product_class
+      def find_impl_class(args)
+        pk = impl_key
+        return impl_for_key(pk, args) if pk
+        filters_by_impl_class.each_pair do |impl_class, filter|
+          return impl_class if filter.call(args)
+        end
+        self
+      end
+
+      def impl_for_key(key_sym, args)
+        fail ArgumentError, "implementation key #{key_sym} not found in argument hash #{args}" unless args.key?(key_sym)
+        key_value = args.delete(key_sym)
+        impl_class = impls_by_key[key_value]
+        fail ArgumentError, "No #{name} implementation found for #{key_sym}: #{key_value}" unless impl_class
+        impl_class
       end
 
       def deep_symbolize_keys(val)
@@ -51,9 +68,10 @@ module Config
         end.to_h
       end
 
-      def products
-        @products ||= {}
+      def impls_by_key
+        @impls_by_key ||= {}
       end
+
     end
   end
 end

data/lib/config/factory/module_info.rb

@@ -4,7 +4,7 @@ module Config
     NAME = 'config-factory'
 
     # The version of this gem
-    VERSION = '0.0.7'
+    VERSION = '0.0.8'
 
     # The copyright notice for this gem
     COPYRIGHT = 'Copyright (c) 2016 The Regents of the University of California'

data/spec/data/multiple-environments.yml

@@ -18,7 +18,7 @@ development:
     adapter: mysql2
     encoding: utf8
     pool: 5
-    database: example_pord
+    database: example_dev
     host: mysql-dev.example.org
     port: 3306
   index:
@@ -47,6 +47,6 @@ production:
     adapter: mysql2
     encoding: utf8
     pool: 5
-    database: example_pord
+    database: example_prod
     host: mysql.example.org
     port: 3306

data/spec/data/raw-section.yml

@@ -0,0 +1,5 @@
+persistence:
+  adapter: sqlite3
+  database: db/production.sqlite3
+  pool: 5
+  timeout: 5000

data/spec/data/single-environment.yml

@@ -1,8 +1,8 @@
-db:
+persistence:
   adapter: mysql2
   encoding: utf8
   pool: 5
-  database: example_pord
+  database: example_prod
   host: mysql-dev.example.org
   port: 3306
 source:

data/spec/unit/config/factory/abstract_factory_spec.rb

@@ -7,31 +7,59 @@ module Config
       describe '#build_from' do
         it 'builds the correct class with the correct config' do
           config_hash = { protocol: 'OAI', oai_base_url: 'http://oai.example.org/oai', metadata_prefix: 'some_prefix', set: 'some_set', seconds_granularity: true }
-          product = SourceConfig.build_from(config_hash)
-          expect(product).to be_an(OAISourceConfig)
+          impl = SourceConfig.build_from(config_hash)
+          expect(impl).to be_an(OAISourceConfig)
           args = { oai_base_url: URI('http://oai.example.org/oai'), metadata_prefix: 'some_prefix', set: 'some_set', seconds_granularity: true }
           args.each do |k, v|
-            expect(product.send(k)).to eq(v)
+            expect(impl.send(k)).to eq(v)
           end
         end
 
-        it 'raises a sensible exception if no product found for the key' do
+        it 'raises a sensible exception if no impl found for the key' do
           config_hash = { protocol: 'Elvis' }
           expect { SourceConfig.build_from(config_hash) }.to raise_error(ArgumentError, /SourceConfig.*protocol.*Elvis/)
         end
 
-        it 'supports concrete factories without product keys' do
+        it 'supports implementation factories without impl keys' do
           config_hash = {
             adapter: 'mysql2',
             encoding: 'utf8',
             pool: 5,
-            database: 'example_pord',
+            database: 'example_prod',
             host: 'mysql-dev.example.org',
             port: 3306
           }
-          product = DBConfig.build_from(config_hash)
-          expect(product).to be_a(DBConfig)
-          expect(product.connection_info).to eq(config_hash)
+          impl = MysqlConfig.build_from(config_hash)
+          expect(impl).to be_a(MysqlConfig)
+          expect(impl.connection_info).to eq(config_hash)
+        end
+
+        it "can build a class without a declared key, so long as it's registered" do
+          config_hash = {
+            adapter: 'mysql2',
+            encoding: 'utf8',
+            pool: 5,
+            database: 'example_prod',
+            host: 'mysql-dev.example.org',
+            port: 3306
+          }
+          impl = PersistenceConfig.build_from(config_hash)
+          expect(impl).to be_a(DBConfig)
+          expect(impl.connection_info).to eq(config_hash)
+        end
+
+        it 'works with section headers' do
+          expected_info = {
+            adapter: 'sqlite3',
+            database: 'db/production.sqlite3',
+            pool: 5,
+            timeout: 5000
+          }
+
+          hash = YAML.load_file('spec/data/raw-section.yml')
+          impl = PersistenceConfig.build_from(hash, :persistence)
+          expect(impl).to be_a(DBConfig)
+          expect(impl.connection_info).to eq(expected_info)
         end
       end
 
@@ -41,15 +69,15 @@ module Config
           env = instance_double(Environment)
           expect(env).to receive(:args_for).with(:source) { config_hash }
 
-          product = SourceConfig.for_environment(env, :source)
-          expect(product).to be_an(OAISourceConfig)
+          impl = SourceConfig.for_environment(env, :source)
+          expect(impl).to be_an(OAISourceConfig)
           args = { oai_base_url: URI('http://oai.example.org/oai'), metadata_prefix: 'some_prefix', set: 'some_set', seconds_granularity: true }
           args.each do |k, v|
-            expect(product.send(k)).to eq(v)
+            expect(impl.send(k)).to eq(v)
           end
         end
 
-        it 'raises a sensible exception if no product found for the key' do
+        it 'raises a sensible exception if no impl found for the key' do
           config_hash = { protocol: 'Elvis' }
           env = instance_double(Environment)
           expect(env).to receive(:args_for).with(:source) { config_hash }
@@ -59,11 +87,11 @@ module Config
 
       describe '#from_file' do
         it 'builds the correct class with the correct config' do
-          product = SourceConfig.from_file('spec/data/single-environment.yml', :source)
-          expect(product).to be_an(OAISourceConfig)
+          impl = SourceConfig.from_file('spec/data/single-environment.yml', :source)
+          expect(impl).to be_an(OAISourceConfig)
           args = { oai_base_url: URI('http://oai.example.org/oai'), metadata_prefix: 'some_prefix', set: 'some_set', seconds_granularity: true }
           args.each do |k, v|
-            expect(product.send(k)).to eq(v)
+            expect(impl.send(k)).to eq(v)
           end
         end
       end

data/spec/unit/config/factory/environment_spec.rb

@@ -44,6 +44,9 @@ module Config
           env = Environment.load_file('spec/data/single-environment.yml')
           expect(env).to be_an(Environment)
           expect(env.name).to eq(Environments::DEFAULT_ENVIRONMENT)
+
+          pers = PersistenceConfig.for_environment(env, :persistence)
+          expect(pers).to be_a(DBConfig)
         end
 
         it 'raises an error for malformed files' do
@@ -70,7 +73,7 @@ module Config
               'adapter' => 'mysql2',
               'encoding' => 'utf8',
               'pool' => 5,
-              'database' => 'example_pord',
+              'database' => 'example_prod',
               'host' => 'mysql-dev.example.org',
               'port' => 3306
             },

data/spec/unit/config/factory/environments_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require_relative 'fixtures'
 
 module Config
   module Factory
@@ -16,6 +17,53 @@ module Config
           end
         end
 
+        it 'supports YAML references' do
+          envs = Environments.load_file('spec/data/multiple-environments.yml')
+
+          defaults = envs[:defaults]
+          source_default = SourceConfig.for_environment(defaults, :source)
+          expect(source_default).to be_an(OAISourceConfig)
+          expect(source_default.source_uri).to eq(URI('http://oai.example.org/oai'))
+          index_default = IndexConfig.for_environment(defaults, :index)
+          expect(index_default).to be_a(SolrConfig)
+          expect(index_default.uri).to eq(URI('http://solr.example.org/'))
+
+          development = envs[:development]
+          source_dev = SourceConfig.for_environment(development, :source)
+          expect(source_dev).to be_an(OAISourceConfig)
+          expect(source_dev.source_uri).to eq(URI('http://oai.example.org/oai'))
+          persistence_dev = PersistenceConfig.for_environment(development, :db)
+          expect(persistence_dev).to be_a(DBConfig)
+          expect(persistence_dev.connection_info[:adapter]).to eq('mysql2')
+          expect(persistence_dev.connection_info[:database]).to eq('example_dev')
+          index_dev = IndexConfig.for_environment(development, :index)
+          expect(index_dev).to be_a(SolrConfig)
+          expect(index_dev.uri).to eq(URI('http://solr-dev.example.org/'))
+
+          test = envs[:test]
+          persistence_test = PersistenceConfig.for_environment(test, :db)
+          expect(persistence_test).to be_a(DBConfig)
+          expect(persistence_test.connection_info[:adapter]).to eq('sqlite3')
+          source_test = SourceConfig.for_environment(test, :source)
+          expect(source_test).to be_a(ResyncSourceConfig)
+          expect(source_test.source_uri).to eq(URI('http://localhost:8888/capabilitylist.xml'))
+          index_test = IndexConfig.for_environment(test, :index)
+          expect(index_test).to be_a(SolrConfig)
+          expect(index_test.uri).to eq(URI('http://localhost:8000/solr/'))
+
+          production = envs[:production]
+          source_production = SourceConfig.for_environment(production, :source)
+          expect(source_production).to be_an(OAISourceConfig)
+          expect(source_production.source_uri).to eq(URI('http://oai.example.org/oai'))
+          index_production = IndexConfig.for_environment(production, :index)
+          expect(index_production).to be_a(SolrConfig)
+          expect(index_production.uri).to eq(URI('http://solr.example.org/'))
+          persistence_production = PersistenceConfig.for_environment(production, :db)
+          expect(persistence_production).to be_a(DBConfig)
+          expect(persistence_production.connection_info[:adapter]).to eq('mysql2')
+          expect(persistence_production.connection_info[:database]).to eq('example_prod')
+        end
+
         it 'reads a standard ActiveRecord DB config' do
           envs = Environments.load_file('spec/data/db-config.yml')
           expect(envs).to be_a(Hash)

data/spec/unit/config/factory/fixtures.rb

@@ -36,12 +36,42 @@ class ResyncSourceConfig < SourceConfig
   attr_reader :capability_list_url
 
   def initialize(capability_list_url:)
-    super(url: capability_list_url)
+    super(source_url: capability_list_url)
     @capability_list_url = source_uri
   end
 end
 
-class DBConfig
+# PersistenceConfig
+
+class PersistenceConfig
+  include Config::Factory
+end
+
+class DBConfig < PersistenceConfig
+  attr_reader :connection_info
+
+  can_build_if { |config| config.key?(:adapter) }
+
+  def initialize(connection_info)
+    @connection_info = connection_info
+  end
+end
+
+class XMLConfig < PersistenceConfig
+  attr_reader :connection_info
+
+  can_build_if do |config|
+    config[:path] && config[:path].end_with?('.xml')
+  end
+
+  def initialize(connection_info)
+    @connection_info = connection_info
+  end
+end
+
+# MysqlConfig
+
+class MysqlConfig
   include Config::Factory
 
   attr_reader :connection_info
@@ -66,7 +96,7 @@ class IndexConfig
 end
 
 class SolrConfig < IndexConfig
-  adapter 'Solr'
+  adapter 'solr'
 
   attr_reader :url
   attr_reader :proxy

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: config-factory
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors:
 - David Moles
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-31 00:00:00.000000000 Z
+date: 2016-04-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -122,6 +122,7 @@ files:
 - spec/.rubocop.yml
 - spec/data/db-config.yml
 - spec/data/multiple-environments.yml
+- spec/data/raw-section.yml
 - spec/data/single-environment.yml
 - spec/spec_helper.rb
 - spec/unit/config/factory/abstract_factory_spec.rb
@@ -157,6 +158,7 @@ test_files:
 - spec/.rubocop.yml
 - spec/data/db-config.yml
 - spec/data/multiple-environments.yml
+- spec/data/raw-section.yml
 - spec/data/single-environment.yml
 - spec/spec_helper.rb
 - spec/unit/config/factory/abstract_factory_spec.rb