hanzo 0.5 → 0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 803ef303a0cfc9a80e8b5054eebeb94296170084
-  data.tar.gz: c4f0ae51305685c86224f45ab3b6668941e81a39
+  metadata.gz: 5f2163d68dba551ae26f662a1e0feef58ce68189
+  data.tar.gz: 28cd31d65ed3326257f96a45a757a0434d7ddacd
 SHA512:
-  metadata.gz: 07529e76fcd35dd0e11902cbe46cd93f3c5831fe46d949fc48f615afbc3abd1080f2796b8efe0de4df3ca53bd7ba580dae639cb920c4265f393b65c8d82cb8f2
-  data.tar.gz: 022c69701c64406218bc681857a2e24d75773cd717e608c6edc658b24410980be6b84a591892bde19b895ac8fd07fd66297cf2ca377fc2e7c97171cd16f74c10
+  metadata.gz: 69325cbe09fc4fac847142901acb2c5e144a65dc15546c50095600b78d94c094c0525c5322338784faca7be2a590384c7d526dd10ae664f6a848a9b1d5b08302
+  data.tar.gz: 382cee77dcbd708ccbe8334c7211d5256b132bf06469bc8d32160247e23e84d0890f0538ac79121f90870bfd1d236aea233d87de6ffd1b8e875be8713d1b20ba

data/README.md

@@ -25,11 +25,17 @@ gem 'hanzo'
 Create an `.hanzo.yml` file at the root of your app that will contain a map of
 remotes, with the remote as the key and the Heroku application name as the value.
 
+You can also specify commands that can be ran on the application after a
+successful deploy. Hanzo will prompt to run each of them, they each will be ran
+with `heroku run` and the application will be restarted at the end.
+
 ```yaml
 remotes:
   qa: heroku-app-name-qa
   staging: heroku-app-name-staging
   production: heroku-app-name-production
+after_deploy:
+  - rake db:migrate
 ```
 
 ### Install remotes

data/lib/hanzo/modules/deploy.rb

@@ -4,12 +4,6 @@ module Hanzo
     UnknownEnvironment = Class.new(StandardError)
     UninstalledEnvironment = Class.new(StandardError)
 
-    # Constants
-    MIGRATION_COMMANDS = {
-      'db/migrate' => 'rake db:migrate',
-      'priv/repo/migrations' => 'mix ecto.migrate'
-    }
-
   protected
 
     def initialize_variables
@@ -20,7 +14,7 @@ module Hanzo
     def initialize_cli
       initialize_help && return if @env.nil?
 
-      deploy && run_migrations
+      deploy && run_after_deploy_commands
     rescue UnknownEnvironment
       Hanzo.unindent_print "Environment `#{@env}` doesn't exist. Add it to .hanzo.yml and run:\n  hanzo install remotes", :red
       Hanzo.unindent_print "\nFor more information, read https://github.com/mirego/hanzo#install-remotes", :red
@@ -48,14 +42,21 @@ module Hanzo
       Hanzo.run "git push -f #{@env} #{branch}:master"
     end
 
-    def run_migrations
-      return if migration_directory.nil?
-      return unless Hanzo.agree('Run database migrations?')
+    def run_after_deploy_commands
+      return unless after_deploy_commands.any?
+
+      after_deploy_commands.each do |command|
+        next unless Hanzo.agree("Run `#{command}` on #{@env}?")
+        Hanzo.run "heroku run #{command} --remote #{@env}"
+      end
 
-      Hanzo.run "heroku run #{migration_command} --remote #{@env}"
       Hanzo.run "heroku ps:restart --remote #{@env}"
     end
 
+    def after_deploy_commands
+      Hanzo.config['after_deploy'] || []
+    end
+
     def validate_environment_existence!
       raise UnknownEnvironment unless fetcher.exist?
       raise UninstalledEnvironment unless fetcher.installed?
@@ -64,13 +65,5 @@ module Hanzo
     def fetcher
       @fetcher ||= Hanzo::Fetchers::Environment.new(@env)
     end
-
-    def migration_directory
-      MIGRATION_COMMANDS.keys.find { |directory| Dir.exist?(directory) }
-    end
-
-    def migration_command
-      MIGRATION_COMMANDS[migration_directory]
-    end
   end
 end

data/lib/hanzo/version.rb

@@ -1,3 +1,3 @@
 module Hanzo
-  VERSION = '0.5'.freeze
+  VERSION = '0.6'.freeze
 end

data/spec/cli/deploy_spec.rb

@@ -2,32 +2,23 @@ require 'spec_helper'
 
 describe Hanzo::CLI do
   describe :deploy do
-    let(:env) { 'production' }
-    let(:branch) { '1.0.0' }
-    let(:deploy!) { Hanzo::CLI.new(['deploy', env]) }
-    let(:heroku_remotes) { { 'production' => 'heroku-app-production' } }
-    let(:migration_dir) { 'db/migrate' }
-
-    let(:migration_question) { 'Run database migrations?' }
-    let(:deploy_question) { "Branch to deploy in #{env}:" }
-
-    let(:migration_cmd) { "heroku run rake db:migrate --remote #{env}" }
-    let(:restart_cmd) { "heroku ps:restart --remote #{env}" }
-    let(:deploy_cmd) { "git push -f #{env} #{branch}:master" }
+    let(:deploy!) { Hanzo::CLI.new(['deploy', 'production']) }
+    let(:deploy_question) { 'Branch to deploy in production:' }
+    let(:deploy_command) { "git push -f production 1.0.0:master" }
 
     before do
       expect(Hanzo::Installers::Remotes).to receive(:environments).and_return(['production'])
       expect(Hanzo::Installers::Remotes).to receive(:installed_environments).and_return(['production'])
     end
 
-    context 'successful deploy and without migrations' do
-      let(:migrations_exist) { false }
+    context 'successful deploy and without after_deploy commands' do
       let(:deploy_result) { true }
+      let(:config) { {} }
 
       before do
-        expect(Dir).to receive(:exist?).with(instance_of(String)).at_least(:once).and_return(migrations_exist)
-        expect(Hanzo).to receive(:ask).with(deploy_question).and_return(branch)
-        expect(Hanzo).to receive(:run).with(deploy_cmd).once.and_return(deploy_result)
+        allow(Hanzo).to receive(:config).and_return(config)
+        expect(Hanzo).to receive(:ask).with(deploy_question).and_return('1.0.0')
+        expect(Hanzo).to receive(:run).with(deploy_command).once.and_return(deploy_result)
       end
 
       it 'should git push to heroku upstream' do
@@ -35,49 +26,37 @@ describe Hanzo::CLI do
       end
     end
 
-    context 'with existing migrations' do
-      let(:migrations_exist) { true }
+    context 'with existing after_deploy commands' do
+      let(:config) { { 'after_deploy' => %w(foo bar) } }
 
       before do
-        expect(Hanzo).to receive(:ask).with(deploy_question).and_return(branch)
-        expect(Hanzo).to receive(:run).with(deploy_cmd).once.and_return(deploy_result)
+        allow(Hanzo).to receive(:config).and_return(config)
+        expect(Hanzo).to receive(:ask).with(deploy_question).and_return('1.0.0')
+        expect(Hanzo).to receive(:run).with(deploy_command).once.and_return(deploy_result)
       end
 
       context 'with successful deploy' do
         let(:deploy_result) { true }
 
         before do
-          expect(Dir).to receive(:exist?).with(instance_of(String)).at_least(:once).and_return(migrations_exist)
-        end
-
-        context 'and migrations that should be ran' do
-          before do
-            expect(Hanzo).to receive(:agree).with(migration_question).and_return(true)
-            expect(Hanzo).to receive(:run).with(migration_cmd)
-            expect(Hanzo).to receive(:run).with(restart_cmd)
-          end
-
-          specify { deploy! }
+          expect(Hanzo).to receive(:agree).with('Run `foo` on production?').and_return(true)
+          expect(Hanzo).to receive(:run).with('heroku run foo --remote production')
+          expect(Hanzo).to receive(:agree).with('Run `bar` on production?').and_return(true)
+          expect(Hanzo).to receive(:run).with('heroku run bar --remote production')
+          expect(Hanzo).to receive(:run).with('heroku ps:restart --remote production')
         end
 
-        context 'and migrations that should not be ran' do
-          before do
-            expect(Hanzo).to receive(:agree).with(migration_question).and_return(false)
-            expect(Hanzo).not_to receive(:run).with(migration_cmd)
-            expect(Hanzo).not_to receive(:run).with(restart_cmd)
-          end
-
-          specify { deploy! }
-        end
+        specify { deploy! }
       end
 
       context 'without successful deploy' do
         let(:deploy_result) { false }
 
         before do
-          expect(Hanzo).not_to receive(:agree).with(migration_question)
-          expect(Hanzo).not_to receive(:run).with(migration_cmd)
-          expect(Hanzo).not_to receive(:run).with(restart_cmd)
+          expect(Hanzo).not_to receive(:agree)
+          expect(Hanzo).not_to receive(:run).with('heroku run foo --remote production')
+          expect(Hanzo).not_to receive(:run).with('heroku run bar --remote production')
+          expect(Hanzo).not_to receive(:run).with('heroku ps:restart --remote production')
         end
 
         specify { deploy! }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hanzo
 version: !ruby/object:Gem::Version
-  version: '0.5'
+  version: '0.6'
 platform: ruby
 authors:
 - Samuel Garneau
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-11 00:00:00.000000000 Z
+date: 2017-02-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -150,7 +150,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Hanzo is a tool to handle deployments in multiple environments on Heroku.