otherinbox-mail 2.4.4

data/lib/mail/utilities.rb

@@ -0,0 +1,215 @@
+# encoding: utf-8
+module Mail
+  module Utilities
+    include Patterns
+    
+    # Returns true if the string supplied is free from characters not allowed as an ATOM
+    def atom_safe?( str )
+      not ATOM_UNSAFE === str
+    end
+
+    # If the string supplied has ATOM unsafe characters in it, will return the string quoted 
+    # in double quotes, otherwise returns the string unmodified
+    def quote_atom( str )
+      atom_safe?( str ) ? str : dquote(str)
+    end
+
+    # If the string supplied has PHRASE unsafe characters in it, will return the string quoted 
+    # in double quotes, otherwise returns the string unmodified
+    def quote_phrase( str )
+      if RUBY_VERSION >= '1.9'
+        original_encoding = str.encoding
+        str.force_encoding('ASCII-8BIT')
+        if (PHRASE_UNSAFE === str)
+          dquote(str).force_encoding(original_encoding)
+        else
+          str.force_encoding(original_encoding)
+        end
+      else
+        (PHRASE_UNSAFE === str) ? dquote(str) : str
+      end
+    end
+
+    # Returns true if the string supplied is free from characters not allowed as a TOKEN
+    def token_safe?( str )
+      not TOKEN_UNSAFE === str
+    end
+
+    # If the string supplied has TOKEN unsafe characters in it, will return the string quoted 
+    # in double quotes, otherwise returns the string unmodified
+    def quote_token( str )
+      token_safe?( str ) ? str : dquote(str)
+    end
+
+    # Wraps supplied string in double quotes unless it is already wrapped.
+    # 
+    # Additionally will escape any double quotation marks in the string with a single
+    # backslash in front of the '"' character.
+    def dquote( str )
+      match = str.match(/^"(.*)?"$/)
+      str = match[1] if match
+      # First remove all escaped double quotes:
+      str = str.gsub(/\\"/, '"')
+      # Then wrap and re-escape all double quotes
+      '"' + str.gsub(/["]/n) {|s| '\\' + s } + '"'
+    end
+    
+    # Unwraps supplied string from inside double quotes.
+    # 
+    # Example:
+    # 
+    #  string = '"This is a string"'
+    #  unquote(string) #=> 'This is a string'
+    def unquote( str )
+      match = str.match(/^"(.*?)"$/)
+      match ? match[1] : str
+    end
+    
+    # Wraps a string in parenthesis and escapes any that are in the string itself.
+    # 
+    # Example:
+    # 
+    #  paren( 'This is a string' ) #=> '(This is a string)'
+    def paren( str )
+      RubyVer.paren( str )
+    end
+    
+    # Unwraps a string from being wrapped in parenthesis
+    # 
+    # Example:
+    # 
+    #  str = '(This is a string)'
+    #  unparen( str ) #=> 'This is a string'
+    def unparen( str )
+      match = str.match(/^\((.*?)\)$/)
+      match ? match[1] : str
+    end
+    
+    # Wraps a string in angle brackets and escapes any that are in the string itself
+    # 
+    # Example:
+    # 
+    #  bracket( 'This is a string' ) #=> '<This is a string>'
+    def bracket( str )
+      RubyVer.bracket( str )
+    end
+    
+    # Unwraps a string from being wrapped in parenthesis
+    # 
+    # Example:
+    # 
+    #  str = '<This is a string>'
+    #  unbracket( str ) #=> 'This is a string'
+    def unbracket( str )
+      match = str.match(/^\<(.*?)\>$/)
+      match ? match[1] : str
+    end
+    
+    # Escape parenthesies in a string
+    # 
+    # Example:
+    # 
+    #  str = 'This is (a) string'
+    #  escape_paren( str ) #=> 'This is \(a\) string'
+    def escape_paren( str )
+      RubyVer.escape_paren( str )
+    end
+    
+    def uri_escape( str )
+      uri_parser.escape(str)
+    end
+    
+    def uri_unescape( str )
+      uri_parser.unescape(str)
+    end
+    
+    def uri_parser
+      @uri_parser ||= URI.const_defined?(:Parser) ? URI::Parser.new : URI
+    end
+    
+    # Matches two objects with their to_s values case insensitively
+    # 
+    # Example:
+    # 
+    #  obj2 = "This_is_An_object"
+    #  obj1 = :this_IS_an_object
+    #  match_to_s( obj1, obj2 ) #=> true
+    def match_to_s( obj1, obj2 )
+      obj1.to_s.downcase == obj2.to_s.downcase
+    end
+    
+    # Capitalizes a string that is joined by hyphens correctly.
+    # 
+    # Example:
+    # 
+    #  string = 'resent-from-field'
+    #  capitalize_field( string ) #=> 'Resent-From-Field'
+    def capitalize_field( str )
+      str.to_s.split("-").map { |v| v.capitalize }.join("-")
+    end
+    
+    # Takes an underscored word and turns it into a class name
+    # 
+    # Example:
+    # 
+    #  constantize("hello") #=> "Hello"
+    #  constantize("hello-there") #=> "HelloThere"
+    #  constantize("hello-there-mate") #=> "HelloThereMate"
+    def constantize( str )
+      str.to_s.split(/[-_]/).map { |v| v.capitalize }.to_s
+    end
+    
+    # Swaps out all underscores (_) for hyphens (-) good for stringing from symbols
+    # a field name.
+    # 
+    # Example:
+    # 
+    #  string = :resent_from_field
+    #  dasherize ( string ) #=> 'resent_from_field'
+    def dasherize( str )
+      str.to_s.gsub('_', '-')
+    end
+
+    # Swaps out all hyphens (-) for underscores (_) good for stringing to symbols
+    # a field name.
+    # 
+    # Example:
+    # 
+    #  string = :resent_from_field
+    #  underscoreize ( string ) #=> 'resent_from_field'
+    def underscoreize( str )
+      str.to_s.downcase.gsub('-', '_')
+    end
+
+    if RUBY_VERSION <= '1.8.6'
+
+      def map_lines( str, &block )
+        results = []
+        str.each_line do |line|
+          results << yield(line)
+        end
+        results
+      end
+  
+      def map_with_index( enum, &block )
+        results = []
+        enum.each_with_index do |token, i|
+          results[i] = yield(token, i)
+        end
+        results
+      end
+      
+    else
+
+      def map_lines( str, &block )
+        str.each_line.map(&block)
+      end
+
+      def map_with_index( enum, &block )
+        enum.each_with_index.map(&block)
+      end
+
+    end
+
+  end
+end

data/lib/mail/version.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+module Mail
+  module VERSION
+    
+    version = {}
+    File.read(File.join(File.dirname(__FILE__), '../', 'VERSION')).each_line do |line|
+      type, value = line.chomp.split(":")
+      next if type =~ /^\s+$/  || value =~ /^\s+$/
+      version[type] = value
+    end
+    
+    MAJOR = version['major']
+    MINOR = version['minor']
+    PATCH = version['patch']
+    BUILD = version['build']
+
+    STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join('.')
+    
+    def self.version
+      STRING
+    end
+    
+  end
+end

data/lib/mail/version_specific/ruby_1_8.rb

@@ -0,0 +1,98 @@
+# encoding: utf-8
+
+module Mail
+  class Ruby18
+    require 'base64'
+
+    # Escapes any parenthesis in a string that are unescaped. This can't
+    # use the Ruby 1.9.1 regexp feature of negative look behind so we have
+    # to do two replacement, first unescape everything, then re-escape it
+    def Ruby18.escape_paren( str )
+      re = /\\\)/
+      str = str.gsub(re) { |s| ')'}
+      re = /\\\(/
+      str = str.gsub(re) { |s| '('}
+      re = /([\(\)])/          # Only match unescaped parens
+      str.gsub(re) { |s| '\\' + s }
+    end
+
+    def Ruby18.paren( str )
+      str = $1 if str =~ /^\((.*)?\)$/
+      str = escape_paren( str )
+      '(' + str + ')'
+    end
+
+    def Ruby18.escape_bracket( str )
+      re = /\\\>/
+      str = str.gsub(re) { |s| '>'}
+      re = /\\\</
+      str = str.gsub(re) { |s| '<'}
+      re = /([\<\>])/          # Only match unescaped parens
+      str.gsub(re) { |s| '\\' + s }
+    end
+
+    def Ruby18.bracket( str )
+      str = $1 if str =~ /^\<(.*)?\>$/
+      str = escape_bracket( str )
+      '<' + str + '>'
+    end
+
+    def Ruby18.decode_base64(str)
+      Base64.decode64(str) if str
+    end
+
+    def Ruby18.encode_base64(str)
+      Base64.encode64(str)
+    end
+
+    def Ruby18.has_constant?(klass, string)
+      klass.constants.include?( string )
+    end
+
+    def Ruby18.get_constant(klass, string)
+      klass.const_get( string )
+    end
+
+    def Ruby18.b_value_encode(str, encoding)
+      # Ruby 1.8 requires an encoding to work
+      raise ArgumentError, "Must supply an encoding" if encoding.nil?
+      encoding = encoding.to_s.upcase.gsub('_', '-')
+      [Encodings::Base64.encode(str), encoding]
+    end
+
+    def Ruby18.b_value_decode(str)
+      match = str.match(/\=\?(.+)?\?[Bb]\?(.+)?\?\=/m)
+      if match
+        encoding = match[1]
+        str = Ruby18.decode_base64(match[2])
+      end
+      str
+    end
+
+    def Ruby18.q_value_encode(str, encoding)
+      # Ruby 1.8 requires an encoding to work
+      raise ArgumentError, "Must supply an encoding" if encoding.nil?
+      encoding = encoding.to_s.upcase.gsub('_', '-')
+      [Encodings::QuotedPrintable.encode(str), encoding]
+    end
+
+    def Ruby18.q_value_decode(str)
+      match = str.match(/\=\?(.+)?\?[Qq]\?(.+)?\?\=/m)
+      if match
+        encoding = match[1]
+        str = Encodings::QuotedPrintable.decode(match[2].gsub(/_/, '=20'))
+      end
+      str
+    end
+
+    def Ruby18.param_decode(str, encoding)
+      URI.unescape(str)
+    end
+
+    def Ruby18.param_encode(str)
+      encoding = $KCODE.to_s.downcase
+      language = Configuration.instance.param_encode_language
+      "#{encoding}'#{language}'#{URI.escape(str)}"
+    end
+  end
+end

data/lib/mail/version_specific/ruby_1_9.rb

@@ -0,0 +1,113 @@
+# encoding: utf-8
+
+module Mail
+  class Ruby19
+
+    # Escapes any parenthesis in a string that are unescaped this uses
+    # a Ruby 1.9.1 regexp feature of negative look behind
+    def Ruby19.escape_paren( str )
+      re = /(?<!\\)([\(\)])/          # Only match unescaped parens
+      str.gsub(re) { |s| '\\' + s }
+    end
+
+    def Ruby19.paren( str )
+      str = $1 if str =~ /^\((.*)?\)$/
+      str = escape_paren( str )
+      '(' + str + ')'
+    end
+
+    def Ruby19.escape_bracket( str )
+      re = /(?<!\\)([\<\>])/          # Only match unescaped brackets
+      str.gsub(re) { |s| '\\' + s }
+    end
+
+    def Ruby19.bracket( str )
+      str = $1 if str =~ /^\<(.*)?\>$/
+      str = escape_bracket( str )
+      '<' + str + '>'
+    end
+
+    def Ruby19.decode_base64(str)
+      str.unpack( 'm' ).first
+    end
+
+    def Ruby19.encode_base64(str)
+      [str].pack( 'm' )
+    end
+
+    def Ruby19.has_constant?(klass, string)
+      klass.const_defined?( string, false )
+    end
+
+    def Ruby19.get_constant(klass, string)
+      klass.const_get( string )
+    end
+
+    def Ruby19.b_value_encode(str, encoding = nil)
+      encoding = str.encoding.to_s
+      [Ruby19.encode_base64(str), encoding]
+    end
+
+    def Ruby19.b_value_decode(str)
+      match = str.match(/\=\?(.+)?\?[Bb]\?(.+)?\?\=/m)
+      if match
+        encoding = match[1]
+        str = Ruby19.decode_base64(match[2])
+        str.force_encoding(fix_encoding(encoding))
+      end
+      decoded = str.encode("utf-8", :invalid => :replace, :replace => "")
+      decoded.valid_encoding? ? decoded : decoded.encode("utf-16le", :invalid => :replace, :replace => "").encode("utf-8")
+    end
+
+    def Ruby19.q_value_encode(str, encoding = nil)
+      encoding = str.encoding.to_s
+      [Encodings::QuotedPrintable.encode(str), encoding]
+    end
+
+    def Ruby19.q_value_decode(str)
+      match = str.match(/\=\?(.+)?\?[Qq]\?(.+)?\?\=/m)
+      if match
+        encoding = match[1]
+        str = Encodings::QuotedPrintable.decode(match[2].gsub(/_/, '=20'))
+        str.force_encoding(fix_encoding(encoding))
+      end
+      decoded = str.encode("utf-8", :invalid => :replace, :replace => "")
+      decoded.valid_encoding? ? decoded : decoded.encode("utf-16le", :invalid => :replace, :replace => "").encode("utf-8")
+    end
+
+    def Ruby19.param_decode(str, encoding)
+      string = uri_parser.unescape(str)
+      string.force_encoding(encoding) if encoding
+      string
+    end
+
+    def Ruby19.param_encode(str)
+      encoding = str.encoding.to_s.downcase
+      language = Configuration.instance.param_encode_language
+      "#{encoding}'#{language}'#{uri_parser.escape(str)}"
+    end
+
+    def Ruby19.uri_parser
+      @uri_parser ||= URI::Parser.new
+    end
+
+     # mails somtimes includes invalid encodings like iso885915 or utf8 so we transform them to iso885915 or utf8
+     # TODO: add this as a test somewhere
+     # Encoding.list.map{|e| [e.to_s.upcase==fix_encoding(e.to_s.downcase.gsub("-", "")), e.to_s] }.select {|a,b| !b}
+     #  Encoding.list.map{|e| [e.to_s==fix_encoding(e.to_s), e.to_s] }.select {|a,b| !b}
+    def Ruby19.fix_encoding(encoding)
+      case encoding
+        # ISO-8859-15, ISO-2022-JP and alike
+        when /iso-?(\d{4})-?(\w{1,2})/i then return "ISO-#{$1}-#{$2}"
+        # "ISO-2022-JP-KDDI"  and alike
+        when /iso-?(\d{4})-?(\w{1,2})-?(\w*)/i then return "ISO-#{$1}-#{$2}-#{$3}"
+        # UTF-8, UTF-32BE and alike
+        when /utf-?(\d{1,2})?(\w{1,2})/i then return "UTF-#{$1}#{$2}".gsub(/\A(UTF-(?:16|32))\z/, '\\1BE')
+        # Windows-1252 and alike
+        when /Windows-?(.*)/i then return "Windows-#{$1}"
+        #more aliases to be added if needed
+        else return encoding
+      end
+    end
+  end
+end