sup 0.3 → 0.4

data/lib/sup/keymap.rb

@@ -7,7 +7,7 @@ class Keymap
     yield self if block_given?
   end
 
-  def keysym_to_keycode k
+  def self.keysym_to_keycode k
     case k
     when :down: Curses::KEY_DOWN
     when :up: Curses::KEY_UP
@@ -31,7 +31,7 @@ class Keymap
     end
   end
 
-  def keysym_to_string k
+  def self.keysym_to_string k
     case k
     when :down: "<down arrow>"
     when :up: "<up arrow>"
@@ -60,25 +60,44 @@ class Keymap
     entry = [action, help, keys]
     @order << entry
     keys.each do |k|
-      raise ArgumentError, "key #{k} already defined (action #{action})" if @map.include? k
-      kc = keysym_to_keycode k
+      kc = Keymap.keysym_to_keycode k
+      raise ArgumentError, "key '#{k}' already defined (as #{@map[kc].first})" if @map.include? kc
       @map[kc] = entry
     end
   end
 
+  def add_multi prompt, key
+    submap = Keymap.new
+    add submap, prompt, key
+    yield submap
+  end
+
   def action_for kc
     action, help, keys = @map[kc]
-    action
+    [action, help]
   end
 
+  def has_key? k; @map[k] end
+
   def keysyms; @map.values.map { |action, help, keys| keys }.flatten; end
 
-  def help_text except_for={}
-    lines = @order.map do |action, help, keys|
+  def help_lines except_for={}, prefix=""
+    lines = [] # :(
+    @order.each do |action, help, keys|
       valid_keys = keys.select { |k| !except_for[k] }
       next if valid_keys.empty?
-      [valid_keys.map { |k| keysym_to_string k }.join(", "), help]
+      case action
+      when Symbol
+        lines << [valid_keys.map { |k| prefix + Keymap.keysym_to_string(k) }.join(", "), help]
+      when Keymap
+        lines += action.help_lines({}, prefix + Keymap.keysym_to_string(keys.first))
+      end
     end.compact
+    lines
+  end
+
+  def help_text except_for={}
+    lines = help_lines except_for
     llen = lines.max_of { |a, b| a.length }
     lines.map { |a, b| sprintf " %#{llen}s : %s", a, b }.join("\n")
   end

data/lib/sup/maildir.rb

@@ -144,7 +144,7 @@ private
 
   def make_id fn
     # use 7 digits for the size. why 7? seems nice.
-    sprintf("%d%07d", File.mtime(fn), File.size(fn)).to_i
+    sprintf("%d%07d", File.mtime(fn), File.size(fn) % 10000000).to_i
   end
 
   def with_file_for id

data/lib/sup/mbox/loader.rb

@@ -37,7 +37,7 @@ class Loader < Source
     if File.dirname(path) =~ /\b(var|usr|spool)\b/
       []
     else
-      [File.basename(path).intern]
+      [File.basename(path).downcase.intern]
     end
   end
 

data/lib/sup/message-chunks.rb

@@ -1,3 +1,5 @@
+require 'tempfile'
+
 ## Here we define all the "chunks" that a message is parsed
 ## into. Chunks are used by ThreadViewMode to render a message. Chunks
 ## are used for both MIME stuff like attachments, for Sup's parsing of
@@ -29,6 +31,14 @@
 ## included as quoted text during a reply. Text, Quotes, and mime-parsed
 ## attachments are quotable; Signatures are not.
 
+## monkey-patch time: make temp files have the right extension
+class Tempfile
+  def make_tmpname basename, n
+    sprintf '%d-%d-%s', $$, n, basename
+  end
+end
+
+
 module Redwood
 module Chunk
   class Attachment
@@ -36,14 +46,23 @@ module Chunk
 Executes when decoding a MIME attachment.
 Variables:
    content_type: the content-type of the message
-       filename: the filename of the attachment as saved to disk (generated
-                 on the fly, so don't call more than once)
+       filename: the filename of the attachment as saved to disk
   sibling_types: if this attachment is part of a multipart MIME attachment,
                  an array of content-types for all attachments. Otherwise,
                  the empty array.
 Return value:
   The decoded text of the attachment, or nil if not decoded.
 EOS
+
+    HookManager.register "mime-view", <<EOS
+Executes when viewing a MIME attachment, i.e., launching a separate
+viewer program.
+Variables:
+   content_type: the content-type of the attachment
+       filename: the filename of the attachment as saved to disk
+Return value:
+  True if the viewing was successful, false otherwise.
+EOS
 #' stupid ruby-mode
 
     ## raw_content is the post-MIME-decode content. this is used for
@@ -54,7 +73,8 @@ EOS
     def initialize content_type, filename, encoded_content, sibling_types
       @content_type = content_type
       @filename = filename
-      @quotable = false # only quotable if we can parse it through the mime-decode hook
+      @quotable = false # changed to true if we can parse it through the
+                        # mime-decode hook, or if it's plain text
       @raw_content =
         if encoded_content.body
           encoded_content.decode
@@ -62,19 +82,21 @@ EOS
           "For some bizarre reason, RubyMail was unable to parse this attachment.\n"
         end
 
-      @lines =
+      text =
         case @content_type
         when /^text\/plain\b/
-          Message.convert_from(@raw_content, encoded_content.charset).split("\n")
+          Message.convert_from @raw_content, encoded_content.charset
         else
-          text = HookManager.run "mime-decode", :content_type => content_type,
-                                 :filename => lambda { write_to_disk },
-                                 :sibling_types => sibling_types
-          if text
-            @quotable = true
-            text.split("\n")
-          end
+          HookManager.run "mime-decode", :content_type => content_type,
+                          :filename => lambda { write_to_disk },
+                          :sibling_types => sibling_types
         end
+
+      @lines = nil
+      if text
+        @lines = text.gsub("\r\n", "\n").gsub(/\t/, "        ").gsub(/\r/, "").split("\n")
+        @quotable = true
+      end
     end
 
     def color; :none end
@@ -93,14 +115,20 @@ EOS
     def expandable?; !viewable? end
     def initial_state; :open end
     def viewable?; @lines.nil? end
-    def view!
-      path = write_to_disk
+    def view_default! path
       system "/usr/bin/run-mailcap --action=view #{@content_type}:#{path} > /dev/null 2> /dev/null"
       $? == 0
     end
 
+    def view!
+      path = write_to_disk
+      ret = HookManager.run "mime-view", :content_type => @content_type,
+                                         :filename => path
+      view_default! path unless ret
+    end
+
     def write_to_disk
-      file = Tempfile.new "redwood.attachment"
+      file = Tempfile.new(@filename || "sup-attachment")
       file.print @raw_content
       file.close
       file.path

data/lib/sup/message.rb

@@ -1,4 +1,3 @@
-require 'tempfile'
 require 'time'
 require 'iconv'
 
@@ -30,7 +29,7 @@ class Message
 
   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*$)/
+  QUOTE_START_PATTERN = /\w.*:$/
   SIG_PATTERN = /(^-- ?$)|(^\s*----------+\s*$)|(^\s*_________+\s*$)|(^\s*--~--~-)|(^\s*--\+\+\*\*==)/
 
   MAX_SIG_DISTANCE = 15 # lines from the end
@@ -39,45 +38,54 @@ class Message
 
   attr_reader :id, :date, :from, :subj, :refs, :replytos, :to, :source,
               :cc, :bcc, :labels, :list_address, :recipient_email, :replyto,
-              :source_info, :chunks, :list_subscribe, :list_unsubscribe
+              :source_info, :list_subscribe, :list_unsubscribe
 
-  bool_reader :dirty, :source_marked_read
+  bool_reader :dirty, :source_marked_read, :snippet_contains_encrypted_content
 
   ## 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"
-    @snippet = opts[:snippet] || ""
-    @have_snippet = !opts[:snippet].nil?
+    @snippet = opts[:snippet]
+    @snippet_contains_encrypted_content = false
+    @have_snippet = !(opts[:snippet].nil? || opts[:snippet].empty?)
     @labels = [] + (opts[:labels] || [])
     @dirty = false
+    @encrypted = false
     @chunks = nil
 
+    ## we need to initialize this. see comments in parse_header as to
+    ## why.
+    @refs = []
+
     parse_header(opts[:header] || @source.load_header(@source_info))
   end
 
   def parse_header header
     header.each { |k, v| header[k.downcase] = v }
-    
+
+    fakeid = nil
+    fakename = nil
+
     @id =
       if header["message-id"]
         sanitize_message_id header["message-id"]
       else
-        returning("sup-faked-" + Digest::MD5.hexdigest(raw_header)) do |id|
-          Redwood::log "faking message-id for message from #@from: #{id}"
-        end
+        fakeid = "sup-faked-" + Digest::MD5.hexdigest(raw_header)
       end
     
     @from =
       if header["from"]
         PersonManager.person_for header["from"]
       else
-        name = "Sup Auto-generated Fake Sender <sup@fake.sender.example.com>"
-        Redwood::log "faking from for message #@id: #{name}"
-        PersonManager.person_for name
+        fakename = "Sup Auto-generated Fake Sender <sup@fake.sender.example.com>"
+        PersonManager.person_for fakename
       end
 
+    Redwood::log "faking message-id for message from #@from: #{id}" if fakeid
+    Redwood::log "faking from for message #@id: #{fakename}" if fakename
+
     date = header["date"]
     @date =
       case date
@@ -98,7 +106,13 @@ class Message
     @to = PersonManager.people_for header["to"]
     @cc = PersonManager.people_for header["cc"]
     @bcc = PersonManager.people_for header["bcc"]
-    @refs = (header["references"] || "").scan(/<(.+?)>/).map { |x| sanitize_message_id x.first }
+
+    ## before loading our full header from the source, we can actually
+    ## have some extra refs set by the UI. (this happens when the user
+    ## joins threads manually). so we will merge the current refs values
+    ## in here.
+    refs = (header["references"] || "").scan(/<(.+?)>/).map { |x| sanitize_message_id x.first }
+    @refs = (@refs + refs).uniq
     @replytos = (header["in-reply-to"] || "").scan(/<(.+?)>/).map { |x| sanitize_message_id x.first }
 
     @replyto = PersonManager.person_for header["reply-to"]
@@ -116,7 +130,12 @@ class Message
   end
   private :parse_header
 
-  def snippet; @snippet || chunks && @snippet; end
+  def add_ref ref
+    @refs << ref
+    @dirty = true
+  end
+
+  def snippet; @snippet || (chunks && @snippet); end
   def is_list_message?; !@list_address.nil?; end
   def is_draft?; @source.is_a? DraftLoader; end
   def draft_filename
@@ -152,11 +171,16 @@ class Message
     @dirty = true
   end
 
+  def chunks
+    load_from_source!
+    @chunks
+  end
+
   ## this is called when the message body needs to actually be loaded.
   def load_from_source!
     @chunks ||=
       if @source.has_errors?
-        [Chunk::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
@@ -175,7 +199,7 @@ class Message
           ## up the error message one
           @source.error ||= e
           Redwood::report_broken_sources :force_to_top => true
-          [Chunk::Text.new(error_message(e.message))]
+          [Chunk::Text.new(error_message(e.message).split("\n"))]
         end
       end
   end
@@ -275,7 +299,6 @@ private
   ## product.
 
   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
@@ -287,13 +310,15 @@ private
       return
     end
 
+    ## this probably will never happen
     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}"
+      ## unknown signature type; just ignore.
+      #Redwood::log "warning: multipart/signed with signature content type #{signature.header.content_type}"
       return
     end
 
@@ -301,7 +326,6 @@ private
   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
@@ -324,11 +348,11 @@ private
     end
 
     decryptedm, sig, notice = CryptoManager.decrypt payload
-    children = message_to_chunks(decryptedm) if decryptedm
+    children = message_to_chunks(decryptedm, true) if decryptedm
     [notice, sig, children].flatten.compact
   end
 
-  def message_to_chunks m, sibling_types=[]
+  def message_to_chunks m, encrypted=false, sibling_types=[]
     if m.multipart?
       chunks =
         case m.header.content_type
@@ -340,7 +364,7 @@ private
 
       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
+        chunks = m.body.map { |p| message_to_chunks p, encrypted, sibling_types }.flatten.compact
       end
 
       chunks
@@ -359,8 +383,16 @@ private
 
         ## haven't found one, but it's a non-text message. fake
         ## it.
+        ##
+        ## TODO: make this less lame.
         elsif m.header["Content-Type"] && m.header["Content-Type"] !~ /^text\/plain/
-          "sup-attachment-#{Time.now.to_i}-#{rand 10000}"
+          extension =
+            case m.header["Content-Type"]
+            when /text\/html/: "html"
+            when /image\/(.*)/: $1
+            end
+
+          ["sup-attachment-#{Time.now.to_i}-#{rand 10000}", extension].join(".")
         end
 
       ## if there's a filename, we'll treat it as an attachment.
@@ -369,17 +401,18 @@ private
 
       ## otherwise, it's body text
       else
-        body = Message.convert_from m.decode, m.charset
-        text_to_chunks body.normalize_whitespace.split("\n")
+        body = Message.convert_from m.decode, m.charset if m.body
+        text_to_chunks((body || "").normalize_whitespace.split("\n"), encrypted)
       end
     end
   end
 
   def self.convert_from body, charset
+    charset = "utf-8" if charset =~ /UTF_?8/i
     begin
       raise MessageFormatError, "RubyMail decode returned a null body" unless body
       return body unless charset
-      Iconv.iconv($encoding, charset, body).join
+      Iconv.iconv($encoding + "//IGNORE", charset, body + " ").join[0 .. -2]
     rescue Errno::EINVAL, Iconv::InvalidEncoding, Iconv::IllegalSequence, MessageFormatError => 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 }
@@ -390,7 +423,7 @@ private
   ## parse the lines of text into chunk objects.  the heuristics here
   ## need tweaking in some nice manner. TODO: move these heuristics
   ## into the classes themselves.
-  def text_to_chunks lines
+  def text_to_chunks lines, encrypted
     state = :text # one of :text, :quote, or :sig
     chunks = []
     chunk_lines = []
@@ -402,7 +435,7 @@ private
       when :text
         newstate = nil
 
-        if line =~ QUOTE_PATTERN || (line =~ QUOTE_START_PATTERN && (nextline =~ QUOTE_PATTERN || nextline =~ QUOTE_START_PATTERN))
+        if line =~ QUOTE_PATTERN || (line =~ QUOTE_START_PATTERN && nextline =~ QUOTE_PATTERN)
           newstate = :quote
         elsif line =~ SIG_PATTERN && (lines.length - i) < MAX_SIG_DISTANCE
           newstate = :sig
@@ -421,7 +454,7 @@ private
       when :quote
         newstate = nil
 
-        if line =~ QUOTE_PATTERN || line =~ QUOTE_START_PATTERN #|| line =~ /^\s*$/
+        if line =~ QUOTE_PATTERN || (line =~ /^\s*$/ && nextline =~ QUOTE_PATTERN)
           chunk_lines << line
         elsif line =~ SIG_PATTERN && (lines.length - i) < MAX_SIG_DISTANCE
           newstate = :sig
@@ -442,11 +475,14 @@ private
       when :block_quote, :sig
         chunk_lines << line
       end
- 
+
       if !@have_snippet && state == :text && (@snippet.nil? || @snippet.length < SNIPPET_LEN) && line !~ /[=\*#_-]{3,}/ && line !~ /^\s*$/
+        @snippet ||= ""
         @snippet += " " unless @snippet.empty?
         @snippet += line.gsub(/^\s+/, "").gsub(/[\r\n]/, "").gsub(/\s+/, " ")
         @snippet = @snippet[0 ... SNIPPET_LEN].chomp
+        @dirty = true unless encrypted && $config[:discard_snippets_from_encrypted_messages]
+        @snippet_contains_encrypted_content = true if encrypted
       end
     end