sup 0.3 → 0.4

data/lib/sup/modes/label-search-results-mode.rb

@@ -9,7 +9,18 @@ class LabelSearchResultsMode < ThreadIndexMode
     super [], opts
   end
 
-  def is_relevant? m; @labels.all? { |l| m.has_label? l }; end
+  register_keymap do |k|
+    k.add :refine_search, "Refine search", '.'
+  end
+
+  def refine_search
+    label_query = @labels.size > 1 ? "(#{@labels.join('||')})" : @labels.first
+    query = BufferManager.ask :search, "query: ", "+label:#{label_query} "
+    return unless query && query !~ /^\s*$/
+    SearchResultsMode.spawn_from_query query
+  end
+
+  def is_relevant? m; @labels.all? { |l| m.has_label? l } end
 
   def self.spawn_nicely label
     label = LabelManager.label_for(label) unless label.is_a?(Symbol)

data/lib/sup/modes/line-cursor-mode.rb

@@ -55,14 +55,11 @@ protected
     buffer.mark_dirty
   end
 
-  ## override search behavior to be cursor-based
+  ## override search behavior to be cursor-based. this is a stupid
+  ## implementation and should be made better. TODO: improve.
   def search_goto_line line
-    while line > botline
-      page_down
-    end
-    while line < topline
-      page_up
-    end
+    page_down while line >= botline
+    page_up while line < topline
     set_cursor_pos line
   end
 

data/lib/sup/modes/reply-mode.rb

@@ -3,17 +3,21 @@ module Redwood
 class ReplyMode < EditMessageMode
   REPLY_TYPES = [:sender, :recipient, :list, :all, :user]
   TYPE_DESCRIPTIONS = {
-    :sender => "Reply to sender",
-    :recipient => "Reply to recipient",
-    :all => "Reply to all",
-    :list => "Reply to mailing list",
-    :user => "Customized reply"
+    :sender => "Sender",
+    :recipient => "Recipient",
+    :all => "All",
+    :list => "Mailing list",
+    :user => "Customized"
   }
 
-  register_keymap do |k|
-    k.add :move_cursor_right, "Move cursor to the right", :right
-    k.add :move_cursor_left, "Move cursor to the left", :left
-  end
+  HookManager.register "attribution", <<EOS
+Generates an attribution ("Excerpts from Joe Bloggs's message of Fri Jan 11 09:54:32 -0500 2008:").
+Variables:
+  message: a message object representing the message being replied to
+    (useful values include message.from.name and message.date)
+Return value:
+  A string containing the text of the quote line (can be multi-line)
+EOS
 
   def initialize message
     @m = message
@@ -23,27 +27,33 @@ class ReplyMode < EditMessageMode
     ## any)
     body = reply_body_lines message
 
+    ## first, determine the address at which we received this email. this will
+    ## become our From: address in the reply.
     from =
-      if @m.recipient_email && (a = AccountManager.account_for(@m.recipient_email))
-        a
+      if @m.recipient_email && AccountManager.is_account_email?(@m.recipient_email)
+        PersonManager.person_for(@m.recipient_email)
       elsif(b = (@m.to + @m.cc).find { |p| AccountManager.is_account? p })
         b
       else
         AccountManager.default_account
       end
 
-    ## ignore reply-to for list messages because it's typically set to
-    ## the list address, which we explicitly treat with :list
+    ## now, determine to: and cc: addressess. we ignore reply-to for list
+    ## messages because it's typically set to the list address, which we
+    ## explicitly treat with reply type :list
     to = @m.is_list_message? ? @m.from : (@m.replyto || @m.from)
-    cc = (@m.to + @m.cc - [from, to]).uniq
 
-    @headers = {}
+    ## next, cc:
+    cc = (@m.to + @m.cc - [from, to]).uniq
 
+    ## one potential reply type is "reply to recipient". this only happens
+    ## in certain cases:
     ## if there's no cc, then the sender is the person you want to reply
     ## to. if it's a list message, then the list address is. otherwise,
     ## the cc contains a recipient.
     useful_recipient = !(cc.empty? || @m.is_list_message?)
     
+    @headers = {}
     @headers[:recipient] = {
       "To" => cc.map { |p| p.full_address },
     } if useful_recipient
@@ -55,10 +65,11 @@ class ReplyMode < EditMessageMode
 
     @headers[:user] = {}
 
+    not_me_ccs = cc.select { |p| !AccountManager.is_account?(p) }
     @headers[:all] = {
       "To" => [to.full_address],
-      "Cc" => cc.select { |p| !AccountManager.is_account?(p) }.map { |p| p.full_address },
-    } unless cc.empty?
+      "Cc" => not_me_ccs.map { |p| p.full_address },
+    } unless not_me_ccs.empty?
 
     @headers[:list] = {
       "To" => [@m.list_address.full_address],
@@ -68,7 +79,7 @@ class ReplyMode < EditMessageMode
 
     @headers.each do |k, v|
       @headers[k] = {
-               "From" => "#{from.name} <#{from.email}>",
+               "From" => from.full_address,
                "To" => [],
                "Cc" => [],
                "Bcc" => [],
@@ -78,47 +89,55 @@ class ReplyMode < EditMessageMode
              }.merge v
     end
 
-    @type_labels = REPLY_TYPES.select { |t| @headers.member?(t) }
-    @selected_type = 
+    types = REPLY_TYPES.select { |t| @headers.member?(t) }
+    @type_selector = HorizontalSelector.new "Reply to:", types, types.map { |x| TYPE_DESCRIPTIONS[x] }
+
+    @type_selector.set_to(
       if @m.is_list_message?
         :list
       elsif @headers.member? :sender
         :sender
       else
         :recipient
-      end
+      end)
 
-    super :header => @headers[@selected_type], :body => body,
-          :skip_top_rows => 2, :twiddles => false
+    super :header => @headers[@type_selector.val], :body => body, :twiddles => false
+    add_selector @type_selector
   end
 
-  def lines; super + 2; end
-  def [] i
-    case i
-    when 0
-      @type_labels.inject([]) do |array, t|
-        array + [[(t == @selected_type ? :none_highlight : :none), 
-          "#{TYPE_DESCRIPTIONS[t]}"], [:none, "  "]]
-      end + [[:none, ""]]
-    when 1
-      ""
-    else
-      super(i - 2)
+protected
+
+  def move_cursor_right
+    super
+    if @headers[@type_selector.val] != self.header
+      self.header = @headers[@type_selector.val]
+      update
     end
   end
 
-protected
+  def move_cursor_left
+    super
+    if @headers[@type_selector.val] != self.header
+      self.header = @headers[@type_selector.val]
+      update
+    end
+  end
 
   def reply_body_lines m
-    lines = ["Excerpts from #{@m.from.name}'s message of #{@m.date}:"] + m.quotable_body_lines.map { |l| "> #{l}" }
+    attribution = HookManager.run("attribution", :message => m) || default_attribution(m)
+    lines = attribution.split("\n") + m.quotable_body_lines.map { |l| "> #{l}" }
     lines.pop while lines.last =~ /^\s*$/
     lines
   end
 
+  def default_attribution m
+    "Excerpts from #{@m.from.name}'s message of #{@m.date}:"
+  end
+
   def handle_new_text new_header, new_body
-    old_header = @headers[@selected_type]
+    old_header = @headers[@type_selector.val]
     if new_header.size != old_header.size || old_header.any? { |k, v| new_header[k] != v }
-      @selected_type = :user
+      @type_selector.set_to :user
       self.header = @headers[:user] = new_header
       update
     end
@@ -131,24 +150,10 @@ protected
   def edit_field field
     edited_field = super
     if edited_field && edited_field != "Subject"
-      @selected_type = :user
+      @type_selector.set_to :user
       update
     end
   end
-  
-  def move_cursor_left
-    i = @type_labels.index @selected_type
-    @selected_type = @type_labels[(i - 1) % @type_labels.length]
-    self.header = @headers[@selected_type]
-    update
-  end
-
-  def move_cursor_right
-    i = @type_labels.index @selected_type
-    @selected_type = @type_labels[(i + 1) % @type_labels.length]
-    self.header = @headers[@selected_type]
-    update
-  end
 end
 
 end

data/lib/sup/modes/resume-mode.rb

@@ -2,13 +2,13 @@ module Redwood
 
 class ResumeMode < EditMessageMode
   def initialize m
-    @id = m.id
+    @m = m
     @safe = false
 
     header, body = parse_file m.draft_filename
     header.delete "Date"
 
-    super :header => header, :body => body
+    super :header => header, :body => body, :have_signature => true
   end
 
   def killable?
@@ -16,13 +16,13 @@ class ResumeMode < EditMessageMode
 
     case BufferManager.ask_yes_or_no "Discard draft?"
     when true
-      DraftManager.discard @id
+      DraftManager.discard @m
       BufferManager.flash "Draft discarded."
       true
     when false
       if edited?
         DraftManager.write_draft { |f| write_message f, false }
-        DraftManager.discard @id
+        DraftManager.discard @m
         BufferManager.flash "Draft saved."
       end
       true
@@ -33,14 +33,14 @@ class ResumeMode < EditMessageMode
 
   def send_message
     if super
-      DraftManager.discard @id 
+      DraftManager.discard @m 
       @safe = true
     end
   end
 
   def save_as_draft
     @safe = true
-    DraftManager.discard @id if super
+    DraftManager.discard @m if super
   end
 end
 

data/lib/sup/modes/scroll-mode.rb

@@ -12,14 +12,14 @@ class ScrollMode < Mode
 
   attr_reader :status, :topline, :botline, :leftcol
 
-  COL_JUMP = 2
+  COL_JUMP = 4
 
   register_keymap do |k|
     k.add :line_down, "Down one line", :down, 'j', 'J'
     k.add :line_up, "Up one line", :up, 'k', 'K'
     k.add :col_left, "Left one column", :left, 'h'
     k.add :col_right, "Right one column", :right, 'l'
-    k.add :page_down, "Down one page", :page_down, 'n', ' '
+    k.add :page_down, "Down one page", :page_down, ' '
     k.add :page_up, "Up one page", :page_up, 'p', :backspace
     k.add :jump_to_start, "Jump to top", :home, '^', '1'
     k.add :jump_to_end, "Jump to bottom", :end, '$', '0'
@@ -101,6 +101,7 @@ class ScrollMode < Mode
   end
 
   def jump_to_col col
+    col = col - (col % COL_JUMP)
     buffer.mark_dirty unless @leftcol == col
     @leftcol = col
   end
@@ -176,7 +177,7 @@ protected
         draw_line_from_array ln, s, opts
       end
     else
-      raise "unknown drawable object: #{s.inspect}" # good for debugging
+      raise "unknown drawable object: #{s.inspect} in #{self} for line #{ln}" # good for debugging
     end
 
       ## speed test

data/lib/sup/modes/search-results-mode.rb

@@ -1,9 +1,11 @@
 module Redwood
 
 class SearchResultsMode < ThreadIndexMode
-  def initialize qobj
+  def initialize qobj, qopts = nil
     @qobj = qobj
-    super [], { :qobj => @qobj }
+    @qopts = qopts
+
+    super [], { :qobj => @qobj }.merge(@qopts)
   end
 
   register_keymap do |k|
@@ -13,7 +15,7 @@ class SearchResultsMode < ThreadIndexMode
   def refine_search
     query = BufferManager.ask :search, "query: ", (@qobj.to_s + " ")
     return unless query && query !~ /^\s*$/
-    SearchResultsMode.spawn_from_query query
+    SearchResultsMode.spawn_from_query query, @qopts
   end
 
   ## a proper is_relevant? method requires some way of asking ferret
@@ -24,9 +26,10 @@ class SearchResultsMode < ThreadIndexMode
 
   def self.spawn_from_query text
     begin
-      qobj = Index.parse_user_query_string(text) or return
+      qobj, extraopts = Index.parse_user_query_string(text)
+      return unless qobj
       short_text = text.length < 20 ? text : text[0 ... 20] + "..."
-      mode = SearchResultsMode.new qobj
+      mode = SearchResultsMode.new qobj, extraopts
       BufferManager.spawn "search: \"#{short_text}\"", mode
       mode.load_threads :num => mode.buffer.content_height
     rescue Ferret::QueryParser::QueryParseException => e

data/lib/sup/modes/text-mode.rb

@@ -4,20 +4,37 @@ class TextMode < ScrollMode
   attr_reader :text
   register_keymap do |k|
     k.add :save_to_disk, "Save to disk", 's'
+    k.add :pipe, "Pipe to process", '|'
   end
 
-  def initialize text=""
+  def initialize text="", filename=nil
     @text = text
+    @filename = filename
     update_lines
     buffer.mark_dirty if buffer
     super()
   end
   
   def save_to_disk
-    fn = BufferManager.ask_for_filename :filename, "Save to file: "
+    fn = BufferManager.ask_for_filename :filename, "Save to file: ", @filename
     save_to_file(fn) { |f| f.puts text } if fn
   end
 
+  def pipe
+    command = BufferManager.ask(:shell, "pipe command: ")
+    return if command.nil? || command.empty?
+
+    output = pipe_to_process(command) do |stream|
+      @text.each { |l| stream.puts l }
+    end
+
+    if output
+      BufferManager.spawn "Output of '#{command}'", TextMode.new(output)
+    else
+      BufferManager.flash "'#{command}' done!"
+    end
+  end
+
   def text= t
     @text = t
     update_lines

data/lib/sup/modes/thread-index-mode.rb

@@ -31,7 +31,9 @@ EOS
     k.add :forward, "Forward latest message in a thread", 'f'
     k.add :toggle_tagged, "Tag/untag selected thread", 't'
     k.add :toggle_tagged_all, "Tag/untag all threads", 'T'
+    k.add :tag_matching, "Tag matching threads", 'g'
     k.add :apply_to_tagged, "Apply next command to all tagged threads", ';'
+    k.add :join_threads, "Force tagged threads to be joined into the same thread", '#'
   end
 
   def initialize hidden_labels=[], load_thread_opts={}
@@ -74,7 +76,7 @@ EOS
   end
 
   ## open up a thread view window
-  def select t=nil
+  def select t=nil, when_done=nil
     t ||= cursor_thread or return
 
     Redwood::reporting_thread("load messages for thread-view-mode") do
@@ -87,73 +89,98 @@ EOS
           m.load_from_source! 
         end
       end
-      mode = ThreadViewMode.new t, @hidden_labels
+      mode = ThreadViewMode.new t, @hidden_labels, self
       BufferManager.spawn t.subj, mode
       BufferManager.draw_screen
-      mode.jump_to_first_open
+      mode.jump_to_first_open true
       BufferManager.draw_screen # lame TODO: make this unnecessary
       ## the first draw_screen is needed before topline and botline
       ## are set, and the second to show the cursor having moved
 
       update_text_for_line curpos
-      UpdateManager.relay self, :read, t
+      UpdateManager.relay self, :read, t.first
+      when_done.call if when_done
     end
   end
 
   def multi_select threads
     threads.each { |t| select t }
   end
-  
-  def handle_label_update sender, m
-    t = @ts_mutex.synchronize { @ts.thread_for(m) } or return
-    handle_label_thread_update sender, t
-  end
 
-  def handle_label_thread_update sender, t
-    l = @lines[t] or return
-    update_text_for_line l
-    BufferManager.draw_screen
+  ## this is called by thread-view-modes when the user wants to view
+  ## the next thread without going to index-mode. we update the cursor
+  ## as a convenience.
+  def launch_next_thread_after thread, &b
+    l = @lines[thread] or return
+    t = @mutex.synchronize do
+      if l < @threads.length - 1
+        set_cursor_pos l + 1 # move out of mutex?
+        @threads[l + 1]
+      end
+    end or return
+
+    select t, b
+  end
+  
+  def handle_single_message_labeled_update sender, m
+    ## no need to do anything different here; we don't differentiate 
+    ## messages from their containing threads
+    handle_labeled_update sender, m
+  end
+
+  def handle_labeled_update sender, m
+    if(t = thread_containing(m)) 
+      l = @lines[t] or return
+      update_text_for_line l
+    elsif is_relevant?(m)
+      add_or_unhide m
+    end
   end
 
-  def handle_read_update sender, t
+  def handle_simple_update sender, m
+    t = thread_containing(m) or return
     l = @lines[t] or return
     update_text_for_line l
-    BufferManager.draw_screen
   end
 
-  def handle_archived_update *a; handle_read_update(*a); end
-
-  def handle_deleted_update sender, t
-    handle_read_update sender, t
-    hide_thread t
-    regen_text
+  %w(read unread archived starred unstarred).each do |state|
+    define_method "handle_#{state}_update" do |*a|
+      handle_simple_update(*a)
+    end
   end
 
   ## overwrite me!
   def is_relevant? m; false; end
 
-  def handle_add_update sender, m
+  def handle_added_update sender, m
+    add_or_unhide m
+    BufferManager.draw_screen
+  end
+
+  def handle_single_message_deleted_update sender, m
     @ts_mutex.synchronize do
-      return unless is_relevant?(m) || @ts.is_relevant?(m)
-      @ts.load_thread_for_message m
+      return unless @ts.contains? m
+      @ts.remove_id m.id
     end
     update
-    BufferManager.draw_screen
   end
 
-  def handle_delete_update sender, mid
+  def handle_deleted_update sender, m
     @ts_mutex.synchronize do
-      return unless @ts.contains_id? mid
-      @ts.remove mid
+      return unless @ts.contains? m
+      @ts.remove_thread_containing_id m.id
     end
     update
-    BufferManager.draw_screen
+  end
+
+  def handle_undeleted_update sender, m
+    add_or_unhide m
   end
 
   def update
     @mutex.synchronize do
       ## let's see you do THIS in python
-      @threads = @ts.threads.select { |t| !@hidden_threads[t] }.sort_by { |t| t.date }.reverse
+      @threads = @ts.threads.select { |t| !@hidden_threads[t] }.sort_by { |t| [t.date, t.first.id] }.reverse
       @size_widgets = @threads.map { |t| size_widget_for_thread t }
       @size_widget_width = @size_widgets.max_of { |w| w.length }
     end
@@ -175,10 +202,10 @@ EOS
   def actually_toggle_starred t
     if t.has_label? :starred # if ANY message has a star
       t.remove_label :starred # remove from all
-      UpdateManager.relay self, :unstarred, t
+      UpdateManager.relay self, :unstarred, t.first
     else
       t.first.add_label :starred # add only to first
-      UpdateManager.relay self, :starred, t
+      UpdateManager.relay self, :starred, t.first
     end
   end  
 
@@ -197,30 +224,30 @@ EOS
   def actually_toggle_archived t
     if t.has_label? :inbox
       t.remove_label :inbox
-      UpdateManager.relay self, :archived, t
+      UpdateManager.relay self, :archived, t.first
     else
       t.apply_label :inbox
-      UpdateManager.relay self, :unarchived, t
+      UpdateManager.relay self, :unarchived, t.first
     end
   end
 
   def actually_toggle_spammed t
     if t.has_label? :spam
       t.remove_label :spam
-      UpdateManager.relay self, :unspammed, t
+      UpdateManager.relay self, :unspammed, t.first
     else
       t.apply_label :spam
-      UpdateManager.relay self, :spammed, t
+      UpdateManager.relay self, :spammed, t.first
     end
   end
 
   def actually_toggle_deleted t
     if t.has_label? :deleted
       t.remove_label :deleted
-      UpdateManager.relay self, :undeleted, t
+      UpdateManager.relay self, :undeleted, t.first
     else
       t.apply_label :deleted
-      UpdateManager.relay self, :deleted, t
+      UpdateManager.relay self, :deleted, t.first
     end
   end
 
@@ -252,6 +279,18 @@ EOS
     regen_text
   end
 
+  def join_threads
+    ## this command has no non-tagged form. as a convenience, allow this
+    ## command to be applied to tagged threads without hitting ';'.
+    @tags.apply_to_tagged :join_threads
+  end
+
+  def multi_join_threads threads
+    @ts.join_threads threads or return
+    @tags.drop_all_tags # otherwise we have tag pointers to invalid threads!
+    update
+  end
+
   def jump_to_next_new
     n = @mutex.synchronize do
       ((curpos + 1) ... lines).find { |i| @threads[i].has_label? :unread } ||
@@ -351,6 +390,14 @@ EOS
     regen_text
   end
 
+  def tag_matching
+    query = BufferManager.ask :search, "tag threads matching: "
+    return if query.nil? || query.empty?
+    query = /#{query}/i
+    @mutex.synchronize { @threads.each { |t| @tags.tag t if thread_matches?(t, query) } }
+    regen_text
+  end
+
   def apply_to_tagged; @tags.apply_to_tagged; end
 
   def edit_labels
@@ -363,7 +410,7 @@ EOS
     return unless user_labels
     thread.labels = keepl + user_labels
     user_labels.each { |l| LabelManager << l }
-    update_text_for_line curpos
+    UpdateManager.relay self, :labeled, thread.first
   end
 
   def multi_edit_labels threads
@@ -395,7 +442,7 @@ EOS
     m = t.latest_message
     return if m.nil? # probably won't happen
     m.load_from_source!
-    ForwardMode.spawn_nicely m
+    ForwardMode.spawn_nicely :message => m
   end
 
   def load_n_threads_background n=LOAD_MORE_THREAD_NUM, opts={}
@@ -465,6 +512,28 @@ EOS
 
 protected
 
+  def add_or_unhide m
+    if @hidden_threads[m]
+      @hidden_threads.delete m
+      ## now it will re-appear when #update is called
+    else
+      @ts_mutex.synchronize do
+        return unless is_relevant?(m) || @ts.is_relevant?(m)
+        @ts.load_thread_for_message m
+      end
+    end
+
+    update
+  end
+
+  def thread_containing m; @ts_mutex.synchronize { @ts.thread_for m } end
+
+  ## used to tag threads by query. this can be made a lot more sophisticated,
+  ## but for right now we'll do the obvious this.
+  def thread_matches? t, query
+    t.subj =~ query || t.snippet =~ query || t.participants.any? { |x| x.longname =~ query }
+  end
+
   def size_widget_for_thread t
     HookManager.run("index-mode-size-widget", :thread => t) || default_size_widget_for(t)
   end