gitty 0.1.0

data/LICENSE

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

data/README.textile

@@ -0,0 +1,21 @@
+h1. Gitty : Unobtrusively extend git.
+
+Gitty provides an interface to manage commonly used git-hooks for repositories. A few use cases are:
+
+* Make it so that git submodules are intellegently updated after switching branches or merging.
+* Prevent trailing whitespace from being committed.
+* Help prevent scratch / debug code from being committed by refusing to commit a KEYWORD that marks it as such.
+* Share hooks with collaborators
+
+h2. Currently in alpha!
+
+Missing features:
+
+* List available hooks
+* List installed hooks
+* Only receive hooks from trusted publishers. (currently when gitty is activated on a repository, any hook published to origin is automatically installed)
+* It's very young and might break
+
+h2. Issues
+
+Report them here: http://github.com/timcharper/gitty/issues

data/Rakefile

@@ -0,0 +1,29 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "gitty"
+    gem.summary = %Q{Unobtrusively extend git}
+    gem.description = %Q{Unobtrusively extend git}
+    gem.email = "timcharper@gmail.com"
+    gem.homepage = "http://github.com/timcharper/gitty"
+    gem.authors = ["Tim Harper"]
+    gem.files = Dir['lib/**/*.rb'] + Dir['assets/**/*'] + Dir['bin/*'] + Dir['cucumber/**/*'] + Dir['spec/**/*'] + %w[cucumber.yml Rakefile README.textile LICENSE]
+    # gem.executables << 'git-hook'/
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "gitty #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/assets/helpers/git-cleanup-branches

@@ -0,0 +1,151 @@
+#!/usr/bin/env ruby
+require "tempfile.rb"
+require 'optparse'
+
+DEFAULT_STABLE_BRANCH="master"
+EDITOR=ENV['EDITOR'] || 'vim'
+
+
+class GitCleanBranchesRunner
+  module CandidateState
+    module ConsiderAll
+      def candidate_instructions
+        "# The following is a list of all local and remote branches in your repository"
+      end
+
+      def branch_candidates
+        @branch_candidates ||= branches
+      end
+    end
+
+    module MergedOnly
+      def branch_candidates
+        @branch_candidates ||= (
+          candidates = []
+          branches.each do |branch|
+            next if %r(/(#{preserve_always * '|'})$) =~ branch
+            next unless `git rev-list origin/#{stable_branch}..#{branch}`.strip.empty?
+            candidates << branch
+          end
+          candidates
+        )
+      end
+
+      def candidate_instructions
+        "# The following branches have been merged in to refs/remotes/origin/#{stable_branch}"
+      end
+    end
+  end
+
+  attr_reader :stable_branch
+
+  def initialize(args, output = STDOUT, error = STDERR)
+    @output, @error = output, error
+    extend CandidateState::MergedOnly
+    @stable_branch = DEFAULT_STABLE_BRANCH
+    opts = OptionParser.new
+    opts.banner = "Usage: #{$0} [options]"
+    opts.separator "Options:"
+    opts.on("-a", "--all", "Consider all branches for deletion, regardless if they've been merged into stable") do
+      extend CandidateState::ConsiderAll
+    end
+    opts.on("-b", "--branch [branch]", "The stable branch (default: #{@stable_branch}). If a branch is merged into this, and -a parameter not specified, consider it for deletion.") do |b|
+      @stable_branch = b
+    end
+    opts.parse!(args)
+  end
+
+  def preserve_always
+    [stable_branch] + %w[staging master next HEAD]
+  end
+
+  def fetch_and_prune
+    puts "Fetching and pruning all remotes"
+    `git remote`.each do |remote|
+      system("git fetch #{remote}")
+      system("git remote prune #{remote}")
+    end
+  end
+
+  def branches
+    %x(git for-each-ref).map do |branch_name|
+      next unless %r{.+(refs/(heads|remotes).+$)}.match(branch_name)
+      $1
+    end.compact
+  end
+
+  def candidate_instructions
+    raise NotImplemented
+  end
+
+  def branch_candidates
+    raise NotImplemented
+  end
+
+  def edit_branch_list
+    file = Tempfile.new("cleanup-branch")
+    file.puts candidate_instructions
+    file.puts "# To delete the branches, delete them from this list, and then save and quit"
+    file.puts(branch_candidates * "\n")
+    file.close
+    system("#{EDITOR} #{file.path}")
+    preserve_branches = File.read(file.path).split("\n").grep(/^[^#].+/)
+    file.delete
+
+    unless (erroneous_branches = (preserve_branches - branch_candidates)).empty?
+      puts <<EOF
+Error! unrecognized branches:
+#{erroneous_branches.map{|b| " - #{b}"} * "\n"}
+EOF
+      exit 1
+    end
+
+    preserve_branches
+  end
+
+  def sort_branches(branches)
+    sorted_branches = {}
+    branches.each do |branch|
+      case branch
+      when %r(^refs/remotes/([^/]+)/(.+)$)
+        remote, branch = $1, $2
+        sorted_branches[remote] ||= []
+        sorted_branches[remote] << branch
+      when %r(^refs/heads/(.+)$)
+        sorted_branches[nil] ||= []
+        sorted_branches[nil] << $1
+      else
+        puts "I don't know how to delete #{branch_for_deletion}"
+      end
+    end
+    sorted_branches
+  end
+
+  def delete_branches(branches_for_deletion)
+    sorted_branches = sort_branches(branches_for_deletion)
+    if sorted_branches.empty?
+      puts "No branches to delete."
+      exit 1
+    end
+    puts <<EOF
+Deleting branches:
+#{branches_for_deletion.map{|b| " - #{b}"} * "\n"}
+EOF
+    sorted_branches.each do |remote, branches|
+      if remote.nil?
+        system(*%w[git branch -D] + branches)
+      else
+        system(*%w[git push] + [remote] + branches.map { |b| ":#{b}" })
+      end
+    end
+  end
+
+  def run
+    fetch_and_prune
+    preserve_branches = edit_branch_list
+    delete_branches(branch_candidates - preserve_branches)
+  end
+end
+
+
+GitCleanBranchesRunner.new(ARGV).run

data/assets/helpers/git-strip-new-whitespace

@@ -0,0 +1,30 @@
+#!/bin/bash
+
+# strip trailing whitespace from any lines you've introduced. If you've staged changes, it strips them from the index (and they stay in your working copy).
+# why would you want to do this?  Keep your patches clean.  Why not just strip all whitespaces from your project?  Well... then you'd have a big nasty commit, wouldn't you?  And some code generators might rely on the whitespace (like annotate-models).
+
+STAGED_CHANGES="$(git diff --cached)"
+if [ "$STAGED_CHANGES" != "" ]; then
+  echo "Stripping trailing spaces from index"
+  git reset 2> /dev/null 1> /dev/null
+  if (echo "$STAGED_CHANGES" | git apply --whitespace=fix --cached); then
+    echo "Successfully stripped all new whitespaces from the index"
+  else
+    BLEW_UP_FILE="/tmp/git-strip-new-whitespace-blew-up"
+    echo "$STAGED_CHANGES" > "$BLEW_UP_FILE"
+    echo "Something went wrong. I wrote the patch for your staged changes to $BLEW_UP_FILE."
+    echo "Apply them back to your index with 'cat $BLEW_UP_FILE | git apply --cached'"
+    exit 1
+  fi
+  exit 0
+fi
+
+git stash
+if (git stash show -p | git apply --whitespace=fix); then
+  echo "Successfully stripped all new whitespaces"
+  git reset 2> /dev/null 1> /dev/null
+  git stash drop 2> /dev/null 1> /dev/null
+else
+  echo "Something went wrong. Your changes were stashed at least :S"
+fi
+exit 0

data/assets/helpers/git-submodule-helper

@@ -0,0 +1,262 @@
+#!/bin/bash
+
+if [ "`which md5`" == "" ]; then
+  if [ "`which md5sum`" == "" ]; then
+    echo "Couldn't find md5 or md5sum.  Aborting"
+    exit 1
+  fi
+
+  md5 () {
+    md5sum | cut -f 1 -d " "
+  }
+fi
+
+list_submodules () {
+  git ls-files --stage | grep "^160000 " | cut -f 2
+}
+
+submodule_url () {
+  git config "submodule.$1.url"
+}
+
+submodule_md5 () {
+  local path="$1"
+  local url=`submodule_url "$path"`
+  local string="$path $url"
+  printf "$string" | md5
+}
+
+submodule_stash_path () {
+  local path="$1"
+  [ ! -d ".git/submodule_cache/" ] && mkdir .git/submodule_cache
+  printf ".git/submodule_cache/`submodule_md5 "$path"`"
+}
+
+submodule_helper_stash () {
+  list_submodules | while read submodule; do
+    [ ! -d "$submodule/.git" ] && continue
+    stash_path="`submodule_stash_path "$submodule"`"
+    if [ -d "$stash_path" ]; then
+      echo "'$stash_path' already exists: it appears that the submodule $submodule has already been stashed"
+    else
+      mv "$submodule" "$stash_path"
+      echo "Stashed '$submodule' to '$stash_path'"
+    fi
+  done
+}
+
+submodule_helper_unstash () {
+  list_submodules | while read submodule; do
+    [ -d "$submodule/.git" ] && continue
+    stash_path="`submodule_stash_path "$submodule"`"
+    if [ ! -d "$stash_path" ]; then
+      echo "'$stash_path' doesn't exist, can't restore from stash (maybe it was never stashed?)"
+    else
+      if [ -d "$submodule" ] && ! rmdir "$submodule"; then
+        echo "Path '$submodule' is in the way.  Leaving stashed."
+        continue
+      fi
+      mv "$stash_path/" "$submodule/"
+      echo "Unstashed '$submodule' from '$stash_path'"
+    fi
+  done
+}
+
+submodule_helper_stash_status () {
+  list_submodules | while read submodule; do
+    stash_path="`submodule_stash_path "$submodule"`"
+    if [ -d "$submodule/.git" ]; then
+      status="checked out"
+    elif [ -d "$stash_path" ]; then
+      status="stashed"
+    else
+      status="????"
+    fi
+
+    if [ "$status" == "stashed" ]; then
+      display_stash_path="$stash_path"
+    else
+      display_stash_path=""
+    fi
+    printf "(%s)\t%s\t%s\n" "$status" "$display_stash_path" "$submodule"
+  done
+}
+
+submodule_helper_attach () {
+  if (cat .git/HEAD | grep ref: 1> /dev/null) ; then
+    echo "You're already on a branch"
+    exit 1
+  fi
+  current_rev=$(git rev-parse HEAD)
+  line=$(git 'for-each-ref' | egrep -v 'HEAD$' | grep $current_rev)
+  if [ $? != 0 ]; then
+    echo "no known branch is currently at ${current_rev}"
+    echo "here are some suggestions: "
+    git branch --contains $current_rev -a | egrep -v 'no branch|HEAD'
+    exit 1
+  fi
+  rev=$(echo $line | awk '{print $1}')
+  ref=$(echo $line | awk '{print $3}')
+  if ( echo $ref | egrep '^refs/heads/' > /dev/null ); then
+    echo "ref: $ref" > .git/HEAD
+    exit 0
+  fi
+
+  if ( echo $ref | egrep '^refs/remotes/' > /dev/null ); then
+    echo "Remote branch ${ref} matches"
+    short_ref=${ref#refs/remotes/}
+    local_ref=${ref#*/*/*/}
+    divergent_commits=$(git rev-list $ref..$local_ref)
+    if [ "$divergent_commits" == "" ]; then
+      echo "fastforwarding $local_ref to $ref"
+      git branch -f "$local_ref" "$ref"
+      git checkout "$local_ref"
+    fi
+    exit 1
+  fi
+}
+
+submodule_helper_status () {
+  local prefix="$1"
+  local status=$(git status)
+  if [ "$(printf "$status" | grep "nothing to commit (working directory clean)")" == "" ]; then
+    echo
+    echo "${prefix}"
+    echo ----------------------------------------
+    echo "$status"
+  fi
+  list_submodules | while read submodule; do
+    pushd $submodule > /dev/null
+    submodule_helper_status "${prefix}${submodule}"
+    popd > /dev/null
+  done
+}
+
+submodule_helper_add_folder () {
+  local folder="$1"
+  pushd $folder > /dev/null
+    url=$(git config remote.origin.url)
+  popd > /dev/null
+  git submodule add "$url" "$folder"
+}
+
+submodule_helper_fetch () {
+  local prefix="$1"
+  local status=$(git status)
+  echo
+  echo "${prefix}"
+  echo ----------------------------------------
+  git fetch
+
+  list_submodules | while read submodule; do
+    pushd $submodule > /dev/null
+    submodule_helper_fetch "${prefix}${submodule}"
+    popd > /dev/null
+  done
+}
+
+submodule_helper_update () {
+  git ls-files --stage | grep "^160000 " | while read line; do
+    submodule=$(printf "$line" | cut -f 2 )
+    version=$(printf "$line" | cut -f 1 | cut -f 2 -d ' ' )
+    pushd $submodule > /dev/null
+    current_version=$(git rev-parse HEAD)
+    if [ ! "$current_version" == "$version" ]; then
+      echo
+      echo "${submodule}"
+      echo ----------------------------------------
+      if [ "$1" != "--offline" ]; then
+        (git show "$version" 2> /dev/null 1> /dev/null) || git fetch
+      fi
+      git checkout $version
+    fi
+    popd > /dev/null
+  done
+}
+
+submodule_helper_checkout () {
+  echo 1
+}
+
+submodule_helper_help () {
+  cat <<EOF
+$0
+V 0.2
+By Tim Harper
+http://tim.theenchanter.com/
+
+A script to help you manage submodules
+
+commands:
+
+  stash   - Takes all of your submodules, and stashes them temporarily
+            to .git/submodule_cache/ Useful if you want to switch to a
+            branch that with a file that gets in the way of of your
+            submodule
+
+  unstash - Takes any stashed modules that are referenced by the
+            current branch, and puts them back in their place
+
+  stash-status
+          - Show the stashed status of any submodules (and the path
+            where they were stashed at)
+
+  fetch   - Fetch all submodules (good for if you plan on going offline and
+            want to make sure you have everything
+
+  update  - Optimized submodule update - only tries to fetch when needed.  Use
+            --offline to prevent it from trying to fetch when encountering a
+            non-existing revision.
+
+  status  - See the status for all submodules
+
+  attach  - Re-attach your HEAD to a branch that matches your current rev.
+
+  add-folder
+          - add a folder that has been cloned as a submodule already
+
+
+DISCLAIMER: Make sure you back things up first in case things go horribly wrong
+EOF
+}
+
+if [ ! -d ".git" ]; then
+  echo "This must be run from the root directory of the git working copy"
+  exit 1
+fi
+
+case "$1" in
+  stash)
+    submodule_helper_stash
+    ;;
+  unstash)
+    submodule_helper_unstash
+    ;;
+  stash-status)
+    submodule_helper_stash_status
+    ;;
+  add-folder)
+    submodule_helper_add_folder $2
+    ;;
+  update)
+    submodule_helper_update $2
+    ;;
+  fetch)
+    submodule_helper_fetch /
+    ;;
+  checkout)
+    submodule_helper_checkout
+    ;;
+  status)
+    submodule_helper_status /
+    ;;
+  attach)
+    submodule_helper_attach
+    ;;
+  help)
+    submodule_helper_help
+    ;;
+  *)
+    submodule_helper_help
+    ;;
+esac