mail 2.6.1 → 2.8.1

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,53 +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
+          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,30 +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
-    
+  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

@@ -1,4 +1,6 @@
+# frozen_string_literal: true
 require 'mail/fields'
+require 'mail/constants'
 
 # encoding: utf-8
 module Mail
@@ -21,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
@@ -68,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
@@ -82,9 +82,31 @@ module Mail
 
       def initialize(element, value, reason)
         @element = element
-        @value = value
-        @reason = reason
-        super("#{element} can not parse |#{value}|\nReason was: #{reason}")
+        @value = to_utf8(value)
+        @reason = to_utf8(reason)
+        super("#{@element} can not parse |#{@value}|: #{@reason}")
+      end
+
+      private
+        def to_utf8(text)
+          if text.respond_to?(:force_encoding)
+            text.dup.force_encoding(Encoding::UTF_8)
+          else
+            text
+          end
+        end
+    end
+
+    class NilParseError < ParseError #:nodoc:
+      def initialize(element)
+        super element, nil, 'nil is invalid'
+      end
+    end
+
+    class IncompleteParseError < ParseError #:nodoc:
+      def initialize(element, original_text, unparsed_index)
+        parsed_text = to_utf8(original_text[0...unparsed_index])
+        super element, original_text, "Only able to parse up to #{parsed_text.inspect}"
       end
     end
 
@@ -92,53 +114,77 @@ module Mail
     class SyntaxError < FieldError #:nodoc:
     end
 
-    # Accepts a string:
-    #
-    #  Field.new("field-name: field data")
-    #
-    # Or name, value pair:
-    #
-    #  Field.new("field-name", "value")
+    class << self
+      # Parse a field from a raw header line:
+      #
+      #  Mail::Field.parse("field-name: field data")
+      #  # => #<Mail::Field …>
+      def parse(field, charset = 'utf-8')
+        name, value = split(field)
+        if name && value
+          new name, value, charset
+        end
+      end
+
+      def split(raw_field) #:nodoc:
+        if raw_field.index(Constants::COLON)
+          name, value = raw_field.split(Constants::COLON, 2)
+          name.rstrip!
+          if name =~ /\A#{Constants::FIELD_NAME}\z/
+            [ name.rstrip, value.strip ]
+          else
+            Kernel.warn "WARNING: Ignoring unparsable header #{raw_field.inspect}: invalid header name syntax: #{name.inspect}"
+            nil
+          end
+        else
+          raw_field.strip
+        end
+      rescue => error
+        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
+
+    # Create a field by name and optional value:
     #
-    # Or a name by itself:
+    #  Mail::Field.new("field-name", "value")
+    #  # => #<Mail::Field …>
     #
-    #  Field.new("field-name")
+    # Values that aren't strings or arrays are coerced to Strings with `#to_s`.
     #
-    # Note, does not want a terminating carriage return.  Returns
-    # self appropriately parsed.  If value is not a string, then
-    # it will be passed through as is, for example, content-type
-    # field can accept an array with the type and a hash of
-    # parameters:
+    #  Mail::Field.new("field-name", 1234)
+    #  # => #<Mail::Field …>
     #
-    #  Field.new('content-type', ['text', 'plain', {:charset => 'UTF-8'}])
+    #  Mail::Field.new('content-type', ['text', 'plain', {:charset => 'UTF-8'}])
+    #  # => #<Mail::Field …>
     def initialize(name, value = nil, charset = 'utf-8')
       case
-      when name =~ /:/                  # Field.new("field-name: field data")
-        @charset = value.blank? ? charset : value
-        @name = name[FIELD_PREFIX]
-        @raw_value = name
-        @value = nil
-      when name !~ /:/ && value.blank?  # Field.new("field-name")
+      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
-        @value = nil
-        @raw_value = nil
+        @unparsed_value = nil
         @charset = charset
-      else                              # Field.new("field-name", "value")
+      else
         @name = name
-        @value = value
-        @raw_value = nil
+        @unparsed_value = value
         @charset = charset
       end
       @name = FIELD_NAME_MAP[@name.to_s.downcase] || @name
     end
 
-    def field=(value)
-      @field = value
+    def field=(field)
+      @field = field
     end
 
     def field
-      _, @value = split(@raw_value) if @raw_value && !@value
-      @field ||= create_field(@name, @value, @charset)
+      @field ||= create_field(@name, @unparsed_value, @charset)
     end
 
     def name
@@ -163,50 +209,63 @@ module Mail
       end.join(" ")}>"
     end
 
-    def update(name, value)
-      @field = create_field(name, value, @charset)
+    def same(other)
+      other.kind_of?(self.class) && Utilities.match_to_s(other.name, name)
     end
 
-    def same( other )
-      match_to_s(other.name, self.name)
+    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
 
-    alias_method :==, :same
-
-    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
 
-    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 ]
+    def respond_to_missing?(method_name, include_private)
+      field.respond_to?(method_name, include_private) || super
+    end
 
-    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 split(raw_field)
-      match_data = raw_field.mb_chars.match(FIELD_SPLIT)
-      [match_data[1].to_s.mb_chars.strip, match_data[2].to_s.mb_chars.strip.to_s]
-    rescue
-      STDERR.puts "WARNING: Could not parse (and so ignoring) '#{raw_field}'"
+    def create_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 parse_field(name, value, charset)
+      value = unfold(value) if value.is_a?(String)
+
+      if klass = self.class.field_class_for(name)
+        klass.parse(value, charset)
+      else
+        OptionalField.parse(name, value, charset)
+      end
     end
 
     # 2.2.3. Long Header Fields
@@ -218,30 +277,7 @@ module Mail
     #  treated in its unfolded form for further syntactic and semantic
     #  evaluation.
     def unfold(string)
-      string.gsub(/[\r\n \t]+/m, ' ')
-    end
-
-    def create_field(name, value, charset)
-      value = unfold(value) if value.is_a?(String)
-
-      begin
-        new_field(name, value, charset)
-      rescue Mail::Field::ParseError => e
-        field = Mail::UnstructuredField.new(name, value)
-        field.errors << [name, value, e]
-        field
-      end
-    end
-
-    def new_field(name, value, charset)
-      lower_case_name = name.to_s.downcase
-      if field_klass = FIELDS_MAP[lower_case_name]
-        field_klass.new(value, charset)
-      else
-        OptionalField.new(name, value, charset)
-      end
+      string.gsub(Constants::UNFOLD_WS, '\1')
     end
-
   end
-
 end