mail 2.6.3 → 2.7.1

data/lib/mail/check_delivery_params.rb

@@ -1,20 +1,60 @@
+# frozen_string_literal: true
 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
+      def check(mail)
+        [ check_from(mail.smtp_envelope_from),
+          check_to(mail.smtp_envelope_to),
+          check_message(mail) ]
       end
 
-      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_from(addr)
+        if Utilities.blank?(addr)
+          raise ArgumentError, "SMTP From address may not be blank: #{addr.inspect}"
+        end
+
+        check_addr 'From', addr
+      end
+
+      def check_to(addrs)
+        if Utilities.blank?(addrs)
+          raise ArgumentError, "SMTP To address may not be blank: #{addrs.inspect}"
+        end
+
+        Array(addrs).map do |addr|
+          check_addr 'To', addr
+        end
       end
 
-      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)
+        validate_smtp_addr addr do |error_message|
+          raise ArgumentError, "SMTP #{addr_name} address #{error_message}: #{addr.inspect}"
+        end
       end
 
-      [mail.smtp_envelope_from, mail.smtp_envelope_to, message]
+      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
+
+        addr
+      end
+
+      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
     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

@@ -1,4 +1,5 @@
 # encoding: us-ascii
+# frozen_string_literal: true
 module Mail
   module Constants
     white_space = %Q|\x9\x20|
@@ -12,10 +13,10 @@ module Mail
     control      = %Q|\x00-\x1f\x7f-\xff|
 
     if control.respond_to?(:force_encoding)
-      control = control.force_encoding(Encoding::BINARY)
+      control = control.dup.force_encoding(Encoding::BINARY)
     end
 
-    CRLF          = /\r\n/
+    CRLF          = /\r?\n/
     WSP           = /[#{white_space}]/
     FWS           = /#{CRLF}#{WSP}*/
     TEXT          = /[#{text}]/ # + obs-text
@@ -33,7 +34,8 @@ 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
+    ENCODED_VALUE = /\=\?([^?]+)\?([QB])\?[^?]*?\?\=/mi
+    FULL_ENCODED_VALUE = /(\=\?[^?]+\?[QB]\?[^?]*?\?\=)/mi
 
     EMPTY          = ''
     SPACE          = ' '

data/lib/mail/core_extensions/smtp.rb

@@ -1,24 +1,28 @@
 # encoding: utf-8
-module Net
-  class SMTP
-    # This is a backport of r30294 from ruby trunk because of a bug in net/smtp.
-    # http://svn.ruby-lang.org/cgi-bin/viewvc.cgi?view=rev&revision=30294
-    #
-    # Fixed in what will be Ruby 1.9.3 - tlsconnect also does not exist in some early versions of ruby
-    begin
-      alias_method :original_tlsconnect, :tlsconnect
+# frozen_string_literal: true
 
-      def tlsconnect(s)
-        verified = false
-        begin
-          original_tlsconnect(s).tap { verified = true }
-        ensure
-          unless verified
-            s.close rescue nil
+# This is a backport of r30294 from ruby trunk because of a bug in net/smtp.
+# http://svn.ruby-lang.org/cgi-bin/viewvc.cgi?view=rev&revision=30294
+#
+# Fixed in Ruby 1.9.3 - tlsconnect also does not exist in some early versions of ruby
+if RUBY_VERSION < '1.9.3'
+  module Net
+    class SMTP
+      begin
+        alias_method :original_tlsconnect, :tlsconnect
+
+        def tlsconnect(s)
+          verified = false
+          begin
+            original_tlsconnect(s).tap { verified = true }
+          ensure
+            unless verified
+              s.close rescue nil
+            end
           end
         end
+      rescue NameError
       end
-    rescue NameError
     end
   end
 end

data/lib/mail/core_extensions/string.rb

@@ -1,32 +1,7 @@
 # encoding: utf-8
+# frozen_string_literal: true
 class String #:nodoc:
 
-  CRLF = "\r\n"
-  LF   = "\n"
-
-  if RUBY_VERSION >= '1.9'
-    # This 1.9 only regex can save a reasonable amount of time (~20%)
-    # by not matching "\r\n" so the string is returned unchanged in
-    # the common case.
-    CRLF_REGEX = Regexp.new("(?<!\r)\n|\r(?!\n)")
-  else
-    CRLF_REGEX = /\n|\r\n|\r/
-  end
-
-  def to_crlf
-    to_str.gsub(CRLF_REGEX, CRLF)
-  end
-
-  def to_lf
-    to_str.gsub(/\r\n|\r/, LF)
-  end
-
-  unless String.instance_methods(false).map {|m| m.to_sym}.include?(:blank?)
-    def blank?
-      self !~ /\S/
-    end
-  end
-
   unless method_defined?(:ascii_only?)
     # Backport from Ruby 1.9 checks for non-us-ascii characters.
     def ascii_only?
@@ -36,10 +11,6 @@ class String #:nodoc:
     MATCH_NON_US_ASCII = /[^\x00-\x7f]/
   end
 
-  def not_ascii_only?
-    !ascii_only?
-  end
-
   unless method_defined?(:bytesize)
     alias :bytesize :length
   end

data/lib/mail/elements/address.rb

@@ -1,7 +1,9 @@
 # encoding: utf-8
+# frozen_string_literal: true
+require 'mail/parsers/address_lists_parser'
+
 module Mail
   class Address
-
     include Mail::Utilities
 
     # Mail::Address handles all email addresses in Mail.  It takes an email address string
@@ -21,7 +23,6 @@ module Mail
     #  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
@@ -43,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)
+      elsif name = display_name(output_type)
+        [quote_phrase(name), "<#{address(output_type)}>", format_comments].compact.join(SPACE)
+      elsif a = address(output_type)
+        [a, format_comments].compact.join(SPACE)
       else
         raw
       end
@@ -61,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.
@@ -79,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.
@@ -92,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
+      @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
@@ -100,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
-      "#{@data.obs_domain_list}#{get_local.strip}" 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
@@ -110,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
-      strip_all_comments(get_domain) 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(SPACE) }
+      end
     end
 
     # Sometimes an address will not have a display name, but might have the name
@@ -153,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
@@ -173,18 +185,18 @@ module Mail
       @data = nil
 
       case value
-      when Mail::Parsers::AddressStruct
+      when Mail::Parsers::AddressListsParser::AddressStruct
         @data = value
       when String
-        unless value.blank?
-          address_list = Mail::Parsers::AddressListsParser.new.parse(value)
+        unless Utilities.blank?(value)
+          address_list = Mail::Parsers::AddressListsParser.parse(value)
           @data = address_list.addresses.first
         end
       end
     end
 
     def strip_all_comments(string)
-      unless comments.blank?
+      unless Utilities.blank?(comments)
         comments.each do |comment|
           string = string.gsub("(#{comment})", EMPTY)
         end
@@ -193,7 +205,7 @@ module Mail
     end
 
     def strip_domain_comments(value)
-      unless comments.blank?
+      unless Utilities.blank?(comments)
         comments.each do |comment|
           if @data.domain && @data.domain.include?("(#{comment})")
             value = value.gsub("(#{comment})", EMPTY)
@@ -204,13 +216,12 @@ 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 str.blank?
+      str unless Utilities.blank?(str)
     end
 
     def get_name
@@ -220,7 +231,7 @@ module Mail
         str = "(#{comments.join(SPACE).squeeze(SPACE)})"
       end
 
-      unparen(str) unless str.blank?
+      unparen(str) unless Utilities.blank?(str)
     end
 
     def format_comments

data/lib/mail/elements/address_list.rb

@@ -1,41 +1,34 @@
 # encoding: utf-8
+# frozen_string_literal: true
+require 'mail/parsers/address_lists_parser'
+
 module Mail
   class AddressList # :nodoc:
+    attr_reader :addresses, :group_names
 
     # Mail::AddressList is the class that parses To, From and other address fields from
     # emails passed into Mail.
-    # 
+    #
     # AddressList provides a way to query the groups and mailbox lists of the passed in
     # string.
-    # 
+    #
     # It can supply all addresses in an array, or return each address as an address object.
-    # 
+    #
     # Mail::AddressList requires a correctly formatted group or mailbox list per RFC2822 or
     # RFC822.  It also handles all obsolete versions in those RFCs.
-    # 
+    #
     #  list = 'ada@test.lindsaar.net, My Group: mikel@test.lindsaar.net, Bob <bob@test.lindsaar.net>;'
     #  a = AddressList.new(list)
     #  a.addresses    #=> [#<Mail::Address:14943130 Address: |ada@test.lindsaar.net...
     #  a.group_names  #=> ["My Group"]
     def initialize(string)
-      @addresses_grouped_by_group = nil
-      @address_list = Parsers::AddressListsParser.new.parse(string)
-    end
-    
-    # Returns a list of address objects from the parsed line
-    def addresses
-      @addresses ||= @address_list.addresses.map do |address_data|
-        Mail::Address.new(address_data)
-      end
+      address_list = Parsers::AddressListsParser.parse(string)
+      @addresses = address_list.addresses.map { |a| Address.new(a) }
+      @group_names = address_list.group_names
     end
 
     def addresses_grouped_by_group
       addresses.select(&:group).group_by(&:group)
     end
-    
-    # Returns the names as an array of strings of all groups
-    def group_names # :nodoc:
-      @address_list.group_names
-    end
   end
 end

data/lib/mail/elements/content_disposition_element.rb

@@ -1,26 +1,20 @@
 # encoding: utf-8
+# frozen_string_literal: true
+require 'mail/parsers/content_disposition_parser'
+
 module Mail
   class ContentDispositionElement # :nodoc:
-    
-    include Mail::Utilities
-    
-    def initialize( string )
-      content_disposition = Mail::Parsers::ContentDispositionParser.new.parse(cleaned(string))
+    attr_reader :disposition_type, :parameters
+
+    def initialize(string)
+      content_disposition = Mail::Parsers::ContentDispositionParser.parse(cleaned(string))
       @disposition_type = content_disposition.disposition_type
       @parameters = content_disposition.parameters
     end
-    
-    def disposition_type
-      @disposition_type
-    end
-    
-    def parameters
-      @parameters
-    end
-    
+
+    private
     def cleaned(string)
       string =~ /(.+);\s*$/ ? $1 : string
     end
-    
   end
 end

data/lib/mail/elements/content_location_element.rb

@@ -1,21 +1,17 @@
 # encoding: utf-8
+# frozen_string_literal: true
+require 'mail/parsers/content_location_parser'
+
 module Mail
   class ContentLocationElement # :nodoc:
-    
-    include Mail::Utilities
-    
-    def initialize( string )
-      content_location = Mail::Parsers::ContentLocationParser.new.parse(string)
-      @location = content_location.location
+    attr_reader :location
+
+    def initialize(string)
+      @location = Mail::Parsers::ContentLocationParser.parse(string).location
     end
-    
-    def location
-      @location
-    end
-    
+
     def to_s(*args)
       location.to_s
     end
-    
   end
 end

data/lib/mail/elements/content_transfer_encoding_element.rb

@@ -1,17 +1,13 @@
 # encoding: utf-8
+# frozen_string_literal: true
+require 'mail/parsers/content_transfer_encoding_parser'
+
 module Mail
   class ContentTransferEncodingElement
-    
-    include Mail::Utilities
-    
+    attr_reader :encoding
+
     def initialize(string)
-      content_transfer_encoding = Mail::Parsers::ContentTransferEncodingParser.new.parse(string)
-      @encoding = content_transfer_encoding.encoding
+      @encoding = Mail::Parsers::ContentTransferEncodingParser.parse(string).encoding
     end
-    
-    def encoding
-      @encoding
-    end
-    
   end
 end

data/lib/mail/elements/content_type_element.rb

@@ -1,31 +1,21 @@
 # encoding: utf-8
+# frozen_string_literal: true
+require 'mail/parsers/content_type_parser'
+
 module Mail
   class ContentTypeElement # :nodoc:
-    
-    include Mail::Utilities
-    
-    def initialize( string )
-      content_type = Mail::Parsers::ContentTypeParser.new.parse(cleaned(string))
+    attr_reader :main_type, :sub_type, :parameters
+
+    def initialize(string)
+      content_type = Mail::Parsers::ContentTypeParser.parse(cleaned(string))
       @main_type = content_type.main_type
       @sub_type = content_type.sub_type
       @parameters = content_type.parameters
     end
-    
-    def main_type
-      @main_type
-    end
-    
-    def sub_type
-      @sub_type
-    end
-    
-    def parameters
-      @parameters
-    end
-    
+
+    private
     def cleaned(string)
       string =~ /(.+);\s*$/ ? $1 : string
     end
-    
   end
 end

data/lib/mail/elements/date_time_element.rb

@@ -1,22 +1,15 @@
 # encoding: utf-8
+# frozen_string_literal: true
+require 'mail/parsers/date_time_parser'
+
 module Mail
   class DateTimeElement # :nodoc:
-    
-    include Mail::Utilities
-    
-    def initialize( string )
-      date_time = Mail::Parsers::DateTimeParser.new.parse(string)
+    attr_reader :date_string, :time_string
+
+    def initialize(string)
+      date_time = Mail::Parsers::DateTimeParser.parse(string)
       @date_string = date_time.date_string
       @time_string = date_time.time_string
     end
-    
-    def date_string
-      @date_string
-    end
-    
-    def time_string
-      @time_string
-    end
-    
   end
 end

data/lib/mail/elements/envelope_from_element.rb

@@ -1,39 +1,33 @@
 # encoding: utf-8
+# frozen_string_literal: true
+require 'mail/parsers/envelope_from_parser'
+require 'date'
+
 module Mail
   class EnvelopeFromElement
-    
-    include Mail::Utilities
-    
-    def initialize( string )
-      @envelope_from = Mail::Parsers::EnvelopeFromParser.new.parse(string)
-      @address = @envelope_from.address
-      @date_time = ::DateTime.parse(@envelope_from.ctime_date)
-    end
-    
-    def date_time
-      @date_time
-    end
-    
-    def address
-      @address
+    attr_reader :date_time, :address
+
+    def initialize(string)
+      envelope_from = Mail::Parsers::EnvelopeFromParser.parse(string)
+      @address = envelope_from.address
+      @date_time = ::DateTime.parse(envelope_from.ctime_date)
     end
-    
+
     # RFC 4155:
     #   a timestamp indicating the UTC date and time when the message
     #   was originally received, conformant with the syntax of the
     #   traditional UNIX 'ctime' output sans timezone (note that the
     #   use of UTC precludes the need for a timezone indicator);
     def formatted_date_time
-      if @date_time.respond_to?(:ctime)
-        @date_time.ctime
+      if date_time.respond_to?(:ctime)
+        date_time.ctime
       else
-        @date_time.strftime '%a %b %e %T %Y'
+        date_time.strftime '%a %b %e %T %Y'
       end
     end
 
     def to_s
-      "#{@address} #{formatted_date_time}"
+      "#{address} #{formatted_date_time}"
     end
-    
   end
 end