sup 0.1 → 0.2

data/lib/sup/colormap.rb

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

data/lib/sup/contact.rb

@@ -10,7 +10,7 @@ class ContactManager
 
     if File.exists? fn
       IO.foreach(fn) do |l|
-        l =~ /^(\S+): (.*)$/ or raise "can't parse #{fn} line #{l.inspect}"
+        l =~ /^([^:]+): (.*)$/ or raise "can't parse #{fn} line #{l.inspect}"
         aalias, addr = $1, $2
         p = PersonManager.person_for addr, :definitive => true
         @p2a[p] = aalias
@@ -35,9 +35,10 @@ class ContactManager
       @a2p.delete aalias
     end
   end    
-  def person_with aalias; @a2p[aalias]; end
+  def contact_for aalias; @a2p[aalias]; end
   def alias_for person; @p2a[person]; end
   def is_contact? person; @p2a.member? person; end
+
   def save
     File.open(@fn, "w") do |f|
       @p2a.each do |p, a|

data/lib/sup/crypto.rb

@@ -0,0 +1,110 @@
+module Redwood
+
+class CryptoManager
+  include Singleton
+
+  def initialize
+    @mutex = Mutex.new
+    self.class.i_am_the_instance self
+
+    bin = `which gpg`.chomp
+    bin = `which pgp`.chomp unless bin =~ /\S/
+
+    @cmd =
+      case bin
+      when /\S/
+        "#{bin} --quiet --batch --no-verbose --logger-fd 1 --use-agent"
+      else
+        nil
+      end
+  end
+
+  # returns a cryptosignature
+  def verify payload, signature # both RubyMail::Message objects
+    return unknown_status(cant_find_binary) unless @cmd
+
+    payload_fn = Tempfile.new "redwood.payload"
+    payload_fn.write payload.to_s.gsub(/(^|[^\r])\n/, "\\1\r\n").gsub(/^MIME-Version: .*\r\n/, "")
+    payload_fn.close
+
+    signature_fn = Tempfile.new "redwood.signature"
+    signature_fn.write signature.decode
+    signature_fn.close
+
+    cmd = "#{@cmd} --verify #{signature_fn.path} #{payload_fn.path} 2> /dev/null"
+
+    #Redwood::log "gpg: running: #{cmd}"
+    gpg_output = `#{cmd}`
+    #Redwood::log "got output: #{gpg_output.inspect}"
+    output_lines = gpg_output.split(/\n/)
+
+    if gpg_output =~ /^gpg: (.* signature from .*$)/
+      if $? == 0
+        Chunk::CryptoNotice.new :valid, $1, output_lines
+      else
+        Chunk::CryptoNotice.new :invalid, $1, output_lines
+      end
+    else
+      unknown_status output_lines
+    end
+  end
+
+  # returns decrypted_message, status, desc, lines
+  def decrypt payload # RubyMail::Message objects
+    return unknown_status(cant_find_binary) unless @cmd
+
+#    cmd = "#{@cmd} --decrypt 2> /dev/null"
+
+#    Redwood::log "gpg: running: #{cmd}"
+
+#    gpg_output =
+#      IO.popen(cmd, "a+") do |f|
+#        f.puts payload.to_s
+#        f.gets
+#      end
+
+    payload_fn = Tempfile.new "redwood.payload"
+    payload_fn.write payload.to_s
+    payload_fn.close
+
+    cmd = "#{@cmd} --decrypt #{payload_fn.path} 2> /dev/null"
+    Redwood::log "gpg: running: #{cmd}"
+    gpg_output = `#{cmd}`
+    Redwood::log "got output: #{gpg_output.inspect}"
+
+    if $? == 0 # successful decryption
+      decrypted_payload, sig_lines =
+        if gpg_output =~ /\A(.*?)((^gpg: .*$)+)\Z/m
+          [$1, $2]
+        else
+          [gpg_output, nil]
+        end
+      
+      sig = 
+        if sig_lines # encrypted & signed
+          if sig_lines =~ /^gpg: (Good signature from .*$)/
+            Chunk::CryptoNotice.new :valid, $1, sig_lines.split("\n")
+          else
+            Chunk::CryptoNotice.new :invalid, $1, sig_lines.split("\n")
+          end
+        end
+
+      notice = Chunk::CryptoNotice.new :valid, "This message has been decrypted for display"
+      [RMail::Parser.read(decrypted_payload), sig, notice]
+    else
+      notice = Chunk::CryptoNotice.new :invalid, "This message could not be decrypted", gpg_output.split("\n")
+      [nil, nil, notice]
+    end
+  end
+
+private
+
+  def unknown_status lines=[]
+    Chunk::CryptoNotice.new :unknown, "Unable to determine validity of cryptographic signature", lines
+  end
+  
+  def cant_find_binary
+    ["Can't find gpg or pgp binary in path"]
+  end
+end
+end

data/lib/sup/draft.rb

@@ -99,12 +99,8 @@ class DraftLoader < Source
     ret
   end
 
-  def raw_full_message offset
-    ret = ""
-    File.open fn_for_offset(offset) do |f|
-      ret += l until f.eof?
-    end
-    ret
+  def raw_message offset
+    IO.readlines(fn_for_offset(offset)).join
   end
 
   def start_offset; 0; end

data/lib/sup/hook.rb

@@ -0,0 +1,131 @@
+module Redwood
+
+class HookManager
+  ## there's probably a better way to do this, but to evaluate a hook
+  ## with a bunch of pre-set "local variables" i define a function
+  ## per variable and then instance_evaluate the code.
+  ##
+  ## how does rails do it, when you pass :locals into a partial?
+  ##
+  ## i don't bother providing setters, since i'm pretty sure the
+  ## charade will fall apart pretty quickly with respect to scoping.
+  ## this is basically fail-fast.
+  class HookContext
+    def initialize name
+      @__name = name
+      @__locals = {}
+    end
+
+    attr_writer :__locals
+
+    def method_missing m, *a
+      case @__locals[m]
+      when Proc
+        @__locals[m].call(*a)
+      when nil
+        super
+      else
+        @__locals[m]
+      end
+    end
+
+    def say s
+      @__say_id = BufferManager.say s, @__say_id
+      BufferManager.draw_screen
+    end
+
+    def log s
+      Redwood::log "hook[#@__name]: #{s}"
+    end
+
+    def ask_yes_or_no q
+      BufferManager.ask_yes_or_no q
+    end
+
+    def __binding 
+      binding
+    end
+
+    def __cleanup
+      BufferManager.clear @__say_id if @__say_id
+    end
+  end
+
+  include Singleton
+
+  def initialize dir
+    @dir = dir
+    @hooks = {}
+    @descs = {}
+    @contexts = {}
+    
+    Dir.mkdir dir unless File.exists? dir
+
+    self.class.i_am_the_instance self
+  end
+
+  def run name, locals={}
+    hook = hook_for(name) or return
+    context = @contexts[hook] ||= HookContext.new(name)
+    context.__locals = locals
+
+    result = nil
+    begin
+      result = context.instance_eval @hooks[name], fn_for(name)
+    rescue Exception => e
+      log "error running hook: #{e.message}"
+      log e.backtrace.join("\n")
+      BufferManager.flash "Error running hook: #{e.message}"
+    end
+    context.__cleanup
+    result
+  end
+
+  def register name, desc
+    @descs[name] = desc
+  end
+
+  def print_hooks f=$stdout
+puts <<EOS
+Have #{@descs.size} registered hooks:
+
+EOS
+
+    @descs.sort.each do |name, desc|
+      f.puts <<EOS
+#{name}
+#{"-" * name.length}
+File: #{fn_for name}
+#{desc}
+EOS
+    end
+  end
+
+private
+
+  def hook_for name
+    unless @hooks.member? name
+      @hooks[name] =
+        begin
+          returning IO.readlines(fn_for(name)).join do
+            log "read '#{name}' from #{fn_for(name)}"
+          end
+        rescue SystemCallError => e
+          #log "disabled hook for '#{name}': #{e.message}"
+          nil
+        end
+    end
+
+    @hooks[name]
+  end
+
+  def fn_for name
+    File.join @dir, "#{name}.rb"
+  end
+
+  def log m
+    Redwood::log("hook: " + m)
+  end
+end
+
+end

data/lib/sup/imap.rb

@@ -3,6 +3,7 @@ require 'net/imap'
 require 'stringio'
 require 'time'
 require 'rmail'
+require 'cgi'
 
 ## fucking imap fucking sucks. what the FUCK kind of committee of
 ## dunces designed this shit.
@@ -62,10 +63,10 @@ class IMAP < Source
     @username = username
     @password = password
     @imap = nil
-    @imap_ids = {}
+    @imap_state = {}
     @ids = []
     @last_scan = nil
-    @labels = (labels || []).freeze
+    @labels = ((labels || []) - LabelManager::RESERVED_LABELS).uniq.freeze
     @say_id = nil
     @mutex = Mutex.new
   end
@@ -82,11 +83,13 @@ class IMAP < Source
   def port; @parsed_uri.port || (ssl? ? 993 : 143); end
   def mailbox
     x = @parsed_uri.path[1..-1]
-    x.nil? || x.empty? ? 'INBOX' : x
+    (x.nil? || x.empty?) ? 'INBOX' : CGI.unescape(x)
   end
   def ssl?; @parsed_uri.scheme == 'imaps' end
 
   def check
+    return unless start_offset
+
     ids = 
       @mutex.synchronize do
         unsynchronized_scan_mailbox
@@ -104,23 +107,21 @@ class IMAP < Source
   end
 
   def load_message id
-    RMail::Parser.read raw_full_message(id)
+    RMail::Parser.read raw_message(id)
   end
 
   def raw_header id
     unsynchronized_scan_mailbox
-    header, flags = get_imap_fields id, 'RFC822.HEADER', 'FLAGS'
-    ## very bad. this is very very bad. very bad bad bad.
-    header = header + "Status: RO\n" if flags.include? :Seen # fake an mbox-style read header # TODO: improve source-marked-as-read reporting system
+    header, flags = get_imap_fields id, 'RFC822.HEADER'
     header.gsub(/\r\n/, "\n")
   end
   synchronized :raw_header
 
-  def raw_full_message id
+  def raw_message id
     unsynchronized_scan_mailbox
     get_imap_fields(id, 'RFC822').first.gsub(/\r\n/, "\n")
   end
-  synchronized :raw_full_message
+  synchronized :raw_message
 
   def connect
     return if @imap
@@ -140,15 +141,17 @@ class IMAP < Source
 
     range = (@ids.length + 1) .. last_id
     Redwood::log "fetching IMAP headers #{range}"
-    fetch(range, ['RFC822.SIZE', 'INTERNALDATE']).each do |v|
+    fetch(range, ['RFC822.SIZE', 'INTERNALDATE', 'FLAGS']).each do |v|
       id = make_id v
       @ids << id
-      @imap_ids[id] = v.seqno
+      @imap_state[id] = { :id => v.seqno, :flags => v.attr["FLAGS"] }
     end
   end
   synchronized :scan_mailbox
 
   def each
+    return unless start_offset
+
     ids = 
       @mutex.synchronize do
         unsynchronized_scan_mailbox
@@ -157,10 +160,18 @@ class IMAP < Source
 
     start = ids.index(cur_offset || start_offset) or raise OutOfSyncSourceError, "Unknown message id #{cur_offset || start_offset}."
 
-    start.upto(ids.length - 1) do |i|         
+    start.upto(ids.length - 1) do |i|
       id = ids[i]
-      self.cur_offset = id
-      yield id, @labels
+      state = @mutex.synchronize { @imap_state[id] } or next
+      self.cur_offset = id 
+      labels = { :Seen => :unread, 
+                 :Flagged => :starred,
+                 :Deleted => :deleted
+               }.inject(@labels) do |cur, (imap, sup)|
+        cur + (state[:flags].include?(imap) ? [sup] : [])
+      end
+
+      yield id, labels
     end
   end
 
@@ -259,9 +270,9 @@ private
   end
 
   def get_imap_fields id, *fields
-    imap_id = @imap_ids[id] or raise OutOfSyncSourceError, "Unknown message id #{id}"
+    raise OutOfSyncSourceError, "Unknown message id #{id}" unless @imap_state[id]
 
-    retried = false
+    imap_id = @imap_state[id][:id]
     result = fetch(imap_id, (fields + ['RFC822.SIZE', 'INTERNALDATE']).uniq).first
     got_id = make_id result
     raise OutOfSyncSourceError, "IMAP message mismatch: requested #{id}, got #{got_id}." unless got_id == id

data/lib/sup/index.rb

@@ -154,11 +154,10 @@ EOS
     docid, entry = load_entry_for_id m.id unless docid && entry
 
     raise "no source info for message #{m.id}" unless m.source && m.source_info
-    raise "trying deleting non-corresponding entry #{docid}" if docid && @index[docid][:message_id] != m.id
+    raise "trying to delete non-corresponding entry #{docid} with index message-id #{@index[docid][:message_id].inspect} and parameter message id #{m.id.inspect}" if docid && @index[docid][:message_id] != m.id
 
     source_id = 
       if m.source.is_a? Integer
-        raise "Debugging: integer source set"
         m.source
       else
         m.source.id or raise "unregistered source #{m.source} (id #{m.source.id.inspect})"
@@ -184,7 +183,7 @@ EOS
     
     docid, entry = load_entry_for_id m.id
     ## this hasn't been triggered in a long time. TODO: decide whether it's still a problem.
-    raise "just added message #{m.id} but couldn't find it in a search" unless docid
+    raise "just added message #{m.id.inspect} but couldn't find it in a search" unless docid
     true
   end
 
@@ -226,10 +225,12 @@ EOS
   ## message-building lambdas, so that building an unwanted message
   ## can be skipped in the block if desired.
   ##
-  ## stops loading any thread if a message with a :killed flag is found.
+  ## only two options, :limit and :skip_killed. if :skip_killed is
+  ## true, stops loading any thread if a message with a :killed flag
+  ## is found.
   SAME_SUBJECT_DATE_LIMIT = 7
   def each_message_in_thread_for m, opts={}
-    Redwood::log "Building thread for #{m.id}: #{m.subj}"
+    #Redwood::log "Building thread for #{m.id}: #{m.subj}"
     messages = {}
     searched = {}
     num_queries = 0
@@ -262,23 +263,33 @@ EOS
       q.add_query Ferret::Search::TermQuery.new(:message_id, id), :should
       q.add_query Ferret::Search::TermQuery.new(:refs, id), :should
 
-      q = build_query :qobj => q, :load_killed => true
+      q = build_query :qobj => q
 
       num_queries += 1
+      killed = false
       @index.search_each(q, :limit => :all) do |docid, score|
         break if opts[:limit] && messages.size >= opts[:limit]
-        break if @index[docid][:label].split(/\s+/).include? "killed" unless opts[:load_killed]
+        if @index[docid][:label].split(/\s+/).include?("killed") && opts[:skip_killed]
+          killed = true
+          break
+        end
         mid = @index[docid][:message_id]
         unless messages.member?(mid)
-          Redwood::log "got #{mid} as a child of #{id}"
+          #Redwood::log "got #{mid} as a child of #{id}"
           messages[mid] ||= lambda { build_message docid }
           refs = @index[docid][:refs].split(" ")
           pending += refs
         end
       end
     end
-    Redwood::log "ran #{num_queries} queries to build thread of #{messages.size + 1} messages for #{m.id}" if num_queries > 0
-    messages.each { |mid, builder| yield mid, builder }
+    if killed
+      Redwood::log "thread for #{m.id} is killed, ignoring"
+      false
+    else
+      Redwood::log "ran #{num_queries} queries to build thread of #{messages.size + 1} messages for #{m.id}: #{m.subj}" if num_queries > 0
+      messages.each { |mid, builder| yield mid, builder }
+      true
+    end
   end
 
   ## builds a message object from a ferret result
@@ -294,7 +305,7 @@ EOS
       "from" => doc[:from],
       "to" => doc[:to],
       "message-id" => doc[:message_id],
-      "references" => doc[:refs],
+      "references" => doc[:refs].split(/\s+/).map { |x| "<#{x}>" }.join(" "),
     }
 
     Message.new :source => source, :source_info => doc[:source_info].to_i, 
@@ -330,7 +341,7 @@ EOS
     num = h[:num] || 20
     @index.search_each(q, :sort => "date DESC", :limit => :all) do |docid, score|
       break if contacts.size >= num
-      #Redwood::log "got message with to: #{@index[docid][:to].inspect} and from: #{@index[docid][:from].inspect}"
+      #Redwood::log "got message #{docid} to: #{@index[docid][:to].inspect} and from: #{@index[docid][:from].inspect}"
       f = @index[docid][:from]
       t = @index[docid][:to]
 
@@ -359,7 +370,20 @@ EOS
 
 protected
 
-  def parse_user_query_string str; @qparser.parse str; end
+  def parse_user_query_string str
+    str2 = str.gsub(/(to|from):(\S+)/) do
+      field, name = $1, $2
+      if(p = ContactManager.contact_for(name))
+        [field, p.email]
+      else
+        [field, name]
+      end.join(":")
+    end
+    
+    Redwood::log "translated #{str} to #{str2}" unless str2 == str
+    @qparser.parse str2
+  end
+
   def build_query opts
     query = Ferret::Search::BooleanQuery.new
     query.add_query opts[:qobj], :must if opts[:qobj]
@@ -376,7 +400,7 @@ protected
         
     query.add_query Ferret::Search::TermQuery.new("label", "spam"), :must_not unless opts[:load_spam] || labels.include?(:spam)
     query.add_query Ferret::Search::TermQuery.new("label", "deleted"), :must_not unless opts[:load_deleted] || labels.include?(:deleted)
-    query.add_query Ferret::Search::TermQuery.new("label", "killed"), :must_not unless opts[:load_killed] || labels.include?(:killed)
+    query.add_query Ferret::Search::TermQuery.new("label", "killed"), :must_not if opts[:skip_killed]
     query
   end