ruby_git_hooks 0.0.31

data/lib/ruby_git_hooks.rb

@@ -0,0 +1,343 @@
+# Copyright (C) 2013 OL2, Inc. See LICENSE.txt for details.
+
+require "ruby_git_hooks/version"
+
+# This module is the core of the ruby_git_hooks code.  It includes the
+# Git commands, the hook types and in general most of the interface.
+# README.md is the best overall documentation for this package, but
+# this is where you can dig into the lowest-level Git specifics.
+
+module RubyGitHooks
+  # This isn't all hook names, just the ones we already support.
+  CAN_FAIL_HOOKS = [ "pre-commit", "pre-receive", "commit-msg" ]
+  NO_FAIL_HOOKS = [ "post-receive", "post-commit" ]
+  HOOK_NAMES = CAN_FAIL_HOOKS + NO_FAIL_HOOKS
+  # applypatch-msg, pre-applypatch, post-applypatch
+  # prepare-commit-msg, commit-msg
+  # pre-rebase, post-checkout, post-merge, update, post-update,
+  # pre-auto-gc, post-rewrite
+
+  class Hook
+    class << self
+      # What hooks are running
+      attr_reader :registered_hooks
+
+      # What command line was run
+      attr_reader :run_as
+
+      # What directory to run from
+      attr_reader :run_from
+
+      # What git hook is being run
+      attr_reader :run_as_hook
+
+      # Whether .run has ever been called
+      attr_reader :has_run
+
+      # Array of what files were changed
+      attr_accessor :files_changed
+
+      # Latest contents of all changed files
+      attr_accessor :file_contents
+
+      # A human-readable diff per file
+      attr_accessor :file_diffs
+
+      # All filenames in repo
+      attr_accessor :ls_files
+
+      # All current commits (sometimes empty)
+      attr_accessor :commits
+
+      # Commit message for current commit
+      attr_accessor :commit_message
+
+      # Commit message file for current commit
+      attr_accessor :commit_message_file
+    end
+
+    # Instances of Hook delegate these methods to the class methods.
+    HOOK_INFO = [ :files_changed, :file_contents, :file_diffs, :ls_files,
+                  :commits, :commit_message, :commit_message_file ]
+    HOOK_INFO.each do |info_method|
+      define_method(info_method) do |*args, &block|
+        Hook.send(info_method, *args, &block)
+      end
+    end
+
+    HOOK_TYPE_SETUP = {
+
+      # Pre-receive gets no args, but STDIN with a list of changes.
+      "pre-receive" => proc {
+        changes = []
+        STDIN.each_line do |line|
+          base, commit, ref = line.strip.split
+          changes.push [base, commit, ref]
+        end
+        self.commits = []
+
+        self.files_changed = []
+        self.file_contents = {}
+        self.file_diffs = {}
+
+        changes.each do |base, commit, ref|
+          no_base = false
+          if base =~  /\A0+\z/
+            # if base is 000... (initial commit), then all files were added, and git diff won't work
+            no_base = true
+            files_with_status = Hook.shell!("git ls-tree --name-status -r #{commit}").split("\n")
+            # put the A at the front
+            files_with_status.map!{|filename| "A\t" + filename}
+          else
+            files_with_status = Hook.shell!("git diff --name-status #{base}..#{commit}").split("\n")
+          end
+
+          files_with_status.each do |f|
+            status, file_changed = f.scan(/([ACDMRTUXB])\s+(\S+)$/).flatten
+            self.files_changed << file_changed
+
+            file_diffs[file_changed] = Hook.shell!("git log -p #{commit} -- #{file_changed}")
+            begin
+              file_contents[file_changed] = status == "D" ? "" : Hook.shell!("git show #{commit}:#{file_changed}")
+            rescue
+              # weird bug where some repos can't run the git show command even when it's not a deleted file.
+              # example: noah-gibbs/barkeep/test/fixtures/text_git_repo  I haven't figured out what's
+              # weird about it yet but this fails, so put in a hack for now.  May want to leave this since
+              # we'd rather continue without the changes than fail, right?
+              file_contents[file_changed] = ""
+            end
+          end
+          commit_range  = no_base ? commit : "#{base}..#{commit}"
+          new_commits = Hook.shell!("git log --pretty=format:%H #{commit_range}").split("\n")
+          self.commits = self.commits | new_commits
+        end
+
+        if !self.commits.empty?
+            file_list_revision =  self.commits.first # can't just use HEAD - remote may be on branch with no HEAD
+            self.ls_files = Hook.shell!("git ls-tree --full-tree --name-only -r #{file_list_revision}").split("\n")
+          # TODO should store ls_files per commit and ls_files with branch name (in case commits on multiple branches)?
+        end
+
+
+
+      },
+
+      "pre-commit" => proc {
+        files_with_status = Hook.shell!("git diff --name-status --cached").split("\n")
+
+        self.files_changed = []
+        self.file_contents = {}
+        self.file_diffs = {}
+        self.commits = []
+
+        files_with_status.each do |f|
+          status, file_changed = f.scan(/([ACDMRTUXB])\s+(\S+)$/).flatten
+          self.files_changed << file_changed
+         
+          file_diffs[file_changed] = Hook.shell!("git diff --cached -- #{file_changed}")          
+          file_contents[file_changed] = status == "D"? "": Hook.shell!("git show :#{file_changed}")
+        end
+
+        self.ls_files = Hook.shell!("git ls-files").split("\n")
+      },
+
+      "post-commit" => proc {
+        last_commit_files = Hook.shell!("git log --oneline --name-status -1")
+        # Split, cut off leading line to get actual files with status
+        files_with_status = last_commit_files.split("\n")[1..-1]
+
+        self.files_changed = []
+        self.commits = [ Hook.shell!("git log -n 1 --pretty=format:%H").chomp ]
+        self.file_contents = {}
+        self.file_diffs = {}
+
+        files_with_status.each do |f|
+          status, file_changed = f.scan(/([ACDMRTUXB])\s+(\S+)$/).flatten
+          self.files_changed << file_changed
+ 
+          file_diffs[file_changed] = Hook.shell!("git log --oneline -p -1 -- #{file_changed}")
+          file_contents[file_changed] = status == "D"? "": Hook.shell!("git show :#{file_changed}")
+        end
+
+        self.ls_files = Hook.shell!("git ls-files").split("\n")
+        self.commit_message = Hook.shell!("git log -1 --pretty=%B")
+      },
+
+      "commit-msg" => proc {
+        files_with_status = Hook.shell!("git diff --name-status --cached").split("\n")
+       
+        self.files_changed = []
+        self.file_contents = {}
+        self.file_diffs = {}
+        self.commits = []
+
+        files_with_status.each do |f|
+          status, file_changed = f.scan(/([ACDMRTUXB])\s+(\S+)$/).flatten
+          self.files_changed << file_changed
+
+          file_diffs[file_changed] = Hook.shell!("git diff --cached -- #{file_changed}")
+          file_contents[file_changed] = status == "D"? "": Hook.shell!("git show :#{file_changed}")
+       end
+
+        self.ls_files = Hook.shell!("git ls-files").split("\n")
+        self.commit_message = File.read(ARGV[0])
+        self.commit_message_file = ARGV[0]
+      }
+    }
+    HOOK_TYPE_SETUP["post-receive"] = HOOK_TYPE_SETUP["pre-receive"]
+
+    def self.initial_setup
+      return if @run_from
+
+      @run_from = Dir.getwd
+      @run_as = $0
+    end
+
+    def setup
+      Dir.chdir Hook.run_from do
+        yield
+      end
+
+    ensure
+      # Nothing yet
+    end
+
+    def self.get_hooks_to_run(hook_specs)
+      @registered_hooks ||= {}
+
+      if hook_specs.empty?
+        return @registered_hooks.values.inject([], &:+)
+      end
+
+      hook_specs.flat_map do |spec|
+        if @registered_hooks[spec]
+          @registered_hooks[spec]
+        elsif spec.is_a?(Hook)
+          [ spec ]
+        elsif spec.is_a?(String)
+          # A string is assumed to be a class name
+          @registered_hooks[Object.const_get(spec)]
+        else
+          raise "Can't find hook for specification: #{spec.inspect}!"
+        end
+      end
+    end
+
+    # Run takes a list of hook specifications.
+    # Those can be Hook classnames or instances of type
+    # Hook.
+    #
+    # @param hook_specs Array[Hook or Class or String] A list of hooks or hook classes
+    def self.run(*hook_specs)
+      if @has_run
+        STDERR.puts <<ERR
+In this version, you can't call .run more than once.  For now, please
+register your hooks individually and then call .run with no args, or
+else call .run with both as arguments.  This may be fixed in a future
+version.  Sorry!
+ERR
+        exit 1
+      end
+      @has_run = true
+
+      initial_setup
+
+      run_as_specific_githook
+
+      # By default, run all hooks
+      hooks_to_run = get_hooks_to_run(hook_specs.flatten)
+
+      failed_hooks = []
+      val = nil
+      hooks_to_run.each do |hook|
+        begin
+          hook.setup { val = hook.check }  # Re-init each time, just in case
+          failed_hooks.push(hook) unless val
+        rescue
+          # Failed.  Return non-zero if that makes a difference.
+          STDERR.puts "Hook #{hook.inspect} raised exception: #{$!.inspect}!\n#{$!.backtrace.join("\n")}"
+          failed_hooks.push hook
+        end
+      end
+
+      if CAN_FAIL_HOOKS.include?(@run_as_hook) && failed_hooks.size > 0
+        STDERR.puts "Hooks failed: #{failed_hooks}"
+        STDERR.puts "Use 'git commit -eF .git/COMMIT_EDITMSG' to restore your commit message" if commit_message
+        STDERR.puts "Exiting!"
+        exit 1
+      end
+    end
+
+    def self.run_as_specific_githook
+      return if @run_as_hook  # Already did this
+
+      self.initial_setup  # Might have already done this
+
+      if ARGV.include? "--hook"
+        idx = ARGV.find_index "--hook"
+        @run_as_hook = ARGV[idx + 1]
+        2.times { ARGV.delete_at(idx) }
+      else
+        @run_as_hook = HOOK_NAMES.detect { |hook| @run_as.include?(hook) }
+      end
+
+      unless @run_as_hook
+        STDERR.puts "Name #{@run_as.inspect} doesn't include " +
+          "any of: #{HOOK_NAMES.inspect}"
+        exit 1
+      end
+
+      unless HOOK_TYPE_SETUP[@run_as_hook]
+        STDERR.puts "No setup defined for hook type #{@run_as_hook.inspect}!"
+        exit 1
+      end
+      self.instance_eval(&HOOK_TYPE_SETUP[@run_as_hook])
+    end
+
+    def self.register(hook)
+      @registered_hooks ||= {}
+      @registered_hooks[hook.class.name] ||= []
+      @registered_hooks[hook.class.name].push hook
+
+      # Figure out when to set this up...
+      #at_exit do
+      #  unless RubyGitHooks::Hook.has_run
+      #    STDERR.puts "No call to RubyGitHooks.run happened, so no hooks ran!"
+      #  end
+      #end
+    end
+
+    def self.shell!(*args)
+      output = `#{args.join(" ")}`
+
+      unless $?.success?
+        STDERR.puts "Job #{args.inspect} failed in dir #{Dir.getwd.inspect}"
+        STDERR.puts "Failed job output:\n#{output}\n======"
+        raise "Exec of #{args.inspect} failed: #{$?}!"
+      end
+
+      output
+    end
+  end
+
+  # Forward these calls from RubyGitHooks to RubyGitHooks::Hook
+  class << self
+    [ :run, :register, :run_as ].each do |method|
+      define_method(method) do |*args, &block|
+        RubyGitHooks::Hook.send(method, *args, &block)
+      end
+    end
+  end
+
+  def self.shebang
+    ENV['RUBYGITHOOKS_SHEBANG']
+  end
+
+  def self.current_hook
+    RubyGitHooks::Hook.run_as_specific_githook
+    RubyGitHooks::Hook.run_as_hook
+  end
+end
+
+# Default to /usr/bin/env ruby for shebang line
+ENV['RUBYGITHOOKS_SHEBANG'] ||= "#!/usr/bin/env ruby"

data/ruby_git_hooks.gemspec

@@ -0,0 +1,37 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ruby_git_hooks/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ruby_git_hooks"
+  spec.version       = RubyGitHooks::VERSION
+  spec.authors       = ["Noah Gibbs", "Ruth Helfinstein", "Alex Snyatkov"]
+  spec.email         = ["noah@onlive.com", "ruth.helfinstein@onlive.com",
+                        "alex.snyatkov@onlive.com"]
+  spec.description   = <<DESC
+Ruby_git_hooks is a library to allow easy writing and installing of
+git hooks in Ruby.  It abstracts away the differences between
+different hook interfaces and supplies implementations of some common
+Git hooks.  It allows overriding "git clone" to automatically
+install your prefered hooks.
+DESC
+  spec.summary       = %q{DSL and manager for git hooks in Ruby.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  spec.bindir        = "bin"
+
+  spec.add_runtime_dependency "pony"  # For email
+  spec.add_runtime_dependency "rest-client"
+  spec.add_runtime_dependency "json"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "rr"
+  spec.add_development_dependency "rake"
+end

data/test/basic_hook_test.rb

@@ -0,0 +1,143 @@
+# Copyright (C) 2013 OL2, Inc. See LICENSE.txt for details.
+
+require "test_helper"
+
+require "minitest/autorun"
+
+class BasicHookTest < HookTestCase
+  REPOS_DIR = File.expand_path File.join(File.dirname(__FILE__), "repos")
+  TEST_PATH = File.join(REPOS_DIR, "hook_test_file")
+  TEST_HOOK_BODY = <<HOOK
+#{RubyGitHooks.shebang}
+require "ruby_git_hooks"
+
+class TestHook < RubyGitHooks::Hook
+  def check
+    File.open("#{TEST_PATH}", "w") do |f|
+      f.puts files_changed.inspect, file_contents.inspect
+    end
+    
+    puts "Test hook runs!"
+    true
+  end
+end
+
+RubyGitHooks.run TestHook.new
+HOOK
+
+  TEST_HOOK_COMMIT_MSG = <<HOOK
+#{RubyGitHooks.shebang}
+require "ruby_git_hooks"
+
+class TestHook < RubyGitHooks::Hook
+  def check
+    File.open("#{TEST_PATH}", "w") do |f|
+      f.puts commit_message
+    end
+    
+    puts "Test hook runs!"
+    true
+  end
+end
+
+RubyGitHooks.run TestHook.new
+HOOK
+
+  def setup(do_first_commit = true)
+    # Empty out the test repos dir
+    Hook.shell! "rm -rf #{File.join(REPOS_DIR, "*")}"
+
+    # Create local parent and child repos with a single shared commit
+    Dir.chdir REPOS_DIR
+
+    new_bare_repo
+    clone_repo
+    if do_first_commit
+      new_single_file_commit
+      git_push
+    end
+  end
+
+  def test_simple_pre_commit
+    add_hook("child_repo", "pre-commit", TEST_HOOK_BODY)
+
+    new_single_file_commit "child_repo"
+
+    assert File.exist?(TEST_PATH), "Test pre-commit hook didn't run!"
+    assert File.read(TEST_PATH).include?("Single-file commit"),
+      "No file contents reached pre-commit hook!"
+  end
+  
+  def test_pre_commit_with_delete
+    add_hook("child_repo", "pre-commit", TEST_HOOK_BODY)
+    new_commit "child_repo", "file_to_delete"
+    git_delete "child_repo", "file_to_delete"
+    git_commit "child_repo", "Deleted file_to_delete"
+
+    assert File.exist?(TEST_PATH), "Test pre-commit hook didn't run!"
+    assert File.read(TEST_PATH).include?('"file_to_delete"=>""'),
+      "File not deleted properly"
+  end
+
+    def test_pre_commit_with_rename
+    add_hook("child_repo", "pre-commit", TEST_HOOK_BODY)
+    new_commit "child_repo", "file_to_rename"
+    git_rename "child_repo", "file_to_rename", "renamed_file"
+    new_commit "child_repo", "renamed_file", nil, "Renamed file"
+
+    assert File.exist?(TEST_PATH), "Test pre-commit hook didn't run!"
+    assert File.read(TEST_PATH).include?('"file_to_rename"=>""'),
+      "File not deleted properly"
+  end
+
+  def test_simple_pre_receive
+    add_hook("parent_repo.git", "pre-receive", TEST_HOOK_BODY)
+
+    new_single_file_commit "child_repo"
+    git_push("child_repo")
+
+    assert File.exist?(TEST_PATH), "Test pre-receive hook didn't run!"
+    assert File.read(TEST_PATH).include?("Single-file commit"),
+      "No file contents reached pre-receive hook!"
+  end
+
+
+  def test_pre_receive_with_delete
+    add_hook("parent_repo.git", "pre-receive", TEST_HOOK_BODY)
+
+    new_commit "child_repo", "file_to_delete"
+    git_push "child_repo"
+
+    
+    git_delete "child_repo", "file_to_delete"
+    git_commit "child_repo", "Deleted file_to_delete"
+    git_push "child_repo"
+
+
+    assert File.exist?(TEST_PATH), "Test pre-receive hook didn't run!"
+    assert File.read(TEST_PATH).include?('"file_to_delete"=>""'),
+      "File deletion did not reach pre-receive hook!"
+  end
+
+  def test_commit_msg
+    add_hook("child_repo", "commit-msg", TEST_HOOK_COMMIT_MSG)
+    new_commit "child_repo", "my_file", "Commit contents", "This is my commit message"
+    assert File.exist?(TEST_PATH), "Test commit-msg hook didn't run!"
+    assert File.read(TEST_PATH).include?("This is my commit message"),
+      "Commit message did not reach commit-msg hook"
+  end
+
+  def test_post_commit_has_commit_msg
+    add_hook("child_repo", "post-commit", TEST_HOOK_COMMIT_MSG)
+    new_commit "child_repo", "my_file", "Commit contents", "This is my commit message"
+    assert File.exist?(TEST_PATH), "Test post-commit hook didn't run!"
+    assert File.read(TEST_PATH).include?("This is my commit message"),
+      "Commit message did not reach post-commit hook"
+  end
+
+  def test_first_pre_receive
+      setup(false)  # don't do first commit
+      test_simple_pre_receive
+  end
+
+end

data/test/case_clash_hook_test.rb

@@ -0,0 +1,58 @@
+# Copyright (C) 2013 OL2, Inc. See LICENSE.txt for details.
+
+require "test_helper"
+
+require "minitest/autorun"
+
+class CaseClashHookTest < HookTestCase
+  REPOS_DIR = File.expand_path File.join(File.dirname(__FILE__), "repos")
+  TEST_HOOK_BODY = <<TEST
+#{RubyGitHooks.shebang}
+require "ruby_git_hooks/case_clash"
+
+RubyGitHooks.run CaseClashHook.new
+TEST
+
+  def setup
+    # Empty out the test repos dir
+    Hook.shell! "rm -rf #{File.join(REPOS_DIR, "*")}"
+
+    # Create local parent and child repos with a single shared commit
+    Dir.chdir REPOS_DIR
+
+    new_bare_repo
+    clone_repo
+    new_commit "child_repo", "README"
+    git_push
+  end
+
+  def test_case_clash_pre_commit
+    add_hook("child_repo", "pre-commit", TEST_HOOK_BODY)
+
+    new_commit "child_repo", "CaseClashFile1"
+    case1_sha = last_commit_sha
+    rewind_one_commit
+
+    new_commit "child_repo", "CASECLASHFILE1"
+    case2_sha = last_commit_sha
+
+    # Cherry-pick new content into place -- this means both files.
+    Hook.shell!("cd child_repo && git cherry-pick #{case1_sha}")
+    case_both = last_commit_sha
+
+    rewind_one_commit
+
+    # Soft-reset so content is still present
+    Hook.shell!("cd child_repo && git reset #{case_both}")
+
+    # Should reject w/ pre-commit hook
+    assert_raises RuntimeError do
+      Hook.shell!("cd child_repo && git commit -m \"Message\"")
+    end
+  end
+
+  #def test_case_clash_pre_receive
+  #  add_hook("parent_repo.git", "pre-receive", TEST_HOOK_BODY)
+  #end
+
+end