mail 2.7.1 → 2.8.0.1

data/lib/mail/elements/message_ids_element.rb

@@ -1,13 +1,18 @@
 # encoding: utf-8
 # frozen_string_literal: true
 require 'mail/parsers/message_ids_parser'
+require 'mail/utilities'
 
 module Mail
-  class MessageIdsElement
+  class MessageIdsElement #:nodoc:
+    def self.parse(string)
+      new(string).tap(&:message_ids)
+    end
+
     attr_reader :message_ids
 
     def initialize(string)
-      @message_ids = Mail::Parsers::MessageIdsParser.parse(string).message_ids.map { |msg_id| clean_msg_id(msg_id) }
+      @message_ids = parse(string)
     end
 
     def message_id
@@ -15,8 +20,12 @@ module Mail
     end
 
     private
-    def clean_msg_id(val)
-      val =~ /.*<(.*)>.*/ ? $1 : val
-    end
+      def parse(string)
+        if Utilities.blank? string
+          []
+        else
+          Mail::Parsers::MessageIdsParser.parse(string).message_ids
+        end
+      end
   end
 end

data/lib/mail/elements/mime_version_element.rb

@@ -3,7 +3,7 @@
 require 'mail/parsers/mime_version_parser'
 
 module Mail
-  class MimeVersionElement
+  class MimeVersionElement #:nodoc:
     attr_reader :major, :minor
 
     def initialize(string)

data/lib/mail/elements/phrase_list.rb

@@ -4,11 +4,16 @@ require 'mail/parsers/phrase_lists_parser'
 require 'mail/utilities'
 
 module Mail
-  class PhraseList
+  class PhraseList #:nodoc:
     attr_reader :phrases
 
     def initialize(string)
-      @phrases = Mail::Parsers::PhraseListsParser.parse(string).phrases.map { |p| Mail::Utilities.unquote(p) }
+      @phrases =
+        if Utilities.blank? string
+          []
+        else
+          Mail::Parsers::PhraseListsParser.parse(string).phrases.map { |p| Mail::Utilities.unquote(p) }
+        end
     end
   end
 end

data/lib/mail/elements/received_element.rb

@@ -1,21 +1,35 @@
 # encoding: utf-8
 # frozen_string_literal: true
 require 'mail/parsers/received_parser'
+require 'mail/utilities'
 require 'date'
 
 module Mail
-  class ReceivedElement
-    include Mail::Utilities
-    attr_reader :date_time, :info
+  class ReceivedElement #:nodoc:
+    attr_reader :info, :date_time
 
     def initialize(string)
-      received = Mail::Parsers::ReceivedParser.parse(string)
-      @date_time = ::DateTime.parse("#{received.date} #{received.time}")
-      @info = received.info
+      if Utilities.blank? string
+        @date_time = nil
+        @info = nil
+      else
+        received = Mail::Parsers::ReceivedParser.parse(string)
+        @date_time = datetime_for(received)
+        @info = received.info
+      end
     end
 
     def to_s(*args)
       "#{info}; #{date_time.to_s(*args)}"
     end
+
+    private
+      def datetime_for(received)
+        ::DateTime.parse("#{received.date} #{received.time}")
+      rescue ArgumentError => e
+        raise e unless e.message == 'invalid date'
+        warn "WARNING: Invalid date field for received element (#{received.date} #{received.time}): #{e.class}: #{e.message}"
+        nil
+      end
   end
 end

data/lib/mail/encodings/7bit.rb

@@ -17,6 +17,11 @@ module Mail
       def self.encode(str)
         ::Mail::Utilities.binary_unsafe_to_crlf str
       end
+
+      # Per RFC 2045 2.7. 7bit Data, No octets with decimal values greater than 127 are allowed.
+      def self.compatible_input?(str)
+        str.ascii_only? && super
+      end
     end
   end
 end

data/lib/mail/encodings/base64.rb

@@ -16,11 +16,11 @@ module Mail
       end
 
       def self.decode(str)
-        RubyVer.decode_base64(str)
+        Utilities.decode_base64(str)
       end
 
       def self.encode(str)
-        ::Mail::Utilities.binary_unsafe_to_crlf(RubyVer.encode_base64(str))
+        ::Mail::Utilities.binary_unsafe_to_crlf(Utilities.encode_base64(str))
       end
 
       # 3 bytes in -> 4 bytes out

data/lib/mail/encodings/quoted_printable.rb

@@ -16,11 +16,11 @@ module Mail
       # Decode the string from Quoted-Printable. Cope with hard line breaks
       # that were incorrectly encoded as hex instead of literal CRLF.
       def self.decode(str)
-        str.gsub(/(?:=0D=0A|=0D|=0A)\r\n/, "\r\n").unpack("M*").first
+        ::Mail::Utilities.to_lf ::Mail::Utilities.to_crlf(str).gsub(/(?:=0D=0A|=0D|=0A)\r\n/, "\r\n").unpack("M*").first
       end
 
       def self.encode(str)
-        [str].pack("M")
+        ::Mail::Utilities.to_crlf [::Mail::Utilities.to_lf(str)].pack("M")
       end
 
       def self.cost(str)

data/lib/mail/encodings.rb

@@ -52,7 +52,7 @@ module Mail
 
     def Encodings.transcode_charset(str, from_charset, to_charset = 'UTF-8')
       if from_charset
-        RubyVer.transcode_charset str, from_charset, to_charset
+        Utilities.transcode_charset str, from_charset, to_charset
       else
         str
       end
@@ -65,8 +65,7 @@ module Mail
     #    param_encode_language 'jp'
     #  end
     #
-    # The character set used for encoding will either be the value of $KCODE for
-    # Ruby < 1.9 or the encoding on the string passed in.
+    # The character set used for encoding will be the encoding on the string passed in.
     #
     # Example:
     #
@@ -78,7 +77,7 @@ module Mail
       when str.ascii_only?
         str
       else
-        RubyVer.param_encode(str)
+        Utilities.param_encode(str)
       end
     end
 
@@ -92,15 +91,15 @@ module Mail
     #  str.encoding #=> 'ISO-8859-1'      ## Only on Ruby 1.9
     #  str #=> "This is fun"
     def Encodings.param_decode(str, encoding)
-      RubyVer.param_decode(str, encoding)
+      Utilities.param_decode(str, encoding)
     end
 
     # Decodes or encodes a string as needed for either Base64 or QP encoding types in
     # the =?<encoding>?[QB]?<string>?=" format.
     #
     # The output type needs to be :decode to decode the input string or :encode to
-    # encode the input string.  The character set used for encoding will either be
-    # the value of $KCODE for Ruby < 1.9 or the encoding on the string passed in.
+    # encode the input string.  The character set used for encoding will be the
+    # encoding on the string passed in.
     #
     # On encoding, will only send out Base64 encoded strings.
     def Encodings.decode_encode(str, output_type)
@@ -111,7 +110,7 @@ module Mail
         if str.ascii_only?
           str
         else
-          Encodings.b_value_encode(str, find_encoding(str))
+          Encodings.b_value_encode(str, str.encoding)
         end
       end
     end
@@ -145,13 +144,8 @@ module Mail
         output
       elsif to_encoding
         begin
-          if RUBY_VERSION >= '1.9'
-            output.encode(to_encoding)
-          else
-            require 'iconv'
-            Iconv.iconv(to_encoding, 'UTF-8', output).first
-          end
-        rescue Iconv::IllegalSequence, Iconv::InvalidEncoding, Errno::EINVAL
+          output.encode(to_encoding)
+        rescue Errno::EINVAL
           # the 'from' parameter specifies a charset other than what the text
           # actually is...not much we can do in this case but just return the
           # unconverted text.
@@ -176,42 +170,23 @@ module Mail
     def Encodings.encode_non_usascii(address, charset)
       return address if address.ascii_only? or charset.nil?
 
-      # With KCODE=u we can't use regexps on other encodings. Go ASCII.
-      with_ascii_kcode do
-        # Encode all strings embedded inside of quotes
-        address = address.gsub(/("[^"]*[^\/]")/) { |s| Encodings.b_value_encode(unquote(s), charset) }
-
-        # Then loop through all remaining items and encode as needed
-        tokens = address.split(/\s/)
-
-        map_with_index(tokens) do |word, i|
-          if word.ascii_only?
-            word
-          else
-            previous_non_ascii = i>0 && tokens[i-1] && !tokens[i-1].ascii_only?
-            if previous_non_ascii #why are we adding an extra space here?
-              word = " #{word}"
-            end
-            Encodings.b_value_encode(word, charset)
-          end
-        end.join(' ')
-      end
-    end
+      # Encode all strings embedded inside of quotes
+      address = address.gsub(/("[^"]*[^\/]")/) { |s| Encodings.b_value_encode(unquote(s), charset) }
+
+      # Then loop through all remaining items and encode as needed
+      tokens = address.split(/\s/)
 
-    if RUBY_VERSION < '1.9'
-      # With KCODE=u we can't use regexps on other encodings. Go ASCII.
-      def Encodings.with_ascii_kcode #:nodoc:
-        if $KCODE
-          $KCODE, original_kcode = '', $KCODE
+      map_with_index(tokens) do |word, i|
+        if word.ascii_only?
+          word
+        else
+          previous_non_ascii = i>0 && tokens[i-1] && !tokens[i-1].ascii_only?
+          if previous_non_ascii #why are we adding an extra space here?
+            word = " #{word}"
+          end
+          Encodings.b_value_encode(word, charset)
         end
-        yield
-      ensure
-        $KCODE = original_kcode if original_kcode
-      end
-    else
-      def Encodings.with_ascii_kcode #:nodoc:
-        yield
-      end
+      end.join(' ')
     end
 
     # Encode a string with Base64 Encoding and returns it ready to be inserted
@@ -226,7 +201,7 @@ module Mail
         string
       else
         Encodings.each_base64_chunk_byterange(string, 60).map do |chunk|
-          str, encoding = RubyVer.b_value_encode(chunk, encoding)
+          str, encoding = Utilities.b_value_encode(chunk, encoding)
           "=?#{encoding}?B?#{str.chomp}?="
         end.join(" ")
       end
@@ -241,7 +216,7 @@ module Mail
     #  #=> "=?UTF-8?Q?This_is_=E3=81=82_string?="
     def Encodings.q_value_encode(encoded_str, encoding = nil)
       return encoded_str if encoded_str.to_s.ascii_only?
-      string, encoding = RubyVer.q_value_encode(encoded_str, encoding)
+      string, encoding = Utilities.q_value_encode(encoded_str, encoding)
       string.gsub!("=\r\n", '') # We already have limited the string to the length we want
       map_lines(string) do |str|
         "=?#{encoding}?Q?#{str.chomp.gsub(/ /, '_')}?="
@@ -257,7 +232,7 @@ module Mail
     #  Encodings.b_value_decode("=?UTF-8?B?VGhpcyBpcyDjgYIgc3RyaW5n?=")
     #  #=> 'This is あ string'
     def Encodings.b_value_decode(str)
-      RubyVer.b_value_decode(str)
+      Utilities.b_value_decode(str)
     end
 
     # Decodes a Quoted-Printable string from the "=?UTF-8?Q?This_is_=E3=81=82_string?=" format
@@ -267,11 +242,7 @@ module Mail
     #  Encodings.q_value_decode("=?UTF-8?Q?This_is_=E3=81=82_string?=")
     #  #=> 'This is あ string'
     def Encodings.q_value_decode(str)
-      RubyVer.q_value_decode(str)
-    end
-
-    def Encodings.find_encoding(str)
-      RUBY_VERSION >= '1.9' ? str.encoding : $KCODE
+      Utilities.q_value_decode(str)
     end
 
     # Gets the encoding type (Q or B) from the string.
@@ -329,7 +300,7 @@ module Mail
         charsize = chr.bytesize
 
         if chunksize + charsize > max_bytesize_per_chunk
-          yield RubyVer.string_byteslice(str, offset, chunksize)
+          yield Utilities.string_byteslice(str, offset, chunksize)
           offset += chunksize
           chunksize = charsize
         else
@@ -337,7 +308,7 @@ module Mail
         end
       end
 
-      yield RubyVer.string_byteslice(str, offset, chunksize)
+      yield Utilities.string_byteslice(str, offset, chunksize)
     end
   end
 end

data/lib/mail/envelope.rb

@@ -1,31 +1,28 @@
 # encoding: utf-8
 # frozen_string_literal: true
-# 
+#
 # = Mail Envelope
-# 
+#
 # The Envelope class provides a field for the first line in an
 # mbox file, that looks like "From mikel@test.lindsaar.net DATETIME"
-# 
+#
 # This envelope class reads that line, and turns it into an
 # Envelope.from and Envelope.date for your use.
+
 module Mail
-  class Envelope < StructuredField
-    
-    def initialize(*args)
-      super(FIELD_NAME, args.last.to_s)
-    end
-    
+  class Envelope < NamedStructuredField
+    NAME = 'Envelope-From'
+
     def element
       @element ||= Mail::EnvelopeFromElement.new(value)
     end
-    
-    def date
-      ::DateTime.parse("#{element.date_time}")
-    end
 
     def from
       element.address
     end
-    
+
+    def date
+      element.date_time
+    end
   end
 end

data/lib/mail/field.rb

@@ -23,8 +23,6 @@ module Mail
   #     sections 3 and 4 of this standard.
   #
   class Field
-
-    include Utilities
     include Comparable
 
     STRUCTURED_FIELDS = %w[ bcc cc content-description content-disposition
@@ -70,7 +68,7 @@ module Mail
     }
 
     FIELD_NAME_MAP = FIELDS_MAP.inject({}) do |map, (field, field_klass)|
-      map.update(field => field_klass::CAPITALIZED_FIELD)
+      map.update(field => field_klass::NAME)
     end
 
     # Generic Field Exception
@@ -121,7 +119,7 @@ module Mail
       #
       #  Mail::Field.parse("field-name: field data")
       #  # => #<Mail::Field …>
-      def parse(field, charset = nil)
+      def parse(field, charset = 'utf-8')
         name, value = split(field)
         if name && value
           new name, value, charset
@@ -145,6 +143,10 @@ module Mail
         warn "WARNING: Ignoring unparsable header #{raw_field.inspect}: #{error.class}: #{error.message}"
         nil
       end
+
+      def field_class_for(name) #:nodoc:
+        FIELDS_MAP[name.to_s.downcase]
+      end
     end
 
     attr_reader :unparsed_value
@@ -163,10 +165,8 @@ module Mail
     #  # => #<Mail::Field …>
     def initialize(name, value = nil, charset = 'utf-8')
       case
-      when name.index(COLON)
-        Kernel.warn 'Passing an unparsed header field to Mail::Field.new is deprecated and will be removed in Mail 2.8.0. Use Mail::Field.parse instead.'
-        @name, @unparsed_value = self.class.split(name)
-        @charset = Utilities.blank?(value) ? charset : value
+      when name.index(Constants::COLON)
+        raise ArgumentError, 'Passing an unparsed header field to Mail::Field.new is not supported in Mail 2.8.0+. Use Mail::Field.parse instead.'
       when Utilities.blank?(value)
         @name = name
         @unparsed_value = nil
@@ -179,8 +179,8 @@ module Mail
       @name = FIELD_NAME_MAP[@name.to_s.downcase] || @name
     end
 
-    def field=(value)
-      @field = value
+    def field=(field)
+      @field = field
     end
 
     def field
@@ -209,81 +209,65 @@ module Mail
       end.join(" ")}>"
     end
 
-    def update(name, value)
-      @field = create_field(name, value, @charset)
-    end
-
-    def same( other )
-      return false unless other.kind_of?(self.class)
-      match_to_s(other.name, self.name)
+    def same(other)
+      other.kind_of?(self.class) && Utilities.match_to_s(other.name, name)
     end
 
-    def ==( other )
-      return false unless other.kind_of?(self.class)
-      match_to_s(other.name, self.name) && match_to_s(other.value, self.value)
+    def ==(other)
+      same(other) && Utilities.match_to_s(other.value, value)
     end
 
-    def responsible_for?( val )
-      name.to_s.casecmp(val.to_s) == 0
+    def responsible_for?(field_name)
+      name.to_s.casecmp(field_name.to_s) == 0
     end
 
-    def <=>( other )
-      self.field_order_id <=> other.field_order_id
+    def <=>(other)
+      field_order_id <=> other.field_order_id
     end
 
     def field_order_id
-      @field_order_id ||= (FIELD_ORDER_LOOKUP[self.name.to_s.downcase] || 100)
+      @field_order_id ||= FIELD_ORDER_LOOKUP.fetch(self.name.to_s.downcase, 100)
     end
 
     def method_missing(name, *args, &block)
       field.send(name, *args, &block)
     end
 
-    if RUBY_VERSION >= '1.9.2'
-      def respond_to_missing?(method_name, include_private)
-        field.respond_to?(method_name, include_private) || super
-      end
-    else
-      def respond_to?(method_name, include_private = false)
-        field.respond_to?(method_name, include_private) || super
-      end
+    def respond_to_missing?(method_name, include_private)
+      field.respond_to?(method_name, include_private) || super
     end
 
-    FIELD_ORDER = %w[ return-path received
-                      resent-date resent-from resent-sender resent-to
-                      resent-cc resent-bcc resent-message-id
-                      date from sender reply-to to cc bcc
-                      message-id in-reply-to references
-                      subject comments keywords
-                      mime-version content-type content-transfer-encoding
-                      content-location content-disposition content-description ]
-
-    FIELD_ORDER_LOOKUP = Hash[FIELD_ORDER.each_with_index.to_a]
+    FIELD_ORDER_LOOKUP = Hash[%w[
+      return-path received
+      resent-date resent-from resent-sender resent-to
+      resent-cc resent-bcc resent-message-id
+      date from sender reply-to to cc bcc
+      message-id in-reply-to references
+      subject comments keywords
+      mime-version content-type content-transfer-encoding
+      content-location content-disposition content-description
+    ].each_with_index.to_a]
 
     private
 
     def create_field(name, value, charset)
-      new_field(name, value, charset)
+      parse_field(name, value, charset)
     rescue Mail::Field::ParseError => e
       field = Mail::UnstructuredField.new(name, value)
       field.errors << [name, value, e]
       field
     end
 
-    def new_field(name, value, charset)
+    def parse_field(name, value, charset)
       value = unfold(value) if value.is_a?(String)
 
-      if klass = field_class_for(name)
-        klass.new(value, charset)
+      if klass = self.class.field_class_for(name)
+        klass.parse(value, charset)
       else
-        OptionalField.new(name, value, charset)
+        OptionalField.parse(name, value, charset)
       end
     end
 
-    def field_class_for(name)
-      FIELDS_MAP[name.to_s.downcase]
-    end
-
     # 2.2.3. Long Header Fields
     #
     #  The process of moving from this folded multiple-line representation
@@ -293,7 +277,7 @@ module Mail
     #  treated in its unfolded form for further syntactic and semantic
     #  evaluation.
     def unfold(string)
-      string.gsub(/#{Constants::CRLF}(#{Constants::WSP})/m, '\1')
+      string.gsub(Constants::UNFOLD_WS, '\1')
     end
   end
 end

data/lib/mail/field_list.rb

@@ -6,8 +6,36 @@ module Mail
   # 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.
     #
@@ -15,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).div(2)
-        if new_field < self[mid]
+        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