ticgit 0.3.6

data/bin/ti

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+# This is a command line client that does all the actual tic commands
+# 
+# author : Scott Chacon (schacon@gmail.com)
+#
+
+require 'rubygems'
+require 'ticgit'
+#require File.dirname(__FILE__) + '/../lib/ticgit'
+TicGit::CLI.execute

data/bin/ticgitweb

@@ -0,0 +1,308 @@
+#!/usr/bin/env ruby
+
+# starts a sinatra based web server that provides an interface to 
+# your ticgit tickets
+# 
+# some of the sinatra code borrowed from sr's git-wiki
+#
+# author : Scott Chacon (schacon@gmail.com)
+#
+
+%w(rubygems sinatra git ticgit haml).each do |dependency| 
+  begin
+    require dependency
+  rescue LoadError => e
+    puts "You need to install #{dependency} before we can proceed"
+  end
+end
+
+# !! TODO : if ARGV[1] is a path to a git repo, use that
+# otherwise, look in ~/.ticgit
+
+$ticgit = TicGit.open('.')
+
+get('/_stylesheet.css') { Sass::Engine.new(File.read(__FILE__).gsub(/.*__END__/m, '')).render }
+
+# ticket list view
+get '/' do
+  @tickets = $ticgit.ticket_list(:order => 'date.desc')
+  haml(list('all'))
+end
+
+get '/fs/:state' do
+  @tickets = $ticgit.ticket_list(:state => params[:state], :order => 'date.desc')
+  haml(list(params[:state]))
+end
+
+get '/tag/:tag' do
+  @tickets = $ticgit.ticket_list(:tag => params[:tag], :order => 'date.desc')
+  haml(list(params[:tag]))
+end
+
+get '/sv/:saved_view' do
+  @tickets = $ticgit.ticket_list(:saved => params[:saved_view])
+  haml(list(params[:saved_view]))
+end
+
+# ticket single view
+get '/ticket/:ticket' do
+  @ticket = $ticgit.ticket_show(params[:ticket])
+  haml(show)
+end
+
+
+# add ticket
+get '/t/new' do
+  haml(new_ticket)
+end
+
+# add ticket finalize
+post '/t/new' do
+  title = params[:title].to_s.strip
+  if title.size > 1
+    tags = params[:tags].split(',').map { |t| t.strip } rescue nil  
+    t = $ticgit.ticket_new(title, {:comment => params[:comment].strip, :tags => tags})
+    redirect '/ticket/' + t.ticket_id.to_s
+  else
+    redirect '/t/new'
+  end
+end
+
+
+# add comment
+post '/a/add_comment/:ticket' do
+  t = $ticgit.ticket_comment(params[:comment], params[:ticket])
+  redirect '/ticket/' + params[:ticket]
+end
+
+# add tag
+post '/a/add_tags/:ticket' do
+  t = $ticgit.ticket_tag(params[:tags], params[:ticket])
+  redirect '/ticket/' + params[:ticket]
+end
+
+# change ticket state
+get '/a/change_state/:ticket/:state' do
+  $ticgit.ticket_change(params[:state], params[:ticket])
+  redirect '/ticket/' + params[:ticket]
+end
+
+
+def layout(title, content)
+  @saved = $ticgit.config['list_options'].keys rescue []
+  %Q(
+%html
+  %head
+    %title #{title}
+    %link{:rel => 'stylesheet', :href => '/_stylesheet.css', :type => 'text/css', :media => 'screen'}
+    %meta{'http-equiv' => 'Content-Type', :content => 'text/html; charset=utf-8'}
+
+  %body
+    #navigation
+      %a{:href => '/'} All
+      %a{:href => '/fs/open'} Open
+      %a{:href => '/fs/resolved'} Resolved
+      %a{:href => '/fs/hold'} Hold
+      %a{:href => '/fs/invalid'} Invalid
+      - if !@saved.empty?
+        | Saved:
+        - @saved.each do |s|
+          %a{:href => "/sv/\#{s}"}= s
+    #action
+      %a{:href => '/t/new'} New Ticket
+
+    #{content}
+  )
+end
+
+def new_ticket
+  layout('New Ticket', %q{
+    %h1 Create a New Ticket
+    %form{:action => '/t/new', :method => 'POST'}
+      %table
+        %tr
+          %th Title
+          %td 
+            %input{:type => 'text', :name => 'title', :size => 30}
+        %tr
+          %th Tags
+          %td
+            %input{:name => 'tags', :size => 30}
+            %small (comma delimited)
+        %tr
+          %th Comment
+          %td 
+            %textarea{:name => 'comment', :rows => 15, :cols => 30}
+        %tr
+          %td
+          %td
+            %input{:type => 'submit', :value => 'Create Ticket'}
+  })
+end
+
+def list(title = 'all')
+  @title = title
+  layout(title + ' tickets', %q{
+    %h1= "#{@title} tickets"
+    - if @tickets.empty?
+      %p No tickets found.
+    - else
+      %table.long
+        - c = 'even'
+        - @tickets.each do |t|
+          %tr{:class => (c == 'even' ? c = 'odd' : c = 'even') }
+            %td
+              %a{:href => "/ticket/#{t.ticket_id}" }
+                %code= t.ticket_id[0,6]
+            %td= t.title
+            %td{:class => t.state}= t.state
+            %td= t.opened.strftime("%m/%d")
+            %td= t.assigned_name
+            %td
+              - t.tags.each do |tag|
+                %a{:href => "/tag/#{tag}"}= tag
+  })
+end
+
+def show
+  layout('ticket', %q{
+  %center
+    %h1= @ticket.title
+  
+    %form{:action => "/a/add_tags/#{@ticket.ticket_id}", :method => 'POST'}
+      %table
+        %tr
+          %th TicId
+          %td
+            %code= @ticket.ticket_id
+        %tr
+          %th Assigned
+          %td= @ticket.assigned
+        %tr
+          %th Opened
+          %td= @ticket.opened
+        %tr
+          %th State
+          %td{:class => @ticket.state}
+            %table{:width => '300'}
+              %tr
+                %td{:width=>'90%'}= @ticket.state
+                - $ticgit.tic_states.select { |s| s != @ticket.state}.each do |st|
+                  %td{:class => st}
+                    %a{:href => "/a/change_state/#{@ticket.ticket_id}/#{st}"}= st[0,2]
+        %tr
+          %th Tags
+          %td
+            - @ticket.tags.each do |t|
+              %a{:href => "/tag/#{t}"}= t
+            %div.addtag
+              %input{:name => 'tags'}
+              %input{:type => 'submit', :value => 'add tag'}
+    
+    %h3 Comments
+    %form{:action => "/a/add_comment/#{@ticket.ticket_id}", :method => 'POST'}
+      %div
+        %textarea{:name => 'comment', :cols => 50}
+        %br
+        %input{:type => 'submit', :value => 'add comment'}
+        
+    %div.comments
+      - @ticket.comments.reverse.each do |t|
+        %div.comment
+          %span.head
+            Added
+            = t.added.strftime("%m/%d %H:%M")
+            by
+            = t.user
+          %div.comment-text
+            = t.comment
+        %br
+  })
+end
+
+__END__
+body
+  :font
+    family: Verdana, Arial, "Bitstream Vera Sans", Helvetica, sans-serif
+    color: black
+  line-height: 160%
+  background-color: white
+  margin: 2em
+
+#navigation
+  a
+    background-color: #e0e0e0
+    color: black
+    text-decoration: none
+    padding: 2px
+  padding: 5px
+  border-bottom: 1px black solid
+  
+#action
+  text-align: right
+  
+.addtag
+  padding: 5px 0
+  
+h1
+  display: block
+  padding-bottom: 5px
+
+a
+  color: black
+a.exists
+  font-weight: bold
+a.unknown
+  font-style: italic
+
+.comments
+  margin: 10px 20px
+  .comment
+    .head
+      background: #eee
+      padding: 4px
+    .comment-text
+      padding: 10px
+      color: #333
+  
+table.long
+  width: 100%
+  
+table
+  tr.even
+    td
+      background: #eee
+  tr.odd
+    td
+      background: #fff
+      
+table
+  tr
+    th
+      text-align: left
+      padding: 3px
+      vertical-align: top
+    td.open
+      background: #ada
+    td.resolved
+      background: #abd
+    td.hold
+      background: #dda
+    td.invalid
+      background: #aaa  
+      
+.submit
+  font-size: large
+  font-weight: bold
+
+.page_title
+  font-size: xx-large
+
+.edit_link
+  color: black
+  font-size: 14px
+  font-weight: bold
+  background-color: #e0e0e0
+  font-variant: small-caps
+  text-decoration: none
+

data/lib/ticgit.rb

@@ -0,0 +1,28 @@
+# Add the directory containing this file to the start of the load path if it
+# isn't there already.
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'rubygems'
+# requires git >= 1.0.5
+require 'git'
+require 'ticgit/base'
+require 'ticgit/ticket'
+require 'ticgit/comment'
+
+require 'ticgit/cli'
+
+# TicGit Library
+#
+# This library implements a git based ticketing system in a git repo
+#
+# Author::    Scott Chacon (mailto:schacon@gmail.com)
+# License::   MIT License
+#
+module TicGit  
+  # options
+  #   :logger => Logger.new(STDOUT)
+  def self.open(git_dir, options = {})
+    Base.new(git_dir, options)
+  end
+end

data/lib/ticgit/base.rb

@@ -0,0 +1,301 @@
+require 'logger'
+require 'fileutils'
+require 'yaml'
+
+module TicGit
+  class NoRepoFound < StandardError;end
+  class Base
+
+    attr_reader :git, :logger
+    attr_reader :tic_working, :tic_index
+    attr_reader :tickets, :last_tickets, :current_ticket  # saved in state
+    attr_reader :config
+    attr_reader :state, :config_file
+    
+    def initialize(git_dir, opts = {})
+      @git = Git.open(find_repo(git_dir))
+      @logger = opts[:logger] || Logger.new(STDOUT)
+      
+      proj = Ticket.clean_string(@git.dir.path)
+      
+      @tic_dir = opts[:tic_dir] || '~/.ticgit'
+      @tic_working = opts[:working_directory] || File.expand_path(File.join(@tic_dir, proj, 'working'))
+      @tic_index = opts[:index_file] || File.expand_path(File.join(@tic_dir, proj, 'index'))
+
+      # load config file
+      @config_file = File.expand_path(File.join(@tic_dir, proj, 'config.yml'))
+      if File.exists?(config_file)
+        @config = YAML.load(File.read(config_file))
+      else
+        @config = {}
+      end
+      
+      @state = File.expand_path(File.join(@tic_dir, proj, 'state'))
+      
+      if File.exists?(@state)
+        load_state
+      else
+        reset_ticgit
+      end
+    end
+    
+    def find_repo(dir)
+      full = File.expand_path(dir)
+      ENV["GIT_WORKING_DIR"] || loop do
+        return full if File.directory?(File.join(full, ".git"))
+        raise NoRepoFound if full == full=File.dirname(full)
+      end
+    end
+    
+    def save_state
+      # marshal dump the internals
+      File.open(@state, 'w') { |f| Marshal.dump([@tickets, @last_tickets, @current_ticket], f) } rescue nil
+      # save config file
+      File.open(@config_file, 'w') { |f| f.write(config.to_yaml) }
+    end
+    
+    def load_state
+      # read in the internals
+      if(File.exists?(@state))
+        @tickets, @last_tickets, @current_ticket = File.open(@state) { |f| Marshal.load(f) } rescue nil
+      end      
+    end
+    
+    # returns new Ticket
+    def ticket_new(title, options = {})
+      t = TicGit::Ticket.create(self, title, options)
+      reset_ticgit
+      TicGit::Ticket.open(self, t.ticket_name, @tickets[t.ticket_name])
+    end
+
+    def reset_ticgit
+      load_tickets
+      save_state
+    end
+    
+    # returns new Ticket
+    def ticket_comment(comment, ticket_id = nil)
+      if t = ticket_revparse(ticket_id)        
+        ticket = TicGit::Ticket.open(self, t, @tickets[t])
+        ticket.add_comment(comment)
+        reset_ticgit
+      end
+    end
+    
+    # returns array of Tickets 
+    def ticket_list(options = {})
+      ts = []
+      @last_tickets = []
+      @config['list_options'] ||= {}
+      
+      @tickets.to_a.each do |name, t|
+        ts << TicGit::Ticket.open(self, name, t)
+      end
+
+      if name = options[:saved]
+         if c = config['list_options'][name]
+           options = c.merge(options)
+         end
+      end   
+      
+      if options[:list]
+        # TODO : this is a hack and i need to fix it
+        config['list_options'].each do |name, opts|
+          puts name + "\t" + opts.inspect
+        end
+        return false
+      end   
+
+      # SORTING
+      if field = options[:order]
+        field, type = field.split('.')
+        case field
+        when 'assigned'
+          ts = ts.sort { |a, b| a.assigned <=> b.assigned }
+        when 'state'
+          ts = ts.sort { |a, b| a.state <=> b.state }
+        when 'date'
+          ts = ts.sort { |a, b| a.opened <=> b.opened }
+        end    
+        ts = ts.reverse if type == 'desc'
+      else
+        # default list
+        ts = ts.sort { |a, b| a.opened <=> b.opened }
+      end
+
+      if options.size == 0
+        # default list
+        options[:state] = 'open'
+      end
+      
+      # :tag, :state, :assigned
+      if t = options[:tag]
+        ts = ts.select { |tag| tag.tags.include?(t) }
+      end
+      if s = options[:state]
+        ts = ts.select { |tag| tag.state =~ /#{s}/ }
+      end
+      if a = options[:assigned]
+        ts = ts.select { |tag| tag.assigned =~ /#{a}/ }
+      end
+      
+      if save = options[:save]
+        options.delete(:save)
+        @config['list_options'][save] = options
+      end
+      
+      @last_tickets = ts.map { |t| t.ticket_name }
+      # :save
+
+      save_state
+      ts
+    end
+    
+    # returns single Ticket
+    def ticket_show(ticket_id = nil)      
+      # ticket_id can be index of last_tickets, partial sha or nil => last ticket
+      if t = ticket_revparse(ticket_id)
+        return TicGit::Ticket.open(self, t, @tickets[t])
+      end
+    end
+    
+    # returns recent ticgit activity
+    # uses the git logs for this
+    def ticket_recent(ticket_id = nil)      
+      if ticket_id
+        t = ticket_revparse(ticket_id) 
+        return git.log.object('ticgit').path(t)
+      else 
+        return git.log.object('ticgit')
+      end
+    end
+    
+    def ticket_revparse(ticket_id)
+      if ticket_id
+        if /^[0-9]*$/ =~ ticket_id
+          if t = @last_tickets[ticket_id.to_i - 1]
+            return t
+          end
+        else
+          # partial or full sha
+          if ch = @tickets.select { |name, t| t['files'].assoc('TICKET_ID')[1] =~ /^#{ticket_id}/ }
+            return ch.first[0]
+          end
+        end
+      elsif(@current_ticket)
+        return @current_ticket
+      end
+    end    
+
+    def ticket_tag(tag, ticket_id = nil, options = {})
+      if t = ticket_revparse(ticket_id)    
+        ticket = TicGit::Ticket.open(self, t, @tickets[t])
+        if options[:remove]
+          ticket.remove_tag(tag)
+        else
+          ticket.add_tag(tag)
+        end
+        reset_ticgit
+      end
+    end
+        
+    def ticket_change(new_state, ticket_id = nil)
+      if t = ticket_revparse(ticket_id)
+        if tic_states.include?(new_state)
+          ticket = TicGit::Ticket.open(self, t, @tickets[t])
+          ticket.change_state(new_state)
+          reset_ticgit
+        end
+      end
+    end
+
+    def ticket_assign(new_assigned = nil, ticket_id = nil)
+      if t = ticket_revparse(ticket_id)
+        ticket = TicGit::Ticket.open(self, t, @tickets[t])
+        ticket.change_assigned(new_assigned)
+        reset_ticgit
+      end
+    end
+    
+    def ticket_checkout(ticket_id)
+      if t = ticket_revparse(ticket_id)
+        ticket = TicGit::Ticket.open(self, t, @tickets[t])
+        @current_ticket = ticket.ticket_name
+        save_state
+      end
+    end
+    
+    def comment_add(ticket_id, comment, options = {})
+    end
+
+    def comment_list(ticket_id)
+    end
+        
+    def tic_states
+      ['open', 'resolved', 'invalid', 'hold']
+    end
+        
+    def load_tickets
+      @tickets = {}
+
+      bs = git.lib.branches_all.map { |b| b[0] }
+      init_ticgit_branch(bs.include?('ticgit')) if !(bs.include?('ticgit') && File.directory?(@tic_working))
+      
+      tree = git.lib.full_tree('ticgit')
+      tree.each do |t|
+        data, file = t.split("\t")
+        mode, type, sha = data.split(" ")
+        tic = file.split('/')
+        if tic.size == 2  # directory depth
+          ticket, info = tic
+          @tickets[ticket] ||= { 'files' => [] }
+          @tickets[ticket]['files'] << [info, sha]
+        end
+      end
+    end
+    
+    def init_ticgit_branch(ticgit_branch = false)
+      @logger.info 'creating ticgit repo branch'
+      
+      in_branch(ticgit_branch) do          
+        new_file('.hold', 'hold')
+        if !ticgit_branch
+          git.add
+          git.commit('creating the ticgit branch')
+        end
+      end
+    end
+    
+    # temporarlily switches to ticgit branch for tic work
+    def in_branch(branch_exists = true)
+      needs_checkout = false
+      if !File.directory?(@tic_working)
+        FileUtils.mkdir_p(@tic_working)
+        needs_checkout = true
+      end
+      if !File.exists?('.hold')
+        needs_checkout = true
+      end
+      
+      old_current = git.lib.branch_current
+      begin
+        git.lib.change_head_branch('ticgit')
+        git.with_index(@tic_index) do          
+          git.with_working(@tic_working) do |wd|
+            git.lib.checkout('ticgit') if needs_checkout && branch_exists
+            yield wd
+          end
+        end
+      ensure
+        git.lib.change_head_branch(old_current)
+      end
+    end
+          
+    def new_file(name, contents)
+      File.open(name, 'w') do |f|
+        f.puts contents
+      end
+    end
+   
+  end
+end

data/lib/ticgit/cli.rb

@@ -0,0 +1,396 @@
+require 'ticgit'
+require 'optparse'
+
+# used Cap as a model for this - thanks Jamis
+
+module TicGit
+  class CLI
+    # The array of (unparsed) command-line options
+    attr_reader :action, :options, :args, :tic
+
+    def self.execute
+      parse(ARGV).execute!
+    end
+    
+    def self.parse(args)
+      cli = new(args)
+      cli.parse_options!
+      cli
+    end
+
+    def initialize(args)
+      @args = args.dup
+      @tic = TicGit.open('.', :keep_state => true)
+      $stdout.sync = true # so that Net::SSH prompts show up
+    rescue NoRepoFound
+      puts "No repo found"
+      exit
+    end    
+    
+    def execute!
+      case action
+      when 'list':
+        handle_ticket_list
+      when 'state'
+        handle_ticket_state
+      when 'assign'
+        handle_ticket_assign
+      when 'show'
+        handle_ticket_show
+      when 'new'
+        handle_ticket_new
+      when 'checkout', 'co'
+        handle_ticket_checkout
+      when 'comment'
+        handle_ticket_comment
+      when 'tag'
+        handle_ticket_tag
+      when 'recent'
+        handle_ticket_recent
+      when 'milestone'
+        handle_ticket_milestone
+      else
+        puts 'not a command'
+      end
+    end
+
+    # tic milestone
+    # tic milestone migration1 (list tickets)
+    # tic milestone -n migration1 3/4/08 (new milestone)
+    # tic milestone -a {1} (add ticket to milestone)
+    # tic milestone -d migration1 (delete)
+    def parse_ticket_milestone
+      @options = {}
+      OptionParser.new do |opts|
+        opts.banner = "Usage: ti milestone [milestone_name] [options] [date]"
+        opts.on("-n MILESTONE", "--new MILESTONE", "Add a new milestone to this project") do |v|
+          @options[:new] = v
+        end
+        opts.on("-a TICKET", "--new TICKET", "Add a ticket to this milestone") do |v|
+          @options[:add] = v
+        end
+        opts.on("-d MILESTONE", "--delete MILESTONE", "Remove a milestone") do |v|
+          @options[:remove] = v
+        end
+      end.parse!
+    end
+
+    def handle_ticket_recent
+      tic.ticket_recent(ARGV[1]).each do |commit|
+        puts commit.sha[0, 7] + "  " + commit.date.strftime("%m/%d %H:%M") + "\t" + commit.message
+      end
+    end
+    
+    def parse_ticket_tag
+      @options = {}
+      OptionParser.new do |opts|
+        opts.banner = "Usage: ti tag [tic_id] [options] [tag_name] "
+        opts.on("-d", "Remove this tag from the ticket") do |v|
+          @options[:remove] = v
+        end
+      end.parse!
+    end
+    
+    def handle_ticket_tag
+      parse_ticket_tag
+      
+      if options[:remove]
+        puts 'remove'
+      end
+      
+      tid = nil
+      if ARGV.size > 2
+        tid = ARGV[1].chomp
+        tic.ticket_tag(ARGV[2].chomp, tid, options)
+      elsif ARGV.size > 1
+        tic.ticket_tag(ARGV[1], nil, options)
+      else  
+        puts 'You need to at least specify one tag to add'
+      end
+    end
+    
+    def parse_ticket_comment
+      @options = {}
+      OptionParser.new do |opts|
+        opts.banner = "Usage: ti comment [tic_id] [options]"
+        opts.on("-m MESSAGE", "--message MESSAGE", "Message you would like to add as a comment") do |v|
+          @options[:message] = v
+        end
+        opts.on("-f FILE", "--file FILE", "A file that contains the comment you would like to add") do |v|
+          raise ArgumentError, "Only 1 of -f/--file and -m/--message can be specified" if @options[:message]
+          raise ArgumentError, "File #{v} doesn't exist" unless File.file?(v) 
+          raise ArgumentError, "File #{v} must be <= 2048 bytes" unless File.size(v) <= 2048
+          @options[:file] = v
+        end
+      end.parse!
+    end
+
+    def handle_ticket_comment
+      parse_ticket_comment
+      
+      tid = nil
+      tid = ARGV[1].chomp if ARGV[1]
+      
+      if(m = options[:message])
+        tic.ticket_comment(m, tid)
+      elsif(f = options[:file])
+        tic.ticket_comment(File.read(options[:file]), tid)
+      else
+        if message = get_editor_message
+          tic.ticket_comment(message.join(''), tid)
+        end
+      end
+    end
+
+    
+    def handle_ticket_checkout
+      tid = ARGV[1].chomp
+      tic.ticket_checkout(tid)
+    end
+    
+    def handle_ticket_state
+      if ARGV.size > 2
+        tid = ARGV[1].chomp
+        new_state = ARGV[2].chomp
+        if valid_state(new_state)
+          tic.ticket_change(new_state, tid)
+        else
+          puts 'Invalid State - please choose from : ' + tic.tic_states.join(", ")
+        end
+      elsif ARGV.size > 1
+        # new state
+        new_state = ARGV[1].chomp
+        if valid_state(new_state)
+          tic.ticket_change(new_state)
+        else
+          puts 'Invalid State - please choose from : ' + tic.tic_states.join(", ")
+        end
+      else  
+        puts 'You need to at least specify a new state for the current ticket'
+      end
+    end
+    
+    def valid_state(state)
+      tic.tic_states.include?(state)
+    end
+    
+    def parse_ticket_assign
+      @options = {}
+      OptionParser.new do |opts|
+        opts.banner = "Usage: ti assign [options] [ticket_id]"
+        opts.on("-u USER", "--user USER", "Assign the ticket to this user") do |v|
+          @options[:user] = v
+        end
+        opts.on("-c TICKET", "--checkout TICKET", "Checkout this ticket") do |v|
+          @options[:checkout] = v
+        end
+      end.parse!
+    end
+
+    # Assigns a ticket to someone
+    #
+    # Usage:
+    # ti assign             (assign checked out ticket to current user)
+    # ti assign {1}         (assign ticket to current user)
+    # ti assign -c {1}      (assign ticket to current user and checkout the ticket)
+    # ti assign -u {name}   (assign ticket to specified user)
+    def handle_ticket_assign
+      parse_ticket_assign
+
+      tic.ticket_checkout(options[:checkout]) if options[:checkout]
+
+      tic_id = ARGV.size > 1 ? ARGV[1].chomp : nil
+      tic.ticket_assign(options[:user], tic_id)
+    end
+
+    ## LIST TICKETS ##
+    def parse_ticket_list
+      @options = {}
+      OptionParser.new do |opts|
+        opts.banner = "Usage: ti list [options]"
+        opts.on("-o ORDER", "--order ORDER", "Field to order by - one of : assigned,state,date") do |v|
+          @options[:order] = v
+        end
+        opts.on("-t TAG", "--tag TAG", "List only tickets with specific tag") do |v|
+          @options[:tag] = v
+        end
+        opts.on("-s STATE", "--state STATE", "List only tickets in a specific state") do |v|
+          @options[:state] = v
+        end
+        opts.on("-a ASSIGNED", "--assigned ASSIGNED", "List only tickets assigned to someone") do |v|
+          @options[:assigned] = v
+        end
+        opts.on("-S SAVENAME", "--saveas SAVENAME", "Save this list as a saved name") do |v|
+          @options[:save] = v
+        end
+        opts.on("-l", "--list", "Show the saved queries") do |v|
+          @options[:list] = true
+        end
+      end.parse!
+    end
+    
+    def handle_ticket_list
+      parse_ticket_list
+      
+      options[:saved] = ARGV[1] if ARGV[1]
+      
+      if tickets = tic.ticket_list(options)
+        counter = 0
+      
+        puts
+        puts [' ', just('#', 4, 'r'), 
+              just('TicId', 6),
+              just('Title', 25), 
+              just('State', 5),
+              just('Date', 5),
+              just('Assgn', 8),
+              just('Tags', 20) ].join(" ")
+            
+        a = []
+        80.times { a << '-'}
+        puts a.join('')
+
+        tickets.each do |t|
+          counter += 1
+          tic.current_ticket == t.ticket_name ? add = '*' : add = ' '
+          puts [add, just(counter, 4, 'r'), 
+                t.ticket_id[0,6], 
+                just(t.title, 25), 
+                just(t.state, 5),
+                t.opened.strftime("%m/%d"), 
+                just(t.assigned_name, 8),
+                just(t.tags.join(','), 20) ].join(" ")
+        end
+        puts
+      end
+      
+    end
+    
+    ## SHOW TICKETS ##
+    
+    def handle_ticket_show
+      if t = @tic.ticket_show(ARGV[1])
+        ticket_show(t)
+      end
+    end
+    
+    def ticket_show(t)
+      days_ago = ((Time.now - t.opened) / (60 * 60 * 24)).round.to_s
+      puts
+      puts just('Title', 10) + ': ' + t.title
+      puts just('TicId', 10) + ': ' + t.ticket_id
+      puts
+      puts just('Assigned', 10) + ': ' + t.assigned.to_s 
+      puts just('Opened', 10) + ': ' + t.opened.to_s + ' (' + days_ago + ' days)'
+      puts just('State', 10) + ': ' + t.state.upcase
+      if !t.tags.empty?
+        puts just('Tags', 10) + ': ' + t.tags.join(', ')
+      end
+      puts
+      if !t.comments.empty?
+        puts 'Comments (' + t.comments.size.to_s + '):'
+        t.comments.reverse.each do |c|
+          puts '  * Added ' + c.added.strftime("%m/%d %H:%M") + ' by ' + c.user
+          
+          wrapped = c.comment.split("\n").collect do |line|
+            line.length > 80 ? line.gsub(/(.{1,80})(\s+|$)/, "\\1\n").strip : line
+          end * "\n"
+          
+          wrapped = wrapped.split("\n").map { |line| "\t" + line }
+          if wrapped.size > 6
+            puts wrapped[0, 6].join("\n")
+            puts "\t** more... **"
+          else
+            puts wrapped.join("\n")
+          end
+          puts
+        end
+      end
+    end
+    
+    ## NEW TICKETS ##
+    
+    def parse_ticket_new
+      @options = {}
+      OptionParser.new do |opts|
+        opts.banner = "Usage: ti new [options]"
+        opts.on("-t TITLE", "--title TITLE", "Title to use for the name of the new ticket") do |v|
+          @options[:title] = v
+        end
+      end.parse!
+    end
+    
+    def handle_ticket_new
+      parse_ticket_new
+      if(t = options[:title])
+        ticket_show(@tic.ticket_new(t, options))
+      else
+        # interactive
+        message_file = Tempfile.new('ticgit_message').path
+        File.open(message_file, 'w') do |f|
+          f.puts "\n# ---"
+          f.puts "tags:"
+          f.puts "# first line will be the title of the tic, the rest will be the first comment"
+          f.puts "# if you would like to add initial tags, put them on the 'tags:' line, comma delim"
+        end
+        if message = get_editor_message(message_file)
+          title = message.shift
+          if title && title.chomp.length > 0
+            title = title.chomp
+            if message.last[0, 5] == 'tags:'
+              tags = message.pop
+              tags = tags.gsub('tags:', '')
+              tags = tags.split(',').map { |t| t.strip }
+            end
+            if message.size > 0
+              comment = message.join("")
+            end
+            ticket_show(@tic.ticket_new(title, :comment => comment, :tags => tags))
+          else
+            puts "You need to at least enter a title"
+          end
+        else
+          puts "It seems you wrote nothing"
+        end
+      end
+    end
+    
+    def get_editor_message(message_file = nil)
+      message_file = Tempfile.new('ticgit_message').path if !message_file
+      
+      editor = ENV["EDITOR"] || 'vim'
+      system("#{editor} #{message_file}");
+      message = File.readlines(message_file)
+      message = message.select { |line| line[0, 1] != '#' } # removing comments   
+      if message.empty?
+        return false
+      else
+        return message
+      end   
+    end
+    
+    def parse_options! #:nodoc:      
+      if args.empty?
+        warn "Please specify at least one action to execute."
+        puts " list state show new checkout comment tag assign "
+        exit
+      end
+
+      @action = args.first
+    end
+    
+    
+    def just(value, size, side = 'l')
+      value = value.to_s
+      if value.size > size
+        value = value[0, size]
+      end
+      if side == 'r'
+        return value.rjust(size)
+      else
+        return value.ljust(size)
+      end
+    end
+    
+  end
+end

data/lib/ticgit/comment.rb

@@ -0,0 +1,17 @@
+module TicGit
+  class Comment
+    
+    attr_reader :base, :user, :added, :comment
+    
+    def initialize(base, file_name, sha)
+      @base = base
+      @comment = base.git.gblob(sha).contents rescue nil
+      
+      type, date, user = file_name.split('_')
+      
+      @added = Time.at(date.to_i)
+      @user = user
+    end
+    
+  end
+end

data/lib/ticgit/ticket.rb

@@ -0,0 +1,214 @@
+module TicGit
+  class Ticket
+  
+    attr_reader :base, :opts
+    attr_accessor :ticket_id, :ticket_name
+    attr_accessor :title, :state, :milestone, :assigned, :opened
+    attr_accessor :comments, :tags, :attachments # arrays
+    
+    def initialize(base, options = {})
+      options[:user_name] ||= base.git.config('user.name') 
+      options[:user_email] ||= base.git.config('user.email')      
+      
+      @base = base
+      @opts = options || {}
+      
+      @state = 'open' # by default
+      @comments = []
+      @tags = []
+      @attachments = []
+    end
+  
+    def self.create(base, title, options = {})
+      t = Ticket.new(base, options)
+      t.title = title
+      t.ticket_name = self.create_ticket_name(title)
+      t.save_new
+      t
+    end
+    
+    def self.open(base, ticket_name, ticket_hash, options = {})
+      tid = nil
+
+      t = Ticket.new(base, options)
+      t.ticket_name = ticket_name
+      
+      title, date = self.parse_ticket_name(ticket_name)
+      
+      t.title = title
+      t.opened = date
+      
+      ticket_hash['files'].each do |fname, value|
+        if fname == 'TICKET_ID'
+          tid = value
+        else
+          # matching
+          data = fname.split('_')
+          if data[0] == 'ASSIGNED'
+            t.assigned = data[1]
+          end
+          if data[0] == 'COMMENT'
+            t.comments << TicGit::Comment.new(base, fname, value)
+          end
+          if data[0] == 'TAG'
+            t.tags << data[1]
+          end
+          if data[0] == 'STATE'
+            t.state = data[1]
+          end          
+        end
+      end
+      
+      t.ticket_id = tid
+      t
+    end
+    
+    
+    def self.parse_ticket_name(name)
+      epoch, title, rand = name.split('_')
+      title = title.gsub('-', ' ')
+      return [title, Time.at(epoch.to_i)]
+    end
+    
+    # write this ticket to the git database
+    def save_new
+      base.in_branch do |wd|
+        base.logger.info "saving #{ticket_name}"
+        
+        Dir.mkdir(ticket_name)
+        Dir.chdir(ticket_name) do
+          base.new_file('TICKET_ID', ticket_name)
+          base.new_file('ASSIGNED_' + email, email)
+          base.new_file('STATE_' + state, state)
+
+          # add initial comment
+          #COMMENT_080315060503045__schacon_at_gmail
+          base.new_file(comment_name(email), opts[:comment]) if opts[:comment]
+
+          # add initial tags
+          if opts[:tags] && opts[:tags].size > 0
+            opts[:tags] = opts[:tags].map { |t| t.strip }.compact
+            opts[:tags].each do |tag|
+              if tag.size > 0
+                tag_filename = 'TAG_' + Ticket.clean_string(tag)
+                if !File.exists?(tag_filename)
+                  base.new_file(tag_filename, tag_filename)
+                end
+              end
+            end
+          end            
+        end
+	      
+        base.git.add
+        base.git.commit("added ticket #{ticket_name}")
+      end
+      # ticket_id
+    end
+    
+    def self.clean_string(string)
+      string.downcase.gsub(/[^a-z0-9]+/i, '-')
+    end
+    
+    def add_comment(comment)
+      return false if !comment
+      base.in_branch do |wd|
+        Dir.chdir(ticket_name) do
+          base.new_file(comment_name(email), comment) 
+        end
+        base.git.add
+        base.git.commit("added comment to ticket #{ticket_name}")
+      end
+    end
+
+    def change_state(new_state)
+      return false if !new_state
+      return false if new_state == state
+      
+      base.in_branch do |wd|
+        Dir.chdir(ticket_name) do
+          base.new_file('STATE_' + new_state, new_state)
+        end
+        base.git.remove(File.join(ticket_name,'STATE_' + state))
+        base.git.add
+        base.git.commit("added state (#{new_state}) to ticket #{ticket_name}")
+      end
+    end
+
+    def change_assigned(new_assigned)
+      new_assigned ||= email
+      return false if new_assigned == assigned
+
+      base.in_branch do |wd|
+        Dir.chdir(ticket_name) do
+          base.new_file('ASSIGNED_' + new_assigned, new_assigned)
+        end
+        base.git.remove(File.join(ticket_name,'ASSIGNED_' + assigned))
+        base.git.add
+        base.git.commit("assigned #{new_assigned} to ticket #{ticket_name}")
+      end
+    end
+    
+    def add_tag(tag)
+      return false if !tag
+      added = false
+      tags = tag.split(',').map { |t| t.strip }
+      base.in_branch do |wd|
+        Dir.chdir(ticket_name) do
+          tags.each do |add_tag|
+            if add_tag.size > 0
+              tag_filename = 'TAG_' + Ticket.clean_string(add_tag)
+              if !File.exists?(tag_filename)
+                base.new_file(tag_filename, tag_filename)
+                added = true
+              end
+            end
+          end
+        end
+        if added
+          base.git.add
+          base.git.commit("added tags (#{tag}) to ticket #{ticket_name}")
+        end
+      end
+    end
+    
+    def remove_tag(tag)
+      return false if !tag
+      removed = false
+      tags = tag.split(',').map { |t| t.strip }
+      base.in_branch do |wd|
+        tags.each do |add_tag|
+          tag_filename = File.join(ticket_name, 'TAG_' + Ticket.clean_string(add_tag))
+          if File.exists?(tag_filename)
+            base.git.remove(tag_filename)
+            removed = true
+          end
+        end
+        if removed
+          base.git.commit("removed tags (#{tag}) from ticket #{ticket_name}")
+        end
+      end
+    end
+    
+    def path
+      File.join(state, ticket_name)
+    end
+    
+    def comment_name(email)
+      'COMMENT_' + Time.now.to_i.to_s + '_' + email
+    end
+    
+    def email
+      opts[:user_email] || 'anon'
+    end
+    
+    def assigned_name
+      assigned.split('@').first rescue ''
+    end
+    
+    def self.create_ticket_name(title)
+      [Time.now.to_i.to_s, Ticket.clean_string(title), rand(999).to_i.to_s].join('_')
+    end
+
+    
+  end
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification 
+name: ticgit
+version: !ruby/object:Gem::Version 
+  version: 0.3.6
+platform: ruby
+authors: 
+- Scott Chacon
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-05-10 00:00:00 -07:00
+default_executable: ti
+dependencies: []
+
+description: 
+email: schacon@gmail.com
+executables: 
+- ti
+- ticgitweb
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/ticgit/base.rb
+- lib/ticgit/cli.rb
+- lib/ticgit/comment.rb
+- lib/ticgit/ticket.rb
+- lib/ticgit.rb
+- bin/ti
+- bin/ticgitweb
+has_rdoc: true
+homepage: http://github.com/schacon/ticgit
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+- bin
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 2
+summary: A distributed ticketing system for Git projects.
+test_files: []
+