use Mouse::Exporter; # enables strict and warnings
-our $VERSION = '0.40_08';
+our $VERSION = '0.95';
-use Carp qw(confess);
-use Scalar::Util qw(blessed);
+use Carp ();
+use Scalar::Util ();
-use Mouse::Util qw(load_class is_class_loaded get_code_package not_supported);
+use Mouse::Util ();
use Mouse::Meta::Module;
use Mouse::Meta::Class;
$meta->throw_error(q{Usage: has 'name' => ( key => value, ... )})
if @_ % 2; # odd number of arguments
- if(ref $name){ # has [qw(foo bar)] => (...)
- for (@{$name}){
- $meta->add_attribute($_ => @_);
- }
- }
- else{ # has foo => (...)
- $meta->add_attribute($_ => @_);
+ for my $n(ref($name) ? @{$name} : $name){
+ $meta->add_attribute($n => @_);
}
return;
}
sub before {
my $meta = Mouse::Meta::Class->initialize(scalar caller);
-
my $code = pop;
-
- for (@_) {
- $meta->add_before_method_modifier($_ => $code);
+ for my $name($meta->_collect_methods(@_)) {
+ $meta->add_before_method_modifier($name => $code);
}
return;
}
sub after {
my $meta = Mouse::Meta::Class->initialize(scalar caller);
-
my $code = pop;
-
- for (@_) {
- $meta->add_after_method_modifier($_ => $code);
+ for my $name($meta->_collect_methods(@_)) {
+ $meta->add_after_method_modifier($name => $code);
}
return;
}
sub around {
my $meta = Mouse::Meta::Class->initialize(scalar caller);
-
my $code = pop;
-
- for (@_) {
- $meta->add_around_method_modifier($_ => $code);
+ for my $name($meta->_collect_methods(@_)) {
+ $meta->add_around_method_modifier($name => $code);
}
return;
}
my %args = @_;
my $class = $args{for_class}
- or confess("Cannot call init_meta without specifying a for_class");
+ or confess("Cannot call init_meta without specifying a for_class");
my $base_class = $args{base_class} || 'Mouse::Object';
my $metaclass = $args{metaclass} || 'Mouse::Meta::Class';
return $meta;
}
-
1;
__END__
=head1 VERSION
-This document describes Mouse version 0.40_08
+This document describes Mouse version 0.95
=head1 SYNOPSIS
$self->y(0);
}
+
+ __PACKAGE__->meta->make_immutable();
+
package Point3D;
use Mouse;
$self->z(0);
};
+ __PACKAGE__->meta->make_immutable();
+
=head1 DESCRIPTION
-L<Moose> is wonderful. B<Use Moose instead of Mouse.>
+L<Moose|Moose> is a postmodern object system for Perl5. Moose is wonderful.
Unfortunately, Moose has a compile-time penalty. Though significant progress
has been made over the years, the compile time penalty is a non-starter for
some very specific applications. If you are writing a command-line application
or CGI script where startup time is essential, you may not be able to use
-Moose. We recommend that you instead use L<HTTP::Engine> and FastCGI for the
-latter, if possible.
+Moose (we recommend that you instead use persistent Perl executing environments
+like C<FastCGI> for the latter, if possible).
-Mouse aims to alleviate this by providing a subset of Moose's functionality,
-faster.
+Mouse is a Moose compatible object system, which aims to alleviate this penalty
+by providing a subset of Moose's functionality.
We're also going as light on dependencies as possible. Mouse currently has
-B<no dependencies> except for testing modules.
+B<no dependencies> except for building/testing modules. Mouse also works
+without XS, although it has an XS backend to make it much faster.
-=head2 MOOSE COMPATIBILITY
+=head2 Moose Compatibility
-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 96%. Even the error messages are taken from Moose. The Mouse code just
-runs the test suite 4x faster.
+Compatibility with Moose has been the utmost concern. The sugary interface is
+highly compatible with Moose. Even the error messages are taken from Moose.
+The Mouse code just runs its test suite 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,
-we have written L<Any::Moose> which will act as Mouse unless Moose is loaded,
+we have written L<Any::Moose|Any::Moose> which will act as Mouse unless Moose is loaded,
in which case it will act as Moose. Since Mouse is a little sloppier than
Moose, if you run into weird errors, it would be worth running:
ANY_MOOSE=Moose perl your-script.pl
to see if the bug is caused by Mouse. Moose's diagnostics and validation are
-also much better.
+also better.
See also L<Mouse::Spec> for compatibility and incompatibility with Moose.
-=head2 MouseX
+=head2 Mouse Extentions
Please don't copy MooseX code to MouseX. If you need extensions, you really
should upgrade to Moose. We don't need two parallel sets of extensions!
Sets this class' superclasses.
-=head2 C<< before (method|methods) => CodeRef >>
+=head2 C<< before (method|methods|regexp) => CodeRef >>
-Installs a "before" method modifier. See L<Moose/before> or
-L<Class::Method::Modifiers/before>.
+Installs a "before" method modifier. See L<Moose/before>.
-Use of this feature requires L<Class::Method::Modifiers>!
+=head2 C<< after (method|methods|regexp) => CodeRef >>
-=head2 C<< after (method|methods) => CodeRef >>
+Installs an "after" method modifier. See L<Moose/after>.
-Installs an "after" method modifier. See L<Moose/after> or
-L<Class::Method::Modifiers/after>.
+=head2 C<< around (method|methods|regexp) => CodeRef >>
-Use of this feature requires L<Class::Method::Modifiers>!
-
-=head2 C<< around (method|methods) => CodeRef >>
-
-Installs an "around" method modifier. See L<Moose/around> or
-L<Class::Method::Modifiers/around>.
-
-Use of this feature requires L<Class::Method::Modifiers>!
+Installs an "around" method modifier. See L<Moose/around>.
=head2 C<< has (name|names) => parameters >>
=item C<< is => ro|rw|bare >>
-If specified, inlines a read-only/read-write accessor with the same name as
+The I<is> option accepts either I<rw> (for read/write), I<ro> (for read
+only) or I<bare> (for nothing). These will create either a read/write accessor
+or a read-only accessor respectively, using the same name as the C<$name> of
the attribute.
-=item C<< isa => TypeConstraint >>
+If you need more control over how your accessors are named, you can
+use the C<reader>, C<writer> and C<accessor> options, however if you
+use those, you won't need the I<is> option.
+
+=item C<< isa => TypeName | ClassName >>
Provides type checking in the constructor and accessor. The following types are
supported. Any unknown type is taken to be a class check
For more documentation on type constraints, see L<Mouse::Util::TypeConstraints>.
+=item C<< does => RoleName >>
+
+This will accept the name of a role which the value stored in this attribute
+is expected to have consumed.
+
+=item C<< coerce => Bool >>
+
+This will attempt to use coercion with the supplied type constraint to change
+the value passed into any accessors or constructors. You B<must> have supplied
+a type constraint in order for this to work. See L<Moose::Cookbook::Basics::Recipe5>
+for an example.
=item C<< required => Bool >>
the attribute's value from the instance. On the next read, lazy or builder will
be invoked.
-=item C<< handles => HashRef|ArrayRef >>
+=item C<< handles => HashRef|ArrayRef|Regexp >>
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.
+L</handles>, such as RoleName and CodeRef, are not yet supported.
=item C<< weak_ref => Bool >>
=item C<< 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.
+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, and the new value.
=item C<< builder => Str >>
=head1 SEE ALSO
+L<Mouse::Role>
+
L<Mouse::Spec>
L<Moose>
+L<Moose::Manual>
+
+L<Moose::Cookbook>
+
L<Class::MOP>
=head1 AUTHORS
=head1 COPYRIGHT AND LICENSE
-Copyright 2008-2009 Infinity Interactive, Inc.
+Copyright (c) 2008-2010 Infinity Interactive, Inc.
http://www.iinteractive.com/
projects / gitmo/Mouse.git / blobdiff