flurin-ticgit 0.3.7

data/lib/ticgit/base.rb

@@ -0,0 +1,308 @@
+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('.')
+        field = "opened" if field == "date" || field.nil?
+        ts = sort_list_by_keys(ts,[field,:ticket_id])
+        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
+    
+    
+    def sort_list_by_keys(list,keys)
+      return list if keys.find{|k| !list.first.respond_to?(k) }
+      list.sort do |a,b|
+        value,i = 0,0
+        while (keys.size > i && value == 0) do 
+          value = a.send(keys[i]) <=> b.send(keys[i])
+          i += 1
+        end
+        value
+      end
+    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,338 @@
+require 'ticgit'
+require 'thor'
+
+module TicGit
+  class CLI < Thor
+    attr_reader :tic
+    
+    def initialize(opts = {}, *args)
+      @tic = TicGit.open('.', :keep_state => true)
+      $stdout.sync = true # so that Net::SSH prompts show up
+    rescue NoRepoFound
+      puts "No repo found"
+      exit
+    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)
+    desc "milestone [<name>]", %(Add a new milestone to this project)
+    method_options :new => :optional, :add => :optional, :delete => :optional
+    def milestone(name = nil)
+      raise NotImplementedError
+    end
+
+    desc "recent [<ticket-id>]", %(Recent ticgit activity)
+    def recent(ticket_id = nil)
+      tic.ticket_recent(ticket_id).each do |commit|
+        puts commit.sha[0, 7] + "  " + commit.date.strftime("%m/%d %H:%M") + "\t" + commit.message
+      end
+    end
+    
+    desc "tag [<ticket-id>] [<tag1,tag2...>]", %(Add or remove ticket tags)
+    method_options %w(--remove -d) => :boolean
+    def tag(*args)
+      puts 'remove' if options[:remove]
+      
+      tid = args.size > 1 && args.shift
+      tags = args.first
+      
+      if tags
+        tic.ticket_tag(tags, tid, options)
+      else  
+        puts 'You need to at least specify one tag to add'
+      end
+    end
+    
+    desc "comment [<ticket-id>]", %(Comment on a ticket)
+    method_options :message => :optional, :file => :optional
+    def comment(ticket_id = nil)
+      if options[:file]
+        raise ArgumentError, "Only 1 of -f/--file and -m/--message can be specified" if options[:message]
+        file = options[:file]
+        raise ArgumentError, "File #{file} doesn't exist" unless File.file?(file)
+        raise ArgumentError, "File #{file} must be <= 2048 bytes" unless File.size(file) <= 2048
+        tic.ticket_comment(File.read(file), ticket_id)
+      elsif m = options[:message]
+        tic.ticket_comment(m, ticket_id)
+      else
+        message, meta = get_editor_message
+        if message
+          tic.ticket_comment(message.join(''), ticket_id)
+        end
+      end
+    end
+
+    desc "checkout <ticket-id>", %(Checkout a ticket)
+    def checkout(ticket_id)
+      tic.ticket_checkout(ticket_id)
+    end
+    
+    desc "state [<ticket-id>] <state>", %(Change state of a ticket)
+    def state(id_or_state, state = nil)
+      if state.nil?
+        state = id_or_state
+        ticket_id = nil
+      else
+        ticket_id = id_or_state
+      end
+      
+      if valid_state(state)
+        tic.ticket_change(state, ticket_id)
+      else
+        puts 'Invalid State - please choose from : ' + tic.tic_states.join(", ")
+      end
+    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)
+    desc "assign [<ticket-id>]", %(Assign ticket to user)
+    method_options :user => :optional, :checkout => :optional
+    def assign(ticket_id = nil)
+      tic.ticket_checkout(options[:checkout]) if options[:checkout]
+      tic.ticket_assign(options[:user], ticket_id)
+    end
+
+    # "-o ORDER", "--order ORDER", "Field to order by - one of : assigned,state,date"
+    # "-t TAG", "--tag TAG", "List only tickets with specific tag"
+    # "-s STATE", "--state STATE", "List only tickets in a specific state"
+    # "-a ASSIGNED", "--assigned ASSIGNED", "List only tickets assigned to someone"
+    # "-S SAVENAME", "--saveas SAVENAME", "Save this list as a saved name"
+    # "-l", "--list", "Show the saved queries"
+    desc "list [<saved-query>]", %(Show existing tickets)
+    method_options :order => :optional, :tag => :optional, :state => :optional,
+                   :assigned => :optional, :list => :optional, %w(--save-as -S) => :optional
+                   
+    def list(saved_query = nil)
+      opts = options.dup
+      opts[:saved] = saved_query if saved_query
+      
+      if tickets = tic.ticket_list(opts)
+        output_ticket_list(tickets)
+      end
+    end
+    
+    ## SHOW TICKETS ##
+    
+    desc 'show <ticket-id>', %(Show a single ticket)
+    def show(ticket_id = nil)
+      if t = @tic.ticket_show(ticket_id)
+        ticket_show(t)
+      end
+    end
+    
+    desc 'new', %(Create a new ticket)
+    method_options :title => :optional
+    def new
+      if title = options[:title]
+        ticket_show(@tic.ticket_new(title, 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 "# The first line will be the title of the ticket,"
+          f.puts "# the rest will be the description. If you would like to add initial tags,"
+          f.puts "# put them on the 'tags:' line, comma delimited"
+        end
+        
+        message, meta = get_editor_message(message_file)
+        if message
+          title, description, tags = parse_editor_message(message,meta)
+          if title and !title.empty?
+            ticket_show(@tic.ticket_new(title, :description => description, :tags => tags))
+          else
+            puts "You need to at least enter a title"
+          end
+        else
+          puts "It seems you wrote nothing"
+        end
+      end
+    end
+    
+    protected
+    
+    def valid_state(state)
+      tic.tic_states.include?(state)
+    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
+      if t.description
+        desc = t.description.split("\n").map{|l| " "*12 + l.strip}.join("\n").lstrip
+        puts just('Descr.',10) + ': ' + desc
+      end
+      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 "# The first line will be the title of the ticket, "
+          f.puts "# the rest will be the description if you would like to add initial tags,"
+          f.puts "# put them on the 'tags:' line, comma delimited"
+        end
+        message,meta = get_editor_message(message_file)
+        if message
+          title,description,tags = parse_editor_message(message,meta)
+          if title != ""
+            ticket_show(@tic.ticket_new(title, :description => description, :tags => tags))
+          else
+            puts "You need to at least enter a title"
+          end
+        else
+          puts "It seems you wrote nothing"
+        end
+      end
+    end
+    
+    def parse_editor_message(message,meta)
+      message.strip!
+      puts message.inspect
+      title,description = message.split(/\r?\n/,2).map{|t| t.strip }
+      tags = []
+      # Strip comments from meta block
+      meta.gsub!(/^\s*#.*$/,"")
+      meta.split("\n").each do |line|
+        if line[0, 5] == 'tags:'
+          tags = line.gsub('tags:', '')
+          tags = tags.split(',').map { |t| t.strip }
+        end
+      end
+      [title,description,tags]
+    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.read(message_file)
+      
+      # We must have some content before the # --- line
+      message, meta  = message.split("# ---")
+      if message =~ /[^\s]+/m
+        return [message,meta]
+      else
+        return [false,false]
+      end   
+    end
+    
+    def parse_editor_message(message, meta)
+      message.strip!
+      puts message.inspect
+      title, description = message.split(/\r?\n/,2).map { |t| t.strip }
+      tags = []
+      # Strip comments from meta block
+      meta.gsub!(/^\s*#.*$/, "")
+      meta.split("\n").each do |line|
+        if line[0, 5] == 'tags:'
+          tags = line.gsub('tags:', '')
+          tags = tags.split(',').map { |t| t.strip }
+        end
+      end
+      [title, description, tags]
+    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
+    
+    def output_ticket_list(tickets)
+      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
+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