fanforce-app-factory 2.0.0.rc36 → 2.0.0.rc37

data/lib/fanforce/app_factory/cli/lib/env.rb

@@ -36,7 +36,7 @@ class Fanforce::AppFactory::CLI::Env
       File.open("#{app.dir}/.appenv", 'w') {|f| f.write convert_hash_to_shell_env(vars) }
     else
       error 'could not find heroku in .fanforce-app-factory' if config[:heroku][environment].blank?
-      Fanforce::AppFactory::CLI::Heroku.new(app).update_config(environment, vars)
+      Fanforce::AppFactory::CLI::Heroku.new(app, environment).update_config(vars)
     end
   end
 

data/lib/fanforce/app_factory/cli/lib/heroku.rb

@@ -1,94 +1,112 @@
 class Fanforce::AppFactory::CLI::Heroku
   include Fanforce::AppFactory::CLI::Utils
 
-  attr_reader :app
+  attr_reader :app, :environment
 
   require_gem 'heroku-api', 'heroku-api'
 
-  def initialize(app)
+  def initialize(app, environment)
     @app = app
+    @environment = environment.to_sym
   end
 
-  def heroku(environment)
-    @heroku ||= {}
-    @heroku[environment] ||= Heroku::API.new(:username => config[:heroku][environment][:user], :password => config[:heroku][environment][:password])
+  def heroku
+    @heroku ||= Heroku::API.new(:username => config[:heroku][environment][:user], :password => config[:heroku][environment][:password])
   rescue Exception => e
     error "OOPS...  #{environment.to_s.upcase}".format(:red,:bold) + ' has not been setup for Heroku' if config[:heroku].blank? or config[:heroku][environment].blank?
     #raise "Heroku user #{config[:heroku][environment][:user]} does not seem to exist: #{e.message}" if e.response.status == 404
     raise
   end
 
-  def setup(environment)
-    environment = environment.to_sym
-    heroku = heroku(environment)
-    heroku_app_name = app_name(environment)
+  def ensure_git_remote_exists
+    remote_name = "#{env}-heroku"
+    remote_url = "git@#{config[:heroku][environment][:git_ssh_domain] || 'heroku.com'}:#{app_name}.git"
 
-    # Setup standard app domain
-    domain = "#{app._id}.#{Fanforce::Base::DomainEnvironments.method(environment).call[:apps_base]}"
-    domain_found = heroku.get_domains(heroku_app_name).body.inject(false) {|result, d| d['domain'] == domain ? (break true) : false }
-    if domain_found
-      puts "#{'Found   '.format(:green,:bold)}" + "#{domain} domain on #{environment}"
-    else
-      heroku.post_domain(heroku_app_name, domain)
-      puts "#{'Added   '.format(:green,:bold)}" + "#{domain} domain to #{environment}"
-    end
-
-    # Setup default short domain
-    domain = "#{app._id}.#{Fanforce::Base::DomainEnvironments.method(environment).call[:default_short_domain]}"
-    domain_found = heroku.get_domains(heroku_app_name).body.inject(false) {|result, d| d['domain'] == domain ? (break true) : false }
-    if domain_found
-      puts "#{'Found   '.format(:green,:bold)}" + "#{domain} domain on #{environment}"
-    else
-      heroku.post_domain(heroku_app_name, domain)
-      puts "#{'Added   '.format(:green,:bold)}" + "#{domain} domain to #{environment}"
+    found_remote = false
+    found_valid_remote = false
+    (`git remote -v`).lines do |line|
+      next if line !~ Regexp.new("^#{remote_name}[\s\t]")
+      found_remote = true
+      found_valid_remote = true if line.include?(remote_url)
+      break
     end
 
-    # Setup git remote
-    remote_name = "#{env(environment)}-heroku"
-    if (`git remote`).split(/\r?\n/).include?(remote_name)
-      puts "#{'Updated '.format(:green,:bold)}" + "git remote for #{remote_name}"
+    if found_valid_remote
+      return log "#{'Found '.format(:green,:bold)}" + "git remote for #{remote_name}"
+    elsif found_remote
+      log "#{'Updated '.format(:green,:bold)}" + "git remote for #{remote_name}"
       `git remote rm #{remote_name}`
     else
-      puts "#{'Created '.format(:green,:bold)}" + "git remote for #{remote_name}"
+      log "#{'Created '.format(:green,:bold)}" + "git remote for #{remote_name}"
     end
-    `git remote add #{remote_name} git@#{config[:heroku][environment][:git_ssh_domain] || 'heroku.com'}:#{heroku_app_name}.git`
+    `git remote add #{remote_name} #{remote_url}`
+  end
+
+  def git_remote_name
+    "#{env}-heroku"
+  end
+
+  def restart
+    heroku.post_ps_restart(app_name)
   end
 
-  def app_exists?(heroku, app_name)
+  def destroy
+    heroku.delete_app(app_name)
+  end
+
+  def app_exists?
     heroku.get_app(app_name)
     return true
   rescue
     return false
   end
 
-  def ensure_app_exists(environment)
-    heroku = heroku(environment)
-    heroku_app_name = app_name(environment)
-    if app_exists?(heroku, heroku_app_name)
-      puts "#{'Found   '.format(:green,:bold)}" + "#{environment} app on heroku (#{heroku_app_name})"
+  def ensure_app_exists
+    return puts "#{'Found '.format(:green,:bold)}" + "#{environment} app on heroku (#{app_name})" if app_exists?
+    create_app
+  end
+
+  def create_app
+    heroku.post_app(name: app_name)
+    puts "#{'Created '.format(:green,:bold)}" + "#{environment} on heroku (#{app_name})"
+
+    # Setup standard app domain
+    domain = "#{app._id}.#{Fanforce::Base::DomainEnvironments.method(environment).call[:apps_base]}"
+    domain_found = heroku.get_domains(app_name).body.inject(false) {|result, d| d['domain'] == domain ? (break true) : false }
+    if domain_found
+      puts "#{'Found '.format(:green,:bold)}" + "#{domain} domain on #{environment}"
+    else
+      heroku.post_domain(app_name, domain)
+      puts "#{'Added '.format(:green,:bold)}" + "#{domain} domain to #{environment}"
+    end
+
+    # Setup default short domain
+    domain = "#{app._id}.#{Fanforce::Base::DomainEnvironments.method(environment).call[:default_short_domain]}"
+    domain_found = heroku.get_domains(app_name).body.inject(false) {|result, d| d['domain'] == domain ? (break true) : false }
+    if domain_found
+      puts "#{'Found '.format(:green,:bold)}" + "#{domain} domain on #{environment}"
     else
-      heroku.post_app(name: heroku_app_name)
-      puts "#{'Created '.format(:green,:bold)}" + "#{environment} on heroku (#{heroku_app_name})"
+      heroku.post_domain(app_name, domain)
+      puts "#{'Added '.format(:green,:bold)}" + "#{domain} domain to #{environment}"
     end
   end
 
-  def update_config(environment, vars)
-    heroku(environment).put_config_vars(app_name(environment), vars) if vars
+  def update_config(vars)
+    heroku.put_config_vars(app_name, vars) if vars
   end
 
-  def env(environment)
+  def env
     case environment
       when :staging then env = :stg
       when :production then env = :prd
     end
   end
 
-  def app_name(environment)
-    environment = environment.to_sym
+  def app_name
     raise 'unknown environment' if ![:production, :staging].include?(environment)
 
-    heroku_app_name = "#{env(environment)}-#{app.dir_name}"
-    heroku_app_name.length > 30 ? heroku_app_name.gsub!(/(a|e|i|o|u)/, '') : heroku_app_name
+    app_name = app._id.length > 22 ? app._id.gsub(/(a|e|i|o|u)/, '') : app._id
+    "#{env}-app-#{app_name}"
   end
 
 end

data/lib/fanforce/app_factory/cli/scripts/destroy.rb

@@ -18,19 +18,17 @@ class Fanforce::AppFactory::CLI::Scripts
     log divider '+-----'
     confirm("You are about to delete both local and remote files for #{app_id}.\nARE YOU SURE?", true)
 
-    # puts "\n---------------------------------------------------------------------------------------------------------------"
-    # puts 'DELETING HEROKU APPS...'
-    # [:staging,:production].each do |environment|
-    #   next if $Config[:heroku].blank? or $Config[:heroku][environment].blank?
-    #   heroku = auth_heroku(environment)
-    #   heroku_app_name = get_heroku_app_name(app, environment)
-    #   begin
-    #     heroku.delete_app(heroku_app_name)
-    #     puts "#{'Removed  '.format(:green,:bold)}" + " #{heroku_app_name}"
-    #   rescue Exception => e
-    #     puts "#{'Already Removed'.format(:green,:bold)}" + " #{heroku_app_name}"
-    #   end
-    # end
+    log divider '+-----------------------------------------------------------------------------------------------------'
+    log 'DELETING HEROKU APPS...'
+    [:staging,:production].each do |environment|
+      heroku = Fanforce::AppFactory::CLI::Heroku.new(app, environment)
+      if heroku.app_exists?
+        heroku.destroy
+        log "#{'Removed  '.format(:green,:bold)}" + " #{heroku.app_name}"
+      else
+        log "#{'Already Removed'.format(:green,:bold)}" + " #{heroku.app_name}"
+      end
+    end
 
     log divider '+-----------------------------------------------------------------------------------------------------'
     log 'REMOVING BITBUCKET REPOSITORY...'

data/lib/fanforce/app_factory/cli/scripts/push.rb

@@ -35,8 +35,8 @@ class Fanforce::AppFactory::CLI::Scripts
     end
 
     if [:all,:heroku].include?(command) and environment != :development
-      heroku = Fanforce::AppFactory::CLI::Heroku.new(app)
-      heroku.ensure_app_exists(environment)
+      heroku = Fanforce::AppFactory::CLI::Heroku.new(app, environment)
+      heroku.ensure_app_exists
     end
 
     if [:all,:iron].include?(command)
@@ -69,20 +69,14 @@ class Fanforce::AppFactory::CLI::Scripts
   end
 
   def push_heroku(heroku, app, environment)
-    case environment
-      when :staging then env = :stg
-      when :production then env = :prd
-    end
-    remote_name = "#{env}-heroku"
-
-    heroku.setup(environment) if !(`git remote`).split(/\r?\n/).include?(remote_name)
+    heroku.ensure_git_remote_exists
 
     vars = Fanforce::AppFactory::CLI::Env.new(app).vars(environment)
-    heroku.update_config(environment, vars)
+    heroku.update_config(vars)
     log 'Updated ENV'.format(:green,:bold) + " on Heroku #{environment.to_s.titleize} (#{vars.size} variables)..."
 
-    puts "\n#{'Pushing '.format(:green,:bold)}" + "latest commit to Heroku #{environment.to_s.titleize} (#{remote_name})..."
-    console_command("git push #{remote_name} master", true)
+    puts "\n#{'Pushing '.format(:green,:bold)}" + "latest commit to Heroku #{environment.to_s.titleize} (#{heroku.git_remote_name})..."
+    console_command("git push #{heroku.git_remote_name} master", true)
   end
 
 end

data/lib/fanforce/app_factory/cli/scripts/restart.rb

@@ -25,13 +25,7 @@ class Fanforce::AppFactory::CLI::Scripts
           FileUtils.mkdir("#{app.dir}/tmp") if !File.directory?("#{app.dir}/tmp")
           FileUtils.touch("#{app.dir}/tmp/restart.txt")
         elsif [:production, :staging].include?(environment)
-          error 'Production and Staging are not working'
-          if config[:heroku].blank? or config[:heroku][environment].blank?
-            puts "#{'OOPS...'.format(:red,:bold)} #{environment} has not been setup on heroku"
-            next
-          end
-          heroku = auth_heroku(environment)
-          heroku.post_ps_restart get_heroku_app_name(app, environment)
+          Fanforce::AppFactory::CLI::Heroku.new(app, environment).restart
         end
         log "#{"Restarted #{environment}".format(:bold,:green)} #{app.dir_name}"
       end

data/lib/fanforce/app_factory/version.rb

@@ -1,5 +1,5 @@
 class Fanforce
   class AppFactory
-    VERSION = '2.0.0.rc36'
+    VERSION = '2.0.0.rc37'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fanforce-app-factory
 version: !ruby/object:Gem::Version
-  version: 2.0.0.rc36
+  version: 2.0.0.rc37
   prerelease: 6
 platform: ruby
 authors: