heroku-rails 0.3.0 → 0.3.1

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    heroku-rails (0.3.0)
+    heroku-rails (0.3.1)
       heroku (>= 1.11.0)
 
 GEM
@@ -10,14 +10,12 @@ GEM
     archive-tar-minitar (0.5.2)
     autotest (4.4.1)
     columnize (0.3.1)
-    configuration (1.1.0)
+    configuration (1.2.0)
     diff-lcs (1.1.2)
     growl-glue (1.0.7)
-    heroku (1.11.0)
-      json_pure (>= 1.2.0, < 1.5.0)
+    heroku (1.20.1)
       launchy (~> 0.3.2)
-      rest-client (>= 1.4.0, < 1.7.0)
-    json_pure (1.4.6)
+      rest-client (< 1.7.0, >= 1.4.0)
     launchy (0.3.7)
       configuration (>= 0.0.5)
       rake (>= 0.8.1)
@@ -60,7 +58,6 @@ PLATFORMS
 DEPENDENCIES
   autotest
   growl-glue
-  heroku (>= 1.11.0)
   heroku-rails!
   rspec (~> 2.0)
   ruby-debug

data/heroku-rails.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "heroku-rails"
-  s.version = "0.3.0"
+  s.version = "0.3.1"
 
   s.authors = ["Elijah Miller", "Glenn Roberts", "Jacques Crocker"]
   s.summary = "Deployment and configuration tools for Heroku/Rails"

data/lib/heroku-rails.rb

@@ -1,3 +1,3 @@
-require 'heroku/rails/heroku_config'
-require 'heroku/rails/heroku_runner'
-require 'heroku/rails/railtie' if defined?(::Rails::Railtie)
+require 'heroku-rails/config'
+require 'heroku-rails/runner'
+require 'heroku-rails/railtie' if defined?(::Rails::Railtie)

data/lib/heroku-rails/config.rb

@@ -0,0 +1,76 @@
+module HerokuRails
+  class Config
+
+    class << self
+      def root
+        @heroku_rails_root || ENV["RAILS_ROOT"] || "."
+      end
+      def root=(root)
+        @heroku_rails_root = root
+      end
+    end
+
+    attr_accessor :settings
+
+    def initialize(config_filepath)
+      if File.exists?(config_filepath)
+        self.settings = YAML.load_file(config_filepath) || {}
+      else
+        self.settings = {}
+      end
+    end
+
+    def apps
+      self.settings['apps'] || {}
+    end
+
+    def app_names
+      apps.values
+    end
+
+    def app_environments
+      apps.keys
+    end
+
+    # return the stack setting for a particular app environment
+    def stack(app_env)
+      stacks = self.settings['stacks'] || {}
+      stacks[app_env] || stacks['all']
+    end
+
+    # pull out the config setting hash for a particular app environment
+    def config(app_env)
+      config = self.settings['config'] || {}
+      all = config['all'] || {}
+
+      # overwrite all configs with the environment specific ones
+      all.merge(config[app_env] || {})
+    end
+
+    # return a list of domains for a particular app environment
+    def domains(app_env)
+      domains = self.settings['domains'] || {}
+      domains[app_env] || []
+    end
+
+    # return a list of collaborators for a particular app environment
+    def collaborators(app_env)
+      app_setting_list('collaborators', app_env)
+    end
+
+    # return a list of addons for a particular app environment
+    def addons(app_env)
+      app_setting_list('addons', app_env)
+    end
+
+    protected
+
+    def app_setting_list(setting_key, app)
+      setting = self.settings[setting_key] || {}
+      all = setting['all'] || []
+
+      # add in collaborators from app environment to the ones defined in all
+      (all + (setting[app] || [])).uniq
+    end
+  end
+end

data/lib/{heroku/rails → heroku-rails}/railtie.rb

@@ -2,6 +2,7 @@ module Heroku
   module Rails
     class Railtie < ::Rails::Railtie
       rake_tasks do
+        HerokuRails::Config.root = Rails.root
         load 'heroku/rails/tasks.rb'
       end
     end

data/lib/heroku-rails/runner.rb

@@ -0,0 +1,256 @@
+require 'heroku/client'
+
+module HerokuRails
+  class Runner
+    def initialize(config)
+      @config = config
+      @environments = []
+    end
+
+    def authorize
+      return if @heroku
+
+      # setup heroku username and password so we can start up a heroku client
+      credentials_path = File.expand_path("~/.heroku/credentials")
+
+      # read in the username,password so we can build the client
+      if File.exists?(credentials_path)
+        auth = File.read(credentials_path)
+        username, password = auth.split("\n")
+        @heroku = Heroku::Client.new(username, password)
+      else
+        puts "Heroku not set up. Run `heroku list` in order to input your credentials and try again"
+        exit(1)
+      end
+    end
+
+    # add a specific environment to the run list
+    def add_environment(env)
+      @environments << env
+    end
+
+    # use all environments
+    def all_environments
+      @environments = @config.app_environments
+    end
+
+    # setup apps (create if necessary)
+    def setup_apps
+      authorize unless @heroku
+
+      # get a list of all my current apps on Heroku (so we don't create dupes)
+      @my_apps = @heroku.list.map{|a| a.first}
+
+      each_heroku_app do |heroku_env, app_name, repo|
+        next if @my_apps.include?(app_name)
+
+        stack = @config.stack(heroku_env)
+        stack_option = " --stack #{stack}" if stack.to_s.size > 0
+        system_with_echo "heroku create #{app_name}#{stack_option} --remote #{app_name}"
+      end
+    end
+
+    # setup the stacks for each app (migrating if necessary)
+    def setup_stacks
+      authorize unless @heroku
+      each_heroku_app do |heroku_env, app_name, repo|
+        # get the intended stack setting
+        stack = @config.stack(heroku_env)
+
+        # get the remote info about the app from heroku
+        heroku_app_info = @heroku.info(app_name) || {}
+
+        # if the stacks don't match, then perform a migration
+        if stack != heroku_app_info[:stack]
+          puts "Migrating the app: #{app_name} to the stack: #{stack}"
+          system_with_echo "heroku stack:migrate #{stack} --app #{app_name}"
+        end
+      end
+    end
+
+    # setup the list of collaborators
+    def setup_collaborators
+      authorize unless @heroku
+      each_heroku_app do |heroku_env, app_name, repo|
+        # get the remote info about the app from heroku
+        heroku_app_info = @heroku.info(app_name) || {}
+
+        # get the intended list of collaborators to add
+        collaborator_emails = @config.collaborators(heroku_env)
+
+        # add current user to collaborator list (always)
+        collaborator_emails << @heroku.user unless collaborator_emails.include?(@heroku.user)
+        collaborator_emails << heroku_app_info[:owner] unless collaborator_emails.include?(heroku_app_info[:owner])
+
+        # get existing collaborators
+        existing_emails = heroku_app_info[:collaborators].to_a.map{|c| c[:email]}
+
+        # get the list of collaborators to delete
+        existing_emails.each do |existing_email|
+          # check to see if we need to delete this person
+          unless collaborator_emails.include?(existing_email)
+            # delete that collaborator if they arent on the approved list
+            system_with_echo "heroku sharing:remove #{existing_email} --app #{app_name}"
+          end
+        end
+
+        # get the list of collaborators to add
+        collaborator_emails.each do |collaborator_email|
+          # check to see if we need to add this person
+          unless existing_emails.include?(collaborator_email)
+            # add the collaborator if they are not already on the server
+            system_with_echo "heroku sharing:add #{collaborator_email} --app #{app_name}"
+          end
+        end
+      end
+    end
+
+    # setup configuration
+    def setup_config
+      authorize unless @heroku
+      each_heroku_app do |heroku_env, app_name, repo|
+        # get the configuration that we are aiming towards
+        new_config = @config.config(heroku_env)
+
+        # default RACK_ENV to the heroku_env (unless its manually set to something else)
+        unless new_config["RACK_ENV"].to_s.length > 0
+          new_config["RACK_ENV"] = heroku_env
+        end
+
+        # get the existing config from heroku's servers
+        existing_config = @heroku.config_vars(app_name) || {}
+
+        # find the config variables to add
+        add_config = {}
+        new_config.each do |new_key, new_val|
+          add_config[new_key] = new_val unless existing_config[new_key] == new_val
+        end
+
+        # persist the changes onto heroku
+        unless add_config.empty?
+          # add the config
+          set_config = ""
+          add_config.each do |key, val|
+            set_config << "#{key}='#{val}' "
+          end
+
+          system_with_echo "heroku config:add #{set_config} --app #{app_name}"
+        end
+      end
+    end
+
+    # setup the addons for heroku
+    def setup_addons
+      authorize unless @heroku
+      each_heroku_app do |heroku_env, app_name, repo|
+        # get the addons that we are aiming towards
+        addons = @config.addons(heroku_env)
+
+        # get the addons that are already on the servers
+        existing_addons = (@heroku.installed_addons(app_name) || []).map{|a| a["name"]}
+
+        # all apps need the shared database
+        addons << "shared-database:5mb" unless addons.index("shared-database:5mb")
+
+        # add "custom_domains" if that addon doesnt already exist
+        # and we have domains configured for this app
+        addons << "custom_domains:basic" unless @config.domains(heroku_env).empty? or
+                                                addons.any?{|a| a =~ /custom_domains/} or
+                                                existing_addons.any?{|a| a =~ /custom_domains/}
+
+        # remove the addons that need to be removed
+        existing_addons.each do |existing_addon|
+          # check to see if we need to delete this addon
+          unless addons.include?(existing_addon)
+            # delete this addon if they arent on the approved list
+            system_with_echo "heroku addons:remove #{existing_addon} --app #{app_name}"
+          end
+        end
+
+        # add the addons that dont exist already
+        addons.each do |addon|
+          # check to see if we need to add this addon
+          unless existing_addons.include?(addon)
+            # add this addon if they are not already added
+            system_with_echo "heroku addons:add #{addon} --app #{app_name}"
+          end
+        end
+      end
+    end
+
+    # setup the domains for heroku
+    def setup_domains
+      authorize unless @heroku
+      each_heroku_app do |heroku_env, app_name, repo|
+        # get the domains that we are aiming towards
+        domains = @config.domains(heroku_env)
+
+        # get the domains that are already on the servers
+        existing_domains = (@heroku.list_domains(app_name) || []).map{|a| a[:domain]}
+
+        # remove the domains that need to be removed
+        existing_domains.each do |existing_domain|
+          # check to see if we need to delete this domain
+          unless domains.include?(existing_domain)
+            # delete this domain if they arent on the approved list
+            system_with_echo "heroku domains:remove #{existing_domain} --app #{app_name}"
+          end
+        end
+
+        # add the domains that dont exist already
+        domains.each do |domain|
+          # check to see if we need to add this domain
+          unless existing_domains.include?(domain)
+            # add this domain if they are not already added
+            system_with_echo "heroku domains:add #{domain} --app #{app_name}"
+          end
+        end
+      end
+    end
+
+    # cycles through each configured heroku app
+    # yields the environment name, the app name, and the repo url
+    def each_heroku_app
+
+      if @config.apps.size == 0
+        puts "\nNo heroku apps are configured. Run:
+          rails generate heroku:config\n\n"
+        puts "this will generate a default config/heroku.yml that you should edit"
+        puts "and then try running this command again"
+
+        exit(1)
+      end
+
+      if @environments.blank? && @config.apps.size == 1
+        @environments = [@config.app_environments.first]
+      end
+
+      if @environments.present?
+        @environments.each do |heroku_env|
+          app_name = @config.apps[heroku_env]
+          yield(heroku_env, app_name, "git@heroku.com:#{app_name}.git")
+        end
+      else
+        puts "\nYou must first specify at least one Heroku app:
+          rake <app> [<app>] <command>
+          rake production restart
+          rake demo staging deploy"
+
+        puts "\n\nYou can use also command all Heroku apps for this project:
+          rake all heroku:setup\n"
+
+        exit(1)
+      end
+    end
+
+    def system_with_echo(*args)
+      puts args.join(' ')
+      command(*args)
+    end
+
+    def command(*args)
+      system(*args)
+    end
+
+  end
+end

data/lib/heroku/rails/tasks.rb

@@ -1,6 +1,8 @@
-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'
+
+HEROKU_CONFIG_FILE = File.join(HerokuRails::Config.root, 'config', 'heroku.yml')
+HEROKU_CONFIG = HerokuRails::Config.new(HEROKU_CONFIG_FILE)
+HEROKU_RUNNER = HerokuRails::Runner.new(HEROKU_CONFIG)
 
 # create all the the environment specific tasks
 (HEROKU_CONFIG.apps).each do |heroku_env, app_name|
@@ -186,14 +188,14 @@ namespace :heroku 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"
+        system_with_echo "mkdir -p #{HerokuRails::Config.root}/db/dumps"
+        file = "#{HerokuRails::Config.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 "gunzip -c #{file} | #{HerokuRails::Config.root}/script/dbconsole"
         # system_with_echo "rake jobs:clear"
       end
     end

data/spec/heroku/rails/heroku_config_spec.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
 
-module Heroku::Rails
-  describe HerokuConfig do
+module HerokuRails
+  describe Config do
     before(:each) do
-      @config = HerokuConfig.new(config_path("heroku-config.yml"))
+      @config = Config.new(config_path("heroku-config.yml"))
     end
 
     it "should read the configuration file" do

metadata

@@ -1,12 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: heroku-rails
 version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 3
-  - 0
-  version: 0.3.0
+  prerelease: 
+  version: 0.3.1
 platform: ruby
 authors: 
 - Elijah Miller
@@ -16,7 +12,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-24 00:00:00 -08:00
+date: 2011-04-08 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -26,10 +22,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 1
-        - 11
-        - 0
         version: 1.11.0
   type: :runtime
   prerelease: false
@@ -41,9 +33,6 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        segments: 
-        - 2
-        - 0
         version: "2.0"
   type: :development
   prerelease: false
@@ -63,10 +52,10 @@ files:
 - lib/generators/heroku/config_generator.rb
 - lib/generators/templates/heroku.rake
 - lib/generators/templates/heroku.yml
-- lib/heroku/rails/heroku_config.rb
-- lib/heroku/rails/heroku_runner.rb
-- lib/heroku/rails/railtie.rb
 - lib/heroku/rails/tasks.rb
+- lib/heroku-rails/config.rb
+- lib/heroku-rails/railtie.rb
+- lib/heroku-rails/runner.rb
 - lib/heroku-rails.rb
 - spec/fixtures/heroku-config.yml
 - spec/heroku/rails/heroku_config_spec.rb
@@ -94,7 +83,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 1405052361419442961
+      hash: 680656138277193896
       segments: 
       - 0
       version: "0"
@@ -103,14 +92,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 1405052361419442961
+      hash: 680656138277193896
       segments: 
       - 0
       version: "0"
 requirements: []
 
 rubyforge_project: none
-rubygems_version: 1.3.7
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: Deployment and configuration tools for Heroku/Rails

data/lib/heroku/rails/heroku_config.rb

@@ -1,69 +0,0 @@
-module Heroku
-  module Rails
-    class HerokuConfig
-
-      attr_accessor :settings
-
-      def initialize(config_filepath)
-        if File.exists?(config_filepath)
-          self.settings = YAML.load_file(config_filepath) || {}
-        else
-          self.settings = {}
-        end
-      end
-
-      def apps
-        self.settings['apps'] || {}
-      end
-
-      def app_names
-        apps.values
-      end
-
-      def app_environments
-        apps.keys
-      end
-
-      # return the stack setting for a particular app environment
-      def stack(app_env)
-        stacks = self.settings['stacks'] || {}
-        stacks[app_env] || stacks['all']
-      end
-
-      # pull out the config setting hash for a particular app environment
-      def config(app_env)
-        config = self.settings['config'] || {}
-        all = config['all'] || {}
-
-        # overwrite all configs with the environment specific ones
-        all.merge(config[app_env] || {})
-      end
-
-      # return a list of domains for a particular app environment
-      def domains(app_env)
-        domains = self.settings['domains'] || {}
-        domains[app_env] || []
-      end
-
-      # return a list of collaborators for a particular app environment
-      def collaborators(app_env)
-        app_setting_list('collaborators', app_env)
-      end
-
-      # return a list of addons for a particular app environment
-      def addons(app_env)
-        app_setting_list('addons', app_env)
-      end
-
-      protected
-
-      def app_setting_list(setting_key, app)
-        setting = self.settings[setting_key] || {}
-        all = setting['all'] || []
-
-        # add in collaborators from app environment to the ones defined in all
-        (all + (setting[app] || [])).uniq
-      end
-    end
-  end
-end

data/lib/heroku/rails/heroku_runner.rb

@@ -1,254 +0,0 @@
-require 'heroku/client'
-
-module Heroku
-  module Rails
-    class HerokuRunner
-      def initialize(config)
-        @config = config
-        @environments = []
-      end
-
-      def authorize
-        return if @heroku
-
-        # setup heroku username and password so we can start up a heroku client
-        credentials_path = File.expand_path("~/.heroku/credentials")
-
-        # read in the username,password so we can build the client
-        if File.exists?(credentials_path)
-          auth = File.read(credentials_path)
-          username, password = auth.split("\n")
-          @heroku = Heroku::Client.new(username, password)
-        else
-          puts "Heroku not set up. Run `heroku list` in order to input your credentials and try again"
-          exit(1)
-        end
-      end
-
-      # add a specific environment to the run list
-      def add_environment(env)
-        @environments << env
-      end
-
-      # use all environments
-      def all_environments
-        @environments = @config.app_environments
-      end
-
-      # setup apps (create if necessary)
-      def setup_apps
-        authorize unless @heroku
-
-        # get a list of all my current apps on Heroku (so we don't create dupes)
-        @my_apps = @heroku.list.map{|a| a.first}
-
-        each_heroku_app do |heroku_env, app_name, repo|
-          next if @my_apps.include?(app_name)
-
-          stack = @config.stack(heroku_env)
-          stack_option = " --stack #{stack}" if stack.to_s.size > 0
-          system_with_echo "heroku create #{app_name}#{stack_option} --remote #{app_name}"
-        end
-      end
-
-      # setup the stacks for each app (migrating if necessary)
-      def setup_stacks
-        authorize unless @heroku
-        each_heroku_app do |heroku_env, app_name, repo|
-          # get the intended stack setting
-          stack = @config.stack(heroku_env)
-
-          # get the remote info about the app from heroku
-          heroku_app_info = @heroku.info(app_name) || {}
-
-          # if the stacks don't match, then perform a migration
-          if stack != heroku_app_info[:stack]
-            puts "Migrating the app: #{app_name} to the stack: #{stack}"
-            system_with_echo "heroku stack:migrate #{stack} --app #{app_name}"
-          end
-        end
-      end
-
-      # setup the list of collaborators
-      def setup_collaborators
-        authorize unless @heroku
-        each_heroku_app do |heroku_env, app_name, repo|
-          # get the remote info about the app from heroku
-          heroku_app_info = @heroku.info(app_name) || {}
-
-          # get the intended list of collaborators to add
-          collaborator_emails = @config.collaborators(heroku_env)
-
-          # get existing collaborators
-          existing_emails = heroku_app_info[:collaborators].to_a.map{|c| c[:email]}
-
-          # get the list of collaborators to delete
-          existing_emails.each do |existing_email|
-            # check to see if we need to delete this person
-            unless collaborator_emails.include?(existing_email)
-              # delete that collaborator if they arent on the approved list
-              system_with_echo "heroku sharing:remove #{existing_email} --app #{app_name}"
-            end
-          end
-
-          # get the list of collaborators to add
-          collaborator_emails.each do |collaborator_email|
-            # check to see if we need to add this person
-            unless existing_emails.include?(collaborator_email)
-              # add the collaborator if they are not already on the server
-              system_with_echo "heroku sharing:add #{collaborator_email} --app #{app_name}"
-            end
-          end
-        end
-      end
-
-      # setup configuration
-      def setup_config
-        authorize unless @heroku
-        each_heroku_app do |heroku_env, app_name, repo|
-          # get the configuration that we are aiming towards
-          new_config = @config.config(heroku_env)
-
-          # default RACK_ENV to the heroku_env (unless its manually set to something else)
-          unless new_config["RACK_ENV"].to_s.length > 0
-            new_config["RACK_ENV"] = heroku_env
-          end
-
-          # get the existing config from heroku's servers
-          existing_config = @heroku.config_vars(app_name) || {}
-
-          # find the config variables to add
-          add_config = {}
-          new_config.each do |new_key, new_val|
-            add_config[new_key] = new_val unless existing_config[new_key] == new_val
-          end
-
-          # persist the changes onto heroku
-          unless add_config.empty?
-            # add the config
-            set_config = ""
-            add_config.each do |key, val|
-              set_config << "#{key}='#{val}' "
-            end
-
-            system_with_echo "heroku config:add #{set_config} --app #{app_name}"
-          end
-        end
-      end
-
-      # setup the addons for heroku
-      def setup_addons
-        authorize unless @heroku
-        each_heroku_app do |heroku_env, app_name, repo|
-          # get the addons that we are aiming towards
-          addons = @config.addons(heroku_env)
-
-          # get the addons that are already on the servers
-          existing_addons = (@heroku.installed_addons(app_name) || []).map{|a| a["name"]}
-
-          # all apps need the shared database
-          addons << "shared-database:5mb" unless addons.index("shared-database:5mb")
-
-          # add "custom_domains" if that addon doesnt already exist
-          # and we have domains configured for this app
-          addons << "custom_domains:basic" unless @config.domains(heroku_env).empty? or
-                                                  addons.any?{|a| a =~ /custom_domains/} or
-                                                  existing_addons.any?{|a| a =~ /custom_domains/}
-
-          # remove the addons that need to be removed
-          existing_addons.each do |existing_addon|
-            # check to see if we need to delete this addon
-            unless addons.include?(existing_addon)
-              # delete this addon if they arent on the approved list
-              system_with_echo "heroku addons:remove #{existing_addon} --app #{app_name}"
-            end
-          end
-
-          # add the addons that dont exist already
-          addons.each do |addon|
-            # check to see if we need to add this addon
-            unless existing_addons.include?(addon)
-              # add this addon if they are not already added
-              system_with_echo "heroku addons:add #{addon} --app #{app_name}"
-            end
-          end
-        end
-      end
-
-      # setup the domains for heroku
-      def setup_domains
-        authorize unless @heroku
-        each_heroku_app do |heroku_env, app_name, repo|
-          # get the domains that we are aiming towards
-          domains = @config.domains(heroku_env)
-
-          # get the domains that are already on the servers
-          existing_domains = (@heroku.list_domains(app_name) || []).map{|a| a[:domain]}
-
-          # remove the domains that need to be removed
-          existing_domains.each do |existing_domain|
-            # check to see if we need to delete this domain
-            unless domains.include?(existing_domain)
-              # delete this domain if they arent on the approved list
-              system_with_echo "heroku domains:remove #{existing_domain} --app #{app_name}"
-            end
-          end
-
-          # add the domains that dont exist already
-          domains.each do |domain|
-            # check to see if we need to add this domain
-            unless existing_domains.include?(domain)
-              # add this domain if they are not already added
-              system_with_echo "heroku domains:add #{domain} --app #{app_name}"
-            end
-          end
-        end
-      end
-
-      # cycles through each configured heroku app
-      # yields the environment name, the app name, and the repo url
-      def each_heroku_app
-
-        if @config.apps.size == 0
-          puts "\nNo heroku apps are configured. Run:
-            rails generate heroku:config\n\n"
-          puts "this will generate a default config/heroku.yml that you should edit"
-          puts "and then try running this command again"
-
-          exit(1)
-        end
-
-        if @environments.blank? && @config.apps.size == 1
-          @environments = [@config.app_environments.first]
-        end
-
-        if @environments.present?
-          @environments.each do |heroku_env|
-            app_name = @config.apps[heroku_env]
-            yield(heroku_env, app_name, "git@heroku.com:#{app_name}.git")
-          end
-        else
-          puts "\nYou must first specify at least one Heroku app:
-            rake <app> [<app>] <command>
-            rake production restart
-            rake demo staging deploy"
-
-          puts "\n\nYou can use also command all Heroku apps for this project:
-            rake all heroku:setup\n"
-
-          exit(1)
-        end
-      end
-
-      def system_with_echo(*args)
-        puts args.join(' ')
-        command(*args)
-      end
-
-      def command(*args)
-        system(*args)
-      end
-
-    end
-  end
-end