rack-mail_exception 0.0.1

data/vendor/mail/lib/mail/fields/sender_field.rb

@@ -0,0 +1,67 @@
+# 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']
+# 
+require 'mail/fields/common/common_address'
+
+module Mail
+  class SenderField < StructuredField
+    
+    include Mail::CommonAddress
+    
+    FIELD_NAME = 'sender'
+    CAPITALIZED_FIELD = 'Sender'
+
+    def initialize(value = nil, charset = 'utf-8')
+      self.charset = charset
+      super(CAPITALIZED_FIELD, strip_field(FIELD_NAME, value), charset)
+      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/vendor/mail/lib/mail/fields/structured_field.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+require 'mail/fields/common/common_field'
+
+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(name = nil, value = nil, charset = nil)
+      self.name    = name
+      self.value   = value
+      self.charset = charset
+      self
+    end
+    
+    def charset
+      @charset
+    end
+    
+    def charset=(val)
+      @charset = val
+    end
+    
+    def default
+      decoded
+    end
+    
+    def errors
+      []
+    end
+
+  end
+end

data/vendor/mail/lib/mail/fields/subject_field.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+# 
+# subject         =       "Subject:" unstructured CRLF
+module Mail
+  class SubjectField < UnstructuredField
+    
+    FIELD_NAME = 'subject'
+    CAPITALIZED_FIELD = "Subject"
+    
+    def initialize(value = nil, charset = 'utf-8')
+      self.charset = charset
+      super(CAPITALIZED_FIELD, strip_field(FIELD_NAME, value), charset)
+    end
+    
+  end
+end

data/vendor/mail/lib/mail/fields/to_field.rb

@@ -0,0 +1,55 @@
+# 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']
+# 
+require 'mail/fields/common/common_address'
+
+module Mail
+  class ToField < StructuredField
+    
+    include Mail::CommonAddress
+    
+    FIELD_NAME = 'to'
+    CAPITALIZED_FIELD = 'To'
+    
+    def initialize(value = nil, charset = 'utf-8')
+      self.charset = charset
+      super(CAPITALIZED_FIELD, strip_field(FIELD_NAME, value), charset)
+      self.parse
+      self
+    end
+    
+    def encoded
+      do_encode(CAPITALIZED_FIELD)
+    end
+    
+    def decoded
+      do_decode
+    end
+    
+  end
+end

data/vendor/mail/lib/mail/fields/unstructured_field.rb

@@ -0,0 +1,166 @@
+# encoding: utf-8
+require 'mail/fields/common/common_field'
+
+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(name, value, charset = nil)
+      self.charset = charset
+      @errors = []
+      if charset
+        self.charset = charset
+      else
+        if value.to_s.respond_to?(:encoding)
+          self.charset = value.to_s.encoding
+        else
+          self.charset = $KCODE
+        end
+      end
+      self.name = name
+      self.value = value
+      self
+    end
+    
+    def charset
+      @charset
+    end
+    
+    def charset=(val)
+      @charset = val
+    end
+
+    def errors
+      @errors
+    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:
+      @folded_line = []
+      @unfolded_line = decoded.to_s.clone
+      fold("#{name}: ".length)
+      wrap_lines(name, @folded_line)
+    end
+
+    def wrap_lines(name, folded_lines)
+      result = []
+      index = 0
+      result[index] = "#{name}: #{folded_lines.shift}"
+      folded_lines.each do |line|
+        if (result[index] + line).length < 77
+          result[index] << " " + line
+        else
+          result[index] << "\r\n\t"
+          index += 1
+          result[index] = line
+        end
+      end
+      result.join
+    end
+
+    def fold(prepend = 0) # :nodoc:
+      # Get the last whitespace character, OR we'll just choose 
+      # 78 if there is no whitespace, or 23 for non ascii:
+      # Each QP byte is 6 chars (=0A)
+      # Plus 18 for the =?encoding?Q?= ... ?=
+      # Plus 2 for the \r\n and 1 for the \t
+      # 80 - 2 - 1 - 18 = 59 / 6 ~= 10
+      @unfolded_line.ascii_only? ? (limit = 78 - prepend) : (limit = 10 - prepend)
+      # find the last white space character within the limit
+      if wspp = @unfolded_line.slice(0..limit) =~ /[ \t][^ \t]*$/
+        wrap = true
+        wspp = limit if wspp == 0
+        @folded_line << encode(@unfolded_line.slice!(0...wspp).strip.to_str)
+        @folded_line.flatten!
+      # if no last whitespace before the limit, find the first
+      elsif wspp = @unfolded_line =~ /[ \t][^ \t]/
+        wrap = true
+        wspp = limit if wspp == 0
+        @folded_line << encode(@unfolded_line.slice!(0...wspp).strip.to_str)
+        @folded_line.flatten!
+      # if no whitespace, don't wrap
+      else
+        wrap = false
+      end
+
+      if wrap && @unfolded_line.length > limit
+        fold
+      else
+        @folded_line << encode(@unfolded_line)
+        @folded_line.flatten!
+      end
+    end
+
+    def encode(value)
+      value.gsub!("\r", "=0D")
+      value.gsub!("\n", "=0A")
+      Encodings.q_value_encode(value, @charset).split(" ")
+    end
+
+  end
+end

data/vendor/mail/lib/mail/header.rb

@@ -0,0 +1,262 @@
+# 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, charset = nil)
+      @errors = []
+      @charset = charset
+      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 ||= FieldList.new
+    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|
+
+        field = Field.new(field, nil, charset)
+        field.errors.each { |error| self.errors << error }
+        selected = select_field_for(field.name)
+
+        if selected.any? && limited_field?(field.name)
+          selected.first.update(field.name, field.value)
+        else
+          @fields << field
+        end
+      end
+
+    end
+    
+    def errors
+      @errors
+    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)
+      name = dasherize(name).downcase
+      selected = select_field_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)
+      name = dasherize(name)
+      fn = name.downcase
+      selected = select_field_for(fn)
+      
+      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_field?(fn)
+        selected.first.update(fn, value)
+        
+      # User wants to create the field
+      else
+        # Need to insert in correct order for trace fields
+        self.fields << Field.new(name.to_s, value, charset)
+      end
+    end
+    
+    def charset
+      if self['content_type'] && self['content_type'].parameters
+        self['content_type'].parameters['charset']
+      else
+        @charset
+      end
+    end
+    
+    def charset=(val)
+      if self['content_type']
+        self['content_type'].parameters['charset'] = val
+      end
+      @charset = val
+    end
+    
+    LIMITED_FIELDS   = %w[ 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-disposition content-location]
+
+    def encoded
+      buffer = ''
+      fields.each do |field|
+        buffer << field.encoded
+      end
+      buffer
+    end
+
+    def to_s
+      encoded
+    end
+    
+    def decoded
+      raise NoMethodError, 'Can not decode an entire header as there could be character set conflicts, try calling #decoded on the various fields.'
+    end
+
+    def field_summary
+      fields.map { |f| "<#{f.name}: #{f.value}>" }.join(", ")
+    end
+
+    # 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 MIME version 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
+    
+    def select_field_for(name)
+      fields.select { |f| f.responsible_for?(name.to_s) }
+    end
+    
+    def limited_field?(name)
+      LIMITED_FIELDS.include?(name.to_s.downcase)
+    end
+    
+  end
+end