sup 0.0.8 → 0.1

data/lib/sup/thread.rb

@@ -1,24 +1,28 @@
-## Herein is all the code responsible for threading messages. I use an
-## online version of the JWZ threading algorithm:
+## Herein lies all the code responsible for threading messages. It's
+## basically an online version of the JWZ threading algorithm:
 ## http://www.jwz.org/doc/threading.html
 ##
-## I certainly didn't implement it for efficiency, but thanks to our
-## search engine backend, it's typically not applied to very many
-## messages at once.
-
-## At the top level, we have a ThreadSet. A ThreadSet represents a set
-## of threads, e.g. a message folder or an inbox. Each ThreadSet
-## contains zero or more Threads. A Thread represents all the message
-## related to a particular subject. Each Thread has one or more
-## Containers. A Container is a recursive structure that holds the
-## tree structure as determined by the references: and in-reply-to:
-## headers. A Thread with multiple Containers occurs if they have the
-## same subject, but (most likely due to someone using a primitive
-## MUA) we don't have evidence from in-reply-to: or references:
-## headers, only subject: (and thus our tree is probably broken). A
-## Container holds zero or one message. In the case of no message, it
-## means we've seen a reference to the message but haven't seen the
-## message itself (yet).
+## I didn't implement it for efficiency, but thanks to our search
+## engine backend, it's typically not applied to very many messages at
+## once.
+##
+## At the top level, we have a ThreadSet, which represents a set of
+## threads, e.g. a message folder or an inbox. Each ThreadSet contains
+## zero or more Threads. A Thread represents all the message related
+## to a particular subject. Each Thread has one or more Containers.  A
+## Container is a recursive structure that holds the message tree as
+## determined by the references: and in-reply-to: headers. EAch
+## Container holds zero or one messages. In the case of zero messages,
+## it means we've seen a reference to the message but haven't (yet)
+## seen the message itself.
+##
+## A Thread can have multiple top-level Containers if we decide to
+## group them together independent of tree structure, typically if
+## (e.g. due to someone using a primitive MUA) the messages have the
+## same subject but we don't have evidence from in-reply-to: or
+## references: headers. In this case Thread#each can optionally yield
+## a faked root object tying them all together into one tree
+## structure.
 
 module Redwood
 
@@ -38,20 +42,20 @@ class Thread
   end
 
   def empty?; @containers.empty?; end
-
-  def drop c
-    raise "bad drop" unless @containers.member? c
-    @containers.delete c
+  def empty!; @containers.clear; end
+  def drop c; @containers.delete(c) or raise "bad drop"; end
+
+  ## unused
+  def dump f=$stdout
+    f.puts "=== start thread #{self} with #{@containers.length} trees ==="
+    @containers.each { |c| c.dump_recursive f }
+    f.puts "=== end thread ==="
   end
 
-  def dump
-    puts "=== start thread #{self} with #{@containers.length} trees ==="
-    @containers.each { |c| c.dump_recursive }
-    puts "=== end thread ==="
-  end
-
-  ## yields each message, its depth, and its parent.  note that the
-  ## message can be a Message object, or :fake_root, or nil.
+  ## yields each message, its depth, and its parent. the message yield
+  ## parameter can be a Message object, or :fake_root, or nil (no
+  ## message found but the presence of one induced from other
+  ## messages).
   def each fake_root=false
     adj = 0
     root = @containers.find_all { |c| !Message.subj_is_reply?(c) }.argmin { |c| c.date || 0 }
@@ -201,11 +205,11 @@ class Container
     ].compact.join(" ") + ">"
   end
 
-  def dump_recursive indent=0, root=true, parent=nil
+  def dump_recursive f=$stdout, indent=0, root=true, parent=nil
     raise "inconsistency" unless parent.nil? || parent.children.include?(self)
     unless root
-      print " " * indent
-      print "+->"
+      f.print " " * indent
+      f.print "+->"
     end
     line = #"[#{useful? ? 'U' : ' '}] " +
       if @message
@@ -214,22 +218,31 @@ class Container
         "<no message>"
       end
 
-    puts "#{id} #{line}"#[0 .. (105 - indent)]
+    f.puts "#{id} #{line}"#[0 .. (105 - indent)]
     indent += 3
-    @children.each { |c| c.dump_recursive indent, false, self }
+    @children.each { |c| c.dump_recursive f, indent, false, self }
   end
 end
 
-## a set of threads (so a forest). builds the thread structures by
-## reading messages from an index.
+## A set of threads (so a forest). Builds thread structures by reading
+## messages from an index.
+##
+## If 'thread_by_subj' is true, puts messages with the same subject in
+## one thread, even if they don't reference each other. This is
+## helpful for crappy MUAs that don't set In-reply-to: or References:
+## headers, but means that messages may be threaded unnecessarily.
 class ThreadSet
   attr_reader :num_messages
+  bool_reader :thread_by_subj
 
-  def initialize index
+  def initialize index, thread_by_subj=true
     @index = index
     @num_messages = 0
-    @messages = {} ## map from message ids to container objects
-    @subj_thread = {} ## map from subject strings to thread objects
+    ## map from message ids to container objects
+    @messages = SavingHash.new { |id| Container.new id }
+    ## map from subject strings or (or root message ids) to thread objects
+    @threads = SavingHash.new { Thread.new }
+    @thread_by_subj = thread_by_subj
   end
 
   def contains_id? id; @messages.member?(id) && !@messages[id].empty?; end
@@ -238,19 +251,20 @@ class ThreadSet
   end
 
   def delete_cruft
-    @subj_thread.each { |k, v| @subj_thread.delete(k) if v.empty? || v.subj != k }
+    @threads.each { |k, v| @threads.delete(k) if v.empty? }
   end
   private :delete_cruft
 
-  def threads; delete_cruft; @subj_thread.values; end
-  def size; delete_cruft; @subj_thread.size; end
+  def threads; delete_cruft; @threads.values; end
+  def size; delete_cruft; @threads.size; end
 
-  def dump
-    @subj_thread.each do |s, t|
-      puts "**********************"
-      puts "** for subject #{s} **"
-      puts "**********************"
-      t.dump
+  ## unused
+  def dump f
+    @threads.each do |s, t|
+      f.puts "**********************"
+      f.puts "** for subject #{s} **"
+      f.puts "**********************"
+      t.dump f
     end
   end
 
@@ -291,7 +305,7 @@ class ThreadSet
       m = builder.call
       add_message m
       load_thread_for_message m, :load_killed => opts[:load_killed]
-      yield @subj_thread.size if block_given?
+      yield size if block_given?
     end
   end
 
@@ -305,19 +319,18 @@ class ThreadSet
 
   ## merges in a pre-loaded thread
   def add_thread t
-    raise "duplicate" if @subj_thread.values.member? t
+    raise "duplicate" if @threads.values.member? t
     t.each { |m, *o| add_message m }
   end
 
   def is_relevant? m
-    m.refs.any? { |ref_id| @messages[ref_id] }
+    m.refs.any? { |ref_id| @messages.member? ref_id }
   end
 
-  ## an "online" version of the jwz threading algorithm.
+  ## the heart of the threading code
   def add_message message
-    id = message.id
-    el = (@messages[id] ||= Container.new id)
-    return if @messages[id].message # we've seen it before
+    el = @messages[message.id]
+    return if el.message # we've seen it before
 
     el.message = message
     oldroot = el.root
@@ -325,8 +338,7 @@ class ThreadSet
     ## link via references:
     prev = nil
     message.refs.each do |ref_id|
-      raise "non-String ref id #{ref_id.inspect} (full: #{message.refs.inspect})" unless ref_id.is_a?(String)
-      ref = (@messages[ref_id] ||= Container.new ref_id)
+      ref = @messages[ref_id]
       link prev, ref if prev
       prev = ref
     end
@@ -334,81 +346,43 @@ class ThreadSet
 
     ## link via in-reply-to:
     message.replytos.each do |ref_id|
-      ref = (@messages[ref_id] ||= Container.new ref_id)
+      ref = @messages[ref_id]
       link ref, el, true
       break # only do the first one
     end
 
-    ## update subject grouping
     root = el.root
-    #    puts "> have #{el}, root #{root}, oldroot #{oldroot}"
-    #    el.dump_recursive
-
-    if root == oldroot
-      if oldroot.thread
-        ## check to see if the subject is still the same (in the case
-        ## that we first added a child message with a different
-        ## subject)
-
-        ## this code is duplicated below. sorry! TODO: refactor
-        s = Message.normalize_subj(root.subj)
-        unless @subj_thread[s] == root.thread
-          ## Redwood::log "[1] moving thread to new subject #{root.subj}"
-          if @subj_thread[s]
-            @subj_thread[s] << root
-            root.thread = @subj_thread[s]
-          else
-            @subj_thread[s] = root.thread
-          end
-        end
 
+    ## new root. need to drop old one and put this one in its place
+    if root != oldroot && oldroot.thread
+      oldroot.thread.drop oldroot
+      oldroot.thread = nil
+    end
+
+    key =
+      if thread_by_subj?
+        Message.normalize_subj root.subj
       else
-        ## to disable subject grouping, use the next line instead
-        ## (and the same for below)
-        #Redwood::log "[1] for #{root}, subject #{Message.normalize_subj(root.subj)} has #{@subj_thread[Message.normalize_subj(root.subj)] ? 'a' : 'no'} thread"
-        thread = (@subj_thread[Message.normalize_subj(root.subj)] ||= Thread.new)
-        #thread = (@subj_thread[root.id] ||= Thread.new)
-
-        thread << root
-        root.thread = thread
-        # Redwood::log "[1] added #{root} to #{thread}"
-      end
-    else
-      if oldroot.thread
-        ## new root. need to drop old one and put this one in its place
-        oldroot.thread.drop oldroot
-        oldroot.thread = nil
+        root.id
       end
 
-      if root.thread
-        ## check to see if the subject is still the same (in the case
-        ## that we first added a child message with a different
-        ## subject)
-        s = Message.normalize_subj(root.subj)
-        unless @subj_thread[s] == root.thread
-          # Redwood::log "[2] moving thread to new subject #{root.subj}"
-          if @subj_thread[s]
-            @subj_thread[s] << root
-            root.thread = @subj_thread[s]
-          else
-            @subj_thread[s] = root.thread
-          end
+    ## check to see if the subject is still the same (in the case
+    ## that we first added a child message with a different
+    ## subject)
+    if root.thread
+      unless @threads[key] == root.thread
+        if @threads[key]
+          root.thread.empty!
+          @threads[key] << root
+          root.thread = @threads[key]
+        else
+          @threads[key] = root.thread
         end
-
-      else
-        ## to disable subject grouping, use the next line instead
-        ## (and the same above)
-        
-        ## this code is duplicated above. sorry! TODO: refactor
-        # Redwood::log "[2] for #{root}, subject '#{Message.normalize_subj(root.subj)}' has #{@subj_thread[Message.normalize_subj(root.subj)] ? 'a' : 'no'} thread"
-
-        thread = (@subj_thread[Message.normalize_subj(root.subj)] ||= Thread.new)
-        #thread = (@subj_thread[root.id] ||= Thread.new)
-
-        thread << root
-        root.thread = thread
-        # Redwood::log "[2] added #{root} to #{thread}"
       end
+    else
+      thread = @threads[key]
+      thread << root
+      root.thread = thread
     end
 
     ## last bit

data/lib/sup/util.rb

@@ -1,3 +1,98 @@
+require 'lockfile'
+require 'mime/types'
+require 'pathname'
+
+## time for some monkeypatching!
+class Lockfile
+  def gen_lock_id
+    Hash[
+         'host' => "#{ Socket.gethostname }",
+         'pid' => "#{ Process.pid }",
+         'ppid' => "#{ Process.ppid }",
+         'time' => timestamp,
+         'pname' => $0,
+         'user' => ENV["USER"]
+        ]
+  end
+
+  def dump_lock_id lock_id = @lock_id
+      "host: %s\npid: %s\nppid: %s\ntime: %s\nuser: %s\npname: %s\n" %
+        lock_id.values_at('host','pid','ppid','time','user', 'pname')
+    end
+
+  def lockinfo_on_disk
+    h = load_lock_id IO.read(path)
+    h['mtime'] = File.mtime path
+    h
+  end
+
+  def touch_yourself; touch path end
+end
+
+class Pathname
+  def human_size
+    s =
+      begin
+        size
+      rescue SystemCallError
+        return "?"
+      end
+
+    if s < 1024
+      s.to_s + "b"
+    elsif s < (1024 * 1024)
+      (s / 1024).to_s + "k"
+    elsif s < (1024 * 1024 * 1024)
+      (s / 1024 / 1024).to_s + "m"
+    else
+      (s / 1024 / 1024 / 1024).to_s + "g"
+    end
+  end
+
+  def human_time
+    begin
+      ctime.strftime("%Y-%m-%d %H:%M")
+    rescue SystemCallError
+      "?"
+    end
+  end
+end
+
+## more monkeypatching!
+module RMail
+  class EncodingUnsupportedError < StandardError; end
+
+  class Message
+    def add_attachment fn
+      bfn = File.basename fn
+      a = Message.new
+      t = MIME::Types.type_for(bfn).first || MIME::Types.type_for("exe").first
+
+      a.header.add "Content-Disposition", "attachment; filename=#{bfn}"
+      a.header.add "Content-Type", "#{t.content_type}; name=#{bfn}"
+      a.header.add "Content-Transfer-Encoding", t.encoding
+      a.body =
+        case t.encoding
+        when "base64"
+          [IO.read(fn)].pack "m"
+        when "quoted-printable"
+          [IO.read(fn)].pack "M"
+        else
+          raise EncodingUnsupportedError, t.encoding
+        end
+
+      add_part a
+    end
+  end
+end
+
+class Range
+  ## only valid for integer ranges (unless I guess it's exclusive)
+  def size 
+    last - first + (exclude_end? ? 0 : 1)
+  end
+end
+
 class Module
   def bool_reader *args
     args.each { |sym| class_eval %{ def #{sym}?; @#{sym}; end } }
@@ -9,7 +104,10 @@ class Module
   end
 
   def defer_all_other_method_calls_to obj
-    class_eval %{ def method_missing meth, *a, &b; @#{obj}.send meth, *a, &b; end }
+    class_eval %{
+      def method_missing meth, *a, &b; @#{obj}.send meth, *a, &b; end
+      def respond_to? meth; @#{obj}.respond_to?(meth); end
+    }
   end
 end
 
@@ -38,6 +136,8 @@ class Object
   ##
   ## i'm sure there's pithy comment i could make here about the
   ## superiority of lisp, but fuck lisp.
+  ##
+  ## addendum: apparently this is a "k combinator". whoda thunk it?
   def returning x; yield x; x; end
 
   ## clone of java-style whole-method synchronization
@@ -174,6 +274,24 @@ module Enumerable
     end
     best
   end
+
+  ## returns the maximum shared prefix of an array of strings
+  ## optinally excluding a prefix
+  def shared_prefix exclude=""
+    return "" if empty?
+    prefix = ""
+    (0 ... first.length).each do |i|
+      c = first[i]
+      break unless all? { |s| s[i] == c }
+      next if exclude[i] == c
+      prefix += c.chr
+    end
+    prefix
+  end
+
+  def max_of
+    map { |e| yield e }.max
+  end
 end
 
 class Array
@@ -185,6 +303,8 @@ class Array
   def rest; self[1..-1]; end
 
   def to_boolean_h; Hash[*map { |x| [x, true] }.flatten]; end
+
+  def last= e; self[-1] = e end
 end
 
 class Time
@@ -271,6 +391,13 @@ module Singleton
     def deinstantiate!; @instance = nil; end
     def method_missing meth, *a, &b
       raise "no instance defined!" unless defined? @instance
+
+      ## if we've been deinstantiated, just drop all calls. this is
+      ## useful because threads that might be active during the
+      ## cleanup process (e.g. polling) would otherwise have to
+      ## special-case every call to a Singleton object
+      return nil if @instance.nil?
+
       @instance.send meth, *a, &b
     end
     def i_am_the_instance o
@@ -301,6 +428,9 @@ class Recoverable
   def id; __pass :id; end
   def to_s; __pass :to_s; end
   def to_yaml x; __pass :to_yaml, x; end
+  def is_a? c; @o.is_a? c; end
+
+  def respond_to? m; @o.respond_to? m end
 
   def __pass m, *a, &b
     begin
@@ -311,3 +441,39 @@ class Recoverable
     end
   end
 end
+
+## acts like a hash with an initialization block, but saves any
+## newly-created value even upon lookup.
+##
+## for example:
+##
+## class C
+##   attr_accessor :val
+##   def initialize; @val = 0 end
+## end
+## 
+## h = Hash.new { C.new }
+## h[:a].val # => 0
+## h[:a].val = 1
+## h[:a].val # => 0
+##
+## h2 = SavingHash.new { C.new }
+## h2[:a].val # => 0
+## h2[:a].val = 1
+## h2[:a].val # => 1
+##
+## important note: you REALLY want to use #member? to test existence,
+## because just checking h[anything] will always evaluate to true
+## (except for degenerate constructor blocks that return nil or false)
+class SavingHash
+  def initialize &b
+    @constructor = b
+    @hash = Hash.new
+  end
+
+  def [] k
+    @hash[k] ||= @constructor.call(k)
+  end
+
+  defer_all_other_method_calls_to :hash
+end