mail 2.6.1 → 2.7.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
+        RubyVer.transcode_charset str, from_charset, to_charset
+      else
+        str
+      end
     end
 
     # Encodes a parameter value using URI Escaping, note the language field 'en' can
@@ -114,34 +122,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>?=
@@ -174,32 +167,51 @@ 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) }
-      # 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}"
+
+      # 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
-          Encodings.b_value_encode(word, charset)
+        end.join(' ')
+      end
+    end
+
+    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
         end
-      end.join(' ')
+        yield
+      ensure
+        $KCODE = original_kcode if original_kcode
+      end
+    else
+      def Encodings.with_ascii_kcode #:nodoc:
+        yield
+      end
     end
 
     # Encode a string with Base64 Encoding and returns it ready to be inserted
@@ -209,12 +221,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 = RubyVer.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
@@ -255,50 +270,74 @@ module Mail
       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
     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 RubyVer.string_byteslice(str, offset, chunksize)
+          offset += chunksize
+          chunksize = charsize
+        else
+          chunksize += charsize
+        end
+      end
+
+      yield RubyVer.string_byteslice(str, offset, chunksize)
+    end
   end
 end

data/lib/mail/envelope.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 # 
 # = Mail Envelope
 # 
@@ -11,7 +12,7 @@ module Mail
   class Envelope < StructuredField
     
     def initialize(*args)
-      super(FIELD_NAME, strip_field(FIELD_NAME, args.last))
+      super(FIELD_NAME, args.last.to_s)
     end
     
     def element

data/lib/mail/field.rb

@@ -1,4 +1,6 @@
+# frozen_string_literal: true
 require 'mail/fields'
+require 'mail/constants'
 
 # encoding: utf-8
 module Mail
@@ -82,9 +84,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,41 +116,64 @@ 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 = nil)
+        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
+    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(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 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
@@ -137,8 +184,7 @@ module Mail
     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
@@ -168,15 +214,19 @@ module Mail
     end
 
     def same( other )
+      return false unless other.kind_of?(self.class)
       match_to_s(other.name, self.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)
+    end
+
     def responsible_for?( val )
       name.to_s.casecmp(val.to_s) == 0
     end
 
-    alias_method :==, :same
-
     def <=>( other )
       self.field_order_id <=> other.field_order_id
     end
@@ -189,6 +239,16 @@ module Mail
       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
+    end
+
     FIELD_ORDER = %w[ return-path received
                       resent-date resent-from resent-sender resent-to
                       resent-cc resent-bcc resent-message-id
@@ -202,11 +262,26 @@ module Mail
 
     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)
+      new_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)
+      value = unfold(value) if value.is_a?(String)
+
+      if klass = field_class_for(name)
+        klass.new(value, charset)
+      else
+        OptionalField.new(name, value, charset)
+      end
+    end
+
+    def field_class_for(name)
+      FIELDS_MAP[name.to_s.downcase]
     end
 
     # 2.2.3. Long Header Fields
@@ -218,30 +293,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::CRLF}(#{Constants::WSP})/m, '\1')
     end
-
   end
-
 end

data/lib/mail/field_list.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 module Mail
 
   # Field List class provides an enhanced array that keeps a list of 
@@ -19,7 +20,7 @@ module Mail
       hi = size
 
       while lo < hi
-        mid = (lo + hi) / 2
+        mid = (lo + hi).div(2)
         if new_field < self[mid]
           hi = mid
         else

data/lib/mail/fields/bcc_field.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 # 
 # = Blind Carbon Copy Field
 # 
@@ -36,16 +37,27 @@ module Mail
     FIELD_NAME = 'bcc'
     CAPITALIZED_FIELD = 'Bcc'
     
-    def initialize(value = '', charset = 'utf-8')
+    def initialize(value = nil, charset = 'utf-8')
       @charset = charset
-      super(CAPITALIZED_FIELD, strip_field(FIELD_NAME, value), charset)
-      self.parse
+      super(CAPITALIZED_FIELD, value, charset)
       self
     end
     
-    # Bcc field should never be :encoded
+    def include_in_headers=(include_in_headers)
+      @include_in_headers = include_in_headers
+    end
+
+    def include_in_headers
+      defined?(@include_in_headers) ? @include_in_headers : self.include_in_headers = false
+    end
+
+    # Bcc field should not be :encoded by default
     def encoded
-      ''
+      if include_in_headers
+        do_encode(CAPITALIZED_FIELD)
+      else
+        ''
+      end
     end
     
     def decoded

data/lib/mail/fields/cc_field.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 # 
 # = Carbon Copy Field
 # 
@@ -38,8 +39,7 @@ module Mail
     
     def initialize(value = nil, charset = 'utf-8')
       self.charset = charset
-      super(CAPITALIZED_FIELD, strip_field(FIELD_NAME, value), charset)
-      self.parse
+      super(CAPITALIZED_FIELD, value, charset)
       self
     end
     

data/lib/mail/fields/comments_field.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 # 
 # = Comments Field
 # 
@@ -32,7 +33,7 @@ module Mail
     
     def initialize(value = nil, charset = 'utf-8')
       @charset = charset
-      super(CAPITALIZED_FIELD, strip_field(FIELD_NAME, value))
+      super(CAPITALIZED_FIELD, value)
       self.parse
       self
     end

data/lib/mail/fields/common/address_container.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Mail
   
   class AddressContainer < Array
@@ -7,10 +8,10 @@ module Mail
       super(list)
     end
 
-    def << (address)
+    def <<(address)
       @field << address
     end
 
   end
   
-end
+end