capistrano 2.8.0 → 3.19.0

data/README.md

@@ -0,0 +1,221 @@
+
+# Capistrano: A deployment automation tool built on Ruby, Rake, and SSH.
+
+[![Gem Version](https://badge.fury.io/rb/capistrano.svg)](http://badge.fury.io/rb/capistrano) [![Build Status](https://github.com/capistrano/capistrano/actions/workflows/ci.yml/badge.svg)](https://github.com/capistrano/capistrano/actions/workflows/ci.yml) [![Code Climate](https://codeclimate.com/github/capistrano/capistrano/badges/gpa.svg)](https://codeclimate.com/github/capistrano/capistrano) [![CodersClan](https://img.shields.io/badge/get-support-blue.svg)](http://codersclan.net/?repo_id=325&source=small)
+
+Capistrano is a framework for building automated deployment scripts. Although Capistrano itself is written in Ruby, it can easily be used to deploy projects of any language or framework, be it Rails, Java, or PHP.
+
+Once installed, Capistrano gives you a `cap` tool to perform your deployments from the comfort of your command line.
+
+```
+$ cd my-capistrano-enabled-project
+$ cap production deploy
+```
+
+When you run `cap`, Capistrano dutifully connects to your server(s) via SSH and executes the steps necessary to deploy your project. You can define those steps yourself by writing [Rake](https://github.com/ruby/rake) tasks, or by using pre-built task libraries provided by the Capistrano community.
+
+Tasks are simple to make. Here's an example:
+
+```ruby
+task :restart_sidekiq do
+  on roles(:worker) do
+    execute :service, "sidekiq restart"
+  end
+end
+after "deploy:published", "restart_sidekiq"
+```
+
+*Note: This documentation is for the current version of Capistrano (3.x). If you are looking for Capistrano 2.x documentation, you can find it in [this archive](https://github.com/capistrano/capistrano-2.x-docs).*
+
+---
+
+## Contents
+
+* [Features](#features)
+* [Gotchas](#gotchas)
+* [Quick start](#quick-start)
+* [Finding help and documentation](#finding-help-and-documentation)
+* [How to contribute](#how-to-contribute)
+* [License](#license)
+
+## Features
+
+There are many ways to automate deployments, from simple rsync bash scripts to complex containerized toolchains. Capistrano sits somewhere in the middle: it automates what you already know how to do manually with SSH, but in a repeatable, scalable fashion. There is no magic here!
+
+Here's what makes Capistrano great:
+
+#### Strong conventions
+
+Capistrano defines a standard deployment process that all Capistrano-enabled projects follow by default. You don't have to decide how to structure your scripts, where deployed files should be placed on the server, or how to perform common tasks: Capistrano has done this work for you.
+
+#### Multiple stages
+
+Define your deployment once, and then easily parameterize it for multiple *stages* (environments), e.g. `qa`, `staging`, and `production`. No copy-and-paste necessary: you only need to specify what is different for each stage, like IP addresses.
+
+#### Parallel execution
+
+Deploying to a fleet of app servers? Capistrano can run each deployment task concurrently across those servers and uses connection pooling for speed.
+
+#### Server roles
+
+Your application may need many different types of servers: a database server, an app server, two web servers, and a job queue work server, for example. Capistrano lets you tag each server with one or more roles, so you can control what tasks are executed where.
+
+#### Community driven
+
+Capistrano is easily extensible using the rubygems package manager. Deploying a Rails app? Wordpress? Laravel? Chances are, someone has already written Capistrano tasks for your framework of choice and has distributed it as a gem. Many Ruby projects also come with Capistrano tasks built-in.
+
+#### It's just SSH
+
+Everything in Capistrano comes down to running SSH commands on remote servers. On the one hand, that makes Capistrano simple. On the other hand, if you aren't comfortable SSH-ing into a Linux box and doing stuff on the command-line, then Capistrano is probably not for you.
+
+## Gotchas
+
+While Capistrano ships with a strong set of conventions that are common for all types of deployments, it needs help understanding the specifics of your project, and there are some things Capistrano is not suited to do.
+
+#### Project specifics
+
+Out of the box, Capistrano can deploy your code to server(s), but it does not know how to *execute* your code. Does `foreman` need to be run? Does Apache need to be restarted? You'll need to tell Capistrano how to do this part by writing these deployment steps yourself, or by finding a gem in the Capistrano community that does it for you.
+
+#### Key-based SSH
+
+Capistrano depends on connecting to your server(s) with SSH using key-based (i.e. password-less) authentication. You'll need this working before you can use Capistrano.
+
+#### Provisioning
+
+Likewise, your server(s) will likely need supporting software installed before you can perform a deployment. Capistrano itself has no requirements other than SSH, but your application probably needs database software, a web server like Apache or Nginx, and a language runtime like Java, Ruby, or PHP. These *server provisioning* steps are not done by Capistrano.
+
+#### `sudo`, etc.
+
+Capistrano is designed to deploy using a single, non-privileged SSH user, using a *non-interactive* SSH session. If your deployment requires `sudo`, interactive prompts, authenticating as one user but running commands as another, you can probably accomplish this with Capistrano, but it may be difficult. Your automated deployments will be much smoother if you can avoid such requirements.
+
+#### Shells
+
+Capistrano 3 expects a POSIX shell like Bash or Sh. Shells like tcsh, csh, and such may work, but probably will not.
+
+## Quick start
+
+### Requirements
+
+* Ruby version 2.0 or higher on your local machine (MRI or Rubinius)
+* A project that uses source control (Git, Mercurial, and Subversion support is built-in)
+* The SCM binaries (e.g. `git`, `hg`) needed to check out your project must be installed on the server(s) you are deploying to
+* [Bundler](http://bundler.io), along with a Gemfile for your project, are recommended
+
+### Install the Capistrano gem
+
+Add Capistrano to your project's Gemfile using `require: false`:
+
+``` ruby
+group :development do
+  gem "capistrano", "~> 3.17", require: false
+end
+```
+
+Then run Bundler to ensure Capistrano is downloaded and installed:
+
+``` sh
+$ bundle install
+```
+
+### "Capify" your project
+
+Make sure your project doesn't already have a "Capfile" or "capfile" present. Then run:
+
+``` sh
+$ bundle exec cap install
+```
+
+This creates all the necessary configuration files and directory structure for a Capistrano-enabled project with two stages, `staging` and `production`:
+
+```
+├── Capfile
+├── config
+│   ├── deploy
+│   │   ├── production.rb
+│   │   └── staging.rb
+│   └── deploy.rb
+└── lib
+    └── capistrano
+            └── tasks
+```
+
+To customize the stages that are created, use:
+
+``` sh
+$ bundle exec cap install STAGES=local,sandbox,qa,production
+```
+
+Note that the files that Capistrano creates are simply templates to get you started. Make sure to edit the `deploy.rb` and stage files so that they contain values appropriate for your project and your target servers.
+
+### Command-line usage
+
+``` sh
+# list all available tasks
+$ bundle exec cap -T
+
+# deploy to the staging environment
+$ bundle exec cap staging deploy
+
+# deploy to the production environment
+$ bundle exec cap production deploy
+
+# simulate deploying to the production environment
+# does not actually do anything
+$ bundle exec cap production deploy --dry-run
+
+# list task dependencies
+$ bundle exec cap production deploy --prereqs
+
+# trace through task invocations
+$ bundle exec cap production deploy --trace
+
+# lists all config variable before deployment tasks
+$ bundle exec cap production deploy --print-config-variables
+```
+
+## Finding help and documentation
+
+Capistrano is a large project encompassing multiple GitHub repositories and a community of plugins, and it can be overwhelming when you are just getting started. Here are resources that can help:
+
+* **The [docs](docs) directory contains the official documentation**, and is used to generate the [Capistrano website](http://capistranorb.com)
+* [Stack Overflow](http://stackoverflow.com/questions/tagged/capistrano) has a Capistrano tag with lots of activity
+* [The Capistrano mailing list](https://groups.google.com/forum/#!forum/capistrano) is low-traffic but is monitored by Capistrano contributors
+* [CodersClan](http://codersclan.net/?repo_id=325&source=link) has Capistrano experts available to solve problems for bounties
+
+Related GitHub repositories:
+
+* [capistrano/sshkit](https://github.com/capistrano/sshkit) provides the SSH behavior that underlies Capistrano (when you use `execute` in a Capistrano task, you are using SSHKit)
+* [capistrano/rails](https://github.com/capistrano/rails) is a very popular gem that adds Ruby on Rails deployment tasks
+* [mattbrictson/airbrussh](https://github.com/mattbrictson/airbrussh) provides Capistrano's default log formatting
+
+GitHub issues are for bug reports and feature requests. Please refer to the [CONTRIBUTING](CONTRIBUTING.md) document for guidelines on submitting GitHub issues.
+
+If you think you may have discovered a security vulnerability in Capistrano, do not open a GitHub issue. Instead, please send a report to <security@capistranorb.com>.
+
+## How to contribute
+
+Contributions to Capistrano, in the form of code, documentation or idea, are gladly accepted. Read the [DEVELOPMENT](DEVELOPMENT.md) document to learn how to hack on Capistrano's code, run the tests, and contribute your first pull request.
+
+## License
+
+MIT License (MIT)
+
+Copyright (c) 2012-2020 Tom Clements, Lee Hambley
+
+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/RELEASING.md

@@ -0,0 +1,17 @@
+# Releasing
+
+## Prerequisites
+
+* You must have commit rights to the Capistrano repository.
+* You must have push rights for the capistrano gem on rubygems.org.
+
+## How to release
+
+1. Run `bundle install` to make sure that you have all the gems necessary for testing and releasing.
+2.  **Ensure all tests are passing by running `rake spec` and `rake features`.**
+3. Determine which would be the correct next version number according to [semver](http://semver.org/).
+4. Update the version in `./lib/capistrano/version.rb`.
+5. Update the version in the `./README.md` Gemfile example (`gem "capistrano", "~> X.Y"`).
+6. Commit the `version.rb` and `README.md` changes in a single commit, the message should be "Release vX.Y.Z"
+7. Run `rake release`; this will tag, push to GitHub, and publish to rubygems.org.
+8. Update the draft release on the [GitHub releases page](https://github.com/capistrano/capistrano/releases) to point to the new tag and publish the release

data/Rakefile

@@ -1,11 +1,20 @@
-require 'bundler'
-Bundler::GemHelper.install_tasks
+require "bundler/gem_tasks"
+require "cucumber/rake/task"
+require "rspec/core/rake_task"
 
-require 'rake/testtask'
-Rake::TestTask.new(:test) do |test|
-  test.libs << 'lib' << 'test'
-  test.pattern = 'test/**/*_test.rb'
-  test.verbose = true
+begin
+  require "rubocop/rake_task"
+  desc "Run RuboCop checks"
+  RuboCop::RakeTask.new
+  task default: %i(spec rubocop)
+rescue LoadError
+  task default: :spec
 end
 
-task :default => :test
+RSpec::Core::RakeTask.new
+Cucumber::Rake::Task.new(:features)
+
+Rake::Task["release"].enhance do
+  puts "Don't forget to publish the release on GitHub!"
+  system "open https://github.com/capistrano/capistrano/releases"
+end

data/UPGRADING-3.7.md

@@ -0,0 +1,86 @@
+# Capistrano 3.7.0 upgrade guide
+
+## The :scm variable is deprecated
+
+Up until now, Capistrano's SCM was configured using the `:scm` variable:
+
+```ruby
+# This is now deprecated
+set :scm, :svn
+```
+
+To avoid deprecation warnings:
+
+1. Remove `set :scm, ...` from your Capistrano configuration.
+2. Add *one* of the following SCM declarations to your `Capfile` after `require "capistrano/deploy"`:
+
+```ruby
+# To use Git
+require "capistrano/scm/git"
+install_plugin Capistrano::SCM::Git
+
+# To use Mercurial
+require "capistrano/scm/hg"
+install_plugin Capistrano::SCM::Hg
+
+# To use Subversion
+require "capistrano/scm/svn"
+install_plugin Capistrano::SCM::Svn
+```
+
+## This is the last release where Git is the automatic default
+
+If you do not specify an SCM, Capistrano assumes Git. However this behavior is
+now deprecated. Add this to your Capfile to avoid deprecation warnings:
+
+```ruby
+require "capistrano/scm/git"
+install_plugin Capistrano::SCM::Git
+```
+
+## :git_strategy, :hg_strategy, and :svn_strategy are removed
+
+Capistrano 3.7.0 has a rewritten SCM system that relies on "plugins". This
+system is more flexible than the old "strategy" system that only allowed certain
+parts of SCM tasks to be customized.
+
+If your deployment relies on a custom SCM strategy, you will need to rewrite
+that strategy to be a full-fledged SCM plugin instead. There is a fairly
+straightforward migration path: write your plugin to be a subclass of the
+built-in SCM that you want to customize. For example:
+
+```ruby
+require "capistrano/scm/git"
+
+class MyCustomGit < Capistrano::SCM::Git
+  # Override the methods you wish to customize, e.g.:
+  def clone_repo
+    # ...
+  end
+end
+```
+
+Then use your plugin in by loading it in the Capfile:
+
+```ruby
+require_relative "path/to/my_custom_git.rb"
+install_plugin MyCustomGit
+```
+
+## Existing third-party SCMs are deprecated
+
+If you are using a third-party SCM, you can continue using it without
+changes, but you will see deprecation warnings. Contact the maintainer of the
+third-party SCM gem and ask them about modifying the gem to work with the new
+Capistrano 3.7.0 SCM plugin system.
+
+## remote_file is removed
+
+The `remote_file` method is no longer in Capistrano 3.7.0. You can read the
+discussion that led to its removal here:
+[issue 762](https://github.com/capistrano/capistrano/issues/762).
+
+There is no direct replacement. To migrate to 3.7.0, you will need to rewrite
+any parts of your deployment that use `remote_file` to use a different
+mechanism for uploading files. Consider using the `upload!` method directly in
+a procedural fashion instead.

data/bin/cap

@@ -1,4 +1,3 @@
 #!/usr/bin/env ruby
-
-require 'capistrano/cli'
-Capistrano::CLI.execute
+require "capistrano/all"
+Capistrano::Application.new.run

data/bin/capify

@@ -1,90 +1,8 @@
 #!/usr/bin/env ruby
-
-require 'optparse'
-require 'fileutils'
-
-OptionParser.new do |opts|
-  opts.banner = "Usage: #{File.basename($0)} [path]"
-
-  opts.on("-h", "--help", "Displays this help info") do
-    puts opts
-    exit 0
-  end
-
-  begin
-    opts.parse!(ARGV)
-  rescue OptionParser::ParseError => e
-    warn e.message
-    puts opts
-    exit 1
-  end
-end
-
-if ARGV.empty?
-  abort "Please specify the directory to capify, e.g. `#{File.basename($0)} .'"
-elsif !File.exists?(ARGV.first)
-  abort "`#{ARGV.first}' does not exist."
-elsif !File.directory?(ARGV.first)
-  abort "`#{ARGV.first}' is not a directory."
-elsif ARGV.length > 1
-  abort "Too many arguments; please specify only the directory to capify."
-end
-
-def unindent(string)
-  indentation = string[/\A\s*/]
-  string.strip.gsub(/^#{indentation}/, "")
-end
-
-files = {
-  "Capfile" => unindent(<<-FILE),
-    load 'deploy' if respond_to?(:namespace) # cap2 differentiator
-
-    # Uncomment if you are using Rails' asset pipeline
-    # load 'deploy/assets'
-
-    Dir['vendor/gems/*/recipes/*.rb','vendor/plugins/*/recipes/*.rb'].each { |plugin| load(plugin) }
-
-    load 'config/deploy' # remove this line to skip loading any of the default tasks
-  FILE
-
-  "config/deploy.rb" => 'set :application, "set your application name here"
-set :repository,  "set your repository location here"
-
-set :scm, :subversion
-# Or: `accurev`, `bzr`, `cvs`, `darcs`, `git`, `mercurial`, `perforce`, `subversion` or `none`
-
-role :web, "your web-server here"                          # Your HTTP server, Apache/etc
-role :app, "your app-server here"                          # This may be the same as your `Web` server
-role :db,  "your primary db-server here", :primary => true # This is where Rails migrations will run
-role :db,  "your slave db-server here"
-
-# if you\'re still using the script/reaper helper you will need
-# these http://github.com/rails/irs_process_scripts
-
-# If you are using Passenger mod_rails uncomment this:
-# namespace :deploy do
-#   task :start do ; end
-#   task :stop do ; end
-#   task :restart, :roles => :app, :except => { :no_release => true } do
-#     run "#{try_sudo} touch #{File.join(current_path,\'tmp\',\'restart.txt\')}"
-#   end
-# end'}
-
-base = ARGV.shift
-files.each do |file, content|
-  file = File.join(base, file)
-  if File.exists?(file)
-    warn "[skip] '#{file}' already exists"
-  elsif File.exists?(file.downcase)
-    warn "[skip] '#{file.downcase}' exists, which could conflict with `#{file}'"
-  else
-    unless File.exists?(File.dirname(file))
-      puts "[add] making directory '#{File.dirname(file)}'"
-      FileUtils.mkdir(File.dirname(file))
-    end
-    puts "[add] writing '#{file}'"
-    File.open(file, "w") { |f| f.write(content) }
-  end
-end
-
-puts "[done] capified!"
+puts "-" * 80
+puts "Capistrano 3.x is incompatible with Capistrano 2.x. "
+puts
+puts "This command has become `cap install` in Capistrano 3.x"
+puts
+puts "For more information see http://www.capistranorb.com/"
+puts "-" * 80

data/capistrano.gemspec

@@ -1,48 +1,34 @@
 # -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "capistrano/version"
 
-Gem::Specification.new do |s|
-  s.name        = "capistrano"
-  s.version     = Capistrano::Version.to_s
-  s.platform    = Gem::Platform::RUBY
-  s.authors     = ["Jamis Buck", "Lee Hambley"]
-  s.email       = ["jamis@jamisbuck.org", "lee.hambley@gmail.com"]
-  s.homepage    = "http://github.com/capistrano/capistrano"
-  s.summary     = %q{Capistrano - Welcome to easy deployment with Ruby over SSH}
-  s.description = %q{Capistrano is a utility and framework for executing commands in parallel on multiple remote machines, via SSH.}
-  s.date        = %q{2011-03-22}
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
-  s.extra_rdoc_files = [
-    "README.mdown"
-  ]
+Gem::Specification.new do |gem|
+  gem.name          = "capistrano"
+  gem.version       = Capistrano::VERSION
+  gem.authors       = ["Tom Clements", "Lee Hambley"]
+  gem.email         = ["seenmyfate@gmail.com", "lee.hambley@gmail.com"]
+  gem.description   = "Capistrano is a utility and framework for executing commands in parallel on multiple remote machines, via SSH."
+  gem.summary       = "Capistrano - Welcome to easy deployment with Ruby over SSH"
+  gem.homepage      = "https://capistranorb.com/"
+  gem.metadata      = {
+    "bug_tracker_uri" => "https://github.com/capistrano/capistrano/issues",
+    "changelog_uri" => "https://github.com/capistrano/capistrano/releases",
+    "source_code_uri" => "https://github.com/capistrano/capistrano",
+    "homepage_uri" => "https://capistranorb.com/",
+    "documentation_uri" => "https://capistranorb.com/"
+  }
+  gem.files         = `git ls-files -z`.split("\x0").reject { |f| f =~ /^docs/ }
+  gem.executables   = %w(cap capify)
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.licenses      = ["MIT"]
 
-  if s.respond_to? :specification_version then
-    s.specification_version = 3
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<highline>, [">= 0"])
-      s.add_runtime_dependency(%q<net-ssh>, [">= 2.0.14"])
-      s.add_runtime_dependency(%q<net-sftp>, [">= 2.0.0"])
-      s.add_runtime_dependency(%q<net-scp>, [">= 1.0.0"])
-      s.add_runtime_dependency(%q<net-ssh-gateway>, [">= 1.1.0"])
-      s.add_development_dependency(%q<mocha>, [">= 0"])
-    else
-      s.add_dependency(%q<net-ssh>, [">= 2.0.14"])
-      s.add_dependency(%q<net-sftp>, [">= 2.0.0"])
-      s.add_dependency(%q<net-scp>, [">= 1.0.0"])
-      s.add_dependency(%q<net-ssh-gateway>, [">= 1.1.0"])
-      s.add_dependency(%q<highline>, [">= 0"])
-      s.add_dependency(%q<mocha>, [">= 0"])
-    end
-  else
-    s.add_dependency(%q<net-ssh>, [">= 2.0.14"])
-    s.add_dependency(%q<net-sftp>, [">= 2.0.0"])
-    s.add_dependency(%q<net-scp>, [">= 1.0.0"])
-    s.add_dependency(%q<net-ssh-gateway>, [">= 1.1.0"])
-    s.add_dependency(%q<highline>, [">= 0"])
-    s.add_dependency(%q<mocha>, [">= 0"])
-  end
+  gem.required_ruby_version = ">= 2.0"
+  gem.add_dependency "airbrussh", ">= 1.0.0"
+  gem.add_dependency "i18n"
+  gem.add_dependency "rake", ">= 10.0.0"
+  gem.add_dependency "sshkit", ">= 1.9.0"
 end

data/docker-compose.yml

@@ -0,0 +1,8 @@
+name: capistrano
+
+services:
+  ssh_server:
+    build:
+      context: .docker
+    ports:
+      - "2022:22"

data/features/configuration.feature

@@ -0,0 +1,28 @@
+Feature: The path to the configuration can be changed, removing the need to
+  follow Ruby/Rails conventions
+
+  Background:
+    Given a test app with the default configuration
+    And servers with the roles app and web
+
+  Scenario: Deploying with configuration in default location
+    When I run "cap test"
+    Then the task is successful
+
+  Scenario: Deploying with configuration in a custom location
+    But the configuration is in a custom location
+    When I run "cap test"
+    Then the task is successful
+
+  Scenario: Show install task with configuration in default location
+    When I run "cap -T"
+    Then the task is successful
+    And contains "install" in the output
+
+  Scenario: Hide install task with configuration in a custom location
+    And config stage file has line "desc 'Special Task'"
+    And config stage file has line "task :special_stage_task"
+    But the configuration is in a custom location
+    When I run "cap -T"
+    Then the task is successful
+    And doesn't contain "special_stage_task" in the output

data/features/deploy.feature

@@ -0,0 +1,92 @@
+Feature: Deploy
+
+  Background:
+    Given a test app with the default configuration
+    And servers with the roles app and web
+
+  Scenario: Creating the repo
+    When I run cap "git:check"
+    Then the task is successful
+    And git wrapper permissions are 0700
+
+  Scenario: Creating the directory structure
+    When I run cap "deploy:check:directories"
+    Then the shared path is created
+    And the releases path is created
+
+  Scenario: Creating linked directories
+    When I run cap "deploy:check:linked_dirs"
+    Then directories in :linked_dirs are created in shared
+
+  Scenario: Creating linked directories for linked files
+    When I run cap "deploy:check:make_linked_dirs"
+    Then directories referenced in :linked_files are created in shared
+
+  Scenario: Checking linked files - missing file
+    Given a linked file "missing_file.txt"
+    But file "missing_file.txt" does not exist in shared path
+    When I run cap "deploy:check:linked_files"
+    Then the task fails
+
+  Scenario: Checking linked files - file exists
+    Given a linked file "existing_file.txt"
+    And file "existing_file.txt" exists in shared path
+    When I run cap "deploy:check:linked_files"
+    Then the task is successful
+
+  Scenario: Creating a release
+    Given I run cap "deploy:check:directories"
+    When I run cap "git:create_release" as part of a release
+    Then the repo is cloned
+    And the release is created
+
+  Scenario: REVISION and REVISION_TIME files are present
+    When I make 1 deployment
+    Then the REVISION file is created in the release
+    Then the REVISION_TIME file is created in the release
+
+  Scenario: Symlink linked files
+    When I run cap "deploy:symlink:linked_files deploy:symlink:release" as part of a release
+    Then file symlinks are created in the new release
+
+  Scenario: Symlink linked dirs
+    When I run cap "deploy:symlink:linked_dirs" as part of a release
+    Then directory symlinks are created in the new release
+
+  Scenario: Publishing
+    When I run cap "deploy:symlink:release"
+    Then the current directory will be a symlink to the release
+
+  Scenario: Cleanup
+    Given config stage file has line "set :keep_releases, 3"
+    And 5 valid existing releases
+    And an invalid release named "new"
+    When I run cap "deploy:cleanup"
+    Then 3 valid releases are kept
+    And the invalid "new" release is ignored
+
+  Scenario: Cleanup after many failed releases doesn't remove last good release
+    Given config stage file has line "set :keep_releases, 2"
+    And I make 2 deployments
+    And an invalid release named "77777777777777"
+    And an invalid release named "88888888888888"
+    And an invalid release named "99999999999999"
+    When I run cap "deploy:cleanup"
+    Then 3 valid releases are kept
+    And the current directory will be a symlink to the release
+
+  Scenario: Cleanup when there are more releases than arguments can handle
+    Given config stage file has line "set :keep_releases, 3"
+    And 5000 valid existing releases
+    When I run cap "deploy:cleanup"
+    Then 3 valid releases are kept
+
+  Scenario: Rolling Back
+    Given I make 2 deployments
+    When I run cap "deploy:rollback"
+    Then the current symlink points to the previous release
+
+  Scenario: Rolling Back to a specific release
+    Given I make 3 deployments
+    When I rollback to a specific release
+    Then the current symlink points to that specific release