mail 2.4.4 → 2.6.3

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

@@ -1,29 +1,31 @@
 # 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
-    lwsp         = %Q| \t\r\n|
     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}*/
     TEXT          = /[#{text}]/ # + obs-text
     FIELD_NAME    = /[#{field_name}]+/
-    FIELD_BODY    = /.+/
+    FIELD_PREFIX  = /\A(#{FIELD_NAME})/
+    FIELD_BODY    = /.+/m
     FIELD_LINE    = /^[#{field_name}]+:\s*.+$/
+    FIELD_SPLIT   = /^(#{FIELD_NAME})\s*:\s*(#{FIELD_BODY})?$/
     HEADER_LINE   = /^([#{field_name}]+:\s*.+)$/
+    HEADER_SPLIT  = /#{CRLF}(?!#{WSP})/
 
     QP_UNSAFE     = /[^#{qp_safe}]/
     QP_SAFE       = /[#{qp_safe}]/
@@ -31,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/nil.rb

@@ -3,8 +3,10 @@
 # This is not loaded if ActiveSupport is already loaded
 
 class NilClass #:nodoc:
-  def blank?
-    true
+  unless nil.respond_to? :blank?
+    def blank?
+      true
+    end
   end
 
   def to_crlf

data/lib/mail/core_extensions/object.rb

@@ -1,13 +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
+unless Object.method_defined? :blank?
+  class Object
+    def blank?
+      if respond_to?(:empty?)
+        empty?
+      else
+        !self
+      end
     end
   end
 end

data/lib/mail/core_extensions/smtp.rb

@@ -5,21 +5,20 @@ module Net
     # http://svn.ruby-lang.org/cgi-bin/viewvc.cgi?view=rev&revision=30294
     #
     # Fixed in what will be Ruby 1.9.3 - tlsconnect also does not exist in some early versions of ruby
-    remove_method :tlsconnect if defined?(Net::SMTP.new.tlsconnect)
+    begin
+      alias_method :original_tlsconnect, :tlsconnect
 
-    def tlsconnect(s)
-      verified = false
-      s = OpenSSL::SSL::SSLSocket.new s, @ssl_context
-      logging "TLS connection started"
-      s.sync_close = true
-      s.connect
-      if @ssl_context.verify_mode != OpenSSL::SSL::VERIFY_NONE
-        s.post_connection_check(@address)
+      def tlsconnect(s)
+        verified = false
+        begin
+          original_tlsconnect(s).tap { verified = true }
+        ensure
+          unless verified
+            s.close rescue nil
+          end
+        end
       end
-      verified = true
-      s
-    ensure
-      s.close unless verified
+    rescue NameError
     end
   end
 end

data/lib/mail/core_extensions/string.rb

@@ -1,11 +1,24 @@
 # 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
+    # the common case.
+    CRLF_REGEX = Regexp.new("(?<!\r)\n|\r(?!\n)")
+  else
+    CRLF_REGEX = /\n|\r\n|\r/
+  end
+
   def to_crlf
-    to_str.gsub(/\n|\r\n|\r/) { "\r\n" }
+    to_str.gsub(CRLF_REGEX, CRLF)
   end
 
   def to_lf
-    to_str.gsub(/\n|\r\n|\r/) { "\n" }
+    to_str.gsub(/\r\n|\r/, LF)
   end
 
   unless String.instance_methods(false).map {|m| m.to_sym}.include?(:blank?)
@@ -15,12 +28,12 @@ class String #:nodoc:
   end
 
   unless method_defined?(:ascii_only?)
-    # Provides all strings with the Ruby 1.9 method of .ascii_only? and
-    # returns true or false
-    US_ASCII_REGEXP = %Q{\x00-\x7f}
+    # Backport from Ruby 1.9 checks for non-us-ascii characters.
     def ascii_only?
-      !(self =~ /[^#{US_ASCII_REGEXP}]/)
+      self !~ MATCH_NON_US_ASCII
     end
+
+    MATCH_NON_US_ASCII = /[^\x00-\x7f]/
   end
 
   def not_ascii_only?

data/lib/mail/elements/address.rb

@@ -1,17 +1,17 @@
 # encoding: utf-8
 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 it's component parts and allowing you to get the
+    # 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'
@@ -21,26 +21,23 @@ module Mail
     #  a.comments     #=> ['My email address']
     #  a.to_s         #=> 'Mikel Lindsaar <mikel@test.lindsaar.net> (My email address)'
     def initialize(value = nil)
-      @output_type = nil
-      @tree = nil
-      @raw_text = value
-      case
-      when value.nil?
+      @output_type = :decode
+      if value.nil?
         @parsed = false
-        return
+        @data = nil
       else
         parse(value)
       end
     end
-    
-    # Returns the raw imput of the passed in string, this is before it is passed
+
+    # Returns the raw input of the passed in string, this is before it is passed
     # by the parser.
     def raw
-      @raw_text
+      @data.raw
     end
 
     # Returns a correctly formatted address for the email going out.  If given
-    # an incorrectly formatted address as input, Mail::Address will do it's best
+    # an incorrectly formatted address as input, Mail::Address will do its best
     # to format it correctly.  This includes quoting display names as needed and
     # putting the address in angle brackets etc.
     #
@@ -48,37 +45,38 @@ module Mail
     #  a.format #=> 'Mikel Lindsaar <mikel@test.lindsaar.net> (My email address)'
     def format
       parse unless @parsed
-      case
-      when tree.nil?
-        ''
-      when display_name
-        [quote_phrase(display_name), "<#{address}>", format_comments].compact.join(" ")
+      if @data.nil?
+        EMPTY
+      elsif display_name
+        [quote_phrase(display_name), "<#{address}>", format_comments].compact.join(SPACE)
+      elsif address
+        [address, format_comments].compact.join(SPACE)
       else
-        [address, format_comments].compact.join(" ")
+        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
@@ -86,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'
@@ -99,57 +97,53 @@ 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
       parse unless @parsed
-      "#{obs_domain_list}#{get_local.strip}" if get_local
+      "#{@data.obs_domain_list}#{get_local.strip}" if get_local
     end
 
     # 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)| >"
@@ -157,48 +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
-      case
-      when value.nil?
-        nil
-      when value.class == String
-        self.tree = Mail::AddressList.new(value).address_nodes.first
-      else
-        self.tree = value
-      end
-    end
-    
-    
-    def get_domain
-      if tree.respond_to?(:angle_addr) && tree.angle_addr.respond_to?(:addr_spec) && tree.angle_addr.addr_spec.respond_to?(:domain)
-        @domain_text ||= tree.angle_addr.addr_spec.domain.text_value.strip
-      elsif tree.respond_to?(:domain)
-        @domain_text ||= tree.domain.text_value.strip
-      elsif tree.respond_to?(:addr_spec) && tree.addr_spec.respond_to?(:domain)
-        tree.addr_spec.domain.text_value.strip
-      else
-        nil
+      @data = nil
+
+      case value
+      when Mail::Parsers::AddressStruct
+        @data = value
+      when String
+        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
@@ -207,100 +195,53 @@ module Mail
     def strip_domain_comments(value)
       unless comments.blank?
         comments.each do |comment|
-          if get_domain && get_domain.include?("(#{comment})")
-            value = value.gsub("(#{comment})", '')
+          if @data.domain && @data.domain.include?("(#{comment})")
+            value = value.gsub("(#{comment})", EMPTY)
           end
         end
       end
       value.to_s.strip
     end
-    
-    def get_comments
-      if tree.respond_to?(:comments)
-        @comments = tree.comments.map { |c| unparen(c.text_value.to_str) } 
-      else
-        @comments = []
-      end
-    end
-    
+
     def get_display_name
-      if tree.respond_to?(:display_name)
-        name = unquote(tree.display_name.text_value.strip)
-        str = strip_all_comments(name.to_s)
-      elsif comments
-        if domain
-          str = strip_domain_comments(format_comments)
-        else
-          str = nil
-        end
-      else
-        nil
-      end
-      
-      if str.blank?
-        nil
-      else
-        str
+      if @data.display_name
+        str = strip_all_comments(@data.display_name.to_s)
+      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
-    end
-    
-    # Provides access to the Treetop parse tree for this address
-    def tree
-      @tree
+      unparen(str) unless str.blank?
     end
-    
-    def tree=(value)
-      @tree = value
-    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
       end
     end
-   
-    def obs_domain_list
-      if tree.respond_to?(:angle_addr)
-        obs = tree.angle_addr.elements.select { |e| e.respond_to?(:obs_domain_list) }
-        !obs.empty? ? obs.first.text_value : nil
-      else
-        nil
-      end
-    end
-    
+
     def get_local
-      case
-      when tree.respond_to?(:local_dot_atom_text)
-        tree.local_dot_atom_text.text_value
-      when tree.respond_to?(:angle_addr) && tree.angle_addr.respond_to?(:addr_spec) && tree.angle_addr.addr_spec.respond_to?(:local_part)
-        tree.angle_addr.addr_spec.local_part.text_value
-      when tree.respond_to?(:addr_spec) && tree.addr_spec.respond_to?(:local_part)
-        tree.addr_spec.local_part.text_value
-      else
-        tree && tree.respond_to?(:local_part) ? tree.local_part.text_value : nil
-      end
+      @data && @data.local
+    end
+
+    def get_domain
+      @data && @data.domain
+    end
+
+    def get_comments
+      @data && @data.comments
     end
-    
- 
   end
-end
+end

data/lib/mail/elements/address_list.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 module Mail
   class AddressList # :nodoc:
-    
+
     # Mail::AddressList is the class that parses To, From and other address fields from
     # emails passed into Mail.
     # 
@@ -18,57 +18,24 @@ module Mail
     #  a.addresses    #=> [#<Mail::Address:14943130 Address: |ada@test.lindsaar.net...
     #  a.group_names  #=> ["My Group"]
     def initialize(string)
-      if string.blank?
-        @address_nodes = []
-        return self
-      end
-      parser = Mail::AddressListsParser.new
-      if tree = parser.parse(string)
-        @address_nodes = tree.addresses
-      else
-        raise Mail::Field::ParseError.new(AddressListsParser, string, parser.failure_reason)
-      end
+      @addresses_grouped_by_group = nil
+      @address_list = Parsers::AddressListsParser.new.parse(string)
     end
     
     # Returns a list of address objects from the parsed line
     def addresses
-      @addresses ||= get_addresses.map do |address_tree|
-        Mail::Address.new(address_tree)
+      @addresses ||= @address_list.addresses.map do |address_data|
+        Mail::Address.new(address_data)
       end
     end
-    
-    # Returns a list of all recipient syntax trees that are not part of a group
-    def individual_recipients # :nodoc:
-      @individual_recipients ||= @address_nodes - group_recipients
-    end
-    
-    # Returns a list of all recipient syntax trees that are part of a group
-    def group_recipients # :nodoc:
-      @group_recipients ||= @address_nodes.select { |an| an.respond_to?(:group_name) }
+
+    def addresses_grouped_by_group
+      addresses.select(&:group).group_by(&:group)
     end
     
     # Returns the names as an array of strings of all groups
     def group_names # :nodoc:
-      group_recipients.map { |g| g.group_name.text_value }
-    end
-    
-    # Returns a list of address syntax trees
-    def address_nodes # :nodoc:
-      @address_nodes
-    end
-    
-    private
-    
-    def get_addresses
-      (individual_recipients + group_recipients.map { |g| get_group_addresses(g) }).flatten
-    end
-    
-    def get_group_addresses(g)
-      if g.group_list.respond_to?(:addresses)
-        g.group_list.addresses
-      else
-        []
-      end
+      @address_list.group_names
     end
   end
 end

data/lib/mail/elements/content_disposition_element.rb

@@ -5,13 +5,9 @@ module Mail
     include Mail::Utilities
     
     def initialize( string )
-      parser = Mail::ContentDispositionParser.new
-      if tree = parser.parse(cleaned(string))
-        @disposition_type = tree.disposition_type.text_value.downcase
-        @parameters = tree.parameters
-      else
-        raise Mail::Field::ParseError.new(ContentDispositionElement, string, parser.failure_reason)
-      end
+      content_disposition = Mail::Parsers::ContentDispositionParser.new.parse(cleaned(string))
+      @disposition_type = content_disposition.disposition_type
+      @parameters = content_disposition.parameters
     end
     
     def disposition_type

data/lib/mail/elements/content_location_element.rb

@@ -5,12 +5,8 @@ module Mail
     include Mail::Utilities
     
     def initialize( string )
-      parser = Mail::ContentLocationParser.new
-      if tree = parser.parse(string)
-        @location = tree.location.text_value
-      else
-        raise Mail::Field::ParseError.new(ContentLocationElement, string, parser.failure_reason)
-      end
+      content_location = Mail::Parsers::ContentLocationParser.new.parse(string)
+      @location = content_location.location
     end
     
     def location