NAME¶
Mail::Box::Manager - manage a set of folders
INHERITANCE¶
Mail::Box::Manager
is a Mail::Reporter
Mail::Box::Manager is extended by
Mail::Box::Manage::User
SYNOPSIS¶
use Mail::Box::Manager;
my $mgr = new Mail::Box::Manager;
# Create folder objects.
my $folder = $mgr->open(folder => $ENV{MAIL});
my $message1 = $folder->message(0);
$mgr->copyMessage('Draft', $message);
my @messages = $folder->message(0,3);
$mgr->moveMessage('Outbox', @messages, create => 1 );
$mgr->close($folder);
# Create thread-detectors (see Mail::Box::Thread::Manager)
my $t = $mgr->threads($inbox, $outbox);
my $threads = $mgr->threads(folder => $folder);
foreach my $thread ($threads->all)
{ $thread->print;
}
$mgr->registerType(mbox => 'Mail::Box::MyType');
DESCRIPTION¶
The manager keeps track on a set of open folders and a set of message-thread
supporting objects. You are not obliged to use this object (you can directly
create a Mail::Box::Mbox if you prefer), but you will create more portable and
safer code if you do use it.
METHODS¶
Constructors¶
- Mail::Box::Manager->new(ARGS)
-
-Option --Defined in --Default
autodetect undef
default_folder_type 'mbox'
folder_types <all standard types>
folderdir [ '.' ]
folderdirs <synonym for C<folderdir>>
log Mail::Reporter 'WARNINGS'
trace Mail::Reporter 'WARNINGS'
- autodetect => TYPE|ARRAY-OF-TYPES
- Select only a subset of the folder types which are
implemented by MailBox to be detected automatically. This may improve the
auto-detection of folder types. Normally, all folder types will be tried
when a folder's name is incorrect, but this option limits the types which
are checked and therefore may respond faster.
- default_folder_type => NAME|CLASS
- Specifies the default folder type for newly created
folders. If this option is not specified, the most recently registered
type is used (see registerType() and the new(folder_types)
option.
- folder_types => NEW-TYPE | ARRAY-OF-NEW-TYPES
- Add one or more new folder types to the list of known
types. The order is important: when you open a file without specifying its
type, the manager will start trying the last added list of types, in
order.
Each TYPE is specified as an array which contains name, class, and defaults
for options which overrule the usual defaults. You may specify
folder-specific defaults as OPTIONS. They override the settings of the
manager.
- folderdir => DIRECTORY
- The default directory, or directories, where folders are
located. The "Mail::Box::Manager" can autodetect the existing
folder-types. There may be different kinds of folders opened at the same
time, and messages can be moved between those types, although that may
result in a loss of information depending on the folder types.
- folderdirs => [DIRECTORIES]
- log => LEVEL
- trace => LEVEL
Attributes¶
- $obj->defaultFolderType()
- Returns the default folder type, some class name.
- $obj->folderTypes()
- Returns the list of currently defined folder types.
example:
print join("\n", $manager->folderTypes), "\n";
- $obj->folderdir()
- In list context, this returns all folderdirs specified. In
SCALAR context only the first.
- $obj->registerType(TYPE, CLASS [,OPTIONS])
- With "registerType" you can register one TYPE of
folders. The CLASS is compiled automatically, so you do not need to
"use" them in your own modules. The TYPE is just an arbitrary
name.
The added types are prepended to the list of known types, so they are
checked first when a folder is opened in autodetect mode.
example:
$manager->registerType(mbox => 'Mail::Box::Mbox',
save_on_exit => 0, folderdir => '/tmp');
Manage open folders¶
- $obj->close(FOLDER, OPTIONS)
- "close" removes the specified folder from the
list of open folders. Indirectly it will update the files on disk if
needed (depends on the Mail::Box::new(save_on_exit) flag for each folder).
OPTIONS are passed to Mail::Box::close() of the folder.
The folder's messages will also be withdrawn from the known message threads.
You may also close the folder directly. The manager will be informed about
this event and take appropriate actions.
-Option --Default
close_by_self <false>
- close_by_self => BOOLEAN
- Used internally to avoid confusion about how the close was
started. Do not change this.
example:
my $inbox = $mgr->open('inbox');
$mgr->close($inbox);
$inbox->close; # alternative
- $obj->closeAllFolders(, OPTIONS)
- "closeAllFolders" calls close() for each
folder managed by this object. It is called just before the program stops
(before global cleanup).
- $obj->isOpenFolder(FOLDER)
- Returns true if the FOLDER is currently open.
example:
print "Yes\n" if $mgr->isOpenFolder('Inbox');
- $obj->open([FOLDERNAME], OPTIONS)
- Open a folder which name is specified as first parameter or
with the option flag "folder". The folder type is autodetected
unless the "type" is specified.
"open" carries options for the manager which are described here,
but may also have additional options for the folder type. For a
description of the folder options, see the options to the constructor
Mail::Box::new() for each type of mail box.
-Option --Default
authenticate 'AUTO'
create <false>
folder $ENV{MAIL}
folderdir '.'
type <first, usually C<mbox>>
- authenticate => TYPE|ARRAY-OF-TYPES|'AUTO'
- The TYPE of authentication to be used, or a list of TYPES
which the client prefers. The server may provide preferences as well, and
that order will be kept. This option is only supported by a small subset
of folder types, especially by POP and IMAP.
- create => BOOLEAN
- Create the folder if it does not exist. By default, this is
not done. The "type" option specifies which type of folder is
created.
- folder => NAME|URL
- Which folder to open, specified by NAME or special URL. The
URL format is composed as
type://username:password@hostname:port/foldername
Like real URLs, all fields are optional and have smart defaults, as long as
the string starts with a known folder type. Far from all folder types
support all these options, but at least they are always split-out. Be
warned that special characters in the password should be properly
url-encoded.
When you specify anything which does not match the URL format, it is passed
directly to the "new" method of the folder which is opened.
- folderdir => DIRECTORY
- The directory where the folders are usually stored.
- type => FOLDERTYPENAME|FOLDERTYPE
- Specify the type of the folder. If you do not specify this
option while opening a folder for reading, the manager checks all
registered folder types in order for the ability to open the folder. If
you open a new folder for writing, then the default will be the most
recently registered type. (If you add more than one type at once, the
first of the list is used.)
example: opening folders via the manager
my $jack = $manager->open(folder => '=jack',
type => 'mbox');
my $rcvd = $manager->open('myMail',
type => 'Mail::Box::Mbox', access => 'rw');
my $inbox = $manager->open('Inbox')
or die "Cannot open Inbox.\n";
my $pop = 'pop3://myself:secret@pop3.server.com:120/x';
my $send = $manager->open($url);
my $send = $manager->open(folder => '/x',
type => 'pop3', username => 'myself', password => 'secret'
server_name => 'pop3.server.com', server_port => '120');
- $obj->openFolders()
- Returns a list of all open folders.
Manage existing folders¶
- $obj->delete(FOLDERNAME, OPTIONS)
- Remove the named folder. The OPTIONS are the same as those
for open().
The deletion of a folder can take some time. Dependent on the type of
folder, the folder must be read first. For some folder-types this will be
fast.
-Option --Default
recursive <folder's default>
- recursive => BOOLEAN
- Some folder can only be recursively deleted, other have
more flexibility.
Move messages to folders¶
- $obj->appendMessage([FOLDER|FOLDERNAME,]
MESSAGES, OPTIONS)
- Append one or more messages to a folder (therefore, an
"appendMessages()" is defined as well). You may specify a
FOLDERNAME or an opened folder as the first argument. When the name is
that of an open folder, it is treated as if the folder-object was
specified, and not directly access the folder-files. You may also specify
the foldername as part of the options list.
If a message is added to an already opened folder, it is only added to the
structure internally in the program. The data will not be written to disk
until a write of that folder takes place. When the name of an unopened
folder is given, the folder is opened, the messages stored on disk, and
then the folder is closed.
A message must be an instance of a Mail::Message. The actual message type
does not have to match the folder type--the folder will try to resolve the
differences with minimal loss of information. The coerced messages (how
the were actually written) are returned as list.
The OPTIONS is a list of key/values, which are added to (overriding) the
default options for the detected folder type.
example:
$mgr->appendMessage('=send', $message, folderdir => '/');
$mgr->appendMessage($received, $inbox->messages);
my @appended = $mgr->appendMessages($inbox->messages,
folder => 'Drafts');
$_->label(seen => 1) foreach @appended;
- $obj->copyMessage([FOLDER|FOLDERNAME,] MESSAGES,
OPTIONS)
- Copy a message from one folder into another folder. If the
destination folder is already opened, Mail::Box::copyTo() is used.
Otherwise, Mail::Box::appendMessages() is called.
You need to specify a folder's name or folder object as the first argument,
or in the options list. The options are the same as those which can be
specified when opening a folder.
-Option--Default
share <false>
- share => BOOLEAN
- Try to share the physical storage of the messages. The
folder types may be different, but it all depends on the actual folder
where the message is copied to. Silently ignored when not possible to
share.
example:
my $drafts = $mgr->open(folder => 'Drafts');
my $outbox = $mgr->open(folder => 'Outbox');
$mgr->copyMessage($outbox, $drafts->message(0));
my @messages = $drafts->message(1,2);
$mgr->copyMessage('=Trash', @messages,
folderdir => '/tmp', create => 1);
$mgr->copyMessage($drafts->message(1),
folder => '=Drafts' folderdir => '/tmp',
create => 1);
- $obj->moveMessage([FOLDER|FOLDERNAME,] MESSAGES,
OPTIONS)
- Move a message from one folder to another.
BE WARNED that removals from a folder only take place when the folder is
closed, so the message is only flagged to be deleted in the opened source
folder.
BE WARNED that message labels may get lost when a message is moved from one
folder type to an other. An attempt is made to translate labels, but there
are many differences in interpretation by applications.
$mgr->moveMessage($received, $inbox->message(1))
is equivalent to
$mgr->copyMessage($received, $inbox->message(1), share => 1);
$inbox->message(1)->delete;
-Option--Default
share <true>
Manage message threads¶
- $obj->threads([FOLDERS], OPTIONS)
- Create a new object which keeps track of message threads.
You can read about the possible options in Mail::Box::Thread::Manager. As
OPTIONS specify one folder or an array of FOLDERS. It is also permitted to
specify folders before the options.
example:
my $t1 = $mgr->threads(folders => [ $inbox, $send ]);
my $t2 = $mgr->threads($inbox);
my $t3 = $mgr->threads($inbox, $send);
Internals¶
- $obj->decodeFolderURL(URL)
- Try to decompose a folder name which is specified as URL
(see open()) into separate options. Special characters like @-sign,
colon, and slash used in the user or password parts must be passed
URL-encoded.
- $obj->toBeThreaded(FOLDER, MESSAGES)
- Signal to the manager that all thread managers which are
using the specified folder must be informed that new messages are coming
in.
- $obj->toBeUnthreaded(FOLDER, MESSAGES)
- Signal to the manager that all thread managers which are
using the specified folder must be informed that new messages are or going
out.
Error handling¶
- $obj->AUTOLOAD()
- See "Error handling" in Mail::Reporter
- $obj->addReport(OBJECT)
- See "Error handling" in Mail::Reporter
- $obj->defaultTrace([LEVEL]|[LOGLEVEL,
TRACELEVEL]|[LEVEL, CALLBACK])
- Mail::Box::Manager->defaultTrace([LEVEL]|[LOGLEVEL,
TRACELEVEL]|[LEVEL, CALLBACK])
- See "Error handling" in Mail::Reporter
- $obj->errors()
- See "Error handling" in Mail::Reporter
- $obj->log([LEVEL [,STRINGS]])
- Mail::Box::Manager->log([LEVEL [,STRINGS]])
- See "Error handling" in Mail::Reporter
- $obj->logPriority(LEVEL)
- Mail::Box::Manager->logPriority(LEVEL)
- See "Error handling" in Mail::Reporter
- $obj->logSettings()
- See "Error handling" in Mail::Reporter
- $obj->notImplemented()
- See "Error handling" in Mail::Reporter
- $obj->report([LEVEL])
- See "Error handling" in Mail::Reporter
- $obj->reportAll([LEVEL])
- See "Error handling" in Mail::Reporter
- $obj->trace([LEVEL])
- See "Error handling" in Mail::Reporter
- $obj->warnings()
- See "Error handling" in Mail::Reporter
Cleanup¶
- $obj->DESTROY()
- See "Cleanup" in Mail::Reporter
- $obj->inGlobalDestruction()
- See "Cleanup" in Mail::Reporter
DETAILS¶
On many places in the documentation you can read that it is useful to have a
manager object. There are two of them: the Mail::Box::Manager, which maintains
a set of open folders, and an extension of it: the Mail::Box::Manage::User.
Managing open folders¶
It is useful to start your program by creating a folder manager object, an
Mail::Box::Manager. The object takes a few burdons from your neck:
- •
- autodetect the type of folder which is used.
This means that your application can be fully folder type independent.
- •
- autoload the required modules
There are so many modules involved in MailBox, that it is useful to have
some lazy autoloading of code. The manager knows which modules belong to
which type of folder.
- •
- avoid double openings
Your programming mistakes may cause the same folder to be opened twice. The
result of that could be very destructive. Therefore, the manager keeps
track on all open folders and avoids the same folder to be opened for the
second time.
- •
- close folders at clean-up
When the program is ending, the manager will cleanly close all folders which
are still open. This is required, because the autodestruct sequence of
Perl works in an unpredicatable order.
- •
- message thread detection
MailBox can discover message threads which span multiple folders. Any set of
open folders may be grouped in a tree of replies on replies on replies.
When a folder is closed, it will automatically be removed from the
threads, and a new folder can dynamically be added to the structure.
The manager is really simplifying things, and should therefore be the base of
all programs. However, it is possible to write useful programs without it.
Managing a user¶
One step further is the Mail::Box::Manage::User object (since MailBox v2.057),
which not only keeps track on open folders, but also collects information
about not-open folders.
The user class is, as the name says, targeted on managing one single user. Where
the Mail::Box::Manager will open any set of folder files, probably from
multiple users, the user class want one root folder directory.
In many aspects, the user manager simplifies the task for user-based servers and
other user-centric applications by setting smart defaults.
DIAGNOSTICS¶
- Error: Folder $name is already open.
- You cannot ask the manager for a folder which is already
open. In some older releases (before MailBox 2.049), this was permitted,
but then behaviour changed, because many nasty side-effects are to be
expected. For instance, an Mail::Box::update() on one folder handle
would influence the second, probably unexpectedly.
- Error: Folder $name is not a Mail::Box; cannot add a
message.
- The folder where the message should be appended to is an
object which is not a folder type which extends Mail::Box. Probably, it is
not a folder at all.
- Warning: Folder does not exist, failed opening $type folder
$name.
- The folder does not exist and creating is not permitted
(see open(create)) or did not succeed. When you do not have sufficient
access rights to the folder (for instance wrong password for POP3), this
warning will be produced as well.
The manager tried to open a folder of the specified type. It may help to
explicitly state the type of your folder with the "type" option.
There will probably be another warning or error message which is related
to this report and provides more details about its cause. You may also
have a look at new(autodetect) and new(folder_types).
- Warning: Folder type $type is unknown, using
autodetect.
- The specified folder type (see open(type), possibly derived
from the folder name when specified as url) is not known to the manager.
This may mean that you forgot to require the Mail::Box extension which
implements this folder type, but probably it is a typo. Usually, the
manager is able to figure-out which type to use by itself.
- Error: Illegal folder URL '$url'.
- The folder name was specified as URL, but not according to
the syntax. See decodeFolderURL() for an description of the
syntax.
- Error: No foldername specified to open.
- "open()" needs a folder name as first argument
(before the list of options), or with the "folder" option within
the list. If no name was found, the MAIL environment variable is checked.
When even that does not result in a usable folder, then this error is
produced. The error may be caused by an accidental odd-length option
list.
- Error: Package $package does not implement $method.
- Fatal error: the specific package (or one of its
superclasses) does not implement this method where it should. This message
means that some other related classes do implement this method however the
class at hand does not. Probably you should investigate this and probably
inform the author of the package.
- Error: Use appendMessage() to add messages which are
not in a folder.
- You do not need to copy this message into the folder,
because you do not share the message between folders.
- Warning: Use moveMessage() or copyMessage()
to move between open folders.
- The message is already part of a folder, and now it should
be appended to a different folder. You need to decide between copy or
move, which both will clone the message (not the body, because they are
immutable).
- Warning: Will never create a folder $name without having
write access.
- You have set open(create), but only want to read the
folder. Create is only useful for folders which have write or append
access modes (see Mail::Box::new(access)).
SEE ALSO¶
This module is part of Mail-Box distribution version 2.105, built on May 07,
2012. Website:
http://perl.overmeer.net/mailbox/
LICENSE¶
Copyrights 2001-2012 by [Mark Overmeer]. For other contributors see ChangeLog.
This program is free software; you can redistribute it and/or modify it under
the same terms as Perl itself. See
http://www.perl.com/perl/misc/Artistic.html