git_hooks 0.2.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Dirk Breuer
+
+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.rdoc

@@ -0,0 +1,31 @@
+= git-hooks
+
+This is a small library which allows you to easily build Git hooks. The
+interaction with Git is done through the Grit library, which allows a clean
+and straight forward Ruby way of talking with Git.
+
+== Config Example
+
+    :post_receive_hooks:
+    -  :jabber:
+        :jid: JABBER_USERNAME
+        :password: JABBER_PASSWORD
+        :server: JABBER_SERVER
+        :recipients: [ "recipient@jabber.id" ]
+  
+    -  :pivotal_tracker:
+        :api_key: API_KEY
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Dirk Breuer. See LICENSE for details.

data/bin/hook-post-receive

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'git_hooks'
+
+# will receive something like this: 034e985b8c1df2869aff99017b66600acb052617 462b4131bf6dd2fea41e3959b2b22380fd10be99 refs/heads/master
+
+GitHooks::Logger.info "running hooks (#{File.basename(__FILE__)}) ..."
+
+GitHooks.run_hook(:post_receive)

data/lib/git_hooks.rb

@@ -0,0 +1,30 @@
+$:.unshift File.dirname(__FILE__) # For use/testing when no gem is installed
+
+require 'active_support/core_ext/string'
+
+require 'git_hooks/notifier'
+require 'git_hooks/git_adapter'
+require 'git_hooks/post_receive_hook'
+require 'git_hooks/logger'
+require 'git_hooks/utils'
+
+module GitHooks
+  
+  class <<self
+    attr_writer :config_file
+    
+    def config
+      @config_instance ||= Utils::Config.new(config_file)
+    end
+    
+    def config_file
+      @config_file || "~/.git_hooks_config"
+    end
+
+    def run_hook(name_of_hook, *args)
+      hook = "GitHooks::#{name_of_hook.to_s.camelize}Hook".constantize.new
+      hook.run(*args)
+    end
+  end
+  
+end

data/lib/git_hooks/git_adapter.rb

@@ -0,0 +1,68 @@
+require 'grit'
+
+module GitHooks
+  class GitAdapter
+    include Grit
+    
+    class Commits
+      include Enumerable
+      
+      attr_reader :ref_name, :repo_name
+      
+      def initialize(commits, ref_name, repo)
+        @commits       = commits
+        self.ref_name  = ref_name
+        self.repo_name = repo
+      end
+      
+      def each
+        @commits.each { |commit| yield commit }
+      end
+      
+      def size
+        @commits.size
+      end
+      
+      private
+      
+        def ref_name=(ref_name)
+          @ref_name ||= ref_name.split("/").last
+        end
+        
+        def repo_name=(repo)
+          return @repo if @repo
+          
+          splitted_path = repo.path.split("/")
+          @repo_name = if (splitted_path.last =~ /\.git/) > 0
+            splitted_path.last.split(".").first
+          else
+            splitted_path[-2]
+          end
+        end
+      
+    end
+    
+    attr_reader :repo
+
+    def initialize
+      @repo = Repo.new(GitAdapter.find_git_root)
+    end
+
+    def find_commits_since_last_receive(prev_rev, current_rev, ref_name = 'master')
+      commits = repo.commits_between(prev_rev, current_rev)
+
+      return Commits.new(commits, ref_name, @repo)
+    end
+
+    def self.find_git_root
+      current_dir = Dir.pwd.split('/')
+      while current_dir.last !~ /\.git/
+        current_dir.pop
+        break if current_dir.empty?
+      end
+
+      return current_dir.join('/')
+    end
+
+  end
+end

data/lib/git_hooks/logger.rb

@@ -0,0 +1,23 @@
+require 'logger'
+
+module GitHooks
+  class Logger
+    include Singleton
+
+    class <<self
+      def method_missing(meth, *args, &blk)
+        if instance.logger.respond_to? meth
+          instance.logger.send(meth, *args)
+        else
+          super
+        end
+      end
+    end
+
+    attr_reader :logger
+
+    def initialize
+      @logger = ::Logger.new("/tmp/git_hooks.log")
+    end
+  end
+end

data/lib/git_hooks/notifier.rb

@@ -0,0 +1,2 @@
+require 'git_hooks/notifier/jabber_client'
+require 'git_hooks/notifier/tracker_client'

data/lib/git_hooks/notifier/jabber_client.rb

@@ -0,0 +1,99 @@
+require 'xmpp4r'
+require 'xmpp4r/roster'
+
+module GitHooks
+  module Notifier
+    class JabberClient
+      include Jabber
+      
+      class Buddy
+        attr_reader :jid
+
+        def initialize(jid, roster_reference)
+          @jid = Jabber::JID.new(jid)
+          @roster = roster_reference
+        end
+
+        def subscribed?
+          roster_item = @roster[jid]
+          if roster_item
+            return roster_item.subscription == :both ? true : false
+          end
+        end
+      end
+
+      def initialize(jabber_options)
+        @jabber_options = jabber_options
+        init_jabber_backend!
+      end
+
+      def create_recipients(recipients)
+        [recipients].flatten.map do |recipient|
+          recipient.is_a?(Buddy) ? recipient : Buddy.new(recipient, roster)
+        end
+      end
+      
+      def buddies
+        roster.items.map { |roster_item| Buddy.new(roster_item.last.jid, roster) }
+      end
+
+      def roster
+        @roster ||= Roster::Helper.new(backend)
+      end
+      
+      def self.deliver(options)
+        commits    = options.delete(:commits)
+        recipients = options.delete(:recipients)
+
+        client_instance = new(options)
+        client_instance.deliver(commits, recipients)
+      end
+
+      def deliver(commits, recipients)
+        send_message_to create_message(commits), recipients
+        true
+      end
+      
+      private unless $TESTING
+      
+        def init_jabber_backend!
+          @backend = Client.new(JID.new(@jabber_options[:jid]))
+          @backend.connect(@jabber_options[:server])
+          @backend.auth(@jabber_options[:password])
+        end
+      
+        def backend
+          @backend
+        end
+
+        def create_message(from_commits)
+          message = "[#{GitHooks::Utils.hostname}] #{from_commits.size} commits have been pushed to '#{from_commits.repo_name}' on '#{from_commits.ref_name}':\n"
+          from_commits.each do |commit|
+            message << "\t#{commit.id[0...5]}...: '#{commit.short_message}' by #{commit.author.name}\n"
+          end
+
+          message
+        end
+        
+        def request_authorization_of(recipient)
+          request      = Jabber::Presence.new
+          request.to   = recipient.respond_to?(:jid) ? recipient.jid : recipient
+          request.type = :subscribe
+          backend.send request
+        end
+
+        def send_message_to(message, recipients)
+          create_recipients(recipients).each do |recipient|
+            subject = "Git commit notification"
+
+            request_authorization_of(recipient) unless recipient.subscribed?
+
+            msg = Message::new(recipient.jid, message).set_type(:normal).set_id('1').set_subject(subject)
+            GitHooks::Logger.debug "msg: #{msg}"
+            backend.send msg
+          end
+        end
+
+    end
+  end
+end

data/lib/git_hooks/notifier/tracker_client.rb

@@ -0,0 +1,45 @@
+require 'curb'
+
+module GitHooks
+  module Notifier
+    class TrackerClient
+      
+      attr_reader :curl
+
+      def self.deliver(options)
+        commits = options.delete(:commits)
+
+        client_instance = new(options)
+        client_instance.deliver(commits)
+      end
+      
+      def initialize(tracker_options)
+        @curl = Curl::Easy.new("http://www.pivotaltracker.com/services/v3/source_commits") do |curl| 
+          curl.headers["X-TrackerToken"] = tracker_options[:api_key]
+          curl.headers["Content-type"] = "application/xml"
+        end
+      end
+
+      def deliver(commits)
+        create_payloads(commits) do |payload|
+          curl.http_post(payload)
+        end
+      end
+      
+      def create_payloads(commits, &block)
+        payloads = commits.map do |commit|
+          <<-XML
+<source_commit>
+<message>#{commit.message}</message>
+<author>#{commit.author.name}</author>
+<commit_id>#{commit.id}</commit_id>
+</source_commit>
+          XML
+        end
+        
+        payloads.each(&block)
+      end
+      
+    end
+  end
+end

data/lib/git_hooks/post_receive_hook.rb

@@ -0,0 +1,28 @@
+module GitHooks
+  class PostReceiveHook
+    
+    def initialize
+      @git_adapter = GitAdapter.new
+    end
+    
+    def run(*args)
+      arguments = read_arguments_from_stdin
+      commits   = @git_adapter.find_commits_since_last_receive(*arguments)
+      
+      GitHooks.config.post_receive_hooks.each do |hook|
+        hook.hook_class.deliver(hook.options.merge(:commits => commits))
+      end
+    end
+    
+    def read_arguments_from_stdin
+      arguments = []
+      
+      while arguments << STDIN.gets
+        break if arguments.last.nil?
+      end
+      
+      arguments.compact.first.split(" ")
+    end
+  end
+  
+end

data/lib/git_hooks/utils.rb

@@ -0,0 +1,13 @@
+require 'git_hooks/utils/config'
+
+module GitHooks
+  module Utils
+
+    class <<self
+      def hostname
+        `hostname -s`.strip
+      end
+    end
+    
+  end
+end

data/lib/git_hooks/utils/config.rb

@@ -0,0 +1,57 @@
+require 'yaml'
+
+module GitHooks
+  module Utils
+
+    class Config
+      
+      class HookWrapper
+        
+        attr_reader :options
+        
+        def initialize(options)
+          @hook_class_name = options.keys.first
+          @options = options.values.first
+        end
+        
+        def hook_class
+          @hook_class ||= "GitHooks::Notifier::#{@hook_class_name.to_s.camelize}Client".constantize
+        end
+        
+      end
+      
+      attr_reader :config
+      
+      def initialize(config_file)
+        @config = if config_file.respond_to?(:read)
+          YAML.load(config_file.read)
+        else
+          YAML.load_file(File.expand_path(config_file))
+        end
+      rescue Errno::ENOENT
+        GitHooks::Logger.error("Config File '#{config_file}' couldn't be loaded!")
+        raise "Config File '#{config_file}' couldn't be loaded!"
+      end
+      
+      def method_missing(hook_name, *args, &blk)
+        if hook_definitions = config[hook_name]
+
+          hooks = hook_definitions.map { |hook_definition| HookWrapper.new(hook_definition) }
+          instance_variable_set("@#{hook_name}", hooks)
+          
+          instance_eval <<-RUBY
+          def #{hook_name}
+            @#{hook_name}
+          end
+          RUBY
+          
+          send(hook_name)
+        else
+          super
+        end
+      end
+      
+    end
+
+  end
+end

data/spec/config_spec.rb

@@ -0,0 +1,74 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Utils" do
+  
+  describe "Config" do
+    
+    it "should have read from a config file located in the home directory" do
+      File.should_receive(:expand_path).with("~/.git_hooks_config").and_return(path_to_config = "/Users/dbreuer/.git_hooks_config")
+      YAML.should_receive(:load_file).with(path_to_config).and_return({:post_receive_hooks => [{:jabber => {:jid => "jabber@example.com", :password => "password"}}]})
+      
+      config_instance = GitHooks::Utils::Config.new("~/.git_hooks_config")
+    end
+    
+    it "should alternatively init the config from a YAML StringIO" do
+      config_yaml = StringIO.new <<-YAML
+      :post_receive_hooks:
+      -  :jabber:
+          :jid: JABBER_USERNAME
+          :password: JABBER_PASSWORD
+          :server: JABBER_SERVER
+          :recipients:
+            :group: [ "recipient@jabber.id" ]
+
+      -  :pivotal_tracker:
+          :api_key: API_KEY
+      YAML
+      
+      config_instance = GitHooks::Utils::Config.new(config_yaml)
+      config_instance.config.should be_a_kind_of(Hash)
+    end
+    
+    it "should return all available hooks as an array of hook wrapper classes" do
+      GitHooks.config.post_receive_hooks.each do |hook|
+        hook.should be_a_kind_of(GitHooks::Utils::Config::HookWrapper)
+      end
+    end
+    
+    describe "HookWrapper" do
+      
+      before(:each) do
+        hook_options = {
+          :jabber => {
+            :jid        => "jabber@example.com",
+            :password   => "password",
+            :recipients => [
+              "bender.rodriguez@planetexpress.com"
+            ]
+          }
+        }
+
+        @hook_wrapper = GitHooks::Utils::Config::HookWrapper.new(hook_options)
+      end
+      
+      it "should know its backing class" do
+        @hook_wrapper.hook_class.should == GitHooks::Notifier::JabberClient
+      end
+      
+      it "should know the options for this hook" do
+        expected_options = {
+          :jid        => "jabber@example.com",
+          :password   => "password",
+          :recipients => [
+            "bender.rodriguez@planetexpress.com"
+          ]
+        }
+        
+        @hook_wrapper.options.should == expected_options
+      end
+      
+    end
+    
+  end
+  
+end

data/spec/git_adapter_spec.rb

@@ -0,0 +1,28 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "GitAdapter" do
+  it "should initialize with a Grit repository" do
+    GitHooks::GitAdapter.should_receive(:find_git_root)
+    Grit::Repo.should_receive(:new)
+    
+    git_adapter = GitHooks::GitAdapter.new
+  end
+  
+  it "should find the Git root directory based on the current directory" do
+    git_adapter = GitHooks::GitAdapter.new
+    commits = git_adapter.find_commits_since_last_receive("7eb08614", "58c3455c")
+    commits.size.should be(2)
+    commits.ref_name.should == "master"
+    commits.repo_name.should =~ /(git_hooks|workspace)/
+  end
+  
+  it "should find commits since last commit" do
+    Dir.should_receive(:pwd).and_return("/srv/example.com/git/repositories/git_hooks.git/hooks")
+    git_root = GitHooks::GitAdapter.find_git_root
+    git_root.should == "/srv/example.com/git/repositories/git_hooks.git"
+    
+    Dir.should_receive(:pwd).and_return("/home/dbreuer/projects/git_hooks/.git/hooks")
+    git_root = GitHooks::GitAdapter.find_git_root
+    git_root.should == "/home/dbreuer/projects/git_hooks/.git"
+  end
+end

data/spec/git_hooks_spec.rb

@@ -0,0 +1,22 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "GitHooks" do
+
+  it "should run a hook identified by a symbol" do
+    post_receive_hook_mock = mock("PostReceiveHook")
+    post_receive_hook_mock.should_receive(:run)
+    GitHooks::PostReceiveHook.should_receive(:new).and_return(post_receive_hook_mock)
+    
+    GitHooks.run_hook(:post_receive)
+  end
+  
+  it "should provide access to a config instance" do
+    GitHooks.config.should be_a_kind_of(GitHooks::Utils::Config)
+  end
+  
+  it "should provide a setter for the config file path" do
+    GitHooks.config_file = "/path/to/config.yml"
+    GitHooks.config_file.should == "/path/to/config.yml"
+  end
+
+end

data/spec/jabber_client_spec.rb

@@ -0,0 +1,122 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "JabberClient" do
+  
+  describe "Buddy" do
+    
+    it "should have a JID and a roster reference" do
+      buddy = GitHooks::Notifier::JabberClient::Buddy.new("lela.starr@jabber.org", mock("RosterMock"))
+      buddy.jid.should be_a_kind_of(Jabber::JID)
+    end
+    
+    it "should should know if already subscribed" do
+      roster_mock = mock("RosterMock")
+
+      roster_mock.should_receive(:[]).with(Jabber::JID.new("lela.starr@jabber.org")).and_return(mock("RosterItemMock", :subscription => :both))
+      buddy = GitHooks::Notifier::JabberClient::Buddy.new("lela.starr@jabber.org", roster_mock)
+      buddy.subscribed?.should be(true)
+      
+      roster_mock.should_receive(:[]).with(Jabber::JID.new("lela.starr@jabber.org")).and_return(mock("RosterItemMock", :subscription => :none))
+      buddy = GitHooks::Notifier::JabberClient::Buddy.new("lela.starr@jabber.org", roster_mock)
+      buddy.subscribed?.should be(false)
+    end
+    
+  end
+  
+  before(:each) do
+    @jabber_client_opts = GitHooks.config.post_receive_hooks.first.options
+  end
+  
+  it "should initialize with a XMPP client" do
+    Jabber::JID.should_receive(:new).and_return(jid_mock = mock("JIDMock"))
+    Jabber::Client.should_receive(:new).with(jid_mock).and_return(client_mock = mock("ClientMock"))
+    client_mock.should_receive(:connect).with("JABBER_SERVER")
+    client_mock.should_receive(:auth)
+    
+    jabber_client = GitHooks::Notifier::JabberClient.new(@jabber_client_opts)
+  end
+  
+  it "should transform a collection of Jabber IDs to Buddy objects" do
+    GitHooks::Notifier::JabberClient.any_instance.stubs(:init_jabber_backend!)
+    jabber_client = GitHooks::Notifier::JabberClient.new(@jabber_client_opts)
+    jabber_client.should_receive(:roster)
+
+
+    jabber_client.create_recipients(["bender.rodriguez@planetexpress.com"]).each do |buddy|
+      buddy.should be_a_kind_of(GitHooks::Notifier::JabberClient::Buddy)
+    end
+  end
+  
+  it "should not transform recipients that are already Buddy objects" do
+    GitHooks::Notifier::JabberClient.any_instance.stubs(:init_jabber_backend!)
+    jabber_client = GitHooks::Notifier::JabberClient.new(@jabber_client_opts)
+    jabber_client.should_receive(:roster)
+
+    buddy = GitHooks::Notifier::JabberClient::Buddy.new("fry@planetexpress.com", nil)
+
+    jabber_client.create_recipients(["bender.rodriguez@planetexpress.com", buddy]).each do |buddy|
+      buddy.should be_a_kind_of(GitHooks::Notifier::JabberClient::Buddy)
+    end
+  end
+  
+  it "should have a list of buddies" do
+    GitHooks::Notifier::JabberClient.any_instance.stubs(:init_jabber_backend!)
+    jabber_client = GitHooks::Notifier::JabberClient.new(@jabber_client_opts)
+    jabber_client.should_receive(:roster).
+      at_least(2).times.
+      and_return(roster_mock = mock("RosterMock"))
+
+    GitHooks::Notifier::JabberClient::Buddy.should_receive(:new).
+      with("lela.starr@jabber.org", roster_mock).
+      and_return(lela_starr = mock("BuddyMock"))
+
+    roster_mock.should_receive(:items).
+      and_return({:jabber_internal => mock("RosterItem", :jid => "lela.starr@jabber.org")})
+    
+    jabber_client.buddies.should == [lela_starr]
+  end
+  
+  it "should create a message out of a bunch of commits" do
+    GitHooks::Notifier::JabberClient.any_instance.stubs(:init_jabber_backend!)
+    jabber_client = GitHooks::Notifier::JabberClient.new(@jabber_client_opts)
+
+    commit = mock("CommitMock")
+    commit.should_receive(:id).and_return("c1be3c82cafc755754ee2247ec8dae1e6a64857f")
+    commit.should_receive(:short_message).and_return("This was a simple test commit.")
+    commit.should_receive(:author).and_return(mock("Author", :name => "Dirk Breuer"))
+    
+    commits = mock("CommitsMock")
+    commits.should_receive(:ref_name).and_return("master")
+    commits.should_receive(:repo_name).and_return("git_hooks")
+    commits.should_receive(:each).and_yield(commit)
+    commits.should_receive(:size).and_return(1)
+    
+    jabber_client.create_message(commits)
+  end
+  
+  it "should request a recipient for authorization if she is not a subscribed buddy" do
+    GitHooks::Notifier::JabberClient.any_instance.stubs(:init_jabber_backend!)
+    jabber_client = GitHooks::Notifier::JabberClient.new(@jabber_client_opts)
+    jabber_client.should_receive(:backend).and_return(mock("JabberBackend", :send => true))
+
+    jabber_client.should_receive(:roster).and_return(roster_mock = mock("RosterMock"))
+    
+    GitHooks::Notifier::JabberClient::Buddy.should_receive(:new).
+      with("lela.starr@jabber.org", roster_mock).
+      and_return(buddy = mock("BuddyMock", :subscribed? => false, :jid => "lela.starr@jabber.org"))
+      
+    jabber_client.should_receive(:request_authorization_of).with(buddy)
+    
+    jabber_client.send_message_to "My testing message", "lela.starr@jabber.org"
+  end
+  
+  it "should send the notification based on the given options" do
+    GitHooks::Notifier::JabberClient.any_instance.stubs(:init_jabber_backend!)
+    jabber_client = GitHooks::Notifier::JabberClient.new(@jabber_client_opts)
+    commits = [mock("Commit")]
+    jabber_client.should_receive(:create_message).with(commits).and_return(message = "Message")
+    jabber_client.should_receive(:send_message_to).with(message, "lela.starr@jabber.org")
+    jabber_client.deliver(commits, "lela.starr@jabber.org")
+  end
+  
+end

data/spec/post_receive_hook_spec.rb

@@ -0,0 +1,37 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "PostReceiveHook" do
+  
+  it "should should read arguments given by Git from stdin" do
+    STDIN.expects(:gets).times(2).returns("old_sha new_sha refs/head/master\n").then.returns(nil)
+
+    post_receive_hook = GitHooks::PostReceiveHook.new
+    arguments = post_receive_hook.read_arguments_from_stdin
+    arguments.should == ["old_sha", "new_sha", "refs/head/master"]
+  end
+  
+  it "should promote the received commits to all registered post_receive hooks" do
+    post_receive_hook = GitHooks::PostReceiveHook.new
+
+    post_receive_hook.should_receive(:read_arguments_from_stdin).
+      and_return(["old_sha", "new_sha", "refs/head/master"])
+
+    GitHooks::GitAdapter.any_instance.
+      expects(:find_commits_since_last_receive).
+      with("old_sha", "new_sha", "refs/head/master").
+      returns(commits = [mock("Commit")])
+
+    jabber_hook = mock("HookMock")
+    jabber_hook.should_receive(:hook_class).and_return(GitHooks::Notifier::JabberClient)
+    jabber_hook.should_receive(:options).and_return({:other_jabber_option => "Option"})
+    
+    post_receive_hooks = [jabber_hook]
+    
+    GitHooks.config.should_receive(:post_receive_hooks).and_return(post_receive_hooks)
+    
+    GitHooks::Notifier::JabberClient.should_receive(:deliver).with({:other_jabber_option => "Option", :commits => commits})
+    
+    post_receive_hook.run
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+require 'rubygems'
+require 'spec'
+require 'spec/autorun'
+require 'mocha'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+$TESTING = true
+
+require 'git_hooks'
+
+# init the config class with testing config
+config_yaml = StringIO.new <<-YAML
+:post_receive_hooks:
+-  :jabber:
+    :jid: JABBER_USERNAME
+    :password: JABBER_PASSWORD
+    :server: JABBER_SERVER
+    :recipients: [ "recipient@jabber.id" ]
+  
+-  :pivotal_tracker:
+    :api_key: API_KEY
+YAML
+GitHooks.config_file = config_yaml
+
+Spec::Runner.configure do |config|
+end

data/spec/tracker_client_spec.rb

@@ -0,0 +1,68 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "TrackerClient" do
+  
+  before(:each) do
+    @tracker_options = { :api_key => "MY_API_KEY" }
+  end
+  
+  it "should create a pivotal tracker ready payload for each passed commit" do
+    commit = mock("CommitMock")
+    commit.should_receive(:id).and_return("SHA_ID")
+    commit.should_receive(:message).and_return("[#1234] Commit Message")
+    commit.should_receive(:author).and_return(mock("AuthorMock", :name => "Seras Victoria"))
+    
+    expected_payload = <<-XML
+<source_commit>
+<message>[#1234] Commit Message</message>
+<author>Seras Victoria</author>
+<commit_id>SHA_ID</commit_id>
+</source_commit>
+    XML
+    
+    client = GitHooks::Notifier::TrackerClient.new(@tracker_options)
+    client.create_payloads([commit]) do |payload|
+      payload.should == expected_payload
+    end
+  end
+  
+  it "should send commit messages to pivotal tracker" do
+    commits = [mock("CommitMock")]
+    payload = "some test payload"
+    curl = mock("CurlMock")
+    curl.should_receive(:http_post).with(payload)
+    
+    client = GitHooks::Notifier::TrackerClient.new(@tracker_options)
+    client.should_receive(:create_payloads).with(commits).and_yield(payload)
+    client.should_receive(:curl).and_return(curl)
+    
+    client.deliver(commits)
+  end
+  
+  it "should initialize client with a curb client ready to post to pivotal tracker" do
+    curb = mock("CurbMock")
+    headers = {}
+    curb.should_receive(:headers).twice.and_return(headers)
+    
+    Curl::Easy.should_receive(:new).with("http://www.pivotaltracker.com/services/v3/source_commits").and_yield(curb)
+    
+    client = GitHooks::Notifier::TrackerClient.new(@tracker_options)
+    
+    headers["X-TrackerToken"].should == @tracker_options[:api_key]
+    headers["Content-type"].should == "application/xml"
+  end
+  
+  it "should provide class level deliver methods" do
+    deliver_options = {
+      :commits => [mock("CommitMock")],
+      :api_key => "MY_API_KEY"
+    }
+    
+    client = mock("TrackerClientMock")
+    client.should_receive(:deliver).with(deliver_options[:commits])
+    GitHooks::Notifier::TrackerClient.should_receive(:new).with({:api_key => "MY_API_KEY"}).and_return(client)
+    
+    GitHooks::Notifier::TrackerClient.deliver(deliver_options)
+  end
+  
+end

data/spec/utils_spec.rb

@@ -0,0 +1,9 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Utils" do
+  
+  it "should find out the hostname" do
+    GitHooks::Utils.hostname.should_not be(nil)
+  end
+  
+end

metadata

@@ -0,0 +1,163 @@
+--- !ruby/object:Gem::Specification 
+name: git_hooks
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 0
+  version: 0.2.0
+platform: ruby
+authors: 
+- Dirk Breuer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-10 00:00:00 +02:00
+default_executable: hook-post-receive
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: grit
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 0
+        - 0
+        version: 2.0.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: xmpp4r
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 5
+        version: "0.5"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: curb
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 7
+        - 1
+        version: 0.7.1
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 3
+        - 0
+        - 0
+        - beta
+        version: 3.0.0.beta
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 2
+        - 9
+        version: 1.2.9
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 9
+        - 8
+        version: 0.9.8
+  type: :development
+  version_requirements: *id006
+description: The goal is to provide a pluggable hook infrastructure, where you can easily use different hooks for different purposes.
+email: dirk.breuer@gmail.com
+executables: 
+- hook-post-receive
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- README.rdoc
+- lib/git_hooks.rb
+- lib/git_hooks/git_adapter.rb
+- lib/git_hooks/logger.rb
+- lib/git_hooks/notifier.rb
+- lib/git_hooks/notifier/jabber_client.rb
+- lib/git_hooks/notifier/tracker_client.rb
+- lib/git_hooks/post_receive_hook.rb
+- lib/git_hooks/utils.rb
+- lib/git_hooks/utils/config.rb
+- LICENSE
+has_rdoc: true
+homepage: http://github.com/railsbros/git-hooks
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: A small Gem to provide various Git-Hooks based on Grit.
+test_files: 
+- spec/config_spec.rb
+- spec/git_adapter_spec.rb
+- spec/git_hooks_spec.rb
+- spec/jabber_client_spec.rb
+- spec/post_receive_hook_spec.rb
+- spec/spec_helper.rb
+- spec/tracker_client_spec.rb
+- spec/utils_spec.rb