hermeneutics 1.8

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ef74159e9784d02b32aebb1b32555dbfb1ea388f4197990c649f326e0ad70e1c
+  data.tar.gz: aee45f2c54b9169d23253ed556fafaa8b5eaba4d22c7ae0b141047ef6e26f4aa
+SHA512:
+  metadata.gz: db155da6e4b37944baf54a2d33d3b4a457a233c038afe7011fc0653fc56dd6bbe5832a168d1e43fb41a9faf706086b8e409b18c110a1d7935443e89ff3348a2f
+  data.tar.gz: 99d58cad68a872bcedbd669c72ba022f678062db94935baf78908ecc030b4e1c03af6a743f21ab70a4b6069d5eb2b435cc7a58028082e4b745a2f3158149f994

data/LICENSE

@@ -0,0 +1,29 @@
+= Hermeneutics  --  Ruby mail and CGI handling
+
+Copyright (c) 2011-2013, Bertram Scharpf <software@bertram-scharpf.de>.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in
+      the documentation and/or other materials provided with the
+      distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

data/bin/hermesmail

@@ -0,0 +1,262 @@
+#!/usr/bin/env ruby
+
+#
+#  hermesmail  --  Mail filtering and delivery
+#
+
+begin
+  require "appl"
+rescue LoadError
+  raise "This requires the Gem 'appl'."
+end
+
+require "hermeneutics/version"
+require "hermeneutics/transports"
+require "hermeneutics/cli/pop"
+
+
+module Hermeneutics
+
+  class Processed < Mail
+
+    attr_accessor :debug
+
+    class Done < Exception ; end
+
+    # Do nothing, just finish.
+    def done
+      raise Done
+    end
+
+    alias delete done
+
+    # Save in a local mailbox
+    def deposit mailbox = nil
+      save mailbox
+      done
+    end
+
+    # Forward by SMTP
+    def forward_smtp to
+      send nil, to
+      done
+    end
+
+    # Forward by sendmail
+    def forward_sendmail to
+      sendmail to
+      done
+    end
+    alias forward forward_smtp
+
+
+    self.logfile  = "hermesmail.log"
+    self.loglevel = :ERR
+
+    @failed_process = "=failed-process"
+
+    class <<self
+      attr_accessor :failed_process
+      def process input, debug = false
+        i = parse input
+        i.debug = debug
+        i.execute
+      rescue
+        raise if debug
+        open_failed { |f|
+          log_exception "Error while parsing mail", f.path
+          f.write input
+        }
+      end
+      def log_exception msg, *args
+        log :ERR, "#{msg}: #$! (#{$!.class})", *args
+        $!.backtrace.each { |b| log :INF, "    #{b}" }
+      end
+      private
+      def open_failed
+        i = 0
+        d = expand_sysdir
+        w = Time.now.strftime "%Y%m%d%H%M%S"
+        begin
+          p = File.join d, "failed-#{w}-%05d" % i
+          File.open p, File::CREAT|File::EXCL|File::WRONLY do |f|
+            yield f
+          end
+        rescue Errno::ENOENT
+          Dir.mkdir! d and retry
+        rescue Errno::EEXIST
+          i +=1
+          retry
+        end
+      end
+    end
+
+    def execute
+      process
+      save
+    rescue Done
+    rescue
+      raise if @debug
+      log_exception "Error while processing mail"
+      b = cls.box cls.failed_process
+      save b
+    end
+
+    def log_exception msg, *args
+      cls.log_exception msg, *args
+    end
+
+  end
+
+
+  class Fetch
+
+    class <<self
+      private :new
+      def create *args, &block
+        i = new
+        i.instance_eval *args, &block
+        def i.each
+          @list.each { |a|
+            c = a[ :type].new *a[ :args]
+            a[ :logins].each { |l|
+              c.login *l do yield c end
+            }
+          }
+        end
+        i
+      end
+    end
+
+    def initialize
+      @list = []
+    end
+
+    def pop  *args ; access Cli::Pop,  *args do yield end ; end
+    def pops *args ; access Cli::Pops, *args do yield end ; end
+
+    def login *args
+      @access[ :logins].push args
+      nil
+    end
+
+    private
+
+    def access type, *args
+      @access and raise "Access methods must not be nested."
+      @access = { type: type, args: args, logins: [] }
+      yield
+      @list.push @access
+      nil
+    ensure
+      @access = nil
+    end
+
+  end
+
+
+  class MailApp < Application
+
+    NAME      = "hermesmail"
+    VERSION   = Hermeneutics::VERSION
+    SUMMARY   = "A mail delivery agent written in Ruby"
+    COPYRIGHT = Hermeneutics::COPYRIGHT
+    LICENSE   = Hermeneutics::LICENSE
+    AUTHORS   = Hermeneutics::AUTHORS
+
+    DESCRIPTION = <<-EOT
+This mail delivery agent (MDA) reads a configuration file
+that is plain Ruby code. See the examples section for how
+to write one.
+    EOT
+
+    attr_accessor :rulesfile, :mbox, :fetchfile
+    attr_bang :debug, :fetch, :keep
+    def quiet! ; @quiet += 1 ; end
+
+    def initialize *args
+      @quiet = 0
+      super
+      $*.concat @args   # make them $<-able again
+      @args.clear
+    end
+
+    RULESFILE = "~/.hermesmail-rules"
+    FETCHFILE = "~/.hermesmail-fetch"
+
+    define_option "r", :rulesfile=, "NAME", RULESFILE, "filtering rules"
+    alias_option  "r", "rulesfile"
+
+    define_option "M", :mbox=, "MBOX",
+                         "process all in MBOX instead of one from stdin"
+    alias_option  "M", "mbox"
+
+    define_option "f", :fetch!,                "fetch from a POP server"
+    alias_option  "f", "fetch"
+
+    define_option "F", :fetchfile=, "FILE", FETCHFILE,
+                         "a PGP-encrypted file containing fetch methods"
+    alias_option  "F", "fetchfile"
+    alias_option  "F", "fetch-file"
+
+    define_option "k", :keep!,    "don't delete the mails on the server"
+    alias_option  "k", "keep"
+
+    define_option "q", :quiet!,
+                     "less output (once = no progress, twice = nothing)"
+    alias_option  "q", "quiet"
+
+    define_option "g", :debug!,               "full Ruby error messages"
+    alias_option  "g", "debug"
+
+    define_option "h", :help,                             "show options"
+    alias_option  "h", "help"
+    define_option "V", :version,                          "show version"
+    alias_option  "V", "version"
+
+    def run
+      Processed.class_eval read_rules
+      if @mbox and @fetch then
+        raise "Specify either mbox or fetch but not both."
+      end
+      if @mbox then
+        b = Box.find @mbox
+        b.each { |m| Processed.process m }
+      elsif @fetch then
+        read_fetches.each { |s|
+          c = s.count
+          puts "#{c} Mails in #{s.name}." if @quiet < 2
+          i = 0
+          s.each { |m|
+            print "\r#{i}/#{c}  " if @quiet < 1
+            i += 1
+            Processed.process m
+            raise Cli::Pop::Keep if @keep
+          }
+          puts "\rDone.     " if @quiet < 1
+        }
+      else
+        msg = $<.read
+        msg.force_encoding Encoding::ASCII_8BIT
+        Processed.process msg, @debug
+      end
+    end
+
+    private
+
+    def read_rules
+      r = File.expand_path @rulesfile
+      File.read r
+    end
+
+    def read_fetches
+      p = File.expand_path @fetchfile
+      Fetch.create `gpg -d #{p}`
+    end
+
+  end
+
+  MailApp.run
+
+end
+

data/etc/exim.conf

@@ -0,0 +1,34 @@
+#
+#  exim.conf  --  example Exim configuration
+#
+
+# ...
+
+begin routers
+
+hermesmail:
+  driver = accept
+  # This will change uid and gid to ${local_part}:
+  check_local_user
+  require_files = ${local_part}:+${home}:${home}/.hermesmail-rules:+/usr/local/bin/hermesmail
+  transport = hermesmail_pipe
+  no_verify
+
+# ...
+
+begin transports
+
+hermesmail_pipe:
+  driver = pipe
+  # Ruby Gems will insert the right shebang line but in case it calls "env"
+  # you have to set the right path.
+  #
+  # path = "/bin:/usr/bin:/usr/local/bin"
+  command = "/usr/local/bin/hermesmail -r .hermesmail-rules"
+  delivery_date_add
+  envelope_to_add
+  message_suffix = ""
+  return_path_add
+
+# ...
+

data/lib/hermeneutics/addrs.rb

@@ -0,0 +1,687 @@
+# encoding: UTF-8
+
+#
+#  hermeneutics/addrs.rb  --  Extract addresses out of a string
+#
+
+=begin rdoc
+
+:section: Classes definied here
+
+Hermeneutics::Addr      is a single address
+Hermeneutics::AddrList  is a list of addresses in mail header fields.
+
+= Remark
+
+In my opinion, RFC 2822 allows too much features for address
+fields (see A.5). Most of them I have never seen anywhere in
+practice but only in the RFC. I doubt whether any mail-related
+software implements the specification correctly. Maybe this
+library does, but I cannot judge it as, after once tested, I
+never again understood my own code. The specification
+inevitably leeds to code of such kind. RFC 2822 address
+specification is a pain.
+
+=end
+
+require "hermeneutics/escape"
+
+
+class NilClass
+  def has? *args
+  end
+  def under_domain *args
+  end
+end
+
+
+module Hermeneutics
+
+  # A parser and generator for mail address fields.
+  #
+  # = Examples
+  #
+  #   a = Addr.create "dummy@example.com", "John Doe"
+  #   a.to_s      #=>  "John Doe <dummy@example.com>"
+  #   a.quote     #=>  "John Doe <dummy@example.com>"
+  #   a.encode    #=>  "John Doe <dummy@example.com>"
+  #
+  #   a = Addr.create "dummy@example.com", "Müller, Fritz"
+  #   a.to_s      #=>  "Müller, Fritz <dummy@example.com>"
+  #   a.quote     #=>  "\"Müller, Fritz\" <dummy@example.com>"
+  #   a.encode    #=>  "=?utf-8?q?M=C3=BCller=2C_Fritz?= <dummy@example.com>"
+  #
+  # = Parsing
+  #
+  #   x = <<-'EOT'
+  #   Jörg Q. Müller <jmuell@example.com>, "Meier, Hans"
+  #     <hmei@example.com>, Möller\, Fritz <fmoel@example.com>
+  #   EOT
+  #   Addr.parse x do |a,g|
+  #     puts a.quote
+  #   end
+  #
+  #   # Output:
+  #   #   Jörg Q. Müller <jmuell@example.com>
+  #   #   "Meier, Hans" <hmei@example.com>
+  #   #   "Möller, Fritz" <fmoel@example.com>
+  #
+  #   x = "some: =?utf-8?q?M=C3=B6ller=2C_Fritz?= " +
+  #       "<fmoeller@example.com> webmaster@example.com; foo@example.net"
+  #   Addr.parse_decode x do |a,g|
+  #     puts g.to_s
+  #     puts a.quote
+  #   end
+  #
+  #   # Output:
+  #   #   some
+  #   #   "Möller, Fritz" <fmoeller@example.com>
+  #   #   some
+  #   #   <webmaster@example.com>
+  #   #
+  #   #   <foo@example.net>
+  #
+  class Addr
+
+    class <<self
+
+      def create mail, real = nil
+        m = Token[ :addr, (Token.lexer mail)]
+        r = Token[ :text, (Token.lexer real)] if real
+        new m, r
+      end
+      alias [] create
+      private :new
+
+    end
+
+    attr_reader :mail, :real
+
+    def initialize mail, real
+      @mail, @real = mail, real
+      @mail.compact!
+      @real.compact! if @real
+    end
+
+    def == oth
+      plain == case oth
+        when Addr then oth.plain
+        else           oth.to_s.downcase
+      end
+    end
+
+    def plain
+      @plain ||= mk_plain
+    end
+
+    def real
+      @real.to_s if @real
+    end
+
+    def inspect
+      "<##{self.class}: mail=#{@mail.inspect} real=#{@real.inspect}>"
+    end
+
+    def to_s
+      tokenized.to_s
+    end
+
+    def quote
+      tokenized.quote
+    end
+
+    def encode
+      tokenized.encode
+    end
+
+    def tokenized
+      r = Token[ :addr, [ Token[ :lang] , @mail, Token[ :rang]]]
+      if @real then
+        r = Token[ :text, [ @real, Token[ :space], r]]
+      end
+      r
+    end
+
+    private
+
+    def mk_plain
+      p = @mail.to_s
+      p.downcase!
+      p
+    end
+
+    @encoding_parameters = {}
+    class <<self
+      attr_reader :encoding_parameters
+    end
+
+    class Token
+
+      attr_accessor :sym, :data, :quot
+
+      class <<self
+        alias [] new
+      end
+
+      def initialize sym, data = nil, quot = nil
+        @sym, @data, @quot = sym, data, quot
+      end
+
+      def inspect
+        d = ": #{@data.inspect}" if @data
+        d << " Q" if @quot
+        "<##@sym#{d}>"
+      end
+
+      def === oth
+        case oth
+          when Symbol then @sym == oth
+          when Token  then self == oth
+        end
+      end
+
+      def force_encoding enc
+        case @sym
+          when :text  then @data.each { |x| x.force_encoding enc }
+          when :char  then @data.force_encoding enc
+        end
+      end
+
+      def to_s
+        text
+      end
+
+      def text
+        case @sym
+          when :addr  then data_map_join { |x| x.quote }
+          when :text  then data_map_join { |x| x.text }
+          when :char  then @data
+          when :space then " "
+          else             SPECIAL_CHARS[ @sym]||""
+        end
+      rescue Encoding::CompatibilityError
+        force_encoding Encoding::ASCII_8BIT
+        retry
+      end
+
+      def quote
+        case @sym
+          when :text,
+               :addr  then data_map_join { |x| x.quote }
+          when :char  then quoted
+          when :space then " "
+          else             SPECIAL_CHARS[ @sym]||""
+        end
+      rescue Encoding::CompatibilityError
+        force_encoding Encoding::ASCII_8BIT
+        retry
+      end
+
+      def encode
+        case @sym
+          when :addr  then data_map_join { |x| x.quote }
+          when :text  then data_map_join { |x| x.encode }
+          when :char  then encoded
+          when :space then " "
+          else             SPECIAL_CHARS[ @sym]||""
+        end
+      end
+
+      def compact!
+        case @sym
+          when :text then
+            return if @data.length <= 1
+            @data = [ Token[ :char, text, needs_quote?]]
+          when :addr then
+            d = []
+            while @data.any? do
+              x, y = d.last, @data.shift
+              if y === :char and x === :char then
+                x.data << y.data
+                x.quot ||= y.quot
+              else
+                y.compact!
+                d.push y
+              end
+            end
+            @data = d
+        end
+      end
+
+      def needs_quote?
+        case @sym
+          when :text  then @data.find { |x| x.needs_quote? }
+          when :char  then @quot
+          when :space then false
+          when :addr  then false
+          else             true
+        end
+      end
+
+      private
+
+      def data_map_join
+        @data.map { |x| yield x }.join
+      end
+
+      def quoted
+        if @quot then
+          q = @data.gsub "\"" do |c| "\\" + c end
+          %Q%"#{q}"%
+        else
+          @data
+        end
+      end
+
+      def encoded
+        if @quot or HeaderExt.needs? @data then
+          c = HeaderExt.new Addr.encoding_parameters
+          c.encode_whole @data
+        else
+          @data
+        end
+      end
+
+      class <<self
+
+        def lexer str
+          if block_given? then
+            while str =~ /./m do
+              h, str = $&, $'
+              t = SPECIAL[ h]
+              if respond_to? t, true then
+                t = send t, h, str
+              end
+              unless Token === t then
+                t = Token[ *t]
+              end
+              yield t
+            end
+          else
+            r = []
+            lexer str do |t| r.push t end
+            r
+          end
+        end
+
+        def lexer_decode str, &block
+          if block_given? then
+            HeaderExt.lexer str do |k,s|
+              case k
+                when :decoded then yield Token[ :char, s, true]
+                when :plain   then lexer s, &block
+                when :space   then yield Token[ :space]
+              end
+            end
+          else
+            r = []
+            lexer_decode str do |t| r.push t end
+            r
+          end
+        end
+
+        private
+
+        def escaped h, c
+          if h then
+            [h].pack "H2"
+          else
+            case c
+              when "n" then "\n"
+              when "r" then "\r"
+              when "t" then "\t"
+              when "f" then "\f"
+              when "v" then "\v"
+              when "b" then "\b"
+              when "a" then "\a"
+              when "e" then "\e"
+              when "0" then "\0"
+              else          c
+            end
+          end
+        end
+
+        def lex_space h, str
+          str.slice! /\A\s*/
+          :space
+        end
+        def lex_bslash h, str
+          str.slice! /\A(?:x(..)|.)/
+          y = escaped $1, $&
+          Token[ :char, y, true]
+        end
+        def lex_squote h, str
+          str.slice! /\A((?:[^\\']|\\.)*)'?/
+          y = $1.gsub /\\(x(..)|.)/ do |c,x|
+            escaped x, c
+          end
+          Token[ :char, y, true]
+        end
+        def lex_dquote h, str
+          str.slice! /\A((?:[^\\"]|\\.)*)"?/
+          y = $1.gsub /\\(x(..)|.)/ do |c,x|
+            escaped x, c
+          end
+          Token[ :char, y, true]
+        end
+        def lex_other h, str
+          until str.empty? or SPECIAL.has_key? str.head do
+            h << (str.eat 1)
+          end
+          Token[ :char, h]
+        end
+
+      end
+
+      # :stopdoc:
+      SPECIAL = {
+        "<"  => :lang,
+        ">"  => :rang,
+        "("  => :lparen,
+        ")"  => :rparen,
+        ","  => :comma,
+        ";"  => :semicol,
+        ":"  => :colon,
+        "@"  => :at,
+        "["  => :lbrack,
+        "]"  => :rbrack,
+        " "  => :lex_space,
+        "'"  => :lex_squote,
+        "\"" => :lex_dquote,
+        "\\" => :lex_bslash,
+      }
+      "\t\n\f\r".each_char do |c| SPECIAL[ c] = SPECIAL[ " "] end
+      SPECIAL.default = :lex_other
+      SPECIAL_CHARS = SPECIAL.invert
+      # :startdoc:
+
+    end
+
+    class <<self
+
+      # Parse a line from a string that was entered by the user.
+      #
+      #   x = "Meier, Hans <hmei@example.com>, foo@example.net"
+      #   Addr.parse x do |a,g|
+      #     puts a.quote
+      #   end
+      #
+      #   # Output:
+      #     "Meier, Hans" <hmei@example.com>
+      #     <foo@example.net>
+      #
+      def parse str, &block
+        l = Token.lexer str
+        compile l, &block
+      end
+
+      # Parse a line from a mail header field and make addresses of it.
+      #
+      # Internally the encoding class +HeaderExt+ will be used.
+      #
+      #   x = "some: =?utf-8?q?M=C3=B6ller=2C_Fritz?= <fmoeller@example.com>"
+      #   Addr.parse_decode x do |addr,group|
+      #     puts group.to_s
+      #     puts addr.quote
+      #   end
+      #
+      #   # Output:
+      #   #   some
+      #   #   "Möller, Fritz" <fmoeller@example.com>
+      #
+      def parse_decode str, &block
+        l = Token.lexer_decode str
+        compile l, &block
+      end
+
+      private
+
+      def compile l, &block
+        l = unspace l
+        l = uncomment l
+        g = split_groups l
+        groups_compile g, &block
+      end
+
+      def groups_compile g
+        if block_given? then
+          g.each { |k,v|
+            split_list v do |m,r|
+              a = new m, r
+              yield a, k
+            end
+          }
+          return
+        end
+        t = []
+        groups_compile g do |a,| t.push a end
+        t
+      end
+
+      def matches l, *tokens
+        z = tokens.zip l
+        z.each { |(s,e)|
+          e === s or return
+        }
+        true
+      end
+
+      def unspace l
+        r = []
+        while l.any? do
+          if matches l, :space then
+            l.shift
+            next
+          end
+          if matches l, :char then
+            e = Token[ :text, [ l.shift]]
+            loop do
+              if matches l, :char then
+                e.data.push l.shift
+              elsif matches l, :space, :char then
+                e.data.push l.shift
+                e.data.push l.shift
+              else
+                break
+              end
+            end
+            l.unshift e
+          end
+          r.push l.shift
+        end
+        r
+      end
+
+      def uncomment l
+        r = []
+        while l.any? do
+          if matches l, :lparen then
+            l.shift
+            l = uncomment l
+            until matches l, :rparen or l.empty? do
+              l.shift
+            end
+            l.shift
+          end
+          r.push l.shift
+        end
+        r
+      end
+
+      def split_groups l
+        g = []
+        n = nil
+        while l.any? do
+          n = if matches l, :text, :colon then
+            e = l.shift
+            l.shift
+            e.to_s
+          end
+          s = []
+          until matches l, :semicol or l.empty? do
+            s.push l.shift
+          end
+          l.shift
+          g.push [ n, s]
+        end
+        g
+      end
+
+      def split_list l
+        while l.any? do
+          if matches l, :text, :comma, :text, :lang then
+            t = l.first.to_s
+            if t =~ /[^a-z0-9_]/ then
+              e = Token[ :text, []]
+              e.data.push l.shift
+              e.data.push l.shift, Token[ :space]
+              e.data.push l.shift
+              l.unshift e
+            end
+          end
+          a, c = find_one_of l, :lang, :comma
+          if a then
+            real = l.shift a if a.nonzero?
+            l.shift
+            a, c = find_one_of l, :rang, :comma
+            mail = l.shift a||c||l.length
+            l.shift
+            l.shift if matches l, :comma
+          else
+            mail = l.shift c||l.length
+            l.shift
+            real = nil
+          end
+          yield Token[ :addr, mail], real&&Token[ :text, real]
+        end
+      end
+
+      def find_one_of l, s, t
+        l.each_with_index { |e,i|
+          if e === s then
+            return i, nil
+          elsif e === t then
+            return nil, i
+          end
+        }
+        nil
+      end
+
+    end
+
+  end
+
+  class AddrList
+
+    class <<self
+      def parse cont
+        new.add_encoded cont
+      end
+    end
+
+    private
+
+    def initialize *addrs
+      @list = []
+      push addrs
+    end
+
+    public
+
+    def push addrs
+      case addrs
+        when nil    then
+        when String then add_encoded addrs
+        when Addr   then @list.push addrs
+        else             addrs.each { |a| push a }
+      end
+    end
+
+    def inspect
+      "<#{self.class}: " + (@list.map { |a| a.inspect }.join ", ") + ">"
+    end
+
+    def to_s
+      @list.map { |a| a.to_s }.join ", "
+    end
+
+    def quote
+      @list.map { |a| a.quote }.join ", "
+    end
+
+    def encode
+      r = []
+      @list.map { |a|
+        if r.last then r.last << "," end
+        r.push a.encode.dup
+      }
+      r
+    end
+
+    # :call-seq:
+    #   each { |addr| ... }     -> self
+    #
+    # Call block for each address.
+    #
+    def each
+      @list.each { |a| yield a }
+    end
+    include Enumerable
+
+    def has? *mails
+      mails.find { |m|
+        case m
+          when Regexp then
+            @list.find { |a|
+              if a.plain =~ m then
+                yield *$~.captures if block_given?
+                true
+              end
+            }
+          else
+            self == m
+        end
+      }
+    end
+    alias has has?
+
+    def under_domain *args
+      @list.each { |a|
+        a.plain =~ /(.*)@/ or next
+        l, d = $1, $'
+        case d
+          when *args then yield l
+        end
+      }
+    end
+
+    def == str
+      @list.find { |a| a == str }
+    end
+
+    def add mail, real = nil
+      if real or not Addr === mail then
+        mail = Addr.create mail, real
+      end
+      @list.push mail
+      self
+    end
+
+    def add_quoted str
+      Addr.parse str.to_s do |a,|
+        @list.push a
+      end
+      self
+    end
+
+    def add_encoded cont
+      Addr.parse_decode cont.to_s do |a,|
+        @list.push a
+      end
+      self
+    end
+
+  end
+
+end
+