X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FMoose.pm;h=f9e156dc7e48f2dc614ab5ec46c38943d6752981;hb=b86a4688111e7f7c0ddbc2195a9ce3c1ec877563;hp=88544bb58b97b940027f8f6374a7fb62d3da153d;hpb=e6ab9ca5a4c8fad570cf70bc6722d06e18542331;p=gitmo%2FMoose.git

diff --git a/lib/Moose.pm b/lib/Moose.pm
index 88544bb..f9e156d 100644
--- a/lib/Moose.pm
+++ b/lib/Moose.pm
@@ -1,8 +1,10 @@
 package Moose;
+use strict;
+use warnings;
 
 use 5.008;
 
-our $VERSION   = '0.83';
+our $VERSION   = '0.89_02';
 $VERSION = eval $VERSION;
 our $AUTHORITY = 'cpan:STEVAN';
 
@@ -11,7 +13,7 @@ use Carp         'confess';
 
 use Moose::Exporter;
 
-use Class::MOP 0.87;
+use Class::MOP 0.92_01;
 
 use Moose::Meta::Class;
 use Moose::Meta::TypeConstraint;
@@ -32,12 +34,7 @@ use Moose::Meta::Role::Application::ToInstance;
 use Moose::Util::TypeConstraints;
 use Moose::Util ();
 
-sub _caller_info {
-    my $level = @_ ? ($_[0] + 1) : 2;
-    my %info;
-    @info{qw(package file line)} = caller($level);
-    return \%info;
-}
+use Moose::Meta::Attribute::Native;
 
 sub throw_error {
     # FIXME This
@@ -46,46 +43,42 @@ sub throw_error {
 }
 
 sub extends {
-    my $class = shift;
+    my $meta = shift;
 
     Moose->throw_error("Must derive at least one class") unless @_;
 
     # this checks the metaclass to make sure
     # it is correct, sometimes it can get out
     # of sync when the classes are being built
-    Moose::Meta::Class->initialize($class)->superclasses(@_);
+    $meta->superclasses(@_);
 }
 
 sub with {
-    my $class = shift;
-    Moose::Util::apply_all_roles(Class::MOP::Class->initialize($class), @_);
+    Moose::Util::apply_all_roles(shift, @_);
 }
 
 sub has {
-    my $class = shift;
-    my $name  = shift;
+    my $meta = shift;
+    my $name = shift;
 
     Moose->throw_error('Usage: has \'name\' => ( key => value, ... )')
         if @_ % 2 == 1;
 
-    my %options = ( definition_context => _caller_info(), @_ );
+    my %options = ( definition_context => Moose::Util::_caller_info(), @_ );
     my $attrs = ( ref($name) eq 'ARRAY' ) ? $name : [ ($name) ];
-    Class::MOP::Class->initialize($class)->add_attribute( $_, %options ) for @$attrs;
+    $meta->add_attribute( $_, %options ) for @$attrs;
 }
 
 sub before {
-    my $class = shift;
-    Moose::Util::add_method_modifier($class, 'before', \@_);
+    Moose::Util::add_method_modifier(shift, 'before', \@_);
 }
 
 sub after {
-    my $class = shift;
-    Moose::Util::add_method_modifier($class, 'after', \@_);
+    Moose::Util::add_method_modifier(shift, 'after', \@_);
 }
 
 sub around {
-    my $class = shift;
-    Moose::Util::add_method_modifier($class, 'around', \@_);
+    Moose::Util::add_method_modifier(shift, 'around', \@_);
 }
 
 our $SUPER_PACKAGE;
@@ -100,9 +93,9 @@ sub super {
 }
 
 sub override {
-    my $class = shift;
+    my $meta = shift;
     my ( $name, $method ) = @_;
-    Class::MOP::Class->initialize($class)->add_override_method_modifier( $name => $method );
+    $meta->add_override_method_modifier( $name => $method );
 }
 
 sub inner {
@@ -120,13 +113,13 @@ sub inner {
 }
 
 sub augment {
-    my $class = shift;
+    my $meta = shift;
     my ( $name, $method ) = @_;
-    Class::MOP::Class->initialize($class)->add_augment_method_modifier( $name => $method );
+    $meta->add_augment_method_modifier( $name => $method );
 }
 
 Moose::Exporter->setup_import_methods(
-    with_caller => [
+    with_meta => [
         qw( extends with has before after around override augment)
     ],
     as_is => [
@@ -178,7 +171,7 @@ sub init_meta {
             my $ancestor_meta = Class::MOP::get_metaclass_by_name($ancestor) || next;
 
             my $ancestor_meta_class = ($ancestor_meta->is_immutable
-                ? $ancestor_meta->get_mutable_metaclass_name
+                ? $ancestor_meta->_get_mutable_metaclass_name
                 : ref($ancestor_meta));
 
             # if we have an ancestor metaclass that inherits $metaclass, we use
@@ -462,14 +455,16 @@ This is only legal if your C<isa> option is either C<ArrayRef> or C<HashRef>.
 
 The I<trigger> option is a CODE reference which will be called after
 the value of the attribute is set. The CODE ref will be passed the
-instance itself and the updated value. You B<can> have a trigger on
-a read-only attribute.
+instance itself and the updated value. If the attribute already had a
+value, this will be passed as the third value to the trigger.
+
+You B<can> have a trigger on a read-only attribute.
 
 B<NOTE:> Triggers will only fire when you B<assign> to the attribute,
 either in the constructor, or using the writer. Default and built values will
 B<not> cause the trigger to be fired.
 
-=item I<handles =E<gt> ARRAY | HASH | REGEXP | ROLE | CODE>
+=item I<handles =E<gt> ARRAY | HASH | REGEXP | ROLE | DUCKTYPE | CODE>
 
 The I<handles> option provides Moose classes with automated delegation features.
 This is a pretty complex and powerful option. It accepts many different option
@@ -543,6 +538,18 @@ In this example, the Tree package gets C<parent_node> and C<siblings> methods,
 which delegate to the C<node> and C<children> methods (respectively) of the Tree
 instance stored in the C<parent> slot.
 
+You may also use an array reference to curry arguments to the original method.
+
+  has 'thing' => (
+      ...
+      handles => { set_foo => [ set => 'foo' ] },
+  );
+
+  # $self->set_foo(...) calls $self->thing->set('foo', ...)
+
+The first element of the array reference is the original method name, and the
+rest is a list of curried arguments.
+
 =item C<REGEXP>
 
 The regexp option works very similar to the ARRAY option, except that it builds
@@ -561,6 +568,14 @@ methods of the role and any required methods of the role. It should be noted
 that this does B<not> include any method modifiers or generated attribute
 methods (which is consistent with role composition).
 
+=item C<DUCKTYPE>
+
+With the duck type option, you pass a duck type object whose "interface" then
+becomes the list of methods to handle. The "interface" can be defined as; the
+list of methods passed to C<duck_type> to create a duck type object. For more
+information on C<duck_type> please check
+L<Moose::Util::TypeConstraints>.
+
 =item C<CODE>
 
 This is the option to use when you really want to do something funky. You should
@@ -582,13 +597,8 @@ capabilities of the I<has> keyword: they are the simplest way to extend the MOP,
 but they are still a fairly advanced topic and too much to cover here, see
 L<Moose::Cookbook::Meta::Recipe1> for more information.
 
-The default behavior here is to just load C<$metaclass_name>; however, we also
-have a way to alias to a shorter name. This will first look to see if
-B<Moose::Meta::Attribute::Custom::$metaclass_name> exists. If it does, Moose
-will then check to see if that has the method C<register_implementation>, which
-should return the actual name of the custom attribute metaclass. If there is no
-C<register_implementation> method, it will fall back to using
-B<Moose::Meta::Attribute::Custom::$metaclass_name> as the metaclass name.
+See L<Metaclass and Trait Name Resolution> for details on how a metaclass name
+is resolved to a class name.
 
 =item I<traits =E<gt> [ @role_names ]>
 
@@ -596,8 +606,8 @@ This tells Moose to take the list of C<@role_names> and apply them to the
 attribute meta-object. This is very similar to the I<metaclass> option, but
 allows you to use more than one extension at a time.
 
-See L<TRAIT NAME RESOLUTION> for details on how a trait name is
-resolved to a class name.
+See L<Metaclass and Trait Name Resolution> for details on how a trait name is
+resolved to a role name.
 
 Also see L<Moose::Cookbook::Meta::Recipe3> for a metaclass trait
 example.
@@ -607,7 +617,7 @@ example.
 The value of this key is the name of the method that will be called to
 obtain the value used to initialize the attribute. See the L<builder
 option docs in Class::MOP::Attribute|Class::MOP::Attribute/builder>
- and/or L<Moose::Cookbook::Basics::Recipe9> for more information.
+ and/or L<Moose::Cookbook::Basics::Recipe8> for more information.
 
 =item I<default> => SCALAR | CODE
 
@@ -772,10 +782,10 @@ B<are not> overridden, or removed.
 
 =item B<around $name|@names =E<gt> sub { ... }>
 
-This three items are syntactic sugar for the before, after, and around method
+These three items are syntactic sugar for the before, after, and around method
 modifier features that L<Class::MOP> provides. More information on these may be
-found in the L<Class::MOP::Class documentation|Class::MOP::Class/"Method
-Modifiers"> for now.
+found in L<Moose::Manual::MethodModifiers> and the
+L<Class::MOP::Class documentation|Class::MOP::Class/"Method Modifiers">.
 
 =item B<super>
 
@@ -828,9 +838,10 @@ You can also specify traits which will be applied to your metaclass:
 
 This is very similar to the attribute traits feature. When you do
 this, your class's C<meta> object will have the specified traits
-applied to it. See L<TRAIT NAME RESOLUTION> for more details.
+applied to it. See L<Metaclass and Trait Name Resolution> for more
+details.
 
-=head2 Trait Name Resolution
+=head2 Metaclass and Trait Name Resolution
 
 By default, when given a trait name, Moose simply tries to load a
 class of the same name. If such a class does not exist, it then looks
@@ -845,6 +856,9 @@ return the I<real> class name of the trait. If there is no
 C<register_implementation> method, it will fall back to using
 B<Moose::Meta::$type::Custom::Trait::$trait> as the trait name.
 
+The lookup method for metaclasses is the same, except that it looks
+for a class matching B<Moose::Meta::$type::Custom::$metaclass_name>.
+
 If all this is confusing, take a look at
 L<Moose::Cookbook::Meta::Recipe3>, which demonstrates how to create an
 attribute trait.
@@ -1099,10 +1113,14 @@ Stevan (stevan) Little E<lt>stevan@iinteractive.comE<gt>
 
 Yuval (nothingmuch) Kogman
 
-Shawn (sartak) Moore
+Shawn (sartak) Moore E<lt>sartak@bestpractical.comE<gt>
 
 Dave (autarch) Rolsky E<lt>autarch@urth.orgE<gt>
 
+Jesse (doy) Luehrs E<lt>doy at tozt dot netE<gt>
+
+Hans Dieter (confound) Pearcey E<lt>hdp@pobox.comE<gt>
+
 =head2 OTHER CONTRIBUTORS
 
 Aankhen
@@ -1115,8 +1133,6 @@ Nathan (kolibrie) Gray
 
 Christian (chansen) Hansen
 
-Hans Dieter (confound) Pearcey
-
 Eric (ewilhelm) Wilhelm
 
 Guillermo (groditi) Roditi