capistrano 2.1.0 → 3.0.0

data/lib/capistrano/tasks/install.rake

@@ -0,0 +1,39 @@
+require 'erb'
+require 'pathname'
+desc 'Install Capistrano, cap install STAGES=staging,production'
+task :install do
+  envs = ENV['STAGES'] || 'staging,production'
+
+  tasks_dir = Pathname.new('lib/capistrano/tasks')
+  config_dir = Pathname.new('config')
+  deploy_dir = config_dir.join('deploy')
+
+  deploy_rb = File.expand_path("../../templates/deploy.rb.erb", __FILE__)
+  stage_rb = File.expand_path("../../templates/stage.rb.erb", __FILE__)
+  capfile = File.expand_path("../../templates/Capfile", __FILE__)
+
+  mkdir_p deploy_dir
+
+  template = File.read(deploy_rb)
+  file = config_dir.join('deploy.rb')
+  File.open(file, 'w+') do |f|
+    f.write(ERB.new(template).result(binding))
+    puts I18n.t(:written_file, scope: :capistrano, file: file)
+  end
+
+  template = File.read(stage_rb)
+  envs.split(',').each do |stage|
+    file = deploy_dir.join("#{stage}.rb")
+    File.open(file, 'w+') do |f|
+      f.write(ERB.new(template).result(binding))
+      puts I18n.t(:written_file, scope: :capistrano, file: file)
+    end
+  end
+
+  mkdir_p tasks_dir
+
+  FileUtils.cp(capfile, 'Capfile')
+
+
+  puts I18n.t :capified, scope: :capistrano
+end

data/lib/capistrano/templates/Capfile

@@ -0,0 +1,26 @@
+# Load DSL and Setup Up Stages
+require 'capistrano/setup'
+
+# Includes default deployment tasks
+require 'capistrano/deploy'
+
+# Includes tasks from other gems included in your Gemfile
+#
+# For documentation on these, see for example:
+#
+#   https://github.com/capistrano/rvm
+#   https://github.com/capistrano/rbenv
+#   https://github.com/capistrano/chruby
+#   https://github.com/capistrano/bundler
+#   https://github.com/capistrano/rails/tree/master/assets
+#   https://github.com/capistrano/rails/tree/master/migrations
+#
+# require 'capistrano/rvm'
+# require 'capistrano/rbenv'
+# require 'capistrano/chruby'
+# require 'capistrano/bundler'
+# require 'capistrano/rails/assets'
+# require 'capistrano/rails/migrations'
+
+# Loads custom tasks from `lib/capistrano/tasks' if you have any defined.
+Dir.glob('lib/capistrano/tasks/*.cap').each { |r| import r }

data/lib/capistrano/templates/deploy.rb.erb

@@ -0,0 +1,40 @@
+set :application, 'my app name'
+set :repo_url, 'git@example.com:me/my_repo.git'
+
+# ask :branch, proc { `git rev-parse --abbrev-ref HEAD`.chomp }
+
+# set :deploy_to, '/var/www/my_app'
+# set :scm, :git
+
+# set :format, :pretty
+# set :log_level, :debug
+# set :pty, true
+
+# set :linked_files, %w{config/database.yml}
+# set :linked_dirs, %w{bin log tmp/pids tmp/cache tmp/sockets vendor/bundle public/system}
+
+# set :default_env, { path: "/opt/ruby/bin:$PATH" }
+# set :keep_releases, 5
+
+namespace :deploy do
+
+  desc 'Restart application'
+  task :restart do
+    on roles(:app), in: :sequence, wait: 5 do
+      # Your restart mechanism here, for example:
+      # execute :touch, release_path.join('tmp/restart.txt')
+    end
+  end
+
+  after :restart, :clear_cache do
+    on roles(:web), in: :groups, limit: 3, wait: 10 do
+      # Here we can do anything such as:
+      # within release_path do
+      #   execute :rake, 'cache:clear'
+      # end
+    end
+  end
+
+  after :finishing, 'deploy:cleanup'
+
+end

data/lib/capistrano/templates/stage.rb.erb

@@ -0,0 +1,42 @@
+set :stage, :<%= stage %>
+
+# Simple Role Syntax
+# ==================
+# Supports bulk-adding hosts to roles, the primary
+# server in each group is considered to be the first
+# unless any hosts have the primary property set.
+role :app, %w{deploy@example.com}
+role :web, %w{deploy@example.com}
+role :db,  %w{deploy@example.com}
+
+# Extended Server Syntax
+# ======================
+# This can be used to drop a more detailed server
+# definition into the server list. The second argument
+# something that quacks like a has can be used to set
+# extended properties on the server.
+server 'example.com', user: 'deploy', roles: %w{web app}, my_property: :my_value
+
+# you can set custom ssh options
+# it's possible to pass any option but you need to keep in mind that net/ssh understand limited list of options
+# you can see them in [net/ssh documentation](http://net-ssh.github.io/net-ssh/classes/Net/SSH.html#method-c-start)
+# set it globally
+#  set :ssh_options, {
+#    keys: %w(/home/rlisowski/.ssh/id_rsa),
+#    forward_agent: false,
+#    auth_methods: %w(password)
+#  }
+# and/or per server
+# server 'example.com',
+#   user: 'user_name',
+#   roles: %w{web app},
+#   ssh_options: {
+#     user: 'user_name', # overrides user setting above
+#     keys: %w(/home/user_name/.ssh/id_rsa),
+#     forward_agent: false,
+#     auth_methods: %w(publickey password)
+#     # password: 'please use keys'
+#   }
+# setting per server overrides global ssh_options
+
+# fetch(:default_env).merge!(rails_env: :<%= stage %>)

data/lib/capistrano/version.rb

@@ -1,22 +1,3 @@
 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 = 1
-    TINY  = 0
-
-    STRING = [MAJOR, MINOR, TINY].join(".")
-    
-    SSH_REQUIRED = [1,0,10]
-    SFTP_REQUIRED = [1,1,0]
-  end
+  VERSION = "3.0.0"
 end

data/lib/capistrano/version_validator.rb

@@ -0,0 +1,37 @@
+module Capistrano
+  class VersionValidator
+
+    def initialize(version)
+      @version = version
+    end
+
+    def verify
+      if match?
+        self
+      else
+        fail "Capfile locked at #{version}, but #{current_version} is loaded"
+      end
+    end
+
+    private
+    attr_reader :version
+
+
+    def match?
+      available =~ requested
+    end
+
+    def current_version
+      VERSION
+    end
+
+    def available
+      Gem::Dependency.new('cap', version)
+    end
+
+    def requested
+      Gem::Dependency.new('cap', current_version)
+    end
+
+  end
+end

data/lib/capistrano.rb

@@ -1,2 +0,0 @@
-require 'capistrano/configuration'
-require 'capistrano/extensions'

data/spec/integration/dsl_spec.rb

@@ -0,0 +1,344 @@
+require 'spec_helper'
+
+describe Capistrano::DSL do
+
+  let(:dsl) { Class.new.extend Capistrano::DSL }
+
+  describe 'setting and fetching hosts' do
+    describe 'when defining a host using the `server` syntax' do
+      before do
+        dsl.server 'example1.com', roles: %w{web}, active: true
+        dsl.server 'example2.com', roles: %w{web}
+        dsl.server 'example3.com', roles: %w{app web}, active: true
+        dsl.server 'example4.com', roles: %w{app}, primary: true
+      end
+
+      describe 'fetching all servers' do
+        subject { dsl.roles(:all) }
+
+        it 'returns all servers' do
+          expect(subject.map(&:hostname)).to eq %w{example1.com example2.com example3.com example4.com}
+        end
+      end
+
+      describe 'fetching servers by multiple roles' do
+        it "does not confuse the last role with options" do
+          expect(dsl.roles(:app, :web).count).to eq 4
+          expect(dsl.roles(:app, :web, filter: :active).count).to eq 2
+        end
+      end
+
+      describe 'fetching servers by role' do
+        subject { dsl.roles(:app) }
+
+        it 'returns the servers' do
+          expect(subject.map(&:hostname)).to eq %w{example3.com example4.com}
+        end
+      end
+
+      describe 'fetching filtered servers by role' do
+        subject { dsl.roles(:app, filter: :active) }
+
+        it 'returns the servers' do
+          expect(subject.map(&:hostname)).to eq %w{example3.com}
+        end
+      end
+
+      describe 'fetching selected servers by role' do
+        subject { dsl.roles(:app, select: :active) }
+
+        it 'returns the servers' do
+          expect(subject.map(&:hostname)).to eq %w{example3.com}
+        end
+      end
+
+      describe 'fetching the primary server by role' do
+        context 'when inferring primary status based on order' do
+          subject { dsl.primary(:web) }
+          it 'returns the servers' do
+            expect(subject.hostname).to eq 'example1.com'
+          end
+        end
+
+        context 'when the attribute `primary` is explicity set' do
+          subject { dsl.primary(:app) }
+          it 'returns the servers' do
+            expect(subject.hostname).to eq 'example4.com'
+          end
+        end
+      end
+
+    end
+
+    describe 'when defining hosts using the `role` syntax' do
+      before do
+        dsl.role :web, %w{example1.com example2.com example3.com}
+        dsl.role :web, %w{example1.com}, active: true
+        dsl.role :app, %w{example3.com example4.com}
+        dsl.role :app, %w{example3.com}, active: true
+        dsl.role :app, %w{example4.com}, primary: true
+      end
+
+      describe 'fetching all servers' do
+        subject { dsl.roles(:all) }
+
+        it 'returns all servers' do
+          expect(subject.map(&:hostname)).to eq %w{example1.com example2.com example3.com example4.com}
+        end
+      end
+
+      describe 'fetching servers by role' do
+        subject { dsl.roles(:app) }
+
+        it 'returns the servers' do
+          expect(subject.map(&:hostname)).to eq %w{example3.com example4.com}
+        end
+      end
+
+      describe 'fetching filtered servers by role' do
+        subject { dsl.roles(:app, filter: :active) }
+
+        it 'returns the servers' do
+          expect(subject.map(&:hostname)).to eq %w{example3.com}
+        end
+      end
+
+      describe 'fetching selected servers by role' do
+        subject { dsl.roles(:app, select: :active) }
+
+        it 'returns the servers' do
+          expect(subject.map(&:hostname)).to eq %w{example3.com}
+        end
+      end
+
+      describe 'fetching the primary server by role' do
+        context 'when inferring primary status based on order' do
+          subject { dsl.primary(:web) }
+          it 'returns the servers' do
+            expect(subject.hostname).to eq 'example1.com'
+          end
+        end
+
+        context 'when the attribute `primary` is explicity set' do
+          subject { dsl.primary(:app) }
+          it 'returns the servers' do
+            expect(subject.hostname).to eq 'example4.com'
+          end
+        end
+      end
+
+    end
+
+  end
+
+  describe 'setting and fetching variables' do
+
+    before do
+      dsl.set :scm, :git
+    end
+
+    context 'without a default' do
+      context 'when the variables is defined' do
+        it 'returns the variable' do
+          expect(dsl.fetch(:scm)).to eq :git
+        end
+      end
+
+      context 'when the variables is undefined' do
+        it 'returns nil' do
+          expect(dsl.fetch(:source_control)).to be_nil
+        end
+      end
+    end
+
+    context 'with a default' do
+      context 'when the variables is defined' do
+        it 'returns the variable' do
+          expect(dsl.fetch(:scm, :svn)).to eq :git
+        end
+      end
+
+      context 'when the variables is undefined' do
+        it 'returns the default' do
+          expect(dsl.fetch(:source_control, :svn)).to eq :svn
+        end
+      end
+    end
+
+    context 'with a block' do
+      context 'when the variables is defined' do
+        it 'returns the variable' do
+          expect(dsl.fetch(:scm) { :svn }).to eq :git
+        end
+      end
+
+      context 'when the variables is undefined' do
+        it 'calls the block' do
+          expect(dsl.fetch(:source_control) { :svn }).to eq :svn
+        end
+      end
+    end
+
+  end
+
+  describe 'asking for a variable' do
+    before do
+      dsl.ask(:scm, :svn)
+      $stdout.stubs(:puts)
+    end
+
+    context 'variable is provided' do
+      before do
+        $stdin.expects(:gets).returns('git')
+      end
+
+      it 'sets the input as the variable' do
+        expect(dsl.fetch(:scm)).to eq 'git'
+      end
+    end
+
+    context 'variable is not provided' do
+      before do
+        $stdin.expects(:gets).returns('')
+      end
+
+      it 'sets the variable as the default' do
+        expect(dsl.fetch(:scm)).to eq :svn
+      end
+    end
+  end
+
+  describe 'checking for presence' do
+    subject { dsl.any? :linked_files }
+
+    before do
+      dsl.set(:linked_files, linked_files)
+    end
+
+    context 'variable is an non-empty array' do
+      let(:linked_files) { %w{1} }
+
+      it { should be_true }
+    end
+
+    context 'variable is an empty array' do
+      let(:linked_files) { [] }
+      it { should be_false }
+    end
+
+    context 'variable exists, is not an array' do
+      let(:linked_files) { stub }
+      it { should be_true }
+    end
+
+    context 'variable is nil' do
+      let(:linked_files) { nil }
+      it { should be_false }
+    end
+  end
+
+  describe 'configuration SSHKit' do
+    let(:config) { SSHKit.config }
+    let(:backend) { SSHKit.config.backend.config }
+    let(:default_env) { { rails_env: :production } }
+
+    before do
+      dsl.set(:format, :dot)
+      dsl.set(:log_level, :debug)
+      dsl.set(:default_env, default_env)
+      dsl.set(:pty, true)
+      dsl.set(:connection_timeout, 10)
+      dsl.set(:ssh_options, {
+        keys: %w(/home/user/.ssh/id_rsa),
+        forward_agent: false,
+        auth_methods: %w(publickey password)
+      })
+      dsl.configure_backend
+    end
+
+    it 'sets the output' do
+      expect(config.output).to be_a SSHKit::Formatter::Dot
+    end
+
+    it 'sets the output verbosity' do
+      expect(config.output_verbosity).to eq 0
+    end
+
+    it 'sets the default env' do
+      expect(config.default_env).to eq default_env
+    end
+
+    it 'sets the backend pty' do
+      expect(backend.pty).to be_true
+    end
+
+    it 'sets the backend connection timeout' do
+      expect(backend.connection_timeout).to eq 10
+    end
+
+    it 'sets the backend ssh_options' do
+      expect(backend.ssh_options[:keys]).to eq %w(/home/user/.ssh/id_rsa)
+      expect(backend.ssh_options[:forward_agent]).to eq false
+      expect(backend.ssh_options[:auth_methods]).to eq %w(publickey password)
+    end
+
+  end
+
+  describe 'release path' do
+
+    before do
+      dsl.set(:deploy_to, '/var/www')
+    end
+
+    describe 'fetching release path' do
+      subject { dsl.release_path }
+
+      context 'where no release path has been set' do
+        before do
+          dsl.delete(:release_path)
+        end
+
+        it 'returns the `current_path` value' do
+          expect(subject.to_s).to eq '/var/www/current'
+        end
+      end
+
+      context 'where the release path has been set' do
+        before do
+          dsl.set(:release_path, '/var/www/release_path')
+        end
+
+        it 'returns the set `release_path` value' do
+          expect(subject.to_s).to eq '/var/www/release_path'
+        end
+      end
+    end
+
+    describe 'setting release path' do
+      let(:now) { Time.parse("Oct 21 16:29:00 2015") }
+      subject { dsl.release_path }
+
+      context 'without a timestamp' do
+        before do
+          dsl.env.expects(:timestamp).returns(now)
+          dsl.set_release_path
+        end
+
+        it 'returns the release path with the current env timestamp' do
+          expect(subject.to_s).to eq '/var/www/releases/20151021162900'
+        end
+      end
+
+      context 'with a timestamp' do
+        before do
+          dsl.set_release_path('timestamp')
+        end
+
+        it 'returns the release path with the timestamp' do
+          expect(subject.to_s).to eq '/var/www/releases/timestamp'
+        end
+      end
+    end
+
+  end
+end

data/spec/integration_spec_helper.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+require 'support/test_app'
+require 'support/matchers'
+
+include TestApp
+
+

data/spec/lib/capistrano/application_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Capistrano::Application do
+
+  it "provides a --trace option which enables SSHKit/NetSSH trace output"
+
+  it "provides a --format option which enables the choice of output formatting"
+
+  it "identifies itself as cap and not rake" do
+    pending "Waiting for: https://github.com/jimweirich/rake/pull/204"
+    out, _ = capture_io do
+      flags '--help', '-h'
+    end
+    out.should match(/\bcap [ -f capfile ]\b/)
+  end
+
+  it "overrides the rake method, but still prints the rake version" do
+    out, _ = capture_io do
+      flags '--version', '-V'
+    end
+    out.should match(/\bCapistrano Version\b/)
+    out.should match(/\b#{Capistrano::VERSION}\b/)
+    out.should match(/\bRake Version\b/)
+    out.should match(/\b#{RAKEVERSION}\b/)
+  end
+
+  def flags(*sets)
+    sets.each do |set|
+      ARGV.clear
+      @exit = catch(:system_exit) { command_line(*set) }
+    end
+    yield(subject.options) if block_given?
+  end
+
+  def command_line(*options)
+    options.each { |opt| ARGV << opt }
+    def subject.exit(*args)
+      throw(:system_exit, :exit)
+    end
+    subject.instance_eval do
+      handle_options
+    end
+    subject.options
+  end
+
+  def capture_io
+    require 'stringio'
+
+    orig_stdout, orig_stderr         = $stdout, $stderr
+    captured_stdout, captured_stderr = StringIO.new, StringIO.new
+    $stdout, $stderr                 = captured_stdout, captured_stderr
+
+    yield
+
+    return captured_stdout.string, captured_stderr.string
+  ensure
+    $stdout = orig_stdout
+    $stderr = orig_stderr
+  end
+
+end

data/spec/lib/capistrano/configuration/question_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+module Capistrano
+  class Configuration
+
+    describe Question do
+
+      let(:question) { Question.new(env, key, default) }
+      let(:default) { :default }
+      let(:key) { :branch }
+      let(:env) { stub }
+
+      describe '.new' do
+        it 'takes a key, default' do
+          question
+        end
+      end
+
+      describe '#call' do
+        subject { question.call }
+
+        context 'value is entered' do
+          let(:branch) { 'branch' }
+
+          before do
+            $stdout.expects(:puts).with('Please enter branch: |default|')
+            $stdin.expects(:gets).returns(branch)
+          end
+
+          it 'sets the value' do
+            env.expects(:set).with(key, branch)
+            question.call
+          end
+        end
+
+        context 'value is not entered' do
+          let(:branch) { default }
+
+          before do
+            $stdout.expects(:puts).with('Please enter branch: |default|')
+            $stdin.expects(:gets).returns('')
+          end
+
+          it 'sets the default as the value' do
+            env.expects(:set).with(key, branch)
+            question.call
+          end
+
+        end
+      end
+    end
+
+  end
+end