recap 0.1.0 → 0.2.0

data/features/templates/gem/binary.erb

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+require 'webrick'
+
+GEM_VERSION = "<%= version %>"
+
+class Server
+  class Action < WEBrick::HTTPServlet::AbstractServlet
+    def do_GET(request, response)
+      response.status = 200
+      response['Content-Type'] = "text/plain"
+      response.body = body
+    end
+  end
+
+  class Version < Action
+    def body
+      GEM_VERSION
+    end
+  end
+
+  class Env < Action
+    def body
+      ENV.keys.sort.map {|k| "#{k}=#{ENV[k]}" }.join("\n")
+    end
+  end
+
+  def self.start
+    server = WEBrick::HTTPServer.new(:Port => 3500)
+    server.mount "/env", Env
+    server.mount "/version", Version
+    server.start
+  end
+end
+
+trap("SIGINT") { exit! }
+trap("TERM") { exit! }
+
+case ARGV[0]
+when "--version" then puts GEM_VERSION
+when "--env" then ENV.keys.sort.each {|k| puts "#{k}=#{ENV[k]}"}
+when "--server" then Server.start
+else puts "Unknown option"
+end

data/features/templates/gem/gemspec.erb

@@ -0,0 +1,11 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Tom Ward"]
+  gem.email         = ["tom@popdog.net"]
+  gem.description   = %q{<%= gem %> <%= version %>}
+  gem.summary       = %q{<%= gem %> <%= version %>}
+  gem.executables   = ['<%= gem %>']
+  gem.name          = "<%= gem %>"
+  gem.version       = "<%= version %>"
+end

data/features/templates/project/Capfile

@@ -0,0 +1,21 @@
+require '<%= recap_require %>'
+
+# To connect to the vagrant VM we need to set up a few non-standard parameters, including the
+# vagrant SSH port and private key
+
+set :user, 'vagrant'
+
+ssh_options[:port] = 2222
+ssh_options[:keys] = ['<%= project.private_key_path %>']
+
+server '127.0.0.1', :web
+
+# Each project has its own location shared between the host machine and the VM
+
+set :application, '<%= project.name %>'
+set :repository, '/recap/share/<%= project.name %>'
+
+# Finally, to ensure tests don't fail if deployments are made within a second of each other
+# which they can do when automated like this, we use a finer-grained release tag
+
+set(:release_tag) { Time.now.utc.strftime("%Y%m%d%H%M%S%L") }

data/features/templates/project/Capfile.erb

@@ -0,0 +1,21 @@
+require '<%= recap_require %>'
+
+# To connect to the vagrant VM we need to set up a few non-standard parameters, including the
+# vagrant SSH port and private key
+
+set :user, 'vagrant'
+
+ssh_options[:port] = 2222
+ssh_options[:keys] = ['<%= project.private_key_path %>']
+
+server '127.0.0.1', :web
+
+# Each project has its own location shared between the host machine and the VM
+
+set :application, '<%= project.name %>'
+set :repository, '/recap/share/projects/<%= project.name %>'
+
+# Finally, to ensure tests don't fail if deployments are made within a second of each other
+# which they can do when automated like this, we use a finer-grained release tag
+
+set(:release_tag) { Time.now.utc.strftime("%Y%m%d%H%M%S%L") }

data/features/templates/project/Gemfile.erb

@@ -0,0 +1,7 @@
+source :rubygems
+<% if foreman %>
+gem 'foreman'
+<% end %>
+<% gems.each do |gem, version| %>
+gem '<%= gem %>', :git => '/recap/share/gems/<%= gem %>', :tag => '<%= version %>'
+<% end %>

data/features/templates/project/Procfile.erb

@@ -0,0 +1 @@
+<%= name %>: <%= command %>

data/index.rb

@@ -1,6 +1,8 @@
 # This is the annotated source code and documentation for
 # [recap](http://github.com/freerange/recap), a simple, opinionated set of capistrano
-# deployment recipes.  Inspired by
+# deployment recipes.
+
+# Inspired in part by
 # [this blog post](https://github.com/blog/470-deployment-script-spring-cleaning), these recipes use
 # git's strengths to deploy applications in a faster, simpler manner than a standard capistrano
 # deployment.  Using git to manage release versions means apps can be deployed to a single directory.
@@ -10,19 +12,19 @@
 
 # These deployment recipes try to do the following:
 
-# Run all commands as the `application_user`, loading the full user environment.  The only
-# exceptions are `git` commands (which often rely on SSH agent forwarding for authentication), and anything
-# that requires `sudo`.
+# Where possible run commands as the `application_user`, loading the full user environment.  The only
+# exceptions are `git` commands (which often rely on SSH agent forwarding for authentication), and
+# anything that requires `sudo`.
 #
 
 # Use `git` to avoid unecessary work.  If the `Gemfile.lock` hasn't changed, there's no need to run
-# `bundle install`.  Similarly if there are no new migrations, why do `rake db:migrate`.  Faster deploys
-# mean more frequent deploys, which in our experience leads to better applications.
+# `bundle install`.  Similarly if there are no new migrations, why do `rake db:migrate`?  Faster
+# deploys mean more frequent deploys.
 #
 
-# Avoid the use of `sudo` (other than to change to the `application_user`).  As much as possible, `sudo`
-# is only used to `su` to the `application_user` before running a command.  To avoid typing a password
-# to perform the majority of deployment tasks, this code can be added to
+# Avoid the use of `sudo` (other than to change to the `application_user`).  As much as possible,
+# `sudo` is only used to `su` to the `application_user` before running a command.  To avoid having to
+# type a password to perform the majority of deployment tasks, these lines can be added to
 # `/etc/sudoers.d/application` (change `application` to the name of your app).
 
 %application ALL=NOPASSWD: /sbin/start application*
@@ -31,23 +33,30 @@
 %application ALL=NOPASSWD: /bin/su - application*
 %application ALL=NOPASSWD: /bin/su application*
 
+# Use environment variables for configuration.  Rather than setting `rails_env` in the `Capfile`,
+# `RAILS_ENV` (or `RACK_ENV`) variables should be set for the `application_user`.  The `env:set` and
+# `env:edit` tasks help do this.
+
 # ### Code layout ###
 
-# The main deployment tasks are defined in [recap.rb](lib/recap.html).  Automatic
+# The main deployment tasks are defined in [recap/deploy.rb](lib/recap/deploy.html).  Automatic
 # checks to ensure servers are correctly setup are in
-# [recap/preflight.rb](lib/recap/preflight.html).
+# [recap/preflight.rb](lib/recap/preflight.html), while tasks for environment variables are in
+# [recap/env.rb](lib/recap/env.html)
 
-# In addition, there are extensions for [bundler](lib/recap/bundler.html) and
-# [foreman](lib/recap/foreman.html).
+# In addition, there are extensions for [bundler](lib/recap/bundler.html),
+# [foreman](lib/recap/foreman.html) and [rails](lib/recap/rails.html)
 
-# For (limited) compatability with other existing recipes, see
-# [compatibility](lib/recap/compatibility.html)
+# For limited compatability with other existing recipes, see
+# [compatibility](lib/recap/compatibility.html).
 
 # ### Deployment target ###
 
-# These recipes have been run successful against Ubuntu.
+# These recipes have been developed and tested using Ubuntu 11.04, though they may work well with
+# other flavours of unix.
 
-# The application should be run as the application user; if using Apache and Passenger, you should set the `PassengerDefaultUser` directive to be the same as the `application_user`.
+# The application should be run as the application user; if using Apache and Passenger, you should
+# set the `PassengerDefaultUser` directive to be the same as the `application_user`.
 
 # The code is available [on github](http://github.com/freerange/recap) and released under the
 # [MIT License](https://github.com/freerange/recap/blob/master/LICENSE)

data/lib/recap/bootstrap.rb

@@ -0,0 +1,47 @@
+module Recap::Bootstrap
+  extend Recap::Namespace
+
+  namespace :bootstrap do
+    set(:remote_username) { capture('whoami').strip }
+    set(:application_home) { "/home/#{application_user}"}
+
+    task :default do
+      application
+      user
+    end
+
+    task :application do
+      if exit_code("id #{application_user}").strip != "0"
+        sudo "useradd #{application_user} -d #{application_home}"
+      end
+      sudo "mkdir -p #{application_home}"
+      sudo "chown #{application_user}:#{application_group} #{application_home}"
+      sudo "chmod 755 #{application_home}"
+
+      put_as_app %{
+if [ -s "$HOME/.env" ]; then
+  rm -rf $HOME/.recap-env-export
+  touch $HOME/.recap-env-export
+  while read line
+  do echo "export $line" >> $HOME/.recap-env-export;
+  done < $HOME/.env
+  . $HOME/.recap-env-export
+fi
+      }, "#{application_home}/.recap"
+
+      as_app "touch .profile", "~"
+
+      if exit_code(%{grep '\\. \\$HOME\\/.recap' .profile}) != "0"
+        as_app %{echo >> .profile && echo ". \\$HOME/.recap" >> .profile}, "~"
+      end
+
+      as_app "mkdir -p #{deploy_to}", "~"
+    end
+
+    task :user do
+      run "git config --global user.name '#{`git config user.name`.strip}'"
+      run "git config --global user.email '#{`git config user.email`.strip}'"
+      sudo "usermod --append -G #{application_group} #{remote_username}"
+    end
+  end
+end

data/lib/recap/bundler.rb

@@ -1,26 +1,32 @@
 # The bundler recipe ensures that the application bundle is installed whenever the code is updated.
 
-Capistrano::Configuration.instance(:must_exist).load do
-  # Each bundle is declared in a `Gemfile`, by default in the root of the application directory
-  set(:bundle_gemfile) { "#{deploy_to}/Gemfile" }
+module Recap::Bundler
+  extend Recap::Namespace
 
-  # As well as a `Gemfile`, application repositories should also contain a `Gemfile.lock`.
-  set(:bundle_gemfile_lock) { "#{bundle_gemfile}.lock" }
+  namespace :bundle do
+    # Each bundle is declared in a `Gemfile`, by default in the root of the application directory
+    set(:bundle_gemfile) { "#{deploy_to}/Gemfile" }
 
-  # An application's gems are installed within the application directory.  By default they are
-  # places under `.bundle/gems`.
-  set(:bundle_dir) { "#{deploy_to}/.bundle/gems" }
+    # As well as a `Gemfile`, application repositories should also contain a `Gemfile.lock`.
+    set(:bundle_gemfile_lock) { "#{bundle_gemfile}.lock" }
 
-  # Not all gems are needed for production environments, so by default the `development`, `test` and
-  # `assets` groups are skipped.
-  set(:bundle_without) { "development test assets" }
+    # An application's gems are installed within the application directory.  By default they are
+    # placed under `vendor/gems`.
+    set(:bundle_path) { "#{deploy_to}/vendor/gems" }
+
+    # Not all gems are needed for production environments, so by default the `development`, `test` and
+    # `assets` groups are skipped.
+    set(:bundle_without) { "development test assets" }
+
+    # The main bundle install command uses all the settings above, together with the `--deployment`,
+    # `--binstubs` and `--quiet` flags
+    set(:bundle_install_command) { "bundle install --gemfile #{bundle_gemfile} --path #{bundle_path} --deployment --quiet --binstubs --without #{bundle_without}" }
 
-  namespace :bundle do
     namespace :install do
-      # After cloning or updating the code, we only install the bundle if the `Gemfile` has changed.
-      desc "Install the latest gem bundle only if Gemfile.lock has changed"
+      # After cloning or updating the code, we only install the bundle if the `Gemfile` or `Gemfile.lock` have changed.
+      desc "Install the latest gem bundle only if Gemfile or Gemfile.lock have changed"
       task :if_changed do
-        if deployed_file_changed?(bundle_gemfile_lock)
+        if deployed_file_changed?(bundle_gemfile) || deployed_file_changed?(bundle_gemfile_lock)
           top.bundle.install.default
         end
       end
@@ -30,16 +36,20 @@ Capistrano::Configuration.instance(:must_exist).load do
       desc "Install the latest gem bundle"
       task :default do
         if deployed_file_exists?(bundle_gemfile)
-          bundler "install --gemfile #{bundle_gemfile} --path #{bundle_dir} --deployment --quiet --binstubs --without #{bundle_without}"
+          if deployed_file_exists?(bundle_gemfile_lock)
+            as_app bundle_install_command
+          else
+            abort 'Gemfile found without Gemfile.lock.  The Gemfile.lock should be committed to the project repository'
+          end
         else
           puts "Skipping bundle:install as no Gemfile found"
         end
       end
     end
-  end
 
-  # To install the bundle automatically each time the code is updated or cloned, hooks are added to
-  # the `deploy:clone_code` and `deploy:update_code` tasks.
-  after 'deploy:clone_code', 'bundle:install:if_changed'
-  after 'deploy:update_code', 'bundle:install:if_changed'
+    # To install the bundle automatically each time the code is updated or cloned, hooks are added to
+    # the `deploy:clone_code` and `deploy:update_code` tasks.
+    after 'deploy:clone_code', 'bundle:install:if_changed'
+    after 'deploy:update_code', 'bundle:install:if_changed'
+  end
 end

data/lib/recap/capistrano_extensions.rb

@@ -19,10 +19,11 @@ module Recap
 
     # Put a string into a file as the application user
     def put_as_app(string, path)
-      as_app "touch #{path} && chmod g+rw #{path}"
-      put string, path
+      put string, "/tmp/recap-put-as-app"
+      as_app "cp /tmp/recap-put-as-app #{path} && chmod g+rw #{path}", "/"
     end
 
+    # Edit a file on the remote server, using a local editor
     def edit_file(path)
       if editor = ENV['DEPLOY_EDITOR'] || ENV['EDITOR']
         as_app "touch #{path} && chmod g+rw #{path}"
@@ -37,17 +38,16 @@ module Recap
 
     # Run a git command in the `deploy_to` directory
     def git(command)
-      run "cd #{deploy_to} && git #{command}"
+      run "cd #{deploy_to} && umask 002 && sg #{application_group} -c \"git #{command}\""
     end
 
     # Capture the result of a git command run within the `deploy_to` directory
     def capture_git(command)
-      capture "cd #{deploy_to} && git #{command}"
+      capture "cd #{deploy_to} && umask 002 && sg #{application_group} -c 'git #{command}'"
     end
 
-    # Run a bundle command in the `deploy_to` directory
-    def bundler(command)
-      as_app "bundle #{command}"
+    def exit_code(command)
+      capture("#{command} > /dev/null 2>&1; echo $?").strip
     end
 
     # Find the latest tag from the repository.  As `git tag` returns tags in order, and our release
@@ -59,14 +59,16 @@ module Recap
 
     # Does the given file exist within the deployment directory?
     def deployed_file_exists?(path)
-      capture("cd #{deploy_to} && [ -f #{path} ]; echo $?").strip == "0"
+      exit_code("cd #{deploy_to} && [ -f #{path} ]") == "0"
     end
 
     # Has the given path been created or changed since the previous deployment?  During the first
     # successful deployment this will always return true.
     def deployed_file_changed?(path)
       return true unless latest_tag
-      capture_git("diff --exit-code #{latest_tag} origin/#{branch} #{path} > /dev/null; echo $?").strip == "1"
+      exit_code("cd #{deploy_to} && git diff --exit-code #{latest_tag} origin/#{branch} #{path}") == "1"
     end
+
+    Capistrano::Configuration.send :include, self
   end
 end

data/lib/recap/cli.rb

@@ -7,7 +7,7 @@ module Recap
     attr_accessor :name, :repository
 
     def self.source_root
-      File.expand_path("../templates", __FILE__)
+      File.expand_path("../deploy/templates", __FILE__)
     end
 
     desc 'setup', 'Setup basic capistrano recipes, e.g: recap setup'

data/lib/recap/compatibility.rb

@@ -1,12 +1,12 @@
 # `recap` isn't intended to be compatible with tasks (such as those within the `bundler`
 # or `whenever` projects) that are built on the original capistrano deployment recipes.  At times
-# though there are tasks that would work, but for some missing (and redundant) settings.  
+# though there are tasks that would work, but for some missing (and redundant) settings.
 #
 # Including this recipe adds these legacy settings, but provides no guarantee that original tasks
 # will work.  Many are based on assumptions about the deployment layout that no longer hold true.
 
-Capistrano::Configuration.instance(:must_exist).load do
-  extend Recap::CapistranoExtensions
+module Recap::Compatibility
+  extend Recap::Namespace
 
   # As `git` to manages releases, all deployments are placed directly in the `deploy_to` folder.  The
   # `current_path` is always this directory (no symlinking required).

data/lib/recap/deploy.rb

@@ -1,49 +1,52 @@
+require 'recap'
 require 'recap/capistrano_extensions'
-require 'recap/bundler'
+
 require 'recap/preflight'
+require 'recap/bootstrap'
+require 'recap/env'
 
-Capistrano::Configuration.instance(:must_exist).load do
-  extend Recap::CapistranoExtensions
+module Recap::Deploy
+  extend Recap::Namespace
 
-  # To use this recipe, both the application's name and its git repository are required.
-  set(:application) { abort "You must set the name of your application in your Capfile, e.g.: set :application, 'tomafro.net'" }
-  set(:repository) { abort "You must set the git respository location in your Capfile, e.g.: set :respository, 'git@github.com/tomafro/tomafro.net'"}
+  namespace :deploy do
+    # To use this recipe, both the application's name and its git repository are required.
+    set(:application) { abort "You must set the name of your application in your Capfile, e.g.: set :application, 'tomafro.net'" }
+    set(:repository) { abort "You must set the git respository location in your Capfile, e.g.: set :respository, 'git@github.com/tomafro/tomafro.net'"}
 
-  # The recipe assumes that the application code will be run as a dedicated user.  Any any user who
-  # can deploy the application should be added as a member of the application's group.  By default,
-  # both the application user and group take the same name as the application.
-  set(:application_user) { application }
-  set(:application_group) { application_user }
+    # The recipe assumes that the application code will be run as a dedicated user.  Any any user who
+    # can deploy the application should be added as a member of the application's group.  By default,
+    # both the application user and group take the same name as the application.
+    set(:application_user) { application }
+    set(:application_group) { application_user }
 
-  # Deployments can be made from any branch. `master` is used by default.
-  set(:branch, 'master')
+    # Deployments can be made from any branch. `master` is used by default.
+    set(:branch, 'master')
 
-  # Unlike a standard capistrano deployment, all releases are stored directly in the `deploy_to`
-  # directory.  The default is `/home/#{application_user}/apps/#{application}`.
-  set(:deploy_to)   { "/home/#{application_user}/apps/#{application}" }
+    # Unlike a standard capistrano deployment, all releases are stored directly in the `deploy_to`
+    # directory.  The default is `/home/#{application_user}/apps/#{application}`.
+    set(:deploy_to)   { "/home/#{application_user}/apps/#{application}" }
 
-  # Each release is marked by a unique tag, generated with the current timestamp.  While this can be
-  # changed, it's not recommended, as the sort order of the tag names is important; later tags must
-  # be listed after earlier tags.
-  set(:release_tag) { "#{Time.now.utc.strftime("%Y%m%d%H%M%S")}"}
+    # Each release is marked by a unique tag, generated with the current timestamp.  While this can be
+    # changed, it's not recommended, as the sort order of the tag names is important; later tags must
+    # be listed after earlier tags.
+    set(:release_tag) { Time.now.utc.strftime("%Y%m%d%H%M%S") }
 
-  # On tagging a release, a message is also recorded alongside the tag.  This message can contain
-  # anything useful - its contents are not important for the recipe.
-  set(:release_message, "Deployed at #{Time.now}")
+    # On tagging a release, a message is also recorded alongside the tag.  This message can contain
+    # anything useful - its contents are not important for the recipe.
+    set(:release_message, "Deployed at #{Time.now}")
 
-  # Some tasks need to know the `latest_tag` - the most recent successful deployment.  If no
-  # deployments have been made, this will be `nil`.
-  set(:latest_tag) { latest_tag_from_repository }
+    # Some tasks need to know the `latest_tag` - the most recent successful deployment.  If no
+    # deployments have been made, this will be `nil`.
+    set(:latest_tag) { latest_tag_from_repository }
 
-  # To authenticate with github or other git servers, it is easier (and cleaner) to forward the
-  # deploying user's ssh key than manage keys on deployment servers.
-  ssh_options[:forward_agent] = true
+    # To authenticate with github or other git servers, it is easier (and cleaner) to forward the
+    # deploying user's ssh key than manage keys on deployment servers.
+    ssh_options[:forward_agent] = true
 
-  # If key forwarding isn't possible, git may show a password prompt which stalls capistrano unless
-  # `:pty` is set to `true`.
-  default_run_options[:pty] = true
+    # If key forwarding isn't possible, git may show a password prompt which stalls capistrano unless
+    # `:pty` is set to `true`.
+    default_run_options[:pty] = true
 
-  namespace :deploy do
     # The `deploy:setup` task prepares all the servers for the deployment.
     desc "Prepare servers for deployment"
     task :setup, :except => {:no_release => true} do
@@ -54,25 +57,11 @@ Capistrano::Configuration.instance(:must_exist).load do
 
     # Clone the repository into the deployment directory.
     task :clone_code, :except => {:no_release => true} do
-      # This is a slightly complicated process, as git doesn't allow us to clone into an existing
-      # directory.  To get around this, using `sudo` we create the base deployment folder (if it
-      # doesn't already exist).
-      sudo "mkdir -p #{File.expand_path(deploy_to + "/..")}"
-      # Next, clone our code into a temporary location.  This is necessary as our user might not have
-      # permission to write in the base deployment folder.
-      run "git clone #{repository} $HOME/#{application}.tmp"
-      # Again using `sudo`, move the temporary clone to its final destination.
-      sudo "mv $HOME/#{application}.tmp #{deploy_to}"
-      # Finally ensure that members of the `application_group` can read and write all files.
-      top.deploy.change_ownership
-    end
-
-    # Any files that have been created or updated by our user need to have thier permissions changed to
-    # ensure they can be read and written by and member of the `application_group` (deploying users and
-    # the application itself).
-    task :change_ownership, :except => {:no_release => true} do
-      run "find #{deploy_to} -user `whoami` ! -group #{application_group} -exec chown :#{application_group} {} \\;"
-      run "find #{deploy_to} -user `whoami` -exec chmod g+rw {} \\;"
+      # Before cloning, the directory needs to exist and be both readable and writable by the application group
+      as_app "mkdir -p #{deploy_to}", "~"
+      as_app "chmod g+rw #{deploy_to}"
+      # Then clone the code
+      git "clone #{repository} ."
     end
 
     # The main deployment task (called with `cap deploy`) deploys the latest application code to all
@@ -91,19 +80,16 @@ Capistrano::Configuration.instance(:must_exist).load do
       on_rollback { git "reset --hard #{latest_tag}" if latest_tag }
       git "fetch"
       git "reset --hard origin/#{branch}"
-      # Finally ensure that the members of the `application_group` can read and write all files.
-      top.deploy.change_ownership
     end
 
     # Tag `HEAD` with the release tag and message
     task :tag, :except => {:no_release => true} do
       on_rollback { git "tag -d #{release_tag}" }
       git "tag #{release_tag} -m '#{release_message}'"
-      top.deploy.change_ownership
     end
 
     # After a successful deployment, the app is restarted.  In the most basic deployments this does
-    # nothing, but other recipes may override it, or attach tasks it's before or after hooks.
+    # nothing, but other recipes may override it, or attach tasks to its before or after hooks.
     desc "Restart the application following a deploy"
     task :restart do
     end
@@ -118,8 +104,10 @@ Capistrano::Configuration.instance(:must_exist).load do
           if previous_tag = latest_tag_from_repository
             git "reset --hard #{previous_tag}"
           end
+          restart
+        else
+          abort "This app is not currently deployed"
         end
-        restart
       end
     end
 

data/lib/recap/env.rb

@@ -1,54 +1,58 @@
-# N.B. To get the environment loaded on every shell invocation add the following to .profile:
+# Environment variables are a useful way to set application configuration, such as database passwords
+# or S3 keys and secrets.  [recap](http://github.com/freerange/recap) stores these extra variables in
+# a special file, usually stored at `$HOME/.env`.  This file is loaded each time the shell starts by
+# adding the following to the user's `.profile`:
 #
-#     if [ -s "$HOME/.env" ]; then export $(cat $HOME/.env); fi
+#     . $HOME/.recap
 #
-# This will eventually be done automatically
+# The `.recap` script is automatically generated in the bootstrap process.
+
+module Recap::Env
+  extend Recap::Namespace
 
-Capistrano::Configuration.instance(:must_exist).load do
   namespace :env do
+    # Environment
     set(:environment_file) { "/home/#{application_user}/.env" }
 
-    def extract_environment(declarations)
-      declarations.inject({}) do |env, line|
-        if line =~ /\A([A-Za-z_]+)=(.*)\z/
-          env[$1] = $2.strip
-        end
-        env
-      end
-    end
-
     def current_environment
       @current_environment ||= begin
         if deployed_file_exists?(environment_file)
-          extract_environment(capture("cat #{environment_file}").split("\n"))
+          Recap::Environment.from_string(capture("cat #{environment_file}"))
         else
-          {}
+          Recap::Environment.new
         end
       end
     end
 
-    def write_environment(env)
-      env.keys.sort.collect do |v|
-        "#{v}=#{env[v]}" unless env[v].nil? || env[v].empty?
-      end.compact.join("\n")
-    end
-
     task :default do
-      puts write_environment(current_environment)
+      if current_environment.empty?
+        puts "There are no config variables set"
+      else
+        puts "The config variables are:"
+        puts
+        puts current_environment
+      end
     end
 
     task :set do
-      additions = extract_environment(ARGV[1..-1])
-      env = write_environment(current_environment.merge(additions))
+      env = ARGV[1..-1].inject(current_environment) do |env, string|
+        env.set_string(string)
+        logger.debug "Setting #{string}"
+        logger.debug "Env is now: #{env}"
+        env
+      end
+
       if env.empty?
-        as_app "rm -f #{environment_file}"
+        as_app "rm -f #{environment_file}", "~"
       else
-        put_as_app env, environment_file
+        put_as_app env.to_s, environment_file
       end
+      default
     end
 
     task :edit do
       edit_file environment_file
+      default
     end
   end
 end