mail 2.5.2 → 2.6.0

data/lib/mail/elements/address.rb

@@ -1,11 +1,11 @@
 # 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.
     # 
@@ -21,26 +21,24 @@ 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
+        @data = nil
         return
       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,13 +46,14 @@ module Mail
     #  a.format #=> 'Mikel Lindsaar <mikel@test.lindsaar.net> (My email address)'
     def format
       parse unless @parsed
-      case
-      when tree.nil?
+      if @data.nil?
         ''
-      when display_name
+      elsif display_name
         [quote_phrase(display_name), "<#{address}>", format_comments].compact.join(" ")
-      else
+      elsif address
         [address, format_comments].compact.join(" ")
+      else
+        raw
       end
     end
 
@@ -104,7 +103,7 @@ module Mail
     #  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
@@ -172,29 +171,24 @@ module Mail
     
     def parse(value = nil)
       @parsed = true
-      case
-      when value.nil?
+
+      case value
+      when NilClass
+        @data = nil
         nil
-      when value.class == String
-        self.tree = Mail::AddressList.new(value).address_nodes.first
-      else
-        self.tree = value
+      when Mail::Parsers::AddressStruct
+        @data = value
+      when String
+        @raw_text = value
+        if value.blank?
+          @data = nil
+        else
+          address_list = Mail::Parsers::AddressListsParser.new.parse(value)
+          @data = address_list.addresses.first
+        end
       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
-      end
-    end
-
     def strip_all_comments(string)
       unless comments.blank?
         comments.each do |comment|
@@ -207,7 +201,7 @@ module Mail
     def strip_domain_comments(value)
       unless comments.blank?
         comments.each do |comment|
-          if get_domain && get_domain.include?("(#{comment})")
+          if @data.domain && @data.domain.include?("(#{comment})")
             value = value.gsub("(#{comment})", '')
           end
         end
@@ -215,20 +209,11 @@ module Mail
       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
+      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
@@ -261,15 +246,6 @@ module Mail
       end
     end
     
-    # Provides access to the Treetop parse tree for this address
-    def tree
-      @tree
-    end
-    
-    def tree=(value)
-      @tree = value
-    end
-    
     def format_comments
       if comments
         comment_text = comments.map {|c| escape_paren(c) }.join(' ').squeeze(" ")
@@ -278,29 +254,17 @@ module Mail
         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,34 @@ 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
+      return @addresses_grouped_by_group if @addresses_grouped_by_group
+
+      @addresses_grouped_by_group = {}
+
+      @address_list.addresses.each do |address_data|
+        if group = address_data.group
+          @addresses_grouped_by_group[group] ||= []
+          @addresses_grouped_by_group[group] << Mail::Address.new(address_data)
+        end
+      end
+      @addresses_grouped_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

data/lib/mail/elements/content_transfer_encoding_element.rb

@@ -4,16 +4,9 @@ module Mail
     
     include Mail::Utilities
     
-    def initialize( string )
-      parser = Mail::ContentTransferEncodingParser.new
-      case
-      when string.blank?
-        @encoding = ''
-      when tree = parser.parse(string.to_s.downcase)
-        @encoding = tree.encoding.text_value
-      else
-        raise Mail::Field::ParseError.new(ContentTransferEncodingElement, string, parser.failure_reason)
-      end
+    def initialize(string)
+      content_transfer_encoding = Mail::Parsers::ContentTransferEncodingParser.new.parse(string)
+      @encoding = content_transfer_encoding.encoding
     end
     
     def encoding

data/lib/mail/elements/content_type_element.rb

@@ -5,14 +5,10 @@ module Mail
     include Mail::Utilities
     
     def initialize( string )
-      parser = Mail::ContentTypeParser.new
-      if tree = parser.parse(cleaned(string))
-        @main_type = tree.main_type.text_value.downcase
-        @sub_type = tree.sub_type.text_value.downcase
-        @parameters = tree.parameters
-      else
-        raise Mail::Field::ParseError.new(ContentTypeElement, string, parser.failure_reason)
-      end
+      content_type = Mail::Parsers::ContentTypeParser.new.parse(cleaned(string))
+      @main_type = content_type.main_type
+      @sub_type = content_type.sub_type
+      @parameters = content_type.parameters
     end
     
     def main_type

data/lib/mail/elements/date_time_element.rb

@@ -5,13 +5,9 @@ module Mail
     include Mail::Utilities
     
     def initialize( string )
-      parser = Mail::DateTimeParser.new
-      if tree = parser.parse(string)
-        @date_string = tree.date.text_value
-        @time_string = tree.time.text_value
-      else
-        raise Mail::Field::ParseError.new(DateTimeElement, string, parser.failure_reason)
-      end
+      date_time = Mail::Parsers::DateTimeParser.new.parse(string)
+      @date_string = date_time.date_string
+      @time_string = date_time.time_string
     end
     
     def date_string

data/lib/mail/elements/envelope_from_element.rb

@@ -5,17 +5,9 @@ module Mail
     include Mail::Utilities
     
     def initialize( string )
-      parser = Mail::EnvelopeFromParser.new
-      if @tree = parser.parse(string)
-        @address = tree.addr_spec.text_value.strip
-        @date_time = ::DateTime.parse("#{tree.ctime_date.text_value}")
-      else
-        raise Mail::Field::ParseError.new(EnvelopeFromElement, string, parser.failure_reason)
-      end
-    end
-    
-    def tree
-      @tree
+      @envelope_from = Mail::Parsers::EnvelopeFromParser.new.parse(string)
+      @address = @envelope_from.address
+      @date_time = ::DateTime.parse(@envelope_from.ctime_date)
     end
     
     def date_time
@@ -26,8 +18,21 @@ module Mail
       @address
     end
     
-    def to_s(*args)
-      "#{@info}; #{@date_time.to_s(*args)}"
+    # RFC 4155:
+    #   a timestamp indicating the UTC date and time when the message
+    #   was originally received, conformant with the syntax of the
+    #   traditional UNIX 'ctime' output sans timezone (note that the
+    #   use of UTC precludes the need for a timezone indicator);
+    def formatted_date_time
+      if @date_time.respond_to?(:ctime)
+        @date_time.ctime
+      else
+        @date_time.strftime '%a %b %e %T %Y'
+      end
+    end
+
+    def to_s
+      "#{@address} #{formatted_date_time}"
     end
     
   end

data/lib/mail/elements/message_ids_element.rb

@@ -5,12 +5,7 @@ module Mail
     include Mail::Utilities
     
     def initialize(string)
-      parser = Mail::MessageIdsParser.new
-      if tree = parser.parse(string)
-        @message_ids = tree.message_ids.map { |msg_id| clean_msg_id(msg_id.text_value) }
-      else
-        raise Mail::Field::ParseError.new(MessageIdsElement, string, parser.failure_reason)
-      end
+      @message_ids = Mail::Parsers::MessageIdsParser.new.parse(string).message_ids.map { |msg_id| clean_msg_id(msg_id) }
     end
     
     def message_ids

data/lib/mail/elements/mime_version_element.rb

@@ -5,13 +5,9 @@ module Mail
     include Mail::Utilities
     
     def initialize( string )
-      parser = Mail::MimeVersionParser.new
-      if tree = parser.parse(string)
-        @major = tree.major.text_value
-        @minor = tree.minor.text_value
-      else
-        raise Mail::Field::ParseError.new(MimeVersionElement, string, parser.failure_reason)
-      end
+      mime_version = Mail::Parsers::MimeVersionParser.new.parse(string)
+      @major = mime_version.major
+      @minor = mime_version.minor
     end
     
     def major

data/lib/mail/elements/phrase_list.rb

@@ -5,16 +5,11 @@ module Mail
     include Mail::Utilities
     
     def initialize(string)
-      parser = Mail::PhraseListsParser.new
-      if tree = parser.parse(string)
-        @phrases = tree.phrases
-      else
-        raise Mail::Field::ParseError.new(PhraseList, string, parser.failure_reason)
-      end
+      @phrase_lists = Mail::Parsers::PhraseListsParser.new.parse(string)
     end
     
     def phrases
-      @phrases.map { |p| unquote(p.text_value) }
+      @phrase_lists.phrases.map { |p| unquote(p) }
     end
 
   end

data/lib/mail/elements/received_element.rb

@@ -5,13 +5,9 @@ module Mail
     include Mail::Utilities
     
     def initialize( string )
-      parser = Mail::ReceivedParser.new
-      if tree = parser.parse(string)
-        @date_time = ::DateTime.parse("#{tree.date_time.date.text_value} #{tree.date_time.time.text_value}")
-        @info = tree.name_val_list.text_value
-      else
-        raise Mail::Field::ParseError.new(ReceivedElement, string, parser.failure_reason)
-      end
+      received = Mail::Parsers::ReceivedParser.new.parse(string)
+      @date_time = ::DateTime.parse("#{received.date} #{received.time}")
+      @info = received.info
     end
     
     def date_time

data/lib/mail/encodings/quoted_printable.rb

@@ -12,13 +12,14 @@ module Mail
         EightBit.can_encode? str
       end
 
-      # Decode the string from Quoted-Printable
+      # Decode the string from Quoted-Printable. Cope with hard line breaks
+      # that were incorrectly encoded as hex instead of literal CRLF.
       def self.decode(str)
-        str.unpack("M*").first
+        str.gsub(/(?:=0D=0A|=0D|=0A)\r\n/, "\r\n").unpack("M*").first.to_lf
       end
 
       def self.encode(str)
-        [str].pack("M").to_crlf
+        [str.to_lf].pack("M").to_crlf
       end
 
       def self.cost(str)

data/lib/mail/encodings.rb

@@ -53,7 +53,7 @@ module Mail
     # Encodes a parameter value using URI Escaping, note the language field 'en' can
     # be set using Mail::Configuration, like so:
     #
-    #  Mail.defaults.do
+    #  Mail.defaults do
     #    param_encode_language 'jp'
     #  end
     #
@@ -114,41 +114,40 @@ 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.index("=?")
+      return str unless str =~ /\=\?[^?]+\?[QB]\?[^?]+?\?\=/xmi
 
-      str = str.gsub(/\?=(\s*)=\?/, '?==?') # Remove whitespaces between 'encoded-word's
+      lines = collapse_adjacent_encodings(str)
 
       # Split on white-space boundaries with capture, so we capture the white-space as well
-      str.split(/([ \t])/).map do |text|
-        if text.index('=?') .nil?
-          text
-        else
-          # Join QP encoded-words that are adjacent to avoid decoding partial chars
-          text.gsub!(/\?\=\=\?.+?\?[Qq]\?/m, '') if text =~ /\?==\?/
-
-          # 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
+      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
           end
         end
-      end.join("")
+      end.flatten.join("")
     end
 
     # Takes an encoded string of the format =?<encoding>?[QB]?<string>?=
     def Encodings.unquote_and_convert_to(str, to_encoding)
       output = value_decode( str ).to_s # output is already converted to UTF-8
-      
+
       if 'utf8' == to_encoding.to_s.downcase.gsub("-", "")
         output
       elsif to_encoding
@@ -157,7 +156,7 @@ module Mail
             output.encode(to_encoding)
           else
             require 'iconv'
-            Iconv.iconv(to_encoding, 'UTF-8', output).first 
+            Iconv.iconv(to_encoding, 'UTF-8', output).first
           end
         rescue Iconv::IllegalSequence, Iconv::InvalidEncoding, Errno::EINVAL
           # the 'from' parameter specifies a charset other than what the text
@@ -194,8 +193,8 @@ module Mail
         if word.ascii_only?
           word
         else
-          previous_non_ascii = tokens[i-1] && !tokens[i-1].ascii_only?
-          if previous_non_ascii
+          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)
@@ -268,5 +267,38 @@ module Mail
     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
+    end
+
+    # When the encoded string consists of multiple lines, lines with the same
+    # encoding (Q or B) can be joined together.
+    #
+    # String has to be of the format =?<encoding>?[QB]?<string>?=
+    def Encodings.collapse_adjacent_encodings(str)
+      lines = str.split(/(\?=)\s*(=\?)/).each_slice(2).map(&:join)
+      results = []
+      previous_encoding = nil
+
+      lines.each do |line|
+        encoding = split_value_encoding_from_string(line)
+
+        if encoding == previous_encoding
+          line = results.pop + line
+        end
+
+        previous_encoding = encoding
+        results << line
+      end
+
+      results
+    end
   end
 end

data/lib/mail/envelope.rb

@@ -14,11 +14,6 @@ module Mail
       super(FIELD_NAME, strip_field(FIELD_NAME, args.last))
     end
     
-    def tree
-      @element ||= Mail::EnvelopeFromElement.new(value)
-      @tree ||= @element.tree
-    end
-    
     def element
       @element ||= Mail::EnvelopeFromElement.new(value)
     end