mail-portertech 2.6.2.edge

data/lib/mail/check_delivery_params.rb

@@ -0,0 +1,20 @@
+module Mail
+  module CheckDeliveryParams
+    def check_delivery_params(mail)
+      if mail.smtp_envelope_from.blank?
+        raise ArgumentError.new('An SMTP From address is required to send a message. Set the message smtp_envelope_from, return_path, sender, or from address.')
+      end
+
+      if mail.smtp_envelope_to.blank?
+        raise ArgumentError.new('An SMTP To address is required to send a message. Set the message smtp_envelope_to, to, cc, or bcc address.')
+      end
+
+      message = mail.encoded if mail.respond_to?(:encoded)
+      if message.blank?
+        raise ArgumentError.new('An encoded message is required to send an email')
+      end
+
+      [mail.smtp_envelope_from, mail.smtp_envelope_to, message]
+    end
+  end
+end

data/lib/mail/configuration.rb

@@ -0,0 +1,75 @@
+# encoding: utf-8
+#
+# Thanks to Nicolas Fouché for this wrapper
+#
+require 'singleton'
+
+module Mail
+
+  # The Configuration class is a Singleton used to hold the default
+  # configuration for all Mail objects.
+  #
+  # Each new mail object gets a copy of these values at initialization
+  # which can be overwritten on a per mail object basis.
+  class Configuration
+    include Singleton
+
+    def initialize
+      @delivery_method  = nil
+      @retriever_method = nil
+      super
+    end
+
+    def delivery_method(method = nil, settings = {})
+      return @delivery_method if @delivery_method && method.nil?
+      @delivery_method = lookup_delivery_method(method).new(settings)
+    end
+
+    def lookup_delivery_method(method)
+      case method.is_a?(String) ? method.to_sym : method
+      when nil
+        Mail::SMTP
+      when :smtp
+        Mail::SMTP
+      when :sendmail
+        Mail::Sendmail
+      when :exim
+        Mail::Exim
+      when :file
+        Mail::FileDelivery
+      when :smtp_connection
+        Mail::SMTPConnection
+      when :test
+        Mail::TestMailer
+      else
+        method
+      end
+    end
+
+    def retriever_method(method = nil, settings = {})
+      return @retriever_method if @retriever_method && method.nil?
+      @retriever_method = lookup_retriever_method(method).new(settings)
+    end
+
+    def lookup_retriever_method(method)
+      case method
+      when nil
+        Mail::POP3
+      when :pop3
+        Mail::POP3
+      when :imap
+        Mail::IMAP
+      when :test
+        Mail::TestRetriever
+      else
+        method
+      end
+    end
+
+    def param_encode_language(value = nil)
+      value ? @encode_language = value : @encode_language ||= 'en'
+    end
+
+  end
+
+end

data/lib/mail/core_extensions/nil.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+# This is not loaded if ActiveSupport is already loaded
+
+class NilClass #:nodoc:
+  unless nil.respond_to? :blank?
+    def blank?
+      true
+    end
+  end
+
+  def to_crlf
+    ''
+  end
+
+  def to_lf
+    ''
+  end
+end

data/lib/mail/core_extensions/object.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+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

@@ -0,0 +1,24 @@
+# encoding: utf-8
+module Net
+  class SMTP
+    # This is a backport of r30294 from ruby trunk because of a bug in net/smtp.
+    # 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
+    begin
+      alias_method :original_tlsconnect, :tlsconnect
+
+      def tlsconnect(s)
+        verified = false
+        begin
+          original_tlsconnect(s).tap { verified = true }
+        ensure
+          unless verified
+            s.close rescue nil
+          end
+        end
+      end
+    rescue NameError
+    end
+  end
+end

data/lib/mail/core_extensions/string.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+class String #:nodoc:
+
+  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(CRLF_REGEX, "\r\n")
+  end
+
+  def to_lf
+    to_str.gsub(/\r\n|\r/, "\n")
+  end
+
+  unless String.instance_methods(false).map {|m| m.to_sym}.include?(:blank?)
+    def blank?
+      self !~ /\S/
+    end
+  end
+
+  unless method_defined?(:ascii_only?)
+    # Backport from Ruby 1.9 checks for non-us-ascii characters.
+    def ascii_only?
+      self !~ MATCH_NON_US_ASCII
+    end
+
+    MATCH_NON_US_ASCII = /[^\x00-\x7f]/
+  end
+
+  def not_ascii_only?
+    !ascii_only?
+  end
+
+  unless method_defined?(:bytesize)
+    alias :bytesize :length
+  end
+end

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

@@ -0,0 +1,145 @@
+# 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
+
+  if Module.method(:const_get).arity == 1
+    # Tries to find a constant with the name specified in the argument string:
+    #
+    #   "Module".constantize     # => Module
+    #   "Test::Unit".constantize # => Test::Unit
+    #
+    # The name is assumed to be the one of a top-level constant, no matter whether
+    # it starts with "::" or not. No lexical context is taken into account:
+    #
+    #   C = 'outside'
+    #   module M
+    #     C = 'inside'
+    #     C               # => 'inside'
+    #     "C".constantize # => 'outside', same as ::C
+    #   end
+    #
+    # NameError is raised when the name is not in CamelCase or the constant is
+    # unknown.
+    def constantize
+      names = self.split('::')
+      names.shift if names.empty? || names.first.empty?
+
+      constant = Object
+      names.each do |name|
+        constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+      end
+      constant
+    end
+  else
+    def constantize #:nodoc:
+      names = self.split('::')
+      names.shift if names.empty? || names.first.empty?
+
+      constant = Object
+      names.each do |name|
+        constant = constant.const_defined?(name, false) ? constant.const_get(name) : constant.const_missing(name)
+      end
+      constant
+    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/elements.rb

@@ -0,0 +1,14 @@
+module Mail
+  register_autoload :Address, 'mail/elements/address'
+  register_autoload :AddressList, 'mail/elements/address_list'
+  register_autoload :ContentDispositionElement, 'mail/elements/content_disposition_element'
+  register_autoload :ContentLocationElement, 'mail/elements/content_location_element'
+  register_autoload :ContentTransferEncodingElement, 'mail/elements/content_transfer_encoding_element'
+  register_autoload :ContentTypeElement, 'mail/elements/content_type_element'
+  register_autoload :DateTimeElement, 'mail/elements/date_time_element'
+  register_autoload :EnvelopeFromElement, 'mail/elements/envelope_from_element'
+  register_autoload :MessageIdsElement, 'mail/elements/message_ids_element'
+  register_autoload :MimeVersionElement, 'mail/elements/mime_version_element'
+  register_autoload :PhraseList, 'mail/elements/phrase_list'
+  register_autoload :ReceivedElement, 'mail/elements/received_element'
+end

data/lib/mail/elements/address.rb

@@ -0,0 +1,270 @@
+# 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 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'
+    #  a.display_name #=> 'Mikel Lindsaar'
+    #  a.local        #=> 'mikel'
+    #  a.domain       #=> 'test.lindsaar.net'
+    #  a.comments     #=> ['My email address']
+    #  a.to_s         #=> 'Mikel Lindsaar <mikel@test.lindsaar.net> (My email address)'
+    def initialize(value = nil)
+      @output_type = :decode
+      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
+      @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 its best
+    # to format it correctly.  This includes quoting display names as needed and
+    # putting the address in angle brackets etc.
+    #
+    #  a = Address.new('Mikel Lindsaar (My email address) <mikel@test.lindsaar.net>')
+    #  a.format #=> 'Mikel Lindsaar <mikel@test.lindsaar.net> (My email address)'
+    def format
+      parse unless @parsed
+      if @data.nil?
+        ''
+      elsif display_name
+        [quote_phrase(display_name), "<#{address}>", format_comments].compact.join(" ")
+      elsif address
+        [address, format_comments].compact.join(" ")
+      else
+        raw
+      end
+    end
+
+    # 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
+      parse unless @parsed
+      @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'
+    #  a.format #=> 'Mikel Lindsaar <mikel@test.lindsaar.net>'
+    def display_name=( str )
+      @display_name = str
+    end
+
+    # 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
+      "#{@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
+    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)| >"
+    def inspect
+      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
+
+    private
+    
+    def parse(value = nil)
+      @parsed = true
+
+      case value
+      when NilClass
+        @data = nil
+        nil
+      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 strip_all_comments(string)
+      unless comments.blank?
+        comments.each do |comment|
+          string = string.gsub("(#{comment})", '')
+        end
+      end
+      string.strip
+    end
+
+    def strip_domain_comments(value)
+      unless comments.blank?
+        comments.each do |comment|
+          if @data.domain && @data.domain.include?("(#{comment})")
+            value = value.gsub("(#{comment})", '')
+          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
+      end
+    end
+    
+    def get_name
+      if display_name
+        str = display_name
+      else
+        if comments
+          comment_text = comments.join(' ').squeeze(" ")
+          str = "(#{comment_text})"
+        end
+      end
+
+      if str.blank?
+        nil
+      else
+        unparen(str)
+      end
+    end
+    
+    def format_comments
+      if comments
+        comment_text = comments.map {|c| escape_paren(c) }.join(' ').squeeze(" ")
+        @format_comments ||= "(#{comment_text})"
+      else
+        nil
+      end
+    end
+
+    def get_local
+      @data && @data.local
+    end
+
+    def get_domain
+      @data && @data.domain
+    end
+    
+    def get_comments
+      @data && @data.comments
+    end
+  end
+end