[catagits/Catalyst-View-Email.git] / lib / Catalyst / View / Email.pm

package Catalyst::View::Email;

use warnings;
use strict;

use Class::C3;
use Carp;

use Encode qw(encode decode);
use Email::Send;
use Email::MIME::Creator;

use parent 'Catalyst::View';

our $VERSION = '0.13';

__PACKAGE__->mk_accessors(qw/ mailer /);

=head1 NAME

Catalyst::View::Email - Send Email from Catalyst

=head1 SYNOPSIS

This module sends out emails from a stash key specified in the
configuration settings.

=head1 CONFIGURATION

WARNING: since version 0.10 the configuration options slightly changed!

Use the helper to create your View:
    
    $ script/myapp_create.pl view Email Email

In your app configuration:

    __PACKAGE__->config(
        'View::Email' => {
            # Where to look in the stash for the email information.
            # 'email' is the default, so you don't have to specify it.
            stash_key => 'email',
            # Define the defaults for the mail
            default => {
                # Defines the default content type (mime type). Mandatory
                content_type => 'text/plain',
                # Defines the default charset for every MIME part with the 
                # content type text.
                # According to RFC2049 a MIME part without a charset should
                # be treated as US-ASCII by the mail client.
                # If the charset is not set it won't be set for all MIME parts
                # without an overridden one.
                # Default: none
                charset => 'utf-8'
            },
            # Setup how to send the email
            # all those options are passed directly to Email::Send
            sender => {
                mailer => 'SMTP',
                # mailer_args is passed directly into Email::Send 
                mailer_args => {
                    Host     => 'smtp.example.com', # defaults to localhost
                    username => 'username',
                    password => 'password',
            }
          }
        }
    );

=head1 NOTE ON SMTP

If you use SMTP and don't specify Host, it will default to localhost and
attempt delivery. This often means an email will sit in a queue and
not be delivered.

=cut

__PACKAGE__->config(
    stash_key   => 'email',
    default     => {
        content_type    => 'text/plain',
    },
);

=head1 SENDING EMAIL

Sending email is just filling the stash and forwarding to the view:

    sub controller : Private {
        my ( $self, $c ) = @_;

        $c->stash->{email} = {
            to      => 'jshirley@gmail.com',
            cc      => 'abraxxa@cpan.org',
            bcc     => join ',', qw/hidden@secret.com hidden2@foobar.com/,
            from    => 'no-reply@foobar.com',
            subject => 'I am a Catalyst generated email',
            body    => 'Body Body Body',
        };
        
        $c->forward( $c->view('Email') );
    }

Alternatively you can use a more raw interface and specify the headers as
an array reference like it is passed to L<Email::MIME::Creator>.
Note that you may also mix both syntaxes if you like ours better but need to
specify additional header attributes.
The attributes are appended to the header array reference without overwriting
contained ones.

    $c->stash->{email} = {
        header => [
            To      => 'jshirley@gmail.com',
            Cc      => 'abraxxa@cpan.org',
            Bcc     => join ',', qw/hidden@secret.com hidden2@foobar.com/,
            From    => 'no-reply@foobar.com',
            Subject => 'Note the capitalization differences',
        ],
        body => qq{Ain't got no body, and nobody cares.},
        # Or, send parts
        parts => [
            Email::MIME->create(
                attributes => {
                    content_type => 'text/plain',
                    disposition  => 'attachment',
                    charset      => 'US-ASCII',
                },
                body => qq{Got a body, but didn't get ahead.},
            )
        ],
    };

=head1 HANDLING ERRORS

If the email fails to send, the view will die (throw an exception).
After your forward to the view, it is a good idea to check for errors:
    
    $c->forward( $c->view('Email') );
    
    if ( scalar( @{ $c->error } ) ) {
        $c->error(0); # Reset the error condition if you need to
        $c->response->body('Oh noes!');
    } else {
        $c->response->body('Email sent A-OK! (At least as far as we can tell)');
    }

=head1 USING TEMPLATES FOR EMAIL

Now, it's no fun to just send out email using plain strings.
Take a look at L<Catalyst::View::Email::Template> to see how you can use your
favourite template engine to render the mail body.

=head1 METHODS

=over 4

=item new

Validates the base config and creates the L<Email::Send> object for later use
by process.

=cut

sub new {
    my $self = shift->next::method(@_);

    my $stash_key = $self->{stash_key};
    croak "$self stash_key isn't defined!"
        if ($stash_key eq '');

    my $sender = Email::Send->new;

    if ( my $mailer = $self->{sender}->{mailer} ) {
        croak "$mailer is not supported, see Email::Send"
            unless $sender->mailer_available($mailer);
        $sender->mailer($mailer);
    }
    else {
        # Default case, run through the most likely options first.
        for ( qw/SMTP Sendmail Qmail/ ) {
            $sender->mailer($_) and last if $sender->mailer_available($_);
        }
    }

    if ( my $args = $self->{sender}->{mailer_args} ) {
        if ( ref $args eq 'HASH' ) {
            $sender->mailer_args([ %$args ]);
        }
        elsif ( ref $args eq 'ARRAY' ) {
            $sender->mailer_args($args);
        } else {
            croak "Invalid mailer_args specified, check pod for Email::Send!";
        }
    }

    $self->mailer($sender);

    return $self;
}

=item process($c)

The process method does the actual processing when the view is dispatched to.

This method sets up the email parts and hands off to L<Email::Send> to handle
the actual email delivery.

=cut

sub process {
    my ( $self, $c ) = @_;

    croak "Unable to send mail, bad mail configuration"
        unless $self->mailer;

    my $email  = $c->stash->{$self->{stash_key}};
    croak "Can't send email without a valid email structure"
        unless $email;

    # Default content type
    if ( exists $self->{content_type} and not $email->{content_type} ) {
        $email->{content_type} = $self->{content_type};
    }

    my $header  = $email->{header} || [];
        push @$header, ('To' => delete $email->{to})
            if $email->{to};
        push @$header, ('Cc' => delete $email->{cc})
            if $email->{cc};
        push @$header, ('Bcc' => delete $email->{bcc})
            if $email->{bcc};
        push @$header, ('From' => delete $email->{from})
            if $email->{from};
        push @$header, ('Subject' => Encode::encode('MIME-Header', delete $email->{subject}))
            if $email->{subject};
        push @$header, ('Content-type' => $email->{content_type})
            if $email->{content_type};

    my $parts = $email->{parts};
    my $body  = $email->{body};
   
    unless ( $parts or $body ) {
        croak "Can't send email without parts or body, check stash";
    }

    my %mime = ( header => $header, attributes => {} );

    if ( $parts and ref $parts eq 'ARRAY' ) {
        $mime{parts} = $parts;
    } else {
        $mime{body} = $body;
    }

    $mime{attributes}->{content_type} = $email->{content_type} 
        if $email->{content_type};
    if ( $mime{attributes} and not $mime{attributes}->{charset} and
         $self->{default}->{charset} )
    {
        $mime{attributes}->{charset} = $self->{default}->{charset};
    }

    my $message = $self->generate_message( $c, \%mime );

    if ( $message ) {
        my $return = $self->mailer->send($message);
        # return is a Return::Value object, so this will stringify as the error
        # in the case of a failure.  
        croak "$return" if !$return;
    } else {
        croak "Unable to create message";
    }
}

=item setup_attributes($c, $attr)

Merge attributes with the configured defaults. You can override this method to
return a structure to pass into L<generate_message> which subsequently
passes the return value of this method to Email::MIME->create under the
C<attributes> key.

=cut

sub setup_attributes {
    my ( $self, $c, $attrs ) = @_;
    
    my $default_content_type    = $self->{default}->{content_type};
    my $default_charset         = $self->{default}->{charset};

    my $e_m_attrs = {};

    if (exists $attrs->{content_type} && defined $attrs->{content_type} && $attrs->{content_type} ne '') {
        $c->log->debug('C::V::Email uses specified content_type ' . $attrs->{content_type} . '.') if $c->debug;
        $e_m_attrs->{content_type} = $attrs->{content_type};
    }
    elsif (defined $default_content_type && $default_content_type ne '') {
        $c->log->debug("C::V::Email uses default content_type $default_content_type.") if $c->debug;
        $e_m_attrs->{content_type} = $default_content_type;
    }
   
    if (exists $attrs->{charset} && defined $attrs->{charset} && $attrs->{charset} ne '') {
        $e_m_attrs->{charset} = $attrs->{charset};
    }
    elsif (defined $default_charset && $default_charset ne '') {
        $e_m_attrs->{charset} = $default_charset;
    }

    return $e_m_attrs;
}

=item generate_message($c, $attr)

Generate a message part, which should be an L<Email::MIME> object and return it.

Takes the attributes, merges with the defaults as necessary and returns a
message object.

=cut

sub generate_message {
    my ( $self, $c, $attr ) = @_;

    # setup the attributes (merge with defaults)
    $attr->{attributes} = $self->setup_attributes($c, $attr->{attributes});
    return Email::MIME->create(%$attr);
}

=back

=head1 TROUBLESHOOTING

As with most things computer related, things break.  Email even more so.  
Typically any errors are going to come from using SMTP as your sending method,
which means that if you are having trouble the first place to look is at
L<Email::Send::SMTP>.  This module is just a wrapper for L<Email::Send>,
so if you get an error on sending, it is likely from there anyway.

If you are using SMTP and have troubles sending, whether it is authentication
or a very bland "Can't send" message, make sure that you have L<Net::SMTP> and,
if applicable, L<Net::SMTP::SSL> installed.

It is very simple to check that you can connect via L<Net::SMTP>, and if you
do have sending errors the first thing to do is to write a simple script
that attempts to connect.  If it works, it is probably something in your
configuration so double check there.  If it doesn't, well, keep modifying
the script and/or your mail server configuration until it does!

=head1 SEE ALSO

=head2 L<Catalyst::View::Email::Template> - Send fancy template emails with Cat

=head2 L<Catalyst::Manual> - The Catalyst Manual

=head2 L<Catalyst::Manual::Cookbook> - The Catalyst Cookbook

=head1 AUTHORS

J. Shirley <jshirley@gmail.com>

Alexander Hartmaier <abraxxa@cpan.org>

=head1 CONTRIBUTORS

(Thanks!)

Matt S Trout

Daniel Westermann-Clark

Simon Elliott <cpan@browsing.co.uk>

Roman Filippov

Lance Brown <lance@bearcircle.net>

=head1 LICENSE

This library is free software, you can redistribute it and/or modify it under
the same terms as Perl itself.

=cut

1;
Commit	Line	Data
529915ab	1	package Catalyst::View::Email;
	2
	3	use warnings;
	4	use strict;
	5
29840e4a	6	use Class::C3;
529915ab	7	use Carp;
529915ab	8
e512f6ca	9	use Encode qw(encode decode);
529915ab	10	use Email::Send;
	11	use Email::MIME::Creator;
	12
e512f6ca	13	use parent 'Catalyst::View';
529915ab	14
b7b30250	15	our $VERSION = '0.13';
529915ab	16
ea115f9b	17	__PACKAGE__->mk_accessors(qw/ mailer /);
529915ab	18
	19	=head1 NAME
	20
	21	Catalyst::View::Email - Send Email from Catalyst
	22
	23	=head1 SYNOPSIS
	24
4a44bcd3	25	This module sends out emails from a stash key specified in the
529915ab	26	configuration settings.
	27
	28	=head1 CONFIGURATION
	29
4a44bcd3	30	WARNING: since version 0.10 the configuration options slightly changed!
4a44bcd3	31
ea115f9b	32	Use the helper to create your View:
	33
	34	$ script/myapp_create.pl view Email Email
	35
e512f6ca	36	In your app configuration:
	37
	38	__PACKAGE__->config(
	39	'View::Email' => {
	40	# Where to look in the stash for the email information.
	41	# 'email' is the default, so you don't have to specify it.
	42	stash_key => 'email',
	43	# Define the defaults for the mail
	44	default => {
	45	# Defines the default content type (mime type). Mandatory
	46	content_type => 'text/plain',
	47	# Defines the default charset for every MIME part with the
	48	# content type text.
	49	# According to RFC2049 a MIME part without a charset should
	50	# be treated as US-ASCII by the mail client.
	51	# If the charset is not set it won't be set for all MIME parts
	52	# without an overridden one.
	53	# Default: none
	54	charset => 'utf-8'
6cbcc613	55	},
e512f6ca	56	# Setup how to send the email
	57	# all those options are passed directly to Email::Send
	58	sender => {
6cbcc613	59	mailer => 'SMTP',
e512f6ca	60	# mailer_args is passed directly into Email::Send
	61	mailer_args => {
	62	Host => 'smtp.example.com', # defaults to localhost
	63	username => 'username',
	64	password => 'password',
	65	}
98e5068b	66	}
98e5068b	67	}
e512f6ca	68	);
229f9fdd	69
4a44bcd3	70	=head1 NOTE ON SMTP
229f9fdd	71
229f9fdd	72	If you use SMTP and don't specify Host, it will default to localhost and
4a44bcd3	73	attempt delivery. This often means an email will sit in a queue and
4a44bcd3	74	not be delivered.
529915ab	75
	76	=cut
	77
	78	__PACKAGE__->config(
06afcdbc	79	stash_key => 'email',
06afcdbc	80	default => {
4a44bcd3	81	content_type => 'text/plain',
06afcdbc	82	},
529915ab	83	);
	84
	85	=head1 SENDING EMAIL
	86
4a44bcd3	87	Sending email is just filling the stash and forwarding to the view:
529915ab	88
	89	sub controller : Private {
	90	my ( $self, $c ) = @_;
4a44bcd3	91
529915ab	92	$c->stash->{email} = {
4a44bcd3	93	to => 'jshirley@gmail.com',
4a44bcd3	94	cc => 'abraxxa@cpan.org',
98e5068b	95	bcc => join ',', qw/hidden@secret.com hidden2@foobar.com/,
4a44bcd3	96	from => 'no-reply@foobar.com',
	97	subject => 'I am a Catalyst generated email',
	98	body => 'Body Body Body',
529915ab	99	};
4a44bcd3	100
4a44bcd3	101	$c->forward( $c->view('Email') );
529915ab	102	}
529915ab	103
4a44bcd3	104	Alternatively you can use a more raw interface and specify the headers as
	105	an array reference like it is passed to L<Email::MIME::Creator>.
	106	Note that you may also mix both syntaxes if you like ours better but need to
	107	specify additional header attributes.
	108	The attributes are appended to the header array reference without overwriting
	109	contained ones.
529915ab	110
	111	$c->stash->{email} = {
	112	header => [
4a44bcd3	113	To => 'jshirley@gmail.com',
4a44bcd3	114	Cc => 'abraxxa@cpan.org',
98e5068b	115	Bcc => join ',', qw/hidden@secret.com hidden2@foobar.com/,
4a44bcd3	116	From => 'no-reply@foobar.com',
4a44bcd3	117	Subject => 'Note the capitalization differences',
529915ab	118	],
	119	body => qq{Ain't got no body, and nobody cares.},
	120	# Or, send parts
	121	parts => [
	122	Email::MIME->create(
	123	attributes => {
	124	content_type => 'text/plain',
	125	disposition => 'attachment',
	126	charset => 'US-ASCII',
	127	},
4a44bcd3	128	body => qq{Got a body, but didn't get ahead.},
529915ab	129	)
	130	],
	131	};
	132
2a175229	133	=head1 HANDLING ERRORS
529915ab	134
4a44bcd3	135	If the email fails to send, the view will die (throw an exception).
	136	After your forward to the view, it is a good idea to check for errors:
	137
	138	$c->forward( $c->view('Email') );
529915ab	139
529915ab	140	if ( scalar( @{ $c->error } ) ) {
529915ab	141	$c->error(0); # Reset the error condition if you need to
4a44bcd3	142	$c->response->body('Oh noes!');
529915ab	143	} else {
4a44bcd3	144	$c->response->body('Email sent A-OK! (At least as far as we can tell)');
529915ab	145	}
529915ab	146
ea115f9b	147	=head1 USING TEMPLATES FOR EMAIL
529915ab	148
ea115f9b	149	Now, it's no fun to just send out email using plain strings.
	150	Take a look at L<Catalyst::View::Email::Template> to see how you can use your
	151	favourite template engine to render the mail body.
529915ab	152
4a44bcd3	153	=head1 METHODS
	154
	155	=over 4
	156
	157	=item new
	158
	159	Validates the base config and creates the L<Email::Send> object for later use
	160	by process.
529915ab	161
	162	=cut
	163
	164	sub new {
25650747	165	my $self = shift->next::method(@_);
25650747	166
ea115f9b	167	my $stash_key = $self->{stash_key};
	168	croak "$self stash_key isn't defined!"
	169	if ($stash_key eq '');
529915ab	170
06afcdbc	171	my $sender = Email::Send->new;
529915ab	172
06afcdbc	173	if ( my $mailer = $self->{sender}->{mailer} ) {
	174	croak "$mailer is not supported, see Email::Send"
	175	unless $sender->mailer_available($mailer);
	176	$sender->mailer($mailer);
4a44bcd3	177	}
4a44bcd3	178	else {
529915ab	179	# Default case, run through the most likely options first.
529915ab	180	for ( qw/SMTP Sendmail Qmail/ ) {
06afcdbc	181	$sender->mailer($_) and last if $sender->mailer_available($_);
529915ab	182	}
	183	}
	184
06afcdbc	185	if ( my $args = $self->{sender}->{mailer_args} ) {
229f9fdd	186	if ( ref $args eq 'HASH' ) {
06afcdbc	187	$sender->mailer_args([ %$args ]);
229f9fdd	188	}
229f9fdd	189	elsif ( ref $args eq 'ARRAY' ) {
06afcdbc	190	$sender->mailer_args($args);
229f9fdd	191	} else {
	192	croak "Invalid mailer_args specified, check pod for Email::Send!";
	193	}
529915ab	194	}
529915ab	195
06afcdbc	196	$self->mailer($sender);
529915ab	197
	198	return $self;
	199	}
	200
4a44bcd3	201	=item process($c)
11a0bf18	202
	203	The process method does the actual processing when the view is dispatched to.
	204
	205	This method sets up the email parts and hands off to L<Email::Send> to handle
	206	the actual email delivery.
	207
	208	=cut
	209
529915ab	210	sub process {
	211	my ( $self, $c ) = @_;
	212
	213	croak "Unable to send mail, bad mail configuration"
	214	unless $self->mailer;
	215
ea115f9b	216	my $email = $c->stash->{$self->{stash_key}};
529915ab	217	croak "Can't send email without a valid email structure"
529915ab	218	unless $email;
d0e11256	219
ab4326b4	220	# Default content type
	221	if ( exists $self->{content_type} and not $email->{content_type} ) {
	222	$email->{content_type} = $self->{content_type};
529915ab	223	}
	224
	225	my $header = $email->{header} \|\| [];
	226	push @$header, ('To' => delete $email->{to})
	227	if $email->{to};
ea115f9b	228	push @$header, ('Cc' => delete $email->{cc})
	229	if $email->{cc};
	230	push @$header, ('Bcc' => delete $email->{bcc})
	231	if $email->{bcc};
529915ab	232	push @$header, ('From' => delete $email->{from})
529915ab	233	if $email->{from};
e512f6ca	234	push @$header, ('Subject' => Encode::encode('MIME-Header', delete $email->{subject}))
529915ab	235	if $email->{subject};
ab4326b4	236	push @$header, ('Content-type' => $email->{content_type})
529915ab	237	if $email->{content_type};
	238
	239	my $parts = $email->{parts};
	240	my $body = $email->{body};
	241
	242	unless ( $parts or $body ) {
	243	croak "Can't send email without parts or body, check stash";
	244	}
	245
ab4326b4	246	my %mime = ( header => $header, attributes => {} );
529915ab	247
	248	if ( $parts and ref $parts eq 'ARRAY' ) {
	249	$mime{parts} = $parts;
	250	} else {
	251	$mime{body} = $body;
	252	}
ab4326b4	253
	254	$mime{attributes}->{content_type} = $email->{content_type}
	255	if $email->{content_type};
43090696	256	if ( $mime{attributes} and not $mime{attributes}->{charset} and
	257	$self->{default}->{charset} )
	258	{
	259	$mime{attributes}->{charset} = $self->{default}->{charset};
	260	}
	261
d0e11256	262	my $message = $self->generate_message( $c, \%mime );
529915ab	263
529915ab	264	if ( $message ) {
95629d46	265	my $return = $self->mailer->send($message);
2a175229	266	# return is a Return::Value object, so this will stringify as the error
2a175229	267	# in the case of a failure.
95629d46	268	croak "$return" if !$return;
529915ab	269	} else {
	270	croak "Unable to create message";
	271	}
	272	}
	273
4a44bcd3	274	=item setup_attributes($c, $attr)
11a0bf18	275
4a44bcd3	276	Merge attributes with the configured defaults. You can override this method to
11a0bf18	277	return a structure to pass into L<generate_message> which subsequently
	278	passes the return value of this method to Email::MIME->create under the
	279	C<attributes> key.
	280
	281	=cut
	282
43090696	283	sub setup_attributes {
	284	my ( $self, $c, $attrs ) = @_;
	285
	286	my $default_content_type = $self->{default}->{content_type};
	287	my $default_charset = $self->{default}->{charset};
	288
	289	my $e_m_attrs = {};
	290
	291	if (exists $attrs->{content_type} && defined $attrs->{content_type} && $attrs->{content_type} ne '') {
d0e11256	292	$c->log->debug('C::V::Email uses specified content_type ' . $attrs->{content_type} . '.') if $c->debug;
43090696	293	$e_m_attrs->{content_type} = $attrs->{content_type};
	294	}
	295	elsif (defined $default_content_type && $default_content_type ne '') {
d0e11256	296	$c->log->debug("C::V::Email uses default content_type $default_content_type.") if $c->debug;
43090696	297	$e_m_attrs->{content_type} = $default_content_type;
	298	}
	299
	300	if (exists $attrs->{charset} && defined $attrs->{charset} && $attrs->{charset} ne '') {
	301	$e_m_attrs->{charset} = $attrs->{charset};
	302	}
	303	elsif (defined $default_charset && $default_charset ne '') {
	304	$e_m_attrs->{charset} = $default_charset;
	305	}
	306
	307	return $e_m_attrs;
	308	}
	309
4a44bcd3	310	=item generate_message($c, $attr)
11a0bf18	311
	312	Generate a message part, which should be an L<Email::MIME> object and return it.
	313
	314	Takes the attributes, merges with the defaults as necessary and returns a
	315	message object.
	316
	317	=cut
	318
d0e11256	319	sub generate_message {
0c8469c1	320	my ( $self, $c, $attr ) = @_;
43090696	321
43090696	322	# setup the attributes (merge with defaults)
d0e11256	323	$attr->{attributes} = $self->setup_attributes($c, $attr->{attributes});
43090696	324	return Email::MIME->create(%$attr);
	325	}
	326
4a44bcd3	327	=back
4a44bcd3	328
e512f6ca	329	=head1 TROUBLESHOOTING
	330
	331	As with most things computer related, things break. Email even more so.
	332	Typically any errors are going to come from using SMTP as your sending method,
	333	which means that if you are having trouble the first place to look is at
	334	L<Email::Send::SMTP>. This module is just a wrapper for L<Email::Send>,
	335	so if you get an error on sending, it is likely from there anyway.
	336
	337	If you are using SMTP and have troubles sending, whether it is authentication
	338	or a very bland "Can't send" message, make sure that you have L<Net::SMTP> and,
	339	if applicable, L<Net::SMTP::SSL> installed.
	340
	341	It is very simple to check that you can connect via L<Net::SMTP>, and if you
	342	do have sending errors the first thing to do is to write a simple script
	343	that attempts to connect. If it works, it is probably something in your
	344	configuration so double check there. If it doesn't, well, keep modifying
	345	the script and/or your mail server configuration until it does!
	346
529915ab	347	=head1 SEE ALSO
	348
	349	=head2 L<Catalyst::View::Email::Template> - Send fancy template emails with Cat
	350
	351	=head2 L<Catalyst::Manual> - The Catalyst Manual
	352
	353	=head2 L<Catalyst::Manual::Cookbook> - The Catalyst Cookbook
	354
	355	=head1 AUTHORS
	356
	357	J. Shirley <jshirley@gmail.com>
	358
4a44bcd3	359	Alexander Hartmaier <abraxxa@cpan.org>
4a44bcd3	360
25650747	361	=head1 CONTRIBUTORS
	362
	363	(Thanks!)
	364
94b4e4ff	365	Matt S Trout
94b4e4ff	366
25650747	367	Daniel Westermann-Clark
25650747	368
ea115f9b	369	Simon Elliott <cpan@browsing.co.uk>
229f9fdd	370
95629d46	371	Roman Filippov
95629d46	372
b7b30250	373	Lance Brown <lance@bearcircle.net>
b7b30250	374
529915ab	375	=head1 LICENSE
	376
	377	This library is free software, you can redistribute it and/or modify it under
	378	the same terms as Perl itself.
	379
	380	=cut
	381
	382	1;