hermeneutics 1.10 → 1.13

data/lib/hermeneutics/mail.rb

@@ -3,73 +3,45 @@
 #
 
 require "hermeneutics/message"
+require "hermeneutics/boxes"
+
 
 module Hermeneutics
 
   class Mail < Message
 
-    # :stopdoc:
-    class FromReader
-      class <<self
-        def open file
-          i = new file
-          yield i
-        end
-        private :new
-      end
-      attr_reader :from
-      def initialize file
-        @file = file
-        @file.eat_lines { |l|
-          l =~ /^From .*/ rescue nil
-          if $& then
-            @from = l
-            @from.chomp!
-          else
-            @first = l
-          end
-          break
-        }
-      end
-      def eat_lines &block
-        if @first then
-          yield @first
-          @first = nil
-        end
-        @file.eat_lines &block
-      end
-    end
-    # :startdoc:
-
     class <<self
 
-      def parse input
-        FromReader.open input do |fr|
-          parse_hb fr do |h,b|
-            new fr.from, h, b
-          end
+      private :new
+
+      def parse input, from = nil, created = nil
+        input.gsub! "\r\n", "\n"
+        parse_hb input do |h,b|
+          new h, b, from, created
         end
       end
 
       def create
-        new nil, nil, nil
+        new nil, nil, nil, nil
       end
 
     end
 
-    def initialize from, headers, body
+    def initialize headers, body, from, created
       super headers, body
-      @from = from
+      @plain_from, @created = from, created
     end
 
-    # String representation with "From " line.
-    # Mails reside in mbox files etc. and so have to end in a newline.
-    def to_s
-      set_unix_from
-      r = ""
-      r << @from << $/ << super
-      r.ends_with? $/ or r << $/
-      r
+    def plain_from
+      @plain_from ||= find_plain_from
+    end
+
+    def created
+      @created ||= Time.now
+    end
+
+    def senders
+      addresses_of :from, :sender, :return_path
     end
 
     def receivers
@@ -78,25 +50,238 @@ module Hermeneutics
 
     private
 
+    def find_plain_from
+      addresses_of :from, :sender, :return_path do |e|
+        return e.plain
+      end
+      require "etc"
+      require "socket"
+      "#{Etc.getlogin}@#{Socket.gethostname}"
+    end
+
     def addresses_of *args
-      l = args.map { |f| @headers.field f }
-      AddrList.new *l
+      if block_given? then
+        l = args.map { |f| @headers.field f }
+        a = AddrList.new *l
+        a.each { |e| yield e }
+      else
+        r = []
+        addresses_of *args do |e| r.push e end
+        r
+      end
+    end
+
+
+    public
+
+
+    SENDMAIL = "/usr/sbin/sendmail"
+
+
+    SPOOLDIR  = "/var/mail"
+    SPOOLFILE = nil
+    MAILDIR   = "~/Mail"
+    SYSDIR   = ".hermeneutics"
+
+    LOGLEVEL = :ERR
+    LOGFILE  = "#{File.basename $0}.log"
+
+    LEVEL = %i(
+      NON
+      ERR
+      INF
+      DBG
+    ).inject Hash.new do |h,k| h[k] = h.length ; h end
+
+    class <<self
+
+      def box path = nil, default_format = nil
+        @cache ||= {}
+        @cache[ path] ||= find_box path, default_format
+      end
+
+      private
+
+      def find_box path, default_format
+        b = case path
+          when Box then
+            path
+          when nil then
+            m = File.expand_path self::SPOOLFILE||getuser, self::SPOOLDIR
+            MBox.new m
+          else
+            m = if path =~ /\A=/ then
+              File.join expand_maildir, $'
+            else
+              File.expand_path path, "~"
+            end
+            Box.find m, default_format
+        end
+        b.exists? or b.create
+        b
+      end
+
+      public
+
+      def log type, *message
+        self::LOGFILE or return
+        return if LEVEL[ type] > LEVEL[ self::LOGLEVEL].to_i
+        l = File.expand_path self::LOGFILE, expand_sysdir
+        File.open l, "a" do |log|
+          log.puts "[#{Time.new}] [#$$] [#{type}] #{message.join ' '}"
+        end
+        nil
+      rescue Errno::ENOENT
+        d = File.dirname l
+        Dir.mkdir! d and retry
+      end
+
+      def expand_maildir
+        File.expand_path self::MAILDIR, "~"
+      end
+
+      def expand_sysdir
+        File.expand_path self::SYSDIR, expand_maildir
+      end
+
+      private
+
+      def getuser
+        require "etc"
+        (Etc.getpwuid Process.uid).name
+      end
+
+    end
+
+    # :call-seq:
+    #   obj.save( path, default_format = nil)           -> mb
+    #
+    # Save into local mailbox.
+    #
+    def save mailbox = nil, default_format = nil
+      b = self.class.box mailbox, default_format
+      log :INF, "Delivering to", b.path
+      b.store self
     end
 
-    def set_unix_from
-      return if @from
-      # Common MTA's will issue a proper "From" line; some MDA's
-      # won't.  Then, build it using the "From:" header.
-      addr = nil
-      l = addresses_of :from, :return_path
-      # Prefer the non-local version if present.
-      l.each { |a|
-        if not addr or addr !~ /@/ then
-          addr = a
+    # :call-seq:
+    #   obj.pipe( cmd, *args)           -> status
+    #
+    # Pipe into an external program.  If a block is given, the programs
+    # output will be yielded there.
+    #
+    def pipe cmd, *args
+      log :INF, "Piping through:", cmd, *args
+      ri, wi = IO.pipe
+      ro, wo = IO.pipe
+      child = fork do
+        wi.close ; ro.close
+        $stdout.reopen wo ; wo.close
+        $stdin .reopen ri ; ri.close
+        exec cmd, *args
+      end
+      ri.close ; wo.close
+      t = Thread.new wi do |wi|
+        begin
+          wi.write to_s
+        ensure
+          wi.close
         end
+      end
+      begin
+        r = ro.read
+        yield r if block_given?
+      ensure
+        ro.close
+      end
+      t.join
+      Process.wait child
+      $?.success? or
+        log :ERR, "Pipe failed with error code %d." % $?.exitstatus
+      $?
+    end
+
+    # :call-seq:
+    #   obj.sendmail( *tos)                -> status
+    #
+    # Send by sendmail; leave the +tos+ list empty to
+    # use Sendmail's -t option.
+    #
+    def sendmail *tos
+      args = []
+      if tos.empty? then
+        args.push "-t"
+      else
+        tos.flatten!
+        tos.each { |t|
+          to = case t
+            when Addr then t.plain
+            else           t.delete %q-,;"'<>(){}[]$&*?-   # security
+          end
+          args.push to
+        }
+      end
+      pipe self::SENDMAIL, *args
+    end
+
+    # :call-seq:
+    #   obj.send!( smtp, *tos)                -> response
+    #
+    # Send by SMTP.
+    #
+    # Be aware that +#send+ without bang is a
+    # standard Ruby method.
+    #
+    def send! conn = nil, *tos
+      if tos.empty? then
+        tos = (addresses_of :to, :cc).map { |t| t.plain }
+      else
+        tos.flatten!
+      end
+      f, m = true, ""
+      to_s.each_line { |l|
+        if f then
+          f = false
+          next if l =~ /^From /
+        end
+        m << l
       }
-      addr or raise ArgumentError, "No From: field present."
-      @from = "From #{addr.plain} #{Time.now.gmtime.asctime}"
+      open_smtp conn do |smtp|
+        log :INF, "Sending to", *tos
+        smtp.mail_from headers.from.first.plain
+        tos.each { |t| smtp.rcpt_to t }
+        smtp.data m
+      end
+    rescue NoMethodError
+      raise "Missing field: #{$!.name}."
+    end
+
+    private
+
+    def open_smtp arg, &block
+      if [ :mail_from, :rcpt_to, :data].map { |m| arg.respond_to? m }.all? then
+        yield arg
+        return
+      end
+      a = {}
+      case arg
+        when nil       then h, p = "localhost", nil
+        when String    then h, p = arg.split ":" ; p &&= Integer p
+        when Array     then h, p = *arg
+        when Hash      then a = arg.clone ; h, p = (a.delete :host), (a.delete :port)
+        else                h, p = arg.host, arg.port ; arg.scheme == "smtps" and a[ :ssl] = true
+      end
+      require "hermeneutics/cli/smtp"
+      Cli::SMTP.open h, p, **a do |smtp|
+        smtp.helo
+        yield smtp
+      ensure
+        smtp.quit
+      end
+    end
+
+    def log level, *msg
+      self.class.log level, *msg
     end
 
   end