capistrano 2.3.0 → 2.4.0

data/lib/capistrano/recipes/deploy/local_dependency.rb

@@ -30,7 +30,7 @@ module Capistrano
       # file is found that matches the parameter, this returns true.
       def find_in_path(utility)
         path = (ENV['PATH'] || "").split(File::PATH_SEPARATOR)
-        suffixes = RUBY_PLATFORM =~ /mswin/ ? %w(.bat .exe .com .cmd) : [""]
+        suffixes = self.class.on_windows? ? %w(.bat .exe .com .cmd) : [""]
 
         path.each do |dir|
           suffixes.each do |sfx|
@@ -41,6 +41,10 @@ module Capistrano
 
         false
       end
+      
+      def self.on_windows?
+        RUBY_PLATFORM =~ /mswin/
+      end
     end
   end
-end
+end

data/lib/capistrano/recipes/deploy/remote_dependency.rb

@@ -1,3 +1,5 @@
+require 'capistrano/errors'
+
 module Capistrano
   module Deploy
     class RemoteDependency

data/lib/capistrano/recipes/deploy/scm/git.rb

@@ -141,17 +141,17 @@ module Capistrano
 
           execute = []
           if args.empty?
-            execute << "#{git} clone #{configuration[:repository]} #{destination}"
+            execute << "#{git} clone #{verbose} #{configuration[:repository]} #{destination}"
           else
-            execute << "#{git} clone #{args.join(' ')} #{configuration[:repository]} #{destination}"
+            execute << "#{git} clone #{verbose} #{args.join(' ')} #{configuration[:repository]} #{destination}"
           end
 
           # checkout into a local branch rather than a detached HEAD
-          execute << "cd #{destination} && #{git} checkout -b deploy #{revision}"
+          execute << "cd #{destination} && #{git} checkout #{verbose} -b deploy #{revision}"
           
           if configuration[:git_enable_submodules]
-            execute << "#{git} submodule init"
-            execute << "#{git} submodule update"
+            execute << "#{git} submodule #{verbose} init"
+            execute << "#{git} submodule #{verbose} update"
           end
 
           execute.join(" && ")
@@ -184,11 +184,11 @@ module Capistrano
           end
 
           # since we're in a local branch already, just reset to specified revision rather than merge
-          execute << "#{git} fetch --tags #{remote} && #{git} reset --hard #{revision}"
+          execute << "#{git} fetch #{verbose} #{remote} && #{git} reset #{verbose} --hard #{revision}"
 
           if configuration[:git_enable_submodules]
-            execute << "#{git} submodule init"
-            execute << "#{git} submodule update"
+            execute << "#{git} submodule #{verbose} init"
+            execute << "#{git} submodule #{verbose} update"
           end
 
           execute.join(" && ")
@@ -202,19 +202,19 @@ module Capistrano
 
         # Returns a log of changes between the two revisions (inclusive).
         def log(from, to=nil)
-          from << "..#{to}" if to
-          scm :log, from
+          scm :log, "#{from}..#{to}"
         end
 
         # Getting the actual commit id, in case we were passed a tag
         # or partial sha or something - it will return the sha if you pass a sha, too
         def query_revision(revision)
+          raise ArgumentError, "Deploying remote branches has been deprecated.  Specify the remote branch as a local branch for the git repository you're deploying from (ie: '#{revision.gsub('origin/', '')}' rather than '#{revision}')." if revision =~ /^origin\//
           return revision if revision =~ /^[0-9a-f]{40}$/
           command = scm('ls-remote', repository, revision)
           result = yield(command)
           revdata = result.split("\t")
           newrev = revdata[0]
-          raise "Unable to resolve revision for #{revision}" unless newrev =~ /^[0-9a-f]{40}$/
+          raise "Unable to resolve revision for '#{revision}' on repository '#{repository}'." unless newrev =~ /^[0-9a-f]{40}$/
           return newrev
         end
 
@@ -227,7 +227,8 @@ module Capistrano
         # from the SCM. Password prompts, connection requests, passphrases,
         # etc. are handled here.
         def handle_data(state, stream, text)
-          logger.info "[#{stream}] #{text}"
+          host = state[:channel][:host]
+          logger.info "[#{host} :: #{stream}] #{text}"
           case text
           when /\bpassword.*:/i
             # git is prompting for a password
@@ -249,6 +250,14 @@ module Capistrano
             "t\n"
           end
         end
+
+        private
+
+          # If verbose output is requested, return nil, otherwise return the
+          # command-line switch for "quiet" ("-q").
+          def verbose
+            variable(:scm_verbose) ? nil : "-q"
+          end
       end
     end
   end

data/lib/capistrano/recipes/deploy/scm/mercurial.rb

@@ -67,7 +67,8 @@ module Capistrano
         # user/pass can come from ssh and http distribution methods
         # yes/no is for when ssh asks you about fingerprints
         def handle_data(state, stream, text)
-          logger.info "[#{stream}] #{text}"
+          host = state[:channel][:host]
+          logger.info "[#{host} :: #{stream}] #{text}"
           case text
           when /^user:/mi
             # support :scm_user for backwards compatibility of this module

data/lib/capistrano/recipes/deploy/scm/subversion.rb

@@ -68,7 +68,8 @@ module Capistrano
         # from the SCM. Password prompts, connection requests, passphrases,
         # etc. are handled here.
         def handle_data(state, stream, text)
-	        logger.info "[#{stream}] #{text}"
+          host = state[:channel][:host]
+	        logger.info "[#{host} :: #{stream}] #{text}"
           case text
           when /\bpassword.*:/i
             # subversion is prompting for a password

data/lib/capistrano/recipes/deploy/strategy/copy.rb

@@ -64,7 +64,9 @@ module Capistrano
                 next if name == "." || name == ".."
                 next if copy_exclude.any? { |pattern| File.fnmatch(pattern, item) }
 
-                if File.directory?(item)
+                if File.symlink?(item)
+                  FileUtils.ln_s(File.readlink(File.join(copy_cache, item)), File.join(destination, item))
+                elsif File.directory?(item)
                   queue += Dir.glob("#{item}/*", File::FNM_DOTMATCH)
                   FileUtils.mkdir(File.join(destination, item))
                 else
@@ -87,8 +89,7 @@ module Capistrano
           logger.trace "compressing #{destination} to #{filename}"
           Dir.chdir(tmpdir) { system(compress(File.basename(destination), File.basename(filename)).join(" ")) }
 
-          content = File.open(filename, "rb") { |f| f.read }
-          put content, remote_filename 
+          upload(filename, remote_filename)
           run "cd #{configuration[:releases_path]} && #{decompress(remote_filename).join(" ")} && rm #{remote_filename}"
         ensure
           FileUtils.rm filename rescue nil
@@ -97,7 +98,7 @@ module Capistrano
 
         def check!
           super.check do |d|
-            d.local.command(source.local.command)
+            d.local.command(source.local.command) if source.local.command
             d.local.command(compress(nil, nil).first)
             d.remote.command(decompress(nil).first)
           end
@@ -147,7 +148,7 @@ module Capistrano
           # Returns the name of the file that the source code will be
           # compressed to.
           def filename
-            @filename ||= File.join(tmpdir, "#{File.basename(destination)}.#{compression_extension}")
+            @filename ||= File.join(tmpdir, "#{File.basename(destination)}.#{compression.extension}")
           end
 
           # The directory to which the copy should be checked out
@@ -167,46 +168,33 @@ module Capistrano
             @remote_filename ||= File.join(remote_dir, File.basename(filename))
           end
 
+          # A struct for representing the specifics of a compression type.
+          # Commands are arrays, where the first element is the utility to be
+          # used to perform the compression or decompression.
+          Compression = Struct.new(:extension, :compress_command, :decompress_command)
+          
           # The compression method to use, defaults to :gzip.
           def compression
-            configuration[:copy_compression] || :gzip
-          end
-
-          # Returns the file extension used for the compression method in
-          # question.
-          def compression_extension
-            case compression
-            when :gzip, :gz   then "tar.gz"
-            when :bzip2, :bz2 then "tar.bz2"
-            when :zip         then "zip"
-            else raise ArgumentError, "invalid compression type #{compression.inspect}"
+            type = configuration[:copy_compression] || :gzip
+            case type
+            when :gzip, :gz   then Compression.new("tar.gz",  %w(tar czf), %w(tar xzf))
+            when :bzip2, :bz2 then Compression.new("tar.bz2", %w(tar cjf), %w(tar xjf))
+            when :zip         then Compression.new("zip",     %w(zip -qr), %w(unzip -q))
+            else raise ArgumentError, "invalid compression type #{type.inspect}"
             end
           end
-
+          
           # Returns the command necessary to compress the given directory
-          # into the given file. The command is returned as an array, where
-          # the first element is the utility to be used to perform the compression.
+          # into the given file.
           def compress(directory, file)
-            case compression
-            when :gzip, :gz   then ["tar", "czf", file, directory]
-            when :bzip2, :bz2 then ["tar", "cjf", file, directory]
-            when :zip         then ["zip", "-qr", file, directory]
-            else raise ArgumentError, "invalid compression type #{compression.inspect}"
-            end
+            compression.compress_command + [file, directory]
           end
 
           # Returns the command necessary to decompress the given file,
           # relative to the current working directory. It must also
-          # preserve the directory structure in the file. The command is returned
-          # as an array, where the first element is the utility to be used to
-          # perform the decompression.
+          # preserve the directory structure in the file.
           def decompress(file)
-            case compression
-            when :gzip, :gz   then ["tar", "xzf", file]
-            when :bzip2, :bz2 then ["tar", "xjf", file]
-            when :zip         then ["unzip", "-q", file]
-            else raise ArgumentError, "invalid compression type #{compression.inspect}"
-            end
+            compression.decompress_command + [file]
           end
       end
 

data/lib/capistrano/recipes/deploy/strategy/remote.rb

@@ -27,7 +27,7 @@ module Capistrano
           # #handle_data filter of the SCM implementation.
           def scm_run(command)
             run(command) do |ch,stream,text|
-              ch[:state] ||= {}
+              ch[:state] ||= { :channel => ch }
               output = source.handle_data(ch[:state], stream, text)
               ch.send_data(output) if output
             end

data/lib/capistrano/version.rb

@@ -1,22 +1,9 @@
 module Capistrano
   module Version #:nodoc:
-    # A method for comparing versions of required modules. It expects two
-    # arrays of integers as parameters, the first being the minimum version
-    # required, and the second being the actual version available. It returns
-    # true if the actual version is at least equal to the required version.
-    def self.check(required, actual) #:nodoc:
-      required = required.map { |v| "%06d" % v }.join(".")
-      actual   = actual.map { |v| "%06d" % v }.join(".")
-      return actual >= required
-    end
-
     MAJOR = 2
-    MINOR = 3
+    MINOR = 4
     TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join(".")
-    
-    SSH_REQUIRED = [1,0,10]
-    SFTP_REQUIRED = [1,1,0]
   end
 end

data/test/cli/execute_test.rb

@@ -15,7 +15,7 @@ class CLIExecuteTest < Test::Unit::TestCase
   def setup
     @cli = MockCLI.new
     @logger = stub_everything
-    @config = stub(:logger => @logger)
+    @config = stub(:logger => @logger, :debug= => nil)
     @config.stubs(:set)
     @config.stubs(:load)
     @config.stubs(:trigger)

data/test/cli/options_test.rb

@@ -24,6 +24,12 @@ class CLIOptionsTest < Test::Unit::TestCase
     assert_raises(ExitException) { @cli.parse_options! }
   end
   
+  def test_parse_options_with_d_should_set_debug_option
+    @cli.args << "-d"
+    @cli.parse_options!
+    assert @cli.options[:debug]
+  end
+
   def test_parse_options_with_e_should_set_explain_option
     @cli.args << "-e" << "sample"
     @cli.parse_options!
@@ -223,4 +229,4 @@ class CLIOptionsTest < Test::Unit::TestCase
     MockCLI.expects(:new).with(%w(a b c)).returns(cli)
     assert_equal cli, MockCLI.parse(%w(a b c))
   end
-end
+end

data/test/configuration/actions/file_transfer_test.rb

@@ -14,7 +14,8 @@ class ConfigurationActionsFileTransferTest < Test::Unit::TestCase
 
   def test_put_should_delegate_to_upload
     @config.expects(:upload).with { |from, to, opts|
-      from.string == "some data" && to == "test.txt" && opts == { :permissions => 0777 } }
+      from.string == "some data" && to == "test.txt" && opts == { :mode => 0777 } }
+    @config.expects(:run).never
     @config.put("some data", "test.txt", :mode => 0777)
   end
 
@@ -28,6 +29,24 @@ class ConfigurationActionsFileTransferTest < Test::Unit::TestCase
     @config.upload("testl.txt", "testr.txt", :foo => "bar")
   end
 
+  def test_upload_without_mode_should_not_try_to_chmod
+    @config.expects(:transfer).with(:up, "testl.txt", "testr.txt", :foo => "bar")
+    @config.expects(:run).never
+    @config.upload("testl.txt", "testr.txt", :foo => "bar")
+  end
+
+  def test_upload_with_mode_should_try_to_chmod
+    @config.expects(:transfer).with(:up, "testl.txt", "testr.txt", :foo => "bar")
+    @config.expects(:run).with("chmod 775 testr.txt")
+    @config.upload("testl.txt", "testr.txt", :mode => 0775, :foo => "bar")
+  end
+
+  def test_upload_with_symbolic_mode_should_try_to_chmod
+    @config.expects(:transfer).with(:up, "testl.txt", "testr.txt", :foo => "bar")
+    @config.expects(:run).with("chmod g+w testr.txt")
+    @config.upload("testl.txt", "testr.txt", :mode => "g+w", :foo => "bar")
+  end
+
   def test_download_should_delegate_to_transfer
     @config.expects(:transfer).with(:down, "testr.txt", "testl.txt", :foo => "bar")
     @config.download("testr.txt", "testl.txt", :foo => "bar")

data/test/configuration/actions/invocation_test.rb

@@ -4,6 +4,7 @@ require 'capistrano/configuration/actions/invocation'
 class ConfigurationActionsInvocationTest < Test::Unit::TestCase
   class MockConfig
     attr_reader :options
+    attr_accessor :debug
 
     def initialize
       @options = {}
@@ -75,6 +76,11 @@ class ConfigurationActionsInvocationTest < Test::Unit::TestCase
     assert_equal({:foo => "bar", :shell => "/bin/bash"}, @config.add_default_command_options(:foo => "bar"))
   end
 
+  def test_add_default_command_options_should_use_default_shell_of_false_if_present
+    @config.set :default_shell, false
+    assert_equal({:foo => "bar", :shell => false}, @config.add_default_command_options(:foo => "bar"))
+  end
+
   def test_add_default_command_options_should_use_shell_in_preference_of_default_shell
     @config.set :default_shell, "/bin/bash"
     assert_equal({:foo => "bar", :shell => "/bin/sh"}, @config.add_default_command_options(:foo => "bar", :shell => "/bin/sh"))
@@ -97,29 +103,29 @@ class ConfigurationActionsInvocationTest < Test::Unit::TestCase
   end
 
   def test_sudo_should_default_to_sudo
-    @config.expects(:run).with("ls", :command_prefix => "sudo -p 'sudo password: '")
+    @config.expects(:run).with("sudo -p 'sudo password: ' ls", {})
     @config.sudo "ls"
   end
 
   def test_sudo_should_use_sudo_variable_definition
-    @config.expects(:run).with("ls", :command_prefix => "/opt/local/bin/sudo -p 'sudo password: '")
+    @config.expects(:run).with("/opt/local/bin/sudo -p 'sudo password: ' ls", {})
     @config.options[:sudo] = "/opt/local/bin/sudo"
     @config.sudo "ls"
   end
 
   def test_sudo_should_interpret_as_option_as_user
-    @config.expects(:run).with("ls", :command_prefix => "sudo -p 'sudo password: ' -u app")
+    @config.expects(:run).with("sudo -p 'sudo password: ' -u app ls", {})
     @config.sudo "ls", :as => "app"
   end
 
   def test_sudo_should_pass_options_through_to_run
-    @config.expects(:run).with("ls", :command_prefix => "sudo -p 'sudo password: '", :foo => "bar")
+    @config.expects(:run).with("sudo -p 'sudo password: ' ls", :foo => "bar")
     @config.sudo "ls", :foo => "bar"
   end
 
   def test_sudo_should_interpret_sudo_prompt_variable_as_custom_prompt
     @config.set :sudo_prompt, "give it to me: "
-    @config.expects(:run).with("ls", :command_prefix => "sudo -p 'give it to me: '")
+    @config.expects(:run).with("sudo -p 'give it to me: ' ls", {})
     @config.sudo "ls"
   end
 
@@ -143,7 +149,7 @@ class ConfigurationActionsInvocationTest < Test::Unit::TestCase
     ch.stubs(:[]).with(:host).returns("capistrano")
     ch.stubs(:[]).with(:server).returns(server("capistrano"))
     @config.expects(:reset!).with(:password)
-    @config.sudo_behavior_callback(nil)[ch, nil, "blah blah try again blah blah"]
+    @config.sudo_behavior_callback(nil)[ch, nil, "Sorry, try again."]
   end
 
   def test_sudo_behavior_callback_with_incorrect_password_on_subsequent_prompts
@@ -158,9 +164,9 @@ class ConfigurationActionsInvocationTest < Test::Unit::TestCase
 
     @config.expects(:reset!).with(:password).times(2)
 
-    callback[ch, nil, "blah blah try again blah blah"]
-    callback[ch2, nil, "blah blah try again blah blah"] # shouldn't call reset!
-    callback[ch, nil, "blah blah try again blah blah"]
+    callback[ch, nil, "Sorry, try again."]
+    callback[ch2, nil, "Sorry, try again."] # shouldn't call reset!
+    callback[ch, nil, "Sorry, try again."]
   end
 
   def test_sudo_behavior_callback_should_defer_to_fallback_for_other_output
@@ -199,4 +205,4 @@ class ConfigurationActionsInvocationTest < Test::Unit::TestCase
       c = mock("data", :called => true)
       Capistrano::Command.expects(:process).with(command, sessions, options).yields(a, b, c)
     end
-end
+end

data/test/configuration/callbacks_test.rb

@@ -12,9 +12,15 @@ class ConfigurationCallbacksTest < Test::Unit::TestCase
     end
 
     def execute_task(task)
-      @called << task
+      invoke_task_directly(task)
     end
 
+    protected
+
+      def invoke_task_directly(task)
+        @called << task
+      end
+
     include Capistrano::Configuration::Callbacks
   end
 
@@ -96,6 +102,14 @@ class ConfigurationCallbacksTest < Test::Unit::TestCase
     assert_equal 1, @config.callbacks[:before].length
     assert_equal %w(primary), @config.callbacks[:before].first.except
   end
+  
+  def test_on_without_tasks_or_block_should_raise_error
+    assert_raises(ArgumentError) { @config.on(:before) }
+  end
+
+  def test_on_with_both_tasks_and_block_should_raise_error
+    assert_raises(ArgumentError) { @config.on(:before, :first) { blah } }
+  end
 
   def test_trigger_without_constraints_should_invoke_all_callbacks
     task = stub(:fully_qualified_name => "any:old:thing")
@@ -203,4 +217,4 @@ class ConfigurationCallbacksTest < Test::Unit::TestCase
 
     @config.execute_task(task)
   end
-end
+end