rims-rfc822 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 51ec6ae41467b2b68bd8d1bb23916ad42f27fb6b688f8769f64e61db5e8afd98
-  data.tar.gz: f48b88893f67da1da2824336bfe274b033131527420de1926bea05faa7036618
+  metadata.gz: '0825e7fac6f422946c68301c42abcce200e31d32a96ed83d6b1879a5a2b7c6cf'
+  data.tar.gz: '091affd6b8394475774ea160b56eb870f01785f72c1b737ea41fe4a5c6698d82'
 SHA512:
-  metadata.gz: 77e6b92ea9e32a7a94972d493103e03face8eaf6872400a324242431b3c8ecd5211bf0bd4c77959c47e634d820bd26089f250cd49a5e54ccfdf496cbbdaf7e08
-  data.tar.gz: a94818fedb229ad9df8683d027aa9c0cacf57a9b5296ae279794d1132e310b0a93a7158bc2c25f72279117ce29c90090b945a2e79f552fab07b1b3a1467dedb2
+  metadata.gz: 210d959c67edec519382dfcb24e7aa1069a93e8da0b001badff3c8e643b2aaf83c5a0f84e54f0354fe1740e86b4a2467f5c5f503420fd6e2b2e89b15c0585dc7
+  data.tar.gz: ad09d49a4f5caab505893a90e5c309d3d2878178aa73dcec2784fbbf38ad24ac5028710c3f62ece160bc7ccbbbdbf1969fe70c38ae13d1a322f0a99cad5e1cd3

data/README.md

@@ -33,6 +33,15 @@ msg = RIMS::RFC822::Message.new(your_rfc822_text)
 p msg.header
 p msg.body
 
+# header fields
+p msg.header[name]
+p msg.header.fetch_upcase(name)
+p msg.header.field_value_list(name)
+p msg.header.key? name
+msg.header.each do |name, value|
+  p [ name, value ]
+end
+
 # source text attributes
 p msg.raw_source
 p msg.header.raw_source
@@ -52,7 +61,7 @@ p msg.content_disposition_parameter(name)
 p msg.content_disposition_parameter_list
 p msg.content_language
 
-# headear attributes
+# header attributes
 p msg.date
 p msg.from
 p msg.sender
@@ -61,12 +70,23 @@ p msg.to
 p msg.cc
 p msg.bcc
 
-# content attributes
+# body structure attributes
 p msg.text?
 p msg.multipart?
 p msg.message?
 p msg.parts
 p msg.message
+
+# MIME header and body attributes
+p msg.mime_decoded_header(name)
+p msg.mime_decoded_header(name, decode_charset)
+p msg.mime_decoded_header_field_value_list(name)
+p msg.mime_decoded_header_field_value_list(name, decode_charset)
+p msg.mime_decoded_header_text
+p msg.mime_decoded_header_text(decode_charset)
+p msg.mime_charset_body_text
+p msg.mime_charset_body_text(charset)
+p msg.mime_binary_body_string
 ```
 
 Contributing

data/lib/rims/rfc822.rb

@@ -1,256 +1,452 @@
 # -*- coding: utf-8; frozen_string_literal: true -*-
 
+require 'forwardable'
 require 'rims/rfc822/version'
 require 'time'
 
 module RIMS
   module RFC822
-    def split_message(msg_txt)
-      header_txt, body_txt = msg_txt.lstrip.split(/\r?\n\r?\n/, 2)
-      if ($&) then
-        header_txt << $& if $&
-      else
-        body_txt = header_txt
-        header_txt = nil
-      end
-
-      [ header_txt.freeze, body_txt.freeze ].freeze
-    end
-    module_function :split_message
+    module Parse
+      def split_message(msg_txt)
+        header_txt, body_txt = msg_txt.lstrip.split(/\r?\n\r?\n/, 2)
+        if ($&) then
+          header_txt << $& if $&
+        else
+          body_txt = header_txt
+          header_txt = nil
+        end
 
-    def parse_header(header_txt)
-      field_pair_list = header_txt.scan(%r{
-        ^
-        ((?#name) \S+? )
-        \s* : \s*
-        (
-           (?#value)
-           .*? (?: \n|\z)
-           (?: ^\s .*? (?: \n|\z) )*
-        )
-      }x)
-
-      for name, value in field_pair_list
-        value.strip!
-        name.freeze
-        value.freeze
-      end
-
-      field_pair_list.freeze
-    end
-    module_function :parse_header
+        [ header_txt.freeze, body_txt.freeze ].freeze
+      end
+      module_function :split_message
+
+      def parse_header(header_txt)
+        field_pair_list = header_txt.scan(%r{
+          ^
+          ((?#name) \S+? )
+          \s* : \s*
+          (
+             (?#value)
+             .*? (?: \n|\z)
+             (?: ^\s .*? (?: \n|\z) )*
+          )
+        }x)
+
+        for name, value in field_pair_list
+          value.strip!
+          name.freeze
+          value.freeze
+        end
 
-    def unquote_phrase(phrase_txt)
-      state = :raw
-      src_txt = phrase_txt.dup
-      dst_txt = ''.encode(phrase_txt.encoding)
-
-      while (src_txt.sub!(/\A (?: " | \( | \) | \\ | [^"\(\)\\]+ )/x, ''))
-        match_txt = $&
-        case (state)
-        when :raw
-          case (match_txt)
-          when '"'
-            state = :quote
-          when '('
-            state = :comment
-          when "\\"
-            src_txt.sub!(/\A./, '') and dst_txt << $&
+        field_pair_list.freeze
+      end
+      module_function :parse_header
+
+      def unquote_phrase(phrase_txt)
+        state = :raw
+        src_txt = phrase_txt.dup
+        dst_txt = ''.encode(phrase_txt.encoding)
+
+        while (src_txt.sub!(/\A (?: " | \( | \) | \\ | [^"\(\)\\]+ )/x, ''))
+          match_txt = $&
+          case (state)
+          when :raw
+            case (match_txt)
+            when '"'
+              state = :quote
+            when '('
+              state = :comment
+            when "\\"
+              src_txt.sub!(/\A./, '') and dst_txt << $&
+            else
+              dst_txt << match_txt
+            end
+          when :quote
+            case (match_txt)
+            when '"'
+              state = :raw
+            when "\\"
+              src_txt.sub!(/\A./, '') && dst_txt << $&
+            else
+              dst_txt << match_txt
+            end
+          when :comment
+            case (match_txt)
+            when ')'
+              state = :raw
+            when "\\"
+              src_txt.sub!(/\A./, '')
+            else
+              # ignore comment text.
+            end
           else
-            dst_txt << match_txt
+            raise "internal error - unknown state: #{state}"
           end
-        when :quote
-          case (match_txt)
-          when '"'
-            state = :raw
-          when "\\"
-            src_txt.sub!(/\A./, '') && dst_txt << $&
+        end
+
+        dst_txt.freeze
+      end
+      module_function :unquote_phrase
+
+      def parse_parameters(parameters_txt)
+        params = {}
+        parameters_txt.scan(%r'(?<name>\S+?) \s* = \s* (?: (?<quoted_string>".*?") | (?<token>\S+?) ) \s* (?:;|\Z)'x) do
+          name = $~[:name]
+          if ($~[:quoted_string]) then
+            quoted_value = $~[:quoted_string]
+            value = unquote_phrase(quoted_value)
           else
-            dst_txt << match_txt
+            value = $~[:token]
           end
-        when :comment
-          case (match_txt)
-          when ')'
-            state = :raw
-          when "\\"
-            src_txt.sub!(/\A./, '')
+          params[name.downcase.freeze] = [ name.freeze, value.freeze ].freeze
+        end
+
+        params.freeze
+      end
+      module_function :parse_parameters
+
+      def split_parameters(type_params_txt)
+        type, params_txt = type_params_txt.split(';', 2)
+        if (type) then
+          type.strip!
+          type.freeze
+          if (params_txt) then
+            params = parse_parameters(params_txt)
           else
-            # ignore comment text.
+            params = {}.freeze
           end
+          [ type, params ].freeze
         else
-          raise "internal error: unknown state #{state}"
+          [ nil, {}.freeze ].freeze
         end
       end
+      module_function :split_parameters
+
+      def parse_content_type(type_txt)
+        media_type_txt, params = split_parameters(type_txt)
+        if (media_type_txt) then
+          main_type, sub_type = media_type_txt.split('/', 2)
+          if (main_type) then
+            main_type.strip!
+            main_type.freeze
+            if (sub_type) then
+              sub_type.strip!
+              sub_type.freeze
+              if (! main_type.empty? && ! sub_type.empty?) then
+                return [ main_type, sub_type, params ].freeze
+              end
+            end
+          end
+        end
 
-      dst_txt.freeze
-    end
-    module_function :unquote_phrase
+        [ 'application'.dup.force_encoding(type_txt.encoding).freeze,
+          'octet-stream'.dup.force_encoding(type_txt.encoding).freeze,
+          params
+        ].freeze
+      end
+      module_function :parse_content_type
 
-    def parse_parameters(parameters_txt)
-      params = {}
-      parameters_txt.scan(%r'(?<name>\S+?) \s* = \s* (?: (?<quoted_string>".*?") | (?<token>\S+?) ) \s* (?:;|\Z)'x) do
-        name = $~[:name]
-        if ($~[:quoted_string]) then
-          quoted_value = $~[:quoted_string]
-          value = unquote_phrase(quoted_value)
-        else
-          value = $~[:token]
-        end
-        params[name.downcase.freeze] = [ name.freeze, value.freeze ].freeze
+      def parse_content_disposition(disposition_txt)
+        split_parameters(disposition_txt)
       end
+      module_function :parse_content_disposition
 
-      params.freeze
-    end
-    module_function :parse_parameters
+      def parse_content_language(language_tags_txt)
+        tag_list = language_tags_txt.split(',')
+        for tag in tag_list
+          tag.strip!
+          tag.freeze
+        end
+        tag_list.reject!(&:empty?)
+
+        tag_list.freeze
+      end
+      module_function :parse_content_language
+
+      def parse_multipart_body(boundary, body_txt)
+        delim = '--' + boundary
+        term = delim + '--'
+        body_txt2, _body_epilogue_txt = body_txt.split(term, 2)
+        if (body_txt2) then
+          _body_preamble_txt, body_parts_txt = body_txt2.split(delim, 2)
+          if (body_parts_txt) then
+            part_list = body_parts_txt.split(delim, -1)
+            for part_txt in part_list
+              part_txt.lstrip!
+              part_txt.chomp!("\n")
+              part_txt.chomp!("\r")
+              part_txt.freeze
+            end
+            return part_list.freeze
+          end
+        end
 
-    def split_parameters(type_params_txt)
-      type, params_txt = type_params_txt.split(';', 2)
-      if (type) then
-        type.strip!
-        type.freeze
-        if (params_txt) then
-          params = parse_parameters(params_txt)
-        else
-          params = {}.freeze
+        [].freeze
+      end
+      module_function :parse_multipart_body
+
+      Address = Struct.new(:display_name, :route, :local_part, :domain)
+      class Address
+        # compatible for Net::MAP::Address
+        alias name display_name
+        alias mailbox local_part
+        alias host domain
+      end
+
+      def parse_mail_address_list(address_list_txt)
+        addr_list = []
+        src_txt = address_list_txt.dup
+
+        while (true)
+          if (src_txt.sub!(%r{
+                \A
+                \s*
+                (?<display_name>\S.*?) \s* : (?<group_list>.*?) ;
+                \s*
+                ,?
+              }x, ''))
+          then
+            display_name = $~[:display_name]
+            group_list = $~[:group_list]
+            addr_list << Address.new( nil, nil, unquote_phrase(display_name), nil).freeze
+            addr_list.concat(parse_mail_address_list(group_list))
+            addr_list << Address.new(nil, nil, nil, nil).freeze
+          elsif (src_txt.sub!(%r{
+                   \A
+                   \s*
+                   (?<local_part>[^<>@",\s]+) \s* @ \s* (?<domain>[^<>@",\s]+)
+                   \s*
+                   ,?
+                 }x, ''))
+          then
+            addr_list << Address.new(nil, nil, $~[:local_part].freeze, $~[:domain].freeze).freeze
+          elsif (src_txt.sub!(%r{
+                   \A
+                   \s*
+                   (?<display_name>\S.*?)
+                   \s*
+                   <
+                     \s*
+                     (?:
+                       (?<route>@[^<>@",]* (?:, \s* @[^<>@",]*)*)
+                       \s*
+                       :
+                     )?
+                     \s*
+                     (?<local_part>[^<>@",\s]+) \s* @ \s* (?<domain>[^<>@",\s]+)
+                     \s*
+                   >
+                   \s*
+                   ,?
+                 }x, ''))
+          then
+            display_name = $~[:display_name]
+            route = $~[:route]
+            local_part = $~[:local_part]
+            domain = $~[:domain]
+            addr_list << Address.new(unquote_phrase(display_name), route.freeze, local_part.freeze, domain.freeze).freeze
+          else
+            break
+          end
         end
-        [ type, params ].freeze
-      else
-        [ nil, {}.freeze ].freeze
+
+        addr_list.freeze
       end
+      module_function :parse_mail_address_list
     end
+
+    # for backward compatibility
+    include Parse
+    module_function :split_message
+    module_function :parse_header
+    module_function :unquote_phrase
+    module_function :parse_parameters
     module_function :split_parameters
+    module_function :parse_content_type
+    module_function :parse_content_disposition
+    module_function :parse_content_language
+    module_function :parse_multipart_body
+    module_function :parse_mail_address_list
 
-    def parse_content_type(type_txt)
-      media_type_txt, params = split_parameters(type_txt)
-      if (media_type_txt) then
-        main_type, sub_type = media_type_txt.split('/', 2)
-        if (main_type) then
-          main_type.strip!
-          main_type.freeze
-          if (sub_type) then
-            sub_type.strip!
-            sub_type.freeze
-            if (! main_type.empty? && ! sub_type.empty?) then
-              return [ main_type, sub_type, params ].freeze
-            end
-          end
+    class CharsetAliases
+      def initialize
+        @alias_table = {}
+      end
+
+      # API methods
+
+      def [](name)
+        @alias_table[name.upcase]
+      end
+
+      def add_alias(name, encoding)
+        @alias_table[name.upcase] = encoding
+        self
+      end
+
+      def delete_alias(name)
+        @alias_table.delete(name.upcase)
+      end
+
+      # minimal methods like `Hash'
+
+      extend Forwardable
+      include Enumerable
+
+      def_delegators :@alias_table, :empty?, :size, :keys
+      alias length size
+
+      def key?(name)
+        @alias_table.key? name.upcase
+      end
+
+      alias has_key? key?
+      alias include? key?
+      alias member? key?
+
+      def each_key
+        return enum_for(:each_key) unless block_given?
+        @alias_table.each_key do |name|
+          yield(name)
         end
+        self
       end
 
-      [ 'application'.dup.force_encoding(type_txt.encoding).freeze,
-        'octet-stream'.dup.force_encoding(type_txt.encoding).freeze,
-        params
-      ].freeze
-    end
-    module_function :parse_content_type
+      def each_pair
+        return enum_for(:each_pair) unless block_given?
+        @alias_table.each_pair do |name, encoding|
+          yield(name, encoding)
+        end
+        self
+      end
 
-    def parse_content_disposition(disposition_txt)
-      split_parameters(disposition_txt)
+      alias each each_pair
     end
-    module_function :parse_content_disposition
 
-    def parse_content_language(language_tags_txt)
-      tag_list = language_tags_txt.split(',')
-      for tag in tag_list
-        tag.strip!
-        tag.freeze
+    DEFAULT_CHARSET_ALIASES = CharsetAliases.new
+    #DEFAULT_CHARSET_ALIASES.add_alias('euc-jp', Encoding::CP51932)
+    DEFAULT_CHARSET_ALIASES.add_alias('euc-jp', Encoding::EUCJP_MS)
+    #DEFAULT_CHARSET_ALIASES.add_alias('iso-2022-jp', Encoding::CP50220)
+    DEFAULT_CHARSET_ALIASES.add_alias('iso-2022-jp', Encoding::CP50221)
+    DEFAULT_CHARSET_ALIASES.add_alias('shift_jis', Encoding::WINDOWS_31J)
+
+    module CharsetText
+      def self.find_string_encoding(name)
+        begin
+          Encoding.find(name)
+        rescue ArgumentError
+          raise EncodingError.new($!.to_s)
+        end
       end
-      tag_list.reject!(&:empty?)
 
-      tag_list.freeze
-    end
-    module_function :parse_content_language
+      def get_mime_charset_text(binary_string, charset, transfer_encoding=nil, charset_aliases: DEFAULT_CHARSET_ALIASES)
+        case (transfer_encoding&.upcase)
+        when 'BASE64'
+          text = binary_string.unpack1('m')
+        when 'QUOTED-PRINTABLE'
+          text = binary_string.unpack1('M')
+        else
+          text = binary_string.dup
+        end
 
-    def parse_multipart_body(boundary, body_txt)
-      delim = '--' + boundary
-      term = delim + '--'
-      body_txt2, _body_epilogue_txt = body_txt.split(term, 2)
-      if (body_txt2) then
-        _body_preamble_txt, body_parts_txt = body_txt2.split(delim, 2)
-        if (body_parts_txt) then
-          part_list = body_parts_txt.split(delim, -1)
-          for part_txt in part_list
-            part_txt.lstrip!
-            part_txt.chomp!("\n")
-            part_txt.chomp!("\r")
-            part_txt.freeze
+        if (charset) then
+          if (charset.is_a? Encoding) then
+            enc = charset
+          else
+            enc = charset_aliases[charset] ||
+                  CharsetText.find_string_encoding(charset) # raise `EncodingError' when wrong charset due to document
           end
-          return part_list.freeze
+          text.force_encoding(enc)
+          text.valid_encoding? or raise EncodingError, "invalid encoding - #{enc}"
         end
+
+        text.freeze
       end
+      module_function :get_mime_charset_text
 
-      [].freeze
-    end
-    module_function :parse_multipart_body
+      ENCODED_WORD_TRANSFER_ENCODING_TABLE = { # :nodoc:
+        'B' => 'BASE64',
+        'Q' => 'QUOTED-PRINTABLE'
+      }.freeze
 
-    Address = Struct.new(:display_name, :route, :local_part, :domain)
-    class Address
-      # compatible for Net::MAP::Address
-      alias name display_name
-      alias mailbox local_part
-      alias host domain
-    end
+      def decode_mime_encoded_words(encoded_string, decode_charset=nil, charset_aliases: DEFAULT_CHARSET_ALIASES, charset_convert_options: {})
+        src = encoded_string
+        dst = ''.dup
 
-    def parse_mail_address_list(address_list_txt)
-      addr_list = []
-      src_txt = address_list_txt.dup
-
-      while (true)
-        if (src_txt.sub!(%r{
-              \A
-              \s*
-              (?<display_name>\S.*?) \s* : (?<group_list>.*?) ;
-              \s*
-              ,?
-            }x, ''))
-        then
-          display_name = $~[:display_name]
-          group_list = $~[:group_list]
-          addr_list << Address.new( nil, nil, unquote_phrase(display_name), nil).freeze
-          addr_list.concat(parse_mail_address_list(group_list))
-          addr_list << Address.new(nil, nil, nil, nil).freeze
-        elsif (src_txt.sub!(%r{
-                 \A
-                 \s*
-                 (?<local_part>[^<>@",\s]+) \s* @ \s* (?<domain>[^<>@",\s]+)
-                 \s*
-                 ,?
-               }x, ''))
-        then
-          addr_list << Address.new(nil, nil, $~[:local_part].freeze, $~[:domain].freeze).freeze
-        elsif (src_txt.sub!(%r{
-                 \A
-                 \s*
-                 (?<display_name>\S.*?)
-                 \s*
-                 <
-                   \s*
-                   (?:
-                     (?<route>@[^<>@",]* (?:, \s* @[^<>@",]*)*)
-                     \s*
-                     :
-                   )?
-                   \s*
-                   (?<local_part>[^<>@",\s]+) \s* @ \s* (?<domain>[^<>@",\s]+)
-                   \s*
-                 >
-                 \s*
-                 ,?
-               }x, ''))
-        then
-          display_name = $~[:display_name]
-          route = $~[:route]
-          local_part = $~[:local_part]
-          domain = $~[:domain]
-          addr_list << Address.new(unquote_phrase(display_name), route.freeze, local_part.freeze, domain.freeze).freeze
+        if (decode_charset) then
+          if (decode_charset.is_a? Encoding) then
+            decode_charset_encoding = decode_charset
+          else
+            decode_charset_encoding = charset_aliases[decode_charset] ||
+                                      Encoding.find(decode_charset) # raise `ArgumentError' when wrong charset due to library user
+          end
+          dst.force_encoding(decode_charset_encoding)
         else
-          break
+          dst.force_encoding(encoded_string.encoding)
         end
-      end
 
-      addr_list.freeze
+        while (src =~ %r{
+                 =\? [^\s?]+ \? [BQ] \? [^\s?]+ \?=
+                 (?:
+                   \s+
+                   =\? [^\s?]+ \? [BQ] \? [^\s?]+ \?=
+                 )*
+               }ix)
+
+          src = $'
+          foreword = $`
+          encoded_word_list = $&.split(/\s+/, -1)
+
+          unless (foreword.empty?) then
+            if (dst.encoding.dummy?) then
+              # run the slow `String#encode' only when really needed
+              # because of a premise that the strings other than
+              # encoded words are ASCII only.
+              foreword.encode!(decode_charset_encoding, charset_convert_options)
+            end
+            dst << foreword
+          end
+
+          for encoded_word in encoded_word_list
+            _, charset, encoding, encoded_text, _ = encoded_word.split('?', 5)
+            encoding.upcase!
+            encoded_text.tr!('_', ' ') if (encoding == 'Q')
+            transfer_encoding = ENCODED_WORD_TRANSFER_ENCODING_TABLE[encoding] or raise "internal error - unknown encoding: #{encoding}"
+            decoded_text = get_mime_charset_text(encoded_text, charset, transfer_encoding, charset_aliases: charset_aliases)
+
+            if (decode_charset_encoding) then
+              if (decoded_text.encoding != decode_charset_encoding) then
+                # `decoded_text' is frozen
+                decoded_text = decoded_text.encode(decode_charset_encoding, charset_convert_options)
+              end
+            elsif (dst.ascii_only?) then
+              if (decoded_text.encoding.dummy?) then
+                dst.encode!(decoded_text.encoding, charset_convert_options)
+              end
+            else
+              if (decoded_text.encoding != dst.encoding) then
+                # `decoded_text' is frozen
+                decoded_text = decoded_text.encode(dst.encoding, charset_convert_options)
+              end
+            end
+            dst << decoded_text
+          end
+        end
+
+        unless (src.empty?) then
+          if (dst.encoding.dummy?) then
+            # run the slow `String#encode' only when really needed
+            # because of a premise that the strings other than encoded
+            # words are ASCII only.
+            src = src.encode(dst.encoding, charset_convert_options) # `src' may be frozen
+          end
+          dst << src
+        end
+
+        dst.freeze
+      end
+      module_function :decode_mime_encoded_words
     end
-    module_function :parse_mail_address_list
 
     class Header
       include Enumerable
@@ -258,26 +454,27 @@ module RIMS
       def initialize(header_txt)
         @raw_source = header_txt
         @field_list = nil
-        @field_map = nil
+        @field_table = nil
       end
 
       attr_reader :raw_source
 
       def setup_header
-        if (@field_list.nil? || @field_map.nil?) then
-          @field_list = RFC822.parse_header(@raw_source)
-          @field_map = {}
+        if (@field_list.nil? || @field_table.nil?) then
+          @field_list = Parse.parse_header(@raw_source)
+          @field_table = {}
           for name, value in @field_list
             key = name.downcase
-            @field_map[key] = [] unless (@field_map.key? key)
-            @field_map[key] << value
+            @field_table[key] = [] unless (@field_table.key? key)
+            @field_table[key] << value
           end
-          @field_map.each_value do |value_list|
+          @field_table.each_value do |value_list|
             value_list.freeze
           end
-          @field_map.freeze
-          self
+          @field_table.freeze
         end
+
+        nil
       end
       private :setup_header
 
@@ -292,19 +489,24 @@ module RIMS
 
       def key?(name)
         setup_header
-        @field_map.key? name.downcase
+        @field_table.key? name.downcase
       end
 
+      # aliases like `Hash'
+      alias has_key? key?
+      alias include? key?
+      alias member? key?
+
       def [](name)
         setup_header
-        if (value_list = @field_map[name.downcase]) then
+        if (value_list = @field_table[name.downcase]) then
           value_list[0]
         end
       end
 
       def fetch_upcase(name)
         setup_header
-        if (value_list = @field_map[name.downcase]) then
+        if (value_list = @field_table[name.downcase]) then
           if (value = value_list[0]) then
             value.upcase
           end
@@ -313,7 +515,7 @@ module RIMS
 
       def field_value_list(name)
         setup_header
-        @field_map[name.downcase]
+        @field_table[name.downcase]
       end
     end
 
@@ -326,8 +528,9 @@ module RIMS
     end
 
     class Message
-      def initialize(msg_txt)
+      def initialize(msg_txt, charset_aliases: DEFAULT_CHARSET_ALIASES)
         @raw_source = msg_txt.dup.freeze
+        @charset_aliases = charset_aliases
         @header = nil
         @body = nil
         @content_type = nil
@@ -342,17 +545,22 @@ module RIMS
         @to = nil
         @cc = nil
         @bcc = nil
+        @mime_decoded_header_cache = nil
+        @mime_decoded_header_field_value_list_cache = nil
+        @mime_decoded_header_text_cache = nil
+        @mime_charset_body_text_cache = nil
       end
 
       attr_reader :raw_source
 
       def setup_message
         if (@header.nil? || @body.nil?) then
-          header_txt, body_txt = RFC822.split_message(@raw_source)
+          header_txt, body_txt = Parse.split_message(@raw_source)
           @header = Header.new(header_txt || '')
           @body = Body.new(body_txt || '')
-          self
         end
+
+        nil
       end
       private :setup_message
 
@@ -367,10 +575,8 @@ module RIMS
       end
 
       def setup_content_type
-        if (@content_type.nil?) then
-          @content_type = RFC822.parse_content_type(header['Content-Type'] || '')
-          self
-        end
+        @content_type ||= Parse.parse_content_type(header['Content-Type'] || '')
+        nil
       end
       private :setup_content_type
 
@@ -430,11 +636,10 @@ module RIMS
 
       def setup_content_disposition
         if (header.key? 'Content-Disposition') then
-          if (@content_disposition.nil?) then
-            @content_disposition = RFC822.parse_content_disposition(header['Content-Disposition'])
-            self
-          end
+          @content_disposition ||= Parse.parse_content_disposition(header['Content-Disposition'])
         end
+
+        nil
       end
       private :setup_content_type
 
@@ -468,11 +673,13 @@ module RIMS
       def setup_content_language
         if (header.key? 'Content-Language') then
           if (@content_language.nil?) then
-            @content_language = header.field_value_list('Content-Language').map{|tags_txt| RFC822.parse_content_language(tags_txt) }.inject(:+)
+            @content_language = header.field_value_list('Content-Language').map{|tags_txt| Parse.parse_content_language(tags_txt) }
+            @content_language.flatten!
             @content_language.freeze
-            self
           end
         end
+
+        nil
       end
       private :setup_content_language
 
@@ -499,7 +706,7 @@ module RIMS
         if (multipart?) then
           if (@parts.nil?) then
             if (boundary = self.boundary) then
-              part_list = RFC822.parse_multipart_body(boundary, body.raw_source)
+              part_list = Parse.parse_multipart_body(boundary, body.raw_source)
               @parts = part_list.map{|msg_txt| Message.new(msg_txt) }
             else
               @parts = []
@@ -517,11 +724,7 @@ module RIMS
 
       def message
         if (message?) then
-          if (@message.nil?) then
-            @message = Message.new(body.raw_source)
-          end
-
-          @message
+          @message ||= Message.new(body.raw_source)
         end
       end
 
@@ -545,7 +748,8 @@ module RIMS
           ivar_name = '@' + field_name.downcase.gsub('-', '_')
           addr_list = instance_variable_get(ivar_name)
           if (addr_list.nil?) then
-            addr_list = header.field_value_list(field_name).map{|addr_list_txt| RFC822.parse_mail_address_list(addr_list_txt) }.inject(:+)
+            addr_list = header.field_value_list(field_name).map{|addr_list_txt| Parse.parse_mail_address_list(addr_list_txt) }
+            addr_list.flatten!
             addr_list.freeze
             instance_variable_set(ivar_name, addr_list)
           end
@@ -578,6 +782,74 @@ module RIMS
       def bcc
         mail_address_header_field('bcc')
       end
+
+      def make_charset_key(charset)
+        if (charset.is_a? Encoding) then
+          charset
+        else
+          charset.downcase.freeze
+        end
+      end
+      private :make_charset_key
+
+      def mime_decoded_header(name, decode_charset=nil, charset_convert_options: {})
+        cache_key = [
+          name.downcase.freeze,
+          (decode_charset) ? make_charset_key(decode_charset) : :default
+        ].freeze
+        @mime_decoded_header_cache ||= {}
+        @mime_decoded_header_cache[cache_key] ||= CharsetText.decode_mime_encoded_words(header[name],
+                                                                                        decode_charset,
+                                                                                        charset_aliases: @charset_aliases,
+                                                                                        charset_convert_options: charset_convert_options)
+      end
+
+      def mime_decoded_header_field_value_list(name, decode_charset=nil, charset_convert_options: {})
+        cache_key = [
+          name.downcase.freeze,
+          (decode_charset) ? make_charset_key(decode_charset) : :default
+        ].freeze
+        @mime_decoded_header_field_value_list_cache ||= {}
+        @mime_decoded_header_field_value_list_cache[cache_key] ||= header.field_value_list(name).map{|field_value|
+          CharsetText.decode_mime_encoded_words(field_value,
+                                                decode_charset,
+                                                charset_aliases: @charset_aliases,
+                                                charset_convert_options: charset_convert_options)
+        }.freeze
+      end
+
+      def mime_decoded_header_text(decode_charset=nil, charset_convert_options: {})
+        cache_key = (decode_charset) ? make_charset_key(decode_charset) : :default
+        @mime_decoded_header_text_cache ||= {}
+        @mime_decoded_header_text_cache[cache_key] ||= CharsetText.decode_mime_encoded_words(header.raw_source,
+                                                                                             decode_charset,
+                                                                                             charset_aliases: @charset_aliases,
+                                                                                             charset_convert_options: charset_convert_options)
+      end
+
+      def mime_charset_body_text(charset=nil)
+        @mime_charset_body_text_cache ||= {}
+        unless (charset) then
+          unless (@mime_charset_body_text_cache.key? :default) then
+            charset = (text?) ? self.charset : Encoding::ASCII_8BIT
+            @mime_charset_body_text_cache[:default] = CharsetText.get_mime_charset_text(body.raw_source,
+                                                                                        charset,
+                                                                                        header['Content-Transfer-Encoding'],
+                                                                                        charset_aliases: @charset_aliases)
+          end
+          @mime_charset_body_text_cache[:default]
+        else
+          cache_key = make_charset_key(charset)
+          @mime_charset_body_text_cache[cache_key] ||= CharsetText.get_mime_charset_text(body.raw_source,
+                                                                                         charset,
+                                                                                         header['Content-Transfer-Encoding'],
+                                                                                         charset_aliases: @charset_aliases)
+        end
+      end
+
+      def mime_binary_body_string
+        mime_charset_body_text(Encoding::ASCII_8BIT)
+      end
     end
   end
 end

data/lib/rims/rfc822/version.rb

@@ -2,7 +2,7 @@
 
 module RIMS
   module RFC822
-    VERSION = '0.2.0'
+    VERSION = '0.2.1'
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rims-rfc822
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - TOKI Yoshinori
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-06-20 00:00:00.000000000 Z
+date: 2019-07-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler