sup 0.0.8 → 0.1

data/lib/sup/maildir.rb

@@ -11,20 +11,24 @@ module Redwood
 class Maildir < Source
   SCAN_INTERVAL = 30 # seconds
 
-  def initialize uri, last_date=nil, usual=true, archived=false, id=nil
-    super
+  yaml_properties :uri, :cur_offset, :usual, :archived, :id, :labels
+  def initialize uri, last_date=nil, usual=true, archived=false, id=nil, labels=[]
+    super uri, last_date, usual, archived, id
     uri = URI(uri)
 
     raise ArgumentError, "not a maildir URI" unless uri.scheme == "maildir"
     raise ArgumentError, "maildir URI cannot have a host: #{uri.host}" if uri.host
 
     @dir = uri.path
+    @labels = (labels || []).freeze
     @ids = []
     @ids_to_fns = {}
     @last_scan = nil
     @mutex = Mutex.new
   end
 
+  def self.suggest_labels_for path; [] end
+
   def check
     scan_mailbox
     start = @ids.index(cur_offset || start_offset) or raise OutOfSyncSourceError, "Unknown message id #{cur_offset || start_offset}." # couldn't find the most recent email
@@ -89,7 +93,7 @@ class Maildir < Source
     start.upto(@ids.length - 1) do |i|         
       id = @ids[i]
       self.cur_offset = id
-      yield id, (@ids_to_fns[id] =~ /,.*R.*$/ ? [] : [:unread])
+      yield id, @labels + (@ids_to_fns[id] =~ /,.*R.*$/ ? [] : [:unread])
     end
   end
 
@@ -122,6 +126,4 @@ private
   end
 end
 
-Redwood::register_yaml(Maildir, %w(uri cur_offset usual archived id))
-
 end

data/lib/sup/mbox.rb

@@ -1,10 +1,14 @@
 require "sup/mbox/loader"
 require "sup/mbox/ssh-file"
 require "sup/mbox/ssh-loader"
+require "sup/rfc2047"
 
 module Redwood
 
-## some utility functions
+## some utility functions. actually these are not mbox-specific at all
+## and should be moved somewhere else.
+##
+## TODO: move functionality to somewhere better, like message.rb
 module MBox
   BREAK_RE = /^From \S+/
 
@@ -16,31 +20,46 @@ module MBox
     ## when scanning over large mbox files.
     while(line = f.gets)
       case line
-      when /^(From):\s+(.*)$/i,
-        /^(To):\s+(.*)$/i,
-        /^(Cc):\s+(.*)$/i,
-        /^(Bcc):\s+(.*)$/i,
-        /^(Subject):\s+(.*)$/i,
-        /^(Date):\s+(.*)$/i,
-        /^(Message-Id):\s+<(.*)>$/i,
-        /^(References):\s+(.*)$/i,
-        /^(In-Reply-To):\s+(.*)$/i,
-        /^(Reply-To):\s+(.*)$/i,
-        /^(List-Post):\s+(.*)$/i,
-        /^(Status):\s+(.*)$/i: header[last = $1] = $2
+      when /^(From):\s+(.*?)\s*$/i,
+        /^(To):\s+(.*?)\s*$/i,
+        /^(Cc):\s+(.*?)\s*$/i,
+        /^(Bcc):\s+(.*?)\s*$/i,
+        /^(Subject):\s+(.*?)\s*$/i,
+        /^(Date):\s+(.*?)\s*$/i,
+        /^(References):\s+(.*?)\s*$/i,
+        /^(In-Reply-To):\s+(.*?)\s*$/i,
+        /^(Reply-To):\s+(.*?)\s*$/i,
+        /^(List-Post):\s+(.*?)\s*$/i,
+        /^(Status):\s+(.*?)\s*$/i: header[last = $1] = $2
+      when /^(Message-Id):\s+(.*?)\s*$/i: header[mid_field = last = $1] = $2
 
       ## these next three can occur multiple times, and we want the
       ## first one
       when /^(Delivered-To):\s+(.*)$/i,
         /^(X-Original-To):\s+(.*)$/i,
-        /^(Envelope-To):\s+(.*)$/i: header[last = $1.downcase] ||= $2
+        /^(Envelope-To):\s+(.*)$/i: header[last = $1] ||= $2
 
       when /^$/: break
-      when /:/: last = nil
+      when /:/: last = nil # some other header we don't care about
       else
         header[last] += " " + line.chomp.gsub(/^\s+/, "") if last
       end
     end
+
+    if mid_field && header[mid_field] && header[mid_field] =~ /<(.*?)>/
+      header[mid_field] = $1
+    end
+
+    header.each do |k, v|
+      next unless Rfc2047.is_encoded? v
+      header[k] =
+        begin
+          Rfc2047.decode_to $encoding, v
+        rescue Errno::EINVAL, Iconv::InvalidEncoding, Iconv::IllegalSequence => e
+          Redwood::log "warning: error decoding RFC 2047 header: #{e.message}"
+          v
+        end
+    end
     header
   end
   

data/lib/sup/mbox/loader.rb

@@ -5,26 +5,36 @@ module Redwood
 module MBox
 
 class Loader < Source
-  def initialize uri_or_fp, start_offset=nil, usual=true, archived=false, id=nil
-    super
+  yaml_properties :uri, :cur_offset, :usual, :archived, :id, :labels
+  def initialize uri_or_fp, start_offset=nil, usual=true, archived=false, id=nil, labels=[]
+    super uri_or_fp, start_offset, usual, archived, id
 
     @mutex = Mutex.new
-    @labels = [:unread]
+    @labels = (labels || []).freeze
 
     case uri_or_fp
     when String
       uri = URI(uri_or_fp)
       raise ArgumentError, "not an mbox uri" unless uri.scheme == "mbox"
       raise ArgumentError, "mbox uri ('#{uri}') cannot have a host: #{uri.host}" if uri.host
-      ## heuristic: use the filename as a label, unless the file
-      ## has a path that probably represents an inbox.
-      @labels << File.basename(uri.path).intern unless File.dirname(uri.path) =~ /\b(var|usr|spool)\b/
       @f = File.open uri.path
     else
       @f = uri_or_fp
     end
   end
 
+  def file_path; URI(uri).path end
+
+  def self.suggest_labels_for path
+    ## heuristic: use the filename as a label, unless the file
+    ## has a path that probably represents an inbox.
+    if File.dirname(path) =~ /\b(var|usr|spool)\b/
+      []
+    else
+      [File.basename(path).intern]
+    end
+  end
+
   def check
     if (cur_offset ||= start_offset) > end_offset
       raise OutOfSyncSourceError, "mbox file is smaller than last recorded message offset. Messages have probably been deleted by another client."
@@ -73,14 +83,24 @@ class Loader < Source
 
   def raw_full_message offset
     ret = ""
+    each_raw_full_message_line(offset) { |l| ret += l }
+    ret
+  end
+
+  ## apparently it's a million times faster to call this directly if
+  ## we're just moving messages around on disk, than reading things
+  ## into memory with raw_full_message.
+  ##
+  ## i hoped never to have to move shit around on disk but
+  ## sup-sync-back has to do it.
+  def each_raw_full_message_line offset
     @mutex.synchronize do
       @f.seek offset
-      @f.gets # skip mbox header
+      yield @f.gets
       until @f.eof? || (l = @f.gets) =~ BREAK_RE
-        ret += l
+        yield l
       end
     end
-    ret
   end
 
   def next
@@ -117,11 +137,9 @@ class Loader < Source
     end
 
     self.cur_offset = next_offset
-    [returned_offset, @labels.clone]
+    [returned_offset, @labels]
   end
 end
 
-Redwood::register_yaml(Loader, %w(uri cur_offset usual archived id))
-
 end
 end

data/lib/sup/mbox/ssh-loader.rb

@@ -6,7 +6,10 @@ module MBox
 class SSHLoader < Source
   attr_accessor :username, :password
 
-  def initialize uri, username=nil, password=nil, start_offset=nil, usual=true, archived=false, id=nil
+  yaml_properties :uri, :username, :password, :cur_offset, :usual, 
+                  :archived, :id, :labels
+
+  def initialize uri, username=nil, password=nil, start_offset=nil, usual=true, archived=false, id=nil, labels=[]
     raise ArgumentError, "not an mbox+ssh uri: #{uri.inspect}" unless uri =~ %r!^mbox\+ssh://!
 
     super uri, start_offset, usual, archived, id
@@ -16,6 +19,7 @@ class SSHLoader < Source
     @password = password
     @uri = uri
     @cur_offset = start_offset
+    @labels = (labels || []).freeze
 
     opts = {}
     opts[:username] = @username if @username
@@ -26,10 +30,10 @@ class SSHLoader < Source
     
     ## heuristic: use the filename as a label, unless the file
     ## has a path that probably represents an inbox.
-    @labels = [:unread]
-    @labels << File.basename(filename).intern unless File.dirname(filename) =~ /\b(var|usr|spool)\b/
   end
 
+  def self.suggest_labels_for path; Loader.suggest_labels_for(path) end
+
   def connect; safely { @f.connect }; end
   def host; @parsed_uri.host; end
   def filename; @parsed_uri.path[1..-1] end
@@ -66,7 +70,5 @@ class SSHLoader < Source
   end
 end
 
-Redwood::register_yaml(SSHLoader, %w(uri username password cur_offset usual archived id))
-
 end
 end

data/lib/sup/message.rb

@@ -1,5 +1,6 @@
 require 'tempfile'
 require 'time'
+require 'iconv'
 
 module Redwood
 
@@ -12,9 +13,6 @@ class MessageFormatError < StandardError; end
 ## i would like, for example, to be able to add in a ruby-talk
 ## specific module that would detect and link to /ruby-talk:\d+/
 ## sequences in the text of an email. (how sweet would that be?)
-##
-## TODO: integrate with user's addressbook to render names
-## appropriately.
 class Message
   SNIPPET_LEN = 80
   WRAP_LEN = 80 # wrap at this width
@@ -28,28 +26,30 @@ class Message
   end
 
   class Attachment
-    attr_reader :content_type, :desc, :filename
-    def initialize content_type, desc, part
+    attr_reader :content_type, :filename, :content, :lines
+    def initialize content_type, filename, content
       @content_type = content_type
-      @desc = desc
-      @part = part
-      @file = nil
-      desc =~ /filename="(.*?)"/ && @filename = $1
+      @filename = filename
+      @content = content
+
+      if inlineable?
+        @lines = to_s.split("\n")
+      end
     end
 
     def view!
-      unless @file
-        @file = Tempfile.new "redwood.attachment"
-        @file.print self
-        @file.close
-      end
+      file = Tempfile.new "redwood.attachment"
+      file.print raw_content
+      file.close
 
-      ## TODO: handle unknown mime-types
-      system "/usr/bin/run-mailcap --action=view #{@content_type}:#{@file.path}"
+      system "/usr/bin/run-mailcap --action=view #{@content_type}:#{file.path} >& /dev/null"
       $? == 0
     end
 
-    def to_s; @part.decode; 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
@@ -74,10 +74,12 @@ class Message
     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*--~--~-)/
+
   MAX_SIG_DISTANCE = 15 # lines from the end
   DEFAULT_SUBJECT = "(missing subject)"
   DEFAULT_SENDER = "(missing sender)"
@@ -95,7 +97,7 @@ class Message
     @source_info = opts[:source_info] or raise ArgumentError, "source_info can't be nil"
     @snippet = opts[:snippet] || ""
     @have_snippet = !opts[:snippet].nil?
-    @labels = opts[:labels] || []
+    @labels = [] + (opts[:labels] || [])
     @dirty = false
     @chunks = nil
 
@@ -118,17 +120,17 @@ class Message
     end
 
     @subj = header.member?("subject") ? header["subject"].gsub(/\s+/, " ").gsub(/\s+$/, "") : DEFAULT_SUBJECT
-    @from = Person.for header["from"]
-    @to = Person.for_several header["to"]
-    @cc = Person.for_several header["cc"]
-    @bcc = Person.for_several header["bcc"]
+    @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
-    @replyto = Person.for header["reply-to"]
+    @replyto = PersonManager.person_for header["reply-to"]
     @list_address =
       if header["list-post"]
-        @list_address = Person.for header["list-post"].gsub(/^<mailto:|>$/, "")
+        @list_address = PersonManager.person_for header["list-post"].gsub(/^<mailto:|>$/, "")
       else
         nil
       end
@@ -140,7 +142,7 @@ class Message
 
   def snippet; @snippet || chunks && @snippet; end
   def is_list_message?; !@list_address.nil?; end
-  def is_draft?; DraftLoader === @source; end
+  def is_draft?; @source.is_a? DraftLoader; end
   def draft_filename
     raise "not a draft" unless is_draft?
     @source.fn_for_offset @source_info
@@ -190,6 +192,7 @@ class Message
           read_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
@@ -221,6 +224,7 @@ EOS
     begin
       @source.raw_header @source_info
     rescue SourceError => e
+      Redwood::log "problem getting messages from #{@source}: #{e.message}"
       error_message e.message
     end
   end
@@ -229,6 +233,7 @@ EOS
     begin
       @source.raw_full_message @source_info
     rescue SourceError => e
+      Redwood::log "problem getting messages from #{@source}: #{e.message}"
       error_message(e.message)
     end
   end
@@ -260,22 +265,71 @@ EOS
 
 private
 
-  ## everything RubyMail-specific goes here.
+  ## here's where we handle decoding mime attachments. unfortunately
+  ## but unsurprisingly, the world of mime attachments is a bit of a
+  ## mess. as an empiricist, i'm basing the following behavior on
+  ## observed mail rather than on interpretations of rfcs, so probably
+  ## this will have to be tweaked.
+  ##
+  ## 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.
+  ##
+  ## 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
-    ret = [] <<
-      case m.header.content_type
-      when "text/plain", nil
-        m.body && body = m.decode or raise MessageFormatError, "For some bizarre reason, RubyMail was unable to parse this message."
-        text_to_chunks body.normalize_whitespace.split("\n")
-      when /^multipart\//
-        nil
+    if m.multipart?
+      m.body.map { |p| message_to_chunks p }.flatten.compact # recurse
+    else
+      filename =
+        ## first, paw through the headers looking for a filename
+        if m.header["Content-Disposition"] &&
+            m.header["Content-Disposition"] =~ /filename="?(.*?[^\\])("|;|$)/
+          $1
+        elsif m.header["Content-Type"] &&
+            m.header["Content-Type"] =~ /name=(.*?)(;|$)/
+          $1
+
+        ## haven't found one, but it's a non-text message. fake
+        ## it.
+        elsif m.header["Content-Type"] && m.header["Content-Type"] !~ /^text\/plain/
+          "sup-attachment-#{Time.now.to_i}-#{rand 10000}"
+        end
+
+      ## if there's a filename, we'll treat it as an attachment.
+      if filename
+        [Attachment.new(m.header.content_type, filename, m)]
+
+      ## otherwise, it's body text
       else
-        disp = m.header["Content-Disposition"] || ""
-        Attachment.new m.header.content_type, disp.gsub(/[\s\n]+/, " "), m
+        body = Message.decode_and_convert m
+        text_to_chunks body.normalize_whitespace.split("\n")
       end
-    
-    m.each_part { |p| ret << message_to_chunks(p) } if m.multipart?
-    ret.compact.flatten
+    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."
+
+    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
+    end
+    body
   end
 
   ## parse the lines of text into chunk objects.  the heuristics here
@@ -323,8 +377,6 @@ private
         if newstate
           if chunk_lines.empty?
             # nothing
-          elsif chunk_lines.size == 1
-            chunks << Text.new(chunk_lines) # forget about one-line quotes
           else
             chunks << Quote.new(chunk_lines)
           end
@@ -332,10 +384,7 @@ private
           state = newstate
         end
 
-      when :block_quote
-        chunk_lines << line
-
-      when :sig
+      when :block_quote, :sig
         chunk_lines << line
       end