mail 2.6.1 → 2.8.1

data/lib/mail/field_list.rb

@@ -1,12 +1,41 @@
 # encoding: utf-8
+# frozen_string_literal: true
 module Mail
 
   # Field List class provides an enhanced array that keeps a list of 
   # email fields in order.  And allows you to insert new fields without
   # having to worry about the order they will appear in.
   class FieldList < Array
+    def has_field?(field_name)
+      any? { |f| f.responsible_for? field_name }
+    end
+
+    def get_field(field_name)
+      fields = select_fields(field_name)
+      case fields.size
+      when 0; nil
+      when 1; fields.first
+      else fields
+      end
+    end
 
-    include Enumerable
+    def add_field(field)
+      if field.singular?
+        replace_field field
+      else
+        insert_field field
+      end
+    end
+    alias_method :<<, :add_field
+
+    def replace_field(field)
+      if first_offset = index { |f| f.responsible_for? field.name }
+        delete_field field.name
+        insert first_offset, field
+      else
+        insert_field field
+      end
+    end
 
     # Insert the field in sorted order.
     #
@@ -14,20 +43,45 @@ module Mail
     #   Copyright (C) 2001-2013 Python Software Foundation.
     #   Licensed under <http://docs.python.org/license.html>
     #   From <http://hg.python.org/cpython/file/2.7/Lib/bisect.py>
-    def <<( new_field )
-      lo = 0
-      hi = size
-
+    def insert_field(field)
+      lo, hi = 0, size
       while lo < hi
-        mid = (lo + hi) / 2
-        if new_field < self[mid]
+        mid = (lo + hi).div(2)
+        if field < self[mid]
           hi = mid
         else
           lo = mid + 1
         end
       end
 
-      insert(lo, new_field)
+      insert lo, field
+    end
+
+    def delete_field(name)
+      delete_if { |f| f.responsible_for? name }
+    end
+
+    def summary
+      map { |f| "<#{f.name}: #{f.value}>" }.join(", ")
+    end
+
+    private
+
+    def select_fields(field_name)
+      fields = select { |f| f.responsible_for? field_name }
+      if fields.size > 1 && singular?(field_name)
+        Array(fields.detect { |f| f.errors.size == 0 } || fields.first)
+      else
+        fields
+      end
+    end
+
+    def singular?(field_name)
+      if klass = Mail::Field.field_class_for(field_name)
+        klass.singular?
+      else
+        false
+      end
     end
   end
 end

data/lib/mail/fields/bcc_field.rb

@@ -1,56 +1,50 @@
 # encoding: utf-8
-# 
-# = Blind Carbon Copy Field
-# 
-# The Bcc field inherits from StructuredField and handles the Bcc: header
-# field in the email.
-# 
-# Sending bcc to a mail message will instantiate a Mail::Field object that
-# has a BccField as its field type.  This includes all Mail::CommonAddress
-# module instance metods.
-# 
-# Only one Bcc field can appear in a header, though it can have multiple
-# addresses and groups of addresses.
-# 
-# == Examples:
-# 
-#  mail = Mail.new
-#  mail.bcc = 'Mikel Lindsaar <mikel@test.lindsaar.net>, ada@test.lindsaar.net'
-#  mail.bcc    #=> ['mikel@test.lindsaar.net', 'ada@test.lindsaar.net']
-#  mail[:bcc]  #=> '#<Mail::Field:0x180e5e8 @field=#<Mail::BccField:0x180e1c4
-#  mail['bcc'] #=> '#<Mail::Field:0x180e5e8 @field=#<Mail::BccField:0x180e1c4
-#  mail['Bcc'] #=> '#<Mail::Field:0x180e5e8 @field=#<Mail::BccField:0x180e1c4
-# 
-#  mail[:bcc].encoded   #=> ''      # Bcc field does not get output into an email
-#  mail[:bcc].decoded   #=> 'Mikel Lindsaar <mikel@test.lindsaar.net>, ada@test.lindsaar.net'
-#  mail[:bcc].addresses #=> ['mikel@test.lindsaar.net', 'ada@test.lindsaar.net']
-#  mail[:bcc].formatted #=> ['Mikel Lindsaar <mikel@test.lindsaar.net>', 'ada@test.lindsaar.net']
-# 
-require 'mail/fields/common/common_address'
+# frozen_string_literal: true
+require 'mail/fields/common_address_field'
 
 module Mail
-  class BccField < StructuredField
-    
-    include Mail::CommonAddress
-    
-    FIELD_NAME = 'bcc'
-    CAPITALIZED_FIELD = 'Bcc'
-    
-    def initialize(value = '', charset = 'utf-8')
-      @charset = charset
-      super(CAPITALIZED_FIELD, strip_field(FIELD_NAME, value), charset)
-      self.parse
-      self
+  # = Blind Carbon Copy Field
+  #
+  # The Bcc field inherits from StructuredField and handles the Bcc: header
+  # field in the email.
+  #
+  # Sending bcc to a mail message will instantiate a Mail::Field object that
+  # has a BccField as its field type.  This includes all Mail::CommonAddress
+  # module instance metods.
+  #
+  # Only one Bcc field can appear in a header, though it can have multiple
+  # addresses and groups of addresses.
+  #
+  # == Examples:
+  #
+  #  mail = Mail.new
+  #  mail.bcc = 'Mikel Lindsaar <mikel@test.lindsaar.net>, ada@test.lindsaar.net'
+  #  mail.bcc    #=> ['mikel@test.lindsaar.net', 'ada@test.lindsaar.net']
+  #  mail[:bcc]  #=> '#<Mail::Field:0x180e5e8 @field=#<Mail::BccField:0x180e1c4
+  #  mail['bcc'] #=> '#<Mail::Field:0x180e5e8 @field=#<Mail::BccField:0x180e1c4
+  #  mail['Bcc'] #=> '#<Mail::Field:0x180e5e8 @field=#<Mail::BccField:0x180e1c4
+  #
+  #  mail[:bcc].encoded   #=> ''      # Bcc field does not get output into an email
+  #  mail[:bcc].decoded   #=> 'Mikel Lindsaar <mikel@test.lindsaar.net>, ada@test.lindsaar.net'
+  #  mail[:bcc].addresses #=> ['mikel@test.lindsaar.net', 'ada@test.lindsaar.net']
+  #  mail[:bcc].formatted #=> ['Mikel Lindsaar <mikel@test.lindsaar.net>', 'ada@test.lindsaar.net']
+  class BccField < CommonAddressField #:nodoc:
+    NAME = 'Bcc'
+
+    attr_accessor :include_in_headers
+
+    def initialize(value = nil, charset = nil)
+      super
+      self.include_in_headers = false
     end
-    
-    # Bcc field should never be :encoded
+
+    # Bcc field should not be :encoded by default
     def encoded
-      ''
-    end
-    
-    def decoded
-      do_decode
+      if include_in_headers
+        super
+      else
+        ''
+      end
     end
-    
   end
 end

data/lib/mail/fields/cc_field.rb

@@ -1,55 +1,34 @@
 # encoding: utf-8
-# 
-# = Carbon Copy Field
-# 
-# The Cc field inherits from StructuredField and handles the Cc: header
-# field in the email.
-# 
-# Sending cc to a mail message will instantiate a Mail::Field object that
-# has a CcField as its field type.  This includes all Mail::CommonAddress
-# module instance metods.
-# 
-# Only one Cc field can appear in a header, though it can have multiple
-# addresses and groups of addresses.
-# 
-# == Examples:
-# 
-#  mail = Mail.new
-#  mail.cc = 'Mikel Lindsaar <mikel@test.lindsaar.net>, ada@test.lindsaar.net'
-#  mail.cc    #=> ['mikel@test.lindsaar.net', 'ada@test.lindsaar.net']
-#  mail[:cc]  #=> '#<Mail::Field:0x180e5e8 @field=#<Mail::CcField:0x180e1c4
-#  mail['cc'] #=> '#<Mail::Field:0x180e5e8 @field=#<Mail::CcField:0x180e1c4
-#  mail['Cc'] #=> '#<Mail::Field:0x180e5e8 @field=#<Mail::CcField:0x180e1c4
-# 
-#  mail[:cc].encoded   #=> 'Cc: Mikel Lindsaar <mikel@test.lindsaar.net>, ada@test.lindsaar.net\r\n'
-#  mail[:cc].decoded   #=> 'Mikel Lindsaar <mikel@test.lindsaar.net>, ada@test.lindsaar.net'
-#  mail[:cc].addresses #=> ['mikel@test.lindsaar.net', 'ada@test.lindsaar.net']
-#  mail[:cc].formatted #=> ['Mikel Lindsaar <mikel@test.lindsaar.net>', 'ada@test.lindsaar.net']
-# 
-require 'mail/fields/common/common_address'
+# frozen_string_literal: true
+require 'mail/fields/common_address_field'
 
 module Mail
-  class CcField < StructuredField
-    
-    include Mail::CommonAddress
-    
-    FIELD_NAME = 'cc'
-    CAPITALIZED_FIELD = 'Cc'
-    
-    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
-    
+  # = Carbon Copy Field
+  #
+  # The Cc field inherits from StructuredField and handles the Cc: header
+  # field in the email.
+  #
+  # Sending cc to a mail message will instantiate a Mail::Field object that
+  # has a CcField as its field type.  This includes all Mail::CommonAddress
+  # module instance metods.
+  #
+  # Only one Cc field can appear in a header, though it can have multiple
+  # addresses and groups of addresses.
+  #
+  # == Examples:
+  #
+  #  mail = Mail.new
+  #  mail.cc = 'Mikel Lindsaar <mikel@test.lindsaar.net>, ada@test.lindsaar.net'
+  #  mail.cc    #=> ['mikel@test.lindsaar.net', 'ada@test.lindsaar.net']
+  #  mail[:cc]  #=> '#<Mail::Field:0x180e5e8 @field=#<Mail::CcField:0x180e1c4
+  #  mail['cc'] #=> '#<Mail::Field:0x180e5e8 @field=#<Mail::CcField:0x180e1c4
+  #  mail['Cc'] #=> '#<Mail::Field:0x180e5e8 @field=#<Mail::CcField:0x180e1c4
+  #
+  #  mail[:cc].encoded   #=> 'Cc: Mikel Lindsaar <mikel@test.lindsaar.net>, ada@test.lindsaar.net\r\n'
+  #  mail[:cc].decoded   #=> 'Mikel Lindsaar <mikel@test.lindsaar.net>, ada@test.lindsaar.net'
+  #  mail[:cc].addresses #=> ['mikel@test.lindsaar.net', 'ada@test.lindsaar.net']
+  #  mail[:cc].formatted #=> ['Mikel Lindsaar <mikel@test.lindsaar.net>', 'ada@test.lindsaar.net']
+  class CcField < CommonAddressField #:nodoc:
+    NAME = 'Cc'
   end
 end

data/lib/mail/fields/comments_field.rb

@@ -1,41 +1,32 @@
 # encoding: utf-8
-# 
-# = Comments Field
-# 
-# The Comments field inherits from UnstructuredField and handles the Comments:
-# header field in the email.
-# 
-# Sending comments to a mail message will instantiate a Mail::Field object that
-# has a CommentsField as its field type.
-#  
-# An email header can have as many comments fields as it wants.  There is no upper
-# limit, the comments field is also optional (that is, no comment is needed)
-# 
-# == Examples:
-# 
-#  mail = Mail.new
-#  mail.comments = 'This is a comment'
-#  mail.comments    #=> 'This is a comment'
-#  mail[:comments]  #=> '#<Mail::Field:0x180e5e8 @field=#<Mail::CommentsField:0x180e1c4
-#  mail['comments'] #=> '#<Mail::Field:0x180e5e8 @field=#<Mail::CommentsField:0x180e1c4
-#  mail['comments'] #=> '#<Mail::Field:0x180e5e8 @field=#<Mail::CommentsField:0x180e1c4
-# 
-#  mail.comments = "This is another comment"
-#  mail[:comments].map { |c| c.to_s } 
-#  #=> ['This is a comment', "This is another comment"]
-#
+# frozen_string_literal: true
+require 'mail/fields/named_unstructured_field'
+
 module Mail
-  class CommentsField < UnstructuredField
-    
-    FIELD_NAME = 'comments'
-    CAPITALIZED_FIELD = 'Comments'
-    
-    def initialize(value = nil, charset = 'utf-8')
-      @charset = charset
-      super(CAPITALIZED_FIELD, strip_field(FIELD_NAME, value))
-      self.parse
-      self
-    end
-    
+  # = Comments Field
+  #
+  # The Comments field inherits from UnstructuredField and handles the Comments:
+  # header field in the email.
+  #
+  # Sending comments to a mail message will instantiate a Mail::Field object that
+  # has a CommentsField as its field type.
+  #
+  # An email header can have as many comments fields as it wants.  There is no upper
+  # limit, the comments field is also optional (that is, no comment is needed)
+  #
+  # == Examples:
+  #
+  #  mail = Mail.new
+  #  mail.comments = 'This is a comment'
+  #  mail.comments    #=> 'This is a comment'
+  #  mail[:comments]  #=> '#<Mail::Field:0x180e5e8 @field=#<Mail::CommentsField:0x180e1c4
+  #  mail['comments'] #=> '#<Mail::Field:0x180e5e8 @field=#<Mail::CommentsField:0x180e1c4
+  #  mail['comments'] #=> '#<Mail::Field:0x180e5e8 @field=#<Mail::CommentsField:0x180e1c4
+  #
+  #  mail.comments = "This is another comment"
+  #  mail[:comments].map { |c| c.to_s }
+  #  #=> ['This is a comment', "This is another comment"]
+  class CommentsField < NamedUnstructuredField #:nodoc:
+    NAME = 'Comments'
   end
 end

data/lib/mail/fields/common_address_field.rb

@@ -0,0 +1,170 @@
+# encoding: utf-8
+# frozen_string_literal: true
+require 'mail/fields/named_structured_field'
+
+module Mail
+  class AddressContainer < Array #:nodoc:
+    def initialize(field, list = nil)
+      @field = field
+      super list if list
+    end
+
+    def <<(address)
+      @field << address
+    end
+  end
+
+  class CommonAddressField < NamedStructuredField #:nodoc:
+    def self.singular?
+      true
+    end
+
+    def initialize(value = nil, charset = nil)
+      super encode_if_needed(value, charset), charset
+    end
+
+    def element # :nodoc:
+      @element ||= AddressList.new(value)
+    end
+
+    # Allows you to iterate through each address object in the address_list
+    def each
+      element.addresses.each do |address|
+        yield(address)
+      end
+    end
+
+    def default
+      addresses
+    end
+
+    def address
+      addresses.first
+    end
+
+    # Returns the address string of all the addresses in the address list
+    def addresses
+      list = element.addresses.map { |a| a.address }
+      Mail::AddressContainer.new(self, list)
+    end
+
+    # Returns the formatted string of all the addresses in the address list
+    def formatted
+      list = element.addresses.map { |a| a.format }
+      Mail::AddressContainer.new(self, list)
+    end
+
+    # Returns the display name of all the addresses in the address list
+    def display_names
+      list = element.addresses.map { |a| a.display_name }
+      Mail::AddressContainer.new(self, list)
+    end
+
+    # Returns the actual address objects in the address list
+    def addrs
+      list = element.addresses
+      Mail::AddressContainer.new(self, list)
+    end
+
+    # Returns a hash of group name => address strings for the address list
+    def groups
+      element.addresses_grouped_by_group
+    end
+
+    # Returns the addresses that are part of groups
+    def group_addresses
+      decoded_group_addresses
+    end
+
+    # Returns a list of decoded group addresses
+    def decoded_group_addresses
+      groups.map { |k,v| v.map { |a| a.decoded } }.flatten
+    end
+
+    # Returns a list of encoded group addresses
+    def encoded_group_addresses
+      groups.map { |k,v| v.map { |a| a.encoded } }.flatten
+    end
+
+    # Returns the name of all the groups in a string
+    def group_names # :nodoc:
+      element.group_names
+    end
+
+    def <<(val)
+      case
+      when val.nil?
+        raise ArgumentError, "Need to pass an address to <<"
+      when Utilities.blank?(val)
+        self
+      else
+        self.value = [self.value, encode_if_needed(val)].reject { |a| Utilities.blank?(a) }.join(", ")
+      end
+    end
+
+    def encode_if_needed(val, val_charset = charset) #:nodoc:
+      case val
+      when nil
+        val
+
+      # Need to join arrays of addresses into a single value
+      when Array
+        val.compact.map { |a| encode_if_needed a, val_charset }.join(', ')
+
+      # Pass through UTF-8; encode non-UTF-8.
+      else
+        utf8_if_needed(val, val_charset) || Encodings.encode_non_usascii(val, val_charset)
+      end
+    end
+
+    private
+      if 'string'.respond_to?(:encoding)
+        # Pass through UTF-8 addresses
+        def utf8_if_needed(val, val_charset)
+          if val_charset =~ /\AUTF-?8\z/i
+            val
+          elsif val.encoding == Encoding::UTF_8
+            val
+          elsif (utf8 = val.dup.force_encoding(Encoding::UTF_8)).valid_encoding?
+            utf8
+          end
+        end
+      else
+        def utf8_if_needed(val, val_charset)
+          if val_charset =~ /\AUTF-?8\z/i
+            val
+          end
+        end
+      end
+
+      def do_encode
+        return '' if Utilities.blank?(value)
+        address_array = element.addresses.reject { |a| encoded_group_addresses.include?(a.encoded) }.compact.map { |a| a.encoded }
+        address_text  = address_array.join(", \r\n\s")
+        group_array = groups.map { |k,v| "#{k}: #{v.map { |a| a.encoded }.join(", \r\n\s")};" }
+        group_text  = group_array.join(" \r\n\s")
+        return_array = [address_text, group_text].reject { |a| Utilities.blank?(a) }
+        "#{name}: #{return_array.join(", \r\n\s")}\r\n"
+      end
+
+      def do_decode
+        return nil if Utilities.blank?(value)
+        address_array = element.addresses.reject { |a| decoded_group_addresses.include?(a.decoded) }.map { |a| a.decoded }
+        address_text  = address_array.join(", ")
+        group_array = groups.map { |k,v| "#{k}: #{v.map { |a| a.decoded }.join(", ")};" }
+        group_text  = group_array.join(" ")
+        return_array = [address_text, group_text].reject { |a| Utilities.blank?(a) }
+        return_array.join(", ")
+      end
+
+      def get_group_addresses(group_list)
+        if group_list.respond_to?(:addresses)
+          group_list.addresses.map do |address|
+            Mail::Address.new(address)
+          end
+        else
+          []
+        end
+      end
+  end
+end

data/lib/mail/fields/common_date_field.rb

@@ -0,0 +1,58 @@
+require 'mail/fields/named_structured_field'
+require 'mail/elements/date_time_element'
+require 'mail/utilities'
+
+module Mail
+  class CommonDateField < NamedStructuredField #:nodoc:
+    def self.singular?
+      true
+    end
+
+    def self.normalize_datetime(string)
+      if Utilities.blank?(string)
+        datetime = ::DateTime.now
+      else
+        stripped = string.to_s.gsub(/\(.*?\)/, '').squeeze(' ')
+        begin
+          datetime = ::DateTime.parse(stripped)
+        rescue ArgumentError => e
+          raise unless 'invalid date' == e.message
+        end
+      end
+
+      if datetime
+        datetime.strftime('%a, %d %b %Y %H:%M:%S %z')
+      else
+        string
+      end
+    end
+
+    def initialize(value = nil, charset = nil)
+      super self.class.normalize_datetime(value), charset
+    end
+
+    # Returns a date time object of the parsed date
+    def date_time
+      ::DateTime.parse("#{element.date_string} #{element.time_string}")
+    rescue ArgumentError => e
+      raise e unless e.message == 'invalid date'
+    end
+
+    def default
+      date_time
+    end
+
+    def element
+      @element ||= Mail::DateTimeElement.new(value)
+    end
+
+    private
+      def do_encode
+        "#{name}: #{value}\r\n"
+      end
+
+      def do_decode
+        value.to_s
+      end
+  end
+end

data/lib/mail/fields/common_field.rb

@@ -0,0 +1,77 @@
+# encoding: utf-8
+# frozen_string_literal: true
+require 'mail/constants'
+
+module Mail
+  class CommonField #:nodoc:
+    def self.singular?
+      false
+    end
+
+    def self.parse(*args)
+      new(*args).tap(&:parse)
+    end
+
+    attr_accessor :name
+    attr_reader :value
+    attr_accessor :charset
+    attr_reader :errors
+
+    def initialize(name = nil, value = nil, charset = nil)
+      @errors = []
+
+      self.name = name
+      self.value = value
+      self.charset = charset || 'utf-8'
+    end
+
+    def singular?
+      self.class.singular?
+    end
+
+    def value=(value)
+      @element = nil
+      @value = value.is_a?(Array) ? value : value.to_s
+      parse
+    end
+
+    def parse
+      tap(&:element)
+    end
+
+    def element
+      nil
+    end
+
+    def to_s
+      decoded.to_s
+    end
+
+    def default
+      decoded
+    end
+
+    def decoded
+      do_decode
+    end
+
+    def encoded
+      do_encode
+    end
+
+    def responsible_for?(field_name)
+      name.to_s.casecmp(field_name.to_s) == 0
+    end
+
+    private
+
+    FILENAME_RE = /\b(filename|name)=([^;"\r\n]+\s[^;"\r\n]+)/
+    def ensure_filename_quoted(value)
+      if value.is_a?(String)
+        value.sub FILENAME_RE, '\1="\2"'
+      else
+        value
+      end
+    end
+  end
+end