hookie 1.0.0

data/.gitignore

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

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Marcin Szczepanski
+
+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,129 @@
+# Hookie
+
+Hookie is a pluggable framework for creating git hooks using Ruby. It was originally designed for writing hooks for gitolite, but should work for any hooks, including local ones.
+
+## Background
+
+After we had setup [HipChat](http://hipchat.com) at our organisation I wanted to get notifications from gitolite pushes pushed to HipChat. I found the [gitolite-hipchat-notification](https://github.com/peplin/gitolite-hipchat-notification) project, and [forked it](https://github.com/marcins/gitolite-hipchat-notification) and cleaned it up a bit for my purposes. However this script wasn't very flexible in that you needed to add it individually to each repo (or suffer with a single config). Then I wanted to add Jenkins build notifications as well, so had to enhance the script to support running multiple tasks. Eventually it was all getting too crufty and so Hookie was born!
+
+Hookie is designed so that you can have multiple actions take place as a result of a git hook (usually post-receive), these actions are built as plugins, and configured via git - the beauty of this is that for gitolite you define the hook globally and then configure which plugins run where via git config keys, which can be defined in your gitolite-admin repository. So once Hookie is setup you don't need to make changes on the server.
+
+Hookie includes those aforementioned plugins for HipChat and Jenkins in the base build.
+
+## Acknowledgements
+
+Hookie is built on the base of @peplin's (gitolite-hipchat-notification)[https://github.com/peplin/gitolite-hipchat-notification] project, which was originally forked from (gitolite-campfire-notification)[https://github.com/LegionSB/gitolite-campfire-notification] - the magic of Open Source!
+
+Hookie uses [grit](https://github.com/mojombo/grit) for accessing information in git repositories.
+
+## Installation
+
+Install the gem on your git server
+
+    gem install hookie
+
+You then need to create a post-receive script in your repository's hooks directory, there are a couple of ways to do this, see below for some options. The post-receive hook will look like this:
+
+    #!/usr/bin/env ruby
+    require 'hookie'
+
+    # Add your plugins here
+    # require 'my_plugin'
+
+    Hookie::Framework.hook "post_receive"
+
+**NOTE** the above doesn't work if your gitolite user is using RVM as the gitolite shell won't have loaded RVM. The alternative hook script looks like this:
+
+    #!/bin/bash
+    source ~/.rvm/scripts/rvm
+    ruby -rhookie -e 'Hookie::Framework.hook "post_receive"'
+
+If you need to add your own custom plugins then add them with additional -r arguments (require)
+
+### Installing hooks with gitolite
+
+The idea is that you install hookie as a post_receive hook for all your repositories, but configuration determines when the hook is actually run. To install for all repositories you create the post-receive script in the .gitolite/hooks/common/ directory.  Make sure the script is exectuable.
+
+### Installing hooks manually
+
+You can also install Hookie hooks manually, by adding them to the hooks directory within your repository. Note that the same configuration still applies.  You should also be able to install Hookie for local repository hooks, but I haven't tried this yet!  Currently Hookie assumes it will be receiving changeset information on STDIN in the format gitolite provides it, I'm not sure if other git servers and/or local hooks also receive information the same way?
+
+## Configuration
+
+Hookie was written such that it can be configured using Gitolite's ability to set git config keys via the gitolite-admin repository.
+
+You can set "global" config keys using the special repository @all in gitolite, and override or set project specific keys within the repository itself. This makes it easy to, for example, set your HipChat API key for all repos, but then set the room that gets notified in each repo separately - and this can all be done via the gitolite-admin repository, without requiring access to the git server.
+
+An example conf/gitolite.conf:
+
+    repo gitolite-admin
+        RW+     =   marcin
+
+    repo testing
+        RW+     =   @all
+        config hookie.core.allowedplugins = hipchat,jenkins
+        config hookie.hipchat.room = 123456
+        config hookie.jenkins.url = http://jenkins.example.com/job/Test%20Job/build?token=test
+        config hookie.jenkins.branches=develop
+        config hookie.jenkins.auth=jenkins:TOKEN
+
+    repo @all
+        config hookie.hipchat.apikey = APIKEY
+        config hookie.hipchat.from = "Git Test"
+        config hookie.core.web.commit = https://fisheye.example.com/changelog/%REPO%?cs=%COMMIT%
+        config hookie.core.web.browse = https://fisheye.example.com/browse/%REPO%
+
+The following core keys are used by the framework:
+
+* **hookie.core.allowedplugins** - comma separated list of plugins that are run for this repo - by default NO plugins get run.
+* **hookie.core.repo.name** - set the name of the repository used when generating URLs or for display purposes. Normally it can be determined from the path and the key isn't required
+* **hookie.core.web.browse** - URL to a web based repo browser. The special variable %REPO% will be replaced with the repo name.
+* **hookie.core.web.commit** - URL to a web based view of a single commit. The special variables %REPO% and %COMMIT% will be replaced with the repo name and commit id respectively.
+* **hookie.core.web.proxy** - optional proxy to use when making HTTP calls in plugins (example syntax: "proxy.example.com:8080")
+
+## Plugins
+
+The following plugins are shipped with Hookie:
+
+* HipChat - posts a notification to a HipChat room in response to a commit
+* Jenkins - triggers a Jenkins build in reponse to a commit
+
+### HipChat
+
+The following config keys apply to the HipChat plugin:
+
+* **hookie.hipchat.apikey** - your HipChat API key
+* **hookie.hipchat.room** - the HipChat room to post your message to - you can get a list of rooms using the following API call:
+    http://api.hipchat.com/v1/rooms/list?auth_token=YOUR_TOKEN
+* **hookie.hipchat.from** - who the notification appears from (default: git)
+* **hookie.hipchat.notify** - set to 1 to trigger a notification (default: 0)
+
+### Jenkins
+
+The following config keys apply to the Jenkins plugin:
+
+* **hookie.jenkins.url** - the trigger URL to be called for this repostiory (you should set this per-repository)
+* **hookie.jenkins.branches** - only trigger a build if the change set includes commits to the branches in this list. Comma separated. Default is to build for any commit.
+* **hookie.jenkins.auth** - the username:token combo to use to authenticate with Jenkins
+
+## Writing Plugins
+
+Hookie was designed to be extensible by writing your own plugins.
+
+A minimal plugin is:
+
+    require 'hookie/plugins/base_plugin'
+
+    module Hookie
+      module Plugin
+        class EmptyPlugin < BasePlugin
+          def post_receive
+            log "Empty Plugin - post_receive"
+          end
+        end
+      end
+    end
+
+BasePlugin provides useful instance variables such as config and framework.config is a symbol keyed hash of your plugins config. By convention your config key is the lowercased first part of your plugin name (eg. EmptyPlugin -> empty), so config keys are, for example, hookie.empty.blah
+
+Your plugin will be called if it has a method matching the name of the hook being run (eg. "post_receive" above).  See the HipChat and Jenkins plugins for vaguely more complex examples.

data/Rakefile

@@ -0,0 +1,4 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new('spec')

data/bin/hookie

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+require 'hookie'
+if ARGV.length < 1
+  puts "Usage: hookie hook_name [repo_path]"
+  exit 1
+end
+Hookie::Framework.hook ARGV[0]

data/hookie.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'hookie'
+
+Gem::Specification.new do |gem|
+  gem.name          = "hookie"
+  gem.version       = Hookie::VERSION
+  gem.authors       = ["Marcin Szczepanski"]
+  gem.email         = ["marcins@webqem.com"]
+  gem.description   = %q{Hookie provides a way to write git hooks with ruby without too much worrying about any of the plumbing required, you can easily write your own plugins and focus on the core of your functionality. 
+
+    Hookie includes plugins for Jenkins and HipChat.}
+  gem.summary       = %q{Framework for writing gitolite/git hooks with Ruby}
+  gem.homepage      = "https://github.com/marcins/hookie"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency 'grit', '~> 2.5.0'
+  gem.add_dependency 'diff-lcs', '~> 1.1.3'
+
+  gem.add_development_dependency 'rspec', '~> 2.12.0'
+end

data/lib/hookie/framework.rb

@@ -0,0 +1,100 @@
+module Hookie
+
+  class Framework
+
+    require 'grit'
+
+    attr_reader :changes
+
+    def self.hook(hook)
+      hookie = Hookie::Framework.new hook, ARGV[1] || Dir.getwd
+      hookie.run_plugins(hook)
+    end
+
+    def initialize(hook, repo_path)
+      @repo = Grit::Repo.new(repo_path)
+      read_changes
+    end
+
+    def run_plugins(hook)
+      # we are only allowed to run if the plugin is in the list of allowed
+      # plugins
+      unless config['hookie.core.allowedplugins']
+        exit 255
+      end
+
+      Dir.glob(File.join(File.join(File.dirname(__FILE__),"plugins"), "*_plugin.rb")) do |filename|
+        begin
+          require filename
+        rescue LoadError => e
+          puts "Unable to load plugin #{filename}: #{e}"
+        end
+      end
+
+      Hookie::Plugin.constants.each do |constant|
+        clazz = Hookie::Plugin.const_get(constant)
+        if clazz < Hookie::BasePlugin
+          plugin = clazz.new(self)
+          if config['hookie.core.allowedplugins'].include?(plugin.config_key) and
+            plugin.respond_to?(hook) and
+            plugin.should_run?
+              begin
+                plugin.send(hook)
+              rescue Exception => e
+                log plugin, "ERROR: plugin threw an exception: #{e}"
+              end
+          end
+        end
+      end
+    end
+
+    def log(plugin, message)
+      timestamp = Time.now.strftime("%Y-%m-%d %H:%M:%S")
+      puts "[#{timestamp}] #{plugin}: #{message}"
+    end
+
+    def repo_url
+      if config['hookie.core.web.browse']
+        config['hookie.core.web.browse'].gsub("%REPO%", repo_name)
+      end
+    end
+
+    def commit_url(commit)
+      if config['hookie.core.web.commit']
+        config['hookie.core.web.commit'].gsub("%REPO%", repo_name).gsub("%COMMIT%", commit.id)
+      end
+    end
+
+    def repo_name
+      if config['hookie.core.repo.name']
+        config['hookie.core.repo.name']
+      elsif @repo.bare
+        File.basename(@repo.path, ".git")
+      else
+        File.basename(File.expand_path(File.join(@repo.path, "..")))
+      end
+    end
+
+    def head_names_for_commit(commit)
+      @repo.heads.collect { |head| head.name if head.commit.id == commit.id }.compact
+    end
+
+    def config
+      @repo.config
+    end
+
+    private
+    def read_changes
+      @changes = []
+      STDIN.each_line do |line|
+        parts = line.split(" ")
+        @changes << {
+          old_hash: parts[0],
+          new_hash: parts[1],
+          ref: parts[2],
+          commit: @repo.commits(parts[1], 1)[0]
+        }
+      end
+    end
+  end
+end

data/lib/hookie/plugins/base_plugin.rb

@@ -0,0 +1,40 @@
+module Hookie
+  class BasePlugin
+
+    attr_reader :config
+
+    def initialize(framework)
+      @framework = framework
+
+      @config = {}
+      @framework.config.keys.each do |k|
+        if k.start_with?("hookie.#{self.config_key}")
+          @config[k.split(".")[2..-1].join("_").to_sym] = @framework.config[k]
+        end
+      end
+
+    end
+
+    def log(message)
+      @framework.log(self, message)
+    end
+
+    def should_run?
+      true
+    end
+
+    def to_s
+      plugin_name
+    end
+
+    def config_key
+      plugin_name.downcase
+    end
+
+    protected
+    def plugin_name
+      @plugin_name ||= self.class.to_s[/(.*::)?(\w+)Plugin/, 2]
+    end
+
+  end
+end

data/lib/hookie/plugins/empty_plugin.rb

@@ -0,0 +1,12 @@
+require_relative "base_plugin"
+
+module Hookie
+  module Plugin
+    class EmptyPlugin < BasePlugin
+      def post_receive
+        log "Empty Plugin - post_receive"
+        raise "Shite"
+      end
+    end
+  end
+end

data/lib/hookie/plugins/hipchat_plugin.rb

@@ -0,0 +1,88 @@
+require_relative 'base_plugin'
+
+require 'time'
+require 'net/https'
+require 'json'
+
+module Hookie
+  module Plugin
+    class HipChatPlugin < BasePlugin
+      def to_s
+        "HipChat Notifier"
+      end
+
+      def should_run?
+        warnings = []
+        if @framework.changes.empty?
+          log "No changes"
+          return false
+        end
+        warnings << "hookie.hipchat.apikey not set!" unless @config[:apikey]
+        warnings << "hookie.hipchat.room not set!" unless @config[:room]
+
+        log warnings.join(", ") unless warnings.empty?
+
+        warnings.empty?
+      end
+
+      def post_receive
+        log "Sending message to HipChat ... "
+        response = {}
+        #log "Message: #{format_message}"
+        response = speak format_message
+        if response[:status]
+          log "Message sent to HipChat"
+        elsif response[:error]
+          log "Message end failed: #{response[:error][:message]}"
+        else
+          log "Unknown response"
+        end
+      end
+
+      private
+      def format_message
+        # Commits just pushed to <a href="repo-url">repo-name</a>:
+        # hash (branch) Author: message
+        message = ""
+        message << "Commits just pushed to "
+        message << if @framework.repo_url
+          "<a href='#{@framework.repo_url}'>#{@framework.repo_name}</a>"
+        else
+          @framework.repo_name
+        end
+        message << ":<br/>"
+        @framework.changes.each do |change|
+          commit = change[:commit]
+
+          message << if @framework.commit_url(commit)
+            "<a href='#{@framework.commit_url(commit)}'>#{commit.id_abbrev}</a>"
+          else
+            "#{commit.id_abbrev}"
+          end
+          head_names = @framework.head_names_for_commit(commit).join(", ")
+          message << " (#{head_names})" unless head_names.empty?
+          message << " #{commit.author}: #{commit.short_message}"
+          message << "<br/>"
+        end
+        message
+      end
+
+      private
+      def speak(message)
+        uri = URI.parse("https://api.hipchat.com/")
+        http = Net::HTTP.new(uri.host, uri.port, @config[:proxyaddress], @config[:proxyport])
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        request = Net::HTTP::Post.new("/v1/rooms/message")
+        request.set_form_data({"message" => message,
+            "auth_token" => @config[:apikey],
+            "room_id" => @config[:room],
+            "notify" => @config[:notify] || 0,
+            "from" => @config[:from] || "git"})
+
+        JSON.parse(http.request(request).body, {symbolize_names: true})
+      end
+
+    end
+  end
+end

data/lib/hookie/plugins/jenkins_plugin.rb

@@ -0,0 +1,39 @@
+require_relative "base_plugin"
+
+module Hookie
+  module Plugin
+    class JenkinsPlugin < BasePlugin
+
+      def should_run?
+        #puts "Config: #{config}"
+        unless config[:url]
+          log "Jenkins URL not configured!"
+          return false
+        end
+
+        if config[:branches]
+          allowed_branches = config[:branches].split(",")
+          commits = @framework.changes.map { |change| change[:commit] }
+          branches = commits.collect { |commit| @framework.head_names_for_commit(commit) }
+          branches.flatten!
+          if (branches & allowed_branches).empty?
+            log "No commits on matching branches (#{allowed_branches.join(', ')})"
+            return false
+          end
+        end
+        return true
+      end
+
+      def post_receive
+        uri = URI.parse(config[:url])
+        http = Net::HTTP.new(uri.host, uri.port)
+        request = Net::HTTP::Get.new(uri.request_uri)
+        if config[:auth]
+          request.basic_auth(*config[:auth].split(":"))
+        end
+        response = http.request(request)
+        log "Response: #{response.body}"
+      end
+    end
+  end
+end

data/lib/hookie.rb

@@ -0,0 +1,5 @@
+require_relative "hookie/framework"
+
+module Hookie
+    VERSION = "1.0.0"
+end

data/spec/base_plugin_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+require 'hookie'
+require 'hookie/plugins/base_plugin'
+
+class ThisHasALongNamePlugin < Hookie::BasePlugin
+end
+
+describe Hookie::BasePlugin do
+  before :each do
+    @hookie = double(Hookie::Framework)
+    @config = double(Grit::Config)
+    @config.stub(:keys).and_return([])
+    @hookie.stub(:config).and_return(@config)
+  end
+  context "base plugin" do
+    before :each do
+      @plugin = Hookie::BasePlugin.new @hookie
+    end
+    it "should initialise" do
+
+    end
+    it "should correctly derive the plugin name" do
+      @plugin.to_s.should eq "Base"
+      @plugin.config_key.should eq "base"
+
+      plugin = ThisHasALongNamePlugin.new @hookie
+      plugin.to_s.should eq "ThisHasALongName"
+      plugin.config_key.should eq "thishasalongname"
+    end
+
+    it "should read the correct config" do
+      @config.should_receive(:keys).once.and_return(["core.key","hookie.base.mykey"])
+      @config.should_receive('[]').with('hookie.base.mykey').and_return("value")
+      @plugin = Hookie::BasePlugin.new @hookie
+      @plugin.config.should have(1).items
+    end
+
+    it "should send log messages" do
+      @hookie.should_receive(:log).once.with(@plugin, "message")
+      @plugin.log "message"
+    end
+  end
+end

data/spec/framework_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe Hookie do
+  before(:each) do
+      @repo = double('Grit::Repo')
+      @config = double('Grit::Config')
+      Grit::Repo.should_receive(:new).once.and_return(@repo)
+      @repo.stub(:commits).and_return([])
+      @repo.stub(:config).and_return(@config)
+      STDIN.should_receive(:each_line).and_yield("bf6245eb3f1fa4cadff4299cb45e3ed85bc3337e b37c9728362ec39ce57adaab6ad9f0225d3513fe refs/heads/master").and_yield("0000000000000000000000000000000000000000 09e6a76d20ae8c8e1d40ce21b6ea586ff860e5d3 refs/heads/develop")
+  end
+
+  context 'initialisation' do
+    it "intialises" do
+      hookie = Hookie::Framework.new "test_hook", Dir.getwd
+    end
+
+    it "reads changes" do
+      commit = double('Grit::Commit')
+      @repo.should_receive(:commits).with("b37c9728362ec39ce57adaab6ad9f0225d3513fe", 1).once.and_return([commit])
+
+      hookie = Hookie::Framework.new "test_hook", Dir.getwd
+
+      hookie.changes.should have(2).items
+      change = hookie.changes[0]
+
+      change[:old_hash].should eq "bf6245eb3f1fa4cadff4299cb45e3ed85bc3337e"
+      change[:new_hash].should eq "b37c9728362ec39ce57adaab6ad9f0225d3513fe"
+      change[:ref].should eq "refs/heads/master"
+
+      change[:commit].should be commit
+    end
+  end
+
+  context "helpers" do
+    before(:each) do
+      @hookie = Hookie::Framework.new "test_hook", Dir.getwd
+    end
+
+    it "should not return a repo browsing url if it's not set" do
+      @repo.should_receive(:config).once.and_return(@config)
+      @config.should_receive('[]').with('hookie.core.web.browse').and_return(nil)
+      @hookie.repo_url.should be_nil
+    end
+
+    it "should return a repo browsing url if it's set" do
+      @repo.config.should_receive('[]').with("hookie.core.web.browse").at_least(:once).and_return("TEST %REPO% TEST")
+      @repo.config.should_receive('[]').with("hookie.core.repo.name").at_least(:once).and_return("testrepo")
+      @hookie.repo_url.should eq "TEST testrepo TEST"
+    end
+
+    it "should not return a commit url if it's not set" do
+      @repo.config.should_receive('[]').with("hookie.core.web.commit").at_least(:once).and_return(nil)
+      commit = double('Grit::Commit')
+      @hookie.commit_url(commit).should be_nil
+    end
+
+    it "should return a commit url if it's set" do
+      @repo.config.should_receive('[]').with("hookie.core.web.commit").at_least(:once).and_return("TEST %REPO% TEST %COMMIT%")
+      @repo.config.should_receive('[]').with("hookie.core.repo.name").at_least(:once).and_return("testrepo")
+      commit = double('Grit::Commit')
+      commit.stub(:id).and_return("ABC")
+      @hookie.commit_url(commit).should eq "TEST testrepo TEST ABC"
+    end
+  end
+end

data/spec/hipchat_plugin_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+require 'hookie'
+require 'hookie/plugins/hipchat_plugin'
+
+describe Hookie::Plugin::HipChatPlugin do
+  before :each do
+    @hookie = double(Hookie::Framework)
+    @config = double(Grit::Config)
+    @config.stub(:keys).and_return([])
+
+    @hookie.stub(:config).and_return(@config)
+    @hookie.stub(:log)
+  end
+  context "HipChat plugin" do
+    before :each do
+      @plugin = Hookie::Plugin::HipChatPlugin.new @hookie
+    end
+
+    context "config" do
+      it "shouldn't run only when there are no changes" do
+        @hookie.should_receive(:changes).once.and_return([])
+        @plugin.should_run?.should be_false
+      end
+
+      it "shouldn't run when there are changes but config is missing" do
+        @hookie.should_receive(:changes).once.and_return(["something"])
+        @hookie.should_receive(:log).once
+        @plugin.should_run?.should be_false
+      end
+
+      it "should run when there are no changes and config is correct" do
+        @config.should_receive(:keys).and_return(['hookie.hipchat.apikey','hookie.hipchat.room'])
+        @config.should_receive('[]').with('hookie.hipchat.apikey').and_return("ABC123")
+        @config.should_receive('[]').with('hookie.hipchat.room').and_return("1234")
+        plugin = Hookie::Plugin::HipChatPlugin.new @hookie
+        @hookie.should_receive(:changes).once.and_return(["something"])
+        @hookie.should_not_receive(:log)
+        plugin.should_run?.should be_true
+      end
+    end
+
+    it "sends the correct message" do
+      # FIXME this neds to be better
+      @plugin.stub(:format_message).and_return("message")
+      @plugin.should_receive(:speak).with("message").and_return({"status" => "sent"})
+      @hookie.should_receive(:log).twice
+      @plugin.post_receive
+    end
+
+  end
+end

data/spec/jenkins_plugin_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+require 'hookie'
+require 'hookie/plugins/jenkins_plugin'
+
+describe Hookie::Plugin::JenkinsPlugin do
+  before :each do
+    @hookie = double(Hookie::Framework)
+    @config = double(Grit::Config)
+    @config.stub(:keys).and_return([])
+
+    @hookie.stub(:config).and_return(@config)
+    @hookie.stub(:log)
+
+    @plugin = Hookie::Plugin::JenkinsPlugin.new @hookie
+  end
+  context "Jenkins plugin" do
+
+    context "config" do
+      it "shouldn't run when not configured" do
+        @plugin.stub(:config).and_return({})
+        @plugin.should_run?.should be_false
+      end
+      it "should run when it is configured" do
+        @plugin.should_receive(:config).at_least(:once).and_return({url: "foo"})
+        @plugin.should_run?.should be_true
+      end
+      it "should check for branches if configured" do
+        commit = double("Grit::Commit")
+        @hookie.should_receive(:changes).at_least(:once).and_return([
+          {old_hash: "", new_hash: "", ref: "", commit: commit}
+          ])
+        @hookie.should_receive(:head_names_for_commit).with(commit).and_return(['develop'])
+        @plugin.should_receive(:config).at_least(:once).and_return({
+            url: "foo",
+            branches: "develop,master"
+          })
+        @plugin.should_run?.should  be_true
+
+        @hookie.should_receive(:head_names_for_commit).with(commit).and_return(['develop','foob'])
+        @plugin.should_run?.should be_true
+
+        @hookie.should_receive(:head_names_for_commit).with(commit).and_return(['develop','master'])
+        @plugin.should_run?.should be_true
+
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'rspec'
+require 'hookie'
+
+RSpec.configure do |config|
+  config.color_enabled = true
+  config.formatter     = 'documentation'
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: hookie
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Marcin Szczepanski
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: grit
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.5.0
+- !ruby/object:Gem::Dependency
+  name: diff-lcs
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.3
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.12.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.12.0
+description: ! "Hookie provides a way to write git hooks with ruby without too much
+  worrying about any of the plumbing required, you can easily write your own plugins
+  and focus on the core of your functionality. \n\n    Hookie includes plugins for
+  Jenkins and HipChat."
+email:
+- marcins@webqem.com
+executables:
+- hookie
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/hookie
+- hookie.gemspec
+- lib/hookie.rb
+- lib/hookie/framework.rb
+- lib/hookie/plugins/base_plugin.rb
+- lib/hookie/plugins/empty_plugin.rb
+- lib/hookie/plugins/hipchat_plugin.rb
+- lib/hookie/plugins/jenkins_plugin.rb
+- spec/base_plugin_spec.rb
+- spec/framework_spec.rb
+- spec/hipchat_plugin_spec.rb
+- spec/jenkins_plugin_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/marcins/hookie
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Framework for writing gitolite/git hooks with Ruby
+test_files:
+- spec/base_plugin_spec.rb
+- spec/framework_spec.rb
+- spec/hipchat_plugin_spec.rb
+- spec/jenkins_plugin_spec.rb
+- spec/spec_helper.rb