recap 0.1.0 → 0.2.0

data/lib/recap/environment.rb

@@ -0,0 +1,54 @@
+class Recap::Environment
+  def initialize(variables = {})
+    @variables = variables
+  end
+
+  def get(name)
+    @variables[name]
+  end
+
+  def set(name, value)
+    if value.nil? || value.empty?
+      @variables.delete(name)
+    else
+      @variables[name] = value
+    end
+  end
+
+  def set_string(string)
+    if string =~ /\A([A-Za-z0-9_]+)=(.*)\z/
+      set $1, $2
+    end
+  end
+
+  def empty?
+    @variables.empty?
+  end
+
+  def merge(hash)
+    hash.each {|k, v| set(k, v)}
+  end
+
+  def each(&block)
+    @variables.sort.each(&block)
+  end
+
+  def include?(key)
+    @variables.include?(key)
+  end
+
+  def to_s
+    @variables.keys.sort.map do |key|
+      key + "=" + @variables[key] + "\n" if @variables[key]
+    end.compact.join
+  end
+
+  class << self
+    def from_string(string)
+      string.split("\n").inject(new) do |env, line|
+        env.set_string(line)
+        env
+      end
+    end
+  end
+end

data/lib/recap/foreman.rb

@@ -1,39 +1,58 @@
-Capistrano::Configuration.instance(:must_exist).load do
+module Recap::Foreman
+  extend Recap::Namespace
+
   namespace :foreman do
-    set(:procfile) {"#{deploy_to}/Procfile"}
+    # Processes are delcared in a `Procfile`, by default in the root of the application directory
+    set(:procfile) { "#{deploy_to}/Procfile" }
+
+    # Foreman startup scripts are exported in `upstart` format by default
     set(:foreman_export_format, "upstart")
+
+    # Scripts are exported (as the the application user) to a temporary location first
+    set(:foreman_tmp_location) { "#{deploy_to}/tmp/foreman" }
+
+    # After exports, the scripts are moved to their final location, usually `/etc/init`
     set(:foreman_export_location, "/etc/init")
 
+    # The standard foreman export
+    set(:foreman_export_command) { "./bin/foreman export #{foreman_export_format} #{foreman_tmp_location} --procfile #{procfile} --app #{application} --user #{application_user} --log #{deploy_to}/log" }
+
     namespace :export do
+      # After each deployment, the startup scripts are exported if the `Procfile` has changed
       task :if_changed do
         if deployed_file_changed?(procfile)
           top.foreman.export.default
         end
       end
 
-      task :default, :roles => :app do
+      # To export the scripts, they are first generated in a temporary location, then copied to their final
+      # destination.  This is done because the foreman export command needs to be run as the application user,
+      # while sudo is required to write to `/etc/init`.
+      task :default do
         if deployed_file_exists?(procfile)
-          tmp = "#{deploy_to}/tmp/foreman"
-          as_app "./bin/foreman export #{foreman_export_format} #{tmp} --procfile #{procfile} --app #{application} --user #{application_user} --log #{deploy_to}/log"
+          as_app foreman_export_command
           sudo "rm -f #{foreman_export_location}/#{application}*"
-          sudo "cp #{tmp}/* #{foreman_export_location}"
+          sudo "cp #{foreman_tmp_location}/* #{foreman_export_location}"
         end
       end
     end
 
-    task :start, :roles => :app do
+    # Starts all processes that form the application
+    task :start do
       if deployed_file_exists?(procfile)
         sudo "start #{application}"
       end
     end
 
-    task :restart, :roles => :app do
+    # Restarts all processes that form the application
+    task :restart do
       if deployed_file_exists?(procfile)
         sudo "restart #{application} || sudo start #{application}"
       end
     end
 
-    task :stop, :roles => :app do
+    # Stops all processes that form the application
+    task :stop do
       if deployed_file_exists?(procfile)
         sudo "stop #{application}"
       end

data/lib/recap/namespace.rb

@@ -0,0 +1,37 @@
+require 'capistrano'
+require 'recap/capistrano_extensions'
+
+module Recap::Namespace
+  def self.default_config
+    @default_config
+  end
+
+  def self.default_config=(config)
+    @default_config = config
+  end
+
+  if Capistrano::Configuration.instance
+    self.default_config = Capistrano::Configuration.instance(:must_exist)
+  end
+
+  def capistrano_definitions
+    @capistrano_definitions ||= []
+  end
+
+  def namespace(name, &block)
+    capistrano_definitions << Proc.new do
+      namespace name do
+        instance_eval(&block)
+      end
+    end
+
+    load_into(Recap::Namespace.default_config) if Recap::Namespace.default_config
+  end
+
+  def load_into(configuration)
+    configuration.extend(self)
+    capistrano_definitions.each do |definition|
+      configuration.load(&definition)
+    end
+  end
+end

data/lib/recap/preflight.rb

@@ -17,17 +17,19 @@
 # This preflight recipe checks each of these things in turn, and attempts to give helpful advice
 # should a check fail.
 
-Capistrano::Configuration.instance(:must_exist).load do
-  # The preflight check is pretty quick, so run it before every `deploy:setup` and `deploy`
-  before 'deploy:setup', 'preflight:check'
-  before 'deploy', 'preflight:check'
-
-  set(:remote_username) { capture('whoami').strip }
+module Recap::Preflight
+  extend Recap::Namespace
 
   namespace :preflight do
+    # The preflight check is pretty quick, so run it before every `deploy:setup` and `deploy`
+    before 'deploy:setup', 'preflight:check'
+    before 'deploy', 'preflight:check'
+
+    set(:remote_username) { capture('whoami').strip }
+
     task :check do
       # First check the `application_user` exists
-      if capture("id #{application_user} > /dev/null 2>&1; echo $?").strip != "0"
+      if exit_code("id #{application_user}").strip != "0"
         abort %{
 The application user '#{application_user}' doesn't exist.  You can create this user by logging into the server and running:
 
@@ -36,7 +38,7 @@ The application user '#{application_user}' doesn't exist.  You can create this u
       end
 
       # Then the `application_group`
-      if capture("id -g #{application_group} > /dev/null 2>&1; echo $?").strip != "0"
+      if exit_code("id -g #{application_group}") != "0"
         abort %{
 The application group '#{application_group}' doesn't exist.  You can create this group by logging into the server and running:
 

data/lib/recap/rails.rb

@@ -1,6 +1,8 @@
 require 'recap/deploy'
 
-Capistrano::Configuration.instance(:must_exist).load do
+module Recap::Rails
+  extend Recap::Namespace
+
   namespace :rails do
     namespace :db do
       task :load_schema do
@@ -15,8 +17,8 @@ Capistrano::Configuration.instance(:must_exist).load do
         end
       end
     end
-  end
 
-  after "deploy:clone_code", "rails:db:load_schema"
-  after "deploy:update_code", "rails:db:migrate"
+    after "deploy:clone_code", "rails:db:load_schema"
+    after "deploy:update_code", "rails:db:migrate"
+  end
 end

data/lib/recap/ruby.rb

@@ -0,0 +1,3 @@
+require 'recap/deploy'
+require 'recap/bundler'
+require 'recap/foreman'

data/lib/recap/static.rb

@@ -0,0 +1 @@
+require 'recap/deploy'

data/lib/recap/version.rb

@@ -1,3 +1,3 @@
 module Recap
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/recap.rb

@@ -0,0 +1,12 @@
+module Recap
+  autoload :Namespace, 'recap/namespace'
+
+  autoload :Bootstrap, 'recap/bootstrap'
+  autoload :Bundler, 'recap/bundler'
+  autoload :Compatibility, 'recap/compatibility'
+  autoload :Deploy, 'recap/deploy'
+  autoload :Env, 'recap/env'
+  autoload :Environment, 'recap/environment'
+  autoload :Foreman, 'recap/foreman'
+  autoload :Rails, 'recap/rails'
+end

data/recap.gemspec

@@ -7,19 +7,23 @@ Gem::Specification.new do |s|
   s.version     = Recap::VERSION
   s.authors     = ["Tom Ward"]
   s.email       = ["tom@popdog.net"]
-  s.homepage    = "https://github.com/freerange/recap"
+  s.homepage    = "http://code.gofreerange.com/recap"
   s.summary     = %q{GIT based deployment recipes for Capistrano}
   s.description = %q{GIT based deployment recipes for Capistrano}
 
-  s.rubyforge_project = "recap"
-
   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.add_dependency('capistrano', '~>2.6.0')
+  s.add_dependency('capistrano', '~>2.9.0')
   s.add_dependency('thor')
   s.add_development_dependency('rake', '~>0.9.2')
   s.add_development_dependency('rocco', '~>0.8.1')
+  s.add_development_dependency('rspec', '~>2.7.0')
+  s.add_development_dependency('mocha', '~>0.10.0')
+  s.add_development_dependency('vagrant', '~>0.9.7')
+  s.add_development_dependency('sahara', '~>0.0.10')
+  s.add_development_dependency('cucumber', '~>1.1.4')
+  s.add_development_dependency('faker', '~>1.0.1')
 end

data/spec/models/environment_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+
+describe Recap::Environment do
+  describe '#empty?' do
+    it 'returns true if no variables set' do
+      Recap::Environment.new.empty?.should be_true
+    end
+
+    it 'returns false if no variables set' do
+      Recap::Environment.new('FIRST' => 'One').empty?.should be_false
+    end
+  end
+
+  describe '#include?(key)' do
+    it 'returns true if variables set' do
+      Recap::Environment.new('FIRST' => 'One').include?('FIRST').should be_true
+    end
+
+    it 'returns false if variable has not been set' do
+      Recap::Environment.new('DIFFERENT' => 'One').include?('FIRST').should be_false
+    end
+  end
+
+  describe '#get(name)' do
+    subject do
+      Recap::Environment.new('FIRST' => 'One')
+    end
+
+    it 'returns value if variable set' do
+      subject.get('FIRST').should eql('One')
+    end
+
+    it 'returns nil if variable not set' do
+      subject.get('MISSING').should be_nil
+    end
+  end
+
+  describe '#set(name, value)' do
+    subject do
+      Recap::Environment.new('FIRST' => 'One')
+    end
+
+    it 'sets variable value' do
+      subject.set('SECOND', 'Two')
+      subject.get('SECOND').should eql('Two')
+    end
+
+    it 'unsets variable if value is nil' do
+      subject.set('FIRST', nil)
+      subject.get('FIRST').should be_nil
+      subject.include?('FIRST').should be_false
+    end
+
+    it 'unsets variable if value is empty' do
+      subject.set('FIRST', '')
+      subject.get('FIRST').should be_nil
+      subject.include?('FIRST').should be_false
+    end
+  end
+
+  describe '#each' do
+    subject do
+      Recap::Environment.new('FIRST' => 'One', 'SECOND' => 'Two', 'THIRD' => 'Three', 'FOURTH' => 'Four')
+    end
+
+    it 'yields each variable and value in turn (ordered alphabetically)' do
+      result = []
+      subject.each do |k, v|
+        result << [k, v]
+      end
+      result.should eql([['FIRST', 'One'], ['FOURTH', 'Four'], ['SECOND', 'Two'], ['THIRD', 'Three']])
+    end
+  end
+
+  describe '#merge(variables)' do
+    subject do
+      Recap::Environment.new('FIRST' => 'One')
+    end
+
+    it 'sets each variable value' do
+      subject.merge('SECOND' => 'Two', 'THIRD' => 'Three')
+      subject.get('SECOND').should eql('Two')
+      subject.get('THIRD').should eql('Three')
+    end
+
+    it 'preserves existing values if not provided' do
+      subject.merge('ANYTHING' => 'Goes')
+      subject.get('FIRST').should eql('One')
+    end
+
+    it 'overides existing values if provided' do
+      subject.merge('FIRST' => 'Un')
+      subject.get('FIRST').should eql('Un')
+    end
+  end
+
+  describe '#to_s' do
+    subject do
+      Recap::Environment.new('FIRST' => 'One', 'SECOND' => 'Two', 'THIRD' => nil, 'FOURTH' => 'Four').to_s
+    end
+
+    it 'declares each variable on its own line' do
+      subject.match(/^FIRST=One\n/).should_not be_nil
+      subject.match(/^SECOND=Two\n/).should_not be_nil
+      subject.match(/^FOURTH=Four\n/).should_not be_nil
+    end
+
+    it 'ignores nil variable values' do
+      subject.match(/THIRD/).should be_nil
+    end
+
+    it 'orders variables alphabetically' do
+      indexes = ['FIRST', 'FOURTH', 'SECOND'].map {|k| subject.index(k)}
+      indexes.sort.should eql(indexes)
+    end
+  end
+
+  describe '.from_string(declarations)' do
+    it 'builds instance using string representation' do
+      instance = Recap::Environment.from_string("FIRST=One\nSECOND=Two\n")
+      instance.get('FIRST').should eql('One')
+      instance.get('SECOND').should eql('Two')
+    end
+
+    it 'handles variables with numbers and underscores in their names' do
+      instance = Recap::Environment.from_string("THIS_1=One\nThose_2=Two\n")
+      instance.get('THIS_1').should eql('One')
+      instance.get('Those_2').should eql('Two')
+    end
+
+    it 'gracefully ignores missing newline at end of string' do
+      instance = Recap::Environment.from_string("FIRST=One\nSECOND=Two")
+      instance.get('FIRST').should eql('One')
+      instance.get('SECOND').should eql('Two')
+    end
+
+    it 'acts as the inverse of #to_s' do
+      string = "FIRST=One\nSECOND=Two\nTHIRD=three\n"
+      excercised = Recap::Environment.from_string(Recap::Environment.from_string(string).to_s).to_s
+      excercised.should eql(string)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'recap'
+
+Recap::Namespace.default_config = nil
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+end

data/spec/tasks/bootstrap_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'recap/bootstrap'
+
+describe Recap::Bootstrap do
+  let :config do
+    Capistrano::Configuration.new
+  end
+
+  let :namespace do
+    config.bootstrap
+  end
+
+  before do
+    Recap::Bootstrap.load_into(config)
+  end
+
+  describe 'Tasks' do
+    describe 'bootstrap' do
+      it 'runs bootsrap:application and bootstrap:user tasks' do
+        namespace.expects(:application).in_sequence
+        namespace.expects(:user).in_sequence
+        config.find_and_execute_task('bootstrap')
+      end
+    end
+
+    describe 'bootstrap:user' do
+      pending 'Tests not written'
+    end
+
+    describe 'bootstrap:application' do
+      pending 'Tests not written'
+    end
+  end
+end

data/spec/tasks/bundler_spec.rb

@@ -0,0 +1,126 @@
+require 'spec_helper'
+
+describe Recap::Bundler do
+  let :config do
+    Capistrano::Configuration.new
+  end
+
+  let :namespace do
+    config.bundle
+  end
+
+  let :deploy_to do
+    'path/to/deploy/to'
+  end
+
+  before do
+    config.set :deploy_to, deploy_to
+    Recap::Bundler.load_into(config)
+  end
+
+  describe 'Settings' do
+    describe '#bundle_gemfile' do
+      it 'defaults to deploy_to + /Gemfile' do
+        config.bundle_gemfile.should eql(deploy_to + '/Gemfile')
+      end
+    end
+
+    describe '#bundle_gemfile_lock' do
+      it 'defaults to bundle_gemfile + .lock' do
+        config.set :bundle_gemfile, 'custom/Gemfile'
+        config.bundle_gemfile_lock.should eql('custom/Gemfile.lock')
+      end
+    end
+
+    describe '#bundle_path' do
+      it 'defaults to deploy_to + /vendor/gems' do
+        config.bundle_path.should eql(deploy_to + '/vendor/gems')
+      end
+    end
+
+    describe '#bundle_without' do
+      it 'defaults to development, test and assets groups' do
+        config.bundle_without.should eql("development test assets")
+      end
+    end
+
+    describe '#bundle_install_command' do
+      it 'takes --gemfile from the bundle_gemfile setting' do
+        config.set :bundle_gemfile, 'path/to/bundle/Gemfile'
+        config.bundle_install_command.include?(" --gemfile path/to/bundle/Gemfile ").should be_true
+      end
+
+      it 'takes --path from the bundle_path setting' do
+        config.set :bundle_path, 'path/to/install/gems'
+        config.bundle_install_command.include?(" --path path/to/install/gems ").should be_true
+      end
+
+      it 'takes --without from the bundle_without setting' do
+        config.set :bundle_without, 'groups to skip'
+        config.bundle_install_command.include?(" --without groups to skip").should be_true
+      end
+
+      it 'includes --deployment flag to ensure Gemfile.lock exists' do
+        config.bundle_install_command.include?(" --deployment ").should be_true
+      end
+
+      it 'includes --binstubs flag to generate binary stubs used by other tasks' do
+        config.bundle_install_command.include?(" --binstubs ").should be_true
+      end
+
+      it 'includes --quiet flag to reduce uneccessary noise' do
+        config.bundle_install_command.include?(" --quiet ").should be_true
+      end
+    end
+  end
+
+  describe 'Tasks' do
+    describe 'bundle:install' do
+      it 'run bundle_install_command as the app if the Gemfile and Gemfile.lock exist' do
+        namespace.stubs(:deployed_file_exists?).with(config.bundle_gemfile).returns(true)
+        namespace.stubs(:deployed_file_exists?).with(config.bundle_gemfile_lock).returns(true)
+        namespace.expects(:as_app).with(config.bundle_install_command)
+
+        config.find_and_execute_task('bundle:install')
+      end
+
+      it 'skips bundle_install if the Gemfile missing' do
+        namespace.stubs(:deployed_file_exists?).with(config.bundle_gemfile).returns(false)
+        namespace.expects(:as_app).never
+
+        config.find_and_execute_task('bundle:install')
+      end
+
+      it 'aborts with warning if Gemfile exists but Gemfile.lock doesn\'t' do
+        namespace.stubs(:deployed_file_exists?).with(config.bundle_gemfile).returns(true)
+        namespace.stubs(:deployed_file_exists?).with(config.bundle_gemfile_lock).returns(false)
+        lambda do
+          namespace.find_and_execute_task('bundle:install')
+        end.should raise_error(SystemExit, 'Gemfile found without Gemfile.lock.  The Gemfile.lock should be committed to the project repository')
+      end
+    end
+
+    describe 'bundle:install:if_changed' do
+      it 'calls bundle:install:default if the Gemfile.lock has changed' do
+        namespace.stubs(:deployed_file_changed?).with(config.bundle_gemfile).returns(false)
+        namespace.stubs(:deployed_file_changed?).with(config.bundle_gemfile_lock).returns(true)
+        namespace.install.expects(:default)
+        config.find_and_execute_task('bundle:install:if_changed')
+      end
+
+      it 'calls bundle:install:default if the Gemfile has changed' do
+        namespace.stubs(:deployed_file_changed?).with(config.bundle_gemfile).returns(true)
+        namespace.stubs(:deployed_file_changed?).with(config.bundle_gemfile_lock).returns(false)
+        namespace.install.expects(:default)
+        config.find_and_execute_task('bundle:install:if_changed')
+      end
+
+      it 'skips bundle_install if neither Gemfile nor Gemfile.lock have changed' do
+        namespace.stubs(:deployed_file_changed?).with(config.bundle_gemfile).returns(false)
+        namespace.stubs(:deployed_file_changed?).with(config.bundle_gemfile_lock).returns(false)
+        namespace.install.expects(:default).never
+        config.find_and_execute_task('bundle:install:if_changed')
+      end
+    end
+  end
+end