sup 0.1 → 0.2

data/lib/sup/keymap.rb

@@ -1,5 +1,3 @@
-require "curses"
-
 module Redwood
 
 class Keymap

data/lib/sup/label.rb

@@ -5,12 +5,12 @@ class LabelManager
 
   ## labels that have special semantics. user will be unable to
   ## add/remove these via normal label mechanisms.
-  RESERVED_LABELS = [ :starred, :spam, :draft, :unread, :killed, :sent, :deleted ]
+  RESERVED_LABELS = [ :starred, :spam, :draft, :unread, :killed, :sent, :deleted, :inbox ]
 
   ## labels which it nonetheless makes sense to search for by
-  LISTABLE_RESERVED_LABELS = [ :starred, :spam, :draft, :sent, :killed, :deleted ]
+  LISTABLE_RESERVED_LABELS = [ :starred, :spam, :draft, :sent, :killed, :deleted, :inbox ]
 
-  ## labels that will never be displayed to the user
+  ## labels that will typically be hidden from the user
   HIDDEN_RESERVED_LABELS = [ :starred, :unread ]
 
   def initialize fn
@@ -28,17 +28,38 @@ class LabelManager
     self.class.i_am_the_instance self
   end
 
-  ## all listable (user-defined and system listable) labels, ordered
+  ## all listable (just user-defined at the moment) labels, ordered
   ## nicely and converted to pretty strings. use #label_for to recover
   ## the original label.
-  def listable_label_strings
-    LISTABLE_RESERVED_LABELS.sort_by { |l| l.to_s }.map { |l| l.to_s.ucfirst } +
-      @labels.keys.map { |l| l.to_s }.sort
+  def listable_labels
+    ## uniq's only necessary here because of certain upgrade issues
+    (LISTABLE_RESERVED_LABELS + @labels.keys).uniq
+  end
+
+  ## all apply-able (user-defined and system listable) labels, ordered
+  ## nicely and converted to pretty strings. use #label_for to recover
+  ## the original label.
+  def applyable_labels
+    @labels.keys
   end
 
   ## reverse the label->string mapping, for convenience!
-  def label_for string
-    string.downcase.intern
+  def string_for l
+    if RESERVED_LABELS.include? l
+      l.to_s.ucfirst
+    else
+      l.to_s
+    end
+  end
+
+  def label_for s
+    l = s.intern
+    l2 = s.downcase.intern
+    if RESERVED_LABELS.include? l2
+      l2
+    else
+      l
+    end
   end
   
   def << t

data/lib/sup/logger.rb

@@ -25,7 +25,18 @@ class Logger
   def log s
 #    $stderr.puts s
     make_buf
-    @mode << "#{Time.now}: #{s.chomp}\n"
+    prefix = "#{Time.now}: "
+    padding = " " * prefix.length
+    first = true
+    s.split(/[\r\n]/).each do |l|
+      l = l.chomp
+      if first
+        first = false
+        @mode << "#{prefix}#{l}\n"
+      else
+        @mode << "#{padding}#{l}\n"
+      end
+    end
     $stderr.puts "[#{Time.now}] #{s.chomp}" unless BufferManager.instantiated? && @mode.buffer
   end
   

data/lib/sup/maildir.rb

@@ -11,13 +11,15 @@ module Redwood
 class Maildir < Source
   SCAN_INTERVAL = 30 # seconds
 
+  ## remind me never to use inheritance again.
   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)
+    uri = URI(Source.expand_filesystem_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
+    raise ArgumentError, "mbox URI must have a path component" unless uri.path
 
     @dir = uri.path
     @labels = (labels || []).freeze
@@ -27,10 +29,14 @@ class Maildir < Source
     @mutex = Mutex.new
   end
 
+  def file_path; @dir end
   def self.suggest_labels_for path; [] end
+  def is_source_for? uri; super || (URI(Source.expand_filesystem_uri(uri)) == URI(self.uri)); end
 
   def check
     scan_mailbox
+    return unless start_offset
+
     start = @ids.index(cur_offset || start_offset) or raise OutOfSyncSourceError, "Unknown message id #{cur_offset || start_offset}." # couldn't find the most recent email
   end
 
@@ -55,7 +61,7 @@ class Maildir < Source
     ret
   end
 
-  def raw_full_message id
+  def raw_message id
     scan_mailbox
     with_file_for(id) { |f| f.readlines.join }
   end
@@ -88,12 +94,14 @@ class Maildir < Source
 
   def each
     scan_mailbox
+    return unless start_offset
+
     start = @ids.index(cur_offset || start_offset) or raise OutOfSyncSourceError, "Unknown message id #{cur_offset || start_offset}." # couldn't find the most recent email
 
     start.upto(@ids.length - 1) do |i|         
       id = @ids[i]
       self.cur_offset = id
-      yield id, @labels + (@ids_to_fns[id] =~ /,.*R.*$/ ? [] : [:unread])
+      yield id, @labels + (seen?(id) ? [] : [:unread]) + (trashed?(id) ? [:deleted] : []) + (flagged?(id) ? [:starred] : [])
     end
   end
 
@@ -109,6 +117,20 @@ class Maildir < Source
 
   def pct_done; 100.0 * (@ids.index(cur_offset) || 0).to_f / (@ids.length - 1).to_f; end
 
+  def draft? msg; maildir_data(msg)[2].include? "D"; end
+  def flagged? msg; maildir_data(msg)[2].include? "F"; end
+  def passed? msg; maildir_data(msg)[2].include? "P"; end
+  def replied? msg; maildir_data(msg)[2].include? "R"; end
+  def seen? msg; maildir_data(msg)[2].include? "S"; end
+  def trashed? msg; maildir_data(msg)[2].include? "T"; end
+
+  def mark_draft msg; maildir_mark_file msg, "D" unless draft? msg; end
+  def mark_flagged msg; maildir_mark_file msg, "F" unless flagged? msg; end
+  def mark_passed msg; maildir_mark_file msg, "P" unless passed? msg; end
+  def mark_replied msg; maildir_mark_file msg, "R" unless replied? msg; end
+  def mark_seen msg; maildir_mark_file msg, "S" unless seen? msg; end
+  def mark_trashed msg; maildir_mark_file msg, "T" unless trashed? msg; end
+
 private
 
   def make_id fn
@@ -124,6 +146,29 @@ private
       raise FatalSourceError, "Problem reading file for id #{id.inspect}: #{fn.inspect}: #{e.message}."
     end
   end
+
+  def maildir_data msg
+    fn = File.basename @ids_to_fns[msg]
+    fn =~ %r{^([^:,]+):([12]),([DFPRST]*)$}
+    [($1 || fn), ($2 || "2"), ($3 || "")]
+  end
+
+  ## not thread-safe on msg
+  def maildir_mark_file msg, flag
+    orig_path = @ids_to_fns[msg]
+    orig_base, orig_fn = File.split(orig_path)
+    new_base = orig_base.slice(0..-4) + 'cur'
+    tmp_base = orig_base.slice(0..-4) + 'tmp'
+    md_base, md_ver, md_flags = maildir_data msg
+    md_flags += flag; md_flags = md_flags.split(//).sort.join.squeeze
+    new_path = File.join new_base, "#{md_base}:#{md_ver},#{md_flags}"
+    tmp_path = File.join tmp_base, "#{md_base}:#{md_ver},#{md_flags}"
+    File.link orig_path, tmp_path
+    File.unlink orig_path
+    File.link tmp_path, new_path
+    File.unlink tmp_path
+    @ids_to_fns[msg] = new_path
+  end
 end
 
 end

data/lib/sup/mbox.rb

@@ -56,7 +56,7 @@ module MBox
         begin
           Rfc2047.decode_to $encoding, v
         rescue Errno::EINVAL, Iconv::InvalidEncoding, Iconv::IllegalSequence => e
-          Redwood::log "warning: error decoding RFC 2047 header: #{e.message}"
+          Redwood::log "warning: error decoding RFC 2047 header (#{e.class.name}): #{e.message}"
           v
         end
     end

data/lib/sup/mbox/loader.rb

@@ -6,24 +6,30 @@ module MBox
 
 class Loader < Source
   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
 
+  ## uri_or_fp is horrific. need to refactor.
+  def initialize uri_or_fp, start_offset=nil, usual=true, archived=false, id=nil, labels=[]
     @mutex = Mutex.new
-    @labels = (labels || []).freeze
+    @labels = ((labels || []) - LabelManager::RESERVED_LABELS).uniq.freeze
 
     case uri_or_fp
     when String
-      uri = URI(uri_or_fp)
+      uri = URI(Source.expand_filesystem_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
+      raise ArgumentError, "mbox URI ('#{uri}') cannot have a host: #{uri.host}" if uri.host
+      raise ArgumentError, "mbox URI must have a path component" unless uri.path
       @f = File.open uri.path
+      @path = uri.path
     else
       @f = uri_or_fp
+      @path = uri_or_fp.path
     end
+
+    super uri_or_fp, start_offset, usual, archived, id
   end
 
-  def file_path; URI(uri).path end
+  def file_path; @path end
+  def is_source_for? uri; super || (self.uri.is_a?(String) && (URI(Source.expand_filesystem_uri(uri)) == URI(Source.expand_filesystem_uri(self.uri)))) end
 
   def self.suggest_labels_for path
     ## heuristic: use the filename as a label, unless the file
@@ -62,7 +68,11 @@ class Loader < Source
       @f.seek offset
       begin
         RMail::Mailbox::MBoxReader.new(@f).each_message do |input|
-          return RMail::Parser.read(input)
+          m = RMail::Parser.read(input)
+          if m.body && m.body.is_a?(String)
+            m.body.gsub!(/^>From /, "From ")
+          end
+          return m
         end
       rescue RMail::Parser::Error => e
         raise FatalSourceError, "error parsing mbox file: #{e.message}"
@@ -81,19 +91,19 @@ class Loader < Source
     ret
   end
 
-  def raw_full_message offset
+  def raw_message offset
     ret = ""
-    each_raw_full_message_line(offset) { |l| ret += l }
+    each_raw_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.
+  ## into memory with raw_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
+  def each_raw_message_line offset
     @mutex.synchronize do
       @f.seek offset
       yield @f.gets
@@ -137,7 +147,7 @@ class Loader < Source
     end
 
     self.cur_offset = next_offset
-    [returned_offset, @labels]
+    [returned_offset, (@labels + [:unread]).uniq]
   end
 end
 

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

@@ -65,7 +65,7 @@ class SSHLoader < Source
     end
   end
 
-  [:start_offset, :load_header, :load_message, :raw_header, :raw_full_message].each do |meth|
+  [:start_offset, :load_header, :load_message, :raw_header, :raw_message].each do |meth|
     define_method(meth) { |*a| safely { @loader.send meth, *a } }
   end
 end

data/lib/sup/message-chunks.rb

@@ -0,0 +1,198 @@
+## 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
+## the message body into text, quote, and signature regions, and for
+## notices like "this message was decrypted" or "this message contains
+## a valid signature"---basically, anything we want to differentiate
+## at display time.
+##
+## A chunk can be inlineable, expandable, or viewable. If it's
+## inlineable, #color and #lines are called and the output is treated
+## as part of the message text. This is how Text and one-line Quotes
+## and Signatures work.
+##
+## If it's not inlineable but is expandable, #patina_color and
+## #patina_text are called to generate a "patina" (a one-line widget,
+## basically), and the user can press enter to toggle the display of
+## the chunk content, which is generated from #color and #lines as
+## above. This is how Quote, Signature, and most widgets
+## work. Exandable chunks can additionally define #initial_state to be
+## :open if they want to start expanded (default is to start collapsed).
+##
+## If it's not expandable but is viewable, a patina is displayed using
+###patina_color and #patina_text, but no toggling is allowed. Instead,
+##if #view! is defined, pressing enter on the widget calls view! and
+##(if that returns false) #to_s. Otherwise, enter does nothing. This
+##is how non-inlineable attachments work.
+
+module Redwood
+module Chunk
+  class Attachment
+    HookManager.register "mime-decode", <<EOS
+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)
+  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
+#' stupid ruby-mode
+
+    ## raw_content is the post-MIME-decode content. this is used for
+    ## saving the attachment to disk.
+    attr_reader :content_type, :filename, :lines, :raw_content
+
+    def initialize content_type, filename, encoded_content, sibling_types
+      @content_type = content_type
+      @filename = filename
+      @raw_content =
+        if encoded_content.body
+          encoded_content.decode
+        else
+          "For some bizarre reason, RubyMail was unable to parse this attachment.\n"
+        end
+
+      @lines =
+        case @content_type
+        when /^text\/plain\b/
+          Message.convert_from(@raw_content, encoded_content.charset).split("\n")
+        else
+          text = HookManager.run "mime-decode", :content_type => content_type,
+                                 :filename => lambda { write_to_disk },
+                                 :sibling_types => sibling_types
+          text.split("\n") if text
+        end
+    end
+
+    def color; :none end
+    def patina_color; :attachment_color end
+    def patina_text
+      if expandable?
+        "Attachment: #{filename} (#{lines.length} lines)"
+      else
+        "Attachment: #{filename} (#{content_type})"
+      end
+    end
+
+    ## an attachment is exapndable if we've managed to decode it into
+    ## something we can display inline. otherwise, it's viewable.
+    def inlineable?; false end
+    def expandable?; !viewable? end
+    def initial_state; :open end
+    def viewable?; @lines.nil? end
+    def view!
+      path = write_to_disk
+      system "/usr/bin/run-mailcap --action=view #{@content_type}:#{path} >& /dev/null"
+      $? == 0
+    end
+
+    def write_to_disk
+      file = Tempfile.new "redwood.attachment"
+      file.print @raw_content
+      file.close
+      file.path
+    end
+
+    ## used when viewing the attachment as text
+    def to_s
+      @lines || @raw_content
+    end
+  end
+
+  class Text
+    WRAP_LEN = 80 # wrap at this width
+
+    attr_reader :lines
+    def initialize lines
+      @lines = lines.map { |l| l.chomp.wrap WRAP_LEN }.flatten # wrap
+
+      ## trim off all empty lines except one
+      lines.pop while lines.last =~ /^\s*$/ 
+    end
+
+    def inlineable?; true end
+    def expandable?; false end
+    def viewable?; false end
+    def color; :none end
+  end
+
+  class Quote
+    attr_reader :lines
+    def initialize lines
+      @lines = lines
+    end
+    
+    def inlineable?; @lines.length == 1 end
+    def expandable?; !inlineable? end
+    def viewable?; false end
+
+    def patina_color; :quote_patina_color end
+    def patina_text; "(#{lines.length} quoted lines)" end
+    def color; :quote_color end
+  end
+
+  class Signature
+    attr_reader :lines
+    def initialize lines
+      @lines = lines
+    end
+
+    def inlineable?; @lines.length == 1 end
+    def expandable?; !inlineable? end
+    def viewable?; false end
+
+    def patina_color; :sig_patina_color end
+    def patina_text; "(#{lines.length}-line signature)" end
+    def color; :sig_color end
+  end
+
+  class EnclosedMessage
+    attr_reader :lines
+    def initialize from, body
+      @from = from
+      @lines = body.split "\n"
+    end
+
+    def from
+      @from ? @from.longname : "unknown sender"
+    end
+
+    def inlineable?; false end
+    def expandable?; true end
+    def initial_state; :open end
+    def viewable?; false end
+
+    def patina_color; :generic_notice_patina_color end
+    def patina_text; "Begin enclosed message from #{from} (#{@lines.length} lines)" end
+
+    def color; :quote_color end
+  end
+
+  class CryptoNotice
+    attr_reader :lines, :status, :patina_text
+
+    def initialize status, description, lines=[]
+      @status = status
+      @patina_text = description
+      @lines = lines
+    end
+
+    def patina_color
+      case status
+      when :valid: :cryptosig_valid_color
+      when :invalid: :cryptosig_invalid_color
+      else :cryptosig_unknown_color
+      end
+    end
+    def color; patina_color end
+
+    def inlineable?; false end
+    def expandable?; !@lines.empty? end
+    def viewable?; false end
+  end
+end
+end