kbaum-mail 2.1.2.1

data/lib/mail/fields/resent_from_field.rb

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

data/lib/mail/fields/resent_message_id_field.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+# 
+# resent-msg-id   =       "Resent-Message-ID:" msg-id CRLF
+module Mail
+  class ResentMessageIdField < StructuredField
+    
+    include CommonMessageId
+    
+    FIELD_NAME = 'resent-message-id'
+    CAPITALIZED_FIELD = 'Resent-Message-ID'
+    
+    def initialize(*args)
+      super(CAPITALIZED_FIELD, strip_field(FIELD_NAME, args.last))
+      self.parse
+      self
+
+    end
+    
+    def name
+      'Resent-Message-ID'
+    end
+    
+    def encoded
+      do_encode(CAPITALIZED_FIELD)
+    end
+    
+    def decoded
+      do_decode
+    end
+    
+  end
+end

data/lib/mail/fields/resent_sender_field.rb

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

data/lib/mail/fields/resent_to_field.rb

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

data/lib/mail/fields/return_path_field.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+# 
+# 4.4.3.  REPLY-TO / RESENT-REPLY-TO
+# 
+#    Note:  The "Return-Path" field is added by the mail  transport
+#           service,  at the time of final deliver.  It is intended
+#           to identify a path back to the orginator  of  the  mes-
+#           sage.   The  "Reply-To"  field  is added by the message
+#           originator and is intended to direct replies.
+# 
+# trace           =       [return]
+#                         1*received
+# 
+# return          =       "Return-Path:" path CRLF
+# 
+# path            =       ([CFWS] "<" ([CFWS] / addr-spec) ">" [CFWS]) /
+#                         obs-path
+# 
+# received        =       "Received:" name-val-list ";" date-time CRLF
+# 
+# name-val-list   =       [CFWS] [name-val-pair *(CFWS name-val-pair)]
+# 
+# name-val-pair   =       item-name CFWS item-value
+# 
+# item-name       =       ALPHA *(["-"] (ALPHA / DIGIT))
+# 
+# item-value      =       1*angle-addr / addr-spec /
+#                          atom / domain / msg-id
+# 
+module Mail
+  class ReturnPathField < StructuredField
+    
+    include Mail::CommonAddress
+    
+    FIELD_NAME = 'return-path'
+    CAPITALIZED_FIELD = 'Return-Path'
+    
+    def initialize(*args)
+      super(CAPITALIZED_FIELD, strip_field(FIELD_NAME, args.last))
+      self.parse
+      self
+
+    end
+    
+    def encoded
+      "#{CAPITALIZED_FIELD}: <#{address}>\r\n"
+    end
+    
+    def decoded
+      do_decode
+    end
+    
+    def address
+      addresses.first
+    end
+    
+    def default
+      address
+    end
+    
+  end
+end

data/lib/mail/fields/sender_field.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+# 
+# = Sender Field
+# 
+# The Sender field inherits sender StructuredField and handles the Sender: header
+# field in the email.
+# 
+# Sending sender to a mail message will instantiate a Mail::Field object that
+# has a SenderField as it's field type.  This includes all Mail::CommonAddress
+# module instance metods.
+# 
+# Only one Sender field can appear in a header, though it can have multiple
+# addresses and groups of addresses.
+# 
+# == Examples:
+# 
+#  mail = Mail.new
+#  mail.sender = 'Mikel Lindsaar <mikel@test.lindsaar.net>, ada@test.lindsaar.net'
+#  mail.sender    #=> ['Mikel Lindsaar <mikel@test.lindsaar.net>', 'ada@test.lindsaar.net']
+#  mail[:sender]  #=> '#<Mail::Field:0x180e5e8 @field=#<Mail::SenderField:0x180e1c4
+#  mail['sender'] #=> '#<Mail::Field:0x180e5e8 @field=#<Mail::SenderField:0x180e1c4
+#  mail['Sender'] #=> '#<Mail::Field:0x180e5e8 @field=#<Mail::SenderField:0x180e1c4
+# 
+#  mail[:sender].encoded   #=> 'Sender: Mikel Lindsaar <mikel@test.lindsaar.net>, ada@test.lindsaar.net\r\n'
+#  mail[:sender].decoded   #=> 'Mikel Lindsaar <mikel@test.lindsaar.net>, ada@test.lindsaar.net'
+#  mail[:sender].addresses #=> ['mikel@test.lindsaar.net', 'ada@test.lindsaar.net']
+#  mail[:sender].formatted #=> ['Mikel Lindsaar <mikel@test.lindsaar.net>', 'ada@test.lindsaar.net']
+# 
+module Mail
+  class SenderField < StructuredField
+    
+    include Mail::CommonAddress
+    
+    FIELD_NAME = 'sender'
+    CAPITALIZED_FIELD = 'Sender'
+
+    def initialize(*args)
+      super(CAPITALIZED_FIELD, strip_field(FIELD_NAME, args.last))
+      self.parse
+      self
+
+    end
+
+    def addresses
+      [address.address]
+    end
+
+    def address
+      result = tree.addresses.first
+    end
+    
+    def encoded
+      do_encode(CAPITALIZED_FIELD)
+    end
+    
+    def decoded
+      do_decode
+    end
+    
+    def default
+      address.address
+    end
+    
+  end
+end

data/lib/mail/fields/structured_field.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+module Mail
+  # Provides access to a structured header field
+  #
+  # ===Per RFC 2822:
+  #  2.2.2. Structured Header Field Bodies
+  #  
+  #     Some field bodies in this standard have specific syntactical
+  #     structure more restrictive than the unstructured field bodies
+  #     described above. These are referred to as "structured" field bodies.
+  #     Structured field bodies are sequences of specific lexical tokens as
+  #     described in sections 3 and 4 of this standard.  Many of these tokens
+  #     are allowed (according to their syntax) to be introduced or end with
+  #     comments (as described in section 3.2.3) as well as the space (SP,
+  #     ASCII value 32) and horizontal tab (HTAB, ASCII value 9) characters
+  #     (together known as the white space characters, WSP), and those WSP
+  #     characters are subject to header "folding" and "unfolding" as
+  #     described in section 2.2.3.  Semantic analysis of structured field
+  #     bodies is given along with their syntax.
+  class StructuredField
+    
+    include Mail::CommonField
+    include Mail::Utilities
+    
+    def initialize(*args)
+      self.name = args.first
+      self.value = args.last
+      self
+    end
+    
+    def default
+      decoded
+    end
+
+  end
+end

data/lib/mail/fields/subject_field.rb

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

data/lib/mail/fields/to_field.rb

@@ -0,0 +1,53 @@
+# 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    #=> ['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].encoded   #=> 'To: Mikel Lindsaar <mikel@test.lindsaar.net>, ada@test.lindsaar.net\r\n'
+#  mail[:to].decoded   #=> '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'
+    CAPITALIZED_FIELD = 'To'
+    
+    def initialize(*args)
+      super(CAPITALIZED_FIELD, strip_field(FIELD_NAME, args.last))
+      self.parse
+      self
+
+    end
+    
+    def encoded
+      do_encode(CAPITALIZED_FIELD)
+    end
+    
+    def decoded
+      do_decode
+    end
+    
+  end
+end

data/lib/mail/fields/unstructured_field.rb

@@ -0,0 +1,117 @@
+# 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
+    
+    def encoded
+      do_encode(self.name)
+    end
+    
+    def decoded
+      do_decode
+    end
+
+    def default
+      decoded
+    end
+    
+    def parse # An unstructured field does not parse
+      self
+    end
+
+    private
+    
+    def do_encode(name)
+      value.nil? ? '' : "#{wrapped_value}\r\n"
+    end
+    
+    def do_decode
+      value.blank? ? nil : Encodings.decode_encode(value, :decode)
+    end
+    
+    # 2.2.3. Long Header Fields
+    # 
+    #  Each header field is logically a single line of characters comprising
+    #  the field name, the colon, and the field body.  For convenience
+    #  however, and to deal with the 998/78 character limitations per line,
+    #  the field body portion of a header field can be split into a multiple
+    #  line representation; this is called "folding".  The general rule is
+    #  that wherever this standard allows for folding white space (not
+    #  simply WSP characters), a CRLF may be inserted before any WSP.  For
+    #  example, the header field:
+    #  
+    #          Subject: This is a test
+    #  
+    #  can be represented as:
+    #  
+    #          Subject: This
+    #           is a test
+    #  
+    #  Note: Though structured field bodies are defined in such a way that
+    #  folding can take place between many of the lexical tokens (and even
+    #  within some of the lexical tokens), folding SHOULD be limited to
+    #  placing the CRLF at higher-level syntactic breaks.  For instance, if
+    #  a field body is defined as comma-separated values, it is recommended
+    #  that folding occur after the comma separating the structured items in
+    #  preference to other places where the field could be folded, even if
+    #  it is allowed elsewhere.
+    def wrapped_value # :nodoc:
+      case
+      when decoded.to_s.ascii_only? && field_length <= 78
+        "#{name}: #{value}"
+      when field_length <= 40 # Allow for =?ISO-8859-1?B?=...=
+        "#{name}: #{encode(value)}"
+      else
+        @folded_line = []
+        @unfolded_line = value.clone
+        fold("#{name}: ".length)
+        folded = @folded_line.map { |l| l unless l.blank? }.compact.join("\r\n\t")
+        "#{name}: #{folded}"
+      end
+    end
+
+    def fold(prepend = 0) # :nodoc:
+      # Get the last whitespace character, OR we'll just choose 
+      # 78 if there is no whitespace
+      @unfolded_line.ascii_only? ? (limit = 78 - prepend) : (limit = 40 - prepend)
+      wspp = @unfolded_line.slice(0..limit) =~ /[ \t][^ \T]*$/ || limit
+      wspp = limit if wspp == 0
+      @folded_line << encode(@unfolded_line.slice!(0...wspp))
+      if @unfolded_line.length > limit
+        fold
+      else
+        @folded_line << encode(@unfolded_line)
+      end
+    end
+
+    def encode(value)
+      if value.ascii_only?
+        value
+      else
+        RUBY_VERSION < '1.9' ? encoding = $KCODE : encoding = @value.encoding
+        Encodings.b_value_encode(value, encoding)
+      end
+    end
+
+  end
+end