ohac-ditz 0.5.1

data/bin/ditz

@@ -0,0 +1,230 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.expand_path("#{File.dirname($0)}/../lib"))
+
+## requires are split in two for efficiency reasons: ditz should be really
+## fast when using it for completion.
+$KCODE = "u"
+
+require 'ditz/operator'
+op = Ditz::Operator.new
+
+## a secret option for shell completion
+if ARGV.include? '--commands'
+  puts op.class.operations.map { |name, _| name }
+  exit
+end
+
+begin
+  require 'rubygems'
+  # list version dependant gems here.
+  gem 'yaml_waml', '>= 0.3'
+  gem 'trollop', '>= 1.9'
+rescue LoadError
+end
+
+require 'fileutils'
+require 'pathname'
+require 'trollop'; include Trollop
+require "ditz"
+
+CONFIG_FN = ".ditz-config"
+PLUGIN_FN = ".ditz-plugins"
+
+config_dir = Ditz::find_dir_containing CONFIG_FN
+plugin_dir = Ditz::find_dir_containing PLUGIN_FN
+
+$opts = options do
+  version "ditz #{Ditz::VERSION}"
+  banner <<EOS
+Usage: ditz [global-opts] [command] [command-opts]
+
+See 'ditz help' for a list of commands.
+
+Global options are:
+EOS
+
+  opt :issue_dir, "Issue database dir", :type => :string
+  opt :config_file, "Configuration file", :default => File.join(config_dir || ".", CONFIG_FN)
+  opt :plugins_file, "Plugins file", :default => File.join(plugin_dir || ".", PLUGIN_FN)
+  opt :verbose, "Verbose output", :default => false
+  opt :list_hooks, "Print all hooks exit", :short => 'l', :default => false
+  opt :version, "Print version and exit", :short => :none
+  stop_on_unknown
+end
+$verbose = true if $opts[:verbose]
+
+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
+
+begin
+  Ditz::load_plugins $opts[:plugins_file] if File.exist? $opts[:plugins_file]
+rescue LoadError => e
+  Ditz::debug "can't load plugins file: #{e.message}"
+end
+
+## prevent ctrl-c and borken pipes from printing a useless backtrace
+def die_gently
+  begin
+    yield
+  rescue Interrupt, Errno::EPIPE
+    puts
+    exit 1
+  end
+end
+
+config = begin
+  Ditz::debug "loading config from #{$opts[:config_file]}"
+  Ditz::Config.from $opts[:config_file]
+rescue SystemCallError => e
+  if ARGV.member? "<options>"
+    ## special case here. if we're asking for tab completion, and the config
+    ## file doesn't exist, don't do the interactive building. just make a
+    ## fake empty one and carry on.
+    Ditz::Config.new
+  else
+    puts <<EOS
+I wasn't able to find a configuration file #{$opts[:config_file]}.
+We'll set it up right now.
+EOS
+    die_gently { Ditz::Config.create_interactively.save! $opts[:config_file] }
+  end
+end
+
+## configure any lowline settings
+Lowline.use_editor_if_possible = config.use_editor_if_possible
+
+issue_dir = Pathname.new($opts[:issue_dir] || config.issue_dir)
+cmd = ARGV.shift || "todo"
+unless op.has_operation? cmd
+  die "no such command: #{cmd}"
+end
+
+## TODO: refactor so that three 'exit' statements aren't required
+case cmd # some special commands not handled by Ditz::Operator
+when "init"
+  die "#{issue_dir} directory already exists" if issue_dir.exist?
+  project = nil
+  die_gently { project = op.init }
+  issue_dir.mkdir
+  fn = issue_dir + Ditz::FileStorage::PROJECT_FN
+  project.save! fn
+  puts "Ok, #{issue_dir} directory created successfully."
+  exit
+when "reconfigure" # might not be able to load the project
+  die_gently { op.do cmd, nil, config, ARGV }
+  exit
+when "help"
+  begin
+    op.do cmd, nil, config, ARGV
+  rescue Ditz::Operator::Error => e
+    die "#{e.message}"
+  end
+  exit
+end
+
+$project_root = Ditz::find_dir_containing(issue_dir + Ditz::FileStorage::PROJECT_FN)
+die "No #{issue_dir} directory---use 'ditz init' to initialize" unless $project_root
+$project_root += issue_dir
+
+storage = Ditz::FileStorage.new $project_root
+project = begin
+  storage.load
+rescue SystemCallError, Ditz::Project::Error => e
+  die "#{e.message} (use 'init' to initialize)"
+end
+
+Ditz::HookManager.run :startup, project, config
+
+Ditz::debug "executing command #{cmd}"
+die_gently do
+  begin
+    op.do cmd, project, config, ARGV
+    ## TODO: make these errors have a common ancestor so that this rescue
+    ## statement isn't so stupid
+  rescue Ditz::Operator::Error, Ditz::Release::Error, Ditz::Project::Error, Ditz::Issue::Error => e
+    ## don't use 'die' here (which is Trollop::die) because this is not a
+    ## problem with the command-line arguments.
+    $stderr.puts "Error: #{e.message}"
+    exit 1
+  end
+end
+
+changed_issues = project.issues.select { |i| i.changed? }
+changed_not_added_issues = changed_issues - project.added_issues
+
+storage.save project
+
+## at this point, for compatibility with older hook stuff, we set the pathname
+## directly on the issues.
+
+project.issues.each { |i| i.pathname = storage.filename_for_issue(i) }
+unless project.added_issues.empty?
+  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 "  " + storage.filename_for_issue(i) }
+  end
+end
+
+unless project.deleted_issues.empty?
+  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 "  " + storage.filename_for_issue(i) }
+  end
+end
+
+unless changed_not_added_issues.empty?
+  unless Ditz::HookManager.run :after_update, project, config, changed_not_added_issues
+    puts "You may have to inform your SCM that the following files have been modified:"
+    changed_not_added_issues.each { |i| puts "  " + storage.filename_for_issue(i) }
+  end
+end
+
+## hack upon a hack
+if project.changed?
+  project.pathname = storage.filename_for_project
+  unless Ditz::HookManager.run :after_update, project, config, [project]
+    puts "You may have to inform your SCM that the following files have been modified:"
+    puts "  " + storage.filename_for_project
+  end
+end
+
+config.save! $opts[:config_file] if config.changed?
+
+# vim: syntax=ruby

data/contrib/completion/_ditz.zsh

@@ -0,0 +1,29 @@
+#compdef ditz
+
+ME=ditz
+COMMANDS=--commands
+OPTIONS='<options>'
+
+if (($CURRENT == 2)); then
+  # We're completing the first word after the tool: the command.
+  _wanted command expl "$ME command" \
+    compadd -- $( "$ME" "$COMMANDS" )
+else
+  # Find the options/files/URL/etc. for the current command by using the tool itself.
+      case "${words[$CURRENT]}"; in
+        -*)
+          _wanted args expl "Arguments for $ME ${words[2]}" \
+             compadd -- $( "$ME" "${words[2]}" "$OPTIONS" ; _files )
+            ;;
+        ht*|ft*)
+            _arguments '*:URL:_urls'
+            ;;
+        /*|./*|\~*|../*)
+            _arguments '*:file:_files'
+            ;;
+        *)
+          _wanted args expl "Arguments for $ME ${words[2]}" \
+             compadd -- $( "$ME" "${words[2]}" "$OPTIONS" )
+          ;;
+      esac
+fi

data/contrib/completion/ditz.bash

@@ -0,0 +1,38 @@
+# ditz bash completion
+#
+# author: Christian Garbs
+#
+# based on bzr.simple by Martin Pool
+
+_ditz() 
+{
+    local cur=${COMP_WORDS[COMP_CWORD]}
+
+    if [ $COMP_CWORD -eq 1 ]; then
+	# no command yet, show all commands
+	COMPREPLY=( $( compgen -W "$(ditz --commands)" -- $cur ) )
+
+    else
+	unset COMP_WORDS[COMP_CWORD]  # remove last
+	unset COMP_WORDS[0]           # remove first
+	
+	# add options if applicable...
+	local options
+	if [ "${cur:0:1}" = '-' ]; then
+	    # ...but only if at least a dash is given
+	    case "${COMP_WORDS[1]}" in
+		add|add_reference|add_release|assign|close|comment|release|set_component|start|stop|unassign)
+		    options="--comment --no-comment"
+		    ;;
+		edit)
+		    options="--comment --no-comment --silent"
+		    ;;
+	    esac
+	fi
+	
+	# let ditz parse the commandline and print available completions, then append the options form above
+	COMPREPLY=( $( compgen -W "$(ditz "${COMP_WORDS[@]}" '<options>' 2>/dev/null) $options" -- $cur ) )
+    fi 
+}
+
+complete -F _ditz -o default ditz

data/lib/ditz/file-storage.rb

@@ -0,0 +1,53 @@
+module Ditz
+
+## stores ditz database on disk
+class FileStorage
+  PROJECT_FN = "project.yaml"
+  ISSUE_FN_GLOB = "issue-*.yaml"
+
+  def ISSUE_TO_FN i; "issue-#{i.id}.yaml" end
+
+  def initialize base_dir
+    @base_dir = base_dir
+    @project_fn = File.join @base_dir, PROJECT_FN
+  end
+
+  def load
+    Ditz::debug "loading project from #{@project_fn}"
+    project = Project.from @project_fn
+
+    fn = File.join @base_dir, ISSUE_FN_GLOB
+    Ditz::debug "loading issues from #{fn}"
+    project.issues = Dir[fn].map { |fn| Issue.from fn }
+    Ditz::debug "found #{project.issues.size} issues"
+
+    project.issues.each { |i| i.project = project }
+    project
+  end
+
+  def save project
+    dirty = project.each_modelobject { |o| break true if o.changed? }
+    if dirty
+      Ditz::debug "project is dirty, saving #{@project_fn}"
+      project.save! @project_fn
+    end
+
+    changed_issues = project.issues.select { |i| i.changed? }
+    changed_issues.each do |i|
+      fn = filename_for_issue i
+      Ditz::debug "issue #{i.name} is dirty, saving #{fn}"
+      i.save! fn
+    end
+
+    project.deleted_issues.each do |i|
+      fn = filename_for_issue i
+      Ditz::debug "issue #{i.name} has been deleted, deleting #{fn}"
+      FileUtils.rm fn
+    end
+  end
+
+  def filename_for_issue i; File.join @base_dir, ISSUE_TO_FN(i) end
+  def filename_for_project; @project_fn end
+end
+
+end

data/lib/ditz/hook.rb

@@ -0,0 +1,67 @@
+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?
+        dirs = [Ditz::home_dir, Ditz::find_dir_containing(".ditz")].compact.map do |d|
+          File.join d, ".ditz", "hooks"
+        end
+        Ditz::debug "looking for hooks in #{dirs.join(" and ")}"
+        files = dirs.map { |d| Dir[File.join(d, "*.rb")] }.flatten
+        files.each do |fn|
+          Ditz::debug "loading hook file #{fn}"
+          require File.expand_path(fn)
+        end
+      end
+
+      @blocks[name] || []
+    end
+  end
+end

data/lib/ditz/html.rb

@@ -0,0 +1,107 @@
+require 'erb'
+
+module Ditz
+
+## pass through any variables needed for template generation, and add a bunch
+## of HTML formatting utility methods.
+class ErbHtml
+  def initialize template_dir, links, binding={}
+    @template_dir = template_dir
+    @links = links
+    @binding = binding
+  end
+
+  ## return an ErbHtml object that has the current binding plus extra_binding merged in
+  def clone_for_binding extra_binding={}
+    extra_binding.empty? ? self : ErbHtml.new(@template_dir, @links, @binding.merge(extra_binding))
+  end
+
+  def render_template template_name, extra_binding={}
+    if extra_binding.empty?
+      @@erbs ||= {}
+      @@erbs[template_name] ||= ERB.new IO.read(File.join(@template_dir, "#{template_name}.rhtml"))
+      @@erbs[template_name].result binding
+    else
+      clone_for_binding(extra_binding).render_template template_name
+    end
+  end
+
+  def render_string s, extra_binding={}
+    if extra_binding.empty?
+      ERB.new(s).result binding
+    else
+      clone_for_binding(extra_binding).render_string s
+    end
+  end
+
+  ###
+  ### the following methods are meant to be called from the ERB itself
+  ###
+
+  def h o; o.to_s.gsub("&", "&amp;").gsub("<", "&lt;").gsub(">", "&gt;") end
+  def t o; o.strftime "%Y-%m-%d %H:%M %Z" end
+  def p o; "<p>" + h(o.to_s).gsub("\n\n", "</p><p>") + "</p>" end
+  def obscured_email e; h e.gsub(/@.*?(>|$)/, "@...\\1") end
+  def link_to o, name
+    dest = @links[o]
+    dest = o if dest.nil? && o.is_a?(String)
+    raise ArgumentError, "no link for #{o.inspect}" unless dest
+    "<a href=\"#{dest}\">#{name}</a>"
+  end
+
+  def issue_status_img_for i, opts={}
+    fn, title = if i.closed?
+      case i.disposition
+      when :fixed; ["green-check.png", "fixed"]
+      when :wontfix; ["red-check.png", "won't fix"]
+      when :reorg; ["blue-check.png", "reorganized"]
+      end
+    elsif i.in_progress?
+      ["green-bar.png", "in progress"]
+    elsif i.paused?
+      ["yellow-bar.png", "paused"]
+    end
+
+    return "" unless fn
+
+    args = {:src => fn, :alt => title, :title => title}
+    args[:class] = opts[:class] if opts[:class]
+
+    "<img " + args.map { |k, v| "#{k}=#{v.inspect}" }.join(" ") + "/>"
+  end
+
+  def issue_link_for i, opts={}
+    link = if opts[:inline]
+      "<span class=\"inline-issue-link\">" + link_to(i, "issue <span class=\"id\">#{i.id[0,8]}</span>: #{i.title}") + "</span>"
+    else
+      link_to i, i.title
+    end
+    link = link + " " + issue_status_img_for(i, :class => "inline-status-image") if opts[:status_image]
+    link
+  end
+
+  def link_issue_names project, s, opts={}
+    project.issues.inject(s) do |s, i|
+      s.gsub(/\b#{i.name}\b/, issue_link_for(i, {:inline => true, :status_image => true}.merge(opts)))
+    end
+  end
+
+  def progress_meter p, size=50
+    done = (p * size).to_i
+    undone = [size - done, 0].max
+    "<span class='progress-meter'><span class='progress-meter-done'>" +
+      ("&nbsp;" * done) +
+      "</span><span class='progress-meter-undone'>" +
+      ("&nbsp;" * undone) +
+      "</span></span>"
+  end
+
+  ## render a nested ERB
+  alias :render :render_template
+
+  def method_missing meth, *a
+    @binding.member?(meth) ? @binding[meth] : super
+  end
+end
+
+end