ursm-ditz 0.4 → 0.5

data/lib/ditz/plugins/git-sync.rb

@@ -0,0 +1,83 @@
+## git-sync ditz plugin
+## 
+## This plugin is useful for when you want synchronized, non-distributed issue
+## coordination with other developers, and you're using git. It allows you to
+## synchronize issue updates with other developers by using the 'ditz sync'
+## command, which does all the git work of sending and receiving issue change
+## for you. However, you have to set things up in a very specific way for this
+## to work:
+##
+## 1. Your ditz state must be on a separate branch. I recommend calling it
+##    'bugs'. Create this branch, do a ditz init, and push it to the remote
+##    repo. (This means you won't be able to mingle issue change and code
+##    change in the same commits. If you care.)
+## 2. Make a checkout of the bugs branch in a separate directory, but NOT in
+##    your code checkout. If you're developing in a directory called "project",
+##    I recommend making a ../project-bugs/ directory, cloning the repo there
+##    as well, and keeping that directory checked out to the 'bugs' branch.
+##    (There are various complicated things you can do to make that directory
+##    share git objects with your code directory, but I wouldn't bother unless
+##    you really care about disk space. Just make it an independent clone.)
+## 3. Set that directory as your issue-dir in your .ditz-config file in your
+##    code checkout directory. (This file should be in .gitignore, btw.)
+## 4. Run 'ditz reconfigure' and fill in the local branch name, remote
+##    branch name, and remote repo for the issue tracking branch.
+##
+## Once that's set up, 'ditz sync' will change to the bugs checkout dir, bundle
+## up any changes you've made to issue status, push them to the remote repo,
+## and pull any new changes in too. All ditz commands will read from your bugs
+## directory, so you should be able to use ditz without caring about where
+## things are anymore.
+##
+## This complicated setup is necessary to avoid accidentally mingling code
+## change and issue change. With this setup, issue change is synchronized,
+## but how you synchronize code is still up to you.
+##
+## Usage:
+##   0. read all the above text very carefully
+##   1. add a line "- git-sync" to the .ditz-plugins file in the project
+##      root
+##   2. run 'ditz reconfigure' and answer its questions
+##   3. run 'ditz sync' with abandon
+
+module Ditz
+
+class Config
+  field :git_sync_local_branch, :prompt => "Local bugs branch name for ditz sync", :default => "bugs"
+  field :git_sync_remote_branch, :prompt => "Remote bugs branch name for ditz sync", :default => "bugs"
+  field :git_sync_remote_repo, :prompt => "Remote bugs repo name for ditz sync", :default => "origin"
+end
+
+class Operator
+  operation :sync, "Sync the repo containing ditz via git" do
+    opt :dry_run, "Dry run: print the commants, but don't execute them", :short => "n"
+  end
+  def sync project, config, opts
+    unless config.git_sync_local_branch
+      $stderr.puts "Please run ditz reconfigure and set the local and remote branch names"
+      return
+    end
+
+    Dir.chdir $project_root
+    puts "[in #{$project_root}]"
+    sh "git add *.yaml", :force => true, :fake => opts[:dry_run]
+    sh "git commit -m 'issue updates'", :force => true, :fake => opts[:dry_run]
+    sh "git pull", :fake => opts[:dry_run]
+    sh "git push #{config.git_sync_remote_repo} #{config.git_sync_local_branch}:#{config.git_sync_remote_branch}", :fake => opts[:dry_run]
+    puts
+    puts "Ditz issue state synchronized."
+  end
+
+  private
+
+  def sh s, opts={}
+    puts "+ #{s}"
+    return if opts[:fake]
+    unless system(s) || opts[:force]
+      $stderr.puts "non-zero (#{$?.exitstatus}) exit code: #{s}"
+      exit(-1)
+    end
+  end
+end
+
+end

data/lib/{plugins → ditz/plugins}/git.rb

@@ -1,3 +1,31 @@
+## git ditz plugin
+## 
+## This plugin allows issues to be associated with git commits and git
+## branches.  Git commits can be easily tagged with a ditz issue with the 'ditz
+## commit' command, and both 'ditz show' and the ditz HTML output will then
+## contain a list of associated commits for each issue.
+##
+## Issues can also be assigned a single git feature branch. In this case, all
+## commits on that branch will listed as commits for that issue. This
+## particular feature is fairly rudimentary, however---it assumes the reference
+## point is the 'master' branch, and once the feature branch is merged back
+## into master, the list of commits disappears.
+##
+## Two configuration variables are added, which, when specified, are used to
+## construct HTML links for the git commit id and branch names in the generated
+## HTML output.
+##
+## Commands added:
+##   ditz set-branch: set the git branch of an issue
+##   ditz commit: run git-commit, and insert the issue id into the commit
+##     message.
+##
+## Usage: 
+##   1. add a line "- git" to the .ditz-plugins file in the project root
+##   2. run ditz reconfigure, and enter the URL prefixes, if any, from
+##      which to create commit and branch links.
+##   3. use 'ditz commit' with abandon.
+
 require 'time'
 
 module Ditz
@@ -11,7 +39,7 @@ class Issue
     filters << "master..#{git_branch}" if git_branch
 
     output = filters.map do |f|
-      `git log --pretty=format:\"%aD\t%an <%ae>\t%h\t%s\" #{f}`
+      `git log --pretty=format:\"%aD\t%an <%ae>\t%h\t%s\" #{f} 2> /dev/null`
     end.join
 
     @git_commits = output.split(/\n/).map { |l| l.split("\t") }.
@@ -55,17 +83,14 @@ EOS
 
     [<<EOS, { :commits => commits, :url_prefix => config.git_commit_url_prefix }]
 <h2>Commits for this issue</h2>
-<table>
+<table class="log">
 <% commits.each_with_index do |(time, who, hash, msg), i| %>
-<% if i % 2 == 0 %>
-  <tr class="logentryeven">
-<% else %>
-  <tr class="logentryodd">
-<% end %>
-  <td class="logtime"><%=t time %></td>
-  <td class="logwho"><%=obscured_email who %></td>
-  <td class="logwhat"><%=h msg %> [<%= url_prefix && !url_prefix.blank? ? link_to([url_prefix, hash].join, hash) : hash %>]</td>
+  <tr class="<%= i % 2 == 0 ? "even-row" : "odd-row" %>">
+  <td class="time"><%=t time %></td>
+  <td class="person"><%=obscured_email who %></td>
+  <td class="message"><%=h msg %> [<%= url_prefix && !url_prefix.blank? ? link_to([url_prefix, hash].join, hash) : hash %>]</td>
   </tr>
+  <tr><td></td></tr>
 <% end %>
 </table>
 EOS
@@ -98,16 +123,30 @@ class Operator
       :short => "-v", :default => false
     opt :message, "Use the given <s> as the commit message.", \
       :short => "-m", :type => :string
+    opt :edit, "Further edit the message, even if --message is given.", :short => "-e", :default => false
   end
+
   def commit project, config, opts, issue
-    verbose_flag = opts[:verbose] ? "--verbose" : ""
-    all_flag = opts[:all] ? "--all" : ""
-    ditz_header = "Ditz-issue: #{issue.id}"
-    message = opts[:message] ? "#{opts[:message]}\n\n#{ditz_header}" : \
-                               "#{ditz_header}"
-    edit_flag = opts[:message] ? "" : "--edit"
-    message_flag = %{--message="#{message}"}
-    exec "git commit #{all_flag} #{verbose_flag} #{message_flag} #{edit_flag}"
+    opts[:edit] = true if opts[:message].nil?
+
+    args = {
+      :verbose => "--verbose",
+      :all => "--all",
+      :edit => "--edit",
+    }.map { |k, v| opts[k] ? v : "" }.join(" ")
+
+    comment = "# #{issue.name}: #{issue.title}"
+    tag = "Ditz-issue: #{issue.id}"
+    message = if opts[:message] && !opts[:edit]
+      "#{opts[:message]}\n\n#{tag}"
+    elsif opts[:message] && opts[:edit]
+      "#{opts[:message]}\n\n#{comment}\n#{tag}"
+    else
+      "#{comment}\n#{tag}"
+    end
+
+    message = message.gsub("\"", "\\\"")
+    exec "git commit #{args} --message=\"#{message}\""
   end
 end
 

data/lib/ditz/plugins/issue-claiming.rb

@@ -0,0 +1,174 @@
+## issue-claiming ditz plugin
+## 
+## This plugin allows people to claim issues. This is useful for avoiding
+## duplication of work---you can check to see if someone's claimed an
+## issue before starting to work on it, and you can let people know what
+## you're working on.
+##
+## Commands added:
+##   ditz claim: claim an issue for yourself
+##   ditz unclaim: unclaim a claimed issue
+##   ditz mine: show all issues claimed by you
+##   ditz claimed: show all claimed issues, by developer
+##   ditz unclaimed: show all unclaimed issues
+##
+## Usage:
+##   1. add a line "- issue-claiming" to the .ditz-plugins file in the project
+##      root
+##   2. use the above commands to abandon
+
+module Ditz
+class Issue
+  field :claimer, :ask => false
+
+  def claim who, comment, force=false
+    raise Error, "already claimed by #{claimer}" if claimer && !force
+    log "issue claimed", who, comment
+    self.claimer = who
+  end
+
+  def unclaim who, comment, force=false
+    raise Error, "not claimed" unless claimer
+    raise Error, "can only be unclaimed by #{claimer}" unless claimer == who || force
+    if claimer == who
+      log "issue unclaimed", who, comment
+    else
+      log "unassigned from #{claimer}", who, comment
+    end
+    self.claimer = nil
+  end
+
+  def claimed?; claimer end
+  def unclaimed?; !claimed? end
+end
+
+class ScreenView
+  add_to_view :issue_summary do |issue, config|
+    " Claimed by: #{issue.claimer || 'none'}\n"
+  end
+end
+
+class HtmlView
+  add_to_view :issue_summary do |issue, config|
+    next unless issue.claimer
+    [<<EOS, { :issue => issue }]
+<tr>
+  <td class='attrname'>Claimed by:</td>
+  <td class='attrval'><%= h(issue.claimer) %></td>
+</tr>
+EOS
+  end
+end
+
+class Operator
+  alias :__issue_claiming_start :start
+  def start project, config, opts, issue
+    if issue.claimed? && issue.claimer != config.user
+      raise Error, "issue #{issue.name} claimed by #{issue.claimer}"
+    else
+      __issue_claiming_start project, config, opts, issue
+    end
+  end
+
+  alias :__issue_claiming_stop :stop
+  def stop project, config, opts, issue
+    if issue.claimed? && issue.claimer != config.user
+      raise Error, "issue #{issue.name} claimed by #{issue.claimer}"
+    else
+      __issue_claiming_stop project, config, opts, issue
+    end
+  end
+
+  alias :__issue_claiming_close :close
+  def close project, config, opts, issue
+    if issue.claimed? && issue.claimer != config.user
+      raise Error, "issue #{issue.name} claimed by #{issue.claimer}"
+    else
+      __issue_claiming_close project, config, opts, issue
+    end
+  end
+
+  operation :claim, "Claim an issue for yourself", :issue do
+    opt :force, "Claim this issue even if someone else has claimed it", :default => false
+  end
+  def claim project, config, opts, issue
+    puts "Claiming issue #{issue.name}: #{issue.title}."
+    comment = ask_multiline "Comments" unless $opts[:no_comment]
+    issue.claim config.user, comment, opts[:force]
+    puts "Issue #{issue.name} marked as claimed by #{config.user}"
+  end
+
+  operation :unclaim, "Unclaim a claimed issue", :issue do
+    opt :force, "Unclaim this issue even if it's claimed by someone else", :default => false
+  end
+  def unclaim project, config, opts, issue
+    puts "Unclaiming issue #{issue.name}: #{issue.title}."
+    comment = ask_multiline "Comments" unless $opts[:no_comment]
+    issue.unclaim config.user, comment, opts[:force]
+    puts "Issue #{issue.name} marked as unclaimed."
+  end
+
+  operation :mine, "Show all issues claimed by you", :maybe_release do
+    opt :all, "Show all issues, not just open ones"
+  end
+  def mine project, config, opts, releases
+    releases ||= project.unreleased_releases + [:unassigned]
+    releases = [*releases]
+
+    issues = project.issues.select do |i|
+      r = project.release_for(i.release) || :unassigned
+      releases.member?(r) && i.claimer == config.user && (opts[:all] || i.open?)
+    end
+    if issues.empty?
+      puts "No issues."
+    else
+      print_todo_list_by_release_for project, issues
+    end
+  end
+
+  operation :claimed, "Show claimed issues by claimer", :maybe_release do
+    opt :all, "Show all issues, not just open ones"
+  end
+  def claimed project, config, opts, releases
+    releases ||= project.unreleased_releases + [:unassigned]
+    releases = [*releases]
+
+    issues = project.issues.inject({}) do |h, i|
+      r = project.release_for(i.release) || :unassigned
+      if i.claimed? && (opts[:all] || i.open?) && releases.member?(r)
+        (h[i.claimer] ||= []) << i
+      end
+      h
+    end
+
+    if issues.empty?
+      puts "No issues."
+    else
+      issues.keys.sort.each do |c|
+        puts "#{c}:"
+        puts todo_list_for(issues[c], :show_release => true)
+        puts
+      end
+    end
+  end
+
+  operation :unclaimed, "Show all unclaimed issues", :maybe_release do
+    opt :all, "Show all issues, not just open ones"
+  end
+  def unclaimed project, config, opts, releases
+    releases ||= project.unreleased_releases + [:unassigned]
+    releases = [*releases]
+
+    issues = project.issues.select do |i|
+      r = project.release_for(i.release) || :unassigned
+      releases.member?(r) && i.claimer.nil? && (opts[:all] || i.open?)
+    end
+    if issues.empty?
+      puts "No issues."
+    else
+      print_todo_list_by_release_for project, issues
+    end
+  end
+end
+
+end

data/lib/ditz/plugins/issue-labeling.rb

@@ -0,0 +1,161 @@
+## issue-labeling ditz plugin
+## 
+## This plugin allows label issues. This can replace the issue component
+## and/or issue types (bug,feature,task), by providing a more flexible
+## to organize your issues.
+##
+## Commands added:
+##   ditz new_label [label]: create a new label for the project
+##   ditz label <issue> <labels>: label an issue with some labels
+##   ditz unlabel <issue> [labels]: remove some label(s) of an issue
+##   ditz labeled <labels> [release]: show all issues with these labels
+##
+## Usage:
+##   1. add a line "- issue-labeling" to the .ditz-plugins file in the project
+##      root
+##   2. use the above commands to abandon
+
+# TODO:
+#   * extend the HTML view to have per-labels listings
+#   * allow for more compact way to type them (completion, prefixes...)
+
+module Ditz
+
+class Label < ModelObject
+  include Comparable
+  field :name
+
+  def name_prefix; @name.gsub(/\s+/, "-").downcase end
+
+  def <=> x ; name <=> x.name end
+  def == x ; name == x.name end
+
+end # class Label
+
+class Project
+  field :labels, :multi => true, :interactive_generator => :get_labels
+
+  def get_labels
+    lab_names = ask_for_many("labels")
+    ([name] + lab_names).uniq.map { |n| Label.create_interactively :with => { :name => n } }
+  end
+
+  def label_for label_name
+    labels.find { |i| i.name == label_name }
+  end
+
+  def labels_for label_names
+    label_names.split(/\s*,\s*/).map do |val|
+      label_for(val) or raise Error, "no label with name #{val}"
+    end
+  end
+
+end # class Project
+
+class Issue
+  field :labels, :multi => true, :interactive_generator => :get_labels
+
+  def get_labels config, project
+    ask_for_selection(project.labels, "label", :name, true).map {|x|x.name}
+  end
+
+  def apply_labels new_labels, who, comment
+    log "issue labeled", who, comment
+    new_labels.each { |l| add_label l }
+  end
+
+  def remove_labels labels_to_remove, who, comment
+    log "issue unlabeled", who, comment
+    if labels_to_remove.nil?
+      self.labels = []
+    else
+      labels_to_remove.each { |l| drop_label l }
+    end
+  end
+
+  def labeled? label=nil; (label.nil?)? !labels.empty? : labels.include?(label) end
+  def unlabeled? label=nil; !labeled?(label) end
+end
+
+class ScreenView
+  add_to_view :issue_summary do |issue, config|
+    " Labels: #{(issue.labeled?)? issue.labels.map{|l|l.name}.join(', ') : 'none'}\n"
+  end
+end
+
+class HtmlView
+  add_to_view :issue_summary do |issue, config|
+    next if issue.unlabeled?
+    [<<EOS, { :issue => issue }]
+<tr>
+  <td class='attrname'>Labels:</td>
+  <td class='attrval'><%= h(issue.labels.map{|l|l.name}.join(', ')) %></td>
+</tr>
+EOS
+  end
+end
+
+class Operator
+
+  operation :new_label, "Create a new label for the project", :maybe_label
+  def new_label project, config, maybe_label
+    puts "Adding label #{maybe_label}." if maybe_label
+    label = Label.create_interactively(:args => [project, config], :with => { :name => maybe_label }) or return
+    project.add_label label
+    puts "Added label #{label.name}."
+  end
+
+  operation :label, "Apply labels to an issue", :issue, :labels
+  def label project, config, issue, label_names
+    labels = project.labels_for label_names
+    puts "Adding labels #{label_names} to issue #{issue.name}: #{issue.title}."
+    comment = ask_multiline "Comments" unless $opts[:no_comment]
+    issue.apply_labels labels, config.user, comment
+    show_labels issue
+  end
+
+  operation :unlabel, "Remove some labels of an issue", :issue, :maybe_labels
+  def unlabel project, config, issue, label_names
+    labels = if label_names
+               puts "Removing #{label_names} labels from issue #{issue.name}: #{issue.title}."
+               project.labels_for label_names
+             else
+               puts "Removing labels from issue #{issue.name}: #{issue.title}."
+              nil
+             end
+    comment = ask_multiline "Comments" unless $opts[:no_comment]
+    issue.remove_labels labels, config.user, comment
+    show_labels issue
+  end
+
+  def show_labels issue
+    if issue.labeled?
+      puts "Issue #{issue.name} is now labeled with #{issue.labels.map{|l|l.name}.join(', ')}"
+    else
+      puts "Issue #{issue.name} is now unlabeled"
+    end
+  end
+  private :show_labels
+
+  operation :labeled, "Show labeled issues", :labels, :maybe_release do
+    opt :all, "Show all issues, not just open ones"
+  end
+  def labeled project, config, opts, labels, releases
+    releases ||= project.unreleased_releases + [:unassigned]
+    releases = [*releases]
+    labels = project.labels_for labels
+
+    issues = project.issues.select do |i|
+      r = project.release_for(i.release) || :unassigned
+      labels.all? { |l| i.labeled? l } && (opts[:all] || i.open?) && releases.member?(r)
+    end
+
+    if issues.empty?
+      puts "No issues."
+    else
+      print_todo_list_by_release_for project, issues
+    end
+  end
+end
+
+end