mail 2.5.4 → 2.6.0

data/lib/mail/message.rb

@@ -240,7 +240,7 @@ module Mail
     # This method bypasses checking perform_deliveries and raise_delivery_errors,
     # so use with caution.
     #
-    # It still however fires off the intercepters and calls the observers callbacks if they are defined.
+    # It still however fires off the interceptors and calls the observers callbacks if they are defined.
     #
     # Returns self
     def deliver!
@@ -353,17 +353,23 @@ module Mail
       return false unless other.respond_to?(:encoded)
 
       if self.message_id && other.message_id
-        result = (self.encoded == other.encoded)
+        self.encoded == other.encoded
       else
         self_message_id, other_message_id = self.message_id, other.message_id
-        self.message_id, other.message_id = '<temp@test>', '<temp@test>'
-        result = self.encoded == other.encoded
-        self.message_id = "<#{self_message_id}>" if self_message_id
-        other.message_id = "<#{other_message_id}>" if other_message_id
-        result
+        begin
+          self.message_id, other.message_id = '<temp@test>', '<temp@test>'
+          self.encoded == other.encoded
+        ensure
+          self.message_id, other.message_id = self_message_id, other_message_id
+        end
       end
     end
 
+    def initialize_copy(original)
+      super
+      @header = @header.dup
+    end
+
     # Provides access to the raw source of the message as it was when it
     # was instantiated. This is set at initialization and so is untouched
     # by the parsers or decoder / encoders
@@ -1388,7 +1394,7 @@ module Mail
       header.has_date?
     end
 
-    # Returns true if the message has a Date field, the field may or may
+    # Returns true if the message has a Mime-Version field, the field may or may
     # not have a value, but the field exists or not.
     def has_mime_version?
       header.has_mime_version?
@@ -1594,7 +1600,7 @@ module Mail
     end
 
     # Returns an AttachmentsList object, which holds all of the attachments in
-    # the receiver object (either the entier email or a part within) and all
+    # the receiver object (either the entire email or a part within) and all
     # of its descendants.
     #
     # It also allows you to add attachments to the mail object directly, like so:
@@ -1974,8 +1980,9 @@ module Mail
     end
 
     def raw_source=(value)
-      value.force_encoding("binary") if RUBY_VERSION >= "1.9.1"
       @raw_source = value.to_crlf
+      @raw_source.force_encoding("binary") if RUBY_VERSION >= "1.9.1"
+      @raw_source
     end
 
     # see comments to body=. We take data and process it lazily
@@ -2128,7 +2135,7 @@ module Mail
         if perform_deliveries
           delivery_method.deliver!(self)
         end
-      rescue Exception => e # Net::SMTP errors or sendmail pipe errors
+      rescue => e # Net::SMTP errors or sendmail pipe errors
         raise e if raise_delivery_errors
       end
     end

data/lib/mail/multibyte/unicode.rb

@@ -341,7 +341,7 @@ module Mail
         def load
           begin
             @codepoints, @composition_exclusion, @composition_map, @boundary, @cp1252 = File.open(self.class.filename, 'rb') { |f| Marshal.load f.read }
-          rescue Exception => e
+          rescue => e
               raise IOError.new("Couldn't load the Unicode tables for UTF8Handler (#{e.message}), Mail::Multibyte is unusable")
           end
 

data/lib/mail/network/delivery_methods/sendmail.rb

@@ -50,7 +50,7 @@ module Mail
       smtp_from, smtp_to, message = check_delivery_params(mail)
 
       from = "-f #{self.class.shellquote(smtp_from)}"
-      to = smtp_to.map { |to| self.class.shellquote(to) }.join(' ')
+      to = smtp_to.map { |_to| self.class.shellquote(_to) }.join(' ')
 
       arguments = "#{settings[:arguments]} #{from} --"
       self.class.call(settings[:location], arguments, to, message)

data/lib/mail/network/delivery_methods/smtp.rb

@@ -132,15 +132,11 @@ module Mail
         openssl_verify_mode = "OpenSSL::SSL::VERIFY_#{openssl_verify_mode.upcase}".constantize
       end
 
-      if RUBY_VERSION < '1.9.0'
-        openssl_verify_mode
-      else
-        context = Net::SMTP.default_ssl_context
-        context.verify_mode = openssl_verify_mode
-        context.ca_path = settings[:ca_path] if settings[:ca_path]
-        context.ca_file = settings[:ca_file] if settings[:ca_file]
-        context
-      end
+      context = Net::SMTP.default_ssl_context
+      context.verify_mode = openssl_verify_mode
+      context.ca_path = settings[:ca_path] if settings[:ca_path]
+      context.ca_file = settings[:ca_file] if settings[:ca_file]
+      context
     end
   end
 end

data/lib/mail/network/retriever_methods/imap.rb

@@ -73,31 +73,35 @@ module Mail
       start do |imap|
         options[:read_only] ? imap.examine(options[:mailbox]) : imap.select(options[:mailbox])
 
-        message_ids = imap.uid_search(options[:keys])
-        message_ids.reverse! if options[:what].to_sym == :last
-        message_ids = message_ids.first(options[:count]) if options[:count].is_a?(Integer)
-        message_ids.reverse! if (options[:what].to_sym == :last && options[:order].to_sym == :asc) ||
+        uids = imap.uid_search(options[:keys])
+        uids.reverse! if options[:what].to_sym == :last
+        uids = uids.first(options[:count]) if options[:count].is_a?(Integer)
+        uids.reverse! if (options[:what].to_sym == :last && options[:order].to_sym == :asc) ||
                                 (options[:what].to_sym != :last && options[:order].to_sym == :desc)
 
         if block_given?
-          message_ids.each do |message_id|
-            fetchdata = imap.uid_fetch(message_id, ['RFC822'])[0]
+          uids.each do |uid|
+            uid = options[:uid].to_i unless options[:uid].nil?
+            fetchdata = imap.uid_fetch(uid, ['RFC822'])[0]
             new_message = Mail.new(fetchdata.attr['RFC822'])
             new_message.mark_for_delete = true if options[:delete_after_find]
             if block.arity == 3
-              yield new_message, imap, message_id
+              yield new_message, imap, uid
             else
               yield new_message
             end
-            imap.uid_store(message_id, "+FLAGS", [Net::IMAP::DELETED]) if options[:delete_after_find] && new_message.is_marked_for_delete?
+            imap.uid_store(uid, "+FLAGS", [Net::IMAP::DELETED]) if options[:delete_after_find] && new_message.is_marked_for_delete?
+            break unless options[:uid].nil?
           end
           imap.expunge if options[:delete_after_find]
         else
           emails = []
-          message_ids.each do |message_id|
-            fetchdata = imap.uid_fetch(message_id, ['RFC822'])[0]
+          uids.each do |uid|
+            uid = options[:uid].to_i unless options[:uid].nil?
+            fetchdata = imap.uid_fetch(uid, ['RFC822'])[0]
             emails << Mail.new(fetchdata.attr['RFC822'])
-            imap.uid_store(message_id, "+FLAGS", [Net::IMAP::DELETED]) if options[:delete_after_find]
+            imap.uid_store(uid, "+FLAGS", [Net::IMAP::DELETED]) if options[:delete_after_find]
+            break unless options[:uid].nil?
           end
           imap.expunge if options[:delete_after_find]
           emails.size == 1 && options[:count] == 1 ? emails.first : emails
@@ -111,8 +115,8 @@ module Mail
       mailbox = Net::IMAP.encode_utf7(mailbox)
 
       start do |imap|
-        imap.uid_search(['ALL']).each do |message_id|
-          imap.uid_store(message_id, "+FLAGS", [Net::IMAP::DELETED])
+        imap.uid_search(['ALL']).each do |uid|
+          imap.uid_store(uid, "+FLAGS", [Net::IMAP::DELETED])
         end
         imap.expunge
       end
@@ -137,6 +141,7 @@ module Mail
         options[:order]   ||= :asc
         options[:what]    ||= :first
         options[:keys]    ||= 'ALL'
+        options[:uid]     ||= nil
         options[:delete_after_find] ||= false
         options[:mailbox] = Net::IMAP.encode_utf7(options[:mailbox])
         options[:read_only] ||= false

data/lib/mail/parsers/address_lists_parser.rb

@@ -0,0 +1,132 @@
+module Mail::Parsers
+  class AddressListsParser
+    include Mail::Utilities
+
+    def parse(s)
+      address_list = AddressListStruct.new([],[])
+
+      if s.blank?
+        return address_list
+      end
+
+      actions, error = Ragel.parse(:address_lists, s)
+      if error
+        raise Mail::Field::ParseError.new(Mail::AddressList, s, error)
+      end
+
+
+      phrase_s = phrase_e = qstr_s = qstr = comment_s = nil
+      group_name_s = domain_s = group_name = nil
+      local_dot_atom_s = local_dot_atom_e = nil
+      local_dot_atom_pre_comment_e = nil
+      obs_domain_list_s = nil
+
+      address_s = 0
+      address = AddressStruct.new(nil, nil, [], nil, nil, nil, nil)
+      actions.each_slice(2) do |action_id, p|
+        action = Mail::Parsers::Ragel::ACTIONS[action_id]
+        case action
+
+        # Phrase
+        when :phrase_s then phrase_s = p
+        when :phrase_e then phrase_e = p-1
+
+        # Quoted String.
+        when :qstr_s then qstr_s = p
+        when :qstr_e then qstr = s[qstr_s..(p-1)]
+
+        # Comment
+        when :comment_s
+          comment_s = p unless comment_s
+        when :comment_e
+          if address
+            address.comments << s[comment_s..(p-2)]
+          end
+          comment_s = nil
+
+        # Group Name
+        when :group_name_s then group_name_s = p
+        when :group_name_e
+          if qstr
+            group = qstr
+            qstr = nil
+          else
+            group = s[group_name_s..(p-1)]
+            group_name_s = nil
+          end
+          address_list.group_names << group
+          group_name = group
+
+          # Start next address
+          address = AddressStruct.new(nil, nil, [], nil, nil, nil, nil)
+          address_s = p
+          address.group = group_name
+
+        # Address
+        when :address_s
+          address_s = p
+        when :address_e
+          # Ignore address end events if they don't have
+          # a matching address start event.
+          next if address_s.nil?
+          if address.local.nil? && local_dot_atom_pre_comment_e && local_dot_atom_s && local_dot_atom_e
+            if address.domain
+              address.local = s[local_dot_atom_s..local_dot_atom_e] if address
+            else
+              address.local = s[local_dot_atom_s..local_dot_atom_pre_comment_e] if address
+            end
+          end
+          address.raw = s[address_s..(p-1)]
+          address_list.addresses << address if address
+
+          # Start next address
+          address = AddressStruct.new(nil, nil, [], nil, nil, nil, nil)
+          address.group = group_name
+          address_s = nil
+
+        # Don't set the display name until the
+        # address has actually started. This allows
+        # us to choose quoted_s version if it
+        # exists and always use the 'full' phrase
+        # version.
+        when :angle_addr_s
+          if qstr
+            address.display_name = qstr
+            qstr = nil
+          elsif phrase_e
+            address.display_name = s[phrase_s..phrase_e].strip
+            phrase_e = phrase_s = nil
+          end
+
+        # Domain
+        when :domain_s
+          domain_s = p
+        when :domain_e
+          address.domain = s[domain_s..(p-1)].rstrip if address
+
+        # Local
+        when :local_dot_atom_s then local_dot_atom_s = p
+        when :local_dot_atom_e then local_dot_atom_e = p-1
+        when :local_dot_atom_pre_comment_e
+          local_dot_atom_pre_comment_e = p-1
+        when :local_quoted_string_e
+          address.local = '"' + qstr + '"' if address
+
+        # obs_domain_list
+        when :obs_domain_list_s then obs_domain_list_s = p
+        when :obs_domain_list_e
+          address.obs_domain_list = s[obs_domain_list_s..(p-1)]
+
+        else
+          raise Mail::Field::ParseError.new(Mail::AddressList, s, "Failed to process unknown action: #{action}")
+        end
+      end
+
+      if address_list.addresses.empty? && address_list.group_names.empty?
+        raise Mail::Field::ParseError.new(Mail::AddressList, s, "Didn't find any addresses or groups")
+      end
+
+      address_list
+    end
+  end
+end

data/lib/mail/parsers/content_disposition_parser.rb

@@ -0,0 +1,67 @@
+module Mail::Parsers
+  class ContentDispositionParser
+    include Mail::Utilities
+
+    def parse(s)
+      content_disposition = ContentDispositionStruct.new("", nil)
+      if s.blank?
+        return content_disposition
+      end
+
+      actions, error = Ragel.parse(:content_disposition, s)
+      if error
+        raise Mail::Field::ParseError.new(Mail::ContentDispositionElement, s, error)
+      end
+
+      content_disposition.parameters = []
+
+      disp_type_s = param_attr_s = param_attr = qstr_s = qstr = param_val_s = nil
+      actions.each_slice(2) do |action_id, p|
+        action = Mail::Parsers::Ragel::ACTIONS[action_id]
+        case action
+
+        # Disposition Type
+        when :disp_type_s then disp_type_s = p
+        when :disp_type_e
+          content_disposition.disposition_type = s[disp_type_s..(p-1)].downcase
+
+        # Parameter Attribute
+        when :param_attr_s then param_attr_s = p
+        when :param_attr_e then param_attr = s[param_attr_s..(p-1)]
+
+        # Quoted String.
+        when :qstr_s then qstr_s = p
+        when :qstr_e then qstr = s[qstr_s..(p-1)]
+
+        # Parameter Value
+        when :param_val_s then param_val_s = p
+        when :param_val_e
+          if param_attr.nil?
+            raise Mail::Field::ParseError.new(Mail::ContentDispositionElement, s, "no attribute for value")
+          end
+
+          # Use quoted string value if one exists, otherwise use parameter value
+          if qstr
+            value = qstr
+          else
+            value = s[param_val_s..(p-1)]
+          end
+
+          content_disposition.parameters <<  { param_attr => value }
+          param_attr = nil
+          qstr = nil
+
+        else
+          raise Mail::Field::ParseError.new(Mail::ContentDispositionElement, s, "Failed to process unknown action: #{action}")
+        end
+      end
+
+      content_disposition
+    end
+
+    private
+    def cleaned(string)
+      string =~ /(.+);\s*$/ ? $1 : string
+    end
+  end
+end

data/lib/mail/parsers/content_location_parser.rb

@@ -0,0 +1,35 @@
+module Mail::Parsers
+  class ContentLocationParser
+    def parse(s)
+      content_location = ContentLocationStruct.new(nil)
+      if s.blank?
+        return content_location
+      end
+
+      actions, error = Ragel.parse(:content_location, s)
+      if error
+        raise Mail::Field::ParseError.new(Mail::ContentLocationElement, s, error)
+      end
+
+      qstr_s = token_string_s = nil
+      actions.each_slice(2) do |action_id, p|
+        action = Mail::Parsers::Ragel::ACTIONS[action_id]
+        case action
+
+        # Quoted String.
+        when :qstr_s then qstr_s = p
+        when :qstr_e then content_location.location = s[qstr_s..(p-1)]
+
+        # Token String
+        when :token_string_s then token_string_s = p
+        when :token_string_e
+          content_location.location = s[token_string_s..(p-1)]
+
+        else
+          raise Mail::Field::ParseError.new(Mail::ContentLocationElement, s, "Failed to process unknown action: #{action}")
+        end
+      end
+      content_location
+    end
+  end
+end

data/lib/mail/parsers/content_transfer_encoding_parser.rb

@@ -0,0 +1,33 @@
+module Mail::Parsers
+  class ContentTransferEncodingParser
+
+    def parse(s)
+      content_transfer_encoding = ContentTransferEncodingStruct.new("")
+      if s.blank?
+        return content_transfer_encoding
+      end
+
+      actions, error = Ragel.parse(:content_transfer_encoding, s)
+      if error
+        raise Mail::Field::ParseError.new(Mail::ContentTransferEncodingElement, s, error)
+      end
+
+      encoding_s = nil
+      actions.each_slice(2) do |action_id, p|
+        action = Mail::Parsers::Ragel::ACTIONS[action_id]
+        case action
+
+        # Encoding
+        when :encoding_s then encoding_s = p
+        when :encoding_e
+          content_transfer_encoding.encoding = s[encoding_s..(p-1)].downcase
+
+        else
+          raise Mail::Field::ParseError.new(Mail::ContentTransferEncodingElement, s, "Failed to process unknown action: #{action}")
+        end
+      end
+
+      content_transfer_encoding
+    end
+  end
+end

data/lib/mail/parsers/content_type_parser.rb

@@ -0,0 +1,64 @@
+module Mail::Parsers
+  class ContentTypeParser
+    include Mail::Utilities
+
+    def parse(s)
+      actions, error = Ragel.parse(:content_type, s)
+      if error
+        raise Mail::Field::ParseError.new(Mail::ContentTypeElement, s, error)
+      end
+
+      content_type = ContentTypeStruct.new(nil,nil,[])
+
+      content_type.parameters = []
+
+      main_type_s = sub_type_s = param_attr_s = param_attr = nil
+      qstr_s = qstr = param_val_s = nil
+      actions.each_slice(2) do |action_id, p|
+        action = Mail::Parsers::Ragel::ACTIONS[action_id]
+        case action
+
+        # Main Type
+        when :main_type_s then main_type_s = p
+        when :main_type_e then
+          content_type.main_type = s[main_type_s..(p-1)].downcase
+
+        # Sub Type
+        when :sub_type_s then sub_type_s = p
+        when :sub_type_e
+          content_type.sub_type = s[sub_type_s..(p-1)].downcase
+
+        # Parameter Attribute
+        when :param_attr_s then param_attr_s = p
+        when :param_attr_e then param_attr = s[param_attr_s..(p-1)]
+
+        # Quoted String.
+        when :qstr_s then qstr_s = p
+        when :qstr_e then qstr = s[qstr_s..(p-1)]
+
+        # Parameter Value
+        when :param_val_s then param_val_s = p
+        when :param_val_e
+          if param_attr.nil?
+            raise Mail::Field::ParseError.new(Mail::ContentTypeElement, s, "no attribute for value")
+          end
+
+          # Use quoted s value if one exists, otherwise use parameter value
+          if qstr
+            value = qstr
+          else
+            value = s[param_val_s..(p-1)]
+          end
+
+          content_type.parameters <<  { param_attr => value }
+          param_attr = nil
+          qstr = nil
+
+        else
+          raise Mail::Field::ParseError.new(Mail::ContentTypeElement, s, "Failed to process unknown action: #{action}")
+        end
+      end
+      content_type
+    end
+  end
+end

data/lib/mail/parsers/date_time_parser.rb

@@ -0,0 +1,36 @@
+module Mail::Parsers
+  class DateTimeParser
+    include Mail::Utilities
+
+    def parse(s)
+      date_time = DateTimeStruct.new([])
+
+      actions, error = Ragel.parse(:date_time, s)
+      if error
+        raise Mail::Field::ParseError.new(Mail::DateTimeElement, s, error)
+      end
+
+      date_s = time_s = nil
+      actions.each_slice(2) do |action_id, p|
+        action = Mail::Parsers::Ragel::ACTIONS[action_id]
+        case action
+
+        # Date
+        when :date_s then date_s = p
+        when :date_e
+          date_time.date_string = s[date_s..(p-1)]
+
+        # Time
+        when :time_s then time_s = p
+        when :time_e
+          date_time.time_string = s[time_s..(p-1)]
+
+        else
+          raise Mail::Field::ParseError.new(Mail::DateTimeElement, s, "Failed to process unknown action: #{action}")
+        end
+      end
+
+      date_time
+    end
+  end
+end

data/lib/mail/parsers/envelope_from_parser.rb

@@ -0,0 +1,45 @@
+module Mail::Parsers
+  class EnvelopeFromParser
+    def parse(s)
+      envelope_from = EnvelopeFromStruct.new
+      if s.blank?
+        return envelope_from
+      end
+
+      actions, error = Ragel.parse(:envelope_from, s)
+      if error
+        raise Mail::Field::ParseError.new(Mail::EnvelopeFromElement, s, error)
+      end
+
+      address_s = ctime_date_s = nil
+      envelope_from = EnvelopeFromStruct.new
+      actions.each_slice(2) do |action_id, p|
+        action = Mail::Parsers::Ragel::ACTIONS[action_id]
+        case action
+
+        # Address
+        when :address_s then address_s = p
+        when :address_e
+          envelope_from.address = s[address_s..(p-1)].rstrip
+
+        # ctime_date
+        when :ctime_date_s then ctime_date_s = p
+        when :ctime_date_e
+          envelope_from.ctime_date = s[ctime_date_s..(p-1)]
+
+        # ignored actions
+        when :angle_addr_s, :comment_e, :comment_s,
+             :domain_e, :domain_s, :local_dot_atom_e,
+             :local_dot_atom_pre_comment_e,
+             :local_dot_atom_pre_comment_s,
+             :local_dot_atom_s, :qstr_e, :qstr_s
+          nil
+
+        else
+          raise Mail::Field::ParseError.new(Mail::EnvelopeFromElement, s, "Failed to process unknown action: #{action}")
+        end
+      end
+      envelope_from
+    end
+  end
+end

data/lib/mail/parsers/message_ids_parser.rb

@@ -0,0 +1,39 @@
+module Mail::Parsers
+  class MessageIdsParser
+    def parse(s)
+      if s.blank?
+        return MessageIdsStruct.new
+      end
+
+      message_ids = MessageIdsStruct.new([])
+
+      actions, error = Ragel.parse(:message_ids, s)
+      if error
+        raise Mail::Field::ParseError.new(Mail::MessageIdsElement, s, error)
+      end
+
+      msg_id_s = nil
+      actions.each_slice(2) do |action_id, p|
+        action = Mail::Parsers::Ragel::ACTIONS[action_id]
+        case action
+
+        # Message Ids
+        when :msg_id_s then msg_id_s = p
+        when :msg_id_e
+          message_ids.message_ids << s[msg_id_s..(p-1)].rstrip
+
+        when :domain_e, :domain_s, :local_dot_atom_e,
+          :local_dot_atom_pre_comment_e,
+          :local_dot_atom_pre_comment_s,
+          :local_dot_atom_s
+
+          # ignored actions
+
+        else
+          raise Mail::Field::ParseError.new(Mail::MessageIdsElement, s, "Failed to process unknown action: #{action}")
+        end
+      end
+      message_ids
+    end
+  end
+end

data/lib/mail/parsers/mime_version_parser.rb

@@ -0,0 +1,41 @@
+module Mail::Parsers
+  class MimeVersionParser
+    include Mail::Utilities
+
+    def parse(s)
+      if s.blank?
+        return MimeVersionStruct.new("", nil)
+      end
+
+      mime_version = MimeVersionStruct.new
+
+      actions, error = Ragel.parse(:mime_version, s)
+      if error
+        raise Mail::Field::ParseError.new(Mail::MimeVersionElement, s, error)
+      end
+
+      major_digits_s = minor_digits_s = nil
+      actions.each_slice(2) do |action_id, p|
+        action = Mail::Parsers::Ragel::ACTIONS[action_id]
+        case action
+
+        # Major Digits
+        when :major_digits_s then major_digits_s = p
+        when :major_digits_e
+          mime_version.major = s[major_digits_s..(p-1)]
+
+        # Minor Digits
+        when :minor_digits_s then minor_digits_s = p
+        when :minor_digits_e
+          mime_version.minor = s[minor_digits_s..(p-1)]
+
+        when :comment_e, :comment_s then nil
+
+        else
+          raise Mail::Field::ParseError.new(Mail::MimeVersionElement, s, "Failed to process unknown action: #{action}")
+        end
+      end
+      mime_version
+    end
+  end
+end