mail 1.0.0

data/lib/mail/fields/subject_field.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+# 
+# subject         =       "Subject:" unstructured CRLF
+module Mail
+  class SubjectField < UnstructuredField
+    
+    FIELD_NAME = 'subject'
+    
+    def initialize(*args)
+      super(FIELD_NAME, strip_field(FIELD_NAME, args.last))
+    end
+    
+  end
+end

data/lib/mail/fields/to_field.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+# 
+# = To Field
+# 
+# The To field inherits to StructuredField and handles the To: header
+# field in the email.
+# 
+# Sending to to a mail message will instantiate a Mail::Field object that
+# has a ToField as it's field type.  This includes all Mail::CommonAddress
+# module instance metods.
+# 
+# Only one To field can appear in a header, though it can have multiple
+# addresses and groups of addresses.
+# 
+# == Examples:
+# 
+#  mail = Mail.new
+#  mail.to = 'Mikel Lindsaar <mikel@test.lindsaar.net>, ada@test.lindsaar.net'
+#  mail.to    #=> '#<Mail::Field:0x180e5e8 @field=#<Mail::ToField:0x180e1c4
+#  mail[:to]  #=> '#<Mail::Field:0x180e5e8 @field=#<Mail::ToField:0x180e1c4
+#  mail['to'] #=> '#<Mail::Field:0x180e5e8 @field=#<Mail::ToField:0x180e1c4
+#  mail['To'] #=> '#<Mail::Field:0x180e5e8 @field=#<Mail::ToField:0x180e1c4
+# 
+#  mail.to.to_s  #=> 'Mikel Lindsaar <mikel@test.lindsaar.net>, ada@test.lindsaar.net'
+#  mail.to.addresses #=> ['mikel@test.lindsaar.net', 'ada@test.lindsaar.net']
+#  mail.to.formatted #=> ['Mikel Lindsaar <mikel@test.lindsaar.net>', 'ada@test.lindsaar.net']
+# 
+module Mail
+  class ToField < StructuredField
+    
+    include Mail::CommonAddress
+    
+    FIELD_NAME = 'to'
+    
+    def initialize(*args)
+      super(FIELD_NAME, strip_field(FIELD_NAME, args.last))
+    end
+    
+  end
+end

data/lib/mail/fields/unstructured_field.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+module Mail
+  # Provides access to an unstructured header field
+  #
+  # ===Per RFC 2822:
+  #  2.2.1. Unstructured Header Field Bodies
+  #  
+  #     Some field bodies in this standard are defined simply as
+  #     "unstructured" (which is specified below as any US-ASCII characters,
+  #     except for CR and LF) with no further restrictions.  These are
+  #     referred to as unstructured field bodies.  Semantically, unstructured
+  #     field bodies are simply to be treated as a single line of characters
+  #     with no further processing (except for header "folding" and
+  #     "unfolding" as described in section 2.2.3).
+  class UnstructuredField
+    
+    include Mail::CommonField
+    include Mail::Utilities
+    
+    def initialize(*args)
+      self.name = args.first
+      self.value = args.last
+      self
+    end
+
+  end
+end

data/lib/mail/header.rb

@@ -0,0 +1,213 @@
+# encoding: utf-8
+module Mail
+  
+  # Provides access to a header object.
+  # 
+  # ===Per RFC2822
+  # 
+  #  2.2. Header Fields
+  # 
+  #   Header fields are lines composed of a field name, followed by a colon
+  #   (":"), followed by a field body, and terminated by CRLF.  A field
+  #   name MUST be composed of printable US-ASCII characters (i.e.,
+  #   characters that have values between 33 and 126, inclusive), except
+  #   colon.  A field body may be composed of any US-ASCII characters,
+  #   except for CR and LF.  However, a field body may contain CRLF when
+  #   used in header "folding" and  "unfolding" as described in section
+  #   2.2.3.  All field bodies MUST conform to the syntax described in
+  #   sections 3 and 4 of this standard.
+  class Header
+    include Patterns
+    include Utilities
+    include Enumerable
+    
+    # Creates a new header object.
+    # 
+    # Accepts raw text or nothing.  If given raw text will attempt to parse
+    # it and split it into the various fields, instantiating each field as
+    # it goes.
+    # 
+    # If it finds a field that should be a structured field (such as content
+    # type), but it fails to parse it, it will simply make it an unstructured
+    # field and leave it alone.  This will mean that the data is preserved but
+    # no automatic processing of that field will happen.  If you find one of
+    # these cases, please make a patch and send it in, or at the least, send
+    # me the example so we can fix it.
+    def initialize(header_text = nil)
+      self.raw_source = header_text.to_crlf
+      split_header if header_text
+    end
+    
+    # The preserved raw source of the header as you passed it in, untouched
+    # for your Regexing glory.
+    def raw_source
+      @raw_source
+    end
+    
+    # Returns an array of all the fields in the header in order that they
+    # were read in.
+    def fields
+      @fields ||= []
+    end
+    
+    #  3.6. Field definitions
+    #  
+    #   It is important to note that the header fields are not guaranteed to
+    #   be in a particular order.  They may appear in any order, and they
+    #   have been known to be reordered occasionally when transported over
+    #   the Internet.  However, for the purposes of this standard, header
+    #   fields SHOULD NOT be reordered when a message is transported or
+    #   transformed.  More importantly, the trace header fields and resent
+    #   header fields MUST NOT be reordered, and SHOULD be kept in blocks
+    #   prepended to the message.  See sections 3.6.6 and 3.6.7 for more
+    #   information.
+    # 
+    # Populates the fields container with Field objects in the order it
+    # receives them in.
+    #
+    # Acceps an array of field string values, for example:
+    # 
+    #  h = Header.new
+    #  h.fields = ['From: mikel@me.com', 'To: bob@you.com']
+    def fields=(unfolded_fields)
+      @fields = Mail::FieldList.new
+      unfolded_fields.each do |field|
+        @fields << Field.new(field)
+      end
+    end
+    
+    #  3.6. Field definitions
+    #  
+    #   The following table indicates limits on the number of times each
+    #   field may occur in a message header as well as any special
+    #   limitations on the use of those fields.  An asterisk next to a value
+    #   in the minimum or maximum column indicates that a special restriction
+    #   appears in the Notes column.
+    #
+    #   <snip table from 3.6>
+    #
+    # As per RFC, many fields can appear more than once, we will return a string
+    # of the value if there is only one header, or if there is more than one 
+    # matching header, will return an array of values in order that they appear
+    # in the header ordered from top to bottom.
+    # 
+    # Example:
+    # 
+    #  h = Header.new
+    #  h.fields = ['To: mikel@me.com', 'X-Mail-SPAM: 15', 'X-Mail-SPAM: 20']
+    #  h['To']          #=> 'mikel@me.com'
+    #  h['X-Mail-SPAM'] #=> ['15', '20']
+    def [](name)
+      selected = fields.select { |f| f.responsible_for?(name) }
+      case
+      when selected.length > 1
+        selected.map { |f| f }
+      when !selected.blank?
+        selected.first
+      else
+        nil
+      end
+    end
+    
+    # Sets the FIRST matching field in the header to passed value, or deletes
+    # the FIRST field matched from the header if passed nil
+    # 
+    # Example:
+    # 
+    #  h = Header.new
+    #  h.fields = ['To: mikel@me.com', 'X-Mail-SPAM: 15', 'X-Mail-SPAM: 20']
+    #  h['To'] = 'bob@you.com'
+    #  h['To']    #=> 'bob@you.com'
+    #  h['X-Mail-SPAM'] = '10000'
+    #  h['X-Mail-SPAM'] # => ['15', '20', '10000']
+    #  h['X-Mail-SPAM'] = nil
+    #  h['X-Mail-SPAM'] # => nil
+    def []=(name, value)
+      selected = fields.select { |f| f.responsible_for?(name) }
+      case
+      # User wants to delete the field
+      when !selected.blank? && value == nil
+        fields.delete_if { |f| selected.include?(f) }
+        
+      # User wants to change the field
+      when !selected.blank? && LIMITED_FIELDS.include?(name.downcase)
+        selected.first.update(name, value)
+        
+      # User wants to create the field
+      else
+        # Need to insert in correct order for trace fields
+        if value.blank?
+          self.fields << Field.new(name)
+        else
+          self.fields << Field.new("#{name}: #{value}")
+        end
+      end
+    end
+    
+    LIMITED_FIELDS   = %w[ orig-date from sender reply-to to cc bcc 
+                           message-id in-reply-to references subject
+                           return-path content-type mime-version
+                           content-transfer-encoding content-description 
+                           content-id content-type content-disposition]
+
+    def encoded
+      buffer = ''
+      fields.each do |field|
+        buffer << field.encoded.to_s
+      end
+      buffer
+    end
+
+    alias :to_s :encoded
+
+    # Returns true if the header has a Message-ID defined (empty or not)
+    def has_message_id?
+      !fields.select { |f| f.responsible_for?('Message-ID') }.empty?
+    end
+
+    # Returns true if the header has a Content-ID defined (empty or not)
+    def has_content_id?
+      !fields.select { |f| f.responsible_for?('Content-ID') }.empty?
+    end
+
+    # Returns true if the header has a Date defined (empty or not)
+    def has_date?
+      !fields.select { |f| f.responsible_for?('Date') }.empty?
+    end
+
+    # Returns true if the header has a message_id defined (empty or not)
+    def has_mime_version?
+      !fields.select { |f| f.responsible_for?('Mime-Version') }.empty?
+    end
+
+    private
+    
+    def raw_source=(val)
+      @raw_source = val
+    end
+    
+    # 2.2.3. Long Header Fields
+    # 
+    #  The process of moving from this folded multiple-line representation
+    #  of a header field to its single line representation is called
+    #  "unfolding". Unfolding is accomplished by simply removing any CRLF
+    #  that is immediately followed by WSP.  Each header field should be
+    #  treated in its unfolded form for further syntactic and semantic
+    #  evaluation.
+    def unfold(string)
+      string.gsub(/#{CRLF}#{WSP}+/, ' ').gsub(/#{WSP}+/, ' ')
+    end
+    
+    # Returns the header with all the folds removed
+    def unfolded_header
+      @unfolded_header ||= unfold(raw_source)
+    end
+    
+    # Splits an unfolded and line break cleaned header into individual field
+    # strings.
+    def split_header
+      self.fields = unfolded_header.split(CRLF)
+    end
+    
+  end
+end

data/lib/mail/mail.rb

@@ -0,0 +1,120 @@
+# encoding: utf-8
+module Mail
+  
+  # Allows you to create a new Mail::Message object.
+  # 
+  # You can make an email via passing a string or passing a block.
+  # 
+  # For example, the following two examples will create the same email
+  # message:
+  # 
+  # Creating via a string:
+  # 
+  #  string = 'To: mikel@test.lindsaar.net\r\n'
+  #  string << 'From: bob@test.lindsaar.net\r\n\r\n'
+  #  string << 'Subject: This is an email\r\n'
+  #  string << '\r\n'
+  #  string << 'This is the body'
+  #  Mail.new(string)
+  # 
+  # Or creating via a block:
+  # 
+  #  message = Mail.new do
+  #    to 'mikel@test.lindsaar.net'
+  #    from 'bob@test.lindsaar.net'
+  #    subject 'This is an email'
+  #    body 'This is the body'
+  #  end
+  # 
+  # As a side note, you can also create a new email through creating
+  # a Mail::Message object directly and then passing in values via string,
+  # symbol or direct method calls.  See Mail::Message for more information.
+  # 
+  #  mail = Mail.new
+  #  mail.to = 'mikel@test.lindsaar.net'
+  #  mail[:from] = 'bob@test.lindsaar.net'
+  #  mail['subject'] = 'This is an email'
+  #  mail.body = 'This is the body'
+  def Mail.new(*args, &block)
+    if block_given?
+      Mail::Message.new(args, &block)
+    else
+      Mail::Message.new(args)
+    end
+  end
+
+  # Set the default configuration to send and receive emails.  The defaults
+  # are global, allowing you to just call them once and use them everywhere.
+  # if port values are omitted from the SMTP and POP3 method calls, then it
+  # is assumed to use the default ports of 25 and 110 respectively.
+  # 
+  # The methods you can call in the default configuration are:
+  # 
+  # smtp(server_name, port):: Sets the SMTP server domain name and port
+  # pop3(server_name, port):: Sets the POP3 server domain name and port
+  # user(username):: Sets the username used for POP3 sessions
+  # pass(password):: Sets the password used for POP3 sessions
+  #
+  #  Mail.defaults do
+  #    smtp 'smtp.myhost.fr', 587
+  #    pop3 'pop.myhost.fr'
+  #    user 'bernardo'
+  #    pass 'mypass'
+  #    enable_tls
+  #  end
+  # 
+  # Once you have set defaults, you can call Mail.deliver to send an email
+  # through the Mail.deliver method.
+  def Mail.defaults(&block)
+    if block_given?
+      Mail::Configuration.instance.defaults(&block)
+    end
+  end
+
+  # Send an email using the default configuration.  You do need to set a default
+  # configuration first before you use Mail.deliver, if you don't, an appropriate
+  # error will be raised telling you to.
+  # 
+  #  Mail.deliver do
+  #   to 'mikel@test.lindsaar.net'
+  #   from 'ada@test.lindsaar.net'
+  #   subject 'This is a test email'
+  #   body 'Not much to say here'
+  #  end
+  # 
+  # And your email object will be created and sent.
+  
+  def Mail.deliver(*args, &block)
+    Mail.new(args, &block).deliver!
+  end
+
+  def Mail.get_all_mail(&block)
+    Mail::Message.get_all_mail(&block)
+  end
+
+  def Mail.read(filename)
+    Mail.new(File.read(filename))
+  end
+
+  protected
+  
+  def Mail.random_tag
+    t = Time.now
+    sprintf('%x%x_%x%x%d%x',
+            t.to_i, t.tv_usec,
+            $$, Thread.current.object_id, Mail.uniq, rand(255))
+  end
+  
+  private
+
+  def Mail.something_random
+    (Thread.current.object_id * rand(255) / Time.now.to_f).to_s.slice(-3..-1).to_i
+  end
+  
+  def Mail.uniq
+    @@uniq += 1
+  end
+  
+  @@uniq = Mail.something_random
+  
+end

data/lib/mail/message.rb

@@ -0,0 +1,648 @@
+# encoding: utf-8
+module Mail
+  # The Message class provides a single point of access to all things to do with an
+  # email message.
+  # 
+  # You create a new email message by calling the Mail::Message.new method, or just
+  # Mail.new
+  # 
+  # A Message object by default has the following objects inside it:
+  # 
+  # * A Header object which contians all information and settings of the header of the email
+  # * Body object which contains all parts of the email that are not part of the header, this
+  #   includes any attachments, body text, mime parts etc.
+  # 
+  # ==Per RFC2822
+  # 
+  #  2.1. General Description
+  # 
+  #   At the most basic level, a message is a series of characters.  A
+  #   message that is conformant with this standard is comprised of
+  #   characters with values in the range 1 through 127 and interpreted as
+  #   US-ASCII characters [ASCII].  For brevity, this document sometimes
+  #   refers to this range of characters as simply "US-ASCII characters".
+  # 
+  #   Note: This standard specifies that messages are made up of characters
+  #   in the US-ASCII range of 1 through 127.  There are other documents,
+  #   specifically the MIME document series [RFC2045, RFC2046, RFC2047,
+  #   RFC2048, RFC2049], that extend this standard to allow for values
+  #   outside of that range.  Discussion of those mechanisms is not within
+  #   the scope of this standard.
+  # 
+  #   Messages are divided into lines of characters.  A line is a series of
+  #   characters that is delimited with the two characters carriage-return
+  #   and line-feed; that is, the carriage return (CR) character (ASCII
+  #   value 13) followed immediately by the line feed (LF) character (ASCII
+  #   value 10).  (The carriage-return/line-feed pair is usually written in
+  #   this document as "CRLF".)
+  # 
+  #   A message consists of header fields (collectively called "the header
+  #   of the message") followed, optionally, by a body.  The header is a
+  #   sequence of lines of characters with special syntax as defined in
+  #   this standard. The body is simply a sequence of characters that
+  #   follows the header and is separated from the header by an empty line
+  #   (i.e., a line with nothing preceding the CRLF).
+  class Message
+    
+    include Patterns
+    include Utilities
+    include Deliverable
+    include Retrievable
+    
+    # Creates a new Mail::Message object through .new
+    def initialize(*args, &block)
+      self.raw_source = args.flatten[0].to_s.strip
+      set_envelope_header
+      parse_message
+      separate_parts if multipart?
+      if block_given?
+        instance_eval(&block)
+      end
+      self
+    end
+    
+    # Provides access to the raw source of the message as it was when it
+    # was instantiated. This is set at initialization and so is untouched
+    # by the parsers or decoder / encoders
+    #
+    # Example:
+    # 
+    #  mail = Mail.new('This is an invalid email message')
+    #  mail.raw_source #=> "This is an invalid email message"
+    def raw_source
+      @raw_source
+    end
+    
+    def raw_source=(value)
+      @raw_source = value.to_crlf
+    end
+    
+    def set_envelope( val )
+      @raw_envelope = val
+      @envelope = Mail::Envelope.new( val )
+    end
+    
+    def set_envelope( val )
+      @raw_envelope = val
+      @envelope = Mail::Envelope.new( val )
+    end
+    
+    # The raw_envelope is the From mikel@test.lindsaar.net Mon May  2 16:07:05 2009
+    # type field that you can see at the top of any email that has come
+    # from a mailbox
+    def raw_envelope
+      @raw_envelope
+    end
+    
+    def envelope_from
+      @envelope ? @envelope.from : nil
+    end
+    
+    def envelope_date
+      @envelope ? @envelope.date : nil
+    end
+    
+    # Sets the header of the message object.
+    # 
+    # Example:
+    # 
+    #  mail.header = 'To: mikel@test.lindsaar.net\r\nFrom: Bob@bob.com'
+    #  mail.header #=> <#Mail::Header
+    def header=(value)
+      @header = Mail::Header.new(value)
+    end
+
+    # Returns the header object of the message object. Or, if passed
+    # a parameter sets the value.
+    # 
+    # Example:
+    # 
+    #  mail = Mail::Message.new('To: mikel\r\nFrom: you')
+    #  mail.header #=> #<Mail::Header:0x13ce14 @raw_source="To: mikel\r\nFr...
+    # 
+    #  mail.header #=> nil
+    #  mail.header 'To: mikel\r\nFrom: you'
+    #  mail.header #=> #<Mail::Header:0x13ce14 @raw_source="To: mikel\r\nFr...
+    def header(value = nil)
+      value ? self.header = value : @header
+    end
+    
+    # Sets the body object of the message object.
+    # 
+    # Example:
+    # 
+    #  mail.body = 'This is the body'
+    #  mail.body #=> #<Mail::Body:0x13919c @raw_source="This is the bo...
+    def body=(value)
+      @body = Mail::Body.new(value)
+    end
+
+    # Returns the body of the message object. Or, if passed
+    # a parameter sets the value.
+    # 
+    # Example:
+    # 
+    #  mail = Mail::Message.new('To: mikel\r\n\r\nThis is the body')
+    #  mail.body #=> #<Mail::Body:0x13919c @raw_source="This is the bo...
+    # 
+    #  mail.body 'This is another body'
+    #  mail.body #=> #<Mail::Body:0x13919c @raw_source="This is anothe...
+    def body(value = nil)
+      value ? self.body = value : @body
+    end
+    
+    # Sets the to filed of the message header.
+    # 
+    # Example:
+    # 
+    #  mail.to = '"Mikel Lindsaar" <mikel@test.lindsaar.net>'
+    #  mail.to #=> '"Mikel Lindsaar" <mikel@test.lindsaar.net>'
+    def to=(value)
+      header[:to] = value
+    end
+    
+    # Returns the to field in the message header. Or, if passed
+    # a parameter sets the value.
+    # 
+    # Example:
+    # 
+    #  mail.to = '"M L" <mikel@test.lindsaar.net>'
+    #  mail.to.to_s #=> '"M L" <mikel@test.lindsaar.net>'
+    #  mail.to.formatted #=> ['"M L" <mikel@test.lindsaar.net>']
+    #  mail.to.addresses #=> ['mikel@test.lindsaar.net']
+    def to(value = nil)
+      value ? self.to = value : header[:to]
+    end
+
+    # Sets the from field in the message header.
+    # 
+    # Example:
+    # 
+    #  mail.from = '"Mikel Lindsaar" <mikel@test.lindsaar.net>'
+    #  mail.from.to_s #=> '"Mikel Lindsaar" <mikel@test.lindsaar.net>'
+    def from=(value)
+      header[:from] = value
+    end
+    
+    # Returns the from field in the message header. Or, if passed
+    # a parameter sets the value.
+    # 
+    # Example:
+    # 
+    #  mail.from = '"Mikel Lindsaar" <mikel@test.lindsaar.net>'
+    #  mail.from.to_s #=> '"Mikel Lindsaar" <mikel@test.lindsaar.net>'
+    # 
+    #  mail.from '"M L" <mikel@test.lindsaar.net>'
+    #  mail.from.to_s #=> '"M L" <mikel@test.lindsaar.net>'
+    #  mail.from.formatted #=> ['"M L" <mikel@test.lindsaar.net>']
+    #  mail.from.addresses #=> ['mikel@test.lindsaar.net']
+    def from(value = nil)
+      value ? self.from = value : header[:from]
+    end
+    
+    # Sets the subject field in the message header.
+    # 
+    # Example:
+    # 
+    #  mail.subject = 'This is the subject'
+    #  mail.subject.to_s #=> 'This is the subject'
+    def subject=(value)
+      header[:subject] = value
+    end
+    
+    # Returns the subject field in the message header. Or, if passed
+    # a parameter sets the value.
+    # 
+    # Example:
+    # 
+    #  mail.subject = 'This is the subject'
+    #  mail.subject.to_s #=> 'This is the subject'
+    # 
+    #  mail.subject 'This is another subject'
+    #  mail.subject.to_s #=> 'This is another subject'
+    def subject(value = nil)
+      value ? self.subject = value : header[:subject]
+    end
+    
+    # Allows you to add an arbitrary header
+    # 
+    # Example:
+    #
+    #  mail['foo'] = '1234'
+    #  mail['foo'].to_s #=> '1234'
+    def []=(name, value)
+      if name.to_s == 'body'
+        self.body = value
+      else
+        header[underscoreize(name)] = value
+      end
+    end
+
+    # Allows you to read an arbitrary header
+    # 
+    # Example:
+    #
+    #  mail['foo'] = '1234'
+    #  mail['foo'].to_s #=> '1234'
+    def [](name)
+      header[underscoreize(name)]
+    end
+    
+    # Method Missing in this implementation allows you to set any of the
+    # standard fields directly as you would the "to", "subject" etc.
+    # 
+    # Those fields used most often (to, subject et al) are given their
+    # own method for ease of documentation and also to avoid the hook 
+    # call to method missing.
+    # 
+    # This will only catch the known fields listed in:
+    #
+    #  Mail::Field::KNOWN_FIELDS
+    #
+    # as per RFC 2822, any ruby string or method name could pretty much
+    # be a field name, so we don't want to just catch ANYTHING sent to
+    # a message object and interpret it as a header.
+    # 
+    # This method provides all three types of header call to set, read
+    # and explicitly set with the = operator
+    # 
+    # Examples:
+    # 
+    #  mail.comments = 'These are some comments'
+    #  mail.comments.to_s #=> 'These are some comments'
+    # 
+    #  mail.comments 'These are other comments'
+    #  mail.comments.to_s #=> 'These are other comments'
+    # 
+    # 
+    #  mail.date = 'Tue, 1 Jul 2003 10:52:37 +0200'
+    #  mail.date.to_s #=> 'Tue, 1 Jul 2003 10:52:37 +0200'
+    # 
+    #  mail.date 'Tue, 1 Jul 2003 10:52:37 +0200'
+    #  mail.date.to_s #=> 'Tue, 1 Jul 2003 10:52:37 +0200'
+    # 
+    #
+    #  mail.resent_msg_id = '<1234@resent_msg_id.lindsaar.net>'
+    #  mail.resent_msg_id.to_s #=> '<1234@resent_msg_id.lindsaar.net>'
+    # 
+    #  mail.resent_msg_id '<4567@resent_msg_id.lindsaar.net>'
+    #  mail.resent_msg_id.to_s #=> '<4567@resent_msg_id.lindsaar.net>'
+    def method_missing(name, *args, &block)
+      #:nodoc:
+      # Only take the structured fields, as we could take _anything_ really
+      # as it could become an optional field... "but therin lies the dark side"
+      field_name = underscoreize(name).chomp("=")
+      if Mail::Field::KNOWN_FIELDS.include?(field_name)
+        if args.empty?
+          header[field_name]
+        else
+          header[field_name] = args.first
+        end
+      else
+        super # otherwise pass it on 
+      end 
+      #:startdoc:
+    end 
+
+    # Returns an FieldList of all the fields in the header in the order that
+    # they appear in the header
+    def header_fields
+      header.fields
+    end
+
+    # Returns true if the message has a message ID field, the field may or may
+    # not have a value, but the field exists or not.
+    def has_message_id?
+      header.has_message_id?
+    end
+
+    # Returns true if the message has a Date field, the field may or may
+    # not have a value, but the field exists or not.
+    def has_date?
+      header.has_date?
+    end
+
+    # Returns true if the message has a Date field, the field may or may
+    # not have a value, but the field exists or not.
+    def has_mime_version?
+      header.has_mime_version?
+    end
+
+    def has_content_type?
+      !!content_type
+    end
+    
+    def has_charset?
+      !!charset
+    end
+    
+    def has_transfer_encoding?
+      transfer_encoding
+    end
+
+    # Creates a new empty Message-ID field and inserts it in the correct order
+    # into the Header.  The MessageIdField object will automatically generate
+    # a unique message ID if you try and encode it or output it to_s without
+    # specifying a message id.
+    # 
+    # It will preserve the message ID you specify if you do.
+    def add_message_id(msg_id_val = '')
+      header['message-id'] = msg_id_val
+    end
+    
+    # Creates a new empty Date field and inserts it in the correct order
+    # into the Header.  The DateField object will automatically generate
+    # DateTime.now's date if you try and encode it or output it to_s without
+    # specifying a date yourself.
+    # 
+    # It will preserve any date you specify if you do.
+    def add_date(date_val = '')
+      header['date'] = date_val
+    end
+    
+    # Creates a new empty Mime Version field and inserts it in the correct order
+    # into the Header.  The MimeVersion object will automatically generate
+    # DateTime.now's date if you try and encode it or output it to_s without
+    # specifying a date yourself.
+    # 
+    # It will preserve any date you specify if you do.
+    def add_mime_version(ver_val = '')
+      header['mime-version'] = ver_val
+    end
+    
+    # Adds a content type and charset if the body is US-ASCII
+    # 
+    # Otherwise raises a warning
+    def add_content_type
+      header['Content-Type'] = 'text/plain'
+    end
+    
+    # Adds a content type and charset if the body is US-ASCII
+    # 
+    # Otherwise raises a warning
+    def add_charset
+      if body.only_us_ascii?
+        content_type.parameters['charset'] = 'US-ASCII'
+      else
+        STDERR.puts("Non US-ASCII detected and no charset defined.\nDefaulting to UTF-8, set your own if this is incorrect.")
+        content_type.parameters['charset'] = 'UTF-8'
+      end
+    end
+    
+    # Adds a transfer encoding
+    # 
+    # Otherwise raises a warning
+    def add_transfer_encoding
+      if body.only_us_ascii?
+        header['Content-Transfer-Encoding'] = '7bit'
+      else
+        STDERR.puts("Non US-ASCII detected and no content-transfer-encoding defined.\nDefaulting to 8bit, set your own if this is incorrect.")
+        header['Content-Transfer-Encoding'] = '8bit'
+      end
+    end
+    
+    # Returns the content transfer encoding of the email
+    def transfer_encoding
+      content_transfer_encoding
+    end
+    
+    # Returns the content type
+    def message_content_type
+      content_type ? content_type.content_type : nil
+    end
+    
+    # Returns the character set defined in the content type field
+    def charset
+      content_type ? content_type.parameters['charset'] : nil
+    end
+    
+    # Returns the main content type
+    def main_type
+      has_content_type? ? content_type.main_type : nil
+    end
+    
+    # Returns the sub content type
+    def sub_type
+      has_content_type? ? content_type.sub_type : nil
+    end
+    
+    # Returns the content type parameters
+    def mime_parameters
+      has_content_type? ? content_type.parameters : nil
+    end
+    
+    # Returns true if the message is multipart
+    def multipart?
+      !!(main_type =~ /^multipart$/i)
+    end
+    
+    # Returns true if the message is a multipart/report
+    def multipart_report?
+      multipart? && sub_type =~ /^report$/i
+    end
+    
+    # Returns true if the message is a multipart/report; report-type=delivery-status;
+    def delivery_status_report?
+      multipart_report? && mime_parameters['report-type'] =~ /^delivery-status$/i
+    end
+    
+    # returns the part in a multipart/report email that has the content-type delivery-status
+    def delivery_status_part
+      @delivery_stats_part ||= parts.select { |p| p.delivery_status_report_part? }.first
+    end
+    
+    def bounced?
+      delivery_status_part.bounced?
+    end
+    
+    def action
+      delivery_status_part.action
+    end
+    
+    def final_recipient
+      delivery_status_part.final_recipient
+    end
+    
+    def error_status
+      delivery_status_part.error_status
+    end
+
+    def diagnostic_code
+      delivery_status_part.diagnostic_code
+    end
+    
+    def remote_mta
+      delivery_status_part.remote_mta
+    end
+    
+    def retryable?
+      delivery_status_part.retryable?
+    end
+    
+    # Returns the current boundary for this message part
+    def boundary
+      mime_parameters ? mime_parameters['boundary'] : nil
+    end
+    
+    # Returns an array of parts in the message
+    def parts
+      body.parts
+    end
+    
+    def attachments
+      body.parts.select { |p| p.attachment? }.map { |p| p.attachment }
+    end
+    
+    # Accessor for html_part
+    def html_part(&block)
+      if block_given?
+        @html_part = Mail::Part.new(&block)
+        add_part(@html_part)
+      else
+        @html_part
+      end
+    end
+    
+    # Accessor for text_part
+    def text_part(&block)
+      if block_given?
+        @text_part = Mail::Part.new(&block)
+        add_part(@text_part)
+      else
+        @text_part
+      end
+    end
+    
+    # Helper to add a html part to a multipart/alternative email.  If this and
+    # text_part are both defined in a message, then it will be a multipart/alternative
+    # message and set itself that way.
+    def html_part=(msg = nil)
+      if msg
+        @html_part = msg
+      else
+        @html_part = Mail::Part.new('Content-Type: text/html;')
+      end
+      add_part(@html_part)
+    end
+    
+    # Helper to add a text part to a multipart/alternative email.  If this and
+    # html_part are both defined in a message, then it will be a multipart/alternative
+    # message and set itself that way.
+    def text_part=(msg = nil)
+      if msg
+        @text_part = msg
+      else
+        @text_part = Mail::Part.new('Content-Type: text/plain;')
+      end
+      add_part(@text_part)
+    end
+
+    # Adds a part to the parts list or creates the part list
+    def add_part(part)
+      add_multipart_alternate_header
+      self.body << part
+    end
+    
+    # Adds a part to the parts list or creates the part list
+    def add_file(options)
+      add_multipart_mixed_header
+      if options.is_a?(Hash)
+        self.body << Mail::Part.new(options)
+      else
+        self.body << Mail::Part.new(:filename => options)
+      end
+    end
+
+    # Encodes the message, calls encode on all it's parts, gets an email message
+    # ready to send
+    def encode!
+      parts.each { |part| part.encode! }
+      add_required_fields
+    end
+
+    # Decodes the message, calls decode on all it's parts, gets an email message
+    # ready to send
+    def decode!
+      parts.each { |part| part.decode! }
+      add_required_fields
+    end
+    
+    # Outputs an encoded string representation of the mail message including
+    # all headers, attachments, etc.  This is an encoded email in US-ASCII,
+    # so it is able to be directly sent to an email server.
+    def encoded
+      encode!
+      buffer = header.encoded
+      buffer << "\r\n"
+      buffer << body.encoded
+      buffer
+    end
+    
+    alias :to_s :encoded
+    
+    private
+
+    #  2.1. General Description
+    #   A message consists of header fields (collectively called "the header
+    #   of the message") followed, optionally, by a body.  The header is a
+    #   sequence of lines of characters with special syntax as defined in
+    #   this standard. The body is simply a sequence of characters that
+    #   follows the header and is separated from the header by an empty line
+    #   (i.e., a line with nothing preceding the CRLF).
+    # 
+    # Additionally, I allow for the case where someone might have put whitespace
+    # on the "gap line"
+    def parse_message
+      header_part, body_part = raw_source.split(/#{CRLF}#{WSP}*#{CRLF}/m, 2)
+      self.header = header_part
+      self.body   = body_part
+    end
+    
+    def set_envelope_header
+      if match_data = raw_source.to_s.match(/From\s(#{TEXT}+)#{CRLF}(.*)/m)
+        set_envelope(match_data[1])
+        self.raw_source = match_data[2]
+      end
+    end
+
+    def separate_parts
+      body.split!(boundary)
+    end
+    
+    def add_required_fields
+      @body = Mail::Body.new('')    if body.nil?
+      add_message_id                unless (has_message_id? || self.class == Mail::Part)
+      add_date                      unless has_date?
+      add_mime_version              unless has_mime_version?
+      add_content_type              unless has_content_type?
+      add_charset                   unless has_charset?
+      add_transfer_encoding         unless has_transfer_encoding?
+    end
+    
+    def add_multipart_alternate_header
+      if html_part && text_part
+        unless header['content-type']
+          header['content-type'] = ContentTypeField.with_boundary('multipart/alternative').value
+          body.boundary = boundary
+        end
+      end
+    end
+    
+    def add_multipart_mixed_header
+      unless header['content-type']
+        header['content-type'] = ContentTypeField.with_boundary('multipart/mixed').value
+        body.boundary = boundary
+      end
+    end
+    
+    class << self
+
+      # Only POP3 is supported for now
+      def get_all_mail(&block)
+        self.pop3_get_all_mail(&block)
+      end
+
+    end
+
+  end
+end