kumade 0.0.2 → 0.0.3

data/.travis.yml

@@ -0,0 +1,7 @@
+rvm:
+  - 1.9.2
+  - 1.8.7
+  - ree-1.8.7
+# branches:
+#   only:
+#     - master

data/README.md

@@ -1,4 +1,4 @@
-# Kumade
+# Kumade [![Build Status](https://secure.travis-ci.org/gabebw/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.
@@ -7,11 +7,11 @@ well-tested.
 Before deploying, Kumade ensures the git repo is clean and that all tests pass.
 After that, it packages assets using
 [Jammit](http://documentcloud.github.com/jammit/) and/or
-[More](https://github.com/cloudhead/more), commits them, and pushes to
-origin. Then it force pushes to the staging or production remote as
-appropriate and runs `rake db:migrate` on the Heroku app.
+[More](https://github.com/cloudhead/more), commits them, and pushes to origin.
+Then it force pushes to the correct remote and runs `rake db:migrate` on the
+Heroku app.
 
-If any step fails, it immediately raises an error and stops the deploy
+If any step fails, it immediately prints an error and stops the deploy
 process.
 
 ## Install
@@ -22,50 +22,109 @@ gem 'kumade'
 ```
 
 ## Usage
-In your Rakefile:
+kumade will deploy to any remote in the repo.
+For example, if you have a remote named "bamboo":
+
+    $ kumade deploy bamboo
+
+which will autodetect the name of the Heroku app that the bamboo remote points
+to, and deploy to it.
+
+To run in pretend mode, which just prints what would be done:
+
+    $ kumade deploy bamboo -p
+
+The default task is to deploy to staging:
+
+    $ kumade # equivalent to "kumade deploy staging"
+
+## Sample Output
+
+### Normal mode
+
+    $ kumade deploy 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 deploy 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 deploy origin -p
+    ==> In Pretend Mode
+    ==> Deploying to: origin
+    ==> ! Cannot deploy: "origin" remote does not point to Heroku
 
-```ruby
-Kumade.load_tasks
-## Set the name of the staging remote (autodetected by default)
-# Kumade.staging_remote = 'staging'
-## Set the name of the production remote (autodetected by default)
-# Kumade.production_remote = 'production'
-
-# Set the name of the staging app on Heroku (required)
-Kumade.staging_app = 'my-staging-app'
-# Set the name of the production app on Heroku (required)
-Kumade.production_app = 'my-production-app'
-```
-
-Now running `rake -T` shows the new tasks:
-
-```bash
-rake deploy             # Alias for kumade:deploy
-rake deploy:production  # Alias for kumade:deploy:production
-rake deploy:staging     # Alias for kumade:deploy:staging
-
-rake kumade:deploy             # Alias for kumade:deploy:staging
-rake kumade:deploy:production  # Deploy to Heroku production
-rake kumade:deploy:staging     # Deploy to Heroku staging
-```
-
-If you only want the namespaced tasks (the ones with "kumade:" in front), do
-this in your Rakefile:
-
-```ruby
-Kumade.load_namespaced_tasks
-```
-
-Now `rake -T` will only show this:
-
-```bash
-rake kumade:deploy             # Alias for kumade:deploy:staging
-rake kumade:deploy:production  # Deploy to Heroku production
-rake kumade:deploy:staging     # Deploy to Heroku staging
-```
 
 ## Compatibility
-Tested on MRI 1.8.7 and 1.9.2.
+Tested against:
+ * 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

data/bin/kumade

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'kumade'
+
+Kumade::ThorTask.start

data/features/kumade_executable.feature

@@ -0,0 +1,35 @@
+@creates-remote
+Feature: Kumade executable
+  As a user
+  I want to be able to use the kumade executable
+  So I can have a better experience than Rake provides
+
+  Background:
+    Given a directory named "executable"
+    And I cd to "executable"
+    When I create a Heroku remote for "pretend-staging-app" named "pretend-staging"
+    And I create a Heroku remote for "app-two" named "staging"
+
+  Scenario: Pretend mode with a Heroku remote
+    When I run `kumade deploy pretend-staging -p`
+    Then the output should contain "In Pretend Mode"
+    And the output should contain:
+      """
+      ==> Git repo is clean
+      ==> Rake passed
+      ==> Packaged assets with Jammit
+      ==> Pushed master -> origin
+      ==> Force pushed master -> pretend-staging
+      ==> Migrated pretend-staging-app
+      ==> Deployed to: pretend-staging
+      """
+    But the output should not contain "==> Packaged assets with More"
+
+  Scenario: Default environment is staging
+    When I run `kumade -p`
+    Then the output should contain "==> Deployed to: staging"
+
+  Scenario: Can deploy to arbitrary environment
+    When I run `kumade deploy bamboo`
+    Then the output should contain "==> Deploying to: bamboo"
+    Then the output should match /Cannot deploy: /

data/features/step_definitions/dependency_steps.rb

@@ -0,0 +1,3 @@
+When /^I add "([^"]*)" from this project as a dependency$/ do |gem_name|
+  append_to_file('Gemfile', %{\ngem "#{gem_name}", :path => "#{PROJECT_ROOT}"})
+end

data/features/step_definitions/git_steps.rb

@@ -0,0 +1,9 @@
+When /^I create a Heroku remote for "([^"]*)" named "([^"]*)"$/ do |app_name, remote_name|
+  `git remote add #{remote_name} git@heroku.com:#{app_name}.git`
+
+end
+
+After("@creates-remote") do
+  heroku_remotes = `git remote -v show | grep heroku | grep fetch | cut -f1`.strip.split
+  heroku_remotes.each { |remote| `git remote rm #{remote} 2> /dev/null` }
+end

data/features/support/env.rb

@@ -1,5 +1,2 @@
 require 'aruba/cucumber'
 require 'kumade'
-require 'cucumber/rspec/doubles'
-
-PROJECT_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..', '..')).freeze

data/kumade.gemspec

@@ -18,6 +18,7 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   s.add_dependency('heroku')
+  s.add_dependency('thor', '~> 0.14')
 
   s.add_development_dependency('rake', '~> 0.8.7')
   s.add_development_dependency('rspec', '~> 2.6.0')

data/lib/kumade.rb

@@ -1,45 +1,14 @@
 require 'kumade/deployer'
-
-class Kumade
-  def self.load_tasks
-    deployer.load_tasks
-  end
-
-  def self.load_namespaced_tasks
-    deployer.load_namespaced_tasks
-  end
-
-  def self.deployer
-    @deployer ||= Deployer.new
-  end
-
-  class << self
-    attr_writer :staging_remote, :production_remote
-    attr_accessor :staging_app, :production_app
-
-    def reset!
-      @staging_remote    = nil
-      @production_remote = nil
-
-      @staging_app    = nil
-      @production_app = nil
-    end
-
-    def staging_remote
-      @staging_remote ||= local_remote_for_app(Kumade.staging_app)
-    end
-
-    def production_remote
-      @production_remote ||= local_remote_for_app(Kumade.production_app)
-    end
-
-    def local_remote_for_app(app_name)
-      heroku_remote_url = heroku_remote_url_for_app(app_name)
-      `git remote -v | grep push | grep '#{heroku_remote_url}' | cut -f1`.strip
-    end
-
-    def heroku_remote_url_for_app(app_name)
-      "git@heroku.com:#{app_name}.git"
+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]
+    else
+      ""
     end
   end
 end

data/lib/kumade/deployer.rb

@@ -1,12 +1,13 @@
-class Kumade
-  class Deployer
-    def load_tasks
-      load_namespaced_tasks
-      load 'kumade/tasks/deploy.rake'
-    end
+require 'thor/shell'
+require 'rake'
+
+module Kumade
+  class Deployer < Thor::Shell::Color
+    attr_reader :pretending
 
-    def load_namespaced_tasks
-      load 'kumade/tasks/namespaced_deploy.rake'
+    def initialize(pretending = false)
+      super()
+      @pretending = !!pretending
     end
 
     def pre_deploy
@@ -16,51 +17,54 @@ class Kumade
       git_push('origin')
     end
 
-    def deploy_to_staging
-      ensure_staging_app_is_present
-      pre_deploy
-      git_force_push(Kumade.staging_remote)
-      heroku_migrate(:staging)
-    end
-
-    def deploy_to_production
-      ensure_production_app_is_present
+    def deploy_to(environment)
+      string_environment = environment.to_s
+      ensure_heroku_remote_exists_for(string_environment)
       pre_deploy
-      git_force_push(Kumade.production_remote)
-      heroku_migrate(:production)
+      git_force_push(string_environment)
+      heroku_migrate(string_environment)
     end
 
     def git_push(remote)
-      run_or_raise("git push #{remote} master",
-                   "Failed to push master -> #{remote}")
-      announce "Pushed master -> #{remote}"
+      unless pretending
+        run_or_error("git push #{remote} master",
+                    "Failed to push master -> #{remote}")
+      end
+      success("Pushed master -> #{remote}")
     end
 
     def git_force_push(remote)
-      run_or_raise("git push -f #{remote} master",
-                   "Failed to force push master -> #{remote}")
-      announce "Force pushed master -> #{remote}"
+      unless pretending
+        run_or_error("git push -f #{remote} master",
+                    "Failed to force push master -> #{remote}")
+      end
+      success("Force pushed master -> #{remote}")
     end
 
     def heroku_migrate(environment)
-      app = if environment == :staging
-              Kumade.staging_app
-            elsif environment == :production
-              Kumade.production_app
-            end
+      app = Kumade.app_for(environment)
 
-      run("bundle exec heroku rake db:migrate --app #{app}")
+      unless pretending
+        run("bundle exec heroku rake db:migrate --app #{app}")
+      end
+      success("Migrated #{app}")
     end
 
     def ensure_clean_git
-      if git_dirty?
-        raise "Cannot deploy: repo is not clean."
+      if git_dirty? && ! pretending
+        error("Cannot deploy: repo is not clean.")
+      else
+        success("Git repo is clean")
       end
     end
 
     def ensure_rake_passes
       if default_task_exists?
-        raise "Cannot deploy: tests did not pass" unless rake_succeeded?
+        if pretending || rake_succeeded?
+          success("Rake passed")
+        else
+          error("Cannot deploy: tests did not pass")
+        end
       end
     end
 
@@ -70,35 +74,45 @@ class Kumade
     end
 
     def package_with_jammit
-      Jammit.package!
-      announce("Successfully packaged with Jammit")
-      if git_dirty?
-        git_add_and_commit_all_assets_in(absolute_assets_path)
+      begin
+        success_message = "Packaged assets with Jammit"
+
+        if pretending
+          success(success_message)
+        else
+          Jammit.package!
+
+          if git_dirty?
+            success(success_message)
+            git_add_and_commit_all_assets_in(jammit_assets_path)
+          end
+        end
+      rescue => jammit_error
+        error("Error: #{jammit_error.class}: #{jammit_error.message}")
       end
     end
 
     def package_with_more
-      Rake::Task['more:generate'].invoke
-      if git_dirty?
-        announce("Successfully packaged with More")
-
-        git_add_and_commit_all_assets_in(more_assets_path)
+      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)
+        end
+      rescue => more_error
+        error("Error: #{more_error.class}: #{more_error.message}")
       end
     end
 
     def git_add_and_commit_all_assets_in(dir)
-      announce "Committing assets"
-      run_or_raise("git add #{dir} && git commit -m 'Assets'",
+      run_or_error("git add #{dir} && git commit -m 'Assets'",
                     "Cannot deploy: couldn't commit assets")
-    end
 
-    def git_add_and_commit_all_more_assets
-      announce "Committing assets"
-      run_or_raise("git add #{more_assets_path} && git commit -m 'Assets'",
-                    "Cannot deploy: couldn't commit assets")
+      success("Added and committed all assets")
     end
 
-    def absolute_assets_path
+    def jammit_assets_path
       File.join(Jammit::PUBLIC_ROOT, Jammit.package_path)
     end
 
@@ -127,12 +141,12 @@ class Kumade
     end
 
     def default_task_exists?
-      Rake::Task.task_defined?('default')
+      `rake -s -P | grep 'rake default'`.strip.size > 0
     end
 
     def rake_succeeded?
       begin
-        Rake::Task[:default].invoke
+        system "bundle exec rake"
       rescue
         false
       end
@@ -149,27 +163,58 @@ class Kumade
       $?.success?
     end
 
-    def run_or_raise(command, error_message)
-      raise(error_message) unless run(command)
+    def run_or_error(command, error_message)
+      if ! pretending
+        unless run(command)
+          error(error_message)
+        end
+      end
     end
 
     def announce(message)
-      puts message
+      say "==> #{message}"
+    end
+
+    def error(message)
+      say("==> ! #{message}", :red)
+      exit 1
+    end
+
+    def success(message)
+      say("==> #{message}", :green)
     end
 
     def string_present?(maybe_string)
       maybe_string.is_a?(String) && maybe_string.size > 0
     end
 
-    def ensure_staging_app_is_present
-      unless string_present?(Kumade.staging_app)
-        raise "Cannot deploy: Kumade.staging_app is not present"
+    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
+        end
+      else
+        error(%{Cannot deploy: "#{environment}" remote does not exist})
+      end
+    end
+
+    def remote_exists?(remote_name)
+      if pretending
+        true
+      else
+        `git remote`.split("\n").include?(remote_name)
       end
     end
 
-    def ensure_production_app_is_present
-      unless string_present?(Kumade.production_app)
-        raise "Cannot deploy: Kumade.production_app is not present"
+    def initialize_rake
+      if Rake.application.tasks.empty?
+        Rake.application.options.rakelib = ['rakelib']
+        Rake.application.load_rakefile
       end
     end
   end