whiskey_disk 0.6.16 → 0.6.17

data/CHANGELOG

@@ -1,4 +1,32 @@
 
+0.6.17 / 2011-03-25 
+==================
+
+  * updating contributor info in README
+  * updating specs to pass under new --debug regime
+  * deployment status message shouldn't appear in spec run output
+  * Refactoring WhiskeyDisk.reset in whiskey_disk_spec.rb
+  * spec helper should keep debugging on for test runs
+  * Make deployment status message more readable
+  * Only run post deploy|setup script with -x in debug mode
+  * Only rake --trace in debug mode
+  * Suppressing git output unless debug mode
+  * Adding log mesage for rsync configuration
+  * Only show rsync verbose and progress if debug enabled
+  * Print out a log message to indicate which host is currently being deployed
+  * Only run set -x in debug mode, also don't use bash -c
+  * Refactor a spec to use build_command directly
+  * Fix spec description for ENV['debug']
+  * Only run ssh with -v if in debug mode
+  * Refactor run to use a #ssh command
+  * Add WhiskeyDisk::Config.debug?
+  * Add -d, --debug to bin/wd
+  * change raise to abort for cleaner help output when doing `wd -h`
+  * change raise to abort for cleaner help output
+  * add --version option to wd
+  * Add support section to README
+
+
 0.6.16 / 2011-03-08 
 ==================
 

data/README.markdown

@@ -439,6 +439,13 @@ are in an environment where the 'app' role is active but the 'web' role is not:
     % wd deploy --to=foo:qa --path=https://github.com/username/project/raw/master/path/to/configs/deploy.yml
     % wd deploy --to=foo:qa --only=myhost.example.com
 
+    % wd --help
+    % wd --version
+
+
+
+Also, `--debug` can be used to enable verbose output when running `wd setup` or `wd deploy`.
+
 Note that the wd command (unlike rake, which requires a Rakefile in the current directory) can be run from anywhere, so you can deploy any project, working from any path, and can even specify where to find the deployment YAML configuration file.
   
 The --path argument can take either a file or a directory.  When given a file it will use that file as the configuration file.  When given a directory it will look in that directory for deploy/<project>/<target>.yml, then deploy/<project>.yml, then deploy/<target>.yml, then <target>.yml, and finally, deploy.yml.
@@ -757,12 +764,22 @@ to see what we have in mind for the near future.
  - [http://github.com/mislav/git-deploy](http://github.com/mislav/git-deploy)
  - [http://toroid.org/ams/git-website-howto](http://toroid.org/ams/git-website-howto)
 
+### Support ###
+
+The [bug tracker](https://github.com/flogic/whiskey_disk/issues)
+is available here:
+
+  -  [https://github.com/flogic/whiskey_disk/issues](https://github.com/flogic/whiskey_disk/issues)
+
+The IRC channel is #whiskey_disk on freenode.
 
 ### Contributors ###
 
- - Rick Bradley (rick@rickbradley.com, github:rick)
- - Jeremy Holland (jeremy@jeremypholland.com, github:therubyneck): feature/bugfix contributions
- - Kevin Barnes (@vinbarnes), Yossef Mendelssohn (cardioid) for design help and proofreading
- - Alex Sharp (ajsharp@gmail.com) - issues, real-world usage cases, design feedback
- - Josh Moore (josh@codingforrent.com) - tracking down issues handling bad project Rakefiles
- - Cristi Balan (evilchelu) for feedback and proofreading
+ - [Rick Bradley](https://github.com/rick): author
+ - [Rein Henrichs](https://github.com/reinh): design help, code
+ - [Jeremy Holland](https://github.com/awebneck): code
+ - [Kevin Barnes](https://github.com/vinbarnes): design help, code
+ - [Alex Sharp](https://github.com/ajsharp): issues, real-world usage cases, design help
+ - [Yossef Mendelssohn](https://github.com/ymendel): design help, proofreading
+ - [Josh Moore](https://github.com/joshsmoore): bug-hunting
+ - [Cristi Balan](https://github.com/evilchelu): feedback, proofreading

data/VERSION

@@ -1 +1 @@
-0.6.16
+0.6.17

data/bin/wd

@@ -22,13 +22,27 @@ op = OptionParser.new do |opts|
   opts.on('-c', '--check', "do a staleness check before deploying") do |path|
     options[:check] = 'true'
   end
+
+  opts.on('-d', '--debug', "turn on debug mode (ssh -v and rake --trace)") do
+    options[:debug] = 'true'
+  end
     
+  opts.on('--version', 'show current version') do
+    puts File.read(File.expand_path(File.join(File.dirname(__FILE__), '..', 'VERSION')))
+    exit 0
+  end
+  
   opts.on_tail('-h', '--help', 'show this message') do
-    raise opts.to_s
+    abort opts.to_s
   end
 end
 
-rest = op.parse(ARGV)
+begin
+  rest = op.parse(ARGV) 
+rescue 
+  abort op.to_s 
+end
+
 raise op.to_s unless options[:target]
 raise op.to_s unless rest and rest.size == 1
 command = rest.first
@@ -38,9 +52,10 @@ ENV['to'] = options[:target]
 ENV['path'] = options[:path]
 ENV['only'] = options[:only]
 ENV['check'] = options[:check]
+ENV['debug'] = options[:debug]
 
 if command == 'deploy'
   Rake::Task['deploy:now'].invoke
 else
   Rake::Task['deploy:setup'].invoke
-end
+end

data/lib/whiskey_disk/config.rb

@@ -28,6 +28,10 @@ class WhiskeyDisk
       def check_staleness?
         !!(ENV['check'] && ENV['check'] =~ /^(?:t(?:rue)?|y(?:es)?|1)$/)
       end
+
+      def debug?
+        !!(ENV['debug'] && ENV['debug'] =~ /^(?:t(?:rue)?|y(?:es)?|1)$/)
+      end
       
       def domain_limit
         return false unless ENV['only'] and ENV['only'] != ''

data/lib/whiskey_disk.rb

@@ -129,11 +129,17 @@ class WhiskeyDisk
     end
 
     def build_command(domain, cmd)
-      "set -x; " + encode_roles(domain[:roles]) + cmd
+      "#{'set -x; ' if Config.debug?}" + encode_roles(domain[:roles]) + cmd
     end
     
     def run(domain, cmd)
-      system('ssh', '-v', domain[:name], 'bash', '-c', build_command(domain, cmd))
+      ssh(domain, cmd)
+    end
+
+    def ssh(domain, cmd)
+      args = [domain[:name], build_command(domain, cmd)]
+      args.unshift '-v' if Config.debug?
+      system('ssh', *args)
     end
     
     def shell(domain, cmd)
@@ -144,6 +150,7 @@ class WhiskeyDisk
       needs(:domain)
       self[:domain].each do |domain|
         next unless domain_of_interest?(domain[:name])
+        puts "Deploying #{domain[:name]}..."
         status = remote?(domain[:name]) ? run(domain, bundle) : shell(domain, bundle)
         record_result(domain[:name], status)
       end
@@ -202,15 +209,16 @@ class WhiskeyDisk
    
     def refresh_checkout(path, repo_branch)
       enqueue "cd #{path}"
-      enqueue "git fetch origin +refs/heads/#{repo_branch}:refs/remotes/origin/#{repo_branch}"
-      enqueue "git checkout #{repo_branch}"
-      enqueue "git reset --hard origin/#{repo_branch}"
+      enqueue "git fetch origin +refs/heads/#{repo_branch}:refs/remotes/origin/#{repo_branch} #{'&>/dev/null' unless Config.debug?}"
+      enqueue "git checkout #{repo_branch} #{'&>/dev/null' unless Config.debug?}"
+      enqueue "git reset --hard origin/#{repo_branch} #{'&>/dev/null' unless Config.debug?}"
     end
 
     def run_rake_task(path, task_name)
+      enqueue "echo Running rake #{task_name}..."
       enqueue "cd #{path}"
       enqueue(if_file_present("#{self[:deploy_to]}/Rakefile", 
-        if_task_defined(task_name, "#{env_vars} rake --trace #{task_name} to=#{self[:environment]}")))
+        if_task_defined(task_name, "#{env_vars} rake #{'--trace' if Config.debug?} #{task_name} to=#{self[:environment]}")))
     end
     
     def build_path(path)
@@ -220,7 +228,7 @@ class WhiskeyDisk
 
     def run_script(script)
       return unless script
-      enqueue(%Q<cd #{self[:deploy_to]}; echo "Running post script..."; #{env_vars} bash -x #{build_path(script)}>)
+      enqueue(%Q<cd #{self[:deploy_to]}; echo "Running post script..."; #{env_vars} bash #{'-x' if Config.debug?} #{build_path(script)}>)
     end
 
     def ensure_main_parent_path_is_present
@@ -256,7 +264,8 @@ class WhiskeyDisk
     def refresh_configuration
       needs(:deploy_to, :deploy_config_to)
       raise "Must specify project name when using a configuration repository." unless project_name_specified?
-      enqueue("rsync -av --progress #{self[:deploy_config_to]}/#{self[:project]}/#{self[:config_target]}/ #{self[:deploy_to]}/")
+      enqueue "echo Rsyncing configuration..."
+      enqueue("rsync -a#{'v --progress' if Config.debug?} #{self[:deploy_config_to]}/#{self[:project]}/#{self[:config_target]}/ #{self[:deploy_to]}/")
     end
     
     def run_post_setup_hooks
@@ -271,4 +280,4 @@ class WhiskeyDisk
       run_rake_task(self[:deploy_to], "deploy:post_deploy")
     end
   end
-end
+end

data/spec/spec_helper.rb

@@ -24,10 +24,11 @@ def setup_deployment_area
 end
 
 # run a wd setup using the provided arguments string
-def run_setup(arguments)
+def run_setup(arguments, debugging = true)
   wd_path  = File.join(File.dirname(__FILE__), '..', 'bin', 'wd')
   lib_path = File.join(File.dirname(__FILE__), '..', 'lib')
-  system("/usr/bin/env ruby -I #{lib_path} -r whiskey_disk -rubygems #{wd_path} setup #{arguments} > #{integration_log} 2> #{integration_log}")
+  debug = debugging ? '--debug' : ''
+  system("/usr/bin/env ruby -I #{lib_path} -r whiskey_disk -rubygems #{wd_path} setup #{debug} #{arguments} > #{integration_log} 2> #{integration_log}")
 end
 
 def integration_log
@@ -35,10 +36,11 @@ def integration_log
 end
 
 # run a wd setup using the provided arguments string
-def run_deploy(arguments)
+def run_deploy(arguments, debugging = true)
   wd_path  = File.join(File.dirname(__FILE__), '..', 'bin', 'wd')
   lib_path = File.join(File.dirname(__FILE__), '..', 'lib')
-  status = system("/usr/bin/env ruby -I #{lib_path} -r whiskey_disk -rubygems #{wd_path} deploy #{arguments} > #{integration_log} 2> #{integration_log}")
+  debug = debugging ? '--debug' : ''
+  status = system("/usr/bin/env ruby -I #{lib_path} -r whiskey_disk -rubygems #{wd_path} deploy #{debug} #{arguments} > #{integration_log} 2> #{integration_log}")
   status
 end
 

data/spec/wd_command_spec.rb

@@ -25,6 +25,20 @@ describe 'wd command' do
       lambda { run_command }.should.raise
     end
   end
+
+  it 'should output usage without a backtrace when --help is specified' do
+    Object.send(:remove_const, :ARGV)
+    ARGV = ['--help']
+    self.stub!(:abort).and_raise(SystemExit)  # primarily to drop extraneous output
+    lambda { run_command }.should.raise(SystemExit)
+  end
+  
+  it 'should output usage without a backtrace when garbage options are specified' do
+    Object.send(:remove_const, :ARGV)
+    ARGV = ['--slkjfsdflkj']
+    self.stub!(:abort).and_raise(SystemExit)  # primarily to drop extraneous output
+    lambda { run_command }.should.raise(SystemExit)
+  end
   
   describe "when the 'setup' command is specified" do
     before do
@@ -42,6 +56,7 @@ describe 'wd command' do
         lambda { run_command }.should.raise
       end
     end
+
     
     describe 'and a --to argument is specified' do
       before do
@@ -184,6 +199,80 @@ describe 'wd command' do
           lambda { run_command }.should.not.raise
         end
       end
+
+      describe 'and a --debug argument is specified' do
+        before do
+          ARGV.push '--debug'
+        end
+
+        it 'should run the deploy:now rake task' do
+          @rake.should.receive(:invoke)
+          run_command
+        end
+
+        it 'should make the specified target available as a "debug" argument to the rake task' do
+          run_command
+          ENV['debug'].should == 'true'
+        end
+
+        it 'should fail if the rake task fails' do
+          @rake.stub!(:invoke).and_raise(RuntimeError)
+          lambda { run_command }.should.raise
+        end
+
+        it 'should not fail if the rake task succeeds' do
+          @rake.stub!(:invoke).and_return(true)
+          lambda { run_command }.should.not.raise
+        end
+      end
+      
+      describe 'and a -d argument is specified' do
+        before do
+          ARGV.push '-d'
+        end
+
+        it 'should run the deploy:now rake task' do
+          @rake.should.receive(:invoke)
+          run_command
+        end
+
+        it 'should make the specified target available as a "debug" argument to the rake task' do
+          run_command
+          ENV['debug'].should == 'true'
+        end
+
+        it 'should fail if the rake task fails' do
+          @rake.stub!(:invoke).and_raise(RuntimeError)
+          lambda { run_command }.should.raise
+        end
+
+        it 'should not fail if the rake task succeeds' do
+          @rake.stub!(:invoke).and_return(true)
+          lambda { run_command }.should.not.raise
+        end
+      end
+
+      describe 'and no --debug or -d argument is specified' do
+        it 'should not make a "debug" argument available to the rake task' do
+          run_command
+          ENV['debug'].should.be.nil
+        end
+
+        it 'should run the deploy:now rake task' do
+          @rake.should.receive(:invoke)
+          run_command
+        end
+
+        it 'should fail if the rake task fails' do
+          @rake.stub!(:invoke).and_raise(RuntimeError)
+          lambda { run_command }.should.raise
+        end
+
+        it 'should not fail if the rake task succeeds' do
+          @rake.stub!(:invoke).and_return(true)
+          lambda { run_command }.should.not.raise
+        end
+      end
     end
 
     describe 'and a -t argument is specified' do
@@ -790,4 +879,4 @@ describe 'wd command' do
       lambda { run_command }.should.raise
     end
   end
-end
+end

data/spec/whiskey_disk/config_spec.rb

@@ -107,6 +107,43 @@ describe WhiskeyDisk::Config do
     end
   end
 
+  describe 'when determining whether to turn debug mode on' do
+    it 'should return false when there is no ENV["debug"] setting' do
+      ENV['debug'] = nil
+      WhiskeyDisk::Config.debug?.should == false
+    end
+
+    it 'should return false when the ENV["debug"] setting is blank' do
+      ENV['debug'] = ''
+      WhiskeyDisk::Config.debug?.should == false
+    end
+
+    it 'should return true if the ENV["debug"] setting is "t"' do
+      ENV['debug'] = 't'
+      WhiskeyDisk::Config.debug?.should == true
+    end
+
+    it 'should return true if the ENV["debug"] setting is "true"' do
+      ENV['debug'] = 'true'
+      WhiskeyDisk::Config.debug?.should == true
+    end
+
+    it 'should return true if the ENV["debug"] setting is "y"' do
+      ENV['debug'] = 'y'
+      WhiskeyDisk::Config.debug?.should == true
+    end
+
+    it 'should return true if the ENV["debug"] setting is "yes"' do
+      ENV['debug'] = 'yes'
+      WhiskeyDisk::Config.debug?.should == true
+    end
+
+    it 'should return true if the ENV["debug"] setting is "1"' do
+      ENV['debug'] = '1'
+      WhiskeyDisk::Config.debug?.should == true
+    end
+  end
+
   describe 'when fetching configuration' do
     describe 'and path specified is an URL' do
       before do

data/spec/whiskey_disk_spec.rb

@@ -39,6 +39,10 @@ describe 'requiring the main library' do
 end
 
 describe 'WhiskeyDisk' do
+  before do
+    WhiskeyDisk.reset
+  end
+  
   describe 'determining if the deployment is remote' do
     before do
       @parameters = { 'deploy_to' => '/path/to/main/repo' }
@@ -131,7 +135,6 @@ describe 'WhiskeyDisk' do
   
   describe 'enabling staleness checks' do
     it 'should ensure that staleness checks are activated' do
-      WhiskeyDisk.reset
       WhiskeyDisk.enable_staleness_checks
       WhiskeyDisk.staleness_checks_enabled?.should == true      
     end
@@ -139,12 +142,10 @@ describe 'WhiskeyDisk' do
   
   describe 'when checking staleness checks' do
     it 'should return false if staleness checks have not been enabled' do
-      WhiskeyDisk.reset
       WhiskeyDisk.staleness_checks_enabled?.should == false
     end
     
     it 'should return true if staleness checks have been enabled' do
-      WhiskeyDisk.reset
       WhiskeyDisk.enable_staleness_checks
       WhiskeyDisk.staleness_checks_enabled?.should == true
     end
@@ -411,6 +412,7 @@ describe 'WhiskeyDisk' do
   describe 'running post setup hooks' do
     before do
       WhiskeyDisk.configuration = { 'deploy_to' => '/path/to/main/repo' }
+      ENV['debug'] = nil
     end
     
     it 'should fail if the deployment path is not specified' do
@@ -426,53 +428,67 @@ 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
-          WhiskeyDisk.configuration = { 'deploy_to' => '/path/to/main/repo', 'post_setup_script' => '/path/to/setup/script', 'rake_env' => { 'FOO' => 'BAR' }  }
+          WhiskeyDisk.configuration = { 'deploy_to' => '/path/to/main/repo', 'post_setup_script' => 'path/to/setup/script', 'rake_env' => { 'FOO' => 'BAR' }  }
         end
       
-        it 'should attempt to run the post setup script' do        
+        it 'should cd to the deploy_to path prior to running the script' do
           WhiskeyDisk.run_post_setup_hooks
-          WhiskeyDisk.buffer.join(' ').should.match(%r{bash -x .*/path/to/setup/script})
+          WhiskeyDisk.buffer.join(' ').should.match(%r{cd /path/to/main/repo;.*bash  /path/to/main/repo/path/to/setup/script})
+        end
+
+        it 'should attempt to run the post setup script with the deployment path prepended' do        
+          WhiskeyDisk.run_post_setup_hooks
+          WhiskeyDisk.buffer.join(' ').should.match(%r{bash  /path/to/main/repo/path/to/setup/script})
         end
       
         it 'should pass any environment variables when running the post setup script' do
           WhiskeyDisk.run_post_setup_hooks
-          WhiskeyDisk.buffer.join(' ').should.match(%r{FOO='BAR'  bash -x .*/path/to/setup/script})      
+          WhiskeyDisk.buffer.join(' ').should.match(%r{FOO='BAR'  bash  /path/to/main/repo/path/to/setup/script})      
         end
 
-        it 'should cd to the deploy_to path prior to running the script' do
+        it 'should enable shell verbosity when debugging is enabled' do
+          ENV['debug'] = 'true'
           WhiskeyDisk.run_post_setup_hooks
-          WhiskeyDisk.buffer.join(' ').should.match(%r{cd /path/to/main/repo;.*bash -x /path/to/setup/script})
+          WhiskeyDisk.buffer.join(' ').should.match(%r{bash -x /path/to/main/repo/path/to/setup/script})      
         end
-            
-        it 'should use an absolute path to run the post setup script when the script path starts with a "/"' do
+
+        it 'should disable shell verbosity when debugging is not enabled' do
+          ENV['debug'] = 'false'
           WhiskeyDisk.run_post_setup_hooks
-          WhiskeyDisk.buffer.join(' ').should.match(%r{bash -x /path/to/setup/script})         
+          WhiskeyDisk.buffer.join(' ').should.match(%r{bash  /path/to/main/repo/path/to/setup/script})      
         end
       end
       
-      describe 'and the script path does not start with a "/"' do
+      describe 'and the script path starts with a "/"' do
         before do
-          WhiskeyDisk.configuration = { 'deploy_to' => '/path/to/main/repo', 'post_setup_script' => 'path/to/setup/script', 'rake_env' => { 'FOO' => 'BAR' } }
+          WhiskeyDisk.configuration = { 'deploy_to' => '/path/to/main/repo', 'post_setup_script' => '/path/to/setup/script', 'rake_env' => { 'FOO' => 'BAR' } }
         end
 
-        it 'should attempt to run the post setup script' do        
+        it 'should cd to the deploy_to path prior to running the script' do
           WhiskeyDisk.run_post_setup_hooks
-          WhiskeyDisk.buffer.join(' ').should.match(%r{bash -x .*/path/to/setup/script})
+          WhiskeyDisk.buffer.join(' ').should.match(%r{cd /path/to/main/repo;.*bash  /path/to/setup/script})
         end
       
+        it 'should run the post setup script using its absolute path' do
+          WhiskeyDisk.run_post_setup_hooks
+          WhiskeyDisk.buffer.join(' ').should.match(%r{bash  /path/to/setup/script})
+        end
+
         it 'should pass any environment variables when running the post setup script' do
           WhiskeyDisk.run_post_setup_hooks
-          WhiskeyDisk.buffer.join(' ').should.match(%r{FOO='BAR'  bash -x .*/path/to/setup/script})      
+          WhiskeyDisk.buffer.join(' ').should.match(%r{FOO='BAR'  bash  /path/to/setup/script})      
         end
 
-        it 'should cd to the deploy_to path prior to running the script' do
+        it 'should enable shell verbosity when debugging is enabled' do
+          ENV['debug'] = 'true'
           WhiskeyDisk.run_post_setup_hooks
-          WhiskeyDisk.buffer.join(' ').should.match(%r{cd /path/to/main/repo;.*bash -x /path/to/main/repo/path/to/setup/script})
+          WhiskeyDisk.buffer.join(' ').should.match(%r{bash -x /path/to/setup/script})      
         end
-      
-        it 'should use a path relative to the setup path to run the post setup script' do
+
+        it 'should disable shell verbosity when debugging is not enabled' do
+          ENV['debug'] = 'false'
           WhiskeyDisk.run_post_setup_hooks
-          WhiskeyDisk.buffer.join(' ').should.match(%r{bash -x /path/to/main/repo/path/to/setup/script})
+          WhiskeyDisk.buffer.join(' ').should.match(%r{bash  /path/to/setup/script})      
         end
       end
     end
@@ -519,6 +535,7 @@ describe 'WhiskeyDisk' do
   describe 'running post deployment hooks' do
     before do
       WhiskeyDisk.configuration = { 'deploy_to' => '/path/to/main/repo' }
+      ENV['debug'] = nil
     end
     
     it 'should fail if the deployment path is not specified' do
@@ -534,53 +551,67 @@ 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
-          WhiskeyDisk.configuration = { 'deploy_to' => '/path/to/main/repo', 'post_deploy_script' => '/path/to/deployment/script', 'rake_env' => { 'FOO' => 'BAR' }  }
+          WhiskeyDisk.configuration = { 'deploy_to' => '/path/to/main/repo', 'post_deploy_script' => 'path/to/deployment/script', 'rake_env' => { 'FOO' => 'BAR' }  }
         end
       
-        it 'should attempt to run the post deployment script' do        
+        it 'should cd to the deploy_to path prior to running the script' do
+          WhiskeyDisk.run_post_deploy_hooks
+          WhiskeyDisk.buffer.join(' ').should.match(%r{cd /path/to/main/repo;.*bash  /path/to/main/repo/path/to/deployment/script})
+        end
+
+        it 'should attempt to run the post deployment script with the deployment path prepended' do        
           WhiskeyDisk.run_post_deploy_hooks
-          WhiskeyDisk.buffer.join(' ').should.match(%r{bash -x .*/path/to/deployment/script})
+          WhiskeyDisk.buffer.join(' ').should.match(%r{bash  /path/to/main/repo/path/to/deployment/script})
         end
         
         it 'should pass any environment variables when running the post deploy script' do
           WhiskeyDisk.run_post_deploy_hooks
-          WhiskeyDisk.buffer.join(' ').should.match(%r{FOO='BAR'  bash -x .*/path/to/deployment/script})      
+          WhiskeyDisk.buffer.join(' ').should.match(%r{FOO='BAR'  bash  /path/to/main/repo/path/to/deployment/script})      
         end
 
-        it 'should cd to the deploy_to path prior to running the script' do
+        it 'should enable shell verbosity when debugging is enabled' do
+          ENV['debug'] = 'true'
           WhiskeyDisk.run_post_deploy_hooks
-          WhiskeyDisk.buffer.join(' ').should.match(%r{cd /path/to/main/repo;.*bash -x /path/to/deployment/script})
+          WhiskeyDisk.buffer.join(' ').should.match(%r{bash -x /path/to/main/repo/path/to/deployment/script})
         end
-        
-        it 'should use an absolute path to run the post deployment script when the script path starts with a "/"' do
+
+        it 'should disable shell verbosity when debugging is not enabled' do
+          ENV['debug'] = 'false'
           WhiskeyDisk.run_post_deploy_hooks
-          WhiskeyDisk.buffer.join(' ').should.match(%r{bash -x /path/to/deployment/script})         
+          WhiskeyDisk.buffer.join(' ').should.match(%r{bash  /path/to/main/repo/path/to/deployment/script})
         end
       end
       
-      describe 'and the script path does not start with a "/"' do
+      describe 'and the script path starts with a "/"' do
         before do
-          WhiskeyDisk.configuration = { 'deploy_to' => '/path/to/main/repo', 'post_deploy_script' => 'path/to/deployment/script', 'rake_env' => { 'FOO' => 'BAR' }  }
+          WhiskeyDisk.configuration = { 'deploy_to' => '/path/to/main/repo', 'post_deploy_script' => '/path/to/deployment/script', 'rake_env' => { 'FOO' => 'BAR' }  }
+        end
+
+        it 'should cd to the deploy_to path prior to running the script' do
+          WhiskeyDisk.run_post_deploy_hooks
+          WhiskeyDisk.buffer.join(' ').should.match(%r{cd /path/to/main/repo;.*bash  /path/to/deployment/script})
         end
 
-        it 'should attempt to run the post deployment script' do        
+        it 'should attempt to run the post deployment script using its absolute path' do        
           WhiskeyDisk.run_post_deploy_hooks
-          WhiskeyDisk.buffer.join(' ').should.match(%r{bash -x .*/path/to/deployment/script})
+          WhiskeyDisk.buffer.join(' ').should.match(%r{bash  /path/to/deployment/script})
         end
       
         it 'should pass any environment variables when running the post deploy script' do
           WhiskeyDisk.run_post_deploy_hooks
-          WhiskeyDisk.buffer.join(' ').should.match(%r{FOO='BAR'  bash -x .*/path/to/deployment/script})      
+          WhiskeyDisk.buffer.join(' ').should.match(%r{FOO='BAR'  bash  /path/to/deployment/script})      
         end
 
-        it 'should cd to the deploy_to path prior to running the script' do
+        it 'should enable shell verbosity when debugging is enabled' do
+          ENV['debug'] = 'true'
           WhiskeyDisk.run_post_deploy_hooks
-          WhiskeyDisk.buffer.join(' ').should.match(%r{cd /path/to/main/repo;.*bash -x /path/to/main/repo/path/to/deployment/script})
+          WhiskeyDisk.buffer.join(' ').should.match(%r{bash -x /path/to/deployment/script})      
         end
-        
-        it 'should use a path relative to the deployment path to run the post deployment script' do
+
+        it 'should disable shell verbosity when debugging is not enabled' do
+          ENV['debug'] = 'false'
           WhiskeyDisk.run_post_deploy_hooks
-          WhiskeyDisk.buffer.join(' ').should.match(%r{bash -x /path/to/main/repo/path/to/deployment/script})
+          WhiskeyDisk.buffer.join(' ').should.match(%r{bash  /path/to/deployment/script})      
         end
       end
     end
@@ -625,10 +656,6 @@ describe 'WhiskeyDisk' do
   end
   
   describe 'bundling up buffered commands for execution' do
-    before do
-      WhiskeyDisk.reset
-    end
-    
     describe 'when staleness checks are disabled' do
       it 'should return an empty string if there are no commands' do
         WhiskeyDisk.bundle.should == ''
@@ -866,6 +893,7 @@ describe 'WhiskeyDisk' do
       WhiskeyDisk.stub!(:domain_of_interest?).and_return(true)
       WhiskeyDisk.stub!(:bundle).and_return(@cmd)
       WhiskeyDisk.stub!(:system)
+      WhiskeyDisk.stub!(:puts)
     end
           
     it 'should fail if the domain path is not specified' do
@@ -899,7 +927,6 @@ describe 'WhiskeyDisk' do
   
   describe 'when running a command string locally' do
     before do
-      WhiskeyDisk.reset
       @domain_name = 'local'
       @domain = { :name => @domain_name }
       WhiskeyDisk.configuration = { 'domain' => [ @domain ] }
@@ -913,23 +940,42 @@ describe 'WhiskeyDisk' do
     it 'should require a domain and a command string' do
       lambda { WhiskeyDisk.shell(@domain) }.should.raise(ArgumentError)
     end
+    
+    describe 'when debugging is enabled' do
+      before { ENV['debug'] = 'true' }
 
-    it 'should pass the string to the shell with verbosity enabled' do
-      WhiskeyDisk.should.receive(:system).with('bash', '-c', "set -x; ls")
-      WhiskeyDisk.shell(@domain, 'ls')
+      it 'should pass the string to the shell with verbosity enabled' do
+        WhiskeyDisk.should.receive(:system).with('bash', '-c', "set -x; ls")
+        WhiskeyDisk.shell(@domain, 'ls')
+      end
+      
+      it 'should include domain role settings when the domain has roles' do
+        @domain = { :name => @domain_name, :roles => [ 'web', 'db' ] }
+        WhiskeyDisk.configuration = { 'domain' => [ @domain ] }
+        WhiskeyDisk.should.receive(:system).with('bash', '-c', "set -x; export WD_ROLES='web:db'; ls")
+        WhiskeyDisk.shell(@domain, 'ls')        
+      end
     end
+    
+    describe 'when debugging is not enabled' do
+      before { ENV['debug'] = 'false' }
+
+      it 'should pass the string to the shell without verbosity enabled' do
+        WhiskeyDisk.should.receive(:system).with('bash', '-c', "ls")
+        WhiskeyDisk.shell(@domain, 'ls')
+      end
       
-    it 'should include domain role settings when the domain has roles' do
-      @domain = { :name => @domain_name, :roles => [ 'web', 'db' ] }
-      WhiskeyDisk.configuration = { 'domain' => [ @domain ] }
-      WhiskeyDisk.should.receive(:system).with('bash', '-c', "set -x; export WD_ROLES='web:db'; ls")
-      WhiskeyDisk.shell(@domain, 'ls')        
+      it 'should include domain role settings when the domain has roles' do
+        @domain = { :name => @domain_name, :roles => [ 'web', 'db' ] }
+        WhiskeyDisk.configuration = { 'domain' => [ @domain ] }
+        WhiskeyDisk.should.receive(:system).with('bash', '-c', "export WD_ROLES='web:db'; ls")
+        WhiskeyDisk.shell(@domain, 'ls')        
+      end
     end
   end
 
   describe 'when running a command string remotely' do
     before do
-      WhiskeyDisk.reset
       @domain_name = 'ogc@ogtastic.com'
       @domain = { :name => @domain_name }
       WhiskeyDisk.configuration = { 'domain' => [ @domain ] }
@@ -944,24 +990,34 @@ describe 'WhiskeyDisk' do
       lambda { WhiskeyDisk.run(@domain) }.should.raise(ArgumentError)
     end
 
-    it 'should pass the string to ssh for the domain, with verbosity enabled' do
-      WhiskeyDisk.should.receive(:system).with('ssh', '-v', @domain_name, 'bash', '-c', "set -x; ls")
-      WhiskeyDisk.run(@domain, 'ls')
+    describe "building a command" do
+      it 'should include domain role settings when the domain has roles' do
+        @domain = { :name => @domain_name, :roles => [ 'web', 'db' ] }
+        WhiskeyDisk.configuration = { 'domain' => [ @domain ] }
+        WhiskeyDisk.build_command(@domain, 'ls').should.match /export WD_ROLES='web:db'; ls/
+      end
     end
-      
-    it 'should include domain role settings when the domain has roles' do
-      @domain = { :name => @domain_name, :roles => [ 'web', 'db' ] }
-      WhiskeyDisk.configuration = { 'domain' => [ @domain ] }
-      WhiskeyDisk.should.receive(:system).with('ssh', '-v', @domain_name, 'bash', '-c', "set -x; export WD_ROLES='web:db'; ls")
-      WhiskeyDisk.run(@domain, 'ls')        
+
+    describe 'when debugging is enabled' do
+      before { ENV['debug'] = 'true' }
+
+      it 'should pass the string to ssh for the domain, with verbosity enabled' do
+        WhiskeyDisk.should.receive(:system).with('ssh', '-v', @domain_name, "set -x; ls")
+        WhiskeyDisk.run(@domain, 'ls')
+      end
+    end
+
+    describe 'when debugging is not enabled' do
+      before { ENV['debug'] = 'false' }
+
+      it 'should pass the string to ssh for the domain, with verbosity disabled' do
+        WhiskeyDisk.should.receive(:system).with('ssh', @domain_name, "ls")
+        WhiskeyDisk.run(@domain, 'ls')
+      end
     end
   end
-  
+
   describe 'determining if all the deployments succeeded' do
-    before do
-      WhiskeyDisk.reset
-    end
-    
     it 'should work without arguments' do
       lambda { WhiskeyDisk.success? }.should.not.raise(ArgumentError)
     end
@@ -991,7 +1047,6 @@ describe 'WhiskeyDisk' do
   
   describe 'summarizing the results of a run' do
     before do
-      WhiskeyDisk.reset
       WhiskeyDisk.stub!(:puts)
     end
     

data/whiskey_disk.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{whiskey_disk}
-  s.version = "0.6.16"
+  s.version = "0.6.17"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Rick Bradley"]
-  s.date = %q{2011-03-08}
+  s.date = %q{2011-03-25}
   s.description = %q{Opinionated gem for doing fast git-based server deployments.}
   s.email = %q{rick@rickbradley.com}
   s.executables = ["wd_role", "wd"]

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: whiskey_disk
 version: !ruby/object:Gem::Version 
-  hash: 39
+  hash: 37
   prerelease: false
   segments: 
   - 0
   - 6
-  - 16
-  version: 0.6.16
+  - 17
+  version: 0.6.17
 platform: ruby
 authors: 
 - Rick Bradley
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-08 00:00:00 -06:00
+date: 2011-03-25 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency