sisimai 4.25.4-java → 4.25.10-java

data/lib/sisimai/mail.rb

@@ -1,31 +1,29 @@
 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 }
+
+    # :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 +32,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 +50,26 @@ 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
 
-    # Mbox/Maildir reader, works as an iterator.
+    # 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
-      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

@@ -7,7 +7,7 @@ module Sisimai
         # dovecot/src/deliver/deliver.c
         # 11: #define DEFAULT_MAIL_REJECTION_HUMAN_REASON \
         # 12: "Your message to <%t> was automatically rejected:%n%r"
-        'dovecot'    => %r/\AYour message to .+ was automatically rejected:\z/,
+        'dovecot'    => %r/\AYour message to [^ ]+ was automatically rejected:\z/,
         'mail.local' => %r/\Amail[.]local: /,
         'procmail'   => %r/\Aprocmail: /,
         'maildrop'   => %r/\Amaildrop: /,
@@ -16,7 +16,7 @@ module Sisimai
       }.freeze
       MarkingsOf = {
         message: %r{\A(?>
-           Your[ ]message[ ]to[ ].+[ ]was[ ]automatically[ ]rejected:\z
+           Your[ ]message[ ]to[ ][^ ]+[ ]was[ ]automatically[ ]rejected:\z
           |(?:mail[.]local|procmail|maildrop|vdelivermail|vdeliver):[ ]
           )
         }x
@@ -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
+      # @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,171 +5,98 @@ module Sisimai
   # method is not a bounce email, the method returns nil.
   class Message
     # Imported from p5-Sisimail/lib/Sisimai/Message.pm
-    require 'sisimai/arf'
+    # :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/rfc3834'
-    require 'sisimai/smtp/error'
-
-    @@rwaccessors = [
-      :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
-    ]
-    @@rwaccessors.each { |e| attr_accessor e }
-
     DefaultSet = Sisimai::Order.another
-    ExtHeaders = Sisimai::Order.headers
-    SubjectTab = Sisimai::Order.by('subject')
-    RFC822Head = Sisimai::RFC5322.HEADERFIELDS
-    RFC3834Set = Sisimai::RFC3834.headerlist
-    HeaderList = %w[from to date subject content-type reply-to message-id
-                    received content-transfer-encoding return-path x-mailer]
-    IsMultiple = { 'received' => true }
-    EndOfEmail = Sisimai::String.EOM
-    BorderLine = '__MIME_ENCODED_BOUNDARY__'
+    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 = email.is_a?(Hash) ? 'json' : 'email'
-      field = argvs[:field] || []
-
-      if input == 'email'
-        # Email message
-        return nil if email.empty?
-        email = email.scrub('?').gsub("\r\n", "\n")
-      end
-
-      unless field.is_a? Array
-        # Unsupported value in "field"
-        warn ' ***warning: "field" accepts an array reference only'
-        return nil
-      end
-
-      methodargv = {
-        'data'  => email,
-        'hook'  => argvs[:hook] || nil,
-        'field' => field,
-        'input' => input,
-      }
+      #methodargv = { 'data' => email, 'hook' => argvs[:hook] || nil }
+      # 1. Load specified MTA modules
       [:load, :order].each do |e|
         # Order of MTA modules
-        next unless argvs.key?(e)
+        next unless argvs[e]
         next unless argvs[e].is_a? Array
         next if argvs[e].empty?
-        methodargv[e.to_s] = argvs[e]
+        param[e.to_s] = argvs[e]
       end
+      tobeloaded = Sisimai::Message.load(param)
 
-      datasource = Sisimai::Message.make(methodargv)
-      return nil unless datasource
-      return nil unless datasource.key?('ds')
-
-      @from   = datasource['from']
-      @header = datasource['header']
-      @ds     = datasource['ds']
-      @rfc822 = datasource['rfc822']
-      @catch  = datasource['catch'] || nil
-    end
+      # 2. Split email data to headers and a body part.
+      return nil unless aftersplit = Sisimai::Message.divideup(email)
 
-    # 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
-    end
+      # 3. Convert email headers from text to hash reference
+      thing['from']   = aftersplit[0]
+      thing['header'] = Sisimai::Message.makemap(aftersplit[1])
 
-    # Make data structure from the email message(a body part and headers)
-    # @param         [Hash] argvs   Email data
-    # @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        [Hash]         Resolved data structure
-    def self.make(argvs)
-      email = argvs['data']
-
-      hookmethod = argvs['hook'] || nil
-      processing = {
-        'from'   => '',  # From_ line
-        'header' => {},  # Email header
-        'rfc822' => '',  # Original message part
-        'ds'     => [],  # Parsed data, Delivery Status
-        'catch'  => nil, # Data parsed by callback method
-      }
-      methodargv = {
-        'load'  => argvs['load'] || [],
-        'order' => argvs['order'] || []
-      }
-      tobeloaded = Sisimai::Message.load(methodargv)
-
-      if argvs['input'] == 'email'
-        # Email message
-        # 1. Split email data to headers and a body part.
-        return nil unless aftersplit = Sisimai::Message.divideup(email)
-
-        # 2. Convert email headers from text to hash reference
-        headerargv = {
-          'extheaders' => ExtHeaders,
-          'tryonfirst' => [],
-          'extrafield' => argvs['field'] || [],
-        }
-        processing['from']   = aftersplit['from']
-        processing['header'] = Sisimai::Message.headers(aftersplit['header'], headerargv)
-
-        # 3. Check headers for detecting MTA modules
-        if headerargv['tryonfirst'].empty?
-          headerargv['tryonfirst'] += Sisimai::Message.makeorder(processing['header'])
+      # 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
-
-        # 4. Rewrite message body for detecting the bounce reason
-        methodargv = {
-          'hook' => hookmethod,
-          'mail' => processing,
-          'body' => aftersplit['body'],
-          'tryonfirst' => headerargv['tryonfirst'],
-          'tobeloaded' => tobeloaded,
-        }
-        return nil unless bouncedata = Sisimai::Message.parse(methodargv)
-      else
-        # JSON object
-        methodargv = {
-          'hook' => hookmethod,
-          'json' => argvs['data'],
-          'tobeloaded' => tobeloaded.concat(Sisimai::Order.forjson),
-        }
-        return nil unless bouncedata = Sisimai::Message.adapt(methodargv)
+        thing['header']['subject'] = q
       end
-      return nil if bouncedata.empty?
 
-      %w|ds catch rfc822|.each { |e| processing[e] = bouncedata[e] }
-      if argvs['input'] == 'email'
-        # 5. Rewrite headers of the original message in the body part
-        p = bouncedata['rfc822']
-        p = aftersplit['body'] if p.empty?
-        processing['rfc822'] = p.is_a?(::String) ? Sisimai::Message.takeapart(p) : p
-      end
+      # 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'])
+      }
+      return nil unless bouncedata = Sisimai::Message.parse(param)
+      return nil if bouncedata.empty?
 
-      return processing
+      # 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
@@ -182,7 +109,7 @@ module Sisimai
 
       %w[load order].each do |e|
         # The order of MTA modules specified by user
-        next unless argvs.key?(e)
+        next unless argvs[e]
         next unless argvs[e].is_a? Array
         next if argvs[e].empty?
 
@@ -198,13 +125,6 @@ module Sisimai
             warn ' ***warning: Failed to load ' << v
             next
           end
-          next unless argvs.input == 'email'
-
-          Module.const_get(v).headerlist.each do |w|
-            # Get header name which required user defined MTA module
-            ExtHeaders[w]  ||= {}
-            ExtHeaders[w][v] = 1
-          end
           tobeloaded << v
         end
       end
@@ -218,192 +138,81 @@ module Sisimai
       return tobeloaded
     end
 
-    # Check headers for detecting MTA module and returns the order of modules
-    # @param         [Hash] heads   Email header data
-    # @return        [Array]        Order of MTA modules
-    def self.makeorder(heads)
-      return [] unless heads
-      return [] unless heads['subject']
-      return [] if heads['subject'].empty?
-      order = []
-
-      # Try to match the value of "Subject" with patterns generated by
-      # Sisimai::Order->by('subject') method
-      title = heads['subject'].downcase
-      SubjectTab.each_key do |e|
-        # Get MTA list from the subject header
-        next unless title.include?(e)
-        order += SubjectTab[e]  # Matched and push MTA list
-        break
-      end
-      return order
-    end
-
-    # Convert email headers from text to hash reference
-    # @param         [String] heads  Email header data
-    # @param         [Hash]   argvs
-    # @param options extheaders [Array] External header table
-    # @return        [Hash]          Structured email header data
-    def self.headers(heads, argvs = {})
-      return nil unless heads
-
-      currheader = ''
-      allheaders = {}
-      structured = {}
-      extheaders = argvs['extheaders'] || []
-      extrafield = argvs['extrafield'] || []
-      hasdivided = heads.split("\n")
-
-      HeaderList.each { |e| structured[e] = nil  }
-      HeaderList.each { |e| allheaders[e] = true }
-      RFC3834Set.each { |e| allheaders[e] = true }
-      IsMultiple.each_key { |e| structured[e] = [] }
-      extheaders.each_key { |e| allheaders[e] = true }
-      unless extrafield.empty?
-        extrafield.each { |e| allheaders[e] = true }
-      end
-
-      while e = hasdivided.shift do
-        # Convert email headers to hash
-        if cv = e.match(/\A[ \t]+(.+)\z/)
-          # Continued (foled) header value from the previous line
-          next unless allheaders.key?(currheader)
-
-          # Header line continued from the previous line
-          if structured[currheader].is_a? Array
-            # Concatenate a header which have multi-lines such as 'Received'
-            structured[currheader][-1] << ' ' << cv[1]
-          else
-            structured[currheader] ||= ''
-            structured[currheader] << ' ' << cv[1]
-          end
-        else
-          # split the line into a header name and a header content
-          (lhs, rhs) = e.split(/:[ ]*/, 2)
-          currheader = lhs ? lhs.downcase : ''
-          next unless allheaders.key?(currheader)
-
-          if IsMultiple.key?(currheader)
-            # Such as 'Received' header, there are multiple headers in a single
-            # email message.
-            #rhs = rhs.tr("\t", ' ').squeeze(' ')
-            rhs = rhs.tr("\t", ' ')
-            structured[currheader] << rhs
-          else
-            # Other headers except "Received" and so on
-            if extheaders[currheader]
-              # MTA specific header
-              extheaders[currheader].each do |r|
-                next if argvs['tryonfirst'].index(r)
-                argvs['tryonfirst'] << r
-              end
-            end
-            structured[currheader] = rhs
-          end
-        end
-      end
-      return structured
-    end
-
     # Divide email data up headers and a body part.
     # @param         [String] email  Email data
-    # @return        [Hash]          Email data after split
+    # @return        [Array]         Email data after split
     def self.divideup(email)
       return nil if email.empty?
 
-      block = { 'from' => '', 'header' => '', 'body' => '' }
-      email.scrub!('?')
+      block = ['', '', '']  # 0:From, 1:Header, 2:Body
       email.gsub!(/\r\n/, "\n")  if email.include?("\r\n")
       email.gsub!(/[ \t]+$/, '') if email =~ /[ \t]+$/
 
-      (block['header'], block['body']) = email.split(/\n\n/, 2)
-      return nil unless block['header']
-      return nil unless block['body']
+      (block[1], block[2]) = email.split(/\n\n/, 2)
+      return nil unless block[1]
+      return nil unless block[2]
 
-      if block['header'][0, 5] == 'From '
+      if block[1].start_with?('From ')
         # From MAILER-DAEMON Tue Feb 11 00:00:00 2014
-        block['from'] = block['header'].split(/\n/, 2)[0].delete("\r")
+        block[0] = block[1].split(/\n/, 2)[0].delete("\r")
       else
         # Set pseudo UNIX From line
-        block['from'] = 'MAILER-DAEMON Tue Feb 11 00:00:00 2014'
+        block[0] = 'MAILER-DAEMON Tue Feb 11 00:00:00 2014'
       end
 
-      block['body'] << "\n"
+      block[1] << "\n" unless block[1].end_with?("\n")
+      block[2] << "\n"
       return block
     end
 
-    # Take each email header in the original message apart
-    # @param         [String] heads The original message header
-    # @return        [Hash]         Structured message headers
-    def self.takeapart(heads)
-      return {} unless heads
-
-      # 1. Scrub to avoid "invalid byte sequence in UTF-8" exception (#82)
-      # 2. Convert from string to hash reference
-      heads = heads.scrub('?').gsub(/^[>]+[ ]/m, '').gsub(/=[ ]+=/, "=\n =")
-
-      previousfn = '' # Previous field name
-      asciiarmor = {} # Header names which has MIME encoded value
-      headerpart = {} # Required headers in the original message part
-      hasdivided = heads.split("\n")
-
-      while e = hasdivided.shift do
-        # Header name as a key, The value of header as a value
-        if e.start_with?(' ', "\t")
-          # Continued (foled) header value from the previous line
-          next if previousfn.empty?
-
-          # Concatenate the line if it is the value of required header
-          if Sisimai::MIME.is_mimeencoded(e)
-            # The line is MIME-Encoded test
-            headerpart[previousfn] << if previousfn == 'subject'
-                                        # Subject: header
-                                        BorderLine + e
-                                      else
-                                        # Is not Subject header
-                                        e
-                                      end
-            asciiarmor[previousfn] = true
-          else
-            # ASCII Characters only: Not MIME-Encoded
-            headerpart[previousfn] << e.lstrip
-            asciiarmor[previousfn] ||= false
-          end
-        else
-          # Header name as a key, The value of header as a value
-          (lhs, rhs) = e.split(/:[ ]*/, 2)
-          next unless lhs
-          lhs.downcase!
-          previousfn = ''
-
-          next unless RFC822Head.key?(lhs)
-          previousfn = lhs
-          headerpart[previousfn] = rhs unless headerpart[previousfn]
-        end
+    # 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
-      return headerpart unless headerpart['subject']
+      headermaps['received'] = recvheader
+
+      return headermaps unless argv1
+      return headermaps if headermaps['subject'].empty?
 
       # Convert MIME-Encoded subject
-      if Sisimai::String.is_8bit(headerpart['subject'])
+      if Sisimai::String.is_8bit(headermaps['subject'])
         # The value of ``Subject'' header is including multibyte character,
         # is not MIME-Encoded text.
-        headerpart['subject'].scrub!('?')
+        headermaps['subject'].scrub!('?')
       else
         # MIME-Encoded subject field or ASCII characters only
         r = []
-        if asciiarmor['subject']
+        if Sisimai::MIME.is_mimeencoded(headermaps['subject'])
           # split the value of Subject by borderline
-          headerpart['subject'].split(BorderLine).each do |v|
+          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 << headerpart['subject']
+          r << headermaps['subject']
         end
-        headerpart['subject'] = Sisimai::MIME.mimedecode(r)
+        headermaps['subject'] = Sisimai::MIME.mimedecode(r)
       end
-      return headerpart
+      return headermaps
     end
 
     # @abstract Parse bounce mail with each MTA module
@@ -425,7 +234,6 @@ module Sisimai
       bodystring = argvs['body']
       hookmethod = argvs['hook'] || nil
       havecaught = nil
-
       return nil unless mailheader
 
       # PRECHECK_EACH_HEADER:
@@ -437,7 +245,6 @@ module Sisimai
       # 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'
@@ -461,166 +268,86 @@ module Sisimai
           bodystring = p unless p.empty?
         end
       end
-
-      # EXPAND_FORWARDED_MESSAGE:
-      # Check whether or not the message is a bounce mail.
-      # Pre-Process email body if it is a forwarded bounce message.
-      # Get the original text when the subject begins from 'fwd:' or 'fw:'
-      if mailheader['subject'].downcase =~ /\A[ \t]*fwd?:/
-        # Delete quoted strings, quote symbols(>)
-        bodystring = bodystring.gsub(/^[>]+[ ]/m, '').gsub(/^[>]$/m, '')
-      elsif Sisimai::MIME.is_mimeencoded(mailheader['subject'])
-        # Decode MIME-Encoded "Subject:" header
-        mailheader['subject'] = Sisimai::MIME.mimedecode(mailheader['subject'].split(/[ ]/))
-        mailheader['subject'].scrub!('?')
-      end
       bodystring = bodystring.scrub('?').delete("\r")
 
+      haveloaded = {}
+      parseddata = nil
+      modulename = ''
       if hookmethod.is_a? Proc
         # Call the hook method
         begin
-          p = {
-            'datasrc' => 'email',
-            'headers' => mailheader,
-            'message' => bodystring,
-            'bounces' => nil
-          }
+          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
 
-      bodystring << EndOfEmail
-      haveloaded = {}
-      parseddata = nil
-
       catch :PARSER do
         while true
-          # 1. Sisimai::ARF
-          # 2. User-Defined Module
-          # 3. MTA Module Candidates to be tried on first
-          # 4. Sisimai::Lhost::*
-          # 5. Sisimai::RFC3464
+          # 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
-          if Sisimai::ARF.is_arf(mailheader)
-            # Feedback Loop message
-            parseddata = Sisimai::ARF.make(mailheader, bodystring)
-            throw :PARSER if parseddata
-          end
-
           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'].concat(DefaultSet)
-          while r = argvs['tryonfirst'].shift do
+          [argvs['tryonfirst'], DefaultSet].flatten.each do |r|
             # Try MTA module candidates
-            next if haveloaded.key?(r)
-            require r.gsub('::', '/').downcase
+            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
 
-          # When the all of Sisimai::Lhost::* modules did not return bounce
-          # data, call Sisimai::RFC3464;
-          require 'sisimai/rfc3464'
-          parseddata = Sisimai::RFC3464.make(mailheader, bodystring)
-          break if parseddata
-
-          # Try to parse the message as auto reply message defined in RFC3834
-          require 'sisimai/rfc3834'
-          parseddata = Sisimai::RFC3834.make(mailheader, bodystring)
-          break if parseddata
-
-          # as of now, we have no sample email for coding this block
-          break
-        end
-      end
-
-      parseddata['catch'] = havecaught if parseddata
-      return parseddata
-    end
-
-    # Parse bounce object with each MTA(JSON) module
-    # @param               [Hash] argvs    Processing message entity.
-    # @param options argvs [Hash] json     Decoded bounce object
-    # @param options argvs [Proc] hook     Hook method to be called
-    # @return              [Hash]          Parsed and structured bounce mails
-    def self.adapt(argvs)
-      Sisimai::Message.warn(self.name, 'gone')
-      bouncedata = argvs['json'] || {}
-      hookmethod = argvs['hook'] || nil
-      havecaught = nil
-      haveloaded = {}
-      parseddata = nil
+          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
 
-      # Call the hook method
-      if hookmethod.is_a? Proc
-        # Execute hook method
-        begin
-          p = {
-            'datasrc' => 'json',
-            'headers' => nil,
-            'message' => nil,
-            'bounces' => argvs['json']
-          }
-          havecaught = hookmethod.call(p)
-        rescue StandardError => ce
-          warn ' ***warning: Something is wrong in hook method :' << ce.to_s
-        end
-      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
 
-      catch :ADAPTOR do
-        while true
-          # 1. User-Defined Module
-          # 2. MTA(JSON) Module Candidates to be tried on first
-          # 3. Sisimai::Lhost::*
-          #
-          argvs['tobeloaded'].each do |r|
-            # Call user defined MTA(JSON) modules
-            next if haveloaded[r]
-            begin
-              require r.gsub('::', '/').downcase
-            rescue LoadError => ce
-              warn ' ***warning: Failed to load ' << ce.to_s
-              next
-            end
-            parseddata = Module.const_get(r).json(bouncedata)
-            haveloaded[r] = true
-            throw :ADAPTOR if parseddata
+          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 JSON data for coding this block
+          break # as of now, we have no sample email for coding this block
         end
       end
       return nil unless parseddata
-      return nil unless parseddata['ds']
 
       parseddata['catch'] = havecaught
-      parseddata['ds'].each { |e| e['agent'].sub!(/\AEmail::/, 'JSON::') }
+      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
 
-    # @abstract Print warnings about an obsoleted method. This method will be
-    #           removed at the future release of Sisimai
-    # @until    v4.25.5
-    def self.warn(whois = '', useit = nil)
-      label = ' ***warning:'
-      methodname = caller[0][/`.*'/][1..-2]
-      messageset = sprintf("%s %s.%s is marked as obsoleted", label, whois, methodname)
-
-      useit ||= methodname
-      messageset << sprintf(" and will be removed at %s.", Sisimai::Lhost.removedat)
-      messageset << sprintf(" Use %s.%s instead.\n", self.name, useit) if useit != 'gone'
-      Kernel.warn messageset
-    end
-
   end
 end