kumade 0.2.2 → 0.3.0

data/.travis.yml

@@ -2,6 +2,7 @@ rvm:
   - 1.9.2
   - 1.8.7
   - ree-1.8.7
+  - 1.8.7-p249
 # branches:
 #   only:
 #     - master

data/README.md

@@ -3,6 +3,11 @@ 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.
 
+## Development
+Development is happening very fast, and the internals are in constant flux. The
+public API is constant (e.g. `kumade production` will work), but you may have to
+rebase against master a couple times before your pull request can be merged.
+
 ## What does Kumade do?
 Before deploying, Kumade ensures the git repo is clean and that all tests pass.
 After that, it packages assets using
@@ -28,6 +33,14 @@ For example, if you have a remote named "bamboo":
 
     $ bundle exec kumade bamboo
 
+or
+
+    # in your Rakefile:
+    require 'kumade'
+
+    # kumade auto-generates a deploy:ENV task for every Heroku environment
+    $ rake deploy:bamboo
+
 which will autodetect the name of the Heroku app that the bamboo remote points
 to and deploy to it.
 
@@ -40,93 +53,13 @@ The default is to deploy to staging:
 
     $ bundle exec kumade # equivalent to "bundle exec kumade staging"
 
+
 ## Does it support the Cedar stack?
 
 Yes. To indicate that a particular app is using Cedar, run with the -c flag:
 
     bundle exec kumade bamboo -c
 
-## Sample Output
-
-### Normal mode
-
-    $ kumade heroku-staging
-    ==> Deploying to: heroku-staging
-    ==> heroku-staging is a Heroku remote
-    ==> Git repo is clean
-    /Users/gabe/.rvm/rubies/ree-1.8.7-2011.03/bin/ruby -S bundle exec rspec [blah blah]
-    ....
-    rake output removed
-    ...
-    ==> Rake passed
-    ==> Packaged assets with Jammit
-    ==> + git add /Users/gabe/thoughtbot/sushi/public/assets && git commit -m 'Assets'
-    [master bc8932b] Assets
-    4 files changed, 0 insertions(+), 0 deletions(-)
-    ==> - true
-    ==> Added and committed all assets
-    ==> + git push origin master
-    Counting objects: 15, done.
-    Delta compression using up to 2 threads.
-    Compressing objects: 100% (8/8), done.
-    Writing objects: 100% (8/8), 639 bytes, done.
-    Total 8 (delta 7), reused 0 (delta 0)
-    To git@github.com:sushi/sushi.git
-      a465afd..bc8932b  master -> master
-    ==> - true
-    ==> Pushed master -> origin
-    ==> + git push -f heroku-staging master
-    Counting objects: 15, done.
-    Delta compression using up to 2 threads.
-    Compressing objects: 100% (8/8), done.
-    Writing objects: 100% (8/8), 639 bytes, done.
-    Total 8 (delta 7), reused 0 (delta 0)
-
-    -----> Heroku receiving push
-    -----> Rails app detected
-    -----> Detected Rails is not set to serve static_assets
-          Installing rails3_serve_static_assets... done
-    -----> Configure Rails 3 to disable x-sendfile
-          Installing rails3_disable_x_sendfile... done
-    -----> Configure Rails to log to stdout
-          Installing rails_log_stdout... done
-    -----> Gemfile detected, running Bundler version 1.0.7
-          All dependencies are satisfied
-    -----> Compiled slug size is 65.5MB
-    -----> Launching... done, v172
-          http://staging-sushi.heroku.com deployed to Heroku
-
-    To git@heroku.com:staging-sushi.git
-      a465afd..bc8932b  master -> master
-    ==> - true
-    ==> Force pushed master -> heroku-staging
-    ==> + bundle exec heroku rake db:migrate --app staging-sushi
-    ... Postgres output removed ...
-    ==> - false
-    ==> Migrated staging-sushi
-    ==> Deployed to: heroku-staging
-
-### Pretend mode
-
-    $ kumade heroku-staging -p
-    ==> In Pretend Mode
-    ==> Deploying to: heroku-staging
-    ==> heroku-staging is a Heroku remote
-    ==> Git repo is clean
-    ==> Rake passed
-    ==> Packaged assets with Jammit
-    ==> Pushed master -> origin
-    ==> Force pushed master -> heroku-staging
-    ==> Migrated staging-sushi
-    ==> Deployed to: heroku-staging
-
-### Pretend Mode with a non-Heroku remote
-
-    $ kumade origin -p
-    ==> In Pretend Mode
-    ==> Deploying to: origin
-    ==> ! Cannot deploy: "origin" remote does not point to Heroku
-
 ## Compatibility
 
 Tested against:
@@ -137,7 +70,7 @@ Tested against:
 
 ## Misc Features
 
-Want to run a task before bundling your assets on deploy? In your rails app's rake tasks, drop in:
+Want to run a task before bundling your assets on deploy? In your Rails app's rake tasks, drop in:
 
 ``` ruby
 namespace :kumade do

data/features/kumade_executable.feature

@@ -26,8 +26,8 @@ Feature: Kumade executable
       ==> Pushed master -> origin
                run  git branch deploy
                run  git push -f pretend-staging deploy:master
-      ==> Force pushed master -> pretend-staging
-      ==> Migrated pretend-staging-app
+      ==> Pushed deploy:master -> pretend-staging
+      ==> Migrated pretend-staging
                run  git checkout master && git branch -D deploy
       ==> Deployed to: pretend-staging
       """
@@ -57,8 +57,8 @@ Feature: Kumade executable
       ==> Pushed new_branch -> origin
                run  git branch deploy
                run  git push -f pretend-staging deploy:master
-      ==> Force pushed new_branch -> pretend-staging
-      ==> Migrated pretend-staging-app
+      ==> Pushed deploy:master -> pretend-staging
+      ==> Migrated pretend-staging
                run  git checkout new_branch && git branch -D deploy
       ==> Deployed to: pretend-staging
       """

data/kumade.gemspec

@@ -7,8 +7,8 @@ Gem::Specification.new do |s|
   s.version     = Kumade::VERSION
   s.authors     = ["Gabe Berke-Williams", "thoughtbot"]
   s.email       = ["gabe@thoughtbot.com", "support@thoughtbot.com"]
-  s.homepage    = ""
-  s.summary     = %q{Simple rake tasks for deploying to Heroku}
+  s.homepage    = "http://thoughtbot.com/community/"
+  s.summary     = %q{A well-tested script for easy deploying to Heroku}
   s.description = s.summary
 
   s.files         = `git ls-files`.split("\n")
@@ -18,8 +18,9 @@ Gem::Specification.new do |s|
 
   s.add_dependency('heroku', '~> 2.0')
   s.add_dependency('thor', '~> 0.14')
+  s.add_dependency('rake', '>= 0.8.7')
 
-  s.add_development_dependency('rake', '~> 0.8.7')
+  s.add_development_dependency('rake', '>= 0.8.7')
   s.add_development_dependency('rspec', '~> 2.6.0')
   s.add_development_dependency('cucumber', '~> 1.0.2')
   s.add_development_dependency('aruba', '~> 0.4.3')

data/lib/kumade.rb

@@ -1,29 +1,13 @@
 require 'rake'
 require 'thor'
+require 'stringio'
 
+require 'kumade/base'
+require 'kumade/git'
 require 'kumade/deployer'
 require 'kumade/runner'
 require 'kumade/railtie'
+require 'kumade/deployment_error'
 
 module Kumade
-  def self.app_for(environment)
-    heroku_git_url = `git config --get remote.#{environment}.url`.strip
-    if heroku_git_url =~ /^git@heroku\.com:(.+)\.git$/
-      $1
-    else
-      nil
-    end
-  end
-  def self.environments
-    url_remotes = `git remote`.strip.split("\n").map{|remote| [remote, `git config --get remote.#{remote}.url`.strip] }.select{|remote| remote.last =~ /^git@heroku\.com:(.+)\.git$/}.map{|remote| remote.first}
-  end
-
-  def self.on_cedar!(app)
-    @cedar_apps ||= []
-    @cedar_apps << app
-  end
-
-  def self.cedar?(app)
-    @cedar_apps.include?(app)
-  end
 end

data/lib/kumade/base.rb

@@ -0,0 +1,30 @@
+module Kumade
+  class Base < Thor::Shell::Color
+    def initialize
+      super()
+    end
+
+    def run_or_error(commands, error_message)
+      all_commands = [commands].flatten.join(' && ')
+      if @pretending
+        say_status(:run, all_commands)
+      else
+        error(error_message) unless run(all_commands)
+      end
+    end
+
+    def run(command, config = {})
+      say_status :run, command
+      config[:capture] ? `#{command}` : system("#{command}")
+    end
+
+    def error(message)
+      say("==> ! #{message}", :red)
+      raise Kumade::DeploymentError.new(message)
+    end
+
+    def success(message)
+      say("==> #{message}", :green)
+    end
+  end
+end

data/lib/kumade/deployer.rb

@@ -1,14 +1,14 @@
 module Kumade
-  class Deployer < Thor::Shell::Color
+  class Deployer < Base
     DEPLOY_BRANCH = "deploy"
-    attr_reader :environment, :pretending
+    attr_reader :environment, :pretending, :git
 
-    def initialize(environment = 'staging', pretending = false, cedar = false)
+    def initialize(environment = 'staging', pretending = false)
       super()
       @environment = environment
       @pretending  = pretending
-      @branch      = current_branch
-      @cedar       = cedar
+      @git         = Git.new(pretending, environment)
+      @branch      = @git.current_branch
     end
 
     def deploy
@@ -26,50 +26,44 @@ module Kumade
     end
 
     def sync_github
-      run_or_error("git push origin #{@branch}",
-                   "Failed to push #{@branch} -> origin")
-      success("Pushed #{@branch} -> origin")
+      git.push(@branch)
     end
 
     def sync_heroku
-      unless branch_exist?(DEPLOY_BRANCH)
-        run_or_error("git branch deploy", "Failed to create #{DEPLOY_BRANCH}")
-      end
-      run_or_error("git push -f #{environment} #{DEPLOY_BRANCH}:master",
-                   "Failed to force push #{DEPLOY_BRANCH} -> #{environment}/master")
-      success("Force pushed #{@branch} -> #{environment}")
+      git.create(DEPLOY_BRANCH)
+      git.push("#{DEPLOY_BRANCH}:master", environment, true)
     end
 
     def heroku_migrate
-      app = Kumade.app_for(environment)
-
-      heroku("rake db:migrate", app) unless pretending
-      success("Migrated #{app}")
+      heroku("rake db:migrate") unless pretending
+      success("Migrated #{environment}")
     end
 
     def post_deploy
-      run_or_error(["git checkout #{@branch}", "git branch -D #{DEPLOY_BRANCH}"],
-                   "Failed to clean up #{DEPLOY_BRANCH} branch")
+      git.delete(DEPLOY_BRANCH, @branch)
     end
 
-    def heroku(command, app)
-      heroku_command = if @cedar
+    def heroku(command)
+      heroku_command = if cedar?
                          "bundle exec heroku run"
                        else
                          "bundle exec heroku"
                        end
-      run_or_error("#{heroku_command} #{command} --app #{app}",
+      run_or_error("#{heroku_command} #{command} --remote #{environment}",
                    "Failed to run #{command} on Heroku")
     end
 
-    def ensure_clean_git
-      if ! pretending && git_dirty?
-        error("Cannot deploy: repo is not clean.")
-      else
-        success("Git repo is clean")
+    def cedar?
+      return @cedar unless @cedar.nil?
+      @cedar = heroku("stack").split("\n").grep(/\*/).any? do |line|
+        line.include?("cedar")
       end
     end
 
+    def ensure_clean_git
+      git.ensure_clean_git
+    end
+
     def package_assets
       invoke_custom_task  if custom_task?
       package_with_jammit if jammit_installed?
@@ -100,7 +94,7 @@ module Kumade
       else
         begin
           run "bundle exec rake more:generate"
-          if git_dirty?
+          if git.dirty?
             success(success_message)
             git_add_and_commit_all_assets_in(more_assets_path)
           end
@@ -116,10 +110,7 @@ module Kumade
     end
 
     def git_add_and_commit_all_assets_in(dir)
-      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"
+      git.add_and_commit_all_in(dir, DEPLOY_BRANCH, 'Compiled assets', "Added and committed all assets", "couldn't commit assets")
     end
 
     def jammit_assets_path
@@ -157,44 +148,9 @@ module Kumade
       Rake::Task.task_defined?("kumade:before_asset_compilation")
     end
 
-    def git_dirty?
-      `git diff --exit-code`
-      !$?.success?
-    end
-
-    def run_or_error(commands, error_message)
-      all_commands = [commands].flatten.join(' && ')
-      if pretending
-        say_status(:run, all_commands)
-      else
-        error(error_message) unless run(all_commands)
-      end
-    end
-
-    def run(command, config = {})
-      say_status :run, command
-      config[:capture] ? `#{command}` : system("#{command}")
-    end
-
-    def branch_exist?(branch)
-        branches = `git branch`
-        regex = Regexp.new('[\\n\\s\\*]+' + Regexp.escape(branch.to_s) + '\\n')
-        result = ((branches =~ regex) ? true : false)
-        return result
-    end
-
-    def error(message)
-      say("==> ! #{message}", :red)
-      exit 1
-    end
-
-    def success(message)
-      say("==> #{message}", :green)
-    end
-
     def ensure_heroku_remote_exists
-      if remote_exists?(environment)
-        if app_name = Kumade.app_for(environment)
+      if git.remote_exists?(environment)
+        if git.heroku_remote?
           success("#{environment} is a Heroku remote")
         else
           error(%{Cannot deploy: "#{environment}" remote does not point to Heroku})
@@ -203,17 +159,5 @@ module Kumade
         error(%{Cannot deploy: "#{environment}" remote does not exist})
       end
     end
-
-    def remote_exists?(remote_name)
-      if pretending
-        true
-      else
-        `git remote` =~ /^#{remote_name}$/
-      end
-    end
-
-    def current_branch
-      `git symbolic-ref HEAD`.sub("refs/heads/", "").strip
-    end
   end
 end

data/lib/kumade/deployment_error.rb

@@ -0,0 +1,4 @@
+module Kumade
+  class DeploymentError < StandardError
+  end
+end

data/lib/kumade/git.rb

@@ -0,0 +1,73 @@
+module Kumade
+  class Git < Base
+    attr_reader :environment
+    def initialize(pretending, environment)
+      super()
+      @pretending = pretending
+      @environment = environment
+    end
+
+    def heroku_remote?
+      `git config --get remote.#{environment}.url`.strip =~ /^git@heroku\..+:(.+)\.git$/
+    end
+
+    def self.environments
+      url_remotes = `git remote`.strip.split("\n").map{|remote| [remote, `git config --get remote.#{remote}.url`.strip] }.select{|remote| remote.last =~ /^git@heroku\.com:(.+)\.git$/}.map{|remote| remote.first}
+    end
+
+    def push(branch, remote = 'origin', force = false)
+      command = ["git push"]
+      command << "-f" if force
+      command << remote
+      command << branch
+      command = command.join(" ")
+      run_or_error([command], "Failed to push #{branch} -> #{remote}")
+      success("Pushed #{branch} -> #{remote}")
+    end
+
+    def create(branch)
+      unless branch_exist?(branch)
+        run_or_error("git branch #{branch}", "Failed to create #{branch}")
+      end
+    end
+
+    def delete(branch_to_delete, branch_to_checkout)
+      run_or_error(["git checkout #{branch_to_checkout}", "git branch -D #{branch_to_delete}"],
+                   "Failed to clean up #{branch_to_delete} branch")
+    end
+
+    def add_and_commit_all_in(dir, branch, commit_message, success_output, error_output)
+      run_or_error ["git checkout -b #{branch}", "git add -f #{dir}", "git commit -m '#{commit_message}'"],
+                   "Cannot deploy: #{error_output}"
+      success success_output
+    end
+
+    def current_branch
+      `git symbolic-ref HEAD`.sub("refs/heads/", "").strip
+    end
+
+    def remote_exists?(remote_name)
+      if @pretending
+        true
+      else
+        `git remote` =~ /^#{remote_name}$/
+      end
+    end
+
+    def dirty?
+      ! system("git diff --exit-code")
+    end
+
+    def ensure_clean_git
+      if ! @pretending && dirty?
+        error("Cannot deploy: repo is not clean.")
+      else
+        success("Git repo is clean")
+      end
+    end
+
+    def branch_exist?(branch)
+      system("git show-ref #{branch}")
+    end
+  end
+end