raincoat 0.1

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2010 Ryan Burrows
+
+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.markdown

@@ -0,0 +1,66 @@
+# Raincoat
+
+    http://github.com/rhburrows/raincoat
+
+## Intro
+
+Git hooks are scripts that git runs before and after it call some
+commands. They can be specified by placing executable files in the
+`.git/hooks` directory and naming them according to a certain
+convention. However, the `.git/hooks` directory is not distributed
+with the git repository, so any hooks that you install must be
+reinstalled every time you or anyone else clones the project.
+
+## Installation
+
+Raincoat can be installed through rubygems.
+
+    gem install raincoat
+
+If you wish to run the tests, or build the documentation you will also
+need to install rspec, cucumber, and yard
+
+## Usage
+
+The first step is to initialize the raincoat hooks in your
+project. This can be done by running the following command from the
+root directory of your project.
+
+    raincoat install
+
+At this time existing git-hooks that you have may be wiped out so be
+sure to back up any hooks that you want to save.
+
+Raincoat works by looking in your script directory for the directory
+with the same name as the hook being executed, and then it runs each
+command in there. For example, the when the `pre-commit` hook is
+executed it will look in `<script_dir>/pre-commit` and run each script
+in there.
+
+By default the script directory is set to `script` but a different
+script directory can be specified by passing it to the
+install command:
+
+    raincoat install hooks
+
+This would create a hooks directory where all of the hook scripts
+could be placed.
+
+## Anatomy of a Raincoat Script
+
+Raincoat expects each of the scripts within the various hook
+directories to follow two conventions.
+
+1. Define a class with a name corresponding to the file name
+  i.e. `email_changes.rb` should contain a class called `EmailChanges`
+2. The defined call should respond to the `call` method with one
+  parameter
+
+The parameter that is passed to the `call` method is a string
+representation of the change that is being made in git. For example in
+the case of `pre-commit` it is the difference between the files that
+are currently staged and the `HEAD` commit.
+
+## TODO
+
+* Add support for additional git-hooks

data/Rakefile

@@ -0,0 +1,73 @@
+require 'rubygems'
+
+spec = Gem::Specification.new do |s|
+  s.name = 'raincoat'
+  s.version = '0.1'
+  s.platform = Gem::Platform::RUBY
+  s.summary = 'Easily define git-hooks that can be passed with your project'
+  s.description = s.summary
+  s.author = 'Ryan Burrows'
+  s.email = 'rhburrows@gmail.com'
+  s.homepage = 'http://github.com/rhburrows/raincoat'
+  s.require_path = 'lib'
+  s.files = %w[LICENSE README.markdown Rakefile] + Dir.glob("{bin,lib}/**/*")
+  s.bindir = 'bin'
+  s.executables = ['raincoat']
+end
+
+spec_file = "#{spec.name}.gemspec"
+desc "Create #{spec_file}"
+file spec_file => "Rakefile" do
+  File.open(spec_file, "w") do |file|
+    file.puts spec.to_ruby
+  end
+end
+
+begin
+  require 'rake/gempackagetask'
+rescue LoadError
+  task(:gem){ $stderr.puts "`gem install rake` to package gems" }
+else
+  Rake::GemPackageTask.new(spec) do |pkg|
+    pkg.gem_spec = spec
+  end
+  task :gem => spec_file
+end
+
+desc "install the gem locally"
+task :install => :package do
+  `gem install pkg/#{spec.name}-#{spec.version}`
+end
+
+begin
+  require 'spec/rake/spectask'
+  Spec::Rake::SpecTask.new do |t|
+    t.spec_files = FileList['spec/**/*_spec.rb']
+  end
+rescue LoadError
+  task(:spec){ $stderr.puts "`gem install rspec` to run specs." }
+end
+
+task :default => [:spec, :features]
+
+begin
+  require 'cucumber'
+  require 'cucumber/rake/task'
+  Cucumber::Rake::Task.new(:features) do |t|
+    t.cucumber_opts = "features --format pretty"
+  end
+rescue LoadError
+  task(:features){ $stderr.puts "`gem install cucumber` to run features." }
+end
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new do |t|
+    t.files   = ['lib/**/*.rb']
+    t.options = [ '--protected',
+                  '--files', 'History.txt',
+                  '--title', 'raincoat' ]
+  end
+rescue LoadError
+  task(:yard){ $stderr.puts "`gem install yard` to build documentation." }
+end

data/bin/raincoat

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+raincoat_dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(raincoat_dir) unless $LOAD_PATH.include?(raincoat_dir)
+require 'raincoat'
+
+unless ARGV[0] == 'install'
+  $stderr.puts "raincoat only supports installation. Try `raincoat install <script_dir>`"
+  exit 1
+end
+
+script_dir = ARGV[1] || "script"
+Raincoat::Installer.new(script_dir).install

data/lib/raincoat.rb

@@ -0,0 +1,4 @@
+require 'raincoat/hook'
+require 'raincoat/script_writer'
+require 'raincoat/installer'
+require 'raincoat/diff_utils'

data/lib/raincoat/diff_utils.rb

@@ -0,0 +1,33 @@
+module Raincoat
+  # A set of utility methods that shell out to git to find changes that have
+  # been made to the code. These changes can then be passed to the various
+  # hook scripts that have been set up
+  #
+  # @author Ryan Burrows
+  class DiffUtils
+    class << self
+
+      # Returns the diff between all staged changes and the current head
+      #
+      # @return [String] a string representation of the difference between
+      #                  the staged changes and the head
+      def precommit_diff
+        execute "git diff --cached"
+      end
+
+      # Returns the diff between the current head and the previous head
+      #
+      # @return [String] a string representation of the difference between
+      #                  the current head and the previous head
+      def postcommit_diff
+        execute "git diff HEAD^"
+      end
+
+      private
+
+      def execute(cmd)
+        `#{cmd}`
+      end
+    end
+  end
+end

data/lib/raincoat/hook.rb

@@ -0,0 +1,60 @@
+module Raincoat
+  # The superclass for the various hooks that are installed to be run by git.
+  # subclasses of Hook should override git_diff to generate the correct diff
+  # string so that it can be passed to the hook scripts.
+  #
+  # @author Ryan Burrows
+  class Hook
+    attr_reader :script_dir
+
+    # Create a new hook object that will execute the scripts located in
+    # script_dir
+    #
+    # @param [String] script_dir the path of the directory of scripts that
+    #                 this hook executes
+    def initialize(script_dir)
+      @script_dir = script_dir
+    end
+
+    # This is called when the hook is executed by git's callbacks. It loads
+    # each file in the script_dir and creates an instance of the defined class
+    # call is then called on the instance being passed the result of git_diff.
+    #
+    # @return [Integer] the sum of the exit statuses of all executed scripts.
+    #                   This number becomes the overall exit status of the hook.
+    def run
+      diff = git_diff.freeze
+      scripts.inject(0) do |result, script|
+        result + script.call(diff)
+      end
+    end
+
+    # This loads all of the scripts in the script dir and instantiates the
+    # objects.
+    #
+    # @return [Array] the list of newly created objects
+    def scripts
+      Dir.glob(File.join(script_dir, "*.rb")).inject([]) do |a, e|
+        Kernel.load(e)
+        a + [initialize_script(e)]
+      end
+    end
+
+    # Should be overridden by subclass to express the diff between the two
+    # git states that are being transitioned between.
+    def git_diff
+      ""
+    end
+
+    private
+
+    def initialize_script(script_name)
+      Object.const_get(class_name_for(script_name)).new
+    end
+
+    # Just like ActiveSupport's #classify
+    def class_name_for(file_name)
+      file_name.split(/\//).last.sub(/\.rb$/, '').split(/_/).map{ |s| s.capitalize }.join('')
+    end
+  end
+end

data/lib/raincoat/installer.rb

@@ -0,0 +1,32 @@
+module Raincoat
+  # Installs the raincoat hooks into the .git directory of the current
+  # project.
+  #
+  # @author Ryan Burrows
+  class Installer
+    # The list of currently supported hooks
+    HOOKS = [ "pre-commit", "post-commit" ]
+
+    # Create an installer that watches scripts contained within script_dir
+    #
+    # @param [String] script_dir the path to the directory where the various
+    #                 scripts that raincoat will run are put.
+    def initialize(script_dir)
+      @script_dir = script_dir
+    end
+    
+    # Install raincoat hooks in the current project for each of the supported
+    # git-hook types. This will create the corresponding script directory if
+    # it doesn't exist
+    def install
+      unless File.directory?(@script_dir)
+        FileUtils.mkdir_p(@script_dir)
+      end
+
+      writer = ScriptWriter.new(@script_dir)
+      HOOKS.each do |hook|
+        writer.write(hook)
+      end
+    end
+  end
+end

data/lib/raincoat/script_writer.rb

@@ -0,0 +1,69 @@
+require 'erb'
+
+module Raincoat
+  # This class generates and writes out the actual git-hook files into the
+  # project's .git directory.
+  #
+  # @author Ryan Burrows
+  class ScriptWriter
+
+    # The directory where git stores it's hooks
+    GIT_HOOK_DIR = File.join(".git","hooks")
+
+    # Create a new ScriptWriter that creates hooks that executes the scripts
+    # in script_dir
+    #
+    # @param [String] script_dir the path to the directory where the various
+    #                 scripts exist
+    def initialize(script_dir)
+      @script_dir = script_dir
+    end
+
+    # Write a new hook to the git directory called hook_name. Also, if there
+    # isn't a corresponding 'hook_name' directory in the script_dir it will
+    # be created.
+    #
+    # @param [String] hook_name the name of the git-hook to write this file for
+    def write(hook_name)
+      init_script_directory(File.join(@script_dir, hook_name))
+      path = File.join(GIT_HOOK_DIR, hook_name)
+      File.open(path, "w") do |f|
+        f.puts(build_script(hook_name))
+      end
+      FileUtils.chmod 0777, path
+    end
+
+    # Generate the script that is going to be written in the git-hook file.
+    #
+    # @param [String] hook_name the name of the git-hook to build a script for
+    def build_script(hook_name)
+      hook_type = hook_name.sub(/-/, '')
+      script_dir = File.join(@script_dir, hook_name)
+      ERB.new(DEFAULT_TEMPLATE).result(binding)
+    end
+
+    private
+
+    def init_script_directory(dir)
+      unless File.directory? dir
+        FileUtils.mkdir_p dir
+      end
+    end
+
+    DEFAULT_TEMPLATE = <<TEMPLATE
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'raincoat'
+
+class ActiveHook < Raincoat::Hook
+  def git_diff
+    Raincoat::DiffUtils.<%= hook_type %>_diff
+  end
+end
+
+puts "RUNNING!"
+exit(ActiveHook.new("<%= script_dir %>").run)
+
+TEMPLATE
+  end
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification 
+name: raincoat
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- Ryan Burrows
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-19 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: Easily define git-hooks that can be passed with your project
+email: rhburrows@gmail.com
+executables: 
+- raincoat
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- LICENSE
+- README.markdown
+- Rakefile
+- bin/raincoat
+- lib/raincoat/diff_utils.rb
+- lib/raincoat/script_writer.rb
+- lib/raincoat/installer.rb
+- lib/raincoat/hook.rb
+- lib/raincoat.rb
+has_rdoc: true
+homepage: http://github.com/rhburrows/raincoat
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+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: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Easily define git-hooks that can be passed with your project
+test_files: []
+