mail 2.2.20 → 2.3.0

data/CHANGELOG.rdoc

@@ -1,10 +1,9 @@
-== Tue May 14 14:22:00 +1100 2013 Mikel Lindsaar <mikel@lindsaar.net>
-
-* Backport 2.4.2 2.4.4 fixes (fractious)
-
-== Tue Apr 26 09:49:54 UTC 2011 Mikel Lindsaar <mikel@rubyx.com>
+== Tue Apr 26 09:59:56 UTC 2011 Mikel Lindsaar <mikel@rubyx.com>
 
+* Remove ActiveSupport from the dependencies, load Active Support if present, or use internals if not
+* Created v2.2 branch for all 2.2 related commits
 * Update activesupport require to use inflector - closes #217
+* Version bump to 2.3 and gem release
 
 == Tue Apr 26 06:18:19 UTC 2011 Mikel Lindsaar <mikel@rubyx.com>
 

data/Dependencies.txt

@@ -0,0 +1,3 @@
+treetop: we need to include this in the gem spec
+tlsmail: if ruby < 1.8.6... we could make it optional, or embed it in Mail
+mime/types: I think we embed a simplified version, or help maintain it, it is old (2006)

data/Gemfile

@@ -0,0 +1,29 @@
+source :rubygems
+
+gem "activesupport", ">= 2.3.6"
+gem "tlsmail" if RUBY_VERSION <= '1.8.6'
+gem "mime-types", "~> 1.16"
+gem "treetop", "~> 1.4.8"
+gem "i18n", ">= 0.4.0"
+
+if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+  gem 'jruby-openssl'
+end
+
+group :test do
+  gem "ZenTest",    "~> 4.4.0"
+  gem "rake",       "~> 0.8.7"
+  gem "bundler"
+  gem "rspec",      "~> 1.3.0"
+  gem "diff-lcs"
+  case
+  when defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
+    # Skip it
+  when RUBY_PLATFORM == 'java'
+    # Skip it
+  when RUBY_VERSION < '1.9'
+    gem "ruby-debug"
+  else
+    # Skip it
+  end
+end

data/lib/VERSION

@@ -1,4 +1,4 @@
 major:2
-minor:2
-patch:20
+minor:3
+patch:0
 build:

data/lib/mail.rb

@@ -4,12 +4,6 @@ module Mail # :doc:
   require 'date'
   require 'shellwords'
 
-  require 'active_support'
-  require 'active_support/core_ext/class/attribute_accessors'
-  require 'active_support/core_ext/hash/indifferent_access'
-  require 'active_support/core_ext/object/blank'
-  require 'active_support/inflector'
-
   require 'uri'
   require 'net/smtp'
   require 'mime/types'
@@ -22,7 +16,7 @@ module Mail # :doc:
     end
   end
 
-  if RUBY_VERSION >= "1.9.1"
+  if RUBY_VERSION >= "1.9.0"
     require 'mail/version_specific/ruby_1_9'
     RubyVer = Ruby19
   else
@@ -33,9 +27,20 @@ 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/shellwords' unless String.new.respond_to?(:shellescape)
   require 'mail/core_extensions/smtp' if RUBY_VERSION < '1.9.3'
+  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/patterns'
   require 'mail/utilities'

data/lib/mail/body.rb

@@ -201,10 +201,11 @@ module Mail
     end
     
     def encoding=( val )
-      if val == "text" || val.blank? then
-        val = "8bit"
+      @encoding = if val == "text" || val.blank?
+          (only_us_ascii? ? '7bit' : '8bit')
+      else
+          val
       end
-      @encoding = (val == "text") ? "8bit" : val
     end
 
     # Returns the preamble (any text that is before the first MIME boundary)

data/lib/mail/core_extensions/nil.rb

@@ -1,5 +1,7 @@
 # encoding: utf-8
 
+# This is not loaded if ActiveSupport is already loaded
+
 class NilClass #:nodoc:
   def to_crlf
     ''

data/lib/mail/core_extensions/object.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+# This is not loaded if ActiveSupport is already loaded
+
+class Object
+  def blank?
+    if respond_to?(:empty?)
+      empty?
+    else
+     !self
+    end
+  end
+end

data/lib/mail/core_extensions/shellwords.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 # The following is imported from ruby 1.9.2 shellwords.rb
 #
 module Shellwords

data/lib/mail/core_extensions/smtp.rb

@@ -1,3 +1,4 @@
+# encoding: utf-8
 module Net
   class SMTP
     # This is a backport of r30294 from ruby trunk because of a bug in net/smtp.

data/lib/mail/core_extensions/string.rb

@@ -8,6 +8,10 @@ class String #:nodoc:
     gsub(/\n|\r\n|\r/) { "\n" }
   end
 
+  def blank?
+    self !~ /\S/
+  end
+
   unless method_defined?(:ascii_only?)
     # Provides all strings with the Ruby 1.9 method of .ascii_only? and
     # returns true or false
@@ -16,7 +20,7 @@ class String #:nodoc:
       !(self =~ /[^#{US_ASCII_REGEXP}]/)
     end
   end
-  
+
   def not_ascii_only?
     !ascii_only?
   end

data/lib/mail/core_extensions/string/access.rb

@@ -0,0 +1,104 @@
+# encoding: utf-8
+
+# This is not loaded if ActiveSupport is already loaded
+
+# 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
+
+class String
+  unless '1.9'.respond_to?(:force_encoding)
+    # Returns the character at the +position+ treating the string as an array (where 0 is the first character).
+    #
+    # Examples:
+    #   "hello".at(0)  # => "h"
+    #   "hello".at(4)  # => "o"
+    #   "hello".at(10) # => ERROR if < 1.9, nil in 1.9
+    def at(position)
+      mb_chars[position, 1].to_s
+    end
+
+    # Returns the remaining of the string from the +position+ treating the string as an array (where 0 is the first character).
+    #
+    # Examples:
+    #   "hello".from(0)  # => "hello"
+    #   "hello".from(2)  # => "llo"
+    #   "hello".from(10) # => "" if < 1.9, nil in 1.9
+    def from(position)
+      mb_chars[position..-1].to_s
+    end
+
+    # Returns the beginning of the string up to the +position+ treating the string as an array (where 0 is the first character).
+    #
+    # Examples:
+    #   "hello".to(0)  # => "h"
+    #   "hello".to(2)  # => "hel"
+    #   "hello".to(10) # => "hello"
+    def to(position)
+      mb_chars[0..position].to_s
+    end
+
+    # Returns the first character of the string or the first +limit+ characters.
+    #
+    # Examples:
+    #   "hello".first     # => "h"
+    #   "hello".first(2)  # => "he"
+    #   "hello".first(10) # => "hello"
+    def first(limit = 1)
+      if limit == 0
+        ''
+      elsif limit >= size
+        self
+      else
+        mb_chars[0...limit].to_s
+      end
+    end
+
+    # Returns the last character of the string or the last +limit+ characters.
+    #
+    # Examples:
+    #   "hello".last     # => "o"
+    #   "hello".last(2)  # => "lo"
+    #   "hello".last(10) # => "hello"
+    def last(limit = 1)
+      if limit == 0
+        ''
+      elsif limit >= size
+        self
+      else
+        mb_chars[(-limit)..-1].to_s
+      end
+    end
+  else
+    def at(position)
+      self[position]
+    end
+
+    def from(position)
+      self[position..-1]
+    end
+
+    def to(position)
+      self[0..position]
+    end
+
+    def first(limit = 1)
+      if limit == 0
+        ''
+      elsif limit >= size
+        self
+      else
+        to(limit - 1)
+      end
+    end
+
+    def last(limit = 1)
+      if limit == 0
+        ''
+      elsif limit >= size
+        self
+      else
+        from(-limit)
+      end
+    end
+  end
+end

data/lib/mail/core_extensions/string/multibyte.rb

@@ -0,0 +1,78 @@
+# encoding: utf-8
+
+# This is not loaded if ActiveSupport is already loaded
+
+# 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
+
+require 'mail/multibyte'
+
+class String
+  if RUBY_VERSION >= "1.9"
+    # == Multibyte proxy
+    #
+    # +mb_chars+ is a multibyte safe proxy for string methods.
+    #
+    # In Ruby 1.8 and older it creates and returns an instance of the Mail::Multibyte::Chars class which
+    # encapsulates the original string. A Unicode safe version of all the String methods are defined on this proxy
+    # class. If the proxy class doesn't respond to a certain method, it's forwarded to the encapsuled string.
+    #
+    #   name = 'Claus Müller'
+    #   name.reverse # => "rell??M sualC"
+    #   name.length  # => 13
+    #
+    #   name.mb_chars.reverse.to_s # => "rellüM sualC"
+    #   name.mb_chars.length       # => 12
+    #
+    # In Ruby 1.9 and newer +mb_chars+ returns +self+ because String is (mostly) encoding aware. This means that
+    # it becomes easy to run one version of your code on multiple Ruby versions.
+    #
+    # == Method chaining
+    #
+    # All the methods on the Chars proxy which normally return a string will return a Chars object. This allows
+    # method chaining on the result of any of these methods.
+    #
+    #   name.mb_chars.reverse.length # => 12
+    #
+    # == Interoperability and configuration
+    #
+    # The Chars object tries to be as interchangeable with String objects as possible: sorting and comparing between
+    # String and Char work like expected. The bang! methods change the internal string representation in the Chars
+    # object. Interoperability problems can be resolved easily with a +to_s+ call.
+    #
+    # For more information about the methods defined on the Chars proxy see Mail::Multibyte::Chars. For
+    # information about how to change the default Multibyte behaviour see Mail::Multibyte.
+    def mb_chars
+      if Mail::Multibyte.proxy_class.consumes?(self)
+        Mail::Multibyte.proxy_class.new(self)
+      else
+        self
+      end
+    end
+
+    def is_utf8? #:nodoc
+      case encoding
+      when Encoding::UTF_8
+        valid_encoding?
+      when Encoding::ASCII_8BIT, Encoding::US_ASCII
+        dup.force_encoding(Encoding::UTF_8).valid_encoding?
+      else
+        false
+      end
+    end
+  else
+    def mb_chars
+      if Mail::Multibyte.proxy_class.wants?(self)
+        Mail::Multibyte.proxy_class.new(self)
+      else
+        self
+      end
+    end
+
+    # Returns true if the string has UTF-8 semantics (a String used for purely byte resources is unlikely to have
+    # them), returns false otherwise.
+    def is_utf8?
+      Mail::Multibyte::Chars.consumes?(self)
+    end
+  end
+end

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

@@ -8,7 +8,7 @@ module Mail
   # to make that happen
   # Parameters are defined in RFC2045, split keys are in RFC2231
 
-  class ParameterHash < HashWithIndifferentAccess
+  class ParameterHash < IndifferentHash
 
     include Mail::Utilities
 
@@ -28,8 +28,8 @@ module Mail
       if pairs.empty? # Just dealing with a single value pair
         super(exact || key_name)
       else # Dealing with a multiple value pair or a single encoded value pair
-        string = pairs.sort { |a,b| a.first <=> b.first }.map { |v| v.last }.join('')
-        if mt = string.match(/([\w\-]+)'(\w\w)'(.*)/)
+        string = pairs.sort { |a,b| a.first.to_s <=> b.first.to_s }.map { |v| v.last }.join('')
+        if mt = string.match(/([\w\d\-]+)'(\w\w)'(.*)/)
           string = mt[3]
           encoding = mt[1]
         else
@@ -40,7 +40,7 @@ module Mail
     end
 
     def encoded
-      map.sort { |a,b| a.first <=> b.first }.map do |key_name, value|
+      map.sort { |a,b| a.first.to_s <=> b.first.to_s }.map do |key_name, value|
         unless value.ascii_only?
           value = Mail::Encodings.param_encode(value)
           key_name = "#{key_name}*"
@@ -50,7 +50,7 @@ module Mail
     end
 
     def decoded
-      map.sort { |a,b| a.first <=> b.first }.map do |key_name, value|
+      map.sort { |a,b| a.first.to_s <=> b.first.to_s }.map do |key_name, value|
         %Q{#{key_name}=#{quote_token(value)}}
       end.join("; ")
     end

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