heroploy 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1abe27a12facd2dc9f5efb27cfd5c959186ef25a
-  data.tar.gz: 1e2995fb4cd6a6af47366cda82c7362adcd032c9
+  metadata.gz: c2596af30153567d6c7fff7dd776b944029034b6
+  data.tar.gz: a1ff270a3b794fb801bc226331c5277059a9b918
 SHA512:
-  metadata.gz: 37e04d64e2abdb2730baeeb28233b25b4471e8b9c1e6000fc3b92e9bb70ede30eaa3f678871baaf8c1e7ac002c23127e21cf84a4efd0c9696ba0ceeb81657d81
-  data.tar.gz: 2e8a442f4431e1b1fbf0b2667033905ac12e927066a309abbe480efe0875cfdc2697a92fb6ac118c10cd254f8dffeb16adb2a8116d43bc7aec69b6ec1fd2a893
+  metadata.gz: 35de3c056e9eff9e0f0cb2a463f20bdce9265ba9247086939e8a0fc1a4f9533d6244aa67cd55c04b342c538f5b65e92bafe1343dca99dfbeac12d1aff9613804
+  data.tar.gz: b369f61be1d4bd0f4caa0d5524125494be8204a2a9b504baf19db95c7a717efe080bc2f47fd3bdf5a3947198109827e3823f1a3c8a534bf07fde0c685b3de390

data/README.md

@@ -1,6 +1,7 @@
 # Heroploy
 
 [![Build Status](https://travis-ci.org/jbrunton/heroploy.png?branch=master)](https://travis-ci.org/jbrunton/heroploy)
+[![Dependency Status](https://gemnasium.com/jbrunton/heroploy.png)](https://gemnasium.com/jbrunton/heroploy)
 [![Code Climate](https://codeclimate.com/github/jbrunton/heroploy.png)](https://codeclimate.com/github/jbrunton/heroploy)
 
 A few helpful rake tasks to manage deploying Rails apps to development, staging and production Heroku servers.
@@ -21,23 +22,23 @@ Or install it yourself as:
 
 ## Usage
 
-Add a .heroploy file in your application's root directory which describes the Heroku apps you will deploy to, and the checks you would like when deploying to each.
+Add a ```heroploy.yml``` file to your application's config directory which describes the Heroku apps you will deploy to, and the checks you would like when deploying to each.
 
 For example:
 
 ```yaml
-apps:
+environments:
   development:
-    heroku: my-app-development
+    heroku: my-development-app
 
   staging:
-    heroku: my-app-staging
+    heroku: my-staging-app
     checks:
       pushed: true
       branch: master
 
   production:
-    heroku: my-app-production
+    heroku: my-production-app
     tag: 'RELEASE_%Y%m%dT%H%M%S%z'
     checks:
       pushed: true
@@ -46,7 +47,7 @@ apps:
 ```
 
 This file:
-* Describes ```development```, ```staging``` and ```production``` deployment rules for three Heroku apps (named ```my-app-development```, ```my-app-staging``` and ```my-app-production``` on Heroku).
+* Describes ```development```, ```staging``` and ```production``` deployment rules for three Heroku apps (named ```my-development-app```, ```my-staging-app``` and ```my-production-app``` on Heroku).
 * Allows any branch to be pushed directly to ```development```.
 * Only allows ```master``` to be pushed to ```staging```, and requires all changes to have first been pushed to ```origin```.
 * Only allows deployment to ```production``` if the changes have first been staged on ```staging```.

data/heroploy.gemspec

@@ -21,4 +21,5 @@ Gem::Specification.new do |spec|
   spec.add_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
+  spec.add_development_dependency "factory_girl"
 end

data/lib/heroploy/commands/checks.rb

@@ -0,0 +1,31 @@
+module Commands
+  module Checks
+    def check_remote(remote)
+      unless git_remote_exists?(remote)
+        raise "Could not find remote '#{remote}'"
+      end
+    end
+    
+    def check_pushed(branch_name)
+      unless git_remote_has_branch?('origin', branch_name)
+        raise "Branch #{branch_name} doesn't exist in origin"
+      end
+
+      if git_remote_behind?('origin', branch_name) then
+        raise "Branch #{branch_name} is behind origin/#{branch_name}"
+      end
+    end
+    
+    def check_branch(branch_name, valid_branch, env_name)
+      unless branch_name == valid_branch
+        raise "Cannot deploy branch #{branch_name} to #{env_name}"
+      end
+    end
+    
+    def check_staged(remote, branch_name, env_name)
+      unless git_staged?(remote, branch_name)
+        raise "Changes not yet staged on #{env_name}"
+      end
+    end
+  end
+end

data/lib/heroploy/commands/git.rb

@@ -0,0 +1,46 @@
+require 'heroploy/commands/shell'
+
+module Commands
+  module Git
+    def git_fetch
+      Shell.exec "git fetch"
+    end
+  
+    def current_branch
+      branch = Shell.eval "git rev-parse --abbrev-ref HEAD"
+      branch.strip
+    end
+  
+    def git_push_to_master(remote, local_branch)
+      if ENV['force'] == 'true' then opts = "--force " end
+      Shell.exec "git push #{opts}#{remote} #{local_branch}:master"
+    end
+  
+    def git_remote_exists?(name)
+      remotes = Shell.eval("git remote").strip.split(/\s+/)
+      remotes.include?(name)
+    end
+  
+    def git_remote_has_branch?(remote, branch_name)
+      branches = Shell.eval("git branch -r").strip.split(/\s+/)
+      branches.include?("#{remote}/#{branch_name}")
+    end
+  
+    def git_remote_behind?(remote, remote_branch_name, local_branch_name = nil)
+      if local_branch_name.nil? then local_branch_name = remote_branch_name end
+      !Shell.eval("git log #{remote}/#{remote_branch_name}..#{local_branch_name}").empty?
+    end
+  
+    def git_staged?(remote, local_branch)
+      !git_remote_behind?(remote, 'master', local_branch)
+    end
+  
+    def git_tag(tag, message)
+      Shell.exec("git tag -a #{tag} -m \"#{message}\"")
+    end
+  
+    def git_push_tag(tag)
+      Shell.exec("git push origin #{tag}")
+    end
+  end
+end

data/lib/heroploy/commands/heroku.rb

@@ -0,0 +1,19 @@
+require 'heroploy/commands/shell'
+
+module Commands
+  module Heroku
+    def heroku_exec(cmd, app_name)
+      Shell.exec "heroku #{cmd} --app #{app_name}"
+    end
+  
+    def heroku_run(cmd, app_name)
+      heroku_exec("run #{cmd}", app_name)
+    end
+  
+    def heroku_migrate(app_name)
+      Bundler.with_clean_env do
+        heroku_run("rake db:migrate", app_name)
+      end
+    end
+  end
+end

data/lib/heroploy/config/checks_config.rb

@@ -0,0 +1,16 @@
+class ChecksConfig
+  attr_accessor :pushed
+  attr_accessor :branch
+  attr_accessor :staged
+  
+  def self.parse(attrs)
+    config = ChecksConfig.new
+    
+    attrs ||= {}
+    config.pushed = attrs['pushed']
+    config.branch = attrs['branch']
+    config.staged = attrs['staged'] == true ? 'staging' : attrs['staged']
+    
+    config
+  end
+end

data/lib/heroploy/config/deploy_config.rb

@@ -0,0 +1,24 @@
+require 'heroploy/config/env_config'
+
+class DeployConfig
+  attr_accessor :environments
+  
+  def [](env_name)
+    environments.select{ |env_config| env_config.name == env_name}.first
+  end
+  
+  def self.parse(attrs)
+    config = DeployConfig.new
+    
+    config.environments = [] 
+    attrs['environments'].each do |name, attrs|
+      config.environments << EnvConfig.parse(name, attrs)
+    end
+    
+    config
+  end
+  
+  def self.load
+    DeployConfig.parse(YAML::load(File.open('config/heroploy.yml')))
+  end
+end

data/lib/heroploy/config/env_config.rb

@@ -0,0 +1,21 @@
+require 'heroploy/config/checks_config'
+
+class EnvConfig
+  attr_accessor :name
+  attr_accessor :remote
+  attr_accessor :heroku
+  attr_accessor :tag
+  attr_accessor :checks
+  
+  def self.parse(name, attrs)
+    config = EnvConfig.new
+    
+    config.name = name
+    config.remote = attrs['remote'] || name
+    config.heroku = attrs['heroku']
+    config.tag = attrs['tag']
+    config.checks = ChecksConfig.parse(attrs['checks'])
+
+    config
+  end
+end

data/lib/heroploy/tasks/check_task_lib.rb

@@ -0,0 +1,56 @@
+require 'rake/tasklib'
+
+require 'heroploy/commands/heroku'
+require 'heroploy/commands/git'
+require 'heroploy/commands/checks'
+
+require 'heroploy/config/deploy_config'
+
+module Heroploy
+  class CheckTaskLib < ::Rake::TaskLib
+    include ::Rake::DSL if defined?(::Rake::DSL)
+    
+    include Commands::Git
+    include Commands::Heroku
+    include Commands::Checks
+    
+    def initialize(deploy_config, env_config)
+      desc "check remote exists for #{env_config.name}"
+      task :remote do
+        remote = env_config.remote
+        check_remote(remote)
+      end
+      
+      all_tasks = [:remote]
+
+      if env_config.checks.pushed then
+        desc "check changes have been pushed to origin"
+        task :pushed do
+          check_pushed(current_branch)
+        end
+        all_tasks << :pushed
+      end
+
+      if env_config.checks.branch then
+        desc "check we can deploy to #{env_config.name} from the current branch"
+        task :branch do
+          valid_branch = env_config.checks.branch
+          check_branch(current_branch, valid_branch, env_config.name)
+        end
+        all_tasks << :branch
+      end
+
+      if env_config.checks.staged then
+        desc "check the changes have already been staged"
+        task :staged do
+          staging_env_config = deploy_config[env_config.checks.staged]
+          check_staged(staging_env_config.remote, current_branch, staging_env_config.name)
+        end
+        all_tasks << :staged
+      end
+
+      desc "do all the checks for #{env_config.name}"
+      task :all => all_tasks
+    end
+  end
+end

data/lib/heroploy/tasks/deploy_task_lib.rb

@@ -0,0 +1,25 @@
+require 'rake/tasklib'
+
+require 'heroploy/commands/heroku'
+require 'heroploy/commands/git'
+require 'heroploy/commands/checks'
+
+require 'heroploy/config/deploy_config'
+require 'heroploy/tasks/env_task_lib'
+
+module Heroploy
+  class DeployTaskLib < ::Rake::TaskLib
+    include ::Rake::DSL if defined?(::Rake::DSL)
+    
+    def initialize(deploy_config)
+      desc 'do a git fetch'
+      task :fetch do
+        git_fetch
+      end
+
+      deploy_config.environments.each do |env_config|
+        EnvTaskLib.new(deploy_config, env_config)
+      end
+    end
+  end
+end

data/lib/heroploy/tasks/env_task_lib.rb

@@ -0,0 +1,48 @@
+require 'rake/tasklib'
+
+require 'heroploy/commands/heroku'
+require 'heroploy/commands/git'
+require 'heroploy/commands/checks'
+
+require 'heroploy/config/deploy_config'
+require 'heroploy/tasks/check_task_lib'
+
+module Heroploy
+  class EnvTaskLib < ::Rake::TaskLib
+    include ::Rake::DSL if defined?(::Rake::DSL)
+    
+    include Commands::Git
+    include Commands::Heroku
+    include Commands::Checks
+    
+    def initialize(deploy_config, env_config)
+      namespace env_config.name do
+        namespace :check do
+          CheckTaskLib.new(deploy_config, env_config)
+        end
+
+        desc "push the current branch to master on #{env_config.name}"
+        task :push do
+          git_push_to_master(env_config.remote, current_branch)
+        end
+
+        desc "run database migrations on #{env_config.name}"
+        task :migrate do
+          heroku_migrate(env_config.heroku)
+        end
+
+        desc "tag the deployment to #{env_config.name}"
+        task :tag do
+          if env_config.tag then
+            tag = DateTime.now.strftime(env_config.tag)
+            git_tag(tag, "Deployed #{current_branch} to #{env_config.name}")
+            git_push_tag(tag)
+          end
+        end
+
+        desc "deploy to #{env_config.name}"
+        task :deploy => ['check:all', :push, :migrate, :tag]
+      end
+    end
+  end
+end

data/lib/heroploy/tasks/tasks.rake

@@ -0,0 +1,6 @@
+require 'heroploy/tasks/deploy_task_lib'
+
+namespace :heroploy do
+  deploy_config = DeployConfig.load  
+  Heroploy::DeployTaskLib.new(deploy_config)
+end

data/lib/heroploy/version.rb

@@ -1,3 +1,3 @@
 module Heroploy
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/heroploy.rb

@@ -2,5 +2,7 @@ require "heroploy/version"
 require File.join(File.dirname(__FILE__), 'railtie.rb') if defined?(Rails) && Rails::VERSION::MAJOR >= 3
 
 module Heroploy
-  # Your code goes here...
+  def self.root
+    Pathname.new(File.expand_path '../..', __FILE__)
+  end
 end

data/lib/railtie.rb

@@ -3,7 +3,7 @@ require 'rails'
 module Heroploy
   class Railtie < Rails::Railtie
     rake_tasks do
-      load 'heroploy/tasks.rb'
+      load 'heroploy/tasks/tasks.rake'
     end
   end
 end

data/spec/factories.rb

@@ -0,0 +1,47 @@
+FactoryGirl.define do
+  factory :checks_config do
+    pushed false
+    staged false
+    branch nil
+    
+    trait :development do
+      pushed false
+      staged false
+      branch nil
+    end
+    
+    trait :staging do
+      pushed true
+      staged false
+      branch 'master'
+    end
+    
+    trait :production do
+      pushed true
+      staged true
+      branch 'master'
+    end
+  end
+  
+  factory :env_config do    
+    checks { build(:checks_config) }
+    
+    [:development, :staging, :production].each do |t|
+      trait t do
+        name t.to_s
+        remote t.to_s
+        checks { build(:checks_config, t) }
+      end
+    end
+  end
+  
+  factory :deploy_config do
+    environments {
+      [
+        build(:env_config, :development),
+        build(:env_config, :staging),
+        build(:env_config, :production)
+      ]
+    }
+  end
+end

data/spec/lib/heroploy/commands/checks_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+describe Commands::Checks do
+  before(:each) do
+    stub_shell
+  end
+  
+  let(:commands) { Object.new.extend(Commands::Checks) }
+
+  describe "#check_remote" do
+    it "invokes git_remote_exists? to check the remote" do
+      expect(commands).to receive(:git_remote_exists?).with("my-remote").and_return(true)
+      commands.check_remote("my-remote")      
+    end
+    
+    context "if the remote exists" do
+      before { commands.stub(:git_remote_exists?).with("my-remote").and_return(true) }
+
+      it "executes successfully" do
+        commands.check_remote("my-remote")
+      end
+    end
+    
+    context "if the remote doesn't exist" do
+      before { commands.stub(:git_remote_exists?).with("my-remote").and_return(false) }
+      
+      it "raises an error" do
+        expect{
+          commands.check_remote("my-remote")
+        }.to raise_error("Could not find remote 'my-remote'")
+      end
+    end
+  end
+  
+  describe "#check_pushed" do
+    context "if the remote branch exists and is up to date" do
+      it "executes successfully" do
+        expect(commands).to receive(:git_remote_has_branch?).with("origin", "my-branch").and_return(true)
+        expect(commands).to receive(:git_remote_behind?).with("origin", "my-branch").and_return(false)
+        commands.check_pushed("my-branch")
+      end
+    end
+    
+    context "if the remote branch doesn't exist" do
+      it "raises an error" do
+        commands.stub(:git_remote_has_branch?).with("origin", "my-branch").and_return(false)
+        commands.stub(:git_remote_behind?).with("origin", "my-branch").and_return(false)
+        expect{
+          commands.check_pushed("my-branch")
+        }.to raise_error("Branch my-branch doesn't exist in origin")
+      end
+    end
+
+    context "if the remote branch is behind" do
+      it "raises an error" do
+        commands.stub(:git_remote_has_branch?).with("origin", "my-branch").and_return(true)
+        commands.stub(:git_remote_behind?).with("origin", "my-branch").and_return(true)
+        expect{
+          commands.check_pushed("my-branch")
+        }.to raise_error("Branch my-branch is behind origin/my-branch")
+      end
+    end
+  end
+  
+  describe "#check_branch" do
+    context "if the branch is valid" do
+      it "executes successfully" do
+        commands.check_branch("my-branch", "my-branch", "production")
+      end
+    end
+    
+    context "if the branch is invalid" do
+      it "raises an error" do
+        expect{
+          commands.check_branch("my-branch", "my-valid-branch", "production")
+        }.to raise_error("Cannot deploy branch my-branch to production")
+      end
+    end
+  end
+  
+  describe "#check_staged" do
+    context "if the branch is staged" do
+      it "executes successfully" do
+        expect(commands).to receive(:git_staged?).with("my-remote", "my-branch").and_return(true)
+        commands.check_staged("my-remote", "my-branch", "staging")
+      end
+    end
+    
+    context "if the branch isn't yet staged" do
+      it "raises an error" do
+        expect{
+          commands.stub(:git_staged?).with("my-remote", "my-branch").and_return(false)
+          commands.check_staged("my-remote", "my-branch", "staging")
+        }.to raise_error("Changes not yet staged on staging")
+      end
+    end
+  end
+end

data/spec/lib/heroploy/{git_commands_spec.rb → commands/git_spec.rb}

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
-describe GitCommands do
+describe Commands::Git do
   before(:each) do
     stub_shell
   end
   
-  let(:commands) { Object.new.extend(GitCommands) }
+  let(:commands) { Object.new.extend(Commands::Git) }
   
   context "#git_fetch" do
     it "executes a git fetch" do

data/spec/lib/heroploy/{heroku_commands_spec.rb → commands/heroku_spec.rb}

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
-describe HerokuCommands do
+describe Commands::Heroku do
   before(:each) do
     stub_shell
   end
   
-  let(:commands) { Object.new.extend(HerokuCommands) }
+  let(:commands) { Object.new.extend(Commands::Heroku) }
   
   context "#heroku_exec" do
     it "executes the heroku command for the given app" do

data/spec/lib/heroploy/tasks/check_all_spec.rb

@@ -0,0 +1,50 @@
+describe "check:all" do
+  let(:environment) { build(:env_config, :production) }
+
+  context "in all cases" do
+    include_context "rake"
+    its(:prerequisites) { should include('remote') }
+  end
+
+  context "if checks.pushed is set" do
+    before { environment.checks.pushed = true }
+    include_context "rake"
+    
+    its(:prerequisites) { should include('pushed') }
+  end
+  
+  context "if checks.pushed is not set" do
+    before { environment.checks.pushed = false }
+    include_context "rake"
+    
+    its(:prerequisites) { should_not include('pushed') }
+  end
+  
+  context "if checks.staged is set" do  
+    before { environment.checks.staged = true }
+    include_context "rake"
+    
+    its(:prerequisites) { should include('staged') }
+  end
+  
+  context "if checks.staged is not set" do
+    before { environment.checks.staged = false }
+    include_context "rake"
+    
+    its(:prerequisites) { should_not include('staged') }
+  end
+  
+  context "if checks.branch is set" do
+    before { environment.checks.branch = 'master' }
+    include_context "rake"
+    
+    its(:prerequisites) { should include('branch') }
+  end
+  
+  context "if checks.staged is not set" do
+    before { environment.checks.branch = nil }
+    include_context "rake"
+    
+    its(:prerequisites) { should_not include('branch') }
+  end
+end

data/spec/lib/heroploy/tasks/check_branch_spec.rb

@@ -0,0 +1,10 @@
+describe "check:branch" do
+  let(:environment) { build(:env_config, :production) }
+  include_context "rake"
+  
+  it "invokes :check_branch" do
+    Heroploy::CheckTaskLib.any_instance.stub(:current_branch).and_return("my-branch")
+    expect_any_instance_of(Heroploy::CheckTaskLib).to receive(:check_branch).with("my-branch", "master", "production")
+    task.invoke
+  end
+end

data/spec/lib/heroploy/tasks/check_pushed_spec.rb

@@ -0,0 +1,10 @@
+describe "check:pushed" do
+  let(:environment) { build(:env_config, :production) }
+  include_context "rake"
+  
+  it "invokes :check_pushed" do
+    Heroploy::CheckTaskLib.any_instance.stub(:current_branch).and_return("my-branch")
+    expect_any_instance_of(Heroploy::CheckTaskLib).to receive(:check_pushed).with("my-branch")
+    task.invoke
+  end
+end

data/spec/lib/heroploy/tasks/check_remote_spec.rb

@@ -0,0 +1,9 @@
+describe "check:remote" do
+  let(:environment) { build(:env_config, :production) }
+  include_context "rake"
+  
+  it "invokes :check_remote" do
+    expect_any_instance_of(Heroploy::CheckTaskLib).to receive(:check_remote).with("production")
+    task.invoke
+  end
+end

data/spec/lib/heroploy/tasks/check_staged_spec.rb

@@ -0,0 +1,19 @@
+describe "check:staged" do
+  let(:production) { build(:env_config, :production) }
+  let(:staging) { build(:env_config, :staging, remote: "my-staging-remote") }
+  let(:environments) { [production, staging] }
+  
+  include_context "rake"
+  
+  context "if checks.staged is set" do
+    before { production.checks.staged = 'staging' }
+
+    it "invokes :check_pushed" do
+      Heroploy::CheckTaskLib.any_instance.stub(:current_branch).and_return("my-branch")
+
+      expect_any_instance_of(Heroploy::CheckTaskLib).to receive(:check_staged).with("my-staging-remote", "my-branch", "staging")
+
+      task.invoke
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,9 +1,17 @@
-require 'heroploy/heroku_commands'
-require 'heroploy/git_commands'
+require 'factory_girl'
+
+require 'heroploy'
+require 'heroploy/tasks/deploy_task_lib'
+
 require 'support/shell_support'
+require 'support/shared_contexts/rake'
+
+FactoryGirl.find_definitions
 
 RSpec.configure do |config|
   config.color_enabled = true
   
+  config.include FactoryGirl::Syntax::Methods
+  
   config.include ShellSupport
 end

data/spec/support/shared_contexts/rake.rb

@@ -0,0 +1,47 @@
+# references:
+#   http://robots.thoughtbot.com/test-rake-tasks-like-a-boss
+#   http://www.e-tobi.net/blog/2008/10/04/
+
+require "rake"
+
+shared_context "rake" do
+  let(:task_name) {
+    if defined?(environment)
+      env_name = environment.name
+    elsif defined?(environments)
+      env_name = environments[0].name
+    else
+      env_name = deploy_config.environments[0].name
+    end
+
+    "#{env_name}:#{self.class.top_level_description}"
+  }
+
+  let(:task) { Rake::Task[task_name] }
+  
+  subject { task }
+  
+  before(:each) do
+    Rake::Task.clear
+    
+    unless defined?(deploy_config)
+      if defined?(environment)
+        deploy_config = build(:deploy_config, environments: [environment])
+      elsif defined?(environments)
+        deploy_config = build(:deploy_config, environments: environments)
+      else
+        deploy_config = build(:deploy_config)
+      end
+    end
+
+    Heroploy::DeployTaskLib.new(deploy_config) 
+
+    Rake::Task.tasks.each do |task|
+      if task.name != task_name
+        task.stub(:execute)
+      end
+    end
+
+    stub_shell
+  end  
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: heroploy
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - John Brunton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-19 00:00:00.000000000 Z
+date: 2014-01-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,6 +52,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: factory_girl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Helpful rake tasks to manage deploying to development, staging and production
   Heroku servers
 email:
@@ -68,17 +82,32 @@ files:
 - Rakefile
 - heroploy.gemspec
 - lib/heroploy.rb
-- lib/heroploy/deploy_config.rb
-- lib/heroploy/git_commands.rb
-- lib/heroploy/heroku_commands.rb
-- lib/heroploy/shell.rb
-- lib/heroploy/tasks.rb
+- lib/heroploy/commands/checks.rb
+- lib/heroploy/commands/git.rb
+- lib/heroploy/commands/heroku.rb
+- lib/heroploy/commands/shell.rb
+- lib/heroploy/config/checks_config.rb
+- lib/heroploy/config/deploy_config.rb
+- lib/heroploy/config/env_config.rb
+- lib/heroploy/tasks/check_task_lib.rb
+- lib/heroploy/tasks/deploy_task_lib.rb
+- lib/heroploy/tasks/env_task_lib.rb
+- lib/heroploy/tasks/tasks.rake
 - lib/heroploy/version.rb
 - lib/railtie.rb
-- spec/lib/heroploy/git_commands_spec.rb
-- spec/lib/heroploy/heroku_commands_spec.rb
-- spec/lib/heroploy/shell_spec.rb
+- spec/factories.rb
+- spec/lib/heroploy/commands/checks_spec.rb
+- spec/lib/heroploy/commands/git_spec.rb
+- spec/lib/heroploy/commands/heroku_spec.rb
+- spec/lib/heroploy/commands/shell_spec.rb
+- spec/lib/heroploy/tasks/check_all_spec.rb
+- spec/lib/heroploy/tasks/check_branch_spec.rb
+- spec/lib/heroploy/tasks/check_pushed_spec.rb
+- spec/lib/heroploy/tasks/check_remote_spec.rb
+- spec/lib/heroploy/tasks/check_staged_spec.rb
 - spec/spec_helper.rb
+- spec/support/helpers/deploy_config_helper.rb
+- spec/support/shared_contexts/rake.rb
 - spec/support/shell_support.rb
 homepage: ''
 licenses:
@@ -105,8 +134,17 @@ signing_key:
 specification_version: 4
 summary: Helpful rake tasks for deploying to Heroku
 test_files:
-- spec/lib/heroploy/git_commands_spec.rb
-- spec/lib/heroploy/heroku_commands_spec.rb
-- spec/lib/heroploy/shell_spec.rb
+- spec/factories.rb
+- spec/lib/heroploy/commands/checks_spec.rb
+- spec/lib/heroploy/commands/git_spec.rb
+- spec/lib/heroploy/commands/heroku_spec.rb
+- spec/lib/heroploy/commands/shell_spec.rb
+- spec/lib/heroploy/tasks/check_all_spec.rb
+- spec/lib/heroploy/tasks/check_branch_spec.rb
+- spec/lib/heroploy/tasks/check_pushed_spec.rb
+- spec/lib/heroploy/tasks/check_remote_spec.rb
+- spec/lib/heroploy/tasks/check_staged_spec.rb
 - spec/spec_helper.rb
+- spec/support/helpers/deploy_config_helper.rb
+- spec/support/shared_contexts/rake.rb
 - spec/support/shell_support.rb

data/lib/heroploy/deploy_config.rb

@@ -1,39 +0,0 @@
-class ChecksConfig
-  attr_reader :pushed
-  attr_reader :branch
-  attr_reader :staged
-  
-  def initialize(attrs)
-    attrs ||= {}
-    @pushed = attrs['pushed']
-    @branch = attrs['branch']
-    @staged = attrs['staged']
-  end
-end
-
-class AppConfig
-  attr_reader :name
-  attr_reader :remote
-  attr_reader :heroku
-  attr_reader :tag
-  attr_reader :checks
-  
-  def initialize(name, attrs)
-    @name = name
-    @remote = attrs['remote'] || name
-    @heroku = attrs['heroku']
-    @tag = attrs['tag']
-    @checks = ChecksConfig.new(attrs['checks'])
-  end
-end
-
-class DeployConfig
-  attr_reader :apps
-  
-  def initialize(file_name)
-    @apps = YAML::load(File.open(file_name))['apps']
-    @apps.each do |app_name, attrs|
-      @apps[app_name] = AppConfig.new(app_name, attrs)
-    end
-  end
-end

data/lib/heroploy/git_commands.rb

@@ -1,44 +0,0 @@
-require 'heroploy/shell'
-
-module GitCommands
-  def git_fetch
-    Shell.exec "git fetch"
-  end
-  
-  def current_branch
-    branch = Shell.eval "git rev-parse --abbrev-ref HEAD"
-    branch.strip
-  end
-  
-  def git_push_to_master(remote, local_branch)
-    if ENV['force'] == 'true' then opts = "--force " end
-    Shell.exec "git push #{opts}#{remote} #{local_branch}:master"
-  end
-  
-  def git_remote_exists?(name)
-    remotes = Shell.eval("git remote").strip.split(/\s+/)
-    remotes.include?(name)
-  end
-  
-  def git_remote_has_branch?(remote, branch_name)
-    branches = Shell.eval("git branch -r").strip.split(/\s+/)
-    branches.include?("#{remote}/#{branch_name}")
-  end
-  
-  def git_remote_behind?(remote, remote_branch_name, local_branch_name = nil)
-    if local_branch_name.nil? then local_branch_name = remote_branch_name end
-    !Shell.eval("git log #{remote}/#{remote_branch_name}..#{local_branch_name}").empty?
-  end
-  
-  def git_staged?(remote, local_branch)
-    !git_remote_behind?(remote, 'master', local_branch)
-  end
-  
-  def git_tag(tag, message)
-    Shell.exec("git tag -a #{tag} -m \"#{message}\"")
-  end
-  
-  def git_push_tag(tag)
-    Shell.exec("git push origin #{tag}")
-  end
-end

data/lib/heroploy/heroku_commands.rb

@@ -1,17 +0,0 @@
-require 'heroploy/shell'
-
-module HerokuCommands
-  def heroku_exec(cmd, app_name)
-    Shell.exec "heroku #{cmd} --app #{app_name}"
-  end
-  
-  def heroku_run(cmd, app_name)
-    heroku_exec("run #{cmd}", app_name)
-  end
-  
-  def heroku_migrate(app_name)
-    Bundler.with_clean_env do
-      heroku_run("rake db:migrate", app_name)
-    end
-  end
-end

data/lib/heroploy/tasks.rb

@@ -1,87 +0,0 @@
-require 'heroploy/git_commands'
-require 'heroploy/heroku_commands'
-require 'heroploy/deploy_config'
-
-namespace :heroploy do
-  include GitCommands
-  include HerokuCommands
-  
-  desc 'do a git fetch'
-  task :fetch do
-    git_fetch
-  end
-  
-  deploy_config = DeployConfig.new('.heroploy.yml')
-  
-  deploy_config.apps.each do |app_name, config|
-    namespace app_name do
-      namespace :check do
-        desc "check remote exists for #{app_name}"
-        task :remote do
-          remote = config.remote || app_name
-          unless git_remote_exists?(remote)
-            raise "Could not find remote '#{remote}'"
-          end
-        end
-        
-        desc "check changes have been pushed to origin"
-        task :pushed do
-          if config.checks.pushed then
-            branch_name = current_branch
-            unless git_remote_has_branch?('origin', branch_name)
-              raise "Branch #{branch_name} doesn't exist in origin"
-            end
-          
-            if git_remote_behind?('origin', branch_name) then
-              raise "Branch #{branch_name} is behind origin/#{branch_name}"
-            end
-          end
-        end
-
-        desc "check we can deploy to #{app_name} from the current branch"
-        task :branch do
-          if config.checks.branch then
-            unless current_branch == config.checks.branch
-              raise "Cannot deploy branch #{current_branch} to #{app_name}"
-            end
-          end
-        end
-        
-        desc "check the changes have already been staged"
-        task :staged do
-          if config.checks.staged then
-            staging_app_name = config.checks.staged == true ? 'staging' : config.checks.staged
-            unless git_staged?(deploy_config.apps[staging_app_name].remote, current_branch)
-              raise "Changes not yet staged on #{app_name}"
-            end
-          end
-        end
-        
-        desc "do all the checks for #{app_name}"
-        task :all => [:remote, :pushed, :branch, :staged]
-      end
-      
-      desc "push the current branch to master on #{app_name}"
-      task :push do
-        git_push_to_master(config.remote, current_branch)
-      end
-      
-      desc "run database migrations on #{app_name}"
-      task :migrate do
-        heroku_migrate(config.heroku)
-      end
-
-      desc "tag the deployment to #{app_name}"
-      task :tag do
-        if config.tag then
-          tag = DateTime.now.strftime(config.tag)
-          git_tag(tag, "Deployed #{current_branch} to #{app_name}")
-          git_push_tag(tag)
-        end
-      end
-
-      desc "deploy to #{app_name}"
-      task :deploy => ['check:all', :push, :migrate, :tag]
-    end
-  end
-end