kumade 0.3.0 → 0.4.0

data/.travis.yml

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

data/README.md

@@ -1,5 +1,5 @@
 # Kumade 熊手 [![Build Status](https://secure.travis-ci.org/thoughtbot/kumade.png)](http://travis-ci.org/thoughtbot/kumade)
-Kumade is a set of basic Rake tasks for deploying to Heroku. It aims to
+Kumade is a command-line program  for deploying to Heroku. It aims to
 provide most of what you want. Unlike other Heroku deploy gems, it is
 well-tested.
 
@@ -9,11 +9,11 @@ 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.
+Before deploying, Kumade ensures the git repo is clean.
 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 correct remote and runs `rake db:migrate` on the
+Then it force pushes to the correct Heroku remote and runs `rake db:migrate` on the
 Heroku app.
 
 If any step fails, it immediately prints an error and stops the deploy
@@ -29,36 +29,34 @@ gem 'kumade'
 ## Usage
 
 kumade will deploy to any Heroku remote in the repo.
-For example, if you have a remote named "bamboo":
+For example, if you have a remote named "staging":
 
-    $ bundle exec kumade bamboo
+    $ bundle exec kumade staging
 
-or
+To run in pretend mode, which prints what would be done without actually doing
+any of it:
 
-    # in your Rakefile:
-    require 'kumade'
+    $ bundle exec kumade staging -p
 
-    # kumade auto-generates a deploy:ENV task for every Heroku environment
-    $ rake deploy:bamboo
+The default is to deploy to staging:
 
-which will autodetect the name of the Heroku app that the bamboo remote points
-to and deploy to it.
+    # equivalent to "bundle exec kumade staging"
+    $ bundle exec kumade
 
-To run in pretend mode, which prints what would be done without actually doing
-any of it:
+## Rake
 
-    $ bundle exec kumade bamboo -p
+Kumade auto-generates a deploy:ENV task for every Heroku environment.
 
-The default is to deploy to staging:
+    # in your Rakefile:
+    require 'kumade'
 
-    $ bundle exec kumade # equivalent to "bundle exec kumade staging"
+    $ rake deploy:staging
 
+If you use rake tasks, you can't pass in options (like -p/--pretend).
 
 ## 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
+Yes. Kumade will automatically detect if your app is running on Cedar.
 
 ## Compatibility
 
@@ -68,7 +66,7 @@ Tested against:
 * MRI 1.9.2
 * REE 1.8.7
 
-## Misc Features
+## Miscellaneous Features
 
 Want to run a task before bundling your assets on deploy? In your Rails app's rake tasks, drop in:
 

data/bin/kumade

@@ -2,4 +2,4 @@
 
 require 'kumade'
 
-Kumade::Runner.run
+Kumade::CLI.new

data/kumade.gemspec

@@ -19,10 +19,12 @@ 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_dependency('cocaine', '>= 0.2.0')
 
   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')
   s.add_development_dependency('jammit', '~> 0.6.3')
+  s.add_development_dependency('bourne')
 end

data/lib/kumade.rb

@@ -1,13 +1,19 @@
-require 'rake'
-require 'thor'
-require 'stringio'
+module Kumade
+  autoload :Base,            "kumade/base"
+  autoload :Git,             "kumade/git"
+  autoload :Deployer,        "kumade/deployer"
+  autoload :CLI,             "kumade/cli"
+  autoload :Railtie,         "kumade/railtie"
+  autoload :DeploymentError, "kumade/deployment_error"
+  autoload :Configuration,   "kumade/configuration"
+  autoload :Heroku,          "kumade/heroku"
+  autoload :Packager,        "kumade/packager"
 
-require 'kumade/base'
-require 'kumade/git'
-require 'kumade/deployer'
-require 'kumade/runner'
-require 'kumade/railtie'
-require 'kumade/deployment_error'
+  def self.configuration
+    @@configuration ||= Configuration.new
+  end
 
-module Kumade
+  def self.configuration=(new_configuration)
+    @@configuration = new_configuration
+  end
 end

data/lib/kumade/base.rb

@@ -1,21 +1,26 @@
+require "thor"
+
 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)
+    def run_or_error(command, error_message)
+      say_status(:run, command)
+      if ! Kumade.configuration.pretending?
+        error(error_message) unless run(command)
       end
     end
 
-    def run(command, config = {})
-      say_status :run, command
-      config[:capture] ? `#{command}` : system("#{command}")
+    def run(command)
+      line = Cocaine::CommandLine.new(command)
+      begin
+        line.run
+        true
+      rescue Cocaine::ExitStatusError => e
+        false
+      end
     end
 
     def error(message)

data/lib/kumade/cli.rb

@@ -0,0 +1,86 @@
+require 'optparse'
+require 'stringio'
+
+module Kumade
+  class CLI
+    class << self
+      attr_writer :deployer
+
+      def deployer
+        @deployer || Kumade::Deployer
+      end
+    end
+
+    def initialize(args = ARGV, out = StringIO.new)
+      @options     = {}
+      parse_arguments!(args)
+
+      Kumade.configuration.pretending  = !!@options[:pretend]
+      Kumade.configuration.environment = args.shift || 'staging'
+
+      self.class.swapping_stdout_for(out, print_output?) do
+        deploy
+      end
+    end
+
+    def self.swapping_stdout_for(io, print_output = false)
+      if print_output
+        yield
+      else
+        begin
+          real_stdout = $stdout
+          $stdout     = io
+          yield
+        rescue Kumade::DeploymentError
+          io.rewind
+          real_stdout.print(io.read)
+        ensure
+          $stdout = real_stdout
+        end
+      end
+    end
+
+    private
+
+    def deploy
+      if Kumade.configuration.pretending?
+        puts "==> In Pretend Mode"
+      end
+      puts "==> Deploying to: #{Kumade.configuration.environment}"
+      self.class.deployer.new.deploy
+      puts "==> Deployed to: #{Kumade.configuration.environment}"
+    end
+
+    def parse_arguments!(args)
+      OptionParser.new do |opts|
+        opts.banner = "Usage: kumade <environment> [options]"
+
+        opts.on("-p", "--pretend", "Pretend mode: print what kumade would do") do |p|
+          @options[:pretend] = true
+        end
+
+        opts.on_tail("-v", "--verbose", "Print what kumade is doing") do
+          @options[:verbose] = true
+        end
+
+        opts.on_tail('--version', 'Show version') do
+          puts "kumade #{Kumade::VERSION}"
+          exit
+        end
+
+        opts.on_tail('-h', '--help', 'Show this message') do
+          puts opts
+          exit
+        end
+      end.parse!(args)
+    end
+
+    def verbose?
+      @options[:verbose]
+    end
+
+    def print_output?
+      Kumade.configuration.pretending? || verbose?
+    end
+  end
+end

data/lib/kumade/configuration.rb

@@ -0,0 +1,14 @@
+module Kumade
+  class Configuration
+    def initialize(environment = 'staging', pretending = false )
+      @environment = environment
+      @pretending  = pretending
+    end
+
+    def pretending?
+      @pretending
+    end
+
+    attr_accessor :pretending, :environment
+  end
+end

data/lib/kumade/deployer.rb

@@ -1,22 +1,28 @@
+require "rake"
+require 'cocaine'
+
 module Kumade
   class Deployer < Base
-    DEPLOY_BRANCH = "deploy"
-    attr_reader :environment, :pretending, :git
+    attr_reader :git, :heroku, :packager
 
-    def initialize(environment = 'staging', pretending = false)
+    def initialize
       super()
-      @environment = environment
-      @pretending  = pretending
-      @git         = Git.new(pretending, environment)
-      @branch      = @git.current_branch
+      @git      = Git.new
+      @heroku   = Heroku.new
+      @branch   = @git.current_branch
+      @packager = Packager.new(@git)
     end
 
     def deploy
-      ensure_heroku_remote_exists
-      pre_deploy
-      sync_heroku
-      heroku_migrate
-      post_deploy
+      begin
+        ensure_heroku_remote_exists
+        pre_deploy
+        heroku.sync
+        heroku.migrate_database
+      rescue
+      ensure
+        post_deploy
+      end
     end
 
     def pre_deploy
@@ -25,138 +31,31 @@ module Kumade
       sync_github
     end
 
-    def sync_github
-      git.push(@branch)
-    end
-
-    def sync_heroku
-      git.create(DEPLOY_BRANCH)
-      git.push("#{DEPLOY_BRANCH}:master", environment, true)
+    def package_assets
+      packager.run
     end
 
-    def heroku_migrate
-      heroku("rake db:migrate") unless pretending
-      success("Migrated #{environment}")
+    def sync_github
+      git.push(@branch)
     end
 
     def post_deploy
-      git.delete(DEPLOY_BRANCH, @branch)
-    end
-
-    def heroku(command)
-      heroku_command = if cedar?
-                         "bundle exec heroku run"
-                       else
-                         "bundle exec heroku"
-                       end
-      run_or_error("#{heroku_command} #{command} --remote #{environment}",
-                   "Failed to run #{command} on Heroku")
-    end
-
-    def cedar?
-      return @cedar unless @cedar.nil?
-      @cedar = heroku("stack").split("\n").grep(/\*/).any? do |line|
-        line.include?("cedar")
-      end
+      heroku.delete_deploy_branch
     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?
-      package_with_more   if more_installed?
-    end
-
-    def package_with_jammit
-      begin
-        success_message = "Packaged assets with Jammit"
-
-        if pretending
-          success(success_message)
-        else
-          Jammit.package!
-
-          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
-    end
-
-    def package_with_more
-      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
-      end
-    end
-
-    def invoke_custom_task
-      success "Running kumade:before_asset_compilation task"
-      Rake::Task["kumade:before_asset_compilation"].invoke unless pretending
-    end
-
-    def git_add_and_commit_all_assets_in(dir)
-      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
-      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)
-    end
-
-    def custom_task?
-      load("Rakefile") if File.exist?("Rakefile")
-      Rake::Task.task_defined?("kumade:before_asset_compilation")
-    end
-
     def ensure_heroku_remote_exists
-      if git.remote_exists?(environment)
+      if git.remote_exists?(Kumade.configuration.environment)
         if git.heroku_remote?
-          success("#{environment} is a Heroku remote")
+          success("#{Kumade.configuration.environment} is a Heroku remote")
         else
-          error(%{Cannot deploy: "#{environment}" remote does not point to Heroku})
+          error(%{Cannot deploy: "#{Kumade.configuration.environment}" remote does not point to Heroku})
         end
       else
-        error(%{Cannot deploy: "#{environment}" remote does not exist})
+        error(%{Cannot deploy: "#{Kumade.configuration.environment}" remote does not exist})
       end
     end
   end