git_tracking 0.1.0

data/.git_tracking

@@ -0,0 +1,7 @@
+--- 
+:raise_on_incomplete_merge: false
+:keys: {}
+
+:emails: []
+
+:raise_on_debugger: false

data/.gitignore

@@ -0,0 +1,3 @@
+pkg/*
+*.gem
+.bundle

data/.rspec

@@ -0,0 +1 @@
+--debug

data/Gemfile

@@ -0,0 +1,10 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in git_tracking.gemspec
+gemspec
+
+group :development do
+  gem 'rspec', '>=2.0'
+  gem 'ruby-debug', :platforms => :ruby_18
+  gem 'ruby-debug19', :platforms => :ruby_19
+end

data/Gemfile.lock

@@ -0,0 +1,66 @@
+PATH
+  remote: .
+  specs:
+    git_tracking (0.0.1)
+      highline
+      pivotal-tracker
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    archive-tar-minitar (0.5.2)
+    builder (2.1.2)
+    columnize (0.3.1)
+    diff-lcs (1.1.2)
+    happymapper (0.3.2)
+      libxml-ruby (~> 1.1.3)
+    highline (1.6.1)
+    libxml-ruby (1.1.4)
+    linecache (0.43)
+    linecache19 (0.5.11)
+      ruby_core_source (>= 0.1.4)
+    mime-types (1.16)
+    nokogiri (1.4.3.1)
+    pivotal-tracker (0.2.2)
+      builder
+      happymapper (>= 0.3.2)
+      nokogiri (~> 1.4.3.1)
+      rest-client (~> 1.6.0)
+    rest-client (1.6.1)
+      mime-types (>= 1.16)
+    rspec (2.0.1)
+      rspec-core (~> 2.0.1)
+      rspec-expectations (~> 2.0.1)
+      rspec-mocks (~> 2.0.1)
+    rspec-core (2.0.1)
+    rspec-expectations (2.0.1)
+      diff-lcs (>= 1.1.2)
+    rspec-mocks (2.0.1)
+      rspec-core (~> 2.0.1)
+      rspec-expectations (~> 2.0.1)
+    ruby-debug (0.10.3)
+      columnize (>= 0.1)
+      ruby-debug-base (~> 0.10.3.0)
+    ruby-debug-base (0.10.3)
+      linecache (>= 0.3)
+    ruby-debug-base19 (0.11.24)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby_core_source (>= 0.1.4)
+    ruby-debug19 (0.11.6)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby-debug-base19 (>= 0.11.19)
+    ruby_core_source (0.1.4)
+      archive-tar-minitar (>= 0.5.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  git_tracking!
+  highline
+  pivotal-tracker
+  rspec (>= 2.0)
+  ruby-debug
+  ruby-debug19

data/README

@@ -0,0 +1,70 @@
+Git Tracking!
+============
+
+## Purpose
+`git_tracking` is a gem whose primary purpose is to
+provide (and enforce) tight integration between
+Pivotal Tracker and git for your project.
+
+At my office, we have all agreed that we shouldn't
+commit code that doesn't have an associated story
+in Pivotal Tracker.  Further, we tend to work on
+code at our glamorous (and blazingly fast) iMac
+pairing stations.  Therefore, we have two needs which
+this gem aims to satisfy:
+
+  1. To always know *who* was the author of a given
+  commit. ('Pairingstation1' is not good enough.)
+  2. To always know *which* story a given commit was
+  intended to fix/implement.
+  3. Bonus: While in Tracker, to be able to see
+  which commits are tied to a given story.
+
+## Installation
+
+    gem install git_tracking
+    git_tracking # this installs the git hooks and .git_tracking config file
+
+## Usage
+Just use git as normal, and you will be prompted for
+stuff.
+
+For example:
+
+    ! g commit -m "Making detect ignore .git_tracking file"
+    The following files have 'debugger' statements in them:
+    spec/detect_spec.rb
+    Git Author (default will be: Steve & Ghost Co-Pilot):
+    1. Enter new
+    ?  1
+    New git author: Steve
+    Pivotal Tracker email (default is: ):
+    1. Enter new
+    ?  1
+    New Email: john@doe.net
+    Enter your PivotalTracker password: xxxxxxx
+    Please enter the PivotalTracker project id for this project
+    137119
+    Found a valid story id in your branch or commit: 6131989 - Bugfixing
+    Hit enter to confirm story id 6131989, or enter some other story id: |6131989| 6132035
+    [master 2162139] [#6132035] Make sure that detect_* ignores .git_tracking file
+     2 files changed, 17 insertions(+), 8 deletions(-)
+
+You can set `git_tracking` to raise (ie reject your
+commit) when it detects that you are about to commit
+a `debugger` or an incomplete merge (`<<<<<<<` or `>>>>>>>`).
+
+All config options are in the `.git_tracking` file.
+
+## BEWARE!!
+
+`git_tracking` will store your api token for tracker
+in the `.git_tracking` file.  This is probably fine
+for private repo's where you know everyone who
+has access, but if you are committing to a public
+repo, you may want to put the `.git_tracking` file
+in your .gitignore.
+
+If you do accidentally make your PivotalTracker
+token public, I believe you request that they
+generate a new one for you.

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/bin/git_tracking

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'git_tracking'
+rescue LoadError
+  require 'rubygems'
+  require 'git_tracking'
+end
+
+puts "Thanks for installing the git_tracking gem!"
+
+if File.exists?(".git") && File.directory?(".git")
+  GitTracking.config
+
+  unless File.exists?(".git_tracking")
+    GitTracking::Config.new.write_to_file
+  else
+    puts "Not writing .git_tracking config file, as it already exists"
+  end
+
+  unless File.exists?(".git/hooks/pre-commit") && File.read(".git/hooks/pre-commit").include?("GitTracking")
+    File.open(".git/hooks/pre-commit", "a") do |file|
+      file.print File.read(File.expand_path("../../hooks/pre-commit", __FILE__))
+    end
+    system "chmod +x .git/hooks/pre-commit"
+  else
+    puts "Not writing pre-commit hook, as it already exists"
+  end
+
+  unless File.exists?(".git/hooks/prepare-commit-msg") && File.read(".git/hooks/prepare-commit-msg").include?("GitTracking")
+    File.open(".git/hooks/prepare-commit-msg", "a") do |file|
+      file.print File.read(File.expand_path("../../hooks/prepare-commit-msg", __FILE__))
+    end
+    system "chmod +x .git/hooks/prepare-commit-msg"
+  else
+    puts "Not writing prepare-commit-msg hook, as it already exists"
+  end
+
+  unless File.exists?(".git/hooks/post-commit") && File.read(".git/hooks/post-commit").include?("GitTracking")
+    File.open(".git/hooks/post-commit", "a") do |file|
+      file.print File.read(File.expand_path("../../hooks/post-commit", __FILE__))
+    end
+    system "chmod +x .git/hooks/post-commit"
+  else
+    puts "Not writing post-commit hook, as it already exists"
+  end
+else
+  puts "Error: No .git directory found. The git_tracking gem can only be used in a project tracked by git"
+  exit 1
+end

data/git_tracking.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "git_tracking/version"
+
+Gem::Specification.new do |s|
+  s.name        = "git_tracking"
+  s.version     = GitTracking::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Steve Hull", "Derrick Camerino"]
+  s.email       = ["p.witty@gmail.com", "robustdj@gmail.com"]
+  s.homepage    = "http://rubygems.org/gems/git_tracking"
+  s.summary     = %q{Better integration between git and PivotalTracker}
+  s.description = %q{Usage: after installing the gem, in your project directory, run: git_tracking}
+
+  s.rubyforge_project = "git_tracking"
+
+  s.add_dependency('highline')
+  s.add_dependency('pivotal-tracker')
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/hooks/post-commit

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+begin
+  require 'git_tracking'
+rescue LoadError
+  require 'rubygems'
+  require 'git_tracking'
+end
+
+GitTracking.post_commit

data/hooks/pre-commit

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+begin
+  require 'git_tracking'
+rescue LoadError
+  require 'rubygems'
+  require 'git_tracking'
+end
+
+GitTracking.pre_commit

data/hooks/prepare-commit-msg

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+begin
+  require 'git_tracking'
+rescue LoadError
+  require 'rubygems'
+  require 'git_tracking'
+end
+
+GitTracking.prepare_commit_msg

data/lib/git_tracking/config.rb

@@ -0,0 +1,81 @@
+class GitTracking
+  class Config
+    def initialize
+      @config = {
+        :raise_on_incomplete_merge => true,
+        :raise_on_debugger => true,
+        :authors => [],
+        :keys => {}
+      }
+      if File.exists? ".git_tracking"
+        @config.merge! YAML.load_file(".git_tracking")
+      end
+    end
+
+    def raise_on_debugger
+      @config[:raise_on_debugger]
+    end
+
+    def raise_on_incomplete_merge
+      @config[:raise_on_incomplete_merge]
+    end
+
+    def emails
+      @config[:keys].keys
+    end
+
+    def last_email
+      @config[:keys].invert[last_api_key]
+    end
+
+    def last_commit_info
+      info = `git log -n 1`.split("\n")
+      info = "#{info.first}\n#{info.last}"
+    end
+
+    def author
+      `git config user.name`.chomp
+    end
+
+    def authors
+      @config[:authors]
+    end
+
+    def author=(new_author)
+      @config[:authors].push(new_author).uniq!
+      write_to_file
+      system "git config user.name '#{new_author}'"
+    end
+
+    [:last_story_id, :last_api_key].each do |config_item|
+      git_config_key = config_item.to_s.gsub("_","-")
+      define_method(config_item) do
+        `git config git-tracking.#{git_config_key}`.chomp
+      end
+
+      define_method("#{config_item}=") do |value|
+        system "git config git-tracking.#{git_config_key} '#{value}'"
+      end
+    end
+
+    def key_for_email(email, key=nil)
+      return (self.last_api_key = @config[:keys][email]) if key.nil?
+      self.last_api_key = key
+      @config[:keys][email] = key
+      write_to_file
+    end
+
+    def project_id(id=nil)
+      return @config[:project_id] if id.nil?
+      @config[:project_id] = id
+      write_to_file
+      id
+    end
+
+    def write_to_file
+      File.open(".git_tracking", "w") do |file|
+        YAML.dump(@config, file)
+      end
+    end
+  end
+end

data/lib/git_tracking/detect.rb

@@ -0,0 +1,26 @@
+class GitTracking
+  class << self
+    def detect_debuggers
+      file_names = `git diff-index --cached -Sdebugger --name-only HEAD`.chomp
+      file_names = file_names.gsub(".git_tracking\n",'')
+      if file_names != ""
+        highline.say highline.color("The following files have 'debugger' statements in them: ", :red)
+        highline.say file_names
+        raise DebuggerException,
+          "Please remove debuggers prior to committing" if config.raise_on_debugger
+      end
+    end
+
+    def detect_incomplete_merges
+      file_names = `git diff-index --cached -S'<<<<<<<' --name-only HEAD`.chomp.split
+      file_names += `git diff-index --cached -S'>>>>>>>' --name-only HEAD`.chomp.split
+      file_names = file_names.uniq.join("\n")
+      if file_names != ""
+        highline.say highline.color("The following files have incomplete merges: ", :red)
+        highline.say file_names
+        raise IncompleteMergeException,
+          "Please complete your merge prior to committing" if config.raise_on_incomplete_merge
+      end
+    end
+  end
+end

data/lib/git_tracking/version.rb

@@ -0,0 +1,3 @@
+class GitTracking
+  VERSION = "0.1.0"
+end

data/lib/git_tracking.rb

@@ -0,0 +1,161 @@
+this_dir = File.expand_path(File.dirname(__FILE__))
+$:.unshift this_dir unless $:.include? this_dir
+
+# stdlib
+if RUBY_VERSION.match "1.9"
+  require 'fileutils'
+else
+  require 'ftools'
+end
+require 'yaml'
+
+# gems
+require 'highline'
+require 'pivotal-tracker'
+
+# stuff frm this library
+require 'git_tracking/config'
+require 'git_tracking/detect'
+
+class PreCommitException < Exception; end
+class DebuggerException < PreCommitException; end
+class IncompleteMergeException < PreCommitException; end
+
+HighLine.track_eof = false
+
+class GitTracking
+  class << self
+    def highline
+      @highline ||= HighLine.new($stdin.reopen("/dev/tty", "a+"), $stdout)
+    end
+
+    def config
+      @config ||= Config.new
+    end
+
+    def commit_message
+      @commit_message ||= File.read(ARGV[0])
+    end
+
+    def pre_commit
+      detect_debuggers
+      detect_incomplete_merges
+    end
+
+    def prepare_commit_msg
+      author
+      commit_message
+      File.open(ARGV[0], "w") do |f|
+        f.puts story_info
+        f.puts
+        f.puts "  - #{commit_message}"
+      end
+    end
+
+    def post_commit
+      @api_key = config.last_api_key
+      story = get_story(config.last_story_id)
+      story.notes.create(:text => config.last_commit_info)
+    end
+
+    def pivotal_project
+      return @pivotal_project if @pivotal_project
+      PivotalTracker::Client.token = api_key
+      @pivotal_project = PivotalTracker::Project.find(project_id)
+    end
+
+    def project_id
+      return config.project_id if config.project_id
+      id = highline.ask("Please enter the PivotalTracker project id for this project") do |q|
+        q.validate = lambda do |a|
+          PivotalTracker::Client.token = api_key
+          PivotalTracker::Project.find(a) rescue false
+        end
+      end
+      config.project_id(id)
+    end
+
+    def story_info
+      "[##{story.id}] #{story.name}"
+    end
+
+    def story
+      return @story if @story
+
+      if story_id && story = get_story(story_id)
+        highline.say("Found a valid story id in your branch or commit: #{story.id} - #{story.name}")
+        @story = highline.ask("Hit enter to confirm story id #{story.id}, or enter some other story id: ", lambda{|a| get_story(a)}) do |q|
+          q.default =  story.id
+          q.validate = lambda{|a| check_story_id(a)}
+        end
+      else
+        @story = highline.ask("Please enter a valid Pivotal Tracker story id: ", lambda{|a| get_story(a)}) do |q|
+          q.validate = lambda{|a| check_story_id(a)}
+        end
+      end
+      config.last_story_id = @story.id
+
+      @story
+    end
+
+    def branch
+      `git branch 2> /dev/null | sed -e '/^[^*]/d' -e 's/* \(.*\)/\1/'`.chomp.gsub("* ", "")
+    end
+
+    def story_id
+      @story_id ||= (extract_story_id(commit_message) || extract_story_id(branch) || config.last_story_id)
+    end
+
+    def extract_story_id(string)
+      the_story_id = string.match(/\d{5,}/)[0] if string.match(/\d{5,}/)
+      return the_story_id if check_story_id(the_story_id)
+    end
+
+    def author
+      return @author if @author
+      @author = highline.choose(*config.authors) do |menu|
+        menu.header = "Git Author (default will be: #{config.author})"
+        menu.default = config.author
+        menu.choice("Enter new") { highline.ask("New git author: ") }
+      end
+      config.author = @author
+    end
+
+    def api_key
+      return @api_key if @api_key
+      message, retry_count = nil, 0
+      email = highline.choose(*config.emails) do |menu|
+        menu.header = "Pivotal Tracker email (default is: #{config.last_email})"
+        menu.default = config.last_email
+        menu.choice("Enter new") { highline.ask("New Email: ") }
+      end
+      unless @api_key = config.key_for_email(email.to_s)
+        begin
+          highline.say message if message
+          password = highline.ask("Enter your PivotalTracker password: ") {|q| q.echo = "x" }
+          @api_key = PivotalTracker::Client.token(email, password)
+          config.key_for_email(email, @api_key)
+        rescue RestClient::Request::Unauthorized
+          retry_count += 1
+          message = "401 Unauthorized. Please try again."
+          if retry_count < 3
+            retry
+          else
+            highline.say("Unable to authenticate to Pivotal Tracker. Exiting...")
+            raise RestClient::Request::Unauthorized
+          end
+        end
+      end
+
+      @api_key
+    end
+
+    def check_story_id(id)
+      return true if get_story(id)
+    end
+
+    def get_story(id)
+      pivotal_project.stories.find(id.to_i) rescue nil
+    end
+  end
+end

data/spec/config_spec.rb

@@ -0,0 +1,199 @@
+require 'lib/git_tracking'
+
+describe GitTracking::Config do
+  before(:all) do
+    File.rename ".git_tracking", ".git_tracking.real" if File.exists?(".git_tracking")
+    @orig_author = `git config user.name`.chomp
+    @orig_last_api_key = `git config git-tracking.last-api-key`.chomp
+    @orig_last_story_id = `git config git-tracking.last-story-id`.chomp
+  end
+
+  after(:all) do
+    File.rename ".git_tracking.real", ".git_tracking" if File.exists?(".git_tracking.real")
+    system "git config user.name '#{@orig_author}'"
+    system "git config git-tracking.last-api-key '#{@orig_last_api_key}'"
+    system "git config git-tracking.last-story-id '#{@orig_last_story_id}'"
+  end
+
+  after(:each) { File.delete(".git_tracking") if File.exists?(".git_tracking") }
+  let(:config) { GitTracking::Config.new }
+
+  it "#initialize should merge in config from .git_tracking file" do
+    config_hash = config.instance_variable_get("@config")
+    config_hash.should == {
+        :raise_on_incomplete_merge => true,
+        :raise_on_debugger => true,
+        :authors => [],
+        :keys => {}
+    }
+    special_options = {
+      :raise_on_incomplete_merge => false,
+      :raise_on_debugger => false
+    }
+    File.open(".git_tracking", "w") do |file|
+      YAML.dump(special_options, file)
+    end
+    GitTracking::Config.new.instance_variable_get("@config").should == config_hash.merge(special_options)
+  end
+
+  it "#raise_on_debugger should return the correct config value" do
+    config.instance_eval { @config[:raise_on_debugger] = true }
+    config.raise_on_debugger.should be_true
+    config.instance_eval { @config[:raise_on_debugger] = false }
+    config.raise_on_debugger.should be_false
+  end
+
+  it "#raise_on_incomplete_merge should return the correct config value" do
+    config.instance_eval { @config[:raise_on_incomplete_merge] = true }
+    config.raise_on_incomplete_merge.should be_true
+    config.instance_eval { @config[:raise_on_incomplete_merge] = false }
+    config.raise_on_incomplete_merge.should be_false
+  end
+
+  it "#emails should return an array of email addresses" do
+    config.instance_eval do
+      @config[:keys] = {
+        "foo@bar.com" => "alsdkjf91",
+        "baz@bang.com" => "dsgkj39dk3"
+      }
+    end
+    config.emails.should == ["foo@bar.com", "baz@bang.com"]
+  end
+
+  it "#author should return the user.name value from the git config" do
+    system "git config user.name 'Steve'"
+    config.author.should == 'Steve'
+  end
+
+  describe "#author=" do
+    it "should set the user.name in the git config" do
+      (config.author='Ghost').should == "Ghost"
+      `git config user.name`.chomp.should == "Ghost"
+    end
+
+    it "should add the author to the list in .git_tracking file" do
+      config.instance_eval { @config[:authors] = ["Joe"] }
+      config.author = "Steve"
+      config.authors.should include("Steve")
+      YAML.load_file(".git_tracking")[:authors].should include("Steve")
+    end
+
+    it "should not add the author more than once" do
+      config.instance_eval { @config[:authors] = ["Joe"] }
+      config.author = "Joe"
+      config.authors.should == ["Joe"]
+      YAML.load_file(".git_tracking")[:authors].should == ["Joe"]
+    end
+  end
+
+  it "#authors should return an array of authors" do
+    config.instance_eval { @config[:authors] = ["Joe", "Bob", "Steve"] }
+    config.authors.should == ["Joe", "Bob", "Steve"]
+  end
+
+  describe "#last_commit_info" do
+    before(:all) do
+      File.rename ".git", ".git_old" if File.exists? ".git"
+    end
+    before(:each) do
+      system "git init; git add README; git commit -m 'initial commit'"
+    end
+    after(:each) do
+      File.delete "foo.txt" if File.exists? "foo.txt"
+      system "rm -rf .git" if File.exists? ".git"
+    end
+    after(:all) do
+      File.rename ".git_old", ".git" if File.exists? ".git_old"
+    end
+
+    it "should return info about the last commit" do
+      f = File.new("foo.txt", "w") {|f| f.puts "lalala"}
+      system "git add foo.txt"
+      system "git commit -m '[#1235] Story info\n  - best commit evar'"
+      config.last_commit_info.should match(/commit \w{40,40}\n      - best commit evar/)
+    end
+  end
+
+  it "#last_story_id should return the git-tracking.last-story-id from git config" do
+    system "git config git-tracking.last-story-id '736741'"
+    config.last_story_id.should == '736741'
+  end
+
+  it "#last_story_id= should set the git-tracking.last-story-id in git config" do
+    (config.last_story_id='234900').should == '234900'
+    `git config git-tracking.last-story-id`.chomp.should == '234900'
+  end
+
+  it "#last_api_key should return the git-tracking.last-api-key from git config" do
+    system "git config git-tracking.last-api-key '736741'"
+    config.last_api_key.should == '736741'
+  end
+
+  it "#last_api_key= should set the git-tracking.last-api-key in git config" do
+    (config.last_api_key='123444').should == '123444'
+    `git config git-tracking.last-api-key`.chomp.should == '123444'
+  end
+
+  it "#last_email should return the email that corresponds to the last api key used" do
+    config.instance_eval do
+      @config[:keys] = {
+        "foo@bar.com" => "987125jf"
+      }
+    end
+    system "git config git-tracking.last-api-key '987125jf'"
+    config.last_email.should == "foo@bar.com"
+  end
+
+  describe "#project_id" do
+    it "should return the project_id" do
+      config.instance_eval { @config[:project_id] = '7472' }
+      config.project_id.should == '7472'
+    end
+
+    it "should set the project id and store it" do
+      config.project_id('8765').should == '8765'
+      YAML.load_file(".git_tracking")[:project_id].should == '8765'
+    end
+  end
+
+  describe "#key_for_email" do
+    it "should return the pivotal api key" do
+      config.instance_eval do
+        @config[:keys] = {
+          "foo@bar.com" => "alsdkjf91",
+          "baz@bang.com" => "dsgkj39dk3"
+        }
+      end
+      config.key_for_email("foo@bar.com").should == 'alsdkjf91'
+    end
+
+    it "should set the pivotal api key and store it" do
+      config.key_for_email("foo@bar.com", 'kdslghj348')
+      YAML.load_file(".git_tracking")[:keys]["foo@bar.com"].should == 'kdslghj348'
+    end
+
+    it "should set the last_api_key as well" do
+      config.should_receive(:last_api_key=).with('kdslghj348').ordered
+      config.should_receive(:last_api_key=).with('dsgkj39dk3').ordered
+      config.key_for_email("foo@bar.com", 'kdslghj348')
+      config.instance_eval do
+        @config[:keys] = {
+          "baz@bang.com" => "dsgkj39dk3"
+        }
+      end
+      config.key_for_email("baz@bang.com")
+    end
+  end
+
+  it "#write_to_file should write the @config var to the file" do
+    special_options = {
+      :raise_on_incomplete_merge => false,
+      :raise_on_debugger => false,
+      :emails => ["your@mom.com"]
+    }
+    config.instance_variable_set("@config", special_options)
+    config.write_to_file
+    YAML.load_file(".git_tracking") == special_options
+  end
+end
+

data/spec/detect_spec.rb

@@ -0,0 +1,95 @@
+require 'lib/git_tracking'
+
+describe GitTracking, "detect" do
+  before(:all) do
+    File.rename ".git_tracking", ".git_tracking.real" if File.exists?(".git_tracking")
+    File.rename ".git", ".git_old" if File.exists? ".git"
+  end
+
+  before(:each) do
+    do_cmd "git init; git add README; git commit -m 'initial commit'"
+  end
+
+  after(:each) do
+    File.delete "foo.txt" if File.exists? "foo.txt"
+    File.delete ".git_tracking" if File.exists? ".git_tracking"
+    do_cmd "rm -rf .git" if File.exists? ".git"
+  end
+
+  after(:all) do
+    File.rename ".git_old", ".git" if File.exists? ".git_old"
+    File.rename ".git_tracking.real", ".git_tracking" if File.exists?(".git_tracking.real")
+  end
+
+  describe ".detect_debuggers" do
+    context "configured to reject commits with debuggers" do
+      it "should detect debuggers and raise DebuggerException" do
+        GitTracking.config.stub(:raise_on_debugger).and_return(true)
+        make_file "foo.txt", "debugger"
+        make_file ".git_tracking", "debugger"
+        do_cmd "git add foo.txt"
+        do_cmd "git add .git_tracking"
+        GitTracking.highline.should_receive("say")
+        GitTracking.highline.should_receive("say").with("foo.txt")
+        lambda{GitTracking.detect_debuggers}.should(
+          raise_error(DebuggerException, "Please remove debuggers prior to committing"))
+      end
+    end
+
+    context "configured to simply warn about commits with debuggers" do
+      it "should detect debuggers" do
+        GitTracking.config.stub(:raise_on_debugger).and_return(false)
+        make_file "foo.txt", "debugger"
+        make_file ".git_tracking", "debugger"
+        do_cmd "git add foo.txt"
+        do_cmd "git add .git_tracking"
+        GitTracking.highline.should_receive("say")
+        GitTracking.highline.should_receive("say").with("foo.txt")
+        lambda{GitTracking.detect_debuggers}.should_not raise_error
+      end
+    end
+  end
+
+  describe ".detect_incomplete_merges" do
+    context "configured to reject commits with incomplete merges" do
+      it "should detect incomplete merges and raise IncompleteMergeException" do
+        GitTracking.config.stub(:raise_on_incomplete_merge).and_return(true)
+        make_file "foo.txt", "<<<<<<<", "your changes", "=======", "my changes", ">>>>>>>"
+        do_cmd "git add foo.txt"
+        GitTracking.highline.should_receive("say")
+        GitTracking.highline.should_receive("say").with("foo.txt")
+        lambda{GitTracking.detect_incomplete_merges}.should(
+          raise_error(IncompleteMergeException, "Please complete your merge prior to committing"))
+      end
+    end
+
+    context "configured to simply warn about commits with incomplete merges" do
+      it "should detect incomplete merges and raise IncompleteMergeException" do
+        GitTracking.config.stub(:raise_on_incomplete_merge).and_return(false)
+        make_file "foo.txt", "<<<<<<<", "your changes", "=======", "my changes", ">>>>>>>"
+        do_cmd "git add foo.txt"
+        GitTracking.highline.should_receive("say")
+        GitTracking.highline.should_receive("say").with("foo.txt")
+        lambda{GitTracking.detect_incomplete_merges}.should_not(
+          raise_error(IncompleteMergeException, "Please complete your merge prior to committing"))
+      end
+    end
+  end
+end
+
+def make_file(name, *content)
+  f = File.new(name, "w")
+  f.puts *content
+  f.close
+end
+
+def do_cmd(command)
+  orig_stdout = $stdout
+
+  # redirect stdout to /dev/null
+  $stdout = File.new('/dev/null', 'w')
+  system command
+ensure
+  # restore stdout
+  $stdout = orig_stdout
+end

data/spec/git_tracking_spec.rb

@@ -0,0 +1,254 @@
+require 'git_tracking'
+require 'ruby-debug'
+
+describe GitTracking do
+  before(:all) do
+    @original_git_author = `git config --global user.name`.chomp
+  end
+
+  after(:all) do
+    system "git config --global user.name '#{@original_git_author}'"
+    File.delete("foo.txt") if File.exists?("foo.txt")
+  end
+
+  it ".pre_commit should call detect_debuggers and detect_incomplete_merges" do
+    GitTracking.should_receive(:detect_debuggers)
+    GitTracking.should_receive(:detect_incomplete_merges)
+    GitTracking.pre_commit
+  end
+
+  describe ".prepare_commit_msg" do
+    it "should get the message" do
+      old_argv = ARGV
+      File.open("foo.txt", "w") do |f|
+        f.print "My awesome commit msg!"
+      end
+      ARGV = ["foo.txt"]
+      GitTracking.stub(:story_info).and_return "[#12345] Best feature evar"
+      GitTracking.stub(:author).and_return "Steve & Ghost Co-Pilot"
+      GitTracking.prepare_commit_msg
+      commit_msg = File.open("foo.txt", "r").read
+      commit_msg.should == <<STRING
+[#12345] Best feature evar
+
+  - My awesome commit msg!
+STRING
+      ARGV = old_argv
+    end
+
+    it "should call story_info and author" do
+      ARGV = ["foo.txt"]
+      GitTracking.should_receive(:story_info).and_return "[#12345] Best feature evar"
+      GitTracking.should_receive(:author)
+      GitTracking.prepare_commit_msg
+    end
+  end
+
+  it ".post_commit should create a comment on the story with the commit msg and hash" do
+    story = mock("story")
+    notes = mock("notes")
+    GitTracking.stub(:get_story).and_return(story)
+    GitTracking.should_not_receive(:story_id)
+    story.should_receive(:notes).and_return(notes)
+    GitTracking.config.should_receive(:last_commit_info).and_return("984752 [#27491] Best commit evar")
+    notes.should_receive(:create).with(:text => "984752 [#27491] Best commit evar")
+    GitTracking.post_commit
+  end
+
+  describe ".story" do
+    before do
+      GitTracking.class_eval{@story = nil}
+    end
+
+    it "should require a story" do
+      the_story = mock('story', :name => 'Best feature evar', :id => 12345)
+      GitTracking.stub(:story_id).and_return("")
+      GitTracking.stub(:get_story).and_return(nil)
+      GitTracking.highline.should_receive(:ask).with("Please enter a valid Pivotal Tracker story id: ", an_instance_of(Proc)).and_return(the_story)
+      GitTracking.config.should_receive(:last_story_id=).with(12345)
+      GitTracking.story.should == the_story
+    end
+
+    it "should not prompt once a story has been confirmed" do
+      the_story = mock('story', :name => 'Best feature evar', :id => 12345)
+      GitTracking.class_eval {@story = the_story}
+      GitTracking.should_not_receive(:highline)
+      GitTracking.story.should == the_story
+    end
+
+    it "should allow you to enter an alternate story when it finds a story_id" do
+      the_story = mock('story', :name => 'Best feature evar', :id => 85918)
+      GitTracking.stub(:story_id).and_return(the_story.id)
+      GitTracking.stub(:get_story).and_return(the_story)
+      GitTracking.config.should_receive(:last_story_id=).with(85918)
+      GitTracking.highline.should_receive(:say).
+        with("Found a valid story id in your branch or commit: 85918 - Best feature evar")
+      GitTracking.highline.should_receive(:ask).
+        with("Hit enter to confirm story id 85918, or enter some other story id: ", an_instance_of(Proc)).
+        and_return(the_story)
+      GitTracking.story.should == the_story
+    end
+  end
+
+  describe ".story_id" do
+    before(:each) do
+      GitTracking.stub(:check_story_id).and_return(true)
+      GitTracking.instance_eval{@story_id = nil}
+    end
+
+    it "should check the commit message for a story id" do
+      GitTracking.stub!(:commit_message).and_return("54261 - Fixing Javascript")
+      GitTracking.story_id.should == '54261'
+    end
+
+    it "should check the branch name for a story id" do
+      GitTracking.stub!(:commit_message).and_return("Fixing Javascript")
+      GitTracking.stub!(:branch).and_return("64371-js-bug")
+      GitTracking.story_id.should == '64371'
+    end
+
+    it "should check the .git/config file for the last story id" do
+      GitTracking.stub!(:commit_message).and_return("Fixing Javascript")
+      GitTracking.config.should_receive(:last_story_id).and_return('35236')
+      GitTracking.story_id.should == '35236'
+    end
+
+    it "should verify the story_id with the pivotal tracker API" do
+      GitTracking.stub!(:commit_message).and_return("Generating 55654 monkeys")
+      GitTracking.stub!(:branch).and_return("64371-js-bug")
+      GitTracking.should_receive(:check_story_id).with('55654').and_return(false)
+      GitTracking.should_receive(:check_story_id).with('64371').and_return(true)
+      GitTracking.story_id.should == "64371"
+    end
+  end
+
+  describe ".extract_story_id" do
+    it "should extract any number that is 5 digits or longer and return it" do
+      GitTracking.stub(:check_story_id).and_return(true)
+      GitTracking.extract_story_id("45674 - The best feature evar").should == "45674"
+      GitTracking.extract_story_id("90873 - The best feature evar").should == "90873"
+    end
+
+    it "should return nil if there is no number that is 5 digits or longer" do
+      GitTracking.stub(:check_story_id).and_return(true)
+      GitTracking.extract_story_id("The best feature evar").should be_nil
+    end
+
+    it "should return nil if it's not a valid Pivotal Tracker story id" do
+      GitTracking.stub(:check_story_id).and_return(false)
+      GitTracking.extract_story_id("45674 - The best feature evar").should be_nil
+    end
+  end
+
+  describe ".pivotal_project" do
+    before(:each) { GitTracking.instance_variable_set("@pivotal_project", nil) }
+    it "should get the token" do
+      project = mock("project")
+      PivotalTracker::Project.should_receive(:find).and_return(project)
+      GitTracking.should_receive(:api_key).and_return("alksjd9123lka")
+      GitTracking.pivotal_project.should == project
+    end
+
+    it "should get and use the project_id from config" do
+      project = mock("project")
+      GitTracking.stub(:api_key)
+      GitTracking.should_receive(:project_id).and_return(1235)
+      PivotalTracker::Project.should_receive(:find).with(1235).and_return(project)
+      GitTracking.pivotal_project.should == project
+    end
+  end
+
+  describe ".project_id" do
+    it "should prompt you to enter the project id if there is none defined" do
+      GitTracking.config.stub(:project_id).ordered.and_return(nil)
+      GitTracking.config.stub(:project_id).with(54876).ordered.and_return(54876)
+      GitTracking.highline.should_receive(:ask).with("Please enter the PivotalTracker project id for this project").and_return(54876)
+      GitTracking.project_id.should == 54876
+    end
+
+    it "should get the project id from the config" do
+      GitTracking.config.should_receive(:project_id).twice.and_return(9712)
+      GitTracking.project_id.should == 9712
+    end
+  end
+
+  describe ".check_story_id" do
+    before(:each) do
+      GitTracking.stub(:api_key).and_return(5678)
+    end
+
+    it "should return true for story id that can be found in tracker" do
+      PivotalTracker::Project.stub(:find).and_return(mock("project"))
+      GitTracking.pivotal_project.should_receive(:stories).and_return(mock("stories", :find => mock("story")))
+      GitTracking.check_story_id(5678).should be_true
+    end
+
+    it "should return false for a valid story id" do
+      PivotalTracker::Project.stub(:find).and_return(mock("project"))
+      GitTracking.pivotal_project.should_receive(:stories).and_return(mock("stories", :find => nil))
+      GitTracking.check_story_id(5678).should be_false
+    end
+  end
+
+  describe ".api_key" do
+    before(:each) { GitTracking.instance_eval{ @api_key = nil} }
+
+    it "should prompt for a pivotal login" do
+      GitTracking.config.stub(:emails).and_return(["steve@home.com", "john@doe.com"])
+      GitTracking.config.should_receive(:key_for_email).with("other@work.net").ordered.and_return(nil)
+      GitTracking.config.should_receive(:key_for_email).with("other@work.net", "0987654567").ordered
+      GitTracking.highline.should_receive(:choose).with("steve@home.com", "john@doe.com").and_return("other@work.net")
+      GitTracking.highline.should_receive(:ask).with("Enter your PivotalTracker password: ").and_return("password")
+      PivotalTracker::Client.should_receive(:token).with("other@work.net", "password").and_return("0987654567")
+      GitTracking.api_key.should == "0987654567"
+    end
+
+    it "should prompt you to enter an alternate pivotal login" do
+      GitTracking.config.stub(:emails).and_return(["steve@home.com", "john@doe.com"])
+      GitTracking.config.stub(:key_for_email).and_return("8876567898")
+      GitTracking.highline.should_receive(:choose).with("steve@home.com", "john@doe.com").and_return("steve@home.com")
+      GitTracking.api_key.should == "8876567898"
+    end
+
+    it "should allow you to re-enter your password if authentication fails" do
+      GitTracking.config.stub(:emails).and_return(["steve@home.com", "john@doe.com"])
+      GitTracking.config.stub(:key_for_email).and_return(nil)
+      GitTracking.highline.should_receive(:choose).and_return("other@work.net")
+      GitTracking.highline.should_receive(:ask).exactly(3).times.and_return("password")
+      PivotalTracker::Client.should_receive(:token).exactly(3).times.and_raise(RestClient::Request::Unauthorized)
+      lambda{GitTracking.api_key}.should raise_error(RestClient::Request::Unauthorized)
+    end
+  end
+
+  describe ".get_story" do
+    before(:each) do
+      GitTracking.stub(:api_key).and_return(5678)
+    end
+
+    it "should return true for story id that can be found in tracker" do
+      story = mock("story")
+      PivotalTracker::Project.stub(:find).and_return(mock("project"))
+      GitTracking.pivotal_project.should_receive(:stories).and_return(mock("stories", :find => story))
+      GitTracking.get_story(5678).should == story
+    end
+
+    it "should return false for a valid story id" do
+      PivotalTracker::Project.stub(:find).and_return(mock("project"))
+      GitTracking.pivotal_project.should_receive(:stories).and_return(mock("stories", :find => nil))
+      GitTracking.get_story(5678).should be_nil
+    end
+  end
+
+  it ".author should present you with an author menu" do
+    GitTracking.instance_eval{ @author = nil }
+    GitTracking.config.stub(:authors).and_return(["Ghost", "Steve"])
+    GitTracking.highline.should_receive(:choose).with("Ghost", "Steve").and_return("Derrick")
+    GitTracking.config.should_receive(:author=).with("Derrick")
+    GitTracking.author.should == "Derrick"
+  end
+
+  it ".story_info should format the story info appropriately" do
+    GitTracking.should_receive(:story).twice.and_return(mock("story", :name => "Best feature evar", :id => "12345"))
+    GitTracking.story_info.should == "[#12345] Best feature evar"
+  end
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification 
+name: git_tracking
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Steve Hull
+- Derrick Camerino
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-08 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: highline
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: pivotal-tracker
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+description: "Usage: after installing the gem, in your project directory, run: git_tracking"
+email: 
+- p.witty@gmail.com
+- robustdj@gmail.com
+executables: 
+- git_tracking
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .git_tracking
+- .gitignore
+- .rspec
+- Gemfile
+- Gemfile.lock
+- README
+- Rakefile
+- bin/git_tracking
+- git_tracking.gemspec
+- hooks/post-commit
+- hooks/pre-commit
+- hooks/prepare-commit-msg
+- lib/git_tracking.rb
+- lib/git_tracking/config.rb
+- lib/git_tracking/detect.rb
+- lib/git_tracking/version.rb
+- spec/config_spec.rb
+- spec/detect_spec.rb
+- spec/git_tracking_spec.rb
+has_rdoc: true
+homepage: http://rubygems.org/gems/git_tracking
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: git_tracking
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Better integration between git and PivotalTracker
+test_files: 
+- spec/config_spec.rb
+- spec/detect_spec.rb
+- spec/git_tracking_spec.rb