ruby_git_hooks 0.0.31

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+test/repos
+test/mail_params

data/.yardopts

@@ -0,0 +1 @@
+--protected --no-private - *.md app/**/*.rb lib/**/*.rb --readme README.md

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ruby_git_hooks.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 OL2, Inc.
+
+MIT License
+
+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.md

@@ -0,0 +1,327 @@
+# RubyGitHooks
+
+RubyGitHooks sets up a reasonable development environment for git hooks.
+
+Git, by default, gives you information that doesn't instantly map to
+what you want.  A pre-receive hook, for instance, doesn't just give
+you the content that's being received.  You have to extract the
+content by running git commands.  If you want to write a pre-receive
+hook that can also be used pre-commit, you have to do a fair bit of
+wrapping.
+
+RubyGitHooks does that extracting and wrapping for your convenience.
+
+## Installation
+
+To use with a single Ruby installation:
+
+    gem install ruby_git_hooks
+
+Remember that ruby_git_hooks is invoked by Git -- it won't normally
+run with Bundler.  Not only do you not need to add it to your Gemfile,
+it probably won't help.  So make sure ruby_git_hooks is installed for
+every Ruby you use day-to-day from the command line.
+
+## Usage
+
+## Writing Hook Scripts
+
+Your new hook script should have a Ruby shebang line (see below).  You
+can use the included hooks or define your own.
+
+The hook should be copied or symlinked to the appropriate location, of
+the form ".git/hooks/hook-name".
+
+Here's an example: a pre-receive hook that uses the shebang line to
+require ruby_git_hooks/case_clash, then runs it.
+
+~~~
+#!/usr/bin/env ruby
+# Put this file in .git/hooks/pre-receive and make it executable!
+require "ruby_git_hooks/case_clash"
+
+RubyGitHooks.run CaseClashHook.new
+~~~
+
+### Multiple Git Hooks, One RubyGitHook
+
+You can put a single hook script in and symlink it from one or more
+git-hook locations:
+
+~~~
+> cp my_hook.rb .git/hooks/
+> chmod +x .git/hooks/my_hook.rb
+> ln -s .git/hooks/my_hook.rb .git/hooks/pre-commit
+> ln -s .git/hooks/my_hook.rb .git/hooks/pre-receive
+~~~
+
+Use this when the hook is meaningful in more than one situation.
+Watch out!  You don't want four or five of the same email
+notification.
+
+### Multiple Hooks and RubyGitHooks.register
+
+You can call register on multiple hooks and then run them:
+
+~~~
+#!/usr/bin/env ruby
+# Put in .git/hooks/post-receive and make it executable!
+require "ruby_git_hooks/case_clash"
+require "ruby_git_hooks/copyright_check"
+
+RubyGitHooks.register CaseClashHook.new
+RubyGitHooks.register CopyrightCheck.new "domain" => "my_company.com",
+       "from" => "MyCo Inc. Copyright Reminders",
+       "via" => {
+                  :address => "smtp.my_company.com",
+                  :domain => "my_company.com"
+                }
+
+RubyGitHooks.run  # Run both
+~~~
+
+### Run By Git Hook Type
+
+You can have a single RubyGitHook file and symlink it to all supported
+git hooks.  But then you probably don't want every RubyGitHook to run
+for each type of git hook -- your pre-commit and post-commit hooks may
+be different, for instance.
+
+~~~
+#!/usr/bin/env ruby
+# Put in .git/hooks/post-receive and make it executable!
+require "ruby_git_hooks/case_clash"
+require "ruby_git_hooks/copyright_check"
+
+if RubyGitHooks.current_hook =~ /pre-/
+  RubyGitHooks.run CaseClashHook.new
+end
+
+if RubyGitHooks.current_hook =~ /post-/
+  RubyGitHooks.run CopyrightCheck.new "domain" => "my_company.com",
+       "from" => "MyCo Inc. Copyright Reminders",
+       "via" => {
+                  :address => "smtp.my_company.com",
+                  :domain => "my_company.com"
+                }
+end
+~~~
+
+### New Hook Types
+
+You can declare a new hook type in your file if you like:
+
+~~~
+#!/usr/bin/env ruby
+require "ruby_git_hooks"
+
+class TestHook < RubyGitHooks::Hook
+  def check
+    fnords = file_contents.values.any? { |v| v.include?("fnord") }
+
+    puts "You may not check in the Fnords!" if fnords
+
+    !fnords
+  end
+end
+
+RubyGitHooks.run TestHook.new
+~~~
+
+### New Hooks on Clone
+
+It's annoying that you don't automatically get hooks when you clone a
+new repo.  Often you want the same (or many of the same) hooks
+everywhere -- don't allow incomplete merges to be re-committed, for
+instance, or don't accept commit messages with non-ASCII characters.
+
+Those preferences are specific to you, but not specific to the repo.
+Clearly you should have a personal ~/.git_hooks directory containing
+your preferred hooks, which are then copied into each new repo you
+clone.  Ruby_git_hooks does exactly that, but the commane is "git
+hclone" instead of "git clone" unless you override it.
+
+You can also call "git add-hooks" to refresh the project's hooks from
+your ~/.git_hooks directory, in case your hooks have changed or files
+may have been corrupted.  This also works if you cloned without hooks
+or otherwise have an existing repository without your hooks.
+
+#### Using .bashrc to Override Git Clone
+
+To override "git clone" itself, you'll need a hack to your .bashrc
+The hack below allows you to add an executable like
+"git-clone" to your path and have it be used in preference to the
+regular git-clone in `git --exec-path`.
+
+You can also skip this hack and always use "git hclone" instead of
+"git clone" if you want hooks installed.
+
+~~~
+# NOTE: Stolen from http://stackoverflow.com/questions/2500586/setting-git-default-flags-on-commands
+# Git supports aliases defined in .gitconfig, but you cannot override Git
+# builtins (e.g. "git log") by putting an executable "git-log" somewhere in the
+# PATH. Also, git aliases are case-insensitive, but case can be useful to create
+# a negated command (gf = grep --files-with-matches; gF = grep
+# --files-without-match). As a workaround, translate "X" to "-x". 
+git()
+{
+    typeset -r gitAlias="git-$1"
+    if 'which' "$gitAlias" >/dev/null 2>&1; then
+        shift
+        "$gitAlias" "$@"
+    elif [[ "$1" =~ [A-Z] ]]; then
+        # Translate "X" to "-x" to enable aliases with uppercase letters.
+        translatedAlias=$(echo "$1" | sed -e 's/[A-Z]/-\l\0/g')
+        shift
+        "$(which git)" "$translatedAlias" "$@"
+    else
+        "$(which git)" "$@"
+    fi
+}
+~~~
+
+### Using RubyGitHooks with RVM
+
+To install ruby_git_hooks on RVM in all Rubies and gemsets:
+
+    rvm all do bash -l -c "rvm use @global && gem install ruby_git_hooks"
+
+If you install a new Ruby then you'll need to install ruby_git_hooks
+in its global gemset as well.  Also, you'll need to install any gems
+that your own personal hooks use, also in all gemsets.
+
+If you don't want to do that, you'll need to create an rvm wrapper and
+use it for the shebang line -- see below.
+
+If you're using Git 1.7.X rather than 1.8.X, Git will prepend /usr/bin
+to your path before running your hook -- you'll probably get the
+system Ruby by accident instead of the one you want.  You can upgrade
+to Git 1.8.X, or create an rvm wrapper and use that.
+
+To create an rvm wrapper:
+
+    rvm wrapper 1.9.3 githooks ruby
+
+You can give your own Ruby version instead of 1.9.3, and an optional
+gemset if you want the git hooks to use one.  Then see "Using
+RubyGitHooks with a Custom Shebang Line" below.
+
+### Using RubyGitHooks with a Custom Shebang Line
+
+If you don't want to use your current Ruby (with Git 1.8.X) or system
+Ruby (with Git 1.7.X), you'll need to set the shebang line for your
+hooks to the appropriate interpreter.
+
+If you're creating your own hook files, it's clear how to do this.
+
+But for RubyGitHooks' unit tests and generated hooks, you'll need to
+tell it what shebang line to use.
+
+Set it as an environment variable:
+
+    > export RUBYGITHOOKS_SHEBANG='#!/usr/bin/env /home/UserName/.rvm/bin/githooks_ruby'
+
+You need this set when generating hook scripts or running the unit
+tests of RubyGitHooks itself, but not later when using the hooks.
+
+You need the /usr/bin/env in it because your wrapper is a shellscript,
+and a shebang can't point to another shellscript on most systems.
+
+### API and Hook Documentation
+
+Documentation of individual hooks can be found in the YARD docs:
+
+    gem install yard redcarpet
+    yardoc
+    # Now open doc/_index.html in a browser of your choice
+
+## Compatibility
+
+This library is tested primarily on Mac OS X with Git 1.8.X, RVM and
+Ruby 1.9.X.
+
+It should be compatible with Git 1.7.X, Ruby 2.0.X and other Unix-like
+systems.
+
+It is *not* expected to work on Ruby 1.8.X.  Please upgrade.
+
+It is *not* expected to work on Windows systems.  We would accept
+patches to help fix this, but I don't know how reasonable it will be.
+Git on Windows is often problematic.
+
+It should be usable on non-RVM systems, including those using other
+Ruby version managers like rbenv.
+
+## Troubleshooting
+
+### It Says It's Not Installed
+
+Sometimes you can get an error saying that ruby_git_hooks isn't
+installed when you try a git operation.
+
+Simple stuff to try:
+
+* Reinstall ruby_git_hooks in all RVM Rubies (see INSTALLATION) and
+  the system Ruby, if any.
+
+* Upgrade Git to 1.8.2 or higher.
+
+* If you don't use /usr/bin/ruby, move it to /usr/bin/old_ruby so it
+  doesn't get in the way.  Your system Ruby is probably ancient Ruby
+  1.8.7 and everything sane uses 1.9.2 or higher.
+
+Obvious problems:
+
+* Not installed.  Fix this for the Ruby or gemset that git runs.
+
+* Running in a wrong/unexpected Ruby.  Often this is /usr/bin/ruby,
+  the system Ruby and/or Ruby 1.8.7.  You can move the bad Ruby out of
+  the way.  Or you can install ruby_git_hooks into it.  Or you can
+  adjust paths, shebang lines and environment variables to make git
+  run the right Ruby.  Note that Git 1.7 adds /usr/bin to the front of
+  your path so you may get an expected Ruby.  Git 1.8 does not.
+  Consider upgrading.
+
+* Running in Bundler without meaning to.  If your hook's shebang
+  includes or can run Bundler and you're using a Gemfile without
+  ruby_git_hooks then it's basically not installed.  Usually the right
+  answer is "don't run Bundler for your git hooks."  Otherwise you'll
+  have to add ruby_git_hooks to your Gemfile and/or add a new Gemfile
+  to .git/hooks.
+
+### Ruby 1.8.7
+
+We specifically do not test on Ruby 1.8.7.
+
+We don't try to sabotage it, but it's not on our radar.
+
+There's a good chance that ruby_git_hooks doesn't work on 1.8.7 at any
+given time.  This won't change.  Ruby 1.8.7 is ancient and as of June
+2013 will no longer even receive security fixes.  Please upgrade.
+Seriously, it's time.
+
+We *do* support systems like Macs with 1.8.7 as /usr/bin/ruby.  But
+you may need a custom shebang line with an rvm wrapper.
+
+### Git 1.7
+
+Git 1.7 has had some problems, and may have more.  Specifically:
+
+* Git 1.7 does not set up parent-branch tracking by default, and
+  some of our unit tests may require that.
+* Git 1.7 prepends /usr/bin to the path when running hooks (see above).
+
+We make a best effort to support it, but 1.8 is a smoother experience.
+
+## Contributing to RubyGitHooks
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## License and Copying
+
+Ruby Git Hooks is released under the MIT License by OL2, Inc.
+Please see the file LICENSE.txt for a copy of this license.

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList["test/*_test.rb"]
+end

data/TODO

@@ -0,0 +1,67 @@
+* Move this file's contents into GitHub issues, once we have a public GitHub repo for it.
+
+* Convert to using Grit in git_ops.rb
+
+* Do on-demand loading of Git information, so if no hook uses an
+  expensive Git operation, it can be skipped.  The API allows it but
+  the implementation isn't in place yet.
+
+* "Illegal content" hook -- for catching incomplete merges (">>>>>>"), etc.
+
+* "Bundle install on pull" hook
+
+* Wire up pre-rebase hooks to allow validations for multi-file
+  criteria.  Then you can't rebase in a new file if it would violate
+  the CaseClashHook, say.
+
+* A hook should have default hook types and file extensions and
+  git-hook names, and should only run if those match -- or if
+  registered with an overrriding git-hook name or file type.
+
+* Add option registration to Hook parent class and do appropriate
+  string/symbol checking there.
+
+* Print message if a hook is registered but run is never called.
+
+* Use SimpleCov to check coverage in test_helper.rb
+
+* Have a simple way to "forward" to another file.  That is, save the
+  arguments and STDIN and call another file with the same arguments
+  and same STDIN.  That would make it easy to have a "pre-commit.d"
+  directory and automatically call to every executable in that
+  directory matching "pre-commit" in the filename.  Then you could
+  easily combine multiple hooks -- for instance, the cloner's personal
+  hooks, the workplace's at-work hooks and the project's supplied
+  hooks.  Wouldn't always be a good idea, of course.
+
+* Document (and figure out) how to write new hooks that aren't part of RubyGitHooks gem
+  There are details about how directories and environment variables are set 
+  up by git when the hooks are called that can affect things like includes done by the hook.
+  For example most hooks are called with GIT_DIR set to .git and the working directory
+  set to the repo root BUT pre and post-receive are called with GIT_DIR set to '.' 
+  and the working directory set to <repo root>/.git.  
+
+* Project-specific hooks.  Right now, create a post-clone hook in
+  ~/.git_hooks that looks for a /.hooks directory in the newly-created
+  repo and copies the hooks into ~/.git_hooks.  Note that for now
+  these hooks will then *override* your personal ones.  TODO: merge them.
+
+* Where tests have "assert_raises RuntimeError", find a more specific
+  error.  This occurs in several places.
+
+* In copyright_check_hook, use regexp#scan instead of first match.
+
+* In copyright_check_hook, allow passing the top-level regexp/check as
+  an option.  This will require documenting that it overrides some other
+  things like the company check option.
+
+* In jira_ref_check_hook, allow passing in list of legal statuses.
+
+* In jira_ref_check_hook and jira_add_comment_hook, figure out how to
+  deal with checking with the server to see if a bug is real and
+  valid.  This will be a tricky UI issue.
+
+* In jira_add_comment_hook, rescue DNS errors for VPN setups.  Allow
+  the commit, but print a message.
+
+* In ruby_git_hooks.rb, have "shell!" capture both STDOUT and STDERR.

data/bin/git-add-hooks

@@ -0,0 +1,111 @@
+#!/usr/bin/env ruby
+
+# Copy files from ~/.git_hooks into .git/hooks in the current repo.
+
+# This script is run by Git, and can wind up running in system Ruby,
+# so it should be as 1.8-compatible and low on dependencies as
+# possible.  I will be so, so happy when Ruby 1.8 is effectively
+# dead.
+
+# Note that we copy files that aren't names of hooks on purpose.
+# It's totally kosher to have required or symlinked Ruby scripts
+# and other stuff in the ~/.git_hooks dir.  It's also totally
+# kosher to use RubyGitHooks support for git clone with hooks
+# even if you don't use RGH for anything else.
+
+# When the system we are running on doesn't support symlinks,
+# we turn the symlinks into wrapper scripts (for Windows, etc)
+
+# As a support for the user's specific installation (a kind of
+# install hooks hook) the file "pre-install-hook" will be run, if present
+# if the pre-install-hook returns a non-zero error code, don't install
+# the other files.
+
+require "fileutils"
+INSTALL_HOOK_SCRIPT = "pre-install-hook"
+ 
+def system_supports_symlinks
+  # if we're on windows we won't recognize symlinks
+  # TO DO: we shouldn't test until we encounter one, but only test once)
+  begin
+    File.readlink("any file") 
+  rescue NotImplementedError
+     puts "(Your system does not support symbolic links.)"
+     return false
+  rescue
+    # just ignore any other errors
+  end
+  return true
+end
+
+def is_symlink(file)
+  # is this file supposed to be a symbolic link?
+  # if so it will contain just the name of the file it should be linked to.
+  # We could just read in part of the file if it's a longer file.
+  # Is it safe to just read the first line and check that?
+  contents = File.read(file) rescue nil
+  m = contents && contents.match(/\A\s*(\w*[\.]?\w*)\s*\z/)
+  return m && m[1]
+end
+
+# Hack to allow git-add-hooks to be called from outide the git directory
+# with the name of the git directory passed in.  Addresses the problem
+# of .rvmrc using a gemset that doesn't have rubygithooks and hence
+# doesn't have git add-hooks.
+if ARGV[0] && Dir.exist?(ARGV[0])
+  STDERR.puts "Installing into #{ARGV[0]}"
+  Dir.chdir(ARGV[0])
+end
+
+until File.exist?(".git") || Dir.getwd =~ /\/$/
+  Dir.chdir ".."
+end
+
+raise "You're not in a git directory!" unless File.exist?(".git")
+Dir.mkdir(".git/hooks") unless File.exists?(".git/hooks")
+
+source_dir = "#{ENV['HOME']}/.git_hooks"
+raise "There's no #{source_dir} directory." unless File.exist?(source_dir)
+
+# run pre-install-hook, if it exists
+hook_file = "#{source_dir}/#{INSTALL_HOOK_SCRIPT}"
+if File.exist?(hook_file)
+  puts "Running #{INSTALL_HOOK_SCRIPT} script."
+  if `echo $0` =~ /\$0/
+    # our ruby doesn't know about the shell and
+    # won't respect the shebang (e.g. we're in windows)
+    ruby_cmd = "#{Config::CONFIG['bindir']}/#{Config::CONFIG['ruby_install_name']}"
+    result = system("#{ruby_cmd} #{hook_file}")
+  else
+    result = system(hook_file) # run the hook
+  end
+
+  if !result
+    puts "pre-install hook failed"
+    exit
+  end
+
+end
+
+has_sym = system_supports_symlinks
+
+Dir["#{source_dir}/*"].each do |file|  
+  system "chmod +x \"#{file}\""  
+  hook_name = file.split("/")[-1] #e.g. pre-commit
+  dest = ".git/hooks/" + hook_name 
+  next if hook_name == INSTALL_HOOK_SCRIPT   # don't copy the script
+  if !has_sym && (link_file = is_symlink(file))
+    puts "Installing shell wrapper for: #{file}"
+    File.open(dest, "w") do |f|
+      f.write("#!/bin/bash\n")
+      f.write("#{Dir.getwd}/.git/hooks/#{link_file} --hook #{hook_name} \"$@\"\n")
+    end
+    system "chmod +x \"#{dest}\""
+  else
+    # otherwise just copy the file.
+    puts "Installing hook file: #{file}"
+    FileUtils.copy_entry(file, dest, false, false, true)
+  end
+end
+
+puts "Copied hooks into #{Dir.getwd}/.git/hooks."

data/bin/git-clone

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+
+# This is used for git-clone and git-hclone.  Git-clone exists in case
+# the user overrides git() with a shell function to allow automatic
+# git-clone-with-hooks.
+
+# This script is run by Git, and can wind up running in system Ruby,
+# so it should be as 1.8-compatible and low on dependencies as
+# possible.  I will be so, so happy when Ruby 1.8 is effectively
+# dead.
+dashdash = ARGV.find_index("--")
+if dashdash
+  nondash = ARGV[(dashdash+1)..-1]
+else
+  # These are the documented git-clone options that take an additional
+  # piece of data afterward, such as "-o someorigin".
+  ARGS_WITH_ARGS = %w(-o -b -u --reference --separate-git-dir --depth)
+
+  nodash = []
+  i = 0
+  while i < ARGV.length
+    if ARGV[i][0] != "-"
+      nodash.push ARGV[i]
+    elsif ARGS_WITH_ARGS.include?(ARGV[i])
+      i += 1
+    end  # else ignore
+
+    i += 1
+  end
+end
+
+# allow to override with --nohooks
+nohooks = ARGV.delete("--nohooks") || ARGV.delete("--noHooks") || ARGV.delete("--no-hooks")
+
+if nodash.size > 1
+  dest_dir = nodash[-1]
+elsif nodash.size == 1
+  # Cloning from a URI
+  dest_dir = nodash[-1].split("/")[-1].gsub(/\.git$/, "")
+else
+  # No args?  Huh.
+  dest_dir = nil
+end
+
+system(File.join(`git --exec-path`.chomp, "git-clone"), *ARGV)
+if $?.success?
+  if nohooks
+    STDERR.puts "Hooks not installed."
+  elsif dest_dir && File.exist?(dest_dir)
+    Dir.chdir dest_dir
+    system(File.join(File.dirname(__FILE__), "git-add-hooks"))
+  elsif dest_dir
+    STDERR.puts "Couldn't find directory #{dest_dir}.  Hooks not installed."
+  else
+    STDERR.puts "Couldn't determine destination directory.  Hooks not installed."
+  end
+end

data/bin/git-hclone

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+
+# This is used for git-clone and git-hclone.  Git-clone exists in case
+# the user overrides git() with a shell function to allow automatic
+# git-clone-with-hooks.
+
+# This script is run by Git, and can wind up running in system Ruby,
+# so it should be as 1.8-compatible and low on dependencies as
+# possible.  I will be so, so happy when Ruby 1.8 is effectively
+# dead.
+dashdash = ARGV.find_index("--")
+if dashdash
+  nondash = ARGV[(dashdash+1)..-1]
+else
+  # These are the documented git-clone options that take an additional
+  # piece of data afterward, such as "-o someorigin".
+  ARGS_WITH_ARGS = %w(-o -b -u --reference --separate-git-dir --depth)
+
+  nodash = []
+  i = 0
+  while i < ARGV.length
+    if ARGV[i][0] != "-"
+      nodash.push ARGV[i]
+    elsif ARGS_WITH_ARGS.include?(ARGV[i])
+      i += 1
+    end  # else ignore
+
+    i += 1
+  end
+end
+
+# allow to override with --nohooks
+nohooks = ARGV.delete("--nohooks") || ARGV.delete("--noHooks") || ARGV.delete("--no-hooks")
+
+if nodash.size > 1
+  dest_dir = nodash[-1]
+elsif nodash.size == 1
+  # Cloning from a URI
+  dest_dir = nodash[-1].split("/")[-1].gsub(/\.git$/, "")
+else
+  # No args?  Huh.
+  dest_dir = nil
+end
+
+system(File.join(`git --exec-path`.chomp, "git-clone"), *ARGV)
+if $?.success?
+  if nohooks
+    STDERR.puts "Hooks not installed."
+  elsif dest_dir && File.exist?(dest_dir)
+    Dir.chdir dest_dir
+    system(File.join(File.dirname(__FILE__), "git-add-hooks"))
+  elsif dest_dir
+    STDERR.puts "Couldn't find directory #{dest_dir}.  Hooks not installed."
+  else
+    STDERR.puts "Couldn't determine destination directory.  Hooks not installed."
+  end
+end

data/lib/ruby_git_hooks/all.rb

@@ -0,0 +1,7 @@
+# Copyright (C) 2013 OL2, Inc. See LICENSE.txt for details.
+
+require "ruby_git_hooks"
+require "ruby_git_hooks/case_clash"
+require "ruby_git_hooks/max_file_size"
+require "ruby_git_hooks/copyright_check"
+require "ruby_git_hooks/ruby_debug_hook"