sup 0.3 → 0.4

data/lib/sup/textfield.rb

@@ -16,9 +16,7 @@ module Redwood
 ## in sup, completion support is implemented through BufferManager#ask
 ## and CompletionMode.
 class TextField
-  def initialize window, y, x, width
-    @w, @x, @y = window, x, y
-    @width = width
+  def initialize
     @i = nil
     @history = []
 
@@ -31,11 +29,11 @@ class TextField
 
   def value; @value || get_cursed_value end
 
-  def activate question, default=nil, &block
+  def activate window, y, x, width, question, default=nil, &block
+    @w, @y, @x, @width = window, y, x, width
     @question = question
     @completion_block = block
-    @field = Ncurses::Form.new_field 1, @width - question.length,
-                                     @y, @x + question.length, 0, 0
+    @field = Ncurses::Form.new_field 1, @width - question.length, @y, @x + question.length, 0, 0
     @form = Ncurses::Form.new_form [@field]
     @value = default
     Ncurses::Form.post_form @form
@@ -47,7 +45,7 @@ class TextField
     @w.mvaddstr @y, 0, @question
     Ncurses.curs_set 1
     Ncurses::Form.form_driver @form, Ncurses::Form::REQ_END_FIELD
-    Ncurses::Form.form_driver @form, Ncurses::Form::REQ_NEXT_CHAR if @value && @value =~ / $/ # fucking RETARDED!!!!
+    Ncurses::Form.form_driver @form, Ncurses::Form::REQ_NEXT_CHAR if @value && @value =~ / $/ # fucking RETARDED
   end
 
   def deactivate
@@ -100,6 +98,8 @@ class TextField
         Ncurses::Form::REQ_PREV_CHAR
       when Ncurses::KEY_RIGHT
         Ncurses::Form::REQ_NEXT_CHAR
+      when Ncurses::KEY_DC
+        Ncurses::Form::REQ_DEL_CHAR
       when Ncurses::KEY_BACKSPACE
         Ncurses::Form::REQ_DEL_PREV
       when 1 #ctrl-a

data/lib/sup/thread.rb

@@ -11,7 +11,7 @@
 ## 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.
@@ -47,8 +47,8 @@ class Thread
 
   ## 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
 
@@ -58,7 +58,7 @@ class Thread
   ## 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
@@ -185,6 +185,10 @@ class Container
   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
@@ -203,7 +207,7 @@ class Container
   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}",
@@ -218,9 +222,9 @@ class Container
       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
@@ -231,13 +235,16 @@ class Container
   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
@@ -252,21 +259,15 @@ class ThreadSet
     @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 delete_cruft
-    @threads.each { |k, v| @threads.delete(k) if v.empty? }
-  end
-  private :delete_cruft
+  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 threads; delete_cruft; @threads.values; end
-  def size; delete_cruft; @threads.size; end
+  def threads; @threads.values end
+  def size; @threads.size end
 
-  ## unused
-  def dump f
+  def dump f=$stdout
     @threads.each do |s, t|
       f.puts "**********************"
       f.puts "** for subject #{s} **"
@@ -275,32 +276,49 @@ class ThreadSet
     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
@@ -331,6 +349,32 @@ class ThreadSet
     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
@@ -340,17 +384,17 @@ class ThreadSet
     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|
@@ -360,13 +404,6 @@ class ThreadSet
     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

data/lib/sup/update.rb

@@ -1,5 +1,16 @@
 module Redwood
 
+## Classic listener/broadcaster paradigm. Handles communication between various
+## parts of Sup.
+##
+## Usage note: don't pass threads around. Neither thread nor message equality is
+## defined anywhere in Sup beyond standard object equality. To communicate
+## something about a particular thread, just pass a representative message from
+## it around.
+##
+## (This assumes that no message will be a part of more than one thread within a
+## single "view". Luckily, that's true.)
+
 class UpdateManager
   include Singleton
 

data/lib/sup/util.rb

@@ -1,3 +1,4 @@
+require 'thread'
 require 'lockfile'
 require 'mime/types'
 require 'pathname'
@@ -37,16 +38,7 @@ class Pathname
       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
+    s.to_human_size
   end
 
   def human_time
@@ -63,33 +55,35 @@ module RMail
   class EncodingUnsupportedError < StandardError; end
 
   class Message
-    def add_file_attachment fn
+    def self.make_file_attachment fn
       bfn = File.basename fn
-      a = Message.new
       t = MIME::Types.type_for(bfn).first || MIME::Types.type_for("exe").first
+      make_attachment IO.read(fn), t.content_type, t.encoding, bfn.to_s
+    end
+
+    def charset
+      if header.field?("content-type") && header.fetch("content-type") =~ /charset="?(.*?)"?(;|$)/i
+        $1
+      end
+    end
 
-      a.header.add "Content-Disposition", "attachment; filename=#{bfn.to_s.inspect}"
-      a.header.add "Content-Type", "#{t.content_type}; name=#{bfn.to_s.inspect}"
-      a.header.add "Content-Transfer-Encoding", t.encoding
+    def self.make_attachment payload, mime_type, encoding, filename
+      a = Message.new
+      a.header.add "Content-Disposition", "attachment; filename=#{filename.inspect}"
+      a.header.add "Content-Type", "#{mime_type}; name=#{filename.inspect}"
+      a.header.add "Content-Transfer-Encoding", encoding if encoding
       a.body =
-        case t.encoding
+        case encoding
         when "base64"
-          [IO.read(fn)].pack "m"
+          [payload].pack "m"
         when "quoted-printable"
-          [IO.read(fn)].pack "M"
-        when "7bit", "8bit"
-          IO.read(fn)
+          [payload].pack "M"
+        when "7bit", "8bit", nil
+          payload
         else
-          raise EncodingUnsupportedError, t.encoding
+          raise EncodingUnsupportedError, encoding.inspect
         end
-
-      add_part a
-    end
-
-    def charset
-      if header.field?("content-type") && header.fetch("content-type") =~ /charset="?(.*?)"?(;|$)/
-        $1
-      end
+      a
     end
   end
 end
@@ -294,14 +288,21 @@ class Numeric
   end
 
   def in? range; range.member? self; end
+
+  def to_human_size
+    if self < 1024
+      to_s + "b"
+    elsif self < (1024 * 1024)
+      (self / 1024).to_s + "k"
+    elsif self < (1024 * 1024 * 1024)
+      (self / 1024 / 1024).to_s + "m"
+    else
+      (self / 1024 / 1024 / 1024).to_s + "g"
+    end
+  end
 end
 
 class Fixnum
-  def num_digits base=10
-    return 1 if self == 0
-    1 + (Math.log(self) / Math.log(10)).floor
-  end
-  
   def to_character
     if self < 128 && self >= 0
       chr
@@ -573,3 +574,42 @@ class SavingHash
 
   defer_all_other_method_calls_to :hash
 end
+
+class OrderedHash < Hash
+  alias_method :store, :[]=
+  alias_method :each_pair, :each
+  attr_reader :keys
+
+  def initialize *a
+    @keys = []
+    a.each { |k, v| self[k] = v }
+  end
+
+  def []= key, val
+    @keys << key unless member?(key)
+    super
+  end
+
+  def values; keys.map { |k| self[k] } end
+  def index key; @keys.index key end
+
+  def delete key
+    @keys.delete key
+    super
+  end
+
+  def each; @keys.each { |k| yield k, self[k] } end
+end
+
+## easy thread-safe class for determining who's the "winner" in a race (i.e.
+## first person to hit the finish line
+class FinishLine
+  def initialize
+    @m = Mutex.new
+    @over = false
+  end
+
+  def winner?
+    @m.synchronize { !@over && @over = true }
+  end
+end

data/test/test_message.rb

@@ -0,0 +1,441 @@
+#!/usr/bin/ruby
+
+require 'test/unit'
+require 'sup'
+require 'stringio'
+
+require 'dummy_source'
+
+# override File.exists? to make it work with StringIO for testing.
+# FIXME: do aliasing to avoid breaking this when sup moves from
+# File.exists? to File.exist?
+
+class File
+
+  def File.exists? file
+    # puts "fake File::exists?"
+
+    if file.is_a?(StringIO)
+      return false
+    end
+    # use the different function
+    File.exist?(file)
+  end
+
+end
+
+module Redwood
+
+class TestMessage < Test::Unit::TestCase
+  
+  def setup
+    person_file = StringIO.new("")
+    # this is a singleton
+    if not PersonManager.instantiated?
+      @person_manager = PersonManager.new(person_file)
+    end
+  end
+  
+  def teardown
+  end
+
+  def test_simple_message
+
+    message = <<EOS
+Return-path: <fake_sender@example.invalid>
+Envelope-to: fake_receiver@localhost
+Delivery-date: Sun, 09 Dec 2007 21:48:19 +0200
+Received: from fake_sender by localhost.localdomain with local (Exim 4.67)
+      (envelope-from <fake_sender@example.invalid>)
+      id 1J1S8R-0006lA-MJ
+      for fake_receiver@localhost; Sun, 09 Dec 2007 21:48:19 +0200
+Date: Sun, 9 Dec 2007 21:48:19 +0200
+Mailing-List: contact example-help@example.invalid; run by ezmlm
+Precedence: bulk
+List-Id: <example.list-id.example.invalid>
+List-Post: <mailto:example@example.invalid>
+List-Help: <mailto:example-help@example.invalid>
+List-Unsubscribe: <mailto:example-unsubscribe@example.invalid>
+List-Subscribe: <mailto:example-subscribe@example.invalid>
+Delivered-To: mailing list example@example.invalid
+Delivered-To: moderator for example@example.invalid
+From: Fake Sender <fake_sender@example.invalid>
+To: Fake Receiver <fake_receiver@localhost>
+Subject: Re: Test message subject
+Message-ID: <20071209194819.GA25972@example.invalid>
+References: <E1J1Rvb-0006k2-CE@localhost.localdomain>
+MIME-Version: 1.0
+Content-Type: text/plain; charset=us-ascii
+Content-Disposition: inline
+In-Reply-To: <E1J1Rvb-0006k2-CE@localhost.localdomain>
+User-Agent: Sup/0.3
+
+Test message!
+EOS
+
+    source = DummySource.new("sup-test://test_simple_message")
+    source.messages = [ message ]
+    source_info = 0
+
+    sup_message = Message.new( {:source => source, :source_info => source_info } )
+
+    # see how well parsing the header went
+
+    to = sup_message.to
+    # "to" is an Array containing person items
+
+    # there should be only one item
+    assert_equal(1, to.length)
+
+    # sup doesn't do capitalized letters in email addresses
+    assert_equal("fake_receiver@localhost", to[0].email)
+    assert_equal("Fake Receiver", to[0].name)
+
+    from = sup_message.from
+    # "from" is just a simple person item 
+
+    assert_equal("fake_sender@example.invalid", from.email)
+    assert_equal("Fake Sender", from.name)
+    
+    subj = sup_message.subj
+    assert_equal("Re: Test message subject", subj)
+    
+    list_subscribe = sup_message.list_subscribe
+    assert_equal("<mailto:example-subscribe@example.invalid>", list_subscribe)
+
+    list_unsubscribe = sup_message.list_unsubscribe
+    assert_equal("<mailto:example-unsubscribe@example.invalid>", list_unsubscribe)
+    
+    list_address = sup_message.list_address
+    assert_equal("example@example.invalid", list_address.email)
+    assert_equal("example", list_address.name)
+    
+    date = sup_message.date
+    assert_equal(Time.parse("Sun, 9 Dec 2007 21:48:19 +0200"), date)
+    
+    id = sup_message.id
+    assert_equal("20071209194819.GA25972@example.invalid", id)
+
+    refs = sup_message.refs
+    assert_equal(1, refs.length)
+    assert_equal("E1J1Rvb-0006k2-CE@localhost.localdomain", refs[0])
+    
+    replytos = sup_message.replytos
+    assert_equal(1, replytos.length)
+    assert_equal("E1J1Rvb-0006k2-CE@localhost.localdomain", replytos[0])
+    
+    cc = sup_message.cc
+    # there are no ccs
+    assert_equal(0, cc.length)
+    
+    bcc = sup_message.bcc
+    # there are no bccs
+    assert_equal(0, bcc.length)
+    
+    recipient_email = sup_message.recipient_email
+    assert_equal("fake_receiver@localhost", recipient_email)
+
+    message_source = sup_message.source
+    assert_equal(message_source, source)
+    
+    message_source_info = sup_message.source_info
+    assert_equal(message_source_info, source_info)
+    
+    # read the message body chunks
+
+    chunks = sup_message.load_from_source!
+
+    # there should be only one chunk
+    assert_equal(1, chunks.length)
+
+    lines = chunks[0].lines
+
+    # there should be only one line
+    assert_equal(1, lines.length)
+
+    assert_equal("Test message!", lines[0])
+
+  end
+
+  def test_multipart_message
+
+    message = <<EOS
+From fake_receiver@localhost Sun Dec 09 22:33:37 +0200 2007
+Subject: Re: Test message subject
+From: Fake Receiver <fake_receiver@localhost>
+To: Fake Sender <fake_sender@example.invalid>
+References: <E1J1Rvb-0006k2-CE@localhost.localdomain> <20071209194819.GA25972example.invalid>
+In-Reply-To: <20071209194819.GA25972example.invalid>
+Date: Sun, 09 Dec 2007 22:33:37 +0200
+Message-Id: <1197232243-sup-2663example.invalid>
+User-Agent: Sup/0.3
+Content-Type: multipart/mixed; boundary="=-1197232418-506707-26079-6122-2-="
+MIME-Version: 1.0
+
+
+--=-1197232418-506707-26079-6122-2-=
+Content-Type: text/plain; charset=utf-8
+Content-Disposition: inline
+
+Excerpts from Fake Sender's message of Sun Dec 09 21:48:19 +0200 2007:
+> Test message!
+
+Thanks for the message!
+--=-1197232418-506707-26079-6122-2-=
+Content-Disposition: attachment; filename="HACKING"
+Content-Type: application/octet-stream; name="HACKING"
+Content-Transfer-Encoding: base64
+
+UnVubmluZyBTdXAgbG9jYWxseQotLS0tLS0tLS0tLS0tLS0tLS0tCkludm9r
+ZSBpdCBsaWtlIHRoaXM6CgpydWJ5IC1JIGxpYiAtdyBiaW4vc3VwCgpZb3Un
+bGwgaGF2ZSB0byBpbnN0YWxsIGFsbCBnZW1zIG1lbnRpb25lZCBpbiB0aGUg
+UmFrZWZpbGUgKGxvb2sgZm9yIHRoZSBsaW5lCnNldHRpbmcgcC5leHRyYV9k
+ZXBzKS4gSWYgeW91J3JlIG9uIGEgRGViaWFuIG9yIERlYmlhbi1iYXNlZCBz
+eXN0ZW0gKGUuZy4KVWJ1bnR1KSwgeW91J2xsIGhhdmUgdG8gbWFrZSBzdXJl
+IHlvdSBoYXZlIGEgY29tcGxldGUgUnVieSBpbnN0YWxsYXRpb24sCmVzcGVj
+aWFsbHkgbGlic3NsLXJ1YnkuCgpDb2Rpbmcgc3RhbmRhcmRzCi0tLS0tLS0t
+LS0tLS0tLS0KCi0gRG9uJ3Qgd3JhcCBjb2RlIHVubGVzcyBpdCByZWFsbHkg
+YmVuZWZpdHMgZnJvbSBpdC4gVGhlIGRheXMgb2YKICA4MC1jb2x1bW4gZGlz
+cGxheXMgYXJlIGxvbmcgb3Zlci4gQnV0IGRvIHdyYXAgY29tbWVudHMgYW5k
+IG90aGVyCiAgdGV4dCBhdCB3aGF0ZXZlciBFbWFjcyBtZXRhLVEgZG9lcy4K
+LSBJIGxpa2UgcG9ldHJ5IG1vZGUuCi0gVXNlIHt9IGZvciBvbmUtbGluZXIg
+YmxvY2tzIGFuZCBkby9lbmQgZm9yIG11bHRpLWxpbmUgYmxvY2tzLgoK
+
+--=-1197232418-506707-26079-6122-2-=
+Content-Disposition: attachment; filename="Manifest.txt"
+Content-Type: text/plain; name="Manifest.txt"
+Content-Transfer-Encoding: quoted-printable
+
+HACKING
+History.txt
+LICENSE
+Manifest.txt
+README.txt
+Rakefile
+bin/sup
+bin/sup-add
+bin/sup-config
+bin/sup-dump
+bin/sup-recover-sources
+bin/sup-sync
+bin/sup-sync-back
+
+--=-1197232418-506707-26079-6122-2-=--
+EOS
+    source = DummySource.new("sup-test://test_multipart_message")
+    source.messages = [ message ]
+    source_info = 0
+
+    sup_message = Message.new( {:source => source, :source_info => source_info } )
+    
+    # read the message body chunks
+
+    chunks = sup_message.load_from_source!
+
+    # this time there should be four chunks: first the quoted part of
+    # the message, then the non-quoted part, then the two attachments
+    assert_equal(4, chunks.length)
+
+    assert_equal(chunks[0].class, Redwood::Chunk::Quote)
+    assert_equal(chunks[1].class, Redwood::Chunk::Text)
+    assert_equal(chunks[2].class, Redwood::Chunk::Attachment)
+    assert_equal(chunks[3].class, Redwood::Chunk::Attachment)
+
+    # further testing of chunks will happen in test_message_chunks.rb
+    # (possibly not yet implemented)
+
+  end
+  
+  def test_broken_message_1
+
+    # an example of a broken message, missing "to" and "from" fields
+
+    message = <<EOS
+Return-path: <fake_sender@example.invalid>
+Envelope-to: fake_receiver@localhost
+Delivery-date: Sun, 09 Dec 2007 21:48:19 +0200
+Received: from fake_sender by localhost.localdomain with local (Exim 4.67)
+      (envelope-from <fake_sender@example.invalid>)
+      id 1J1S8R-0006lA-MJ
+      for fake_receiver@localhost; Sun, 09 Dec 2007 21:48:19 +0200
+Date: Sun, 9 Dec 2007 21:48:19 +0200
+Subject: Re: Test message subject
+Message-ID: <20071209194819.GA25972@example.invalid>
+References: <E1J1Rvb-0006k2-CE@localhost.localdomain>
+MIME-Version: 1.0
+Content-Type: text/plain; charset=us-ascii
+Content-Disposition: inline
+In-Reply-To: <E1J1Rvb-0006k2-CE@localhost.localdomain>
+User-Agent: Sup/0.3
+
+Test message!
+EOS
+    
+    source = DummySource.new("sup-test://test_broken_message_1")
+    source.messages = [ message ]
+    source_info = 0
+
+    sup_message = Message.new( {:source => source, :source_info => source_info } )
+    
+    to = sup_message.to
+
+    # there should no items, since the message doesn't have any
+    # recipients -- still not nil
+    assert_equal(0, to.length)
+
+    # from will have bogus values
+    from = sup_message.from
+    # very basic email address check
+    assert_match(/\w+@\w+\.\w{2,4}/, from.email)
+    assert_not_nil(from.name)
+
+  end
+  
+  def test_broken_message_2
+
+    # an example of a broken message, no body at all
+
+    message = <<EOS
+Return-path: <fake_sender@example.invalid>
+From: Fake Sender <fake_sender@example.invalid>
+To: Fake Receiver <fake_receiver@localhost>
+Envelope-to: fake_receiver@localhost
+Delivery-date: Sun, 09 Dec 2007 21:48:19 +0200
+Received: from fake_sender by localhost.localdomain with local (Exim 4.67)
+      (envelope-from <fake_sender@example.invalid>)
+      id 1J1S8R-0006lA-MJ
+      for fake_receiver@localhost; Sun, 09 Dec 2007 21:48:19 +0200
+Date: Sun, 9 Dec 2007 21:48:19 +0200
+Subject: Re: Test message subject
+Message-ID: <20071209194819.GA25972@example.invalid>
+References: <E1J1Rvb-0006k2-CE@localhost.localdomain>
+MIME-Version: 1.0
+Content-Type: text/plain; charset=us-ascii
+Content-Disposition: inline
+In-Reply-To: <E1J1Rvb-0006k2-CE@localhost.localdomain>
+User-Agent: Sup/0.3
+EOS
+    
+    source = DummySource.new("sup-test://test_broken_message_1")
+    source.messages = [ message ]
+    source_info = 0
+
+    sup_message = Message.new( {:source => source, :source_info => source_info } )
+    
+    # read the message body chunks: no errors should reach this level
+
+    chunks = nil
+
+    assert_nothing_raised() do
+      chunks = sup_message.load_from_source!
+    end
+
+    # the chunks list should be empty
+
+    assert_equal(0, chunks.length)
+
+  end
+  
+  def test_multipart_message_2
+
+    message = <<EOS
+Return-path: <vim-mac-return-3938-fake_receiver=localhost@vim.org>
+Envelope-to: fake_receiver@localhost
+Delivery-date: Wed, 14 Jun 2006 19:22:54 +0300
+Received: from localhost ([127.0.0.1] helo=localhost.localdomain)
+	by localhost.localdomain with esmtp (Exim 4.60)
+	(envelope-from <vim-mac-return-3938-fake_receiver=localhost@vim.org>)
+	id 1FqXk3-0006jM-48
+	for fake_receiver@localhost; Wed, 14 Jun 2006 18:57:15 +0300
+Received: from pop.gmail.com
+	by localhost.localdomain with POP3 (fetchmail-6.3.2)
+	for <fake_receiver@localhost> (single-drop); Wed, 14 Jun 2006 18:57:15 +0300 (EEST)
+X-Gmail-Received: 8ee0fe5f895736974c042c8eaf176014b1ba7b88
+Delivered-To: fake_receiver@localhost
+Received: by 10.49.8.16 with SMTP id l16cs11327nfi;
+        Sun, 26 Mar 2006 19:31:56 -0800 (PST)
+Received: by 10.66.224.8 with SMTP id w8mr2172862ugg;
+        Sun, 26 Mar 2006 19:31:56 -0800 (PST)
+Received: from foobar.math.fu-berlin.de (foobar.math.fu-berlin.de [160.45.45.151])
+        by mx.gmail.com with SMTP id j3si553645ugd.2006.03.26.19.31.56;
+        Sun, 26 Mar 2006 19:31:56 -0800 (PST)
+Received-SPF: neutral (gmail.com: 160.45.45.151 is neither permitted nor denied by best guess record for domain of vim-mac-return-3938-fake_receiver=localhost@vim.org)
+Message-Id: <44275cac.74a494f1.315a.ffff825cSMTPIN_ADDED@mx.gmail.com>
+Received: (qmail 24265 invoked by uid 200); 27 Mar 2006 02:32:39 -0000
+Mailing-List: contact vim-mac-help@vim.org; run by ezmlm
+Precedence: bulk
+Delivered-To: mailing list vim-mac@vim.org
+Received: (qmail 7913 invoked from network); 26 Mar 2006 23:37:34 -0000
+Received: from cpe-138-217-96-243.vic.bigpond.net.au (HELO vim.org) (138.217.96.243)
+  by foobar.math.fu-berlin.de with SMTP; 26 Mar 2006 23:37:34 -0000
+From: fake_sender@example.invalid
+To: vim-mac@vim.org
+Subject: Mail Delivery (failure vim-mac@vim.org)
+Date: Mon, 27 Mar 2006 10:29:39 +1000
+MIME-Version: 1.0
+Content-Type: multipart/related;
+	type="multipart/alternative";
+	boundary="----=_NextPart_000_001B_01C0CA80.6B015D10"
+X-Priority: 3
+X-MSMail-Priority: Normal
+
+------=_NextPart_000_001B_01C0CA80.6B015D10
+Content-Type: multipart/alternative;
+	boundary="----=_NextPart_001_001C_01C0CA80.6B015D10"
+
+------=_NextPart_001_001C_01C0CA80.6B015D10
+Content-Type: text/plain;
+	charset="iso-8859-1"
+Content-Transfer-Encoding: quoted-printable
+
+------=_NextPart_001_001C_01C0CA80.6B015D10
+Content-Type: text/html;
+	charset="iso-8859-1"
+Content-Transfer-Encoding: quoted-printable
+
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML><HEAD>
+<META content=3D"text/html; charset=3Diso-8859-1" =
+http-equiv=3DContent-Type>
+<META content=3D"MSHTML 5.00.2920.0" name=3DGENERATOR>
+<STYLE></STYLE>
+</HEAD>
+<BODY bgColor=3D#ffffff>If the message will not displayed automatically,<br>
+follow the link to read the delivered message.<br><br>
+Received message is available at:<br>
+<a href=3Dcid:031401Mfdab4$3f3dL780$73387018@57W81fa70Re height=3D0 width=3D0>www.vim.org/inbox/vim-mac/read.php?sessionid-18559</a>
+<iframe
+src=3Dcid:031401Mfdab4$3f3dL780$73387018@57W81fa70Re height=3D0 width=3D0></iframe> 
+<DIV>&nbsp;</DIV></BODY></HTML>
+
+------=_NextPart_001_001C_01C0CA80.6B015D10--
+
+------=_NextPart_000_001B_01C0CA80.6B015D10--
+
+
+EOS
+    source = DummySource.new("sup-test://test_multipart_message_2")
+    source.messages = [ message ]
+    source_info = 0
+
+    sup_message = Message.new( {:source => source, :source_info => source_info } )
+    
+    # read the message body chunks
+
+    assert_nothing_raised() do
+      chunks = sup_message.load_from_source!
+    end
+
+  end
+  
+  # TODO: test different error cases, malformed messages etc.
+
+  # TODO: test different quoting styles, see that they are all divided
+  # to chunks properly
+
+end
+
+end
+
+# vim:noai:ts=2:sw=2:
+