[gitmo/Mouse.git] / lib / Mouse.pm

#!/usr/bin/env perl
package Mouse;
use strict;
use warnings;

our $VERSION = '0.07';
use 5.006;

use Sub::Exporter;
use Carp 'confess';
use Scalar::Util 'blessed';

use Mouse::Meta::Attribute;
use Mouse::Meta::Class;
use Mouse::Object;
use Mouse::TypeRegistry;

do {
    my $CALLER;

    my %exports = (
        meta => sub {
            my $meta = Mouse::Meta::Class->initialize($CALLER);
            return sub { $meta };
        },

        extends => sub {
            my $caller = $CALLER;
            return sub {
                $caller->meta->superclasses(@_);
            };
        },

        has => sub {
            my $caller = $CALLER;

            return sub {
                my $meta = $caller->meta;

                my $names = shift;
                $names = [$names] if !ref($names);

                for my $name (@$names) {
                    if ($name =~ s/^\+//) {
                        Mouse::Meta::Attribute->clone_parent($meta, $name, @_);
                    }
                    else {
                        Mouse::Meta::Attribute->create($meta, $name, @_);
                    }
                }
            };
        },

        confess => sub {
            return \&confess;
        },

        blessed => sub {
            return \&blessed;
        },

        before => sub {
            my $caller = $CALLER;

            return sub {
                my $code = pop;
                my $class = $caller->meta;

                for (@_) {
                    $class->add_before_method_modifier($_ => $code);
                }
            };
        },

        after => sub {
            my $caller = $CALLER;

            return sub {
                my $code = pop;
                my $class = $caller->meta;

                for (@_) {
                    $class->add_after_method_modifier($_ => $code);
                }
            };
        },

        around => sub {
            my $caller = $CALLER;

            return sub {
                my $code = pop;
                my $class = $caller->meta;

                for (@_) {
                    $class->add_around_method_modifier($_ => $code);
                }
            };
        },

        with => sub {
            my $caller = $CALLER;

            return sub {
                my $role  = shift;
                my $class = $caller->meta;

                confess "Mouse::Role only supports 'with' on individual roles at a time" if @_;

                Mouse::load_class($role);
                $role->meta->apply($class);
            };
        },
    );

    my $exporter = Sub::Exporter::build_exporter({
        exports => \%exports,
        groups  => { default => [':all'] },
    });

    sub import {
        $CALLER = caller;

        strict->import;
        warnings->import;

        my $meta = Mouse::Meta::Class->initialize($CALLER);
        $meta->superclasses('Mouse::Object')
            unless $meta->superclasses;

        goto $exporter;
    }

    sub unimport {
        my $caller = caller;

        no strict 'refs';
        for my $keyword (keys %exports) {
            next if $keyword eq 'meta'; # we don't delete this one
            delete ${ $caller . '::' }{$keyword};
        }
    }
};

sub load_class {
    my $class = shift;

    if (ref($class) || !defined($class) || !length($class)) {
        my $display = defined($class) ? $class : 'undef';
        confess "Invalid class name ($display)";
    }

    return 1 if is_class_loaded($class);

    (my $file = "$class.pm") =~ s{::}{/}g;

    eval { CORE::require($file) };
    confess "Could not load class ($class) because : $@" if $@;

    return 1;
}

sub is_class_loaded {
    my $class = shift;

    return 0 if ref($class) || !defined($class) || !length($class);

    # walk the symbol table tree to avoid autovififying
    # \*{${main::}{"Foo::"}} == \*main::Foo::

    my $pack = \*::;
    foreach my $part (split('::', $class)) {
        return 0 unless exists ${$$pack}{"${part}::"};
        $pack = \*{${$$pack}{"${part}::"}};
    }

    # check for $VERSION or @ISA
    return 1 if exists ${$$pack}{VERSION}
             && defined *{${$$pack}{VERSION}}{SCALAR};
    return 1 if exists ${$$pack}{ISA}
             && defined *{${$$pack}{ISA}}{ARRAY};

    # check for any method
    foreach ( keys %{$$pack} ) {
        next if substr($_, -2, 2) eq '::';
        return 1 if defined *{${$$pack}{$_}}{CODE};
    }

    # fail
    return 0;
}

1;

__END__

=head1 NAME

Mouse - Moose minus the antlers

=head1 SYNOPSIS

    package Point;
    use Mouse; # automatically turns on strict and warnings

    has 'x' => (is => 'rw', isa => 'Int');
    has 'y' => (is => 'rw', isa => 'Int');

    sub clear {
        my $self = shift;
        $self->x(0);
        $self->y(0);
    }

    package Point3D;
    use Mouse;

    extends 'Point';

    has 'z' => (is => 'rw', isa => 'Int');

    after 'clear' => sub {
        my $self = shift;
        $self->z(0);
    };

=head1 DESCRIPTION

L<Moose> is wonderful.

Unfortunately, it's a little slow. Though significant progress has been made
over the years, the compile time penalty is a non-starter for some
applications.

Mouse aims to alleviate this by providing a subset of Moose's
functionality, faster. In particular, L<Moose/has> is missing only a few
expert-level features.

=head2 MOOSE COMPAT

Compatibility with Moose has been the utmost concern. Fewer than 1% of the
tests fail when run against Moose instead of Mouse. Mouse code coverage is also
over 97%. Even the error messages are taken from Moose. The Mouse code just
runs the test suite 3x-4x faster.

The idea is that, if you need the extra power, you should be able to run
C<s/Mouse/Moose/g> on your codebase and have nothing break. To that end,
nothingmuch has written L<Squirrel> (part of this distribution) which will act
as Mouse unless Moose is loaded, in which case it will act as Moose.

Mouse also has the blessings of Moose's author, stevan.

=head2 MISSING FEATURES

=head3 Roles

We're working on fixing this one! stevan has suggested an implementation
strategy. Mouse currently ignores methods, so that needs to be fixed next.
Roles that consist entirely of attributes may be usable in this very version.

=head3 Complex types

User-defined type constraints and parameterized types may be implemented. Type
coercions probably not (patches welcome).

=head3 Bootstrapped meta world

Very handy for extensions to the MOP. Not pressing, but would be nice to have.

=head3 Modification of attribute metaclass

When you declare an attribute with L</has>, you get the inlined accessors
installed immediately. Modifying the attribute metaclass, even if possible,
does nothing.

=head3 Lots more..

MouseX?

=head1 KEYWORDS

=head2 meta -> Mouse::Meta::Class

Returns this class' metaclass instance.

=head2 extends superclasses

Sets this class' superclasses.

=head2 before (method|methods) => Code

Installs a "before" method modifier. See L<Moose/before> or
L<Class::Method::Modifiers/before>.

=head2 after (method|methods) => Code

Installs an "after" method modifier. See L<Moose/after> or
L<Class::Method::Modifiers/after>.

=head2 around (method|methods) => Code

Installs an "around" method modifier. See L<Moose/around> or
L<Class::Method::Modifiers/around>.

=head2 has (name|names) => parameters

Adds an attribute (or if passed an arrayref of names, multiple attributes) to
this class. Options:

=over 4

=item is => ro|rw

If specified, inlines a read-only/read-write accessor with the same name as
the attribute.

=item isa => TypeConstraint

Provides basic type checking in the constructor and accessor. Basic types such
as C<Int>, C<ArrayRef>, C<Defined> are supported. Any unknown type is taken to
be a class check (e.g. isa => 'DateTime' would accept only L<DateTime>
objects).

=item required => 0|1

Whether this attribute is required to have a value. If the attribute is lazy or
has a builder, then providing a value for the attribute in the constructor is
optional.

=item init_arg => Str

Allows you to use a different key name in the constructor.

=item default => Value | CodeRef

Sets the default value of the attribute. If the default is a coderef, it will
be invoked to get the default value. Due to quirks of Perl, any bare reference
is forbidden, you must wrap the reference in a coderef. Otherwise, all
instances will share the same reference.

=item lazy => 0|1

If specified, the default is calculated on demand instead of in the
constructor.

=item predicate => Str

Lets you specify a method name for installing a predicate method, which checks
that the attribute has a value. It will not invoke a lazy default or builder
method.

=item clearer => Str

Lets you specify a method name for installing a clearer method, which clears
the attribute's value from the instance. On the next read, lazy or builder will
be invoked.

=item handles => HashRef|ArrayRef

Lets you specify methods to delegate to the attribute. ArrayRef forwards the
given method names to method calls on the attribute. HashRef maps local method
names to remote method names called on the attribute. Other forms of
L</handles>, such as regular expression and coderef, are not yet supported.

=item weak_ref => 0|1

Lets you automatically weaken any reference stored in the attribute.

=item trigger => CodeRef

Any time the attribute's value is set (either through the accessor or the constructor), the trigger is called on it. The trigger receives as arguments the instance, the new value, and the attribute instance.

Mouse 0.05 supported more complex triggers, but this behavior is now deprecated.

=item builder => Str

Defines a method name to be called to provide the default value of the
attribute. C<< builder => 'build_foo' >> is mostly equivalent to
C<< default => sub { $_[0]->build_foo } >>.

=item auto_deref => 0|1

Allows you to automatically dereference ArrayRef and HashRef attributes in list
context. In scalar context, the reference is returned (NOT the list length or
bucket status). You must specify an appropriate type constraint to use
auto_deref.

=back

=head2 confess error -> BOOM

L<Carp/confess> for your convenience.

=head2 blessed value -> ClassName | undef

L<Scalar::Util/blessed> for your convenience.

=head1 MISC

=head2 import

Importing Mouse will default your class' superclass list to L<Mouse::Object>.
You may use L</extends> to replace the superclass list.

=head2 unimport

Please unimport Mouse (C<no Mouse>) so that if someone calls one of the
keywords (such as L</extends>) it will break loudly instead breaking subtly.

=head1 FUNCTIONS

=head2 load_class Class::Name

This will load a given C<Class::Name> (or die if it's not loadable).
This function can be used in place of tricks like
C<eval "use $module"> or using C<require>.

=head2 is_class_loaded Class::Name -> Bool

Returns whether this class is actually loaded or not. It uses a heuristic which
involves checking for the existence of C<$VERSION>, C<@ISA>, and any
locally-defined method.

=head1 AUTHOR

Shawn M Moore, C<< <sartak at gmail.com> >>

with plenty of code borrowed from L<Class::MOP> and L<Moose>

=head1 BUGS

No known bugs.

Please report any bugs through RT: email
C<bug-mouse at rt.cpan.org>, or browse
L<http://rt.cpan.org/NoAuth/ReportBug.html?Queue=Mouse>.

=head1 COPYRIGHT AND LICENSE

Copyright 2008 Shawn M Moore.

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

=cut
Commit	Line	Data
9baf5d6b	1	#!/usr/bin/env perl
c3398f5b	2	package Mouse;
	3	use strict;
	4	use warnings;
	5
5c557f4f	6	our $VERSION = '0.07';
126765f0	7	use 5.006;
c3398f5b	8
	9	use Sub::Exporter;
	10	use Carp 'confess';
	11	use Scalar::Util 'blessed';
	12
306290e8	13	use Mouse::Meta::Attribute;
306290e8	14	use Mouse::Meta::Class;
c3398f5b	15	use Mouse::Object;
d60c78b9	16	use Mouse::TypeRegistry;
c3398f5b	17
	18	do {
	19	my $CALLER;
	20
	21	my %exports = (
	22	meta => sub {
306290e8	23	my $meta = Mouse::Meta::Class->initialize($CALLER);
c3398f5b	24	return sub { $meta };
	25	},
	26
	27	extends => sub {
	28	my $caller = $CALLER;
	29	return sub {
	30	$caller->meta->superclasses(@_);
	31	};
	32	},
	33
	34	has => sub {
724c77c0	35	my $caller = $CALLER;
724c77c0	36
c3398f5b	37	return sub {
724c77c0	38	my $meta = $caller->meta;
724c77c0	39
c3398f5b	40	my $names = shift;
	41	$names = [$names] if !ref($names);
	42
	43	for my $name (@$names) {
1bfebf5f	44	if ($name =~ s/^\+//) {
724c77c0	45	Mouse::Meta::Attribute->clone_parent($meta, $name, @_);
1bfebf5f	46	}
1bfebf5f	47	else {
724c77c0	48	Mouse::Meta::Attribute->create($meta, $name, @_);
1bfebf5f	49	}
c3398f5b	50	}
	51	};
	52	},
	53
	54	confess => sub {
b17094ce	55	return \&confess;
c3398f5b	56	},
	57
	58	blessed => sub {
b17094ce	59	return \&blessed;
c3398f5b	60	},
8517d2ff	61
8517d2ff	62	before => sub {
50dc6ee5	63	my $caller = $CALLER;
	64
	65	return sub {
	66	my $code = pop;
	67	my $class = $caller->meta;
	68
	69	for (@_) {
	70	$class->add_before_method_modifier($_ => $code);
	71	}
	72	};
8517d2ff	73	},
	74
	75	after => sub {
50dc6ee5	76	my $caller = $CALLER;
	77
	78	return sub {
	79	my $code = pop;
	80	my $class = $caller->meta;
	81
	82	for (@_) {
	83	$class->add_after_method_modifier($_ => $code);
	84	}
	85	};
8517d2ff	86	},
	87
	88	around => sub {
50dc6ee5	89	my $caller = $CALLER;
	90
	91	return sub {
	92	my $code = pop;
	93	my $class = $caller->meta;
	94
	95	for (@_) {
	96	$class->add_around_method_modifier($_ => $code);
	97	}
	98	};
8517d2ff	99	},
3ab0ee8f	100
	101	with => sub {
	102	my $caller = $CALLER;
	103
	104	return sub {
	105	my $role = shift;
	106	my $class = $caller->meta;
	107
e5f31f1f	108	confess "Mouse::Role only supports 'with' on individual roles at a time" if @_;
e7dff5dc	109
3ab0ee8f	110	Mouse::load_class($role);
da0c885d	111	$role->meta->apply($class);
3ab0ee8f	112	};
3ab0ee8f	113	},
c3398f5b	114	);
	115
	116	my $exporter = Sub::Exporter::build_exporter({
	117	exports => \%exports,
	118	groups => { default => [':all'] },
	119	});
	120
	121	sub import {
	122	$CALLER = caller;
	123
	124	strict->import;
	125	warnings->import;
	126
306290e8	127	my $meta = Mouse::Meta::Class->initialize($CALLER);
ca73a208	128	$meta->superclasses('Mouse::Object')
ca73a208	129	unless $meta->superclasses;
c3398f5b	130
	131	goto $exporter;
	132	}
	133
	134	sub unimport {
	135	my $caller = caller;
	136
	137	no strict 'refs';
	138	for my $keyword (keys %exports) {
	139	next if $keyword eq 'meta'; # we don't delete this one
	140	delete ${ $caller . '::' }{$keyword};
	141	}
	142	}
	143	};
	144
	145	sub load_class {
	146	my $class = shift;
262801ef	147
9694b71b	148	if (ref($class) \|\| !defined($class) \|\| !length($class)) {
	149	my $display = defined($class) ? $class : 'undef';
	150	confess "Invalid class name ($display)";
	151	}
c3398f5b	152
2a674d23	153	return 1 if is_class_loaded($class);
2a674d23	154
c3398f5b	155	(my $file = "$class.pm") =~ s{::}{/}g;
	156
	157	eval { CORE::require($file) };
2a674d23	158	confess "Could not load class ($class) because : $@" if $@;
c3398f5b	159
	160	return 1;
	161	}
	162
2a674d23	163	sub is_class_loaded {
	164	my $class = shift;
	165
7ecc2123	166	return 0 if ref($class) \|\| !defined($class) \|\| !length($class);
7ecc2123	167
bf134049	168	# walk the symbol table tree to avoid autovififying
	169	# \{${main::}{"Foo::"}} == \main::Foo::
	170
	171	my $pack = \*::;
	172	foreach my $part (split('::', $class)) {
	173	return 0 unless exists ${$$pack}{"${part}::"};
	174	$pack = \*{${$$pack}{"${part}::"}};
2a674d23	175	}
bf134049	176
	177	# check for $VERSION or @ISA
	178	return 1 if exists ${$$pack}{VERSION}
	179	&& defined *{${$$pack}{VERSION}}{SCALAR};
	180	return 1 if exists ${$$pack}{ISA}
	181	&& defined *{${$$pack}{ISA}}{ARRAY};
	182
	183	# check for any method
	184	foreach ( keys %{$$pack} ) {
	185	next if substr($_, -2, 2) eq '::';
	186	return 1 if defined *{${$$pack}{$_}}{CODE};
	187	}
	188
	189	# fail
2a674d23	190	return 0;
	191	}
	192
c3398f5b	193	1;
	194
	195	__END__
	196
	197	=head1 NAME
	198
0fff36e6	199	Mouse - Moose minus the antlers
c3398f5b	200
c3398f5b	201	=head1 SYNOPSIS
	202
	203	package Point;
6caea456	204	use Mouse; # automatically turns on strict and warnings
	205
	206	has 'x' => (is => 'rw', isa => 'Int');
	207	has 'y' => (is => 'rw', isa => 'Int');
	208
	209	sub clear {
	210	my $self = shift;
	211	$self->x(0);
	212	$self->y(0);
	213	}
	214
	215	package Point3D;
c3398f5b	216	use Mouse;
c3398f5b	217
6caea456	218	extends 'Point';
c3398f5b	219
6caea456	220	has 'z' => (is => 'rw', isa => 'Int');
6caea456	221
8517d2ff	222	after 'clear' => sub {
	223	my $self = shift;
	224	$self->z(0);
	225	};
c3398f5b	226
	227	=head1 DESCRIPTION
	228
0fff36e6	229	L<Moose> is wonderful.
c3398f5b	230
0fff36e6	231	Unfortunately, it's a little slow. Though significant progress has been made
	232	over the years, the compile time penalty is a non-starter for some
	233	applications.
	234
	235	Mouse aims to alleviate this by providing a subset of Moose's
	236	functionality, faster. In particular, L<Moose/has> is missing only a few
	237	expert-level features.
	238
	239	=head2 MOOSE COMPAT
	240
	241	Compatibility with Moose has been the utmost concern. Fewer than 1% of the
	242	tests fail when run against Moose instead of Mouse. Mouse code coverage is also
faa5cb70	243	over 97%. Even the error messages are taken from Moose. The Mouse code just
8e1a28a8	244	runs the test suite 3x-4x faster.
0fff36e6	245
0fff36e6	246	The idea is that, if you need the extra power, you should be able to run
8e1a28a8	247	C<s/Mouse/Moose/g> on your codebase and have nothing break. To that end,
	248	nothingmuch has written L<Squirrel> (part of this distribution) which will act
	249	as Mouse unless Moose is loaded, in which case it will act as Moose.
0fff36e6	250
	251	Mouse also has the blessings of Moose's author, stevan.
	252
	253	=head2 MISSING FEATURES
	254
0fff36e6	255	=head3 Roles
0fff36e6	256
faa5cb70	257	We're working on fixing this one! stevan has suggested an implementation
	258	strategy. Mouse currently ignores methods, so that needs to be fixed next.
	259	Roles that consist entirely of attributes may be usable in this very version.
0fff36e6	260
	261	=head3 Complex types
	262
	263	User-defined type constraints and parameterized types may be implemented. Type
	264	coercions probably not (patches welcome).
	265
	266	=head3 Bootstrapped meta world
	267
	268	Very handy for extensions to the MOP. Not pressing, but would be nice to have.
	269
	270	=head3 Modification of attribute metaclass
	271
	272	When you declare an attribute with L</has>, you get the inlined accessors
	273	installed immediately. Modifying the attribute metaclass, even if possible,
	274	does nothing.
	275
	276	=head3 Lots more..
	277
	278	MouseX?
	279
	280	=head1 KEYWORDS
c3398f5b	281
306290e8	282	=head2 meta -> Mouse::Meta::Class
c3398f5b	283
	284	Returns this class' metaclass instance.
	285
	286	=head2 extends superclasses
	287
	288	Sets this class' superclasses.
	289
b7a74822	290	=head2 before (method\|methods) => Code
	291
	292	Installs a "before" method modifier. See L<Moose/before> or
	293	L<Class::Method::Modifiers/before>.
	294
	295	=head2 after (method\|methods) => Code
	296
	297	Installs an "after" method modifier. See L<Moose/after> or
	298	L<Class::Method::Modifiers/after>.
	299
	300	=head2 around (method\|methods) => Code
	301
	302	Installs an "around" method modifier. See L<Moose/around> or
	303	L<Class::Method::Modifiers/around>.
	304
c3398f5b	305	=head2 has (name\|names) => parameters
	306
	307	Adds an attribute (or if passed an arrayref of names, multiple attributes) to
0fff36e6	308	this class. Options:
	309
	310	=over 4
	311
	312	=item is => ro\|rw
	313
	314	If specified, inlines a read-only/read-write accessor with the same name as
	315	the attribute.
	316
	317	=item isa => TypeConstraint
	318
	319	Provides basic type checking in the constructor and accessor. Basic types such
	320	as C<Int>, C<ArrayRef>, C<Defined> are supported. Any unknown type is taken to
	321	be a class check (e.g. isa => 'DateTime' would accept only L<DateTime>
	322	objects).
	323
	324	=item required => 0\|1
	325
	326	Whether this attribute is required to have a value. If the attribute is lazy or
	327	has a builder, then providing a value for the attribute in the constructor is
	328	optional.
	329
	330	=item init_arg => Str
	331
	332	Allows you to use a different key name in the constructor.
	333
	334	=item default => Value \| CodeRef
	335
	336	Sets the default value of the attribute. If the default is a coderef, it will
	337	be invoked to get the default value. Due to quirks of Perl, any bare reference
	338	is forbidden, you must wrap the reference in a coderef. Otherwise, all
	339	instances will share the same reference.
	340
	341	=item lazy => 0\|1
	342
	343	If specified, the default is calculated on demand instead of in the
	344	constructor.
	345
	346	=item predicate => Str
	347
	348	Lets you specify a method name for installing a predicate method, which checks
	349	that the attribute has a value. It will not invoke a lazy default or builder
	350	method.
	351
	352	=item clearer => Str
	353
	354	Lets you specify a method name for installing a clearer method, which clears
	355	the attribute's value from the instance. On the next read, lazy or builder will
	356	be invoked.
	357
	358	=item handles => HashRef\|ArrayRef
	359
	360	Lets you specify methods to delegate to the attribute. ArrayRef forwards the
	361	given method names to method calls on the attribute. HashRef maps local method
	362	names to remote method names called on the attribute. Other forms of
	363	L</handles>, such as regular expression and coderef, are not yet supported.
	364
	365	=item weak_ref => 0\|1
	366
	367	Lets you automatically weaken any reference stored in the attribute.
	368
844fa049	369	=item trigger => CodeRef
	370
	371	Any time the attribute's value is set (either through the accessor or the constructor), the trigger is called on it. The trigger receives as arguments the instance, the new value, and the attribute instance.
	372
	373	Mouse 0.05 supported more complex triggers, but this behavior is now deprecated.
0fff36e6	374
	375	=item builder => Str
	376
	377	Defines a method name to be called to provide the default value of the
	378	attribute. C<< builder => 'build_foo' >> is mostly equivalent to
	379	C<< default => sub { $_[0]->build_foo } >>.
	380
	381	=item auto_deref => 0\|1
	382
	383	Allows you to automatically dereference ArrayRef and HashRef attributes in list
	384	context. In scalar context, the reference is returned (NOT the list length or
	385	bucket status). You must specify an appropriate type constraint to use
	386	auto_deref.
	387
	388	=back
c3398f5b	389
	390	=head2 confess error -> BOOM
	391
	392	L<Carp/confess> for your convenience.
	393
	394	=head2 blessed value -> ClassName \| undef
	395
	396	L<Scalar::Util/blessed> for your convenience.
	397
	398	=head1 MISC
	399
	400	=head2 import
	401
6caea456	402	Importing Mouse will default your class' superclass list to L<Mouse::Object>.
c3398f5b	403	You may use L</extends> to replace the superclass list.
	404
	405	=head2 unimport
	406
0fff36e6	407	Please unimport Mouse (C<no Mouse>) so that if someone calls one of the
0fff36e6	408	keywords (such as L</extends>) it will break loudly instead breaking subtly.
c3398f5b	409
	410	=head1 FUNCTIONS
	411
	412	=head2 load_class Class::Name
	413
6caea456	414	This will load a given C<Class::Name> (or die if it's not loadable).
c3398f5b	415	This function can be used in place of tricks like
	416	C<eval "use $module"> or using C<require>.
	417
262801ef	418	=head2 is_class_loaded Class::Name -> Bool
	419
	420	Returns whether this class is actually loaded or not. It uses a heuristic which
	421	involves checking for the existence of C<$VERSION>, C<@ISA>, and any
	422	locally-defined method.
	423
c3398f5b	424	=head1 AUTHOR
	425
	426	Shawn M Moore, C<< <sartak at gmail.com> >>
	427
0fff36e6	428	with plenty of code borrowed from L<Class::MOP> and L<Moose>
0fff36e6	429
c3398f5b	430	=head1 BUGS
	431
	432	No known bugs.
	433
	434	Please report any bugs through RT: email
	435	C<bug-mouse at rt.cpan.org>, or browse
	436	L<http://rt.cpan.org/NoAuth/ReportBug.html?Queue=Mouse>.
	437
	438	=head1 COPYRIGHT AND LICENSE
	439
	440	Copyright 2008 Shawn M Moore.
	441
	442	This program is free software; you can redistribute it and/or modify it
	443	under the same terms as Perl itself.
	444
	445	=cut
	446