ohac-ditz 0.5.1

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/ditz/plugins/git.rb

@@ -0,0 +1,153 @@
+## 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
+class Issue
+  field :git_branch, :ask => false
+
+  def git_commits
+    return @git_commits if @git_commits
+
+    filters = ["--grep=\"Ditz-issue: #{id}\""]
+    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} 2> /dev/null`
+    end.join
+
+    @git_commits = output.split(/\n/).map { |l| l.split("\t") }.
+      map { |date, email, hash, msg| [Time.parse(date).utc, email, hash, msg] }
+  end
+end
+
+class Config
+  field :git_commit_url_prefix, :prompt => "URL prefix to link git commits to", :default => ""
+  field :git_branch_url_prefix, :prompt => "URL prefix to link git branches to", :default => ""
+end
+
+class ScreenView
+  add_to_view :issue_summary do |issue, config|
+    " Git branch: #{issue.git_branch || 'none'}\n"
+  end
+
+  add_to_view :issue_details do |issue, config|
+    commits = issue.git_commits[0...5]
+    next if commits.empty?
+    "Recent commits:\n" + commits.map do |date, email, hash, msg|
+      "- #{msg} [#{hash}] (#{email.shortened_email}, #{date.ago} ago)\n"
+     end.join + "\n"
+  end
+end
+
+class HtmlView
+  add_to_view :issue_summary do |issue, config|
+    next unless issue.git_branch
+    [<<EOS, { :issue => issue, :url_prefix => config.git_branch_url_prefix }]
+<tr>
+  <td class='attrname'>Git branch:</td>
+  <td class='attrval'><%= url_prefix && !url_prefix.blank? ? link_to([url_prefix, issue.git_branch].join, issue.git_branch) : h(issue.git_branch) %></td>
+</tr>
+EOS
+  end
+
+  add_to_view :issue_details do |issue, config|
+    commits = issue.git_commits
+    next if commits.empty?
+
+    [<<EOS, { :commits => commits, :url_prefix => config.git_commit_url_prefix }]
+<h2>Commits for this issue</h2>
+<table class="log">
+<% commits.each_with_index do |(time, who, hash, msg), i| %>
+  <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
+  end
+end
+
+class Operator
+  operation :set_branch, "Set the git feature branch of an issue", :issue, :maybe_string
+  def set_branch project, config, issue, maybe_string
+    puts "Issue #{issue.name} currently " + if issue.git_branch
+      "assigned to git branch #{issue.git_branch.inspect}."
+    else
+      "not assigned to any git branch."
+    end
+
+    branch = maybe_string || ask("Git feature branch name:")
+    return unless branch
+
+    if branch == issue.git_branch
+      raise Error, "issue #{issue.name} already assigned to branch #{issue.git_branch.inspect}"
+    end
+
+    puts "Assigning to branch #{branch.inspect}."
+    issue.git_branch = branch
+  end
+
+  operation :commit, "Runs git-commit and auto-fills the issue name in the commit message", :issue do
+    opt :all, "commit all changed files", :short => "-a", :default => false
+    opt :verbose, "show diff between HEAD and what would be committed", \
+      :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
+    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#{tag}\n\n#{comment}"
+    else
+      "#{comment}\n\n#{tag}"
+    end
+
+    message = message.gsub("\"", "\\\"")
+    exec "git commit #{args} --message=\"#{message}\""
+  end
+end
+
+end

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

@@ -0,0 +1,193 @@
+## 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 or a dev specified in project.yaml
+##   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. (optional:) add a 'devs' key to project.yaml, e.g:
+## devs: 
+##   :roy: Roy Baty <roy@marsproject.com>
+##   :pris: Pris Stratton <pris@marsproject.com>
+
+##   3. use the above commands to abandon
+
+module Ditz
+
+class Project
+  field :devs, :prompt => "Hash of developer nicknames (as symbols) to email addresses",
+               :default => {:roy => "Roy Baty <roy@marsproject.com>"}
+end
+
+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 "unclaimed 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, :maybe_dev do
+    opt :force, "Claim this issue even if someone else has claimed it", :default => false
+  end
+  def claim project, config, opts, issue, dev = nil
+    if dev
+      dev_full_email = project.devs ? project.devs[dev.to_sym] : nil
+      raise Error, "no nickname :#{dev} has been defined in project.yaml" unless dev_full_email
+    end
+    dev_full_email ||= config.user
+    puts "Claiming issue #{issue.name}: #{issue.title} for #{dev_full_email}."
+    comment = ask_multiline_or_editor "Comments" unless $opts[:no_comment]
+    issue.claim dev_full_email, comment, opts[:force]
+    puts "Issue #{issue.name} marked as claimed by #{dev_full_email}"
+  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_or_editor "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
+      run_pager config
+      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
+      run_pager config
+      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
+      run_pager config
+      print_todo_list_by_release_for project, issues
+    end
+  end
+end
+
+end

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

@@ -0,0 +1,170 @@
+## 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}
+  end
+
+  def apply_labels new_labels, who, comment
+    new_labels.each { |l| add_label l }
+    log "issue labeled", who, comment
+  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
+    begin
+      project.add_label label
+      puts "Added label #{label.name}."
+    rescue Ditz::ModelError => e
+      puts "Error: Project #{e}"
+    end
+  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_or_editor "Comments" unless $opts[:no_comment]
+    begin
+      issue.apply_labels labels, config.user, comment
+    rescue Ditz::ModelError => e
+      puts "Error: Issue #{e}"
+      return
+    end
+    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_or_editor "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

data/lib/ditz/util.rb

@@ -0,0 +1,61 @@
+class Object
+  def returning o; yield o; o end # k-combinator
+end
+
+module Enumerable
+  def count_of(&b); select(&b).size end
+  def max_of(&b); map(&b).max end
+  def min_of(&b); map(&b).min end
+end
+
+class Array
+  def uniq_by; inject({}) { |h, o| h[yield(o)] = o; h }.values end
+end
+
+class NilClass
+  def blank?; true end
+end
+
+module Enumerable
+  def map_with_index # sigh...
+    ret = []
+    each_with_index { |e, i| ret << yield(e, i) }
+    ret
+  end
+
+  def argfind
+    each { |e| x = yield(e); return x if x }
+    nil
+  end
+
+  def group_by
+    inject({}) do |groups, element|
+      (groups[yield(element)] ||= []) << element
+      groups
+    end
+  end if RUBY_VERSION < '1.9'
+
+end
+
+class Array
+  def first_duplicate
+    sa = sort
+    (1 .. sa.length).argfind { |i| (sa[i] == sa[i - 1]) && sa[i] }
+  end
+
+  def to_h
+    Hash[*flatten]
+  end
+
+  def flatten_one_level
+    inject([]) do |ret, e|
+      case e
+      when Array
+        ret + e
+      else
+        ret << e
+      end
+    end
+  end
+end
+

data/lib/ditz/view.rb

@@ -0,0 +1,16 @@
+module Ditz
+
+class View
+  def self.add_to_view type, &block
+    @views ||= {}
+    @views[type] ||= []
+    @views[type] << block
+  end
+
+  def self.view_additions_for type
+    @views ||= {}
+    @views[type] || []
+  end
+end
+
+end