use strict;
use warnings;
-our $VERSION = '0.06';
+our $VERSION = '0.09_03';
use Scalar::Util 'blessed', 'reftype';
use Carp 'confess';
my %exports = (
extends => sub {
my $class = $CALLER;
- return subname 'Moose::extends' => sub {
+ return subname 'Moose::extends' => sub ($;@) {
_load_all_classes(@_);
my $meta = $class->meta;
foreach my $super (@_) {
},
with => sub {
my $class = $CALLER;
- return subname 'Moose::with' => sub {
+ return subname 'Moose::with' => sub ($;@) {
my (@roles) = @_;
_load_all_classes(@roles);
($_->can('meta') && $_->meta->isa('Moose::Meta::Role'))
},
has => sub {
my $class = $CALLER;
- return subname 'Moose::has' => sub {
+ return subname 'Moose::has' => sub ($;%) {
my ($name, %options) = @_;
my $meta = $class->meta;
if ($name =~ /^\+(.*)/) {
},
before => sub {
my $class = $CALLER;
- return subname 'Moose::before' => sub {
+ return subname 'Moose::before' => sub (@&) {
my $code = pop @_;
my $meta = $class->meta;
$meta->add_before_method_modifier($_, $code) for @_;
},
after => sub {
my $class = $CALLER;
- return subname 'Moose::after' => sub {
+ return subname 'Moose::after' => sub (@&) {
my $code = pop @_;
my $meta = $class->meta;
$meta->add_after_method_modifier($_, $code) for @_;
},
around => sub {
my $class = $CALLER;
- return subname 'Moose::around' => sub {
+ return subname 'Moose::around' => sub (@&) {
my $code = pop @_;
my $meta = $class->meta;
$meta->add_around_method_modifier($_, $code) for @_;
},
override => sub {
my $class = $CALLER;
- return subname 'Moose::override' => sub {
+ return subname 'Moose::override' => sub ($&) {
my ($name, $method) = @_;
$class->meta->add_override_method_modifier($name => $method);
};
},
augment => sub {
my $class = $CALLER;
- return subname 'Moose::augment' => sub {
+ return subname 'Moose::augment' => sub (@&) {
my ($name, $method) = @_;
$class->meta->add_augment_method_modifier($name => $method);
};
sub import {
$CALLER = caller();
+
+ strict->import;
+ warnings->import;
# we should never export to main
return if $CALLER eq 'main';
=head1 SYNOPSIS
package Point;
+ use strict;
+ use warnings;
use Moose;
- has 'x' => (isa => 'Int', is => 'rw');
- has 'y' => (isa => 'Int', is => 'rw');
+ has 'x' => (is => 'rw', isa => 'Int');
+ has 'y' => (is => 'rw', isa => 'Int');
sub clear {
my $self = shift;
}
package Point3D;
+ use strict;
+ use warnings;
use Moose;
extends 'Point';
- has 'z' => (isa => 'Int');
+ has 'z' => (is => 'rw', isa => 'Int');
after 'clear' => sub {
my $self = shift;
- $self->{z} = 0;
+ $self->z(0);
};
=head1 CAVEAT
-This is an early release of this module, it still needs
-some fine tuning and B<lots> more documentation. I am adopting
-the I<release early and release often> approach with this module,
-so keep an eye on your favorite CPAN mirror!
+Moose is a rapidly maturing module, and is already being used by
+a number of people. It's test suite is growing larger by the day,
+and the docs should soon follow.
+
+This said, Moose is not yet finished, and should still be considered
+to be evolving. Much of the outer API is stable, but the internals
+are still subject to change (although not without serious thought
+given to it).
+
+For more details, please refer to the L<FUTURE PLANS> section of
+this document.
=head1 DESCRIPTION
Perl 5 objects better, but it also provides the power of metaclass
programming.
-=head2 What does Moose stand for??
+=head2 Can I use this in production? Or is this just an experiment?
-Moose doesn't stand for one thing in particular, however, if you
-want, here are a few of my favorites, feel free to contribute
-more :)
+Moose is I<based> on the prototypes and experiments I did for the Perl 6
+meta-model, however Moose is B<NOT> an experiment/prototype, it is
+for B<real>. I will be deploying Moose into production environments later
+this year, and I have all intentions of using it as my de-facto class
+builderfrom now on.
-=over 4
+=head2 Is Moose just Perl 6 in Perl 5?
-=item Make Other Object Systems Envious
-
-=item Makes Object Orientation So Easy
-
-=item Makes Object Orientation Spiffy- Er (sorry ingy)
-
-=item Most Other Object Systems Emasculate
-
-=item My Overcraft Overfilled (with) Some Eels
-
-=item Moose Often Ovulate Sorta Early
-
-=item Many Overloaded Object Systems Exists
-
-=item Moose Offers Often Super Extensions
-
-=item Meta Object Orientation Syntax Extensions
-
-=back
+No. While Moose is very much inspired by Perl 6, it is not. Instead, it
+is an OO system for Perl 5. I built Moose because I was tired or writing
+the same old boring Perl 5 OO code, and drooling over Perl 6 OO. So
+instead of switching to Ruby, I wrote Moose :)
=head1 BUILDING CLASSES WITH MOOSE
Moose makes every attempt to provide as much convience during class
construction/definition, but still stay out of your way if you want
-it to. Here are some of the features Moose provides:
+it to. Here are a few items to note when building classes with Moose.
Unless specified with C<extends>, any class which uses Moose will
inherit from L<Moose::Object>.
all instance slots, setting defaults where approprtiate and performing any
type constraint checking or coercion.
-For more details, see the ever expanding L<Moose::Cookbook>.
-
=head1 EXPORTED FUNCTIONS
Moose will export a number of functions into the class's namespace, which
replace it. This is important to ensure that classes which do not have
superclasses properly inherit from L<Moose::Object>.
-=item B<with ($role)>
+=item B<with (@roles)>
-This will apply a given C<$role> to the local class. Role support is
-currently very experimental, see L<Moose::Role> for more details.
+This will apply a given set of C<@roles> to the local class. Role support
+is currently under heavy development, see L<Moose::Role> for more details.
=item B<has ($name, %options)>
This will install an attribute of a given C<$name> into the current class.
-The list of C<%options> are the same as those provided by both
-L<Class::MOP::Attribute> and L<Moose::Meta::Attribute>, in addition to a
-few convience ones provided by Moose which are listed below:
+The list of C<%options> are the same as those provided by
+L<Class::MOP::Attribute>, in addition to the list below which are provided
+by Moose (L<Moose::Meta::Attribute> to be more specific):
=over 4
accessor respectively, using the same name as the C<$name> of the attribute.
If you need more control over how your accessors are named, you can use the
-I<reader>, I<writer> and I<accessor> options inherited from L<Moose::Meta::Attribute>.
+I<reader>, I<writer> and I<accessor> options inherited from L<Class::MOP::Attribute>.
=item I<isa =E<gt> $type_name>
This will tell the class to not create this slot until absolutely nessecary.
If an attribute is marked as lazy it B<must> have a default supplied.
+=item I<auto_deref =E<gt> (1|0)>
+
+This tells the accessor whether to automatically de-reference the value returned.
+This is only legal if your C<isa> option is either an C<ArrayRef> or C<HashRef>.
+
=item I<trigger =E<gt> $code>
The trigger option is a CODE reference which will be called after the value of
and can typically be ignored in most cases). You can B<not> have a trigger on
a read-only attribute.
+=item I<handles =E<gt> [ @handles ]>
+
+There is experimental support for attribute delegation using the C<handles>
+option. More docs to come later.
+
=back
=item B<before $name|@names =E<gt> sub { ... }>
=back
+=head1 FUTURE PLANS
+
+Here is just a sampling of the plans we have in store for Moose:
+
+=over 4
+
+=item *
+
+Compiling Moose classes/roles into C<.pmc> files for faster loading and execution.
+
+=item *
+
+Supporting sealed and finalized classes in Moose. This will allow greater control
+of the extensions of frameworks and such.
+
+=back
+
+=head1 MISC.
+
+=head2 What does Moose stand for??
+
+Moose doesn't stand for one thing in particular, however, if you
+want, here are a few of my favorites, feel free to contribute
+more :)
+
+=over 4
+
+=item Make Other Object Systems Envious
+
+=item Makes Object Orientation So Easy
+
+=item Makes Object Orientation Spiffy- Er (sorry ingy)
+
+=item Most Other Object Systems Emasculate
+
+=item Moose Often Ovulate Sorta Early
+
+=item Moose Offers Often Super Extensions
+
+=item Meta Object Orientation Syntax Extensions
+
+=back
+
=head1 CAVEATS
=over 4
projects / gitmo/Moose.git / blobdiff