whiskey_disk 0.5.3 → 0.5.4

data/Rakefile

@@ -23,6 +23,6 @@ begin
   end
   Jeweler::GemcutterTasks.new  
 rescue LoadError
-  puts "Jeweler not available. Install it with: sudo gem install jeweler -s http://gemcutter.org"
+  # if you get here, you need Jeweler installed to do packaging and gem installation, yo.
 end
 

data/VERSION

@@ -1 +1 @@
-0.5.3
+0.5.4

data/lib/whiskey_disk.rb

@@ -2,6 +2,8 @@ require File.expand_path(File.join(File.dirname(__FILE__), 'whiskey_disk', 'conf
 
 class WhiskeyDisk
   class << self
+    attr_writer :configuration
+    
     def reset
       @configuration = nil
       @buffer = nil

data/spec/whiskey_disk/config_spec.rb

@@ -1,9 +1,19 @@
 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 'yaml'
+require 'tmpdir'
+require 'fileutils'
 
-CURRENT_FILE = File.expand_path(__FILE__)           # Bacon evidently mucks around with __FILE__ or something related :-/
-CURRENT = File.expand_path(File.dirname(__FILE__))  # Bacon evidently mucks around with __FILE__ or something related :-/
+# create a file at the specified path
+def make(path)
+  FileUtils.mkdir_p(File.dirname(path))
+  FileUtils.touch(path)
+end
+
+def build_temp_dir
+  return Dir.mktmpdir(nil, '/private/tmp') if File.exists?('/private/tmp')
+  Dir.mktmpdir
+end
 
 describe WhiskeyDisk::Config do
   describe 'when computing the environment name' do
@@ -68,6 +78,12 @@ describe WhiskeyDisk::Config do
   describe 'when fetching configuration' do
     before do
       ENV['to'] = @env = 'foo:staging'
+      @path = build_temp_dir
+      ENV['path'] = @config_file = File.join(@path, 'deploy.yml')
+    end
+
+    after do
+      FileUtils.rm_rf(@path)
     end
 
     it 'should fail if the current environment cannot be determined' do
@@ -76,28 +92,27 @@ describe WhiskeyDisk::Config do
     end
 
     it 'should fail if the configuration file does not exist' do
-      WhiskeyDisk::Config.stub!(:configuration_file).and_return(__FILE__ + "_.crap")
       lambda { WhiskeyDisk::Config.fetch }.should.raise
     end
 
     it 'should fail if the configuration file cannot be read' do
-      WhiskeyDisk::Config.stub!(:configuration_file).and_return("/tmp")
+      Dir.mkdir(File.join(@path, 'tmp'))
       lambda { WhiskeyDisk::Config.fetch }.should.raise
     end
 
     it 'should fail if the configuration file is invalid' do
-      YAML.stub!(:load).and_raise
+      File.open(@config_file, 'w') {|f| f.puts "}" }
       lambda { WhiskeyDisk::Config.fetch }.should.raise
     end
 
     it 'should fail if the configuration file does not define data for this environment' do
-      WhiskeyDisk::Config.stub!(:configuration_data).and_return(YAML.dump({'foo' => { 'production' => { 'a' => 'b'}}}))
+      File.open(@config_file, 'w') {|f| f.puts YAML.dump({'foo' => { 'production' => { 'a' => 'b'}}}) }
       lambda { WhiskeyDisk::Config.fetch }.should.raise
     end
 
     it 'should return the configuration yaml file data for this environment as a hash' do
       staging = { 'foo' => 'bar', 'repository' => 'xyzzy' }
-      WhiskeyDisk::Config.stub!(:configuration_data).and_return(YAML.dump({'foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging }}))
+      File.open(@config_file, 'w') {|f| f.puts YAML.dump({'foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging }}) }
       result = WhiskeyDisk::Config.fetch
       staging.each_pair do |k,v|
         result[k].should == v
@@ -106,72 +121,85 @@ describe WhiskeyDisk::Config do
 
     it 'should not include configuration information for other environments in the returned hash' do
       staging = { 'foo' => 'bar', 'baz' => 'xyzzy' }
-      WhiskeyDisk::Config.stub!(:configuration_data).and_return(YAML.dump({ 'production' => { 'repository' => 'c', 'a' => 'b'}, 'staging' => staging }))
+      File.open(@config_file, 'w') {|f| f.puts YAML.dump({ 'production' => { 'repository' => 'c', 'a' => 'b'}, 'staging' => staging }) }
       WhiskeyDisk::Config.fetch['a'].should.be.nil
     end
 
     it 'should include the environment in the hash' do
       staging = { 'foo' => 'bar', 'baz' => 'xyzzy' }
-      WhiskeyDisk::Config.stub!(:configuration_data).and_return(YAML.dump({'foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging }}))
+      File.open(@config_file, 'w') {|f| f.puts YAML.dump({'foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging }}) }
       WhiskeyDisk::Config.fetch['environment'].should == 'staging'
     end
 
     it 'should not allow overriding the environment in the configuration file' do
       staging = { 'foo' => 'bar', 'repository' => 'xyzzy', 'environment' => 'production' }
-      WhiskeyDisk::Config.stub!(:configuration_data).and_return(YAML.dump({'foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging }}))
+      File.open(@config_file, 'w') {|f| f.puts YAML.dump({'foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging }}) }
       WhiskeyDisk::Config.fetch['environment'].should == 'staging'
     end
 
     it 'should include the project handle in the hash' do
       staging = { 'foo' => 'bar', 'repository' => 'xyzzy' }
-      WhiskeyDisk::Config.stub!(:configuration_data).and_return(YAML.dump({'foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging }}))
+      File.open(@config_file, 'w') {|f| f.puts YAML.dump({'foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging }}) }
       WhiskeyDisk::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
       staging = { 'foo' => 'bar', 'repository' => 'xyzzy', 'project' => 'diskey_whisk' }
-      WhiskeyDisk::Config.stub!(:configuration_data).and_return(YAML.dump({'foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging }}))
+      File.open(@config_file, 'w') {|f| f.puts YAML.dump({'foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging }}) }
       WhiskeyDisk::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
       ENV['to'] = @env = 'staging'
       staging = { 'foo' => 'bar', 'repository' => 'xyzzy', 'project' => 'diskey_whisk' }
-      WhiskeyDisk::Config.stub!(:configuration_data).and_return(YAML.dump({'production' => { 'repository' => 'b'}, 'staging' => staging }))
+      File.open(@config_file, 'w') {|f| f.puts YAML.dump({'production' => { 'repository' => 'b'}, 'staging' => staging }) }
       WhiskeyDisk::Config.fetch['project'].should == 'diskey_whisk'
     end
   end
 
   describe 'returning configuration data from a configuration file' do
+    before do
+      @path = build_temp_dir
+      ENV['path'] = @config_file = File.join(@path, 'deploy.yml')
+    end
+    
+    after do
+      FileUtils.rm_rf(@path)
+    end
+
     it 'should fail if the configuration file does not exist' do
-      WhiskeyDisk::Config.stub!(:configuration_file).and_return(CURRENT_FILE + '._crap')
       lambda { WhiskeyDisk::Config.configuration_data }.should.raise
     end
 
     it 'should return the contents of the configuration file' do
-      WhiskeyDisk::Config.stub!(:configuration_file).and_return(CURRENT_FILE)
-      File.stub!(:read).with(CURRENT_FILE).and_return('file contents')
-      WhiskeyDisk::Config.configuration_data.should == 'file contents'
+      File.open(@config_file, 'w') { |f| f.puts "file contents" }
+      WhiskeyDisk::Config.configuration_data.should == "file contents\n"
     end
   end
 
   describe 'transforming data from the configuration file' do
+    before do
+      ENV['to'] = 'foo:bar'
+      @path = build_temp_dir
+      ENV['path'] = @config_file = File.join(@path, 'deploy.yml')
+    end
+    
+    after do
+      FileUtils.rm_rf(@path)
+    end
+    
     it 'should fail if the configuration data cannot be loaded' do
-      WhiskeyDisk::Config.stub!(:configuration_data).and_raise
       lambda { WhiskeyDisk::Config.load_data }.should.raise
     end
 
     it 'should fail if converting the configuration data from YAML fails' do
-      WhiskeyDisk::Config.stub!(:configuration_data).and_return('configuration data')
-      YAML.stub!(:load).and_raise
+      File.open(@config_file, 'w') { |f| f.puts "}" }
       lambda { WhiskeyDisk::Config.load_data }.should.raise
     end
 
     it 'should return a normalized version of the un-YAMLized configuration data' do
-      data = { 'a' => 'b', 'c' => 'd' }
-      WhiskeyDisk::Config.stub!(:configuration_data).and_return(YAML.dump(data))
-      WhiskeyDisk::Config.stub!(:normalize_data).with(data).and_return('normalized data')
-      WhiskeyDisk::Config.load_data.should == 'normalized data'
+      File.open(@config_file, 'w') { |f| f.puts YAML.dump({ 'repository' => 'x'}) }
+      WhiskeyDisk::Config.load_data.should == { 'foo' => { 'bar' => { 'repository' => 'x' } } }
     end
   end
 
@@ -286,187 +314,199 @@ describe WhiskeyDisk::Config do
     describe 'and no path is specified' do
       before do
         ENV['path'] = @path = nil
+        @original_path = Dir.pwd
+        @base_path = build_temp_dir
+        Dir.chdir(@base_path)
+        FileUtils.touch(File.join(@base_path, 'Rakefile'))
+        @dir = File.join(@base_path, 'config')
+        Dir.mkdir(@dir)
+        
+        [ 
+          "/deploy/foo/staging.yml", 
+          "/deploy/foo.yml", 
+          "/deploy/staging.yml",
+          "/staging.yml", 
+          "/deploy.yml"
+        ].each { |file| make(File.join(@dir, file)) }
       end
-
+      
+      after do
+        FileUtils.rm_rf(@base_path)
+        Dir.chdir(@original_path)
+      end
+      
       describe 'and a project name is specified in ENV["to"]' do
         before 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.stub!(:base_path).and_return('/path/to/project/config')
-          File.stub!(:exists?).with('/path/to/project/config/deploy/foo/staging.yml').and_return(true)
-          WhiskeyDisk::Config.configuration_file.should == '/path/to/project/config/deploy/foo/staging.yml'
+          WhiskeyDisk::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
-          WhiskeyDisk::Config.stub!(:base_path).and_return('/path/to/project/config')
-          File.stub!(:exists?).with('/path/to/project/config/deploy/foo/staging.yml').and_return(false)
-          File.stub!(:exists?).with('/path/to/project/config/deploy/foo.yml').and_return(true)
-          WhiskeyDisk::Config.configuration_file.should == '/path/to/project/config/deploy/foo.yml'
+          File.unlink("#{@dir}/deploy/foo/staging.yml")
+          WhiskeyDisk::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
-          WhiskeyDisk::Config.stub!(:base_path).and_return('/path/to/project/config')
-          File.stub!(:exists?).with('/path/to/project/config/deploy/foo/staging.yml').and_return(false)
-          File.stub!(:exists?).with('/path/to/project/config/deploy/foo.yml').and_return(false)
-          File.stub!(:exists?).with('/path/to/project/config/deploy/staging.yml').and_return(true)
-          WhiskeyDisk::Config.configuration_file.should == '/path/to/project/config/deploy/staging.yml'
+          File.unlink("#{@dir}/deploy/foo/staging.yml")
+          File.unlink("#{@dir}/deploy/foo.yml")
+          WhiskeyDisk::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
-          WhiskeyDisk::Config.stub!(:base_path).and_return('/path/to/project/config')
-          File.stub!(:exists?).with('/path/to/project/config/deploy/foo/staging.yml').and_return(false)
-          File.stub!(:exists?).with('/path/to/project/config/deploy/foo.yml').and_return(false)
-          File.stub!(:exists?).with('/path/to/project/config/deploy/staging.yml').and_return(false)
-          File.stub!(:exists?).with('/path/to/project/config/staging.yml').and_return(true)
-          WhiskeyDisk::Config.configuration_file.should == '/path/to/project/config/staging.yml'
+          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"
         end
 
         it 'should return the path to deploy.yml under the project base path' do
-          WhiskeyDisk::Config.stub!(:base_path).and_return('/path/to/project/config')
-          File.stub!(:exists?).with('/path/to/project/config/deploy/foo/staging.yml').and_return(false)
-          File.stub!(:exists?).with('/path/to/project/config/deploy/foo.yml').and_return(false)
-          File.stub!(:exists?).with('/path/to/project/config/deploy/staging.yml').and_return(false)
-          File.stub!(:exists?).with('/path/to/project/config/staging.yml').and_return(false)
-          File.stub!(:exists?).with('/path/to/project/config/deploy.yml').and_return(true)
-          WhiskeyDisk::Config.configuration_file.should == '/path/to/project/config/deploy.yml'
+          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"
         end
 
         it 'should fail if no per-environment config file nor deploy.yml exists under the project base path' do
-          WhiskeyDisk::Config.stub!(:base_path).and_return('/path/to/project/config')
-          File.stub!(:exists?).with('/path/to/project/config/deploy/foo/staging.yml').and_return(false)
-          File.stub!(:exists?).with('/path/to/project/config/deploy/foo.yml').and_return(false)
-          File.stub!(:exists?).with('/path/to/project/config/deploy/staging.yml').and_return(false)
-          File.stub!(:exists?).with('/path/to/project/config/staging.yml').and_return(false)
-          File.stub!(:exists?).with('/path/to/project/config/deploy.yml').and_return(false)
+          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
         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.stub!(:base_path).and_return('/path/to/project/config')
-          File.stub!(:exists?).with('/path/to/project/config/deploy/staging.yml').and_return(true)
-          WhiskeyDisk::Config.configuration_file.should == '/path/to/project/config/deploy/staging.yml'
+          WhiskeyDisk::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
-          WhiskeyDisk::Config.stub!(:base_path).and_return('/path/to/project/config')
-          File.stub!(:exists?).with('/path/to/project/config/deploy/staging.yml').and_return(false)
-          File.stub!(:exists?).with('/path/to/project/config/staging.yml').and_return(true)
-          WhiskeyDisk::Config.configuration_file.should == '/path/to/project/config/staging.yml'
+          File.unlink("#{@dir}/deploy/staging.yml")
+          WhiskeyDisk::Config.configuration_file.should == "#{@dir}/staging.yml"
         end
 
         it 'should return the path to deploy.yml under the project base path' do
-          WhiskeyDisk::Config.stub!(:base_path).and_return('/path/to/project/config')
-          File.stub!(:exists?).with('/path/to/project/config/deploy/staging.yml').and_return(false)
-          File.stub!(:exists?).with('/path/to/project/config/staging.yml').and_return(false)
-          File.stub!(:exists?).with('/path/to/project/config/deploy.yml').and_return(true)
-          WhiskeyDisk::Config.configuration_file.should == '/path/to/project/config/deploy.yml'
+          File.unlink("#{@dir}/deploy/staging.yml")
+          File.unlink("#{@dir}/staging.yml")
+          WhiskeyDisk::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
-          WhiskeyDisk::Config.stub!(:base_path).and_return('/path/to/project/config')
-          File.stub!(:exists?).with('/path/to/project/config/deploy/staging.yml').and_return(false)
-          File.stub!(:exists?).with('/path/to/project/config/staging.yml').and_return(false)
-          File.stub!(:exists?).with('/path/to/project/config/deploy.yml').and_return(false)
+          File.unlink("#{@dir}/deploy/staging.yml")
+          File.unlink("#{@dir}/staging.yml")
+          File.unlink("#{@dir}/deploy.yml")
           lambda { WhiskeyDisk::Config.configuration_file }.should.raise
         end
       end
     end
 
-    it 'should fail if a path is specified which does not exist' do
-      ENV['path'] = @path = (CURRENT_FILE + "_.crap")
-      lambda { WhiskeyDisk::Config.configuration_file }.should.raise
-    end
+    describe 'and looking up a file' do
+      before do
+        @path = build_temp_dir
+        ENV['path'] = @config_file = File.join(@path, 'deploy.yml')
+      end
+      
+      after 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
+      end
 
-    it 'should return the file path when a path which points to an existing file is specified' do
-      ENV['path'] = @path = CURRENT_FILE
-      File.stub!(:exists?).with(@path).and_return(true)
-      WhiskeyDisk::Config.configuration_file.should == @path
+      it 'should return 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
+      end
     end
 
     describe 'and a path which points to a directory is specified' do
       before do
-        ENV['path'] = @path = CURRENT
+        ENV['path'] = @path = build_temp_dir
+        
+        [ 
+          "/deploy/foo/staging.yml", 
+          "/deploy/foo.yml", 
+          "/deploy/staging.yml",
+          "/staging.yml", 
+          "/deploy.yml"
+        ].each { |file| make(File.join(@path, file)) }
       end
 
+      after do
+        FileUtils.rm_rf(@path)
+      end
+      
       describe 'and a project name is specified in ENV["to"]' do
         before 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.stub!(:base_path).and_return(@path)
-          File.stub!(:exists?).with(File.join(@path, 'deploy', 'foo', 'staging.yml')).and_return(true)
           WhiskeyDisk::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
-          WhiskeyDisk::Config.stub!(:base_path).and_return(@path)
-          File.stub!(:exists?).with(File.join(@path, 'deploy', 'foo', 'staging.yml')).and_return(false)
-          File.stub!(:exists?).with(File.join(@path, 'deploy', 'foo.yml')).and_return(true)
+          File.unlink(File.join(@path, 'deploy', 'foo', 'staging.yml'))
           WhiskeyDisk::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
-          File.stub!(:exists?).with(File.join(@path, 'deploy', 'foo', 'staging.yml')).and_return(false)
-          File.stub!(:exists?).with(File.join(@path, 'deploy', 'foo.yml')).and_return(false)
-          File.stub!(:exists?).with(File.join(@path, 'deploy', 'staging.yml')).and_return(true)
+          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')
         end
 
         it 'should return the path to a per-environment configuration file in the path specified if that file exists' do
-          File.stub!(:exists?).with(File.join(@path, 'deploy', 'foo', 'staging.yml')).and_return(false)
-          File.stub!(:exists?).with(File.join(@path, 'deploy', 'foo.yml')).and_return(false)
-          File.stub!(:exists?).with(File.join(@path, 'deploy', 'staging.yml')).and_return(false)
-          File.stub!(:exists?).with(File.join(@path, 'staging.yml')).and_return(true)
+          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')
         end
 
         it 'should return the path to deploy.yaml in the path specified if deploy.yml exists' do
-          File.stub!(:exists?).with(File.join(@path, 'deploy', 'foo', 'staging.yml')).and_return(false)
-          File.stub!(:exists?).with(File.join(@path, 'deploy', 'foo.yml')).and_return(false)
-          File.stub!(:exists?).with(File.join(@path, 'deploy', 'staging.yml')).and_return(false)
-          File.stub!(:exists?).with(File.join(@path, 'staging.yml')).and_return(false)
-          File.stub!(:exists?).with(File.join(@path, 'deploy.yml')).and_return(true)
+          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')
         end
 
         it 'should fail if no per-environment configuration file nor deploy.yml exists in the path specified' do
-          File.stub!(:exists?).with(File.join(@path, 'deploy', 'foo', 'staging.yml')).and_return(false)
-          File.stub!(:exists?).with(File.join(@path, 'deploy', 'foo.yml')).and_return(false)
-          File.stub!(:exists?).with(File.join(@path, 'deploy', 'staging.yml')).and_return(false)
-          File.stub!(:exists?).with(File.join(@path, 'staging.yml')).and_return(false)
-          File.stub!(:exists?).with(File.join(@path, 'deploy.yml')).and_return(false)
+          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
         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
-          File.stub!(:exists?).with(File.join(@path, 'deploy', 'staging.yml')).and_return(true)
           WhiskeyDisk::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
-          File.stub!(:exists?).with(File.join(@path, 'deploy', 'staging.yml')).and_return(false)
-          File.stub!(:exists?).with(File.join(@path, 'staging.yml')).and_return(true)
+          File.unlink(File.join(@path, 'deploy', 'staging.yml'))
           WhiskeyDisk::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
-          File.stub!(:exists?).with(File.join(@path, 'deploy', 'staging.yml')).and_return(false)
-          File.stub!(:exists?).with(File.join(@path, 'staging.yml')).and_return(false)
-          File.stub!(:exists?).with(File.join(@path, 'deploy.yml')).and_return(true)
+          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')
         end
 
         it 'should fail if no per-environment configuration file nor deploy.yml exists in the path specified' do
-          File.stub!(:exists?).with(File.join(@path, 'deploy', 'staging.yml')).and_return(false)
-          File.stub!(:exists?).with(File.join(@path, 'staging.yml')).and_return(false)
-          File.stub!(:exists?).with(File.join(@path, 'deploy.yml')).and_return(false)
+          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
         end
       end
@@ -485,8 +525,13 @@ describe WhiskeyDisk::Config do
 
     describe 'and a "path" environment variable is set' do
       before do
-        ENV['path'] = @path = CURRENT
-        Dir.chdir(CURRENT)
+        ENV['path'] = @path = build_temp_dir
+        @original_path = Dir.pwd
+      end
+      
+      after do
+        FileUtils.rm_rf(@path)
+        Dir.chdir(@original_path)
       end
 
       it 'should return the path set in the "path" environment variable' do
@@ -495,41 +540,54 @@ describe WhiskeyDisk::Config do
 
       it 'should leave the current working path the same as when the base path lookup started' do
         WhiskeyDisk::Config.base_path
-        Dir.pwd.should == CURRENT
+        Dir.pwd.should == @original_path
       end
     end
 
     describe 'and there is no Rakefile in the root path to the current directory' do
       before do
-        Dir.chdir(CURRENT)
-        WhiskeyDisk::Config.stub!(:contains_rakefile?).and_return(false)
+        @original_path = Dir.pwd
+        @path = build_temp_dir
+        Dir.chdir(@path)
+      end
+
+      after do
+        Dir.chdir(@original_path)
+        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(CURRENT, 'config')
+        WhiskeyDisk::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
+        prior = Dir.pwd
         WhiskeyDisk::Config.base_path
-        Dir.pwd.should == CURRENT
+        Dir.pwd.should == prior
       end
     end
 
     describe 'and there is a Rakefile in the root path to the current directory' do
       before do
-        @top = ::File.expand_path(File.join(CURRENT, '..', '..'))
-        WhiskeyDisk::Config.stub!(:contains_rakefile?).and_return(false)
-        WhiskeyDisk::Config.stub!(:contains_rakefile?).with(@top).and_return(true)
-        Dir.chdir(CURRENT)
+        @original_path = Dir.pwd
+        @path = build_temp_dir
+        Dir.chdir(@path)
+        FileUtils.touch(File.join(@path, 'Rakefile'))
+      end
+
+      after do
+        Dir.chdir(@original_path)
+        FileUtils.rm_rf(@path)
       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(@top, 'config')
+        WhiskeyDisk::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
+        prior = Dir.pwd
         WhiskeyDisk::Config.base_path
-        Dir.pwd.should == CURRENT
+        Dir.pwd.should == prior
       end
     end
   end

data/spec/whiskey_disk/rake_spec.rb

@@ -14,8 +14,7 @@ describe 'rake tasks' do
   
   describe 'deploy:setup' do
     before do
-      @configuration = { }
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@configuration)
+      WhiskeyDisk.configuration = {}
       [ 
         :ensure_main_parent_path_is_present, 
         :ensure_config_parent_path_is_present,
@@ -33,15 +32,13 @@ describe 'rake tasks' do
     end
     
     it 'should make changes on the specified domain when a domain is specified' do
-      @configuration = { 'domain' => 'some domain' }
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@configuration)
+      WhiskeyDisk.configuration = { 'domain' => 'some domain' }
       @rake["deploy:setup"].invoke
       WhiskeyDisk.should.be.remote
     end
     
     it 'should make changes on the local system when no domain is specified' do
-      @configuration = { 'domain' => '' }
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@configuration)        
+      WhiskeyDisk.configuration = { 'domain' => '' }
       WhiskeyDisk.should.not.be.remote
     end
     
@@ -52,7 +49,7 @@ describe 'rake tasks' do
     
     describe 'when a configuration repo is specified' do
       it 'should ensure that the parent path for the configuration repository checkout is present' do
-        WhiskeyDisk.stub!(:has_config_repo?).and_return(true)
+        WhiskeyDisk.configuration = { 'config_repository' => 'foo' }
         WhiskeyDisk.should.receive(:ensure_config_parent_path_is_present)
         @rake["deploy:setup"].invoke    
       end
@@ -60,7 +57,6 @@ describe 'rake tasks' do
     
     describe 'when no configuration repo is specified' do
       it 'should not ensure that the path for the configuration repository checkout is present' do
-        WhiskeyDisk.stub!(:has_config_repo?).and_return(false)
         WhiskeyDisk.should.not.receive(:ensure_config_parent_path_is_present)
         @rake["deploy:setup"].invoke        
       end
@@ -73,7 +69,7 @@ describe 'rake tasks' do
     
     describe 'when a configuration repository is specified' do
       it 'should check out the configuration repository' do
-        WhiskeyDisk.stub!(:has_config_repo?).and_return(true)
+        WhiskeyDisk.configuration = { 'config_repository' => 'foo' }
         WhiskeyDisk.should.receive(:checkout_configuration_repository)
         @rake["deploy:setup"].invoke
       end
@@ -81,7 +77,6 @@ describe 'rake tasks' do
     
     describe 'when no configuration repository is specified' do
       it 'should not check out the configuration repository' do
-        WhiskeyDisk.stub!(:has_config_repo?).and_return(false)
         WhiskeyDisk.should.not.receive(:checkout_configuration_repository)
         @rake["deploy:setup"].invoke
       end
@@ -94,7 +89,7 @@ describe 'rake tasks' do
     
     describe 'when a configuration repository is specified' do
       it 'should update the configuration repository checkout' do
-        WhiskeyDisk.stub!(:has_config_repo?).and_return(true)
+        WhiskeyDisk.configuration = { 'config_repository' => 'foo' }
         WhiskeyDisk.should.receive(:update_configuration_repository_checkout)
         @rake["deploy:setup"].invoke
       end
@@ -102,7 +97,6 @@ describe 'rake tasks' do
     
     describe 'when no configuration repository is specified' do
       it 'should update the configuration repository checkout' do
-        WhiskeyDisk.stub!(:has_config_repo?).and_return(false)
         WhiskeyDisk.should.not.receive(:update_configuration_repository_checkout)
         @rake["deploy:setup"].invoke
       end
@@ -110,7 +104,7 @@ describe 'rake tasks' do
 
     describe 'when a configuration repository is specified' do      
       it 'should refresh the configuration' do
-        WhiskeyDisk.stub!(:has_config_repo?).and_return(true)
+        WhiskeyDisk.configuration = { 'config_repository' => 'foo' }
         WhiskeyDisk.should.receive(:refresh_configuration)
         @rake["deploy:setup"].invoke
       end
@@ -118,7 +112,6 @@ describe 'rake tasks' do
     
     describe 'when no configuration repository is specified' do      
       it 'should not refresh the configuration' do
-        WhiskeyDisk.stub!(:has_config_repo?).and_return(false)
         WhiskeyDisk.should.not.receive(:refresh_configuration)
         @rake["deploy:setup"].invoke
       end
@@ -137,8 +130,7 @@ describe 'rake tasks' do
   
   describe 'deploy:now' do
     before do
-      @configuration = { }
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@configuration)
+      WhiskeyDisk.configuration = { }
       [ 
         :enable_staleness_checks,
         :update_main_repository_checkout,
@@ -152,8 +144,7 @@ describe 'rake tasks' do
     end
     
     it 'should make changes on the specified domain when a domain is specified' do
-      @configuration = { 'domain' => 'some domain'}
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@configuration)
+      WhiskeyDisk.configuration = { 'domain' => 'some domain'}
       @rake["deploy:now"].invoke
       WhiskeyDisk.should.be.remote
     end
@@ -174,7 +165,7 @@ describe 'rake tasks' do
     
     describe 'when a configuration repository is specified' do
       it 'should update the configuration repository checkout' do
-        WhiskeyDisk.stub!(:has_config_repo?).and_return(true)
+        WhiskeyDisk.configuration = { 'config_repository' => 'foo' }
         WhiskeyDisk.should.receive(:update_configuration_repository_checkout)
         @rake["deploy:now"].invoke
       end
@@ -182,7 +173,6 @@ describe 'rake tasks' do
     
     describe 'when no configuration repository is specified' do
       it 'should not update the configuration repository checkout' do
-        WhiskeyDisk.stub!(:has_config_repo?).and_return(false)
         WhiskeyDisk.should.not.receive(:update_configuration_repository_checkout)
         @rake["deploy:now"].invoke
       end
@@ -190,7 +180,7 @@ describe 'rake tasks' do
     
     describe 'when a configuration repository is specified' do
       it 'should refresh the configuration' do
-        WhiskeyDisk.stub!(:has_config_repo?).and_return(true)
+        WhiskeyDisk.configuration = { 'config_repository' => 'foo' }
         WhiskeyDisk.should.receive(:refresh_configuration)
         @rake["deploy:now"].invoke
       end
@@ -198,7 +188,6 @@ describe 'rake tasks' do
     
     describe 'when no configuration repository is specified' do
       it 'should not refresh the configuration' do
-        WhiskeyDisk.stub!(:has_config_repo?).and_return(false)
         WhiskeyDisk.should.not.receive(:refresh_configuration)
         @rake["deploy:now"].invoke
       end
@@ -217,9 +206,7 @@ describe 'rake tasks' do
       
   describe 'deploy:post_setup' do
     it 'should run the defined post_setup rake task when a post_setup rake task is defined for this environment' do
-      @configuration = { 'environment' => 'production'}
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@configuration)
-      WhiskeyDisk.reset      
+      WhiskeyDisk.configuration = { 'environment' => 'production'}
 
       task "deploy:production:post_setup" do
         WhiskeyDisk.fake_method
@@ -230,18 +217,14 @@ describe 'rake tasks' do
     end
 
     it 'should not fail when no post_setup rake task is defined for this environment' do
-      @configuration = { 'environment' => 'staging'}
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@configuration)
-      WhiskeyDisk.reset      
+      WhiskeyDisk.configuration = { 'environment' => 'staging'}
       lambda { Rake::Task['deploy:post_setup'].invoke }.should.not.raise
     end
   end
   
   describe 'deploy:post_deploy' do
     it 'should run the defined post_deploy rake task when a post_deploy rake task is defined for this environment' do
-      @configuration = { 'environment' => 'production'}
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@configuration)
-      WhiskeyDisk.reset      
+      WhiskeyDisk.configuration = { 'environment' => 'production'}
 
       task "deploy:production:post_deploy" do
         WhiskeyDisk.fake_method
@@ -252,9 +235,7 @@ describe 'rake tasks' do
     end
 
     it 'should not fail when no post_deploy rake task is defined for this environment' do
-      @configuration = { 'environment' => 'staging'}
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@configuration)
-      WhiskeyDisk.reset      
+      WhiskeyDisk.configuration = { 'environment' => 'staging'}
       lambda { Rake::Task['deploy:post_deploy'].invoke }.should.not.raise
     end
   end

data/spec/whiskey_disk_spec.rb

@@ -25,8 +25,7 @@ describe 'WhiskeyDisk' do
   describe 'determining if the deployment is remote' do
     before do
       @parameters = { 'deploy_to' => '/path/to/main/repo' }
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters
     end
     
     it 'should work without arguments' do
@@ -56,8 +55,7 @@ describe 'WhiskeyDisk' do
   describe 'determining if the deployment has a configuration repository' do
     before do
       @parameters = { 'deploy_to' => '/path/to/main/repo' }
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters
     end
     
     it 'should work without arguments' do
@@ -107,14 +105,11 @@ describe 'WhiskeyDisk' do
 
   describe 'ensuring that the parent path for the main repository checkout is present' do
     before do
-      @parameters = { 'deploy_to' => '/path/to/main/repo' }
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = { 'deploy_to' => '/path/to/main/repo' }
     end
     
     it 'should fail if the deployment path is not specified' do
-      WhiskeyDisk::Config.stub!(:fetch).and_return({})
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = {}
       lambda { WhiskeyDisk.ensure_main_parent_path_is_present }.should.raise
     end
     
@@ -127,14 +122,11 @@ describe 'WhiskeyDisk' do
 
   describe 'ensuring that the parent path for the configuration repository checkout is present' do
     before do
-      @parameters = { 'deploy_config_to' => '/path/to/config/repo' }
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = { 'deploy_config_to' => '/path/to/config/repo' }
     end
     
     it 'should fail if the configuration deployment path is not specified' do
-      WhiskeyDisk::Config.stub!(:fetch).and_return({})
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = {}
       lambda { WhiskeyDisk.ensure_config_parent_path_is_present }.should.raise
     end
     
@@ -148,19 +140,16 @@ describe 'WhiskeyDisk' do
   describe 'checking out the main repository' do
     before do
       @parameters = { 'deploy_to' => '/path/to/main/repo', 'repository' => 'git@ogtastic.com:whiskey_disk.git' }
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters
     end
     
     it 'should fail if the deployment path is not specified' do
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters.merge('deploy_to' => nil))
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters.merge('deploy_to' => nil)
       lambda { WhiskeyDisk.checkout_main_repository }.should.raise
     end
     
     it 'should fail if the repository is not specified' do
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters.merge('repository' => nil))
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters.merge('repository' => nil)
       lambda { WhiskeyDisk.checkout_main_repository }.should.raise
     end
     
@@ -184,19 +173,16 @@ describe 'WhiskeyDisk' do
   describe 'checking out the configuration repository' do
     before do
       @parameters = { 'deploy_config_to' => '/path/to/config/repo', 'config_repository' => 'git@ogtastic.com:config.git' }
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters
     end
 
     it 'should fail if the configuration deployment path is not specified' do
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters.merge('deploy_config_to' => nil))
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters.merge('deploy_config_to' => nil)
       lambda { WhiskeyDisk.checkout_configuration_repository }.should.raise
     end
 
     it 'should fail if the configuration repository is not specified' do
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters.merge('config_repository' => nil))
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters.merge('config_repository' => nil)
       lambda { WhiskeyDisk.checkout_configuration_repository }.should.raise
     end
 
@@ -220,13 +206,11 @@ describe 'WhiskeyDisk' do
   describe 'updating the main repository checkout' do
     before do
       @parameters = { 'deploy_to' => '/path/to/main/repo' }
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters
     end
     
     it 'should fail if the deployment path is not specified' do
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters.merge('deploy_to' => nil))
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters.merge('deploy_to' => nil)
       lambda { WhiskeyDisk.update_main_repository_checkout }.should.raise
     end
     
@@ -241,8 +225,7 @@ describe 'WhiskeyDisk' do
     end
     
     it 'should attempt to fetch the specified branch from the origin if a branch is specified' do
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters.merge({'branch' => 'production'}))
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters.merge({'branch' => 'production'})
       WhiskeyDisk.update_main_repository_checkout
       WhiskeyDisk.buffer.join(' ').should.match(%r{git fetch origin \+refs/heads/production:refs/remotes/origin/production})
     end
@@ -253,8 +236,7 @@ describe 'WhiskeyDisk' do
     end
     
     it 'should attempt to reset the specified branch from the origin if a branch is specified' do
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters.merge({'branch' => 'production'}))
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters.merge({'branch' => 'production'})
       WhiskeyDisk.update_main_repository_checkout
       WhiskeyDisk.buffer.join(' ').should.match(%r{git reset --hard origin/production})
     end
@@ -263,13 +245,11 @@ describe 'WhiskeyDisk' do
   describe 'updating the configuration repository checkout' do
     before do
       @parameters = { 'deploy_config_to' => '/path/to/config/repo' }
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters
     end
     
     it 'should fail if the configuration deployment path is not specified' do
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters.merge('deploy_config_to' => nil))
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters.merge('deploy_config_to' => nil)
       lambda { WhiskeyDisk.update_configuration_repository_checkout }.should.raise
     end
     
@@ -284,8 +264,7 @@ describe 'WhiskeyDisk' do
     end
     
     it 'should attempt to fetch the specified branch from the origin if a configuration branch is specified' do
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters.merge({'config_branch' => 'production'}))
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters.merge({'config_branch' => 'production'})
       WhiskeyDisk.update_configuration_repository_checkout
       WhiskeyDisk.buffer.join(' ').should.match(%r{git fetch origin \+refs/heads/production:refs/remotes/origin/production})
     end
@@ -296,8 +275,7 @@ describe 'WhiskeyDisk' do
     end
 
     it 'should attempt to reset the master branch from the origin if no configuration branch is specified' do
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters.merge({'config_branch' => 'production'}))
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters.merge({'config_branch' => 'production'})
       WhiskeyDisk.update_configuration_repository_checkout
       WhiskeyDisk.buffer.join(' ').should.match(%r{git reset --hard origin/production})
     end
@@ -311,25 +289,21 @@ describe 'WhiskeyDisk' do
                       'config_repository' => 'git@git://foo.bar.git',
                       'config_branch' => 'master',
                       'project' => 'whiskey_disk' }
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters
     end
-    
+
     it 'should fail if the main deployment path is not specified' do
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters.merge('deploy_to' => nil))
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters.merge('deploy_to' => nil)
       lambda { WhiskeyDisk.refresh_configuration }.should.raise
     end
     
     it 'should fail if the configuration deployment path is not specified' do
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters.merge('deploy_config_to' => nil))
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters.merge('deploy_config_to' => nil)
       lambda { WhiskeyDisk.refresh_configuration }.should.raise
     end
     
     it 'should fail if no project name was specified' do
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters.merge('project' => 'unnamed_project'))
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters.merge('project' => 'unnamed_project')
       lambda { WhiskeyDisk.refresh_configuration }.should.raise      
     end
     
@@ -341,14 +315,11 @@ describe 'WhiskeyDisk' do
   
   describe 'running post setup hooks' do
     before do
-      @parameters = { 'deploy_to' => '/path/to/main/repo' }
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = { 'deploy_to' => '/path/to/main/repo' }
     end
     
     it 'should fail if the deployment path is not specified' do
-      WhiskeyDisk::Config.stub!(:fetch).and_return({})
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = {}
       lambda { WhiskeyDisk.run_post_setup_hooks }.should.raise
     end
     
@@ -360,10 +331,7 @@ describe 'WhiskeyDisk' do
     describe 'when a post setup script is specified' do
       describe 'and the script path does not start with a "/"' do      
         before do
-          @parameters = { 'deploy_to'          => '/path/to/main/repo', 
-                          'post_setup_script' => '/path/to/setup/script' }
-          WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-          WhiskeyDisk.reset
+          WhiskeyDisk.configuration = { 'deploy_to' => '/path/to/main/repo', 'post_setup_script' => '/path/to/setup/script' }
         end
       
         it 'should attempt to run the post setup script' do        
@@ -384,10 +352,7 @@ describe 'WhiskeyDisk' do
       
       describe 'and the script path does not start with a "/"' do
         before do
-          @parameters = { 'deploy_to'          => '/path/to/main/repo', 
-                          'post_setup_script' => 'path/to/setup/script' }
-          WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-          WhiskeyDisk.reset         
+          WhiskeyDisk.configuration = { 'deploy_to' => '/path/to/main/repo', 'post_setup_script' => 'path/to/setup/script' }
         end
 
         it 'should attempt to run the post setup script' do        
@@ -429,8 +394,7 @@ describe 'WhiskeyDisk' do
 
     it 'should ensure that any rake ENV variable are set when checking for deploy:post_setup tasks' do
       @parameters = { 'deploy_to' => '/path/to/main/repo', 'rake_env' => { 'RAILS_ENV' => 'production', 'FOO' => 'bar' } }
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters
       WhiskeyDisk.run_post_setup_hooks
       @parameters['rake_env'].each_pair do |k,v|
         WhiskeyDisk.buffer.join(' ').should.match(%r{#{k}='#{v}' .*rake -P})
@@ -439,8 +403,7 @@ describe 'WhiskeyDisk' do
     
     it 'should set any rake_env variables when running the rake tasks' do
       @parameters = { 'deploy_to' => '/path/to/main/repo', 'rake_env' => { 'RAILS_ENV' => 'production', 'FOO' => 'bar' } }
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters
       WhiskeyDisk.run_post_setup_hooks
       @parameters['rake_env'].each_pair do |k,v|
         WhiskeyDisk.buffer.join(' ').should.match(%r{#{k}='#{v}' })
@@ -450,14 +413,11 @@ describe 'WhiskeyDisk' do
   
   describe 'running post deployment hooks' do
     before do
-      @parameters = { 'deploy_to' => '/path/to/main/repo' }
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = { 'deploy_to' => '/path/to/main/repo' }
     end
     
     it 'should fail if the deployment path is not specified' do
-      WhiskeyDisk::Config.stub!(:fetch).and_return({})
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = {}
       lambda { WhiskeyDisk.run_post_deploy_hooks }.should.raise
     end
     
@@ -469,10 +429,7 @@ describe 'WhiskeyDisk' do
     describe 'when a post deployment script is specified' do
       describe 'and the script path does not start with a "/"' do      
         before do
-          @parameters = { 'deploy_to'          => '/path/to/main/repo', 
-                          'post_deploy_script' => '/path/to/deployment/script' }
-          WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-          WhiskeyDisk.reset
+          WhiskeyDisk.configuration = { 'deploy_to' => '/path/to/main/repo', 'post_deploy_script' => '/path/to/deployment/script' }
         end
       
         it 'should attempt to run the post deployment script' do        
@@ -493,10 +450,7 @@ describe 'WhiskeyDisk' do
       
       describe 'and the script path does not start with a "/"' do
         before do
-          @parameters = { 'deploy_to'          => '/path/to/main/repo', 
-                          'post_deploy_script' => 'path/to/deployment/script' }
-          WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-          WhiskeyDisk.reset         
+          WhiskeyDisk.configuration = { 'deploy_to' => '/path/to/main/repo', 'post_deploy_script' => 'path/to/deployment/script' }
         end
 
         it 'should attempt to run the post deployment script' do        
@@ -538,8 +492,7 @@ describe 'WhiskeyDisk' do
 
     it 'should ensure that any rake ENV variable are set when checking for deploy:post_setup tasks' do
       @parameters = { 'deploy_to' => '/path/to/main/repo', 'rake_env' => { 'RAILS_ENV' => 'production', 'FOO' => 'bar' } }
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters
       WhiskeyDisk.run_post_deploy_hooks
       @parameters['rake_env'].each_pair do |k,v|
         WhiskeyDisk.buffer.join(' ').should.match(%r{#{k}='#{v}' .*rake -P})
@@ -548,8 +501,7 @@ describe 'WhiskeyDisk' do
     
     it 'should set any rake_env variables when running the rake tasks' do
       @parameters = { 'deploy_to' => '/path/to/main/repo', 'rake_env' => { 'RAILS_ENV' => 'production', 'FOO' => 'bar' } }
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters
       WhiskeyDisk.run_post_deploy_hooks
       @parameters['rake_env'].each_pair do |k,v|
         WhiskeyDisk.buffer.join(' ').should.match(%r{#{k}='#{v}' })
@@ -560,18 +512,15 @@ describe 'WhiskeyDisk' do
   describe 'flushing changes' do
     describe 'when running remotely' do
       before do
-        @parameters = { 'domain' => 'www.domain.com', 'deploy_to' => '/path/to/main/repo' }
-        WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-        WhiskeyDisk.reset
+        WhiskeyDisk.configuration = { 'domain' => 'www.domain.com', 'deploy_to' => '/path/to/main/repo' }
         WhiskeyDisk.stub!(:bundle).and_return('command string')
-        WhiskeyDisk.stub!(:register_configuration)
         WhiskeyDisk.stub!(:run)
       end
       
       it 'should bundle the buffer of commands' do
         WhiskeyDisk.enqueue('x')
         WhiskeyDisk.enqueue('y')
-        WhiskeyDisk.should.receive(:bundle).and_return('command string')
+        WhiskeyDisk.should.receive(:bundle)
         WhiskeyDisk.flush
       end
       
@@ -583,9 +532,7 @@ describe 'WhiskeyDisk' do
     
     describe 'when running locally' do
       before do
-        @parameters = { 'deploy_to' => '/path/to/main/repo' }
-        WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-        WhiskeyDisk.reset
+        WhiskeyDisk.configuration = { 'deploy_to' => '/path/to/main/repo' }
         WhiskeyDisk.stub!(:bundle).and_return('command string')
         WhiskeyDisk.stub!(:system)
       end
@@ -664,8 +611,7 @@ describe 'WhiskeyDisk' do
             @deploy_to = '/path/to/main/repo'
             @repository = 'git@git://foo.bar.git'
             @parameters = { 'deploy_to' => @deploy_to, 'repository' => @repository }
-            WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-            WhiskeyDisk.reset
+            WhiskeyDisk.configuration = @parameters
             WhiskeyDisk.enable_staleness_checks
           end
           
@@ -695,8 +641,7 @@ describe 'WhiskeyDisk' do
           end
           
           it "should query the head of the main checkout's specified branch if a branch is specified" do
-            WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters.merge({'branch' => 'production'}))
-            WhiskeyDisk.reset
+            WhiskeyDisk.configuration = @parameters.merge({'branch' => 'production'})
             WhiskeyDisk.enable_staleness_checks
             WhiskeyDisk.enqueue("COMMAND")
             WhiskeyDisk.bundle.should.match(Regexp.new(Regexp.escape("cd #{@deploy_to}; ml=\`cat .git/refs/heads/production\`;")))
@@ -708,8 +653,7 @@ describe 'WhiskeyDisk' do
           end
           
           it "should query the head of the main repository's specified branch if a branch is specified" do
-            WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters.merge({'branch' => 'production'}))
-            WhiskeyDisk.reset
+            WhiskeyDisk.configuration = @parameters.merge({'branch' => 'production'})
             WhiskeyDisk.enable_staleness_checks
             WhiskeyDisk.enqueue("COMMAND")
             WhiskeyDisk.bundle.should.match(Regexp.new(Regexp.escape("mr=\`git ls-remote #{@repository} refs/heads/production\`;")))
@@ -731,8 +675,7 @@ describe 'WhiskeyDisk' do
               'deploy_to' => @deploy_to, 'repository' => @repository,
               'deploy_config_to' => @deploy_config_to, 'config_repository' => @config_repository
             }
-            WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-            WhiskeyDisk.reset
+            WhiskeyDisk.configuration = @parameters
             WhiskeyDisk.enable_staleness_checks
           end
           
@@ -762,8 +705,7 @@ describe 'WhiskeyDisk' do
           end
           
           it "should query the head of the main checkout's specified branch if a branch is specified" do
-            WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters.merge({'branch' => 'production'}))
-            WhiskeyDisk.reset
+            WhiskeyDisk.configuration = @parameters.merge({'branch' => 'production'})
             WhiskeyDisk.enable_staleness_checks
             WhiskeyDisk.enqueue("COMMAND")
             WhiskeyDisk.bundle.should.match(Regexp.new(Regexp.escape("cd #{@deploy_to}; ml=\`cat .git/refs/heads/production\`;")))
@@ -775,8 +717,7 @@ describe 'WhiskeyDisk' do
           end
           
           it "should query the head of the main repository's specified branch if a branch is specified" do
-            WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters.merge({'branch' => 'production'}))
-            WhiskeyDisk.reset
+            WhiskeyDisk.configuration = @parameters.merge({'branch' => 'production'})
             WhiskeyDisk.enable_staleness_checks
             WhiskeyDisk.enqueue("COMMAND")
             WhiskeyDisk.bundle.should.match(Regexp.new(Regexp.escape("mr=\`git ls-remote #{@repository} refs/heads/production\`;")))
@@ -788,8 +729,7 @@ describe 'WhiskeyDisk' do
           end
           
           it "should query the head of the config checkout's specified branch if a branch is specified" do
-            WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters.merge({'config_branch' => 'production'}))
-            WhiskeyDisk.reset
+            WhiskeyDisk.configuration = @parameters.merge({'config_branch' => 'production'})
             WhiskeyDisk.enable_staleness_checks
             WhiskeyDisk.enqueue("COMMAND")
             WhiskeyDisk.bundle.should.match(Regexp.new(Regexp.escape("cd #{@deploy_config_to}; cl=\`cat .git/refs/heads/production\`;")))
@@ -801,8 +741,7 @@ describe 'WhiskeyDisk' do
           end
           
           it "should query the head of the config repository's specified branch if a branch is specified" do
-            WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters.merge({'config_branch' => 'production'}))
-            WhiskeyDisk.reset
+            WhiskeyDisk.configuration = @parameters.merge({'config_branch' => 'production'})
             WhiskeyDisk.enable_staleness_checks
             WhiskeyDisk.enqueue("COMMAND")
             WhiskeyDisk.bundle.should.match(Regexp.new(Regexp.escape("cr=\`git ls-remote #{@config_repository} refs/heads/production\`;")))
@@ -815,8 +754,7 @@ describe 'WhiskeyDisk' do
   describe 'when running a command string remotely' do
     before do
       @domain = 'ogc@ogtastic.com'
-      WhiskeyDisk::Config.stub!(:fetch).and_return({ 'domain' => @domain })
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = { 'domain' => @domain }
       WhiskeyDisk.stub!(:system)      
     end
     
@@ -829,8 +767,7 @@ describe 'WhiskeyDisk' do
     end
     
     it 'should fail if the domain path is not specified' do
-      WhiskeyDisk::Config.stub!(:fetch).and_return({})
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = {}
       lambda { WhiskeyDisk.run('ls') }.should.raise
     end
     

data/whiskey_disk.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{whiskey_disk}
-  s.version = "0.5.3"
+  s.version = "0.5.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Rick Bradley"]
-  s.date = %q{2010-09-07}
+  s.date = %q{2010-10-26}
   s.default_executable = %q{wd}
   s.description = %q{Opinionated gem for doing fast git-based server deployments.}
   s.email = %q{rick@rickbradley.com}

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: whiskey_disk
 version: !ruby/object:Gem::Version 
-  hash: 13
+  hash: 3
   prerelease: false
   segments: 
   - 0
   - 5
-  - 3
-  version: 0.5.3
+  - 4
+  version: 0.5.4
 platform: ruby
 authors: 
 - Rick Bradley
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-07 00:00:00 -05:00
+date: 2010-10-26 00:00:00 -05:00
 default_executable: wd
 dependencies: 
 - !ruby/object:Gem::Dependency