ursm-ditz 0.4 → 0.5

data/lib/ditz/model.rb

@@ -0,0 +1,321 @@
+require 'yaml'
+require "yaml_waml"
+require 'sha1'
+require "ditz/lowline"; include Lowline
+require "ditz/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.class.fields.each do |f, opts|
+        m = "__serialized_#{f}"
+        if opts[:multi] && o.send(m).nil?
+          o.send(m + '=', [])
+        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
+    value
+  end
+
+  ## convert memory form => disk form
+  def serialized_form_of field, value
+    value
+  end
+
+  ## Add a field to a model object
+  ##
+  ## The options you specify here determine how the field is populated when an
+  ## instance of this object is created. Objects can be created interactively,
+  ## with #create_interactively, or non-interactively, with #create, and the
+  ## creation mode, combined with these options, determine how the field is
+  ## populated on a new model object.
+  ##
+  ## The default behavior is to simply prompt the user with the field name when
+  ## in interactive mode, and to raise an exception if the value is not passed
+  ## to #create in non-interactive mode.
+  ##
+  ## Options:
+  ##   :interactive_generator => a method name or Proc that will be called to
+  ##     return the value of this field, if the model object is created
+  ##     interactively.
+  ##   :generator => a method name or Proc that will be called to return the
+  ##     value of this field. If the model object is created interactively, and
+  ##     a :interactive_generator option is specified, that will be used instead.
+  ##   :multi => a boolean determining whether the field has multiple values,
+  ##     i.e., is an array. If created with :ask => false, will be initialized
+  ##     to [] instead of to nil. Additionally, the model object will have
+  ##     #add_<field> and #drop_<field> methods.
+  ##   :ask => a boolean determining whether, if the model object is created
+  ##     interactively, the user will be prompted for the value of this field.
+  ##     TRUE BY DEFAULT. If :interactive_generator or :generator are specified,
+  ##     those will be called instead.
+  ##
+  ##     If this is true, non-interactive creation
+  ##     will raise an exception unless the field value is passed as an argument.
+  ##     If this is false, non-interactive creation will initialize this to nil
+  ##     (or [] if this field is additionally marked :multi) unless the value is
+  ##     passed as an argument.
+  ##  :prompt => a string to display to the user when prompting for the field
+  ##    value during interactive creation. Not used if :generator or
+  ##    :interactive_generator is specified.
+  ##  :multiline => a boolean determining whether to prompt the user for a
+  ##    multiline answer during interactive creation. Default false. Not used
+  ##    if :generator or :interactive_generator is specified.
+  ##  :default => a default value when prompting for the field value during
+  ##    interactive creation. Not used if :generator, :interactive_generator,
+  ##    :multiline, or :default_generator is specified.
+  ##  :default_generator => a method name or Proc which will be called to
+  ##    generate the default value when prompting for the field value during
+  ##    interactive creation. Not used if :generator, :interactive_generator,
+  ##    or :multiline is specified.
+  ##  :nil_ok => a boolean determining whether, if created in non-interactive
+  ##    mode and the value for this field is not passed in, (or is passed in
+  ##    as nil), that's ok. Default is false. This is not necessary if :ask =>
+  ##    false is specified; it's only necessary for fields that you want an
+  ##    interactive prompt for, but a nil value is fine.
+  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 send(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 "__serialized_#{name}" do
+      @serialized_values[name]
+    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}: " + send(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
+    YamlWaml.decode(ret)
+  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
+
+  class << self
+    ## creates the object, prompting the user when necessary. can take
+    ## a :with => { hash } parameter for pre-filling model fields.
+    ##
+    ## can also take a :defaults_from => obj parameter for pre-filling model
+    ## fields from another object with (some of) those fields. kinda like a
+    ## bizarre interactive copy constructor.
+    def create_interactively opts={}
+      o = self.new
+      generator_args = opts[:args] || []
+      @fields.each do |name, field_opts|
+        val = if opts[:with] && opts[:with][name]
+          opts[:with][name]
+        elsif(found, v = generate_field_value(o, field_opts, generator_args, :interactive => true)) && found
+          v
+        else
+          q = field_opts[:prompt] || name.to_s.capitalize
+          if field_opts[:multiline]
+            ## multiline options currently aren't allowed to have a default
+            ## value, so just ask.
+            ask_multiline_smartly q
+          else
+            default = if opts[:defaults_from] && opts[:defaults_from].respond_to?(name) && (x = opts[:defaults_from].send(name))
+              x
+            else
+              default = generate_field_default o, field_opts, generator_args
+            end
+            ask q, :default => default
+          end
+        end
+        o.send "#{name}=", val
+      end
+      o
+    end
+
+    ## creates the object, filling in fields from 'vals', and throwing a
+    ## ModelError when it can't find all the requisite fields
+    def create vals={}, generator_args=[]
+      o = self.new
+      @fields.each do |fname, fopts|
+        val = if(x = vals[fname] || vals[fname.to_s])
+          x
+        elsif(found, x = generate_field_value(o, fopts, generator_args, :interactive => false)) && found
+          x
+        elsif !fopts[:nil_ok]
+          raise ModelError, "missing required field #{fname.inspect} on #{self.name} object (got #{vals.keys.inspect})"
+        end
+        o.send "#{fname}=", val if val
+      end
+      o
+    end
+
+  private
+
+    ## get the value for a field if it can be automatically determined
+    ## returns [success, value] (because a successful value can be nil)
+    def generate_field_value o, field_opts, args, opts={}
+      gen = if opts[:interactive]
+        field_opts[:interactive_generator] || field_opts[:generator]
+      else
+        field_opts[:generator]
+      end
+
+      if gen.is_a? Proc
+        [true, gen.call(*args)]
+      elsif gen
+        [true, o.send(gen, *args)]
+      elsif field_opts[:ask] == false # nil counts as true here
+        [true, field_opts[:default] || (field_opts[:multi] ? [] : nil)]
+      else
+        [false, nil]
+      end
+    end
+
+    def generate_field_default o, field_opts, args
+      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
+    end
+  end
+end
+
+end

data/lib/{operator.rb → ditz/operator.rb}

@@ -134,8 +134,9 @@ class Operator
     if opts[:cow]
       puts "MOO!"
       puts "All is well with the world now. A bit more methane though."
-      exit 0
+      return
     end
+    run_pager
     return help_single(command) if command
     puts <<EOS
 Ditz commands:
@@ -170,14 +171,35 @@ Usage: ditz #{name} #{args}
 EOS
   end
 
-  operation :add, "Add an issue"
-  def add project, config
+  ## gets a comment from the user, assuming the standard argument setup
+  def get_comment opts
+    comment = if opts[:no_comment]
+      nil
+    elsif opts[:comment]
+      opts[:comment]
+    else
+      ask_multiline_smartly "Comments"
+    end
+  end
+  private :get_comment
+
+  operation :reconfigure, "Rerun configuration script"
+  def reconfigure project, config
+    new_config = Config.create_interactively :defaults_from => config
+    new_config.save! $opts[:config_file]
+    puts "Configuration written."
+  end
+
+  operation :add, "Add an issue" do
+    opt :comment, "Specify a comment", :short => 'm', :type => String
+    opt :no_comment, "Skip asking for a comment", :default => false
+  end
+  def add project, config, opts
     issue = Issue.create_interactively(:args => [config, project]) or return
-    comment = ask_multiline "Comments" unless $opts[:no_comment]
-    issue.log "created", config.user, comment
+    issue.log "created", config.user, get_comment(opts)
     project.add_issue issue
     project.assign_issue_names!
-    puts "Added issue #{issue.name}."
+    puts "Added issue #{issue.name} (#{issue.id})."
   end
 
   operation :drop, "Drop an issue", :issue
@@ -186,12 +208,14 @@ EOS
     puts "Dropped #{issue.name}. Note that other issue names may have changed."
   end
 
-  operation :add_release, "Add a release", :maybe_name
-  def add_release project, config, maybe_name
+  operation :add_release, "Add a release", :maybe_name do
+    opt :comment, "Specify a comment", :short => 'm', :type => String
+    opt :no_comment, "Skip asking for a comment", :default => false
+  end
+  def add_release project, config, opts, maybe_name
     puts "Adding release #{maybe_name}." if maybe_name
     release = Release.create_interactively(:args => [project, config], :with => { :name => maybe_name }) or return
-    comment = ask_multiline "Comments" unless $opts[:no_comment]
-    release.log "created", config.user, comment
+    release.log "created", config.user, get_comment(opts)
     project.add_release release
     puts "Added release #{release.name}."
   end
@@ -203,18 +227,21 @@ EOS
     puts "Added component #{component.name}."
   end
 
-  operation :add_reference, "Add a reference to an issue", :issue
-  def add_reference project, config, issue
+  operation :add_reference, "Add a reference to an issue", :issue do
+    opt :comment, "Specify a comment", :short => 'm', :type => String
+    opt :no_comment, "Skip asking for a comment", :default => false
+  end
+  def add_reference project, config, opts, issue
     puts "Adding a reference to #{issue.name}: #{issue.title}."
     reference = ask "Reference"
-    comment = ask_multiline "Comments" unless $opts[:no_comment]
     issue.add_reference reference
-    issue.log "added reference #{issue.references.size}", config.user, comment
+    issue.log "added reference #{issue.references.size}", config.user, get_comment(opts)
     puts "Added reference to #{issue.name}."
   end
 
   operation :status, "Show project status", :maybe_release
   def status project, config, releases
+    run_pager
     releases ||= project.unreleased_releases + [:unassigned]
 
     if releases.empty?
@@ -233,7 +260,9 @@ EOS
         "%2d/%2d %s" % [nc, num, type.to_s.pluralize(num, false)]
       end
 
-      bar = if r != :unassigned && r.released?
+      bar = if r == :unassigned
+        ""
+      elsif r.released?
         "(released)"
       elsif issues.empty?
         "(no issues)"
@@ -273,23 +302,25 @@ EOS
       join
   end
 
-  def todo_list_for issues
+  def todo_list_for issues, opts={}
     return if issues.empty?
     name_len = issues.max_of { |i| i.name.length }
     issues.map do |i|
-      sprintf "%s %#{name_len}s: %s\n", i.status_widget, i.name, i.title
+      s = sprintf "%s %#{name_len}s: %s", i.status_widget, i.name, i.title
+      s += " [#{i.release}]" if opts[:show_release] && i.release
+      s + "\n"
     end.join
   end
 
   def print_todo_list_by_release_for project, issues
     by_release = issues.inject({}) do |h, i|
-      r = project.release_for i.release
+      r = project.release_for(i.release) || :unassigned
       h[r] ||= []
       h[r] << i
       h
     end
 
-    project.releases.each do |r|
+    (project.releases + [:unassigned]).each do |r|
       next unless by_release.member? r
       puts r == :unassigned ? "Unassigned:" : "#{r.name} (#{r.status}):"
       print todo_list_for(by_release[r])
@@ -297,17 +328,15 @@ EOS
     end
   end
 
-  operation :todo, "Generate todo list", :maybe_release
-  def todo project, config, releases
-    actually_do_todo project, config, releases, false
+  operation :todo, "Generate todo list", :maybe_release do
+    opt :all, "Show all issues, included completed ones", :default => false
   end
-
-  operation :todo_full, "Generate full todo list, including completed items", :maybe_release
-  def todo_full project, config, releases
-    actually_do_todo project, config, releases, true
+  def todo project, config, opts, releases
+    actually_do_todo project, config, releases, opts[:all]
   end
 
   def actually_do_todo project, config, releases, full
+    run_pager
     releases ||= project.unreleased_releases + [:unassigned]
     releases = [*releases]
     releases.each do |r|
@@ -324,33 +353,42 @@ EOS
     ScreenView.new(project, config).render_issue issue
   end
 
-  operation :start, "Start work on an issue", :unstarted_issue
-  def start project, config, issue
+  operation :start, "Start work on an issue", :unstarted_issue do
+    opt :comment, "Specify a comment", :short => 'm', :type => String
+    opt :no_comment, "Skip asking for a comment", :default => false
+  end
+  def start project, config, opts, issue
     puts "Starting work on issue #{issue.name}: #{issue.title}."
-    comment = ask_multiline "Comments" unless $opts[:no_comment]
-    issue.start_work config.user, comment
+    issue.start_work config.user, get_comment(opts)
     puts "Recorded start of work for #{issue.name}."
   end
 
-  operation :stop, "Stop work on an issue", :started_issue
-  def stop project, config, issue
+  operation :stop, "Stop work on an issue", :started_issue do
+    opt :comment, "Specify a comment", :short => 'm', :type => String
+    opt :no_comment, "Skip asking for a comment", :default => false
+  end
+  def stop project, config, opts, issue
     puts "Stopping work on issue #{issue.name}: #{issue.title}."
-    comment = ask_multiline "Comments" unless $opts[:no_comment]
-    issue.stop_work config.user, comment
+    issue.stop_work config.user, get_comment(opts)
     puts "Recorded work stop for #{issue.name}."
   end
 
-  operation :close, "Close an issue", :open_issue
-  def close project, config, issue
+  operation :close, "Close an issue", :open_issue do
+    opt :comment, "Specify a comment", :short => 'm', :type => String
+    opt :no_comment, "Skip asking for a comment", :default => false
+  end
+  def close project, config, opts, issue
     puts "Closing issue #{issue.name}: #{issue.title}."
     disp = ask_for_selection Issue::DISPOSITIONS, "disposition", lambda { |x| Issue::DISPOSITION_STRINGS[x] || x.to_s }
-    comment = ask_multiline "Comments" unless $opts[:no_comment]
-    issue.close disp, config.user, comment
+    issue.close disp, config.user, get_comment(opts)
     puts "Closed issue #{issue.name} with disposition #{issue.disposition_string}."
   end
 
-  operation :assign, "Assign an issue to a release", :issue, :maybe_release
-  def assign project, config, issue, maybe_release
+  operation :assign, "Assign an issue to a release", :issue, :maybe_release do
+    opt :comment, "Specify a comment", :short => 'm', :type => String
+    opt :no_comment, "Skip asking for a comment", :default => false
+  end
+  def assign project, config, opts, issue, maybe_release
     if maybe_release && maybe_release.name == issue.release
       raise Error, "issue #{issue.name} already assigned to release #{issue.release}"
     end
@@ -361,8 +399,6 @@ EOS
       "not assigned to any release."
     end
 
-    puts "Assigning to release #{maybe_release.name}." if maybe_release
-
     release = maybe_release || begin
       releases = project.releases.sort_by { |r| (r.release_time || 0).to_i }
       releases -= [releases.find { |r| r.name == issue.release }] if issue.release
@@ -374,13 +410,15 @@ EOS
         end
       end
     end
-    comment = ask_multiline "Comments" unless $opts[:no_comment]
-    issue.assign_to_release release, config.user, comment
+    issue.assign_to_release release, config.user, get_comment(opts)
     puts "Assigned #{issue.name} to #{release.name}."
   end
 
-  operation :set_component, "Set an issue's component", :issue, :maybe_component
-  def set_component project, config, issue, maybe_component
+  operation :set_component, "Set an issue's component", :issue, :maybe_component do
+    opt :comment, "Specify a comment", :short => 'm', :type => String
+    opt :no_comment, "Skip asking for a comment", :default => false
+  end
+  def set_component project, config, opts, issue, maybe_component
     puts "Changing the component of issue #{issue.name}: #{issue.title}."
 
     if project.components.size == 1
@@ -396,8 +434,7 @@ EOS
       components -= [components.find { |r| r.name == issue.component }] if issue.component
       ask_for_selection(components, "component") { |r| r.name }
     end
-    comment = ask_multiline "Comments" unless $opts[:no_comment]
-    issue.assign_to_component component, config.user, comment
+    issue.assign_to_component component, config.user, get_comment(opts)
     oldname = issue.name
     project.assign_issue_names!
     puts <<EOS
@@ -406,18 +443,23 @@ have changed as well.
 EOS
   end
 
-  operation :unassign, "Unassign an issue from any releases", :assigned_issue
-  def unassign project, config, issue
+  operation :unassign, "Unassign an issue from any releases", :assigned_issue do
+    opt :comment, "Specify a comment", :short => 'm', :type => String
+    opt :no_comment, "Skip asking for a comment", :default => false
+  end
+  def unassign project, config, opts, issue
     puts "Unassigning issue #{issue.name}: #{issue.title}."
-    comment = ask_multiline "Comments" unless $opts[:no_comment]
-    issue.unassign config.user, comment
+    issue.unassign config.user, get_comment(opts)
     puts "Unassigned #{issue.name}."
   end
 
-  operation :comment, "Comment on an issue", :issue
-  def comment project, config, issue
+  operation :comment, "Comment on an issue", :issue do
+    opt :comment, "Specify a comment", :short => 'm', :type => String
+    opt :no_comment, "Skip asking for a comment", :default => false
+  end
+  def comment project, config, opts, issue
     puts "Commenting on issue #{issue.name}: #{issue.title}."
-    comment = ask_multiline "Comments"
+    comment = get_comment opts
     if comment.blank?
       puts "Empty comment, aborted."
     else
@@ -428,6 +470,7 @@ EOS
 
   operation :releases, "Show releases"
   def releases project, config
+    run_pager
     a, b = project.releases.partition { |r| r.released? }
     (b + a.sort_by { |r| r.release_time }).each do |r|
       status = r.released? ? "released #{r.release_time.pretty_date}" : r.status
@@ -435,15 +478,18 @@ EOS
     end
   end
 
-  operation :release, "Release a release", :unreleased_release
-  def release project, config, release
-    comment = ask_multiline "Comments" unless $opts[:no_comment]
-    release.release! project, config.user, comment
+  operation :release, "Release a release", :unreleased_release do
+    opt :comment, "Specify a comment", :short => 'm', :type => String
+    opt :no_comment, "Skip asking for a comment", :default => false
+  end
+  def release project, config, opts, release
+    release.release! project, config.user, get_comment(opts)
     puts "Release #{release.name} released!"
   end
 
   operation :changelog, "Generate a changelog for a release", :release
   def changelog project, config, r
+    run_pager
     puts "== #{r.name} / #{r.released? ? r.release_time.pretty_date : 'unreleased'}"
     project.group_issues(project.issues_for_release(r)).each do |type, issues|
       issues.select { |i| i.closed? }.each do |i|
@@ -467,9 +513,13 @@ EOS
     ## a no-op
   end
 
-  operation :grep, "Show issues matching a string or regular expression", :string
-  def grep project, config, match
-    re = /#{match}/
+  operation :grep, "Show issues matching a string or regular expression", :string do
+    opt :ignore_case, "Ignore case distinctions in both the expression and in the issue data", :default => false
+  end
+
+  def grep project, config, opts, match
+    run_pager
+    re = Regexp.new match, opts[:ignore_case]
     issues = project.issues.select do |i|
       i.title =~ re || i.desc =~ re ||
         i.log_events.map { |time, who, what, comments| comments }.join(" ") =~ re
@@ -479,6 +529,7 @@ EOS
 
   operation :log, "Show recent activity"
   def log project, config
+    run_pager
     project.issues.map { |i| i.log_events.map { |e| [e, i] } }.
       flatten_one_level.sort_by { |e| e.first.first }.reverse.
       each do |(date, author, what, comment), i|
@@ -496,6 +547,7 @@ EOS
 
   operation :shortlog, "Show recent activity (short form)"
   def shortlog project, config
+    run_pager
     project.issues.map { |i| i.log_events.map { |e| [e, i] } }.
       flatten_one_level.sort_by { |e| e.first.first }.reverse.
       each do |(date, author, what, comment), i|
@@ -521,8 +573,12 @@ EOS
     puts "Archived to #{dir}."
   end
 
-  operation :edit, "Edit an issue", :issue
-  def edit project, config, issue
+  operation :edit, "Edit an issue", :issue do
+    opt :comment, "Specify a comment", :short => 'm', :type => String
+    opt :no_comment, "Skip asking for a comment", :default => false
+    opt :silent, "Don't add a log message detailing the change", :default => false
+  end
+  def edit project, config, opts, issue
     data = { :title => issue.title, :description => issue.desc,
              :reporter => issue.reporter }
 
@@ -533,11 +589,10 @@ EOS
       return
     end
 
-    comment = ask_multiline "Comments" unless $opts[:no_comment]
-
     begin
       edits = YAML.load_file fn
-      if issue.change edits, config.user, comment
+      comment = opts[:silent] ? nil : get_comment(opts)
+      if issue.change edits, config.user, comment, opts[:silent]
         puts "Change recorded."
       else
         puts "No changes."