lib/sup/thread.rb in sup-0.3 vs lib/sup/thread.rb in sup-0.4
- old
+ new
@@ -9,11 +9,11 @@
## 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
+## 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
@@ -45,22 +45,22 @@
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 "=== start thread with #{@containers.length} trees ==="
+ @containers.each { |c| c.dump_recursive f; f.puts }
f.puts "=== end thread ==="
end
## 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 deduced 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 }
+ root = @containers.find_all { |c| c.message && !Message.subj_is_reply?(c.message.subj) }.argmin { |c| c.date }
if root
adj = 1
root.first_useful_descendant.each_with_stuff do |c, d, par|
yield c.message, d, (par ? par.message : nil)
@@ -183,10 +183,14 @@
def empty?; @message.nil?; end
def root?; @parent.nil?; end
def root; root? ? self : @parent.root; end
+ ## skip over any containers which are empty and have only one child. we use
+ ## this make the threaded display a little nicer, and only stick in the
+ ## "missing message" line when it's graphically necessary, i.e. when the
+ ## missing message has more than one descendent.
def first_useful_descendant
if empty? && @children.size == 1
@children.first.first_useful_descendant
else
self
@@ -201,11 +205,11 @@
end
end
def subj; find_attr :subj; end
def date; find_attr :date; end
- def is_reply?; subj && Message.subject_is_reply?(subj); end
+ def is_reply?; subj && Message.subj_is_reply?(subj); end
def to_s
[ "<#{id}",
(@parent.nil? ? nil : "parent=#{@parent.id}"),
(@children.empty? ? nil : "children=#{@children.map { |c| c.id }.inspect}"),
@@ -216,30 +220,33 @@
raise "inconsistency" unless parent.nil? || parent.children.include?(self)
unless root
f.print " " * indent
f.print "+->"
end
- line = #"[#{useful? ? 'U' : ' '}] " +
+ line = "[#{thread.nil? ? ' ' : '*'}] " + #"[#{useful? ? 'U' : ' '}] " +
if @message
- "[#{thread}] #{@message.subj} " ##{@message.refs.inspect} / #{@message.replytos.inspect}"
+ message.subj ##{@message.refs.inspect} / #{@message.replytos.inspect}"
else
"<no message>"
end
f.puts "#{id} #{line}"#[0 .. (105 - indent)]
indent += 3
@children.each { |c| c.dump_recursive f, indent, false, self }
end
end
-## A set of threads (so a forest). Builds thread structures by reading
-## messages from an index.
+## A set of threads, so a forest. Is integrated with the index and
+## builds thread structures by reading messages from it.
##
## 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.
+##
+## The following invariants are maintained: every Thread has at least one
+## Container tree, and every Container tree has at least one Message.
class ThreadSet
attr_reader :num_messages
bool_reader :thread_by_subj
def initialize index, thread_by_subj=true
@@ -250,59 +257,70 @@
## 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
- def thread_for m
- (c = @messages[m.id]) && c.root.thread
- end
+ def thread_for_id mid; (c = @messages[mid]) && c.root.thread end
+ def contains_id? id; @messages.member?(id) && !@messages[id].empty? end
+ def thread_for m; thread_for_id m.id end
+ def contains? m; contains_id? m.id end
- def delete_cruft
- @threads.each { |k, v| @threads.delete(k) if v.empty? }
- end
- private :delete_cruft
+ def threads; @threads.values end
+ def size; @threads.size end
- def threads; delete_cruft; @threads.values; end
- def size; delete_cruft; @threads.size; end
-
- ## unused
- def dump f
+ def dump f=$stdout
@threads.each do |s, t|
f.puts "**********************"
f.puts "** for subject #{s} **"
f.puts "**********************"
t.dump f
end
end
+ ## link two containers
def link p, c, overwrite=false
if p == c || p.descendant_of?(c) || c.descendant_of?(p) # would create a loop
-# puts "*** linking parent #{p} and child #{c} would create a loop"
+ #puts "*** linking parent #{p.id} and child #{c.id} would create a loop"
return
end
- if c.parent.nil? || overwrite
- c.parent.children.delete c if overwrite && c.parent
- if c.thread
- c.thread.drop c
- c.thread = nil
- end
- p.children << c
- c.parent = p
- end
+ #puts "in link for #{p.id} to #{c.id}, perform? #{c.parent.nil?} || #{overwrite}"
+
+ return unless c.parent.nil? || overwrite
+ remove_container c
+ p.children << c
+ c.parent = p
+
+ ## if the child was previously a top-level container, it now ain't,
+ ## so ditch our thread and kill it if necessary
+ prune_thread_of c
end
private :link
- def remove mid
+ def remove_container c
+ c.parent.children.delete c if c.parent # remove from tree
+ end
+ private :remove_container
+
+ def prune_thread_of c
+ return unless c.thread
+ c.thread.drop c
+ @threads.delete_if { |k, v| v == c.thread } if c.thread.empty?
+ c.thread = nil
+ end
+ private :prune_thread_of
+
+ def remove_id mid
return unless(c = @messages[mid])
+ remove_container c
+ prune_thread_of c
+ end
- c.parent.children.delete c if c.parent
- if c.thread
- c.thread.drop c
- c.thread = nil
- end
+ def remove_thread_containing_id mid
+ c = @messages[mid] or return
+ t = c.root.thread
+ @threads.delete_if { |key, thread| t == thread }
end
## load in (at most) num number of threads from the index
def load_n_threads num, opts={}
@index.each_id_by_date opts do |mid, builder|
@@ -329,45 +347,64 @@
def add_thread t
raise "duplicate" if @threads.values.member? t
t.each { |m, *o| add_message m }
end
+ ## merges two threads together. both must be members of this threadset.
+ ## does its best, heuristically, to determine which is the parent.
+ def join_threads threads
+ return if threads.size < 2
+
+ containers = threads.map do |t|
+ c = @messages[t.first.id]
+ raise "not in threadset: #{t.first.id}" unless c && c.message
+ c
+ end
+
+ ## use subject headers heuristically
+ parent = containers.find { |c| !c.is_reply? }
+
+ ## no thread was rooted by a non-reply, so make a fake parent
+ parent ||= @messages["joining-ref-" + containers.map { |c| c.id }.join("-")]
+
+ containers.each do |c|
+ next if c == parent
+ c.message.add_ref parent.id
+ link parent, c
+ end
+
+ true
+ end
+
def is_relevant? m
m.refs.any? { |ref_id| @messages.member? ref_id }
end
## the heart of the threading code
def add_message message
el = @messages[message.id]
return if el.message # we've seen it before
+ #puts "adding: #{message.id}, refs #{message.refs.inspect}"
+
el.message = message
oldroot = el.root
## link via references:
- prev = nil
- message.refs.each do |ref_id|
+ (message.refs + [el.id]).inject(nil) do |prev, ref_id|
ref = @messages[ref_id]
link prev, ref if prev
- prev = ref
+ ref
end
- link prev, el, true if prev
## link via in-reply-to:
message.replytos.each do |ref_id|
ref = @messages[ref_id]
link ref, el, true
break # only do the first one
end
root = el.root
-
- ## 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
root.id