8 attr_reader :containers
17 def empty?; @containers.empty?; end
20 raise "bad drop" unless @containers.member? c
25 puts "=== start thread #{self} with #{@containers.length} trees ==="
26 @containers.each { |c| c.dump_recursive }
27 puts "=== end thread ==="
30 ## yields each message and some stuff
31 def each fake_root=false
33 root = @containers.find_all { |c| !Message.subj_is_reply?(c) }.argmin { |c| c.date }
37 root.first_useful_descendant.each_with_stuff do |c, d, par|
38 yield c.message, d, (par ? par.message : nil)
40 elsif @containers.length > 1 && fake_root
42 yield :fake_root, 0, nil
45 @containers.each do |cont|
47 fud = cont.first_useful_descendant
48 fud.each_with_stuff do |c, d, par|
49 ## special case here: if we're an empty root that's already
50 ## been joined by a fake root, don't emit
51 yield c.message, d + adj, (par ? par.message : nil) unless
52 fake_root && c.message.nil? && root.nil? && c == fud
57 def dirty?; any? { |m, *o| m && m.dirty? }; end
58 def date; map { |m, *o| m.date if m }.compact.max; end
59 def snippet; argfind { |m, *o| m && m.snippet }; end
60 def authors; map { |m, *o| m.from if m }.compact.uniq; end
62 def apply_label t; each { |m, *o| m && m.add_label(t) }; end
64 each { |m, *o| m && m.remove_label(t) }
67 def toggle_label label
77 def set_labels l; each { |m, *o| m && m.labels = l }; end
79 def has_label? t; any? { |m, *o| m && m.has_label?(t) }; end
80 def save index; each { |m, *o| m && m.save(index) }; end
82 def direct_participants
83 map { |m, *o| [m.from] + m.to if m }.flatten.compact.uniq
87 map { |m, *o| [m.from] + m.to + m.cc + m.bcc if m }.flatten.compact.uniq
90 def size; map { |m, *o| m ? 1 : 0 }.sum; end
91 def subj; argfind { |m, *o| m && m.subj }; end
93 map { |m, *o| m && m.labels }.flatten.compact.uniq.sort_by { |t| t.to_s }
96 each { |m, *o| m && m.labels = l.clone }
100 inject(nil) do |a, b|
107 b.date > a.date ? b : a
113 "<thread containing: #{@containers.join ', '}>"
117 ## recursive structure used internally to represent message trees as
118 ## described by reply-to: and references: headers.
120 ## the 'id' field is the same as the message id. but the message might
121 ## be empty, in the case that we represent a message that was referenced
122 ## by another message (as an ancestor) but never received.
124 attr_accessor :message, :parent, :children, :id, :thread
127 raise "non-String #{id.inspect}" unless id.is_a? String
129 @message, @parent, @thread = nil, nil, nil
133 def each_with_stuff parent=nil
134 yield self, 0, parent
135 @children.each do |c|
136 c.each_with_stuff(self) { |cc, d, par| yield cc, d + 1, par }
144 @parent && @parent.descendant_of?(o)
148 def == o; Container === o && id == o.id; end
150 def empty?; @message.nil?; end
151 def root?; @parent.nil?; end
152 def root; root? ? self : @parent.root; end
154 def first_useful_descendant
155 if empty? && @children.size == 1
156 @children.first.first_useful_descendant
164 @children.argfind { |c| c.find_attr attr }
169 def subj; find_attr :subj; end
170 def date; find_attr :date; end
172 def is_reply?; subj && Message.subject_is_reply?(subj); end
176 (@parent.nil? ? nil : "parent=#{@parent.id}"),
177 (@children.empty? ? nil : "children=#{@children.map { |c| c.id }.inspect}"),
178 ].compact.join(" ") + ">"
181 def dump_recursive indent=0, root=true, parent=nil
182 raise "inconsistency" unless parent.nil? || parent.children.include?(self)
187 line = #"[#{useful? ? 'U' : ' '}] " +
189 "[#{thread}] #{@message.subj} " ##{@message.refs.inspect} / #{@message.replytos.inspect}"
194 puts "#{id} #{line}"#[0 .. (105 - indent)]
196 @children.each { |c| c.dump_recursive indent, false, self }
200 ## a set of threads (so a forest). builds the thread structures by
201 ## reading messages from an index.
203 attr_reader :num_messages
208 @messages = {} ## map from message ids to container objects
209 @subj_thread = {} ## map from subject strings to thread objects
212 def contains_id? id; @messages.member?(id) && !@messages[id].empty?; end
214 (c = @messages[m.id]) && c.root.thread
218 @subj_thread.each { |k, v| @subj_thread.delete(k) if v.empty? }
220 private :delete_empties
222 def threads; delete_empties; @subj_thread.values; end
223 def size; delete_empties; @subj_thread.size; end
226 @subj_thread.each do |s, t|
227 puts "**********************"
228 puts "** for subject #{s} **"
229 puts "**********************"
234 def link p, c, overwrite=false
235 if p == c || p.descendant_of?(c) || c.descendant_of?(p) # would create a loop
236 # puts "*** linking parent #{p} and child #{c} would create a loop"
240 if c.parent.nil? || overwrite
241 c.parent.children.delete c if overwrite && c.parent
253 return unless(c = @messages[mid])
255 c.parent.children.delete c if c.parent
262 ## load in (at most) num number of threads from the index
263 def load_n_threads num, opts={}
264 @index.each_id_by_date opts do |mid, builder|
266 next if contains_id? mid
270 load_thread_for_message m
271 yield @subj_thread.size if block_given?
275 ## loads in all messages needed to thread m
276 def load_thread_for_message m
277 @index.each_message_in_thread_for m, :limit => 100 do |mid, builder|
278 next if contains_id? mid
279 add_message builder.call
284 m.refs.any? { |ref_id| @messages[ref_id] }
287 ## an "online" version of the jwz threading algorithm.
288 def add_message message
290 el = (@messages[id] ||= Container.new id)
291 return if @messages[id].message # we've seen it before
296 ## link via references:
298 message.refs.each do |ref_id|
299 raise "non-String ref id #{ref_id.inspect} (full: #{message.refs.inspect})" unless ref_id.is_a?(String)
300 ref = (@messages[ref_id] ||= Container.new ref_id)
301 link prev, ref if prev
304 link prev, el, true if prev
306 ## link via in-reply-to:
307 message.replytos.each do |ref_id|
308 ref = (@messages[ref_id] ||= Container.new ref_id)
310 break # only do the first one
313 ## update subject grouping
315 # puts "> have #{el}, root #{root}, oldroot #{oldroot}"
320 # puts "*** root (#{root.subj}) == oldroot (#{oldroot.subj}); ignoring"
322 ## to disable subject grouping, use the next line instead
323 ## (and the same for below)
324 thread = (@subj_thread[Message.normalize_subj(root.subj)] ||= Thread.new)
325 #thread = (@subj_thread[root.id] ||= Thread.new)
329 # puts "# (1) added #{root} to #{thread}"
333 ## new root. need to drop old one and put this one in its place
334 # puts "*** DROPPING #{oldroot} from #{oldroot.thread}"
335 oldroot.thread.drop oldroot
340 # puts "*** IGNORING cuz root already has a thread"
342 ## to disable subject grouping, use the next line instead
343 ## (and the same above)
344 thread = (@subj_thread[Message.normalize_subj(root.subj)] ||= Thread.new)
345 #thread = (@subj_thread[root.id] ||= Thread.new)
349 # puts "# (2) added #{root} to #{thread}"