sisimai 4.25.3 → 4.25.8

data/lib/sisimai/mail.rb

@@ -1,31 +1,30 @@
 module Sisimai
-  # Sisimai::Mail is a handler of UNIX mbox or Maildir for reading each mail. It is
-  # wrapper class of Sisimai::Mail::Mbox and Sisimai::Mail::Maildir classes.
+  # Sisimai::Mail is a handler of UNIX mbox or Maildir for reading each mail.
+  # It is a wrapper class of Sisimai::Mail::Mbox, Sisimai::Mail::Maildir, and
+  # Sisimai::Mail::Memory classes.
   class Mail
     # Imported from p5-Sisimail/lib/Sisimai/Mail.pm
-    @@roaccessors = [
-      :path,  # [String] path to mbox or Maildir/
-      :type,  # [String] Data type: mailbox, maildir, or stdin
-    ]
-    @@rwaccessors = [
-      :mail,  # [Sisimai::Mail::[Mbox,Maildir,Memory,STDIN]] Object
-    ]
-    @@roaccessors.each { |e| attr_reader   e }
-    @@rwaccessors.each { |e| attr_accessor e }
+    Until = 'v4.25.10'
+
+    # :path [String] path to mbox or Maildir/
+    # :kind [String] Data type: mailbox, maildir, or stdin
+    # :data [Sisimai::Mail::[Mbox,Maildir,Memory,STDIN]] Object
+    attr_reader   :path, :kind
+    attr_accessor :data
 
     # Constructor of Sisimai::Mail
     # @param    [String] argv1        Path to mbox or Maildir/
     # @return   [Sisimai::Mail, Nil]  Object or nil if the argument was wrong
     def initialize(argv1)
       classname = nil
-      parameter = { 'path' => argv1, 'type' => nil, 'mail' => nil }
+      parameter = { 'path' => argv1, 'kind' => nil, 'data' => nil }
 
       if argv1.is_a?(::String)
         # Path to mail or '<STDIN>' ?
         if argv1 == '<STDIN>'
           # Sisimai::Mail.new('<STDIN>')
           classname = self.class.to_s << '::STDIN'
-          parameter['type'] = 'stdin'
+          parameter['kind'] = 'stdin'
           parameter['path'] = $stdin
         else
           # The argumenet is a mailbox or a Maildir/.
@@ -34,17 +33,17 @@ module Sisimai
           if mediatype == 'file'
             # The argument is a file, it is an mbox or email file in Maildir/
             classname = self.class.to_s << '::Mbox'
-            parameter['type'] = 'mailbox'
+            parameter['kind'] = 'mailbox'
 
           elsif mediatype == 'directory'
             # The agument is not a file, it is a Maildir/
             classname = self.class.to_s << '::Maildir'
-            parameter['type'] = 'maildir'
+            parameter['kind'] = 'maildir'
 
           elsif mediatype == 'memory'
             # The argument is an email string
             classname = self.class.to_s << '::Memory'
-            parameter['type'] = 'memory'
+            parameter['kind'] = 'memory'
             parameter['path'] = 'MEMORY'
           end
         end
@@ -52,33 +51,45 @@ module Sisimai
         # Read from STDIN
         # The argument neither a mailbox nor a Maildir/.
         classname = self.class.to_s << '::STDIN'
-        parameter['type'] = 'stdin'
+        parameter['kind'] = 'stdin'
       end
       return nil unless classname
 
       classpath = classname.gsub('::', '/').downcase
       require classpath
-      parameter['mail'] = Module.const_get(classname).new(argv1)
+      parameter['data'] = Module.const_get(classname).new(argv1)
 
       @path = parameter['path']
-      @type = parameter['type']
-      @mail = parameter['mail']
+      @kind = parameter['kind']
+      @data = parameter['data']
+    end
+
+    def mail
+      warn " ***warning: Sisimai::Mail.mail will be removed at #{Until}. Use Sisimai::Mail.data instead"
+      return data
     end
 
-    # Mbox/Maildir reader, works as an iterator.
+    def type
+      warn " ***warning: Sisimai::Mail.type will be removed at #{Until}. Use Sisimai::Mail.kind instead"
+      return kind
+    end
+
+    # Alias method of Sisimai::Mail.data.read()
     # @return   [String] Contents of mbox/Maildir
     def read
-      return nil unless mail
-      return mail.read
+      return nil unless data
+      return data.read
     end
 
     # Close the handle
     # @return   [True,False]  true:  Successfully closed the handle
     #                         false: Mail handle is not defined
     def close
-      return false unless mail.handle
-      mail.handle = nil
+      warn " ***warning: Sisimai::Mail.close will be removed at #{Until}. The handle automatically closes at the EOF"
+      return false unless data.handle
+      data.handle = nil
       return true
     end
   end
 end
+

data/lib/sisimai/mail/maildir.rb

@@ -1,27 +1,22 @@
 module Sisimai
   class Mail
-    # Sisimai::Mail::Maildir is a reader for getting contents of each email in the
-    # Maildir/ directory.
+    # Sisimai::Mail::Maildir is a reader for getting contents of each email in
+    # the Maildir/ directory.
     class Maildir
       # Imported from p5-Sisimail/lib/Sisimai/Mail/Maildir.pm
-      @@roaccessors = [
-        :dir,     # [String] Path to Maildir/
-        :size,    # [Integer] The number of entires in the directory
-      ]
-      @@rwaccessors = [
-        :path,    # [String] Path to each file
-        :file,    # [String] Each file name of a mail in the Maildir/
-        :inodes,  # [Array]  i-node List of files in the Maildir/
-        :count,   # [Integer] The number of file has read
-        :handle,  # [IO::Dir] Directory handle
-      ]
-      @@roaccessors.each { |e| attr_reader   e }
-      @@rwaccessors.each { |e| attr_accessor e }
+      # :dir    [String] Path to Maildir/
+      # :size   [Integer] The number of files/directories in the Maildir/
+      # :path   [String] Path to each file
+      # :file,  [String] Each file name of a mail in the Maildir/
+      # :offset [Integer] The number of email files in the Maildir/
+      # :handle [IO::Dir] Directory handle
+      attr_reader :dir
+      attr_accessor :size, :path, :file, :offset, :handle
 
       # Constructor of Sisimai::Mail::Maildir
-      # @param    [String] argvs                Path to Maildir/
-      # @return   [Sisimai::Mail::Maildir,Nil]  Object or nil if the argument is
-      #                                         not a directory or does not exist
+      # @param    [String] argvs            Path to Maildir/
+      # @return   [Sisimai::Mail::Maildir]  Object
+      #           [Nil]                     is not a directory or does not exist
       def initialize(argv1)
         raise Errno::ENOENT  unless File.exist?(argv1)
         raise Errno::ENOTDIR unless File.ftype(argv1) == 'directory'
@@ -30,45 +25,45 @@ module Sisimai
         @size   = Dir.entries(argv1).size
         @dir    = argv1
         @file   = nil
-        @inodes = {}
-        @count  = 0
+        @offset = 0
         @handle = Dir.open(argv1)
       end
 
       # Maildir reader, works as a iterator.
       # @return       [String] Contents of file in Maildir/
       def read
-        return nil unless self.count < self.size
-
+        return nil unless self.offset < self.size
         seekhandle = self.handle
         readbuffer = ''
 
         begin
           while r = seekhandle.read do
             # Read each file in the directory
-            next if r == '.' || r == '..'
+            if r == '.' || r == '..'
+              # Is a directory
+              self.offset += 1
+              next
+            end
 
             emailindir = (self.dir + '/' + r).squeeze('/')
-            next unless File.ftype(emailindir) == 'file'
-            next unless File.size(emailindir) > 0
-            next unless File.readable?(emailindir)
-
-            emailinode = File.stat(emailindir).ino
-            next if self.inodes.key?(emailinode)
+            if File.ftype(emailindir) != 'file' ||
+               File.size(emailindir) == 0 ||
+               File.readable?(emailindir) == false
+              # The file is not a file, is empty, is not readable
+              self.offset += 1
+              next
+            end
 
             File.open(emailindir, 'r:UTF-8') do |f|
               readbuffer = f.read
             end
 
-            self.inodes[emailinode] = 1
-            self.path = emailindir
-            self.file = r
-
+            self.offset += 1
+            self.path    = emailindir
+            self.file    = r
             break
           end
-
-          self.count += 1
-          seekhandle.close unless self.count < self.size
+          seekhandle.close unless self.offset < self.size
         end
 
         return readbuffer

data/lib/sisimai/mail/mbox.rb

@@ -3,18 +3,14 @@ module Sisimai
     # Sisimai::Mail::Mbox is a mailbox file (UNIX mbox) reader.
     class Mbox
       # Imported from p5-Sisimail/lib/Sisimai/Mail/Mbox.pm
-      @@roaccessors = [
-        :dir,     # [String]  Directory name of the mbox
-        :file,    # [String]  File name of the mbox
-        :path,    # [String]  Path to mbox
-        :size,    # [Integer] File size of the mbox
-      ]
-      @@rwaccessors = [
-        :offset,  # [Integer]  Offset position for seeking
-        :handle,  # [IO::File] File handle
-      ]
-      @@roaccessors.each { |e| attr_reader   e }
-      @@rwaccessors.each { |e| attr_accessor e }
+      # :dir    [String]  Directory name of the mbox
+      # :file   [String]  File name of the mbox
+      # :path   [String]  Path to mbox
+      # :size   [Integer] File size of the mbox
+      # :offset [Integer]  Offset position for seeking
+      # :handle [IO::File] File handle
+      attr_reader :dir, :file, :path, :size
+      attr_accessor :offset, :handle
 
       # Constructor of Sisimai::Mail::Mbox
       # @param    [String] argv1            Path to mbox

data/lib/sisimai/mail/memory.rb

@@ -3,43 +3,41 @@ module Sisimai
     # Sisimai::Mail::Memory is a class for reading an email string
     class Memory
       # Imported from p5-Sisimail/lib/Sisimai/Mail/Memory.pm
-      @@roaccessors = [
-        :size,    # [Integer] data size of the email text
-      ]
-      @@rwaccessors = [
-        :data,    # [Array]   Entire bounce mail message
-        :offset,  # [Integer] Index of ":data"
-      ]
-      @@roaccessors.each { |e| attr_reader   e }
-      @@rwaccessors.each { |e| attr_accessor e }
+      # :path    [String]  Fixed string "<MEMORY>"
+      # :size    [Integer] data size of the email text
+      # :payload [Array]   Entire bounce mail message
+      # :offset  [Integer] Index of ":payload"
+      attr_reader :path, :size
+      attr_accessor :payload, :offset
 
       # Constructor of Sisimai::Mail::Memory
-      # @param    [String] argv1              Entire email string
-      # @return   [Sisimai::Mail::Memory,Nil] Object or nil if the argument is
-      #                                       not specified or does not exist
+      # @param    [String] argv1          Entire email string
+      # @return   [Sisimai::Mail::Memory] Object
+      #           [Nil]                   is not specified or does not exist
       def initialize(argv1)
         raise 'is not a String' unless argv1.is_a? ::String
         raise 'is empty'        if argv1.empty?
 
-        @size   = argv1.size
-        @data   = []
-        @offset = 0
+        @path    = '<MEMORY>'
+        @size    = argv1.size
+        @payload = []
+        @offset  = 0
 
         if argv1.start_with?('From ')
           # UNIX mbox
-          @data = argv1.split(/^From /).map! { |e| e = 'From ' + e }
-          @data.shift
+          @payload = argv1.split(/^From /).map! { |e| e = 'From ' + e }
+          @payload.shift
         else
-          @data = [argv1]
+          @payload = [argv1]
         end
       end
 
       # Memory reader, works as an iterator.
       # @return   [String] Contents of a bounce mail
       def read
-        return nil if self.data.empty?
+        return nil if self.payload.empty?
         self.offset += 1
-        return self.data.shift
+        return self.payload.shift
       end
     end
   end

data/lib/sisimai/mail/stdin.rb

@@ -4,17 +4,12 @@ module Sisimai
     # STDIN
     class STDIN
       # Imported from p5-Sisimail/lib/Sisimai/Mail/STDIN.pm
-      @@roaccessors = [
-        :path,    # [String]  Path to mbox
-        :name,    # [String]  File name of the mbox
-        :size,    # [Integer] File size of the mbox
-      ]
-      @@rwaccessors = [
-        :offset,  # [Integer]  Offset position for seeking
-        :handle,  # [IO::File] File handle
-      ]
-      @@roaccessors.each { |e| attr_reader   e }
-      @@rwaccessors.each { |e| attr_accessor e }
+      # :path   [String]  Fixed string "<STDIN>"
+      # :size   [Integer] Data size which has been read
+      # :offset [Integer]  The number of emails which have neen read
+      # :handle [IO::File] File handle
+      attr_reader :path, :name, :size
+      attr_accessor :offset, :handle
 
       # Constructor of Sisimai::Mail::STDIN
       # @param    [IO::STDIN] stdin      Standard-In
@@ -23,7 +18,6 @@ module Sisimai
         raise 'is not an IO object' unless stdin.is_a?(IO)
 
         @path   = '<STDIN>'
-        @name   = '<STDIN>'
         @size   = nil
         @offset = 0
         @handle = stdin
@@ -49,6 +43,8 @@ module Sisimai
           readhandle.close
         end
 
+        self.size   += readbuffer.size
+        self.offset += 1
         return readbuffer
       end
     end

data/lib/sisimai/mda.rb

@@ -75,26 +75,20 @@ module Sisimai
       }.freeze
 
       # Parse message body and return reason and text
-      # @param         [Hash] mhead       Message header of a bounce email
-      # @options mhead [String] from      From header
-      # @options mhead [String] date      Date header
-      # @options mhead [String] subject   Subject header
-      # @options mhead [Array]  received  Received headers
-      # @options mhead [String] others    Other required headers
-      # @param         [String] mbody     Message body of a bounce email
-      # @return        [Hash, Nil]        Bounce data list and message/rfc822 part
-      #                                   or nil if it failed to parse or the
-      #                                   arguments are missing
-      def scan(mhead, mbody)
+      # @param  [Hash] mhead    Message headers of a bounce email
+      # @param  [String] mbody  Message body of a bounce email
+      # @return [Hash]          Bounce data list and message/rfc822 part
+      # @return [Nil]           it failed to parse or the arguments are missing
+      def make(mhead, mbody)
         return nil unless mhead['from'].downcase.start_with?('mail delivery subsystem','mailer-daemon', 'postmaster')
 
         agentname0 = ''   # [String] MDA name
         reasonname = ''   # [String] Error reason
         bouncemesg = ''   # [String] Error message
-        hasdivided = mbody.split("\n")
+        bodyslices = mbody.split("\n")
         linebuffer = []
 
-        while e = hasdivided.shift do
+        while e = bodyslices.shift do
           # Check each line with each MDA's symbol regular expression.
           if agentname0 == ''
             # Try to match with each regular expression

data/lib/sisimai/message.rb

@@ -5,114 +5,348 @@ module Sisimai
   # method is not a bounce email, the method returns nil.
   class Message
     # Imported from p5-Sisimail/lib/Sisimai/Message.pm
+    # :from   [String] UNIX From line
+    # :header [Hash]   Header part of an email
+    # :ds     [Array]  Parsed data by Sisimai::Lhost::* module
+    # :rfc822 [Hash]   Header part of the original message
+    # :catch  [Any]    The results returned by hook method
+    attr_accessor :from, :header, :ds, :rfc822, :catch
+
+    require 'sisimai/mime'
     require 'sisimai/order'
+    require 'sisimai/lhost'
     require 'sisimai/string'
     require 'sisimai/address'
     require 'sisimai/rfc5322'
-    require 'sisimai/smtp/error'
-
-    @@rwaccessors = [
-      :from,    # [String] UNIX From line
-      :header,  # [Hash]   Header part of an email
-      :ds,      # [Array]  Parsed data by Sisimai::Bite::*::* module
-      :rfc822,  # [Hash]   Header part of the original message
-      :catch,   # [?]      The results returned by hook method
-    ]
-    @@rwaccessors.each { |e| attr_accessor e }
+    DefaultSet = Sisimai::Order.another
+    LhostTable = Sisimai::Lhost.path
 
     # Constructor of Sisimai::Message
     # @param         [String] data      Email text data
     # @param         [Hash] argvs       Module to be loaded
     # @options argvs [String] :data     Entire email message
     # @options argvs [Array]  :load     User defined MTA module list
-    # @options argvs [Array]  :field    Email header names to be captured
     # @options argvs [Array]  :order    The order of MTA modules
     # @options argvs [Code]   :hook     Reference to callback method
     # @return        [Sisimai::Message] Structured email data or nil if each
     #                                   value of the arguments are missing
     def initialize(data: '', **argvs)
       return nil if data.empty?
+      param = {}
+      email = data.scrub('?').gsub("\r\n", "\n")
+      thing = { 'from' => '','header' => {}, 'rfc822' => '', ds => [], 'catch' => nil }
 
-      email = data
-      input = argvs[:input] || 'email'
-      field = argvs[:field] || []
-      child = nil
-
-      if input == 'email'
-        # Sisimai::Message::Email
-        return nil if email.empty?
-        email = email.scrub('?').gsub("\r\n", "\n")
-        child = 'Sisimai::Message::Email'
-
-      elsif input == 'json'
-        # Sisimai::Message::JSON
-        return nil unless email.is_a? Hash
-        child = 'Sisimai::Message::JSON'
-      else
-        # Unsupported value in "input"
-        warn ' ***warning: Unsupported value in "input": ' << input.to_s
-        return nil
+      #methodargv = { 'data' => email, 'hook' => argvs[:hook] || nil }
+      # 1. Load specified MTA modules
+      [:load, :order].each do |e|
+        # Order of MTA modules
+        next unless argvs[e]
+        next unless argvs[e].is_a? Array
+        next if argvs[e].empty?
+        param[e.to_s] = argvs[e]
       end
+      tobeloaded = Sisimai::Message.load(param)
 
-      unless field.is_a? Array
-        # Unsupported value in "field"
-        warn ' ***warning: "field" accepts an array reference only'
-        return nil
-      end
+      # 2. Split email data to headers and a body part.
+      return nil unless aftersplit = Sisimai::Message.divideup(email)
 
-      begin
-        require child.gsub('::', '/').downcase
-      rescue LoadError => ce
-        warn ' ***warning: Failed to load module: ' << ce.to_s
-        return nil
+      # 3. Convert email headers from text to hash reference
+      thing['from']   = aftersplit[0]
+      thing['header'] = Sisimai::Message.makemap(aftersplit[1])
+
+      # 4. Decode and rewrite the "Subject:" header
+      unless thing['header']['subject'].empty?
+        # Decode MIME-Encoded "Subject:" header
+        s = thing['header']['subject']
+        q = Sisimai::MIME.is_mimeencoded(s) ? Sisimai::MIME.mimedecode(s.split(/[ ]/)) : s
+
+        # Remove "Fwd:" string from the Subject: header
+        if cv = q.downcase.match(/\A[ \t]*fwd?:[ ]*(.*)\z/)
+          # Delete quoted strings, quote symbols(>)
+          q = cv[1]
+          aftersplit[2] = aftersplit[2].gsub(/^[>]+[ ]/, '').gsub(/^[>]$/, '')
+        end
+        thing['header']['subject'] = q
       end
 
-      methodargv = {
-        'data'  => email,
-        'hook'  => argvs[:hook] || nil,
-        'field' => field,
+      # 5. Rewrite message body for detecting the bounce reason
+      param = {
+        'hook' => argvs[:hook] || nil,
+        'mail' => thing,
+        'body' => aftersplit[2],
+        'tobeloaded' => tobeloaded,
+        'tryonfirst' => Sisimai::Order.make(thing['header']['subject'])
       }
-      [:load, :order].each do |e|
-        # Order of MTA modules
-        next unless argvs.key?(e)
+      return nil unless bouncedata = Sisimai::Message.parse(param)
+      return nil if bouncedata.empty?
+
+      # 6. Rewrite headers of the original message in the body part
+      %w|ds catch rfc822|.each { |e| thing[e] = bouncedata[e] }
+      p = bouncedata['rfc822']
+      p = aftersplit[2] if p.empty?
+      thing['rfc822'] = p.is_a?(::String) ? Sisimai::Message.makemap(p, true) : p
+
+      @from   = thing['from']
+      @header = thing['header']
+      @ds     = thing['ds']
+      @rfc822 = thing['rfc822']
+      @catch  = thing['catch'] || nil
+    end
+
+    # Check whether the object has valid content or not
+    # @return        [True,False]   returns true if the object is void
+    def void; return @ds ? false : true; end
+
+    # Load MTA modules which specified at 'order' and 'load' in the argument
+    # @param         [Hash] argvs       Module information to be loaded
+    # @options argvs [Array]  load      User defined MTA module list
+    # @options argvs [Array]  order     The order of MTA modules
+    # @return        [Array]            Module list
+    # @since v4.20.0
+    def self.load(argvs)
+      modulelist = []
+      tobeloaded = []
+
+      %w[load order].each do |e|
+        # The order of MTA modules specified by user
+        next unless argvs[e]
         next unless argvs[e].is_a? Array
         next if argvs[e].empty?
-        methodargv[e.to_s] = argvs[e]
+
+        modulelist += argvs['order'] if e == 'order'
+        next unless e == 'load'
+
+        # Load user defined MTA module
+        argvs['load'].each do |v|
+          # Load user defined MTA module
+          begin
+            require v.to_s.gsub('::', '/').downcase
+          rescue LoadError
+            warn ' ***warning: Failed to load ' << v
+            next
+          end
+          tobeloaded << v
+        end
       end
 
-      datasource = Module.const_get(child).make(methodargv)
-      return nil unless datasource
-      return nil unless datasource.key?('ds')
+      while e = modulelist.shift do
+        # Append the custom order of MTA modules
+        next if tobeloaded.index(e)
+        tobeloaded << e
+      end
 
-      @from   = datasource['from']
-      @header = datasource['header']
-      @ds     = datasource['ds']
-      @rfc822 = datasource['rfc822']
-      @catch  = datasource['catch'] || nil
+      return tobeloaded
     end
 
-    # Check whether the object has valid content or not
-    # @return        [True,False]   returns true if the object is void
-    def void
-      return true unless @ds
-      return false
+    # Divide email data up headers and a body part.
+    # @param         [String] email  Email data
+    # @return        [Array]         Email data after split
+    def self.divideup(email)
+      return nil if email.empty?
+
+      block = ['', '', '']  # 0:From, 1:Header, 2:Body
+      email.gsub!(/\r\n/, "\n")  if email.include?("\r\n")
+      email.gsub!(/[ \t]+$/, '') if email =~ /[ \t]+$/
+
+      (block[1], block[2]) = email.split(/\n\n/, 2)
+      return nil unless block[1]
+      return nil unless block[2]
+
+      if block[1].start_with?('From ')
+        # From MAILER-DAEMON Tue Feb 11 00:00:00 2014
+        block[0] = block[1].split(/\n/, 2)[0].delete("\r")
+      else
+        # Set pseudo UNIX From line
+        block[0] = 'MAILER-DAEMON Tue Feb 11 00:00:00 2014'
+      end
+
+      block[1] << "\n" unless block[1].end_with?("\n")
+      block[2] << "\n"
+      return block
     end
 
-    # Make data structure (Should be implemeneted at each child class)
-    def make
-      return {
-        'from'   => '',  # From_ line
-        'header' => {},  # Email header
-        'rfc822' => '',  # Original message part
-        'ds'     => [],  # Parsed data, Delivery Status
-        'catch'  => nil, # Data parsed by callback method
-      }
+    # Convert a text including email headers to a hash reference
+    # @param    [String] argv0  Email header data
+    # @param    [Bool]   argv1  Decode "Subject:" header
+    # @return   [Hash]          Structured email header data
+    # @since    v4.25.6
+    def self.makemap(argv0 = '', argv1 = nil)
+      return {} if argv0.empty?
+      argv0.gsub!(/^[>]+[ ]/m, '') # Remove '>' indent symbol of forwarded message
+
+      # Select and convert all the headers in $argv0. The following regular expression
+      # is based on https://gist.github.com/xtetsuji/b080e1f5551d17242f6415aba8a00239
+      headermaps = { 'subject' => '' }
+      recvheader = []
+      argv0.scan(/^([\w-]+):[ ]*(.*?)\n(?![\s\t])/m) { |e| headermaps[e[0].downcase] = e[1] }
+      headermaps.delete('received')
+      headermaps.each_key { |e| headermaps[e].gsub!(/\n[\s\t]+/, ' ') }
+
+      if argv0.include?('Received:')
+        # Capture values of each Received: header
+        recvheader = argv0.scan(/^Received:[ ]*(.*?)\n(?![\s\t])/m).flatten
+        recvheader.each { |e| e.gsub!(/\n[\s\t]+/, ' ') }
+      end
+      headermaps['received'] = recvheader
+
+      return headermaps unless argv1
+      return headermaps if headermaps['subject'].empty?
+
+      # Convert MIME-Encoded subject
+      if Sisimai::String.is_8bit(headermaps['subject'])
+        # The value of ``Subject'' header is including multibyte character,
+        # is not MIME-Encoded text.
+        headermaps['subject'].scrub!('?')
+      else
+        # MIME-Encoded subject field or ASCII characters only
+        r = []
+        if Sisimai::MIME.is_mimeencoded(headermaps['subject'])
+          # split the value of Subject by borderline
+          headermaps['subject'].split(/ /).each do |v|
+            # Insert value to the array if the string is MIME encoded text
+            r << v if Sisimai::MIME.is_mimeencoded(v)
+          end
+        else
+          # Subject line is not MIME encoded
+          r << headermaps['subject']
+        end
+        headermaps['subject'] = Sisimai::MIME.mimedecode(r)
+      end
+      return headermaps
     end
 
-    # Load MTA modules which specified at 'order' and 'load' in the argument
-    # This method should be implemented at each child class
-    # @since v4.20.0
-    def load; return []; end
+    # @abstract Parse bounce mail with each MTA module
+    # @param               [Hash] argvs    Processing message entity.
+    # @param options argvs [Hash] mail     Email message entity
+    # @param options mail  [String] from   From line of mbox
+    # @param options mail  [Hash]   header Email header data
+    # @param options mail  [String] rfc822 Original message part
+    # @param options mail  [Array]  ds     Delivery status list(parsed data)
+    # @param options argvs [String] body   Email message body
+    # @param options argvs [Array] tryonfirst  MTA module list to load on first
+    # @param options argvs [Array] tobeloaded  User defined MTA module list
+    # @return              [Hash]          Parsed and structured bounce mails
+    def self.parse(argvs)
+      return nil unless argvs['mail']
+      return nil unless argvs['body']
+
+      mailheader = argvs['mail']['header']
+      bodystring = argvs['body']
+      hookmethod = argvs['hook'] || nil
+      havecaught = nil
+      return nil unless mailheader
+
+      # PRECHECK_EACH_HEADER:
+      # Set empty string if the value is nil
+      mailheader['from']         ||= ''
+      mailheader['subject']      ||= ''
+      mailheader['content-type'] ||= ''
+
+      # Decode BASE64 Encoded message body, rewrite.
+      mesgformat = (mailheader['content-type'] || '').downcase
+      ctencoding = (mailheader['content-transfer-encoding'] || '').downcase
+      if mesgformat.start_with?('text/plain', 'text/html')
+        # Content-Type: text/plain; charset=UTF-8
+        if ctencoding == 'base64'
+          # Content-Transfer-Encoding: base64
+          bodystring = Sisimai::MIME.base64d(bodystring)
+
+        elsif ctencoding == 'quoted-printable'
+          # Content-Transfer-Encoding: quoted-printable
+          bodystring = Sisimai::MIME.qprintd(bodystring)
+        end
+
+        if mesgformat.start_with?('text/html;')
+          # Content-Type: text/html;...
+          bodystring = Sisimai::String.to_plain(bodystring, true)
+        end
+      else
+        # NOT text/plain
+        if mesgformat.start_with?('multipart/')
+          # In case of Content-Type: multipart/*
+          p = Sisimai::MIME.makeflat(mailheader['content-type'], bodystring)
+          bodystring = p unless p.empty?
+        end
+      end
+      bodystring = bodystring.scrub('?').delete("\r")
+
+      haveloaded = {}
+      parseddata = nil
+      modulename = ''
+      if hookmethod.is_a? Proc
+        # Call the hook method
+        begin
+          p = { 'headers' => mailheader, 'message' => bodystring }
+          havecaught = hookmethod.call(p)
+        rescue StandardError => ce
+          warn ' ***warning: Something is wrong in hook method :' << ce.to_s
+        end
+      end
+
+      catch :PARSER do
+        while true
+          # 1. User-Defined Module
+          # 2. MTA Module Candidates to be tried on first
+          # 3. Sisimai::Lhost::*
+          # 4. Sisimai::RFC3464
+          # 5. Sisimai::ARF
+          # 6. Sisimai::RFC3834
+          while r = argvs['tobeloaded'].shift do
+            # Call user defined MTA modules
+            next if haveloaded[r]
+            parseddata = Module.const_get(r).make(mailheader, bodystring)
+            haveloaded[r] = true
+            modulename = r
+            throw :PARSER if parseddata
+          end
+
+          [argvs['tryonfirst'], DefaultSet].flatten.each do |r|
+            # Try MTA module candidates
+            next if haveloaded[r]
+            require LhostTable[r]
+            parseddata = Module.const_get(r).make(mailheader, bodystring)
+            haveloaded[r] = true
+            modulename = r
+            throw :PARSER if parseddata
+          end
+
+          unless haveloaded['Sisimai::RFC3464']
+            # When the all of Sisimai::Lhost::* modules did not return bounce
+            # data, call Sisimai::RFC3464;
+            require 'sisimai/rfc3464'
+            parseddata = Sisimai::RFC3464.make(mailheader, bodystring)
+            modulename = 'RFC3464'
+            throw :PARSER if parseddata
+          end
+
+          unless haveloaded['Sisimai::ARF']
+            # Feedback Loop message
+            require 'sisimai/arf'
+            parseddata = Sisimai::ARF.make(mailheader, bodystring) if Sisimai::ARF.is_arf(mailheader)
+            throw :PARSER if parseddata
+          end
+
+          unless haveloaded['Sisimai::RFC3834']
+            # Try to parse the message as auto reply message defined in RFC3834
+            require 'sisimai/rfc3834'
+            parseddata = Sisimai::RFC3834.make(mailheader, bodystring)
+            modulename = 'RFC3834'
+            throw :PARSER if parseddata
+          end
+
+          break # as of now, we have no sample email for coding this block
+        end
+      end
+      return nil unless parseddata
+
+      parseddata['catch'] = havecaught
+      modulename = modulename.sub(/\A.+::/, '')
+      parseddata['ds'].each do |e|
+        e['agent'] = modulename unless e['agent']
+        e.each_key { |a| e[a] ||= '' }  # Replace nil with ""
+      end
+      return parseddata
+    end
 
   end
 end