TicGit-ng 1.0.0

data/bin/ticgitweb

@@ -0,0 +1,313 @@
+#!/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)
+#
+
+# Add the library from the source tree to the front of the load path.
+# This allows ticgitweb to run without first installing a ticgit gem,
+# which is important when testing multiple branches of development.
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+%w(rubygems sinatra git ticgit haml sass).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-ng/base.rb

@@ -0,0 +1,365 @@
+module TicGitNG
+  class NoRepoFound < StandardError;end
+  class Base
+
+    attr_reader :git, :logger
+    attr_reader :tic_working, :tic_index
+    attr_reader :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)
+      @last_tickets = []
+
+      proj = Ticket.clean_string(@git.dir.path)
+
+      @tic_dir = opts[:tic_dir] || '~/.ticgit-ng'
+      @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.file?(@state)
+        load_state
+      else
+        reset_ticgitng
+      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
+
+    # marshal dump the internals
+    # save config file
+    def save_state
+      state_list = [@last_tickets, @current_ticket]
+      File.open(@state, 'w+'){|io| Marshal.dump(state_list, io) }
+      File.open(@config_file, 'w+'){|io| io.write(config.to_yaml) }
+    end
+
+    # read in the internals
+    def load_state
+      state_list = File.open(@state){|io| Marshal.load(io) }
+      garbage_data=nil
+      if state_list.length == 2
+        @last_tickets, @current_ticket = state_list
+      else
+        #This was left behind so that people can continue load_state-ing
+        #without having to delete their ~/.ticgit directory when
+        #updating to this version (rename to ticgit-ng)
+        garbage_data, @last_tickets, @current_ticket = state_list
+      end
+    end
+
+    # returns new Ticket
+    def ticket_new(title, options = {})
+      t = TicGitNG::Ticket.create(self, title, options)
+      reset_ticgitng
+      TicGitNG::Ticket.open(self, t.ticket_name, tickets[t.ticket_name])
+    end
+
+    #This is a legacy function from back when ticgit-ng needed to have its
+    #cache reset in order to avoid cache corruption.
+    def reset_ticgitng
+      tickets
+      save_state
+    end
+
+    # returns new Ticket
+    def ticket_comment(comment, ticket_id = nil)
+      if t = ticket_revparse(ticket_id)
+        ticket = TicGitNG::Ticket.open(self, t, tickets[t])
+        ticket.add_comment(comment)
+        reset_ticgitng
+      end
+    end
+
+    # returns array of Tickets
+    def ticket_list(options = {})
+      reset_ticgitng
+      ts = []
+      @last_tickets = []
+      @config['list_options'] ||= {}
+
+      tickets.to_a.each do |name, t|
+        ts << TicGitNG::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
+
+      if options.size == 0
+        # default list
+        options[:state] = 'open'
+      end
+
+      # :tag, :state, :assigned
+      if t = options[:tags]
+        t = {false => Set.new, true => Set.new}.merge t.classify { |x| x[0,1] != "-" }
+        t[false].map! { |x| x[1..-1] }
+        ts = ts.reject { |tic| t[true].intersection(tic.tags).empty? } unless t[true].empty?
+        ts = ts.select { |tic| t[false].intersection(tic.tags).empty? } unless t[false].empty?
+      end
+      if s = options[:states]
+        s = {false => Set.new, true => Set.new}.merge s.classify { |x| x[0,1] != "-" }
+        s[true].map! { |x| Regexp.new(x, Regexp::IGNORECASE) }
+        s[false].map! { |x| Regexp.new(x[1..-1], Regexp::IGNORECASE) }
+        ts = ts.select { |tic| s[true].any? { |st| tic.state =~ st } } unless s[true].empty?
+        ts = ts.reject { |tic| s[false].any? { |st| tic.state =~ st } } unless s[false].empty?
+      end
+      if a = options[:assigned]
+        ts = ts.select { |tic| tic.assigned =~ Regexp.new(a, Regexp::IGNORECASE) }
+      end
+
+      # SORTING
+      if field = options[:order]
+        field, type = field.split('.')
+
+        case field
+        when 'assigned'; ts = ts.sort_by{|a| a.assigned }
+        when 'state';    ts = ts.sort_by{|a| a.state }
+        when 'date';     ts = ts.sort_by{|a| a.opened }
+        when 'title';    ts = ts.sort_by{|a| a.title }
+        end
+
+        ts = ts.reverse if type == 'desc'
+      else
+        # default list
+        ts = ts.sort_by{|a| a.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
+      reset_ticgitng
+      if t = ticket_revparse(ticket_id)
+        return TicGitNG::Ticket.open(self, t, tickets[t])
+      end
+    end
+
+    # returns recent ticgit-ng 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-ng').path(t)
+      else
+        return git.log.object('ticgit-ng')
+      end
+    end
+
+    def ticket_revparse(ticket_id)
+      if ticket_id
+        ticket_id = ticket_id.strip
+        
+        if /^[0-9]*$/ =~ ticket_id
+          if t = @last_tickets[ticket_id.to_i - 1]
+            return t
+          end
+        else # partial or full sha
+          regex = /^#{Regexp.escape(ticket_id)}/
+          ch = tickets.select{|name, t|
+            t['files'].assoc('TICKET_ID')[1] =~ regex }
+          ch.first[0] if ch.first
+        end
+      elsif(@current_ticket)
+        return @current_ticket
+      end
+    end
+
+    def ticket_tag(tag, ticket_id = nil, options = OpenStruct.new)
+      if t = ticket_revparse(ticket_id)
+        ticket = TicGitNG::Ticket.open(self, t, tickets[t])
+        if options.remove
+          ticket.remove_tag(tag)
+        else
+          ticket.add_tag(tag)
+        end
+        reset_ticgitng
+      end
+    end
+
+    def ticket_change(new_state, ticket_id = nil)
+      if t = ticket_revparse(ticket_id)
+        if tic_states.include?(new_state)
+          ticket = TicGitNG::Ticket.open(self, t, tickets[t])
+          ticket.change_state(new_state)
+          reset_ticgitng
+        end
+      end
+    end
+
+    def ticket_assign(new_assigned = nil, ticket_id = nil)
+      if t = ticket_revparse(ticket_id)
+        ticket = TicGitNG::Ticket.open(self, t, tickets[t])
+        ticket.change_assigned(new_assigned)
+        reset_ticgitng
+      end
+    end
+
+    def ticket_points(new_points = nil, ticket_id = nil)
+      if t = ticket_revparse(ticket_id)
+        ticket = TicGitNG::Ticket.open(self, t, tickets[t])
+        ticket.change_points(new_points)
+        reset_ticgitng
+      end
+    end
+
+    def ticket_checkout(ticket_id)
+      if t = ticket_revparse(ticket_id)
+        ticket = TicGitNG::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 sync_tickets(repo='origin', push=true, verbose=true )
+      in_branch(false) do 
+         repo_g=git.remote(repo)
+         git.pull(repo_g, repo+'/ticgit-ng')
+         git.push(repo_g, 'ticgit-ng:ticgit-ng') if push
+         puts "Tickets synchronized." if verbose
+      end
+    end
+
+    def tickets
+      read_tickets
+    end
+
+    def read_tickets
+      tickets = {}
+
+      bs = git.lib.branches_all.map{|b| b.first }
+
+      unless bs.include?('ticgit-ng') && File.directory?(@tic_working)
+        init_ticgitng_branch(bs.include?('ticgit-ng'))
+      end
+
+      tree = git.lib.full_tree('ticgit-ng')
+      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
+      tickets
+    end
+
+    def init_ticgitng_branch(ticgitng_branch = false)
+      @logger.info 'creating ticgit-ng repo branch'
+
+      in_branch(ticgitng_branch) do
+        #The .hold file seems to have little to no purpose aside from helping
+        #figure out if the branch should be checked out or not.  It is created
+        #when the ticgit branch is created, and seems to exist for the lifetime
+        #of the ticgit branch. The purpose seems to be, to be able to tell if
+        #the ticgit branch is already checked out and not check it out again if
+        #it is.  This might be superfluous after switching to grit.
+        new_file('.hold', 'hold')
+
+        unless ticgitng_branch
+          git.add
+          git.commit('creating the ticgit-ng branch')
+        end
+      end
+    end
+
+    # temporarlily switches to ticgit branch for tic work
+    def in_branch(branch_exists = true)
+      needs_checkout = false
+
+      unless File.directory?(@tic_working)
+        FileUtils.mkdir_p(@tic_working)
+        needs_checkout = true
+      end
+
+      needs_checkout = true unless File.file?('.hold')
+
+      old_current = git.lib.branch_current
+      begin
+        git.lib.change_head_branch('ticgit-ng')
+        git.with_index(@tic_index) do
+          git.with_working(@tic_working) do |wd|
+            git.lib.checkout('ticgit-ng') 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+'){|f| f.puts(contents) }
+    end
+
+  end
+end