mail 2.7.1 → 2.8.0.1

data/lib/mail/multibyte/chars.rb

@@ -38,16 +38,10 @@ module Mail #:nodoc:
       alias to_s wrapped_string
       alias to_str wrapped_string
 
-      if RUBY_VERSION >= "1.9"
-        # Creates a new Chars instance by wrapping _string_.
-        def initialize(string)
-          @wrapped_string = string.dup
-          @wrapped_string.force_encoding(Encoding::UTF_8) unless @wrapped_string.frozen?
-        end
-      else
-        def initialize(string) #:nodoc:
-          @wrapped_string = string
-        end
+      # Creates a new Chars instance by wrapping _string_.
+      def initialize(string)
+        @wrapped_string = string.dup
+        @wrapped_string.force_encoding(Encoding::UTF_8) unless @wrapped_string.frozen?
       end
 
       # Forward all undefined methods to the wrapped string.
@@ -72,15 +66,6 @@ module Mail #:nodoc:
         true
       end
 
-      # Returns +true+ when the proxy class can handle the string. Returns +false+ otherwise.
-      def self.consumes?(string)
-        # Unpack is a little bit faster than regular expressions.
-        string.unpack('U*')
-        true
-      rescue ArgumentError
-        false
-      end
-
       include Comparable
 
       # Returns -1, 0, or 1, depending on whether the Chars object is to be sorted before,
@@ -94,151 +79,8 @@ module Mail #:nodoc:
         @wrapped_string <=> other.to_s
       end
 
-      if RUBY_VERSION < "1.9"
-        # Returns +true+ if the Chars class can and should act as a proxy for the string _string_. Returns
-        # +false+ otherwise.
-        def self.wants?(string)
-          $KCODE == 'UTF8' && consumes?(string)
-        end
-
-        # Returns a new Chars object containing the _other_ object concatenated to the string.
-        #
-        # Example:
-        #   (Mail::Multibyte.mb_chars('Café') + ' périferôl').to_s # => "Café périferôl"
-        def +(other)
-          chars(@wrapped_string + other)
-        end
-
-        # Like <tt>String#=~</tt> only it returns the character offset (in codepoints) instead of the byte offset.
-        #
-        # Example:
-        #   Mail::Multibyte.mb_chars('Café périferôl') =~ /ô/ # => 12
-        def =~(other)
-          translate_offset(@wrapped_string =~ other)
-        end
-
-        # Inserts the passed string at specified codepoint offsets.
-        #
-        # Example:
-        #   Mail::Multibyte.mb_chars('Café').insert(4, ' périferôl').to_s # => "Café périferôl"
-        def insert(offset, fragment)
-          unpacked = Unicode.u_unpack(@wrapped_string)
-          unless offset > unpacked.length
-            @wrapped_string.replace(
-              Unicode.u_unpack(@wrapped_string).insert(offset, *Unicode.u_unpack(fragment)).pack('U*')
-            )
-          else
-            raise IndexError, "index #{offset} out of string"
-          end
-          self
-        end
-
-        # Returns +true+ if contained string contains _other_. Returns +false+ otherwise.
-        #
-        # Example:
-        #   Mail::Multibyte.mb_chars('Café').include?('é') # => true
-        def include?(other)
-          # We have to redefine this method because Enumerable defines it.
-          @wrapped_string.include?(other)
-        end
-
-        # Returns the position _needle_ in the string, counting in codepoints. Returns +nil+ if _needle_ isn't found.
-        #
-        # Example:
-        #   Mail::Multibyte.mb_chars('Café périferôl').index('ô')   # => 12
-        #   Mail::Multibyte.mb_chars('Café périferôl').index(/\w/u) # => 0
-        def index(needle, offset=0)
-          wrapped_offset = first(offset).wrapped_string.length
-          index = @wrapped_string.index(needle, wrapped_offset)
-          index ? (Unicode.u_unpack(@wrapped_string.slice(0...index)).size) : nil
-        end
-
-        # Returns the position _needle_ in the string, counting in
-        # codepoints, searching backward from _offset_ or the end of the
-        # string. Returns +nil+ if _needle_ isn't found.
-        #
-        # Example:
-        #   Mail::Multibyte.mb_chars('Café périferôl').rindex('é')   # => 6
-        #   Mail::Multibyte.mb_chars('Café périferôl').rindex(/\w/u) # => 13
-        def rindex(needle, offset=nil)
-          offset ||= length
-          wrapped_offset = first(offset).wrapped_string.length
-          index = @wrapped_string.rindex(needle, wrapped_offset)
-          index ? (Unicode.u_unpack(@wrapped_string.slice(0...index)).size) : nil
-        end
-
-        # Returns the number of codepoints in the string
-        def size
-          Unicode.u_unpack(@wrapped_string).size
-        end
-        alias_method :length, :size
-
-        # Strips entire range of Unicode whitespace from the right of the string.
-        def rstrip
-          chars(@wrapped_string.gsub(Unicode::TRAILERS_PAT, ''))
-        end
-
-        # Strips entire range of Unicode whitespace from the left of the string.
-        def lstrip
-          chars(@wrapped_string.gsub(Unicode::LEADERS_PAT, ''))
-        end
-
-        # Strips entire range of Unicode whitespace from the right and left of the string.
-        def strip
-          rstrip.lstrip
-        end
-
-        # Returns the codepoint of the first character in the string.
-        #
-        # Example:
-        #   Mail::Multibyte.mb_chars('こんにちは').ord # => 12371
-        def ord
-          Unicode.u_unpack(@wrapped_string)[0]
-        end
-
-        # Works just like <tt>String#rjust</tt>, only integer specifies characters instead of bytes.
-        #
-        # Example:
-        #
-        #   Mail::Multibyte.mb_chars("¾ cup").rjust(8).to_s
-        #   # => "   ¾ cup"
-        #
-        #   Mail::Multibyte.mb_chars("¾ cup").rjust(8, " ").to_s # Use non-breaking whitespace
-        #   # => "   ¾ cup"
-        def rjust(integer, padstr=' ')
-          justify(integer, :right, padstr)
-        end
-
-        # Works just like <tt>String#ljust</tt>, only integer specifies characters instead of bytes.
-        #
-        # Example:
-        #
-        #   Mail::Multibyte.mb_chars("¾ cup").rjust(8).to_s
-        #   # => "¾ cup   "
-        #
-        #   Mail::Multibyte.mb_chars("¾ cup").rjust(8, " ").to_s # Use non-breaking whitespace
-        #   # => "¾ cup   "
-        def ljust(integer, padstr=' ')
-          justify(integer, :left, padstr)
-        end
-
-        # Works just like <tt>String#center</tt>, only integer specifies characters instead of bytes.
-        #
-        # Example:
-        #
-        #   Mail::Multibyte.mb_chars("¾ cup").center(8).to_s
-        #   # => " ¾ cup  "
-        #
-        #   Mail::Multibyte.mb_chars("¾ cup").center(8, " ").to_s # Use non-breaking whitespace
-        #   # => " ¾ cup  "
-        def center(integer, padstr=' ')
-          justify(integer, :center, padstr)
-        end
-
-      else
-        def =~(other)
-          @wrapped_string =~ other
-        end
+      def =~(other)
+        @wrapped_string =~ other
       end
 
       # Works just like <tt>String#split</tt>, with the exception that the items in the resulting list are Chars
@@ -331,7 +173,7 @@ module Mail #:nodoc:
       #
       # Example:
       #   s = 'こんにちは'
-      #   s.mb_chars.limit(7) # => "こに"
+      #   s.mb_chars.limit(7) # => "こん"
       def limit(limit)
         slice(0...translate_offset(limit))
       end
@@ -419,7 +261,7 @@ module Mail #:nodoc:
         # exclude lstrip!, rstrip! and strip! because they are already work as expected on multibyte strings.
         if public_method_defined?(method)
           define_method("#{method}!") do |*args|
-            @wrapped_string = send(args.nil? ? method : method, *args).to_s
+            @wrapped_string = send(method, *args).to_s
             self
           end
         end

data/lib/mail/multibyte/utils.rb

@@ -3,59 +3,42 @@
 
 module Mail #:nodoc:
   module Multibyte #:nodoc:
-    if RUBY_VERSION >= "1.9"
-      # Returns a regular expression that matches valid characters in the current encoding
-      def self.valid_character
-        VALID_CHARACTER[Encoding.default_external.to_s]
-      end
-    else
-      def self.valid_character
-        case $KCODE
-        when 'UTF8'
-          VALID_CHARACTER['UTF-8']
-        when 'SJIS'
-          VALID_CHARACTER['Shift_JIS']
-        end
-      end
+    # Returns a regular expression that matches valid characters in the current encoding
+    def self.valid_character
+      VALID_CHARACTER[Encoding.default_external.to_s]
     end
 
-    if 'string'.respond_to?(:valid_encoding?)
-      # Verifies the encoding of a string
-      def self.verify(string)
-        string.valid_encoding?
-      end
-    else
-      def self.verify(string)
-        if expression = valid_character
-          # Splits the string on character boundaries, which are determined based on $KCODE.
-          string.split(//).all? { |c| expression =~ c }
-        else
-          true
-        end
+    # Returns true if string has valid utf-8 encoding
+    def self.is_utf8?(string)
+      case string.encoding
+      when Encoding::UTF_8
+        verify(string)
+      when Encoding::ASCII_8BIT, Encoding::US_ASCII
+        verify(to_utf8(string))
+      else
+        false
       end
     end
 
+    # Verifies the encoding of a string
+    def self.verify(string)
+      string.valid_encoding?
+    end
+
     # Verifies the encoding of the string and raises an exception when it's not valid
     def self.verify!(string)
       raise EncodingError.new("Found characters with invalid encoding") unless verify(string)
     end
 
-    if 'string'.respond_to?(:force_encoding)
-      # Removes all invalid characters from the string.
-      #
-      # Note: this method is a no-op in Ruby 1.9
-      def self.clean(string)
-        string
-      end
-    else
-      def self.clean(string)
-        if expression = valid_character
-          # Splits the string on character boundaries, which are determined based on $KCODE.
-          string.split(//).grep(expression).join
-        else
-          string
-        end
-      end
+    # Removes all invalid characters from the string.
+    #
+    # Note: this method is a no-op in Ruby 1.9
+    def self.clean(string)
+      string
+    end
+
+    def self.to_utf8(string)
+      string.dup.force_encoding(Encoding::UTF_8)
     end
   end
 end

data/lib/mail/multibyte.rb

@@ -19,7 +19,6 @@ module Mail #:nodoc:
 
     self.proxy_class = Mail::Multibyte::Chars
 
-    if RUBY_VERSION >= "1.9"
       # == Multibyte proxy
       #
       # +mb_chars+ is a multibyte safe proxy for string methods.
@@ -54,21 +53,12 @@ module Mail #:nodoc:
       # 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 self.mb_chars(str)
-        if proxy_class.consumes?(str)
+        if is_utf8?(str)
           proxy_class.new(str)
         else
           str
         end
       end
-    else
-      def self.mb_chars(str)
-        if proxy_class.wants?(str)
-          proxy_class.new(str)
-        else
-          str
-        end
-      end
-    end
 
     # Regular expressions that describe valid byte sequences for a character
     VALID_CHARACTER = {

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
-module Mail
 
+module Mail
   # A delivery method implementation which sends via exim.
   #
   # To use this, first find out where the exim binary is on your computer,
@@ -39,11 +39,12 @@ module Mail
   class Exim < Sendmail
     DEFAULTS = {
       :location   => '/usr/sbin/exim',
-      :arguments  => '-i -t'
+      :arguments  => %w[ -i -t ]
     }
 
-    def self.call(path, arguments, destinations, encoded_message)
-      super path, arguments, nil, encoded_message
+    # Uses -t option to extract recipients from the message.
+    def destinations_for(envelope)
+      nil
     end
   end
 end

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

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-require 'mail/check_delivery_params'
+require 'mail/smtp_envelope'
 
 module Mail
   # FileDelivery class delivers emails into multiple files based on the destination
@@ -13,20 +13,16 @@ module Mail
   # Make sure the path you specify with :location is writable by the Ruby process
   # running Mail.
   class FileDelivery
-    if RUBY_VERSION >= '1.9.1'
-      require 'fileutils'
-    else
-      require 'ftools'
-    end
+    require 'fileutils'
 
     attr_accessor :settings
 
     def initialize(values)
-      self.settings = { :location => './mails' }.merge!(values)
+      self.settings = { :location => './mails', :extension => '' }.merge!(values)
     end
 
     def deliver!(mail)
-      Mail::CheckDeliveryParams.check(mail)
+      envelope = Mail::SmtpEnvelope.new(mail)
 
       if ::File.respond_to?(:makedirs)
         ::File.makedirs settings[:location]
@@ -34,8 +30,13 @@ module Mail
         ::FileUtils.mkdir_p settings[:location]
       end
 
-      mail.destinations.uniq.each do |to|
-        ::File.open(::File.join(settings[:location], File.basename(to.to_s)), 'a') { |f| "#{f.write(mail.encoded)}\r\n\r\n" }
+      envelope.to.uniq.each do |to|
+        path = ::File.join(settings[:location], File.basename(to.to_s+settings[:extension]))
+
+        ::File.open(path, 'a') do |f|
+          f.write envelope.message
+          f.write "\r\n\r\n"
+        end
       end
     end
   end

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

@@ -1,9 +1,7 @@
-require 'mail/check_delivery_params'
+require 'mail/smtp_envelope'
 
 module Mail
   class LoggerDelivery
-    include Mail::CheckDeliveryParams
-
     attr_reader :logger, :severity, :settings
 
     def initialize(settings)
@@ -13,8 +11,7 @@ module Mail
     end
 
     def deliver!(mail)
-      Mail::CheckDeliveryParams.check(mail)
-      logger.log(severity) { mail.encoded }
+      logger.log(severity) { Mail::SmtpEnvelope.new(mail).message }
     end
 
     private

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

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-require 'mail/check_delivery_params'
+require 'mail/smtp_envelope'
 
 module Mail
   # A delivery method implementation which sends via sendmail.
@@ -40,56 +40,48 @@ module Mail
   class Sendmail
     DEFAULTS = {
       :location   => '/usr/sbin/sendmail',
-      :arguments  => '-i'
+      :arguments  => %w[ -i ]
     }
 
     attr_accessor :settings
 
+    class DeliveryError < StandardError
+    end
+
     def initialize(values)
       self.settings = self.class::DEFAULTS.merge(values)
+      raise ArgumentError, ":arguments expected to be an Array of individual string args" if settings[:arguments].is_a?(String)
+    end
+
+    def destinations_for(envelope)
+      envelope.to
     end
 
     def deliver!(mail)
-      smtp_from, smtp_to, message = Mail::CheckDeliveryParams.check(mail)
+      envelope = Mail::SmtpEnvelope.new(mail)
 
-      from = "-f #{self.class.shellquote(smtp_from)}" if smtp_from
-      to = smtp_to.map { |_to| self.class.shellquote(_to) }.join(' ')
+      command = [settings[:location]]
+      command.concat Array(settings[:arguments])
+      command.concat [ '-f', envelope.from ] if envelope.from
 
-      arguments = "#{settings[:arguments]} #{from} --"
-      self.class.call(settings[:location], arguments, to, message)
-    end
+      if destinations = destinations_for(envelope)
+        command.push '--'
+        command.concat destinations
+      end
 
-    def self.call(path, arguments, destinations, encoded_message)
-      popen "#{path} #{arguments} #{destinations}" do |io|
-        io.puts ::Mail::Utilities.binary_unsafe_to_lf(encoded_message)
+      popen(command) do |io|
+        io.puts ::Mail::Utilities.binary_unsafe_to_lf(envelope.message)
         io.flush
       end
     end
 
-    if RUBY_VERSION < '1.9.0'
-      def self.popen(command, &block)
-        IO.popen "#{command} 2>&1", 'w+', &block
-      end
-    else
-      def self.popen(command, &block)
-        IO.popen command, 'w+', :err => :out, &block
+    private
+      def popen(command, &block)
+        IO.popen(command, 'w+', :err => :out, &block).tap do
+          if $?.exitstatus != 0
+            raise DeliveryError, "Delivery failed with exitstatus #{$?.exitstatus}: #{command.inspect}"
+          end
+        end
       end
-    end
-
-    # The following is an adaptation of ruby 1.9.2's shellwords.rb file,
-    # with the following modifications:
-    #
-    # - Wraps in double quotes
-    # - Allows '+' to accept email addresses with them
-    # - Allows '~' as it is not unescaped in double quotes
-    def self.shellquote(address)
-      # Process as a single byte sequence because not all shell
-      # implementations are multibyte aware.
-      #
-      # A LF cannot be escaped with a backslash because a backslash + LF
-      # combo is regarded as line continuation and simply ignored. Strip it.
-      escaped = address.gsub(/([^A-Za-z0-9_\s\+\-.,:\/@~])/n, "\\\\\\1").gsub("\n", '')
-      %("#{escaped}")
-    end
   end
 end

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

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-require 'mail/check_delivery_params'
+require 'mail/smtp_envelope'
 
 module Mail
   # == Sending Email with SMTP
@@ -88,8 +88,8 @@ module Mail
       :openssl_verify_mode  => nil,
       :ssl                  => nil,
       :tls                  => nil,
-      :open_timeout         => nil,
-      :read_timeout         => nil
+      :open_timeout         => 5,
+      :read_timeout         => 5
     }
 
     def initialize(values)
@@ -111,17 +111,33 @@ module Mail
 
       def build_smtp_session
         Net::SMTP.new(settings[:address], settings[:port]).tap do |smtp|
-          if settings[:tls] || settings[:ssl]
-            if smtp.respond_to?(:enable_tls)
+          tls = settings[:tls] || settings[:ssl]
+          if !tls.nil?
+            case tls
+            when true
               smtp.enable_tls(ssl_context)
+            when false
+              smtp.disable_tls
+            else
+              raise ArgumentError, "Unrecognized :tls value #{settings[:tls].inspect}; expected true, false, or nil"
             end
-          elsif settings[:enable_starttls]
-            if smtp.respond_to?(:enable_starttls)
+          elsif settings.include?(:enable_starttls) && !settings[:enable_starttls].nil?
+            case settings[:enable_starttls]
+            when true
               smtp.enable_starttls(ssl_context)
+            when false
+              smtp.disable_starttls
+            else
+              raise ArgumentError, "Unrecognized :enable_starttls value #{settings[:enable_starttls].inspect}; expected true, false, or nil"
             end
-          elsif settings[:enable_starttls_auto]
-            if smtp.respond_to?(:enable_starttls_auto)
+          elsif settings.include?(:enable_starttls_auto) && !settings[:enable_starttls_auto].nil?
+            case settings[:enable_starttls_auto]
+            when true
               smtp.enable_starttls_auto(ssl_context)
+            when false
+              smtp.disable_starttls_auto
+            else
+              raise ArgumentError, "Unrecognized :enable_starttls_auto value #{settings[:enable_starttls_auto].inspect}; expected true, false, or nil"
             end
           end
 

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

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-require 'mail/check_delivery_params'
+require 'mail/smtp_envelope'
 
 module Mail
   # == Sending Email with SMTP
@@ -49,18 +49,9 @@ module Mail
     # Send the message via SMTP.
     # The from and to attributes are optional. If not set, they are retrieve from the Message.
     def deliver!(mail)
-      smtp_from, smtp_to, message = Mail::CheckDeliveryParams.check(mail)
-
-      response = smtp.sendmail(dot_stuff(message), smtp_from, smtp_to)
-
+      envelope = Mail::SmtpEnvelope.new(mail)
+      response = smtp.sendmail(envelope.message, envelope.from, envelope.to)
       settings[:return_response] ? response : self
     end
-
-    private
-      # This is Net::SMTP's job, but before Ruby 2.x it does not dot-stuff
-      # an unterminated last line: https://bugs.ruby-lang.org/issues/9627
-      def dot_stuff(message)
-        message.gsub(/(\r\n\.)(\r\n|$)/, '\1.\2')
-      end
   end
 end

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

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-require 'mail/check_delivery_params'
+require 'mail/smtp_envelope'
 
 module Mail
   # The TestMailer is a bare bones mailer that does nothing.  It is useful
@@ -35,7 +35,9 @@ module Mail
     end
 
     def deliver!(mail)
-      Mail::CheckDeliveryParams.check(mail)
+      # Create the envelope to validate it
+      Mail::SmtpEnvelope.new(mail)
+
       Mail::TestMailer.deliveries << mail
     end
   end

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

@@ -11,8 +11,8 @@ module Mail
     #   count: number of emails to retrieve. The default value is 1.
     #   order: order of emails returned. Possible values are :asc or :desc. Default value is :asc.
     #
-    def first(options = {}, &block)
-      options ||= {}
+    def first(options = nil, &block)
+      options = options ? Hash[options] : {}
       options[:what] = :first
       options[:count] ||= 1
       find(options, &block)
@@ -24,8 +24,8 @@ module Mail
     #   count: number of emails to retrieve. The default value is 1.
     #   order: order of emails returned. Possible values are :asc or :desc. Default value is :asc.
     #
-    def last(options = {}, &block)
-      options ||= {}
+    def last(options = nil, &block)
+      options = options ? Hash[options] : {}
       options[:what] = :last
       options[:count] ||= 1
       find(options, &block)
@@ -36,8 +36,8 @@ module Mail
     # Possible options:
     #   order: order of emails returned. Possible values are :asc or :desc. Default value is :asc.
     #
-    def all(options = {}, &block)
-      options ||= {}
+    def all(options = nil, &block)
+      options = options ? Hash[options] : {}
       options[:count] = :all
       find(options, &block)
     end
@@ -53,8 +53,8 @@ module Mail
     #   delete_after_find: flag for whether to delete each retreived email after find. Default
     #           is true. Call #find if you would like this to default to false.
     #
-    def find_and_delete(options = {}, &block)
-      options ||= {}
+    def find_and_delete(options = nil, &block)
+      options = options ? Hash[options] : {}
       options[:delete_after_find] ||= true
       find(options, &block)      
     end 

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

@@ -70,7 +70,7 @@ module Mail
     #           The default is 'ALL'
     #   search_charset: charset to pass to IMAP server search. Omitted by default. Example: 'UTF-8' or 'ASCII'.
     #
-    def find(options={}, &block)
+    def find(options=nil, &block)
       options = validate_options(options)
 
       start do |imap|
@@ -142,7 +142,7 @@ module Mail
 
       # Set default options
       def validate_options(options)
-        options ||= {}
+        options = options ? Hash[options] : {}
         options[:mailbox] ||= 'INBOX'
         options[:count]   ||= 10
         options[:order]   ||= :asc