git-deployer 0.0.1

data/README.textile

@@ -0,0 +1,78 @@
+h1. About
+
+This is simple and flexible deployment solution based on Git post-receive hook.
+
+* You don't have to install anything on your server
+* It works with whichever thinkable solution, Rails, Merb, "Rango":http://github.com/botanicus/rango, Sinatra or even Django or static pages, it just doesn't matter!
+* Deployment to more servers is supported.
+
+h1. Usage
+
+* Run @gem install git-deployer --development@
+* Add following lines to your file with "Nake":http://github.com/botanicus/nake tasks (I'll refer this file as @tasks.rb@):
+
+<pre>
+begin
+  load "git-deployer.nake"
+  Task["deployer:setup"].config[:servers] = {
+    server1: {
+      user: "www",
+      host: "127.0.0.1",
+      repo: "/var/sources/deploy-test.git",
+      path: "/var/www/deploy-test"
+    }
+  }
+rescue LoadError
+  warn "You have to install git-deployer gem if you want to deploy to remote servers!"
+end
+</pre>
+
+* Install hooks via @./tasks.rb deployer:install@
+* Edit @hooks/clone@ and @hooks/update@
+* Install @post-receive@ hook and create necessary directories via @./tasks.rb deployer:install@
+* Push your changes via @git push origin master@
+
+That's it. When you run @git push origin master@ for the first time, it should found that given branch isn't cloned yet, so it should
+
+h1. Available tasks
+
+h3. Task @deployer:install@
+
+This task will copy @hooks/clone@ and @hooks/update@ hooks to your project. This step is mandatory.
+
+h3. Task @deployer:setup@
+
+It can take one or more optional arguments with
+It takes the same arguments resp. configuration options as @deployer:compile_hook@ task
+
+h3. Task @deployer:compile_hook@
+
+This task will copy @hooks/post-receive@ hook to your project. This step is optional and you will use the task you in case that you aren't happy with the default @post-receive@ hook distributed with git-deployer and you want to customize things. But you shouldn't need this, there is a bunch of arguments which you can use for influencing the generated @post-receive@ hook.
+
+h3. Task @deployer:remote:copy_hook@
+
+Again, you typically don't need this task, because it run during @deployer:setup@. However if you changed something in the @post-receive@ hook, you might want to run this task which will install @post-receive@ on remote servers. By default the hook will be installed to all the servers, but you can specify just a subset via @./tasks.rb deployer:remote:copy_hook server1 server2@.
+
+h4. Setup
+
+h2. Restricting Just for @deploy@ Branch
+
+You might not want to deploy every branch you push to origin.
+
+h3. Task @deployer:run@
+
+If you pushed to the remote server but the hook failed, this is the way how you can re-run it. Just fix the problem and run @./tasks.rb deployer:run@. By default it runs on all the servers, but you can run it just on some servers via @./tasks.rb deployer:run server1 server2@.
+
+h3. Task @deploy@
+
+This task is useful for deployment to *multiple servers*. Just run @git push server1 master && git push server1 master@ or @./tasks.rb deploy@ which is a shortcut for pushing current branch to all or specified remote servers.
+
+h1. FAQ
+
+*Q:* _I had typo in my hooks, so it failed during deploy, how can I rerun it?_
+
+*A:* @./tasks.rb deployer:run@ with optional argument which
+
+*Q:* _You are using "Nake":http://github.com/botanicus/nake, but everyone's using Rake. Is there any chance that you will support Rake in future?_
+
+*A:* The trouble with Rake is that Rake doesn't support configuration and it also really suck in command-line parsing. If Rake will support at least the command line arguments in a reasonable way, I can think about it.

data/example/README.textile

@@ -0,0 +1,14 @@
+h1. About
+
+This is a "git-deployer":http://github.com/botanicus/git-deployer demo.
+
+h1. Usage
+
+# Copy this directory out of the git-deployer repository.
+# Edit connection details in @tasks.rb@.
+# Ensure you have "Nake":http://github.com/botanicus/nake task manager installed.
+# Run @./tasks.rb deployer:setup@
+# Run @git init && git add . && git commit -a -m "Initial import"@ and then @git remote add@ with the URL of remote repository.
+# Run @git push origin master@ and see what's going on.
+
+Of course if you want to see something real, you have to point your web server to this repository, probably via vhost.

data/example/hooks/clone

@@ -0,0 +1,31 @@
+# === Documentation === #
+# This is just a standard shell script, which is loaded from the
+# post-receive hook when a new branch is created.
+
+# Just don't forget that gems you have on your local machine probably
+# aren't installed at the server, at least before you run gem bundle.
+
+# Your working directory is root of your application which was just cloned
+# here. (Probably) unlike to your local machine, basename is name of the branch,
+# not name of the application. It shouldn't matter in most cases, but sometimes
+# it does, for example in Python where you are using import myapp.something.
+# 1) Write an awful perl-ish script with sed -i / perl -i / ruby -i and just replace
+#    the name in your code. It might work, but come on, you don't want to do that.
+# 2) Your application will be as a subdirectory of the root of the repository,
+#    so you may call it whatever you want.
+# 3) Obviously the best solution is to change the post-receive script, for example:
+#    Task["deployer:compile_hook"].config[:target] = "myappname"
+
+# Make sure this script isn't executable, otherwise the script will simply run,
+# so you won't have access to shell functions from the post-receive hook.
+# However this is useful if you want to run this script under another interpret.
+# If you want to install hooks which will be executed rather than just
+# loaded, use ./tasks.rb deployer:install --executable or add
+# Task["deployer:install"].config[:executable] = false to your tasks.rb
+
+# Also, post-receive hook run under /bin/sh by default, but you might want to
+# use something more advance like bash or zsh. Since these shells are compatible
+# with the original sh, it's easy, just run ./tasks.rb deployer:compile_hook --shebang="#!/bin/zsh"
+# or add Task["deployer:compile_hook"].config[:shebang] = "#!/bin/zsh" to your tasks.rb and reinstall the hooks.
+
+. "hooks/update"

data/example/hooks/update

@@ -0,0 +1,24 @@
+# === Documentation === #
+# This is just a standard shell script, which is loaded from the
+# post-receive hook each time a branch is updated.
+
+# Just don't forget that gems you have on your local machine probably
+# aren't installed at the server, at least before you run gem bundle.
+
+# Your working directory is root of your application which was just cloned
+# here. (Probably) unlike to your local machine, basename is name of the branch,
+# not name of the application. It shouldn't matter in most cases, but sometimes
+# it does, for example in Python where you are using import myapp.something.
+# 1) Write an awful perl-ish script with sed -i / perl -i / ruby -i and just replace
+#    the name in your code. It might work, but come on, you don't want to do that.
+# 2) Your application will be as a subdirectory of the root of the repository,
+#    so you may call it whatever you want.
+# 3) Obviously the best solution is to change the post-receive script, for example:
+#    Task["deployer:compile_hook"].config[:target] = "myappname"
+
+# Make sure this script isn't executable, otherwise the script will simply run,
+# so you won't have access to shell functions from the post-receive hook.
+# However this is useful if you want to run this script under another interpret.
+# If you want to install hooks which will be executed rather than just
+# loaded, use ./tasks.rb deployer:install --executable or add
+# Task["deployer:install"].config[:executable] = false to your tasks.rb

data/example/tasks.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/env nake
+
+# TODO: rewrite the example to Rango, it would be more interesting
+# Or maybe add more examples for jekyll, nanoc, Django, maybe Rails.
+$:.unshift(File.join(File.dirname(__FILE__), "..", "tasks"))
+
+load "git-deployer.nake"
+
+Task["deployer:setup"].config[:user] = "TODO"
+Task["deployer:setup"].config[:host] = "TODO"
+Task["deployer:setup"].config[:path] = "/var/www/deploy-test"
+

data/example/www/index.html

@@ -0,0 +1,15 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+  "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+  <head>
+    <meta http-equiv="Content-type" content="text/html; charset=utf-8">
+    <title>Hello World!</title>
+  </head>
+
+  <body>
+    <h1>Hello World!</h1>
+    <p>
+      This is an example page for <a href="http://github.com/botanicus/git-deployer">git-deployer</a>.
+    </p>
+  </body>
+</html>

data/git-deployer.gemspec

@@ -0,0 +1,24 @@
+#!/usr/bin/env gem build
+# encoding: utf-8
+
+Gem::Specification.new do |s|
+  s.name = "git-deployer"
+  s.version = "0.0.1"
+  s.authors = ["Jakub Šťastný aka Botanicus"]
+  s.homepage = "http://github.com/botanicus/git-deployer"
+  s.summary = "Easy deploy system based on Git hooks"
+  s.description = "" # TODO: long description
+  s.cert_chain = nil
+  s.email = ["knava.bestvinensis", "gmail.com"].join("@")
+  s.has_rdoc = false
+
+  # files
+  s.files = Dir.glob("**/*") - Dir.glob("*.gem")
+  s.require_paths = ["tasks"]
+
+  # dependencies
+  s.add_development_dependency "nake"
+
+  # RubyForge
+  s.rubyforge_project = "git-deployer"
+end

data/hooks/project/clone.exec.erb

@@ -0,0 +1,53 @@
+<%= options[:shebang] %>
+
+# === Documentation === #
+# This hook run when a new branch is pushed. It's just a standard
+# executable script, feel free to use ruby, python, shell or whatever.
+
+# Just don't forget that gems you have on your local machine probably
+# aren't installed at the server, at least before you run gem bundle.
+
+# Your working directory is root of your application which was just cloned
+# here. (Probably) unlike to your local machine, basename is name of the branch,
+# not name of the application. It shouldn't matter in most cases, but sometimes
+# it does, for example in Python where you are using import myapp.something.
+# 1) Write an awful perl-ish script with sed -i / perl -i / ruby -i and just replace
+#    the name in your code. It might work, but come on, you don't want to do that.
+# 2) Your application will be as a subdirectory of the root of the repository,
+#    so you may call it whatever you want.
+# 3) Obviously the best solution is to change the post-receive script, for example:
+#    Task["deployer:compile_hook"].config[:target] = "myappname"
+
+# Make sure this script is executable, otherwise the script will be just
+# loaded from post-receive hook, which means your shebang will be ignored.
+# However this is useful when you want to use functions defined in the hook.
+# If you want to install hooks which will be loaded rather than just
+# executed, use ./tasks.rb deployer:install --no-executable or add
+# Task["deployer:install"].config[:executable] = false to your tasks.rb
+
+# Ruby on Rails
+export RAILS_ENV="stagging" # if you are deploying to more servers, you might want to setup this in your /etc/profile
+echo "Please edit config/database.yml and rerun this hook via ./tasks.rb deployer:run if you need so"
+test -f config/database.yml.sample && cp config/database.yml.sample config/database.yml
+rake db:create
+exec "hooks/update"
+
+# Rango
+export RACK_ENV="stagging" # if you are deploying to more servers, you might want to setup this in your /etc/profile
+echo "Please edit environments.rb and rerun this hook via ./tasks.rb deployer:run if you need so"
+test -f environments_sample.rb && cp environments_sample.rb environments.rb
+exec "hooks/update"
+
+# Django
+echo "Please edit settings_local.py and rerun this hook via ./tasks.rb deployer:run if you need so"
+test -f settings_local_sample.py && cp settings_local_sample.py settings_local.py
+
+# === Hints === #
+# If each branch means a subdomain, you can generate vhosts in this
+# hook. If you do so, then don't forget to restart your server!
+# git push origin alpha  => alpha.example.com
+# git push origin beta   => beta.example.com
+# git push origin master => example.com
+
+echo "Don't forget to edit hooks/clone\!"
+exit 1

data/hooks/project/clone.source.erb

@@ -0,0 +1,55 @@
+# === Documentation === #
+# This is just a standard shell script, which is loaded from the
+# post-receive hook when a new branch is created.
+
+# Just don't forget that gems you have on your local machine probably
+# aren't installed at the server, at least before you run gem bundle.
+
+# Your working directory is root of your application which was just cloned
+# here. (Probably) unlike to your local machine, basename is name of the branch,
+# not name of the application. It shouldn't matter in most cases, but sometimes
+# it does, for example in Python where you are using import myapp.something.
+# 1) Write an awful perl-ish script with sed -i / perl -i / ruby -i and just replace
+#    the name in your code. It might work, but come on, you don't want to do that.
+# 2) Your application will be as a subdirectory of the root of the repository,
+#    so you may call it whatever you want.
+# 3) Obviously the best solution is to change the post-receive script, for example:
+#    Task["deployer:compile_hook"].config[:target] = "myappname"
+
+# Make sure this script isn't executable, otherwise the script will simply run,
+# so you won't have access to shell functions from the post-receive hook.
+# However this is useful if you want to run this script under another interpret.
+# If you want to install hooks which will be executed rather than just
+# loaded, use ./tasks.rb deployer:install --executable or add
+# Task["deployer:install"].config[:executable] = false to your tasks.rb
+
+# Also, post-receive hook run under /bin/sh by default, but you might want to
+# use something more advance like bash or zsh. Since these shells are compatible
+# with the original sh, it's easy, just run ./tasks.rb deployer:compile_hook --shebang="#!/bin/zsh"
+# or add Task["deployer:compile_hook"].config[:shebang] = "#!/bin/zsh" to your tasks.rb and reinstall the hooks.
+
+# Ruby on Rails
+export RAILS_ENV="stagging" # if you are deploying to more servers, you might want to setup this in your /etc/profile
+info "Please edit config/database.yml and rerun this hook via ./tasks.rb deployer:run if you need so"
+test -f config/database.yml.sample && cp config/database.yml.sample config/database.yml
+rake db:create
+. "hooks/update"
+
+# Rango
+export RACK_ENV="stagging" # if you are deploying to more servers, you might want to setup this in your /etc/profile
+info "Please edit environments.rb and rerun this hook via ./tasks.rb deployer:run if you need so"
+test -f environments_sample.rb && cp environments_sample.rb environments.rb
+. "hooks/update"
+
+# Django
+info "Please edit settings_local.py and rerun this hook via ./tasks.rb deployer:run if you need so"
+test -f settings_local_sample.py && cp settings_local_sample.py settings_local.py
+
+# === Hints === #
+# If each branch means a subdomain, you can generate vhosts in this
+# hook. If you do so, then don't forget to restart your server!
+# git push origin alpha  => alpha.example.com
+# git push origin beta   => beta.example.com
+# git push origin master => example.com
+
+abort "Don't forget to edit hooks/clone\!"

data/hooks/project/update.exec.erb

@@ -0,0 +1,64 @@
+<%= options[:shebang] %>
+
+# === Documentation === #
+# This hooks run each time the branch is updated. If a new branch is created,
+# than the clone hook runs first. It's just a standard executable script, feel
+# free to use ruby, python, shell or whatever.
+
+# Just don't forget that gems you have on your local machine probably
+# aren't installed at the server, at least before you run gem bundle.
+
+# Your working directory is root of your application which was just cloned
+# here. (Probably) unlike to your local machine, basename is name of the branch,
+# not name of the application. It shouldn't matter in most cases, but sometimes
+# it does, for example in Python where you are using import myapp.something.
+# 1) Write an awful perl-ish script with sed -i / perl -i / ruby -i and just replace
+#    the name in your code. It might work, but come on, you don't want to do that.
+# 2) Your application will be as a subdirectory of the root of the repository,
+#    so you may call it whatever you want.
+# 3) Obviously the best solution is to change the post-receive script, for example:
+#    Task["deployer:compile_hook"].config[:target] = "myappname"
+
+# Make sure this script is executable, otherwise the script will be just
+# loaded from post-receive hook, which means your shebang will be ignored.
+# However this is useful when you want to use functions defined in the hook.
+# If you want to install hooks which will be loaded rather than just
+# executed, use ./tasks.rb deployer:install --no-executable or add
+# Task["deployer:install"].config[:executable] = false to your tasks.rb
+
+# === Setup === #
+# If we have everything bundled in bin, we have to put bin to the beginning of the PATH
+# variable, so all commands like rake etc will be loaded from bin, if they are in there
+export PATH="bin:$PATH" # TODO: maybe you are using script directory instead of bin?
+
+# Ruby on Rails
+export RAILS_ENV="stagging" # if you are deploying to more servers, you might want to setup this in your /etc/profile
+gem bundle --cached # this requires bundler installed on your server
+rake db:migrate
+#rake db:seed
+
+# Rango
+export RACK_ENV="stagging" # if you are deploying to more servers, you might want to setup this in your /etc/profile
+gem bundle --cached
+./tasks.rb db:autoupgrade
+#./tasks.rb db:seed
+
+# Django
+# load data from fixtures
+echo "Running syncdb ..."
+python "manage.py syncdb --noinput"
+
+# Jekyll
+# point your vhost to the _site directory
+jekyll --pygments
+
+# Nanoc
+# point your vhost to the output directory
+nanoc3 compile
+
+# Restart passenger application
+echo "Restarting Passenger ..."
+touch tmp/restart.txt
+
+echo "Don't forget to edit hooks/update\!"
+exit 1

data/hooks/project/update.source.erb

@@ -0,0 +1,60 @@
+# === Documentation === #
+# This is just a standard shell script, which is loaded from the
+# post-receive hook each time a branch is updated.
+
+# Just don't forget that gems you have on your local machine probably
+# aren't installed at the server, at least before you run gem bundle.
+
+# Your working directory is root of your application which was just cloned
+# here. (Probably) unlike to your local machine, basename is name of the branch,
+# not name of the application. It shouldn't matter in most cases, but sometimes
+# it does, for example in Python where you are using import myapp.something.
+# 1) Write an awful perl-ish script with sed -i / perl -i / ruby -i and just replace
+#    the name in your code. It might work, but come on, you don't want to do that.
+# 2) Your application will be as a subdirectory of the root of the repository,
+#    so you may call it whatever you want.
+# 3) Obviously the best solution is to change the post-receive script, for example:
+#    Task["deployer:compile_hook"].config[:target] = "myappname"
+
+# Make sure this script isn't executable, otherwise the script will simply run,
+# so you won't have access to shell functions from the post-receive hook.
+# However this is useful if you want to run this script under another interpret.
+# If you want to install hooks which will be executed rather than just
+# loaded, use ./tasks.rb deployer:install --executable or add
+# Task["deployer:install"].config[:executable] = false to your tasks.rb
+
+# === Setup === #
+# If we have everything bundled in bin, we have to put bin to the beginning of the PATH
+# variable, so all commands like rake etc will be loaded from bin, if they are in there
+export PATH="bin:$PATH" # TODO: maybe you are using script directory instead of bin?
+
+# Ruby on Rails
+export RAILS_ENV="stagging" # if you are deploying to more servers, you might want to setup this in your /etc/profile
+gem bundle --cached # this requires bundler installed on your server
+rake db:migrate
+#rake db:seed
+
+# Rango
+export RACK_ENV="stagging" # if you are deploying to more servers, you might want to setup this in your /etc/profile
+gem bundle --cached
+./tasks.rb db:autoupgrade
+#./tasks.rb db:seed
+
+# Django
+# load data from fixtures
+info "Running syncdb ..."
+python "manage.py syncdb --noinput"
+
+# Jekyll
+# point your vhost to the _site directory
+jekyll --pygments
+
+# Nanoc
+# point your vhost to the output directory
+nanoc3 compile
+
+# Restart passenger application
+info "Restarting Passenger ..."
+touch tmp/restart.txt
+
+abort "Don't forget to edit hooks/update\!"

data/hooks/server/post-receive.erb

@@ -0,0 +1,95 @@
+<%= shebang %>
+
+# This script is SH-compatible, but it doesn't mean you have to use SH.
+# You can use bash or zsh and enjoy features of more powerful shells, just change the shebang!
+
+# POST-RECEIVE HOOK
+# ARGV: empty
+# STDIN: [OLD HEAD] [NEW HEAD] refs/heads/alpha
+
+<% if colors %>
+export TERM="xterm-color"
+
+abort()   { printf "\e[1;31m$*\e[0m\n"; exit 1; }
+success() { printf "\e[1;32m$*\e[0m\n"; }
+info()    { printf "\e[1;34m$*\e[0m\n"; }
+debug()   { $DEBUG && printf "\e[1;33m$*\e[0m\n"; }
+<% else %>
+abort()   { printf "$*\n"; exit 1; }
+success() { printf "$*\n"; }
+info()    { printf "$*\n"; }
+debug()   { $DEBUG && printf "$*\n"; }
+<% end %>
+run()     { info $* ; $*; }
+
+set -- $(cat /dev/stdin)
+
+old=$1 && new=$2 && ref=$3
+export BRANCH=$(basename $ref)
+export DEBUG=<%= debug %>
+export TARGET="<%= File.join(path, target) %>"
+export REPO="<%= repo %>"
+
+<% if branch %>
+# restrict deployment just to given branch
+if [ $BRANCH != <%= branch %> ]
+  info "Branch $BRANCH isn't supposed to be deployable, finishing"
+  exit
+fi
+<% end %>
+
+cd $(dirname $TARGET) # the target might not exist yet
+
+# GIT_DIR is "." which should points to bare repozitory
+GIT_DIR="$REPO"
+
+info "Reading /etc/profile ..."
+. /etc/profile
+
+debug
+debug "=== Environment ==="
+debug "PATH: $PATH"
+debug "USER: $USER"
+debug "TERM: $TERM"
+debug "Ruby version: $(ruby --version)"
+debug "Ruby path: $(which ruby)"
+debug
+debug "=== Git-deployer ==="
+debug "TARGET: $TARGET"
+debug "BRANCH: $BRANCH"
+debug "REPO: $REPO"
+debug "PWD: $PWD"
+debug
+
+if [ -d $TARGET ] ; then
+  cd $TARGET
+  info "Updating $BRANCH in `pwd` ... (from $old' to '$new')"
+  git fetch
+  git reset $new --hard
+else
+  info "Cloning $BRANCH to $(pwd)/$TARGET (HEAD: '$new') ..."
+  git clone $REPO $TARGET
+  cd $TARGET
+  if [ -x "hooks/clone" ] ; then
+    info "[$PWD] Running clone hook"
+    exec "./hooks/clone"
+  elif [ -f "hooks/clone" ] ; then
+    info "[$PWD] Loading clone hook"
+    . "./hooks/clone" # so user can use functions defined in this hook in his clone hook
+    exit $?
+  else
+    abort "No clone hook found!"
+  fi
+fi
+
+# Update hook
+if [ -x "hooks/update" ] ; then
+  info "[$PWD] Running update hook"
+  exec "./hooks/update"
+elif [ -f "hooks/update" ] ; then
+  info "[$PWD] Loading update hook"
+  . "./hooks/update" # so user can use functions defined in this hook in his update hook
+  exit $?
+else
+  abort "No update hook found!"
+fi

data/tasks/git-deployer.nake

@@ -0,0 +1,280 @@
+#!/usr/bin/env nake
+
+# TODO: what about a console support as capistrano has? Would be so helpful! Or at least ./tasks.rb deployer:ssh which starts ssh session for a server and cd to application path.
+# TODO: run a command on all/given servers, like if you forget to create tmp in your clone hook
+
+require "nake/template"
+
+# === Helpers === #
+
+# TODO: put it to nake
+class Nake::Task
+  def run_from_task(task, *args)
+    self.call(*args)
+  rescue SystemExit => exception
+    Kernel.abort "Exception during task #{task}: #{exception.message}. Please re-run the task.\n#{exception.backtrace.join("\n- ")}"
+  rescue Exception => exception
+    abort "Exception during task #{task}: #{exception.message}. Please re-run the task.\n#{exception.backtrace.join("\n- ")}"
+  end
+end
+
+module SshMixin
+  def ssh(server, command)
+    sh "ssh %{user}@%{host} '#{command}'" % server
+  end
+
+  def servers(*names, &block)
+    names.map! { |name| name.to_sym }
+    config = Task["deployer:setup"].config
+
+    if ! config.has_key?(:servers) || config[:servers].empty?
+      abort "You have to configure servers. Read documentation online at http://github.com/botanicus/git-deployer"
+    end
+
+    names = config[:servers].keys if names.empty?
+    names.each do |name|
+      server = config[:servers][name]
+      raise "There isn't any server named #{name}. Please specify one of #{config[:servers].keys} or add #{name} to your configuration." if server.nil?
+
+      [:user, :host, :repo, :path].each do |key|
+        unless server.has_key?(key)
+          abort "Server #{name} doesn't have key #{key}, you have to provide it!"
+        end
+      end
+
+      info "Server #{name} #{server.inspect}"
+      block.call(name, server)
+    end
+  end
+end
+
+# === Tasks === #
+
+# @settings
+#   Task["deployer:install"].config[:executable] = true
+# @options
+#   --[no-]force       Overwrite local hooks. Default is false.
+#   --[no-]executable  Install hooks as executable scripts, so you can use whichever interpret,
+#                      but you can't access to shell functions from post-receive.
+Task.new("deployer:install") do |task|
+  task.description = "Install clone and update hooks to the project."
+
+  # path to the given hook
+  task.define_singleton_method(:path) do |name, options|
+    basename = options[:executable] ? "#{name}.exec.erb" : "#{name}.source.erb"
+    File.join(File.dirname(__FILE__), "..", "hooks", "project", basename)
+  end
+
+  # install given hook from its template
+  task.define_singleton_method(:install) do |source, target, options|
+    mkdir_p File.dirname(target)
+    note "Creating #{target} from #{source}"
+    if ! File.exist?(target) || options[:force]
+      erb source, target, options: options
+      sh "chmod +x #{target}" if options[:executable]
+    else
+      abort "File #{target} already exist. Run this hook with --force to override the file."
+    end
+  end
+
+  task.define do |options|
+    self.install(self.path("clone", options),  "hooks/clone", options)
+    self.install(self.path("update", options), "hooks/update", options)
+  end
+end
+
+# @settings
+#   Task["deployer:setup"].config[:servers] = {
+#     server1: {
+#       user: "www",
+#       host: "127.0.0.1",
+#       repo: "/var/sources/deploy-test.git",
+#       path: "/var/www/deploy-test"
+#     }
+#   }
+# @options
+#   --[no-]force  Overwrite remote repository and application path. Default is false.
+#   Also, this tasks takes the same arguments as deployer:remote:copy_hook.
+# @see Task["deployer:remote:copy_hook"] for configuring generation of the post-receive hook.
+Task.new("deployer:setup") do |task|
+  task.description = "Install Git hooks on remote server"
+  task.extend(SshMixin)
+
+  task.define do |options|
+    servers do |name, server|
+      if options[:force]
+        ssh server, "test -d %{path} && rm -rf %{path}; test -d %{repo} && rm -rf %{repo}"
+      end
+
+      unless ssh server, "test -d %{path}"
+        ssh server, "mkdir -p %{path}" || abort("Creating of some necessary directories failed.")
+      else
+        abort "Path %{path} already exist. Try to run with --force if you want to overwrite it." % server
+      end
+
+      unless ssh server, "test -d %{repo}"
+        ssh server, "mkdir -p %{repo}" || abort("Creating of some necessary directories failed.")
+        ssh server, "cd %{repo} && git init --bare" || abort("There was a problems during attempt to create a bare repository.")
+        sh "git remote add #{name} %{user}@%{host}:%{repo}" % server
+      else
+        abort "Repository %{repo} already exist. Try to run with --force if you want to overwrite it." % server
+      end
+
+      info "Setup at server #{name} finished"
+    end
+
+    # copy post-receive hooks
+    Task["deployer:remote:copy_hook"].run_from_task("deployer:setup", [], options)
+  end
+end
+
+# @options
+#   This tasks takes the same arguments as deployer:compile_hook.
+# @see Task["deployer:compile_hook"] for configuring generation of the post-receive hook.
+Task.new("deployer:remote:copy_hook") do |task|
+  task.description = "Copy Git hook to remote server"
+  task.extend(SshMixin)
+
+  # TODO: change gemspec to require Ruby 1.9
+  task.define_singleton_method(:template) do |path|
+    path.end_with?(".erb") ? path : compile_template(path)
+  end
+
+  # Template precedence:
+  #   1) hooks/post-receive.server_name
+  #   2) hooks/post-receive.server_name.erb
+  #   3) hooks/post-receive
+  #   3) hooks/post-receive.erb
+  #   5) the default template distributed with git-deployer
+  task.define_singleton_method(:find_template) do |name|
+    ["hooks/post-receive.#{name}", "hooks/post-receive"].find do |template|
+      File.exist?(template)
+    end
+  end
+
+  # @return [String] path to the post-receive hook which was generated
+  task.define_singleton_method(:compile_template) do |name|
+    path = ["hooks/post-receive.#{name}.erb", "hooks/post-receive.erb"].find do |template|
+      if File.exist?(template)
+        info "Compiling template #{template}"
+        Task["deployer:compile_hook"].call(template, name, options)
+      end
+    end
+    path.sub(/\.erb$/, "") if path
+  end
+
+  task.define_singleton_method(:upload) do |server, local_path|
+    sh "scp #{local_path} %{user}@%{host}:%{repo}/hooks/post-receive" % server
+    ssh server, "chmod +x %{repo}/hooks/post-receive"
+  end
+
+  task.define do |*names, options|
+    servers(*names) do |name, server|
+      # generate the hook if it doesn't exist
+      if local_path = self.find_template(name)
+        info "Using hook #{local_path}"
+        self.upload(server, local_path)
+      elsif local_path = self.compile_template(name)
+        self.upload(server, local_path)
+        sh "rm #{local_path}"
+      else
+        template = File.join(File.dirname(__FILE__), "..", "hooks", "server", "post-receive.erb")
+        info "Generating hook from default post-receive template"
+        Task["deployer:compile_hook"].call([template, name], options)
+        local_path = "hooks/post-receive.#{name}"
+        self.upload(server, local_path)
+        sh "rm #{local_path}"
+      end
+    end
+  end
+end
+
+# TODO: Task["deployer:compile_hook"].config[:colors] is fine, but there should be also server-specific configuration in Task["deployer:setup"].config[:servers][:origin][:colors]
+
+# @example
+#   ./tasks.rb deployer:compile_hook hooks/post-receive.erb --colors
+# @settings
+#   Task["deployer:compile_hook"].config[:colors]  = false
+#   Task["deployer:compile_hook"].config[:debug]   = true
+#   Task["deployer:compile_hook"].config[:branch]  = "master"
+#   Task["deployer:compile_hook"].config[:shebang] = "#!/usr/bin/env ruby"
+#   Task["deployer:compile_hook"].config[:target]  = "$BRANCH"
+# @options
+#   --[no-]force            Overwrite local post-receive hook. Default is keep it.
+#   --[no-]colors           Do not use colors in the hook. Some servers might have problems with them.
+#   --[no-]debug            Print debug messages from the post-receive hook.
+#   --branch=deploy         Deploy just this specified branch. Default is deploy all of them.
+#   --shebang='#!/bin/zsh'  Use this shebang in the post-receive hook.
+#   --target='$BRANCH'      Relative path from the apps root to the application. So if we have apps root in /var/www/myapp and we
+#                           specify target to '$BRANCH', then each branch will be located in directory with same name as the branch,
+#                           i. e. /var/www/myapp/master. Empty target means put everything directly into the apps root. It's reasonable
+#                           just if you specify also the --branch=mybranch switch, otherwise the code will be reset in each push to the
+#                           different branch which isn't probably what you want. But if you deploy just one branch, then it's OK.
+Task.new("deployer:compile_hook") do |task|
+  task.description = "Copy Git hook locally, so you can edit it and at the next remote copy it will be used instead of the hook distributed with git-deployer."
+  task.extend(SshMixin)
+
+  # default configuration
+  task.config[:shebang] = "#!/bin/sh"
+  task.config[:debug]   = true
+  task.config[:colors]  = true
+  task.config[:branch]  = nil
+  task.config[:target]  = "$BRANCH"
+
+  # We have to generate one hook for each server configuration because we have to specify local paths
+  task.define do |source = nil, server_name = nil, options|
+    abort "[#1] You have to specify the template you want to compile!" if source.nil?
+    abort "[#2] You have to specify the the server_name!" if server_name.nil?
+    abort "First argument has to be a template with .erb extension!" unless source.end_with?(".erb")
+    server = Task["deployer:setup"].config[:servers][server_name]
+    target = "hooks/post-receive.#{server_name}"
+    if ! File.exist?(target) || options[:force]
+      info "Creating #{target} from template #{source}"
+      erb source, target, {repo: server[:repo], path: server[:path]}.merge(config).merge(options)
+    else
+      abort "File #{target} already exist. Run this task with --force option to override."
+    end
+  end
+end
+
+Task.new("deployer:copy_hook") do |task|
+  task.description = "Copy Git hook locally, so you can edit it and at the next remote copy it will be used instead of the hook distributed with git-deployer."
+
+  task.define do |target = "hooks/post-receive", options|
+    source = File.join(File.dirname(__FILE__), "..", "hooks", "server", "post-receive.erb")
+    if ! File.exist?(target) || options[:force]
+      cp source, target
+    else
+      abort "File #{target} already exist. Run this task with --force option to override."
+    end
+  end
+end
+
+Task.new("deployer:run") do |task|
+  task.description = "Run remote hook"
+  task.extend(SshMixin)
+
+  # STDIN for post-receive:
+  # SHA1 SHA1 refs/heads/master
+  task.define do
+    servers do |name, server|
+      head = `git rev-parse HEAD`
+      refs = `cat .git/HEAD | awk '{ print $2 }'`
+      ssh server, "cd %{path} && echo #{head} #{head} #{refs} | ./hooks/post-receive"
+    end
+  end
+end
+
+# ./tasks.rb deployer:remove
+# ./tasks.rb deployer:remove server1 server2
+Task.new("deployer:remove") do |task|
+  task.description = "Remove created directory for remote servers"
+  task.config = Task["deployer:setup"].config
+  task.extend(SshMixin)
+
+  task.define do |*names, options|
+    servers(names) do |name, server|
+      ssh "rm -rf %{path}; rm -rf %repo"
+    end
+  end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+name: git-deployer
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- "Jakub \xC5\xA0\xC5\xA5astn\xC3\xBD aka Botanicus"
+autorequire: 
+bindir: bin
+cert_chain: 
+date: 2010-01-03 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: nake
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: ""
+email: knava.bestvinensis@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- example/hooks/clone
+- example/hooks/update
+- example/README.textile
+- example/tasks.rb
+- example/www/index.html
+- git-deployer.gemspec
+- hooks/project/clone.exec.erb
+- hooks/project/clone.source.erb
+- hooks/project/update.exec.erb
+- hooks/project/update.source.erb
+- hooks/server/post-receive.erb
+- README.textile
+- tasks/git-deployer.nake
+has_rdoc: true
+homepage: http://github.com/botanicus/git-deployer
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- tasks
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: git-deployer
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Easy deploy system based on Git hooks
+test_files: []
+