gurgitate-mail 1.8.4 → 1.8.5

data/bin/gurgitate-mail

@@ -47,4 +47,8 @@ else
   gurgitate.add_rules(GLOBAL_RULES_POST, :system => true)
 end
 
-gurgitate.process
+begin
+    gurgitate.process
+rescue 
+    exit 75
+end

data/lib/gurgitate-mail.rb

@@ -36,7 +36,7 @@ module Gurgitate
         # syntax will continue to work.
         def self.attr_configparam(*syms)
             syms.each do |sym|
-                class_eval %{
+                class_eval %/
                     def #{sym} (*vals)
                         if vals.length == 1
                             @#{sym} = vals[0]
@@ -53,7 +53,7 @@ module Gurgitate
                     # old-style accessors though.  Breaking people's
                     # .gurgitate-rules is a bad idea.
                     attr_writer :#{sym}
-                }
+                /
             end
         end
 
@@ -175,7 +175,7 @@ module Gurgitate
         #   handled any other way.
         def method_missing(meth)
             headername=meth.to_s.split(/_/).map {|x| x.capitalize}.join("-")
-            if defined?(headers[headername]) then
+            if headers[headername] then
                 return headers[headername]
             else
                 raise NameError,"undefined local variable or method, or header not found `#{meth}' for #{self}:#{self.class}"
@@ -211,9 +211,6 @@ module Gurgitate
                 f.print(self.to_s)
             end
             return $?>>8
-          rescue SystemCallError
-            save(spoolfile())
-            return -1
         end
 
         # Pipes the message through +program+, and returns another
@@ -237,34 +234,39 @@ module Gurgitate
                     end
                 end
             end
-          rescue SystemCallError
-            save(Spoolfile)
-            return nil
         end
 
         # Processes your .gurgitate-rules.rb.
         def process(&block)
-            if @rules.size > 0 or block
-                @rules.each do |configfilespec|
-                    begin
-                        eval File.new(configfilespec).read, nil,
-                            configfilespec
-                    rescue ScriptError
-                        log "Couldn't load #{configfilespec}: "+$!
-                        save(spoolfile)
-                    rescue Exception
-                        log "Error while executing #{configfilespec}: #{$!}"
-                        $@.each { |tr| log "Backtrace: #{tr}" }
-                        folderstyle = MBox
-                        save(spoolfile)
+            begin
+                if @rules.size > 0 or block
+                    @rules.each do |configfilespec|
+                        begin
+                            eval File.new(configfilespec).read, nil,
+                                configfilespec
+                        rescue ScriptError
+                            log "Couldn't load #{configfilespec}: "+$!
+                            save(spoolfile)
+                        rescue Exception
+                            log "Error while executing #{configfilespec}: #{$!}"
+                            $@.each { |tr| log "Backtrace: #{tr}" }
+                            folderstyle = MBox
+                            save(spoolfile)
+                        end
                     end
+                    if block
+                        instance_eval(&block)
+                    end
+                    log "Mail not covered by rules, saving to default spool"
+                    save(spoolfile)
+                else
+                    save(spoolfile)
                 end
-                if block
-                    instance_eval(&block)
-                end
-                log "Mail not covered by rules, saving to default spool"
-                save(spoolfile)
-            else
+            rescue Exception
+                log "Error while executing rules: #{$!}"
+                $@.each { |tr| log "Backtrace: #{tr}" }
+                log "Attempting to save to spoolfile after error"
+                folderstyle = MBox
                 save(spoolfile)
             end
         end

data/lib/gurgitate/deliver.rb

@@ -40,10 +40,8 @@ module Gurgitate
             begin
                 [MBox,Maildir].each do |mod|
                     if mod::check_mailbox(mailbox) then
-                        self.class.instance_eval do 
-                            include mod
-                            raise MailboxFound
-                        end
+                        extend mod
+                        raise MailboxFound
                     end
                 end
 
@@ -51,23 +49,21 @@ module Gurgitate
                 # let's default to whatever's in @folderstyle.  (I
                 # guess we'll be making a new mailbox, eh?)
 
-                if defined? @folderstyle then
+                if Module === @folderstyle then
                     #
                     # Careful we don't get the wrong instance variable 
                     folderstyle=@folderstyle 
 
-                    self.class.instance_eval do
-                        include folderstyle
-                    end
+                    extend folderstyle
                 else
                     # No hints from the user either.  Let's guess!
                     # I'll use the same heuristic that Postfix uses--if the
                     # mailbox name ends with a /, then make it a Maildir,
                     # otherwise make it a mail file
                     if mailbox =~ /\/$/ then
-                        include Maildir
+                        extend Maildir
                     else
-                        include MBox
+                        extend MBox
                     end
                 end
                 
@@ -81,7 +77,8 @@ module Gurgitate
                 deliver_message(mailbox)
             rescue SystemCallError
                 self.log "Gack!  Something went wrong: "+$!
-                exit 75
+                raise
+                # exit 75
             end
         end
     end

data/lib/gurgitate/deliver/maildir.rb

@@ -70,6 +70,10 @@ module Gurgitate
                     make_mailbox(mailbox)
                 end
 
+                unless File.stat(mailbox).directory?
+                    raise SystemError, 'not a directory'
+                end
+
                 tmpfilename=maildir_getfilename(File.join(mailbox,"tmp"))
                 File.open(tmpfilename,File::CREAT|File::WRONLY) do |fh|
                     fh.write(self.to_s)
@@ -91,7 +95,7 @@ module Gurgitate
                     File.link(tmpfilename,newfilename)
                 rescue SystemCallError
                     log("Couldn't create maildir link to \"new\"!")
-                    exit 75 # Argh, I tried, it didn't work out
+                    raise
                 end
                 File.delete(tmpfilename)
             end

data/lib/gurgitate/headers.rb

@@ -65,6 +65,9 @@ module Gurgitate
         # regex::
         #   The regular expression to match against the header's contents
         def matches (regex)
+            if String === regex
+                regex = Regexp.new(Regexp.escape(regex))
+            end
             @contents =~ regex
         end
 
@@ -89,7 +92,6 @@ module Gurgitate
             each do |header|
                 header.contents = header.contents.sub regex, replacement
             end
-            p self
         end
         
         def sub(regex, replacement)
@@ -108,61 +110,91 @@ module Gurgitate
     # A slightly bigger class for all of a message's headers
     class Headers
 
-        # Creates a Headers object.
-        # headertext::
-        #   The text of the message headers.
-        def initialize(headertext)
-            @headers=Hash.new(nil)
-            @headertext=headertext
+        private
 
-            (unix_from,normal_headers)=headertext.split(/\n/,2);
+        # Figures out whether the first line of a mail message is an
+        # mbox-style "From " line (say, if you get this from sendmail),
+        # or whether it's just a normal header.
+        # -- 
+        # If you run "fetchmail" with the -m option to feed the
+        # mail message straight to gurgitate, skipping the "local
+        # MTA" step, then it doesn't have a "From " line.  So I
+        # have to deal with that by hand.  First, check to see if
+        # there's a "From " line present in the first place.
+        def figure_out_from_line(headertext)
+            (unix_from,normal_headers)  = headertext.split(/\n/,2)
 
-            # If you run "fetchmail" with the -m option to feed the
-            # mail message straight to gurgitate, skipping the "local
-            # MTA" step, then it doesn't have a "From " line.  So I
-            # have to deal with that by hand.  First, check to see if
-            # there's a "From " line present in the first place.
             if unix_from =~ /^From /  then
-                @headertext=normal_headers
-                @unix_from=unix_from
+                headertext=normal_headers
+                unix_from=unix_from
             else
                 # If there isn't, then deal with it after we've
                 # worried about the rest of the headers, 'cos we'll
                 # have to make our own.
-                unix_from=""
+                unix_from=nil
             end
+            return unix_from, headertext
+        end
 
+        def parse_headers
             @headertext.each do |h|
                 h.chomp!
                 if(h=~/^\s+/) then
                     @lastheader << h
                 else
                     header=Header.new(h)
-                    @headers[header.name] ||= HeaderBag.new;
+                    @headers[header.name] ||= HeaderBag.new
                     @headers[header.name].push(header)
                     @lastheader=header
                 end
             end
 
             @headers_changed=false
+        end
 
-            # Get the envelope From information.  This comes with a
-            # whole category of rants: this information is absurdly hard
-            # to get your hands on.  The best you can manage is a sort
-            # of educated guess.
+        # Get the envelope From information.  This comes with a
+        # whole category of rants: this information is absurdly hard
+        # to get your hands on.  The best you can manage is a sort
+        # of educated guess.  Thus, this horrible glob of hackiness.
+        # I don't recommend looking too closely at this code if you
+        # can avoid it, and further I recommend making sure to
+        # configure your MTA so that it sends proper sender and
+        # recipient information to gurgitate so that this code never
+        # has to be run at all.
+        def guess_sender
+            # Start by worrying about the "From foo@bar" line.  If it's
+            # not there, then make one up from the Return-Path: header.
+            # If there isn't a "Return-Path:" header (then I suspect we
+            # have bigger problems, but still) then use From: as a wild
+            # guess.  If I hope that this entire lot of code doesn't get
+            # used, then I _particularly_ hope that things never get so
+            # bad that poor gurgitate has to use the From: header as a
+            # source of authoritative information on anything.
             #
-            # Okay, now worry about the "From foo@bar" line.  If it's
-            # not there, then make one up from the Return-Path:
-            # header.  If there isn't a "Return-Path:" header (then I
-            # suspect we have bigger problems, but still) then use
-            # From:
-            if unix_from == "" then
-                fromregex=/([^ ]+@[^ ]+) \(.*\)|[^<]*[<](.*@.*)[>]|([^ ]+@[^ ]+)/;
+            # And then after all that fuss, if we're delivering to a
+            # Maildir, I have to get rid of it.  And sometimes the MTA
+            # gives me a mbox-style From line and sometimes it doesn't.
+            # It's annoying, but I have no choice but to Just Deal With
+            # It.
+            if @unix_from then
+                # If it is there, then grab the email address in it and
+                # use that as our official "from".
+                fromregex=/^From ([^ ]+@[^ ]+) /
+                fromregex.match(@unix_from)
+                @from=$+
+
+                # or maybe it's local
+                if @from == nil then
+                    @unix_from =~ /^From (\S+) /
+                    @from=$+
+                end
+            else
+                fromregex=/([^ ]+@[^ ]+) \(.*\)|[^<]*[<](.*@.*)[>]|([^ ]+@[^ ]+)/
                 if self["Return-Path"] != nil then
-                    fromregex.match(self["Return-Path"][0].contents);
+                    fromregex.match(self["Return-Path"][0].contents)
                 else
                     if self["From"] != nil then
-                        fromregex.match(self["From"][0].contents);
+                        fromregex.match(self["From"][0].contents)
                     end
                 end
                 address_candidate=$+
@@ -170,32 +202,53 @@ module Gurgitate
                 # If there STILL isn't a match, then it's probably safe to
                 # assume that it's local mail, and doesn't have an @ in its
                 # address.
-                if address_candidate == nil then
+                unless address_candidate
                     if self["Return-Path"] != nil then
                         self["Return-Path"][0].contents =~ /(\S+)/
                         address_candidate=$+
                     else
-                        if self["From"] then
-                            self["From"][0].contents =~ /(\S+)/
-                        end
+                        self["From"][0].contents =~ /(\S+)/
                         address_candidate=$+
                     end
                 end
 
                 @from=address_candidate
 
-                @unix_from="From "+self.from+" "+Time.new.to_s;
+                @unix_from="From "+self.from+" "+Time.new.to_s
+            end
+        end
+
+        public
+
+        # Creates a Headers object.
+        # headertext::
+        #   The text of the message headers.
+        def initialize(headertext=nil,sender=nil, recipient=nil)
+            @from    = sender
+            @to      = recipient
+            @headers = Hash.new(nil)
+
+            if Hash === headertext
+                @headers_changed = true
+                headertext.each_key do |key|
+
+                    headername = key.to_s.gsub("_","-")
+
+                    header=Header.new(headername, headertext[key])
+                    @headers[header.name] ||= HeaderBag.new
+                    @headers[header.name].push(header)
+                end
             else
-                # If it is there, then grab the email address in it and
-                # use that as our official "from".
-                fromregex=/^From ([^ ]+@[^ ]+) /;
-                fromregex.match(unix_from);
-                @from=$+
+                if headertext
+                    @unix_from, @headertext = figure_out_from_line headertext
+                    parse_headers if @headertext
 
-                # or maybe it's local
-                if @from == nil then
-                    unix_from =~ /^From (\S+) /;
-                    @from=$+
+                    if sender # then don't believe the mbox separator
+                        @from = sender
+                        @unix_from="From "+self.from+" "+Time.new.to_s
+                    else
+                        guess_sender
+                    end
                 end
             end
         end
@@ -226,7 +279,7 @@ module Gurgitate
         #
         # Yet another bucket of rants.  Unix mail sucks.
         def to
-            return @headers["X-Original-To"] || nil
+            return @to || @headers["X-Original-To"] || nil
         end
 
         # Who the message is from (the envelope from)
@@ -239,7 +292,7 @@ module Gurgitate
         # newfrom:: An email address
         def from=(newfrom) 
             @from=newfrom
-            @unix_from="From "+self.from+" "+Time.new.to_s;
+            @unix_from="From "+self.from+" "+Time.new.to_s
         end
 
         # Match header +name+ against +regex+
@@ -262,9 +315,11 @@ module Gurgitate
         # regex:: The regex to match the headers against.
         def matches(names,regex)
             ret=false
-            if names.class == "String" then
-                names=[names];
+
+            if names.class == String then
+                names=[names]
             end
+
             names.each do |n|
                 ret |= match(n,regex)
             end
@@ -281,9 +336,9 @@ module Gurgitate
         # the "From " line
         def to_s
             if @headers_changed then
-                return @headers.collect { |n,h|
-                    h.collect { |h| h.to_s }.join("\n")
-                }.join("\n")
+                return @headers.map do |n,h|
+                    h.map do |h| h.to_s end.join("\n")
+                end.join("\n")
             else
                 return @headertext
             end

data/lib/gurgitate/mailmessage.rb

@@ -7,22 +7,67 @@
 require 'gurgitate/headers'
 
 module Gurgitate
-    # A complete mail message.
 
+    # A complete mail message.
     class Mailmessage
+
+        Fromregex=/([^ ]+@[^ ]+) \(.*\)|[^<][<](.*@.*)[>]|([^ ]+@[^ ]+)/;
+
         # The headers of the message
         attr_reader :headers
         # The body of the message
         attr_accessor :body
 
-        def initialize(text, recipient=nil, sender=nil)
-            (@headertext,@body)=text.split(/^$/,2)
-            fromregex=/([^ ]+@[^ ]+) \(.*\)|[^<][<](.*@.*)[>]|([^ ]+@[^ ]+)/;
-            @headers=Headers.new(@headertext);
-            fromregex.match(@headers["From"][0].contents);
-            @from=$+
-            @recipient = recipient
-            @sender = sender
+        # The envelope sender and recipient, if anyone thought to
+        # mention them to us.
+        attr_accessor :sender
+        attr_accessor :recipient
+
+        # Creates a new mail message with headers built from the options hash,
+        # and the body of the message in a string.
+        def self.create(*args)
+            options = body = nil
+
+            if String === args[0]
+                options = args[1]
+                body = args[0]
+            elsif Hash === args[0]
+                options = args[0]
+            end
+
+            options = options.clone # just in case, since I'm meddling with it
+            message = self.new
+
+            message.instance_eval do
+                if body
+                    @body=body
+                end
+
+                %w/sender recipient body/.each do |key|
+                    if options.has_key? key.to_sym
+                        instance_variable_set("@#{key}", options[key.to_sym])
+                        options.delete key
+                    end
+                end
+
+                @headers = Headers.new(options)
+            end
+
+            message
+        end
+
+        def initialize(text=nil, recipient=nil, sender=nil)
+            if text
+                (@headertext,@body)=text.split(/\n\n/,2)
+                @headers=Headers.new(@headertext);
+                Fromregex.match(@headers["From"][0].contents);
+                @from=$+
+                    @recipient = recipient
+                @sender = sender
+            else
+                @headers = Headers.new
+                @body = ""
+            end
         end
 
         # Returns the header +name+
@@ -40,9 +85,9 @@ module Gurgitate
         # def to; @headers["To","Cc"]; end
 
         # Returns the formatted mail message
-        def to_s; @headers.to_s + ( @body || ""); end
+        def to_s; @headers.to_s + "\n\n" + ( @body || ""); end
 
         # Returns the mail message formatted for mbox
-        def to_mbox; @headers.to_mbox + @body; end
+        def to_mbox; @headers.to_mbox + "\n\n" + @body; end
     end
 end