whiskey_disk 0.6.22 → 0.6.23

data/spec/whiskey_disk/config/filters/normalize_ssh_options_filter_spec.rb

@@ -0,0 +1,56 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'spec_helper.rb'))
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'lib', 'whiskey_disk', 'config'))
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'lib', 'whiskey_disk', 'config', 'filters', 'normalize_ssh_options_filter'))
+
+describe 'normalizing SSH options' do
+  before do
+    @config = WhiskeyDisk::Config.new
+    @filter = WhiskeyDisk::Config::NormalizeSshOptionsFilter.new(@config)
+  end
+    
+  it 'eliminates ssh options with nil, or empty values' do
+    @data = {
+      'domain' => [
+        { 'name' => 'foo', 'ssh_options' => nil },
+        { 'name' => 'bar', 'ssh_options' => '' },
+        { 'name' => 'baz', 'ssh_options' => [] },
+        { 'name' => 'xyzzy', 'ssh_options' => ['', ''] },
+        { 'name' => 'quux', 'ssh_options' => [nil, '', nil] },
+      ]
+    }
+    
+    @filter.filter(@data).should == {
+      'domain' => [
+        { 'name' => 'foo' },
+        { 'name' => 'bar' },
+        { 'name' => 'baz' },
+        { 'name' => 'xyzzy' },
+        { 'name' => 'quux' }
+      ]
+    }
+  end
+  
+  it 'preserves non-empty ssh options' do
+    @data = {
+      'domain' => [
+        { 'name' => 'foo', 'ssh_options' => nil },
+        { 'name' => 'bar', 'ssh_options' => 'c' },
+        { 'name' => 'baz', 'ssh_options' => [] },
+        { 'name' => 'xyzzy', 'ssh_options' => ['', 'c'] },
+        { 'name' => 'quux', 'ssh_options' => [nil, '', 'a', nil, 'b' ] },
+        { 'name' => 'wut', 'ssh_options' => [nil, '', 'x', 'a', 'a', nil, 'b' ] },
+      ]
+    }
+    
+    @filter.filter(@data).should == {
+      'domain' => [
+        { 'name' => 'foo' },
+        { 'name' => 'bar', 'ssh_options' => [ 'c' ] },
+        { 'name' => 'baz' },
+        { 'name' => 'xyzzy', 'ssh_options' => [ 'c' ] },
+        { 'name' => 'quux', 'ssh_options' => [ 'a', 'b' ] },
+        { 'name' => 'wut', 'ssh_options' => [ 'x', 'a', 'a', 'b' ] }
+      ]
+    }
+  end
+end

data/spec/whiskey_disk/config/filters/project_scope_filter_spec.rb

@@ -0,0 +1,75 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'spec_helper.rb'))
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'lib', 'whiskey_disk', 'config'))
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'lib', 'whiskey_disk', 'config', 'filters', 'project_scope_filter'))
+
+describe 'filtering configuration data by adding project scoping' do
+  before do
+    ENV['to'] = @env = 'foo:staging'
+
+    @config = WhiskeyDisk::Config.new
+    @filter = WhiskeyDisk::Config::ProjectScopeFilter.new(@config)
+
+    @bare_data  = { 'staging' => { 'repository' => 'git://foo/bar.git', 'domain' => [ { :name => 'ogc@ogtastic.com' } ] } }
+    @proj_data  = { 'foo' => @bare_data }
+  end
+
+  it 'fails if the configuration data is not a hash' do
+    lambda { @filter.filter([]) }.should.raise
+  end
+
+  describe 'when no project name is specified via ENV["to"]' do
+    before do
+      ENV['to'] = @env = 'staging'
+    end
+
+    it 'returns the original data if it has both project and environment scoping' do
+      @filter.filter(@proj_data).should == @proj_data
+    end
+
+    describe 'when no project name is specified in the bare config hash' do
+      it 'returns the original data wrapped in project scope, using a dummy project, if it has environment scoping but no project scoping' do
+        @filter.filter(@bare_data).should == { 'unnamed_project' => @bare_data }
+      end
+    end
+
+    describe 'when a project name is specified in the bare config hash' do
+      before do
+        @bare_data['staging']['project'] = 'whiskey_disk'
+      end
+
+      it 'returns the original data wrapped in project scope if it has environment scoping but no project scoping' do
+        @filter.filter(@bare_data).should == { 'whiskey_disk' => @bare_data }
+      end
+    end
+  end
+
+  describe 'when a project name is specified via ENV["to"]' do
+    before do
+      ENV['to'] = @env = 'whiskey_disk:staging'
+    end
+  
+    describe 'when a project name is not specified in the bare config hash' do
+      it 'returns the original data if it has both project and environment scoping' do
+        @filter.filter(@proj_data).should == @proj_data
+      end
+  
+      it 'returns the original data wrapped in project scope if it has environment scoping but no project scoping' do
+        @filter.filter(@bare_data).should == { 'whiskey_disk' => @bare_data }
+      end
+    end
+  
+    describe 'when a project name is specified in the bare config hash' do
+      before do
+        @bare_data['staging']['project'] = 'whiskey_disk'
+      end
+  
+      it 'returns the original data if it has both project and environment scoping' do
+        @filter.filter(@proj_data).should == @proj_data
+      end
+  
+      it 'returns the original data wrapped in project scope if it has environment scoping but no project scoping' do
+        @filter.filter(@bare_data).should == { 'whiskey_disk' => @bare_data }
+      end
+    end
+  end 
+end

data/spec/whiskey_disk/config/filters/select_project_and_environment_filter_spec.rb

@@ -0,0 +1,30 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'spec_helper.rb'))
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'lib', 'whiskey_disk', 'config'))
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'lib', 'whiskey_disk', 'config', 'filters', 'select_project_and_environment_filter'))
+
+describe 'filtering configuration data by selecting the data for the project and environment' do
+  before do
+    @config = WhiskeyDisk::Config.new
+    @filter = WhiskeyDisk::Config::SelectProjectAndEnvironmentFilter.new(@config)
+    
+    @data = { 
+      'project' => { 'environment' => { 'a' => 'b' } },
+      'other'   => { 'missing' => { 'c' => 'd' } },
+    }
+  end
+  
+  it 'fails when the specified project cannot be found' do
+    ENV['to'] = @env = 'something:environment'
+    lambda { @filter.filter(@data) }.should.raise
+  end
+
+  it 'fails when the specified environment cannot be found for the specified project' do
+    ENV['to'] = @env = 'other:environment'
+    lambda { @filter.filter(@data) }.should.raise
+  end
+
+  it 'returns only the data for the specified project and environment' do
+    ENV['to'] = @env = 'project:environment'
+    @filter.filter(@data).should == @data['project']['environment']
+  end
+end

data/spec/whiskey_disk/config/filters/stringify_hash_keys_filter_spec.rb

@@ -0,0 +1,40 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'spec_helper.rb'))
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'lib', 'whiskey_disk', 'config'))
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'lib', 'whiskey_disk', 'config', 'filters', 'stringify_hash_keys_filter'))
+
+describe 'filtering configuration data to only have symbol hash keys' do
+  before do
+    @config = WhiskeyDisk::Config.new
+    @filter = WhiskeyDisk::Config::StringifyHashKeysFilter.new(@config)
+    @data = { 
+      'a' => {
+        :x => 'y',
+        'c' => 'd',
+        :e => {
+          'f' => ['a', 'b', 'c']
+        }
+      },
+      :b => [ '1', '2', '3' ]
+    }
+  end
+  
+  it 'recursively stringifies hash keys in the provided data structure' do
+    @filter.filter(@data).should == {
+      'a' => {
+        'x' => 'y',
+        'c' => 'd',
+        'e' => {
+          'f' => [ 'a', 'b', 'c' ]
+        }
+      },
+      'b' => [ '1', '2', '3' ]
+    }
+  end
+  
+  it 'clones value data so that the original data structure is not shared' do
+    original = @data.clone
+    result = @filter.filter(@data)
+    result['a']['e']['f'] << 'd'
+    @data.should == original
+  end
+end

data/spec/whiskey_disk/config_spec.rb

@@ -21,126 +21,130 @@ end
 
 # class for testing .open calls -- for use with URL config paths
 class TestURLConfig < WhiskeyDisk::Config
-  def self.open
-    raise
+  def set_response(data)
+    @fake_response = YAML.dump(data)
   end
-end
 
-def set_config_url_response(data)
-  TestURLConfig.stub!(:open).and_return(YAML.dump(data))
+  def open(path)
+    @fake_response || raise
+  end
 end
 
 describe WhiskeyDisk::Config do
+  before do
+    @config = WhiskeyDisk::Config.new
+  end
+  
   describe 'when computing the environment name' do
-    it 'should return false when there is no ENV["to"] setting' do
+    it 'returns false when there is no ENV["to"] setting' do
       ENV['to'] = nil
-      WhiskeyDisk::Config.environment_name.should == false
+      @config.environment_name.should == false
     end
 
-    it 'should return false when the ENV["to"] setting is blank' do
+    it 'returns false when the ENV["to"] setting is blank' do
       ENV['to'] = ''
-      WhiskeyDisk::Config.environment_name.should == false
+      @config.environment_name.should == false
     end
 
-    it 'should return the ENV["to"] setting when it is non-blank' do
+    it 'returns the ENV["to"] setting when it is non-blank' do
       ENV['to'] = 'staging'
-      WhiskeyDisk::Config.environment_name.should == 'staging'
+      @config.environment_name.should == 'staging'
     end
 
-    it 'should return the environment portion of the ENV["to"] setting when a project is specified' do
+    it 'returns the environment portion of the ENV["to"] setting when a project is specified' do
       ENV['to'] = 'project:staging'
-      WhiskeyDisk::Config.environment_name.should == 'staging'
+      @config.environment_name.should == 'staging'
     end
   end
 
   describe 'when determining whether to do a staleness check before updating' do
-    it 'should return false when there is no ENV["check"] setting' do
+    it 'returns false when there is no ENV["check"] setting' do
       ENV['check'] = nil
-      WhiskeyDisk::Config.check_staleness?.should == false
+      @config.check_staleness?.should == false
     end
 
-    it 'should return false when the ENV["check"] setting is blank' do
+    it 'returns false when the ENV["check"] setting is blank' do
       ENV['check'] = ''
-      WhiskeyDisk::Config.check_staleness?.should == false
+      @config.check_staleness?.should == false
     end
 
-    it 'should return true if the ENV["check"] setting is "t"' do
+    it 'returns true if the ENV["check"] setting is "t"' do
       ENV['check'] = 't'
-      WhiskeyDisk::Config.check_staleness?.should == true
+      @config.check_staleness?.should == true
     end
 
-    it 'should return true if the ENV["check"] setting is "true"' do
+    it 'returns true if the ENV["check"] setting is "true"' do
       ENV['check'] = 'true'
-      WhiskeyDisk::Config.check_staleness?.should == true
+      @config.check_staleness?.should == true
     end
 
-    it 'should return true if the ENV["check"] setting is "y"' do
+    it 'returns true if the ENV["check"] setting is "y"' do
       ENV['check'] = 'y'
-      WhiskeyDisk::Config.check_staleness?.should == true
+      @config.check_staleness?.should == true
     end
 
-    it 'should return true if the ENV["check"] setting is "yes"' do
+    it 'returns true if the ENV["check"] setting is "yes"' do
       ENV['check'] = 'yes'
-      WhiskeyDisk::Config.check_staleness?.should == true
+      @config.check_staleness?.should == true
     end
 
-    it 'should return true if the ENV["check"] setting is "1"' do
+    it 'returns true if the ENV["check"] setting is "1"' do
       ENV['check'] = '1'
-      WhiskeyDisk::Config.check_staleness?.should == true
+      @config.check_staleness?.should == true
     end
   end
   
   describe 'when determining whether there is a domain limit set' do
-    it 'should return false when ENV["only"] is nil' do
+    it 'returns false when ENV["only"] is nil' do
       ENV['only'] = nil
-      WhiskeyDisk::Config.domain_limit.should == false
+      @config.domain_limit.should == false
     end
     
-    it 'should return false when ENV["only"] is empty' do
+    it 'returns false when ENV["only"] is empty' do
       ENV['only'] = ''
-      WhiskeyDisk::Config.domain_limit.should == false
+      @config.domain_limit.should == false
     end
     
-    it 'should return the value in ENV["only"] when it is non-empty' do
+    it 'returns the value in ENV["only"] when it is non-empty' do
       ENV['only'] = 'somedomain'
-      WhiskeyDisk::Config.domain_limit.should == 'somedomain'      
+      @config.domain_limit.should == 'somedomain'      
     end
   end
 
   describe 'when determining whether to turn debug mode on' do
-    it 'should return false when there is no ENV["debug"] setting' do
+    it 'returns false when there is no ENV["debug"] setting' do
       ENV['debug'] = nil
-      WhiskeyDisk::Config.debug?.should == false
+      @config.debug?.should == false
     end
 
-    it 'should return false when the ENV["debug"] setting is blank' do
+    it 'returns false when the ENV["debug"] setting is blank' do
       ENV['debug'] = ''
-      WhiskeyDisk::Config.debug?.should == false
+      @config.debug?.should == false
     end
 
-    it 'should return true if the ENV["debug"] setting is "t"' do
+    it 'returns true if the ENV["debug"] setting is "t"' do
       ENV['debug'] = 't'
-      WhiskeyDisk::Config.debug?.should == true
+      @config.debug?.should == true
     end
 
-    it 'should return true if the ENV["debug"] setting is "true"' do
+    it 'returns true if the ENV["debug"] setting is "true"' do
       ENV['debug'] = 'true'
-      WhiskeyDisk::Config.debug?.should == true
+      @config.debug?.should == true
     end
 
-    it 'should return true if the ENV["debug"] setting is "y"' do
+    it 'returns true if the ENV["debug"] setting is "y"' do
       ENV['debug'] = 'y'
-      WhiskeyDisk::Config.debug?.should == true
+      @config.debug?.should == true
     end
 
-    it 'should return true if the ENV["debug"] setting is "yes"' do
+    it 'returns true if the ENV["debug"] setting is "yes"' do
       ENV['debug'] = 'yes'
-      WhiskeyDisk::Config.debug?.should == true
+      @config.debug?.should == true
     end
 
-    it 'should return true if the ENV["debug"] setting is "1"' do
+    it 'returns true if the ENV["debug"] setting is "1"' do
       ENV['debug'] = '1'
-      WhiskeyDisk::Config.debug?.should == true
+      @config.debug?.should == true
     end
   end
 
@@ -149,89 +153,90 @@ describe WhiskeyDisk::Config do
       before do
         ENV['to'] = @env = 'foo:staging'
         ENV['path'] = 'https://www.example.com/foo/bar/deploy.yml'
+        @config = TestURLConfig.new
       end
       
-      it 'should fail if the current environment cannot be determined' do
+      it 'fails if the current environment cannot be determined' do
         ENV['to'] = nil
-        lambda { TestURLConfig.fetch }.should.raise
+        lambda { @config.fetch }.should.raise
       end
 
-      it 'should fail if the configuration data cannot be retrieved' do
-        TestURLConfig.stub!(:open).and_raise(RuntimeError)
-        lambda { TestURLConfig.fetch }.should.raise
+      it 'fails if the configuration data cannot be retrieved' do
+        @config.stub!(:open).and_raise(RuntimeError)
+        lambda { @config.fetch }.should.raise
       end
 
-      it 'should fail if the retrieved configuration data is invalid' do
-        TestURLConfig.stub!(:open).and_return("}")
-        lambda { TestURLConfig.fetch }.should.raise
+      it 'fails if the retrieved configuration data is invalid' do
+        @config.stub!(:open).and_return("}")
+        lambda { @config.fetch }.should.raise
       end
 
-      it 'should fail if the retrieved configuration data does not define data for this environment' do
-        set_config_url_response('foo' => { 'production' => { 'a' => 'b'} })
-        lambda { TestURLConfig.fetch }.should.raise
+      it 'fails if the retrieved configuration data does not define data for this environment' do
+        @config.set_response('foo' => { 'production' => { 'a' => 'b'} })
+        lambda { @config.fetch }.should.raise
       end
 
-      it 'should return the retrieved configuration yaml data for this environment as a hash' do
+      it 'returns the retrieved configuration yaml data for this environment as a hash' do
         staging = { 'foo' => 'bar', 'repository' => 'xyzzy' }
-        set_config_url_response('foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging })
-        result = TestURLConfig.fetch
+        @config.set_response('foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging })
+        result = @config.fetch
         staging.each_pair do |k,v|
           result[k].should == v
         end
       end
     
-      it 'should not include configuration information for other environments in the returned hash' do
+      it 'does not include configuration information for other environments in the returned hash' do
         staging = { 'foo' => 'bar', 'baz' => 'xyzzy' }
-        set_config_url_response('production' => { 'repository' => 'c', 'a' => 'b'}, 'staging' => staging)
-        TestURLConfig.fetch['a'].should.be.nil
+        @config.set_response('production' => { 'repository' => 'c', 'a' => 'b'}, 'staging' => staging)
+        @config.fetch['a'].should.be.nil
       end
 
-      it 'should include the environment in the hash' do
+      it 'includes the environment in the hash' do
         staging = { 'foo' => 'bar', 'baz' => 'xyzzy' }
-        set_config_url_response('foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging })
-        TestURLConfig.fetch['environment'].should == 'staging'
+        @config.set_response('foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging })
+        @config.fetch['environment'].should == 'staging'
       end
 
-      it 'should not allow overriding the environment in the configuration file' do
+      it 'does not allow overriding the environment in the configuration file' do
         staging = { 'foo' => 'bar', 'repository' => 'xyzzy', 'environment' => 'production' }
-        set_config_url_response('foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging })
-        TestURLConfig.fetch['environment'].should == 'staging'
+        @config.set_response('foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging })
+        @config.fetch['environment'].should == 'staging'
       end
 
-      it 'should include the project handle in the hash' do
+      it 'includes the project handle in the hash' do
         staging = { 'foo' => 'bar', 'repository' => 'xyzzy' }
-        set_config_url_response('foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging })
-        TestURLConfig.fetch['project'].should == 'foo'
+        @config.set_response('foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging })
+        @config.fetch['project'].should == 'foo'
       end
 
-      it 'should not allow overriding the project handle in the configuration file when a project root is specified' do
+      it 'does not allow overriding the project handle in the configuration file when a project root is specified' do
         staging = { 'foo' => 'bar', 'repository' => 'xyzzy', 'project' => 'diskey_whisk' }
-        set_config_url_response('foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging })
-        TestURLConfig.fetch['project'].should == 'foo'
+        @config.set_response('foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging })
+        @config.fetch['project'].should == 'foo'
       end
 
-      it 'should allow overriding the project handle in the configuration file when a project root is not specified' do
+      it 'allows overriding the project handle in the configuration file when a project root is not specified' do
         ENV['to'] = @env = 'staging'
         staging = { 'foo' => 'bar', 'repository' => 'xyzzy', 'project' => 'diskey_whisk' }
-        set_config_url_response('production' => { 'repository' => 'b'}, 'staging' => staging)
-        TestURLConfig.fetch['project'].should == 'diskey_whisk'
+        @config.set_response('production' => { 'repository' => 'b'}, 'staging' => staging)
+        @config.fetch['project'].should == 'diskey_whisk'
       end
     
-      it 'should include the environment name as the config_target setting when no config_target is specified' do
+      it 'includes the environment name as the config_target setting when no config_target is specified' do
         staging = { 'foo' => 'bar', 'repository' => 'xyzzy', 'project' => 'diskey_whisk' }
-        set_config_url_response('production' => { 'repository' => 'b'}, 'staging' => staging)
-        TestURLConfig.fetch['config_target'].should == 'staging'
+        @config.set_response('production' => { 'repository' => 'b'}, 'staging' => staging)
+        @config.fetch['config_target'].should == 'staging'
       end
     
-      it 'should include the config_target setting when a config_target is specified' do
+      it 'includes the config_target setting when a config_target is specified' do
         staging = { 'foo' => 'bar', 'repository' => 'xyzzy', 'project' => 'diskey_whisk', 'config_target' => 'testing' }
-        set_config_url_response('production' => { 'repository' => 'b'}, 'staging' => staging)
-        TestURLConfig.fetch['config_target'].should == 'testing'
+        @config.set_response('production' => { 'repository' => 'b'}, 'staging' => staging)
+        @config.fetch['config_target'].should == 'testing'
       end
       
-      it 'should fail if the named target cannot be found' do
+      it 'fails if the named target cannot be found' do
         ENV['to'] = @env = 'bogus:thing'
-        lambda { TestURLConfig.fetch }.should.raise
+        lambda { @config.fetch }.should.raise
       end
     end
     
@@ -246,91 +251,91 @@ describe WhiskeyDisk::Config do
         FileUtils.rm_rf(@path)
       end
       
-      it 'should fail if the current environment cannot be determined' do
+      it 'fails if the current environment cannot be determined' do
         ENV['to'] = nil
-        lambda { WhiskeyDisk::Config.fetch }.should.raise
+        lambda { @config.fetch }.should.raise
       end
 
-      it 'should fail if the configuration file does not exist' do
-        lambda { WhiskeyDisk::Config.fetch }.should.raise
+      it 'fails if the configuration file does not exist' do
+        lambda { @config.fetch }.should.raise
       end
 
-      it 'should fail if the configuration file cannot be read' do
+      it 'fails if the configuration file cannot be read' do
         Dir.mkdir(File.join(@path, 'tmp'))
-        lambda { WhiskeyDisk::Config.fetch }.should.raise
+        lambda { @config.fetch }.should.raise
       end
 
-      it 'should fail if the configuration file is invalid' do
+      it 'fails if the configuration file is invalid' do
         File.open(@config_file, 'w') {|f| f.puts "}" }
-        lambda { WhiskeyDisk::Config.fetch }.should.raise
+        lambda { @config.fetch }.should.raise
       end
 
-      it 'should fail if the configuration file does not define data for this environment' do
+      it 'fails if the configuration file does not define data for this environment' do
         write_config_file('foo' => { 'production' => { 'a' => 'b'} })
-        lambda { WhiskeyDisk::Config.fetch }.should.raise
+        lambda { @config.fetch }.should.raise
       end
 
-      it 'should return the configuration yaml file data for this environment as a hash' do
+      it 'returns the configuration yaml file data for this environment as a hash' do
         staging = { 'foo' => 'bar', 'repository' => 'xyzzy' }
         write_config_file('foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging })
-        result = WhiskeyDisk::Config.fetch
+        result = @config.fetch
         staging.each_pair do |k,v|
           result[k].should == v
         end
       end
     
-      it 'should not include configuration information for other environments in the returned hash' do
+      it 'does not include configuration information for other environments in the returned hash' do
         staging = { 'foo' => 'bar', 'baz' => 'xyzzy' }
         write_config_file('production' => { 'repository' => 'c', 'a' => 'b'}, 'staging' => staging)
-        WhiskeyDisk::Config.fetch['a'].should.be.nil
+        @config.fetch['a'].should.be.nil
       end
 
-      it 'should include the environment in the hash' do
+      it 'includes the environment in the hash' do
         staging = { 'foo' => 'bar', 'baz' => 'xyzzy' }
         write_config_file('foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging })
-        WhiskeyDisk::Config.fetch['environment'].should == 'staging'
+        @config.fetch['environment'].should == 'staging'
       end
 
-      it 'should not allow overriding the environment in the configuration file' do
+      it 'does not allow overriding the environment in the configuration file' do
         staging = { 'foo' => 'bar', 'repository' => 'xyzzy', 'environment' => 'production' }
         write_config_file('foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging })
-        WhiskeyDisk::Config.fetch['environment'].should == 'staging'
+        @config.fetch['environment'].should == 'staging'
       end
 
-      it 'should include the project handle in the hash' do
+      it 'includes the project handle in the hash' do
         staging = { 'foo' => 'bar', 'repository' => 'xyzzy' }
         write_config_file('foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging })
-        WhiskeyDisk::Config.fetch['project'].should == 'foo'
+        @config.fetch['project'].should == 'foo'
       end
 
-      it 'should not allow overriding the project handle in the configuration file when a project root is specified' do
+      it 'does not allow overriding the project handle in the configuration file when a project root is specified' do
         staging = { 'foo' => 'bar', 'repository' => 'xyzzy', 'project' => 'diskey_whisk' }
         write_config_file('foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging })
-        WhiskeyDisk::Config.fetch['project'].should == 'foo'
+        @config.fetch['project'].should == 'foo'
       end
 
-      it 'should allow overriding the project handle in the configuration file when a project root is not specified' do
+      it 'allows overriding the project handle in the configuration file when a project root is not specified' do
         ENV['to'] = @env = 'staging'
         staging = { 'foo' => 'bar', 'repository' => 'xyzzy', 'project' => 'diskey_whisk' }
         write_config_file('production' => { 'repository' => 'b'}, 'staging' => staging)
-        WhiskeyDisk::Config.fetch['project'].should == 'diskey_whisk'
+        @config.fetch['project'].should == 'diskey_whisk'
       end
     
-      it 'should include the environment name as the config_target setting when no config_target is specified' do
+      it 'includes the environment name as the config_target setting when no config_target is specified' do
         staging = { 'foo' => 'bar', 'repository' => 'xyzzy', 'project' => 'diskey_whisk' }
         write_config_file('production' => { 'repository' => 'b'}, 'staging' => staging)
-        WhiskeyDisk::Config.fetch['config_target'].should == 'staging'
+        @config.fetch['config_target'].should == 'staging'
       end
     
-      it 'should include the config_target setting when a config_target is specified' do
+      it 'includes the config_target setting when a config_target is specified' do
         staging = { 'foo' => 'bar', 'repository' => 'xyzzy', 'project' => 'diskey_whisk', 'config_target' => 'testing' }
         write_config_file('production' => { 'repository' => 'b'}, 'staging' => staging)
-        WhiskeyDisk::Config.fetch['config_target'].should == 'testing'
+        @config.fetch['config_target'].should == 'testing'
       end
       
-      it 'should fail if the named target cannot be found' do
+      it 'fails if the named target cannot be found' do
         ENV['to'] = @env = 'bogus:thing'
-        lambda { WhiskeyDisk::Config.fetch }.should.raise
+        lambda { @config.fetch }.should.raise
       end
     end
   end
@@ -345,17 +350,17 @@ describe WhiskeyDisk::Config do
       FileUtils.rm_rf(@path)
     end
 
-    it 'should fail if the configuration file does not exist' do
-      lambda { WhiskeyDisk::Config.configuration_data }.should.raise
+    it 'fails if the configuration file does not exist' do
+      lambda { @config.configuration_data }.should.raise
     end
 
-    it 'should return the contents of the configuration file' do
+    it 'returns the contents of the configuration file' do
       File.open(@config_file, 'w') { |f| f.puts "file contents" }
-      WhiskeyDisk::Config.configuration_data.should == "file contents\n"
+      @config.configuration_data.should == "file contents\n"
     end
   end
 
-  describe 'transforming data from the configuration file' do
+  describe 'loading data from the configuration file' do
     before do
       ENV['to'] = 'foo:bar'
       @path = build_temp_dir
@@ -366,290 +371,35 @@ describe WhiskeyDisk::Config do
       FileUtils.rm_rf(@path)
     end
     
-    it 'should fail if the configuration data cannot be loaded' do
-      lambda { WhiskeyDisk::Config.load_data }.should.raise
+    it 'fails if the configuration data cannot be loaded' do
+      lambda { @config.load_data }.should.raise
     end
 
-    it 'should fail if converting the configuration data from YAML fails' do
+    it 'fails if converting the configuration data from YAML fails' do
       File.open(@config_file, 'w') { |f| f.puts "}" }
-      lambda { WhiskeyDisk::Config.load_data }.should.raise
+      lambda { @config.load_data }.should.raise
     end
 
-    it 'should return a normalized version of the un-YAMLized configuration data' do
+    it 'returns the un-YAMLized configuration data' do
       write_config_file('repository' => 'x')
-      WhiskeyDisk::Config.load_data.should == { 'foo' => { 'bar' => { 'repository' => 'x', 'domain' => [{ :name => 'local' } ] } } }
-    end
-    
-    describe 'normalizing domains' do
-      before do
-        write_config_file(
-          'foo' => { 
-            'xyz' => { 'repository' => 'x' },
-            'eee' => { 'repository' => 'x', 'domain' => '' },
-            'abc' => { 'repository' => 'x', 'domain' => 'what@example.com' },
-            'baz' => { 'repository' => 'x', 'domain' => [ 'bar@example.com', 'baz@domain.com' ]},
-            'bar' => { 'repository' => 'x', 'domain' => [ 'user@example.com', nil, 'foo@domain.com' ]},
-            'bat' => { 'repository' => 'x', 'domain' => [ 'user@example.com', 'foo@domain.com', '' ]},
-            'hsh' => { 'repository' => 'x', 'domain' => [ { 'name' => 'bar@example.com' }, { 'name' => 'baz@domain.com' } ]},
-            'mix' => { 'repository' => 'x', 'domain' => [ { 'name' => 'bar@example.com' }, 'baz@domain.com' ]},            
-            'erl' => { 'repository' => 'x', 'domain' => [ { 'name' => 'bar@example.com', 'roles' => nil }, 
-                                                          { 'name' => 'baz@domain.com', 'roles' => '' },
-                                                          { 'name' => 'aok@domain.com', 'roles' => [] } ]},
-            'rol' => { 'repository' => 'x', 'domain' => [ { 'name' => 'bar@example.com', 'roles' => [ 'web', 'db' ] }, 
-                                                          { 'name' => 'baz@domain.com', 'roles' => [ 'db' ] },            
-                                                          { 'name' => 'aok@domain.com', 'roles' => 'app' } ]},            
-            'wow' => { 'repository' => 'x', 'domain' => [ { 'name' => 'bar@example.com', 'roles' => [ 'web', 'db' ] }, 
-                                                          { 'name' => 'baz@domain.com', 'roles' => [ 'db' ] },   
-                                                            '', 'foo@bar.example.com',      
-                                                          { 'name' => 'aok@domain.com', 'roles' => 'app' } ]},            
-          },
-
-          'zyx' => {
-            'xyz' => { 'repository' => 'x' },
-            'eee' => { 'repository' => 'x', 'domain' => '' },
-            'abc' => { 'repository' => 'x', 'domain' => 'what@example.com' },
-            'hij' => { 'repository' => 'x', 'domain' => [ 'bar@example.com', 'baz@domain.com' ]},
-            'def' => { 'repository' => 'x', 'domain' => [ 'user@example.com', nil, 'foo@domain.com' ]},
-            'dex' => { 'repository' => 'x', 'domain' => [ 'user@example.com', 'foo@domain.com', '' ]},
-            'hsh' => { 'repository' => 'x', 'domain' => [ { 'name' => 'bar@example.com' }, { 'name' => 'baz@domain.com' } ]},
-            'mix' => { 'repository' => 'x', 'domain' => [ { 'name' => 'bar@example.com' }, 'baz@domain.com' ]},
-            'erl' => { 'repository' => 'x', 'domain' => [ { 'name' => 'bar@example.com', 'roles' => nil }, 
-                                                          { 'name' => 'baz@domain.com', 'roles' => '' },
-                                                          { 'name' => 'aok@domain.com', 'roles' => [] } ]},
-            'rol' => { 'repository' => 'x', 'domain' => [ { 'name' => 'bar@example.com', 'roles' => [ 'web', 'db' ] }, 
-                                                          { 'name' => 'baz@domain.com', 'roles' => [ 'db' ] },         
-                                                          { 'name' => 'aok@domain.com', 'roles' => 'app' } ]},            
-            'wow' => { 'repository' => 'x', 'domain' => [ { 'name' => 'bar@example.com', 'roles' => [ 'web', 'db' ] }, 
-                                                          { 'name' => 'baz@domain.com', 'roles' => [ 'db' ] },   
-                                                             '', 'foo@bar.example.com',      
-                                                          { 'name' => 'aok@domain.com', 'roles' => 'app' } ]},            
-          }
-        )
-      end
-    
-      it 'should set the domain to "local" when no domain is specified' do
-        WhiskeyDisk::Config.load_data['foo']['xyz']['domain'].should == [ { :name => 'local' } ]   
-      end
-      
-      it 'should handle nil domains across all projects and targets' do
-        WhiskeyDisk::Config.load_data['zyx']['xyz']['domain'].should == [ { :name => 'local' } ]
-      end
-    
-      it 'should return domain as "local" if a single empty domain was specified' do
-        WhiskeyDisk::Config.load_data['foo']['eee']['domain'].should == [ { :name => 'local' } ]
-      end
-      
-      it 'should handle single empty specified domains across all projects and targets' do
-        WhiskeyDisk::Config.load_data['zyx']['eee']['domain'].should == [ { :name => 'local' } ]                 
-      end
-      
-      it 'should return domain as a single element list with a name if a single non-empty domain was specified' do
-        WhiskeyDisk::Config.load_data['foo']['abc']['domain'].should == [ { :name => 'what@example.com' } ]
-      end
-  
-      it 'should handle single specified domains across all projects and targets' do
-        WhiskeyDisk::Config.load_data['zyx']['abc']['domain'].should == [ { :name => 'what@example.com' } ]
-      end
-    
-      it 'should return the list of domain name hashes when a list of domains is specified' do
-        WhiskeyDisk::Config.load_data['foo']['baz']['domain'].should == [ 
-          { :name => 'bar@example.com' }, { :name => 'baz@domain.com' } 
-        ]
-      end
-    
-      it 'should handle lists of domains across all projects and targets' do
-        WhiskeyDisk::Config.load_data['zyx']['hij']['domain'].should == [ 
-          { :name => 'bar@example.com' }, { :name => 'baz@domain.com' } 
-         ]
-      end
-      
-      it 'should replace any nil domains with "local" domains in a domain list' do
-        WhiskeyDisk::Config.load_data['foo']['bar']['domain'].should == [
-          { :name => 'user@example.com' }, { :name => 'local' }, { :name => 'foo@domain.com' }
-         ]
-      end
-  
-      it 'should handle localizing nils across all projects and targets' do
-        WhiskeyDisk::Config.load_data['zyx']['def']['domain'].should == [
-          { :name => 'user@example.com' }, { :name => 'local' }, { :name => 'foo@domain.com' }
-         ]
-      end
-      
-      it 'should replace any blank domains with "local" domains in a domain list' do
-        WhiskeyDisk::Config.load_data['foo']['bat']['domain'].should == [
-          { :name => 'user@example.com' }, { :name => 'foo@domain.com' }, { :name => 'local' }
-         ]
-      end
-  
-      it 'should handle localizing blanks across all projects and targets' do
-        WhiskeyDisk::Config.load_data['zyx']['dex']['domain'].should == [
-          { :name => 'user@example.com' }, { :name => 'foo@domain.com' }, { :name => 'local' }
-         ]
-      end
-      
-      it 'should not include roles when only nil, blank or empty roles lists are specified' do
-        WhiskeyDisk::Config.load_data['foo']['erl']['domain'].should == [
-          { :name => 'bar@example.com' }, { :name => 'baz@domain.com' }, { :name => 'aok@domain.com' }
-         ]        
-      end
-
-      it 'should handle filtering empty roles across all projects and targets ' do
-        WhiskeyDisk::Config.load_data['zyx']['erl']['domain'].should == [
-          { :name => 'bar@example.com' }, { :name => 'baz@domain.com' }, { :name => 'aok@domain.com' }
-         ]        
-      end
-      
-      it 'should include and normalize roles when specified as strings or lists' do
-        WhiskeyDisk::Config.load_data['foo']['rol']['domain'].should == [
-          { :name => 'bar@example.com', :roles => [ 'web', 'db' ] }, 
-          { :name => 'baz@domain.com',  :roles => [ 'db' ] }, 
-          { :name => 'aok@domain.com',  :roles => [ 'app' ] }
-         ]        
-      end
-
-      it 'should handle normalizing roles across all projects and targets ' do
-        WhiskeyDisk::Config.load_data['zyx']['rol']['domain'].should == [
-          { :name => 'bar@example.com', :roles => [ 'web', 'db' ] }, 
-          { :name => 'baz@domain.com',  :roles => [ 'db' ] }, 
-          { :name => 'aok@domain.com',  :roles => [ 'app' ] }
-         ]        
-      end
-      
-      it 'should respect empty domains among role data' do
-        WhiskeyDisk::Config.load_data['foo']['wow']['domain'].should == [
-          { :name => 'bar@example.com', :roles => [ 'web', 'db' ] }, 
-          { :name => 'baz@domain.com',  :roles => [ 'db' ] }, 
-          { :name => 'local' },
-          { :name => 'foo@bar.example.com' },
-          { :name => 'aok@domain.com',  :roles => [ 'app' ] }
-         ]                
-      end
-      
-      it 'should handle empty domain filtering among roles across all projects and targets' do
-        WhiskeyDisk::Config.load_data['zyx']['wow']['domain'].should == [
-          { :name => 'bar@example.com', :roles => [ 'web', 'db' ] }, 
-          { :name => 'baz@domain.com',  :roles => [ 'db' ] }, 
-          { :name => 'local' },
-          { :name => 'foo@bar.example.com' },
-          { :name => 'aok@domain.com',  :roles => [ 'app' ] }
-         ]        
-      end
-      
-      it 'should raise an exception if a domain appears more than once in a target' do
-        write_config_file(
-          'foo' => { 
-            'erl' => { 'repository' => 'x', 'domain' => [ { 'name' => 'bar@example.com', 'roles' => nil }, 
-                                                          { 'name' => 'baz@domain.com', 'roles' => '' },
-                                                          { 'name' => 'bar@example.com', 'roles' => [] } ]},
-          }
-        )
-        
-        lambda { WhiskeyDisk::Config.load_data }.should.raise
-        
-      end
-    end
-  end
-
-  describe 'normalizing YAML data from the configuration file' do
-    before do
-      ENV['to'] = @env = 'foo:staging'
-
-      @bare_data  = { 'repository' => 'git://foo/bar.git', 'domain' => [ { :name => 'ogc@ogtastic.com' } ] }
-      @env_data   = { 'staging' => @bare_data }
-      @proj_data  = { 'foo' => @env_data }
-    end
-
-    it 'should fail if the configuration data is not a hash' do
-      lambda { WhiskeyDisk::Config.normalize_data([]) }.should.raise
-    end
-
-    describe 'when no project name is specified via ENV["to"]' do
-      before do
-        ENV['to'] = @env = 'staging'
-      end
-
-      it 'should return the original data if it has both project and environment scoping' do
-        WhiskeyDisk::Config.normalize_data(@proj_data).should == @proj_data
-      end
-
-      describe 'when no project name is specified in the bare config hash' do
-        it 'should return the original data wrapped in project scope, using a dummy project, if it has environment scoping but no project scoping' do
-          WhiskeyDisk::Config.normalize_data(@env_data).should == { 'unnamed_project' => @env_data }
-        end
-
-        it 'should return the original data wrapped in a project scope, using a dummy project, and an environment scope if it has neither scoping' do
-          WhiskeyDisk::Config.normalize_data(@bare_data).should == { 'unnamed_project' => { 'staging' => @bare_data } }
-        end
-      end
-
-      describe 'when a project name is specified in the bare config hash' do
-        before do
-          @bare_data['project'] = 'whiskey_disk'
-        end
-
-        it 'should return the original data wrapped in project scope if it has environment scoping but no project scoping' do
-          WhiskeyDisk::Config.normalize_data(@env_data).should == { 'whiskey_disk' => @env_data }
-        end
-
-        it 'should return the original data wrapped in a project scope and an environment scope if it has neither scoping' do
-          WhiskeyDisk::Config.normalize_data(@bare_data).should == { 'whiskey_disk' => { 'staging' => @bare_data } }
-        end
-      end
-    end
-
-    describe 'when a project name is specified via ENV["to"]' do
-      before do
-        ENV['to'] = @env = 'whiskey_disk:staging'
-      end
-
-      describe 'when a project name is not specified in the bare config hash' do
-        it 'should return the original data if it has both project and environment scoping' do
-          WhiskeyDisk::Config.normalize_data(@proj_data).should == @proj_data
-        end
-
-        it 'should return the original data wrapped in project scope if it has environment scoping but no project scoping' do
-          WhiskeyDisk::Config.normalize_data(@env_data).should == { 'whiskey_disk' => @env_data }
-        end
-
-        it 'should return the original data wrapped in a project scope and an environment scope if it has neither scoping' do
-          WhiskeyDisk::Config.normalize_data(@bare_data).should == { 'whiskey_disk' => { 'staging' => @bare_data } }
-        end
-      end
-
-      describe 'when a project name is specified in the bare config hash' do
-        before do
-          @bare_data['project'] = 'whiskey_disk'
-        end
-
-        it 'should return the original data if it has both project and environment scoping' do
-          WhiskeyDisk::Config.normalize_data(@proj_data).should == @proj_data
-        end
-
-        it 'should return the original data wrapped in project scope if it has environment scoping but no project scoping' do
-          WhiskeyDisk::Config.normalize_data(@env_data).should == { 'whiskey_disk' => @env_data }
-        end
-
-        it 'should return the original data wrapped in a project scope and an environment scope if it has neither scoping' do
-          WhiskeyDisk::Config.normalize_data(@bare_data).should == { 'whiskey_disk' => { 'staging' => @bare_data } }
-        end
-      end
-    end
+      @config.load_data.should == { 'repository' => 'x' }
+    end    
   end
 
-  describe 'computing the project name from a configuration hash' do
-    it 'should return the project name from the ENV["to"] setting when it is available' do
+  describe 'computing the project name' do
+    it 'returns the project name from the ENV["to"] setting when it is available' do
       ENV['to'] = 'foo:staging'
-      WhiskeyDisk::Config.project_name.should == 'foo'
+      @config.project_name.should == 'foo'
     end
 
-    it 'should return "unnamed_project" when ENV["to"] is unset' do
+    it 'returns "unnamed_project" when ENV["to"] is unset' do
       ENV['to'] = ''
-      WhiskeyDisk::Config.project_name.should == 'unnamed_project'
+      @config.project_name.should == 'unnamed_project'
     end
 
-    it 'should return "unnamed_project" when no ENV["to"] project setting is available' do
+    it 'returns "unnamed_project" when no ENV["to"] project setting is available' do
       ENV['to'] = 'staging'
-      WhiskeyDisk::Config.project_name.should == 'unnamed_project'
+      @config.project_name.should == 'unnamed_project'
     end
   end
 
@@ -687,67 +437,67 @@ describe WhiskeyDisk::Config do
           ENV['to'] = @env = 'foo:staging'
         end
 
-        it 'should return the path to deploy/foo/<environment>.yml under the project base path if it exists' do
-          WhiskeyDisk::Config.configuration_file.should == "#{@dir}/deploy/foo/staging.yml"
+        it 'returns the path to deploy/foo/<environment>.yml under the project base path if it exists' do
+          @config.configuration_file.should == "#{@dir}/deploy/foo/staging.yml"
         end
 
-        it 'should return the path to deploy/foo.yml under the project base path if it exists' do
+        it 'returns the path to deploy/foo.yml under the project base path if it exists' do
           File.unlink("#{@dir}/deploy/foo/staging.yml")
-          WhiskeyDisk::Config.configuration_file.should == "#{@dir}/deploy/foo.yml"
+          @config.configuration_file.should == "#{@dir}/deploy/foo.yml"
         end
 
-        it 'should return the path to a per-environment configuration file in the deploy/ directory under the project base path if it exists' do
+        it 'returns the path to a per-environment configuration file in the deploy/ directory under the project base path if it exists' do
           File.unlink("#{@dir}/deploy/foo/staging.yml")
           File.unlink("#{@dir}/deploy/foo.yml")
-          WhiskeyDisk::Config.configuration_file.should == "#{@dir}/deploy/staging.yml"
+          @config.configuration_file.should == "#{@dir}/deploy/staging.yml"
         end
 
-        it 'should return the path to a per-environment configuration file under the project base path if it exists' do
+        it 'returns the path to a per-environment configuration file under the project base path if it exists' do
           File.unlink("#{@dir}/deploy/foo/staging.yml")
           File.unlink("#{@dir}/deploy/foo.yml")
           File.unlink("#{@dir}/deploy/staging.yml")
-          WhiskeyDisk::Config.configuration_file.should == "#{@dir}/staging.yml"
+          @config.configuration_file.should == "#{@dir}/staging.yml"
         end
 
-        it 'should return the path to deploy.yml under the project base path' do
+        it 'returns the path to deploy.yml under the project base path' do
           File.unlink("#{@dir}/deploy/foo/staging.yml")
           File.unlink("#{@dir}/deploy/foo.yml")
           File.unlink("#{@dir}/deploy/staging.yml")
           File.unlink("#{@dir}/staging.yml")
-          WhiskeyDisk::Config.configuration_file.should == "#{@dir}/deploy.yml"
+          @config.configuration_file.should == "#{@dir}/deploy.yml"
         end
 
-        it 'should fail if no per-environment config file nor deploy.yml exists under the project base path' do
+        it 'fails if no per-environment config file nor deploy.yml exists under the project base path' do
           File.unlink("#{@dir}/deploy/foo/staging.yml")
           File.unlink("#{@dir}/deploy/foo.yml")
           File.unlink("#{@dir}/deploy/staging.yml")
           File.unlink("#{@dir}/staging.yml")
           File.unlink("#{@dir}/deploy.yml")
-          lambda { WhiskeyDisk::Config.configuration_file }.should.raise
+          lambda { @config.configuration_file }.should.raise
         end
       end
 
       describe 'and no project name is specified in ENV["to"]' do
-        it 'should return the path to a per-environment configuration file in the deploy/ directory under the project base path if it exists' do
-          WhiskeyDisk::Config.configuration_file.should == "#{@dir}/deploy/staging.yml"
+        it 'returns the path to a per-environment configuration file in the deploy/ directory under the project base path if it exists' do
+          @config.configuration_file.should == "#{@dir}/deploy/staging.yml"
         end
 
-        it 'should return the path to a per-environment configuration file under the project base path if it exists' do
+        it 'returns the path to a per-environment configuration file under the project base path if it exists' do
           File.unlink("#{@dir}/deploy/staging.yml")
-          WhiskeyDisk::Config.configuration_file.should == "#{@dir}/staging.yml"
+          @config.configuration_file.should == "#{@dir}/staging.yml"
         end
 
-        it 'should return the path to deploy.yml under the project base path' do
+        it 'returns the path to deploy.yml under the project base path' do
           File.unlink("#{@dir}/deploy/staging.yml")
           File.unlink("#{@dir}/staging.yml")
-          WhiskeyDisk::Config.configuration_file.should == "#{@dir}/deploy.yml"
+          @config.configuration_file.should == "#{@dir}/deploy.yml"
         end
 
-        it 'should fail if no per-environment config file nor deploy.yml exists under the project base path' do
+        it 'fails if no per-environment config file nor deploy.yml exists under the project base path' do
           File.unlink("#{@dir}/deploy/staging.yml")
           File.unlink("#{@dir}/staging.yml")
           File.unlink("#{@dir}/deploy.yml")
-          lambda { WhiskeyDisk::Config.configuration_file }.should.raise
+          lambda { @config.configuration_file }.should.raise
         end
       end
     end
@@ -762,13 +512,13 @@ describe WhiskeyDisk::Config do
         FileUtils.rm_rf(@path)
       end
     
-      it 'should fail if a path is specified which does not exist' do
-        lambda { WhiskeyDisk::Config.configuration_file }.should.raise
+      it 'fails if a path is specified which does not exist' do
+        lambda { @config.configuration_file }.should.raise
       end
 
-      it 'should return the file path when a path which points to an existing file is specified' do
+      it 'returns the file path when a path which points to an existing file is specified' do
         FileUtils.touch(@config_file)
-        WhiskeyDisk::Config.configuration_file.should == @config_file
+        @config.configuration_file.should == @config_file
       end
     end
 
@@ -794,72 +544,135 @@ describe WhiskeyDisk::Config do
           ENV['to'] = @env = 'foo:staging'
         end
 
-        it 'should return the path to deploy/foo/<environment>.yml under the project base path if it exists' do
-          WhiskeyDisk::Config.configuration_file.should == File.join(@path, 'deploy', 'foo' ,'staging.yml')
+        it 'returns the path to deploy/foo/<environment>.yml under the project base path if it exists' do
+          @config.configuration_file.should == File.join(@path, 'deploy', 'foo' ,'staging.yml')
         end
 
-        it 'should return the path to deploy/foo.yml under the project base path if it exists' do
+        it 'returns the path to deploy/foo.yml under the project base path if it exists' do
           File.unlink(File.join(@path, 'deploy', 'foo', 'staging.yml'))
-          WhiskeyDisk::Config.configuration_file.should == File.join(@path, 'deploy', 'foo.yml')
+          @config.configuration_file.should == File.join(@path, 'deploy', 'foo.yml')
         end
 
-        it 'should return the path to a per-environment configuration file under deploy/ in the path specified if that file exists' do
+        it 'returns the path to a per-environment configuration file under deploy/ in the path specified if that file exists' do
           File.unlink(File.join(@path, 'deploy', 'foo', 'staging.yml'))
           File.unlink(File.join(@path, 'deploy', 'foo.yml'))
-          WhiskeyDisk::Config.configuration_file.should == File.join(@path, 'deploy', 'staging.yml')
+          @config.configuration_file.should == File.join(@path, 'deploy', 'staging.yml')
         end
 
-        it 'should return the path to a per-environment configuration file in the path specified if that file exists' do
+        it 'returns the path to a per-environment configuration file in the path specified if that file exists' do
           File.unlink(File.join(@path, 'deploy', 'foo', 'staging.yml'))
           File.unlink(File.join(@path, 'deploy', 'foo.yml'))
           File.unlink(File.join(@path, 'deploy', 'staging.yml'))
-          WhiskeyDisk::Config.configuration_file.should == File.join(@path, 'staging.yml')
+          @config.configuration_file.should == File.join(@path, 'staging.yml')
         end
 
-        it 'should return the path to deploy.yaml in the path specified if deploy.yml exists' do
+        it 'returns the path to deploy.yaml in the path specified if deploy.yml exists' do
           File.unlink(File.join(@path, 'deploy', 'foo', 'staging.yml'))
           File.unlink(File.join(@path, 'deploy', 'foo.yml'))
           File.unlink(File.join(@path, 'deploy', 'staging.yml'))
           File.unlink(File.join(@path, 'staging.yml'))
-          WhiskeyDisk::Config.configuration_file.should == File.join(@path, 'deploy.yml')
+          @config.configuration_file.should == File.join(@path, 'deploy.yml')
         end
 
-        it 'should fail if no per-environment configuration file nor deploy.yml exists in the path specified' do
+        it 'fails if no per-environment configuration file nor deploy.yml exists in the path specified' do
           File.unlink(File.join(@path, 'deploy', 'foo', 'staging.yml'))
           File.unlink(File.join(@path, 'deploy', 'foo.yml'))
           File.unlink(File.join(@path, 'deploy', 'staging.yml'))
           File.unlink(File.join(@path, 'staging.yml'))
           File.unlink(File.join(@path, 'deploy.yml'))
-          lambda { WhiskeyDisk::Config.configuration_file }.should.raise
+          lambda { @config.configuration_file }.should.raise
         end
       end
 
       describe 'and no project name is specified in ENV["to"]' do
-        it 'should return the path to a per-environment configuration file under deploy/ in the path specified if that file exists' do
-          WhiskeyDisk::Config.configuration_file.should == File.join(@path, 'deploy', 'staging.yml')
+        it 'returns the path to a per-environment configuration file under deploy/ in the path specified if that file exists' do
+          @config.configuration_file.should == File.join(@path, 'deploy', 'staging.yml')
         end
 
-        it 'should return the path to a per-environment configuration file in the path specified if that file exists' do
+        it 'returns the path to a per-environment configuration file in the path specified if that file exists' do
           File.unlink(File.join(@path, 'deploy', 'staging.yml'))
-          WhiskeyDisk::Config.configuration_file.should == File.join(@path, 'staging.yml')
+          @config.configuration_file.should == File.join(@path, 'staging.yml')
         end
 
-        it 'should return the path to deploy.yaml in the path specified if deploy.yml exists' do
+        it 'returns the path to deploy.yaml in the path specified if deploy.yml exists' do
           File.unlink(File.join(@path, 'deploy', 'staging.yml'))
           File.unlink(File.join(@path, 'staging.yml'))
-          WhiskeyDisk::Config.configuration_file.should == File.join(@path, 'deploy.yml')
+          @config.configuration_file.should == File.join(@path, 'deploy.yml')
         end
 
-        it 'should fail if no per-environment configuration file nor deploy.yml exists in the path specified' do
+        it 'fails if no per-environment configuration file nor deploy.yml exists in the path specified' do
           File.unlink(File.join(@path, 'deploy', 'staging.yml'))
           File.unlink(File.join(@path, 'staging.yml'))
           File.unlink(File.join(@path, 'deploy.yml'))
-          lambda { WhiskeyDisk::Config.configuration_file }.should.raise
+          lambda { @config.configuration_file }.should.raise
         end
       end
     end
   end
 
+  describe 'filtering configuration data' do
+    before do
+      ENV['to'] = @env = 'foo:erl'
+      @data = {
+        'foo' => { 
+          'xyz' => { 'repository' => 'x' },
+          'eee' => { 'repository' => 'x', 'domain' => '' },
+          'abc' => { 'repository' => 'x', 'domain' => 'what@example.com' },
+          'baz' => { 'repository' => 'x', 'domain' => [ 'bar@example.com', 'baz@domain.com' ]},
+          'bar' => { 'repository' => 'x', 'domain' => [ 'user@example.com', nil, 'foo@domain.com' ]},
+          'bat' => { 'repository' => 'x', 'domain' => [ 'user@example.com', 'foo@domain.com', '' ]},
+          'hsh' => { 'repository' => 'x', 'domain' => [ { 'name' => 'bar@example.com' }, { 'name' => 'baz@domain.com' } ]},
+          'mix' => { 'repository' => 'x', 'domain' => [ { 'name' => 'bar@example.com' }, 'baz@domain.com' ]},            
+          'erl' => { 'repository' => 'x', 'domain' => [ { 'name' => 'bar@example.com', 'roles' => nil }, 
+                                                        { 'name' => 'baz@domain.com', 'roles' => '' },
+                                                        { 'name' => 'aok@domain.com', 'roles' => [] } ]},
+          'rol' => { 'repository' => 'x', 'domain' => [ { 'name' => 'bar@example.com', 'roles' => [ 'web', 'db' ] }, 
+                                                        { 'name' => 'baz@domain.com', 'roles' => [ 'db' ] },            
+                                                        { 'name' => 'aok@domain.com', 'roles' => 'app' } ]},            
+          'wow' => { 'repository' => 'x', 'domain' => [ { 'name' => 'bar@example.com', 'roles' => [ 'web', 'db' ] }, 
+                                                        { 'name' => 'baz@domain.com', 'roles' => [ 'db' ] },   
+                                                          '', 'foo@bar.example.com',      
+                                                        { 'name' => 'aok@domain.com', 'roles' => 'app' } ]},            
+        },
+  
+        'zyx' => {
+          'xyz' => { 'repository' => 'x' },
+          'eee' => { 'repository' => 'x', 'domain' => '' },
+          'abc' => { 'repository' => 'x', 'domain' => 'what@example.com' },
+          'hij' => { 'repository' => 'x', 'domain' => [ 'bar@example.com', 'baz@domain.com' ]},
+          'def' => { 'repository' => 'x', 'domain' => [ 'user@example.com', nil, 'foo@domain.com' ]},
+          'dex' => { 'repository' => 'x', 'domain' => [ 'user@example.com', 'foo@domain.com', '' ]},
+          'hsh' => { 'repository' => 'x', 'domain' => [ { 'name' => 'bar@example.com' }, { 'name' => 'baz@domain.com' } ]},
+          'mix' => { 'repository' => 'x', 'domain' => [ { 'name' => 'bar@example.com' }, 'baz@domain.com' ]},
+          'erl' => { 'repository' => 'x', 'domain' => [ { 'name' => 'bar@example.com', 'roles' => nil }, 
+                                                        { 'name' => 'baz@domain.com', 'roles' => '' },
+                                                        { 'name' => 'aok@domain.com', 'roles' => [] } ]},
+          'rol' => { 'repository' => 'x', 'domain' => [ { 'name' => 'bar@example.com', 'roles' => [ 'web', 'db' ] }, 
+                                                        { 'name' => 'baz@domain.com', 'roles' => [ 'db' ] },         
+                                                        { 'name' => 'aok@domain.com', 'roles' => 'app' } ]},            
+          'wow' => { 'repository' => 'x', 'domain' => [ { 'name' => 'bar@example.com', 'roles' => [ 'web', 'db' ] }, 
+                                                        { 'name' => 'baz@domain.com', 'roles' => [ 'db' ] },   
+                                                           '', 'foo@bar.example.com',      
+                                                        { 'name' => 'aok@domain.com', 'roles' => 'app' } ]},            
+        }
+      }
+    end
+    
+    it 'should apply all available filters' do
+      @config.filter_data(@data).should == {
+        "repository" => "x", 
+        "project" => "foo", 
+        "config_target" => "erl", 
+        "environment" => "erl",
+        "domain"     => [ 
+          { 'name' => "bar@example.com" }, 
+          { 'name' => "baz@domain.com" }, 
+          { 'name' => "aok@domain.com" }
+        ]
+      }
+    end
+  end
+
   describe 'computing the base path for the project' do
     before do
       @original_path = Dir.pwd
@@ -881,12 +694,12 @@ describe WhiskeyDisk::Config do
         Dir.chdir(@original_path)
       end
 
-      it 'should return the path set in the "path" environment variable' do
-        WhiskeyDisk::Config.base_path.should == @path
+      it 'returns the path set in the "path" environment variable' do
+        @config.base_path.should == @path
       end
 
-      it 'should leave the current working path the same as when the base path lookup started' do
-        WhiskeyDisk::Config.base_path
+      it 'leaves the current working path the same as when the base path lookup started' do
+        @config.base_path
         Dir.pwd.should == @original_path
       end
     end
@@ -903,13 +716,13 @@ describe WhiskeyDisk::Config do
         FileUtils.rm_rf(@path)
       end
 
-      it 'should return the config directory under the current directory if there is no Rakefile along the root path to the current directory' do
-        WhiskeyDisk::Config.base_path.should == File.join(@path, 'config')
+      it 'returns the config directory under the current directory if there is no Rakefile along the root path to the current directory' do
+        @config.base_path.should == File.join(@path, 'config')
       end
 
-      it 'should leave the current working path the same as when the base path lookup started' do
+      it 'leaves the current working path the same as when the base path lookup started' do
         prior = Dir.pwd
-        WhiskeyDisk::Config.base_path
+        @config.base_path
         Dir.pwd.should == prior
       end
     end
@@ -928,12 +741,12 @@ describe WhiskeyDisk::Config do
       end
 
       it 'return the config directory in the nearest enclosing path with a Rakefile along the root path to the current directory' do
-        WhiskeyDisk::Config.base_path.should == File.join(@path, 'config')
+        @config.base_path.should == File.join(@path, 'config')
       end
 
-      it 'should leave the current working path the same as when the base path lookup started' do
+      it 'leaves the current working path the same as when the base path lookup started' do
         prior = Dir.pwd
-        WhiskeyDisk::Config.base_path
+        @config.base_path
         Dir.pwd.should == prior
       end
     end