--- /dev/null
+#--
+# = COPYRIGHT:
+#
+# Copyright (c) 1998-2003 Minero Aoki <aamine@loveruby.net>
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+# Note: Originally licensed under LGPL v2+. Using MIT license for Rails
+# with permission of Minero Aoki.
+#++
+#:stopdoc:
+require 'nkf'
+require 'tmail/base64'
+require 'tmail/stringio'
+require 'tmail/utils'
+#:startdoc:
+
+
+module TMail
+
+ #:stopdoc:
+ class << self
+ attr_accessor :KCODE
+ end
+ self.KCODE = 'NONE'
+
+ module StrategyInterface
+
+ def create_dest( obj )
+ case obj
+ when nil
+ StringOutput.new
+ when String
+ StringOutput.new(obj)
+ when IO, StringOutput
+ obj
+ else
+ raise TypeError, 'cannot handle this type of object for dest'
+ end
+ end
+ module_function :create_dest
+
+ #:startdoc:
+ # Returns the TMail object encoded and ready to be sent via SMTP etc.
+ # You should call this before you are packaging up your email to
+ # correctly escape all the values that need escaping in the email, line
+ # wrap the email etc.
+ #
+ # It is also a good idea to call this before you marshal or serialize
+ # a TMail object.
+ #
+ # For Example:
+ #
+ # email = TMail::Load(my_email_file)
+ # email_to_send = email.encoded
+ def encoded( eol = "\r\n", charset = 'j', dest = nil )
+ accept_strategy Encoder, eol, charset, dest
+ end
+
+ # Returns the TMail object decoded and ready to be used by you, your
+ # program etc.
+ #
+ # You should call this before you are packaging up your email to
+ # correctly escape all the values that need escaping in the email, line
+ # wrap the email etc.
+ #
+ # For Example:
+ #
+ # email = TMail::Load(my_email_file)
+ # email_to_send = email.encoded
+ def decoded( eol = "\n", charset = 'e', dest = nil )
+ # Turn the E-Mail into a string and return it with all
+ # encoded characters decoded. alias for to_s
+ accept_strategy Decoder, eol, charset, dest
+ end
+
+ alias to_s decoded
+
+ def accept_strategy( klass, eol, charset, dest = nil ) #:nodoc:
+ dest ||= ''
+ accept klass.new( create_dest(dest), charset, eol )
+ dest
+ end
+
+ end
+
+ #:stopdoc:
+
+ ###
+ ### MIME B encoding decoder
+ ###
+
+ class Decoder
+
+ include TextUtils
+
+ encoded = '=\?(?:iso-2022-jp|euc-jp|shift_jis)\?[QB]\?[a-z0-9+/=]+\?='
+ ENCODED_WORDS = /#{encoded}(?:\s+#{encoded})*/i
+
+ OUTPUT_ENCODING = {
+ 'EUC' => 'e',
+ 'SJIS' => 's',
+ }
+
+ def self.decode( str, encoding = nil )
+ encoding ||= (OUTPUT_ENCODING[TMail.KCODE] || 'j')
+ opt = '-mS' + encoding
+ str.gsub(ENCODED_WORDS) {|s| NKF.nkf(opt, s) }
+ end
+
+ def initialize( dest, encoding = nil, eol = "\n" )
+ @f = StrategyInterface.create_dest(dest)
+ @encoding = (/\A[ejs]/ === encoding) ? encoding[0,1] : nil
+ @eol = eol
+ end
+
+ def decode( str )
+ self.class.decode(str, @encoding)
+ end
+ private :decode
+
+ def terminate
+ end
+
+ def header_line( str )
+ @f << decode(str)
+ end
+
+ def header_name( nm )
+ @f << nm << ': '
+ end
+
+ def header_body( str )
+ @f << decode(str)
+ end
+
+ def space
+ @f << ' '
+ end
+
+ alias spc space
+
+ def lwsp( str )
+ @f << str
+ end
+
+ def meta( str )
+ @f << str
+ end
+
+ def text( str )
+ @f << decode(str)
+ end
+
+ def phrase( str )
+ @f << quote_phrase(decode(str))
+ end
+
+ def kv_pair( k, v )
+ v = dquote(v) unless token_safe?(v)
+ @f << k << '=' << v
+ end
+
+ def puts( str = nil )
+ @f << str if str
+ @f << @eol
+ end
+
+ def write( str )
+ @f << str
+ end
+
+ end
+
+
+ ###
+ ### MIME B-encoding encoder
+ ###
+
+ #
+ # FIXME: This class can handle only (euc-jp/shift_jis -> iso-2022-jp).
+ #
+ class Encoder
+
+ include TextUtils
+
+ BENCODE_DEBUG = false unless defined?(BENCODE_DEBUG)
+
+ def Encoder.encode( str )
+ e = new()
+ e.header_body str
+ e.terminate
+ e.dest.string
+ end
+
+ SPACER = "\t"
+ MAX_LINE_LEN = 78
+ RFC_2822_MAX_LENGTH = 998
+
+ OPTIONS = {
+ 'EUC' => '-Ej -m0',
+ 'SJIS' => '-Sj -m0',
+ 'UTF8' => nil, # FIXME
+ 'NONE' => nil
+ }
+
+ def initialize( dest = nil, encoding = nil, eol = "\r\n", limit = nil )
+ @f = StrategyInterface.create_dest(dest)
+ @opt = OPTIONS[TMail.KCODE]
+ @eol = eol
+ @folded = false
+ @preserve_quotes = true
+ reset
+ end
+
+ def preserve_quotes=( bool )
+ @preserve_quotes
+ end
+
+ def preserve_quotes
+ @preserve_quotes
+ end
+
+ def normalize_encoding( str )
+ if @opt
+ then NKF.nkf(@opt, str)
+ else str
+ end
+ end
+
+ def reset
+ @text = ''
+ @lwsp = ''
+ @curlen = 0
+ end
+
+ def terminate
+ add_lwsp ''
+ reset
+ end
+
+ def dest
+ @f
+ end
+
+ def puts( str = nil )
+ @f << str if str
+ @f << @eol
+ end
+
+ def write( str )
+ @f << str
+ end
+
+ #
+ # add
+ #
+
+ def header_line( line )
+ scanadd line
+ end
+
+ def header_name( name )
+ add_text name.split(/-/).map {|i| i.capitalize }.join('-')
+ add_text ':'
+ add_lwsp ' '
+ end
+
+ def header_body( str )
+ scanadd normalize_encoding(str)
+ end
+
+ def space
+ add_lwsp ' '
+ end
+
+ alias spc space
+
+ def lwsp( str )
+ add_lwsp str.sub(/[\r\n]+[^\r\n]*\z/, '')
+ end
+
+ def meta( str )
+ add_text str
+ end
+
+ def text( str )
+ scanadd normalize_encoding(str)
+ end
+
+ def phrase( str )
+ str = normalize_encoding(str)
+ if CONTROL_CHAR === str
+ scanadd str
+ else
+ add_text quote_phrase(str)
+ end
+ end
+
+ # FIXME: implement line folding
+ #
+ def kv_pair( k, v )
+ return if v.nil?
+ v = normalize_encoding(v)
+ if token_safe?(v)
+ add_text k + '=' + v
+ elsif not CONTROL_CHAR === v
+ add_text k + '=' + quote_token(v)
+ else
+ # apply RFC2231 encoding
+ kv = k + '*=' + "iso-2022-jp'ja'" + encode_value(v)
+ add_text kv
+ end
+ end
+
+ def encode_value( str )
+ str.gsub(TOKEN_UNSAFE) {|s| '%%%02x' % s[0] }
+ end
+
+ private
+
+ def scanadd( str, force = false )
+ types = ''
+ strs = []
+ if str.respond_to?(:encoding)
+ enc = str.encoding
+ str.force_encoding(Encoding::ASCII_8BIT)
+ end
+ until str.empty?
+ if m = /\A[^\e\t\r\n ]+/.match(str)
+ types << (force ? 'j' : 'a')
+ if str.respond_to?(:encoding)
+ strs.push m[0].force_encoding(enc)
+ else
+ strs.push m[0]
+ end
+ elsif m = /\A[\t\r\n ]+/.match(str)
+ types << 's'
+ if str.respond_to?(:encoding)
+ strs.push m[0].force_encoding(enc)
+ else
+ strs.push m[0]
+ end
+
+ elsif m = /\A\e../.match(str)
+ esc = m[0]
+ str = m.post_match
+ if esc != "\e(B" and m = /\A[^\e]+/.match(str)
+ types << 'j'
+ if str.respond_to?(:encoding)
+ strs.push m[0].force_encoding(enc)
+ else
+ strs.push m[0]
+ end
+ end
+
+ else
+ raise 'TMail FATAL: encoder scan fail'
+ end
+ (str = m.post_match) unless m.nil?
+ end
+
+ do_encode types, strs
+ end
+
+ def do_encode( types, strs )
+ #
+ # result : (A|E)(S(A|E))*
+ # E : W(SW)*
+ # W : (J|A)+ but must contain J # (J|A)*J(J|A)*
+ # A : <<A character string not to be encoded>>
+ # J : <<A character string to be encoded>>
+ # S : <<LWSP>>
+ #
+ # An encoding unit is `E'.
+ # Input (parameter `types') is (J|A)(J|A|S)*(J|A)
+ #
+ if BENCODE_DEBUG
+ puts
+ puts '-- do_encode ------------'
+ puts types.split(//).join(' ')
+ p strs
+ end
+
+ e = /[ja]*j[ja]*(?:s[ja]*j[ja]*)*/
+
+ while m = e.match(types)
+ pre = m.pre_match
+ concat_A_S pre, strs[0, pre.size] unless pre.empty?
+ concat_E m[0], strs[m.begin(0) ... m.end(0)]
+ types = m.post_match
+ strs.slice! 0, m.end(0)
+ end
+ concat_A_S types, strs
+ end
+
+ def concat_A_S( types, strs )
+ if RUBY_VERSION < '1.9'
+ a = ?a; s = ?s
+ else
+ a = 'a'.ord; s = 's'.ord
+ end
+ i = 0
+ types.each_byte do |t|
+ case t
+ when a then add_text strs[i]
+ when s then add_lwsp strs[i]
+ else
+ raise "TMail FATAL: unknown flag: #{t.chr}"
+ end
+ i += 1
+ end
+ end
+
+ METHOD_ID = {
+ ?j => :extract_J,
+ ?e => :extract_E,
+ ?a => :extract_A,
+ ?s => :extract_S
+ }
+
+ def concat_E( types, strs )
+ if BENCODE_DEBUG
+ puts '---- concat_E'
+ puts "types=#{types.split(//).join(' ')}"
+ puts "strs =#{strs.inspect}"
+ end
+
+ flush() unless @text.empty?
+
+ chunk = ''
+ strs.each_with_index do |s,i|
+ mid = METHOD_ID[types[i]]
+ until s.empty?
+ unless c = __send__(mid, chunk.size, s)
+ add_with_encode chunk unless chunk.empty?
+ flush
+ chunk = ''
+ fold
+ c = __send__(mid, 0, s)
+ raise 'TMail FATAL: extract fail' unless c
+ end
+ chunk << c
+ end
+ end
+ add_with_encode chunk unless chunk.empty?
+ end
+
+ def extract_J( chunksize, str )
+ size = max_bytes(chunksize, str.size) - 6
+ size = (size % 2 == 0) ? (size) : (size - 1)
+ return nil if size <= 0
+ if str.respond_to?(:encoding)
+ enc = str.encoding
+ str.force_encoding(Encoding::ASCII_8BIT)
+ "\e$B#{str.slice!(0, size)}\e(B".force_encoding(enc)
+ else
+ "\e$B#{str.slice!(0, size)}\e(B"
+ end
+ end
+
+ def extract_A( chunksize, str )
+ size = max_bytes(chunksize, str.size)
+ return nil if size <= 0
+ str.slice!(0, size)
+ end
+
+ alias extract_S extract_A
+
+ def max_bytes( chunksize, ssize )
+ (restsize() - '=?iso-2022-jp?B??='.size) / 4 * 3 - chunksize
+ end
+
+ #
+ # free length buffer
+ #
+
+ def add_text( str )
+ @text << str
+ # puts '---- text -------------------------------------'
+ # puts "+ #{str.inspect}"
+ # puts "txt >>>#{@text.inspect}<<<"
+ end
+
+ def add_with_encode( str )
+ @text << "=?iso-2022-jp?B?#{Base64.encode(str)}?="
+ end
+
+ def add_lwsp( lwsp )
+ # puts '---- lwsp -------------------------------------'
+ # puts "+ #{lwsp.inspect}"
+ fold if restsize() <= 0
+ flush(@folded)
+ @lwsp = lwsp
+ end
+
+ def flush(folded = false)
+ # puts '---- flush ----'
+ # puts "spc >>>#{@lwsp.inspect}<<<"
+ # puts "txt >>>#{@text.inspect}<<<"
+ @f << @lwsp << @text
+ if folded
+ @curlen = 0
+ else
+ @curlen += (@lwsp.size + @text.size)
+ end
+ @text = ''
+ @lwsp = ''
+ end
+
+ def fold
+ # puts '---- fold ----'
+ unless @f.string =~ /^.*?:$/
+ @f << @eol
+ @lwsp = SPACER
+ else
+ fold_header
+ @folded = true
+ end
+ @curlen = 0
+ end
+
+ def fold_header
+ # Called because line is too long - so we need to wrap.
+ # First look for whitespace in the text
+ # if it has text, fold there
+ # check the remaining text, if too long, fold again
+ # if it doesn't, then don't fold unless the line goes beyond 998 chars
+
+ # Check the text to see if there is whitespace, or if not
+ @wrapped_text = []
+ until @text.blank?
+ fold_the_string
+ end
+ @text = @wrapped_text.join("#{@eol}#{SPACER}")
+ end
+
+ def fold_the_string
+ whitespace_location = @text =~ /\s/ || @text.length
+ # Is the location of the whitespace shorter than the RCF_2822_MAX_LENGTH?
+ # if there is no whitespace in the string, then this
+ unless mazsize(whitespace_location) <= 0
+ @text.strip!
+ @wrapped_text << @text.slice!(0...whitespace_location)
+ # If it is not less, we have to wrap it destructively
+ else
+ slice_point = RFC_2822_MAX_LENGTH - @curlen - @lwsp.length
+ @text.strip!
+ @wrapped_text << @text.slice!(0...slice_point)
+ end
+ end
+
+ def restsize
+ MAX_LINE_LEN - (@curlen + @lwsp.size + @text.size)
+ end
+
+ def mazsize(whitespace_location)
+ # Per RFC2822, the maximum length of a line is 998 chars
+ RFC_2822_MAX_LENGTH - (@curlen + @lwsp.size + whitespace_location)
+ end
+
+ end
+ #:startdoc:
+end # module TMail
projects / depot.git / blobdiff