ursm-ditz 0.4

data/lib/model-objects.rb

@@ -0,0 +1,314 @@
+require 'model'
+
+module Ditz
+
+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
+
+  attr_accessor :pathname
+
+  field :name, :default_generator => lambda { File.basename(Dir.pwd) }
+  field :version, :default => Ditz::VERSION, :ask => false
+  field :components, :multi => true, :generator => :get_components
+  field :releases, :multi => true, :ask => false
+
+  ## issues are not model fields proper, so we build up their interface here.
+  attr_accessor :issues
+  def add_issue issue; added_issues << issue; issues << issue end
+  def drop_issue issue; deleted_issues << issue if issues.delete issue 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 =~ /^#{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
+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 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
+    what = []
+    if title != hash[:title]
+      what << "changed title"
+      self.title = hash[:title]
+    end
+
+    if desc != hash[:description]
+      what << "changed description"
+      self.desc = hash[:description]
+    end
+
+    if reporter != hash[:reporter]
+      what << "changed reporter"
+      self.reporter = hash[:reporter]
+    end
+
+    unless what.empty?
+      log what.join(", "), who, comment
+      true
+    end
+  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, :ask => false, :default => "bugs"
+
+  def user; "#{name} <#{email}>" end
+
+  def get_default_name
+    require 'etc'
+
+    name = Etc.getpwnam(ENV["USER"])
+    name = name ? name.gecos.split(/,/).first : ""
+  end
+
+  def get_default_email
+    require 'socket'
+    email = (ENV["USER"] || "") + "@" +
+      begin
+        Socket.gethostbyname(Socket.gethostname).first
+      rescue SocketError
+        Socket.gethostname
+      end
+  end
+end
+
+end

data/lib/model.rb

@@ -0,0 +1,208 @@
+require 'yaml'
+require 'sha1'
+require "lowline"; include Lowline
+require "util"
+
+class Time
+  alias :old_to_yaml :to_yaml
+  def to_yaml(opts = {})
+    self.utc.old_to_yaml(opts)
+  end
+end
+
+module Ditz
+
+class ModelObject
+  class ModelError < StandardError; end
+
+  def initialize
+    @values = {}
+    @serialized_values = {}
+    self.class.fields.map { |f, opts| @values[f] = [] if opts[:multi] }
+  end
+
+  ## yamlability
+  def self.yaml_domain; "ditz.rubyforge.org,2008-03-06" end
+  def self.yaml_other_thing; name.split('::').last.dcfirst end
+  def to_yaml_type; "!#{self.class.yaml_domain}/#{self.class.yaml_other_thing}" end
+  def self.inherited subclass
+    YAML.add_domain_type(yaml_domain, subclass.yaml_other_thing) do |type, val|
+      o = subclass.new
+      val.each do |k, v|
+        m = "__serialized_#{k}="
+        if o.respond_to? m
+          o.send m, v
+        else
+          $stderr.puts "warning: unknown field #{k.inspect} in YAML for #{type}; ignoring"
+        end
+      end
+      o.unchanged!
+      o
+    end
+  end
+
+  ## override these two to model per-field transformations between disk and
+  ## memory.
+  ##
+  ## convert disk form => memory form
+  def deserialized_form_of field, value
+    @serialized_values[field]
+  end
+
+  ## convert memory form => disk form
+  def serialized_form_of field, value
+    @values[field]
+  end
+
+  ## add a new field to a model object
+  def self.field name, opts={}
+    @fields ||= [] # can't use a hash because we need to preserve field order
+    raise ModelError, "field with name #{name} already defined" if @fields.any? { |k, v| k == name }
+    @fields << [name, opts]
+
+    if opts[:multi]
+      single_name = name.to_s.sub(/s$/, "") # oh yeah
+      define_method "add_#{single_name}" do |obj|
+        array = send(name)
+        raise ModelError, "already has a #{single_name} with name #{obj.name.inspect}" if obj.respond_to?(:name) && array.any? { |o| o.name == obj.name }
+        changed!
+        @serialized_values.delete name
+        array << obj
+      end
+
+      define_method "drop_#{single_name}" do |obj|
+        return unless @values[name].delete obj
+        @serialized_values.delete name
+        changed!
+        obj
+      end
+    end
+
+    define_method "#{name}=" do |o|
+      changed!
+      @serialized_values.delete name
+      @values[name] = o
+    end
+
+    define_method "__serialized_#{name}=" do |o|
+      changed!
+      @values.delete name
+      @serialized_values[name] = o
+    end
+
+    define_method name do
+      return @values[name] if @values.member?(name)
+      @values[name] = deserialized_form_of name, @serialized_values[name]
+    end
+  end
+
+  def self.field_names; @fields.map { |name, opts| name } end
+  class << self
+    attr_reader :fields, :values, :serialized_values
+  end
+
+  def self.changes_are_logged
+    define_method(:changes_are_logged?) { true }
+    field :log_events, :multi => true, :ask => false
+  end
+
+  def self.from fn
+    returning YAML::load_file(fn) do |o|
+      raise ModelError, "error loading from yaml file #{fn.inspect}: expected a #{self}, got a #{o.class}" unless o.class == self
+      o.pathname = fn if o.respond_to? :pathname=
+    end
+  end
+
+  def to_s
+    "<#{self.class.name}: " + self.class.field_names.map { |f| "#{f}: " + (@values[f].to_s || @serialized_values[f]).inspect }.join(", ") + ">"
+  end
+
+  def inspect; to_s end
+
+  ## depth-first search on all reachable ModelObjects. fuck yeah.
+  def each_modelobject
+    seen = {}
+    to_see = [self]
+    until to_see.empty?
+      cur = to_see.pop
+      seen[cur] = true
+      yield cur
+      cur.class.field_names.each do |f|
+        val = cur.send(f)
+        next if seen[val]
+        if val.is_a?(ModelObject)
+          to_see.push val
+        elsif val.is_a?(Array)
+          to_see += val.select { |v| v.is_a?(ModelObject) }
+        end
+      end
+    end
+  end
+
+  def save! fn
+    #FileUtils.mv fn, "#{fn}~", :force => true rescue nil
+    File.open(fn, "w") { |f| f.puts to_yaml }
+    self
+  end
+
+  def to_yaml opts={}
+    ret = YAML::quick_emit(object_id, opts) do |out|
+      out.map(taguri, nil) do |map|
+        self.class.fields.each do |f, fops|
+          v = if @serialized_values.member?(f)
+            @serialized_values[f]
+          else
+            @serialized_values[f] = serialized_form_of f, @values[f]
+          end
+
+          map.add f.to_s, v
+        end
+      end
+    end
+    ret.decode
+  end
+
+  def log what, who, comment
+    add_log_event([Time.now, who, what, comment || ""])
+    self
+  end
+
+  def changed?; @changed ||= false end
+  def changed!; @changed = true end
+  def unchanged!; @changed = false end
+
+  def self.create_interactively opts={}
+    o = self.new
+    args = opts[:args] || []
+    @fields.each do |name, field_opts|
+      val = if opts[:with] && opts[:with][name]
+        opts[:with][name]
+      elsif field_opts[:generator].is_a? Proc
+        field_opts[:generator].call(*args)
+      elsif field_opts[:generator]
+        o.send field_opts[:generator], *args
+      elsif field_opts[:ask] == false # nil counts as true here
+        field_opts[:default] || (field_opts[:multi] ? [] : nil)
+      else
+        q = field_opts[:prompt] || name.to_s.capitalize
+        if field_opts[:multiline]
+          ask_multiline q
+        else
+          default = if field_opts[:default_generator].is_a? Proc
+            field_opts[:default_generator].call(*args)
+          elsif field_opts[:default_generator]
+            o.send field_opts[:default_generator], *args
+          elsif field_opts[:default]
+            field_opts[:default]
+          end
+            
+          ask q, :default => default
+        end
+      end
+      o.send("#{name}=", val)
+    end
+    o
+  end
+end
+
+end