heroku-rails 0.0.1 → 0.2.0

data/lib/heroku/rails/railtie.rb

@@ -0,0 +1,9 @@
+module Heroku
+  module Rails
+    class Railtie < ::Rails::Railtie
+      rake_tasks do
+        load 'heroku/rails/tasks.rb'
+      end
+    end
+  end
+end

data/lib/heroku/rails/tasks.rb

@@ -1,224 +1,180 @@
 HEROKU_CONFIG_FILE = Rails.root.join('config', 'heroku.yml')
+HEROKU_CONFIG = Heroku::Rails::HerokuConfig.new(HEROKU_CONFIG_FILE)
+HEROKU_RUNNER = Heroku::Rails::HerokuRunner.new(HEROKU_CONFIG)
 
-require 'heroku/rails/config'
-HEROKU_CONFIG = Heroku::Rails::Config.new(HEROKU_CONFIG_FILE)
-
-(HEROKU_CONFIG.settings['apps'] || []).each do |name, app|
-  desc "Select #{name} Heroku app for later commands"
-  task name do
-    @heroku_apps ||= []
-    @heroku_apps << name
+# create all the the environment specific tasks
+(HEROKU_CONFIG.apps).each do |heroku_env, app_name|
+  desc "Select #{heroku_env} Heroku app for later commands"
+  task heroku_env do
+    HEROKU_RUNNER.add_environment(heroku_env)
   end
 end
 
 desc 'Select all Heroku apps for later command'
 task :all do
-  @heroku_apps = HEROKU_CONFIG.settings['apps'].keys
+  HEROKU_RUNNER.all_environments
 end
 
 namespace :heroku do
-  desc "Creates the Heroku app"
-  task :create do
-    each_heroku_app do |name, app, repo|
-      system_with_echo "heroku create #{app}"
-    end
-  end
-
-  desc "Generate the Heroku gems manifest from gem dependencies"
-  task :gems => 'gems:base' do
-    RAILS_ENV='production'
-    Rake::Task[:environment].invoke
-    gems = Rails.configuration.gems.reject { |g| g.frozen? && !g.framework_gem? }
-    list = gems.collect do |g|
-      command, *options = g.send(:install_command)
-      options.join(" ")
-    end
-
-    list.unshift(%Q{rails --version "= #{Rails.version}"})
-
-    File.open(Rails.root.join('.gems'), 'w') do |f|
-      f.write(list.join("\n"))
-    end
+  def system_with_echo(*args)
+    HEROKU_RUNNER.system_with_echo(*args)
   end
 
   desc 'Add git remotes for all apps in this project'
   task :remotes do
-    each_heroku_app do |name, app, repo|
-      system("git remote add #{name} #{repo}")
-    end
-  end
-
-  desc 'Adds a collaborator'
-  task :share do
-    print "Email address of collaborator to add: "
-    $stdout.flush
-    email = $stdin.gets
-    each_heroku_app do |name, app, repo|
-      system_with_echo "heroku sharing:add --app #{app} #{email}"
-    end
-  end
-
-  desc 'Adds a collaborator'
-  task :unshare do
-    print "Email address of collaborator to remove: "
-    $stdout.flush
-    email = $stdin.gets
-    each_heroku_app do |name, app, repo|
-      system_with_echo "heroku sharing:remove --app #{app} #{email}"
+    HEROKU_RUNNER.each_heroku_app do |heroku_env, app_name, repo|
+      system_with_echo("git remote add #{app_name} #{repo}")
     end
   end
 
   desc 'Lists configured apps'
   task :apps => :all do
-    each_heroku_app do |name, app, repo|
-      puts "#{name} is shorthand for the Heroku app #{app} located at:"
+    puts "\n"
+    HEROKU_RUNNER.each_heroku_app do |heroku_env, app_name, repo|
+      puts "#{heroku_env} maps to the Heroku app #{app_name} located at:"
       puts "  #{repo}"
       puts
     end
   end
 
-  desc 'Add proper RACK_ENV to each application'
-  task :rack_env => :all do
-    each_heroku_app do |name, app, repo|
-      command = "heroku config --app #{app}"
-      puts command
-      config = Hash[`#{command}`.scan(/^(.+?)\s*=>\s*(.+)$/)]
-      if config['RACK_ENV'] != name
-        system_with_echo "heroku config:add --app #{app} RACK_ENV=#{name}"
-      end
-    end
-  end
-
-  desc 'Creates an example configuration file'
-  task :create_config do
-    example = File.join(File.dirname(__FILE__), '..', 'templates', 'heroku.example.yml')
-    if File.exists?(HEROKU_CONFIG_FILE)
-      puts "config/heroku.yml already exists"
-    else
-      puts "Copied example config to config/heroku.yml"
-      FileUtils.cp(example, HEROKU_CONFIG_FILE)
-      system_with_echo("#{ENV['EDITOR']} #{HEROKU_CONFIG_FILE}")
+  desc "Get remote server information on the heroku app"
+  task :info do
+    HEROKU_RUNNER.each_heroku_app do |heroku_env, app_name, repo|
+      system_with_echo "heroku info --app #{app_name}"
+      puts "\n"
     end
   end
 
-  namespace :setup do
-    # TODO
-  end
+  desc "Deploys, migrates and restarts latest code"
+  task :deploy => "heroku:before_deploy" do
+    HEROKU_RUNNER.each_heroku_app do |heroku_env, app_name, repo|
 
-end
+      # set the current heroku_app so that callbacks can read the data
+      @heroku_app = {:env => heroku_env, :app_name => app_name, :repo => repo}
+      Rake::Task["heroku:before_each_deploy"].invoke
 
-desc "Deploys, migrates and restarts latest code"
-task :deploy => :before_deploy do
-  each_heroku_app do |name, app, repo|
-    @heroku_app = {:name => name, :app => app, :repo => repo}
-    Rake::Task[:before_each_deploy].invoke
-    branch = `git branch`.scan(/^\* (.*)\n/).flatten.first.to_s
-    if branch.present?
-      @git_push_arguments ||= []
-      system_with_echo "git push #{repo} #{@git_push_arguments.join(' ')} #{branch}:master && heroku rake --app #{app} db:migrate && heroku restart --app #{app}"
-    else
-      puts "Unable to determine the current git branch, please checkout the branch you'd like to deploy"
-      exit(1)
+      branch = `git branch`.scan(/^\* (.*)\n/).flatten.first.to_s
+      if branch.present?
+        @git_push_arguments ||= []
+        system_with_echo "git push #{repo} #{@git_push_arguments.join(' ')} #{branch}:master && heroku rake --app #{app_name} db:migrate && heroku restart --app #{app_name}"
+      else
+        puts "Unable to determine the current git branch, please checkout the branch you'd like to deploy"
+        exit(1)
+      end
+      Rake::Task["heroku:after_each_deploy"].invoke
     end
-    Rake::Task[:after_each_deploy].invoke
+    Rake::Task["heroku:after_deploy"].execute
   end
-  Rake::Task[:after_deploy].execute
-end
 
-desc "Callback before all deploys"
-task :before_deploy do
-end
-
-desc "Callback after all deploys"
-task :after_deploy do
-end
-
-desc "Callback before each deploy"
-task :before_each_deploy do
-end
-
-desc "Callback after each deploy"
-task :after_each_deploy do
-end
+  # Callback before all deploys
+  task :before_deploy do
+  end
 
+  # Callback after all deploys
+  task :after_deploy do
+  end
 
-desc "Force deploys, migrates and restarts latest code"
-task :force_deploy do
-  @git_push_arguments ||= []
-  @git_push_arguments << '--force'
-  Rake::Task[:deploy].execute
-end
+  # Callback before each deploy
+  task :before_each_deploy do
+  end
 
-desc "Captures a bundle on Heroku"
-task :capture do
-  each_heroku_app do |name, app, repo|
-    system_with_echo "heroku bundles:capture --app #{app}"
+  # Callback after each deploy
+  task :after_each_deploy do
   end
-end
 
-desc "Opens a remote console"
-task :console do
-  each_heroku_app do |name, app, repo|
-    system_with_echo "heroku console --app #{app}"
+  desc "Force deploys, migrates and restarts latest code"
+  task :force_deploy do
+    @git_push_arguments ||= []
+    @git_push_arguments << '--force'
+    Rake::Task["heroku:deploy"].execute
   end
-end
 
-desc "Restarts remote servers"
-task :restart do
-  each_heroku_app do |name, app, repo|
-    system_with_echo "heroku restart --app #{app}"
+  desc "Captures a bundle on Heroku"
+  task :capture do
+    HEROKU_RUNNER.each_heroku_app do |heroku_env, app_name, repo|
+      system_with_echo "heroku bundles:capture --app #{app_name}"
+    end
   end
-end
 
-desc "Migrates and restarts remote servers"
-task :migrate do
-  each_heroku_app do |name, app, repo|
-    system_with_echo "heroku rake --app #{app} db:migrate && heroku restart --app #{app}"
+  desc "Opens a remote console"
+  task :console do
+    HEROKU_RUNNER.each_heroku_app do |heroku_env, app_name, repo|
+      system_with_echo "heroku console --app #{app_name}"
+    end
   end
-end
 
-namespace :db do
-  task :pull do
-    each_heroku_app do |name, app, repo|
-      system_with_echo "heroku pgdumps:capture --app #{app}"
-      dump = `heroku pgdumps --app #{app}`.split("\n").last.split(" ").first
-      system_with_echo "mkdir -p #{Rails.root}/db/dumps"
-      file = "#{Rails.root}/db/dumps/#{dump}.sql.gz"
-      url = `heroku pgdumps:url --app #{app} #{dump}`.chomp
-      system_with_echo "wget", url, "-O", file
-      system_with_echo "rake db:drop db:create"
-      system_with_echo "gunzip -c #{file} | #{Rails.root}/script/dbconsole"
-      system_with_echo "rake jobs:clear"
+  desc "Restarts remote servers"
+  task :restart do
+    HEROKU_RUNNER.each_heroku_app do |heroku_env, app_name, repo|
+      system_with_echo "heroku restart --app #{app_name}"
     end
   end
-end
 
-def system_with_echo(*args)
-  puts args.join(' ')
-  system(*args)
-end
+  namespace :setup do
 
-def each_heroku_app
-  if @heroku_apps.blank? && HEROKU_CONFIG.settings['apps'].size == 1
-    app = HEROKU_CONFIG.settings['apps'].keys.first
-    puts "Defaulting to #{app} app since only one app is defined"
-    @heroku_apps = [app]
-  end
-  if @heroku_apps.present?
-    @heroku_apps.each do |name|
-      app = HEROKU_CONFIG.settings['apps'][name]
-      yield(name, app, "git@heroku.com:#{app}.git")
+    desc "Creates the apps on Heroku"
+    task :create_apps do
+      HEROKU_RUNNER.create_apps
+    end
+
+    desc "Setup the Heroku stacks from heroku.yml config"
+    task :stacks do
+      HEROKU_RUNNER.setup_stacks
+    end
+
+    desc "Setup the Heroku collaborators from heroku.yml config"
+    task :collaborators do
+      HEROKU_RUNNER.setup_collaborators
+    end
+
+    desc "Setup the Heroku environment config variables from heroku.yml config"
+    task :config do
+      HEROKU_RUNNER.setup_config
     end
-    puts
-  else
-    puts "You must first specify at least one Heroku app:
-      rake <app> [<app>] <command>
-      rake production restart
-      rake demo staging deploy"
 
-    puts "\nYou can use also command all Heroku apps for this project:
-      rake all heroku:share"
+    desc "Setup the Heroku addons from heroku.yml config"
+    task :addons do
+      HEROKU_RUNNER.setup_addons
+    end
 
-    exit(1)
+    desc "Setup the Heroku domains from heroku.yml config"
+    task :domains do
+      HEROKU_RUNNER.setup_domains
+    end
   end
-end
+
+  desc "Setup Heroku deploy environment from heroku.yml config"
+  task :setup => [
+    "heroku:setup:stacks",
+    "heroku:setup:collaborators",
+    "heroku:setup:config",
+    "heroku:setup:addons",
+    "heroku:setup:domains",
+  ]
+
+  namespace :db do
+    desc "Migrates and restarts remote servers"
+    task :migrate do
+      HEROKU_RUNNER.each_heroku_app do |heroku_env, app_name, repo|
+        system_with_echo "heroku rake --app #{app_name} db:migrate && heroku restart --app #{app_name}"
+      end
+    end
+
+    desc "Pulls the database from heroku and stores it into db/dumps/"
+    task :pull do
+      HEROKU_RUNNER.each_heroku_app do |heroku_env, app_name, repo|
+        system_with_echo "heroku pgdumps:capture --app #{app_name}"
+        dump = `heroku pgdumps --app #{app_name}`.split("\n").last.split(" ").first
+        system_with_echo "mkdir -p #{Rails.root}/db/dumps"
+        file = "#{Rails.root}/db/dumps/#{dump}.sql.gz"
+        url = `heroku pgdumps:url --app #{app_name} #{dump}`.chomp
+        system_with_echo "wget", url, "-O", file
+
+        # TODO: these are a bit distructive...
+        # system_with_echo "rake db:drop db:create"
+        # system_with_echo "gunzip -c #{file} | #{Rails.root}/script/dbconsole"
+        # system_with_echo "rake jobs:clear"
+      end
+    end
+  end
+end

data/spec/fixtures/heroku-config.yml

@@ -0,0 +1,48 @@
+apps:
+  production: awesomeapp
+  staging: awesomeapp-staging
+
+stacks:
+  all: bamboo-mri-1.9.2
+  staging: bamboo-ree-1.8.7
+
+config:
+  all:
+    BUNDLE_WITHOUT: "test development"
+    CONFIG_VAR1: "config1"
+    CONFIG_VAR2: "config2"
+
+  production:
+    CONFIG_VAR1: "config1-production"
+
+  staging:
+    CONFIG_VAR1: "config1-staging"
+    STAGING_CONFIG: "special-staging"
+
+collaborators:
+  all:
+    - "all-user1@somedomain.com"
+    - "all-user2@somedomain.com"
+    - "all-user2@somedomain.com"
+  staging:
+    - "staging-user@somedomain.com"
+  production:
+    - "production-user@somedomain.com"
+
+domains:
+  staging:
+    - "staging.awesomeapp.com"
+  production:
+    - "awesomeapp.com"
+    - "www.awesomeapp.com"
+
+addons:
+  all:
+    # add any other addons here
+    - custom_domains:basic
+    - newrelic:bronze
+
+  production:
+    # list production env specific addons here
+    - ssl:piggyback
+    - cron:hourly

data/spec/heroku/rails/heroku_config_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+
+module Heroku::Rails
+  describe HerokuConfig do
+    before(:each) do
+      @config = HerokuConfig.new(config_path("heroku-config.yml"))
+    end
+
+    it "should read the configuration file" do
+      @config.settings.should_not be_empty
+    end
+
+    describe "#apps" do
+      it "should return the list of apps defined" do
+        @config.apps.should have(2).apps
+        @config.apps.should include("production" => "awesomeapp")
+        @config.apps.should include("staging" => "awesomeapp-staging")
+      end
+    end
+
+    describe "#app_names" do
+      it "should return the list of apps defined" do
+        @config.app_names.should have(2).names
+        @config.app_names.should include("awesomeapp")
+        @config.app_names.should include("awesomeapp-staging")
+      end
+    end
+
+    describe "#app_environments" do
+      it "should return a list of the environments defined" do
+        @config.app_environments.should have(2).environments
+        @config.app_environments.should include("production")
+        @config.app_environments.should include("staging")
+      end
+    end
+
+    describe "#stack" do
+      it "should return the associated stack for an environment" do
+        @config.stack("staging").should == "bamboo-ree-1.8.7"
+      end
+
+      it "should default to the all setting if not explicitly defined" do
+        @config.stack("production").should == "bamboo-mri-1.9.2"
+      end
+    end
+
+    describe "#config" do
+      context "staging environment" do
+        before(:each) do
+          @config = @config.config("staging")
+        end
+        it "should include configs defined in 'staging'" do
+          @config["STAGING_CONFIG"].should == "special-staging"
+        end
+
+        it "should include configs defined in 'all'" do
+          @config["BUNDLE_WITHOUT"].should == "test development"
+        end
+
+        it "should use configs defined in 'staging' ahead of configs defined in 'all'" do
+          @config["CONFIG_VAR1"].should == "config1-staging"
+        end
+      end
+    end
+
+    describe "#collaborators" do
+      context "staging environment" do
+        before(:each) do
+          @collaborators = @config.collaborators('staging')
+        end
+
+        it "should include the collaborators defined in 'all'" do
+          @collaborators.should include('all-user1@somedomain.com')
+          @collaborators.should include('all-user2@somedomain.com')
+          @collaborators.should have(3).collaborators
+        end
+
+        it "should include collaborators defined in 'staging'" do
+          @collaborators.should include('staging-user@somedomain.com')
+        end
+
+        it "should not include collaborators defined in 'production'" do
+          @collaborators.should_not include('production-user@somedomain.com')
+        end
+      end
+    end
+
+    describe "#domains" do
+      context "staging environment" do
+        before(:each) do
+          @domains = @config.domains('staging')
+        end
+
+        it "should include the domains defined in 'staging'" do
+          @domains.should include('staging.awesomeapp.com')
+        end
+
+        it "should not include the domains defined in 'production'" do
+          @domains.should_not include('awesomeapp.com')
+          @domains.should_not include('www.awesomeapp.com')
+        end
+      end
+
+      context "production environment" do
+        it "should include the domains defined in 'production'" do
+          @domains = @config.domains('production')
+          @domains.should include('awesomeapp.com')
+          @domains.should include('www.awesomeapp.com')
+        end
+      end
+    end
+
+    describe "#addons" do
+      context "staging environment" do
+        before(:each) do
+          @addons = @config.addons('staging')
+        end
+
+        it "should include addons defined in 'all'" do
+          @addons.should include('custom_domains:basic')
+          @addons.should include('newrelic:bronze')
+        end
+
+        it "should not include addons defined in 'production'" do
+          @addons.should_not include('ssl:piggyback')
+        end
+      end
+    end
+
+  end
+end