gurgitate-mail 1.10.3 → 1.10.5

data/lib/gurgitate/deliver.rb

@@ -1,86 +0,0 @@
-#!/opt/bin/ruby -w
-
-#------------------------------------------------------------------------
-# Code to handle saving a message to a mailbox (and a framework for detecting
-# what kind of mailbox it is)
-#------------------------------------------------------------------------
-
-require "gurgitate/deliver/mbox"
-require "gurgitate/deliver/maildir"
-require "gurgitate/deliver/mh"
-
-module Gurgitate
-    module Deliver
-
-        class MailboxFound < Exception
-            # more of a "flag" than an exception really
-        end
-
-        # Saves a message to +mailbox+, after detecting what the mailbox's
-        # format is.
-        # mailbox::
-        #   A string containing the path of the mailbox to save
-        #   the message to.  If it is of the form "=mailbox", it
-        #   saves the message to +Maildir+/+mailbox+.  Otherwise,
-        #   it simply saves the message to the file +mailbox+.
-        def save(mailbox)
-
-            if mailbox[0,1]=='=' and @maildir != nil then
-                if @folderstyle == Maildir and mailbox !~ /^=\./ then
-                    mailbox["="]=@maildir+"/."
-                else
-                    mailbox["="]=@maildir+"/"
-                end
-            end
-
-            if mailbox[0,1] != '/' then
-                log("Cannot save to relative filenames!  Saving to spool file");
-                mailbox=spoolfile
-            end
-
-            begin
-                [MBox,Maildir,MH].each do |mod|
-                    if mod::check_mailbox(mailbox) then
-                        extend mod
-                        raise MailboxFound
-                    end
-                end
-
-                # Huh, nothing could find anything.  Oh well,
-                # let's default to whatever's in @folderstyle.  (I
-                # guess we'll be making a new mailbox, eh?)
-
-                if Module === @folderstyle then
-                    #
-                    # Careful we don't get the wrong instance variable 
-                    folderstyle=@folderstyle 
-
-                    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
-                        extend Maildir
-                    else
-                        extend MBox
-                    end
-                end
-                
-            rescue MailboxFound
-                # Don't need to do anything--we only have to worry
-                # about it if there wasn't a mailbox there.
-                nil
-            end
-
-            begin
-                deliver_message(mailbox)
-            rescue SystemCallError
-                self.log "Gack!  Something went wrong: " + $!.to_s
-                raise
-                # exit 75
-            end
-        end
-    end
-end

data/lib/gurgitate/deliver/maildir.rb

@@ -1,104 +0,0 @@
-#!/opt/bin/ruby -w
-
-#------------------------------------------------------------------------
-# Deliver mail to a maildir (also, detects maildir)
-#------------------------------------------------------------------------
-
-require "socket" # for gethostname (!)
-
-module Gurgitate
-    module Deliver
-        module Maildir
-            # Figures out if +mailbox+ is a Maildir mailbox
-            # mailbox::
-            #   A string containing the path of the mailbox to save the
-            #   message to.  If it is of the form "=mailbox", it saves
-            #   the message to +Maildir+/+mailbox+.  Otherwise, it
-            #   simply saves the message to the file +mailbox+.
-            def self::check_mailbox mailbox
-                begin
-                    if File.stat(mailbox).directory? then
-                        if File.stat(File.join(mailbox,"cur")).directory? then
-                            return Maildir
-                        end
-                    end
-                rescue Errno::ENOENT
-                    return nil
-                end
-            end
-
-            # Figures out the first available filename in the mail dir
-            # +dir+ and returns the filename to use.
-            # dir::
-            #   One of "+mailbox+/tmp" or "+mailbox+/new", but that's
-            #   only because that's what the maildir spec
-            #   (http://cr.yp.to/proto/maildir.html) says.
-            def maildir_getfilename dir
-                time=Time.now.to_f
-                counter=0
-                hostname=Socket::gethostname
-                filename=nil
-                loop do
-                    filename=File.join(dir,sprintf("%.4f.%d_%d.%s",
-                                                   time,$$,counter,hostname))
-                    break if not File.exists?(filename)
-                    counter+=1
-                end
-                return filename
-            end
-
-            # Creates a new Maildir folder +mailbox+
-            # mailbox::
-            #   The full path of the new folder to be created
-            def make_mailbox mailbox
-                Dir.mkdir(mailbox)
-                %w{cur tmp new}.each do |dir|
-                    Dir.mkdir(File.join(mailbox,dir))
-                end
-            end
-
-            # Delivers a message to the maildir-format mailbox +mailbox+.
-            # mailbox::
-            #   A string containing the path of the mailbox to save the
-            #   message to.  If it is of the form "=mailbox", it saves
-            #   the message to +Maildir+/+mailbox+.  Otherwise, it
-            #   simply saves the message to the file +mailbox+.
-            def deliver_message mailbox
-                begin
-                    File.stat(mailbox)
-                rescue Errno::ENOENT
-                    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)
-                    fh.flush
-                    # I should put a caveat here, unfortunately.  Ruby's
-                    # IO#flush only flushes Ruby's buffers, not the
-                    # operating system's.  If anyone knows how to force
-                    # a real fflush(), I'd love to know.  Otherwise, I'm
-                    # going to hope that closing the file does the trick
-                    # for me.
-                end
-
-                # ...and link to new.
-                # (I guess Maildir mailboxes don't work too well
-                # on Windows, eh?)
-                newfilename = maildir_getfilename(
-                                        File.join(mailbox,"new"))
-                begin
-                    File.link(tmpfilename,newfilename)
-                rescue SystemCallError
-                    log("Couldn't create maildir link to \"new\"!")
-                    exit 75 # Argh, I tried, it didn't work out
-                end
-                File.delete(tmpfilename)
-            end
-        end
-    end
-end

data/lib/gurgitate/deliver/mbox.rb

@@ -1,47 +0,0 @@
-#!/opt/bin/ruby -w
-
-#------------------------------------------------------------------------
-# Delivers a message to an mbox (also includes mbox detector)
-#------------------------------------------------------------------------
-
-module Gurgitate
-    module Deliver
-        module MBox
-            # Checks to see if +mailbox+ is an mbox mailbox
-            # mailbox::
-            #   A string containing the path of the mailbox to save
-            #   the message to.  If it is of the form "=mailbox", it
-            #   saves the message to +Maildir+/+mailbox+.  Otherwise,
-            #   it simply saves the message to the file +mailbox+.
-            def self::check_mailbox mailbox
-
-                begin
-                    if File.stat(mailbox).file? then
-                        return MBox
-                    else
-                        return nil
-                    end
-                rescue Errno::ENOENT
-                    return nil
-                end
-            end
-
-            # Delivers the message to +mailbox+
-            # mailbox::
-            #   A string containing the path of the mailbox to save
-            #   the message to.  If it is of the form "=mailbox", it
-            #   saves the message to +Maildir+/+mailbox+.  Otherwise,
-            #   it simply saves the message to the file +mailbox+.
-            def deliver_message mailbox
-                File.open(mailbox,File::WRONLY |
-                                  File::APPEND |
-                                  File::CREAT) do |f|
-                    f.flock(File::LOCK_EX)
-                    message=(if f.stat.size > 0 then "\n" else "" end) + to_mbox
-                    f.print message
-                    f.flock(File::LOCK_UN)
-                end
-           end
-        end
-    end
-end

data/lib/gurgitate/deliver/mh.rb

@@ -1,147 +0,0 @@
-#!/opt/bin/ruby -w
-
-require "yaml"
-
-#------------------------------------------------------------------------
-# Delivers a message to an mbox (also includes mbox detector)
-#------------------------------------------------------------------------
-
-module Gurgitate
-    module Deliver
-        module MH
-            # Checks to see if +mailbox+ is an mbox mailbox
-            # mailbox::
-            #   A string containing the path of the mailbox to save
-            #   the message to.  If it is of the form "=mailbox", it
-            #   saves the message to +Maildir+/+mailbox+.  Otherwise,
-            #   it simply saves the message to the file +mailbox+.
-            def self::check_mailbox mailbox
-                begin
-                    # Rather annoyingly, pretty well any directory can
-                    # be a MH mailbox, but this just checks to make sure
-                    # it's not actually a Maildir by mistake.
-                    #
-                    # I could put in a check for the path given in
-                    # $HOME/.mh_profile, but Claws-Mail uses MH mailboxes and
-                    # disregards $HOME/.mh_profile.
-                    if File.stat(mailbox).directory? and
-                        not ( File.exists?(File.join(mailbox, "cur")) or
-                              File.exists?(File.join(mailbox, "tmp")) or
-                              File.exists?(File.join(mailbox, "new"))) then
-                        return MH
-                    end
-                rescue Errno::ENOENT
-                    return nil
-                end
-            end
-
-            # Delivers the message to +mailbox+
-            # mailbox::
-            #   A string containing the path of the mailbox to save
-            #   the message to.  If it is of the form "=mailbox", it
-            #   saves the message to +Maildir+/+mailbox+.  Otherwise,
-            #   it simply saves the message to the file +mailbox+.
-            def deliver_message mailbox
-                if ! File.exists? mailbox then
-                    Dir.mkdir(mailbox)
-                end
-
-                if File.exists? mailbox and not File.directory? mailbox then
-                    raise SystemError, "not a directory"
-                end
-
-                new_msgnum = next_message(mailbox) do |filehandle|
-                    filehandle.print self.to_s
-                end
-
-                update_sequences(mailbox, new_msgnum)
-            end
-
-            private
-
-            def update_sequences mailbox, msgnum
-                sequences = File.join(mailbox, ".mh_sequences")
-                lockfile = sequences + ".lock" # how quaint
-                counter=0
-                while counter < 10 do
-                    begin
-                        File.open(lockfile,
-                                  File::WRONLY |
-                                  File::CREAT |
-                                  File::EXCL ) do |lock|
-                            File.open(sequences,
-                                      File::RDWR | File::CREAT) do |seq|
-
-                                seq.flock(File::LOCK_EX)
-                                metadata = YAML.load(seq.read) || Hash.new
-
-                                metadata["unseen"] = update_unseen \
-                                    metadata["unseen"], msgnum
-
-                                seq.rewind
-                                metadata.each do |key, val|
-                                    seq.puts "#{key}: #{val}"
-                                end
-                                seq.truncate seq.tell
-                                seq.flock(File::LOCK_UN)
-                            end
-                        end
-
-                        File.unlink lockfile
-                        break
-                    rescue Errno::EEXIST
-                        # some other process is doing something, so wait a few
-                        # milliseconds until it's done
-                        counter += 1
-                        sleep(0.1)
-                    end
-                end
-
-                # If it's still around after 10 tries, then obviously 
-                # something bigger went wrong; forcibly remove it and
-                # try again.
-                if counter == 10 then
-                    File.unlink lockfile
-                    update_sequences mailbox, msgnum
-                end
-            end
-
-            def update_unseen unseen, msgnum
-                prevmsg = msgnum - 1
-                if unseen
-                    unseenstring = unseen.to_s
-
-                    if unseenstring =~ /-#{prevmsg}/ then
-                        return unseenstring.sub(/\b#{prevmsg}\b/, msgnum.to_s)
-                    end
-
-                    if unseenstring.match(/\b#{prevmsg}\b/) then
-                        return "#{unseenstring}-#{msgnum}"
-                    end
-
-                    return "#{unseenstring} #{msgnum}"
-                else
-                    return msgnum
-                end
-            end
-
-            def next_message mailbox
-                next_msgnum = Dir.open(mailbox).map { |ent| ent.to_i }.max + 1
-                loop do
-                    begin
-                        File.open(File.join(mailbox, next_msgnum.to_s),
-                                  File::WRONLY |
-                                  File::CREAT |
-                                  File::EXCL ) do |filehandle|
-                            yield filehandle
-                        end
-                        break
-                    rescue Errno::EEXIST
-                        next_msgnum += 1
-                    end
-                end
-                return next_msgnum
-            end
-        end
-    end
-end

data/lib/gurgitate/header.rb

@@ -1,81 +0,0 @@
-#!/opt/bin/ruby -w
-
-module Gurgitate
-    class IllegalHeader < RuntimeError ; end
-
-    # A little class for a single header
-    class Header
-        # The name of the header
-        attr_accessor :name
-        # The contents of the header
-        attr_accessor :contents
-
-        alias_method :value, :contents
-
-        # A recent rash of viruses has forced me to canonicalize
-        # the capitalization of headers.  Sigh.
-        def capitalize_words(s)
-            return s.split(/-/).map { |w| w.capitalize }.join("-")
-          rescue
-            return s
-        end
-
-        private :capitalize_words
-
-        # Creates a Header object.
-        # header::
-        #   The text of the email-message header
-        def initialize(*header)
-            name,contents=nil,nil
-            if header.length == 1 then
-                # RFC822 says that a header consists of some (printable,
-                # non-whitespace) crap, followed by a colon, followed by
-                # some more (printable, but can include whitespaces)
-                # crap.
-                if(header[0] =~ /^[\x21-\x39\x3b-\x7e]+:/) then
-                    (name,contents)=header[0].split(/:\s*/,2)
-                    if(name =~ /:$/ and contents == nil) then
-                        # It looks like someone is using Becky!
-                        name=header[0].gsub(/:$/,"")
-                        contents = ""
-                    end
-
-                    raise IllegalHeader, "Empty name" \
-                        if (name == "" or name == nil)
-                    contents="" if contents == nil
-
-                    @@lastname=name
-                else
-                    raise IllegalHeader, "Bad header syntax: no colon in #{header}"
-                end
-            elsif header.length == 2 then
-                name,contents = *header
-            end
-
-            @name=capitalize_words(name)
-            @contents=contents
-        end
-
-        # Extended header
-        def << (text)
-            @contents += "\n" + text
-        end
-
-        # Matches a header's contents.
-        # 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
-
-        alias :=~ :matches
-
-        # Returns the header, ready to put into an email message
-        def to_s
-            @name+": "+@contents
-        end
-    end
-end