mail 2.6.6 → 2.8.1

data/lib/mail/multibyte/chars.rb

@@ -1,5 +1,6 @@
 # encoding: utf-8
 # frozen_string_literal: true
+require 'mail/multibyte/unicode'
 
 module Mail #:nodoc:
   module Multibyte #:nodoc:
@@ -37,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
-          @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.
@@ -71,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,
@@ -93,158 +79,15 @@ 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:
-        #   ('Café'.mb_chars + ' 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:
-        #   'Café périferôl'.mb_chars =~ /ô/ # => 12
-        def =~(other)
-          translate_offset(@wrapped_string =~ other)
-        end
-
-        # Inserts the passed string at specified codepoint offsets.
-        #
-        # Example:
-        #   'Café'.mb_chars.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:
-        #   'Café'.mb_chars.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:
-        #   'Café périferôl'.mb_chars.index('ô')   # => 12
-        #   'Café périferôl'.mb_chars.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:
-        #   'Café périferôl'.mb_chars.rindex('é')   # => 6
-        #   'Café périferôl'.mb_chars.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:
-        #   'こんにちは'.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:
-        #
-        #   "¾ cup".mb_chars.rjust(8).to_s
-        #   # => "   ¾ cup"
-        #
-        #   "¾ cup".mb_chars.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:
-        #
-        #   "¾ cup".mb_chars.rjust(8).to_s
-        #   # => "¾ cup   "
-        #
-        #   "¾ cup".mb_chars.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:
-        #
-        #   "¾ cup".mb_chars.center(8).to_s
-        #   # => " ¾ cup  "
-        #
-        #   "¾ cup".mb_chars.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
       # instances instead of String. This makes chaining methods easier.
       #
       # Example:
-      #   'Café périferôl'.mb_chars.split(/é/).map { |part| part.upcase.to_s } # => ["CAF", " P", "RIFERÔL"]
+      #   Mail::Multibyte.mb_chars('Café périferôl').split(/é/).map { |part| part.upcase.to_s } # => ["CAF", " P", "RIFERÔL"]
       def split(*args)
         @wrapped_string.split(*args).map { |i| i.mb_chars }
       end
@@ -292,7 +135,7 @@ module Mail #:nodoc:
       # Reverses all characters in the string.
       #
       # Example:
-      #   'Café'.mb_chars.reverse.to_s # => 'éfaC'
+      #   Mail::Multibyte.mb_chars('Café').reverse.to_s # => 'éfaC'
       def reverse
         chars(Unicode.g_unpack(@wrapped_string).reverse.flatten.pack('U*'))
       end
@@ -301,7 +144,7 @@ module Mail #:nodoc:
       # character.
       #
       # Example:
-      #   'こんにちは'.mb_chars.slice(2..3).to_s # => "にち"
+      #   Mail::Multibyte.mb_chars('こんにちは').slice(2..3).to_s # => "にち"
       def slice(*args)
         if args.size > 2
           raise ArgumentError, "wrong number of arguments (#{args.size} for 1)" # Do as if we were native
@@ -330,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
@@ -338,7 +181,7 @@ module Mail #:nodoc:
       # Convert characters in the string to uppercase.
       #
       # Example:
-      #   'Laurent, où sont les tests ?'.mb_chars.upcase.to_s # => "LAURENT, OÙ SONT LES TESTS ?"
+      #   Mail::Multibyte.mb_chars('Laurent, où sont les tests ?').upcase.to_s # => "LAURENT, OÙ SONT LES TESTS ?"
       def upcase
         chars(Unicode.apply_mapping(@wrapped_string, :uppercase_mapping))
       end
@@ -346,7 +189,7 @@ module Mail #:nodoc:
       # Convert characters in the string to lowercase.
       #
       # Example:
-      #   'VĚDA A VÝZKUM'.mb_chars.downcase.to_s # => "věda a výzkum"
+      #   Mail::Multibyte.mb_chars('VĚDA A VÝZKUM').downcase.to_s # => "věda a výzkum"
       def downcase
         chars(Unicode.apply_mapping(@wrapped_string, :lowercase_mapping))
       end
@@ -354,7 +197,7 @@ module Mail #:nodoc:
       # Converts the first character to uppercase and the remainder to lowercase.
       #
       # Example:
-      #  'über'.mb_chars.capitalize.to_s # => "Über"
+      #  Mail::Multibyte.mb_chars('über').capitalize.to_s # => "Über"
       def capitalize
         (slice(0) || chars('')).upcase + (slice(1..-1) || chars('')).downcase
       end
@@ -362,8 +205,8 @@ module Mail #:nodoc:
       # Capitalizes the first letter of every word, when possible.
       #
       # Example:
-      #   "ÉL QUE SE ENTERÓ".mb_chars.titleize    # => "Él Que Se Enteró"
-      #   "日本語".mb_chars.titleize                 # => "日本語"
+      #   Mail::Multibyte.mb_chars("ÉL QUE SE ENTERÓ").titleize    # => "Él Que Se Enteró"
+      #   Mail::Multibyte.mb_chars("日本語").titleize                 # => "日本語"
       def titleize
         chars(downcase.to_s.gsub(/\b('?\S)/u) { Unicode.apply_mapping $1, :uppercase_mapping })
       end
@@ -383,7 +226,7 @@ module Mail #:nodoc:
       #
       # Example:
       #   'é'.length                         # => 2
-      #   'é'.mb_chars.decompose.to_s.length # => 3
+      #   Mail::Multibyte.mb_chars('é').decompose.to_s.length # => 3
       def decompose
         chars(Unicode.decompose_codepoints(:canonical, Unicode.u_unpack(@wrapped_string)).pack('U*'))
       end
@@ -392,7 +235,7 @@ module Mail #:nodoc:
       #
       # Example:
       #   'é'.length                       # => 3
-      #   'é'.mb_chars.compose.to_s.length # => 2
+      #   Mail::Multibyte.mb_chars('é').compose.to_s.length # => 2
       def compose
         chars(Unicode.compose_codepoints(Unicode.u_unpack(@wrapped_string)).pack('U*'))
       end
@@ -400,8 +243,8 @@ module Mail #:nodoc:
       # Returns the number of grapheme clusters in the string.
       #
       # Example:
-      #   'क्षि'.mb_chars.length   # => 4
-      #   'क्षि'.mb_chars.g_length # => 3
+      #   Mail::Multibyte.mb_chars('क्षि').length   # => 4
+      #   Mail::Multibyte.mb_chars('क्षि').g_length # => 3
       def g_length
         Unicode.g_unpack(@wrapped_string).length
       end
@@ -418,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/unicode.rb

@@ -302,16 +302,16 @@ module Mail
         # See http://www.unicode.org/reports/tr15, Table 1
         codepoints = u_unpack(string)
         case form
-          when :d
-            reorder_characters(decompose_codepoints(:canonical, codepoints))
-          when :c
-            compose_codepoints(reorder_characters(decompose_codepoints(:canonical, codepoints)))
-          when :kd
-            reorder_characters(decompose_codepoints(:compatability, codepoints))
-          when :kc
-            compose_codepoints(reorder_characters(decompose_codepoints(:compatability, codepoints)))
-          else
-            raise ArgumentError, "#{form} is not a valid normalization variant", caller
+        when :d
+          reorder_characters(decompose_codepoints(:canonical, codepoints))
+        when :c
+          compose_codepoints(reorder_characters(decompose_codepoints(:canonical, codepoints)))
+        when :kd
+          reorder_characters(decompose_codepoints(:compatability, codepoints))
+        when :kc
+          compose_codepoints(reorder_characters(decompose_codepoints(:compatability, codepoints)))
+        else
+          raise ArgumentError, "#{form} is not a valid normalization variant", caller
         end.pack('U*')
       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

@@ -1,25 +1,64 @@
 # encoding: utf-8
 # frozen_string_literal: true
+require 'mail/multibyte/chars'
+
 module Mail #:nodoc:
   module Multibyte
-    require 'mail/multibyte/exceptions'
-    require 'mail/multibyte/chars'
-    require 'mail/multibyte/unicode'
+    # Raised when a problem with the encoding was found.
+    class EncodingError < StandardError; end
 
-    # The proxy class returned when calling mb_chars. You can use this accessor to configure your own proxy
-    # class so you can support other encodings. See the Mail::Multibyte::Chars implementation for
-    # an example how to do this.
-    #
-    # Example:
-    #   Mail::Multibyte.proxy_class = CharsForUTF32
-    def self.proxy_class=(klass)
-      @proxy_class = klass
+    class << self
+      # The proxy class returned when calling mb_chars. You can use this accessor to configure your own proxy
+      # class so you can support other encodings. See the Mail::Multibyte::Chars implementation for
+      # an example how to do this.
+      #
+      # Example:
+      #   Mail::Multibyte.proxy_class = CharsForUTF32
+      attr_accessor :proxy_class
     end
 
-    # Returns the current proxy class
-    def self.proxy_class
-      @proxy_class ||= Mail::Multibyte::Chars
-    end
+    self.proxy_class = Mail::Multibyte::Chars
+
+      # == 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 self.mb_chars(str)
+        if is_utf8?(str)
+          proxy_class.new(str)
+        else
+          str
+        end
+      end
 
     # Regular expressions that describe valid byte sequences for a character
     VALID_CHARACTER = {
@@ -40,4 +79,4 @@ module Mail #:nodoc:
   end
 end
 
-require 'mail/multibyte/utils'
+require 'mail/multibyte/utils'

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

@@ -0,0 +1,34 @@
+require 'mail/smtp_envelope'
+
+module Mail
+  class LoggerDelivery
+    attr_reader :logger, :severity, :settings
+
+    def initialize(settings)
+      @settings = settings
+      @logger   = settings.fetch(:logger) { default_logger }
+      @severity = derive_severity(settings[:severity])
+    end
+
+    def deliver!(mail)
+      logger.log(severity) { Mail::SmtpEnvelope.new(mail).message }
+    end
+
+    private
+      def default_logger
+        require 'logger'
+        ::Logger.new($stdout)
+      end
+
+      def derive_severity(severity)
+        case severity
+        when nil
+          Logger::INFO
+        when Integer
+          severity
+        else
+          Logger.const_get(severity.to_s.upcase)
+        end
+      end
+  end
+end