heroku_rails 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 877dd9dceebb80e6c15c8e5fd3f631569152f8eea1b7951c3cce6863224f73fc
+  data.tar.gz: 89b27c00e706dd8ed87c31cae2c75f20f7d8dab9182388445e8961a1f00ddb7c
+SHA512:
+  metadata.gz: d85490b81a5b2177b64bc8280c5a2df3527b5f80316cc68797c09614d92701ad90bb4971b18e6fb85c8919e15c17f9bd0c36d9e9bd4fb9befaa1087fee38e852
+  data.tar.gz: e0d8a4042afa600672f227cef5bbc94254ace3f678c4500fcbe7dd25cd055d70c96b53c94ea7779b8b4c26021ec3ebd481e95b59c77e6dce379916a4a9419dc8

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/Gemfile.lock
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.5.7
+before_install: gem install bundler -v 1.17.3

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,42 @@
+# Code of Conduct
+
+## 1. Purpose
+
+One of the primary goals of Siapbantu is to be inclusive to all contributors, with the most varied and diverse backgrounds possible. Everyone is welcome to contribute! Therefore, we are committed to providing a friendly and safe environment for everyone.
+
+This code of conduct outlines our overall expectations for anyone who participates in our community, as well as the consequences for unacceptable behavior.
+
+We invite all those who participate in Siapbantu to help us foster a safe and positive experience for everyone.
+
+## 2. Expected Behavior
+
+- Embody our Culture & Values.
+- Be friendly, kind and empathic towards each other.
+- Use welcoming and inclusive language.
+- Be respectful of differing viewpoints and experiences.
+- Gracefully accept constructive criticism.
+- Focus on what is best for the community.
+- Participate in an authentic and active way. By doing so, you contribute to the success, health and future of this initiative.
+- Please alert community leaders if you notice violations of this Code of Conduct, even if they seem minor.
+
+## 3. Unacceptable Behavior
+
+- Sexist, racist, homophobic, transphobic, ableist or otherwise discriminatory jokes or insults.
+- Trolling, insulting/derogatory comments, and personal or political attacks.
+- Inciting or threatening violence, including encouraging others to hurt themselves
+- The use of sexualized language or imagery and unwelcome sexual attention or advances.
+- False accusations or accusations without evidence.
+- Spam (unsolicited or frequently off-topic messages)
+- Advocating for, or encouraging, any of the above behavior.
+
+## 4. Consequences of Unacceptable Behavior
+
+Unacceptable behavior from any volunteer or community member will not be tolerated. If you are subject to or witness unacceptable behavior, or have any other concerns, please notify your team leads and @shitiomatic via slack or email (human@shitiomatic.tech). We have the the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
+
+## 5. Addressing Grievances
+
+If you feel you have been falsely or unfairly accused of violating this Code of Conduct, you should notify @shitiomatic via slack or (human@shitiomatic.tech) and/or the Siapbantu team leads with a concise description of your grievance.
+
+## 6. Scope
+
+We expect all volunteers and community participants to abide by this Code of Conduct in all community channels, calls, events and in-person–as well as in all one-on-one communications pertaining to Siapbantu..

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in heroku_rails.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Siapbantu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,109 @@
+# Heroku ❤️ Rails
+
+Useless tool for easy deploy Ruby on Rails to Heroku
+
+If you're using continuous deployment with pipelines in Heroku, you won't need this. However if that style doesn't work, then this may allow you to manage databases and deployment with more control but less hassle.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'heroku_rails'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install heroku_rails
+
+## Configuration
+
+> TODO: Some of these manual configuration steps, would be nicer to make a bit more automatic perhaps by making this a Rails engine.
+1) Your database configuration (config/database.yml) needs to have a username if you want to use the db configurations
+
+2) Append `load "heroku_rails/tasks/db_drop_all_tables.rake"` to the end of Rakefile. 
+
+3) Copy templates into codebase:
+
+       cp $(bundle show heroku_rails)/templates/heroku.thor ./lib/tasks
+       cp $(bundle show heroku_rails)/templates/heroku_targets.yml ./config
+
+4) update heroku_targets.yml with your staging and production targets. 
+  My set up for this is to have staging deploy the local version, but production 
+  deploy the origin/master.
+
+      > TODO: more detail
+
+5) You may want to set up a smoke test that your heroku targets are valid
+
+       require "heroku_rails/heroku_targets"
+
+       RSpec.describe "heroku_targets.yml" do
+         it "is valid (smoke test)" do 
+           HerokuRails::HerokuTargets.from_file(Rails.root.join("config/heroku_targets.yml"))
+         end
+       end 
+
+## Usage
+
+### Deploy 
+
+Deploy the latest with db migrate during maintenance
+
+    thor heroku:deploy staging
+
+or without maintenance
+
+    thor heroku:deploy staging --no-maintenance
+
+or without migrating
+
+    thor heroku:deploy staging --no-migrate
+
+or a specific tag/branch
+
+    thor heroku:deploy staging hotfix-branch
+
+
+### Sync
+
+Sync a database down from remote to local 
+
+    thor heroku:sync:grab -f staging
+    # when it finishes
+    rake db:drop_all_tables && thor heroku:sync:from_dump -f staging
+
+_FYI rake db:drop_all_tables is handy as it doesn't require you to disconnect any running processes from the database._
+
+Copy production db to staging
+
+    thor heroku:sync:to staging -f production
+
+NB: this won't work from a staging to a production environment (failsafe)
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+Ensure standards before PR:
+
+    bundle exec standardrb --fix
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/siapbantu/heroku_rails. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the HerokuRails project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/siapbantu/heroku_rails/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "heroku_rails"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/heroku_rails.gemspec

@@ -0,0 +1,31 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "heroku_rails/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "heroku_rails"
+  spec.version = HerokuRails::VERSION
+  spec.authors = ["Ahmad Ainul Rizki"]
+  spec.email = ["human@shitiomatic.email"]
+
+  spec.summary = "Useless tool for easy deploy Ruby on Rails to Heroku"
+  spec.homepage = "https://github.com/siapbantu/heroku_rails"
+  spec.license = "MIT"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path("..", __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "thor", "~> 0.18"
+  spec.add_dependency "activesupport"
+
+  spec.add_development_dependency "bundler", "~> 1.17"
+  spec.add_development_dependency "rake", ">= 12.3.3"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "standard", "~> 0.4.1"
+end

data/lib/heroku_rails.rb

@@ -0,0 +1,7 @@
+require "heroku_rails/db_configuration"
+require "heroku_rails/heroku_targets"
+require "heroku_rails/version"
+
+module HerokuRails
+  class Error < StandardError; end
+end

data/lib/heroku_rails/db_configuration.rb

@@ -0,0 +1,34 @@
+# NB need to specify a username in the database.yml if you want to use any of these commands
+module HerokuRails
+  class DbConfiguration
+    def config
+      @config ||= YAML.load(
+        ERB.new(File.read("config/database.yml")).result
+      )
+    end
+
+    def generate_drop_tables_sql
+      sql = %(select 'DROP TABLE IF EXISTS \\"' || tablename || '\\" CASCADE;' from pg_tables where schemaname = 'public')
+      %(psql #{user_arg} #{database} -t -c "#{sql}")
+    end
+
+    def user_arg
+      username = db_config["username"]
+      username.present? && "-U #{username}" || ""
+    end
+
+    def database
+      db_config["database"]
+    end
+
+    private
+
+    def db_config
+      config[env]
+    end
+
+    def env
+      ENV["RAILS_ENV"] || "development"
+    end
+  end
+end

data/lib/heroku_rails/heroku_targets.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require "active_support/all"
+require "yaml"
+
+module HerokuRails
+  class HerokuTargets
+    class << self
+      def from_string(heroku_targets_yml)
+        new(YAML.safe_load(heroku_targets_yml))
+      end
+
+      def from_file(yaml_file)
+        new(YAML.safe_load(File.read(yaml_file)))
+      end
+    end
+
+    attr_reader :targets, :staging_targets
+
+    DEFAULTS_KEY = "_defaults"
+
+    def initialize(targets_hash)
+      defaults = if targets_hash.keys.first == DEFAULTS_KEY
+        targets_hash.delete(DEFAULTS_KEY)
+      else
+        {}
+      end
+      specified = targets_hash.collect { |name, values|
+        heroku_target = HerokuTarget.new(defaults.merge(values), name)
+        [heroku_target.heroku_app, heroku_target]
+      }
+      built_in = [["local", LocalProxy.new(defaults)]]
+      @targets = TargetsContainer[(specified + built_in)].freeze
+      @staging_targets = TargetsContainer[@targets.select { |_name, target| target.staging? }]
+    end
+
+    class TargetsContainer < HashWithIndifferentAccess
+      def [](key)
+        return super if key?(key)
+        values.each do |value|
+          return value if value.name.to_s == key.to_s
+        end
+        nil
+      end
+    end
+
+    class HerokuTarget
+      attr_reader :name
+
+      def initialize(values_hash, name = nil)
+        @values = values_hash.symbolize_keys.freeze
+        @name = name.to_sym if name
+        %i[heroku_app git_remote deploy_ref].each do |required_name|
+          raise required_value(required_name) unless @values[required_name] || local?
+        end
+      end
+
+      def required_value(required_name)
+        ArgumentError.new("please specify '#{required_name}:' ")
+      end
+
+      def staging?
+        @values[:staging]
+      end
+
+      def local?
+        false
+      end
+
+      def display_name
+        @values[:display_name] || @values[:heroku_app]
+      end
+
+      def heroku_app
+        @values[:heroku_app]
+      end
+
+      def database_url
+        @values[:database_url]
+      end
+
+      def git_remote
+        @values[:git_remote]
+      end
+
+      def deploy_ref
+        @values[:deploy_ref]
+      end
+
+      def db_color
+        @values[:db_color] || "DATABASE"
+      end
+
+      def repository
+        @values[:repository] || raise(required_value(:repository))
+      end
+
+      def to_s
+        display_name
+      end
+
+      def dump_filename
+        File.expand_path("tmp/latest_#{heroku_app}_backup.dump")
+      end
+
+      def trackable_release_stage
+        @values[:trackable_release_stage].presence || (staging? ? "staging" : "production")
+      end
+    end
+
+    class LocalProxy < HerokuTarget
+      def initialize(defaults)
+        super(defaults.merge(staging: true, heroku_app: "local"), "local")
+      end
+
+      def local?
+        true
+      end
+    end
+  end
+end

data/lib/heroku_rails/tasks/db_drop_all_tables.rake

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+namespace :db do
+  desc "drop all tables without worrying about concurrent accesses"
+  task drop_all_tables: :environment do
+    require File.expand_path("../../heroku_rails/db_configuration.rb", __FILE__)
+    abort("Don't run this on production") if Rails.env.production?
+
+    db_config = HerokuRails::DbConfiguration.new
+    generate_drop_tables_sql = db_config.generate_drop_tables_sql
+    cmd_string = %(#{generate_drop_tables_sql} | psql #{db_config.user_arg} #{db_config.database})
+    puts cmd_string
+    system(cmd_string)
+  end
+end

data/lib/heroku_rails/tasks/heroku.thor

@@ -0,0 +1,435 @@
+# frozen_string_literal: true
+
+require "thor"
+require_relative "../db_configuration"
+require_relative "../heroku_targets"
+require_relative "../thor_utils"
+
+class Heroku < Thor
+  module Configuration
+    class << self
+      def base_asset_url
+        asset_host = get_config_env(target, "ASSET_HOST")
+        "https://#{asset_host}"
+      end
+
+      def maintenance_mode_env_var
+        "X_HEROKU_RAILS_MAINTENANCE_MODE"
+      end
+
+      def app_revision_env_var
+        raise "choose between APP_REVISION and COMMIT_HASH"
+      end
+
+      def before_deploying(_instance, target, version, description: nil)
+        puts "about to deploy #{version} to #{target.name}"
+        puts "         #{description}" if description
+      end
+
+      def after_deploying(_instance, target, version, description: nil)
+        puts "deployed #{version} to #{target.name}"
+        puts "         #{description}" if description
+      end
+
+      def notify_of_deploy_tracking(running_thor_task, release_stage:, revision:, revision_describe:, repository:, target:, target_name:, deploy_ref:)
+        if ENV["BUGSNAG_API_KEY"].present?
+          running_thor_task.notify_bugsnag_of_deploy_tracking(deploy_ref, release_stage, repository, revision, revision_describe, target_name)
+        else
+          puts "can't notify of deploy tracking: env var not present: BUGSNAG_API_KEY"
+        end
+      end
+
+      def after_sync_down(instance)
+        instance.puts_and_system "rake db:migrate"
+        instance.puts_and_system "rake db:test:prepare"
+      end
+
+      def after_sync_to(instance, target)
+        instance.puts_and_system %(heroku run rake db:migrate -a #{target.heroku_app})
+      end
+    end
+  end
+
+  module Shared
+    def self.exit_on_failure?
+      true
+    end
+
+    def lookup_heroku_staging(staging_target_name)
+      heroku_targets.staging_targets[staging_target_name] || raise_missing_target(staging_target_name, true)
+    end
+
+    def lookup_heroku(target_name)
+      heroku_targets.targets[target_name] || raise_missing_target(target_name, false)
+    end
+
+    def check_deploy_ref(deploy_ref, target)
+      if deploy_ref && deploy_ref[0] == "-"
+        raise Thor::Error, "Invalid deploy ref '#{deploy_ref}'"
+      end
+
+      deploy_ref || target.deploy_ref
+    end
+
+    def raise_missing_target(target_name, staging)
+      if staging
+        description = "Staging target_name '#{target_name}'"
+        targets = heroku_targets.staging_targets.keys
+      else
+        description = "Target '#{target_name}'"
+        targets = heroku_targets.targets.keys
+      end
+      msg = "#{description} was not found. Valid targets are #{targets.collect { |t| "'#{t}'" }.join(",")}"
+      raise Thor::Error, msg
+    end
+
+    def heroku_targets
+      @heroku_targets ||= HerokuRails::HerokuTargets.from_file(File.expand_path("config/heroku_targets.yml"))
+    end
+
+    def puts_and_system(cmd)
+      puts cmd
+      puts "-------------"
+      system_with_clean_env cmd
+      puts "-------------"
+    end
+
+    def puts_and_exec(cmd)
+      puts cmd
+      exec_with_clean_env(cmd)
+    end
+
+    protected
+
+    def deploy_message(target, deploy_ref_describe)
+      downtime = options[:migrate] ? "👷 There will be a very short maintenance downtime" : ""
+      message = <<-DEPLOY_MESSAGE
+     Deploying #{target.display_name} #{deploy_ref_describe}.
+     #{downtime} (in less than a minute from now).
+      DEPLOY_MESSAGE
+      message.gsub(/(\s|\n)+/, " ")
+    end
+
+    def system_with_clean_env(cmd)
+      if defined?(Bundler)
+        Bundler.with_clean_env { system cmd }
+      else
+        system cmd
+      end
+    end
+
+    def exec_with_clean_env(cmd)
+      if defined?(Bundler)
+        Bundler.with_clean_env { `#{cmd}` }
+      else
+        `#{cmd}`
+      end
+    end
+
+    def maintenance_on(target)
+      puts_and_system "heroku maintenance:on -a #{target.heroku_app}"
+      puts_and_system "heroku config:set #{Heroku::Configuration.maintenance_mode_env_var}=true -a #{target.heroku_app}"
+    end
+
+    def maintenance_off(target)
+      puts_and_system "heroku maintenance:off -a #{target.heroku_app}"
+      puts_and_system "heroku config:unset #{Heroku::Configuration.maintenance_mode_env_var} -a #{target.heroku_app}"
+    end
+  end
+
+  include Shared
+
+  class_option :verbose, type: :boolean, aliases: "v", default: true
+  default_command :help
+
+  desc "details", "collects and prints some information local and each target"
+
+  def details
+    puts
+    details = heroku_targets.targets.map { |name, target|
+      next if target.local?
+
+      print "."
+      [
+        "Heroku #{name}",
+        "(versions suppressed -- takes too long)" || exec_with_clean_env("heroku run 'rails -v && ruby -v' -a #{target.heroku_app}"),
+        exec_with_clean_env("heroku releases -n 1 -a #{target.heroku_app}").split("\n").last
+      ]
+    }
+    puts
+    details << [
+      "Local",
+      exec_with_clean_env("rails -v && ruby -v"),
+      exec_with_clean_env("git describe --always")
+    ]
+    details.each do |n, v, d|
+      puts "-" * 80
+      puts n
+      puts "-" * 80
+      puts v
+      puts d
+    end
+  end
+
+  desc "deploy TARGET (REF)", "deploy the latest to TARGET (optionally give a REF like a tag to deploy)"
+  method_option :migrate, default: true, desc: "Run with migrations", type: :boolean
+  method_option :maintenance, default: nil, desc: "Run with migrations", type: :boolean
+
+  def deploy(target_name, deploy_ref = nil)
+    target = lookup_heroku(target_name)
+    deploy_ref = check_deploy_ref(deploy_ref, target)
+    deploy_ref_description = deploy_ref_describe(deploy_ref)
+    maintenance = options[:maintenance].nil? && options[:migrate] || options[:maintenance]
+    puts "Deploy #{deploy_ref_description} to #{target} with migrate=#{options[:migrate]} maintenance=#{maintenance} "
+
+    invoke :list_deployed, [target_name, deploy_ref], {}
+    message = deploy_message(target, deploy_ref_description)
+    Configuration.before_deploying(self, target, deploy_ref_description)
+    set_message(target_name, message)
+    puts_and_system "git push -f #{target.git_remote} #{deploy_ref}^{}:master"
+
+    maintenance_on(target) if maintenance
+    if options[:migrate]
+      puts_and_system "heroku run rake db:migrate -a #{target.heroku_app}"
+    end
+
+    puts_and_system %{heroku config:set #{Heroku::Configuration.app_revision_env_var}=$(git describe --always #{deploy_ref}) -a #{target.heroku_app}}
+    if maintenance
+      maintenance_off(target)
+    else
+      puts_and_system "heroku restart -a #{target.heroku_app}"
+    end
+    set_message(target_name, nil)
+    Configuration.after_deploying(self, target, deploy_ref_description)
+    deploy_tracking(target_name, deploy_ref)
+  end
+
+  desc "maintenance ON|OFF", "turn maintenance mode on or off"
+  method_option :target_name, aliases: "a", desc: "Target (app or remote)"
+
+  def maintenance(on_or_off)
+    target = lookup_heroku(options[:target_name])
+    case on_or_off.upcase
+    when "ON"
+      maintenance_on(target)
+    when "OFF"
+      maintenance_off(target)
+    else
+      raise Thor::Error, "maintenance must be ON or OFF not #{on_or_off}"
+    end
+  end
+
+  desc "set_urls TARGET", "set and cache the error and maintenance page urls for TARGET"
+
+  def set_urls(target_name)
+    target = lookup_heroku(target_name)
+    time = Time.now.strftime("%Y%m%d-%H%M-%S")
+    url_hash = {
+      ERROR_PAGE_URL: "#{Heroku::Configuration.base_asset_url}/platform_error/#{time}",
+      MAINTENANCE_PAGE_URL: "#{Heroku::Configuration.base_asset_url}/platform_maintenance/#{time}"
+    }
+    url_hash.each do |_env, url|
+      puts_and_system "open #{url}"
+    end
+    puts_and_system(
+      "heroku config:set #{url_hash.map { |e, u| "#{e}=#{u}" }.join(" ")} -a #{target.heroku_app}"
+    )
+  end
+
+  no_commands do
+    def get_config_env(target, env_var)
+      puts_and_exec("heroku config:get #{env_var} -a #{target.heroku_app}").strip.presence
+    end
+
+    def deploy_ref_describe(deploy_ref)
+      `git describe #{deploy_ref}`.strip
+    end
+
+    def notify_bugsnag_of_deploy_tracking(deploy_ref, release_stage, repository, revision, revision_describe, target_name)
+      api_key = ENV["BUGSNAG_API_KEY"]
+      data = %W[
+        apiKey=#{api_key}
+        releaseStage=#{release_stage}
+        repository=#{repository}
+        revision=#{revision}
+        appVersion=#{revision_describe}
+      ].join("&")
+      if api_key.blank?
+        puts "\n" + ("*" * 80) + "\n"
+        command = "curl -d #{data} http://notify.bugsnag.com/deploy"
+        puts command
+        puts "\n" + ("*" * 80) + "\n"
+        puts "NB: can't notify unless you specify BUGSNAG_API_KEY and rerun"
+        puts "  thor heroku:deploy_tracking #{target_name} #{deploy_ref}"
+      else
+        puts_and_system "curl -d \"#{data}\" http://notify.bugsnag.com/deploy"
+      end
+    end
+  end
+
+  desc "deploy_tracking TARGET (REF)", "set deploy tracking for TARGET and REF (used by deploy)"
+
+  def deploy_tracking(target_name, deploy_ref = nil)
+    target = lookup_heroku(target_name)
+    deploy_ref = check_deploy_ref(deploy_ref, target)
+    release_stage = target.staging? ? "staging" : "production"
+    revision = `git log -1 #{deploy_ref} --pretty=format:%H`
+    Heroku::Configuration.notify_of_deploy_tracking(
+      self,
+      deploy_ref: deploy_ref,
+      release_stage: target.trackable_release_stage,
+      revision: revision,
+      target: target,
+      target_name: target_name,
+      revision_describe: deploy_ref_describe(deploy_ref),
+      repository: target.repository
+    )
+  end
+
+  include HerokuRails::ThorUtils
+  desc "set_message TARGET (MESSAGE)", "set message (no-op by default)"
+
+  def set_message(target_name, message = nil)
+    # no-op -- define as override
+  end
+
+  desc "list_deployed TARGET (DEPLOY_REF)", "list what would be deployed to TARGET (optionally specify deploy_ref)"
+
+  def list_deployed(target_name, deploy_ref = nil)
+    target = lookup_heroku(target_name)
+    deploy_ref = check_deploy_ref(deploy_ref, target)
+    puts "------------------------------"
+    puts " Deploy to #{target}:"
+    puts "------------------------------"
+    system_with_clean_env "git --no-pager log $(heroku config:get #{Heroku::Configuration.app_revision_env_var} -a #{target.heroku_app})..#{deploy_ref}"
+    puts "------------------------------"
+  end
+
+  desc "about (TARGET)", "Describe available targets or one specific target"
+
+  def about(target_name = nil)
+    if target_name.nil?
+      puts "Targets: "
+      heroku_targets.targets.each_pair do |key, target|
+        puts " * #{key} (#{target})"
+      end
+    else
+      target = lookup_heroku(target_name)
+      puts "Target #{target_name}:"
+      puts " * display_name: #{target.display_name}"
+      puts " * heroku_app:   #{target.heroku_app}"
+      puts " * git_remote:   #{target.git_remote}"
+      puts " * deploy_ref:   #{target.deploy_ref}"
+    end
+    puts
+    puts "(defined in config/heroku_targets.yml)"
+  end
+
+  class Sync < Thor
+    include Shared
+    class_option :from, type: :string, desc: "source target (production, staging...)", required: true, aliases: "f"
+
+    desc "down --from SOURCE_TARGET", "syncs db down from SOURCE_TARGET | thor heroku:sync -f production"
+
+    def down
+      invoke "grab", [], from: options[:from]
+      invoke "from_dump", [], from: options[:from]
+    end
+
+    desc "warn", "warn", hide: true
+
+    def warn
+      puts "should maybe 'rake db:drop_all_tables' first"
+      puts "if you have done some table-creating migrations that need tobe undone???"
+    end
+
+    desc "grab --from SOURCE_TARGET", "capture and download dump from SOURCE_TARGET", hide: true
+
+    def grab
+      source = lookup_heroku(options[:from])
+      capture_cmd = "heroku pg:backups:capture -a #{source.heroku_app}"
+      puts_and_system capture_cmd
+      invoke "download", [], from: options[:from]
+    end
+
+    desc "download --from SOURCE_TARGET", "download latest db snapshot on source_target"
+
+    def download
+      source = lookup_heroku(options[:from])
+      download_cmd = "curl -o #{source.dump_filename} `heroku pg:backups:public-url -a #{source.heroku_app}`"
+      puts_and_system download_cmd
+    end
+
+    desc "from_dump --from SOURCE_TARGET", "make the db the same as the last target dump from SOURCE_TARGET"
+
+    method_option :just_restore, default: false, desc: "Just do restore without post-actions", type: :boolean
+
+    def from_dump
+      invoke "warn", [], from: options[:from]
+      source = lookup_heroku(options[:from])
+      rails_env = ENV["RAILS_ENV"] || "development"
+      db_config = HerokuRails::DbConfiguration.new.config[rails_env]
+      db_username = db_config["username"]
+      db = db_config["database"]
+      db_username_params = db_username.blank? && "" || "-U #{db_username}"
+      puts_and_system "pg_restore --verbose --clean --no-acl --no-owner -h localhost #{db_username_params} -d #{db} #{source.dump_filename}"
+      Configuration.after_sync_down(self) unless options[:just_restore]
+    end
+
+    desc "dump_to_tmp", "dump to tmp directory"
+    method_option(:from, type: :string, default: "local", desc: "heroku target (defaults to local)", required: false, aliases: "f")
+    def dump_to_tmp
+      source = lookup_heroku(options[:from])
+      dump_local(source.dump_filename)
+    end
+
+    desc "to STAGING_TARGET --from=SOURCE_TARGET", "push db onto STAGING_TARGET from SOURCE_TARGET"
+
+    def to(to_target_name)
+      target = lookup_heroku_staging(to_target_name)
+      source = lookup_heroku(options[:from])
+
+      maintenance_on(target)
+
+      puts_and_system %(
+        heroku pg:copy #{source.heroku_app}::#{source.db_color} #{target.db_color} -a #{target.heroku_app} --confirm #{target.heroku_app}
+      )
+      Configuration.after_sync_to(self, target) unless options[:just_copy]
+      puts_and_system %(heroku restart -a #{target.heroku_app})
+      maintenance_off(target)
+    end
+
+    private
+
+    def dump_local(dumpfilepath)
+      puts "dumping postgres to #{dumpfilepath}"
+      rails_env = ENV["RAILS_ENV"] || "development"
+      db_config = HerokuRails::DbConfiguration.new.config[rails_env]
+      db_username = db_config["username"]
+      db = db_config["database"]
+      system_with_clean_env "pg_dump --verbose --clean --no-acl --no-owner -h localhost -U #{db_username} --format=c #{db} > #{dumpfilepath}"
+    end
+  end
+
+  class Db < Thor
+    include Shared
+
+    desc "drop_all_tables on STAGING_TARGET", "drop all tables on STAGING_TARGET"
+
+    def drop_all_tables(staging_target_name)
+      target = lookup_heroku_staging(staging_target_name)
+      generate_drop_tables_sql = `#{HerokuRails::DbConfiguration.new.generate_drop_tables_sql}`
+      cmd_string = %(heroku pg:psql -a #{target.heroku_app} -c "#{generate_drop_tables_sql}")
+      puts_and_system(cmd_string)
+    end
+
+    desc "anonymize STAGING_TARGET", "run anonymization scripts on STAGING_TARGET"
+
+    def anonymize(staging_target_name)
+      target = lookup_heroku_staging(staging_target_name)
+      puts_and_system %(
+        heroku run rake data:anonymize -a #{target.heroku_app}
+      )
+    end
+  end
+end

data/lib/heroku_rails/thor_utils.rb

@@ -0,0 +1,33 @@
+module HerokuRails
+  module ThorUtils
+    protected
+
+    def puts_and_system(cmd)
+      puts cmd
+      puts "-------------"
+      system_with_clean_env cmd
+      puts "-------------"
+    end
+
+    def puts_and_exec(cmd)
+      puts cmd
+      exec_with_clean_env(cmd)
+    end
+
+    def system_with_clean_env(cmd)
+      if defined?(Bundler)
+        Bundler.with_clean_env { system cmd }
+      else
+        system cmd
+      end
+    end
+
+    def exec_with_clean_env(cmd)
+      if defined?(Bundler)
+        Bundler.with_clean_env { `#{cmd}` }
+      else
+        `#{cmd}`
+      end
+    end
+  end
+end

data/lib/heroku_rails/version.rb

@@ -0,0 +1,3 @@
+module HerokuRails
+  VERSION = "0.1.0"
+end

data/templates/Rakefile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require_relative "config/application"
+
+Rails.application.load_tasks
+
+load "vendor/heroku_rails/lib/tasks/db_drop_all_tables.rake"

data/templates/heroku.thor

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "thor"
+spec = Gem::Specification.find_by_name "heroku_rails"
+Thor::Util.load_thorfile(File.expand_path("lib/heroku_rails/tasks/heroku.thor", spec.gem_dir))
+
+class Heroku
+  module MyConfig
+    # def notify_of_deploy_tracking(running_thor_task, release_stage:, revision:, revision_describe:, repository:, target:, target_name:, deploy_ref:)
+    # end
+
+    # def app_revision_env_var
+    #  "APP_REVISION"
+    # end
+    #
+    # def after_sync_down(instance)
+    #  super
+    #  instance.puts_and_system "rake dev:dev_data"
+    # end
+    #
+    # def after_sync_to(instance, target)
+    #  super
+    #  instance.puts_and_system %(heroku run rake dev:staging_data -a #{target.heroku_app})
+    # end
+    #
+    # def before_deploying(instance, target, version)
+    #   # override
+    # end
+    #
+    # def after_deploying(instance, target, version)
+    #   # override
+    # end
+  end
+
+  module Configuration
+    class << self
+      prepend MyConfig
+    end
+  end
+
+  # desc "set_message TARGET (MESSAGE)", "sets a MESSAGE to display on the TARGET server. If you give no MESSAGE, it will clear the message"
+  #
+  # def set_message(target_name, message = nil)
+  #   target = lookup_heroku(target_name)
+  #   if message
+  #     puts_and_system "heroku run rake data:util:set_message[\"#{message}\"] -a #{target.heroku_app}"
+  #   else
+  #     puts_and_system "heroku run rake data:util:set_message -a #{target.heroku_app}"
+  #   end
+  # end
+end

data/templates/heroku_targets.yml

@@ -0,0 +1,21 @@
+# find `database_url` by running `heroku pg:info --app=APP_NAME`
+_defaults:
+  repository: https://github.com/siapbantu/heroku_rails
+production:
+  heroku_app : some-heroku-production
+  git_remote : heroku-production
+  deploy_ref : origin/master
+  display_name : production (heroku_rails)
+demo:
+  heroku_app : some-heroku-demo
+  git_remote : heroku-demo
+  deploy_ref : HEAD
+  display_name : demo (heroku_rails)
+  trackable_release_stage : demo
+  staging : true
+staging:
+  heroku_app : some-heroku-staging
+  git_remote : heroku-staging
+  deploy_ref : HEAD
+  display_name : staging (heroku_rails)
+  staging : true

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: heroku_rails
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ahmad Ainul Rizki
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-07-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 12.3.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 12.3.3
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: standard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.1
+description: 
+email:
+- human@shitiomatic.email
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- heroku_rails.gemspec
+- lib/heroku_rails.rb
+- lib/heroku_rails/db_configuration.rb
+- lib/heroku_rails/heroku_targets.rb
+- lib/heroku_rails/tasks/db_drop_all_tables.rake
+- lib/heroku_rails/tasks/heroku.thor
+- lib/heroku_rails/thor_utils.rb
+- lib/heroku_rails/version.rb
+- templates/Rakefile
+- templates/heroku.thor
+- templates/heroku_targets.yml
+homepage: https://github.com/siapbantu/heroku_rails
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Useless tool for easy deploy Ruby on Rails to Heroku
+test_files: []