mail 2.5.5 → 2.8.1

data/lib/mail/encodings/transfer_encoding.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 module Mail
   module Encodings
     class TransferEncoding
@@ -6,52 +7,70 @@ module Mail
 
       PRIORITY = -1
 
+      # And encoding's superclass can always transport it since the
+      # class hierarchy is arranged e.g. Base64 < 7bit < 8bit < Binary.
       def self.can_transport?(enc)
-        enc = Encodings.get_name(enc)
-        if Encodings.defined? enc
-          Encodings.get_encoding(enc).new.is_a? self
-        else
-          false
-        end
+        enc && enc <= self
       end
 
+      # Override in subclasses to indicate that they can encode text
+      # that couldn't be directly transported, e.g. Base64 has 7bit output,
+      # but it can encode binary.
       def self.can_encode?(enc)
-        can_transport? enc 
+        can_transport? enc
       end
 
       def self.cost(str)
         raise "Unimplemented"
       end
 
+      def self.compatible_input?(str)
+        true
+      end
+
       def self.to_s
         self::NAME
       end
 
-      def self.get_best_compatible(source_encoding, str)
-        if self.can_transport? source_encoding then
-            source_encoding 
+      def self.negotiate(message_encoding, source_encoding, str, allowed_encodings = nil)
+        message_encoding = Encodings.get_encoding(message_encoding) || Encodings.get_encoding('8bit')
+        source_encoding  = Encodings.get_encoding(source_encoding)
+
+        if message_encoding && source_encoding && message_encoding.can_transport?(source_encoding) && source_encoding.compatible_input?(str)
+          source_encoding
         else
-            choices = []
-            Encodings.get_all.each do |enc|
-                choices << enc if self.can_transport? enc and enc.can_encode? source_encoding
-            end
-            best = nil 
-            best_cost = 100
-            choices.each do |enc|
-                this_cost = enc.cost str
-                if this_cost < best_cost then
-                    best_cost = this_cost
-                    best = enc
-                elsif this_cost == best_cost then 
-                    best = enc if enc::PRIORITY < best::PRIORITY
-                end
-            end
-            best
+          renegotiate(message_encoding, source_encoding, str, allowed_encodings)
         end
       end
 
-      def to_s
-        self.class.to_s
+      def self.renegotiate(message_encoding, source_encoding, str, allowed_encodings = nil)
+        encodings = Encodings.get_all.select do |enc|
+          (allowed_encodings.nil? || allowed_encodings.include?(enc)) &&
+            message_encoding.can_transport?(enc) &&
+            enc.can_encode?(source_encoding)
+        end
+
+        lowest_cost(str, encodings)
+      end
+
+      def self.lowest_cost(str, encodings)
+        best = nil
+        best_cost = nil
+
+        encodings.each do |enc|
+          # If the current choice cannot be transported safely, give priority
+          # to other choices but allow it to be used as a fallback.
+          this_cost = enc.cost(str) if enc.compatible_input?(str)
+
+          if !best_cost || (this_cost && this_cost < best_cost)
+            best_cost = this_cost
+            best = enc
+          elsif this_cost == best_cost
+            best = enc if enc::PRIORITY < best::PRIORITY
+          end
+        end
+
+        best
       end
     end
   end

data/lib/mail/encodings/unix_to_unix.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+module Mail
+  module Encodings
+    class UnixToUnix < TransferEncoding
+      NAME = "x-uuencode"
+
+      def self.decode(str)
+        str.sub(/\Abegin \d+ [^\n]*\n/, '').unpack('u').first
+      end
+
+      def self.encode(str)
+        [str].pack("u")
+      end
+
+      Encodings.register(NAME, self)
+      Encodings.register("uuencode", self)
+      Encodings.register("x-uue", self)
+    end
+  end
+end

data/lib/mail/encodings.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module Mail
   # Raised when attempting to decode an unknown encoding type
@@ -6,8 +7,7 @@ module Mail
   end
 
   module Encodings
-
-    include Mail::Patterns
+    include Mail::Constants
     extend  Mail::Utilities
 
     @transfer_encodings = {}
@@ -18,7 +18,7 @@ module Mail
     #
     # Encodings.register "base64", Mail::Encodings::Base64
     def Encodings.register(name, cls)
-        @transfer_encodings[get_name(name)] = cls
+      @transfer_encodings[get_name(name)] = cls
     end
 
     # Is the encoding we want defined?
@@ -26,8 +26,8 @@ module Mail
     # Example:
     #
     #  Encodings.defined?(:base64) #=> true
-    def Encodings.defined?( str )
-      @transfer_encodings.include? get_name(str)
+    def Encodings.defined?(name)
+      @transfer_encodings.include? get_name(name)
     end
 
     # Gets a defined encoding type, QuotedPrintable or Base64 for now.
@@ -38,16 +38,24 @@ module Mail
     # Example:
     #
     #  Encodings.get_encoding(:base64) #=> Mail::Encodings::Base64
-    def Encodings.get_encoding( str )
-      @transfer_encodings[get_name(str)]
+    def Encodings.get_encoding(name)
+      @transfer_encodings[get_name(name)]
     end
 
     def Encodings.get_all
       @transfer_encodings.values
     end
 
-    def Encodings.get_name(enc)
-      enc = enc.to_s.gsub("-", "_").downcase
+    def Encodings.get_name(name)
+      underscoreize(name).downcase
+    end
+
+    def Encodings.transcode_charset(str, from_charset, to_charset = 'UTF-8')
+      if from_charset
+        Utilities.transcode_charset str, from_charset, to_charset
+      else
+        str
+      end
     end
 
     # Encodes a parameter value using URI Escaping, note the language field 'en' can
@@ -57,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:
     #
@@ -70,7 +77,7 @@ module Mail
       when str.ascii_only?
         str
       else
-        RubyVer.param_encode(str)
+        Utilities.param_encode(str)
       end
     end
 
@@ -84,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)
@@ -103,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
@@ -114,34 +121,19 @@ module Mail
     # String has to be of the format =?<encoding>?[QB]?<string>?=
     def Encodings.value_decode(str)
       # Optimization: If there's no encoded-words in the string, just return it
-      return str unless str =~ /\=\?[^?]+\?[QB]\?[^?]+?\?\=/xmi
+      return str unless str =~ ENCODED_VALUE
 
       lines = collapse_adjacent_encodings(str)
 
       # Split on white-space boundaries with capture, so we capture the white-space as well
-      lines.map do |line|
-        line.split(/([ \t])/).map do |text|
-          if text.index('=?').nil?
-            text
-          else
-            # Search for occurences of quoted strings or plain strings
-            text.scan(/(                                 # Group around entire regex to include it in matches
-                        \=\?[^?]+\?([QB])\?[^?]+?\?\=    # Quoted String with subgroup for encoding method
-                        |                                # or
-                        .+?(?=\=\?|$)                    # Plain String
-                      )/xmi).map do |matches|
-              string, method = *matches
-              if    method == 'b' || method == 'B'
-                b_value_decode(string)
-              elsif method == 'q' || method == 'Q'
-                q_value_decode(string)
-              else
-                string
-              end
-            end
+      lines.each do |line|
+        line.gsub!(ENCODED_VALUE) do |string|
+          case $2
+          when *B_VALUES then b_value_decode(string)
+          when *Q_VALUES then q_value_decode(string)
           end
         end
-      end.flatten.join("")
+      end.join("")
     end
 
     # Takes an encoded string of the format =?<encoding>?[QB]?<string>?=
@@ -152,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.
@@ -174,21 +161,21 @@ module Mail
 
     def Encodings.address_encode(address, charset = 'utf-8')
       if address.is_a?(Array)
-        # loop back through for each element
         address.compact.map { |a| Encodings.address_encode(a, charset) }.join(", ")
-      else
-        # find any word boundary that is not ascii and encode it
-        encode_non_usascii(address, charset) if address
+      elsif address
+        encode_non_usascii(address, charset)
       end
     end
 
     def Encodings.encode_non_usascii(address, charset)
       return address if address.ascii_only? or charset.nil?
-      us_ascii = %Q{\x00-\x7f}
-      # Encode any non usascii strings embedded inside of quotes
-      address = address.gsub(/(".*?[^#{us_ascii}].*?")/) { |s| Encodings.b_value_encode(unquote(s), charset) }
+
+      # 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
@@ -209,12 +196,15 @@ module Mail
     #
     #  Encodings.b_value_encode('This is あ string', 'UTF-8')
     #  #=> "=?UTF-8?B?VGhpcyBpcyDjgYIgc3RyaW5n?="
-    def Encodings.b_value_encode(encoded_str, encoding = nil)
-      return encoded_str if encoded_str.to_s.ascii_only?
-      string, encoding = RubyVer.b_value_encode(encoded_str, encoding)
-      map_lines(string) do |str|
-        "=?#{encoding}?B?#{str.chomp}?="
-      end.join(" ")
+    def Encodings.b_value_encode(string, encoding = nil)
+      if string.to_s.ascii_only?
+        string
+      else
+        Encodings.each_base64_chunk_byterange(string, 60).map do |chunk|
+          str, encoding = Utilities.b_value_encode(chunk, encoding)
+          "=?#{encoding}?B?#{str.chomp}?="
+        end.join(" ")
+      end
     end
 
     # Encode a string with Quoted-Printable Encoding and returns it ready to be inserted
@@ -226,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(/ /, '_')}?="
@@ -242,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
@@ -252,54 +242,73 @@ 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.split_encoding_from_string( str )
-      match = str.match(/\=\?([^?]+)?\?[QB]\?(.+)?\?\=/mi)
-      if match
-        match[1]
-      else
-        nil
-      end
-    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.
-    def Encodings.split_value_encoding_from_string(str)
-      match = str.match(/\=\?[^?]+?\?([QB])\?(.+)?\?\=/mi)
-      if match
-        match[1]
-      else
-        nil
-      end
+    def Encodings.value_encoding_from_string(str)
+      str[ENCODED_VALUE, 1]
     end
 
-    # When the encoded string consists of multiple lines, lines with the same
-    # encoding (Q or B) can be joined together.
+    # Split header line into proper encoded and unencoded parts.
     #
     # String has to be of the format =?<encoding>?[QB]?<string>?=
+    #
+    # Omit unencoded space after an encoded-word.
     def Encodings.collapse_adjacent_encodings(str)
-      lines = str.split(/(\?=)\s*(=\?)/).each_slice(2).map(&:join)
       results = []
-      previous_encoding = nil
+      last_encoded = nil  # Track whether to preserve or drop whitespace
 
-      lines.each do |line|
-        encoding = split_value_encoding_from_string(line)
+      lines = str.split(FULL_ENCODED_VALUE)
+      lines.each_slice(2) do |unencoded, encoded|
+        if last_encoded = encoded
+          if !Utilities.blank?(unencoded) || (!last_encoded && unencoded != EMPTY)
+            results << unencoded
+          end
 
-        if encoding == previous_encoding
-          line = results.pop + line
-          line.gsub!(/\?\=\=\?.+?\?[QqBb]\?/m, '')
+          results << encoded
+        else
+          results << unencoded
         end
-
-        previous_encoding = encoding
-        results << line
       end
 
       results
     end
+
+    # Partition the string into bounded-size chunks without splitting
+    # multibyte characters.
+    def Encodings.each_base64_chunk_byterange(str, max_bytesize_per_base64_chunk, &block)
+      raise "size per chunk must be multiple of 4" if (max_bytesize_per_base64_chunk % 4).nonzero?
+
+      if block_given?
+        max_bytesize = ((3 * max_bytesize_per_base64_chunk) / 4.0).floor
+        each_chunk_byterange(str, max_bytesize, &block)
+      else
+        enum_for :each_base64_chunk_byterange, str, max_bytesize_per_base64_chunk
+      end
+    end
+
+    # Partition the string into bounded-size chunks without splitting
+    # multibyte characters.
+    def Encodings.each_chunk_byterange(str, max_bytesize_per_chunk)
+      return enum_for(:each_chunk_byterange, str, max_bytesize_per_chunk) unless block_given?
+
+      offset = 0
+      chunksize = 0
+
+      str.each_char do |chr|
+        charsize = chr.bytesize
+
+        if chunksize + charsize > max_bytesize_per_chunk
+          yield Utilities.string_byteslice(str, offset, chunksize)
+          offset += chunksize
+          chunksize = charsize
+        else
+          chunksize += charsize
+        end
+      end
+
+      yield Utilities.string_byteslice(str, offset, chunksize)
+    end
   end
 end

data/lib/mail/envelope.rb

@@ -1,35 +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, strip_field(FIELD_NAME, args.last))
-    end
-    
-    def tree
-      @element ||= Mail::EnvelopeFromElement.new(value)
-      @tree ||= @element.tree
-    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