mail 2.6.4 → 2.9.0

data/lib/mail/body.rb

@@ -1,28 +1,28 @@
 # encoding: utf-8
 # frozen_string_literal: true
 module Mail
-  
+
   # = Body
-  # 
+  #
   # The body is where the text of the email is stored.  Mail treats the body
   # as a single object.  The body itself has no information about boundaries
   # used in the MIME standard, it just looks at its content as either a single
   # block of text, or (if it is a multipart message) as an array of blocks of text.
-  # 
+  #
   # A body has to be told to split itself up into a multipart message by calling
   # #split with the correct boundary.  This is because the body object has no way
   # of knowing what the correct boundary is for itself (there could be many
   # boundaries in a body in the case of a nested MIME text).
-  # 
+  #
   # Once split is called, Mail::Body will slice itself up on this boundary,
   # assigning anything that appears before the first part to the preamble, and
   # anything that appears after the closing boundary to the epilogue, then
   # each part gets initialized into a Mail::Part object.
-  # 
+  #
   # The boundary that is used to split up the Body is also stored in the Body
-  # object for use on encoding itself back out to a string.  You can 
+  # object for use on encoding itself back out to a string.  You can
   # overwrite this if it needs to be changed.
-  # 
+  #
   # On encoding, the body will return the preamble, then each part joined by
   # the boundary, followed by a closing boundary string and then the epilogue.
   class Body
@@ -32,7 +32,7 @@ module Mail
       @preamble = nil
       @epilogue = nil
       @charset  = nil
-      @part_sort_order = [ "text/plain", "text/enriched", "text/html" ]
+      @part_sort_order = [ "text/plain", "text/enriched", "text/html", "multipart/alternative" ]
       @parts = Mail::PartsList.new
       if Utilities.blank?(string)
         @raw_source = ''
@@ -46,21 +46,26 @@ module Mail
           raise "You can only assign a string or an object that responds_to? :join or :to_s to a body."
         end
       end
-      @encoding = (only_us_ascii? ? '7bit' : '8bit')
+      @encoding = default_encoding
       set_charset
     end
-    
+
+    def init_with(coder)
+      coder.map.each { |k, v| instance_variable_set(:"@#{k}", v) }
+      @parts = Mail::PartsList.new(coder['parts'])
+    end
+
     # Matches this body with another body.  Also matches the decoded value of this
     # body with a string.
-    # 
+    #
     # Examples:
-    # 
+    #
     #   body = Mail::Body.new('The body')
     #   body == body #=> true
-    #   
+    #
     #   body = Mail::Body.new('The body')
     #   body == 'The body' #=> true
-    #   
+    #
     #   body = Mail::Body.new("VGhlIGJvZHk=\n")
     #   body.encoding = 'base64'
     #   body == "The body" #=> true
@@ -71,28 +76,28 @@ module Mail
         super
       end
     end
-    
+
     # Accepts a string and performs a regular expression against the decoded text
-    # 
+    #
     # Examples:
-    # 
+    #
     #   body = Mail::Body.new('The body')
     #   body =~ /The/ #=> 0
-    #   
+    #
     #   body = Mail::Body.new("VGhlIGJvZHk=\n")
     #   body.encoding = 'base64'
     #   body =~ /The/ #=> 0
     def =~(regexp)
       self.decoded =~ regexp
     end
-    
+
     # Accepts a string and performs a regular expression against the decoded text
-    # 
+    #
     # Examples:
-    # 
+    #
     #   body = Mail::Body.new('The body')
     #   body.match(/The/) #=> #<MatchData "The">
-    #   
+    #
     #   body = Mail::Body.new("VGhlIGJvZHk=\n")
     #   body.encoding = 'base64'
     #   body.match(/The/) #=> #<MatchData "The">
@@ -115,12 +120,12 @@ module Mail
     end
 
     # Allows you to set the sort order of the parts, overriding the default sort order.
-    # Defaults to 'text/plain', then 'text/enriched', then 'text/html' with any other content
-    # type coming after.
+    # Defaults to 'text/plain', then 'text/enriched', then 'text/html', then 'multipart/alternative'
+    # with any other content type coming after.
     def set_sort_order(order)
       @part_sort_order = order
     end
-    
+
     # Allows you to sort the parts according to the default sort order, or the sort order you
     # set with :set_sort_order.
     #
@@ -132,47 +137,45 @@ module Mail
       end
       @parts.sort!(@part_sort_order)
     end
-    
-    # Returns the raw source that the body was initialized with, without
-    # any tampering
-    def raw_source
-      @raw_source
-    end
-   
-    def get_best_encoding(target)
-      target_encoding = Mail::Encodings.get_encoding(target)
-      target_encoding.get_best_compatible(encoding, raw_source)
+
+    def negotiate_best_encoding(message_encoding, allowed_encodings = nil)
+      Mail::Encodings::TransferEncoding.negotiate(message_encoding, encoding, raw_source, allowed_encodings)
     end
- 
+
     # Returns a body encoded using transfer_encoding.  Multipart always uses an
     # identiy encoding (i.e. no encoding).
     # Calling this directly is not a good idea, but supported for compatibility
     # TODO: Validate that preamble and epilogue are valid for requested encoding
-    def encoded(transfer_encoding = '8bit')
+    def encoded(transfer_encoding = nil)
       if multipart?
         self.sort_parts!
         encoded_parts = parts.map { |p| p.encoded }
         ([preamble] + encoded_parts).join(crlf_boundary) + end_boundary + epilogue.to_s
       else
-        be = get_best_encoding(transfer_encoding)
-        dec = Mail::Encodings::get_encoding(encoding)
-        enc = Mail::Encodings::get_encoding(be)
+        dec = Mail::Encodings.get_encoding(encoding)
+        enc =
+          if Utilities.blank?(transfer_encoding)
+            dec
+          else
+            negotiate_best_encoding(transfer_encoding)
+          end
+
         if dec.nil?
-            # Cannot decode, so skip normalization
-            raw_source
+          # Cannot decode, so skip normalization
+          raw_source
         else
-            # Decode then encode to normalize and allow transforming 
-            # from base64 to Q-P and vice versa
-            decoded = dec.decode(raw_source)
-            if defined?(Encoding) && charset && charset != "US-ASCII"
-              decoded.encode!(charset)
-              decoded.force_encoding('BINARY') unless Encoding.find(charset).ascii_compatible?
-            end
-            enc.encode(decoded)
+          # Decode then encode to normalize and allow transforming
+          # from base64 to Q-P and vice versa
+          decoded = dec.decode(raw_source)
+          if defined?(Encoding) && charset && charset != "US-ASCII"
+            decoded = decoded.encode(charset)
+            decoded.force_encoding('BINARY') unless Encoding.find(charset).ascii_compatible?
+          end
+          enc.encode(decoded)
         end
       end
     end
-    
+
     def decoded
       if !Encodings.defined?(encoding)
         raise UnknownEncodingType, "Don't know how to decode #{encoding}, please call #encoded and decode it yourself."
@@ -180,18 +183,10 @@ module Mail
         Encodings.get_encoding(encoding).decode(raw_source)
       end
     end
-    
+
     def to_s
       decoded
     end
-    
-    def charset
-      @charset
-    end
-    
-    def charset=( val )
-      @charset = val
-    end
 
     def encoding(val = nil)
       if val
@@ -200,54 +195,41 @@ module Mail
         @encoding
       end
     end
-    
+
     def encoding=( val )
-      @encoding = if val == "text" || Utilities.blank?(val)
-          (only_us_ascii? ? '7bit' : '8bit')
-      else
+      @encoding =
+        if val == "text" || Utilities.blank?(val)
+          default_encoding
+        else
           val
-      end
+        end
     end
 
-    # Returns the preamble (any text that is before the first MIME boundary)
-    def preamble
-      @preamble
-    end
+    # Returns the raw source that the body was initialized with, without
+    # any tampering
+    attr_reader :raw_source
+
+    # Returns parts of the body
+    attr_reader :parts
+
+    # Returns and sets the original character encoding
+    attr_accessor :charset
+
+    # Returns and sets the preamble as a string (any text that is before the first MIME boundary)
+    attr_accessor :preamble
+
+    # Returns and sets the epilogue as a string (any text that is after the last MIME boundary)
+    attr_accessor :epilogue
+
+    # Returns and sets the boundary used by the body
+    # Allows you to change the boundary of this Body object
+    attr_accessor :boundary
 
-    # Sets the preamble to a string (adds text before the first MIME boundary)
-    def preamble=( val )
-      @preamble = val
-    end
-    
-    # Returns the epilogue (any text that is after the last MIME boundary)
-    def epilogue
-      @epilogue
-    end
-    
-    # Sets the epilogue to a string (adds text after the last MIME boundary)
-    def epilogue=( val )
-      @epilogue = val
-    end
-    
     # Returns true if there are parts defined in the body
     def multipart?
       true unless parts.empty?
     end
-    
-    # Returns the boundary used by the body
-    def boundary
-      @boundary
-    end
-    
-    # Allows you to change the boundary of this Body object
-    def boundary=( val )
-      @boundary = val
-    end
 
-    def parts
-      @parts
-    end
-    
     def <<( val )
       if @parts
         @parts << val
@@ -268,14 +250,21 @@ module Mail
       self
     end
 
-    def only_us_ascii?
-      !(raw_source =~ /[^\x01-\x7f]/)
+    def ascii_only?
+      unless defined? @ascii_only
+        @ascii_only = raw_source.ascii_only?
+      end
+      @ascii_only
     end
-    
+
     def empty?
       !!raw_source.to_s.empty?
     end
-    
+
+    def default_encoding
+      ascii_only? ? '7bit' : '8bit'
+    end
+
     private
 
     # split parts by boundary, ignore first part if empty, append final part when closing boundary was missing
@@ -283,7 +272,7 @@ module Mail
       parts_regex = /
         (?:                    # non-capturing group
           \A                |  # start of string OR
-          \r\n                 # line break
+          \r?\n                # line break with optional CR
          )
         (
           --#{Regexp.escape(boundary || "")}  # boundary delimiter
@@ -300,17 +289,17 @@ module Mail
       end
       parts.map(&:first)
     end
-    
+
     def crlf_boundary
       "\r\n--#{boundary}\r\n"
     end
-    
+
     def end_boundary
       "\r\n--#{boundary}--\r\n"
     end
-    
+
     def set_charset
-      only_us_ascii? ? @charset = 'US-ASCII' : @charset = nil
+      @charset = ascii_only? ? 'US-ASCII' : nil
     end
   end
 end

data/lib/mail/configuration.rb

@@ -42,6 +42,8 @@ module Mail
         Mail::SMTPConnection
       when :test
         Mail::TestMailer
+      when :logger
+        Mail::LoggerDelivery
       else
         method
       end

data/lib/mail/constants.rb

@@ -16,9 +16,10 @@ module Mail
       control = control.dup.force_encoding(Encoding::BINARY)
     end
 
-    CRLF          = /\r\n/
+    LAX_CRLF      = /\r?\n/
     WSP           = /[#{white_space}]/
-    FWS           = /#{CRLF}#{WSP}*/
+    FWS           = /#{LAX_CRLF}#{WSP}*/
+    UNFOLD_WS     = /#{LAX_CRLF}(#{WSP})/m
     TEXT          = /[#{text}]/ # + obs-text
     FIELD_NAME    = /[#{field_name}]+/
     FIELD_PREFIX  = /\A(#{FIELD_NAME})/
@@ -26,7 +27,7 @@ module Mail
     FIELD_LINE    = /^[#{field_name}]+:\s*.+$/
     FIELD_SPLIT   = /^(#{FIELD_NAME})\s*:\s*(#{FIELD_BODY})?$/
     HEADER_LINE   = /^([#{field_name}]+:\s*.+)$/
-    HEADER_SPLIT  = /#{CRLF}(?!#{WSP})/
+    HEADER_SPLIT  = /#{LAX_CRLF}(?!#{WSP})/
 
     QP_UNSAFE     = /[^#{qp_safe}]/
     QP_SAFE       = /[#{qp_safe}]/
@@ -34,8 +35,28 @@ module Mail
     ATOM_UNSAFE   = /[#{Regexp.quote aspecial}#{control}#{sp}]/n
     PHRASE_UNSAFE = /[#{Regexp.quote aspecial}#{control}]/n
     TOKEN_UNSAFE  = /[#{Regexp.quote tspecial}#{control}#{sp}]/n
-    ENCODED_VALUE = /\=\?([^?]+)\?([QB])\?[^?]*?\?\=/mi
-    FULL_ENCODED_VALUE = /(\=\?[^?]+\?[QB]\?[^?]*?\?\=)/mi
+
+    ENCODED_VALUE = %r{
+      \=\?     # literal =?
+      ([^?]+)  #
+      \?       # literal ?
+      ([QB])   # either a "Q" or a "B"
+      \?       # literal ?
+      .*?      # lazily match all characters
+      \?\=     # literal ?=
+    }mix # m is multi-line, i is case-insensitive, x is free-spacing
+
+    FULL_ENCODED_VALUE = %r{ # Identical to ENCODED_VALUE but captures the whole rather than components of
+      (
+        \=\?    # literal =?
+        [^?]+   #
+        \?      # literal ?
+        [QB]    # either a "Q" or a "B"
+        \?      # literal ?
+        .*?     # lazily match all characters
+        \?\=    # literal ?=
+      )
+    }mix # m is multi-line, i is case-insensitive, x is free-spacing
 
     EMPTY          = ''
     SPACE          = ' '
@@ -43,6 +64,7 @@ module Mail
     HYPHEN         = '-'
     COLON          = ':'
     ASTERISK       = '*'
+    CRLF           = "\r\n"
     CR             = "\r"
     LF             = "\n"
     CR_ENCODED     = "=0D"

data/lib/mail/elements/address.rb

@@ -1,28 +1,28 @@
 # encoding: utf-8
 # frozen_string_literal: true
+require 'mail/parsers/address_lists_parser'
+require 'mail/constants'
+require 'mail/utilities'
+
 module Mail
+  # Mail::Address handles all email addresses in Mail.  It takes an email address string
+  # and parses it, breaking it down into its component parts and allowing you to get the
+  # address, comments, display name, name, local part, domain part and fully formatted
+  # address.
+  #
+  # Mail::Address requires a correctly formatted email address per RFC2822 or RFC822.  It
+  # handles all obsolete versions including obsolete domain routing on the local part.
+  #
+  #  a = Address.new('Mikel Lindsaar (My email address) <mikel@test.lindsaar.net>')
+  #  a.format       #=> 'Mikel Lindsaar <mikel@test.lindsaar.net> (My email address)'
+  #  a.address      #=> 'mikel@test.lindsaar.net'
+  #  a.display_name #=> 'Mikel Lindsaar'
+  #  a.local        #=> 'mikel'
+  #  a.domain       #=> 'test.lindsaar.net'
+  #  a.comments     #=> ['My email address']
+  #  a.to_s         #=> 'Mikel Lindsaar <mikel@test.lindsaar.net> (My email address)'
   class Address
-
-    include Mail::Utilities
-
-    # Mail::Address handles all email addresses in Mail.  It takes an email address string
-    # and parses it, breaking it down into its component parts and allowing you to get the
-    # address, comments, display name, name, local part, domain part and fully formatted
-    # address.
-    #
-    # Mail::Address requires a correctly formatted email address per RFC2822 or RFC822.  It
-    # handles all obsolete versions including obsolete domain routing on the local part.
-    #
-    #  a = Address.new('Mikel Lindsaar (My email address) <mikel@test.lindsaar.net>')
-    #  a.format       #=> 'Mikel Lindsaar <mikel@test.lindsaar.net> (My email address)'
-    #  a.address      #=> 'mikel@test.lindsaar.net'
-    #  a.display_name #=> 'Mikel Lindsaar'
-    #  a.local        #=> 'mikel'
-    #  a.domain       #=> 'test.lindsaar.net'
-    #  a.comments     #=> ['My email address']
-    #  a.to_s         #=> 'Mikel Lindsaar <mikel@test.lindsaar.net> (My email address)'
     def initialize(value = nil)
-      @output_type = :decode
       if value.nil?
         @parsed = false
         @data = nil
@@ -44,14 +44,14 @@ module Mail
     #
     #  a = Address.new('Mikel Lindsaar (My email address) <mikel@test.lindsaar.net>')
     #  a.format #=> 'Mikel Lindsaar <mikel@test.lindsaar.net> (My email address)'
-    def format
+    def format(output_type = :decode)
       parse unless @parsed
       if @data.nil?
-        EMPTY
-      elsif display_name
-        [quote_phrase(display_name), "<#{address}>", format_comments].compact.join(SPACE)
-      elsif address
-        [address, format_comments].compact.join(SPACE)
+        Constants::EMPTY
+      elsif name = display_name(output_type)
+        [Utilities.quote_phrase(name), "<#{address(output_type)}>", format_comments].compact.join(Constants::SPACE)
+      elsif a = address(output_type)
+        [a, format_comments].compact.join(Constants::SPACE)
       else
         raw
       end
@@ -62,9 +62,13 @@ module Mail
     #
     #  a = Address.new('Mikel Lindsaar (My email address) <mikel@test.lindsaar.net>')
     #  a.address #=> 'mikel@test.lindsaar.net'
-    def address
+    def address(output_type = :decode)
       parse unless @parsed
-      domain ? "#{local}@#{domain}" : local
+      if d = domain(output_type)
+        "#{local(output_type)}@#{d}"
+      else
+        local(output_type)
+      end
     end
 
     # Provides a way to assign an address to an already made Mail::Address object.
@@ -80,10 +84,10 @@ module Mail
     #
     #  a = Address.new('Mikel Lindsaar (My email address) <mikel@test.lindsaar.net>')
     #  a.display_name #=> 'Mikel Lindsaar'
-    def display_name
+    def display_name(output_type = :decode)
       parse unless @parsed
       @display_name ||= get_display_name
-      Encodings.decode_encode(@display_name.to_s, @output_type) if @display_name
+      Encodings.decode_encode(@display_name.to_s, output_type) if @display_name
     end
 
     # Provides a way to assign a display name to an already made Mail::Address object.
@@ -93,7 +97,7 @@ module Mail
     #  a.display_name = 'Mikel Lindsaar'
     #  a.format #=> 'Mikel Lindsaar <mikel@test.lindsaar.net>'
     def display_name=( str )
-      @display_name = str.dup # in case frozen
+      @display_name = str.nil? ? nil : str.dup # in case frozen
     end
 
     # Returns the local part (the left hand side of the @ sign in the email address) of
@@ -101,9 +105,9 @@ module Mail
     #
     #  a = Address.new('Mikel Lindsaar (My email address) <mikel@test.lindsaar.net>')
     #  a.local #=> 'mikel'
-    def local
+    def local(output_type = :decode)
       parse unless @parsed
-      Encodings.decode_encode("#{@data.obs_domain_list}#{get_local.strip}", @output_type) if get_local
+      Encodings.decode_encode("#{@data.obs_domain_list}#{get_local.strip}", output_type) if get_local
     end
 
     # Returns the domain part (the right hand side of the @ sign in the email address) of
@@ -111,19 +115,28 @@ module Mail
     #
     #  a = Address.new('Mikel Lindsaar (My email address) <mikel@test.lindsaar.net>')
     #  a.domain #=> 'test.lindsaar.net'
-    def domain
+    def domain(output_type = :decode)
       parse unless @parsed
-      Encodings.decode_encode(strip_all_comments(get_domain), @output_type) if get_domain
+      Encodings.decode_encode(strip_all_comments(get_domain), output_type) if get_domain
     end
 
-    # Returns an array of comments that are in the email, or an empty array if there
+    # Returns an array of comments that are in the email, or nil if there
     # are no comments
     #
     #  a = Address.new('Mikel Lindsaar (My email address) <mikel@test.lindsaar.net>')
     #  a.comments #=> ['My email address']
+    #
+    #  b = Address.new('Mikel Lindsaar <mikel@test.lindsaar.net>')
+    #  b.comments #=> nil
+
     def comments
       parse unless @parsed
-      get_comments.map { |c| c.squeeze(SPACE) } unless get_comments.empty?
+      comments = get_comments
+      if comments.nil? || comments.none?
+        nil
+      else
+        comments.map { |c| c.squeeze(Constants::SPACE) }
+      end
     end
 
     # Sometimes an address will not have a display name, but might have the name
@@ -154,13 +167,11 @@ module Mail
     end
 
     def encoded
-      @output_type = :encode
-      format
+      format :encode
     end
 
     def decoded
-      @output_type = :decode
-      format
+      format :decode
     end
 
     def group
@@ -174,11 +185,11 @@ module Mail
       @data = nil
 
       case value
-      when Mail::Parsers::AddressStruct
+      when Mail::Parsers::AddressListsParser::AddressStruct
         @data = value
       when String
         unless Utilities.blank?(value)
-          address_list = Mail::Parsers::AddressListsParser.new.parse(value)
+          address_list = Mail::Parsers::AddressListsParser.parse(value)
           @data = address_list.addresses.first
         end
       end
@@ -187,7 +198,7 @@ module Mail
     def strip_all_comments(string)
       unless Utilities.blank?(comments)
         comments.each do |comment|
-          string = string.gsub("(#{comment})", EMPTY)
+          string = string.gsub("(#{comment})", Constants::EMPTY)
         end
       end
       string.strip
@@ -197,7 +208,7 @@ module Mail
       unless Utilities.blank?(comments)
         comments.each do |comment|
           if @data.domain && @data.domain.include?("(#{comment})")
-            value = value.gsub("(#{comment})", EMPTY)
+            value = value.gsub("(#{comment})", Constants::EMPTY)
           end
         end
       end
@@ -205,9 +216,9 @@ module Mail
     end
 
     def get_display_name
-      if @data.display_name
+      if @data && @data.display_name
         str = strip_all_comments(@data.display_name.to_s)
-      elsif @data.comments && @data.domain
+      elsif @data && @data.comments && @data.domain
         str = strip_domain_comments(format_comments)
       end
       str unless Utilities.blank?(str)
@@ -217,15 +228,15 @@ module Mail
       if display_name
         str = display_name
       elsif comments
-        str = "(#{comments.join(SPACE).squeeze(SPACE)})"
+        str = "(#{comments.join(Constants::SPACE).squeeze(Constants::SPACE)})"
       end
 
-      unparen(str) unless Utilities.blank?(str)
+      Utilities.unparen(str) unless Utilities.blank?(str)
     end
 
     def format_comments
       if comments
-        comment_text = comments.map {|c| escape_paren(c) }.join(SPACE).squeeze(SPACE)
+        comment_text = comments.map {|c| Utilities.escape_paren(c) }.join(Constants::SPACE).squeeze(Constants::SPACE)
         @format_comments ||= "(#{comment_text})"
       else
         nil