dball-mail 2.2.9.1

data/lib/mail/parsers/rfc2822_obsolete.treetop

@@ -0,0 +1,241 @@
+module Mail
+  grammar RFC2822Obsolete
+  
+    rule obs_qp
+      "\\" [\x00-\x7F]
+    end
+
+    rule obs_text
+      LF* CR* (obs_char LF* CR*)*
+    end
+
+    rule obs_char
+      [\x00-\x09]      /       # %d0-127 except CR and
+      [\x0B-\x0C]      /       # LF
+      [\x0E-\x7F]
+    end
+
+    rule obs_utext
+      obs_text
+    end
+
+    rule obs_phrase
+      (word / ".")+
+    end
+
+    rule obs_phrase_list
+      phrase / (phrase? CFWS? "," CFWS?)+ phrase?
+    end
+
+    rule obs_FWS
+      WSP+ (CRLF WSP+)*
+    end
+
+    rule obs_day_of_week
+      CFWS? day_name CFWS?
+    end
+
+    rule obs_year
+      CFWS? (DIGIT DIGIT) CFWS?
+    end
+
+    rule obs_month
+      CFWS month_name CFWS
+    end
+
+    rule obs_day
+      CFWS? (DIGIT / (DIGIT DIGIT))  CFWS?
+    end
+
+    rule obs_hour
+       CFWS? (DIGIT DIGIT) CFWS?
+    end
+
+    rule obs_minute
+      CFWS? (DIGIT DIGIT) CFWS?
+    end
+
+    rule obs_second
+      CFWS? (DIGIT DIGIT) CFWS?
+    end
+
+    rule obs_zone
+      "UT" / "GMT" /          # Universal Time
+                              # North American UT
+                              # offsets
+      "EST" / "EDT" /         # Eastern:  - 5/ - 4
+      "CST" / "CDT" /         # Central:  - 6/ - 5
+      "MST" / "MDT" /         # Mountain: - 7/ - 6
+      "PST" / "PDT" /         # Pacific:  - 8/ - 7
+                              #
+      [\x41-\x49] /           # Military zones - "A"
+      [\x4B-\x5A] /           # through "I" and "K"
+      [\x61-\x69] /           # through "Z", both
+      [\x6B-\x7A]             # upper and lower case
+    end
+
+    rule obs_angle_addr
+      CFWS? "<" obs_route? addr_spec ">" CFWS?
+    end
+    
+    rule obs_route
+      CFWS? obs_domain_list ":" CFWS?
+    end
+
+    rule obs_domain_list
+      "@" domain (("," )* CFWS? "@" domain)*
+    end
+    
+    rule obs_local_part
+      word ("." word)*
+    end
+
+    rule obs_domain
+      atom ("." atom)*
+    end
+
+    rule obs_mbox_list
+      (mailbox? CFWS? "," CFWS?)+ mailbox?
+    end
+
+    rule obs_addr_list
+      (address? CFWS? "," CFWS?)+ address?
+    end
+
+    rule obs_fields
+      (obs_return /
+       obs_received /
+       obs_orig_date /
+       obs_from /
+       obs_sender /
+       obs_reply_to /
+       obs_to /
+       obs_cc /
+       obs_bcc /
+       obs_message_id /
+       obs_in_reply_to /
+       obs_references /
+       obs_subject /
+       obs_comments /
+       obs_keywords /
+       obs_resent_date /
+       obs_resent_from /
+       obs_resent_send /
+       obs_resent_rply /
+       obs_resent_to /
+       obs_resent_cc /
+       obs_resent_bcc /
+       obs_resent_mid /
+       obs_optional)*
+    end
+
+    rule obs_orig_date
+      "Date" WSP* ":" date_time CRLF
+    end
+
+    rule obs_from
+      "From" WSP* ":" mailbox_list CRLF
+    end
+  
+    rule obs_sender
+      "Sender" WSP* ":" mailbox CRLF
+    end
+  
+    rule obs_reply_to
+      "Reply-To" WSP* ":" mailbox_list CRLF
+    end
+
+
+    rule obs_to
+      "To" WSP* ":" address_list CRLF
+    end
+
+    rule obs_cc
+      "Cc" WSP* ":" address_list CRLF
+    end
+
+    rule obs_bcc
+      "Bcc" WSP* ":" (address_list / CFWS?) CRLF
+    end
+
+    rule obs_message_id
+      "Message-ID" WSP* ":" msg_id CRLF
+    end
+
+    rule obs_in_reply_to
+      "In-Reply-To" WSP* ":" (phrase / msg_id)* CRLF
+    end
+
+    rule obs_references
+      "References" WSP* ":" (phrase / msg_id)* CRLF
+    end
+
+    rule obs_id_left
+      local_part
+    end
+
+    rule obs_id_right
+      domain
+    end
+
+    rule obs_subject
+      "Subject" WSP* ":" unstructured CRLF
+    end
+
+    rule obs_comments
+      "Comments" WSP* ":" unstructured CRLF
+    end
+
+    rule obs_keywords
+      "Keywords" WSP* ":" obs_phrase_list CRLF
+    end
+
+    rule obs_resent_from
+      "Resent-From" WSP* ":" mailbox_list CRLF
+    end
+
+    rule obs_resent_send
+      "Resent-Sender" WSP* ":" mailbox CRLF
+    end
+
+    rule obs_resent_date
+      "Resent-Date" WSP* ":" date_time CRLF
+    end
+
+    rule obs_resent_to
+      "Resent-To" WSP* ":" address_list CRLF
+    end
+
+    rule obs_resent_cc
+      "Resent-Cc" WSP* ":" address_list CRLF
+    end
+
+    rule obs_resent_bcc
+      "Resent-Bcc" WSP* ":" (address_list / CFWS?) CRLF
+    end
+
+    rule obs_resent_mid
+      "Resent-Message-ID" WSP* ":" msg_id CRLF
+    end
+
+    rule obs_resent_rply
+      "Resent-Reply-To" WSP* ":" address_list CRLF
+    end
+
+    rule obs_return
+      "Return-Path" WSP* ":" path CRLF
+    end
+
+    rule obs_received
+      "Received" WSP* ":" name_val_list CRLF
+    end
+
+    rule obs_path
+      obs_angle_addr
+    end
+
+    rule obs_optional
+      field_name WSP* ":" unstructured CRLF
+    end
+  end
+end

data/lib/mail/part.rb

@@ -0,0 +1,116 @@
+# encoding: utf-8
+module Mail
+  class Part < Message
+    
+    # Creates a new empty Content-ID field and inserts it in the correct order
+    # into the Header.  The ContentIdField object will automatically generate
+    # a unique content ID if you try and encode it or output it to_s without
+    # specifying a content id.
+    # 
+    # It will preserve the content ID you specify if you do.
+    def add_content_id(content_id_val = '')
+      header['content-id'] = content_id_val
+    end
+    
+    # Returns true if the part has a content ID field, the field may or may
+    # not have a value, but the field exists or not.
+    def has_content_id?
+      header.has_content_id?
+    end
+    
+    def inline_content_id
+      # TODO: Deprecated in 2.2.2 - Remove in 2.3
+      STDERR.puts("Part#inline_content_id is deprecated, please call Part#cid instead")
+      cid
+    end
+    
+    def cid
+      add_content_id unless has_content_id?
+      uri_escape(unbracket(content_id))
+    end
+    
+    def url
+      "cid:#{cid}"
+    end
+    
+    def inline?
+      header[:content_disposition].disposition_type == 'inline' if header[:content_disposition]
+    end
+    
+    def add_required_fields
+      add_content_id unless has_content_id?
+      super
+    end
+    
+    def delivery_status_report_part?
+      (main_type =~ /message/i && sub_type =~ /delivery-status/i) && body =~ /Status:/
+    end
+    
+    def delivery_status_data
+      delivery_status_report_part? ? parse_delivery_status_report : {}
+    end
+    
+    def bounced?
+      if action.is_a?(Array)
+        !!(action.first =~ /failed/i)
+      else
+        !!(action =~ /failed/i)
+      end
+    end
+    
+    
+    # Either returns the action if the message has just a single report, or an
+    # array of all the actions, one for each report
+    def action
+      get_return_values('action')
+    end
+    
+    def final_recipient
+      get_return_values('final-recipient')
+    end
+    
+    def error_status
+      get_return_values('status')
+    end
+
+    def diagnostic_code
+      get_return_values('diagnostic-code')
+    end
+    
+    def remote_mta
+      get_return_values('remote-mta')
+    end
+    
+    def retryable?
+      !(error_status =~ /^5/)
+    end
+
+    private
+    
+    def get_return_values(key)
+      if delivery_status_data[key].is_a?(Array)
+        delivery_status_data[key].map { |a| a.value }
+      else
+        delivery_status_data[key].value
+      end
+    end
+    
+    # A part may not have a header.... so, just init a body if no header
+    def parse_message
+      header_part, body_part = raw_source.split(/#{CRLF}#{WSP}*#{CRLF}/m, 2)
+      if header_part =~ HEADER_LINE
+        self.header = header_part
+        self.body   = body_part
+      else
+        self.header = "Content-Type: text/plain\r\n"
+        self.body   = header_part
+      end
+    end
+    
+    def parse_delivery_status_report
+      @delivery_status_data ||= Header.new(body.to_s.gsub("\r\n\r\n", "\r\n"))
+    end
+
+  end
+  
+end

data/lib/mail/parts_list.rb

@@ -0,0 +1,43 @@
+module Mail
+  class PartsList < Array
+    
+    def attachments
+      Mail::AttachmentsList.new(self)
+    end
+
+    def collect
+      if block_given?
+        ary = PartsList.new
+        each { |o| ary << yield(o) }
+        ary
+      else
+        to_a
+      end
+    end
+    
+    undef :map
+    alias_method :map, :collect
+
+    def map!
+      raise NoMethodError, "#map! is not defined, please call #collect and create a new PartsList"
+    end
+    
+    def collect!
+      raise NoMethodError, "#collect! is not defined, please call #collect and create a new PartsList"
+    end
+    
+    def sort!(order)
+      sorted = self.sort do |a, b|
+        # OK, 10000 is arbitrary... if anyone actually wants to explicitly sort 10000 parts of a
+        # single email message... please show me a use case and I'll put more work into this method,
+        # in the meantime, it works :)
+        a_order = order.index(a[:content_type].string.downcase) || 10000
+        b_order = order.index(b[:content_type].string.downcase) || 10000
+        a_order <=> b_order
+      end
+      self.clear
+      sorted.each { |p| self << p }
+    end
+    
+  end
+end

data/lib/mail/patterns.rb

@@ -0,0 +1,34 @@
+# encoding: us-ascii
+module Mail
+  module Patterns
+    white_space = %Q|\x9\x20|
+    text        = %Q|\x1-\x8\xB\xC\xE-\x7f|
+    field_name  = %Q|\x21-\x39\x3b-\x7e|
+    qp_safe     = %Q|\x20-\x3c\x3e-\x7e|
+    
+    aspecial     = %Q|()<>[]:;@\\,."| # RFC5322
+    tspecial     = %Q|()<>@,;:\\"/[]?=| # RFC2045
+    lwsp         = %Q| \t\r\n|
+    control      = %Q|\x00-\x1f\x7f-\xff|
+    
+    if control.respond_to?(:force_encoding)
+      control = control.force_encoding(Encoding::BINARY)
+    end
+    
+    CRLF          = /\r\n/
+    WSP           = /[#{white_space}]/
+    FWS           = /#{CRLF}#{WSP}*/
+    TEXT          = /[#{text}]/ # + obs-text
+    FIELD_NAME    = /[#{field_name}]+/
+    FIELD_BODY    = /.+/
+    FIELD_LINE    = /^[#{field_name}]+:\s*.+$/
+    HEADER_LINE   = /^([#{field_name}]+:\s*.+)$/
+
+    QP_UNSAFE     = /[^#{qp_safe}]/
+    QP_SAFE       = /[#{qp_safe}]/
+    CONTROL_CHAR  = /[#{control}]/n
+    ATOM_UNSAFE   = /[#{Regexp.quote aspecial}#{control}#{lwsp}]/n
+    PHRASE_UNSAFE = /[#{Regexp.quote aspecial}#{control}]/n
+    TOKEN_UNSAFE  = /[#{Regexp.quote tspecial}#{control}#{lwsp}]/n
+  end
+end

data/lib/mail/utilities.rb

@@ -0,0 +1,211 @@
+# encoding: utf-8
+module Mail
+  module Utilities
+    include Patterns
+    
+    # Returns true if the string supplied is free from characters not allowed as an ATOM
+    def atom_safe?( str )
+      not ATOM_UNSAFE === str
+    end
+
+    # If the string supplied has ATOM unsafe characters in it, will return the string quoted 
+    # in double quotes, otherwise returns the string unmodified
+    def quote_atom( str )
+      atom_safe?( str ) ? str : dquote(str)
+    end
+
+    # If the string supplied has PHRASE unsafe characters in it, will return the string quoted 
+    # in double quotes, otherwise returns the string unmodified
+    def quote_phrase( str )
+      if RUBY_VERSION >= '1.9'
+        original_encoding = str.encoding
+        str.force_encoding('ASCII-8BIT')
+        if (PHRASE_UNSAFE === str)
+          dquote(str).force_encoding(original_encoding)
+        else
+          str.force_encoding(original_encoding)
+        end
+      else
+        (PHRASE_UNSAFE === str) ? dquote(str) : str
+      end
+    end
+
+    # Returns true if the string supplied is free from characters not allowed as a TOKEN
+    def token_safe?( str )
+      not TOKEN_UNSAFE === str
+    end
+
+    # If the string supplied has TOKEN unsafe characters in it, will return the string quoted 
+    # in double quotes, otherwise returns the string unmodified
+    def quote_token( str )
+      token_safe?( str ) ? str : dquote(str)
+    end
+
+    # Wraps supplied string in double quotes unless it is already wrapped.
+    # 
+    # Additionally will escape any double quotation marks in the string with a single
+    # backslash in front of the '"' character.
+    def dquote( str )
+      match = str.match(/^"(.*)?"$/)
+      str = match[1] if match
+      # First remove all escaped double quotes:
+      str = str.gsub(/\\"/, '"')
+      # Then wrap and re-escape all double quotes
+      '"' + str.gsub(/["]/n) {|s| '\\' + s } + '"'
+    end
+    
+    # Unwraps supplied string from inside double quotes.
+    # 
+    # Example:
+    # 
+    #  string = '"This is a string"'
+    #  unquote(string) #=> 'This is a string'
+    def unquote( str )
+      match = str.match(/^"(.*?)"$/)
+      match ? match[1] : str
+    end
+    
+    # Wraps a string in parenthesis and escapes any that are in the string itself.
+    # 
+    # Example:
+    # 
+    #  paren( 'This is a string' ) #=> '(This is a string)'
+    def paren( str )
+      RubyVer.paren( str )
+    end
+    
+    # Unwraps a string from being wrapped in parenthesis
+    # 
+    # Example:
+    # 
+    #  str = '(This is a string)'
+    #  unparen( str ) #=> 'This is a string'
+    def unparen( str )
+      match = str.match(/^\((.*?)\)$/)
+      match ? match[1] : str
+    end
+    
+    # Wraps a string in angle brackets and escapes any that are in the string itself
+    # 
+    # Example:
+    # 
+    #  bracket( 'This is a string' ) #=> '<This is a string>'
+    def bracket( str )
+      RubyVer.bracket( str )
+    end
+    
+    # Unwraps a string from being wrapped in parenthesis
+    # 
+    # Example:
+    # 
+    #  str = '<This is a string>'
+    #  unbracket( str ) #=> 'This is a string'
+    def unbracket( str )
+      match = str.match(/^\<(.*?)\>$/)
+      match ? match[1] : str
+    end
+    
+    # Escape parenthesies in a string
+    # 
+    # Example:
+    # 
+    #  str = 'This is (a) string'
+    #  escape_paren( str ) #=> 'This is \(a\) string'
+    def escape_paren( str )
+      RubyVer.escape_paren( str )
+    end
+    
+    def uri_escape( str )
+      URI.escape(str)
+    end
+    
+    def uri_unescape( str )
+      URI.unescape(str)
+    end
+    
+    # Matches two objects with their to_s values case insensitively
+    # 
+    # Example:
+    # 
+    #  obj2 = "This_is_An_object"
+    #  obj1 = :this_IS_an_object
+    #  match_to_s( obj1, obj2 ) #=> true
+    def match_to_s( obj1, obj2 )
+      obj1.to_s.downcase == obj2.to_s.downcase
+    end
+    
+    # Capitalizes a string that is joined by hyphens correctly.
+    # 
+    # Example:
+    # 
+    #  string = 'resent-from-field'
+    #  capitalize_field( string ) #=> 'Resent-From-Field'
+    def capitalize_field( str )
+      str.to_s.split("-").map { |v| v.capitalize }.join("-")
+    end
+    
+    # Takes an underscored word and turns it into a class name
+    # 
+    # Example:
+    # 
+    #  constantize("hello") #=> "Hello"
+    #  constantize("hello-there") #=> "HelloThere"
+    #  constantize("hello-there-mate") #=> "HelloThereMate"
+    def constantize( str )
+      str.to_s.split(/[-_]/).map { |v| v.capitalize }.to_s
+    end
+    
+    # Swaps out all underscores (_) for hyphens (-) good for stringing from symbols
+    # a field name.
+    # 
+    # Example:
+    # 
+    #  string = :resent_from_field
+    #  dasherize ( string ) #=> 'resent_from_field'
+    def dasherize( str )
+      str.to_s.gsub('_', '-')
+    end
+
+    # Swaps out all hyphens (-) for underscores (_) good for stringing to symbols
+    # a field name.
+    # 
+    # Example:
+    # 
+    #  string = :resent_from_field
+    #  underscoreize ( string ) #=> 'resent_from_field'
+    def underscoreize( str )
+      str.to_s.downcase.gsub('-', '_')
+    end
+
+    if RUBY_VERSION <= '1.8.6'
+
+      def map_lines( str, &block )
+        results = []
+        str.each_line do |line|
+          results << yield(line)
+        end
+        results
+      end
+  
+      def map_with_index( enum, &block )
+        results = []
+        enum.each_with_index do |token, i|
+          results[i] = yield(token, i)
+        end
+        results
+      end
+      
+    else
+
+      def map_lines( str, &block )
+        str.each_line.map(&block)
+      end
+
+      def map_with_index( enum, &block )
+        enum.each_with_index.map(&block)
+      end
+
+    end
+
+  end
+end

data/lib/mail/version.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+module Mail
+  module VERSION
+    
+    version = {}
+    File.read(File.join(File.dirname(__FILE__), '../', 'VERSION')).each_line do |line|
+      type, value = line.chomp.split(":")
+      next if type =~ /^\s+$/  || value =~ /^\s+$/
+      version[type] = value
+    end
+    
+    MAJOR = version['major']
+    MINOR = version['minor']
+    PATCH = version['patch']
+    BUILD = version['build']
+
+    STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join('.')
+    
+    def self.version
+      STRING
+    end
+    
+  end
+end