4 use Mouse::Exporter; # enables strict and warnings
6 our $VERSION = '0.37_02';
11 use Mouse::Util qw(load_class is_class_loaded get_code_package not_supported);
13 use Mouse::Meta::Module;
14 use Mouse::Meta::Class;
15 use Mouse::Meta::Role;
16 use Mouse::Meta::Attribute;
18 use Mouse::Util::TypeConstraints ();
20 Mouse::Exporter->setup_import_methods(
28 \&Scalar::Util::blessed,
33 sub extends { Mouse::Meta::Class->initialize(scalar caller)->superclasses(@_) }
36 my $meta = Mouse::Meta::Class->initialize(scalar caller);
39 $meta->add_attribute($_ => @_) for ref($name) ? @{$name} : $name;
43 my $meta = Mouse::Meta::Class->initialize(scalar caller);
48 $meta->add_before_method_modifier($_ => $code);
53 my $meta = Mouse::Meta::Class->initialize(scalar caller);
58 $meta->add_after_method_modifier($_ => $code);
63 my $meta = Mouse::Meta::Class->initialize(scalar caller);
68 $meta->add_around_method_modifier($_ => $code);
73 Mouse::Util::apply_all_roles(scalar(caller), @_);
81 # This check avoids a recursion loop - see
82 # t/100_bugs/020_super_recursion.t
83 return if defined $SUPER_PACKAGE && $SUPER_PACKAGE ne caller();
84 return if !defined $SUPER_BODY;
85 $SUPER_BODY->(@SUPER_ARGS);
89 # my($name, $method) = @_;
90 Mouse::Meta::Class->initialize(scalar caller)->add_override_method_modifier(@_);
98 if ( my $body = $INNER_BODY{$pkg} ) {
99 my $args = $INNER_ARGS{$pkg};
100 local $INNER_ARGS{$pkg};
101 local $INNER_BODY{$pkg};
102 return $body->(@{$args});
110 #my($name, $method) = @_;
111 Mouse::Meta::Class->initialize(scalar caller)->add_augment_method_modifier(@_);
118 my $class = $args{for_class}
119 or confess("Cannot call init_meta without specifying a for_class");
120 my $base_class = $args{base_class} || 'Mouse::Object';
121 my $metaclass = $args{metaclass} || 'Mouse::Meta::Class';
123 # make a subtype for each Mouse class
124 Mouse::Util::TypeConstraints::class_type($class)
125 unless Mouse::Util::TypeConstraints::find_type_constraint($class);
127 my $meta = $metaclass->initialize($class);
129 $meta->add_method(meta => sub{
130 return $metaclass->initialize(ref($_[0]) || $_[0]);
133 $meta->superclasses($base_class)
134 unless $meta->superclasses;
146 Mouse - Moose minus the antlers
151 use Mouse; # automatically turns on strict and warnings
153 has 'x' => (is => 'rw', isa => 'Int');
154 has 'y' => (is => 'rw', isa => 'Int');
167 has 'z' => (is => 'rw', isa => 'Int');
169 after 'clear' => sub {
176 L<Moose> is wonderful. B<Use Moose instead of Mouse.>
178 Unfortunately, Moose has a compile-time penalty. Though significant progress
179 has been made over the years, the compile time penalty is a non-starter for
180 some very specific applications. If you are writing a command-line application
181 or CGI script where startup time is essential, you may not be able to use
182 Moose. We recommend that you instead use L<HTTP::Engine> and FastCGI for the
185 Mouse aims to alleviate this by providing a subset of Moose's functionality,
188 We're also going as light on dependencies as possible.
189 L<Class::Method::Modifiers::Fast> or L<Class::Method::Modifiers> is required
190 if you want support for L</before>, L</after>, and L</around>.
192 =head2 MOOSE COMPATIBILITY
194 Compatibility with Moose has been the utmost concern. Fewer than 1% of the
195 tests fail when run against Moose instead of Mouse. Mouse code coverage is also
196 over 96%. Even the error messages are taken from Moose. The Mouse code just
197 runs the test suite 4x faster.
199 The idea is that, if you need the extra power, you should be able to run
200 C<s/Mouse/Moose/g> on your codebase and have nothing break. To that end,
201 we have written L<Any::Moose> which will act as Mouse unless Moose is loaded,
202 in which case it will act as Moose. Since Mouse is a little sloppier than
203 Moose, if you run into weird errors, it would be worth running:
205 ANY_MOOSE=Moose perl your-script.pl
207 to see if the bug is caused by Mouse. Moose's diagnostics and validation are
212 Please don't copy MooseX code to MouseX. If you need extensions, you really
213 should upgrade to Moose. We don't need two parallel sets of extensions!
215 If you really must write a Mouse extension, please contact the Moose mailing
216 list or #moose on IRC beforehand.
220 =head2 C<< $object->meta -> Mouse::Meta::Class >>
222 Returns this class' metaclass instance.
224 =head2 C<< extends superclasses >>
226 Sets this class' superclasses.
228 =head2 C<< before (method|methods) => CodeRef >>
230 Installs a "before" method modifier. See L<Moose/before> or
231 L<Class::Method::Modifiers/before>.
233 Use of this feature requires L<Class::Method::Modifiers>!
235 =head2 C<< after (method|methods) => CodeRef >>
237 Installs an "after" method modifier. See L<Moose/after> or
238 L<Class::Method::Modifiers/after>.
240 Use of this feature requires L<Class::Method::Modifiers>!
242 =head2 C<< around (method|methods) => CodeRef >>
244 Installs an "around" method modifier. See L<Moose/around> or
245 L<Class::Method::Modifiers/around>.
247 Use of this feature requires L<Class::Method::Modifiers>!
249 =head2 C<< has (name|names) => parameters >>
251 Adds an attribute (or if passed an arrayref of names, multiple attributes) to
256 =item C<< is => ro|rw|bare >>
258 If specified, inlines a read-only/read-write accessor with the same name as
261 =item C<< isa => TypeConstraint >>
263 Provides type checking in the constructor and accessor. The following types are
264 supported. Any unknown type is taken to be a class check
265 (e.g. C<< isa => 'DateTime' >> would accept only L<DateTime> objects).
267 Any Item Bool Undef Defined Value Num Int Str ClassName
268 Ref ScalarRef ArrayRef HashRef CodeRef RegexpRef GlobRef
271 For more documentation on type constraints, see L<Mouse::Util::TypeConstraints>.
274 =item C<< required => Bool >>
276 Whether this attribute is required to have a value. If the attribute is lazy or
277 has a builder, then providing a value for the attribute in the constructor is
280 =item C<< init_arg => Str | Undef >>
282 Allows you to use a different key name in the constructor. If undef, the
283 attribute can't be passed to the constructor.
285 =item C<< default => Value | CodeRef >>
287 Sets the default value of the attribute. If the default is a coderef, it will
288 be invoked to get the default value. Due to quirks of Perl, any bare reference
289 is forbidden, you must wrap the reference in a coderef. Otherwise, all
290 instances will share the same reference.
292 =item C<< lazy => Bool >>
294 If specified, the default is calculated on demand instead of in the
297 =item C<< predicate => Str >>
299 Lets you specify a method name for installing a predicate method, which checks
300 that the attribute has a value. It will not invoke a lazy default or builder
303 =item C<< clearer => Str >>
305 Lets you specify a method name for installing a clearer method, which clears
306 the attribute's value from the instance. On the next read, lazy or builder will
309 =item C<< handles => HashRef|ArrayRef >>
311 Lets you specify methods to delegate to the attribute. ArrayRef forwards the
312 given method names to method calls on the attribute. HashRef maps local method
313 names to remote method names called on the attribute. Other forms of
314 L</handles>, such as regular expression and coderef, are not yet supported.
316 =item C<< weak_ref => Bool >>
318 Lets you automatically weaken any reference stored in the attribute.
320 Use of this feature requires L<Scalar::Util>!
322 =item C<< trigger => CodeRef >>
324 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.
326 =item C<< builder => Str >>
328 Defines a method name to be called to provide the default value of the
329 attribute. C<< builder => 'build_foo' >> is mostly equivalent to
330 C<< default => sub { $_[0]->build_foo } >>.
332 =item C<< auto_deref => Bool >>
334 Allows you to automatically dereference ArrayRef and HashRef attributes in list
335 context. In scalar context, the reference is returned (NOT the list length or
336 bucket status). You must specify an appropriate type constraint to use
339 =item C<< lazy_build => Bool >>
341 Automatically define the following options:
346 builder => "_build_$attr",
347 clearer => "clear_$attr",
348 predicate => "has_$attr",
353 =head2 C<< confess(message) -> BOOM >>
355 L<Carp/confess> for your convenience.
357 =head2 C<< blessed(value) -> ClassName | undef >>
359 L<Scalar::Util/blessed> for your convenience.
365 Importing Mouse will default your class' superclass list to L<Mouse::Object>.
366 You may use L</extends> to replace the superclass list.
370 Please unimport Mouse (C<no Mouse>) so that if someone calls one of the
371 keywords (such as L</extends>) it will break loudly instead breaking subtly.
373 =head1 SOURCE CODE ACCESS
375 We have a public git repository:
377 git clone git://jules.scsys.co.uk/gitmo/Mouse.git
391 Shawn M Moore, E<lt>sartak at gmail.comE<gt>
393 Yuval Kogman, E<lt>nothingmuch at woobling.orgE<gt>
401 Goro Fuji (gfx) E<lt>gfuji at cpan.orgE<gt>
403 with plenty of code borrowed from L<Class::MOP> and L<Moose>
407 All complex software has bugs lurking in it, and this module is no exception.
408 Please report any bugs to C<bug-mouse at rt.cpan.org>, or through the web
409 interface at L<http://rt.cpan.org/Public/Dist/Display.html?Name=Mouse>
411 =head1 COPYRIGHT AND LICENSE
413 Copyright 2008-2009 Infinity Interactive, Inc.
415 http://www.iinteractive.com/
417 This program is free software; you can redistribute it and/or modify it
418 under the same terms as Perl itself.