mail 2.6.1 → 2.7.1

data/lib/mail/utilities.rb

@@ -1,7 +1,14 @@
 # encoding: utf-8
+# frozen_string_literal: true
+require 'mail/constants'
+
 module Mail
   module Utilities
-    include Patterns
+
+    LF   = "\n"
+    CRLF = "\r\n"
+
+    include Constants
 
     # Returns true if the string supplied is free from characters not allowed as an ATOM
     def atom_safe?( str )
@@ -17,15 +24,13 @@ module Mail
     # If the string supplied has PHRASE unsafe characters in it, will return the string quoted
     # in double quotes, otherwise returns the string unmodified
     def quote_phrase( str )
-      if RUBY_VERSION >= '1.9'
+      if str.respond_to?(:force_encoding)
         original_encoding = str.encoding
-        str.force_encoding('ASCII-8BIT')
-        if (PHRASE_UNSAFE === str)
-          quoted_str = dquote(str).force_encoding(original_encoding)
-          str.force_encoding(original_encoding)
-          quoted_str
+        ascii_str = str.to_s.dup.force_encoding('ASCII-8BIT')
+        if (PHRASE_UNSAFE === ascii_str)
+          dquote(ascii_str).force_encoding(original_encoding)
         else
-          str.force_encoding(original_encoding)
+          str
         end
       else
         (PHRASE_UNSAFE === str) ? dquote(str) : str
@@ -40,7 +45,17 @@ module Mail
     # If the string supplied has TOKEN unsafe characters in it, will return the string quoted
     # in double quotes, otherwise returns the string unmodified
     def quote_token( str )
-      token_safe?( str ) ? str : dquote(str)
+      if str.respond_to?(:force_encoding)
+        original_encoding = str.encoding
+        ascii_str = str.to_s.dup.force_encoding('ASCII-8BIT')
+        if token_safe?( ascii_str )
+          str
+        else
+          dquote(ascii_str).force_encoding(original_encoding)
+        end
+      else
+        token_safe?( str ) ? str : dquote(str)
+      end
     end
 
     # Wraps supplied string in double quotes and applies \-escaping as necessary,
@@ -69,11 +84,26 @@ module Mail
     #  unqoute(string) #=> 'This is "a string"'
     def unquote( str )
       if str =~ /^"(.*?)"$/
-        $1.gsub(/\\(.)/, '\1')
+        unescape($1)
       else
         str
       end
     end
+    module_function :unquote
+
+    # Removes any \-escaping.
+    #
+    # Example:
+    #
+    #  string = 'This is \"a string\"'
+    #  unescape(string) #=> 'This is "a string"'
+    #
+    #  string = '"This is \"a string\""'
+    #  unescape(string) #=> '"This is "a string""'
+    def unescape( str )
+      str.gsub(/\\(.)/, '\1')
+    end
+    module_function :unescape
 
     # Wraps a string in parenthesis and escapes any that are in the string itself.
     #
@@ -175,9 +205,9 @@ module Mail
     # Example:
     #
     #  string = :resent_from_field
-    #  dasherize ( string ) #=> 'resent_from_field'
+    #  dasherize( string ) #=> 'resent-from-field'
     def dasherize( str )
-      str.to_s.gsub('_', '-')
+      str.to_s.tr(UNDERSCORE, HYPHEN)
     end
 
     # Swaps out all hyphens (-) for underscores (_) good for stringing to symbols
@@ -188,7 +218,7 @@ module Mail
     #  string = :resent_from_field
     #  underscoreize ( string ) #=> 'resent_from_field'
     def underscoreize( str )
-      str.to_s.downcase.gsub('-', '_')
+      str.to_s.downcase.tr(HYPHEN, UNDERSCORE)
     end
 
     if RUBY_VERSION <= '1.8.6'
@@ -221,5 +251,74 @@ module Mail
 
     end
 
+    def self.binary_unsafe_to_lf(string) #:nodoc:
+      string.gsub(/\r\n|\r/, LF)
+    end
+
+    TO_CRLF_REGEX =
+      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.
+        Regexp.new("(?<!\r)\n|\r(?!\n)")
+      else
+        /\n|\r\n|\r/
+      end
+
+    def self.binary_unsafe_to_crlf(string) #:nodoc:
+      string.gsub(TO_CRLF_REGEX, CRLF)
+    end
+
+    if RUBY_VERSION < '1.9'
+      def self.safe_for_line_ending_conversion?(string) #:nodoc:
+        string.ascii_only?
+      end
+    else
+      def self.safe_for_line_ending_conversion?(string) #:nodoc:
+        if string.encoding == Encoding::BINARY
+          string.ascii_only?
+        else
+          string.valid_encoding?
+        end
+      end
+    end
+
+    # Convert line endings to \n unless the string is binary. Used for
+    # sendmail delivery and for decoding 8bit Content-Transfer-Encoding.
+    def self.to_lf(string)
+      string = string.to_s
+      if safe_for_line_ending_conversion? string
+        binary_unsafe_to_lf string
+      else
+        string
+      end
+    end
+
+    # Convert line endings to \r\n unless the string is binary. Used for
+    # encoding 8bit and base64 Content-Transfer-Encoding and for convenience
+    # when parsing emails with \n line endings instead of the required \r\n.
+    def self.to_crlf(string)
+      string = string.to_s
+      if safe_for_line_ending_conversion? string
+        binary_unsafe_to_crlf string
+      else
+        string
+      end
+    end
+
+    # Returns true if the object is considered blank.
+    # A blank includes things like '', '   ', nil,
+    # and arrays and hashes that have nothing in them.
+    #
+    # This logic is mostly shared with ActiveSupport's blank?
+    def self.blank?(value)
+      if value.kind_of?(NilClass)
+        true
+      elsif value.kind_of?(String)
+        value !~ /\S/
+      else
+        value.respond_to?(:empty?) ? value.empty? : !value
+      end
+    end
   end
 end

data/lib/mail/version.rb

@@ -1,24 +1,17 @@
-# encoding: utf-8
+# frozen_string_literal: true
 module Mail
   module VERSION
-    
-    version = {}
-    File.read(File.join(File.dirname(__FILE__), '../', '../', 'VERSION')).each_line do |line|
-      type, value = line.chomp.split(":")
-      next if type =~ /^\s+$/  || value =~ /^\s+$/
-      version[type] = value
-    end
-    
-    MAJOR = version['major']
-    MINOR = version['minor']
-    PATCH = version['patch']
-    BUILD = version['build']
+
+    MAJOR = 2
+    MINOR = 7
+    PATCH = 1
+    BUILD = nil
 
     STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join('.')
-    
+
     def self.version
       STRING
     end
-    
+
   end
 end

data/lib/mail/version_specific/ruby_1_8.rb

@@ -1,4 +1,6 @@
 # encoding: utf-8
+# frozen_string_literal: true
+require 'net/imap' # for decode_utf7
 
 module Mail
   class Ruby18
@@ -54,19 +56,43 @@ module Mail
       klass.const_get( string )
     end
 
+    def Ruby18.transcode_charset(str, from_encoding, to_encoding = 'UTF-8')
+      case from_encoding
+      when /utf-?7/i
+        decode_utf7(str)
+      else
+        retried = false
+        begin
+          Iconv.conv("#{normalize_iconv_charset_encoding(to_encoding)}//IGNORE", normalize_iconv_charset_encoding(from_encoding), str)
+        rescue Iconv::InvalidEncoding
+          if retried
+            raise
+          else
+            from_encoding = 'ASCII'
+            retried = true
+            retry
+          end
+        end
+      end
+    end
+
+    def Ruby18.decode_utf7(str)
+      Net::IMAP.decode_utf7(str)
+    end
+
     def Ruby18.b_value_encode(str, encoding)
       # Ruby 1.8 requires an encoding to work
       raise ArgumentError, "Must supply an encoding" if encoding.nil?
       encoding = encoding.to_s.upcase.gsub('_', '-')
-      [Encodings::Base64.encode(str), fix_encoding(encoding)]
+      [Encodings::Base64.encode(str), normalize_iconv_charset_encoding(encoding)]
     end
 
     def Ruby18.b_value_decode(str)
-      match = str.match(/\=\?(.+)?\?[Bb]\?(.+)?\?\=/m)
+      match = str.match(/\=\?(.+)?\?[Bb]\?(.*)\?\=/m)
       if match
         encoding = match[1]
         str = Ruby18.decode_base64(match[2])
-        str = Iconv.conv('UTF-8//IGNORE', fix_encoding(encoding), str)
+        str = transcode_charset(str, encoding)
       end
       str
     end
@@ -79,20 +105,25 @@ module Mail
     end
 
     def Ruby18.q_value_decode(str)
-      match = str.match(/\=\?(.+)?\?[Qq]\?(.+)?\?\=/m)
+      match = str.match(/\=\?(.+)?\?[Qq]\?(.*)\?\=/m)
       if match
         encoding = match[1]
         string = match[2].gsub(/_/, '=20')
         # Remove trailing = if it exists in a Q encoding
         string = string.sub(/\=$/, '')
         str = Encodings::QuotedPrintable.decode(string)
-        str = Iconv.conv('UTF-8//IGNORE', fix_encoding(encoding), str)
+        str = transcode_charset(str, encoding)
       end
       str
     end
 
     def Ruby18.param_decode(str, encoding)
-      URI.unescape(str)
+      str = URI.unescape(str)
+      if encoding
+        transcode_charset(str, encoding)
+      else
+        str
+      end
     end
 
     def Ruby18.param_encode(str)
@@ -101,9 +132,13 @@ module Mail
       "#{encoding}'#{language}'#{URI.escape(str)}"
     end
 
+    def Ruby18.string_byteslice(str, *args)
+      str.slice(*args)
+    end
+
     private
 
-    def Ruby18.fix_encoding(encoding)
+    def Ruby18.normalize_iconv_charset_encoding(encoding)
       case encoding.upcase
       when 'UTF8', 'UTF_8'
         'UTF-8'
@@ -111,8 +146,17 @@ module Mail
         'UTF-16BE'
       when 'UTF32', 'UTF-32'
         'UTF-32BE'
+      when 'KS_C_5601-1987'
+        'CP949'
       else
-        encoding
+        # Fall back to ASCII for charsets that Iconv doesn't recognize
+        begin
+          Iconv.new('UTF-8', encoding)
+        rescue Iconv::InvalidEncoding => e
+          'ASCII'
+        else
+          encoding
+        end
       end
     end
   end

data/lib/mail/version_specific/ruby_1_9.rb

@@ -1,7 +1,48 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module Mail
   class Ruby19
+    class StrictCharsetEncoder
+      def encode(string, charset)
+        case charset
+        when /utf-?7/i
+          Mail::Ruby19.decode_utf7(string)
+        else
+          string.force_encoding(Mail::Ruby19.pick_encoding(charset))
+        end
+      end
+    end
+
+    class BestEffortCharsetEncoder
+      def encode(string, charset)
+        case charset
+        when /utf-?7/i
+          Mail::Ruby19.decode_utf7(string)
+        else
+          string.force_encoding(pick_encoding(charset))
+        end
+      end
+
+      private
+
+      def pick_encoding(charset)
+        charset = case charset
+        when /ansi_x3.110-1983/
+          'ISO-8859-1'
+        when /Windows-?1258/i # Windows-1258 is similar to 1252
+          "Windows-1252"
+        else
+          charset
+        end
+        Mail::Ruby19.pick_encoding(charset)
+      end
+    end
+
+    class << self
+      attr_accessor :charset_encoder
+    end
+    self.charset_encoder = BestEffortCharsetEncoder.new
 
     # Escapes any parenthesis in a string that are unescaped this uses
     # a Ruby 1.9.1 regexp feature of negative look behind
@@ -28,6 +69,9 @@ module Mail
     end
 
     def Ruby19.decode_base64(str)
+      if !str.end_with?("=") && str.length % 4 != 0
+        str = str.ljust((str.length + 3) & ~3, "=")
+      end
       str.unpack( 'm' ).first
     end
 
@@ -43,20 +87,51 @@ module Mail
       klass.const_get( string )
     end
 
+    def Ruby19.transcode_charset(str, from_encoding, to_encoding = Encoding::UTF_8)
+      to_encoding = to_encoding.to_s if RUBY_VERSION < '1.9.3'
+      to_encoding = Encoding.find(to_encoding)
+      replacement_char = to_encoding == Encoding::UTF_8 ? '�' : '?'
+      charset_encoder.encode(str.dup, from_encoding).encode(to_encoding, :undef => :replace, :invalid => :replace, :replace => replacement_char)
+    end
+
+    # From Ruby stdlib Net::IMAP
+    def Ruby19.encode_utf7(string)
+      string.gsub(/(&)|[^\x20-\x7e]+/) do
+        if $1
+          "&-"
+        else
+          base64 = [$&.encode(Encoding::UTF_16BE)].pack("m0")
+          "&" + base64.delete("=").tr("/", ",") + "-"
+        end
+      end.force_encoding(Encoding::ASCII_8BIT)
+    end
+
+    def Ruby19.decode_utf7(utf7)
+      utf7.gsub(/&([^-]+)?-/n) do
+        if $1
+          ($1.tr(",", "/") + "===").unpack("m")[0].encode(Encoding::UTF_8, Encoding::UTF_16BE)
+        else
+          "&"
+        end
+      end
+    end
+
     def Ruby19.b_value_encode(str, encoding = nil)
       encoding = str.encoding.to_s
       [Ruby19.encode_base64(str), encoding]
     end
 
     def Ruby19.b_value_decode(str)
-      match = str.match(/\=\?(.+)?\?[Bb]\?(.+)?\?\=/m)
+      match = str.match(/\=\?(.+)?\?[Bb]\?(.*)\?\=/m)
       if match
         charset = match[1]
         str = Ruby19.decode_base64(match[2])
-        str.force_encoding(pick_encoding(charset))
+        str = charset_encoder.encode(str, charset)
       end
-      decoded = str.encode("utf-8", :invalid => :replace, :replace => "")
-      decoded.valid_encoding? ? decoded : decoded.encode("utf-16le", :invalid => :replace, :replace => "").encode("utf-8")
+      transcode_to_scrubbed_utf8(str)
+    rescue Encoding::UndefinedConversionError, ArgumentError, Encoding::ConverterNotFoundError
+      warn "Encoding conversion failed #{$!}"
+      str.dup.force_encoding(Encoding::UTF_8)
     end
 
     def Ruby19.q_value_encode(str, encoding = nil)
@@ -65,28 +140,31 @@ module Mail
     end
 
     def Ruby19.q_value_decode(str)
-      match = str.match(/\=\?(.+)?\?[Qq]\?(.+)?\?\=/m)
+      match = str.match(/\=\?(.+)?\?[Qq]\?(.*)\?\=/m)
       if match
         charset = match[1]
         string = match[2].gsub(/_/, '=20')
         # Remove trailing = if it exists in a Q encoding
         string = string.sub(/\=$/, '')
         str = Encodings::QuotedPrintable.decode(string)
-        str.force_encoding(pick_encoding(charset))
+        str = charset_encoder.encode(str, charset)
         # We assume that binary strings hold utf-8 directly to work around
         # jruby/jruby#829 which subtly changes String#encode semantics.
-        str.force_encoding('utf-8') if str.encoding == Encoding::ASCII_8BIT
+        str.force_encoding(Encoding::UTF_8) if str.encoding == Encoding::ASCII_8BIT
       end
-      decoded = str.encode("utf-8", :invalid => :replace, :replace => "")
-      decoded.valid_encoding? ? decoded : decoded.encode("utf-16le", :invalid => :replace, :replace => "").encode("utf-8")
-    rescue Encoding::UndefinedConversionError
-      str.dup.force_encoding("utf-8")
+      transcode_to_scrubbed_utf8(str)
+    rescue Encoding::UndefinedConversionError, ArgumentError, Encoding::ConverterNotFoundError
+      warn "Encoding conversion failed #{$!}"
+      str.dup.force_encoding(Encoding::UTF_8)
     end
 
     def Ruby19.param_decode(str, encoding)
-      string = uri_parser.unescape(str)
-      string.force_encoding(encoding) if encoding
-      string
+      str = uri_parser.unescape(str)
+      str = charset_encoder.encode(str, encoding) if encoding
+      transcode_to_scrubbed_utf8(str)
+    rescue Encoding::UndefinedConversionError, ArgumentError, Encoding::ConverterNotFoundError
+      warn "Encoding conversion failed #{$!}"
+      str.dup.force_encoding(Encoding::UTF_8)
     end
 
     def Ruby19.param_encode(str)
@@ -106,37 +184,38 @@ module Mail
     #   Encoding.list.map { |e| [e.to_s.upcase == pick_encoding(e.to_s.downcase.gsub("-", "")), e.to_s] }.select {|a,b| !b}
     #   Encoding.list.map { |e| [e.to_s == pick_encoding(e.to_s), e.to_s] }.select {|a,b| !b}
     def Ruby19.pick_encoding(charset)
-      case charset
+      charset = charset.to_s
+      encoding = case charset.downcase
 
       # ISO-8859-8-I etc. http://en.wikipedia.org/wiki/ISO-8859-8-I
-      when /^iso-?8859-(\d+)(-i)?$/i
+      when /^iso[-_]?8859-(\d+)(-i)?$/
         "ISO-8859-#{$1}"
 
       # ISO-8859-15, ISO-2022-JP and alike
-      when /iso-?(\d{4})-?(\w{1,2})/i
+      when /^iso[-_]?(\d{4})-?(\w{1,2})$/
         "ISO-#{$1}-#{$2}"
 
       # "ISO-2022-JP-KDDI"  and alike
-      when /iso-?(\d{4})-?(\w{1,2})-?(\w*)/i
+      when /^iso[-_]?(\d{4})-?(\w{1,2})-?(\w*)$/
         "ISO-#{$1}-#{$2}-#{$3}"
 
       # UTF-8, UTF-32BE and alike
-      when /utf[\-_]?(\d{1,2})?(\w{1,2})/i
+      when /^utf[\-_]?(\d{1,2})?(\w{1,2})$/
         "UTF-#{$1}#{$2}".gsub(/\A(UTF-(?:16|32))\z/, '\\1BE')
 
       # Windows-1252 and alike
-      when /Windows-?(.*)/i
+      when /^windows-?(.*)$/
         "Windows-#{$1}"
 
-      when /^8bit$/
+      when '8bit'
         Encoding::ASCII_8BIT
 
       # alternatives/misspellings of us-ascii seen in the wild
-      when /^iso-?646(-us)?$/i, /us=ascii/i
+      when /^iso[-_]?646(-us)?$/, 'us=ascii'
         Encoding::ASCII
 
       # Microsoft-specific alias for MACROMAN
-      when /^macintosh$/i
+      when 'macintosh'
         Encoding::MACROMAN
 
       # Microsoft-specific alias for CP949 (Korean)
@@ -148,12 +227,52 @@ module Mail
         Encoding::Shift_JIS
 
       # GB2312 (Chinese charset) is a subset of GB18030 (its replacement)
-      when /gb2312/i
+      when 'gb2312'
         Encoding::GB18030
 
+      when 'cp-850'
+        Encoding::CP850
+
+      when 'latin2'
+        Encoding::ISO_8859_2
+
       else
         charset
       end
+
+      convert_to_encoding(encoding)
+    end
+
+    if "string".respond_to?(:byteslice)
+      def Ruby19.string_byteslice(str, *args)
+        str.byteslice(*args)
+      end
+    else
+      def Ruby19.string_byteslice(str, *args)
+        str.unpack('C*').slice(*args).pack('C*').force_encoding(str.encoding)
+      end
+    end
+
+    class << self
+      private
+
+      def convert_to_encoding(encoding)
+        if encoding.is_a?(Encoding)
+          encoding
+        else
+          # Fall back to ASCII for charsets that Ruby doesn't recognize
+          begin
+            Encoding.find(encoding)
+          rescue ArgumentError
+            Encoding::BINARY
+          end
+        end
+      end
+
+      def transcode_to_scrubbed_utf8(str)
+        decoded = str.encode(Encoding::UTF_8, :undef => :replace, :invalid => :replace, :replace => "�")
+        decoded.valid_encoding? ? decoded : decoded.encode(Encoding::UTF_16LE, :invalid => :replace, :replace => "�").encode(Encoding::UTF_8)
+      end
     end
   end
 end

data/lib/mail.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 module Mail # :doc:
 
   require 'date'
@@ -6,7 +7,7 @@ module Mail # :doc:
 
   require 'uri'
   require 'net/smtp'
-  require 'mime/types'
+  require 'mini_mime'
 
   if RUBY_VERSION <= '1.8.6'
     begin
@@ -26,22 +27,13 @@ module Mail # :doc:
 
   require 'mail/version'
 
-  require 'mail/core_extensions/nil'
-  require 'mail/core_extensions/object'
   require 'mail/core_extensions/string'
-  require 'mail/core_extensions/smtp' if RUBY_VERSION < '1.9.3'
+  require 'mail/core_extensions/smtp'
   require 'mail/indifferent_hash'
 
-  # Only load our multibyte extensions if AS is not already loaded
-  if defined?(ActiveSupport)
-    require 'active_support/inflector'
-  else
-    require 'mail/core_extensions/string/access'
-    require 'mail/core_extensions/string/multibyte'
-    require 'mail/multibyte'
-  end
+  require 'mail/multibyte'
 
-  require 'mail/patterns'
+  require 'mail/constants'
   require 'mail/utilities'
   require 'mail/configuration'
 
@@ -76,15 +68,17 @@ module Mail # :doc:
 
   require 'mail/envelope'
 
-  require 'mail/parsers'
+  register_autoload :Parsers, "mail/parsers"
 
   # Autoload header field elements and transfer encodings.
   require 'mail/elements'
   require 'mail/encodings'
   require 'mail/encodings/base64'
   require 'mail/encodings/quoted_printable'
+  require 'mail/encodings/unix_to_unix'
 
   require 'mail/matchers/has_sent_mail'
+  require 'mail/matchers/attachment_matchers.rb'
 
   # Finally... require all the Mail.methods
   require 'mail/mail'