sup 0.0.1

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,45 @@
+require 'thread'
+
+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 :load_more_threads, "Load #{LOAD_MORE_THREAD_NUM} more threads", 'M'
+    k.add :reload, "Discard threads and reload", 'R'
+  end
+
+  def initialize
+    super [:inbox], [:inbox]
+  end
+
+  def archive
+    remove_label_and_hide_thread cursor_thread, :inbox
+    regen_text
+  end
+
+  def multi_archive threads
+    threads.each { |t| remove_label_and_hide_thread t, :inbox }
+    regen_text
+  end
+
+  def is_relevant? m; m.has_label? :inbox; end
+
+  def load_more_threads n=ThreadIndexMode::LOAD_MORE_THREAD_NUM
+    load_n_threads_background n, :label => :inbox,
+                                 :load_killed => false,
+                                 :load_spam => false,
+                                 :when_done => lambda { |num|
+      BufferManager.flash "Added #{num} threads."
+    }
+  end
+
+  def reload
+    drop_all_threads
+    BufferManager.draw_screen
+    load_more_threads buffer.content_height
+  end
+end
+
+end

data/lib/sup/modes/label-list-mode.rb

@@ -0,0 +1,89 @@
+module Redwood
+
+class LabelListMode < LineCursorMode
+  register_keymap do |k|
+    k.add :view_results, "View messages with the selected label", :enter
+    k.add :reload, "Reload", "R"
+  end
+
+  def initialize
+    @labels = []
+    @text = []
+    super()
+  end
+
+  def lines; @text.length; end
+  def [] i; @text[i]; end
+
+  def load; regen_text; end
+
+  def load_in_background
+    ::Thread.new do
+      regen_text do |i|
+        if i % 10 == 0
+          buffer.mark_dirty
+          BufferManager.draw_screen
+          sleep 0.1 # ok, dirty trick.
+        end
+      end
+      buffer.mark_dirty
+      BufferManager.draw_screen
+    end
+  end
+
+protected
+
+  def reload
+    buffer.mark_dirty
+    BufferManager.draw_screen
+    load_in_background
+  end
+  
+  def regen_text
+    @text = []
+    @labels = LabelManager::LISTABLE_LABELS.sort_by { |t| t.to_s } +
+                LabelManager.user_labels.sort_by { |t| t.to_s }
+
+    counts = @labels.map do |t|
+      total = Index.num_results_for :label => t
+      unread = Index.num_results_for :labels => [t, :unread]
+      [t, total, unread]
+    end      
+
+    width = @labels.map { |t| t.to_s.length }.max
+
+    counts.map_with_index do |(t, total, unread), i|
+      if total == 0 && !LabelManager::LISTABLE_LABELS.include?(t)
+        Redwood::log "no hits for label #{t}, deleting"
+        LabelManager.delete t
+        @labels.delete t
+        next
+      end
+
+      label =
+        case t
+        when *LabelManager::LISTABLE_LABELS
+          t.to_s.ucfirst
+        else
+          t.to_s
+        end
+      @text << [[(unread == 0 ? :labellist_old_color : :labellist_new_color),
+          sprintf("%#{width + 1}s %5d %s, %5d unread", label, total, total == 1 ? " message" : "messages", unread)]]
+      yield i if block_given?
+    end.compact
+  end
+
+  def view_results
+    label = @labels[curpos]
+    if label == :inbox
+      BufferManager.raise_to_front BufferManager["inbox"]
+    else
+      b = BufferManager.spawn_unless_exists(label) do
+        mode = LabelSearchResultsMode.new [label]
+      end
+      b.mode.load_more_threads b.content_height
+    end
+  end
+end
+
+end

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

@@ -0,0 +1,29 @@
+module Redwood
+
+class LabelSearchResultsMode < ThreadIndexMode
+  register_keymap do |k|
+    k.add :load_more_threads, "Load #{LOAD_MORE_THREAD_NUM} more threads", 'M'
+  end
+
+  def initialize labels
+    @labels = labels
+    super
+  end
+
+  def is_relevant? m; @labels.all? { |l| m.has_label? l }; end
+
+  def load_more_threads n=ThreadIndexMode::LOAD_MORE_THREAD_NUM
+    load_n_threads_background n, :labels => @labels,
+                                 :load_killed => true,
+                                 :load_spam => false,
+                                 :when_done =>(lambda do |num|
+      if num > 0
+        BufferManager.flash "Found #{num} threads"
+      else
+        BufferManager.flash "No matches"
+      end
+    end)
+  end
+end
+
+end

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

@@ -0,0 +1,133 @@
+module Redwood
+
+class LineCursorMode < ScrollMode
+  register_keymap do |k|
+    ## overwrite scrollmode binding on arrow keys for cursor movement
+    ## but j and k still scroll!
+    k.add :cursor_down, "Move cursor down one line", :down, 'j'
+    k.add :cursor_up, "Move cursor up one line", :up, 'k'
+    k.add :select, "Select this item", :enter
+  end
+
+  attr_reader :curpos
+
+  def initialize cursor_top=0, opts={}
+    @cursor_top = cursor_top
+    @curpos = cursor_top
+    super opts
+  end
+
+  def draw
+    super
+    set_status
+  end
+
+protected
+
+  def draw_line ln, opts={}
+    if ln == @curpos
+      super ln, :highlight => true, :debug => opts[:debug]
+    else
+      super
+    end
+  end
+
+  def ensure_mode_validity
+    super
+    raise @curpos.inspect unless @curpos.is_a?(Integer)
+    c = @curpos.clamp topline, botline - 1
+    c = @cursor_top if c < @cursor_top
+    buffer.mark_dirty unless c == @curpos
+    @curpos = c
+  end
+
+  def set_cursor_pos p
+    return if @curpos == p
+    @curpos = p.clamp @cursor_top, lines
+    buffer.mark_dirty
+  end
+
+  def line_down # overwrite scrollmode
+    super
+    set_cursor_pos topline if @curpos < topline
+  end
+
+  def line_up # overwrite scrollmode
+    super
+    set_cursor_pos botline - 1 if @curpos > botline - 1
+  end
+
+  def cursor_down
+    return false unless @curpos < lines - 1
+    if @curpos >= botline - 1
+      page_down
+      set_cursor_pos [topline + 1, botline].min
+    else
+      @curpos += 1
+      unless buffer.dirty?
+        draw_line @curpos - 1
+        draw_line @curpos
+        set_status
+        buffer.commit
+      end
+    end
+    true
+  end
+
+  def cursor_up
+    return false unless @curpos > @cursor_top
+    if @curpos == topline
+      page_up
+      set_cursor_pos [botline - 2, topline].max
+#      raise "cursor position now #@curpos, topline #{topline} botline #{botline}"
+    else
+      @curpos -= 1
+      unless buffer.dirty?
+        draw_line @curpos + 1
+        draw_line @curpos
+        set_status
+        buffer.commit
+      end
+    end
+    true
+  end
+
+  def page_up # overwrite
+    if topline <= @cursor_top
+      set_cursor_pos @cursor_top
+    else
+      relpos = @curpos - topline
+      super
+      set_cursor_pos topline + relpos
+    end
+  end
+
+  def page_down
+    if topline >= lines - buffer.content_height
+      set_cursor_pos(lines - 1)
+    else
+      relpos = @curpos - topline
+      super
+      set_cursor_pos [topline + relpos, lines - 1].min
+    end
+  end
+
+  def jump_to_home
+    super
+    set_cursor_pos @cursor_top
+  end
+
+  def jump_to_end
+    super if topline < (lines - buffer.content_height)
+    set_cursor_pos(lines - 1)
+  end
+
+private
+
+  def set_status
+    @status = "line #{@curpos + 1} of #{lines}"
+  end
+
+end
+
+end

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

@@ -0,0 +1,44 @@
+module Redwood
+
+class LogMode < TextMode
+  register_keymap do |k|
+    k.add :toggle_follow, "Toggle follow mode", 'f'
+  end
+
+  def initialize
+    @follow = true
+    super ""
+  end
+
+  def toggle_follow
+    @follow = !@follow
+    if buffer
+      if @follow
+        jump_to_line lines - buffer.content_height + 1 # leave an empty line at bottom
+      end
+      buffer.mark_dirty
+    end
+  end
+
+  def text= t
+    super
+    if buffer && @follow
+      follow_top = lines - buffer.content_height + 1
+      jump_to_line follow_top if topline < follow_top
+    end
+  end
+
+  def << line
+    super
+    if buffer && @follow
+      follow_top = lines - buffer.content_height + 1
+      jump_to_line follow_top if topline < follow_top
+    end
+  end
+
+  def status
+    super + " (follow: #@follow)"
+  end
+end
+
+end

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

@@ -0,0 +1,29 @@
+module Redwood
+
+class PersonSearchResultsMode < ThreadIndexMode
+  register_keymap do |k|
+    k.add :load_more_threads, "Load #{LOAD_MORE_THREAD_NUM} more threads", 'M'
+  end
+
+  def initialize people
+    @people = people
+    super
+  end
+
+  def is_relevant? m; @people.any? { |p| m.from == p }; end
+
+  def load_more_threads n=ThreadIndexMode::LOAD_MORE_THREAD_NUM
+    load_n_threads_background n, :participants => @people,
+                                 :load_killed => true,
+                                 :load_spam => false,
+                                 :when_done =>(lambda do |num|
+      if num > 0
+        BufferManager.flash "Found #{num} threads"
+      else
+        BufferManager.flash "No matches"
+      end
+    end)
+  end
+end
+
+end

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

@@ -0,0 +1,24 @@
+module Redwood
+
+class PollMode < LogMode
+  def initialize
+    @new = true
+    super
+  end
+
+  def puts s=""
+    self << s + "\n"
+#    if lines % 5 == 0
+      BufferManager.draw_screen
+#    end
+  end
+
+  def poll
+    puts unless @new
+    @new = false
+    puts "poll started at #{Time.now}"
+    PollManager.poll { |s| puts s }
+  end
+end
+
+end

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

@@ -0,0 +1,136 @@
+module Redwood
+
+class ReplyMode < EditMessageMode
+  REPLY_TYPES = [:sender, :list, :all, :user]
+  TYPE_DESCRIPTIONS = {
+    :sender => "Reply to sender",
+    :all => "Reply to all",
+    :list => "Reply to mailing list",
+    :user => "Customized reply"
+  }
+
+  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
+
+  def initialize message
+    super 2, :twiddles => false
+    @m = message
+
+    from =
+      if @m.recipient_email
+        AccountManager.account_for(@m.recipient_email)
+      else
+        (@m.to + @m.cc).argfind { |p| AccountManager.is_account? p }
+      end || AccountManager.default_account
+
+    from_email = @m.recipient_email || from.email
+
+    ## ignore reply-to for list messages because it's typically set to
+    ## the list address anyways
+    to = @m.is_list_message? ? @m.from : (@m.replyto || @m.from)
+    cc = (@m.to + @m.cc - [from, to]).uniq
+
+    @headers = {}
+    @headers[:sender] = {
+      "From" => "#{from.name} <#{from_email}>",
+      "To" => [to.full_address],
+    }
+
+    @headers[:user] = {
+      "From" => "#{from.name} <#{from_email}>",
+      "To" => "",
+    }
+
+    @headers[:all] = {
+      "From" => "#{from.name} <#{from_email}>",
+      "To" => [to.full_address],
+      "Cc" => cc.map { |p| p.full_address },
+    } unless cc.empty?
+
+    @headers[:list] = {
+      "From" => "#{from.name} <#{from_email}>",
+      "To" => [@m.list_address.full_address],
+    } if @m.is_list_message?
+
+    refs = gen_references
+    mid = gen_message_id
+    @headers.each do |k, v|
+      @headers[k] = v.merge({
+               "In-Reply-To" => "<#{@m.id}>",
+               "Subject" => Message.reify_subj(@m.subj),
+               "Message-Id" => mid,
+               "References" => refs,
+             })
+    end
+
+    @type_labels = REPLY_TYPES.select { |t| @headers.member?(t) }
+    @selected_type = @m.is_list_message? ? :list : :sender
+
+    @body = reply_body_lines(message) + sig_lines
+    regen_text
+  end
+
+  def lines; @text.length + 2; end
+  def [] i
+    case i
+    when 0
+      lame = []
+      @type_labels.each do |t|
+        lame << [(t == @selected_type ? :none_highlight : :none), 
+          "#{TYPE_DESCRIPTIONS[t]}"]
+        lame << [:none, "  "]
+      end
+      lame + [[:none, ""]]
+    when 1
+      ""
+    else
+      @text[i - 2]
+    end
+  end
+
+protected
+
+  def body; @body; end
+  def header; @headers[@selected_type]; end
+
+  def reply_body_lines m
+    lines = ["Excerpts from #{@m.from.name}'s message of #{@m.date}:"] + 
+      m.basic_body_lines.map { |l| "> #{l}" }
+    lines.pop while lines.last !~ /[:alpha:]/
+    lines
+  end
+
+  def handle_new_text new_header, new_body
+    @body = new_body
+
+    if new_header.size != header.size ||
+        header.any? { |k, v| new_header[k] != v }
+      @selected_type = :user
+      @headers[:user] = new_header
+    end
+  end
+
+  def regen_text
+    @text = header_lines(@headers[@selected_type] - NON_EDITABLE_HEADERS) + [""] + @body
+  end
+
+  def gen_references
+    (@m.refs + [@m.id]).map { |x| "<#{x}>" }.join(" ")
+  end
+  
+  def move_cursor_left
+    i = @type_labels.index @selected_type
+    @selected_type = @type_labels[(i - 1) % @type_labels.length]
+    update
+  end
+
+  def move_cursor_right
+    i = @type_labels.index @selected_type
+    @selected_type = @type_labels[(i + 1) % @type_labels.length]
+    update
+  end
+end
+
+end