mail 2.6.1 → 2.8.1

data/lib/mail/body.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 module Mail
   
   # = Body
@@ -31,24 +32,29 @@ 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 string.blank?
+      if Utilities.blank?(string)
         @raw_source = ''
       else
         # Do join first incase we have been given an Array in Ruby 1.9
         if string.respond_to?(:join)
-          @raw_source = string.join('')
+          @raw_source = ::Mail::Utilities.to_crlf(string.join(''))
         elsif string.respond_to?(:to_s)
-          @raw_source = string.to_s
+          @raw_source = ::Mail::Utilities.to_crlf(string.to_s)
         else
           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.
     # 
@@ -114,8 +120,8 @@ 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
@@ -132,46 +138,44 @@ module Mail
       @parts.sort!(@part_sort_order)
     end
     
-    # Returns the raw source that the body was initialized with, without
-    # any tampering
-    def raw_source
-      @raw_source
+    def negotiate_best_encoding(message_encoding, allowed_encodings = nil)
+      Mail::Encodings::TransferEncoding.negotiate(message_encoding, encoding, raw_source, allowed_encodings)
     end
-   
-    def get_best_encoding(target)
-      target_encoding = Mail::Encodings.get_encoding(target)
-      target_encoding.get_best_compatible(encoding, raw_source)
-    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)
-        if transfer_encoding == encoding and dec.nil?
-            # Cannot decode, so skip normalization
-            raw_source
+        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
         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."
@@ -183,14 +187,6 @@ module Mail
     def to_s
       decoded
     end
-    
-    def charset
-      @charset
-    end
-    
-    def charset=( val )
-      @charset = val
-    end
 
     def encoding(val = nil)
       if val
@@ -199,54 +195,41 @@ module Mail
         @encoding
       end
     end
-    
+
     def encoding=( val )
-      @encoding = if val == "text" || val.blank?
-          (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
@@ -254,27 +237,58 @@ module Mail
         @parts = Mail::PartsList.new[val]
       end
     end
-    
+
     def split!(boundary)
       self.boundary = boundary
-      parts = raw_source.split(/(?:\A|\r\n)--#{Regexp.escape(boundary || "")}(?=(?:--)?\s*$)/)
+      parts = extract_parts
+
       # Make the preamble equal to the preamble (if any)
       self.preamble = parts[0].to_s.strip
       # Make the epilogue equal to the epilogue (if any)
-      self.epilogue = parts[-1].to_s.sub('--', '').strip
+      self.epilogue = parts[-1].to_s.strip
       parts[1...-1].to_a.each { |part| @parts << Mail::Part.new(part) }
       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
+    def extract_parts
+      parts_regex = /
+        (?:                    # non-capturing group
+          \A                |  # start of string OR
+          \r\n                 # line break
+         )
+        (
+          --#{Regexp.escape(boundary || "")}  # boundary delimiter
+          (?:--)?                             # with non-capturing optional closing
+        )
+        (?=\s*$)                              # lookahead matching zero or more spaces followed by line-ending
+      /x
+      parts = raw_source.split(parts_regex).each_slice(2).to_a
+      parts.each_with_index { |(part, _), index| parts.delete_at(index) if index > 0 && Utilities.blank?(part) }
+
+      if parts.size > 1
+        final_separator = parts[-2][1]
+        parts << [""] if final_separator != "--#{boundary}--"
+      end
+      parts.map(&:first)
+    end
     
     def crlf_boundary
       "\r\n--#{boundary}\r\n"
@@ -283,9 +297,9 @@ module Mail
     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/check_delivery_params.rb

@@ -1,20 +1,65 @@
+# frozen_string_literal: true
+#
+# This whole class and associated specs is deprecated and will go away in the version 3 release of mail.
 module Mail
-  module CheckDeliveryParams
-    def check_delivery_params(mail)
-      if mail.smtp_envelope_from.blank?
-        raise ArgumentError.new('An SMTP From address is required to send a message. Set the message smtp_envelope_from, return_path, sender, or from address.')
+  module CheckDeliveryParams #:nodoc:
+    class << self
+
+      extend Gem::Deprecate
+
+      def check(mail)
+        envelope = Mail::SmtpEnvelope.new(mail)
+        [ envelope.from,
+          envelope.to,
+          envelope.message ]
+      end
+      deprecate :check, 'Mail::SmtpEnvelope.new created in commit c106bebea066782a72e4f24dd37b532d95773df7', 2023, 6
+
+      def check_from(addr)
+        mail = Mail.new(from: 'deprecated@example.com', to: 'deprecated@example.com')
+        Mail::SmtpEnvelope.new(mail).send(:validate_addr, 'From', addr)
       end
+      deprecate :check_from, :none, 2023, 6
 
-      if mail.smtp_envelope_to.blank?
-        raise ArgumentError.new('An SMTP To address is required to send a message. Set the message smtp_envelope_to, to, cc, or bcc address.')
+      def check_to(addrs)
+        mail = Mail.new(from: 'deprecated@example.com', to: 'deprecated@example.com')
+        Array(addrs).map do |addr|
+          Mail::SmtpEnvelope.new(mail).send(:validate_addr, 'To', addr)
+        end
       end
+      deprecate :check_to, :none, 2023, 6
 
-      message = mail.encoded if mail.respond_to?(:encoded)
-      if message.blank?
-        raise ArgumentError.new('An encoded message is required to send an email')
+      def check_addr(addr_name, addr)
+        mail = Mail.new(from: 'deprecated@example.com', to: 'deprecated@example.com')
+        Mail::SmtpEnvelope.new(mail).send(:validate_addr, addr_name, addr)
       end
+      deprecate :check_addr, :none, 2023, 6
+
+      def validate_smtp_addr(addr)
+        if addr
+          if addr.bytesize > 2048
+            yield 'may not exceed 2kB'
+          end
+
+          if /[\r\n]/ =~ addr
+            yield 'may not contain CR or LF line breaks'
+          end
+        end
 
-      [mail.smtp_envelope_from, mail.smtp_envelope_to, message]
+        addr
+      end
+      deprecate :validate_smtp_addr, :none, 2023, 6
+
+      def check_message(message)
+        message = message.encoded if message.respond_to?(:encoded)
+
+        if Utilities.blank?(message)
+          raise ArgumentError, 'An encoded message is required to send an email'
+        end
+
+        message
+      end
+      deprecate :check_message, :none, 2023, 6
     end
   end
 end

data/lib/mail/configuration.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 #
 # Thanks to Nicolas Fouché for this wrapper
 #
@@ -41,6 +42,8 @@ module Mail
         Mail::SMTPConnection
       when :test
         Mail::TestMailer
+      when :logger
+        Mail::LoggerDelivery
       else
         method
       end

data/lib/mail/constants.rb

@@ -0,0 +1,79 @@
+# encoding: us-ascii
+# frozen_string_literal: true
+module Mail
+  module Constants
+    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
+    sp           = %Q| |
+    control      = %Q|\x00-\x1f\x7f-\xff|
+
+    if control.respond_to?(:force_encoding)
+      control = control.dup.force_encoding(Encoding::BINARY)
+    end
+
+    LAX_CRLF      = /\r?\n/
+    WSP           = /[#{white_space}]/
+    FWS           = /#{LAX_CRLF}#{WSP}*/
+    UNFOLD_WS     = /#{LAX_CRLF}(#{WSP})/m
+    TEXT          = /[#{text}]/ # + obs-text
+    FIELD_NAME    = /[#{field_name}]+/
+    FIELD_PREFIX  = /\A(#{FIELD_NAME})/
+    FIELD_BODY    = /.+/m
+    FIELD_LINE    = /^[#{field_name}]+:\s*.+$/
+    FIELD_SPLIT   = /^(#{FIELD_NAME})\s*:\s*(#{FIELD_BODY})?$/
+    HEADER_LINE   = /^([#{field_name}]+:\s*.+)$/
+    HEADER_SPLIT  = /#{LAX_CRLF}(?!#{WSP})/
+
+    QP_UNSAFE     = /[^#{qp_safe}]/
+    QP_SAFE       = /[#{qp_safe}]/
+    CONTROL_CHAR  = /[#{control}]/n
+    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 = %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          = ' '
+    UNDERSCORE     = '_'
+    HYPHEN         = '-'
+    COLON          = ':'
+    ASTERISK       = '*'
+    CRLF           = "\r\n"
+    CR             = "\r"
+    LF             = "\n"
+    CR_ENCODED     = "=0D"
+    LF_ENCODED     = "=0A"
+    CAPITAL_M      = 'M'
+    EQUAL_LF       = "=\n"
+    NULL_SENDER    = '<>'
+
+    Q_VALUES       = ['Q','q']
+    B_VALUES       = ['B','b']
+  end
+end