[catagits/Catalyst-Model-DBIC-Schema.git] / lib / Catalyst / Model / DBIC / Schema.pm

package Catalyst::Model::DBIC::Schema;

use strict;
use base qw/Catalyst::Model Class::Accessor::Fast Class::Data::Accessor/;
use NEXT;
use UNIVERSAL::require;
use Carp;
require DBIx::Class;

our $VERSION = '0.12';

__PACKAGE__->mk_classaccessor('composed_schema');
__PACKAGE__->mk_accessors('schema');

=head1 NAME

Catalyst::Model::DBIC::Schema - DBIx::Class::Schema Model Class

=head1 SYNOPSIS

Manual creation of a DBIx::Class::Schema and a Catalyst::Model::DBIC::Schema:

=over

=item 1.

Create the DBIx:Class schema in MyApp/Schema/FilmDB.pm:

  package MyApp::Schema::FilmDB;
  use base qw/DBIx::Class::Schema/;

  __PACKAGE__->load_classes(qw/Actor Role/);

=item 2.

Create some classes for the tables in the database, for example an 
Actor in MyApp/Schema/FilmDB/Actor.pm:

  package MyApp::Schema::FilmDB::Actor;
  use base qw/DBIx::Class/
  
  __PACKAGE__->load_components(qw/Core/);
  __PACKAGE__->table('actor');
  
  ...

and a Role in MyApp/Schema/Role.pm:

  package MyApp::Schema::FilmDB::Role;
  use base qw/DBIx::Class/
  
  __PACKAGE__->load_components(qw/Core/);
  __PACKAGE__->table('actor');
  
  ...    

Notice that the schema is in MyApp::Schema, not in MyApp::Model. This way it's 
usable as a standalone module and you can test/run it without Catalyst. 

=item 3.

To expose it to Catalyst as a model, you should create a DBIC Model in
MyApp/Model/FilmDB.pm:

  package MyApp::Model::FilmDB;
  use base qw/Catalyst::Model::DBIC::Schema/;
  
  __PACKAGE__->config(
      schema_class => 'MyApp::Schema::FilmDB',
      connect_info => [
                        "DBI:...",
                        "username",
                        "password",
                        {AutoCommit => 1}
                      ]
  );

See below for a full list of the possible config parameters.

=back

Now you have a working Model, accessing your separate DBIC Schema. Which can
be used/accessed in the normal Catalyst manner, via $c->model():

  my $actor = $c->model('FilmDB::Actor')->find(1);

You can also use it to set up DBIC authentication with 
Authentication::Store::DBIC in MyApp.pm:

  package MyApp;
  
  use Catalyst qw/... Authentication::Store::DBIC/;
  
  ...
  
  __PACKAGE__->config->{authentication}{dbic} = {
      user_class      => 'FilmDB::Actor',
      user_field      => 'name',
      password_field  => 'password'
  }

C<< $c->model() >> returns a L<DBIx::Class::ResultSet> for the source name
parameter passed. To find out more about which methods can be called on a
ResultSet, or how to add your own methods to it, please see the ResultSet
documentation in the L<DBIx::Class> distribution.

Some examples are given below:

    # to access schema methods directly:
    $c->model('FilmDB')->schema->source(...);

    # to access the source object, resultset, and class:
    $c->model('FilmDB')->source(...);
    $c->model('FilmDB')->resultset(...);
    $c->model('FilmDB')->class(...);

    # For resultsets, there's an even quicker shortcut:
    $c->model('FilmDB::Actor')
    # is the same as $c->model('FilmDB')->resultset('Actor')

    # To get the composed schema for making new connections:
    my $newconn = $c->model('FilmDB')->composed_schema->connect(...);

    # Or the same thing via a convenience shortcut:
    my $newconn = $c->model('FilmDB')->connect(...);

    # or, if your schema works on different storage drivers:
    my $newconn = $c->model('FilmDB')->composed_schema->clone();
    $newconn->storage_type('::LDAP');
    $newconn->connection(...);

    # and again, a convenience shortcut
    my $newconn = $c->model('FilmDB')->clone();
    $newconn->storage_type('::LDAP');
    $newconn->connection(...);

=head1 DESCRIPTION

This is a Catalyst Model for L<DBIx::Class::Schema>-based Models.  See
the documentation for L<Catalyst::Helper::Model::DBIC::Schema> and
L<Catalyst::Helper::Model::DBIC::SchemaLoader> for information
on generating these Models via Helper scripts.  The latter of the two
will also generated a L<DBIx::Class::Schema::Loader>-based Schema class
for you.

=head1 CONFIG PARAMETERS

=over 4

=item schema_class

This is the classname of your L<DBIx::Class::Schema> Schema.  It needs
to be findable in C<@INC>, but it does not need to be inside the 
C<Catalyst::Model::> namespace.  This parameter is required.

=item connect_info

This is an arrayref of connection parameters, which are specific to your
C<storage_type> (see your storage type documentation for more details).

This is not required if C<schema_class> already has connection information
defined in itself (which would be the case for a Schema defined by
L<DBIx::Class::Schema::Loader>, for instance).

For L<DBIx::Class::Storage::DBI>, which is the only supported
C<storage_type> in L<DBIx::Class> at the time of this writing, the
parameters are your dsn, username, password, and connect options hashref.

If you need to specify the L<DBIx::Class::Storage::DBI> specific parameter
C<on_connect_do>, or the related C<sql_maker> options C<limit_dialect>,
C<quote_char>, or C<name_sep>, you can place these options into a hashref
as the final element of the C<connect_info> arrayref.  If in doubt, don't
specify these options.  You would know it if you needed them.

Examples:

    connect_info => [ 'dbi:Pg:dbname=mypgdb', 'postgres', '' ],

    connect_info => [
                      'dbi:SQLite:dbname=foo.db',
                      {
                        on_connect_do => [
                          'PRAGMA synchronous = OFF',
                        ],
                      }
                    ],

    connect_info => [
                      'dbi:Pg:dbname=mypgdb',
                      'postgres',
                      '',
                      { AutoCommit => 0 },
                      {
                        on_connect_do => [
                          'some SQL statement',
                          'another SQL statement',
                        ],
                      }
                    ],

=item storage_type

Allows the use of a different C<storage_type> than what is set in your
C<schema_class> (which in turn defaults to C<::DBI> if not set in current
L<DBIx::Class>).  Completely optional, and probably unnecessary for most
people until other storage backends become available for L<DBIx::Class>.

=back

=head1 METHODS

=over 4

=item new

Instantiates the Model based on the above-documented ->config parameters.
The only required parameter is C<schema_class>.  C<connect_info> is
required in the case that C<schema_class> does not already have connection
information defined for it.

=item schema

Accessor which returns the connected schema being used by the this model.
There are direct shortcuts on the model class itself for
schema->resultset, schema->source, and schema->class.

=item composed_schema

Accessor which returns the composed schema, which has no connection info,
which was used in constructing the C<schema> above.  Useful for creating
new connections based on the same schema/model.  There are direct shortcuts
from the model object for composed_schema->clone and composed_schema->connect

=item clone

Shortcut for ->composed_schema->clone

=item connect

Shortcut for ->composed_schema->connect

=item source

Shortcut for ->schema->source

=item class

Shortcut for ->schema->class

=item resultset

Shortcut for ->schema->resultset

=item storage

Provides an accessor for the connected schema's storage object.
Used often for debugging and controlling transactions.

=back

=cut

sub new {
    my $self = shift->NEXT::new(@_);
    
    my $class = ref($self);
    my $model_name = $class;
    $model_name =~ s/^[\w:]+::(?:Model|M):://;

    croak "->config->{schema_class} must be defined for this model"
        unless $self->{schema_class};

    my $schema_class = $self->{schema_class};

    $schema_class->require
        or croak "Cannot load schema class '$schema_class': $@";

    if( !$self->{connect_info} ) {
        if($schema_class->storage && $schema_class->storage->connect_info) {
            $self->{connect_info} = $schema_class->storage->connect_info;
        }
        else {
            croak "Either ->config->{connect_info} must be defined for $class"
                  . " or $schema_class must have connect info defined on it";
        }
    }

    $self->composed_schema($schema_class->compose_namespace($class));
    $self->schema($self->composed_schema->clone);

    $self->schema->storage_type($self->{storage_type})
        if $self->{storage_type};

    # XXX This is temporary, until DBIx::Class::Storage::DBI supports the
    #  same syntax and we switch our requisite to that version somewhere
    #  down the line.  This syntax is already committed into DBIx::Class
    #  dev branch post-0.06.
    # At that time, this whole block can revert back to just being:
    #  $self->schema->connection(@{$self->{connect_info}});
    
    my $connect_info = [ @{$self->{connect_info}} ];
    my ($on_connect_do, %sql_maker_opts);
    if($DBIx::Class::VERSION < 0.069) {
        my $used;
        my $last_info = $self->{connect_info}->[-1];
        if(ref $last_info eq 'HASH') {
            if($on_connect_do = $last_info->{on_connect_do}) {
              $used = 1;
            }
            for my $sql_maker_opt (qw/limit_dialect quote_char name_sep/) {
              if(my $opt_val = $last_info->{$sql_maker_opt}) {
                $used = 1;
                $sql_maker_opts{$sql_maker_opt} = $opt_val;
              }
            }
            pop(@$connect_info) if $used;
        }
    }

    $self->schema->connection(@$connect_info);

    if($DBIx::Class::VERSION < 0.069) {
        $self->schema->storage->on_connect_do($on_connect_do)
            if $on_connect_do;
        foreach my $sql_maker_opt (keys %sql_maker_opts) {
            $self->schema->storage->sql_maker->$sql_maker_opt(
                $sql_maker_opts{$sql_maker_opt}
            );
        }
    }

    # XXX end of compatibility block referenced above

    no strict 'refs';
    foreach my $moniker ($self->schema->sources) {
        my $classname = "${class}::$moniker";
        *{"${classname}::ACCEPT_CONTEXT"} = sub {
            shift;
            shift->model($model_name)->resultset($moniker);
        }
    }

    return $self;
}

sub clone { shift->composed_schema->clone(@_); }

sub connect { shift->composed_schema->connect(@_); }

sub storage { shift->schema->storage(@_); }

=head1 SEE ALSO

General Catalyst Stuff:

L<Catalyst::Manual>, L<Catalyst::Test>, L<Catalyst::Request>,
L<Catalyst::Response>, L<Catalyst::Helper>, L<Catalyst>,

Stuff related to DBIC and this Model style:

L<DBIx::Class>, L<DBIx::Class::Schema>,
L<DBIx::Class::Schema::Loader>, L<Catalyst::Helper::Model::DBIC::Schema>,
L<Catalyst::Helper::Model::DBIC::SchemaLoader>

=head1 AUTHOR

Brandon L Black, C<blblack@gmail.com>

=head1 COPYRIGHT

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

=cut

1;
Commit	Line	Data
ad91060a	1	package Catalyst::Model::DBIC::Schema;
	2
	3	use strict;
14d912a2	4	use base qw/Catalyst::Model Class::Accessor::Fast Class::Data::Accessor/;
ad91060a	5	use NEXT;
	6	use UNIVERSAL::require;
	7	use Carp;
7db6da78	8	require DBIx::Class;
ad91060a	9
150c864c	10	our $VERSION = '0.12';
ad91060a	11
14d912a2	12	__PACKAGE__->mk_classaccessor('composed_schema');
ad91060a	13	__PACKAGE__->mk_accessors('schema');
	14
	15	=head1 NAME
	16
	17	Catalyst::Model::DBIC::Schema - DBIx::Class::Schema Model Class
	18
	19	=head1 SYNOPSIS
	20
aabc1d75	21	Manual creation of a DBIx::Class::Schema and a Catalyst::Model::DBIC::Schema:
	22
	23	=over
	24
	25	=item 1.
	26
	27	Create the DBIx:Class schema in MyApp/Schema/FilmDB.pm:
	28
	29	package MyApp::Schema::FilmDB;
	30	use base qw/DBIx::Class::Schema/;
	31
	32	__PACKAGE__->load_classes(qw/Actor Role/);
	33
	34	=item 2.
	35
	36	Create some classes for the tables in the database, for example an
	37	Actor in MyApp/Schema/FilmDB/Actor.pm:
	38
	39	package MyApp::Schema::FilmDB::Actor;
	40	use base qw/DBIx::Class/
	41
	42	__PACKAGE__->load_components(qw/Core/);
	43	__PACKAGE__->table('actor');
	44
	45	...
	46
	47	and a Role in MyApp/Schema/Role.pm:
	48
	49	package MyApp::Schema::FilmDB::Role;
	50	use base qw/DBIx::Class/
	51
	52	__PACKAGE__->load_components(qw/Core/);
	53	__PACKAGE__->table('actor');
	54
	55	...
	56
	57	Notice that the schema is in MyApp::Schema, not in MyApp::Model. This way it's
	58	usable as a standalone module and you can test/run it without Catalyst.
	59
	60	=item 3.
	61
	62	To expose it to Catalyst as a model, you should create a DBIC Model in
	63	MyApp/Model/FilmDB.pm:
	64
	65	package MyApp::Model::FilmDB;
	66	use base qw/Catalyst::Model::DBIC::Schema/;
	67
	68	__PACKAGE__->config(
	69	schema_class => 'MyApp::Schema::FilmDB',
	70	connect_info => [
	71	"DBI:...",
	72	"username",
	73	"password",
	74	{AutoCommit => 1}
	75	]
	76	);
	77
	78	See below for a full list of the possible config parameters.
	79
	80	=back
	81
	82	Now you have a working Model, accessing your separate DBIC Schema. Which can
	83	be used/accessed in the normal Catalyst manner, via $c->model():
	84
85	my $actor = $c->model('FilmDB::Actor')->find(1);
86
87	You can also use it to set up DBIC authentication with
88	Authentication::Store::DBIC in MyApp.pm:
89
90	package MyApp;
91
92	use Catalyst qw/... Authentication::Store::DBIC/;
93
94	...
95
96	__PACKAGE__->config->{authentication}{dbic} = {
97	user_class => 'FilmDB::Actor',
98	user_field => 'name',
99	password_field => 'password'
100	}
101
102	C<< $c->model() >> returns a L<DBIx::Class::ResultSet> for the source name
103	parameter passed. To find out more about which methods can be called on a
104	ResultSet, or how to add your own methods to it, please see the ResultSet
105	documentation in the L<DBIx::Class> distribution.
106
107	Some examples are given below:
108
109	# to access schema methods directly:
110	$c->model('FilmDB')->schema->source(...);
111
112	# to access the source object, resultset, and class:
113	$c->model('FilmDB')->source(...);
114	$c->model('FilmDB')->resultset(...);
115	$c->model('FilmDB')->class(...);
c12b7310	116
c12b7310	117	# For resultsets, there's an even quicker shortcut:
150c864c	118	$c->model('FilmDB::Actor')
aabc1d75	119	# is the same as $c->model('FilmDB')->resultset('Actor')
ad91060a	120
ad91060a	121	# To get the composed schema for making new connections:
aabc1d75	122	my $newconn = $c->model('FilmDB')->composed_schema->connect(...);
ad91060a	123
ad91060a	124	# Or the same thing via a convenience shortcut:
aabc1d75	125	my $newconn = $c->model('FilmDB')->connect(...);
ad91060a	126
ad91060a	127	# or, if your schema works on different storage drivers:
aabc1d75	128	my $newconn = $c->model('FilmDB')->composed_schema->clone();
ad91060a	129	$newconn->storage_type('::LDAP');
f7a944f8	130	$newconn->connection(...);
ad91060a	131
ad91060a	132	# and again, a convenience shortcut
aabc1d75	133	my $newconn = $c->model('FilmDB')->clone();
ad91060a	134	$newconn->storage_type('::LDAP');
f7a944f8	135	$newconn->connection(...);
ad91060a	136
	137	=head1 DESCRIPTION
	138
7b39f3f0	139	This is a Catalyst Model for L<DBIx::Class::Schema>-based Models. See
7b39f3f0	140	the documentation for L<Catalyst::Helper::Model::DBIC::Schema> and
1aeb6e1e	141	L<Catalyst::Helper::Model::DBIC::SchemaLoader> for information
	142	on generating these Models via Helper scripts. The latter of the two
	143	will also generated a L<DBIx::Class::Schema::Loader>-based Schema class
	144	for you.
ad91060a	145
	146	=head1 CONFIG PARAMETERS
	147
	148	=over 4
	149
	150	=item schema_class
	151
	152	This is the classname of your L<DBIx::Class::Schema> Schema. It needs
aabc1d75	153	to be findable in C<@INC>, but it does not need to be inside the
aabc1d75	154	C<Catalyst::Model::> namespace. This parameter is required.
ad91060a	155
	156	=item connect_info
	157
	158	This is an arrayref of connection parameters, which are specific to your
7db6da78	159	C<storage_type> (see your storage type documentation for more details).
ad91060a	160
0f2fd2c0	161	This is not required if C<schema_class> already has connection information
	162	defined in itself (which would be the case for a Schema defined by
	163	L<DBIx::Class::Schema::Loader>, for instance).
	164
7db6da78	165	For L<DBIx::Class::Storage::DBI>, which is the only supported
	166	C<storage_type> in L<DBIx::Class> at the time of this writing, the
	167	parameters are your dsn, username, password, and connect options hashref.
	168
	169	If you need to specify the L<DBIx::Class::Storage::DBI> specific parameter
	170	C<on_connect_do>, or the related C<sql_maker> options C<limit_dialect>,
	171	C<quote_char>, or C<name_sep>, you can place these options into a hashref
	172	as the final element of the C<connect_info> arrayref. If in doubt, don't
	173	specify these options. You would know it if you needed them.
	174
	175	Examples:
	176
	177	connect_info => [ 'dbi:Pg:dbname=mypgdb', 'postgres', '' ],
aabc1d75	178
7db6da78	179	connect_info => [
	180	'dbi:SQLite:dbname=foo.db',
	181	{
	182	on_connect_do => [
aabc1d75	183	'PRAGMA synchronous = OFF',
7db6da78	184	],
	185	}
	186	],
aabc1d75	187
7db6da78	188	connect_info => [
	189	'dbi:Pg:dbname=mypgdb',
	190	'postgres',
	191	'',
	192	{ AutoCommit => 0 },
	193	{
	194	on_connect_do => [
	195	'some SQL statement',
	196	'another SQL statement',
	197	],
	198	}
	199	],
	200
ad91060a	201	=item storage_type
	202
	203	Allows the use of a different C<storage_type> than what is set in your
	204	C<schema_class> (which in turn defaults to C<::DBI> if not set in current
b8427e0b	205	L<DBIx::Class>). Completely optional, and probably unnecessary for most
b8427e0b	206	people until other storage backends become available for L<DBIx::Class>.
ad91060a	207
	208	=back
	209
	210	=head1 METHODS
	211
	212	=over 4
	213
	214	=item new
	215
	216	Instantiates the Model based on the above-documented ->config parameters.
0f2fd2c0	217	The only required parameter is C<schema_class>. C<connect_info> is
	218	required in the case that C<schema_class> does not already have connection
	219	information defined for it.
ad91060a	220
	221	=item schema
	222
	223	Accessor which returns the connected schema being used by the this model.
aabc1d75	224	There are direct shortcuts on the model class itself for
c12b7310	225	schema->resultset, schema->source, and schema->class.
ad91060a	226
	227	=item composed_schema
	228
	229	Accessor which returns the composed schema, which has no connection info,
	230	which was used in constructing the C<schema> above. Useful for creating
c12b7310	231	new connections based on the same schema/model. There are direct shortcuts
c12b7310	232	from the model object for composed_schema->clone and composed_schema->connect
ad91060a	233
	234	=item clone
	235
	236	Shortcut for ->composed_schema->clone
	237
	238	=item connect
	239
	240	Shortcut for ->composed_schema->connect
	241
c12b7310	242	=item source
	243
	244	Shortcut for ->schema->source
	245
	246	=item class
	247
	248	Shortcut for ->schema->class
	249
	250	=item resultset
	251
	252	Shortcut for ->schema->resultset
	253
b8427e0b	254	=item storage
	255
	256	Provides an accessor for the connected schema's storage object.
	257	Used often for debugging and controlling transactions.
	258
ad91060a	259	=back
	260
	261	=cut
	262
	263	sub new {
46878f2e	264	my $self = shift->NEXT::new(@_);
ad91060a	265
	266	my $class = ref($self);
	267	my $model_name = $class;
	268	$model_name =~ s/^[\w:]+::(?:Model\|M):://;
	269
0f2fd2c0	270	croak "->config->{schema_class} must be defined for this model"
0f2fd2c0	271	unless $self->{schema_class};
ad91060a	272
	273	my $schema_class = $self->{schema_class};
	274
1aeb6e1e	275	$schema_class->require
1aeb6e1e	276	or croak "Cannot load schema class '$schema_class': $@";
ad91060a	277
0f2fd2c0	278	if( !$self->{connect_info} ) {
	279	if($schema_class->storage && $schema_class->storage->connect_info) {
	280	$self->{connect_info} = $schema_class->storage->connect_info;
	281	}
	282	else {
	283	croak "Either ->config->{connect_info} must be defined for $class"
1aeb6e1e	284	. " or $schema_class must have connect info defined on it";
0f2fd2c0	285	}
	286	}
	287
ad91060a	288	$self->composed_schema($schema_class->compose_namespace($class));
ad91060a	289	$self->schema($self->composed_schema->clone);
cd7e6e4f	290
	291	$self->schema->storage_type($self->{storage_type})
	292	if $self->{storage_type};
7db6da78	293
	294	# XXX This is temporary, until DBIx::Class::Storage::DBI supports the
	295	# same syntax and we switch our requisite to that version somewhere
	296	# down the line. This syntax is already committed into DBIx::Class
	297	# dev branch post-0.06.
	298	# At that time, this whole block can revert back to just being:
	299	# $self->schema->connection(@{$self->{connect_info}});
	300
	301	my $connect_info = [ @{$self->{connect_info}} ];
	302	my ($on_connect_do, %sql_maker_opts);
	303	if($DBIx::Class::VERSION < 0.069) {
	304	my $used;
	305	my $last_info = $self->{connect_info}->[-1];
	306	if(ref $last_info eq 'HASH') {
	307	if($on_connect_do = $last_info->{on_connect_do}) {
	308	$used = 1;
	309	}
	310	for my $sql_maker_opt (qw/limit_dialect quote_char name_sep/) {
	311	if(my $opt_val = $last_info->{$sql_maker_opt}) {
	312	$used = 1;
	313	$sql_maker_opts{$sql_maker_opt} = $opt_val;
	314	}
4bd6775c	315	}
7db6da78	316	pop(@$connect_info) if $used;
4bd6775c	317	}
4bd6775c	318	}
ad91060a	319
7db6da78	320	$self->schema->connection(@$connect_info);
	321
	322	if($DBIx::Class::VERSION < 0.069) {
	323	$self->schema->storage->on_connect_do($on_connect_do)
	324	if $on_connect_do;
	325	foreach my $sql_maker_opt (keys %sql_maker_opts) {
	326	$self->schema->storage->sql_maker->$sql_maker_opt(
	327	$sql_maker_opts{$sql_maker_opt}
	328	);
	329	}
	330	}
	331
	332	# XXX end of compatibility block referenced above
	333
ad91060a	334	no strict 'refs';
ad91060a	335	foreach my $moniker ($self->schema->sources) {
0b2a7108	336	my $classname = "${class}::$moniker";
7db6da78	337	*{"${classname}::ACCEPT_CONTEXT"} = sub {
ad91060a	338	shift;
c12b7310	339	shift->model($model_name)->resultset($moniker);
ad91060a	340	}
	341	}
	342
	343	return $self;
	344	}
	345
ad91060a	346	sub clone { shift->composed_schema->clone(@_); }
ad91060a	347
ad91060a	348	sub connect { shift->composed_schema->connect(@_); }
ad91060a	349
b8427e0b	350	sub storage { shift->schema->storage(@_); }
b8427e0b	351
ad91060a	352	=head1 SEE ALSO
ad91060a	353
7b39f3f0	354	General Catalyst Stuff:
	355
	356	L<Catalyst::Manual>, L<Catalyst::Test>, L<Catalyst::Request>,
	357	L<Catalyst::Response>, L<Catalyst::Helper>, L<Catalyst>,
	358
	359	Stuff related to DBIC and this Model style:
	360
	361	L<DBIx::Class>, L<DBIx::Class::Schema>,
	362	L<DBIx::Class::Schema::Loader>, L<Catalyst::Helper::Model::DBIC::Schema>,
1aeb6e1e	363	L<Catalyst::Helper::Model::DBIC::SchemaLoader>
ad91060a	364
	365	=head1 AUTHOR
	366
	367	Brandon L Black, C<blblack@gmail.com>
	368
	369	=head1 COPYRIGHT
	370
	371	This program is free software, you can redistribute it and/or modify it
	372	under the same terms as Perl itself.
	373
	374	=cut
	375
	376	1;