git-pivotal-tracker 0.9.0

data/features/test_repo/origin.git/hooks/prepare-commit-msg.sample

@@ -0,0 +1,36 @@
+#!/bin/sh
+#
+# An example hook script to prepare the commit log message.
+# Called by "git commit" with the name of the file that has the
+# commit message, followed by the description of the commit
+# message's source.  The hook's purpose is to edit the commit
+# message file.  If the hook fails with a non-zero status,
+# the commit is aborted.
+#
+# To enable this hook, rename this file to "prepare-commit-msg".
+
+# This hook includes three examples.  The first comments out the
+# "Conflicts:" part of a merge commit.
+#
+# The second includes the output of "git diff --name-status -r"
+# into the message, just before the "git status" output.  It is
+# commented because it doesn't cope with --amend or with squashed
+# commits.
+#
+# The third example adds a Signed-off-by line to the message, that can
+# still be edited.  This is rarely a good idea.
+
+case "$2,$3" in
+  merge,)
+    /usr/bin/perl -i.bak -ne 's/^/# /, s/^# #/#/ if /^Conflicts/ .. /#/; print' "$1" ;;
+
+# ,|template,)
+#   /usr/bin/perl -i.bak -pe '
+#      print "\n" . `git diff --cached --name-status -r`
+#	 if /^#/ && $first++ == 0' "$1" ;;
+
+  *) ;;
+esac
+
+# SOB=$(git var GIT_AUTHOR_IDENT | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p')
+# grep -qs "^$SOB" "$1" || echo "$SOB" >> "$1"

data/features/test_repo/origin.git/hooks/update.sample

@@ -0,0 +1,128 @@
+#!/bin/sh
+#
+# An example hook script to blocks unannotated tags from entering.
+# Called by "git receive-pack" with arguments: refname sha1-old sha1-new
+#
+# To enable this hook, rename this file to "update".
+#
+# Config
+# ------
+# hooks.allowunannotated
+#   This boolean sets whether unannotated tags will be allowed into the
+#   repository.  By default they won't be.
+# hooks.allowdeletetag
+#   This boolean sets whether deleting tags will be allowed in the
+#   repository.  By default they won't be.
+# hooks.allowmodifytag
+#   This boolean sets whether a tag may be modified after creation. By default
+#   it won't be.
+# hooks.allowdeletebranch
+#   This boolean sets whether deleting branches will be allowed in the
+#   repository.  By default they won't be.
+# hooks.denycreatebranch
+#   This boolean sets whether remotely creating branches will be denied
+#   in the repository.  By default this is allowed.
+#
+
+# --- Command line
+refname="$1"
+oldrev="$2"
+newrev="$3"
+
+# --- Safety check
+if [ -z "$GIT_DIR" ]; then
+	echo "Don't run this script from the command line." >&2
+	echo " (if you want, you could supply GIT_DIR then run" >&2
+	echo "  $0 <ref> <oldrev> <newrev>)" >&2
+	exit 1
+fi
+
+if [ -z "$refname" -o -z "$oldrev" -o -z "$newrev" ]; then
+	echo "Usage: $0 <ref> <oldrev> <newrev>" >&2
+	exit 1
+fi
+
+# --- Config
+allowunannotated=$(git config --bool hooks.allowunannotated)
+allowdeletebranch=$(git config --bool hooks.allowdeletebranch)
+denycreatebranch=$(git config --bool hooks.denycreatebranch)
+allowdeletetag=$(git config --bool hooks.allowdeletetag)
+allowmodifytag=$(git config --bool hooks.allowmodifytag)
+
+# check for no description
+projectdesc=$(sed -e '1q' "$GIT_DIR/description")
+case "$projectdesc" in
+"Unnamed repository"* | "")
+	echo "*** Project description file hasn't been set" >&2
+	exit 1
+	;;
+esac
+
+# --- Check types
+# if $newrev is 0000...0000, it's a commit to delete a ref.
+zero="0000000000000000000000000000000000000000"
+if [ "$newrev" = "$zero" ]; then
+	newrev_type=delete
+else
+	newrev_type=$(git cat-file -t $newrev)
+fi
+
+case "$refname","$newrev_type" in
+	refs/tags/*,commit)
+		# un-annotated tag
+		short_refname=${refname##refs/tags/}
+		if [ "$allowunannotated" != "true" ]; then
+			echo "*** The un-annotated tag, $short_refname, is not allowed in this repository" >&2
+			echo "*** Use 'git tag [ -a | -s ]' for tags you want to propagate." >&2
+			exit 1
+		fi
+		;;
+	refs/tags/*,delete)
+		# delete tag
+		if [ "$allowdeletetag" != "true" ]; then
+			echo "*** Deleting a tag is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/tags/*,tag)
+		# annotated tag
+		if [ "$allowmodifytag" != "true" ] && git rev-parse $refname > /dev/null 2>&1
+		then
+			echo "*** Tag '$refname' already exists." >&2
+			echo "*** Modifying a tag is not allowed in this repository." >&2
+			exit 1
+		fi
+		;;
+	refs/heads/*,commit)
+		# branch
+		if [ "$oldrev" = "$zero" -a "$denycreatebranch" = "true" ]; then
+			echo "*** Creating a branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/heads/*,delete)
+		# delete branch
+		if [ "$allowdeletebranch" != "true" ]; then
+			echo "*** Deleting a branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/remotes/*,commit)
+		# tracking branch
+		;;
+	refs/remotes/*,delete)
+		# delete tracking branch
+		if [ "$allowdeletebranch" != "true" ]; then
+			echo "*** Deleting a tracking branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	*)
+		# Anything else (is there anything else?)
+		echo "*** Update hook: unknown type of update to ref $refname of type $newrev_type" >&2
+		exit 1
+		;;
+esac
+
+# --- Finished
+exit 0

data/features/test_repo/origin.git/info/exclude

@@ -0,0 +1,6 @@
+# git ls-files --others --exclude-from=.git/info/exclude
+# Lines that start with '#' are comments.
+# For a project mostly in C, the following would be a good set of
+# exclude patterns (uncomment them if you want to use them):
+# *.[oa]
+# *~

data/features/test_repo/origin.git/logs/HEAD

@@ -0,0 +1 @@
+0000000000000000000000000000000000000000 10ecf2b7ce989f01f3f7266e712b48d9275f2635 Jeff Tucker <trydionel@gmail.com> 1279979728 -0400	commit (initial): A blank repo for testing

data/features/test_repo/origin.git/logs/refs/heads/master

@@ -0,0 +1 @@
+0000000000000000000000000000000000000000 10ecf2b7ce989f01f3f7266e712b48d9275f2635 Jeff Tucker <trydionel@gmail.com> 1279979728 -0400	commit (initial): A blank repo for testing

data/features/test_repo/origin.git/refs/heads/master

@@ -0,0 +1 @@
+10ecf2b7ce989f01f3f7266e712b48d9275f2635

data/features/test_repo/readme

@@ -0,0 +1 @@
+Testing repo

data/features/unblock.feature

@@ -0,0 +1,68 @@
+Feature: git block
+
+  In order to get information about a specific card you can issue one of the following 
+  commands:
+
+    git unblock
+    git unblock <options>
+    git unblock <card_id>
+    git unblock <card_id> <options>
+
+  Supported options:
+    -k <api_key>    - specify the Pivotal API key to use. Overrides configuration.
+    -p <project_id> - specify the Pivotal project id to use. Overrides configuration.
+    
+  Background:
+    Given I have a Pivotal Tracker feature named "Test Story" with description "This is the description!"
+    And I am on the "CURRENT_CARD-feature" branch
+
+  # This scenario is to test the presence of a bug in Pivotal Tracker's v3 API. It is 
+  # impossible to remove the last label from a story. When this fails then git-unblock
+  # will need to be updated to not use a placeholder label.
+  Scenario: Is Pivotal's API for removing the last label on a card still broken?
+    Given I have configured the Git repos for Pivotal
+    And the card is labeled "blocked"
+    When I run `git-unblock`
+    Then the card CURRENT_CARD should have the "blocked" label
+
+  Scenario: Executing with no settings
+    When I run `git-unblock`
+    Then the output should contain:
+      """
+      Pivotal Tracker API Token and Project ID are required
+      """
+    And the exit status should be 1
+    
+  Scenario: Unblocking the current topic branch
+    Given I have configured the Git repos for Pivotal
+    And the card is labeled "blocked"
+    When I run `git-unblock`
+    Then the output should contain "Story CURRENT_CARD has been unblocked."
+    When the current card is refreshed
+    Then the card CURRENT_CARD should not have the "blocked" label
+
+  Scenario: Unlocking a specific card
+    Given I have configured the Git repos for Pivotal
+    And the card is labeled "blocked"
+    When I run `git-unblock CURRENT_CARD`
+    Then the output should contain "Story CURRENT_CARD has been unblocked."
+    When the current card is refreshed
+    Then the card CURRENT_CARD should not have the "blocked" label
+
+  Scenario: Unblocking a card that is not blocked
+    Given I have configured the Git repos for Pivotal
+    When I run `git-unblock CURRENT_CARD`
+    Then the output should contain "Story CURRENT_CARD is already unblocked."
+    When the current card is refreshed
+    Then the card CURRENT_CARD should not have the "blocked" label
+
+  Scenario: Trying to unblock when not on a topic branch and not supplying a card id
+    Given I have configured the Git repos for Pivotal
+    And I am on the "foo" branch
+    Then I should be on the "foo" branch
+    When I run `git-unblock`
+    Then the output should contain:
+      """
+      No story id was supplied and you aren't on a topic branch!
+      """
+  

data/git-pivotal-tracker.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-  
+$:.push File.expand_path("../lib", __FILE__)  
+  
+Gem::Specification.new do |s|  
+  s.name          = "git-pivotal-tracker"
+  s.version       = IO.read("VERSION")
+  s.platform      = Gem::Platform::RUBY
+  s.authors       = ["Zach Dennis", "Jeff Tucker", "Sam Stokes"]
+  s.email         = "zach.dennis@gmail.com"
+  s.homepage      = "https://github.com/zdennis/git-pivotal"  
+  s.summary       = "A collection of git utilities to ease integration with Pivotal Tracker."
+  s.description   = "A collection of git utilities to ease integration with 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"]
+
+  s.add_runtime_dependency(%q<pivotal-tracker>, [">= 0"])
+  s.add_development_dependency(%q<rake>, [">= 0"])
+  s.add_development_dependency(%q<mocha>, [">= 0"])
+  s.add_development_dependency(%q<simplecov>, [">= 0"])
+  s.add_development_dependency(%q<aruba>, [">= 0"])
+  s.add_development_dependency(%q<rspec>, [">= 0"])
+  s.add_development_dependency(%q<cucumber>, [">= 0"])
+end
+

data/lib/commands/accept.rb

@@ -0,0 +1,76 @@
+require 'commands/base'
+
+module Commands
+  class Accept < Base
+    def run!
+      super
+
+      unless story_id
+        put "Branch name must contain a Pivotal Tracker story id"
+        return 1
+      end
+
+      if story_is_acceptable?
+        accept_story!
+        return 0
+      else
+        put "Story is not in an acceptable state. It's currently #{story.current_state}."
+        return 1
+      end
+    end
+
+  protected
+  
+    def accept_story!
+      put "Marking Story #{story_id} as accepted..."
+      if story.update(:current_state => "accepted")
+        topic_branch = current_branch
+        
+        put "Pushing #{topic_branch} to #{remote}"
+        sys "git push --set-upstream #{remote} #{topic_branch}"
+        
+        put "Pulling #{integration_branch}..."
+        sys "git checkout #{integration_branch}"
+        sys "git pull"
+
+        put "Merging #{topic_branch} into #{integration_branch}"
+        sys "git merge --no-ff #{topic_branch}"
+  
+        put "Pushing #{integration_branch} to #{remote}"
+        sys "git push"
+      
+        put "Now on #{integration_branch}."
+
+        return 0
+      else
+        put "Unable to mark Story #{story_id} as finished"
+
+        return 1
+      end
+    end
+  
+    def chore_and_acceptable?
+      story.story_type == "chore" && story.current_state == "accepted"
+    end
+    
+    def bug_and_acceptable?
+      story.story_type == "bug" && %(finished delivered).include?(story.current_state)
+    end
+    
+    def feature_and_acceptable?
+      story.story_type == "feature" && %(finished delivered).include?(story.current_state)
+    end
+  
+    def story_is_acceptable?
+      chore_and_acceptable? || bug_and_acceptable? || feature_and_acceptable?
+    end
+
+    def story_id
+      match = current_branch[/\d+/] and match.to_i
+    end
+
+    def story
+      @story ||= project.stories.find(story_id)
+    end
+  end
+end

data/lib/commands/base.rb

@@ -0,0 +1,128 @@
+require 'rubygems'
+require 'pivotal-tracker'
+require 'optparse'
+
+module Commands
+  class Base
+
+    attr_accessor :input, :output, :options
+
+    def initialize(*args)
+      @input = STDIN
+      @output = STDOUT
+
+      @options = {}
+
+      parse_gitconfig
+      parse_argv(*args)
+    end
+    
+    def with(input, output)
+      tap do
+        @input = input
+        @output = output
+      end
+    end
+
+    def put(string, newline=true)
+      @output.print(newline ? string + "\n" : string) unless options[:quiet]
+    end
+
+    def sys(cmd)
+      put cmd if options[:verbose]
+      system cmd #"#{cmd} > /dev/null 2>&1"
+    end
+
+    def get(cmd)
+      put cmd if options[:verbose]
+      `#{cmd}`
+    end
+
+    def run!
+      unless options[:api_token] && options[:project_id]
+        put "Pivotal Tracker API Token and Project ID are required"
+        return 1
+      end
+
+      PivotalTracker::Client.token = options[:api_token]
+      PivotalTracker::Client.use_ssl = options[:use_ssl]
+
+      return 0
+    end
+
+  protected
+  
+    def on_parse(opts)
+      # no-op, override in sub-class to provide command specific options
+    end
+
+    def current_branch
+      @current_branch ||= get('git symbolic-ref HEAD').chomp.split('/').last
+    end
+
+    def project
+      @project ||= PivotalTracker::Project.find(options[:project_id])
+    end
+    
+    def acceptance_branch
+      options[:acceptance_branch] || "acceptance"
+    end
+
+    def integration_branch
+      options[:integration_branch] || "master"
+    end
+    
+    def full_name
+      options[:full_name]
+    end
+    
+    def remote
+      options[:remote] || "origin"
+    end
+
+  private
+
+    def parse_gitconfig
+      token              = get("git config --get pivotal.api-token").strip
+      name               = get("git config --get pivotal.full-name").strip
+      id                 = get("git config --get pivotal.project-id").strip
+      remote             = get("git config --get pivotal.remote").strip
+      acceptance_branch  = get("git config --get pivotal.acceptance-branch").strip
+      integration_branch = get("git config --get pivotal.integration-branch").strip
+      only_mine          = get("git config --get pivotal.only-mine").strip
+      append_name        = get("git config --get pivotal.append-name").strip
+      use_ssl            = get("git config --get pivotal.use-ssl").strip
+
+      options[:api_token]          = token              unless token == ""
+      options[:project_id]         = id                 unless id == ""
+      options[:full_name]          = name               unless name == ""
+      options[:remote]             = remote             unless remote == ""
+      options[:acceptance_branch]  = acceptance_branch  unless acceptance_branch == ""
+      options[:integration_branch] = integration_branch unless integration_branch == ""
+      options[:only_mine]          = (only_mine != "")  unless name == ""
+      options[:append_name]        = (append_name != "")
+      options[:use_ssl] = (/^true$/i.match(use_ssl))
+    end
+
+    def parse_argv(*args)
+      OptionParser.new do |opts|
+        opts.banner = "Usage: git pick [options]"
+        opts.on("-k", "--api-key=", "Pivotal Tracker API key") { |k| options[:api_token] = k }
+        opts.on("-p", "--project-id=", "Pivotal Tracker project id") { |p| options[:project_id] = p }
+        opts.on("-n", "--full-name=", "Pivotal Tracker full name") { |n| options[:full_name] = n }
+        opts.on("-b", "--integration-branch=", "The branch to merge finished stories back down onto") { |b| options[:integration_branch] = b }
+        opts.on("-m", "--only-mine", "Only select Pivotal Tracker stories assigned to you") { |m| options[:only_mine] = m }
+        opts.on("-S", "--use-ssl", "Use SSL for connection to Pivotal Tracker (for private repos(?))") { |s| options[:use_ssl] = s }
+        opts.on("-a", "--append-name", "whether to append the story id to branch name instead of prepend") { |a| options[:append_name] = a }
+        opts.on("-D", "--defaults", "Accept default options. No-interaction mode") { |d| options[:defaults] = d }
+        opts.on("-q", "--quiet", "Quiet, no-interaction mode") { |q| options[:quiet] = q }
+        opts.on("-v", "--[no-]verbose", "Run verbosely") { |v| options[:verbose] = v }
+        
+        on_parse(opts)
+        
+        opts.on_tail("-h", "--help", "This usage guide") { put opts.to_s; exit 0 }
+      end.parse!(args)
+    end
+
+  end
+end