sup 0.0.1

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

@@ -0,0 +1,338 @@
+module Redwood
+
+class ThreadViewMode < LineCursorMode
+  DATE_FORMAT = "%B %e %Y %l:%M%P"
+
+  register_keymap do |k|
+    k.add :toggle_detailed_header, "Toggle detailed header", 'd'
+    k.add :show_header, "Show full message header", 'H'
+    k.add :toggle_expanded, "Expand/collapse item", :enter
+    k.add :expand_all_messages, "Expand/collapse all messages", 'E'
+    k.add :edit_message, "Edit message (drafts only)", 'e'
+    k.add :expand_all_quotes, "Expand/collapse all quotes in a message", 'o'
+    k.add :jump_to_next_open, "Jump to next open message", 'n'
+    k.add :jump_to_prev_open, "Jump to previous open message", 'p'
+    k.add :toggle_starred, "Star or unstar message", '*'
+    k.add :collapse_non_new_messages, "Collapse all but new messages", 'N'
+    k.add :reply, "Reply to a message", 'r'
+    k.add :forward, "Forward a message", 'f'
+  end
+
+  def initialize thread, hidden_labels=[]
+    super()
+    @thread = thread
+    @state = {}
+    @hidden_labels = hidden_labels
+
+    earliest = nil
+    latest = nil
+    latest_date = nil
+    @thread.each do |m, d, p|
+      next unless m
+      earliest ||= m
+      @state[m] = 
+        if m.has_label?(:unread) && m == earliest
+          :detailed
+        elsif m.has_label?(:starred) || m.has_label?(:unread)
+          :open
+        else
+          :closed
+        end
+      if latest_date.nil? || m.date > latest_date
+        latest_date = m.date
+        latest = m
+      end
+    end
+    @state[latest] = :open if @state[latest] == :closed
+
+    regen_chunks
+    regen_text
+  end
+
+  def draw_line ln, opts={}
+    if ln == curpos
+      super ln, :highlight => true
+    else
+      super
+    end
+  end
+  def lines; @text.length; end
+  def [] i; @text[i]; end
+
+  def show_header
+    return unless(m = @message_lines[curpos])
+    BufferManager.spawn_unless_exists("Full header") do
+      TextMode.new m.content #m.header_text
+    end
+  end
+
+  def toggle_detailed_header
+    return unless(m = @message_lines[curpos])
+    @state[m] = (@state[m] == :detailed ? :open : :detailed)
+    update
+  end
+
+  def reply
+    return unless(m = @message_lines[curpos])
+    mode = ReplyMode.new m
+    BufferManager.spawn "Reply to #{m.subj}", mode
+  end
+
+  def forward
+    return unless(m = @message_lines[curpos])
+    mode = ForwardMode.new m
+    BufferManager.spawn "Forward of #{m.subj}", mode
+    mode.edit
+  end
+
+  def toggle_starred
+    return unless(m = @message_lines[curpos])
+    if m.has_label? :starred
+      m.remove_label :starred
+    else
+      m.add_label :starred
+    end
+    ## TODO: don't recalculate EVERYTHING just to add a stupid little
+    ## star to the display
+    update
+    UpdateManager.relay :starred, m
+  end
+
+  def toggle_expanded
+    return unless(chunk = @chunk_lines[curpos])
+    case chunk
+    when Message, Message::Quote, Message::Signature
+      @state[chunk] = (@state[chunk] != :closed ? :closed : :open)
+    when Message::Attachment
+      view_attachment chunk
+    end
+    update
+  end
+
+  def edit_message
+    return unless(m = @message_lines[curpos])
+    if m.is_draft?
+      mode = ResumeMode.new m
+      BufferManager.spawn "Edit message", mode
+    else
+      BufferManager.flash "Not a draft message!"
+    end
+  end
+
+  def jump_to_next_open
+    return unless(m = @message_lines[curpos])
+    while nextm = @messages[m][3]
+      break if @state[nextm] == :open
+      m = nextm
+    end
+    jump_to_message nextm if nextm
+  end
+
+  def jump_to_prev_open
+    return unless(m = @message_lines[curpos])
+    ## jump to the top of the current message if we're in the body;
+    ## otherwise, to the previous message
+    top = @messages[m][0]
+    if curpos == top
+      while prevm = @messages[m][2]
+        break if @state[prevm] == :open
+        m = prevm
+      end
+      jump_to_message prevm if prevm
+    else
+      jump_to_message m
+    end
+  end
+
+  def jump_to_message m
+    top, bot, prevm, nextm = @messages[m]
+    jump_to_line top unless top >= topline &&
+      top <= botline && bot >= topline && bot <= botline
+    set_cursor_pos top
+  end
+
+  def expand_all_messages
+    @global_message_state ||= :closed
+    @global_message_state = (@global_message_state == :closed ? :open : :closed)
+    @state.each { |m, v| @state[m] = @global_message_state if m.is_a? Message }
+    update
+  end
+
+
+  def collapse_non_new_messages
+    @messages.each { |m, v| @state[m] = m.has_label?(:unread) ? :open : :closed }
+    update
+  end
+
+  def expand_all_quotes
+    if(m = @message_lines[curpos])
+      quotes = @chunks[m].select { |c| c.is_a?(Message::Quote) || c.is_a?(Message::Signature) }
+      open, closed = quotes.partition { |c| @state[c] == :open }
+      newstate = open.length > closed.length ? :closed : :open
+      Redwood::log "#{open.length} opened, #{closed.length} closed, new state is thus #{newstate}"
+      quotes.each { |c| @state[c] = newstate }
+      update
+    end
+  end
+
+  ## not sure if this is really necessary but we might as well...
+  def cleanup
+    @thread.each do |m, d, p|
+      if m.has_label? :unread
+        m.remove_label :unread 
+        UpdateManager.relay :read, m
+      end
+    end
+
+    Redwood::log "releasing chunks and text from \"#{buffer.title}\""
+    @messages = @chunks = @text = nil
+  end
+
+private 
+
+  def update
+    regen_text
+    buffer.mark_dirty if buffer
+  end
+
+  def regen_chunks
+    @chunks = {}
+    @thread.each { |m, d, p| @chunks[m] = m.to_chunks if m.is_a?(Message) }
+  end
+  
+  def regen_text
+    @text = []
+    @chunk_lines = []
+    @message_lines = []
+    @messages = {}
+
+    prev_m = nil
+    @thread.each do |m, depth, parent|
+      text = chunk_to_lines m, @state[m], @text.length, depth, parent
+      (0 ... text.length).each do |i|
+        @chunk_lines[@text.length + i] = m
+        @message_lines[@text.length + i] = m
+      end
+
+      @messages[m] = [@text.length, @text.length + text.length, prev_m, nil]
+      @messages[prev_m][3] = m if prev_m
+      prev_m = m
+
+      @text += text
+      if @state[m] != :closed && @chunks.member?(m)
+        @chunks[m].each do |c|
+          @state[c] ||= :closed
+          text = chunk_to_lines c, @state[c], @text.length, depth
+          (0 ... text.length).each do |i|
+            @chunk_lines[@text.length + i] = c
+            @message_lines[@text.length + i] = m
+          end
+          @text += text
+        end
+        @messages[m][1] = @text.length
+      end
+    end
+  end
+
+  def message_patina_lines m, state, parent, prefix
+    prefix_widget = [:message_patina_color, prefix]
+    widget = 
+      case state
+      when :closed
+        [:message_patina_color, "+ "]
+      when :open, :detailed
+        [:message_patina_color, "- "]
+      end
+    imp_widget = 
+      if m.has_label?(:starred)
+        [:starred_patina_color, "* "]
+      else
+        [:message_patina_color, "  "]
+      end
+
+    case state
+    when :open
+      [[prefix_widget, widget, imp_widget,
+        [:message_patina_color, 
+            "#{m.from ? m.from.mediumname : '?'} to #{m.to.map { |l| l.shortname }.join(', ')} #{m.date.to_nice_s} (#{m.date.to_nice_distance_s})"]]]
+#        (m.to.empty? ? [] : [[[:message_patina_color, prefix + "    To: " + m.recipients.map { |x| x.mediumname }.join(", ")]]]) +
+    when :closed
+      [[prefix_widget, widget, imp_widget,
+        [:message_patina_color, 
+        "#{m.from ? m.from.mediumname : '?'}, #{m.date.to_nice_s} (#{m.date.to_nice_distance_s})  #{m.snippet}"]]]
+    when :detailed
+      labels = m.labels# - @hidden_labels
+      x = [[prefix_widget, widget, imp_widget, [:message_patina_color, "From: #{m.from ? m.from.longname : '?'}"]]] +
+        ((m.to.empty? ? [] : break_into_lines("  To: ", m.to.map { |x| x.longname })) +
+              (m.cc.empty? ? [] : break_into_lines("  Cc: ", m.cc.map { |x| x.longname })) +
+              (m.bcc.empty? ? [] : break_into_lines(" Bcc: ", m.bcc.map { |x| x.longname })) +
+              ["  Date: #{m.date.strftime DATE_FORMAT} (#{m.date.to_nice_distance_s})"] +
+              ["  Subject: #{m.subj}"] +
+              [(parent ? "  In reply to: #{parent.from.mediumname}'s message of #{parent.date.strftime DATE_FORMAT}" : nil)] +
+              [labels.empty? ? nil : "  Labels: #{labels.join(', ')}"]
+            ).flatten.compact.map { |l| [[:message_patina_color, prefix + "  " + l]] }
+      #raise x.inspect
+      x
+    end
+  end
+
+  def break_into_lines prefix, list
+    pad = " " * prefix.length
+    [prefix + list.first + (list.length > 1 ? "," : "")] + 
+      list[1 .. -1].map_with_index do |e, i|
+        pad + e + (i == list.length - 1 ? "" : ",")
+      end
+  end
+
+
+  def chunk_to_lines chunk, state, start, depth, parent=nil
+    prefix = "  " * depth
+    case chunk
+    when :fake_root
+      [[[:message_patina_color, "#{prefix}<one or more unreceived messages>"]]]
+    when nil
+      [[[:message_patina_color, "#{prefix}<an unreceived message>"]]]
+    when Message
+      message_patina_lines(chunk, state, parent, prefix) +
+        (chunk.is_draft? ? [[[:draft_notification_color, prefix + " >>> This message is a draft. To edit, hit 'e'. <<<"]]] : [])
+
+    when Message::Attachment
+      [[[:mime_color, "#{prefix}+ MIME attachment #{chunk.content_type}#{chunk.desc ? ' (' + chunk.desc + ')': ''}"]]]
+    when Message::Text
+      t = chunk.lines
+      if t.last =~ /^\s*$/
+        t.pop while t[t.length - 2] =~ /^\s*$/
+      end
+      t.map { |line| [[:none, "#{prefix}#{line}"]] }
+    when Message::Quote
+      case state
+      when :closed
+        [[[:quote_patina_color, "#{prefix}+ #{chunk.lines.length} quoted lines"]]]
+      when :open
+        t = chunk.lines
+        [[[:quote_patina_color, "#{prefix}- #{chunk.lines.length} quoted lines"]]] +
+           t.map { |line| [[:quote_color, "#{prefix}#{line}"]] }
+      end
+    when Message::Signature
+      case state
+      when :closed
+        [[[:sig_patina_color, "#{prefix}+ #{chunk.lines.length}-line signature"]]]
+      when :open
+        t = chunk.lines
+        [[[:sig_patina_color, "#{prefix}- #{chunk.lines.length}-line signature"]]] +
+           t.map { |line| [[:sig_color, "#{prefix}#{line}"]] }
+      end
+    else
+      raise "unknown chunk type #{chunk.class.name}"
+    end
+  end
+
+  def view_attachment a
+    BufferManager.flash "viewing #{a.content_type} attachment..."
+    a.view!
+    BufferManager.erase_flash
+  end
+
+end
+
+end

data/lib/sup/person.rb

@@ -0,0 +1,120 @@
+module Redwood
+
+class Person
+  @@email_map = {}
+
+  attr_accessor :name, :email
+
+  def initialize name, email
+    raise ArgumentError, "email can't be nil" unless email
+    @name = 
+      if name
+        name.gsub(/^\s+|\s+$/, "").gsub(/\s+/, " ")
+      else
+        nil
+      end
+    @email = email.gsub(/^\s+|\s+$/, "").gsub(/\s+/, " ").downcase
+    @@email_map[@email] = self
+  end
+
+  def == o; o && o.email == email; end
+  alias :eql? :==
+
+  def hash
+    [name, email].hash
+  end
+
+  def shortname
+    case @name
+    when /\S+, (\S+)/
+      $1
+    when /(\S+) \S+/
+      $1
+    when nil
+      @email #[0 ... 10]
+    else
+      @name #[0 ... 10]
+    end
+  end
+
+  def longname
+    if @name && @email
+      "#@name <#@email>"
+    else
+      @email
+    end
+  end
+
+  def mediumname
+    if @name
+      name
+    else
+      @email
+    end
+  end
+
+  def full_address
+    if @name && @email
+      if @name =~ /"/
+        "#{@name.inspect} <#@email>"
+      else
+        "#@name <#@email>"
+      end
+    else
+      @email
+    end
+  end
+
+  def sort_by_me
+    case @name
+    when /^(\S+), \S+/
+      $1
+    when /^\S+ \S+ (\S+)/
+      $1
+    when /^\S+ (\S+)/
+      $1
+    when nil
+      @email
+    else
+      @name
+    end.downcase
+  end
+
+  def self.for_several s
+    return [] if s.nil?
+
+    begin
+      s.split_on_commas.map { |ss| self.for ss }
+    rescue StandardError => e
+      raise "#{e.message}: for #{s.inspect}"
+    end
+  end
+
+  def self.for s
+    return nil if s.nil?
+    name, email =
+      case s
+      when /["'](.*?)["'] <(.*?)>/, /([^,]+) <(.*?)>/
+        a, b = $1, $2
+        [a.gsub('\"', '"'), b]
+      when /<((\S+?)@\S+?)>/
+        [$2, $1]
+      when /((\S+?)@\S+)/
+        [$2, $1]
+      else
+        [nil, s]
+      end
+
+    if name && (p = @@email_map[email])
+      ## all else being equal, prefer longer names, unless the prior name
+      ## doesn't contain any capitalization
+      p.name = name if (p.name.nil? || p.name.length < name.length) unless
+        p.name =~ /[A-Z]/ || (AccountManager.instantiated? && AccountManager.is_account?(p))
+      p 
+    else
+      Person.new name, email
+    end
+  end
+end
+
+end