ruby-issues 0.1.0 → 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f6deed01a2a59cd3b896a927a85b51eae83ca73c
+  data.tar.gz: 1812367238a2c59990e949bbe4070ec5c217847b
+SHA512:
+  metadata.gz: 9b26f17dbae9bfa96b8316fba969aa06366455678addce3bd383e23f6bc18862639ff031d8041b2a69ceae0a6816cdf2a5bfac775817731ba76f19a8b6ba945b
+  data.tar.gz: cad3041f6a80b68ecf71e0f8d4048ce552cbc57b34cea295191dd7a0cdfa921e60a813c45e8a4a9ff79f084233a152a0c6a3dfb042a96ebfa2d48bfcc5a3f2e9

data/bin/issues

@@ -1,30 +1,56 @@
 #!/usr/bin/env ruby
 # encoding: utf-8 
-#======================================================================================================================#
-
+#===========================================================================================
 require 'rubygems'
 require 'fattr'
 require 'io/console'
-require 'SecureRandom'
+require 'securerandom'
 require 'PrettyComment'
 require 'trollop'
-require 'tempfile'
 require 'yaml'
+require 'git'
 
 #YAML::ENGINE.yamler = 'psych'
 
-#======================================================================================================================#
+#===========================================================================================
 
+def git_get_current_branch()
+  current_branch = `git branch`.split(/\n/).find{ |l| l.start_with?("*") }
+  
+  if current_branch
+    current_branch =~ /\*\s+(.+)/
+    $~[1]
+  end 
+end
 
+#-------------------------------------------------------------------------------------------
+
+def is_issue_branch()
+  (git_get_current_branch() =~ /(feature|improvement|bug|task)\/[a-f0-9]{6}/) != nil
+end
 
-#======================================================================================================================#
+#-------------------------------------------------------------------------------------------
+
+def max(a,b)
+  a > b ? a : b
+end
+
+#-------------------------------------------------------------------------------------------
+
+def edit_string(aString)
+  tempfile_name = "/tmp/issues-" << SecureRandom.hex.force_encoding("UTF-8")
+  File.write(tempfile_name, aString)
+  system("$EDITOR #{tempfile_name}")
+  new_string = File.read(tempfile_name)
+  File.unlink(tempfile_name)
+  new_string
+end
+
+#===========================================================================================
 
 class LogEntry
   fattr :date, :message
   
-
-#----------------------------------------------------------------------------------------------------------------------#  
-
   def initialize(message)
     @date = Time.new
     @message = message.dup
@@ -32,21 +58,19 @@ class LogEntry
 end
 
 
-#======================================================================================================================#
+#===========================================================================================
 
 class Issue
-  fattr :id, :created, :type, :title, :description, :status
+  fattr :id, :created, :type, :title, :description, :status, :milestone, :estimate
   attr_accessor :history
   
-
-#----------------------------------------------------------------------------------------------------------------------#  
+#-------------------------------------------------------------------------------------------
 
   def initialize
     @history = []
   end
 
-
-#----------------------------------------------------------------------------------------------------------------------#  
+#-------------------------------------------------------------------------------------------
 
   def self.createNewIssue(title, type="bug")
     newIssue = Issue.new
@@ -59,100 +83,103 @@ class Issue
     newIssue
   end
 
-
-#----------------------------------------------------------------------------------------------------------------------#  
+#-------------------------------------------------------------------------------------------
 
   def copy_from(a_issue)
     self.class.fattrs.each do |a|
-      a_issue.send(a) && self.send(a, a_issue.send(a).dup)
+      value = a_issue.send(a)
+      new_value = value.is_a?(Numeric) || value == nil ? value : value.dup
+      a_issue.send(a) && self.send(a, new_value)
     end
   end  
-      
 
-#----------------------------------------------------------------------------------------------------------------------#  
+#-------------------------------------------------------------------------------------------
 
   def log(message)
     @history ||= []
     @history << LogEntry.new(message)
   end
   
-      
-
-#----------------------------------------------------------------------------------------------------------------------#  
+#-------------------------------------------------------------------------------------------
   
-  def format_verbose
-    puts PrettyComment.separator
-    puts PrettyComment.comment("#{@id[0,6]} #{@type.capitalize} (#{@status})  #{@created.to_s[0,16]}")
-    puts PrettyComment.comment("")
-    puts PrettyComment.format_line(@title, "#", false, "#")
+  def format_verbose(opts)
+    milestone = @milestone ? "#{@milestone}" : "NO MILESTONE"
+    estimate = @estimate ? "#{@estimate}h" : "NO ESTIMATE"
+    milestone_estimate = "[#{estimate}, #{milestone}]"
+    
+    result = []
+    result << PrettyComment.separator
+    result << PrettyComment.comment("#{@id[0,6]} #{@type.capitalize} (#{@status}) #{milestone_estimate} #{@created.to_s[0,16]}")
+    result << PrettyComment.comment("")
+    result << PrettyComment.format_line(@title, "#", false, "#")
     
     if @description
-      puts PrettyComment.sub_heading("Description:")
+      result << PrettyComment.sub_heading("Description:")
       @description.split("\n").each do |l|
-        puts PrettyComment.format_line(@description, "#", false, "#")
+        result << PrettyComment.format_line(l, "#", false, "#")
       end
     end
     
     if @history && @history.count > 0
-      puts PrettyComment.sub_heading("Log:")
-      @history.each { |l| puts PrettyComment.format_line("#{l.message}", "# #{l.date.to_s[0,16]}", true, "#", "#") }
+      result << PrettyComment.sub_heading("Log:")
+      @history.each { |l| result << PrettyComment.format_line("#{l.message}", "# #{l.date.to_s[0,16]}", true, "#", "#") }
     end
     
-    puts PrettyComment.separator
-    puts
-    puts
+    result << PrettyComment.separator
+    result << ""
+    result << ""
+    
+    result.join("\n")
   end
 
+#-------------------------------------------------------------------------------------------
 
-#----------------------------------------------------------------------------------------------------------------------#
+  def format_list(opts)
+    entry = @title.dup
+    info_string = "#{short_id} (#{@type[0,1].capitalize})"
 
-  def format_list
-    puts PrettyComment.format_line(@title, "#{short_id} (#{@type[0,1].capitalize})", true)
-  end
+    if opts[:list_milestone] == true
+      width = opts[:milestone_column_width]
+      info_string << " " << (@milestone ? @milestone.ljust(width) : "UNASSIGNED".ljust(width))
+    end
 
+    if opts[:list_estimate] == true
+      info_string << " " << (@estimate ? sprintf("%.2fh", @estimate).rjust(4) : "     ")
+    end
 
-#----------------------------------------------------------------------------------------------------------------------#  
+    #suffix = estimate_milestone.count > 0 ? "[#{estimate_milestone.join(' => ')}]" : ""
+    
+    PrettyComment.format_line(entry, info_string, true) 
+  end
 
-  def edit_description
-    file = Tempfile.new('issues')
-    file.write(@description)
-    file.close
-    system("$EDITOR #{file.path}")
+#-------------------------------------------------------------------------------------------
 
-    file.open
-    new_description = file.read
+  def edit_description
+    new_description = edit_string(@description)
 
     if new_description != @description
       @description = new_description.dup
       return true
     end
-    
+
     return false
   end
 
-
-#----------------------------------------------------------------------------------------------------------------------#  
+#-------------------------------------------------------------------------------------------
 
   def edit_all
-    edit_file = file = Tempfile.new('issues')
-    file.write(self.to_yaml)
-    file.close
+    original_yaml = self.to_yaml
+    new_yaml = edit_string(original_yaml)
     
-    system("$EDITOR #{file.path}")
-
-    file.open
-    
-    if (file.read != self.to_yaml)
-      new_issue = YAML::load_file(file.path)
-      self.copy_from(new_issue)
+    if (new_yaml != original_yaml)
+      self.copy_from(YAML::parse(new_string))
       return true
     end 
     
     return false
   end
 
-
-#----------------------------------------------------------------------------------------------------------------------#  
+#-------------------------------------------------------------------------------------------
 
   def short_id
     @id[0,6]
@@ -160,30 +187,27 @@ class Issue
     
 end
 
-
-#======================================================================================================================#
-#                                                   Main Program Logic
-#======================================================================================================================#
+#===========================================================================================
+# Main Program Logic
+#===========================================================================================
 
 class IssuesDb
   fattr :issues_array
   
-#----------------------------------------------------------------------------------------------------------------------#
+#-------------------------------------------------------------------------------------------
 
   def initialize(database_file)
     @database_file = database_file
     @issues_array = FileTest.exists?(database_file) && YAML.load_file(database_file) || []
   end
   
-
-#----------------------------------------------------------------------------------------------------------------------#
+#-------------------------------------------------------------------------------------------
 
   def select_issues(&select_proc)
     return @issues_array.select(&select_proc)
   end
   
-
-#----------------------------------------------------------------------------------------------------------------------#
+#-------------------------------------------------------------------------------------------
 
   def select_issue(&select_proc)
     result = select_issues(&select_proc)
@@ -204,34 +228,32 @@ class IssuesDb
     nil
   end  
 
-
-#----------------------------------------------------------------------------------------------------------------------#
+#-------------------------------------------------------------------------------------------
 
   def has_issue(issue_id)
     @issues_array.any? { |issue| issue.id.start_with?(issue_id) }
   end
   
-
-#----------------------------------------------------------------------------------------------------------------------#
+#-------------------------------------------------------------------------------------------
 
   def save_db()
     FileTest.exists?('.issues') || Dir.mkdir('.issues')
     File.open(@database_file, 'w' ) { |out| YAML.dump(@issues_array, out) }
   end
   
-
-#----------------------------------------------------------------------------------------------------------------------#
+#-------------------------------------------------------------------------------------------
 
   def determine_issue_type(opts)
-    issue_types = %w{bug improvement task}
-    issue_type = nil
-    issue_types.each { |t| opts[t.to_sym] == true && issue_type = t }
+    issue_types = %w{bug improvement task feature}
+    issue_type = opts[:type] ? opts[:type].downcase : nil
     
     issue_type && (return issue_type)
 
     case opts[:title]
-    when /\b(improve|implement)/i
+    when /\b(improve)/i
       "improvement"
+    when /\b(implement)/i
+      "feature"
     when /\b(fix|bug|crash)/i
       "bug"
     else
@@ -239,47 +261,100 @@ class IssuesDb
     end
   end
 
-
-#----------------------------------------------------------------------------------------------------------------------#
+#-------------------------------------------------------------------------------------------
 
   def create_issue(opts)
     type = determine_issue_type(opts)
     new_issue = Issue.createNewIssue(opts[:title], type)
+    new_issue.milestone = opts[:milestone]
+    new_issue.estimate = opts[:estimate]
     @issues_array << new_issue
     save_db()  
     puts "Created issue #{new_issue.short_id} #{new_issue.title}"
   end
 
+#-------------------------------------------------------------------------------------------
+  
+  def select_issues_with_opts(opts)
+    did_select_issue_types = opts[:type]       
+    status_regex = opts[:all] ? /^(open|resolved|duplicate|wontfix)/ : /^open$/
+    did_select_milestone = opts[:milestone] != nil
+    milestone = opts[:milestone]
+                  
+    return @issues_array.select do |issue| 
+      (status_regex =~ issue.status) \
+        && (issue.type == opts[:type] || !did_select_issue_types) \
+        && (issue.milestone == opts[:milestone] \
+            || !did_select_milestone \
+            || milestone.end_with?(".") && issue.milestone.start_with?(milestone)\
+            || milestone.start_with?(".") && issue.milestone.end_with?(milestone)) \
+        && (issue.milestone == nil || opts["no-milestone"] == false)
+    end
+  end
+
+#-------------------------------------------------------------------------------------------
+
+  def has_open_issues_with_milestone?
+    @issues_array.any? { |issue| issue.status == "open" && issue.milestone != nil }
+  end
+
+#-------------------------------------------------------------------------------------------
+
+  def has_open_issues_with_estimate?
+    @issues_array.any? { |issue| issue.status == "open" && issue.estimate != nil }
+  end
+
+#-------------------------------------------------------------------------------------------
+
+  def milestone_column_width(array = @issues_array)
+    result = 0
+
+    array.each { |issue| issue.milestone != nil && result = max(issue.milestone.length, result) }
+
+    result
+  end
+
+#-------------------------------------------------------------------------------------------
+
+  def sort_none(a, b)
+    return 0
+  end
+#-------------------------------------------------------------------------------------------
+
+  def sort_milestone(a, b)
+    return a.milestone <=> b.milestone
+  end
 
-#----------------------------------------------------------------------------------------------------------------------#
+#-------------------------------------------------------------------------------------------
 
   def list_issues(opts)
     if opts[:issue_id]
-      list_issue(opts[:issue_id])
+      list_issue(opts)
+      sort_proc = "sort_milestone"
     else
       list_proc = opts[:verbose] ? "format_verbose" : "format_list"
-
-      issue_types = %w{bug improvement task}
-      did_select_issue_types = opts.any? { |key,value| issue_types.include?(key.to_s.chomp('s')) && value == true }
-      did_select_issue_types && issue_types.delete_if { |issue_type| opts["#{issue_type}s".to_sym] == false }
-      
-      status_regex = opts[:all] ? /^(open|resolved|duplicate|wontfix)/ : /^open$/
-            
-      issues = @issues_array.select { |issue| (status_regex =~ issue.status) && issue_types.include?(issue.type) } 
-      issues.each {|issue| issue.method(list_proc).call}
+      select_issues_with_opts(opts).\
+        sort {|a,b| sort_milestone(a,b)}.\
+        each {|issue| puts issue.method(list_proc).call(opts)}
     end
   end
 
+#-------------------------------------------------------------------------------------------
 
-#----------------------------------------------------------------------------------------------------------------------#
-
-  def list_issue(issue_id)
+  def list_issue(opts)
+    issue_id = opts[:issue_id]
     issue = select_issue {|i| i.id.start_with?(issue_id) }
-    issue.format_verbose()
+    puts issue.format_verbose(opts)
   end
 
+#-------------------------------------------------------------------------------------------
+
+  def count_issues(opts)
+    num_issues = select_issues_with_opts(opts).count
+    puts "#{num_issues} issues."
+  end
 
-#----------------------------------------------------------------------------------------------------------------------#
+#-------------------------------------------------------------------------------------------
 
   def resolve_issues(opts)
     issue_id = opts[:issue_id]
@@ -293,6 +368,8 @@ class IssuesDb
       ["resolved", "Resolved"]
     when "wontfix"
       ["wontfix", "Won't fix"]
+    when "cantreproduce"
+      ["cantreproduce", "Can't reproduce"]
     when "duplicate"
       ["duplicate(#{duplicate_of_id})", "Duplicate"]
     end
@@ -300,16 +377,25 @@ class IssuesDb
     resolved_issue.status = status
     resolved_issue.log "Changed status to #{status}"
     
-    message = "#{message} issue #{resolved_issue.short_id} #{resolved_issue.title}"
+    message = "#{message} issue #{resolved_issue.short_id}: #{resolved_issue.title}"
     puts message
     
-
     save_db()
-    opts[:commit] && exec("git commit -a -m \"#{message}\"")
-  end
 
+    if opts[:commit]
+      system "git add .issues"
+      system "git commit -m \"#{message}\""
+    end
+    
+    if opts[:close_branch] == true
+      issue_branch = git_get_current_branch()
+      system "git checkout dev"
+      system "git merge #{issue_branch}"
+      system "git branch -d #{issue_branch}"
+    end
+  end
 
-#----------------------------------------------------------------------------------------------------------------------#
+#-------------------------------------------------------------------------------------------
 
   def delete_issues(opts)
     delete_issues = []
@@ -339,8 +425,7 @@ class IssuesDb
 
   end
 
-
-#----------------------------------------------------------------------------------------------------------------------#
+#-------------------------------------------------------------------------------------------
 
   def edit_issue(opts)
     issue_id = opts[:issue_id]
@@ -357,35 +442,123 @@ class IssuesDb
     did_change_issue && save_db()
   end
 
+#-------------------------------------------------------------------------------------------
+
+  def select_issue_for_estimate?(issue, milestone)
+    issue.milestone != nil \
+    && issue.status == "open" \
+    && (issue.milestone == milestone \
+       || milestone.start_with?(".") && issue.milestone.end_with?(milestone) \
+       || milestone.end_with?(".") && issue.milestone.start_with?(milestone) )
+  end
+
+#-------------------------------------------------------------------------------------------
+  
+  def get_milestones_for_pattern(pattern)
+    result_hash = {}    
+    issues_array.each { |i| select_issue_for_estimate?(i, pattern) && result_hash[i.milestone] = true }
+    result_hash.keys.sort
+  end
+
+#-------------------------------------------------------------------------------------------
 
-#----------------------------------------------------------------------------------------------------------------------#
+  def estimate(opts)
+    milestone = opts[:milestone]
+    total = 0.0
+    
+    issues_to_estimate = @issues_array.select { |i| select_issue_for_estimate?(i, milestone) }
+    issues_without_estimates = @issues_array.select { |i| select_issue_for_estimate?(i, milestone) && !i.estimate }
+
+    if issues_to_estimate.empty? 
+      puts "No open issues found for milestone " << milestone << "!"
+      exit
+    end
+
+    if issues_without_estimates.count > 0 
+      puts PrettyComment.h3("Warning: Found issues without estimates")
+      issues_without_estimates.each {|i| puts i.format_list(opts)}
+      puts PrettyComment.separator("-")
+      puts
+    end
+    
+    issues_to_estimate.each { |i| (i.estimate && total += i.estimate) }
+    
+    milestones = get_milestones_for_pattern(milestone)
 
-  def set_type(opts)
-    new_type = opts[:new_type]
+    result_str = "Milestone" << (milestones.length > 1 ? "s" : "")
+
+    puts result_str << " #{milestones.join(", ")} will take #{total} man-hours to complete."
+    puts
+  end
+
+#-------------------------------------------------------------------------------------------
+
+  def update(opts)
+    new_type = opts[:type]
+    new_milestone = opts[:milestone]
+    new_estimate = opts[:estimate]
+    
     opts[:issue_ids].each do |issue_id|
+      did_update = false
       issue = select_issue { |i| i.id.start_with?(issue_id) }
-      if issue.type != new_type
-        issue.type = new_type
-        issue.log("Changed typed to #{issue.type}")
-        issue.format_list
-      else
-        puts "Issue #{issue.short_id} already of type #{issue.type}."
+
+      if new_type 
+        if issue.type != new_type
+          issue.type = new_type
+          issue.log("Changed type to #{issue.type}")
+          did_update = true
+        else
+          puts "Issue #{issue.short_id} already of type #{issue.type}."
+        end
+      end
+
+      if new_milestone
+        if issue.milestone != new_milestone
+          issue.milestone = new_milestone
+          issue.log("Changed milestone to #{issue.milestone}")
+          did_update = true
+        else
+          puts "Issue #{issue.short_id} already in milestone #{issue.milestone}."
+        end
+      end
+
+      if new_estimate
+        if issue.estimate != new_estimate
+          issue.estimate = new_estimate
+          issue.log("Changed estimate to #{issue.estimate}")
+          did_update = true
+        else
+          puts "Issue #{issue.short_id} already has estimate #{issue.estimate}h."
+        end
+      end
+
+      if did_update == true
+        puts issue.format_list(opts)
+        save_db()
       end
     end
-    
-    save_db()
   end
 
+#-------------------------------------------------------------------------------------------
 
-#----------------------------------------------------------------------------------------------------------------------#
+  def start_branch(opts)
+    git_get_current_branch() == "dev" || Trollop::die("Must be on dev branch to start new issue branch.")
+    
+    issue_id = opts[:issue_id]
+    issue = select_issue{|i| i.id.start_with?(issue_id) && i.status == "open"}
+
+    system("git checkout -b #{issue.type}/#{issue.short_id}")
+  end
+    
+#-------------------------------------------------------------------------------------------
 
 
 end
 
 
-#======================================================================================================================#
+#===========================================================================================
 # Command Line Parsing
-#======================================================================================================================#
+#===========================================================================================
 
 def get_issue_ids(num_ids, usage)
   result = []
@@ -404,21 +577,24 @@ def get_issue_ids(num_ids, usage)
   end
 end
 
-
-#----------------------------------------------------------------------------------------------------------------------#
+#-------------------------------------------------------------------------------------------
 
 EXECUTABLE_NAME=File.basename($0)
 DATABASE_NAME= ".issues/" << EXECUTABLE_NAME << ".yaml"
 
 SUB_COMMANDS = {
-  "list"      => "list issues",
-  "create"    => "create a new issue",
-  "resolve"   => "set status of issue to \"resolved\"",
-  "wontfix"   => "set status of issue to \"won't fix\"",
-  "duplicate" => "mark issue as duplicate of another issue",
-  "edit"      => "edit an existing issue",
-  "delete"    => "delete an issue",
-  "set-type"  => "set the type of an issue"}
+  "list"          => "list issues",
+  "count"         => "count issues",
+  "create"        => "create a new issue",
+  "resolve"       => "set status of issue to \"resolved\"",
+  "wontfix"       => "set status of issue to \"won't fix\"",
+  "cantreproduce" => "set status of issue to \"can't reproduce\"",
+  "duplicate"     => "mark issue as duplicate of another issue",
+  "edit"          => "edit an existing issue",
+  "delete"        => "delete an issue",
+  "estimate"      => "calculate estimated man-hours for a milestone",
+  "update"        => "update issue fields.",
+  "startbranch"   => "start a new git branch with to work on issue"}
 
 LeftFieldLength = 
   SUB_COMMANDS.collect { |key, value| key.length }.max
@@ -451,31 +627,33 @@ cmd ||= 'list'
 
 cmd_opts = {}
 
-if cmd == 'list'
+if cmd == 'list' || cmd == 'count'
   cmd_opts = 
     Trollop::options do
-      opt :all, "list all issues",            :short => 'a'
-      opt :newest, "list newest issues first"
-      opt :oldest, "list oldest issues first"
-      opt :verbose, "verbose list of issues", :short => 'v'
-      opt :bugs, "list bugs",                 :short => 'b'
-      opt :improvements, "list improvements", :short => 'i'
-      opt :tasks, "list tasks",               :short => 't'
+      opt :all,    "#{cmd} all issues",            :short => 'a'
+      opt :newest, "#{cmd} newest issues first" if cmd == 'list'
+      opt :oldest, "#{cmd} oldest issues first" if cmd == 'list'
+      opt :verbose, "verbose list of issues", :short => 'v' if cmd == 'list'
+      opt :type, "#{cmd} issues of given type (bug, improvement, task, feature)", :short => 't', :type => String 
+      opt :milestone, "#{cmd} issues for given milestone", :short => 'm', :type => String
+      opt "no-milestone", "#{cmd} all issues not assigned to any milestone"
     end
     
-    ARGV.count > 0 && cmd_opts[:issue_id] = get_issue_ids(1, "list ID")
+    if cmd == 'list'
+      ARGV.count > 0 && cmd_opts[:issue_id] = get_issue_ids(1, "list ID")
+    end
 
 elsif cmd == "create"
   cmd_opts = 
     Trollop::options do
-      opt :bug, "create a bug", :short => 'b'
-      opt :improvement, "create an improvement", :short => 'i'
-      opt :task, "create a task", :short => 't'
+      opt :type, "create issue of specific type (e.g. bug, feature, improvement, task)", :short => 't', :type => String
+      opt :milestone, "specify the milestone of the new issue", :short => 'm', :type => String
+      opt :estimate, "specify the estimated effort", :short => 'e', :type => Float
     end
   cmd_opts[:title] = ARGV.shift || Trollop::die( "Please enter a title for the new issue!")
 
 
-elsif cmd == "resolve" || cmd == "wontfix" || cmd == "duplicate"
+elsif cmd == "resolve" || cmd == "wontfix" || cmd == "duplicate" || cmd == "cantreproduce"
   cmd_opts = 
     Trollop::options do
       opt :commit, "do a git commit", :short => 'c'
@@ -483,6 +661,10 @@ elsif cmd == "resolve" || cmd == "wontfix" || cmd == "duplicate"
     
   if cmd == "duplicate"
     cmd_opts[:issue_id], cmd_opts[:duplicate_of_id] = get_issue_ids(2, "duplicate ID(issue) ID(duplicate of)")
+  elsif cmd == "resolve" && is_issue_branch()
+    cmd_opts[:issue_id] = git_get_current_branch().split('/')[1]
+    cmd_opts[:close_branch] = true
+    cmd_opts[:commit] = true
   else
     cmd_opts[:issue_id] = get_issue_ids(1, "#{cmd} [-c] ID")
   end
@@ -494,29 +676,56 @@ elsif cmd == "edit"
       opt :description, "edit the issue description", :short => 'd'
     end
   cmd_opts[:issue_id] = get_issue_ids(1, "edit ID") 
-
-
-elsif cmd == "set-type"
+  
+elsif cmd == "estimate"
   Trollop::options do
     banner <<-EOL
 Usage:
 ------
-issues set-type {bug|improvement|task} ID
+issues estimate MILESTONE
+
+Options:
+--------
+EOL
+  end
+
+  ARGV.count > 0 || Trollop::die("Usage: issues estmiate MILSTONE")
+  cmd_opts[:milestone] = ARGV.shift
+
+elsif cmd == "update"
+  my_banner = <<-EOL
+Usage:
+------
+issues update \
+ [--type (bug|improvement|task|feature)]\
+ [--milestone MILESTONE]\
+ [--estimate ESTIMATE]\
+ ID{,ID2,...}
 
 Options:
 --------
 EOL
+
+  cmd_opts = Trollop::options do
+    banner my_banner
+    opt :type, "update the issue type", :short => 't', :type => String
+    opt :milestone, "update the milestone", :short => 'm', :type => String
+    opt :estimate,  "update the estimate", :short => 'e', :type => Float
   end
 
-  new_type = ARGV.shift
-  %w{bug improvement task}.include?(new_type) || Trollop::die("Please specify one of [bug, improvement, task] as new issue type")
-  cmd_opts[:new_type] = new_type
-  ARGV.count > 0 && cmd_opts[:issue_ids] = get_issue_ids(-1, "set-type {bug|improvement|task} ID")
+  cmd_opts[:type] && (%w{bug improvement task feature}.include?(cmd_opts[:type]) || Trollop::die("Please specify one of [bug, improvement, task, freature] as new issue type"))
+  cmd_opts[:type] || cmd_opts[:milestone] || cmd_opts[:estimate] || Trollop::die("You must specify one of (--type, --milestone, --estimate)")
+
+  ARGV.count > 0 && cmd_opts[:issue_ids] = get_issue_ids(-1, "set-type {bug|improvement|task|feature} ID")
 
 
 elsif cmd == "delete"
   cmd_opts[:issue_ids] = get_issue_ids(-1, "#{cmd} ID")
 
+
+elsif cmd == "startbranch"
+  cmd_opts[:issue_id] = get_issue_ids(1, "list ID") || Trollop::die( "Please enter an id for the issue to work on in the new branch!")
+
 else
   Trollop::die "unknown command #{cmd.inspect}"
 end
@@ -525,27 +734,35 @@ end
 cmd_opts[:cmd] = cmd 
 
 
-#======================================================================================================================#
-#                                                         Main
-#======================================================================================================================#
+#===========================================================================================
+# Main
+#===========================================================================================
 
 Issues = IssuesDb.new(DATABASE_NAME)
+cmd_opts[:list_estimate] = Issues.has_open_issues_with_estimate?()
+cmd_opts[:milestone_column_width] = Issues.milestone_column_width()
+cmd_opts[:list_milestone] = Issues.has_open_issues_with_milestone?()
 
 case cmd
   when "create" 
     Issues.create_issue(cmd_opts)
   when "list" 
     Issues.list_issues(cmd_opts)
-  when "resolve", "wontfix", "duplicate"
+  when "count"
+    Issues.count_issues(cmd_opts)
+  when "resolve", "wontfix", "duplicate", "cantreproduce"
     Issues.resolve_issues(cmd_opts)
   when "edit"
     Issues.edit_issue(cmd_opts)
-  when "set-type"
-    Issues.set_type(cmd_opts)
+  when "estimate"
+    Issues.estimate(cmd_opts)
+  when "update"
+    Issues.update(cmd_opts)
   when "delete"
     Issues.delete_issues(cmd_opts)
+  when "startbranch"
+    Issues.start_branch(cmd_opts)
 end
 
-
-#======================================================================================================================#
+#===========================================================================================