kumade 0.4.0 → 0.5.0

data/README.md

@@ -85,6 +85,14 @@ You can hook in any custom code you want to run there before deploying!
 Kumade ([pronunciation here](http://translate.google.com/#ja|en|熊手)) means
 "bamboo rake" in Japanese.
 
+## Credits
+
+![thoughtbot](http://thoughtbot.com/images/tm/logo.png)
+
+Kumade is maintained and funded by [thoughtbot, inc](http://thoughtbot.com/community)
+
+The names and logos for thoughtbot are trademarks of thoughtbot, inc.
+
 ## License
 
-kumade is Copyright © thoughtbot. It is free software, and may be redistributed under the terms specified in the LICENSE file.
+Kumade is Copyright © 2011 thoughtbot. It is free software, and may be redistributed under the terms specified in the LICENSE file.

data/features/kumade_executable.feature

@@ -21,17 +21,16 @@ Feature: Kumade executable
     And the output should contain:
       """
       ==> Git repo is clean
-      ==> Packaged assets with Jammit
-               run  git push origin master
+      ==> Packaged with Kumade::JammitPackager
+              git push origin master
       ==> Pushed master -> origin
-               run  git branch deploy
-               run  git push -f pretend-staging deploy:master
+              git branch deploy >/dev/null
+              git push -f pretend-staging deploy:master
       ==> Pushed deploy:master -> pretend-staging
       ==> Migrated pretend-staging
-               run  git checkout master && git branch -D deploy
       ==> Deployed to: pretend-staging
       """
-    But the output should not contain "==> Packaged assets with More"
+    But the output should not contain "==> Packaged with Kumade::MorePackager"
 
   Scenario: Default environment is staging
     When I run kumade with "-p"
@@ -52,14 +51,13 @@ Feature: Kumade executable
     Then the output should contain:
       """
       ==> Git repo is clean
-      ==> Packaged assets with Jammit
-               run  git push origin new_branch
+      ==> Packaged with Kumade::JammitPackager
+              git push origin new_branch
       ==> Pushed new_branch -> origin
-               run  git branch deploy
-               run  git push -f pretend-staging deploy:master
+              git branch deploy >/dev/null
+              git push -f pretend-staging deploy:master
       ==> Pushed deploy:master -> pretend-staging
       ==> Migrated pretend-staging
-               run  git checkout new_branch && git branch -D deploy
       ==> Deployed to: pretend-staging
       """
 
@@ -95,4 +93,5 @@ Feature: Kumade executable
       end
       """
     When I run kumade with "pretend-staging -p"
-    Then the output should match /kumade:before_asset_compilation.*Packaged assets with Jammit/
+    Then the output should contain "kumade:before_asset_compilation"
+    And the output should contain "==> Packaged with Kumade::JammitPackager"

data/features/kumade_without_jammit.feature

@@ -23,7 +23,7 @@ Feature: Kumade without jammit
       end
       """
     When I run kumade with "pretend-staging"
-    Then the output should contain "Running kumade:before_asset_compilation task"
+    Then the output should contain "Running rake task: kumade:before_asset_compilation"
     And the output should contain "Hi!"
 
   Scenario: Don't run rake task in pretend mode
@@ -36,5 +36,5 @@ Feature: Kumade without jammit
       end
       """
     When I run kumade with "pretend-staging -p"
-    Then the output should contain "Running kumade:before_asset_compilation task"
+    Then the output should contain "Running rake task: kumade:before_asset_compilation"
     And the output should not contain "Hi!"

data/kumade.gemspec

@@ -26,5 +26,6 @@ Gem::Specification.new do |s|
   s.add_development_dependency('cucumber', '~> 1.0.2')
   s.add_development_dependency('aruba', '~> 0.4.3')
   s.add_development_dependency('jammit', '~> 0.6.3')
+  s.add_development_dependency('less', '~> 2.0')
   s.add_development_dependency('bourne')
 end

data/lib/kumade.rb

@@ -1,5 +1,4 @@
 module Kumade
-  autoload :Base,            "kumade/base"
   autoload :Git,             "kumade/git"
   autoload :Deployer,        "kumade/deployer"
   autoload :CLI,             "kumade/cli"
@@ -8,6 +7,13 @@ module Kumade
   autoload :Configuration,   "kumade/configuration"
   autoload :Heroku,          "kumade/heroku"
   autoload :Packager,        "kumade/packager"
+  autoload :MorePackager,    "kumade/packagers/more_packager"
+  autoload :JammitPackager,  "kumade/packagers/jammit_packager"
+  autoload :NoopPackager,    "kumade/packagers/noop_packager"
+  autoload :PackagerList,    "kumade/packager_list"
+  autoload :RakeTaskRunner,  "kumade/rake_task_runner"
+  autoload :CommandLine,     "kumade/command_line"
+  autoload :Outputter,       "kumade/outputter"
 
   def self.configuration
     @@configuration ||= Configuration.new

data/lib/kumade/cli.rb

@@ -16,7 +16,7 @@ module Kumade
       parse_arguments!(args)
 
       Kumade.configuration.pretending  = !!@options[:pretend]
-      Kumade.configuration.environment = args.shift || 'staging'
+      Kumade.configuration.environment = args.shift
 
       self.class.swapping_stdout_for(out, print_output?) do
         deploy
@@ -44,11 +44,11 @@ module Kumade
 
     def deploy
       if Kumade.configuration.pretending?
-        puts "==> In Pretend Mode"
+        Kumade.configuration.outputter.info("In Pretend Mode")
       end
-      puts "==> Deploying to: #{Kumade.configuration.environment}"
+      Kumade.configuration.outputter.info("Deploying to: #{Kumade.configuration.environment}")
       self.class.deployer.new.deploy
-      puts "==> Deployed to: #{Kumade.configuration.environment}"
+      Kumade.configuration.outputter.info("Deployed to: #{Kumade.configuration.environment}")
     end
 
     def parse_arguments!(args)

data/lib/kumade/command_line.rb

@@ -0,0 +1,33 @@
+require 'cocaine'
+
+module Kumade
+  class CommandLine
+    def initialize(command_to_run)
+      @command_line = Cocaine::CommandLine.new(command_to_run)
+    end
+
+    def run_or_error(error_message = nil)
+      run_with_status || Kumade.configuration.outputter.error(error_message)
+    end
+
+    def run_with_status
+      Kumade.configuration.outputter.say_command(command)
+      Kumade.configuration.pretending? || run
+    end
+
+    def run
+      begin
+        @command_line.run
+        true
+      rescue Cocaine::ExitStatusError, Cocaine::CommandNotFoundError
+        false
+      end
+    end
+
+    private
+
+    def command
+      @command_line.command
+    end
+  end
+end

data/lib/kumade/configuration.rb

@@ -1,14 +1,21 @@
 module Kumade
   class Configuration
-    def initialize(environment = 'staging', pretending = false )
-      @environment = environment
-      @pretending  = pretending
-    end
+    attr_writer :pretending, :environment
 
     def pretending?
-      @pretending
+      @pretending || false
+    end
+
+    def environment
+      @environment || "staging"
     end
 
-    attr_accessor :pretending, :environment
+    def outputter
+      @outputter ||= Outputter.new
+    end
+
+    def outputter=(new_outputter)
+      @outputter = new_outputter
+    end
   end
 end

data/lib/kumade/deployer.rb

@@ -2,11 +2,10 @@ require "rake"
 require 'cocaine'
 
 module Kumade
-  class Deployer < Base
+  class Deployer
     attr_reader :git, :heroku, :packager
 
     def initialize
-      super()
       @git      = Git.new
       @heroku   = Heroku.new
       @branch   = @git.current_branch
@@ -19,7 +18,8 @@ module Kumade
         pre_deploy
         heroku.sync
         heroku.migrate_database
-      rescue
+      rescue => deploying_error
+        Kumade.configuration.outputter.error("#{deploying_error.class}: #{deploying_error.message}")
       ensure
         post_deploy
       end
@@ -28,14 +28,14 @@ module Kumade
     def pre_deploy
       ensure_clean_git
       package_assets
-      sync_github
+      sync_origin
     end
 
     def package_assets
-      packager.run
+      @packager.run
     end
 
-    def sync_github
+    def sync_origin
       git.push(@branch)
     end
 
@@ -50,12 +50,12 @@ module Kumade
     def ensure_heroku_remote_exists
       if git.remote_exists?(Kumade.configuration.environment)
         if git.heroku_remote?
-          success("#{Kumade.configuration.environment} is a Heroku remote")
+          Kumade.configuration.outputter.success("#{Kumade.configuration.environment} is a Heroku remote")
         else
-          error(%{Cannot deploy: "#{Kumade.configuration.environment}" remote does not point to Heroku})
+          Kumade.configuration.outputter.error(%{Cannot deploy: "#{Kumade.configuration.environment}" remote does not point to Heroku})
         end
       else
-        error(%{Cannot deploy: "#{Kumade.configuration.environment}" remote does not exist})
+        Kumade.configuration.outputter.error(%{Cannot deploy: "#{Kumade.configuration.environment}" remote does not exist})
       end
     end
   end

data/lib/kumade/git.rb

@@ -1,10 +1,6 @@
 require 'cocaine'
 module Kumade
-  class Git < Base
-    def initialize
-      super()
-    end
-
+  class Git
     def heroku_remote?
       remote_url = `git config --get remote.#{Kumade.configuration.environment}.url`.strip
       !! remote_url.strip.match(/^git@heroku\..+:(.+)\.git$/)
@@ -20,25 +16,32 @@ module Kumade
       command << remote
       command << branch
       command = command.join(" ")
-      run_or_error(command, "Failed to push #{branch} -> #{remote}")
-      success("Pushed #{branch} -> #{remote}")
+
+      command_line = CommandLine.new(command)
+      command_line.run_or_error("Failed to push #{branch} -> #{remote}")
+      Kumade.configuration.outputter.success("Pushed #{branch} -> #{remote}")
     end
 
     def create(branch)
-      unless branch_exist?(branch)
-        run_or_error("git branch #{branch}", "Failed to create #{branch}")
+      unless has_branch?(branch)
+        CommandLine.new("git branch #{branch} >/dev/null").run_or_error("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")
+      if has_branch?(branch_to_delete)
+        command_line = CommandLine.new("git checkout #{branch_to_checkout} 2>/dev/null && git branch -D #{branch_to_delete}")
+        command_line.run_or_error("Failed to clean up #{branch_to_delete} branch")
+      end
     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
+    def add_and_commit_all_assets_in(dir)
+      command = ["git checkout -b #{Kumade::Heroku::DEPLOY_BRANCH} 2>/dev/null",
+                 "git add -f #{dir}",
+                 "git commit -m 'Compiled assets.'"].join(' && ')
+      command_line = CommandLine.new(command)
+      command_line.run_or_error("Cannot deploy: couldn't commit assets")
+      Kumade.configuration.outputter.success("Added and committed all assets")
     end
 
     def current_branch
@@ -54,19 +57,21 @@ module Kumade
     end
 
     def dirty?
-      !run("git diff --exit-code")
+      ! CommandLine.new("git diff --exit-code").run
     end
 
     def ensure_clean_git
       if ! Kumade.configuration.pretending? && dirty?
-        error("Cannot deploy: repo is not clean.")
+        Kumade.configuration.outputter.error("Cannot deploy: repo is not clean.")
       else
-        success("Git repo is clean")
+        Kumade.configuration.outputter.success("Git repo is clean")
       end
     end
 
-    def branch_exist?(branch)
-      run("git show-ref #{branch}")
+    private
+
+    def has_branch?(branch)
+      CommandLine.new("git show-ref #{branch}").run
     end
   end
 end

data/lib/kumade/heroku.rb

@@ -1,12 +1,11 @@
 require 'cocaine'
 
 module Kumade
-  class Heroku < Base
+  class Heroku
     DEPLOY_BRANCH = "deploy"
     attr_reader :git
 
     def initialize
-      super()
       @git    = Git.new
       @branch = @git.current_branch
     end
@@ -18,7 +17,7 @@ module Kumade
 
     def migrate_database
       heroku("rake db:migrate") unless Kumade.configuration.pretending?
-      success("Migrated #{Kumade.configuration.environment}")
+      Kumade.configuration.outputter.success("Migrated #{Kumade.configuration.environment}")
     end
 
     def delete_deploy_branch
@@ -26,21 +25,29 @@ module Kumade
     end
 
     def heroku(command)
-      heroku_command = if cedar?
-                         "bundle exec heroku run"
-                       else
-                         "bundle exec heroku"
-                       end
-      run_or_error("#{heroku_command} #{command} --remote #{Kumade.configuration.environment}",
-                   "Failed to run #{command} on Heroku")
+      full_heroku_command = "#{bundle_exec_heroku} #{command} --remote #{Kumade.configuration.environment}"
+      command_line = CommandLine.new(full_heroku_command)
+      command_line.run_or_error("Failed to run #{command} on Heroku")
     end
 
     def cedar?
       return @cedar unless @cedar.nil?
 
-      @cedar = Cocaine::CommandLine.new("bundle exec heroku stack --remote #{Kumade.configuration.environment}").run.split("\n").grep(/\*/).any? do |line|
+      command_line = CommandLine.new("bundle exec heroku stack --remote #{Kumade.configuration.environment}")
+
+      @cedar = command_line.run_or_error.split("\n").grep(/\*/).any? do |line|
         line.include?("cedar")
       end
     end
+
+    private
+
+    def bundle_exec_heroku
+      if cedar?
+        "bundle exec heroku run"
+      else
+        "bundle exec heroku"
+      end
+    end
   end
 end

data/lib/kumade/outputter.rb

@@ -0,0 +1,21 @@
+module Kumade
+  class Outputter
+    def success(message)
+      puts "==> #{message}"
+    end
+
+    def info(message)
+      puts "==> #{message}"
+    end
+
+    def error(message)
+      puts "==> ! #{message}"
+      raise Kumade::DeploymentError, message
+    end
+
+    def say_command(command)
+      prefix = " " * 8
+      puts "#{prefix}#{command}"
+    end
+  end
+end

data/lib/kumade/packager.rb

@@ -1,94 +1,41 @@
 module Kumade
-  class Packager < Base
-    attr_reader :git
-
-    def initialize(git)
-      super()
-      @git = git
+  class Packager
+    def initialize(git, packager = Packager.available_packager)
+      @packager = packager
+      @git      = git
     end
 
     def run
-      invoke_custom_task  if custom_task?
-      package_with_jammit if jammit_installed?
-      package_with_more   if more_installed?
-    end
-
-    def invoke_custom_task
-      success "Running kumade:before_asset_compilation task"
-      Rake::Task["kumade:before_asset_compilation"].invoke unless Kumade.configuration.pretending?
+      precompile_assets
+      package
     end
 
-    def custom_task?
-      load("Rakefile") if File.exist?("Rakefile")
-      Rake::Task.task_defined?("kumade:before_asset_compilation")
+    def self.available_packager
+      Kumade::PackagerList.new.first
     end
 
-    def package_with_jammit
-      begin
-        success_message = "Packaged assets with Jammit"
-
-        if Kumade.configuration.pretending?
-          success(success_message)
-        else
-          Jammit.package!
+    private
 
-          success(success_message)
-          git_add_and_commit_all_assets_in(jammit_assets_path)
-        end
-      rescue => jammit_error
-        error("Error: #{jammit_error.class}: #{jammit_error.message}")
-      end
+    def precompile_assets
+      RakeTaskRunner.new("kumade:before_asset_compilation").invoke
     end
 
-    def package_with_more
-      success_message = "Packaged assets with More"
-      if Kumade.configuration.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}")
+    def package
+      return Kumade.configuration.outputter.success(success_message) if Kumade.configuration.pretending?
+
+      begin
+        @packager.package
+        if @git.dirty?
+          @git.add_and_commit_all_assets_in(@packager.assets_path)
+          Kumade.configuration.outputter.success(success_message)
         end
+      rescue => packager_exception
+        Kumade.configuration.outputter.error("Error: #{packager_exception.class}: #{packager_exception.message}")
       end
     end
 
-    def git_add_and_commit_all_assets_in(dir)
-      git.add_and_commit_all_in(dir, Kumade::Heroku::DEPLOY_BRANCH, 'Compiled assets', "Added and committed all assets", "couldn't commit assets")
-    end
-
-    def jammit_assets_path
-      File.join(Jammit::PUBLIC_ROOT, Jammit.package_path)
-    end
-
-    def more_assets_path
-      File.join('public', ::Less::More.destination_path)
-    end
-
-    def jammit_installed?
-      @jammit_installed ||=
-        (defined?(Jammit) ||
-          begin
-            require 'jammit'
-            true
-          rescue LoadError
-            false
-          end)
-    end
-
-    def more_installed?
-      @more_installed ||=
-        (defined?(Less::More) ||
-          begin
-            require 'less/more'
-            true
-          rescue LoadError
-            false
-          end)
+    def success_message
+      "Packaged with #{@packager.name}"
     end
   end
 end