mail 2.6.1 → 2.6.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b36c7dad6398232438e90270f9814eb04aeda138
-  data.tar.gz: 7dbe4c27bd7cab8569892fc5d6a676718aaf755b
+  metadata.gz: 3af499471587d4cb917ab992eb4bb45f19b9579e
+  data.tar.gz: f05e6aaf887b9a79b9252e7edc2dd74b81f7cb6c
 SHA512:
-  metadata.gz: 0628c04e7acf3cf0c3a801aff33a6008fe338ebd9a96a1d2b290ffbd98af1c287c0bdd958eda0ec77f495f498880dd69aaf8325da77e2f7d6ddb9f50396b1635
-  data.tar.gz: 1d813d0f8b64feb0a5a0561e7d031d795b54bf3d0160c02fcd35a9f11e04875dd6ea05a67b5a565b3d67486ce8941a14ac2d1362a288032eb3863641c533fece
+  metadata.gz: 75bb13148f71ffbbef303ca23f01b0c6c8a14aeea255bd528ba3ac0545c056b75ff3a420dc0578c7f15efd894a3367072496121c8479aa8ddc78e376c115168f
+  data.tar.gz: 0f26c569a7c210d3ee57d95cf5011f8ff4941f5c1cd054ef804f018aa829bec44db3fdde7ab2fe1a89056cf81a5e6d618735caaaf9ccf4e8810e4295256f012e

data/CHANGELOG.rdoc

@@ -1,10 +1,17 @@
 == HEAD
 
-Features:
+== Version 2.6.3 - Mon Nov 3 23:53 +1100 2014 Mikel Lindsaar <mikel@reinteractive.net>
+
+* #796 support uu encoding (grosser)
+
+== Version 2.6.2 (Unreleased) - Wed Oct 22 13:42 -0500 2014 Benjamin Fleischer <github@benjaminfleischer.com>
 
 Performance:
+* #681 - fewer hotspot object allocations (srawlins)
+* #815 - autoload parsers for load-time speed and memory usage (grosser)
 
 Bugs:
+* #736 - Mail.new copes with non-UTF8 messages marked as UTF8 (jeremy)
 
 == Version 2.6.1 - Sun Jun 8 15:34 +1100 2014 Mikel Lindsaar <mikel@reinteractive.net>
 

data/README.md

@@ -15,7 +15,7 @@ Built from my experience with TMail, it is designed to be a pure ruby
 implementation that makes generating, sending and parsing emails a no
 brainer.
 
-It is also designed form the ground up to work with the more modern versions
+It is also designed from the ground up to work with the more modern versions
 of Ruby.  This is because Ruby > 1.9 handles text encodings much more wonderfully
 than Ruby 1.8.x and so these features have been taken full advantage of in this
 library allowing Mail to handle a lot more messages more cleanly than TMail.
@@ -44,10 +44,10 @@ Compatibility
 
 Every Mail commit is tested by Travis on the [following platforms](https://github.com/mikel/mail/blob/master/.travis.yml)
 
-* ruby-1.8.7-p374 [ i686 ]
-* ruby-1.9.2-p320 [ x86_64 ]
-* ruby-1.9.3-p327 [ x86_64 ]
-* ruby-2.0.0-p451 [ x86_64 ]
+* ruby-1.8.7 [ i686 ]
+* ruby-1.9.2 [ x86_64 ]
+* ruby-1.9.3 [ x86_64 ]
+* ruby-2.0.0 [ x86_64 ]
 * ruby-2.1.2 [ x86_64 ]
 * ruby-head [ x86_64 ]
 * jruby [ x86_64 ]

data/lib/mail.rb

@@ -41,7 +41,7 @@ module Mail # :doc:
     require 'mail/multibyte'
   end
 
-  require 'mail/patterns'
+  require 'mail/constants'
   require 'mail/utilities'
   require 'mail/configuration'
 
@@ -76,13 +76,14 @@ 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'
 

data/lib/mail/body.rb

@@ -254,18 +254,19 @@ module Mail
         @parts = Mail::PartsList.new[val]
       end
     end
-    
+
     def split!(boundary)
       self.boundary = boundary
-      parts = raw_source.split(/(?:\A|\r\n)--#{Regexp.escape(boundary || "")}(?=(?:--)?\s*$)/)
+      parts = extract_parts
+
       # Make the preamble equal to the preamble (if any)
       self.preamble = parts[0].to_s.strip
       # Make the epilogue equal to the epilogue (if any)
-      self.epilogue = parts[-1].to_s.sub('--', '').strip
+      self.epilogue = parts[-1].to_s.strip
       parts[1...-1].to_a.each { |part| @parts << Mail::Part.new(part) }
       self
     end
-    
+
     def only_us_ascii?
       !(raw_source =~ /[^\x01-\x7f]/)
     end
@@ -275,6 +276,29 @@ module Mail
     end
     
     private
+
+    # split parts by boundary, ignore first part if empty, append final part when closing boundary was missing
+    def extract_parts
+      parts_regex = /
+        (?:                    # non-capturing group
+          \A                |  # start of string OR
+          \r\n                 # line break
+         )
+        (
+          --#{Regexp.escape(boundary || "")}  # boundary delimiter
+          (?:--)?                             # with non-capturing optional closing
+        )
+        (?=\s*$)                              # lookahead matching zero or more spaces followed by line-ending
+      /x
+      parts = raw_source.split(parts_regex).each_slice(2).to_a
+      parts.each_with_index { |(part, _), index| parts.delete_at(index) if index > 0 && part.blank? }
+
+      if parts.size > 1
+        final_separator = parts[-2][1]
+        parts << [""] if final_separator != "--#{boundary}--"
+      end
+      parts.map(&:first)
+    end
     
     def crlf_boundary
       "\r\n--#{boundary}\r\n"

data/lib/mail/{patterns.rb → constants.rb}

@@ -1,20 +1,20 @@
 # encoding: us-ascii
 module Mail
-  module Patterns
+  module Constants
     white_space = %Q|\x9\x20|
     text        = %Q|\x1-\x8\xB\xC\xE-\x7f|
     field_name  = %Q|\x21-\x39\x3b-\x7e|
     qp_safe     = %Q|\x20-\x3c\x3e-\x7e|
-    
+
     aspecial     = %Q|()<>[]:;@\\,."| # RFC5322
     tspecial     = %Q|()<>@,;:\\"/[]?=| # RFC2045
     sp           = %Q| |
     control      = %Q|\x00-\x1f\x7f-\xff|
-    
+
     if control.respond_to?(:force_encoding)
       control = control.force_encoding(Encoding::BINARY)
     end
-    
+
     CRLF          = /\r\n/
     WSP           = /[#{white_space}]/
     FWS           = /#{CRLF}#{WSP}*/
@@ -33,5 +33,23 @@ module Mail
     ATOM_UNSAFE   = /[#{Regexp.quote aspecial}#{control}#{sp}]/n
     PHRASE_UNSAFE = /[#{Regexp.quote aspecial}#{control}]/n
     TOKEN_UNSAFE  = /[#{Regexp.quote tspecial}#{control}#{sp}]/n
+    ENCODED_VALUE = /\=\?[^?]+\?([QB])\?[^?]*?\?\=/mi
+
+    EMPTY          = ''
+    SPACE          = ' '
+    UNDERSCORE     = '_'
+    HYPHEN         = '-'
+    COLON          = ':'
+    ASTERISK       = '*'
+    CR             = "\r"
+    LF             = "\n"
+    CR_ENCODED     = "=0D"
+    LF_ENCODED     = "=0A"
+    CAPITAL_M      = 'M'
+    EQUAL_LF       = "=\n"
+    NULL_SENDER    = '<>'
+
+    Q_VALUES       = ['Q','q']
+    B_VALUES       = ['B','b']
   end
 end

data/lib/mail/core_extensions/string.rb

@@ -1,6 +1,9 @@
 # encoding: utf-8
 class String #:nodoc:
 
+  CRLF = "\r\n"
+  LF   = "\n"
+
   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
@@ -11,11 +14,11 @@ class String #:nodoc:
   end
 
   def to_crlf
-    to_str.gsub(CRLF_REGEX, "\r\n")
+    to_str.gsub(CRLF_REGEX, CRLF)
   end
 
   def to_lf
-    to_str.gsub(/\r\n|\r/, "\n")
+    to_str.gsub(/\r\n|\r/, LF)
   end
 
   unless String.instance_methods(false).map {|m| m.to_sym}.include?(:blank?)

data/lib/mail/elements/address.rb

@@ -3,15 +3,15 @@ module Mail
   class Address
 
     include Mail::Utilities
-    
+
     # Mail::Address handles all email addresses in Mail.  It takes an email address string
     # and parses it, breaking it down into its component parts and allowing you to get the
     # address, comments, display name, name, local part, domain part and fully formatted
     # address.
-    # 
+    #
     # Mail::Address requires a correctly formatted email address per RFC2822 or RFC822.  It
     # handles all obsolete versions including obsolete domain routing on the local part.
-    # 
+    #
     #  a = Address.new('Mikel Lindsaar (My email address) <mikel@test.lindsaar.net>')
     #  a.format       #=> 'Mikel Lindsaar <mikel@test.lindsaar.net> (My email address)'
     #  a.address      #=> 'mikel@test.lindsaar.net'
@@ -25,12 +25,11 @@ module Mail
       if value.nil?
         @parsed = false
         @data = nil
-        return
       else
         parse(value)
       end
     end
-    
+
     # Returns the raw input of the passed in string, this is before it is passed
     # by the parser.
     def raw
@@ -47,37 +46,37 @@ module Mail
     def format
       parse unless @parsed
       if @data.nil?
-        ''
+        EMPTY
       elsif display_name
-        [quote_phrase(display_name), "<#{address}>", format_comments].compact.join(" ")
+        [quote_phrase(display_name), "<#{address}>", format_comments].compact.join(SPACE)
       elsif address
-        [address, format_comments].compact.join(" ")
+        [address, format_comments].compact.join(SPACE)
       else
         raw
       end
     end
 
-    # Returns the address that is in the address itself.  That is, the 
+    # Returns the address that is in the address itself.  That is, the
     # local@domain string, without any angle brackets or the like.
-    # 
+    #
     #  a = Address.new('Mikel Lindsaar (My email address) <mikel@test.lindsaar.net>')
     #  a.address #=> 'mikel@test.lindsaar.net'
     def address
       parse unless @parsed
       domain ? "#{local}@#{domain}" : local
     end
-    
+
     # Provides a way to assign an address to an already made Mail::Address object.
-    # 
+    #
     #  a = Address.new
     #  a.address = 'Mikel Lindsaar (My email address) <mikel@test.lindsaar.net>'
     #  a.address #=> 'mikel@test.lindsaar.net'
     def address=(value)
       parse(value)
     end
-    
+
     # Returns the display name of the email address passed in.
-    # 
+    #
     #  a = Address.new('Mikel Lindsaar (My email address) <mikel@test.lindsaar.net>')
     #  a.display_name #=> 'Mikel Lindsaar'
     def display_name
@@ -85,9 +84,9 @@ module Mail
       @display_name ||= get_display_name
       Encodings.decode_encode(@display_name.to_s, @output_type) if @display_name
     end
-    
+
     # Provides a way to assign a display name to an already made Mail::Address object.
-    # 
+    #
     #  a = Address.new
     #  a.address = 'mikel@test.lindsaar.net'
     #  a.display_name = 'Mikel Lindsaar'
@@ -98,7 +97,7 @@ module Mail
 
     # Returns the local part (the left hand side of the @ sign in the email address) of
     # the address
-    # 
+    #
     #  a = Address.new('Mikel Lindsaar (My email address) <mikel@test.lindsaar.net>')
     #  a.local #=> 'mikel'
     def local
@@ -108,47 +107,43 @@ module Mail
 
     # Returns the domain part (the right hand side of the @ sign in the email address) of
     # the address
-    # 
+    #
     #  a = Address.new('Mikel Lindsaar (My email address) <mikel@test.lindsaar.net>')
     #  a.domain #=> 'test.lindsaar.net'
     def domain
       parse unless @parsed
       strip_all_comments(get_domain) if get_domain
     end
-    
+
     # Returns an array of comments that are in the email, or an empty array if there
     # are no comments
-    # 
+    #
     #  a = Address.new('Mikel Lindsaar (My email address) <mikel@test.lindsaar.net>')
     #  a.comments #=> ['My email address']
     def comments
       parse unless @parsed
-      if get_comments.empty?
-        nil
-      else
-        get_comments.map { |c| c.squeeze(" ") }
-      end
+      get_comments.map { |c| c.squeeze(SPACE) } unless get_comments.empty?
     end
-    
+
     # Sometimes an address will not have a display name, but might have the name
     # as a comment field after the address.  This returns that name if it exists.
-    # 
+    #
     #  a = Address.new('mikel@test.lindsaar.net (Mikel Lindsaar)')
     #  a.name #=> 'Mikel Lindsaar'
     def name
       parse unless @parsed
       get_name
     end
-    
+
     # Returns the format of the address, or returns nothing
-    # 
+    #
     #  a = Address.new('Mikel Lindsaar (My email address) <mikel@test.lindsaar.net>')
     #  a.format #=> 'Mikel Lindsaar <mikel@test.lindsaar.net> (My email address)'
     def to_s
       parse unless @parsed
       format
     end
-    
+
     # Shows the Address object basic details, including the Address
     #  a = Address.new('Mikel (My email) <mikel@test.lindsaar.net>')
     #  a.inspect #=> "#<Mail::Address:14184910 Address: |Mikel <mikel@test.lindsaar.net> (My email)| >"
@@ -156,43 +151,42 @@ module Mail
       parse unless @parsed
       "#<#{self.class}:#{self.object_id} Address: |#{to_s}| >"
     end
-    
+
     def encoded
       @output_type = :encode
       format
     end
-    
+
     def decoded
       @output_type = :decode
       format
     end
 
+    def group
+      @data && @data.group
+    end
+
     private
-    
+
     def parse(value = nil)
       @parsed = true
+      @data = nil
 
       case value
-      when NilClass
-        @data = nil
-        nil
       when Mail::Parsers::AddressStruct
         @data = value
       when String
-        @raw_text = value
-        if value.blank?
-          @data = nil
-        else
+        unless value.blank?
           address_list = Mail::Parsers::AddressListsParser.new.parse(value)
           @data = address_list.addresses.first
         end
       end
     end
-    
+
     def strip_all_comments(string)
       unless comments.blank?
         comments.each do |comment|
-          string = string.gsub("(#{comment})", '')
+          string = string.gsub("(#{comment})", EMPTY)
         end
       end
       string.strip
@@ -202,53 +196,36 @@ module Mail
       unless comments.blank?
         comments.each do |comment|
           if @data.domain && @data.domain.include?("(#{comment})")
-            value = value.gsub("(#{comment})", '')
+            value = value.gsub("(#{comment})", EMPTY)
           end
         end
       end
       value.to_s.strip
     end
-    
+
     def get_display_name
       if @data.display_name
         str = strip_all_comments(@data.display_name.to_s)
-      elsif @data.comments
-        if @data.domain
-          str = strip_domain_comments(format_comments)
-        else
-          str = nil
-        end
-      else
-        nil
-      end
-      
-      if str.blank?
-        nil
-      else
-        str
+      elsif @data.comments && @data.domain
+        str = strip_domain_comments(format_comments)
       end
+
+      str unless str.blank?
     end
-    
+
     def get_name
       if display_name
         str = display_name
-      else
-        if comments
-          comment_text = comments.join(' ').squeeze(" ")
-          str = "(#{comment_text})"
-        end
+      elsif comments
+        str = "(#{comments.join(SPACE).squeeze(SPACE)})"
       end
 
-      if str.blank?
-        nil
-      else
-        unparen(str)
-      end
+      unparen(str) unless str.blank?
     end
-    
+
     def format_comments
       if comments
-        comment_text = comments.map {|c| escape_paren(c) }.join(' ').squeeze(" ")
+        comment_text = comments.map {|c| escape_paren(c) }.join(SPACE).squeeze(SPACE)
         @format_comments ||= "(#{comment_text})"
       else
         nil
@@ -262,7 +239,7 @@ module Mail
     def get_domain
       @data && @data.domain
     end
-    
+
     def get_comments
       @data && @data.comments
     end