mattscilipoti-capistrano_rsync_with_remote_cache 2.3.6

data/.document

@@ -0,0 +1,5 @@
+README.md
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,5 @@
+/pkg/
+/doc/
+/coverage/
+*.gem
+.yardoc

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2007, 2008 Mark Cornick of Viget Labs (http://www.viget.com/)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,36 @@
+# Capistrano rsync_with_remote_cache
+
+This gem provides a deployment strategy for Capistrano which combines `rsync` with a remote cache, allowing fast deployments from Subversion repositories behind firewalls.
+
+## Requirements
+
+This gem requires Capistrano 2.0.0 or higher. Git support requires Capistrano 2.1.0 or higher.
+
+This gem supports Subversion, Git, Mercurial and Bazaar. Only Subversion and Git have been extensively tested. This gem is unlikely to be supported for other SCM systems.
+
+This gem requires `rsync` command line utilities on the local and remote hosts. It also requires either `svn`, `git`, `hg` or `bzr` on the local host, but not the remote host.
+
+This gem is tested on Mac OS X and Linux. Windows is not tested or supported.
+
+## Using the strategy
+
+To use this deployment strategy, add this line to your `deploy.rb` file:
+
+    set :deploy_via, :rsync_with_remote_cache
+
+## How it works
+
+This strategy maintains two cache directories:
+
+* The local cache directory is a checkout from the SCM repository. The local cache directory is specified with the `local_cache` variable in the configuration. If not specified, it will default to `.rsync_cache` in the same directory as the Capfile.
+* The remote cache directory is an `rsync` copy of the local cache directory. The remote cache directory is specified with the `repository_cache` variable in the configuration (this name comes from the `remote_cache` strategy that ships with Capistrano, and has been maintained for compatibility.) If not specified, it will default to `shared/cached-copy` (again, for compatibility with remote_cache.)
+
+Deployment happens in three major steps. First, the local cache directory is processed. There are three possibilities:
+
+* If the local cache does not exist, it is created with a checkout of the revision to be deployed.
+* If the local cache exists and matches the `:repository` variable, it is updated to the revision to be deployed.
+* If the local cache exists and does not match the `:repository` variable, the local cache is purged and recreated with a checkout of the revision to be deployed.
+
+Second, `rsync` runs on the local side to sync the remote cache to the local cache. When the `rsync` is complete, the remote cache should be an exact replica of the local cache.
+
+Finally, a copy of the remote cache (excluding scm directories) is made in the appropriate release directory. The end result is the same as if the code had been checked out directly on the remote server, as in the default strategy.  Refer to rsync --cvs_ignore to customize excluded dirs/files. 

data/Rakefile

@@ -0,0 +1,86 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "capistrano_rsync_with_remote_cache"
+    gem.summary = "rsync_with_remote_cache strategy for Capistrano"
+    gem.description = 'A deployment strategy for Capistrano 2.0 which combines rsync with a remote cache, allowing fast deployments from SCM servers behind firewalls.'
+    gem.email = "mark@viget.com"
+    gem.homepage = "http://github.com/vigetlabs/capistrano_rsync_with_remote_cache"
+    gem.authors = ["Mark Cornick"]
+    gem.rubyforge_project = "viget"
+    gem.add_dependency 'capistrano', '>= 2.0'
+    gem.add_development_dependency "thoughtbot-shoulda"
+    gem.add_development_dependency "yard"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+  Jeweler::RubyforgeTasks.new do |rubyforge|
+    rubyforge.doc_task = "yardoc"
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+    test.rcov_opts << '-x gems'
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install relevance-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+begin
+  require 'reek/rake_task'
+  Reek::RakeTask.new do |t|
+    t.fail_on_error = true
+    t.verbose = false
+    t.source_files = 'lib/**/*.rb'
+  end
+rescue LoadError
+  task :reek do
+    abort "Reek is not available. In order to run reek, you must: sudo gem install reek"
+  end
+end
+
+begin
+  require 'roodi'
+  require 'roodi_task'
+  RoodiTask.new do |t|
+    t.verbose = false
+  end
+rescue LoadError
+  task :roodi do
+    abort "Roodi is not available. In order to run roodi, you must: sudo gem install roodi"
+  end
+end
+
+task :default => :test
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new do |t|
+    t.options = ['--private']
+  end
+rescue LoadError
+  task :yardoc do
+    abort "YARD is not available. In order to run yardoc, you must: sudo gem install yard"
+  end
+end

data/VERSION

@@ -0,0 +1 @@
+2.3.6

data/capistrano_rsync_with_remote_cache.gemspec

@@ -0,0 +1,61 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{mattscilipoti-capistrano_rsync_with_remote_cache}
+  s.version = "2.3.6"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Mark Cornick"]
+  s.date = %q{2009-11-13}
+  s.description = %q{A deployment strategy for Capistrano 2.0 which combines rsync with a remote cache, allowing fast deployments from SCM servers behind firewalls.}
+  s.email = %q{mark@viget.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.md"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.md",
+     "Rakefile",
+     "VERSION",
+     "capistrano_rsync_with_remote_cache.gemspec",
+     "lib/capistrano/recipes/deploy/strategy/exceptions.reek",
+     "lib/capistrano/recipes/deploy/strategy/rsync_with_remote_cache.rb",
+     "test/capistrano_rsync_with_remote_cache_test.rb",
+     "test/test_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/vigetlabs/capistrano_rsync_with_remote_cache}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{viget}
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{rsync_with_remote_cache strategy for Capistrano}
+  s.test_files = [
+    "test/test_helper.rb",
+     "test/capistrano_rsync_with_remote_cache_test.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<capistrano>, [">= 2.0"])
+      s.add_development_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+      s.add_development_dependency(%q<yard>, [">= 0"])
+    else
+      s.add_dependency(%q<capistrano>, [">= 2.0"])
+      s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+      s.add_dependency(%q<yard>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<capistrano>, [">= 2.0"])
+    s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+    s.add_dependency(%q<yard>, [">= 0"])
+  end
+end

data/lib/capistrano/recipes/deploy/strategy/exceptions.reek

@@ -0,0 +1,15 @@
+---
+Duplication:
+  exclude:
+  - check!
+  - command
+  - deploy!
+  - rsync_host
+  - remove_cache_if_repo_changed
+
+FeatureEnvy:
+  exclude:
+  - check!
+
+LongMethod: 
+  max_statements: 10

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

@@ -0,0 +1,118 @@
+require 'capistrano/recipes/deploy/strategy/remote'
+require 'fileutils'
+
+module Capistrano
+  module Deploy
+    module Strategy
+      class RsyncWithRemoteCache < Remote
+
+        INFO_COMMANDS = {
+          :subversion => "svn info . | sed -n \'s/URL: //p\'",
+          :git        => "git config remote.origin.url",
+          :mercurial  => "hg showconfig paths.default",
+          :bzr        => "bzr info | grep parent | sed \'s/^.*parent branch: //\'"
+        }
+
+        # The deployment method itself, in three major steps: update the local cache, update the remote
+        # cache, and copy the remote cache into place.
+        def deploy!
+
+          # Step 1: Update the local cache.
+          system(command)
+          File.open(File.join(local_cache, "REVISION"), "w") { |file| file.puts(revision) }
+
+          # Step 2: Update the remote cache.
+          logger.trace "copying local cache to remote"
+          find_servers(:except => { :no_release => true }).each do |server|
+            system("rsync #{rsync_options} --rsh='ssh -p #{ssh_port}' #{local_cache}/ #{rsync_host(server)}:#{repository_cache}/")
+          end
+
+          # Step 3: Copy the remote cache into place, excluding scm directories (for svn, git, cvs, bzr and more).
+          run("rsync -a --cvs-exclude --delete #{repository_cache}/ #{configuration[:release_path]}/ && #{mark}")
+        end
+
+        # Defines commands that should be checked for by deploy:check. These include the SCM command
+        # on the local end, and rsync on both ends. Note that the SCM command is not needed on the
+        # remote end.
+        def check!
+          super.check do |check|
+            check.local.command(source.command)
+            check.local.command('rsync')
+            check.remote.command('rsync')
+          end
+        end
+
+        private
+
+        # Path to the remote cache. We use a variable name and default that are compatible with
+        # the stock remote_cache strategy, for easy migration.
+        # @return [String] the path to the remote cache
+        def repository_cache
+          File.join(shared_path, configuration[:repository_cache] || "cached-copy")
+        end
+
+        # Path to the local cache. If not specified in the Capfile, we use an arbitrary default.
+        # @return [String] the path to the local cache
+        def local_cache
+          configuration[:local_cache] || ".rsync_cache"
+        end
+
+        # Options to use for rsync in step 2. If not specified in the Capfile, we use the default
+        # from prior versions.
+        # @return [String] the options to be passed to rsync
+        def rsync_options
+          configuration[:rsync_options] || "-az --delete"
+        end
+
+        # Port to use for rsync in step 2. If not specified with (ssh_options) in the Capfile, we
+        # use the default well-known port 22.
+        # @return [Fixnum] the port to connect to with rsync
+        def ssh_port
+          ssh_options[:port] || 22
+        end
+
+        # Get a hostname to be used in the rsync command.
+        # @param [Capistrano::ServerDefinition, #host] the host which rsync will connect to
+        # @return [String] the hostname, prefixed with user@ if necessary
+        def rsync_host(server)
+          if configuration[:user]
+            "#{configuration[:user]}@#{server.host}"
+          else
+            server.host
+          end
+        end
+
+        # Remove the local cache (so it can be recreated) if the repository URL has changed
+        # since the last deployment.
+        # TODO: punt in some sensible way if local_cache exists but is a regular file.
+        def remove_cache_if_repo_changed
+          if INFO_COMMANDS[configuration[:scm]] && File.directory?(local_cache)
+            info_command = "cd #{local_cache} && #{INFO_COMMANDS[configuration[:scm]]}"
+            cached_repo_url = IO.popen(info_command){|pipe| pipe.readline}.chomp
+            if cached_repo_url != configuration[:repository]
+              logger.trace "repository has changed; removing old local cache"
+              FileUtils.rm_rf(local_cache)
+            end
+          end
+        end
+
+        # Command to get source from SCM on the local side. The local cache is either created,
+        # updated, or destroyed and recreated depending on whether it exists and is a cache of
+        # the right repository.
+        # @return [String] command to either checkout or update the local cache
+        def command
+          remove_cache_if_repo_changed
+          if File.exists?(local_cache) && File.directory?(local_cache)
+            logger.trace "updating local cache to revision #{revision}"
+            return source.sync(revision, local_cache)
+          else
+            logger.trace "creating local cache with revision #{revision}"
+            File.delete(local_cache) if File.exists?(local_cache)
+            Dir.mkdir(File.dirname(local_cache)) unless File.directory?(File.dirname(local_cache))
+            return source.checkout(revision, local_cache)
+          end
+        end
+      end
+    end
+  end
+end

data/test/capistrano_rsync_with_remote_cache_test.rb

@@ -0,0 +1,174 @@
+# This test suite was written way after the code, back when the author didn't do TDD consistently.
+# Also, the code does a lot of things with external servers and services, so there's a lot of mocking.
+# Therefore, this suite is nearly impossible to follow in places. Sorry.
+
+require 'test_helper'
+
+class CapistranoRsyncWithRemoteCacheTest < Test::Unit::TestCase
+  def stub_configuration(hash)
+    @rwrc.expects(:configuration).at_least_once.returns(hash)
+  end
+
+  def stub_ssh_options(hash)
+    @rwrc.expects(:ssh_options).at_least_once.returns(hash)
+  end
+
+  context 'RsyncWithRemoteCache' do
+    setup do
+      @rwrc = Capistrano::Deploy::Strategy::RsyncWithRemoteCache.new
+      logger_stub = stub()
+      logger_stub.stubs(:trace)
+      @rwrc.stubs(:logger).returns(logger_stub)
+    end
+
+    should 'deploy!' do
+      stub_configuration(:deploy_to => 'deploy_to', :release_path => 'release_path', :scm => :subversion)
+      stub_ssh_options(:port => nil)
+      @rwrc.stubs(:shared_path).returns('shared')
+
+      # Step 1: Update the local cache.
+      @rwrc.expects(:command).returns('command')
+      @rwrc.expects(:system).with('command')
+      revision_file_stub = stub()
+      revision_file_stub.expects(:puts)
+      File.expects(:open).with(File.join('.rsync_cache', 'REVISION'), 'w').yields(revision_file_stub)
+
+      # Step 2: Update the remote cache.
+      server_stub = stub(:host => 'host')
+      @rwrc.expects(:system).with("rsync -az --delete --rsh='ssh -p 22' .rsync_cache/ host:shared/cached-copy/")
+      @rwrc.expects(:find_servers).returns([server_stub])
+
+      # Step 3: Copy the remote cache into place.
+      @rwrc.expects(:mark).returns('mark')
+      @rwrc.expects(:run).with("rsync -a --cvs-exclude --delete shared/cached-copy/ release_path/ && mark")
+
+      @rwrc.deploy!
+    end
+
+    should 'check!' do
+      configuration = {:releases_path => 'releases_path', :deploy_to => 'deploy_to'}
+      configuration.stubs(:invoke_command)
+      @rwrc.expects(:configuration).at_least_once.returns(configuration)
+
+      source_stub = stub(:command => 'command')
+      @rwrc.stubs(:source).returns(source_stub)
+
+      @rwrc.check!
+    end
+
+    context 'repository_cache' do
+      setup do
+        @rwrc.expects(:shared_path).returns('shared')
+      end
+
+      should 'return specified cache if present in configuration' do
+        stub_configuration(:repository_cache => 'cache')
+        assert_equal 'shared/cache', @rwrc.send(:repository_cache)
+      end
+
+      should 'return default cache if not present in configuration' do
+        stub_configuration(:repository_cache => nil)
+        assert_equal 'shared/cached-copy', @rwrc.send(:repository_cache)
+      end
+    end
+
+    context 'local_cache' do
+      should 'return specified cache if present in configuration' do
+        stub_configuration(:local_cache => 'cache')
+        assert_equal 'cache', @rwrc.send(:local_cache)
+      end
+
+      should 'return default cache if not present in configuration' do
+        stub_configuration(:local_cache => nil)
+        assert_equal '.rsync_cache', @rwrc.send(:local_cache)
+      end
+    end
+
+    context 'rsync_options' do
+      should 'return specified options if present in configuration' do
+        stub_configuration(:rsync_options => 'options')
+        assert_equal 'options', @rwrc.send(:rsync_options)
+      end
+
+      should 'return default options if not present in configuration' do
+        stub_configuration(:rsync_options => nil)
+        assert_equal '-az --delete', @rwrc.send(:rsync_options)
+      end
+    end
+
+    context 'ssh_port' do
+      should 'return specified port if present in configuration' do
+        stub_ssh_options(:port => 2222)
+        assert_equal 2222, @rwrc.send(:ssh_port)
+      end
+
+      should 'return default port if not present in configuration' do
+        stub_ssh_options(:port => nil)
+        assert_equal 22, @rwrc.send(:ssh_port)
+      end
+    end
+
+    context 'rsync_host' do
+      setup do
+        @server_stub = stub(:host => 'host')
+      end
+
+      should 'prefix user if present in configuration' do
+        stub_configuration(:user => 'user')
+        assert_equal 'user@host', @rwrc.send(:rsync_host, @server_stub)
+      end
+
+      should 'not prefix user if not present in configuration' do
+        stub_configuration(:user => nil)
+        assert_equal 'host', @rwrc.send(:rsync_host, @server_stub)
+      end
+    end
+
+    context 'remove_cache_if_repo_changed' do
+      [:subversion, :git, :mercurial, :bzr].each do |scm|
+        should "purge local cache if it detects #{scm} info has changed" do
+          stub_configuration(:scm => scm, :repository => 'repository')
+          info_command = Capistrano::Deploy::Strategy::RsyncWithRemoteCache::INFO_COMMANDS[scm]
+          File.expects(:directory?).with('.rsync_cache').returns(true)
+          IO.expects(:popen).with("cd .rsync_cache && #{info_command}").returns('abc')
+          FileUtils.expects(:rm_rf).with('.rsync_cache')
+          @rwrc.send(:remove_cache_if_repo_changed)
+        end
+      end
+
+      should 'not attempt to purge local cache if it does not exist' do
+        stub_configuration(:scm => :subversion, :repository => 'repository')
+        File.expects(:directory?).with('.rsync_cache').returns(false)
+        FileUtils.expects(:rm_rf).with('.rsync_cache').never
+        @rwrc.send(:remove_cache_if_repo_changed)
+      end
+
+      should 'not attempt to purge local cache if the scm is not supported by this gem' do
+        stub_configuration(:scm => :cvs, :repository => 'repository')
+        FileUtils.expects(:rm_rf).with('.rsync_cache').never
+        @rwrc.send(:remove_cache_if_repo_changed)
+      end
+    end
+
+    context 'command' do
+      should 'update local cache if it exists' do
+        File.expects(:exists?).with('.rsync_cache').returns(true)
+        File.expects(:directory?).with('.rsync_cache').returns(true)
+        source_stub = stub()
+        source_stub.expects(:sync)
+        @rwrc.expects(:source).returns(source_stub)
+        @rwrc.send(:command)
+      end
+
+      should 'create local cache if it does not exist' do
+        File.expects(:exists?).with('.rsync_cache').times(2).returns(false)
+        File.expects(:directory?).with(File.dirname('.rsync_cache')).returns(false)
+        Dir.expects(:mkdir).with(File.dirname('.rsync_cache'))
+        source_stub = stub()
+        source_stub.expects(:checkout)
+        @rwrc.expects(:source).returns(source_stub)
+        @rwrc.send(:command)
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,11 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'capistrano/recipes/deploy/strategy/rsync_with_remote_cache'
+
+class Test::Unit::TestCase
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification 
+name: mattscilipoti-capistrano_rsync_with_remote_cache
+version: !ruby/object:Gem::Version 
+  version: 2.3.6
+platform: ruby
+authors: 
+- Mark Cornick
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-13 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: capistrano
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "2.0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: thoughtbot-shoulda
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: yard
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: A deployment strategy for Capistrano 2.0 which combines rsync with a remote cache, allowing fast deployments from SCM servers behind firewalls.
+email: mark@viget.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.md
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.md
+- Rakefile
+- VERSION
+- capistrano_rsync_with_remote_cache.gemspec
+- lib/capistrano/recipes/deploy/strategy/exceptions.reek
+- lib/capistrano/recipes/deploy/strategy/rsync_with_remote_cache.rb
+- test/capistrano_rsync_with_remote_cache_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/vigetlabs/capistrano_rsync_with_remote_cache
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: viget
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: rsync_with_remote_cache strategy for Capistrano
+test_files: 
+- test/test_helper.rb
+- test/capistrano_rsync_with_remote_cache_test.rb