gitty 0.1.0

data/assets/helpers/git-trash

@@ -0,0 +1,26 @@
+#!/bin/bash
+
+# 'git trash' does the same thing as 'git reset --hard' or 'git checkout ./',
+# except rather than completely vaporizing the changes, it stores them in an
+# unreachable stash object.  This means you can save yourself from accidents
+# without having to grep the filesystem.
+#
+# trashed changes can be found using 'git fsck' with relative ease.
+#
+# 'git prune' will delete your trashed changes. 'git gc' will delete your
+# trashed changes older than gc.pruneExpire (which defaults to 2 weeks
+# according to the git-gc man page).
+
+current_stash=$(git rev-parse stash@{0})
+if [ "$1" == "-a" ]; then
+  git add .
+fi
+
+result=$(git stash save 'trashed changes' 2>&1)
+saved_stash=$(git rev-parse stash@{0})
+if [ ! "$current_stash" == "$saved_stash" ]; then
+  result=$(git stash drop 2>&1)
+  echo "Changes were trashed. Type 'git stash apply $saved_stash to bring them back"
+else
+  echo "Trash failed. 'git stash' reported: $result" 1>&2
+fi

data/assets/helpers/git-when-introduced

@@ -0,0 +1,16 @@
+#!/bin/sh
+if [ -z "$1" ]; then
+  echo "Usage: $0 <commit> <branch>"
+  echo "  branch is optimal and defaults to current"
+  exit 1
+fi
+what_ref=$1
+branch=$(git symbolic-ref HEAD | sed 's|refs/heads/||')
+git reflog show $branch@{now} | while read ref rest; do
+  if [ -z "$(git rev-list -1 $ref..$what_ref)" ]; then
+    printf "[x] "
+  else
+    printf "[ ] "
+  fi
+  echo $ref $rest
+done | less -R

data/assets/helpers/hookd_wrapper

@@ -0,0 +1,22 @@
+#!/bin/bash
+dirname=$(dirname $0)
+hooktype=$(basename $0)
+
+# Check for updates.  Since there is no post-fetch hook, we check before we're about to run a hook.
+remote_branch=$(git show-ref origin/--hooks--)
+[ -n "$remote_branch" ] && (
+  cd ${dirname}/shared > /dev/null
+  local_rev=$(GIT_OBJECT_DIRECTORY="../../objects" git rev-parse HEAD)
+  [ "${remote_branch%% *}" != "$local_rev" ] && (
+    echo "Hook updates were applied:" 1>&2
+    GIT_OBJECT_DIRECTORY=../../objects git branch origin/--hooks-- ${remote_branch%% *} -f 1>&2
+    GIT_OBJECT_DIRECTORY=../../objects git reset --hard ${remote_branch%% *} 1>&2
+  )
+)
+  
+for base_dir in "${dirname}"/{shared,local}; do
+  [ -d "${base_dir}/${hooktype}.d" ] || continue
+  for script in "${base_dir}/${hooktype}.d"/*; do
+    HELPERS="${base_dir}/helpers" "${script}" || exit $?
+  done
+done

data/assets/hooks/clean-patches

@@ -0,0 +1,43 @@
+#!/bin/sh
+#
+# description: |-
+#   A hook script to verify what is about to be committed.
+#   Called by git-commit with no arguments.  The hook should
+#   exit with non-zero status after issuing an appropriate message if
+#   it wants to stop the commit.
+# targets: ["pre-commit"]
+
+# If you want to allow non-ascii filenames set this variable to true.
+allownonascii=$(git config hooks.allownonascii)
+
+# Cross platform projects tend to avoid non-ascii filenames; prevent
+# them from being added to the repository. We exploit the fact that the
+# printable range starts at the space character and ends with tilde.
+if [ "$allownonascii" != "true" ] &&
+	test "$(git diff --cached --name-only --diff-filter=A -z |
+	  LC_ALL=C tr -d '[ -~]\0')"
+then
+	echo "Error: Attempt to add a non-ascii filename."
+	echo
+	echo "This can cause problems if you want to work together"
+	echo "with people on other platforms than you."
+	echo
+	echo "To be portable it is adviseable to rename the file ..."
+	echo
+	echo "If you know what you are doing you can disable this"
+	echo "check using:"
+	echo
+	echo "  git config hooks.allownonascii true"
+	echo
+	exit 1
+fi
+
+if git-rev-parse --verify HEAD >/dev/null 2>&1
+then
+	against=HEAD
+else
+	# Initial commit: diff against an empty tree object
+	against=4b825dc642cb6eb9a060e54bf8d69288fbee4904
+fi
+
+exec git diff-index --check --cached $against --

data/assets/hooks/git-post-checkout-submodules

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+#
+# description: |-
+#   A git hook that automatically updates your submodules for you when you change branches or pull
+#
+#   It works like this:
+#   - If before you changed branches, your submodule's revision differed from what the master repo specified, your submodule is left alone
+#   - If a submodule has been removed from the branch you move to, it alerts you
+#   - If a submodule has been added on the branch you move to, it alerts you
+#   - Otherwise, it checks out the revision for you
+# version: 0.1
+# targets: ["post-applypatch", "post-checkout", "post-merge"]
+
+module GitMethods
+  def chdir_parent
+    Dir.chdir('..') until File.directory?('.git') || Dir.pwd == '/'
+  end
+
+  def list_submodules(ref)
+    `git ls-tree --full-tree -r #{ref} | egrep '^160000'`.split("\n").inject({}) do |h, line|
+      info, path = line.split("\t")
+      filemode, object_type, ref = info.split(" ")
+      h[path] = ref
+      h
+    end
+  end
+
+  def submodule_current_rev(path)
+    return nil unless File.directory?(path)
+    ref = nil
+    Dir.chdir(path) do
+      ref = `git rev-parse HEAD`.chomp
+    end
+    ref
+  end
+
+  def output_submodule_header(path)
+    puts "\nSubmodule: #{path}\n#{'-' * 60}"
+  end
+end
+include GitMethods
+
+chdir_parent
+current_submodules = list_submodules('HEAD')
+previous_submodules = list_submodules('HEAD@{1}')
+
+(current_submodules.keys + previous_submodules.keys).uniq.sort.each do |path|
+  rev = submodule_current_rev(path)
+  case
+  when rev.nil?
+    output_submodule_header(path)
+    # it should be initialized / unstashed
+    puts "Submodule is new and needs to be initialized"
+  when rev == current_submodules[path]
+    # do nothing
+  when rev != previous_submodules[path]
+    output_submodule_header(path)
+    puts rev
+    # it was modified before... don't touch it
+    puts "Not updating '#{path}' because it's revision pointer isn't the same as the previous HEAD specified"
+  when current_submodules[path].nil?
+    output_submodule_header(path)
+    # it should be stashed
+    puts "Does not exist in this revision (you may wish to stash it with git submodule-helper stash)."
+  when rev != current_submodules[path]
+    output_submodule_header(path)
+    # it should be updated to the latest
+    # Fetch if it the change doesn't exist
+    Dir.chdir(path) do
+      system("(git show '#{current_submodules[path]}' 2> /dev/null 1> /dev/null) || git fetch")
+      system("git checkout '#{current_submodules[path]}'")
+    end
+  end
+end

data/assets/hooks/git-prevent-messy-rebase

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+# description: Detects if your rebase will rewrite commits that have been propagated to other branches, and stops the rebase if so.
+# version: 0.1
+# targets: ["pre-rebase"]
+# helpers: []
+
+target_branch = ARGV[0]
+latest_commit = %x{git rev-list #{target_branch}..HEAD}.split("\n").last
+other_branches_with_commit = %x{git branch --contains #{latest_commit}}.split("\n").select { |l| ! /^ *\*/.match(l) }.map {|b| b.strip }
+if other_branches_with_commit.empty?
+  exit 0
+else
+  puts "Running this rebase would cause commit #{latest_commit[0..-7]} be rewritten, but it's included in the history of #{other_branches_with_commit * ", "}\n\n\n"
+  system("git show #{latest_commit} --pretty=oneline")
+  puts "\n\n\n"
+  exit 1
+end

data/assets/hooks/prevent-nocommit-tags

@@ -0,0 +1,11 @@
+#!/bin/bash
+# description: Let's you tag debug code and prevent it from being committed by adding the word "NOCOMMIT" to your source
+# version: 0.1
+# targets: ["pre-commit"]
+# helpers: []
+
+if git diff --cached | grep NOCOMMIT > /dev/null; then
+  echo "You tried to commit a line containing NOCOMMIT"
+  exit 1
+fi
+exit 0

data/bin/git-hook

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+$: << File.dirname(__FILE__) + "/../lib/"
+require "gitty"
+Gitty::Hook.new(ARGV).run

data/cucumber.yml

@@ -0,0 +1 @@
+default: -f pretty -r features

data/lib/ext.rb

@@ -0,0 +1,16 @@
+class Symbol
+  unless method_defined?(:to_proc)
+    def to_proc
+      proc { |obj, *args| obj.send(self, *args) }
+    end
+  end
+end
+
+class Object
+  unless method_defined?(:tap)
+    def tap
+      yield self
+      self
+    end
+  end
+end

data/lib/gitty.rb

@@ -0,0 +1,55 @@
+require "pathname"
+
+GITTY_ROOT_PATH = Pathname.new(File.expand_path("..", File.dirname(__FILE__)))
+ASSETS_PATH    = GITTY_ROOT_PATH + "assets"
+GITTY_LIB_PATH = GITTY_ROOT_PATH + "lib"
+GITTY_PATH     = GITTY_ROOT_PATH + "lib/gitty"
+$: << GITTY_LIB_PATH.to_s
+
+require 'fileutils'
+require 'stringio'
+require 'yaml'
+require "string.rb"
+require "ext.rb"
+
+module Gitty
+  autoload :Helpers, (GITTY_PATH + "helpers.rb").to_s
+  def self.asset_paths
+    [ENV["GITTY_ASSETS"], ENV["HOME"] + "/.gitty", ASSETS_PATH].compact.map {|p| Pathname.new(p)}
+  end
+
+  def self.find_asset(file)
+    asset_paths.each do |asset_path|
+      fullpath = File.join(asset_path, file)
+      return fullpath if File.exist?(fullpath)
+    end
+    nil
+  end
+
+  def self.creating_dir_if_nonexistant(dir)
+    FileUtils.mkdir_p(dir)
+    Pathname.new(dir)
+  end
+
+  def self.extract_meta_data(string_or_io)
+    io = string_or_io.respond_to?(:readline) ? string_or_io : StringIO.new(string_or_io)
+    meta_yaml = ""
+    begin
+      while line = io.readline
+        next unless line.match(/^# (description.+)/)
+        meta_yaml = "#{$1}\n"
+        break
+      end
+
+      while line = io.readline
+        break unless line.match(/^# (.+)/)
+        meta_yaml << "#{$1}\n"
+      end
+    rescue EOFError
+    end
+    meta_yaml.empty? ? nil : YAML.load(meta_yaml)
+  end
+end
+
+require "gitty/runner.rb"
+require "gitty/hook.rb"

data/lib/gitty/commands/add.rb

@@ -0,0 +1,26 @@
+require GITTY_PATH + "commands/manager"
+
+class Gitty::Hook::Add < Gitty::Hook::Manager
+  include FileUtils
+
+  def run
+    cp(src_hook_file, master_hook_file)
+    chmod(0755, master_hook_file)
+    meta_data["targets"].each do |target|
+      ln_s(
+        "../hooks/#{@hookname}",
+        file_with_existing_directory!(base_directory + "#{target}.d" + @hookname)
+      )
+    end
+    (meta_data["helpers"] || []).each do |helper|
+      cp(Gitty.find_asset("helpers/#{helper}"), helpers_directory + helper)
+      chmod(0755, helpers_directory + helper)
+    end
+  end
+
+  def option_parser
+    @option_parser ||= super.tap do |opts|
+      opts.banner = "Usage: git hook add [opts] hook-name"
+    end
+  end
+end

data/lib/gitty/commands/init.rb

@@ -0,0 +1,55 @@
+require 'fileutils'
+class Gitty::Hook::Init < Gitty::Runner
+  include ::Gitty::Helpers
+  
+  CLIENT_HOOKS = %w[
+    applypatch-msg
+    commit-msg
+    post-applypatch
+    post-checkout
+    post-commit
+    post-merge
+    pre-applypatch
+    pre-auto-gc
+    pre-commit
+    pre-rebase
+    prepare-commit-msg
+  ]
+  def run
+    puts "Initializing with gitty"
+    FileUtils.mkdir_p(".git/hooks/shared")
+    FileUtils.mkdir_p(".git/hooks/local")
+
+    CLIENT_HOOKS.each do |hook|
+      FileUtils.cp((ASSETS_PATH + "helpers/hookd_wrapper").to_s, ".git/hooks/#{hook}")
+      FileUtils.chmod(0755, ".git/hooks/#{hook}")
+    end
+    
+    hooks_rev = remote_hooks_rev
+    
+    with_env_var("GIT_OBJECT_DIRECTORY", File.join(Dir.pwd, ".git/objects")) do
+      Dir.chdir(".git/hooks/shared") do
+        unless File.exist?(".git")
+          cmd(*%w[git init])
+          cmd(*%w[git symbolic-ref HEAD refs/heads/--hooks--])
+          cmd(*%w[git commit --allow-empty -m initial\ commit])
+        end
+        cmd(*%w[git reset --hard], hooks_rev) if hooks_rev
+      end
+    end
+  end
+  
+  def option_parser
+    super.tap do |opts|
+      opts.banner = "Usage: git hook init"
+    end
+  end
+  
+  protected
+    def remote_hooks_rev
+      %x{git for-each-ref}.chomp.split("\n").map {|l| l.split(/\s+/) }.each do |rev, kind, ref|
+        return rev if ref == "refs/remotes/origin/--hooks--"
+      end
+      nil
+    end
+end

data/lib/gitty/commands/list.rb

@@ -0,0 +1,67 @@
+require 'fileutils'
+class Gitty::Hook::List < Gitty::Runner
+  include ::Gitty::Helpers
+  include FileUtils
+  KINDS = [:local, :shared, :available]
+
+  def run
+    stdout.puts "Listing hooks"
+    which_to_show = KINDS.select { |k| options[k] }
+    which_to_show = KINDS if which_to_show.empty? # default to everything
+    which_to_show.each { |w| show_hooks(w) }
+  end
+
+  def show_hooks(which)
+    case which
+    when :local     then show_local_or_shared_hooks('local')
+    when :shared    then show_local_or_shared_hooks('shared')
+    when :available then show_available_hooks
+    end
+  end
+
+  def show_local_or_shared_hooks(which)
+    hook_names = filenames_in(installed_hooks_path(which))
+    return if hook_names.empty?
+    puts "#{which}:\n#{listify(hook_names)}\n\n"
+  end
+
+  def listify(hooks)
+    hooks.map { |h| "- #{h}" }.join("\n")
+  end
+
+  def filenames_in(dir)
+    if File.directory?(dir)
+      Dir.glob((dir + "*").to_s).sort.map do |path|
+        File.basename(path)
+      end
+    else
+      []
+    end
+  end
+
+  def installed_hooks_path(which)
+    Pathname.new(".git/hooks/#{which}/hooks")
+  end
+
+  def show_available_hooks
+    all_hooks = Gitty.asset_paths.map {|asset_path| filenames_in(asset_path + "hooks")}.flatten
+    installed_hooks = [:local, :shared].map { |which| filenames_in(installed_hooks_path(which)) }.flatten
+    available_hooks = all_hooks.sort - installed_hooks.sort
+    puts "available:\n#{listify(available_hooks)}\n\n"
+  end
+
+  def option_parser
+    super.tap do |opts|
+      opts.banner = "Usage: git hook list"
+      opts.on("-l", "--local", "Show local hooks") do
+        options[:local] = true
+      end
+      opts.on("-r", "--shared", "Show shared hooks") do
+        options[:shared] = true
+      end
+      opts.on("-a", "--available", "Show available hooks") do
+        options[:available] = true
+      end
+    end
+  end
+end