git-deploy 0.4.1 → 0.5.5

data/README.markdown

@@ -1,109 +1,116 @@
-Capistrano strategy for smart git deployment
-============================================
+Easy git deployment
+===================
 
-Let's set up a straightforward, [Heroku][]-style, push-based deployment, shall we? The goal is that our deployment looks like this:
+Straightforward, [Heroku][]-style, push-based deployment. Your deploys can become as simple as this:
 
-    $ git push origin production
+    $ git push production master
 
-Assumptions are that you are using git for your Rails app and Passenger on the server. For now, we're going to deploy on a single host.
+To get started, install the "git-deploy" gem.
 
-To get started, install the "git-deploy" gem from Gemcutter.org.
+    gem install git-deploy
 
+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.
 
-Considerations
---------------
 
-This is not "yet another Capistrano strategy". Capistrano is only used for setup, after which it's all git hooks (see detailed description in "Deployment"). This actually replaces the default Capistrano recipe (which is not loaded) with only a basic set of tasks. If you have more advanced deployment (multiple hosts, many "after deploy" hooks) then this library cannot suit your needs at present.
+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.
 
-Setup steps
------------
+Your deployment is customized with per-project callback scripts which can be written in any language.
 
-1.  Create a git remote for where you'll push the code on your server. The name of this remote in the examples is "origin", but it can be whatever you wish ("online", "website", or other).
-    
-        $ git remote add origin user@example.com:/path/to/myapp
-    
-    The "/path/to/myapp" is the directory where your code will reside. It doesn't have to exist; it will be created for you during this setup.
+The assumption is that you're deploying to a single host to which you connect over SSH using public/private key authentication.
 
-2.  Create/overwrite the following files in your project:
-    
-    **config/deploy.rb** (entire file):
-    
-        # set to the name of git remote you intend to deploy to
-        set :remote, "origin"
-        # specify the deployment branch
-        set :branch, "master"
-        # sudo will only be used to create the deployment directory
-        set :use_sudo, true
-        # the remote host is read automatically from your git remote specification
-        server remote_host, :app, :web, :db, :primary => true
-    
-    **Capfile**:
-    
-        require 'git_deploy'
-        load 'config/deploy'
-    
-    Test it by running `cap -T`. You should see several deploy tasks listed.
 
-3.  Run the setup task:
-    
-        $ cap deploy:setup
-    
-    This will initialize a git repository in the target directory, install the push hook and push the branch you specified to the server.
+Initial setup
+-------------
 
-4.  Login to your server to perform necessary one-time administrative operations. This might include:
-    * set up the Apache/nginx virtual host for this application;
-    * check out the branch which you will push production code into (often this is "production");
-    * check your config/database.yml and create or import the production database.
+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.
 
-Deployment
-----------
+2.  Run the setup task:
 
-After you've set everything up, visiting "http://example.com" in your browser should show your app up and running. Subsequent deployments are done simply by pushing to the branch that is currently checked out on our server (see step 4.). The branch is by default "master", but it's suggested to have production code in another branch like "production" or other. This, of course, depends on your git workflow.
+    ```sh
+    git deploy setup -r "production"
+    ```
 
-We've reached our goal; our deployment now looks like:
+    This will initialize the remote git repository in the deploy directory
+    (`/apps/mynewapp` in the above example) and install the remote git hook.
 
-    $ git push origin production
+3.  Run the init task:
 
-In fact, running "cap deploy" does exactly this. So what does it do?
+    ```sh
+    git deploy init
+    ```
 
-The "deploy:setup" task installed a couple of hooks in the remote git repository: "post-receive" and "post-reset". The former is a git hook which is invoked after every push to your server, while the latter is a *custom* hook that's called asynchronously by "post-receive" when we updated the deployment branch. This is how your working copy on the server is kept up-to-date.
+    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.
 
-Thus, on first push your server automatically:
+4.  Push the code.
 
-1. creates the "log" and "tmp" directories;
-2. copies "config/database.example.yml" or "config/database.yml.example" to "config/database.yml".
+    ```sh
+    git push production master
+    ```
 
-On every subsequent deploy, the "post-reset" script analyzes changes and:
+3.  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.
 
-1. clears cached css and javascript assets if any versioned files under "public/stylesheets" and "public/javascripts" have changed, respectively;
-2. runs "rake db:migrate" if new migrations have been added;
-3. sync submodule urls if ".gitmodules" file has changed;
-4. initialize and update submodules;
-5. touches "tmp/restart.txt" if app restart is needed.
 
-Finally, these are the conditions that dictate an app restart:
+Everyday deployments
+--------------------
 
-1. css/javascript assets have been cleared;
-2. the database has migrated;
-3. one or more files/submodules under "app", "config", "lib", "public", or "vendor" changed.
+If you've set your app correctly, visiting <http://example.com> in your browser
+should show it up and running.
 
-The output of "post-reset" is logged to "log/deploy.log" in your application.
+Now, subsequent deployments are done simply **by pushing to the branch that is
+currently checked out on the remote**:
 
-It's worth remembering that "post-reset" is done asynchronously from your push operation. This is because migrating the database and updating submodules might take a long time and we don't want to wait for all that while we're doing a git push. But, this means that when the push is done, the server has not yet restarted. You might need to wait a few seconds or a minute, depending on what you pushed.
+    git push production master
 
+Because the deployments are performed with git, nobody else on the team needs to
+install the "git-deploy" gem.
 
-In the future
--------------
+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/after_push` - on subsequent pushes. It in turn executes:
+  * `deploy/before_restart`
+  * `deploy/restart`
+  * `deploy/after_restart`
 
-Next steps for this library are:
+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.
 
-* Support for deployment on multiple hosts. This is a slightly different strategy based on git pull instead of push; something in-between regular "remote cache" strategy and the aforementioned
-* Better configurability
-* Steps forward to supporting more existing 3rd-party Capistrano tasks, like that of the EngineYard gem
-* Support for multiple environments on the same server (production, staging, continuous integration, etc.) sharing the same git repo, so you don't have to push same objects twice
-* Automatic submodule conflict resolving
+It's worth remembering that "after_push" is done **asynchronously from your git push**. This is because migrating the database and updating submodules might take a long time and you don't want to wait for all that during a git push. But, this means that when the push is done, the server has *not yet restarted*. You might need to wait a few seconds or a minute.
 
 
-[heroku]: http://heroku.com/
+  [heroku]: http://heroku.com/

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,83 @@
+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_delegator :remote_url, :path, :deploy_to
+
+    def remote_user
+      @user ||= begin
+        user = remote_url.user
+        user ? CGI.unescape(user) : `whoami`.chomp
+      end
+    end
+
+    def branch
+      'master'
+    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(/\(.+?\)$/, '') }
+    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,99 @@
+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)
+      cmd = yield(cmd) if block_given?
+      cmd = cmd.join(' && ') if Array === cmd
+      puts "[#{options[:remote]}] $ " + cmd.gsub(' && ', " && \\\n  ")
+
+      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)
+        at_exit { ssh.close }
+        ssh
+      end
+    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,39 @@
+#!/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 = []
+
+  num_migrations = `git diff #{oldrev} #{newrev} --diff-filter=A --name-only -z db/migrate`.split("\0").size
+  # 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

@@ -1,121 +1,85 @@
-require 'capistrano/recipes/deploy/scm/git'
+require 'thor'
+require 'net/ssh'
+require 'net/scp'
 
-Capistrano::Configuration.instance(true).load do
-  def _cset(name, *args, &block)
-    unless exists?(name)
-      set(name, *args, &block)
-    end
-  end
-
-  _cset(:application) { abort "Please specify the name of your application, set :application, 'foo'" }
-  _cset :remote, "origin"
-  _cset :branch, "master"
+class GitDeploy < Thor
+  LOCAL_DIR = File.expand_path('..', __FILE__)
 
-  _cset(:multiple_hosts) { roles.values.map{ |v| v.servers}.flatten.uniq.size > 1 }
-  _cset(:repository)  { `#{ source.local.scm('config', "remote.#{remote}.url") }`.chomp }
-  _cset(:remote_host) { repository.split(':', 2).first }
-  _cset(:deploy_to)   { repository.split(':', 2).last }
-  _cset(:run_method)  { fetch(:use_sudo, true) ? :sudo : :run }
-  _cset :group_writeable, false
+  require 'git_deploy/configuration'
+  require 'git_deploy/ssh_methods'
+  include Configuration
+  include SSHMethods
 
-  _cset(:current_branch) { File.read('.git/HEAD').chomp.split(' refs/heads/').last }
-  _cset(:revision) { branch }
-  _cset(:source)   { Capistrano::Deploy::SCM::Git.new(self) }
+  class_option :remote, :aliases => '-r', :type => :string, :default => 'origin'
+  class_option :noop, :aliases => '-n', :type => :boolean, :default => false
 
-  # If :run_method is :sudo (or :use_sudo is true), this executes the given command
-  # via +sudo+. Otherwise is uses +run+. If :as is given as a key, it will be
-  # passed as the user to sudo as, if using sudo. If the :as key is not given,
-  # it will default to whatever the value of the :admin_runner variable is,
-  # which (by default) is unset.
-  def try_sudo(*args)
-    options = args.last.is_a?(Hash) ? args.pop : {}
-    command = args.shift
-    raise ArgumentError, "too many arguments" if args.any?
-
-    as = options.fetch(:as, fetch(:admin_runner, nil))
-    
-    if command
-      invoke_command(command, :via => run_method, :as => as)
-    elsif :sudo == run_method
-      sudo(:as => as)
-    else
-      ""
-    end
+  desc "init", "Generates deployment customization scripts for your app"
+  def init
+    require 'git_deploy/generator'
+    Generator::start([])
   end
 
-  namespace :deploy do
-    desc "Deploys your project."
-    task :default do
-      unless multiple_hosts
-        push
-      else
-        code
-        command = ["cd #{deploy_to}"]
-        command << ".git/hooks/post-reset `cat .git/ORIG_HEAD` HEAD 2>&1 | tee -a log/deploy.log"
-        
-        run command.join(' && ')
-      end
-    end
-
-    task :push do
-      system source.local.scm('push', remote, "#{revision}:#{branch}")
-    end
+  desc "setup", "Create the remote git repository and install push hooks for it"
+  method_option :shared, :aliases => '-g', :type => :boolean, :default => true
+  method_option :sudo, :aliases => '-s', :type => :boolean, :default => true
+  def setup
+    sudo = options.sudo? ? "#{sudo_cmd} " : ''
 
-    task :code do
-      command = ["cd #{deploy_to}"]
-      command << source.scm('fetch', remote, "+refs/heads/#{branch}:refs/remotes/origin/#{branch}")
-      command << source.scm('reset', '--hard', "origin/#{branch}")
-      
-      run command.join(' && ')
+    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
 
-    desc "Prepares servers for deployment."
-    task :setup do
-      shared = fetch(:group_writeable)
-      
-      command = ["#{try_sudo} mkdir -p #{deploy_to}"]
-      command << "#{try_sudo} chown $USER #{deploy_to}" if :sudo == run_method
-      command << "chmod g+ws #{deploy_to}" if shared
-      command << "cd #{deploy_to}"
-      command << "git init #{shared ? '--shared' : ''}"
-      command << "sed -i'' -e 's/master/#{branch}/' .git/HEAD" unless branch == 'master'
-      command << "git config --bool receive.denyNonFastForwards false" if shared
-      command << "git config receive.denyCurrentBranch ignore"
-      run command.join(' && ')
-      
-      install_hooks
-      push
+    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
 
-    task :install_hooks do
-      dir = File.dirname(__FILE__) + '/hooks'
-      remote_dir = "#{deploy_to}/.git/hooks"
+    invoke :hooks
+  end
 
-      top.upload "#{dir}/post-receive.rb", "#{remote_dir}/post-receive"
-      top.upload "#{dir}/post-reset.rb", "#{remote_dir}/post-reset"
-      run "chmod +x #{remote_dir}/post-receive #{remote_dir}/post-reset"
-    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"
 
-    desc "Restarts your Passenger application."
-    task :restart, :roles => :app do
-      run "touch #{deploy_to}/tmp/restart.txt"
-    end
+    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 <<-DESC
-      Copy files to the currently deployed version. Use a comma-separated \
-      list in FILES to specify which files to upload.
+  desc "rollback", "Rolls back the checkout to before the last push"
+  def rollback
+    run "cd #{deploy_to} && git reset --hard ORIG_HEAD"
+    invoke :restart
+  end
 
-      Note that unversioned files on your server are likely to be \
-      overwritten by the next push. Always persist your changes by committing.
+  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
 
-        $ cap deploy:upload FILES=templates,controller.rb
-        $ cap deploy:upload FILES='config/apache/*.conf'
-    DESC
-    task :upload do
-      files = (ENV["FILES"] || "").split(",").map { |f| Dir[f.strip] }.flatten
-      abort "Please specify at least one file or directory to update (via the FILES environment variable)" if files.empty?
+  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?
 
-      files.each { |file| top.upload(file, File.join(deploy_to, file)) }
-    end
+    scp_upload files.inject({}) { |all, file|
+      all[file] = File.join(deploy_to, file)
+      all
+    }
   end
-end
+end

data/lib/hooks/post-receive.sh

@@ -0,0 +1,52 @@
+#!/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
+else
+  # log timestamp
+  echo ==== $(date) ==== >> $logfile
+
+  # execute the deploy hook in background
+  [ -x deploy/after_push ] && (nohup deploy/after_push $oldrev $newrev 1>>$logfile 2>>$logfile &)
+fi

data/spec/configuration_spec.rb

@@ -0,0 +1,48 @@
+require 'rspec/autorun'
+require 'git_deploy/configuration'
+
+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 "extracting user/host from remote url" do
+    context "ssh url" do
+      before { stub_remote_url 'ssh://jon%20doe@example.com:88/path/to/app' }
+
+      its(:host)        { should eq('example.com') }
+      its(:remote_port) { should eq(88) }
+      its(:remote_user) { should eq('jon doe') }
+      its(:deploy_to)   { should eq('/path/to/app') }
+    end
+
+    context "scp-style" do
+      before { stub_remote_url 'git@example.com:/path/to/app' }
+
+      its(:host)        { should eq('example.com') }
+      its(:remote_port) { should be_nil }
+      its(:remote_user) { should eq('git') }
+      its(:deploy_to)   { should eq('/path/to/app') }
+    end
+  end
+
+end

metadata

@@ -1,86 +1,107 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: git-deploy
-version: !ruby/object:Gem::Version 
-  hash: 13
-  prerelease: false
-  segments: 
-  - 0
-  - 4
-  - 1
-  version: 0.4.1
+version: !ruby/object:Gem::Version
+  prerelease: 
+  version: 0.5.5
 platform: ruby
-authors: 
-- "Mislav Marohni\xC4\x87"
+authors:
+- Mislav Marohnić
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2010-10-08 00:00:00 +02:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: capistrano
+date: 2013-07-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.14.6
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.14.6
+- !ruby/object:Gem::Dependency
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 9
-        segments: 
-        - 2
-        - 5
-        - 9
-        version: 2.5.9
+      - !ruby/object:Gem::Version
+        version: 2.6.6
+  name: net-ssh
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.6.6
+- !ruby/object:Gem::Dependency
+  prerelease: false
   type: :runtime
-  version_requirements: *id001
-description: A tool to install useful git hooks on your remote repository to enable push-based, Heroku-like deployment on your host.
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  name: net-scp
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+description: A tool to install useful git hooks on your remote repository to enable
+  push-based, Heroku-like deployment on your host.
 email: mislav.marohnic@gmail.com
-executables: []
-
+executables:
+- git-deploy
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
+- bin/git-deploy
+- 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/git_deploy.rb
-- lib/hooks/post-receive.rb
-- lib/hooks/post-reset.rb
+- lib/hooks/post-receive.sh
+- spec/configuration_spec.rb
 - README.markdown
 - LICENSE
-has_rdoc: false
-homepage: http://github.com/mislav/git-deploy
-licenses: []
-
+homepage: https://github.com/mislav/git-deploy
+licenses:
+- MIT
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Simple git push-based application deployment
 test_files: []
-

data/lib/hooks/post-receive.rb

@@ -1,57 +0,0 @@
-#!/usr/bin/env ruby
-if ENV['GIT_DIR'] == '.'
-  # this means the script has been called as a hook, not manually.
-  # get the proper GIT_DIR so we can descend into the working copy dir;
-  # if we don't then `git reset --hard` doesn't affect the working tree.
-  Dir.chdir('..')
-  ENV['GIT_DIR'] = '.git'
-end
-
-cmd = %(bash -c "[ -f /etc/profile ] && source /etc/profile; echo $PATH")
-envpath = IO.popen(cmd, 'r') { |io| io.read.chomp }
-ENV['PATH'] = envpath
-
-# find out the current branch
-head = `git symbolic-ref HEAD`.chomp
-# abort if we're on a detached head
-exit unless $?.success?
-
-oldrev = newrev = nil
-null_ref = '0' * 40
-
-# read the STDIN to detect if this push changed the current branch
-while newrev.nil? and gets
-  # each line of input is in form of "<oldrev> <newrev> <refname>"
-  revs = $_.split
-  oldrev, newrev = revs if head == revs.pop
-end
-
-# abort if there's no update, or in case the branch is deleted
-exit if newrev.nil? or newrev == null_ref
-
-# update the working copy
-`umask 002 && git reset --hard`
-
-config = 'config/database.yml'
-logfile = 'log/deploy.log'
-restart = 'tmp/restart.txt'
-
-if oldrev == null_ref
-  # this is the first push; this branch was just created
-  require 'fileutils'
-  FileUtils.mkdir_p %w(log tmp)
-  FileUtils.chmod 0775, %w(log tmp)
-  FileUtils.touch [logfile, restart]
-  FileUtils.chmod 0664, [logfile, restart]
-  
-  unless File.exists?(config)
-    # install the database config from the example file
-    example = ['config/database.example.yml', config + '.example'].find { |f| File.exists? f }
-    FileUtils.cp example, config if example
-  end
-else
-  # log timestamp
-  File.open(logfile, 'a') { |log| log.puts "==== #{Time.now} ====" }
-  # start the post-reset hook in background
-  system %(nohup .git/hooks/post-reset #{oldrev} #{newrev} 1>>#{logfile} 2>>#{logfile} &)
-end

data/lib/hooks/post-reset.rb

@@ -1,116 +0,0 @@
-#!/usr/bin/env ruby
-RAILS_ENV = 'production'
-oldrev, newrev = ARGV
-$stdout.sync = true
-
-def parse_configuration(file)
-  config = {}
-  current = nil
-
-  File.open(file).each_line do |line|
-    case line
-    when /^\[(\w+)(?: "(.+)")\]/
-      key, subkey = $1, $2
-      current = (config[key] ||= {})
-      current = (current[subkey] ||= {}) if subkey
-    else
-      key, value = line.strip.split(' = ')
-      current[key] = value
-    end
-  end
-  
-  config
-end
-
-class Array
-  # scans the list of files to see if any of them are under the given path
-  def any_in_dir?(dir)
-    if Array === dir
-      exp = %r{^(?:#{dir.join('|')})/}
-      any? { |file| file =~ exp }
-    else
-      dir += '/'
-      any? { |file| file.index(dir) == 0 }
-    end
-  end
-end
-
-# get a list of files that changed
-changes = `git diff #{oldrev} #{newrev} --diff-filter=ACDMR --name-status`.split("\n")
-
-# make a hash of files that changed and how they changed
-changes_hash = changes.inject(Hash.new { |h, k| h[k] = [] }) do |hash, line|
-  modifier, filename = line.split("\t", 2)
-  hash[modifier] << filename
-  hash
-end
-
-# create an array of files added, copied, modified or renamed
-modified_files = %w(A C M R).inject([]) { |files, bit| files.concat changes_hash[bit] }
-added_files = changes_hash['A'] # added
-deleted_files = changes_hash['D'] # deleted
-changed_files = modified_files + deleted_files # all
-puts "files changed: #{changed_files.size}"
-
-cached_assets_cleared = false
-
-# detect modified asset dirs
-asset_dirs = %w(public/stylesheets public/javascripts).select do |dir|
-  # did any on the assets under this dir change?
-  changed_files.any_in_dir?(dir)
-end
-
-unless asset_dirs.empty?
-  # clear cached assets (unversioned/ignored files)
-  system %(git clean -x -f -- #{asset_dirs.join(' ')})
-  cached_assets_cleared = true
-end
-
-if changed_files.include?('Gemfile') || changed_files.include?('Gemfile.lock')
-  # update bundled gems if manifest file has changed
-  system %(umask 002 && bundle install --deployment)
-end
-
-# run migrations when new ones added
-if new_migrations = added_files.any_in_dir?('db/migrate')
-  system %(umask 002 && rake db:migrate RAILS_ENV=#{RAILS_ENV})
-end
-
-if modified_files.include?('.gitmodules')
-  # initialize new submodules
-  system %(umask 002 && git submodule init)
-  # sync submodule remote urls in case of changes
-  config = parse_configuration('.gitmodules')
-
-  if config['submodule']
-    config['submodule'].values.each do |submodule|
-      path = submodule['path']
-      subconf = "#{path}/.git/config"
-
-      if File.exists? subconf
-        old_url = `git config -f "#{subconf}" remote.origin.url`.chomp
-        new_url = submodule['url']
-        unless old_url == new_url
-          puts "changing #{path.inspect} URL:\n  #{old_url.inspect} → #{new_url.inspect}"
-          `git config -f "#{subconf}" remote.origin.url "#{new_url}"`
-        end
-      else
-        $stderr.puts "a submodule in #{path.inspect} doesn't exist"
-      end
-    end
-  end
-end
-# update existing submodules
-system %(umask 002 && git submodule update)
-
-# clean unversioned files from vendor (e.g. old submodules)
-system %(git clean -d -f vendor)
-
-# determine if app restart is needed
-if cached_assets_cleared or new_migrations or !File.exists?('config/environment.rb') or
-    changed_files.any_in_dir?(%w(app config lib public vendor))
-  require 'fileutils'
-  # tell Passenger to restart this app
-  FileUtils.touch 'tmp/restart.txt'
-  puts "restarting Passenger app"
-end