ditz-str 0.0.1

data/lib/ditzstr/hook.rb

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

data/lib/ditzstr/html.rb

@@ -0,0 +1,104 @@
+require 'erb'
+
+module DitzStr
+
+## 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 = link_to i, "#{i.title}"
+    link = "<span class=\"inline-issue-link\">" + link + "</span>" if opts[:inline]
+    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

data/lib/ditzstr/lowline.rb

@@ -0,0 +1,201 @@
+require 'tempfile'
+require "ditzstr/util"
+
+class Numeric
+  def to_pretty_s
+    %w(zero one two three four five six seven eight nine ten)[self] || to_s
+  end
+end
+
+class String
+  def dcfirst; self[0..0].downcase + self[1..-1] end
+  def blank?; self =~ /\A\s*\z/ end
+  def underline; self + "\n" + ("-" * self.length) end
+  def pluralize n, b=true
+    s = (n == 1 ? self : (self == 'bugfix' ? 'bugfixes' : self + "s")) # oh yeah
+    b ? n.to_pretty_s + " " + s : s
+  end
+  def shortened_email; self =~ /<?(\S+?)@.+/ ? $1 : self end
+  def multistrip; strip.gsub(/\n\n+/, "\n\n") end
+end
+
+class Array
+  def listify prefix=""
+    return "" if empty?
+    "\n" +
+      map_with_index { |x, i| x.to_s.gsub(/^/, "#{prefix}#{i + 1}. ") }.
+        join("\n")
+  end
+end
+
+class Time
+  def pretty; strftime "%c" end
+  def pretty_date; strftime "%Y-%m-%d" end
+  def ago
+    diff = (Time.now - self).to_i.abs
+    if diff < 60
+      "second".pluralize diff
+    elsif diff < 60*60*3
+      "minute".pluralize(diff / 60)
+    elsif diff < 60*60*24*3
+      "hour".pluralize(diff / (60*60))
+    elsif diff < 60*60*24*7*2
+      "day".pluralize(diff / (60*60*24))
+    elsif diff < 60*60*24*7*8
+      "week".pluralize(diff / (60*60*24*7))
+    elsif diff < 60*60*24*7*52
+      "month".pluralize(diff / (60*60*24*7*4))
+    else
+      "year".pluralize(diff / (60*60*24*7*52))
+    end
+  end
+end
+
+module Lowline
+  def run_editor
+    f = Tempfile.new "ditz"
+    yield f
+    f.close
+
+    editor = ENV["EDITOR"] || "/usr/bin/vi"
+    cmd = "#{editor} #{f.path.inspect}"
+
+    mtime = File.mtime f.path
+    system cmd or raise Error, "cannot execute command: #{cmd.inspect}"
+
+    File.mtime(f.path) == mtime ? nil : f.path
+  end
+
+  def ask q, opts={}
+    default_s = case opts[:default]
+      when nil; nil
+      when ""; " (enter for none)"
+      else; " (enter for #{opts[:default].inspect})"
+    end
+
+    tail = case q
+      when /[:?]$/; " "
+      when /[:?]\s+$/; ""
+      else; ": "
+    end
+
+    while true
+      prompt = [q, default_s, tail].compact.join
+      if DitzStr::has_readline?
+        ans = Readline::readline(prompt)
+      else
+        print prompt
+        ans = STDIN.gets.strip
+      end
+      if opts[:default]
+        ans = opts[:default] if ans.blank?
+      else
+        next if ans.blank? && !opts[:empty_ok]
+      end
+      break ans unless (opts[:restrict] && ans !~ opts[:restrict])
+    end
+  end
+
+  def ask_via_editor q, default=nil
+    fn = run_editor do |f|
+      f.puts(default || "")
+      f.puts q.gsub(/^/, "## ")
+      f.puts "##"
+      f.puts "## Enter your text above. Lines starting with a '#' will be ignored."
+    end
+    return unless fn
+    IO.read(fn).gsub(/^#.*$/, "").multistrip
+  end
+
+  def ask_multiline q
+    puts "#{q} (ctrl-d, ., or /stop to stop, /edit to edit, /reset to reset):"
+    ans = ""
+    while true
+      if DitzStr::has_readline?
+        line = Readline::readline('> ')
+      else
+        (line = STDIN.gets) && line.strip!
+      end
+      if line
+        if DitzStr::has_readline?
+          Readline::HISTORY.push(line)
+        end
+        case line
+        when /^\.$/, "/stop"
+          break
+        when "/reset"
+          return ask_multiline(q)
+        when "/edit"
+          return ask_via_editor(q, ans)
+        else
+          ans << line + "\n"
+        end
+      else
+        puts
+        break
+      end
+    end
+    ans.multistrip
+  end
+
+  def ask_yon q
+    while true
+      print "#{q} (y/n): "
+      a = STDIN.gets.strip
+      break a if a =~ /^[yn]$/i
+    end =~ /y/i
+  end
+
+  def ask_for_many plural_name, name=nil
+    name ||= plural_name.gsub(/s$/, "")
+    stuff = []
+
+    while true
+      puts
+      puts "Current #{plural_name}:"
+      if stuff.empty?
+        puts "None!"
+      else
+        stuff.each_with_index { |c, i| puts "  #{i + 1}) #{c}" }
+      end
+      puts
+      ans = ask "(A)dd #{name}, (r)emove #{name}, or (d)one"
+      case ans
+      when "a", "A"
+        ans = ask "#{name.capitalize} name", ""
+        stuff << ans unless ans =~ /^\s*$/
+      when "r", "R"
+        ans = ask "Remove which #{name}? (1--#{stuff.size})"
+        stuff.delete_at(ans.to_i - 1) if ans
+      when "d", "D"
+        break
+      end
+    end
+    stuff
+  end
+
+  def ask_for_selection stuff, name, to_string=:to_s
+    puts "Choose a #{name}:"
+    stuff.each_with_index do |c, i|
+      pretty = case to_string
+      when block_given? && to_string # heh
+        yield c
+      when Symbol
+        c.send to_string
+      when Proc
+        to_string.call c
+      else
+        raise ArgumentError, "unknown to_string argument type; expecting Proc or Symbol"
+      end
+      puts "  #{i + 1}) #{pretty}"
+    end
+
+    j = while true
+      i = ask "#{name.capitalize} (1--#{stuff.size})"
+      break i.to_i if i && (1 .. stuff.size).member?(i.to_i)
+    end
+
+    stuff[j - 1]
+  end
+end
+

data/lib/ditzstr/model-objects.rb

@@ -0,0 +1,346 @@
+require 'ditzstr/model'
+
+module DitzStr
+
+class Component < ModelObject
+  field :name
+  def name_prefix; name.gsub(/\s+/, "-").downcase end
+end
+
+class Release < ModelObject
+  class Error < StandardError; end
+
+  field :name
+  field :status, :default => :unreleased, :ask => false
+  field :release_time, :ask => false
+  changes_are_logged
+
+  def released?; self.status == :released end
+  def unreleased?; !released? end
+
+  def issues_from project; project.issues.select { |i| i.release == name } end
+
+  def release! project, who, comment
+    raise Error, "already released" if released?
+
+    issues = issues_from project
+    bad = issues.find { |i| i.open? }
+    raise Error, "open issue #{bad.name} must be reassigned" if bad
+
+    self.release_time = Time.now
+    self.status = :released
+    log "released", who, comment
+  end
+end
+
+class Project < ModelObject
+  class Error < StandardError; end
+
+  field :name, :prompt => "Project name", :default_generator => lambda { File.basename(Dir.pwd) }
+  field :version, :default => DitzStr::VERSION, :ask => false
+  field :components, :multi => true, :generator => :get_components
+  field :releases, :multi => true, :ask => false
+
+  attr_accessor :pathname
+
+  ## issues are not model fields proper, so we build up their interface here.
+  attr_reader :issues
+  def issues= issues
+    @issues = issues
+    @issues.each { |i| i.project = self }
+    assign_issue_names!
+    issues
+  end
+
+  def add_issue issue
+    added_issues << issue
+    issues << issue
+    issue.project = self
+    assign_issue_names!
+    issue
+  end
+
+  def drop_issue issue
+    if issues.delete issue
+      deleted_issues << issue
+      assign_issue_names!
+    end
+  end
+
+  def added_issues; @added_issues ||= [] end
+  def deleted_issues; @deleted_issues ||= [] end
+
+  def get_components
+    puts <<EOS
+Issues can be tracked across the project as a whole, or the project can be
+split into components, and issues tracked separately for each component.
+EOS
+    use_components = ask_yon "Track issues separately for different components?"
+    comp_names = use_components ? ask_for_many("components") : []
+
+    ([name] + comp_names).uniq.map { |n| Component.create_interactively :with => { :name => n } }
+  end
+
+  def issues_for ident
+    by_name = issues.find { |i| i.name == ident }
+    by_name ? [by_name] : issues.select { |i| i.id =~ /^#{Regexp::escape ident}/ }
+  end
+
+  def component_for component_name
+    components.find { |i| i.name == component_name }
+  end
+
+  def release_for release_name
+    releases.find { |i| i.name == release_name }
+  end
+
+  def unreleased_releases; releases.select { |r| r.unreleased? } end
+
+  def issues_for_release release
+    release == :unassigned ? unassigned_issues : issues.select { |i| i.release == release.name }
+  end
+
+  def issues_for_component component
+    issues.select { |i| i.component == component.name }
+  end
+
+  def unassigned_issues
+    issues.select { |i| i.release.nil? }
+  end
+
+  def group_issues these_issues=issues
+    these_issues.group_by { |i| i.type }.sort_by { |(t,g)| Issue::TYPE_ORDER[t] }
+  end
+
+  def assign_issue_names!
+    prefixes = components.map { |c| [c.name, c.name.gsub(/^\s+/, "-").downcase] }.to_h
+    ids = components.map { |c| [c.name, 0] }.to_h
+    issues.sort_by { |i| i.creation_time }.each do |i|
+      i.name = "#{prefixes[i.component]}-#{ids[i.component] += 1}"
+    end
+  end
+
+  def validate!
+    if(dup = components.map { |c| c.name }.first_duplicate)
+      raise Error, "more than one component named #{dup.inspect}: #{components.inspect}"
+    elsif(dup = releases.map { |r| r.name }.first_duplicate)
+      raise Error, "more than one release named #{dup.inspect}"
+    end
+  end
+
+  def self.from *a
+    p = super(*a)
+    p.validate!
+    p
+  end
+end
+
+class Issue < ModelObject
+  class Error < StandardError; end
+
+  field :title
+  field :desc, :prompt => "Description", :multiline => true
+  field :type, :generator => :get_type
+  field :component, :generator => :get_component
+  field :release, :generator => :get_release
+  field :reporter, :prompt => "Issue creator", :default_generator => lambda { |config, proj| config.user }
+  field :status, :ask => false, :default => :unstarted
+  field :disposition, :ask => false
+  field :creation_time, :ask => false, :generator => lambda { Time.now }
+  field :references, :ask => false, :multi => true
+  field :id, :ask => false, :generator => :make_id
+  changes_are_logged
+
+  attr_accessor :name, :pathname, :project
+
+  ## these are the fields we interpolate issue names on
+  INTERPOLATED_FIELDS = [:title, :desc, :log_events]
+
+  STATUS_SORT_ORDER = { :unstarted => 2, :paused => 1, :in_progress => 0, :closed => 3 }
+  STATUS_WIDGET = { :unstarted => "_", :in_progress => ">", :paused => "=", :closed => "x" }
+  DISPOSITIONS = [ :fixed, :wontfix, :reorg ]
+  TYPES = [ :bugfix, :feature, :task ]
+  TYPE_ORDER = { :bugfix => 0, :feature => 1, :task => 2 }
+  TYPE_LETTER = { 'b' => :bugfix, 'f' => :feature, 't' => :task }
+  STATUSES = STATUS_WIDGET.keys
+
+  STATUS_STRINGS = { :in_progress => "in progress", :wontfix => "won't fix" }
+  DISPOSITION_STRINGS = { :wontfix => "won't fix", :reorg => "reorganized" }
+
+  def serialized_form_of field, value
+    return super unless INTERPOLATED_FIELDS.member? field
+
+    if field == :log_events
+      value.map do |time, who, what, comment|
+        comment = @project.issues.inject(comment) do |s, i|
+          s.gsub(/\b#{i.name}\b/, "{issue #{i.id}}")
+        end
+        [time, who, what, comment]
+      end
+    else
+      @project.issues.inject(value) do |s, i|
+        s.gsub(/\b#{i.name}\b/, "{issue #{i.id}}")
+      end
+    end
+  end
+
+  def deserialized_form_of field, value
+    return super unless INTERPOLATED_FIELDS.member? field
+
+    if field == :log_events
+      value.map do |time, who, what, comment|
+        comment = @project.issues.inject(comment) do |s, i|
+          s.gsub(/\{issue #{i.id}\}/, i.name)
+        end.gsub(/\{issue \w+\}/, "[unknown issue]")
+        [time, who, what, comment]
+      end
+    else
+      @project.issues.inject(value) do |s, i|
+        s.gsub(/\{issue #{i.id}\}/, i.name)
+      end.gsub(/\{issue \w+\}/, "[unknown issue]")
+    end
+  end
+
+  ## make a unique id
+  def make_id config, project
+    SHA1.hexdigest [Time.now, rand, creation_time, reporter, title, desc].join("\n")
+  end
+
+  def sort_order; [STATUS_SORT_ORDER[status], creation_time] end
+  def status_widget; STATUS_WIDGET[status] end
+
+  def status_string; STATUS_STRINGS[status] || status.to_s end
+  def disposition_string; DISPOSITION_STRINGS[disposition] || disposition.to_s end
+
+  def closed?; status == :closed end
+  def open?; !closed? end
+  def in_progress?; status == :in_progress end
+  def unstarted?; !in_progress? end
+  def bug?; type == :bugfix end
+  def feature?; type == :feature end
+  def unassigned?; release.nil? end
+  def assigned?; !unassigned? end
+  def paused?; status == :paused end
+
+  def start_work who, comment; change_status :in_progress, who, comment end
+  def stop_work who, comment
+    raise Error, "unstarted" unless self.status == :in_progress
+    change_status :paused, who, comment
+  end
+
+  def close disp, who, comment
+    raise Error, "unknown disposition #{disp}" unless DISPOSITIONS.member? disp
+    log "closed with disposition #{disp}", who, comment
+    self.status = :closed
+    self.disposition = disp
+  end
+
+  def change_status to, who, comment
+    raise Error, "unknown status #{to}" unless STATUSES.member? to
+    raise Error, "already marked as #{to}" if status == to
+    log "changed status from #{status} to #{to}", who, comment
+    self.status = to
+  end
+  private :change_status
+
+  def change hash, who, comment, silent
+    what = []
+    if title != hash[:title]
+      what << "title"
+      self.title = hash[:title]
+    end
+
+    if desc != hash[:description]
+      what << "description"
+      self.desc = hash[:description]
+    end
+
+    if reporter != hash[:reporter]
+      what << "reporter"
+      self.reporter = hash[:reporter]
+    end
+
+    unless what.empty? || silent
+      log "edited " + what.join(", "), who, comment
+      true
+    end
+
+    !what.empty?
+  end
+
+  def assign_to_release release, who, comment
+    log "assigned to release #{release.name} from #{self.release || 'unassigned'}", who, comment
+    self.release = release.name
+  end
+
+  def assign_to_component component, who, comment
+    log "assigned to component #{component.name} from #{self.component}", who, comment
+    self.component = component.name
+  end
+
+  def unassign who, comment
+    raise Error, "not assigned to a release" unless release
+    log "unassigned from release #{release}", who, comment
+    self.release = nil
+  end
+
+  def get_type config, project
+    type = ask "Is this a (b)ugfix, a (f)eature, or a (t)ask?", :restrict => /^[bft]$/
+    TYPE_LETTER[type]
+  end
+
+  def get_component config, project
+    if project.components.size == 1
+      project.components.first
+    else
+      ask_for_selection project.components, "component", :name
+    end.name
+  end
+
+  def get_release config, project
+    releases = project.releases.select { |r| r.unreleased? }
+    if !releases.empty? && ask_yon("Assign to a release now?")
+      if releases.size == 1
+        r = releases.first
+        puts "Assigning to release #{r.name}."
+        r
+      else
+        ask_for_selection releases, "release", :name
+      end.name
+    end
+  end
+
+  def get_reporter config, project
+    reporter = ask "Creator", :default => config.user
+  end
+end
+
+class Config < ModelObject
+  field :name, :prompt => "Your name", :default_generator => :get_default_name
+  field :email, :prompt => "Your email address", :default_generator => :get_default_email
+  field :issue_dir, :prompt => "Directory to store issues state in", :default => "bugs"
+
+  def user; "#{name} <#{email}>" end
+
+  def get_default_name
+    require 'etc'
+
+    name = if ENV["USER"]
+      pwent = Etc.getpwnam ENV["USER"]
+      pwent ? pwent.gecos.split(/,/).first : nil
+    end
+    name || "Ditz User"
+  end
+
+  def get_default_email
+    require 'socket'
+    email = (ENV["USER"] || "") + "@" +
+      begin
+        Socket.gethostbyname(Socket.gethostname).first
+      rescue SocketError
+        Socket.gethostname
+      end
+  end
+end
+
+end