capistrano-deploy-management 0.1.0

data/.gitignore

@@ -0,0 +1,7 @@
+pkg/*
+*.gem
+.bundle
+.yardoc
+doc
+Gemfile.lock
+vendor/bundle

data/.rspec

@@ -0,0 +1,2 @@
+--backtrace
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3

data/Gemfile

@@ -0,0 +1,7 @@
+source :rubygems
+
+# Specify your gem's dependencies in capistrano-deploy-management.gemspec
+gemspec
+
+gem 'rake'
+gem 'rspec'

data/MIT-LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2012 Sergey Nartimov
+
+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,172 @@
+Capistrano deploy recipes [![TravisCI](https://secure.travis-ci.org/lest/capistrano-deploy-management.png?branch=master)](http://travis-ci.org/lest/capistrano-deploy-management) [![Gemnasium](https://gemnasium.com/lest/capistrano-deploy-management.png)](https://gemnasium.com/lest/capistrano-deploy-management)
+=========================
+
+Fast git-based deploy process inspired by https://github.com/blog/470-deployment-script-spring-cleaning.
+
+Quickstart with Git and Rails
+-----------------------------
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'capistrano-deploy-management', :group => :development, :require => false
+```
+
+Create a file named `Capfile` in your project root directory:
+
+```ruby
+require 'capistrano-deploy-management'
+use_recipes :git, :bundle, :rails
+
+server 'server name or ip address', :web, :app, :db, :primary => true
+set :user, 'user for deploy'
+set :deploy_to, '/deploy/to/path'
+set :repository, 'your git repository'
+
+after 'deploy:update', 'bundle:install'
+```
+
+And then execute:
+
+    bundle
+
+To setup:
+
+    cap deploy:setup
+
+Then when you push some changes to git repository simply run:
+
+    cap deploy
+
+Or if you have migrations (`:rails` recipe should be used in Capfile: `use_recipe :rails`):
+
+    cap deploy:migrations
+
+To look through the changes to be deployed:
+
+    cap deploy:pending
+
+If you want to update to a specific commit (e.g. to rollback):
+
+    cap deploy COMMIT=foobarbaz
+
+Note: it may be required to run `bundle exec cap ...` instead of `cap ...`.
+
+Multistage
+----------
+
+Basic usage:
+
+```ruby
+use_recipe :multistage
+
+set :default_stage, :development
+
+stage :development do
+  ...
+end
+
+stage :production do
+  ...
+end
+```
+
+You can also pass options that allow setting variables and default stage:
+
+```ruby
+stage :development, :branch => :develop, :default => true
+stage :production,  :branch => :master
+```
+
+When branches are specified for stages and git recipe is used
+it will automatically select stage based on current local branch.
+
+Bundle
+------
+
+Use recipe:
+
+```ruby
+use_recipe :bundle
+```
+
+And add callback to run `bundle install` on each deploy:
+
+```ruby
+after 'deploy:update', 'bundle:install'
+```
+
+Rails Assets
+------------
+
+Use recipe:
+
+```ruby
+use_recipe :rails_assets
+```
+
+Add callback to precompile assets after update:
+
+```ruby
+after 'deploy:update', 'deploy:assets:precompile'
+```
+
+Passenger
+---------
+
+Use recipe:
+
+```ruby
+use_recipe :passenger
+```
+
+It will automatically do `touch tmp/restart.txt` on each deploy.
+
+Unicorn
+-------
+
+Use recipe:
+
+```ruby
+use_recipe :unicorn
+```
+
+You can setup callback to reload unicorn after deploy is done:
+
+```ruby
+after 'deploy:restart', 'unicorn:reload'
+```
+
+Puma
+-------
+
+Use recipe:
+
+```ruby
+use_recipe :puma
+```
+
+You can setup callback to reload puma after deploy is done:
+
+```ruby
+after 'deploy:restart', 'puma:reload'
+```
+
+Whenever
+--------
+
+Use recipe:
+
+```ruby
+use_recipe :whenever
+```
+
+To automatically update crontab file:
+
+```ruby
+after 'deploy:restart', 'whenever:update_crontab'
+```
+
+You can also clear crontab file with command:
+
+    cap whenever:clear_crontab

data/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+
+desc 'Run all specs in spec directory'
+RSpec::Core::RakeTask.new
+
+task :default => :spec

data/capistrano-deploy-management.gemspec

@@ -0,0 +1,16 @@
+# -*- encoding: utf-8 -*-
+Gem::Specification.new do |s|
+  s.name        = 'capistrano-deploy-management'
+  s.version     = '0.1.0'
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Dominik Rodler']
+  s.email       = ['dominik.rodler@gmail.com']
+  s.homepage    = 'https://github.com/drdla/capistrano-deploy-management'
+  s.summary     = 'Capistrano deploy recipes'
+
+  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.add_dependency('capistrano', '~> 2.9')
+end

data/lib/capistrano-deploy-management.rb

@@ -0,0 +1,57 @@
+require 'capistrano'
+
+module CapistranoDeployManagement
+  def self.load_into(configuration)
+    configuration.load do
+      @used_recipes = []
+
+      class << self
+        attr_reader :used_recipes
+      end
+
+      def use_recipe(recipe_name)
+        return if @used_recipes.include?(recipe_name.to_sym)
+
+        begin
+          require "capistrano-deploy-management/#{recipe_name}"
+
+          recipe = CapistranoDeployManagement.const_get(recipe_name.to_s.capitalize.gsub(/_(\w)/) { $1.upcase })
+          recipe.load_into(self)
+          @used_recipes << recipe.to_s.split('::').last.downcase.to_sym
+        rescue LoadError
+          abort "Did you misspell `#{recipe_name}` recipe name?"
+        end
+      end
+
+      def use_recipes(*recipes)
+        recipes.each do |recipe|
+          use_recipe(recipe)
+        end
+      end
+
+      def using_recipe?(recipe)
+        used_recipes.include?(recipe.to_sym)
+      end
+
+      namespace :deploy do
+        desc 'Run deploy'
+        task :default do
+          update
+          restart
+        end
+
+        task :update do
+          # nothing
+        end
+
+        task :restart do
+          # nothing
+        end
+      end
+    end
+  end
+end
+
+if Capistrano::Configuration.instance
+  CapistranoDeployManagement.load_into(Capistrano::Configuration.instance)
+end

data/lib/capistrano-deploy-management/bundle.rb

@@ -0,0 +1,21 @@
+module CapistranoDeployManagement
+  module Bundle
+    def self.load_into(configuration)
+      configuration.load do
+        namespace :bundle do
+          desc 'Install gems'
+          task :install, :except => {:no_release => true} do
+            bundle_cmd = fetch(:bundle_cmd, 'bundle')
+            bundle_flags = fetch(:bundle_flags, '--deployment --quiet')
+            bundle_without = [*fetch(:bundle_without, [:development, :test])].compact
+
+            args = [bundle_flags.to_s]
+            args << "--without #{bundle_without.join(' ')}" unless bundle_without.empty?
+
+            run "cd #{current_path} && #{bundle_cmd} install #{args.join(' ')}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/capistrano-deploy-management/bundler.rb

@@ -0,0 +1,2 @@
+require 'capistrano-deploy-management/bundle'
+CapistranoDeployManagement::Bundler = CapistranoDeployManagement::Bundle

data/lib/capistrano-deploy-management/git.rb

@@ -0,0 +1,42 @@
+module CapistranoDeployManagement
+  module Git
+    def self.load_into(configuration)
+      configuration.load do
+        ssh_options[:forward_agent] = true
+
+        set(:application) { repository.slice(/[^\/:]+?(?=\.git$)/) }
+        set(:repository) { abort "Please specify repository, set :repository, 'foo'" }
+        set :branch, 'master'
+        set :enable_submodules, false
+
+        set(:current_revision) { capture("cd #{current_path} && git rev-parse HEAD").chomp }
+
+        set :local_branch do
+          `git symbolic-ref HEAD 2> /dev/null`.strip.sub('refs/heads/', '')
+        end
+
+        namespace :deploy do
+          desc 'Setup'
+          task :setup, :except => {:no_release => true} do
+            run "mkdir -p `dirname #{current_path}` && git clone --no-checkout #{repository} #{deploy_to}"
+            update
+          end
+
+          desc 'Update the deployed code'
+          task :update, :except => {:no_release => true} do
+            commit = ENV['COMMIT'] || "origin/#{branch}"
+            command = ["cd #{current_path}", 'git fetch origin', "git reset --hard #{commit}"]
+            command += ['git submodule init', 'git submodule -q sync', 'git submodule -q update'] if enable_submodules
+            run command.join(' && ')
+          end
+
+          desc 'Show pending commits'
+          task :pending do
+            commit = ENV['COMMIT'] || "origin/#{branch}"
+            system("git log --pretty=medium --stat #{current_revision}..#{commit}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/capistrano-deploy-management/memcached.rb

@@ -0,0 +1,28 @@
+module CapistranoDeployManagement
+  module Memcached
+    def self.load_into(configuration)
+      configuration.load do
+        namespace :deploy do
+          namespace :memcached do
+            desc "Restart the Memcache daemon."
+            task :restart, :roles => :app do
+              deploy.memcached.stop
+              deploy.memcached.start
+            end
+
+            desc "Start the Memcache daemon."
+            task :start, :roles => :app do
+              invoke_command "memcached -P #{current_path}/shared/log/memcached.pid -d", :via => run_method
+            end
+
+            desc "Stop the Memcache daemon."
+            task :stop, :roles => :app do
+              pid_file = "#{current_path}/shared/log/memcached.pid"
+              invoke_command("killall -9 memcached", :via => run_method) if File.exist?(pid_file)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/capistrano-deploy-management/multistage.rb

@@ -0,0 +1,77 @@
+module CapistranoDeployManagement
+  module Multistage
+    def self.load_into(configuration)
+      configuration.load do
+        set :multistage_config, Config.new(configuration)
+
+        def define_stage(*args, &block)
+          warn "[DEPRECATION] `define_stage` is deprecated, use `stage` instead"
+          stage(*args, &block)
+        end
+
+        def stage(name, options={}, &block)
+          set :default_stage, name.to_sym if options.delete(:default)
+          multistage_config.stage(name, options)
+          callbacks[:start].detect { |c| c.source == 'multistage:ensure' }.except << name.to_s
+
+          task(name) do
+            set :current_stage, name.to_s
+            options.each do |k, v|
+              set k, v if v
+            end
+            block.call if block
+          end
+        end
+
+        namespace :multistage do
+          task :ensure do
+            unless exists?(:current_stage)
+              if stage = multistage_config.inferred_stage
+                find_and_execute_task(stage.name)
+              elsif exists?(:default_stage)
+                find_and_execute_task(default_stage)
+              else
+                stage_names = multistage_config.stages.map(&:name)
+                abort "No stage specified. Please specify one of: #{stage_names.join(', ')} (e.g. `cap #{stage_names.first} #{ARGV.last}')"
+              end
+            end
+          end
+        end
+
+        on :start, 'multistage:ensure'
+      end
+    end
+
+    # Handles multistage configuration
+    class Config
+      attr_reader :config
+      attr_reader :stages
+
+      def initialize(config)
+        @config = config
+        @stages = []
+      end
+
+      def stage(name, options={})
+        stages << Stage.new(name, options)
+      end
+
+      def inferred_stage
+        if config.using_recipe?(:git)
+          branch = config.local_branch
+          stages.find { |stage| stage.options[:branch].to_s == branch }
+        end
+      end
+    end
+
+    class Stage
+      attr_reader :name
+      attr_reader :options
+
+      def initialize(name, options={})
+        @name    = name
+        @options = options
+      end
+    end
+  end
+end

data/lib/capistrano-deploy-management/passenger.rb

@@ -0,0 +1,16 @@
+module CapistranoDeployManagement
+  module Passenger
+    def self.load_into(configuration)
+      configuration.load do
+        namespace :passenger do
+          desc 'Restart passenger'
+          task :restart, :roles => :app, :except => {:no_release => true} do
+            run "touch #{current_path}/tmp/restart.txt"
+          end
+        end
+
+        after 'deploy:restart', 'passenger:restart'
+      end
+    end
+  end
+end

data/lib/capistrano-deploy-management/rails.rb

@@ -0,0 +1,31 @@
+module CapistranoDeployManagement
+  module Rails
+    def self.load_into(configuration)
+      configuration.load do
+        set :rake do
+          if using_recipe?(:bundle)
+            'bundle exec rake'
+          else
+            'rake'
+          end
+        end
+
+        set(:rails_env) { 'production' }
+
+        namespace :deploy do
+          desc 'Deploy & migrate'
+          task :migrations do
+            update
+            migrate
+            restart
+          end
+
+          desc 'Run migrations'
+          task :migrate, :roles => :db, :only => {:primary => true} do
+            run "cd #{current_path} && RAILS_ENV=#{rails_env} #{rake} db:migrate"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/capistrano-deploy-management/rails_assets.rb

@@ -0,0 +1,28 @@
+module CapistranoDeployManagement
+  module RailsAssets
+    def self.load_into(configuration)
+      configuration.load do
+        use_recipe :rails
+
+        namespace :deploy do
+          namespace :assets do
+            desc 'Precompile assets.'
+            task :precompile do
+              run "cd #{current_path} && RAILS_ENV=#{rails_env} RAILS_GROUPS=assets #{rake} assets:precompile"
+            end
+
+            desc 'Clean assets.'
+            task :clean do
+              run "cd #{current_path} && RAILS_ENV=#{rails_env} RAILS_GROUPS=assets #{rake} assets:clean"
+            end
+
+            desc 'Clear application cache (e.g. Memcached).'
+            task :refresh_cache, roles: :app do
+              run "cd #{current_path} && rake cache:clear RAILS_ENV=#{rails_env}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/capistrano-deploy-management/rvm.rb

@@ -0,0 +1,27 @@
+module CapistranoDeployManagement
+  module Rvm
+    def self.load_into(configuration)
+      configuration.load do
+        set :rvm_ruby_string, 'default'
+        set :rvm_path, '/usr/local/rvm'
+
+        set(:rvm_shell_path) { "#{rvm_path}/bin/rvm-shell" }
+
+        set :default_shell do
+          shell = rvm_shell_path
+          ruby  = rvm_ruby_string.to_s.strip
+          shell = "rvm_path=#{rvm_path} #{shell} '#{ruby}'" unless ruby.empty?
+
+          shell
+        end
+
+        if File.exists?('.rvmrc')
+          matches = File.read('.rvmrc').scan(/^rvm\s+use\s+.*?([\w\-\.]+@[\w\-]+).*$/)
+          if matches.any?
+            set :rvm_ruby_string, matches.last.first
+          end
+        end
+      end
+    end
+  end
+end

data/lib/capistrano-deploy-management/unicorn.rb

@@ -0,0 +1,27 @@
+module CapistranoDeployManagement
+  module Unicorn
+    def self.load_into(configuration)
+      configuration.load do
+	set(:unicorn_config) { "#{deploy_to}/current/config/unicorn.rb" }
+        set(:unicorn_pidfile) { "#{deploy_to}/shared/pids/unicorn.pid" }
+
+        namespace :unicorn do
+          desc 'Reload unicorn'
+          task :reload, :roles => :app, :except => {:no_release => true} do
+            run "test -s #{unicorn_pidfile} && kill -s USR2 `cat #{unicorn_pidfile}` || echo 'pidfile does not exist'"
+          end
+
+          desc 'Stop unicorn'
+          task :stop, :roles => :app, :except => {:no_release => true} do
+            run "test -s #{unicorn_pidfile} && kill -s QUIT `cat #{unicorn_pidfile}` || echo 'pidfile does not exist'"
+          end
+
+          desc 'Reexecute unicorn'
+          task :reexec, :roles => :app, :except => {:no_release => true} do
+            run "test ! -s #{unicorn_pidfile} && unicorn -c #{unicorn_config} -E production -D || echo 'pidfile already exists'"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/capistrano-deploy-management/whenever.rb

@@ -0,0 +1,35 @@
+module CapistranoDeployManagement
+  module Whenever
+    def self.load_into(configuration)
+      configuration.load do
+        set :whenever_cmd do
+          if using_recipe?(:bundle)
+            'bundle exec whenever'
+          else
+            'whenever'
+          end
+        end
+
+        set :whenever_identifier do
+          if using_recipe?(:multistage)
+            "#{application}_#{current_stage}"
+          else
+            application
+          end
+        end
+
+        namespace :whenever do
+          desc 'Update crontab file'
+          task :update_crontab, :roles => :db, :only => {:primary => true} do
+            run "cd #{current_path} && #{whenever_cmd} --update-crontab #{whenever_identifier}"
+          end
+
+          desc 'Clear crontab file'
+          task :clear_crontab, :roles => :db, :only => {:primary => true} do
+            run "cd #{current_path} && #{whenever_cmd} --clear-crontab #{whenever_identifier}"
+          end
+        end
+      end
+    end
+  end
+end

data/spec/bundle_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe 'bundler' do
+  before do
+    mock_config do
+      use_recipes :bundler
+      set :deploy_to, '/foo/bar'
+    end
+  end
+
+  it 'uses bundler alias for bundle recipe' do
+    config.used_recipes.should == [:bundle]
+  end
+end

data/spec/deploy_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe 'deploy' do
+  before do
+    mock_config do
+      use_recipes :git, :rails
+      set :deploy_to, '/foo/bar'
+    end
+  end
+
+  it 'returns used recipes' do
+    config.used_recipes.should == [:git, :rails]
+  end
+
+  it 'checks if recipe is used' do
+    config.should be_using_recipe(:git)
+    config.should_not be_using_recipe(:bundle)
+  end
+
+  it 'uses recipe once' do
+    config.use_recipe :git
+    config.used_recipes.should == [:git, :rails]
+  end
+
+  it 'aborts when recipe name misspelled' do
+    with_stderr do |output|
+      expect { config.use_recipe(:rvn) }.to raise_error(SystemExit)
+      output.should include('Are you misspelled `rvn` recipe name?')
+    end
+  end
+
+  describe 'deploy' do
+    it 'runs update and restart' do
+      cli_execute 'deploy'
+      config.should have_executed('deploy:update', 'deploy:restart')
+    end
+  end
+end

data/spec/git_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe 'git' do
+  before do
+    mock_config do
+      use_recipe :git
+      set :deploy_to, '/foo/bar'
+    end
+
+    ENV.delete('COMMIT')
+  end
+
+  it 'has branch' do
+    config.branch.should == 'master'
+  end
+
+  context 'with repository' do
+    before do
+      mock_config { set :repository, 'git@example.com/test-app.git' }
+    end
+
+    it 'sets application from repo' do
+      config.application.should == 'test-app'
+    end
+
+    describe 'deploy:setup' do
+      it 'clones repository' do
+        cli_execute 'deploy:setup'
+        config.should have_run('mkdir -p `dirname /foo/bar` && git clone --no-checkout git@example.com/test-app.git /foo/bar')
+      end
+
+      it 'invokes update during setup' do
+        config.namespaces[:deploy].should_receive(:update)
+        cli_execute 'deploy:setup'
+      end
+    end
+
+    describe 'deploy:update' do
+      it 'updates' do
+        cli_execute 'deploy:update'
+        config.should have_run('cd /foo/bar && git fetch origin && git reset --hard origin/master')
+      end
+
+      it 'updates submodules' do
+        mock_config { set :enable_submodules, true }
+        cli_execute 'deploy:update'
+        config.should have_run('cd /foo/bar && git fetch origin && git reset --hard origin/master && git submodule init && git submodule -q sync && git submodule -q update')
+      end
+
+      it 'updates to specific commit' do
+        cli_execute 'deploy:update', 'COMMIT=foobarbaz'
+        config.should have_run('cd /foo/bar && git fetch origin && git reset --hard foobarbaz')
+      end
+    end
+  end
+
+  it 'has current revision' do
+    config.should_receive(:capture).with('cd /foo/bar && git rev-parse HEAD') { "baz\n" }
+    config.current_revision.should == 'baz'
+  end
+
+  it 'shows pending' do
+    config.should_receive(:current_revision) { 'baz' }
+    config.namespaces[:deploy].should_receive(:system).with('git log --pretty=medium --stat baz..origin/master')
+    cli_execute 'deploy:pending'
+  end
+
+  it 'shows pending against specific commit' do
+    config.should_receive(:current_revision) { 'baz' }
+    config.namespaces[:deploy].should_receive(:system).with('git log --pretty=medium --stat baz..foobarbaz')
+    cli_execute 'deploy:pending', 'COMMIT=foobarbaz'
+  end
+
+  it 'sets forward agent' do
+    config.ssh_options[:forward_agent].should == true
+  end
+end

data/spec/multistage_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe 'multistage' do
+  before do
+    mock_config do
+      use_recipes :multistage
+
+      set :default_stage, :development
+      stage(:development, :branch => 'develop') { set :foo, 'bar' }
+      stage(:production,  :branch => 'master')  { set :foo, 'baz' }
+      stage :another_stage, :foo => 'bar'
+
+      task(:example) {}
+    end
+  end
+
+  it 'uses default stage' do
+    cli_execute 'example'
+    config.current_stage.should == 'development'
+    config.foo.should == 'bar'
+  end
+
+  it 'aborts when no stage selected' do
+    with_stderr do |output|
+      config.unset :default_stage
+      expect { cli_execute 'example' }.to raise_error(SystemExit)
+      output.should include('No stage specified. Please specify one of: development, production')
+    end
+  end
+
+  it 'uses specified stage' do
+    cli_execute %w[production example]
+    config.current_stage.should == 'production'
+    config.foo.should == 'baz'
+  end
+
+  it 'sets variables from options' do
+    cli_execute 'another_stage'
+    config.foo.should == 'bar'
+  end
+
+  it 'accepts default option' do
+    mock_config { stage :to_be_default, :default => true }
+    config.default_stage.should == :to_be_default
+  end
+
+  context 'with git' do
+    before do
+      mock_config { use_recipe :git }
+    end
+
+    it 'infers stage using local branch' do
+      config.stub(:local_branch) { 'master' }
+      cli_execute 'example'
+      config.current_stage.should == 'production'
+      config.branch.should == 'master'
+    end
+
+    it 'uses default state when local branch not matches' do
+      config.stub(:local_branch) { 'foo' }
+      cli_execute 'example'
+      config.current_stage.should == 'development'
+      config.branch.should == 'develop'
+    end
+  end
+end

data/spec/passenger_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe 'passenger' do
+  before do
+    mock_config do
+      use_recipe :passenger
+      set :deploy_to, '/foo/bar'
+    end
+  end
+
+  describe 'passenger:restart' do
+    it 'touches tmp/restart.txt' do
+      cli_execute 'passenger:restart'
+      config.should have_run('touch /foo/bar/tmp/restart.txt')
+    end
+
+    it 'is executed after deploy:restart' do
+      cli_execute 'deploy:restart'
+      config.should have_executed('deploy:restart', 'passenger:restart')
+    end
+  end
+end

data/spec/rails_assets_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe 'rails assets' do
+  before do
+    mock_config do
+      use_recipe :rails_assets
+      set :deploy_to, '/foo/bar'
+    end
+  end
+
+  it 'uses rails recipe' do
+    config.should be_using_recipe(:rails)
+  end
+
+  describe 'deploy:assets:precompile' do
+    it 'runs precompile' do
+      cli_execute 'deploy:assets:precompile'
+      config.should have_run('cd /foo/bar && RAILS_ENV=production RAILS_GROUPS=assets rake assets:precompile')
+    end
+
+    it 'uses bundle command' do
+      mock_config { use_recipe :bundle }
+      cli_execute 'deploy:assets:precompile'
+      config.should have_run('cd /foo/bar && RAILS_ENV=production RAILS_GROUPS=assets bundle exec rake assets:precompile')
+    end
+  end
+
+  describe 'deploy:assets:clean' do
+    it 'runs clean' do
+      cli_execute 'deploy:assets:clean'
+      config.should have_run('cd /foo/bar && RAILS_ENV=production RAILS_GROUPS=assets rake assets:clean')
+    end
+  end
+end

data/spec/rails_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe 'rails' do
+  before do
+    mock_config do
+      use_recipe :rails
+      set :deploy_to, '/foo/bar'
+    end
+  end
+
+  describe 'deploy:migrate' do
+    it 'runs rake db:migrate' do
+      cli_execute 'deploy:migrate'
+      config.should have_run('cd /foo/bar && RAILS_ENV=production rake db:migrate')
+    end
+
+    it 'runs bundle exec db:migrate when using with bundle' do
+      mock_config { use_recipe :bundle }
+      cli_execute 'deploy:migrate'
+      config.should have_run('cd /foo/bar && RAILS_ENV=production bundle exec rake db:migrate')
+    end
+  end
+
+  describe 'deploy:migrations' do
+    it 'runs update, migrate and restart' do
+      cli_execute 'deploy:migrations'
+      config.should have_executed('deploy:update', 'deploy:migrate', 'deploy:restart')
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,102 @@
+require 'capistrano-deploy-management'
+require 'capistrano/cli'
+
+module CapistranoDeployManagement
+  module Spec
+    module ConfigurationExtension
+      def run(cmd, options={}, &block)
+        runned_commands[cmd] = {:options => options, :block => block}
+      end
+
+      def execute_task(task)
+        executed_tasks << task.fully_qualified_name
+        super
+      end
+
+      def runned_commands
+        @runned_commands ||= {}
+      end
+
+      def executed_tasks
+        @executed_tasks ||= []
+      end
+    end
+
+    module Helper
+      def mock_config(new_instance = false, &block)
+        if !@config || new_instance
+          @config = Capistrano::Configuration.new(:output => StringIO.new)
+          @config.extend(CapistranoDeployManagement::Spec::ConfigurationExtension)
+          CapistranoDeployManagement.load_into(@config)
+        end
+
+        @config.instance_eval(&block)
+      end
+
+      def config
+        @config
+      end
+
+      def cli_execute(*args)
+        config = @config
+        cli = Capistrano::CLI.parse(args.flatten)
+        cli.instance_eval do
+          (class << self; self end).send(:define_method, :instantiate_configuration) do |options|
+            config
+          end
+        end
+
+        cli.execute!
+      end
+
+      def with_stderr
+        original, $stderr = $stderr, StringIO.new
+        output = Object.new
+        class << output
+          instance_methods.each { |m| undef_method m unless m =~ /^__|^object_id$|^instance_eval$/ }
+        end
+        def output.method_missing(*args, &block)
+          ($stderr.rewind && $stderr.read).__send__(*args, &block)
+        end
+
+        yield output
+      ensure
+        $stderr = original
+      end
+    end
+
+    module Matchers
+      extend RSpec::Matchers::DSL
+
+      define :have_run do |cmd|
+        match do |configuration|
+          configuration.runned_commands[cmd]
+        end
+
+        failure_message_for_should do |configuration|
+          "expected configuration to run #{cmd}, but it wasn't found in #{configuration.runned_commands.keys}"
+        end
+      end
+
+      define :have_executed do |*tasks|
+        match do |configuration|
+          expected = tasks.dup
+          configuration.executed_tasks.each do |actual|
+            expected.shift if actual == expected.first
+          end
+
+          expected.empty?
+        end
+
+        failure_message_for_should do |configuration|
+          "expected configuration to execute #{tasks}, but it executed #{configuration.executed_tasks.keys}"
+        end
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include CapistranoDeployManagement::Spec::Helper
+  config.include CapistranoDeployManagement::Spec::Matchers
+end

data/spec/unicorn_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe 'unicorn' do
+  before do
+    mock_config { use_recipes :unicorn }
+  end
+
+  it 'has default unicorn pid' do
+    mock_config { set :deploy_to, '/foo/bar' }
+    config.unicorn_pid.should == '`cat /foo/bar/tmp/pids/unicorn.pid`'
+  end
+
+  context 'signals' do
+    before do
+      mock_config { set :unicorn_pid, '/foo.pid' }
+    end
+
+    it 'sends HUP' do
+      cli_execute 'unicorn:reload'
+      config.should have_run('kill -HUP /foo.pid')
+    end
+
+    it 'sends QUIT' do
+      cli_execute 'unicorn:stop'
+      config.should have_run('kill -QUIT /foo.pid')
+    end
+
+    it 'sends USR2' do
+      cli_execute 'unicorn:reexec'
+      config.should have_run('kill -USR2 /foo.pid')
+    end
+  end
+end

data/spec/whenever_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe 'whenever' do
+  before do
+    mock_config { use_recipe :whenever}
+  end
+
+  describe 'whenever_identifier' do
+    before do
+      mock_config { set :application, 'foo' }
+    end
+
+    it 'defaults to application' do
+      config.whenever_identifier.should == 'foo'
+    end
+
+    it 'default to application with stage when using multistage' do
+      mock_config do
+        use_recipe :multistage
+        set :current_stage, 'bar'
+      end
+      config.whenever_identifier.should == 'foo_bar'
+    end
+  end
+
+  describe 'whenever_cmd' do
+    it 'has default value' do
+      config.whenever_cmd.should == 'whenever'
+    end
+
+    it 'respects bundle recipe' do
+      mock_config { use_recipe :bundle }
+      config.whenever_cmd.should == 'bundle exec whenever'
+    end
+  end
+
+  describe 'whenever:update_crontab' do
+    it 'runs command' do
+      mock_config do
+        set :deploy_to, '/foo/bar'
+        set :whenever_cmd, 'wc'
+        set :whenever_identifier, 'wi'
+      end
+      cli_execute 'whenever:update_crontab'
+      config.should have_run('cd /foo/bar && wc --update-crontab wi')
+    end
+  end
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: capistrano-deploy-management
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Dominik Rodler
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: capistrano
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.9'
+description: 
+email:
+- dominik.rodler@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .DS_Store
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- MIT-LICENSE
+- README.md
+- Rakefile
+- capistrano-deploy-management.gemspec
+- lib/.DS_Store
+- lib/capistrano-deploy-management.rb
+- lib/capistrano-deploy-management/bundle.rb
+- lib/capistrano-deploy-management/bundler.rb
+- lib/capistrano-deploy-management/git.rb
+- lib/capistrano-deploy-management/memcached.rb
+- lib/capistrano-deploy-management/multistage.rb
+- lib/capistrano-deploy-management/passenger.rb
+- lib/capistrano-deploy-management/rails.rb
+- lib/capistrano-deploy-management/rails_assets.rb
+- lib/capistrano-deploy-management/rvm.rb
+- lib/capistrano-deploy-management/unicorn.rb
+- lib/capistrano-deploy-management/whenever.rb
+- spec/.DS_Store
+- spec/bundle_spec.rb
+- spec/deploy_spec.rb
+- spec/git_spec.rb
+- spec/multistage_spec.rb
+- spec/passenger_spec.rb
+- spec/rails_assets_spec.rb
+- spec/rails_spec.rb
+- spec/spec_helper.rb
+- spec/unicorn_spec.rb
+- spec/whenever_spec.rb
+homepage: https://github.com/drdla/capistrano-deploy-management
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Capistrano deploy recipes
+test_files:
+- spec/bundle_spec.rb
+- spec/deploy_spec.rb
+- spec/git_spec.rb
+- spec/multistage_spec.rb
+- spec/passenger_spec.rb
+- spec/rails_assets_spec.rb
+- spec/rails_spec.rb
+- spec/spec_helper.rb
+- spec/unicorn_spec.rb
+- spec/whenever_spec.rb