whiskey_disk 0.5.2 → 0.5.3

data/README.markdown

@@ -364,3 +364,8 @@ to see what we have in mind for the near future.
  - [http://toroid.org/ams/git-website-howto](http://toroid.org/ams/git-website-howto)
 
 
+### Contributors ###
+
+ - Rick Bradley (rick@rickbradley.com, github:rick)
+ - Jeremy Holland (jeremy@jeremypholland.com, github:therubyneck): feature/bugfix contributions
+

data/VERSION

@@ -1 +1 @@
-0.5.2
+0.5.3

data/lib/whiskey_disk/config.rb

@@ -8,24 +8,29 @@ class WhiskeyDisk
         return ENV['to'] unless ENV['to'] =~ /:/
         ENV['to'].split(/:/)[1]
       end
-      
+
       def specified_project_name
         return false unless (ENV['to'] && ENV['to'] =~ /:/)
         ENV['to'].split(/:/).first
       end
-      
+
+      def override_project_name!(data)
+        return if ENV['to'] && ENV['to'] =~ /:/
+        ENV['to'] = data[environment_name]['project'] + ':' + ENV['to'] if data[environment_name]['project']
+      end
+
       def path
         (ENV['path'] && ENV['path'] != '') ? ENV['path'] : false
       end
-      
+
       def check_staleness?
         !!(ENV['check'] && ENV['check'] =~ /^(?:t(?:rue)?|y(?:es)?|1)$/)
       end
-      
+
       def contains_rakefile?(path)
         File.exists?(File.expand_path(File.join(path, 'Rakefile')))
       end
-      
+
       def find_rakefile_from_current_path
         original_path = Dir.pwd
         while (!contains_rakefile?(Dir.pwd))
@@ -36,38 +41,38 @@ class WhiskeyDisk
       ensure
         Dir.chdir(original_path)
       end
-      
+
       def base_path
         return path if path
         find_rakefile_from_current_path
       end
-      
+
       def configuration_file
         return path if path and File.file?(path)
-        
+
         files = []
 
         files += [
           File.join(base_path, 'deploy', specified_project_name, "#{environment_name}.yml"),  # /deploy/foo/staging.yml
           File.join(base_path, 'deploy', "#{specified_project_name}.yml") # /deploy/foo.yml
         ] if specified_project_name
-        
-        files += [ 
+
+        files += [
           File.join(base_path, 'deploy', "#{environment_name}.yml"),  # /deploy/staging.yml
           File.join(base_path, "#{environment_name}.yml"), # /staging.yml
           File.join(base_path, 'deploy.yml') # /deploy.yml
         ]
-        
+
         files.each { |file|  return file if File.exists?(file) }
-        
+
         raise "Could not locate configuration file in path [#{base_path}]"
       end
-      
+
       def configuration_data
         raise "Configuration file [#{configuration_file}] not found!" unless File.exists?(configuration_file)
         File.read(configuration_file)
       end
-      
+
       def project_name
         specified_project_name || 'unnamed_project'
       end
@@ -77,12 +82,12 @@ class WhiskeyDisk
         return depth if data.has_key?('repository')
         repository_depth(data.values.first, depth + 1)
       end
-      
+
       # is this data hash a bottom-level data hash without an environment name?
       def needs_environment_scoping?(data)
         repository_depth(data) == 0
       end
-      
+
       # is this data hash an environment data hash without a project name?
       def needs_project_scoping?(data)
         repository_depth(data) == 1
@@ -93,33 +98,34 @@ class WhiskeyDisk
         { environment_name => data }
       end
 
-      def add_project_scoping(data)        
+      def add_project_scoping(data)
         return data unless needs_project_scoping?(data)
+        override_project_name!(data)
         { project_name => data }
       end
 
       def normalize_data(data)
         add_project_scoping(add_environment_scoping(data.clone))
-      end      
-      
+      end
+
       def load_data
         normalize_data(YAML.load(configuration_data))
       rescue Exception => e
         raise %Q{Error reading configuration file [#{configuration_file}]: "#{e}"}
       end
-      
+
       def filter_data(data)
         raise "No configuration file defined data for environment [#{environment_name}]" unless data[project_name][environment_name]
         data[project_name][environment_name].merge({
-          'environment' => environment_name, 
+          'environment' => environment_name,
           'project' => project_name
         })
       end
-      
+
       def fetch
         raise "Cannot determine current environment -- try rake ... to=staging, for example." unless environment_name
         filter_data(load_data)
       end
     end
   end
-end
+end

data/spec/whiskey_disk/config_spec.rb

@@ -11,37 +11,37 @@ describe WhiskeyDisk::Config do
       ENV['to'] = nil
       WhiskeyDisk::Config.environment_name.should == false
     end
-    
+
     it 'should return false when the ENV["to"] setting is blank' do
       ENV['to'] = ''
-      WhiskeyDisk::Config.environment_name.should == false  
+      WhiskeyDisk::Config.environment_name.should == false
     end
-    
+
     it 'should return the ENV["to"] setting when it is non-blank' do
       ENV['to'] = 'staging'
       WhiskeyDisk::Config.environment_name.should == 'staging'
     end
-    
+
     it 'should return the environment portion of the ENV["to"] setting when a project is specified' do
       ENV['to'] = 'project:staging'
-      WhiskeyDisk::Config.environment_name.should == 'staging'      
+      WhiskeyDisk::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
       ENV['check'] = nil
       WhiskeyDisk::Config.check_staleness?.should == false
     end
-    
+
     it 'should return false when the ENV["check"] setting is blank' do
       ENV['check'] = ''
-      WhiskeyDisk::Config.check_staleness?.should == false      
+      WhiskeyDisk::Config.check_staleness?.should == false
     end
-    
+
     it 'should return true if the ENV["check"] setting is "t"' do
       ENV['check'] = 't'
-      WhiskeyDisk::Config.check_staleness?.should == true      
+      WhiskeyDisk::Config.check_staleness?.should == true
     end
 
     it 'should return true if the ENV["check"] setting is "true"' do
@@ -51,50 +51,50 @@ describe WhiskeyDisk::Config do
 
     it 'should return true if the ENV["check"] setting is "y"' do
       ENV['check'] = 'y'
-      WhiskeyDisk::Config.check_staleness?.should == true      
+      WhiskeyDisk::Config.check_staleness?.should == true
     end
 
     it 'should return true if the ENV["check"] setting is "yes"' do
       ENV['check'] = 'yes'
-      WhiskeyDisk::Config.check_staleness?.should == true      
+      WhiskeyDisk::Config.check_staleness?.should == true
     end
 
     it 'should return true if the ENV["check"] setting is "1"' do
       ENV['check'] = '1'
-      WhiskeyDisk::Config.check_staleness?.should == true      
+      WhiskeyDisk::Config.check_staleness?.should == true
     end
   end
-  
+
   describe 'when fetching configuration' do
     before do
       ENV['to'] = @env = 'foo:staging'
     end
-    
+
     it 'should fail if the current environment cannot be determined' do
       ENV['to'] = nil
       lambda { WhiskeyDisk::Config.fetch }.should.raise
     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")
-      lambda { WhiskeyDisk::Config.fetch }.should.raise        
+      lambda { WhiskeyDisk::Config.fetch }.should.raise
     end
-    
+
     it 'should fail if the configuration file is invalid' do
       YAML.stub!(:load).and_raise
-      lambda { WhiskeyDisk::Config.fetch }.should.raise        
+      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'}}}))
       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 }}))
@@ -103,63 +103,70 @@ describe WhiskeyDisk::Config do
         result[k].should == v
       end
     end
-    
+
     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 }))
       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 }}))
       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 }}))
       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 }}))
       WhiskeyDisk::Config.fetch['project'].should == 'foo'
     end
-    
-    it 'should not allow overriding the project handle in the configuration file' do
+
+    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 }}))
       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 }))
+      WhiskeyDisk::Config.fetch['project'].should == 'diskey_whisk'
+    end
   end
-  
+
   describe 'returning configuration data from a configuration file' do
     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'
     end
   end
-  
+
   describe 'transforming data from the configuration file' do
     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
       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))
@@ -167,53 +174,89 @@ describe WhiskeyDisk::Config do
       WhiskeyDisk::Config.load_data.should == 'normalized data'
     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' => '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    
+    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
-        
-      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 }
+
+      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
-    
-      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 } } 
+
+      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    
+    describe 'when a project name is specified via ENV["to"]' do
       before do
         ENV['to'] = @env = 'whiskey_disk: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
-        
-      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 }
+
+      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
-    
-      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 } } 
+
+      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
   end
@@ -221,17 +264,17 @@ describe WhiskeyDisk::Config do
   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
       ENV['to'] = 'foo:staging'
-      WhiskeyDisk::Config.project_name.should == 'foo'      
+      WhiskeyDisk::Config.project_name.should == 'foo'
     end
-    
-    it 'should fail when ENV["to"] is unset' do
+
+    it 'should return "unnamed_project" when ENV["to"] is unset' do
       ENV['to'] = ''
-      WhiskeyDisk::Config.project_name.should == 'unnamed_project'    
+      WhiskeyDisk::Config.project_name.should == 'unnamed_project'
     end
-    
+
     it 'should return "unnamed_project" when no ENV["to"] project setting is available' do
       ENV['to'] = 'staging'
-      WhiskeyDisk::Config.project_name.should == 'unnamed_project'      
+      WhiskeyDisk::Config.project_name.should == 'unnamed_project'
     end
   end
 
@@ -239,47 +282,47 @@ describe WhiskeyDisk::Config do
     before do
       ENV['to'] = @env = 'staging'
     end
-    
-    describe 'and no path is specified' do    
+
+    describe 'and no path is specified' do
       before do
         ENV['path'] = @path = nil
       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 == '/path/to/project/config/deploy/foo/staging.yml'
         end
-        
-        it 'should return the path to deploy/foo.yml under the project base path if it exists' do          
+
+        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'          
+          WhiskeyDisk::Config.configuration_file.should == '/path/to/project/config/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'      
+          WhiskeyDisk::Config.configuration_file.should == '/path/to/project/config/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'      
+          WhiskeyDisk::Config.configuration_file.should == '/path/to/project/config/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)
@@ -300,21 +343,21 @@ describe WhiskeyDisk::Config do
           lambda { WhiskeyDisk::Config.configuration_file }.should.raise
         end
       end
-      
-      describe 'and no project name is specified in ENV["to"]' do          
+
+      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 == '/path/to/project/config/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'      
+          WhiskeyDisk::Config.configuration_file.should == '/path/to/project/config/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)
@@ -343,37 +386,37 @@ describe WhiskeyDisk::Config do
       File.stub!(:exists?).with(@path).and_return(true)
       WhiskeyDisk::Config.configuration_file.should == @path
     end
-  
+
     describe 'and a path which points to a directory is specified' do
       before do
         ENV['path'] = @path = CURRENT
       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')     
+          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          
+
+        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)
           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)
           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)
@@ -381,7 +424,7 @@ describe WhiskeyDisk::Config do
           File.stub!(:exists?).with(File.join(@path, 'staging.yml')).and_return(true)
           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)
@@ -390,7 +433,7 @@ describe WhiskeyDisk::Config do
           File.stub!(:exists?).with(File.join(@path, 'deploy.yml')).and_return(true)
           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)
@@ -401,25 +444,25 @@ describe WhiskeyDisk::Config do
         end
       end
 
-      describe 'and no project name is specified in ENV["to"]' do      
+      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)
           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)
           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)
@@ -429,49 +472,49 @@ describe WhiskeyDisk::Config do
       end
     end
   end
-  
+
   describe 'computing the base path for the project' do
     before do
       @original_path = Dir.pwd
       ENV['path'] = @path = nil
     end
-    
+
     after do
       Dir.chdir(@original_path)
-    end      
-    
+    end
+
     describe 'and a "path" environment variable is set' do
       before do
         ENV['path'] = @path = CURRENT
         Dir.chdir(CURRENT)
       end
-      
+
       it 'should return the path set in the "path" environment variable' do
-        WhiskeyDisk::Config.base_path.should == @path      
+        WhiskeyDisk::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
         Dir.pwd.should == CURRENT
       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)
       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')
       end
-      
+
       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
       end
-    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, '..', '..'))
@@ -479,15 +522,15 @@ describe WhiskeyDisk::Config do
         WhiskeyDisk::Config.stub!(:contains_rakefile?).with(@top).and_return(true)
         Dir.chdir(CURRENT)
       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')
       end
-      
+
       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
       end
     end
   end
-end
+end

data/whiskey_disk.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{whiskey_disk}
-  s.version = "0.5.2"
+  s.version = "0.5.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Rick Bradley"]
-  s.date = %q{2010-09-06}
+  s.date = %q{2010-09-07}
   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: 15
+  hash: 13
   prerelease: false
   segments: 
   - 0
   - 5
-  - 2
-  version: 0.5.2
+  - 3
+  version: 0.5.3
 platform: ruby
 authors: 
 - Rick Bradley
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-06 00:00:00 -05:00
+date: 2010-09-07 00:00:00 -05:00
 default_executable: wd
 dependencies: 
 - !ruby/object:Gem::Dependency