sup 0.19.0

data/lib/sup/modes/file_browser_mode.rb

@@ -0,0 +1,109 @@
+require 'pathname'
+
+module Redwood
+
+## meant to be spawned via spawn_modal!
+class FileBrowserMode < LineCursorMode
+  RESERVED_ROWS = 1
+
+  register_keymap do |k|
+    k.add :back, "Go back to previous directory", "B"
+    k.add :view, "View file", "v"
+    k.add :select_file_or_follow_directory, "Select the highlighted file, or follow the directory", :enter
+    k.add :reload, "Reload file list", "R"
+  end
+
+  bool_reader :done
+  attr_reader :value
+
+  def initialize dir="."
+    @dirs = [Pathname.new(dir).realpath]
+    @done = false
+    @value = nil
+    regen_text
+    super :skip_top_rows => RESERVED_ROWS
+  end
+
+  def cwd; @dirs.last end
+  def lines; @text.length; end
+  def [] i; @text[i]; end
+
+protected
+
+  def back
+    return if @dirs.size == 1
+    @dirs.pop
+    reload
+  end
+
+  def reload
+    regen_text
+    jump_to_start
+    buffer.mark_dirty
+  end
+
+  def view
+     name, f = @files[curpos - RESERVED_ROWS]
+    return unless f && f.file?
+
+    begin
+      BufferManager.spawn f.to_s, TextMode.new(f.read.ascii)
+    rescue SystemCallError => e
+      BufferManager.flash e.message
+    end
+  end
+
+  def select_file_or_follow_directory
+    name, f = @files[curpos - RESERVED_ROWS]
+    return unless f
+
+    if f.directory? && f.to_s != "."
+      if f.readable?
+        @dirs.push f
+        reload
+      else
+        BufferManager.flash "Permission denied - #{f.realpath}"
+      end
+    else
+      begin
+        @value = f.realpath.to_s
+        @done = true
+      rescue SystemCallError => e
+        BufferManager.flash e.message
+      end
+    end
+  end
+
+  def regen_text
+    @files =
+      begin
+        cwd.entries.sort_by do |f|
+          [f.directory? ? 0 : 1, f.basename.to_s]
+        end
+      rescue SystemCallError => e
+        BufferManager.flash "Error: #{e.message}"
+        [Pathname.new("."), Pathname.new("..")]
+      end.map do |f|
+      real_f = cwd + f
+      name = f.basename.to_s +
+        case
+        when real_f.symlink?
+          "@"
+        when real_f.directory?
+          "/"
+        else
+          ""
+        end
+      [name, real_f]
+    end
+
+    size_width = @files.max_of { |name, f| f.human_size.length }
+    time_width = @files.max_of { |name, f| f.human_time.length }
+
+    @text = ["#{cwd}:"] + @files.map do |name, f|
+      sprintf "%#{time_width}s %#{size_width}s %s", f.human_time, f.human_size, name
+    end
+  end
+end
+
+end

data/lib/sup/modes/forward_mode.rb

@@ -0,0 +1,82 @@
+module Redwood
+
+class ForwardMode < EditMessageMode
+  ## TODO: share some of this with reply-mode
+  def initialize opts={}
+    header = {
+      "From" => AccountManager.default_account.full_address,
+    }
+
+    @m = opts[:message]
+    header["Subject"] =
+      if @m
+        "Fwd: " + @m.subj
+      elsif opts[:attachments]
+        "Fwd: " + opts[:attachments].keys.join(", ")
+      end
+
+    header["To"] = opts[:to].map { |p| p.full_address }.join(", ") if opts[:to]
+    header["Cc"] = opts[:cc].map { |p| p.full_address }.join(", ") if opts[:cc]
+    header["Bcc"] = opts[:bcc].map { |p| p.full_address }.join(", ") if opts[:bcc]
+
+    body =
+      if @m
+        forward_body_lines @m
+      elsif opts[:attachments]
+        ["Note: #{opts[:attachments].size.pluralize 'attachment'}."]
+      end
+
+    super :header => header, :body => body, :attachments => opts[:attachments]
+  end
+
+  def self.spawn_nicely opts={}
+    to = opts[:to] || (BufferManager.ask_for_contacts(:people, "To: ") or return if ($config[:ask_for_to] != false))
+    cc = opts[:cc] || (BufferManager.ask_for_contacts(:people, "Cc: ") or return if $config[:ask_for_cc])
+    bcc = opts[:bcc] || (BufferManager.ask_for_contacts(:people, "Bcc: ") or return if $config[:ask_for_bcc])
+
+    attachment_hash = {}
+    attachments = opts[:attachments] || []
+
+    if(m = opts[:message])
+      m.load_from_source! # read the full message in. you know, maybe i should just make Message#chunks do this....
+      attachments += m.chunks.select { |c| c.is_a?(Chunk::Attachment) && !c.quotable? }
+    end
+
+    attachments.each do |c|
+      mime_type = MIME::Types[c.content_type].first || MIME::Types["application/octet-stream"].first
+      attachment_hash[c.filename] = RMail::Message.make_attachment c.raw_content, mime_type.content_type, mime_type.encoding, c.filename
+    end
+
+    mode = ForwardMode.new :message => opts[:message], :to => to, :cc => cc, :bcc => bcc, :attachments => attachment_hash
+
+    title = "Forwarding " +
+      if opts[:message]
+        opts[:message].subj
+      elsif attachments
+        attachment_hash.keys.join(", ")
+      else
+        "something"
+      end
+
+    BufferManager.spawn title, mode
+    mode.default_edit_message
+  end
+
+protected
+
+  def forward_body_lines m
+    ["--- Begin forwarded message from #{m.from.mediumname} ---"] +
+      m.quotable_header_lines + [""] + m.quotable_body_lines +
+      ["--- End forwarded message ---"]
+  end
+
+  def send_message
+    return unless super # super returns true if the mail has been sent
+    if @m
+      @m.add_label :forwarded
+      Index.save_message @m
+    end
+  end
+end
+
+end

data/lib/sup/modes/help_mode.rb

@@ -0,0 +1,19 @@
+module Redwood
+
+class HelpMode < TextMode
+  def initialize mode, global_keymap
+    title = "Help for #{mode.name}"
+    super <<EOS
+#{title}
+#{'=' * title.length}
+
+#{mode.help_text}
+Global keybindings
+------------------
+#{global_keymap.help_text}
+EOS
+  end
+end
+
+end
+

data/lib/sup/modes/inbox_mode.rb

@@ -0,0 +1,85 @@
+require "sup/modes/thread_index_mode"
+
+module Redwood
+
+class InboxMode < ThreadIndexMode
+  register_keymap do |k|
+    ## overwrite toggle_archived with archive
+    k.add :archive, "Archive thread (remove from inbox)", 'a'
+    k.add :refine_search, "Refine search", '|'
+  end
+
+  def initialize
+    super [:inbox, :sent, :draft], { :label => :inbox, :skip_killed => true }
+    raise "can't have more than one!" if defined? @@instance
+    @@instance = self
+  end
+
+  def is_relevant? m; (m.labels & [:spam, :deleted, :killed, :inbox]) == Set.new([:inbox]) end
+
+  def refine_search
+    text = BufferManager.ask :search, "refine inbox with query: "
+    return unless text && text !~ /^\s*$/
+    text = "label:inbox -label:spam -label:deleted " + text
+    SearchResultsMode.spawn_from_query text
+  end
+
+  ## label-list-mode wants to be able to raise us if the user selects
+  ## the "inbox" label, so we need to keep our singletonness around
+  def self.instance; @@instance; end
+  def killable?; false; end
+
+  def archive
+    return unless cursor_thread
+    thread = cursor_thread # to make sure lambda only knows about 'old' cursor_thread
+
+    UndoManager.register "archiving thread" do
+      thread.apply_label :inbox
+      add_or_unhide thread.first
+      Index.save_thread thread
+    end
+
+    cursor_thread.remove_label :inbox
+    hide_thread cursor_thread
+    regen_text
+    Index.save_thread thread
+  end
+
+  def multi_archive threads
+    UndoManager.register "archiving #{threads.size.pluralize 'thread'}" do
+      threads.map do |t|
+        t.apply_label :inbox
+        add_or_unhide t.first
+        Index.save_thread t
+      end
+      regen_text
+    end
+
+    threads.each do |t|
+      t.remove_label :inbox
+      hide_thread t
+    end
+    regen_text
+    threads.each { |t| Index.save_thread t }
+  end
+
+  def handle_unarchived_update sender, m
+    add_or_unhide m
+  end
+
+  def handle_archived_update sender, m
+    t = thread_containing(m) or return
+    hide_thread t
+    regen_text
+  end
+
+  def handle_idle_update sender, idle_since
+    flush_index
+  end
+
+  def status
+    super + "    #{Index.size} messages in index"
+  end
+end
+
+end

data/lib/sup/modes/label_list_mode.rb

@@ -0,0 +1,138 @@
+module Redwood
+
+class LabelListMode < LineCursorMode
+  register_keymap do |k|
+    k.add :select_label, "Search by label", :enter
+    k.add :reload, "Discard label list and reload", '@'
+    k.add :jump_to_next_new, "Jump to next new thread", :tab
+    k.add :toggle_show_unread_only, "Toggle between showing all labels and those with unread mail", 'u'
+  end
+
+  HookManager.register "label-list-filter", <<EOS
+Filter the label list, typically to sort.
+Variables:
+  counted: an array of counted labels.
+Return value:
+  An array of counted labels with sort_by output structure.
+EOS
+
+  HookManager.register "label-list-format", <<EOS
+Create the sprintf format string for label-list-mode.
+Variables:
+  width: the maximum label width
+  tmax: the maximum total message count
+  umax: the maximum unread message count
+Return value:
+  A format string for sprintf
+EOS
+
+  def initialize
+    @labels = []
+    @text = []
+    @unread_only = false
+    super
+    UpdateManager.register self
+    regen_text
+  end
+
+  def cleanup
+    UpdateManager.unregister self
+    super
+  end
+
+  def lines; @text.length end
+  def [] i; @text[i] end
+
+  def jump_to_next_new
+    n = ((curpos + 1) ... lines).find { |i| @labels[i][1] > 0 } || (0 ... curpos).find { |i| @labels[i][1] > 0 }
+    if n
+      ## jump there if necessary
+      jump_to_line n unless n >= topline && n < botline
+      set_cursor_pos n
+    else
+      BufferManager.flash "No labels messages with unread messages."
+    end
+  end
+
+  def focus
+    reload # make sure unread message counts are up-to-date
+  end
+
+  def handle_added_update sender, m
+    reload
+  end
+
+protected
+
+  def toggle_show_unread_only
+    @unread_only = !@unread_only
+    reload
+  end
+
+  def reload
+    regen_text
+    buffer.mark_dirty if buffer
+  end
+
+  def regen_text
+    @text = []
+    labels = LabelManager.all_labels
+
+    counted = labels.map do |label|
+      string = LabelManager.string_for label
+      total = Index.num_results_for :label => label
+      unread = (label == :unread)? total : Index.num_results_for(:labels => [label, :unread])
+      [label, string, total, unread]
+    end
+
+    if HookManager.enabled? "label-list-filter"
+      counts = HookManager.run "label-list-filter", :counted => counted
+    else
+      counts = counted.sort_by { |l, s, t, u| s.downcase }
+    end
+
+    width = counts.max_of { |l, s, t, u| s.length }
+    tmax  = counts.max_of { |l, s, t, u| t }
+    umax  = counts.max_of { |l, s, t, u| u }
+
+    if @unread_only
+      counts.delete_if { | l, s, t, u | u == 0 }
+    end
+
+    @labels = []
+    counts.map do |label, string, total, unread|
+      ## if we've done a search and there are no messages for this label, we can delete it from the
+      ## list. BUT if it's a brand-new label, the user may not have sync'ed it to the index yet, so
+      ## don't delete it in this case.
+      ##
+      ## this is all a hack. what should happen is:
+      ##   TODO make the labelmanager responsible for label counts
+      ## and then it can listen to labeled and unlabeled events, etc.
+      if total == 0 && !LabelManager::RESERVED_LABELS.include?(label) && !LabelManager.new_label?(label)
+        debug "no hits for label #{label}, deleting"
+        LabelManager.delete label
+        next
+      end
+
+      fmt = HookManager.run "label-list-format", :width => width, :tmax => tmax, :umax => umax
+      if !fmt
+        fmt = "%#{width + 1}s %5d %s, %5d unread"
+      end
+
+      @text << [[(unread == 0 ? :labellist_old_color : :labellist_new_color),
+          sprintf(fmt, string, total, total == 1 ? " message" : "messages", unread)]]
+      @labels << [label, unread]
+      yield i if block_given?
+    end.compact
+
+    BufferManager.flash "No labels with unread messages!" if counts.empty? && @unread_only
+  end
+
+  def select_label
+    label, num_unread = @labels[curpos]
+    return unless label
+    LabelSearchResultsMode.spawn_nicely label
+  end
+end
+
+end

data/lib/sup/modes/label_search_results_mode.rb

@@ -0,0 +1,38 @@
+module Redwood
+
+class LabelSearchResultsMode < ThreadIndexMode
+  def initialize labels
+    @labels = labels
+    opts = { :labels => @labels }
+    opts[:load_deleted] = true if labels.include? :deleted
+    opts[:load_spam] = true if labels.include? :spam
+    super [], opts
+  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, "refine 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)
+    case label
+    when nil
+    when :inbox
+      BufferManager.raise_to_front InboxMode.instance.buffer
+    else
+      b, new = BufferManager.spawn_unless_exists("All threads with label '#{label}'") { LabelSearchResultsMode.new [label] }
+      b.mode.load_threads :num => b.content_height if new
+    end
+  end
+end
+
+end