git-deploy-ng 0.8.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b9bac8c7043b8147444e762d919dbc943862b999a420b26112edcf8e893fb509
+  data.tar.gz: 00e10711fdcdafc3fc8a473f273f051d0eb09b9ee9c84c9db3796c4d1ee71abf
+SHA512:
+  metadata.gz: aa0e71d63684c7e958e90b118cb3cfe18fce10ec21993a8d84e307e9f74ba806a632647554bdea917e502b24089b5faa59029820e14a36eb8cd31b4c9abdcca4
+  data.tar.gz: f81335e3f58ff15a32d7b335acb888df020b7a139dfbaa24ea8cec5c2027c54789ddb201b634f160062f4eb21e189a7a37cde5858454c35390c40d424258653d

data/CONTRIBUTING.md

@@ -0,0 +1,35 @@
+# Contributing
+
+Thank you for contributing to git-deploy-ng. This project is a backwards-compatible continuation of [mislav/git-deploy](https://github.com/mislav/git-deploy).
+
+## Getting started
+
+```bash
+git clone https://github.com/npfedwards/git-deploy.git
+cd git-deploy
+bundle install
+bundle exec rspec
+```
+
+## Pull requests
+
+1. Fork the repo and create a feature branch from `master`.
+2. Add or update tests for any behaviour change. We use RSpec and prefer integration-style tests through public interfaces.
+3. Keep the CLI, hook defaults, and deploy callback contract backwards-compatible unless explicitly discussed in an issue.
+4. Open a PR with a clear description of the user-facing behaviour change.
+
+## Backwards compatibility
+
+v0.8.x must not break existing users migrating from upstream 0.7.0:
+
+- Same `git deploy` subcommands and flags
+- Same default `post-receive` hook behaviour (improvements are opt-in via `git deploy hooks`)
+- Existing `deploy/` callback scripts in deployed apps should keep working unchanged
+
+## Releases
+
+Releases are tagged (`v0.8.0`, etc.) and published to RubyGems as `git-deploy-ng`. Maintainers cut releases from `master` after CI passes.
+
+## Internal planning
+
+Working notes may live in a local `plans/` directory (gitignored). [ROADMAP.md](ROADMAP.md) lists ideas under consideration — open an issue to discuss priorities.

data/LICENSE

@@ -0,0 +1,18 @@
+Copyright (c) 2009 Mislav Marohnić
+
+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/MAINTAINERS.md

@@ -0,0 +1,15 @@
+# Maintainers
+
+git-deploy-ng is a community continuation of [mislav/git-deploy](https://github.com/mislav/git-deploy).
+
+## Original author
+
+- **Mislav Marohnić** — created git-deploy and maintained it through v0.7.0
+
+## Current maintainers
+
+- **Nathan Edwards** ([@npfedwards](https://github.com/npfedwards)) — fork maintainer
+
+## License
+
+MIT — see [LICENSE](LICENSE).

data/README.markdown

@@ -0,0 +1,172 @@
+Easy git deployment
+===================
+
+Community continuation of [mislav/git-deploy](https://github.com/mislav/git-deploy), published as **git-deploy-ng**. The CLI is unchanged: `git deploy <command>`.
+
+Straightforward, [Heroku][]-style, push-based deployment. Your deploys can become as simple as this:
+
+    $ git push production main
+
+To get started, install the gem on the machine that runs setup (once per project):
+
+    gem install git-deploy-ng
+
+Only the person who is setting up deployment for the first time needs to install
+the gem. You don't have to add it to your project's Gemfile. Production servers
+do not need Ruby — only bash and git.
+
+See [ROADMAP.md](ROADMAP.md) for ideas under consideration and [CONTRIBUTING.md](CONTRIBUTING.md) to contribute.
+
+
+Migrating from mislav/git-deploy
+--------------------------------
+
+Requires **Ruby 2.7+** on the setup machine (including Ruby 4.x; system Ruby 2.6 on macOS is not supported).
+
+1. `gem uninstall git-deploy` (optional)
+2. `gem install git-deploy-ng`
+3. `git deploy hooks -r production` (optional, per host — refreshes remote hooks)
+
+Existing `deploy/` callback scripts in your apps do not need to change.
+
+
+Which app languages/frameworks are supported?
+---------------------------------------------
+
+Regardless of the fact that this tool is mostly written in Ruby, git-deploy can be useful for any kind of code that needs deploying on a remote server. The default scripts are suited for Ruby web apps, but can be edited to accommodate other frameworks.
+
+Your deployment is customized with per-project callback scripts which can be written in any language.
+
+The assumption is that you're deploying to a single host to which you connect over SSH using public/private key authentication.
+
+
+Initial setup
+-------------
+
+1.  Create a git remote for where you'll push the code on your server. The name of this remote in the examples is "production", but it can be whatever you wish ("online", "website", or other).
+
+    ```sh
+    git remote add production "user@example.com:/apps/mynewapp"
+    ```
+
+    `/apps/mynewapp` is the directory where you want your code to reside on the
+    remote server. If the directory doesn't exist, the next step creates it.
+
+2.  Run the setup task:
+
+    ```sh
+    git deploy setup -r "production"
+    ```
+
+    This will initialize the remote git repository in the deploy directory
+    (`/apps/mynewapp` in the above example) and install the remote git hook.
+
+3.  Run the init task:
+
+    ```sh
+    git deploy init
+    ```
+
+    This generates default deploy callback scripts in the `deploy/` directory.
+    You should check them in git because they are going to be executed on the
+    server during each deploy.
+
+4.  Push the code.
+
+    ```sh
+    git push production main
+    ```
+
+    Use whichever branch is checked out locally; `git deploy setup` configures the remote repo to match your current branch (`main` or `master`).
+
+5.  Login to your server and manually perform necessary one-time administrative operations. This might include:
+    * set up the Apache/nginx virtual host for this application;
+    * check your `config/database.yml` and create the production database.
+
+
+Everyday deployments
+--------------------
+
+If you've set your app correctly, visiting <http://example.com> in your browser
+should show it up and running.
+
+Now, subsequent deployments are done simply **by pushing to the branch that is
+currently checked out on the remote**:
+
+    git push production main
+
+Because the deployments are performed with git, nobody else on the team needs to
+install the git-deploy gem.
+
+On every deploy, the default `deploy/after_push` script performs the following:
+
+1. updates git submodules (if there are any);
+2. runs `bundle install --deployment` if there is a Gemfile;
+3. runs `rake db:migrate` if new migrations have been added;
+4. clears cached CSS/JS assets in "public/stylesheets" and "public/javascripts";
+5. restarts the web application.
+
+You can customize all this by editing generated scripts in the `deploy/`
+directory of your app.
+
+Deployments are logged to `log/deploy.log` in your application's directory.
+
+
+How it works
+------------
+
+The `git deploy setup` command installed a `post-receive` git hook in the remote
+repository. This is how your code on the server is kept up to date. This script
+checks out the latest version of your project from the current branch and
+runs the following callback scripts:
+
+* `deploy/setup` - on first push.
+* `deploy/after_push` - on subsequent pushes. It in turn executes:
+  * `deploy/before_restart`
+  * `deploy/restart`
+  * `deploy/after_restart`
+* `deploy/rollback` - executed for `git deploy rollback`.
+
+All of the callbacks are optional. These scripts are ordinary Unix executables.
+The ones which get generated for you by `git deploy init` are written in shell
+script and Ruby.
+
+
+Extra commands
+--------------
+
+* `git deploy hooks` - Updates git hooks on the remote repository
+
+* `git deploy log [N=20]` - Shows last 20 lines of deploy log on the server
+
+* `git deploy rerun` - Re-runs the `deploy/after_push` callback as if a git push happened
+
+* `git deploy restart` - Runs the `deploy/restart` callback
+
+* `git deploy rollback` - Undo a deploy by checking out the previous revision,
+  runs `deploy/rollback` if exists instead of `deploy/after_push`
+
+* `git deploy upload <files>` - Copy local files to the remote app
+
+
+Troubleshooting
+---------------
+
+### `unsupported key type ssh-ed25519`
+
+Modern OpenSSH keys (ed25519) require optional gems that net-ssh does not bundle:
+
+```sh
+gem install ed25519 bcrypt_pbkdf
+```
+
+git-deploy-ng will print this command if the gems are missing when connecting.
+
+### Still running upstream `git-deploy` 0.7.0?
+
+The original gem targets older Ruby and net-ssh versions. Migrate to `git-deploy-ng`
+on Ruby 2.7+ — see [Migrating from mislav/git-deploy](#migrating-from-mislavgit-deploy).
+
+
+
+  [heroku]: http://heroku.com/

data/ROADMAP.md

@@ -0,0 +1,31 @@
+# Roadmap
+
+Tracking for git-deploy-ng. **Nothing listed here is a commitment** — items may be reprioritised, dropped, or implemented differently. Any change that affects default behaviour will be called out explicitly in release notes.
+
+## v0.8.0 (in progress)
+
+Scoped fixes for this release:
+
+| Fix | Upstream context |
+|-----|------------------|
+| Ruby 3.x compatibility | [#88](https://github.com/mislav/git-deploy/issues/88), [#67](https://github.com/mislav/git-deploy/issues/67) |
+| Dynamic default branch (`main` / `master`) | Hardcoded `master` in setup |
+| Dependency upgrades (Thor, net-ssh, net-scp) | OpenSSL / Ruby 3.2+ SSH failures |
+| Modern CI (GitHub Actions, Ruby 2.7–4.0) | Travis CI retired |
+| Publish as `git-deploy-ng` on RubyGems | Avoids namespace conflict with upstream gem |
+
+## Ideas under consideration (post-v0.8.0)
+
+Sourced from upstream open issues and community discussion. If something here interests you, open an issue — priorities are not fixed.
+
+| Idea | Source | Notes |
+|------|--------|-------|
+| Multi-server deploy | [#89](https://github.com/mislav/git-deploy/issues/89) | Single push triggers deploy on N hosts |
+| Multiple environments | [#71](https://github.com/mislav/git-deploy/issues/71) | `staging` / `production` config profiles |
+| Custom deploy script directory | [#75](https://github.com/mislav/git-deploy/issues/75) | Not hardcoded to `deploy/` |
+| Rails 6+ default templates | [#92](https://github.com/mislav/git-deploy/issues/92) | Zeitwerk, credentials, modern asset pipeline |
+| Improved PATH in hooks | [#68](https://github.com/mislav/git-deploy/issues/68) | rbenv/nvm/pyenv in non-login hook context |
+| Windows client support | [#80](https://github.com/mislav/git-deploy/issues/80) | May remain unsupported; needs discussion |
+| Homebrew distribution | — | `brew install` for macOS setup machines |
+| Download remote files | [#83](https://github.com/mislav/git-deploy/issues/83) | `git deploy download` — inverse of `upload` |
+| Hook dry-run | — | `git deploy rerun --noop` on server |

data/bin/git-deploy

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require 'git_deploy'
+GitDeploy.start

data/lib/git_deploy/configuration.rb

@@ -0,0 +1,95 @@
+require 'uri'
+require 'cgi'
+require 'forwardable'
+
+class GitDeploy
+  module Configuration
+    private
+
+    extend Forwardable
+    def_delegator :remote_url, :host
+    def_delegator :remote_url, :port, :remote_port
+
+    def deploy_to
+      @deploy_to ||= begin
+        if remote_url.path.start_with? '/~/'
+          remote_url.path[1..-1]
+        else
+          remote_url.path 
+        end
+      end
+    end
+
+    def remote_user
+      @user ||= begin
+        user = remote_url.user
+        user ? CGI.unescape(user) : `whoami`.chomp
+      end
+    end
+
+    def branch
+      @branch ||= begin
+        ref = current_branch
+        ref && !ref.empty? ? normalize_branch(ref) : 'master'
+      end
+    end
+
+    def git_config
+      @git_config ||= Hash.new do |cache, cmd|
+        git = ENV['GIT'] || 'git'
+        out = `#{git} #{cmd}`
+        if $?.success? then cache[cmd] = out.chomp
+        else cache[cmd] = nil
+        end
+        cache[cmd]
+      end
+    end
+
+    def remote_urls(remote)
+      git_config["remote -v"].to_s.split("\n").
+        select {|l| l =~ /^#{remote}\t.+/ }.
+        map {|l| l.split("\t")[1].sub(/\s+\(.+?\)$/, '') }
+    end
+
+    def remote_url(remote = options[:remote])
+      @remote_url ||= {}
+      @remote_url[remote] ||= begin
+        url = remote_urls(remote).first
+        if url.nil?
+          abort "Error: Remote url not found for remote #{remote.inspect}"
+        elsif url =~ /(^|@)github\.com\b/
+          abort "Error: Remote url for #{remote.inspect} points to GitHub. Can't deploy there!"
+        else
+          url = 'ssh://' + url.sub(%r{:/?}, '/') unless url =~ %r{^[\w-]+://}
+          begin
+            url = URI.parse url
+          rescue
+            abort "Error parsing remote url #{url}"
+          end
+        end
+        url
+      end
+    end
+
+    def current_branch
+      git_config['symbolic-ref -q HEAD']
+    end
+
+    def tracked_branch
+      branch = current_branch && tracked_for(current_branch)
+      normalize_branch(branch) if branch
+    end
+
+    def normalize_branch(branch)
+      branch.sub('refs/heads/', '')
+    end
+
+    def remote_for(branch)
+      git_config['config branch.%s.remote' % normalize_branch(branch)]
+    end
+
+    def tracked_for(branch)
+      git_config['config branch.%s.merge' % normalize_branch(branch)]
+    end
+  end
+end

data/lib/git_deploy/generator.rb

@@ -0,0 +1,28 @@
+require 'thor/group'
+
+class GitDeploy::Generator < Thor::Group
+  include Thor::Actions
+
+  def self.source_root
+    File.expand_path('../templates', __FILE__)
+  end
+
+  def copy_main_hook
+    copy_hook 'after_push.sh', 'deploy/after_push'
+  end
+
+  def copy_restart_hook
+    copy_hook 'restart.sh', 'deploy/restart'
+  end
+
+  def copy_restart_callbacks
+    copy_hook 'before_restart.rb', 'deploy/before_restart'
+  end
+
+  private
+
+  def copy_hook(template, destination)
+    copy_file template, destination
+    chmod destination, 0744 unless File.executable? destination
+  end
+end

data/lib/git_deploy/ssh_methods.rb

@@ -0,0 +1,119 @@
+class GitDeploy
+  module SSHMethods
+    private
+
+    def sudo_cmd
+      "sudo -p 'sudo password: '"
+    end
+
+    def system(*args)
+      puts "[local] $ " + args.join(' ').gsub(' && ', " && \\\n  ")
+      super unless options.noop?
+    end
+
+    def run(cmd = nil, opt = {})
+      cmd = yield(cmd) if block_given?
+      cmd = cmd.join(' && ') if Array === cmd
+
+      if opt.fetch(:echo, true)
+        puts "[#{options[:remote]}] $ " + cmd.gsub(' && ', " && \\\n  ")
+      end
+
+      unless options.noop?
+        status, output = ssh_exec cmd do |ch, stream, data|
+          case stream
+          when :stdout then $stdout.print data
+          when :stderr then $stderr.print data
+          end
+          ch.send_data(askpass) if data =~ /^sudo password: /
+        end
+        output
+      end
+    end
+
+    def run_test(cmd)
+      status, output = ssh_exec(cmd) { }
+      status == 0
+    end
+
+    def ssh_exec(cmd, &block)
+      status = nil
+      output = ''
+
+      channel = ssh_connection.open_channel do |chan|
+        chan.exec(cmd) do |ch, success|
+          raise "command failed: #{cmd.inspect}" unless success
+          # ch.request_pty
+
+          ch.on_data do |c, data|
+            output << data
+            yield(c, :stdout, data)
+          end
+
+          ch.on_extended_data do |c, type, data|
+            output << data
+            yield(c, :stderr, data)
+          end
+
+          ch.on_request "exit-status" do |ch, data|
+            status = data.read_long
+          end
+        end
+      end
+
+      channel.wait
+      [status, output]
+    end
+
+    # TODO: use Highline for cross-platform support
+    def askpass
+      tty_state = `stty -g`
+      system 'stty raw -echo -icanon isig' if $?.success?
+      pass = ''
+      while char = $stdin.getbyte and not (char == 13 or char == 10)
+        if char == 127 or char == 8
+          pass[-1,1] = '' unless pass.empty?
+        else
+          pass << char.chr
+        end
+      end
+      pass
+    ensure
+      system "stty #{tty_state}" unless tty_state.empty?
+    end
+
+    def scp_upload(files)
+      channels = []
+      files.each do |local, remote|
+        puts "FILE: [local] #{local.sub(LOCAL_DIR + '/', '')}  ->  [#{options[:remote]}] #{remote}"
+        channels << ssh_connection.scp.upload(local, remote) unless options.noop?
+      end
+      channels.each { |c| c.wait }
+    end
+
+    def ssh_connection
+      @ssh ||= begin
+        ssh = Net::SSH.start(host, remote_user, :port => remote_port || 22)
+        at_exit { ssh.close }
+        ssh
+      end
+    rescue NotImplementedError, Gem::MissingSpecError => e
+      abort ed25519_ssh_help if ed25519_ssh_error?(e)
+      raise
+    end
+
+    def ed25519_ssh_error?(error)
+      error.message.downcase.include?('ed25519')
+    end
+
+    def ed25519_ssh_help
+      <<~HELP
+        Error: Your SSH key requires ed25519 support, but the optional gems are not installed.
+
+          gem install ed25519 bcrypt_pbkdf
+
+        See https://github.com/net-ssh/net-ssh/issues/565
+      HELP
+    end
+  end
+end

data/lib/git_deploy/templates/after_push.sh

@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+set -e
+oldrev=$1
+newrev=$2
+
+run() {
+  [ -x $1 ] && $1 $oldrev $newrev
+}
+
+echo files changed: $(git diff $oldrev $newrev --diff-filter=ACDMR --name-only | wc -l)
+
+umask 002
+
+git submodule sync && git submodule update --init --recursive
+
+run deploy/before_restart
+run deploy/restart && run deploy/after_restart

data/lib/git_deploy/templates/before_restart.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+oldrev, newrev = ARGV
+
+def run(cmd)
+  exit($?.exitstatus) unless system "umask 002 && #{cmd}"
+end
+
+RAILS_ENV   = ENV['RAILS_ENV'] || 'production'
+use_bundler = File.file? 'Gemfile'
+rake_cmd    = use_bundler ? 'bundle exec rake' : 'rake'
+
+if use_bundler
+  bundler_args = ['--deployment']
+  BUNDLE_WITHOUT = ENV['BUNDLE_WITHOUT'] || 'development:test'
+  bundler_args << '--without' << BUNDLE_WITHOUT unless BUNDLE_WITHOUT.empty?
+
+  # update gem bundle
+  run "bundle install #{bundler_args.join(' ')}"
+end
+
+if File.file? 'Rakefile'
+  tasks = []
+
+  if File.exist?('db/migrate')
+    num_migrations = `git diff #{oldrev} #{newrev} --diff-filter=A --name-only -z -- db/migrate`.split("\0").size
+  else
+    num_migrations = 0
+  end
+
+  # run migrations if new ones have been added
+  tasks << "db:migrate" if num_migrations > 0
+
+  # precompile assets
+  changed_assets = `git diff #{oldrev} #{newrev} --name-only -z -- app/assets`.split("\0")
+  tasks << "assets:precompile" if changed_assets.size > 0
+
+  run "#{rake_cmd} #{tasks.join(' ')} RAILS_ENV=#{RAILS_ENV}" if tasks.any?
+end
+
+# clear cached assets (unversioned/ignored files)
+run "git clean -x -f -- public/stylesheets public/javascripts"
+
+# clean unversioned files from vendor/plugins (e.g. old submodules)
+run "git clean -d -f -- vendor/plugins"

data/lib/git_deploy/templates/restart.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+touch tmp/restart.txt
+echo "restarting Passenger app"

data/lib/git_deploy.rb

@@ -0,0 +1,104 @@
+require 'thor'
+require 'net/ssh'
+require 'net/scp'
+
+class GitDeploy < Thor
+  LOCAL_DIR = File.expand_path('..', __FILE__)
+
+  require 'git_deploy/configuration'
+  require 'git_deploy/ssh_methods'
+  include Configuration
+  include SSHMethods
+
+  class_option :remote, :aliases => '-r', :type => :string, :default => 'origin'
+  class_option :noop, :aliases => '-n', :type => :boolean, :default => false
+
+  desc "init", "Generates deployment customization scripts for your app"
+  def init
+    require 'git_deploy/generator'
+    Generator::start([])
+  end
+
+  desc "setup", "Create the remote git repository and install push hooks for it"
+  method_option :shared, :aliases => '-g', :type => :boolean, :default => false
+  method_option :sudo, :aliases => '-s', :type => :boolean, :default => false
+  def setup
+    sudo = options.sudo? ? "#{sudo_cmd} " : ''
+
+    unless run_test("test -x #{deploy_to}")
+      run ["#{sudo}mkdir -p #{deploy_to}"] do |cmd|
+        cmd << "#{sudo}chown $USER #{deploy_to}" if options.sudo?
+        cmd
+      end
+    end
+
+    run [] do |cmd|
+      cmd << "chmod g+ws #{deploy_to}" if options.shared?
+      cmd << "cd #{deploy_to}"
+      cmd << "git init #{options.shared? ? '--shared' : ''}"
+      cmd << "sed -i'' -e 's/master/#{branch}/' .git/HEAD" unless branch == 'master'
+      cmd << "git config --bool receive.denyNonFastForwards false" if options.shared?
+      cmd << "git config receive.denyCurrentBranch ignore"
+    end
+
+    invoke :hooks
+  end
+
+  desc "hooks", "Installs git hooks to the remote repository"
+  def hooks
+    hooks_dir = File.join(LOCAL_DIR, 'hooks')
+    remote_dir = "#{deploy_to}/.git/hooks"
+
+    scp_upload "#{hooks_dir}/post-receive.sh" => "#{remote_dir}/post-receive"
+    run "chmod +x #{remote_dir}/post-receive"
+  end
+  
+  desc "restart", "Restarts the application on the server"
+  def restart
+    run "cd #{deploy_to} && deploy/restart 2>&1 | tee -a log/deploy.log"
+  end
+
+  desc "rerun", "Runs the `deploy/after_push' callback as if a new revision was pushed via git"
+  def rerun
+    run <<-BASH, :echo => false
+      bash -e -c '
+        cd '#{deploy_to}'
+        declare -a revs=( $(git rev-parse HEAD@{1} HEAD) )
+        deploy/after_push ${revs[@]} 2>&1 | tee -a log/deploy.log
+      '
+    BASH
+  end
+
+  desc "rollback", "Rolls back the checkout to before the last push"
+  def rollback
+    run <<-BASH, :echo => false
+      bash -e -c '
+        cd '#{deploy_to}'
+        declare -a revs=( $(git rev-parse HEAD HEAD@{1}) )
+        git reset --hard ${revs[1]}
+        callback=after_push
+        [ -x deploy/rollback ] && callback=rollback
+        deploy/$callback ${revs[@]} 2>&1 | tee -a log/deploy.log
+      '
+    BASH
+  end
+
+  desc "log", "Shows the last part of the deploy log on the server"
+  method_option :tail, :aliases => '-t', :type => :boolean, :default => false
+  method_option :lines, :aliases => '-l', :type => :numeric, :default => 20
+  def log(n = nil)
+    tail_args = options.tail? ? '-f' : "-n#{n || options.lines}"
+    run "tail #{tail_args} #{deploy_to}/log/deploy.log"
+  end
+
+  desc "upload <files>", "Copy local files to the remote app"
+  def upload(*files)
+    files = files.map { |f| Dir[f.strip] }.flatten
+    abort "Error: Specify at least one file to upload" if files.empty?
+
+    scp_upload files.inject({}) { |all, file|
+      all[file] = File.join(deploy_to, file)
+      all
+    }
+  end
+end

data/lib/hooks/post-receive.sh

@@ -0,0 +1,55 @@
+#!/bin/bash
+set -e
+
+if [ "$GIT_DIR" = "." ]; then
+  # The script has been called as a hook; chdir to the working copy
+  cd ..
+  unset GIT_DIR
+fi
+
+# try to obtain the usual system PATH
+if [ -f /etc/profile ]; then
+  PATH=$(source /etc/profile; echo $PATH)
+  export PATH
+fi
+
+# get the current branch
+head="$(git symbolic-ref HEAD)"
+
+# read the STDIN to detect if this push changed the current branch
+while read oldrev newrev refname
+do
+  [ "$refname" = "$head" ] && break
+done
+
+# abort if there's no update, or in case the branch is deleted
+if [ -z "${newrev//0}" ]; then
+  exit
+fi
+
+# check out the latest code into the working copy
+umask 002
+git reset --hard
+
+logfile=log/deploy.log
+restart=tmp/restart.txt
+
+if [ -z "${oldrev//0}" ]; then
+  # this is the first push; this branch was just created
+  mkdir -p log tmp
+  chmod 0775 log tmp
+  touch $logfile $restart
+  chmod 0664 $logfile $restart
+
+  # init submodules
+  git submodule update --recursive --init 2>&1 | tee -a $logfile
+
+  # execute the one-time setup hook
+  [ -x deploy/setup ] && deploy/setup $oldrev $newrev 2>&1 | tee -a $logfile
+else
+  # log timestamp
+  echo ==== $(date) ==== >> $logfile
+
+  # execute the main deploy hook
+  [ -x deploy/after_push ] && deploy/after_push $oldrev $newrev 2>&1 | tee -a $logfile
+fi

data/spec/cli_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe GitDeploy do
+  it 'exposes the upstream CLI commands' do
+    commands = described_class.all_commands.keys
+    expect(commands).to include(
+      'init', 'setup', 'hooks', 'restart', 'rerun', 'rollback', 'log', 'upload'
+    )
+  end
+end

data/spec/commands_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'tmpdir'
+
+describe GitDeploy do
+  describe '#upload' do
+    it 'copies local files to the remote app directory' do
+      instance = described_class.new([], remote: 'production', noop: true)
+      uploads = {}
+
+      allow(instance).to receive(:scp_upload) { |files| uploads.merge!(files) }
+      instance.send(:git_config)['remote -v'] = "production\tgit@example.com:/apps/demo (fetch)"
+
+      Dir.mktmpdir do |dir|
+        file = File.join(dir, 'config.yml')
+        File.write(file, 'test')
+
+        instance.upload(file)
+
+        expect(uploads[file]).to eq(File.join('/apps/demo', file))
+      end
+    end
+  end
+
+  describe '#restart' do
+    it 'runs the deploy restart script on the server' do
+      instance = described_class.new([], remote: 'production', noop: true)
+      commands = []
+
+      allow(instance).to receive(:run) { |cmd| commands << cmd }
+      instance.send(:git_config)['remote -v'] = "production\tgit@example.com:/apps/demo (fetch)"
+
+      instance.restart
+
+      expect(commands.first).to include('deploy/restart')
+    end
+  end
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+describe GitDeploy::Configuration do
+
+  subject {
+    mod = described_class
+    obj = Object.new
+    opt = options
+    (class << obj; self; end).class_eval do
+      include mod
+      mod.private_instance_methods.each {|m| public m }
+      define_method(:options) { opt }
+    end
+    obj
+  }
+
+  let(:options) { {:remote => 'production'} }
+
+  def stub_git_config(cmd, value)
+    subject.git_config[cmd] = value
+  end
+
+  def stub_remote_url(url, remote = options[:remote])
+    stub_git_config("remote -v", "#{remote}\t#{url} (fetch)")
+  end
+
+  describe '#branch' do
+    it 'uses the current branch when HEAD is on main' do
+      stub_git_config('symbolic-ref -q HEAD', 'refs/heads/main')
+      expect(subject.branch).to eq('main')
+    end
+
+    it 'uses master when no symbolic ref is available' do
+      stub_git_config('symbolic-ref -q HEAD', nil)
+      expect(subject.branch).to eq('master')
+    end
+
+    it 'uses master when on the master branch' do
+      stub_git_config('symbolic-ref -q HEAD', 'refs/heads/master')
+      expect(subject.branch).to eq('master')
+    end
+  end
+
+  describe '#tracked_branch' do
+    it 'returns the branch name for the current HEAD' do
+      stub_git_config('symbolic-ref -q HEAD', 'refs/heads/main')
+      stub_git_config('config branch.main.merge', 'refs/heads/main')
+      expect(subject.tracked_branch).to eq('main')
+    end
+  end
+
+  describe '#remote_for' do
+    it 'returns the remote tracking a branch' do
+      stub_git_config('config branch.main.remote', 'production')
+      expect(subject.remote_for('refs/heads/main')).to eq('production')
+    end
+  end
+
+  describe "extracting user/host from remote url" do
+    context "ssh url" do
+      before { stub_remote_url 'ssh://jon%20doe@example.com:88/path/to/app' }
+
+      it { expect(subject.host).to eq('example.com') }
+      it { expect(subject.remote_port).to eq(88) }
+      it { expect(subject.remote_user).to eq('jon doe') }
+      it { expect(subject.deploy_to).to eq('/path/to/app') }
+    end
+
+    context "scp-style" do
+      before { stub_remote_url 'git@example.com:/path/to/app' }
+
+      it { expect(subject.host).to eq('example.com') }
+      it { expect(subject.remote_port).to be_nil }
+      it { expect(subject.remote_user).to eq('git') }
+      it { expect(subject.deploy_to).to eq('/path/to/app') }
+    end
+
+    context "scp-style with home" do
+      before { stub_remote_url 'git@example.com:~/path/to/app' }
+
+      it { expect(subject.host).to eq('example.com') }
+      it { expect(subject.remote_port).to be_nil }
+      it { expect(subject.remote_user).to eq('git') }
+      it { expect(subject.deploy_to).to eq('~/path/to/app') }
+    end
+
+    context "pushurl only" do
+      before {
+        remote = options.fetch(:remote)
+        url = 'git@example.com:/path/to/app'
+        stub_git_config("remote -v", "#{remote}\t\n#{remote}\t#{url} (push)")
+      }
+
+      it { expect(subject.host).to eq('example.com') }
+      it { expect(subject.remote_user).to eq('git') }
+    end
+  end
+
+end

data/spec/generator_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+require 'tmpdir'
+require 'git_deploy/generator'
+
+describe GitDeploy::Generator do
+  it 'generates deploy callback scripts in the current directory' do
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) do
+        described_class.start([])
+
+        expect(File.executable?('deploy/after_push')).to be true
+        expect(File.executable?('deploy/restart')).to be true
+        expect(File.executable?('deploy/before_restart')).to be true
+      end
+    end
+  end
+end

data/spec/hooks_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe GitDeploy do
+  describe '#hooks' do
+    it 'uploads the post-receive hook to the remote repository' do
+      instance = described_class.new([], remote: 'production', noop: true)
+      uploads = {}
+
+      allow(instance).to receive(:scp_upload) { |files| uploads.merge!(files) }
+      allow(instance).to receive(:run)
+      instance.send(:git_config)['remote -v'] = "production\tgit@example.com:/apps/demo (fetch)"
+
+      instance.hooks
+
+      expect(uploads.values).to include('/apps/demo/.git/hooks/post-receive')
+    end
+  end
+end

data/spec/setup_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe GitDeploy do
+  describe '#setup' do
+    let(:instance) { described_class.new([], remote: 'production', noop: true, shared: false, sudo: false) }
+    let(:commands) { [] }
+
+    before do
+      allow(instance).to receive(:run_test).and_return(false)
+      allow(instance).to receive(:run) do |cmd = nil, **_opts, &block|
+        cmd = block.call([]) if block
+        commands << cmd
+      end
+      allow(instance).to receive(:invoke)
+      instance.send(:git_config)['remote -v'] = "production\tgit@example.com:/apps/demo (fetch)"
+    end
+
+    it 'initializes the remote repo with the current branch as HEAD' do
+      instance.send(:git_config)['symbolic-ref -q HEAD'] = 'refs/heads/main'
+
+      instance.setup
+
+      init_cmd = commands.flatten.join(' && ')
+      expect(init_cmd).to include('git init')
+      expect(init_cmd).to include("sed -i'' -e 's/master/main/' .git/HEAD")
+    end
+
+    it 'skips HEAD rewrite when the current branch is master' do
+      instance.send(:git_config)['symbolic-ref -q HEAD'] = 'refs/heads/master'
+
+      instance.setup
+
+      init_cmd = commands.flatten.join(' && ')
+      expect(init_cmd).not_to include('sed')
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+require 'simplecov'
+SimpleCov.minimum_coverage 80
+SimpleCov.start
+
+require 'rspec'
+require 'rspec/mocks'
+require 'git_deploy'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

data/spec/ssh_connection_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe GitDeploy do
+  describe 'SSH connection' do
+    let(:instance) { described_class.new([], remote: 'production') }
+
+    before do
+      instance.send(:git_config)['remote -v'] = "production\tgit@example.com:/apps/demo (fetch)"
+    end
+
+    it 'advises installing ed25519 gems when SSH keys require them' do
+      allow(Net::SSH).to receive(:start).and_raise(
+        NotImplementedError,
+        "unsupported key type `ssh-ed25519'\n * ed25519 (>= 1.2, < 2.0)"
+      )
+
+      expect { instance.send(:run_test, 'true') }.to raise_error(SystemExit, /gem install ed25519 bcrypt_pbkdf/)
+    end
+
+    it 're-raises unrelated SSH errors' do
+      allow(Net::SSH).to receive(:start).and_raise(NotImplementedError, 'unexpected failure')
+
+      expect { instance.send(:run_test, 'true') }.to raise_error(NotImplementedError, 'unexpected failure')
+    end
+  end
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: git-deploy-ng
+version: !ruby/object:Gem::Version
+  version: 0.8.0
+platform: ruby
+authors:
+- Nathan Edwards
+- Mislav Marohnić
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: net-ssh
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: net-scp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: logger
+  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'
+description: A community continuation of mislav/git-deploy. Push-based, Heroku-like
+  deployment over SSH.
+email: npfedwards@gmail.com
+executables:
+- git-deploy
+extensions: []
+extra_rdoc_files: []
+files:
+- CONTRIBUTING.md
+- LICENSE
+- MAINTAINERS.md
+- README.markdown
+- ROADMAP.md
+- bin/git-deploy
+- lib/git_deploy.rb
+- lib/git_deploy/configuration.rb
+- lib/git_deploy/generator.rb
+- lib/git_deploy/ssh_methods.rb
+- lib/git_deploy/templates/after_push.sh
+- lib/git_deploy/templates/before_restart.rb
+- lib/git_deploy/templates/restart.sh
+- lib/hooks/post-receive.sh
+- spec/cli_spec.rb
+- spec/commands_spec.rb
+- spec/configuration_spec.rb
+- spec/generator_spec.rb
+- spec/hooks_spec.rb
+- spec/setup_spec.rb
+- spec/spec_helper.rb
+- spec/ssh_connection_spec.rb
+homepage: https://github.com/npfedwards/git-deploy#readme
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: Simple git push-based application deployment
+test_files: []