IOWA 1.0.0

data/external/tmail/tmail/encode.rb

@@ -0,0 +1,447 @@
+#
+# encode.rb
+#
+# Copyright (c) 1998-2004 Minero Aoki
+#
+# This program is free software.
+# You can distribute/modify this program under the terms of
+# the GNU Lesser General Public License version 2.1.
+#
+
+require 'nkf'
+require 'tmail/base64.rb'
+require 'tmail/stringio'
+require 'tmail/textutils'
+
+
+module TMail
+
+  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
+
+    def encoded(eol = "\r\n", charset = 'j', dest = nil)
+      accept_strategy Encoder, eol, charset, dest
+    end
+
+    def decoded(eol = "\n", charset = 'e', dest = nil)
+      accept_strategy Decoder, eol, charset, dest
+    end
+
+    alias to_s decoded
+  
+    def accept_strategy(klass, eol, charset, dest = nil)
+      dest ||= ''
+      accept klass.new(create_dest(dest), charset, eol)
+      dest
+    end
+
+  end
+
+
+  ###
+  ### 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[$KCODE] || 'j')
+      opt = '-m' + 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)
+      @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 = 70
+
+    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[$KCODE]
+      @eol = eol
+      reset
+    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)
+      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(RFC2231_UNSAFE) {|s| '%%%02X' % s[0] }
+    end
+
+    private
+
+    def scanadd(str, force = false)
+      types = ''
+      strs = []
+
+      until str.empty?
+        if m = /\A[^\e\t\r\n ]+/.match(str)
+          types << (force ? 'j' : 'a')
+          strs.push m[0]
+
+        elsif m = /\A[\t\r\n ]+/.match(str)
+          types << 's'
+          strs.push m[0]
+
+        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'
+            strs.push m[0]
+          end
+
+        else
+          raise 'TMail FATAL: encoder scan fail'
+        end
+        str = m.post_match
+      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)
+      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
+      "\e$B#{str.slice!(0, size)}\e(B"
+    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
+      @lwsp = lwsp
+    end
+
+    def flush
+      # puts '---- flush ----'
+      # puts "spc >>>#{@lwsp.inspect}<<<"
+      # puts "txt >>>#{@text.inspect}<<<"
+      @f << @lwsp << @text
+      @curlen += (@lwsp.size + @text.size)
+      @text = ''
+      @lwsp = ''
+    end
+
+    def fold
+      # puts '---- fold ----'
+      @f << @eol
+      @curlen = 0
+      @lwsp = SPACER
+    end
+
+    def restsize
+      MAX_LINE_LEN - (@curlen + @lwsp.size + @text.size)
+    end
+
+  end
+
+end    # module TMail

data/external/tmail/tmail/header.rb

@@ -0,0 +1,895 @@
+#
+# header.rb
+#
+# Copyright (c) 1998-2004 Minero Aoki
+#
+# This program is free software.
+# You can distribute/modify this program under the terms of
+# the GNU Lesser General Public License version 2.1.
+#
+
+require 'tmail/encode'
+require 'tmail/address'
+require 'tmail/parser'
+require 'tmail/config'
+require 'tmail/textutils'
+
+
+module TMail
+
+  class HeaderField
+
+    include TextUtils
+
+    class << self
+
+      alias newobj new
+
+      def new(name, body, conf = DEFAULT_CONFIG)
+        klass = FNAME_TO_CLASS[name.downcase] || UnstructuredHeader
+        klass.newobj body, conf
+      end
+
+      def new_from_port(port, name, conf = DEFAULT_CONFIG)
+        re = Regexp.new('\A(' + Regexp.quote(name) + '):', 'i')
+        str = nil
+        port.ropen {|f|
+          f.each do |line|
+            if m = re.match(line)           then str = m.post_match.strip
+            elsif str and /\A[\t ]/ =~ line then str << ' ' << line.strip
+            elsif /\A-*\s*\z/ =~ line       then break
+            elsif str                       then break
+            end
+          end
+        }
+        new(name, str, Config.to_config(conf))
+      end
+
+      def internal_new(name, conf)
+        FNAME_TO_CLASS[name].newobj('', conf, true)
+      end
+
+    end   # class << self
+
+    def initialize(body, conf, intern = false)
+      @body = body
+      @config = conf
+
+      @illegal = false
+      @parsed = false
+      if intern
+        @parsed = true
+        parse_init
+      end
+    end
+
+    def inspect
+      "#<#{self.class} #{@body.inspect}>"
+    end
+
+    def illegal?
+      @illegal
+    end
+
+    def empty?
+      ensure_parsed
+      return true if @illegal
+      isempty?
+    end
+
+    private
+
+    def ensure_parsed
+      return if @parsed
+      @parsed = true
+      parse
+    end
+
+    # defabstract parse
+    # end
+
+    def clear_parse_status
+      @parsed = false
+      @illegal = false
+    end
+
+    public
+
+    def body
+      ensure_parsed
+      v = Decoder.new(s = '')
+      do_accept v
+      v.terminate
+      s
+    end
+
+    def body=(str)
+      @body = str
+      clear_parse_status
+    end
+
+    include StrategyInterface
+
+    def accept(strategy, dummy1 = nil, dummy2 = nil)
+      ensure_parsed
+      do_accept strategy
+      strategy.terminate
+    end
+
+    # abstract do_accept
+
+  end
+
+
+  class UnstructuredHeader < HeaderField
+
+    def body
+      ensure_parsed
+      @body
+    end
+
+    def body=(arg)
+      ensure_parsed
+      @body = arg
+    end
+
+    private
+
+    def parse_init
+    end
+
+    def parse
+      @body = Decoder.decode(@body.gsub(/\n|\r\n|\r/, ''))
+    end
+
+    def isempty?
+      not @body
+    end
+
+    def do_accept(strategy)
+      strategy.text @body
+    end
+
+  end
+
+
+  class StructuredHeader < HeaderField
+
+    def comments
+      ensure_parsed
+      @comments
+    end
+
+    private
+
+    def parse
+      save = nil
+
+      begin
+        parse_init
+        do_parse
+      rescue SyntaxError
+        if not save and mime_encoded? @body
+          save = @body
+          @body = Decoder.decode(save)
+          retry
+        elsif save
+          @body = save
+        end
+
+        @illegal = true
+        raise if @config.strict_parse?
+      end
+    end
+
+    def parse_init
+      @comments = []
+      init
+    end
+
+    def do_parse
+      obj = Parser.parse(self.class::PARSE_TYPE, @body, @comments)
+      set obj if obj
+    end
+
+  end
+
+
+  class DateTimeHeader < StructuredHeader
+
+    PARSE_TYPE = :DATETIME
+
+    def date
+      ensure_parsed
+      @date
+    end
+
+    def date=(arg)
+      ensure_parsed
+      @date = arg
+    end
+
+    private
+
+    def init
+      @date = nil
+    end
+
+    def set(t)
+      @date = t
+    end
+
+    def isempty?
+      not @date
+    end
+
+    def do_accept(strategy)
+      strategy.meta time2str(@date)
+    end
+
+  end
+
+
+  class AddressHeader < StructuredHeader
+
+    PARSE_TYPE = :MADDRESS
+
+    def addrs
+      ensure_parsed
+      @addrs
+    end
+
+    private
+
+    def init
+      @addrs = []
+    end
+
+    def set(a)
+      @addrs = a
+    end
+
+    def isempty?
+      @addrs.empty?
+    end
+
+    def do_accept(strategy)
+      first = true
+      @addrs.each do |a|
+        if first
+          first = false
+        else
+          strategy.meta ','
+          strategy.space
+        end
+        a.accept strategy
+      end
+
+      @comments.each do |c|
+        strategy.space
+        strategy.meta '('
+        strategy.text c
+        strategy.meta ')'
+      end
+    end
+
+  end
+
+
+  class ReturnPathHeader < AddressHeader
+
+    PARSE_TYPE = :RETPATH
+
+    def addr
+      addrs()[0]
+    end
+
+    def spec
+      a = addr() or return nil
+      a.spec
+    end
+
+    def routes
+      a = addr() or return nil
+      a.routes
+    end
+
+    private
+
+    def do_accept(strategy)
+      a = addr()
+
+      strategy.meta '<'
+      unless a.routes.empty?
+        strategy.meta a.routes.map {|i| '@' + i }.join(',')
+        strategy.meta ':'
+      end
+      spec = a.spec
+      strategy.meta spec if spec
+      strategy.meta '>'
+    end
+
+  end
+
+
+  class SingleAddressHeader < AddressHeader
+
+    def addr
+      addrs()[0]
+    end
+
+    private
+
+    def do_accept(strategy)
+      a = addr()
+      a.accept strategy
+      @comments.each do |c|
+        strategy.space
+        strategy.meta '('
+        strategy.text c
+        strategy.meta ')'
+      end
+    end
+
+  end
+
+
+  class MessageIdHeader < StructuredHeader
+
+    def id
+      ensure_parsed
+      @id
+    end
+
+    def id=(arg)
+      ensure_parsed
+      @id = arg
+    end
+
+    private
+
+    def init
+      @id = nil
+    end
+
+    def isempty?
+      not @id
+    end
+
+    def do_parse
+      @id = @body.slice(MESSAGE_ID) or
+              raise SyntaxError, "wrong Message-ID format: #{@body}"
+    end
+
+    def do_accept(strategy)
+      strategy.meta @id
+    end
+
+  end
+
+
+  class ReferencesHeader < StructuredHeader
+
+    def refs
+      ensure_parsed
+      @refs
+    end
+
+    def each_id
+      self.refs.each do |i|
+        yield i if MESSAGE_ID =~ i
+      end
+    end
+
+    def ids
+      ensure_parsed
+      @ids
+    end
+
+    def each_phrase
+      self.refs.each do |i|
+        yield i unless MESSAGE_ID =~ i
+      end
+    end
+
+    def phrases
+      result = []
+      each_phrase do |i|
+        result.push i
+      end
+      result
+    end
+
+    private
+
+    def init
+      @refs = []
+      @ids = []
+    end
+
+    def isempty?
+      @ids.empty?
+    end
+
+    def do_parse
+      str = @body
+      while m = MESSAGE_ID.match(str)
+        pre = m.pre_match.strip
+        @refs.push pre unless pre.empty?
+        @refs.push s = m[0]
+        @ids.push s
+        str = m.post_match
+      end
+      str = str.strip
+      @refs.push str unless str.empty?
+    end
+
+    def do_accept(strategy)
+      first = true
+      @ids.each do |i|
+        if first
+          first = false
+        else
+          strategy.space
+        end
+        strategy.meta i
+      end
+    end
+
+  end
+
+
+  class ReceivedHeader < StructuredHeader
+
+    PARSE_TYPE = :RECEIVED
+
+    def from
+      ensure_parsed
+      @from
+    end
+
+    def from=(arg)
+      ensure_parsed
+      @from = arg
+    end
+
+    def by
+      ensure_parsed
+      @by
+    end
+
+    def by=(arg)
+      ensure_parsed
+      @by = arg
+    end
+
+    def via
+      ensure_parsed
+      @via
+    end
+
+    def via=(arg)
+      ensure_parsed
+      @via = arg
+    end
+
+    def with
+      ensure_parsed
+      @with
+    end
+
+    def id
+      ensure_parsed
+      @id
+    end
+
+    def id=(arg)
+      ensure_parsed
+      @id = arg
+    end
+
+    def _for
+      ensure_parsed
+      @_for
+    end
+
+    def _for=(arg)
+      ensure_parsed
+      @_for = arg
+    end
+
+    def date
+      ensure_parsed
+      @date
+    end
+
+    def date=(arg)
+      ensure_parsed
+      @date = arg
+    end
+
+    private
+
+    def init
+      @from = @by = @via = @with = @id = @_for = nil
+      @with = []
+      @date = nil
+    end
+
+    def set(args)
+      @from, @by, @via, @with, @id, @_for, @date = *args
+    end
+
+    def isempty?
+      @with.empty? and not (@from or @by or @via or @id or @_for or @date)
+    end
+
+    def do_accept(strategy)
+      list = []
+      list.push 'from '  + @from       if @from
+      list.push 'by '    + @by         if @by
+      list.push 'via '   + @via        if @via
+      @with.each do |i|
+        list.push 'with ' + i
+      end
+      list.push 'id '    + @id         if @id
+      list.push 'for <'  + @_for + '>' if @_for
+
+      first = true
+      list.each do |i|
+        strategy.space unless first
+        strategy.meta i
+        first = false
+      end
+      if @date
+        strategy.meta ';'
+        strategy.space
+        strategy.meta time2str(@date)
+      end
+    end
+
+  end
+
+
+  class KeywordsHeader < StructuredHeader
+
+    PARSE_TYPE = :KEYWORDS
+
+    def keys
+      ensure_parsed
+      @keys
+    end
+
+    private
+
+    def init
+      @keys = []
+    end
+
+    def set(a)
+      @keys = a
+    end
+
+    def isempty?
+      @keys.empty?
+    end
+
+    def do_accept(strategy)
+      first = true
+      @keys.each do |i|
+        if first
+          first = false
+        else
+          strategy.meta ','
+        end
+        strategy.meta i
+      end
+    end
+
+  end
+
+
+  class EncryptedHeader < StructuredHeader
+
+    PARSE_TYPE = :ENCRYPTED
+
+    def encrypter
+      ensure_parsed
+      @encrypter
+    end
+
+    def encrypter=(arg)
+      ensure_parsed
+      @encrypter = arg
+    end
+
+    def keyword
+      ensure_parsed
+      @keyword
+    end
+
+    def keyword=(arg)
+      ensure_parsed
+      @keyword = arg
+    end
+
+    private
+
+    def init
+      @encrypter = nil
+      @keyword = nil
+    end
+
+    def set(args)
+      @encrypter, @keyword = args
+    end
+
+    def isempty?
+      not (@encrypter or @keyword)
+    end
+
+    def do_accept(strategy)
+      if @key
+        strategy.meta @encrypter + ','
+        strategy.space
+        strategy.meta @keyword
+      else
+        strategy.meta @encrypter
+      end
+    end
+
+  end
+
+
+  class MimeVersionHeader < StructuredHeader
+
+    PARSE_TYPE = :MIMEVERSION
+
+    def major
+      ensure_parsed
+      @major
+    end
+
+    def major=(arg)
+      ensure_parsed
+      @major = arg
+    end
+
+    def minor
+      ensure_parsed
+      @minor
+    end
+
+    def minor=(arg)
+      ensure_parsed
+      @minor = arg
+    end
+
+    def version
+      sprintf('%d.%d', major, minor)
+    end
+
+    private
+
+    def init
+      @major = nil
+      @minor = nil
+    end
+
+    def set(args)
+      @major, @minor = *args
+    end
+
+    def isempty?
+      not (@major or @minor)
+    end
+
+    def do_accept(strategy)
+      strategy.meta sprintf('%d.%d', @major, @minor)
+    end
+
+  end
+
+
+  class ContentTypeHeader < StructuredHeader
+
+    PARSE_TYPE = :CTYPE
+
+    def main_type
+      ensure_parsed
+      @main
+    end
+
+    def main_type=(arg)
+      ensure_parsed
+      @main = arg.downcase
+    end
+
+    def sub_type
+      ensure_parsed
+      @sub
+    end
+
+    def sub_type=(arg)
+      ensure_parsed
+      @sub = arg.downcase
+    end
+
+    def content_type
+      ensure_parsed
+      @sub ? sprintf('%s/%s', @main, @sub) : @main
+    end
+
+    def params
+      ensure_parsed
+      @params
+    end
+
+    def [](key)
+      ensure_parsed
+      @params and @params[key]
+    end
+
+    def []=(key, val)
+      ensure_parsed
+      (@params ||= {})[key] = val
+    end
+
+    private
+
+    def init
+      @main = @sub = @params = nil
+    end
+
+    def set(args)
+      @main, @sub, @params = *args
+    end
+
+    def isempty?
+      not (@main or @sub)
+    end
+
+    def do_accept(strategy)
+      if @sub
+        strategy.meta sprintf('%s/%s', @main, @sub)
+      else
+        strategy.meta @main
+      end
+      @params.each do |k,v|
+        strategy.meta ';'
+        strategy.space
+        strategy.kv_pair k, v
+      end
+    end
+
+  end
+
+
+  class ContentTransferEncodingHeader < StructuredHeader
+
+    PARSE_TYPE = :CENCODING
+
+    def encoding
+      ensure_parsed
+      @encoding
+    end
+
+    def encoding=(arg)
+      ensure_parsed
+      @encoding = arg
+    end
+
+    private
+
+    def init
+      @encoding = nil
+    end
+
+    def set(s)
+      @encoding = s
+    end
+
+    def isempty?
+      not @encoding
+    end
+
+    def do_accept(strategy)
+      strategy.meta @encoding.capitalize
+    end
+
+  end
+
+
+  class ContentDispositionHeader < StructuredHeader
+
+    PARSE_TYPE = :CDISPOSITION
+
+    def disposition
+      ensure_parsed
+      @disposition
+    end
+
+    def disposition=(str)
+      ensure_parsed
+      @disposition = str.downcase
+    end
+
+    def params
+      ensure_parsed
+      @params
+    end
+
+    def [](key)
+      ensure_parsed
+      @params and @params[key]
+    end
+
+    def []=(key, val)
+      ensure_parsed
+      (@params ||= {})[key] = val
+    end
+
+    private
+
+    def init
+      @disposition = @params = nil
+    end
+
+    def set(args)
+      @disposition, @params = *args
+    end
+
+    def isempty?
+      not @disposition and (not @params or @params.empty?)
+    end
+
+    def do_accept(strategy)
+      strategy.meta @disposition
+      @params.each do |k,v|
+        strategy.meta ';'
+        strategy.space
+        strategy.kv_pair k, v
+      end
+    end
+      
+  end
+
+
+  class HeaderField   # redefine
+
+    FNAME_TO_CLASS = {
+      'date'                      => DateTimeHeader,
+      'resent-date'               => DateTimeHeader,
+      'to'                        => AddressHeader,
+      'cc'                        => AddressHeader,
+      'bcc'                       => AddressHeader,
+      'from'                      => AddressHeader,
+      'reply-to'                  => AddressHeader,
+      'resent-to'                 => AddressHeader,
+      'resent-cc'                 => AddressHeader,
+      'resent-bcc'                => AddressHeader,
+      'resent-from'               => AddressHeader,
+      'resent-reply-to'           => AddressHeader,
+      'sender'                    => SingleAddressHeader,
+      'resent-sender'             => SingleAddressHeader,
+      'return-path'               => ReturnPathHeader,
+      'message-id'                => MessageIdHeader,
+      'resent-message-id'         => MessageIdHeader,
+      'in-reply-to'               => ReferencesHeader,
+      'received'                  => ReceivedHeader,
+      'references'                => ReferencesHeader,
+      'keywords'                  => KeywordsHeader,
+      'encrypted'                 => EncryptedHeader,
+      'mime-version'              => MimeVersionHeader,
+      'content-type'              => ContentTypeHeader,
+      'content-transfer-encoding' => ContentTransferEncodingHeader,
+      'content-disposition'       => ContentDispositionHeader,
+      'content-id'                => MessageIdHeader,
+      'subject'                   => UnstructuredHeader,
+      'comments'                  => UnstructuredHeader,
+      'content-description'       => UnstructuredHeader
+    }
+
+  end
+
+end   # module TMail