kumade 0.0.3 → 0.0.4

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2008 Joe Ferris and thoughtbot, inc.
+
+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

@@ -1,4 +1,4 @@
-# Kumade [![Build Status](https://secure.travis-ci.org/gabebw/kumade.png)](http://travis-ci.org/gabebw/kumade)
+# Kumade [![Build Status](https://secure.travis-ci.org/thoughtbot/kumade.png)](http://travis-ci.org/gabebw/kumade)
 Kumade is a set of basic Rake tasks for deploying to Heroku. It aims to
 provide most of what you want. Unlike other Heroku deploy gems, it is
 well-tested.
@@ -38,6 +38,10 @@ The default task is to deploy to staging:
 
     $ kumade # equivalent to "kumade deploy staging"
 
+## Does it support the Cedar stack?
+
+Yes.
+
 ## Sample Output
 
 ### Normal mode
@@ -119,13 +123,19 @@ The default task is to deploy to staging:
     ==> Deploying to: origin
     ==> ! Cannot deploy: "origin" remote does not point to Heroku
 
-
 ## Compatibility
+
 Tested against:
- * MRI 1.8.7
- * MRI 1.9.2
- * REE 1.8.7
+
+* MRI 1.8.7
+* MRI 1.9.2
+* REE 1.8.7
 
 ## What's with the name?
+
 Kumade ([pronunciation here](http://translate.google.com/#ja|en|熊手)) means
 "bamboo rake" in Japanese.
+
+## License
+
+kumade is Copyright © thoughtbot. It is free software, and may be redistributed under the terms specified in the LICENSE file.

data/features/kumade_executable.feature

@@ -1,4 +1,4 @@
-@creates-remote
+@extra-timeout @creates-remote
 Feature: Kumade executable
   As a user
   I want to be able to use the kumade executable
@@ -18,9 +18,13 @@ Feature: Kumade executable
       ==> Git repo is clean
       ==> Rake passed
       ==> Packaged assets with Jammit
+               run  git push origin master
       ==> Pushed master -> origin
+               run  git push -f pretend-staging master
       ==> Force pushed master -> pretend-staging
+               run  bundle exec heroku rake db:migrate --app pretend-staging-app
       ==> Migrated pretend-staging-app
+               run  git checkout master && git branch -D deploy
       ==> Deployed to: pretend-staging
       """
     But the output should not contain "==> Packaged assets with More"
@@ -33,3 +37,7 @@ Feature: Kumade executable
     When I run `kumade deploy bamboo`
     Then the output should contain "==> Deploying to: bamboo"
     Then the output should match /Cannot deploy: /
+
+  Scenario: Deploying to a non-Heroku remote fails
+    When I run `kumade deploy origin`
+    Then the output should match /==> ! Cannot deploy: "origin" remote does not point to Heroku/

data/features/support/env.rb

@@ -1,2 +1,6 @@
 require 'aruba/cucumber'
 require 'kumade'
+
+Before('@extra-timeout') do
+  @aruba_timeout_seconds = 60
+end

data/kumade.gemspec

@@ -5,7 +5,6 @@ require "kumade/version"
 Gem::Specification.new do |s|
   s.name        = "kumade"
   s.version     = Kumade::VERSION
-  s.platform    = Gem::Platform::RUBY
   s.authors     = ["Gabe Berke-Williams"]
   s.email       = ["gabe@thoughtbot.com"]
   s.homepage    = ""

data/lib/kumade.rb

@@ -3,12 +3,11 @@ require 'kumade/thor_task'
 
 module Kumade
   def self.app_for(environment)
-    heroku_git_url = `git remote show -n #{environment} | grep 'Push  URL' | cut -d' ' -f6`.strip
-    match = heroku_git_url.match(/^git@heroku\.com:(.+)\.git$/)
-    if match
-      match[1]
+    heroku_git_url = `git config --get remote.#{environment}.url`.strip
+    if heroku_git_url =~ /^git@heroku\.com:(.+)\.git$/
+      $1
     else
-      ""
+      nil
     end
   end
 end

data/lib/kumade/deployer.rb

@@ -3,18 +3,12 @@ require 'rake'
 
 module Kumade
   class Deployer < Thor::Shell::Color
+    DEPLOY_BRANCH = "deploy"
     attr_reader :pretending
 
     def initialize(pretending = false)
       super()
-      @pretending = !!pretending
-    end
-
-    def pre_deploy
-      ensure_clean_git
-      ensure_rake_passes
-      package_assets
-      git_push('origin')
+      @pretending = pretending
     end
 
     def deploy_to(environment)
@@ -23,35 +17,57 @@ module Kumade
       pre_deploy
       git_force_push(string_environment)
       heroku_migrate(string_environment)
+      post_deploy
+    end
+
+    def pre_deploy
+      ensure_clean_git
+      ensure_rake_passes
+      package_assets
+      git_push('origin')
     end
 
     def git_push(remote)
-      unless pretending
-        run_or_error("git push #{remote} master",
-                    "Failed to push master -> #{remote}")
-      end
+      run_or_error("git push #{remote} master",
+                  "Failed to push master -> #{remote}")
       success("Pushed master -> #{remote}")
     end
 
     def git_force_push(remote)
-      unless pretending
-        run_or_error("git push -f #{remote} master",
-                    "Failed to force push master -> #{remote}")
-      end
+      run_or_error("git push -f #{remote} master",
+                  "Failed to force push master -> #{remote}")
       success("Force pushed master -> #{remote}")
     end
 
     def heroku_migrate(environment)
       app = Kumade.app_for(environment)
 
-      unless pretending
-        run("bundle exec heroku rake db:migrate --app #{app}")
-      end
+      heroku("rake db:migrate", app)
       success("Migrated #{app}")
     end
 
+    def post_deploy
+      run_or_error("git checkout master", "git branch -D #{DEPLOY_BRANCH}",
+                   "Failed to clean up #{DEPLOY_BRANCH} branch")
+    end
+
+    def heroku(command, app)
+      heroku_command = if on_cedar?(app)
+                         "bundle exec heroku run"
+                       else
+                         "bundle exec heroku"
+                       end
+      run_or_error("#{heroku_command} #{command} --app #{app}",
+                   "Failed to run #{command} on Heroku")
+    end
+
+    def on_cedar?(app)
+      selected_stack = `heroku stack --app '#{app}'`.split("\n").grep(/^\*/).first
+      selected_stack && selected_stack.include?('cedar')
+    end
+
     def ensure_clean_git
-      if git_dirty? && ! pretending
+      if ! pretending && git_dirty?
         error("Cannot deploy: repo is not clean.")
       else
         success("Git repo is clean")
@@ -60,7 +76,7 @@ module Kumade
 
     def ensure_rake_passes
       if default_task_exists?
-        if pretending || rake_succeeded?
+        if rake_succeeded?
           success("Rake passed")
         else
           error("Cannot deploy: tests did not pass")
@@ -93,23 +109,27 @@ module Kumade
     end
 
     def package_with_more
-      begin
-        system "bundle exec rake more:generate"
-        if git_dirty?
-          success("Packaged assets with More")
-
-          git_add_and_commit_all_assets_in(more_assets_path)
+      success_message = "Packaged assets with More"
+      if pretending
+        success(success_message)
+      else
+        begin
+          run "bundle exec rake more:generate"
+          if git_dirty?
+            success(success_message)
+            git_add_and_commit_all_assets_in(more_assets_path)
+          end
+        rescue => more_error
+          error("Error: #{more_error.class}: #{more_error.message}")
         end
-      rescue => more_error
-        error("Error: #{more_error.class}: #{more_error.message}")
       end
     end
 
     def git_add_and_commit_all_assets_in(dir)
-      run_or_error("git add #{dir} && git commit -m 'Assets'",
-                    "Cannot deploy: couldn't commit assets")
+      run_or_error "git checkout -b #{DEPLOY_BRANCH}", "git add -f #{dir}", "git commit -m 'Compiled assets'",
+                   "Cannot deploy: couldn't commit assets"
 
-      success("Added and committed all assets")
+      success "Added and committed all assets"
     end
 
     def jammit_assets_path
@@ -125,6 +145,7 @@ module Kumade
         (defined?(Jammit) ||
           begin
             require 'jammit'
+            true
           rescue LoadError
             false
           end)
@@ -135,6 +156,7 @@ module Kumade
         (defined?(Less::More) ||
           begin
             require 'less/more'
+            true
           rescue LoadError
             false
           end)
@@ -145,29 +167,26 @@ module Kumade
     end
 
     def rake_succeeded?
+      return true if pretending
+
       begin
-        system "bundle exec rake"
+        run "bundle exec rake"
       rescue
         false
       end
     end
 
     def git_dirty?
-      git_changed = `git status --short 2> /dev/null | tail -n1`
-      dirty = git_changed.size > 0
-    end
-
-    def run(command)
-      announce "+ #{command}"
-      announce "- #{system command}"
-      $?.success?
+      `git diff --exit-code`
+      !$?.success?
     end
 
-    def run_or_error(command, error_message)
-      if ! pretending
-        unless run(command)
-          error(error_message)
-        end
+    def run_or_error(*commands, error_message)
+      all_commands = commands.join(' && ')
+      if pretending
+        say_status(:run, all_commands)
+      else
+        error(error_message) unless run(all_commands)
       end
     end
 
@@ -184,19 +203,12 @@ module Kumade
       say("==> #{message}", :green)
     end
 
-    def string_present?(maybe_string)
-      maybe_string.is_a?(String) && maybe_string.size > 0
-    end
-
     def ensure_heroku_remote_exists_for(environment)
       if remote_exists?(environment)
-        if Kumade.app_for(environment)
-          app_name = Kumade.app_for(environment)
-          if string_present?(app_name)
-            success("#{environment} is a Heroku remote")
-          else
-            error(%{Cannot deploy: "#{environment}" remote does not point to Heroku})
-          end
+        if app_name = Kumade.app_for(environment)
+          success("#{environment} is a Heroku remote")
+        else
+          error(%{Cannot deploy: "#{environment}" remote does not point to Heroku})
         end
       else
         error(%{Cannot deploy: "#{environment}" remote does not exist})
@@ -207,14 +219,7 @@ module Kumade
       if pretending
         true
       else
-        `git remote`.split("\n").include?(remote_name)
-      end
-    end
-
-    def initialize_rake
-      if Rake.application.tasks.empty?
-        Rake.application.options.rakelib = ['rakelib']
-        Rake.application.load_rakefile
+        `git remote` =~ /^#{remote_name}$/
       end
     end
   end

data/lib/kumade/thor_task.rb

@@ -5,7 +5,7 @@ module Kumade
     default_task :deploy
 
     desc "deploy [ENV]", "Deploy to ENV (default: staging)"
-    method_option :pretend, :aliases => "-p", :desc => "Pretend Mode - print out what kumade would do"
+    method_option :pretend, :aliases => "-p", :desc => "Pretend Mode - print out what kumade would do", :default => false
     def deploy(environment = 'staging')
       say("==> In Pretend Mode", :red) if options[:pretend]
       say "==> Deploying to: #{environment}"

data/lib/kumade/version.rb

@@ -1,3 +1,3 @@
 module Kumade
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/spec/kumade/deployer_spec.rb

@@ -1,586 +1,598 @@
 require 'spec_helper'
-require 'jammit'
-
-module Kumade
-  describe Deployer, "#pre_deploy" do
-    before { subject.stub(:say) }
-
-    it "calls the correct methods in order" do
-      %w(
-        ensure_clean_git
-        ensure_rake_passes
-        package_assets
-        git_push
-        ).each do |task|
-        subject.should_receive(task).ordered.and_return(true)
-      end
 
-      subject.pre_deploy
-    end
+describe Kumade::Deployer, "#pre_deploy" do
+  before { subject.stub(:say) }
 
-    it "pushes to origin" do
-      %w(
-        ensure_clean_git
-        ensure_rake_passes
-        package_assets
+  it "calls the correct methods in order" do
+    %w(
+      ensure_clean_git
+      ensure_rake_passes
+      package_assets
+      git_push
       ).each do |task|
-        subject.stub(task)
-      end
+      subject.should_receive(task).ordered.and_return(true)
+    end
 
-      subject.should_receive(:git_push).with('origin')
-      subject.pre_deploy
+    subject.pre_deploy
+  end
+
+  it "pushes to origin" do
+    %w(
+      ensure_clean_git
+      ensure_rake_passes
+      package_assets
+    ).each do |task|
+      subject.stub(task)
     end
+
+    subject.should_receive(:git_push).with('origin')
+    subject.pre_deploy
   end
+end
 
-  describe Deployer, "#deploy_to" do
-    let(:remote_name){ 'staging' }
-    let(:app_name){ 'kumade-staging' }
+describe Kumade::Deployer, "#deploy_to" do
+  let(:remote_name){ 'staging' }
+  let(:app_name){ 'kumade-staging' }
 
-    before do
-      subject.stub(:say)
-      force_add_heroku_remote(remote_name, app_name)
-    end
+  before do
+    subject.stub(:say)
+    force_add_heroku_remote(remote_name, app_name)
+  end
 
-    after  { remove_remote(remote_name) }
+  after  { remove_remote(remote_name) }
 
-    it "calls the correct methods in order" do
-      subject.stub(:run => true)
+  it "calls the correct methods in order" do
+    subject.stub(:run => true)
 
-      subject.should_receive(:ensure_heroku_remote_exists_for).
-        ordered.
-        with(remote_name)
+    subject.should_receive(:ensure_heroku_remote_exists_for).
+      ordered.
+      with(remote_name)
 
-      subject.should_receive(:pre_deploy).
-        ordered.
-        and_return(true)
+    subject.should_receive(:pre_deploy).
+      ordered.
+      and_return(true)
 
-      subject.should_receive(:git_force_push).
-        ordered.
-        and_return(true)
+    subject.should_receive(:git_force_push).
+      ordered.
+      and_return(true)
 
-      subject.should_receive(:heroku_migrate).
-        ordered.
-        with(remote_name)
+    subject.should_receive(:heroku_migrate).
+      ordered.
+      with(remote_name)
 
-      subject.deploy_to(remote_name)
-    end
+    subject.should_receive(:post_deploy)
 
-    it "deploys to the correct remote" do
-      subject.stub(:ensure_heroku_remote_exists_for => true,
-                   :pre_deploy                      => true,
-                   :run                             => true)
+    subject.deploy_to(remote_name)
+  end
 
-      subject.should_receive(:git_force_push).with(remote_name)
+  it "deploys to the correct remote" do
+    subject.stub(:ensure_heroku_remote_exists_for => true,
+                 :pre_deploy                      => true,
+                 :on_cedar?                       => false,
+                 :run                             => true)
 
-      subject.deploy_to(remote_name)
-    end
+    subject.should_receive(:git_force_push).with(remote_name)
+
+    subject.deploy_to(remote_name)
   end
+end
 
-  describe Deployer, "#git_push" do
-    let(:remote){ 'origin' }
+describe Kumade::Deployer, "#git_push" do
+  let(:remote){ 'origin' }
 
-    before { subject.stub(:say) }
+  before { subject.stub(:say) }
 
-    it "calls `git push`" do
-      subject.should_receive(:run).
-        with("git push #{remote} master").
-        and_return(true)
-      subject.git_push(remote)
-    end
+  it "calls `git push`" do
+    subject.should_receive(:run).
+      with("git push #{remote} master").
+      and_return(true)
+    subject.git_push(remote)
+  end
 
-    context "when `git push` fails" do
-      before { subject.stub(:run => false) }
+  context "when `git push` fails" do
+    before { subject.stub(:run => false) }
 
-      it "prints an error message" do
-        subject.should_receive(:error).with("Failed to push master -> #{remote}")
+    it "prints an error message" do
+      subject.should_receive(:error).with("Failed to push master -> #{remote}")
 
-        subject.git_push(remote)
-      end
+      subject.git_push(remote)
     end
+  end
 
-    context "when `git push` succeeds" do
-      before { subject.stub(:run => true) }
+  context "when `git push` succeeds" do
+    before { subject.stub(:run => true) }
 
-      it "does not raise an error" do
-        subject.should_not_receive(:error)
-        subject.git_push(remote)
-      end
+    it "does not raise an error" do
+      subject.should_not_receive(:error)
+      subject.git_push(remote)
+    end
 
-      it "prints a success message" do
-        subject.should_receive(:success).with("Pushed master -> #{remote}")
+    it "prints a success message" do
+      subject.should_receive(:success).with("Pushed master -> #{remote}")
 
-        subject.git_push(remote)
-      end
+      subject.git_push(remote)
     end
   end
+end
 
-  describe Deployer, "#git_force_push" do
-    let(:remote){ 'origin' }
-    before { subject.stub(:say) }
+describe Kumade::Deployer, "#git_force_push" do
+  let(:remote){ 'origin' }
+  before { subject.stub(:say) }
 
-    it "calls `git push -f`" do
-      subject.should_receive(:run).
-        with("git push -f #{remote} master").
-        and_return(true)
-      subject.git_force_push(remote)
-    end
+  it "calls `git push -f`" do
+    subject.should_receive(:run).
+      with("git push -f #{remote} master").
+      and_return(true)
+    subject.git_force_push(remote)
+  end
 
-    context "when `git push -f` fails" do
-      before do
-        subject.stub(:run => false)
-      end
+  context "when `git push -f` fails" do
+    before do
+      subject.stub(:run => false)
+    end
 
-      it "prints an error" do
-        subject.should_receive(:error).with("Failed to force push master -> #{remote}")
-        subject.git_force_push(remote)
-      end
+    it "prints an error" do
+      subject.should_receive(:error).with("Failed to force push master -> #{remote}")
+      subject.git_force_push(remote)
     end
+  end
 
-    context "when `git push -f` succeeds" do
-      before do
-        subject.stub(:run => true)
-        subject.stub(:say)
-      end
+  context "when `git push -f` succeeds" do
+    before do
+      subject.stub(:run => true)
+      subject.stub(:say)
+    end
 
-      it "does not raise an error" do
-        subject.should_not_receive(:error)
-        subject.git_force_push(remote)
-      end
+    it "does not raise an error" do
+      subject.should_not_receive(:error)
+      subject.git_force_push(remote)
+    end
 
-      it "prints a success message" do
-        subject.should_receive(:success).
-          with("Force pushed master -> #{remote}")
+    it "prints a success message" do
+      subject.should_receive(:success).
+        with("Force pushed master -> #{remote}")
 
-        subject.git_force_push(remote)
-      end
+      subject.git_force_push(remote)
     end
   end
+end
 
-  describe Deployer, "#ensure_clean_git" do
-    before { subject.stub(:say) }
+describe Kumade::Deployer, "#ensure_clean_git" do
+  before { subject.stub(:say) }
 
-    context "when git is dirty" do
-      before { subject.stub(:git_dirty? => true) }
+  context "when git is dirty" do
+    before { subject.stub(:git_dirty? => true) }
 
-      it "prints an error" do
-        subject.should_receive(:error).with("Cannot deploy: repo is not clean.")
-        subject.ensure_clean_git
-      end
+    it "prints an error" do
+      subject.should_receive(:error).with("Cannot deploy: repo is not clean.")
+      subject.ensure_clean_git
     end
+  end
 
-    context "when git is clean" do
-      before { subject.stub(:git_dirty? => false) }
+  context "when git is clean" do
+    before { subject.stub(:git_dirty? => false) }
 
-      it "prints a success message" do
-        subject.should_not_receive(:error)
-        subject.should_receive(:success).with("Git repo is clean")
+    it "prints a success message" do
+      subject.should_not_receive(:error)
+      subject.should_receive(:success).with("Git repo is clean")
 
-        subject.ensure_clean_git
-      end
+      subject.ensure_clean_git
     end
   end
+end
 
-  describe Deployer, "#ensure_rake_passes" do
-    context "with a default task" do
-      before do
-        subject.stub(:default_task_exists? => true)
-      end
+describe Kumade::Deployer, "#ensure_rake_passes" do
+  context "with a default task" do
+    before do
+      subject.stub(:default_task_exists? => true)
+    end
 
-      it "prints a success message if the default task succeeds" do
-        subject.stub(:rake_succeeded? => true)
-        subject.should_not_receive(:error)
-        subject.should_receive(:success).with("Rake passed")
+    it "prints a success message if the default task succeeds" do
+      subject.stub(:rake_succeeded? => true)
+      subject.should_not_receive(:error)
+      subject.should_receive(:success).with("Rake passed")
 
-        subject.ensure_rake_passes
-      end
+      subject.ensure_rake_passes
+    end
 
-      it "prints an error if the default task failse" do
-        subject.stub(:rake_succeeded? => false)
-        subject.should_receive(:error).with("Cannot deploy: tests did not pass")
+    it "prints an error if the default task failse" do
+      subject.stub(:rake_succeeded? => false)
+      subject.should_receive(:error).with("Cannot deploy: tests did not pass")
 
-        subject.ensure_rake_passes
-      end
+      subject.ensure_rake_passes
     end
   end
+end
 
-  describe Deployer, "#default_task_exists?" do
-    it "returns true because a default task does exist" do
-      subject.default_task_exists?.should be_true
-    end
+describe Kumade::Deployer, "#default_task_exists?" do
+  it "returns true because a default task does exist" do
+    subject.default_task_exists?.should be_true
   end
+end
 
-  describe Deployer, "#rake_succeeded?" do
-    it "returns true if the default task passed" do
-      subject.should_receive(:system).with("bundle exec rake").and_return(true)
+describe Kumade::Deployer, "#rake_succeeded?" do
+  it "returns true if the default task passed" do
+    subject.should_receive(:run).with("bundle exec rake").and_return(true)
 
-      subject.rake_succeeded?.should be_true
-    end
+    subject.rake_succeeded?.should be_true
+  end
 
-    it "returns false if the default task failed" do
-      subject.should_receive(:system).with("bundle exec rake").and_raise("blerg")
-      subject.rake_succeeded?.should be_false
-    end
+  it "returns false if the default task failed" do
+    subject.should_receive(:run).with("bundle exec rake").and_raise("blerg")
+    subject.rake_succeeded?.should be_false
   end
+end
 
-  describe Deployer, "#package_assets" do
-    context "with Jammit installed" do
-      it "calls package_with_jammit" do
-        subject.should_receive(:package_with_jammit)
-        subject.package_assets
-      end
+describe Kumade::Deployer, "#package_assets" do
+  context "with Jammit installed" do
+    it "calls package_with_jammit" do
+      subject.should_receive(:package_with_jammit)
+      subject.package_assets
     end
+  end
 
-    context "with Jammit not installed" do
-      before { subject.stub(:jammit_installed? => false) }
-      it "does not call package_with_jammit" do
-        subject.should_not_receive(:package_with_jammit)
-        subject.package_assets
-      end
+  context "with Jammit not installed" do
+    before { subject.stub(:jammit_installed? => false) }
+    it "does not call package_with_jammit" do
+      subject.should_not_receive(:package_with_jammit)
+      subject.package_assets
     end
+  end
 
-    context "with More installed" do
-      before do
-        subject.stub(:jammit_installed? => false)
-        subject.stub(:more_installed? => true)
-      end
-
-      it "calls package_with_more" do
-        subject.should_receive(:package_with_more)
-        subject.package_assets
-      end
+  context "with More installed" do
+    before do
+      subject.stub(:jammit_installed? => false)
+      subject.stub(:more_installed? => true)
     end
 
-    context "with More not installed" do
-      before do
-        subject.stub(:jammit_installed? => false)
-        subject.stub(:more_installed? => false)
-      end
-
-      it "does not call package_with_more" do
-        subject.should_not_receive(:package_with_more)
-        subject.package_assets
-      end
+    it "calls package_with_more" do
+      subject.should_receive(:package_with_more)
+      subject.package_assets
     end
   end
 
-  describe Deployer, "#package_with_jammit" do
+  context "with More not installed" do
     before do
-      subject.stub(:git_add_and_commit_all_assets_in)
-      subject.stub(:say)
-      Jammit.stub(:package!)
+      subject.stub(:jammit_installed? => false)
+      subject.stub(:more_installed? => false)
     end
 
-    it "calls Jammit.package!" do
-      Jammit.should_receive(:package!).once
-      subject.package_with_jammit
+    it "does not call package_with_more" do
+      subject.should_not_receive(:package_with_more)
+      subject.package_assets
     end
+  end
+end
 
-    context "with updated assets" do
-      before { subject.stub(:git_dirty? => true) }
+describe Kumade::Deployer, "#package_with_jammit" do
+  before do
+    subject.stub(:git_add_and_commit_all_assets_in)
+    subject.stub(:say)
+    Jammit.stub(:package!)
+  end
 
-      it "prints the correct message" do
-        subject.should_receive(:success).with("Packaged assets with Jammit")
+  it "calls Jammit.package!" do
+    Jammit.should_receive(:package!).once
+    subject.package_with_jammit
+  end
 
-        subject.package_with_jammit
-      end
+  context "with updated assets" do
+    before { subject.stub(:git_dirty? => true) }
 
-      it "calls git_add_and_commit_all_assets_in" do
-        subject.stub(:jammit_assets_path => 'jammit-assets')
-        subject.should_receive(:git_add_and_commit_all_assets_in).
-          with('jammit-assets').
-          and_return(true)
+    it "prints the correct message" do
+      subject.should_receive(:success).with("Packaged assets with Jammit")
 
-        subject.package_with_jammit
-      end
+      subject.package_with_jammit
     end
 
-    it "prints an error if packaging failed" do
-      Jammit.stub(:package!) do
-        raise Jammit::MissingConfiguration.new("random Jammit error")
-      end
-      subject.should_receive(:error).with("Error: Jammit::MissingConfiguration: random Jammit error")
+    it "calls git_add_and_commit_all_assets_in" do
+      subject.stub(:jammit_assets_path => 'jammit-assets')
+      subject.should_receive(:git_add_and_commit_all_assets_in).
+        with('jammit-assets').
+        and_return(true)
 
       subject.package_with_jammit
     end
+  end
 
-    context "no assets were added" do
-      before { subject.stub(:git_dirty? => false) }
+  it "prints an error if packaging failed" do
+    Jammit.stub(:package!) do
+      raise Jammit::MissingConfiguration.new("random Jammit error")
+    end
+    subject.should_receive(:error).with("Error: Jammit::MissingConfiguration: random Jammit error")
 
-      it "does not call git_add_and_commit_all_jammit_assets" do
-        subject.should_not_receive(:git_add_and_commit_all_assets_in)
+    subject.package_with_jammit
+  end
 
-        subject.package_with_jammit
-      end
+  context "no assets were added" do
+    before { subject.stub(:git_dirty? => false) }
 
-      it "does not print a success message" do
-        subject.should_not_receive(:success)
-        subject.package_with_jammit
-      end
-    end
-  end
+    it "does not call git_add_and_commit_all_jammit_assets" do
+      subject.should_not_receive(:git_add_and_commit_all_assets_in)
 
-  describe Deployer, "#package_with_more" do
-    before do
-      subject.stub(:git_add_and_commit_all_assets_in => true,
-                   :more_assets_path                 => 'assets')
-      subject.stub(:say)
+      subject.package_with_jammit
     end
 
-    it "calls the more:generate task" do
-      subject.should_receive(:system).with("bundle exec rake more:generate")
-      subject.package_with_more
+    it "does not print a success message" do
+      subject.should_not_receive(:success)
+      subject.package_with_jammit
     end
+  end
+end
 
-    context "with changed assets" do
-      it "prints a success message" do
-        subject.stub(:system).with("bundle exec rake more:generate")
-        subject.stub(:git_dirty? => true)
-        subject.should_receive(:success).with("Packaged assets with More")
+describe Kumade::Deployer, "#package_with_more" do
+  before do
+    subject.stub(:git_add_and_commit_all_assets_in => true,
+                 :more_assets_path                 => 'assets')
+    subject.stub(:say)
+  end
 
-        subject.package_with_more
-      end
+  it "calls the more:generate task" do
+    subject.should_receive(:run).with("bundle exec rake more:generate")
+    subject.package_with_more
+  end
 
-      it "calls git_add_and_commit_all_assets_in if assets were added" do
-        subject.stub(:git_dirty?       => true,
-                     :more_assets_path => 'blerg')
-        subject.stub(:system).with("bundle exec rake more:generate")
-        subject.should_receive(:git_add_and_commit_all_assets_in).
-          with('blerg').
-          and_return(true)
+  context "with changed assets" do
+    it "prints a success message" do
+      subject.stub(:run).with("bundle exec rake more:generate")
+      subject.stub(:git_dirty? => true)
+      subject.should_receive(:success).with("Packaged assets with More")
 
-        subject.package_with_more
-      end
+      subject.package_with_more
     end
 
-    context "with no changed assets" do
-      it "prints no message" do
-        subject.stub(:system).with("bundle exec rake more:generate")
-        subject.stub(:git_dirty? => false)
-        subject.should_not_receive(:say)
+    it "calls git_add_and_commit_all_assets_in if assets were added" do
+      subject.stub(:git_dirty?       => true,
+                   :more_assets_path => 'blerg')
+      subject.stub(:run).with("bundle exec rake more:generate")
+      subject.should_receive(:git_add_and_commit_all_assets_in).
+        with('blerg').
+        and_return(true)
 
-        subject.package_with_more
-      end
+      subject.package_with_more
+    end
+  end
 
-      it "does not call git_add_and_commit_all_more_assets" do
-        subject.stub(:system).with("bundle exec rake more:generate")
-        subject.stub(:git_dirty? => false)
-        subject.should_not_receive(:git_add_and_commit_all_assets_in)
+  context "with no changed assets" do
+    it "prints no message" do
+      subject.stub(:run).with("bundle exec rake more:generate")
+      subject.stub(:git_dirty? => false)
+      subject.should_not_receive(:say)
 
-        subject.package_with_more
-      end
+      subject.package_with_more
     end
 
-    it "prints an error if packaging failed" do
-      subject.stub(:system) do |arg|
-        if arg == "bundle exec rake more:generate"
-          raise "blerg"
-        end
-      end
-
-      subject.should_receive(:error).with("Error: RuntimeError: blerg")
+    it "does not call git_add_and_commit_all_more_assets" do
+      subject.stub(:run).with("bundle exec rake more:generate")
+      subject.stub(:git_dirty? => false)
+      subject.should_not_receive(:git_add_and_commit_all_assets_in)
 
       subject.package_with_more
     end
   end
 
-  describe Deployer, "#git_add_and_commit_all_assets_in" do
-    before do
-      subject.stub(:run => true)
-      subject.stub(:say)
+  it "prints an error if packaging failed" do
+    subject.stub(:run) do |arg|
+      if arg == "bundle exec rake more:generate"
+        raise "blerg"
+      end
     end
 
-    it "prints a success message" do
-      subject.should_receive(:success).with("Added and committed all assets")
+    subject.should_receive(:error).with("Error: RuntimeError: blerg")
 
-      subject.git_add_and_commit_all_assets_in('blerg')
-    end
+    subject.package_with_more
+  end
+end
 
-    it "runs the correct commands" do
-      subject.should_receive(:run).
-        with("git add blerg && git commit -m 'Assets'")
+describe Kumade::Deployer, "#git_add_and_commit_all_assets_in" do
+  before do
+    subject.stub(:run => true)
+    subject.stub(:say)
+  end
 
-      subject.git_add_and_commit_all_assets_in('blerg')
-    end
+  it "prints a success message" do
+    subject.should_receive(:success).with("Added and committed all assets")
 
-    it "prints an error if it could not add and commit assets" do
-      subject.stub(:run => false)
-      subject.should_receive(:error).with("Cannot deploy: couldn't commit assets")
+    subject.git_add_and_commit_all_assets_in('blerg')
+  end
 
-      subject.git_add_and_commit_all_assets_in('blerg')
-    end
+  it "runs the correct commands" do
+    subject.should_receive(:run).
+      with("git checkout -b deploy && git add -f blerg && git commit -m 'Compiled assets'")
+
+    subject.git_add_and_commit_all_assets_in('blerg')
   end
 
-  describe Deployer, "#jammit_assets_path" do
-    it "returns the correct asset path" do
-      Jammit.stub(:package_path => 'blerg')
-      current_dir = File.expand_path(Dir.pwd)
-      subject.jammit_assets_path.should == File.join(current_dir, 'public', 'blerg')
-    end
+  it "prints an error if it could not add and commit assets" do
+    subject.stub(:run => false)
+    subject.should_receive(:error).with("Cannot deploy: couldn't commit assets")
+
+    subject.git_add_and_commit_all_assets_in('blerg')
+  end
+end
+
+describe Kumade::Deployer, "#jammit_assets_path" do
+  it "returns the correct asset path" do
+    Jammit.stub(:package_path => 'blerg')
+    current_dir = File.expand_path(Dir.pwd)
+    subject.jammit_assets_path.should == File.join(current_dir, 'public', 'blerg')
   end
+end
 
-  describe Deployer, "#more_assets_path" do
-    it "returns the correct asset path" do
-      module ::Less
-        class More
-          def self.destination_path
-            'blerg'
-          end
+describe Kumade::Deployer, "#more_assets_path" do
+  it "returns the correct asset path" do
+    module ::Less
+      class More
+        def self.destination_path
+          'blerg'
         end
       end
-      subject.more_assets_path.should == 'public/blerg'
     end
+    subject.more_assets_path.should == 'public/blerg'
   end
+end
 
-  describe Deployer, "#jammit_installed?" do
-    it "returns true because it's loaded by the Gemfile" do
-      subject.jammit_installed?.should be_true
-    end
+describe Kumade::Deployer, "#jammit_installed?" do
+  it "returns true because it's loaded by the Gemfile" do
+    Kumade::Deployer.new.jammit_installed?.should be_true
   end
 
-  describe Deployer, "#more_installed?" do
-    before do
-      if defined?(Less)
-        Object.send(:remove_const, :Less)
-      end
-    end
-
-    it "returns false if it does not find Less::More" do
-      subject.more_installed?.should be_false
-    end
+  it "returns false if jammit is not installed" do
+    Kumade::Deployer.new.jammit_installed?.should be_true
+  end
+end
 
-    it "returns true if it finds Less::More" do
-      module Less
-        class More
-        end
-      end
-      subject.more_installed?.should be_true
+describe Kumade::Deployer, "#more_installed?" do
+  before do
+    if defined?(Less)
+      Object.send(:remove_const, :Less)
     end
   end
 
-  describe Deployer, "#heroku_migrate" do
-    let(:environment){ 'staging' }
-    let(:app_name){ 'sushi' }
+  it "returns false if it does not find Less::More" do
+    Kumade::Deployer.new.more_installed?.should be_false
+  end
 
-    before do
-      subject.stub(:say)
-      force_add_heroku_remote(environment, app_name)
+  it "returns true if it finds Less::More" do
+    module Less
+      class More
+      end
     end
+    Kumade::Deployer.new.more_installed?.should be_true
+  end
+end
 
-    after { remove_remote(environment) }
-
-    it "runs db:migrate with the correct app" do
-      subject.should_receive(:run).
-        with("bundle exec heroku rake db:migrate --app #{app_name}")
-      subject.should_receive(:success).with("Migrated #{app_name}")
+describe Kumade::Deployer, "#heroku_migrate" do
+  let(:environment){ 'staging' }
+  let(:app_name){ 'sushi' }
 
-      subject.heroku_migrate(environment)
-    end
+  before do
+    subject.stub(:say)
+    force_add_heroku_remote(environment, app_name)
   end
 
-  describe Deployer, "#string_present?" do
-    it "returns false for nil" do
-      subject.string_present?(nil).should be_false
-    end
+  after { remove_remote(environment) }
 
-    it "returns false for false" do
-      subject.string_present?(false).should be_false
-    end
+  it "runs db:migrate with the correct app" do
+    subject.stub(:run => true)
+    subject.should_receive(:heroku).
+      with("rake db:migrate", app_name)
+    subject.should_receive(:success).with("Migrated #{app_name}")
 
-    it "returns false for true" do
-      subject.string_present?(true).should be_false
-    end
+    subject.heroku_migrate(environment)
+  end
+end
 
-    it "returns false for an empty string" do
-      subject.string_present?('').should be_false
-    end
+describe Kumade::Deployer, "#ensure_heroku_remote_exists_for" do
+  let(:environment){ 'staging' }
+  let(:bad_environment){ 'bad' }
+  let(:staging_app_name) { 'staging-sushi' }
 
-    it "returns true for a non-empty string" do
-      subject.string_present?('abc').should be_true
-    end
+  before do
+    subject.stub(:say)
+    force_add_heroku_remote(environment, staging_app_name)
+    `git remote add #{bad_environment} blerg@example.com`
   end
 
-  describe Deployer, "#ensure_heroku_remote_exists_for" do
-    let(:environment){ 'staging' }
-    let(:bad_environment){ 'bad' }
-    let(:staging_app_name) { 'staging-sushi' }
+  after do
+    remove_remote(environment)
+    remove_remote(bad_environment)
+  end
 
-    before do
-      subject.stub(:say)
-      force_add_heroku_remote(environment, staging_app_name)
-      `git remote add #{bad_environment} blerg@example.com`
-    end
+  context "when the remote points to Heroku" do
+    it "does not print an error" do
+      subject.should_not_receive(:error)
 
-    after do
-      remove_remote(environment)
-      remove_remote(bad_environment)
+      subject.ensure_heroku_remote_exists_for(environment)
     end
 
-    context "when the remote points to Heroku" do
-      it "does not print an error" do
-        subject.should_not_receive(:error)
-
-        subject.ensure_heroku_remote_exists_for(environment)
-      end
-
-      it "prints a success message" do
-        subject.should_receive(:success).with("#{environment} is a Heroku remote")
+    it "prints a success message" do
+      subject.should_receive(:success).with("#{environment} is a Heroku remote")
 
-        subject.ensure_heroku_remote_exists_for(environment)
-      end
+      subject.ensure_heroku_remote_exists_for(environment)
     end
+  end
 
 
-    context "when the remote does not exist" do
-      before { remove_remote(environment) }
+  context "when the remote does not exist" do
+    before { remove_remote(environment) }
 
-      it "prints an error" do
-        subject.should_receive(:error).with(%{Cannot deploy: "#{environment}" remote does not exist})
+    it "prints an error" do
+      subject.should_receive(:error).with(%{Cannot deploy: "#{environment}" remote does not exist})
 
-        subject.ensure_heroku_remote_exists_for(environment)
-      end
+      subject.ensure_heroku_remote_exists_for(environment)
     end
+  end
 
-    context "when the remote does not point to Heroku" do
-      it "prints an error" do
-        subject.should_receive(:error).with(%{Cannot deploy: "#{bad_environment}" remote does not point to Heroku})
+  context "when the remote does not point to Heroku" do
+    it "prints an error" do
+      subject.should_receive(:error).with(%{Cannot deploy: "#{bad_environment}" remote does not point to Heroku})
 
-        subject.ensure_heroku_remote_exists_for(bad_environment)
-      end
+      subject.ensure_heroku_remote_exists_for(bad_environment)
     end
   end
+end
 
-  describe Deployer, "#remote_exists?" do
-    let(:remote_name){ 'staging' }
+describe Kumade::Deployer, "#remote_exists?" do
+  let(:remote_name){ 'staging' }
 
-    before { force_add_heroku_remote(remote_name, 'i-am-a-heroku-app') }
-    after  { remove_remote(remote_name) }
+  before { force_add_heroku_remote(remote_name, 'i-am-a-heroku-app') }
+  after  { remove_remote(remote_name) }
 
-    it "returns true if the remote exists" do
-      subject.remote_exists?(remote_name).should be_true
-    end
+  it "returns true if the remote exists" do
+    subject.remote_exists?(remote_name).should be_true
+  end
 
-    it "returns false if the remote does not exist" do
-      remove_remote(remote_name)
+  it "returns false if the remote does not exist" do
+    remove_remote(remote_name)
 
-      subject.remote_exists?(remote_name).should be_false
-    end
+    subject.remote_exists?(remote_name).should be_false
   end
+end
+
+describe Kumade::Deployer, "#heroku" do
+  let(:app_name){ 'sushi' }
 
-  describe Deployer, "#announce" do
-    it "exists" do
-      subject.should respond_to(:announce)
+  context "when on Cedar" do
+    before { subject.stub(:on_cedar? => true) }
+    it "runs commands with `run`" do
+      subject.should_receive(:run_or_error).with("bundle exec heroku run rake --app #{app_name}", //)
+      subject.heroku("rake", app_name)
     end
   end
 
-  describe Deployer, "#success" do
-    it "exists" do
-      subject.should respond_to(:success)
+  context "when not on Cedar" do
+    before { subject.stub(:on_cedar? => false) }
+    it "runs commands without `run`" do
+      subject.should_receive(:run_or_error).with("bundle exec heroku rake --app #{app_name}", //)
+      subject.heroku("rake", app_name)
     end
   end
+end
 
-  describe Deployer, "#error" do
-    it "exists" do
-      subject.should respond_to(:error)
-    end
+describe Kumade::Deployer, "#announce" do
+  it "exists" do
+    subject.should respond_to(:announce)
+  end
+end
+
+describe Kumade::Deployer, "#success" do
+  it "exists" do
+    subject.should respond_to(:success)
+  end
+end
+
+describe Kumade::Deployer, "#error" do
+  it "exists" do
+    subject.should respond_to(:error)
+  end
+end
+
+describe Kumade::Deployer, "#post_deploy" do
+  before { subject.stub(:run => true, :say => true) }
+
+  it "cleans up the deploy branch" do
+    subject.should_receive(:run).with('git checkout master && git branch -D deploy')
+    subject.post_deploy
   end
 end