mail 2.6.4 → 2.9.0

data/lib/mail/fields/structured_field.rb

@@ -1,13 +1,12 @@
 # encoding: utf-8
 # frozen_string_literal: true
-require 'mail/fields/common/common_field'
 
 module Mail
   # Provides access to a structured header field
   #
   # ===Per RFC 2822:
   #  2.2.2. Structured Header Field Bodies
-  #  
+  #
   #     Some field bodies in this standard have specific syntactical
   #     structure more restrictive than the unstructured field bodies
   #     described above. These are referred to as "structured" field bodies.
@@ -20,33 +19,6 @@ module Mail
   #     characters are subject to header "folding" and "unfolding" as
   #     described in section 2.2.3.  Semantic analysis of structured field
   #     bodies is given along with their syntax.
-  class StructuredField
-    
-    include Mail::CommonField
-    include Mail::Utilities
-    
-    def initialize(name = nil, value = nil, charset = nil)
-      self.name    = name
-      self.value   = value
-      self.charset = charset
-      self
-    end
-    
-    def charset
-      @charset
-    end
-    
-    def charset=(val)
-      @charset = val
-    end
-    
-    def default
-      decoded
-    end
-    
-    def errors
-      []
-    end
-
+  class StructuredField < CommonField #:nodoc:
   end
 end

data/lib/mail/fields/subject_field.rb

@@ -1,17 +1,14 @@
 # encoding: utf-8
 # frozen_string_literal: true
-# 
-# subject         =       "Subject:" unstructured CRLF
+
 module Mail
-  class SubjectField < UnstructuredField
-    
-    FIELD_NAME = 'subject'
-    CAPITALIZED_FIELD = "Subject"
-    
-    def initialize(value = nil, charset = 'utf-8')
-      self.charset = charset
-      super(CAPITALIZED_FIELD, strip_field(FIELD_NAME, value), charset)
+  #
+  # subject         =       "Subject:" unstructured CRLF
+  class SubjectField < NamedUnstructuredField #:nodoc:
+    NAME = 'Subject'
+
+    def self.singular?
+      true
     end
-    
   end
 end

data/lib/mail/fields/to_field.rb

@@ -1,55 +1,33 @@
 # encoding: utf-8
 # frozen_string_literal: true
-# 
-# = To Field
-# 
-# The To field inherits to StructuredField and handles the To: header
-# field in the email.
-# 
-# Sending to to a mail message will instantiate a Mail::Field object that
-# has a ToField as its field type.  This includes all Mail::CommonAddress
-# module instance metods.
-# 
-# Only one To field can appear in a header, though it can have multiple
-# addresses and groups of addresses.
-# 
-# == Examples:
-# 
-#  mail = Mail.new
-#  mail.to = 'Mikel Lindsaar <mikel@test.lindsaar.net>, ada@test.lindsaar.net'
-#  mail.to    #=> ['mikel@test.lindsaar.net', 'ada@test.lindsaar.net']
-#  mail[:to]  #=> '#<Mail::Field:0x180e5e8 @field=#<Mail::ToField:0x180e1c4
-#  mail['to'] #=> '#<Mail::Field:0x180e5e8 @field=#<Mail::ToField:0x180e1c4
-#  mail['To'] #=> '#<Mail::Field:0x180e5e8 @field=#<Mail::ToField:0x180e1c4
-# 
-#  mail[:to].encoded   #=> 'To: Mikel Lindsaar <mikel@test.lindsaar.net>, ada@test.lindsaar.net\r\n'
-#  mail[:to].decoded   #=> 'Mikel Lindsaar <mikel@test.lindsaar.net>, ada@test.lindsaar.net'
-#  mail[:to].addresses #=> ['mikel@test.lindsaar.net', 'ada@test.lindsaar.net']
-#  mail[:to].formatted #=> ['Mikel Lindsaar <mikel@test.lindsaar.net>', 'ada@test.lindsaar.net']
-# 
-require 'mail/fields/common/common_address'
 
 module Mail
-  class ToField < StructuredField
-    
-    include Mail::CommonAddress
-    
-    FIELD_NAME = 'to'
-    CAPITALIZED_FIELD = 'To'
-    
-    def initialize(value = nil, charset = 'utf-8')
-      self.charset = charset
-      super(CAPITALIZED_FIELD, strip_field(FIELD_NAME, value), charset)
-      self
-    end
-    
-    def encoded
-      do_encode(CAPITALIZED_FIELD)
-    end
-    
-    def decoded
-      do_decode
-    end
-    
+  # = To Field
+  #
+  # The To field inherits to StructuredField and handles the To: header
+  # field in the email.
+  #
+  # Sending to to a mail message will instantiate a Mail::Field object that
+  # has a ToField as its field type.  This includes all Mail::CommonAddress
+  # module instance metods.
+  #
+  # Only one To field can appear in a header, though it can have multiple
+  # addresses and groups of addresses.
+  #
+  # == Examples:
+  #
+  #  mail = Mail.new
+  #  mail.to = 'Mikel Lindsaar <mikel@test.lindsaar.net>, ada@test.lindsaar.net'
+  #  mail.to    #=> ['mikel@test.lindsaar.net', 'ada@test.lindsaar.net']
+  #  mail[:to]  #=> '#<Mail::Field:0x180e5e8 @field=#<Mail::ToField:0x180e1c4
+  #  mail['to'] #=> '#<Mail::Field:0x180e5e8 @field=#<Mail::ToField:0x180e1c4
+  #  mail['To'] #=> '#<Mail::Field:0x180e5e8 @field=#<Mail::ToField:0x180e1c4
+  #
+  #  mail[:to].encoded   #=> 'To: Mikel Lindsaar <mikel@test.lindsaar.net>, ada@test.lindsaar.net\r\n'
+  #  mail[:to].decoded   #=> 'Mikel Lindsaar <mikel@test.lindsaar.net>, ada@test.lindsaar.net'
+  #  mail[:to].addresses #=> ['mikel@test.lindsaar.net', 'ada@test.lindsaar.net']
+  #  mail[:to].formatted #=> ['Mikel Lindsaar <mikel@test.lindsaar.net>', 'ada@test.lindsaar.net']
+  class ToField < CommonAddressField #:nodoc:
+    NAME = 'To'
   end
 end

data/lib/mail/fields/unstructured_field.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 # frozen_string_literal: true
-require 'mail/fields/common/common_field'
+require 'mail/utilities'
 
 module Mail
   # Provides access to an unstructured header field
@@ -15,59 +15,39 @@ module Mail
   #     field bodies are simply to be treated as a single line of characters
   #     with no further processing (except for header "folding" and
   #     "unfolding" as described in section 2.2.3).
-  class UnstructuredField
-
-    include Mail::CommonField
-    include Mail::Utilities
-
-    attr_accessor :charset
-    attr_reader :errors
-
+  class UnstructuredField < CommonField #:nodoc:
     def initialize(name, value, charset = nil)
-      @errors = []
-
       if value.is_a?(Array)
         # Probably has arrived here from a failed parse of an AddressList Field
         value = value.join(', ')
-      else
-        # Ensure we are dealing with a string
-        value = value.to_s
+
+      # Mark UTF-8 strings parsed from ASCII-8BIT
+      elsif value.respond_to?(:force_encoding) && value.encoding == Encoding::ASCII_8BIT
+        utf8 = value.dup.force_encoding(Encoding::UTF_8)
+        value = utf8 if utf8.valid_encoding?
       end
 
-      if charset
-        self.charset = charset
-      else
+      charset ||=
         if value.respond_to?(:encoding)
-          self.charset = value.encoding
-        else
-          self.charset = $KCODE
+          value.encoding
         end
-      end
-      self.name = name
-      self.value = value
-      self
-    end
 
-    def encoded
-      do_encode
+      super name, value.to_s, charset
     end
 
-    def decoded
-      do_decode
-    end
-
-    def default
-      decoded
-    end
-
-    def parse # An unstructured field does not parse
+    # An unstructured field does not parse
+    def parse
       self
     end
 
     private
 
     def do_encode
-      value.nil? ? '' : "#{wrapped_value}\r\n"
+      if value && !value.empty?
+        "#{wrapped_value}\r\n"
+      else
+        ''
+      end
     end
 
     def do_decode
@@ -121,7 +101,7 @@ module Mail
     def fold(prepend = 0) # :nodoc:
       encoding       = normalized_encoding
       decoded_string = decoded.to_s
-      should_encode  = decoded_string.not_ascii_only?
+      should_encode  = !decoded_string.ascii_only?
       if should_encode
         first = true
         words = decoded_string.split(/[ \t]/).map do |word|
@@ -130,7 +110,7 @@ module Mail
           else
             word = " #{word}"
           end
-          if word.not_ascii_only?
+          if !word.ascii_only?
             word
           else
             word.scan(/.{7}|.+$/)
@@ -148,7 +128,14 @@ module Mail
         first_word = true
         while !words.empty?
           break unless word = words.first.dup
-          word.encode!(charset) if charset && word.respond_to?(:encode!)
+
+          # Convert on 1.9+ only since we aren't sure of the current
+          # charset encoding on 1.8. We'd need to track internal/external
+          # charset on each field.
+          if charset && word.respond_to?(:encoding)
+            word = Encodings.transcode_charset(word, word.encoding, charset)
+          end
+
           word = encode(word) if should_encode
           word = encode_crlf(word)
           # Skip to next line if we're going to go past the limit
@@ -179,7 +166,7 @@ module Mail
     end
 
     def encode(value)
-      value = [value].pack(CAPITAL_M).gsub(EQUAL_LF, EMPTY)
+      value = [value].pack(Constants::CAPITAL_M).gsub(Constants::EQUAL_LF, Constants::EMPTY)
       value.gsub!(/"/,  '=22')
       value.gsub!(/\(/, '=28')
       value.gsub!(/\)/, '=29')
@@ -190,16 +177,13 @@ module Mail
     end
 
     def encode_crlf(value)
-      value.gsub!(CR, CR_ENCODED)
-      value.gsub!(LF, LF_ENCODED)
+      value.gsub!(Constants::CR, Constants::CR_ENCODED)
+      value.gsub!(Constants::LF, Constants::LF_ENCODED)
       value
     end
 
     def normalized_encoding
-      encoding = charset.to_s.upcase.gsub('_', '-')
-      encoding = 'UTF-8' if encoding == 'UTF8' # Ruby 1.8.x and $KCODE == 'u'
-      encoding
+      charset.to_s.upcase.gsub('_', '-')
     end
-
   end
 end

data/lib/mail/fields.rb

@@ -1,6 +1,12 @@
 # frozen_string_literal: true
 module Mail
+  register_autoload :CommonField, 'mail/fields/common_field'
+  register_autoload :CommonAddressField, 'mail/fields/common_address_field'
+  register_autoload :CommonMessageIdField, 'mail/fields/common_message_id_field'
+  register_autoload :CommonDateField, 'mail/fields/common_date_field'
+
   register_autoload :UnstructuredField, 'mail/fields/unstructured_field'
+  register_autoload :NamedUnstructuredField, 'mail/fields/named_unstructured_field'
   register_autoload :StructuredField, 'mail/fields/structured_field'
   register_autoload :OptionalField, 'mail/fields/optional_field'
 
@@ -19,6 +25,7 @@ module Mail
   register_autoload :KeywordsField, 'mail/fields/keywords_field'
   register_autoload :MessageIdField, 'mail/fields/message_id_field'
   register_autoload :MimeVersionField, 'mail/fields/mime_version_field'
+  register_autoload :NamedStructuredField, 'mail/fields/named_structured_field'
   register_autoload :ReceivedField, 'mail/fields/received_field'
   register_autoload :ReferencesField, 'mail/fields/references_field'
   register_autoload :ReplyToField, 'mail/fields/reply_to_field'
@@ -33,4 +40,6 @@ module Mail
   register_autoload :SenderField, 'mail/fields/sender_field'
   register_autoload :SubjectField, 'mail/fields/subject_field'
   register_autoload :ToField, 'mail/fields/to_field'
+
+  register_autoload :ParameterHash, 'mail/fields/parameter_hash'
 end

data/lib/mail/header.rb

@@ -1,13 +1,15 @@
 # encoding: utf-8
 # frozen_string_literal: true
+require 'mail/constants'
+require 'mail/utilities'
+
 module Mail
-  
   # Provides access to a header object.
-  # 
+  #
   # ===Per RFC2822
-  # 
+  #
   #  2.2. Header Fields
-  # 
+  #
   #   Header fields are lines composed of a field name, followed by a colon
   #   (":"), followed by a field body, and terminated by CRLF.  A field
   #   name MUST be composed of printable US-ASCII characters (i.e.,
@@ -18,14 +20,12 @@ module Mail
   #   2.2.3.  All field bodies MUST conform to the syntax described in
   #   sections 3 and 4 of this standard.
   class Header
-    include Constants
-    include Utilities
     include Enumerable
-    
+
     @@maximum_amount = 1000
 
     # Large amount of headers in Email might create extra high CPU load
-    # Use this parameter to limit number of headers that will be parsed by 
+    # Use this parameter to limit number of headers that will be parsed by
     # mail library.
     # Default: 1000
     def self.maximum_amount
@@ -36,12 +36,14 @@ module Mail
       @@maximum_amount = value
     end
 
+    attr_reader :raw_source, :charset
+
     # Creates a new header object.
-    # 
+    #
     # Accepts raw text or nothing.  If given raw text will attempt to parse
     # it and split it into the various fields, instantiating each field as
     # it goes.
-    # 
+    #
     # If it finds a field that should be a structured field (such as content
     # type), but it fails to parse it, it will simply make it an unstructured
     # field and leave it alone.  This will mean that the data is preserved but
@@ -50,29 +52,24 @@ module Mail
     # me the example so we can fix it.
     def initialize(header_text = nil, charset = nil)
       @charset = charset
-      self.raw_source = ::Mail::Utilities.to_crlf(header_text).lstrip
+      @raw_source = ::Mail::Utilities.to_crlf(header_text).lstrip
       split_header if header_text
     end
 
     def initialize_copy(original)
       super
       @fields = @fields.dup
+      @fields.map!(&:dup)
     end
-    
-    # The preserved raw source of the header as you passed it in, untouched
-    # for your Regexing glory.
-    def raw_source
-      @raw_source
-    end
-    
+
     # Returns an array of all the fields in the header in order that they
     # were read in.
     def fields
       @fields ||= FieldList.new
     end
-    
+
     #  3.6. Field definitions
-    #  
+    #
     #   It is important to note that the header fields are not guaranteed to
     #   be in a particular order.  They may appear in any order, and they
     #   have been known to be reordered occasionally when transported over
@@ -82,35 +79,35 @@ module Mail
     #   header fields MUST NOT be reordered, and SHOULD be kept in blocks
     #   prepended to the message.  See sections 3.6.6 and 3.6.7 for more
     #   information.
-    # 
+    #
     # Populates the fields container with Field objects in the order it
     # receives them in.
     #
     # Acceps an array of field string values, for example:
-    # 
+    #
     #  h = Header.new
     #  h.fields = ['From: mikel@me.com', 'To: bob@you.com']
     def fields=(unfolded_fields)
       @fields = Mail::FieldList.new
-      warn "Warning: more than #{self.class.maximum_amount} header fields only using the first #{self.class.maximum_amount}" if unfolded_fields.length > self.class.maximum_amount
-      unfolded_fields[0..(self.class.maximum_amount-1)].each do |field|
 
-        field = Field.new(field, nil, charset)
-        if limited_field?(field.name) && (selected = select_field_for(field.name)) && selected.any? 
-          selected.first.update(field.name, field.value)
-        else
-          @fields << field
-        end
+      if unfolded_fields.size > self.class.maximum_amount
+        Kernel.warn "WARNING: More than #{self.class.maximum_amount} header fields; only using the first #{self.class.maximum_amount} and ignoring the rest"
+        unfolded_fields = unfolded_fields.slice(0...self.class.maximum_amount)
       end
 
+      unfolded_fields.each do |field|
+        if field = Field.parse(field, charset)
+          @fields.add_field field
+        end
+      end
     end
-    
+
     def errors
       @fields.map(&:errors).flatten(1)
     end
-    
+
     #  3.6. Field definitions
-    #  
+    #
     #   The following table indicates limits on the number of times each
     #   field may occur in a message header as well as any special
     #   limitations on the use of those fields.  An asterisk next to a value
@@ -120,35 +117,25 @@ module Mail
     #   <snip table from 3.6>
     #
     # As per RFC, many fields can appear more than once, we will return a string
-    # of the value if there is only one header, or if there is more than one 
+    # of the value if there is only one header, or if there is more than one
     # matching header, will return an array of values in order that they appear
     # in the header ordered from top to bottom.
-    # 
+    #
     # Example:
-    # 
+    #
     #  h = Header.new
     #  h.fields = ['To: mikel@me.com', 'X-Mail-SPAM: 15', 'X-Mail-SPAM: 20']
     #  h['To']          #=> 'mikel@me.com'
     #  h['X-Mail-SPAM'] #=> ['15', '20']
     def [](name)
-      name = dasherize(name)
-      name.downcase!
-      selected = select_field_for(name)
-      case
-      when selected.length > 1
-        selected.map { |f| f }
-      when !Utilities.blank?(selected)
-        selected.first
-      else
-        nil
-      end
+      fields.get_field(Utilities.dasherize(name))
     end
-    
+
     # Sets the FIRST matching field in the header to passed value, or deletes
     # the FIRST field matched from the header if passed nil
-    # 
+    #
     # Example:
-    # 
+    #
     #  h = Header.new
     #  h.fields = ['To: mikel@me.com', 'X-Mail-SPAM: 15', 'X-Mail-SPAM: 20']
     #  h['To'] = 'bob@you.com'
@@ -158,51 +145,39 @@ module Mail
     #  h['X-Mail-SPAM'] = nil
     #  h['X-Mail-SPAM'] # => nil
     def []=(name, value)
-      name = dasherize(name)
-      if name.include?(':')
+      name = name.to_s
+      if name.include?(Constants::COLON)
         raise ArgumentError, "Header names may not contain a colon: #{name.inspect}"
       end
-      fn = name.downcase
-      selected = select_field_for(fn)
-      
-      case
-      # User wants to delete the field
-      when !Utilities.blank?(selected) && value == nil
-        fields.delete_if { |f| selected.include?(f) }
-        
-      # User wants to change the field
-      when !Utilities.blank?(selected) && limited_field?(fn)
-        selected.first.update(fn, value)
-        
-      # User wants to create the field
+
+      name = Utilities.dasherize(name)
+
+      # Assign nil to delete the field
+      if value.nil?
+        fields.delete_field name
       else
-        # Need to insert in correct order for trace fields
-        self.fields << Field.new(name.to_s, value, charset)
-      end
-      if dasherize(fn) == "content-type"
+        fields.add_field Field.new(name.to_s, value, charset)
+
         # Update charset if specified in Content-Type
-        params = self[:content_type].parameters rescue nil
-        @charset = params[:charset] if params && params[:charset]
+        if name == 'content-type'
+          params = self[:content_type].parameters rescue nil
+          @charset = params[:charset] if params && params[:charset]
+        end
       end
     end
-    
-    def charset
-      @charset
-    end
-    
+
     def charset=(val)
       params = self[:content_type].parameters rescue nil
       if params
-        params[:charset] = val
+        if val
+          params[:charset] = val
+        else
+          params.delete(:charset)
+        end
       end
       @charset = val
     end
-    
-    LIMITED_FIELDS   = %w[ date from sender reply-to to cc bcc 
-                           message-id in-reply-to references subject
-                           return-path content-type mime-version
-                           content-transfer-encoding content-description 
-                           content-id content-disposition content-location]
+
 
     def encoded
       buffer = String.new
@@ -216,61 +191,47 @@ module Mail
     def to_s
       encoded
     end
-    
+
     def decoded
-      raise NoMethodError, 'Can not decode an entire header as there could be character set conflicts, try calling #decoded on the various fields.'
+      raise NoMethodError, 'Can not decode an entire header as there could be character set conflicts. Try calling #decoded on the various fields.'
     end
 
     def field_summary
-      fields.map { |f| "<#{f.name}: #{f.value}>" }.join(", ")
+      fields.summary
     end
 
     # Returns true if the header has a Message-ID defined (empty or not)
     def has_message_id?
-      !fields.select { |f| f.responsible_for?('Message-ID') }.empty?
+      fields.has_field? 'Message-ID'
     end
 
     # Returns true if the header has a Content-ID defined (empty or not)
     def has_content_id?
-      !fields.select { |f| f.responsible_for?('Content-ID') }.empty?
+      fields.has_field? 'Content-ID'
     end
 
     # Returns true if the header has a Date defined (empty or not)
     def has_date?
-      !fields.select { |f| f.responsible_for?('Date') }.empty?
+      fields.has_field? 'Date'
     end
 
     # Returns true if the header has a MIME version defined (empty or not)
     def has_mime_version?
-      !fields.select { |f| f.responsible_for?('Mime-Version') }.empty?
+      fields.has_field? 'MIME-Version'
     end
 
     private
-    
-    def raw_source=(val)
-      @raw_source = val
-    end
-    
+
     # Splits an unfolded and line break cleaned header into individual field
     # strings.
     def split_header
-      self.fields = raw_source.split(HEADER_SPLIT)
-    end
-    
-    def select_field_for(name)
-      fields.select { |f| f.responsible_for?(name) }
-    end
-    
-    def limited_field?(name)
-      LIMITED_FIELDS.include?(name.to_s.downcase)
+      self.fields = @raw_source.split(Constants::HEADER_SPLIT)
     end
 
-    # Enumerable support; yield each field in order to the block if there is one,
-    # or return an Enumerator for them if there isn't.
-    def each( &block )
-      return self.fields.each( &block ) if block
-      self.fields.each
-    end
 
+    # Enumerable support. Yield each field in order.
+    def each(&block)
+      fields.each(&block)
+    end
   end
 end