kumade 0.3.0 → 0.4.0

data/lib/kumade/git.rb

@@ -1,14 +1,13 @@
+require 'cocaine'
 module Kumade
   class Git < Base
-    attr_reader :environment
-    def initialize(pretending, environment)
+    def initialize
       super()
-      @pretending = pretending
-      @environment = environment
     end
 
     def heroku_remote?
-      `git config --get remote.#{environment}.url`.strip =~ /^git@heroku\..+:(.+)\.git$/
+      remote_url = `git config --get remote.#{Kumade.configuration.environment}.url`.strip
+      !! remote_url.strip.match(/^git@heroku\..+:(.+)\.git$/)
     end
 
     def self.environments
@@ -21,7 +20,7 @@ module Kumade
       command << remote
       command << branch
       command = command.join(" ")
-      run_or_error([command], "Failed to push #{branch} -> #{remote}")
+      run_or_error(command, "Failed to push #{branch} -> #{remote}")
       success("Pushed #{branch} -> #{remote}")
     end
 
@@ -32,12 +31,12 @@ module Kumade
     end
 
     def delete(branch_to_delete, branch_to_checkout)
-      run_or_error(["git checkout #{branch_to_checkout}", "git branch -D #{branch_to_delete}"],
+      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}'"],
+      run_or_error "git checkout -b #{branch} && git add -f #{dir} && git commit -m '#{commit_message}'",
                    "Cannot deploy: #{error_output}"
       success success_output
     end
@@ -47,7 +46,7 @@ module Kumade
     end
 
     def remote_exists?(remote_name)
-      if @pretending
+      if Kumade.configuration.pretending?
         true
       else
         `git remote` =~ /^#{remote_name}$/
@@ -55,11 +54,11 @@ module Kumade
     end
 
     def dirty?
-      ! system("git diff --exit-code")
+      !run("git diff --exit-code")
     end
 
     def ensure_clean_git
-      if ! @pretending && dirty?
+      if ! Kumade.configuration.pretending? && dirty?
         error("Cannot deploy: repo is not clean.")
       else
         success("Git repo is clean")
@@ -67,7 +66,7 @@ module Kumade
     end
 
     def branch_exist?(branch)
-      system("git show-ref #{branch}")
+      run("git show-ref #{branch}")
     end
   end
 end

data/lib/kumade/heroku.rb

@@ -0,0 +1,46 @@
+require 'cocaine'
+
+module Kumade
+  class Heroku < Base
+    DEPLOY_BRANCH = "deploy"
+    attr_reader :git
+
+    def initialize
+      super()
+      @git    = Git.new
+      @branch = @git.current_branch
+    end
+
+    def sync
+      git.create(DEPLOY_BRANCH)
+      git.push("#{DEPLOY_BRANCH}:master", Kumade.configuration.environment, true)
+    end
+
+    def migrate_database
+      heroku("rake db:migrate") unless Kumade.configuration.pretending?
+      success("Migrated #{Kumade.configuration.environment}")
+    end
+
+    def delete_deploy_branch
+      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 #{Kumade.configuration.environment}",
+                   "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|
+        line.include?("cedar")
+      end
+    end
+  end
+end

data/lib/kumade/packager.rb

@@ -0,0 +1,94 @@
+module Kumade
+  class Packager < Base
+    attr_reader :git
+
+    def initialize(git)
+      super()
+      @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?
+    end
+
+    def custom_task?
+      load("Rakefile") if File.exist?("Rakefile")
+      Rake::Task.task_defined?("kumade:before_asset_compilation")
+    end
+
+    def package_with_jammit
+      begin
+        success_message = "Packaged assets with Jammit"
+
+        if Kumade.configuration.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 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}")
+        end
+      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)
+    end
+  end
+end

data/lib/kumade/version.rb

@@ -1,3 +1,3 @@
 module Kumade
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/lib/tasks/deploy.rake

@@ -2,7 +2,7 @@ namespace :deploy do
   Kumade::Git.environments.each do |environment|
     desc "Deploy to #{environment} environment"
     task environment do
-      Kumade::Runner.run([environment])
+      Kumade::CLI.run([environment])
     end
   end
 end

data/spec/kumade/base_spec.rb

@@ -1,18 +1,99 @@
 require 'spec_helper'
 
 describe Kumade::Base, "#success" do
-  it "exists" do
-    subject.should respond_to(:success)
-  end
+  it { should respond_to(:success) }
 end
 
 describe Kumade::Base, "#error" do
-  it "exists" do
-    subject.should respond_to(:error)
-  end
+  before { STDOUT.stubs(:puts) }
+
+  it { should respond_to(:error) }
 
   it "prints its message and raises its message" do
-    subject.should_receive(:say).with("==> ! I'm an error!", :red)
-    lambda{ subject.error("I'm an error!") }.should raise_error(Kumade::DeploymentError)
+    lambda { subject.error("I'm an error!") }.should raise_error(Kumade::DeploymentError)
+
+    STDOUT.should have_received(:puts).with(regexp_matches(/I'm an error!/))
+  end
+end
+
+describe Kumade::Base, "#run_or_error" do
+  let(:command)       { "dummy command" }
+  let(:error_message) { "dummy error message" }
+
+  before do
+    STDOUT.stubs(:puts)
+  end
+
+  context "when pretending" do
+    before do
+      Kumade.configuration.pretending = true
+      subject.stubs(:run)
+    end
+
+    it "does not run the command" do
+      subject.run_or_error("dummy command", "dummy error message")
+
+      subject.should_not have_received(:run)
+      STDOUT.should have_received(:puts).with(regexp_matches(/#{command}/))
+    end
+  end
+
+  context "when not pretending" do
+    context "when it runs successfully" do
+      before do
+        Cocaine::CommandLine.stubs(:new).returns(stub(:run))
+      end
+
+      it "does not print an error" do
+        subject.run_or_error(command, error_message)
+
+        STDOUT.should_not have_received(:puts).with(regexp_matches(/#{error_message}/))
+      end
+    end
+
+    context "when it does not run successfully " do
+      let(:failing_command_line) { stub("Failing Cocaine::CommandLine") }
+
+      before do
+        subject.stubs(:error)
+        failing_command_line.stubs(:run).raises(Cocaine::ExitStatusError)
+        Cocaine::CommandLine.stubs(:new).returns(failing_command_line)
+      end
+
+      it "prints an error message" do
+        subject.run_or_error(command, error_message)
+
+        subject.should have_received(:error).with(error_message)
+      end
+    end
+  end
+end
+
+describe Kumade::Base, "#run" do
+  let(:command_line) { stub("Cocaine::CommandLine") }
+  let(:command)      { "command" }
+
+  before do
+    Cocaine::CommandLine.stubs(:new).with(command).returns(command_line)
+  end
+
+  context "when not successful" do
+    before do
+      command_line.stubs(:run)
+    end
+
+    it "returns true" do
+      subject.run(command).should == true
+    end
+  end
+
+  context "when successful" do
+    before do
+      command_line.stubs(:run).raises(Cocaine::ExitStatusError)
+    end
+
+    it "returns false" do
+      subject.run(command).should == false
+    end
   end
 end

data/spec/kumade/cli_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+
+describe Kumade::CLI do
+  let(:out)         { StringIO.new }
+  let(:environment) { 'my-environment' }
+  let(:deployer)          { stub("Deployer", :new => deployer_instance) }
+  let(:deployer_instance) { stub("DeployerInstance", :deploy => nil) }
+
+  before  { Kumade::CLI.deployer = deployer }
+  after   { Kumade::CLI.deployer = nil }
+
+  context "when pretending" do
+    %w(-p --pretend).each do |pretend_flag|
+      subject { Kumade::CLI.new([pretend_flag, environment], out) }
+
+      context pretend_flag do
+        it "sets pretending to true" do
+          subject
+          Kumade.configuration.pretending.should == true
+        end
+
+        it "deploys" do
+          subject
+
+          deployer_instance.should have_received(:deploy)
+        end
+      end
+    end
+  end
+
+  context "with no command-line arguments" do
+    subject { Kumade::CLI.new([], out) }
+
+    it "sets the environment to staging" do
+      Kumade.configuration.environment.should == 'staging'
+    end
+
+    it "sets pretending to false" do
+      Kumade.configuration.pretending.should == false
+    end
+  end
+
+  context "running normally" do
+    subject { Kumade::CLI.new([environment], out) }
+
+    it "sets pretending to false" do
+      subject
+      Kumade.configuration.pretending.should == false
+    end
+
+    it "deploys" do
+      subject
+
+      deployer_instance.should have_received(:deploy)
+    end
+  end
+end
+
+describe Kumade::CLI, ".deployer" do
+  after { Kumade::CLI.deployer = nil }
+
+  it "sets the deployer to the Deployer class by default" do
+    Kumade::CLI.deployer.should == Kumade::Deployer
+  end
+
+  it "can override deployer" do
+    Kumade::CLI.deployer = "deployer!"
+    Kumade::CLI.deployer.should == "deployer!"
+  end
+end
+
+describe Kumade::CLI, ".swapping_stdout_for" do
+  let(:stdout) { $stdout }
+  let(:output) { StringIO.new }
+
+  before do
+    stdout.stubs(:print => nil, :puts => nil)
+  end
+
+  it 'does not let anything get printed' do
+    Kumade::CLI.swapping_stdout_for(output) do
+      $stdout.puts "Hello, you can't see me."
+    end
+
+    stdout.should_not have_received(:print)
+
+    output.rewind
+    output.read.should == "Hello, you can't see me.\n"
+  end
+
+  it 'dumps the output stash to real stdout when an error happens' do
+    Kumade::CLI.swapping_stdout_for(output) do
+      $stdout.puts "Hello, you can see me!"
+      raise Kumade::DeploymentError.new("error")
+    end
+
+    stdout.should have_received(:print)
+  end
+
+  context "in print output mode" do
+    it 'prints everything' do
+      Kumade::CLI.swapping_stdout_for(output, true) do
+        $stdout.puts "Hello, you can see me!"
+      end
+
+      stdout.should have_received(:puts)
+    end
+  end
+end

data/spec/kumade/configuration_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Kumade::Configuration, "by default" do
+  its(:environment) { should == 'staging' }
+  it { should_not be_pretending }
+end
+
+describe Kumade::Configuration, "#pretending" do
+  it "has read/write access for the pretending attribute" do
+    subject.pretending = true
+    subject.pretending.should == true
+  end
+end
+
+describe Kumade::Configuration, "#pretending?" do
+  it "returns false when not pretending" do
+    subject.pretending = false
+    subject.should_not be_pretending
+  end
+
+  it "returns true when pretending" do
+    subject.pretending = true
+    subject.should be_pretending
+  end
+
+  it "defaults to false" do
+    subject.pretending.should == false
+  end
+end
+
+describe Kumade::Configuration, "#environment" do
+  it "has read/write access for the environment attribute" do
+    subject.environment = 'new-environment'
+    subject.environment.should == 'new-environment'
+  end
+end