sup 0.1 → 0.2

data/lib/sup/message.rb

@@ -15,9 +15,8 @@ class MessageFormatError < StandardError; end
 ## sequences in the text of an email. (how sweet would that be?)
 class Message
   SNIPPET_LEN = 80
-  WRAP_LEN = 80 # wrap at this width
   RE_PATTERN = /^((re|re[\[\(]\d[\]\)]):\s*)+/i
-    
+
   ## some utility methods
   class << self
     def normalize_subj s; s.gsub(RE_PATTERN, ""); end
@@ -25,63 +24,13 @@ class Message
     def reify_subj s; subj_is_reply?(s) ? s : "Re: " + s; end
   end
 
-  class Attachment
-    attr_reader :content_type, :filename, :content, :lines
-    def initialize content_type, filename, content
-      @content_type = content_type
-      @filename = filename
-      @content = content
-
-      if inlineable?
-        @lines = to_s.split("\n")
-      end
-    end
-
-    def view!
-      file = Tempfile.new "redwood.attachment"
-      file.print raw_content
-      file.close
-
-      system "/usr/bin/run-mailcap --action=view #{@content_type}:#{file.path} >& /dev/null"
-      $? == 0
-    end
-
-    def to_s; Message.decode_and_convert @content; end
-    def raw_content; @content.decode end
-
-    def inlineable?; @content_type =~ /^text\/plain/ end
-  end
-
-  class Text
-    attr_reader :lines
-    def initialize lines
-      ## do some wrapping
-      @lines = lines.map { |l| l.chomp.wrap WRAP_LEN }.flatten
-    end
-  end
-
-  class Quote
-    attr_reader :lines
-    def initialize lines
-      @lines = lines
-    end
-  end
-
-  class Signature
-    attr_reader :lines
-    def initialize lines
-      @lines = lines
-    end
-  end
-
-
   QUOTE_PATTERN = /^\s{0,4}[>|\}]/
   BLOCK_QUOTE_PATTERN = /^-----\s*Original Message\s*----+$/
   QUOTE_START_PATTERN = /(^\s*Excerpts from)|(^\s*In message )|(^\s*In article )|(^\s*Quoting )|((wrote|writes|said|says)\s*:\s*$)/
-  SIG_PATTERN = /(^-- ?$)|(^\s*----------+\s*$)|(^\s*_________+\s*$)|(^\s*--~--~-)/
+  SIG_PATTERN = /(^-- ?$)|(^\s*----------+\s*$)|(^\s*_________+\s*$)|(^\s*--~--~-)|(^\s*--\+\+\*\*==)/
 
   MAX_SIG_DISTANCE = 15 # lines from the end
-  DEFAULT_SUBJECT = "(missing subject)"
+  DEFAULT_SUBJECT = ""
   DEFAULT_SENDER = "(missing sender)"
 
   attr_reader :id, :date, :from, :subj, :refs, :replytos, :to, :source,
@@ -90,8 +39,8 @@ class Message
 
   bool_reader :dirty, :source_marked_read
 
-  ## if you specify a :header, will use values from that. otherwise, will try and
-  ## load the header from the source.
+  ## if you specify a :header, will use values from that. otherwise,
+  ## will try and load the header from the source.
   def initialize opts
     @source = opts[:source] or raise ArgumentError, "source can't be nil"
     @source_info = opts[:source_info] or raise ArgumentError, "source_info can't be nil"
@@ -101,32 +50,45 @@ class Message
     @dirty = false
     @chunks = nil
 
-    read_header(opts[:header] || @source.load_header(@source_info))
+    parse_header(opts[:header] || @source.load_header(@source_info))
   end
 
-  def read_header header
+  def parse_header header
     header.each { |k, v| header[k.downcase] = v }
+    
+    @from = PersonManager.person_for header["from"]
 
-    %w(message-id date).each do |f|
-      raise MessageFormatError, "no #{f} field in header #{header.inspect} (source #@source offset #@source_info)" unless header.include? f
-      raise MessageFormatError, "nil #{f} field in header #{header.inspect} (source #@source offset #@source_info)" unless header[f]
-    end
-
-    begin
-      date = header["date"]
-      @date = Time === date ? date : Time.parse(header["date"])
-    rescue ArgumentError => e
-      raise MessageFormatError, "unparsable date #{header['date']}: #{e.message}"
-    end
+    @id =
+      if header["message-id"]
+        sanitize_message_id header["message-id"]
+      else
+        "sup-faked-" + Digest::MD5.hexdigest(raw_header)
+        Redwood::log "faking message-id for message from #@from: #@id"
+      end
+    
+    date = header["date"]
+    @date =
+      case date
+      when Time
+        date
+      when String
+        begin
+          Time.parse date
+        rescue ArgumentError => e
+          raise MessageFormatError, "unparsable date #{header['date']}: #{e.message}"
+        end
+      else
+        Redwood::log "faking date header for #{@id}"
+        Time.now
+      end
 
     @subj = header.member?("subject") ? header["subject"].gsub(/\s+/, " ").gsub(/\s+$/, "") : DEFAULT_SUBJECT
-    @from = PersonManager.person_for header["from"]
     @to = PersonManager.people_for header["to"]
     @cc = PersonManager.people_for header["cc"]
     @bcc = PersonManager.people_for header["bcc"]
-    @id = header["message-id"]
-    @refs = (header["references"] || "").gsub(/[<>]/, "").split(/\s+/).flatten
-    @replytos = (header["in-reply-to"] || "").scan(/<(.*?)>/).flatten
+    @refs = (header["references"] || "").scan(/<(.+?)>/).map { |x| sanitize_message_id x.first }
+    @replytos = (header["in-reply-to"] || "").scan(/<(.+?)>/).map { |x| sanitize_message_id x.first }
+
     @replyto = PersonManager.person_for header["reply-to"]
     @list_address =
       if header["list-post"]
@@ -138,7 +100,7 @@ class Message
     @recipient_email = header["envelope-to"] || header["x-original-to"] || header["delivered-to"]
     @source_marked_read = header["status"] == "RO"
   end
-  private :read_header
+  private :parse_header
 
   def snippet; @snippet || chunks && @snippet; end
   def is_list_message?; !@list_address.nil?; end
@@ -148,6 +110,8 @@ class Message
     @source.fn_for_offset @source_info
   end
 
+  def sanitize_message_id mid; mid.gsub(/\s/, "") end
+
   def save index
     index.sync_message self if @dirty
     @dirty = false
@@ -178,7 +142,7 @@ class Message
   def load_from_source!
     @chunks ||=
       if @source.has_errors?
-        [Text.new(error_message(@source.error.message.split("\n")))]
+        [Chunk::Text.new(error_message(@source.error.message.split("\n")))]
       else
         begin
           ## we need to re-read the header because it contains information
@@ -189,14 +153,14 @@ class Message
           ## bloat the index.
           ## actually, it's also the differentiation between to/cc/bcc,
           ## so i will keep this.
-          read_header @source.load_header(@source_info)
+          parse_header @source.load_header(@source_info)
           message_to_chunks @source.load_message(@source_info)
         rescue SourceError, SocketError, MessageFormatError => e
           Redwood::log "problem getting messages from #{@source}: #{e.message}"
           ## we need force_to_top here otherwise this window will cover
           ## up the error message one
           Redwood::report_broken_sources :force_to_top => true
-          [Text.new(error_message(e.message))]
+          [Chunk::Text.new(error_message(e.message))]
         end
       end
   end
@@ -220,22 +184,26 @@ The error message was:
 EOS
   end
 
-  def raw_header
+  def with_source_errors_handled
     begin
-      @source.raw_header @source_info
+      yield
     rescue SourceError => e
       Redwood::log "problem getting messages from #{@source}: #{e.message}"
       error_message e.message
     end
   end
 
-  def raw_full_message
-    begin
-      @source.raw_full_message @source_info
-    rescue SourceError => e
-      Redwood::log "problem getting messages from #{@source}: #{e.message}"
-      error_message(e.message)
-    end
+  def raw_header
+    with_source_errors_handled { @source.raw_header @source_info }
+  end
+
+  def raw_message
+    with_source_errors_handled { @source.raw_message @source_info }
+  end
+
+  ## much faster than raw_message
+  def each_raw_message_line &b
+    with_source_errors_handled { @source.each_raw_message_line(@source_info, &b) }
   end
 
   def content
@@ -245,13 +213,13 @@ EOS
       to.map { |p| "#{p.name} #{p.email}" },
       cc.map { |p| "#{p.name} #{p.email}" },
       bcc.map { |p| "#{p.name} #{p.email}" },
-      chunks.select { |c| c.is_a? Text }.map { |c| c.lines },
+      chunks.select { |c| c.is_a? Chunk::Text }.map { |c| c.lines },
       Message.normalize_subj(subj),
     ].flatten.compact.join " "
   end
 
   def basic_body_lines
-    chunks.find_all { |c| c.is_a?(Text) || c.is_a?(Quote) }.map { |c| c.lines }.flatten
+    chunks.find_all { |c| c.is_a?(Chunk::Text) || c.is_a?(Chunk::Quote) }.map { |c| c.lines }.flatten
   end
 
   def basic_header_lines
@@ -274,18 +242,95 @@ private
   ## the general behavior i want is: ignore content-disposition, at
   ## least in so far as it suggests something being inline vs being an
   ## attachment. (because really, that should be the recipient's
-  ## decision to make.) if a mime part is text/plain, then decode it
-  ## and display it inline. if it has associated filename, then make
-  ## it collapsable and individually saveable; otherwise, treat it as
-  ## regular body text.
+  ## decision to make.) if a mime part is text/plain, OR if the user
+  ## decoding hook converts it, then decode it and display it
+  ## inline. for these decoded attachments, if it has associated
+  ## filename, then make it collapsable and individually saveable;
+  ## otherwise, treat it as regular body text.
+  ##
+  ## everything else is just an attachment and is not displayed
+  ## inline.
   ##
   ## so, in contrast to mutt, the user is not exposed to the workings
   ## of the gruesome slaughterhouse and sausage factory that is a
   ## mime-encoded message, but need only see the delicious end
   ## product.
-  def message_to_chunks m
+
+  def multipart_signed_to_chunks m
+#    Redwood::log ">> multipart SIGNED: #{m.header['Content-Type']}: #{m.body.size}"
+    if m.body.size != 2
+      Redwood::log "warning: multipart/signed with #{m.body.size} parts (expecting 2)"
+      return
+    end
+
+    payload, signature = m.body
+    if signature.multipart?
+      Redwood::log "warning: multipart/signed with payload multipart #{payload.multipart?} and signature multipart #{signature.multipart?}"
+      return
+    end
+
+    if payload.header.content_type == "application/pgp-signature"
+      Redwood::log "warning: multipart/signed with payload content type #{payload.header.content_type}"
+      return
+    end
+
+    if signature.header.content_type != "application/pgp-signature"
+      Redwood::log "warning: multipart/signed with signature content type #{signature.header.content_type}"
+      return
+    end
+
+    [CryptoManager.verify(payload, signature), message_to_chunks(payload)].flatten.compact
+  end
+
+  def multipart_encrypted_to_chunks m
+    Redwood::log ">> multipart ENCRYPTED: #{m.header['Content-Type']}: #{m.body.size}"
+    if m.body.size != 2
+      Redwood::log "warning: multipart/encrypted with #{m.body.size} parts (expecting 2)"
+      return
+    end
+
+    control, payload = m.body
+    if control.multipart?
+      Redwood::log "warning: multipart/encrypted with control multipart #{control.multipart?} and payload multipart #{payload.multipart?}"
+      return
+    end
+
+    if payload.header.content_type != "application/octet-stream"
+      Redwood::log "warning: multipart/encrypted with payload content type #{payload.header.content_type}"
+      return
+    end
+
+    if control.header.content_type != "application/pgp-encrypted"
+      Redwood::log "warning: multipart/encrypted with control content type #{signature.header.content_type}"
+      return
+    end
+
+    decryptedm, sig, notice = CryptoManager.decrypt payload
+    children = message_to_chunks(decryptedm) if decryptedm
+    [notice, sig, children].flatten.compact
+  end
+
+  def message_to_chunks m, sibling_types=[]
     if m.multipart?
-      m.body.map { |p| message_to_chunks p }.flatten.compact # recurse
+      chunks =
+        case m.header.content_type
+        when "multipart/signed"
+          multipart_signed_to_chunks m
+        when "multipart/encrypted"
+          multipart_encrypted_to_chunks m
+        end
+
+      unless chunks
+        sibling_types = m.body.map { |p| p.header.content_type }
+        chunks = m.body.map { |p| message_to_chunks p, sibling_types }.flatten.compact
+      end
+
+      chunks
+    elsif m.header.content_type == "message/rfc822"
+      payload = RMail::Parser.read(m.body)
+      from = payload.header.from.first
+      from_person = from ? PersonManager.person_for(from.format) : nil
+      [Chunk::EnclosedMessage.new(from_person, payload.to_s)]
     else
       filename =
         ## first, paw through the headers looking for a filename
@@ -304,32 +349,26 @@ private
 
       ## if there's a filename, we'll treat it as an attachment.
       if filename
-        [Attachment.new(m.header.content_type, filename, m)]
+        [Chunk::Attachment.new(m.header.content_type, filename, m, sibling_types)]
 
       ## otherwise, it's body text
       else
-        body = Message.decode_and_convert m
+        body = Message.convert_from m.decode, m.charset
         text_to_chunks body.normalize_whitespace.split("\n")
       end
     end
   end
 
-  def self.decode_and_convert m
-    charset =
-      if m.header.field?("content-type") && m.header.fetch("content-type") =~ /charset=(.*?)(;|$)/
-        $1
-      end
-
-    m.body && body = m.decode or raise MessageFormatError, "For some bizarre reason, RubyMail was unable to parse this message."
+  def self.convert_from body, charset
+    return body unless charset
 
-    if charset
-      begin
-        body = Iconv.iconv($encoding, charset, body).join
-      rescue Errno::EINVAL, Iconv::InvalidEncoding, Iconv::IllegalSequence => e
-        Redwood::log "warning: error decoding message body from #{charset}: #{e.message}"
-      end
+    begin
+      Iconv.iconv($encoding, charset, body).join
+    rescue Errno::EINVAL, Iconv::InvalidEncoding, Iconv::IllegalSequence => e
+      Redwood::log "warning: error (#{e.class.name}) decoding message body from #{charset}: #{e.message}"
+      File.open("sup-unable-to-decode.txt", "w") { |f| f.write body }
+      body
     end
-    body
   end
 
   ## parse the lines of text into chunk objects.  the heuristics here
@@ -356,7 +395,7 @@ private
         end
 
         if newstate
-          chunks << Text.new(chunk_lines) unless chunk_lines.empty?
+          chunks << Chunk::Text.new(chunk_lines) unless chunk_lines.empty?
           chunk_lines = [line]
           state = newstate
         else
@@ -378,7 +417,7 @@ private
           if chunk_lines.empty?
             # nothing
           else
-            chunks << Quote.new(chunk_lines)
+            chunks << Chunk::Quote.new(chunk_lines)
           end
           chunk_lines = [line]
           state = newstate
@@ -398,11 +437,11 @@ private
     ## final object
     case state
     when :quote, :block_quote
-      chunks << Quote.new(chunk_lines) unless chunk_lines.empty?
+      chunks << Chunk::Quote.new(chunk_lines) unless chunk_lines.empty?
     when :text
-      chunks << Text.new(chunk_lines) unless chunk_lines.empty?
+      chunks << Chunk::Text.new(chunk_lines) unless chunk_lines.empty?
     when :sig
-      chunks << Signature.new(chunk_lines) unless chunk_lines.empty?
+      chunks << Chunk::Signature.new(chunk_lines) unless chunk_lines.empty?
     end
     chunks
   end

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

@@ -1,5 +1,17 @@
 module Redwood
 
+module CanSpawnComposeMode
+  def spawn_compose_mode opts={}
+    to = opts[:to] || BufferManager.ask_for_contacts(:people, "To: ") or return
+    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]
+    
+    mode = ComposeMode.new :to => to, :cc => cc, :bcc => bcc
+    BufferManager.spawn "New Message", mode
+    mode.edit_message
+  end
+end
+
 class ComposeMode < EditMessageMode
   def initialize opts={}
     header = {
@@ -13,6 +25,12 @@ class ComposeMode < EditMessageMode
 
     super :header => header, :body => (opts[:body] || [])
   end
+
+  def edit_message
+    edited = super
+    BufferManager.kill_buffer self.buffer unless edited
+    edited
+  end
 end
 
 end

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

@@ -67,7 +67,7 @@ class ContactListMode < LineCursorMode
     when :regular
       mode = ComposeMode.new :to => people
       BufferManager.spawn "new message", mode
-      mode.edit
+      mode.edit_message
     end
   end