capistrano 3.0.0.pre14 → 3.0.0

data/lib/capistrano/tasks/hg.rake

@@ -0,0 +1,39 @@
+namespace :hg do
+  desc 'Check that the repo is reachable'
+  task :check do
+    on roles :all do
+      execute "hg", "id", repo_url
+    end
+  end
+
+  desc 'Clone the repo to the cache'
+  task :clone do
+    on roles :all do
+      if test " [ -d #{repo_path}/.hg ] "
+        info t(:mirror_exists, at: repo_path)
+      else
+        within deploy_path do
+          execute "hg", "clone", "--noupdate", repo_url, repo_path
+        end
+      end
+    end
+  end
+
+  desc 'Pull changes from the remote repo'
+  task :update => :'hg:clone' do
+    on roles :all do
+      within repo_path do
+        execute "hg", "pull"
+      end
+    end
+  end
+
+  desc 'Copy repo to releases'
+  task :create_release => :'hg:update' do
+    on roles :all do
+      within repo_path do
+        execute "hg", "archive", release_path, "--rev", fetch(:branch)
+      end
+    end
+  end
+end

data/lib/capistrano/templates/Capfile

@@ -10,38 +10,17 @@ require 'capistrano/deploy'
 #
 #   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 }
-
-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 latest_release_path do
-      #   execute :rake, 'cache:clear'
-      # end
-    end
-  end
-
-  after :finishing, 'deploy:cleanup'
-
-end

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

@@ -15,3 +15,26 @@ set :repo_url, 'git@example.com:me/my_repo.git'
 
 # 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

@@ -39,4 +39,4 @@ server 'example.com', user: 'deploy', roles: %w{web app}, my_property: :my_value
 #   }
 # setting per server overrides global ssh_options
 
-# fetch(:default_env).merge!(:rails_env, :<%= stage %>)
+# fetch(:default_env).merge!(rails_env: :<%= stage %>)

data/lib/capistrano/version.rb

@@ -1,3 +1,3 @@
 module Capistrano
-  VERSION = "3.0.0.pre14"
+  VERSION = "3.0.0"
 end

data/spec/integration/dsl_spec.rb

@@ -165,6 +165,20 @@ describe Capistrano::DSL do
       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
@@ -270,4 +284,61 @@ describe Capistrano::DSL do
 
   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/lib/capistrano/configuration/server_spec.rb

@@ -134,6 +134,75 @@ module Capistrano
         end
       end
 
+      describe '#include?' do
+        let(:options) { {} }
+
+        subject { server.select?(options) }
+
+        before do
+          server.properties.active = true
+        end
+
+        context 'options are empty' do
+          it { should be_true }
+        end
+
+        context 'value is a symbol' do
+          context 'value matches server property' do
+
+            context 'with :filter' do
+              let(:options) { { filter: :active }}
+              it { should be_true }
+            end
+
+            context 'with :select' do
+              let(:options) { { select: :active }}
+              it { should be_true }
+            end
+          end
+
+          context 'value does not match server properly' do
+            context 'with :filter' do
+              let(:options) { { filter: :inactive }}
+              it { should be_false }
+            end
+
+            context 'with :select' do
+              let(:options) { { select: :inactive }}
+              it { should be_false }
+            end
+          end
+        end
+
+        context 'value is a proc' do
+          context 'value matches server property' do
+
+            context 'with :filter' do
+              let(:options) { { filter: ->(s) { s.properties.active } } }
+              it { should be_true }
+            end
+
+            context 'with :select' do
+              let(:options) { { select: ->(s) { s.properties.active } } }
+              it { should be_true }
+            end
+          end
+
+          context 'value does not match server properly' do
+            context 'with :filter' do
+              let(:options) { { filter: ->(s) { s.properties.inactive } } }
+              it { should be_false }
+            end
+
+            context 'with :select' do
+              let(:options) { { select: ->(s) { s.properties.inactive } } }
+              it { should be_false }
+            end
+          end
+        end
+
+      end
+
       describe 'assign ssh_options' do
         let(:server) { Server.new('user_name@hostname') }
 

data/spec/lib/capistrano/configuration/servers/role_filter_spec.rb

@@ -0,0 +1,140 @@
+require 'spec_helper'
+
+module Capistrano
+  class Configuration
+    class Servers
+
+      describe RoleFilter do
+        let(:role_filter) { RoleFilter.new(required, available) }
+        let(:required) { [] }
+        let(:available) { [:web, :app, :db] }
+
+        describe '#new' do
+          it 'takes two arrays of role names' do
+            expect(role_filter)
+          end
+        end
+
+        describe '.for' do
+
+          subject { RoleFilter.for(required, available) }
+
+          context 'without env vars' do
+            context ':all required' do
+              let(:required) { [:all] }
+
+              it 'returns all available names' do
+                expect(subject).to eq available
+              end
+            end
+
+            context 'role names required' do
+              let(:required) { [:web, :app] }
+              it 'returns all required names' do
+                expect(subject).to eq required
+              end
+            end
+          end
+
+          context 'with ENV vars' do
+            before do
+              ENV.stubs(:[]).with('ROLES').returns('app,web')
+            end
+
+            context ':all required' do
+              let(:required) { [:all] }
+
+              it 'returns available names defined in ROLES' do
+                expect(subject).to eq [:app, :web]
+              end
+            end
+
+            context 'role names required' do
+              let(:required) { [:web, :db] }
+              it 'returns all required names defined in ROLES' do
+                expect(subject).to eq [:web]
+              end
+            end
+          end
+
+          context 'with configuration filters' do
+            before do
+              Configuration.env.set(:filter, roles: %w{app web})
+            end
+
+            context ':all required' do
+              let(:required) { [:all] }
+
+              it 'returns available names defined in the filter' do
+                expect(subject).to eq [:app, :web]
+              end
+            end
+
+            context 'role names required' do
+              let(:required) { [:web, :db] }
+              it 'returns all required names defined in the filter' do
+                expect(subject).to eq [:web]
+              end
+            end
+
+            after do
+              Configuration.env.delete(:filter)
+            end
+          end
+
+          context 'with a single configuration filter' do
+            before do
+              Configuration.env.set(:filter, roles: 'web')
+            end
+
+            context ':all required' do
+              let(:required) { [:all] }
+
+              it 'returns available names defined in the filter' do
+                expect(subject).to eq [:web]
+              end
+            end
+
+            context 'role names required' do
+              let(:required) { [:web, :db] }
+              it 'returns all required names defined in the filter' do
+                expect(subject).to eq [:web]
+              end
+            end
+
+            after do
+              Configuration.env.delete(:filter)
+            end
+          end
+
+          context 'with configuration filters and ENV vars' do
+            before do
+              Configuration.env.set(:filter, roles: %w{app})
+              ENV.stubs(:[]).with('ROLES').returns('web')
+            end
+
+            context ':all required' do
+              let(:required) { [:all] }
+
+              it 'returns available names defined in the filter' do
+                expect(subject).to eq [:web, :app]
+              end
+            end
+
+            context 'role names required' do
+              let(:required) { [:web, :db] }
+              it 'returns all required names defined in the filter' do
+                expect(subject).to eq [:web]
+              end
+            end
+
+            after do
+              Configuration.env.delete(:filter)
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

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

@@ -108,16 +108,15 @@ module Capistrano
 
       end
 
-      describe '#roles' do
+      describe 'selecting roles' do
 
         before do
           servers.add_host('1', roles: :app, active: true)
           servers.add_host('2', roles: :app)
         end
 
-        it 'raises if the filter would remove all matching hosts' do
-          I18n.expects(:t)
-          expect { servers.roles_for([:app, select: :inactive]) }.to raise_error
+        it 'is empty if the filter would remove all matching hosts' do
+          expect(servers.roles_for([:app, select: :inactive])).to be_empty
         end
 
         it 'can filter hosts by properties on the host object using symbol as shorthand' do
@@ -129,19 +128,57 @@ module Capistrano
         end
 
         it 'can filter hosts by properties on the host using a regular proc' do
-          expect(servers.roles_for([:app, filter: lambda { |h| h.properties.active }]).length).to eq 1
+          expect(servers.roles_for([:app, filter: ->(h) { h.properties.active }]).length).to eq 1
         end
 
         it 'can select hosts by properties on the host using a regular proc' do
-          expect(servers.roles_for([:app, select: lambda { |h| h.properties.active }]).length).to eq 1
+          expect(servers.roles_for([:app, select: ->(h) { h.properties.active }]).length).to eq 1
         end
 
-        it 'raises if the regular proc filter would remove all matching hosts' do
-          I18n.expects(:t)
-          expect { servers.roles_for([:app, select: lambda { |h| h.properties.inactive }])}.to raise_error
+        it 'is empty if the regular proc filter would remove all matching hosts' do
+          expect(servers.roles_for([:app, select: ->(h) { h.properties.inactive }])).to be_empty
         end
 
       end
+
+      describe 'filtering roles' do
+
+        before do
+          ENV.stubs(:[]).with('ROLES').returns('web,db')
+          servers.add_host('1', roles: :app, active: true)
+          servers.add_host('2', roles: :app)
+          servers.add_host('3', roles: :web)
+          servers.add_host('4', roles: :web)
+          servers.add_host('5', roles: :db)
+        end
+
+        subject { servers.roles_for(roles).map(&:hostname) }
+
+        context 'when selecting all roles' do
+          let(:roles) { [:all] }
+
+          it 'returns the roles specified by ROLE' do
+            expect(subject).to eq %w{3 4 5}
+          end
+        end
+
+        context 'when selecting roles included in ROLE' do
+          let(:roles) { [:app, :web] }
+
+          it 'returns only roles that match ROLE' do
+            expect(subject).to eq %w{3 4}
+          end
+        end
+
+        context 'when selecting roles not included in ROLE' do
+          let(:roles) { [:app] }
+
+          it 'is empty' do
+            expect(subject).to be_empty
+          end
+        end
+      end
+
     end
   end
 end