ditz 0.2 → 0.3

data/Changelog

@@ -1,3 +1,16 @@
+== 0.3 / 2008-06-04
+* readline support for all text entry
+* hook system. Use ditz -l to see possible hooks.
+* new commands: archive, shortlog, set-component
+* improved commands: log, assign, add-release
+* new issue type: 'tasks'
+* 'ditz' by itself shows the todo list
+* zsh tab completion for subcommands
+* local config can now specify bugs directory location
+* issue name interpolation now on all issue fields
+* bugfix: various HTML generation bugs
+* bugfix: ditz now works from project subdirectories
+* bugfix: removed UNIX-specific environment variable assumptions
 == 0.2 / 2008-04-11
 * bugfix: store each issue in a separate file to avoid false conflicts
 * added per-command help

data/README.txt

@@ -8,14 +8,14 @@ http://ditz.rubyforge.org
 
 Ditz is a simple, light-weight distributed issue tracker designed to work with
 distributed version control systems like darcs and git. Ditz maintains an issue
-database file on disk, written in a line-based and human-editable format. This
-file is kept under version control, alongside project code.  Changes in issue
-state is handled by version control like code change: included as part of a
-commit, merged with changes from other developers, conflict-resolved in the
-standard manner, etc.
+database directory on disk, with files written in a line-based and human-
+editable format. This directory is kept under version control alongside
+project code. Changes in issue state is handled by version control like code
+change: included as part of a commit, merged with changes from other
+developers, conflict-resolved in the standard manner, etc.
 
 Ditz provides a simple, console-based interface for creating and updating the
-issue database file, and some rudimentary HTML generation capabilities for
+issue database files, and some rudimentary HTML generation capabilities for
 producing world-readable status pages. It offers no central public method of
 bug submission.
 

data/Rakefile

@@ -33,11 +33,11 @@ SCREENSHOTS.each do |fn|
 end
 
 task :upload_webpage => WWW_FILES do |t|
-  sh "scp -C #{t.prerequisites * ' '} wmorgan@rubyforge.org:/var/www/gforge-projects/ditz/"
+  sh "rsync -essh -cavz #{t.prerequisites * ' '} wmorgan@rubyforge.org:/var/www/gforge-projects/ditz/"
 end
 
 task :upload_webpage_images => (SCREENSHOTS + SCREENSHOTS_SMALL) do |t|
-  sh "scp -C #{t.prerequisites * ' '} wmorgan@rubyforge.org:/var/www/gforge-projects/ditz/"
+  sh "rsync -essh -cavs #{t.prerequisites * ' '} wmorgan@rubyforge.org:/var/www/gforge-projects/ditz/"
 end
 
 task :upload_report do |t|

data/ReleaseNotes

@@ -1,3 +1,16 @@
+0.3
+---
+Ditz now works from project subdirectories, and you can have a .ditz-config in
+the project root for project-specific configuration. (This is not merged with
+the global config, so this file overrides everything in ~/.ditz-config.)
+
+You can specify an :issue_dir key in this file, which can be a relative path to
+the directory containing project.yaml. So if you want to rename that directory,
+or keep it somewhere else, now you can.
+
+There's also a new hook system for plugging in your own code. Run ditz -l to
+see a list of available hooks.
+
 0.2
 ---
 

data/bin/ditz

@@ -1,47 +1,126 @@
 #!/usr/bin/env ruby
 
+## requires are split in two for efficiency reasons: ditz should be really
+## fast when using it for completion.
+require 'operator'
+op = Ditz::Operator.new
+
+## a secret option for shell completion
+if ARGV.include? '--commands'
+  puts op.class.operations.map { |name, _| name }
+  exit 0
+end
+
 require 'rubygems'
 require 'fileutils'
+require 'pathname'
 require 'trollop'; include Trollop
 require "ditz"
 
 PROJECT_FN = "project.yaml"
 CONFIG_FN = ".ditz-config"
-def ISSUE_TO_FN i; "issue-#{i.id}.yaml" end
+
+## helper for recursive search
+def find_dir_containing target, start=Pathname.new(".")
+  return start if (start + target).exist?
+  unless start.parent.realpath == start.realpath
+    find_dir_containing target, start.parent
+  end
+end
 
 $opts = options do
   version "ditz #{Ditz::VERSION}"
   opt :issue_dir, "Issue database dir", :default => "bugs"
   opt :config_file, "Configuration file", :default => File.join(ENV["HOME"], CONFIG_FN)
   opt :verbose, "Verbose output", :default => false
+  opt :no_comment, "Skip asking for a comment", :default => false
+  opt :list_hooks, "List all hooks and descriptions, and quit.", :short => 'l', :default => false
 end
 
-cmd = ARGV.shift or die "expecting a ditz command"
-op = Ditz::Operator.new
-dir = $opts[:issue_dir]
+Ditz::HookManager.register :startup, <<EOS
+Executes at startup
+
+Variables: project, config
+No return value.
+EOS
+
+Ditz::HookManager.register :after_add, <<EOS
+Executes before terminating if new issue files has been created.
+Basically you want to instruct your SCM that these files has
+been added.
+
+Variables: project, config, issues
+No return value.
+EOS
+
+Ditz::HookManager.register :after_delete, <<EOS
+Executes before terminating if new issue files has been deleted.
+Basically you want to instruct your SCM that these files has
+been deleted.
+
+Variables: project, config, issues
+No return value.
+EOS
+
+Ditz::HookManager.register :after_update, <<EOS
+Executes before terminating if new issue files has been updated.
+You may want to instruct your SCM about these changes.
+Note that new issues are not considered updated.
+
+Variables: project, config, issues
+No return value.
+EOS
+
+if $opts[:list_hooks]
+  Ditz::HookManager.print_hooks
+  exit 0
+end
+
+local_config_dir = find_dir_containing CONFIG_FN
+config = begin
+  if local_config_dir
+    fn = local_config_dir + CONFIG_FN
+    Ditz::debug "loading local config from #{fn}"
+    Ditz::Config.from fn
+  else
+    Ditz::debug "loading global config from #{$opts[:config_file]}"
+    Ditz::Config.from $opts[:config_file]
+  end
+rescue SystemCallError, Ditz::ModelObject::ModelError => e
+  puts <<EOS
+I wasn't able to find a configuration file #{$opts[:config_file]}.
+We'll set it up right now.
+EOS
+  Ditz::Config.create_interactively.save! $opts[:config_file]
+end
 
-case cmd # some special cases not handled by Ditz::Operator
+cmd = ARGV.shift || "todo"
+issue_dir = Pathname.new(config.issue_dir || $opts[:issue_dir])
+
+case cmd # some special commands not handled by Ditz::Operator
 when "init"
-  die "#{dir} directory already exists" if File.exists? dir
-  FileUtils.mkdir dir
-  fn = File.join dir, PROJECT_FN
+  die "#{issue_dir} directory already exists" if issue_dir.exist?
+  issue_dir.mkdir
+  fn = issue_dir + PROJECT_FN
   project = op.init
   project.save! fn
-  puts "Ok, #{dir} directory created successfully."
+  puts "Ok, #{issue_dir} directory created successfully."
   exit
 when "help"
   op.do "help", nil, nil, ARGV
   exit
 end
 
-die "No #{dir} directory---use 'ditz init' to initialize" unless File.exists? dir
+project_root = find_dir_containing(issue_dir + PROJECT_FN)
+die "No #{issue_dir} directory---use 'ditz init' to initialize" unless project_root
+project_root += issue_dir
 
 project = begin
-  fn = File.join dir, PROJECT_FN
+  fn = project_root + PROJECT_FN
   Ditz::debug "loading project from #{fn}"
   project = Ditz::Project.from fn
 
-  fn = File.join dir, "issue-*.yaml"
+  fn = project_root + "issue-*.yaml"
   Ditz::debug "loading issues from #{fn}"
   project.issues = Dir[fn].map { |fn| Ditz::Issue.from fn }
   Ditz::debug "found #{project.issues.size} issues"
@@ -51,29 +130,15 @@ rescue SystemCallError, Ditz::Project::Error => e
 end
 
 project.validate!
+project.issues.each { |p| p.project = project}
 project.assign_issue_names!
-project.each_modelobject { |o| o.after_deserialize project }
-
-config = begin
-  if File.exists? CONFIG_FN
-    Ditz::debug "loading local config from #{CONFIG_FN}"
-    Ditz::Config.from CONFIG_FN
-  else
-    Ditz::debug "loading global config from #{$opts[:config_file]}"
-    Ditz::Config.from $opts[:config_file]
-  end
-rescue SystemCallError, Ditz::ModelObject::ModelError => e
-  puts <<EOS
-I wasn't able to find a configuration file #{$opts[:config_file]}.
-We'll set it up right now.
-EOS
-  Ditz::Config.create_interactively
-end
 
 unless op.has_operation? cmd
   die "no such command: #{cmd}"
 end
 
+Ditz::HookManager.run :startup, project, config
+
 ## talk about the law of unintended consequences. 'gets' requires this.
 args = []
 args << ARGV.shift until ARGV.empty?
@@ -83,44 +148,51 @@ begin
   op.do cmd, project, config, args
 rescue Ditz::Operator::Error => e
   die e.message
-rescue Interrupt
+rescue Errno::EPIPE, Interrupt
   exit 1
 end
 
 ## save project.yaml
 dirty = project.each_modelobject { |o| break true if o.changed? } || false
 if dirty
-  fn = File.join dir, PROJECT_FN
+  fn = project_root + PROJECT_FN
   Ditz::debug "project is dirty, saving #{fn}"
-  project.each_modelobject { |o| o.before_serialize project }
   project.save! fn
 end
 
 ## project issues are not model fields proper, so they must be
 ## saved independently.
-project.issues.each do |i|
-  if i.changed?
-    i.before_serialize project
-    fn = File.join dir, ISSUE_TO_FN(i)
-    Ditz::debug "issue #{i.name} is dirty, saving #{fn}"
-    i.save! fn
-  end
+changed_issues = project.issues.select { |i| i.changed? }
+changed_issues.each do |i|
+  i.pathname ||= (project_root + "issue-#{i.id}.yaml")
+  i.project ||= project # hack: not set on new issues
+  Ditz::debug "issue #{i.name} is dirty, saving #{i.pathname}"
+  i.save! i.pathname
 end
 
 project.deleted_issues.each do |i|
-  fn = File.join dir, ISSUE_TO_FN(i)
+  fn = i.pathname
   Ditz::debug "issue #{i.name} has been deleted, deleting #{fn}"
   FileUtils.rm fn
 end
 
 unless project.added_issues.empty?
-  puts "You may have to inform your SCM that the following files have been added:"
-  project.added_issues.each { |i| puts "  " + File.join(dir, ISSUE_TO_FN(i)) }
+  unless Ditz::HookManager.run :after_add, project, config, project.added_issues
+    puts "You may have to inform your SCM that the following files have been added:"
+    project.added_issues.each { |i| puts "  " + i.pathname }
+  end
 end
 
 unless project.deleted_issues.empty?
-  puts "You may have to inform your SCM that the following files have been deleted:"
-  project.deleted_issues.each { |i| puts "  " + File.join(dir, ISSUE_TO_FN(i)) }
+  unless Ditz::HookManager.run :after_delete, project, config, project.deleted_issues
+    puts "You may have to inform your SCM that the following files have been deleted:"
+    project.deleted_issues.each { |i| puts "  " + i.pathname }
+  end
+end
+
+changed_not_added_issues = changed_issues - project.added_issues
+unless changed_not_added_issues.empty?
+  Ditz::HookManager.run :after_update, project, config, changed_not_added_issues
 end
 
 config.save! $opts[:config_file] if config.changed?

data/lib/ditz.rb

@@ -1,13 +1,29 @@
 module Ditz
 
-VERSION = "0.2"
+VERSION = "0.3"
 
 def debug s
   puts "# #{s}" if $opts[:verbose]
 end
 module_function :debug
 
+def self.has_readline?
+  @has_readline
+end
+
+def self.has_readline= val
+  @has_readline = val
+end
+end
+
+begin
+  Ditz::has_readline = false
+  require 'readline'
+  Ditz::has_readline = true
+rescue LoadError
+  # do nothing
 end
 
 require 'model-objects'
 require 'operator'
+require 'hook'

data/lib/hook.rb

@@ -0,0 +1,60 @@
+module Ditz
+  class HookManager
+    def initialize
+      @descs = {}
+      @blocks = {}
+    end
+
+    @@instance = nil
+    def self.method_missing m, *a, &b
+      @@instance ||= self.new
+      @@instance.send m, *a, &b
+    end
+
+    def register name, desc
+      @descs[name] = desc
+      @blocks[name] = []
+    end
+
+    def on *names, &block
+      names.each do |name|
+        raise "unregistered hook #{name.inspect}" unless @descs[name]
+        @blocks[name] << block
+      end
+    end
+
+    def run name, *args
+      raise "unregistered hook #{name.inspect}" unless @descs[name]
+      blocks = hooks_for name
+      return false if blocks.empty?
+      blocks.each { |block| block[*args] }
+      true
+    end
+
+    def print_hooks f=$stdout
+puts <<EOS
+Ditz has #{@descs.size} registered hooks:
+
+EOS
+
+      @descs.map{ |k,v| [k.to_s,v] }.sort.each do |name, desc|
+        f.puts <<EOS
+#{name}
+#{"-" * name.length}
+#{desc}
+EOS
+      end
+    end
+
+    def enabled? name; !hooks_for(name).empty? end
+
+    def hooks_for name
+      if @blocks[name].nil? || @blocks[name].empty?
+        fns = File.join(ENV['HOME'], '.ditz', 'hooks', '*.rb') 
+        Dir[fns].each { |fn| load fn }
+      end
+
+      @blocks[name] || []
+    end
+  end
+end

data/lib/html.rb

@@ -25,6 +25,12 @@ class ErbHtml
     "<a href=\"#{dest}\">#{name}</a>"
   end
 
+  def link_issue_names project, s
+    project.issues.inject(s) do |s, i|
+      s.gsub(/\b#{i.name}\b/, link_to(i, i.title))
+    end
+  end
+
   def render template_name, morevars={}
     ErbHtml.new(@template_dir, template_name, @links, @mapping.merge(morevars)).to_s
   end

data/lib/index.rhtml

@@ -18,8 +18,7 @@
       issues = project.issues_for_release r
       num_done = issues.count_of { |i| i.closed? }
       pct_done = issues.size == 0 ? 100 : (100.0 * num_done / issues.size)
-      num_bugs_todo = issues.count_of { |i| i.bug? && i.open? }
-      num_feats_todo = issues.count_of { |i| i.feature? && i.open? }
+      open_issues = project.group_issues(issues.select { |i| i.open? })
     %>
     <li>
       <%= link_to r, "Release #{r.name}" %>: 
@@ -27,8 +26,11 @@
         no issues
       <% else %>
         <%= sprintf "%.0f%%", pct_done %> complete;
-        <%= "bug".pluralize num_bugs_todo %> and 
-        <%= "feature".pluralize num_feats_todo %> open.
+        <% if open_issues.empty? %>
+          ready for release!
+        <% else %>
+          <%= open_issues.map { |n,is| n.to_s.pluralize is.size }.join(' and ') %> open.
+        <% end %>
       <% end %>
     </li>
   <% end %>
@@ -52,7 +54,11 @@
   open_issues = issues.select { |i| i.open? }
 %>
 <p>
-  <%= link_to "unassigned", "unassigned issue".pluralize(issues.size).ucfirst %>; <%= open_issues.size.to_pretty_s %> open.
+  <% if issues.empty? %>
+    No unassigned issues.
+  <% else %>
+    <%= link_to "unassigned", "unassigned issue".pluralize(issues.size).capitalize %>; <%= open_issues.size.to_pretty_s %> of them open.
+  <% end %>
 </p>
 
 <% if components.size > 1 %>
@@ -60,17 +66,14 @@
   <ul>
   <% components.each do |c| %>
     <%
-      open_issues = project.issues_for_component(c).select { |i| i.open? }
-      num_bugs_todo = open_issues.count_of { |i| i.bug? }
-      num_feats_todo = open_issues.count_of { |i| i.feature? }
+      open_issues = project.group_issues(project.issues_for_component(c).select { |i| i.open? })
     %>
     <li>
       <%= link_to c, c.name %>:
       <% if open_issues.empty? %>
         no open issues.
       <% else %>
-        <%= "open bug".pluralize num_bugs_todo %> and
-        <%= "open feature".pluralize num_feats_todo %>.
+        <%= open_issues.map { |n,is| n.to_s.pluralize is.size }.join(' and ') %> open.
       <% end %>
     </li>
   <% end %>