mail 2.2.15 → 2.3.0

data/lib/mail/fields/received_field.rb

@@ -52,15 +52,23 @@ module Mail
     end
    
     def formatted_date
-        date_time.strftime("%a, %d %b %Y %H:%M:%S ") + date_time.zone.delete(':')
+      date_time.strftime("%a, %d %b %Y %H:%M:%S ") + date_time.zone.delete(':')
     end
  
     def encoded
-      "#{CAPITALIZED_FIELD}: #{info}; #{formatted_date}\r\n"
+      if value.blank?
+        "#{CAPITALIZED_FIELD}: \r\n"
+      else
+        "#{CAPITALIZED_FIELD}: #{info}; #{formatted_date}\r\n"
+      end
     end
     
     def decoded
-      "#{info}; #{formatted_date}" 
+      if value.blank?
+        ""
+      else
+        "#{info}; #{formatted_date}" 
+      end
     end
     
   end

data/lib/mail/fields/return_path_field.rb

@@ -38,6 +38,7 @@ module Mail
     CAPITALIZED_FIELD = 'Return-Path'
     
     def initialize(value = nil, charset = 'utf-8')
+      value = nil if value == '<>'
       self.charset = charset
       super(CAPITALIZED_FIELD, strip_field(FIELD_NAME, value), charset)
       self.parse

data/lib/mail/fields/unstructured_field.rb

@@ -166,6 +166,7 @@ module Mail
     end
         
     def encode(value)
+      value.encode!(charset) if defined?(Encoding) && charset
       (value.not_ascii_only? ? [value].pack("M").gsub("=\n", '') : value).gsub("\r", "=0D").gsub("\n", "=0A")
     end
     

data/lib/mail/header.rb

@@ -73,7 +73,8 @@ module Mail
     #  h.fields = ['From: mikel@me.com', 'To: bob@you.com']
     def fields=(unfolded_fields)
       @fields = Mail::FieldList.new
-      unfolded_fields.each do |field|
+      warn "Warning: more than 1000 header fields only using the first 1000" if unfolded_fields.length > 1000
+      unfolded_fields[0..1000].each do |field|
 
         field = Field.new(field, nil, charset)
         field.errors.each { |error| self.errors << error }

data/lib/mail/indifferent_hash.rb

@@ -0,0 +1,146 @@
+# encoding: utf-8
+
+# This is an almost cut and paste from ActiveSupport v3.0.6, copied in here so that Mail
+# itself does not depend on ActiveSupport to avoid versioning conflicts
+
+module Mail
+  class IndifferentHash < Hash
+
+    def initialize(constructor = {})
+      if constructor.is_a?(Hash)
+        super()
+        update(constructor)
+      else
+        super(constructor)
+      end
+    end
+
+    def default(key = nil)
+      if key.is_a?(Symbol) && include?(key = key.to_s)
+        self[key]
+      else
+        super
+      end
+    end
+
+    def self.new_from_hash_copying_default(hash)
+      IndifferentHash.new(hash).tap do |new_hash|
+        new_hash.default = hash.default
+      end
+    end
+
+    alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
+    alias_method :regular_update, :update unless method_defined?(:regular_update)
+
+    # Assigns a new value to the hash:
+    #
+    #   hash = HashWithIndifferentAccess.new
+    #   hash[:key] = "value"
+    #
+    def []=(key, value)
+      regular_writer(convert_key(key), convert_value(value))
+    end
+
+    alias_method :store, :[]=
+
+    # Updates the instantized hash with values from the second:
+    #
+    #   hash_1 = HashWithIndifferentAccess.new
+    #   hash_1[:key] = "value"
+    #
+    #   hash_2 = HashWithIndifferentAccess.new
+    #   hash_2[:key] = "New Value!"
+    #
+    #   hash_1.update(hash_2) # => {"key"=>"New Value!"}
+    #
+    def update(other_hash)
+      other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
+      self
+    end
+
+    alias_method :merge!, :update
+
+    # Checks the hash for a key matching the argument passed in:
+    #
+    #   hash = HashWithIndifferentAccess.new
+    #   hash["key"] = "value"
+    #   hash.key? :key  # => true
+    #   hash.key? "key" # => true
+    #
+    def key?(key)
+      super(convert_key(key))
+    end
+
+    alias_method :include?, :key?
+    alias_method :has_key?, :key?
+    alias_method :member?, :key?
+
+    # Fetches the value for the specified key, same as doing hash[key]
+    def fetch(key, *extras)
+      super(convert_key(key), *extras)
+    end
+
+    # Returns an array of the values at the specified indices:
+    #
+    #   hash = HashWithIndifferentAccess.new
+    #   hash[:a] = "x"
+    #   hash[:b] = "y"
+    #   hash.values_at("a", "b") # => ["x", "y"]
+    #
+    def values_at(*indices)
+      indices.collect {|key| self[convert_key(key)]}
+    end
+
+    # Returns an exact copy of the hash.
+    def dup
+      IndifferentHash.new(self)
+    end
+
+    # Merges the instantized and the specified hashes together, giving precedence to the values from the second hash
+    # Does not overwrite the existing hash.
+    def merge(hash)
+      self.dup.update(hash)
+    end
+
+    # Performs the opposite of merge, with the keys and values from the first hash taking precedence over the second.
+    # This overloaded definition prevents returning a regular hash, if reverse_merge is called on a HashWithDifferentAccess.
+    def reverse_merge(other_hash)
+      super self.class.new_from_hash_copying_default(other_hash)
+    end
+
+    def reverse_merge!(other_hash)
+      replace(reverse_merge( other_hash ))
+    end
+
+    # Removes a specified key from the hash.
+    def delete(key)
+      super(convert_key(key))
+    end
+
+    def stringify_keys!; self end
+    def stringify_keys; dup end
+    def symbolize_keys; to_hash.symbolize_keys end
+    def to_options!; self end
+
+    def to_hash
+      Hash.new(default).merge!(self)
+    end
+
+  protected
+
+    def convert_key(key)
+      key.kind_of?(Symbol) ? key.to_s : key
+    end
+
+    def convert_value(value)
+      if value.class == Hash
+        self.class.new_from_hash_copying_default(value)
+      elsif value.is_a?(Array)
+        value.dup.replace(value.map { |e| convert_value(e) })
+      else
+        value
+      end
+    end
+
+  end
+end

data/lib/mail/message.rb

@@ -1,4 +1,6 @@
 # encoding: utf-8
+require "yaml"
+
 module Mail
   # The Message class provides a single point of access to all things to do with an
   # email message.
@@ -240,9 +242,9 @@ module Mail
     #
     # Returns self
     def deliver!
-      delivery_method.deliver!(self)
+      response = delivery_method.deliver!(self)
       inform_observers
-      self
+      delivery_method.settings[:return_response] ? response : self
     end
 
     def delivery_method(method = nil, settings = {})
@@ -268,7 +270,7 @@ module Mail
           reply.references ||= bracketed_message_id
         end
         if subject
-          reply.subject = "RE: #{subject}"
+          reply.subject = subject =~ /^Re:/i ? subject : "RE: #{subject}"
         end
         if reply_to || from
           reply.to = self[reply_to ? :reply_to : :from].to_s
@@ -1677,6 +1679,7 @@ module Mail
       self.body = ''
       text_part = Mail::Part.new({:content_type => 'text/plain;',
                                   :body => text})
+      text_part.charset = charset unless @defaulted_charset
       self.body << text_part
     end
 
@@ -1708,6 +1711,25 @@ module Mail
       buffer
     end
 
+    def to_yaml
+      ready_to_send!
+      hash = {}
+      header.fields.each do |field|
+        hash[field.name] = field.value
+      end
+      hash['subject'] = subject
+      hash['body'] = body.encoded(content_transfer_encoding)
+      hash.to_yaml
+    end
+
+    def self.from_yaml(str)
+      from_hash(YAML::load(str))
+    end
+
+    def self.from_hash(hash)
+      Mail::Message.new(hash)
+    end
+
     def to_s
       encoded
     end
@@ -1906,7 +1928,7 @@ module Mail
     end
 
     def init_with_hash(hash)
-      passed_in_options = hash.with_indifferent_access
+      passed_in_options = IndifferentHash.new(hash)
       self.raw_source = ''
 
       @header = Mail::Header.new