X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FMoose%2FMeta%2FClass.pm;h=d7317fe039b43e92c1f62b4754ed398fefd9b114;hb=70bb0f972929efcf64ea1a28efb272cf6334d17f;hp=ced2a76865c3ef778971cb9e92a729d60dd3d685;hpb=2351f08e7d635babd893a7951af6ef553ef23cec;p=gitmo%2FMoose.git diff --git a/lib/Moose/Meta/Class.pm b/lib/Moose/Meta/Class.pm index ced2a76..d7317fe 100644 --- a/lib/Moose/Meta/Class.pm +++ b/lib/Moose/Meta/Class.pm @@ -11,11 +11,11 @@ use List::Util qw( first ); use List::MoreUtils qw( any all uniq ); use Scalar::Util 'weaken', 'blessed'; -our $VERSION = '0.59'; +our $VERSION = '0.72'; $VERSION = eval $VERSION; our $AUTHORITY = 'cpan:STEVAN'; -use Moose::Meta::Method::Overriden; +use Moose::Meta::Method::Overridden; use Moose::Meta::Method::Augmented; use Moose::Error::Default; @@ -90,8 +90,8 @@ sub create_anon_class { # something like Super::Class|Super::Class::2=Role|Role::1 my $cache_key = join '=' => ( - join('|', sort @{$options{superclasses} || []}), - join('|', sort @{$options{roles} || []}), + join('|', @{$options{superclasses} || []}), + join('|', sort @{$options{roles} || []}), ); if ($cache_ok && defined $ANON_CLASSES{$cache_key}) { @@ -186,7 +186,7 @@ sub construct_instance { my $meta_instance = $class->get_meta_instance; # FIXME: # the code below is almost certainly incorrect - # but this is foreign inheritence, so we might + # but this is foreign inheritance, so we might # have to kludge it in the end. my $instance = $params->{'__INSTANCE__'} || $meta_instance->create_instance(); foreach my $attr ($class->compute_all_applicable_attributes()) { @@ -195,74 +195,6 @@ sub construct_instance { return $instance; } -# FIXME: -# This is ugly -sub get_method_map { - my $self = shift; - - my $current = Class::MOP::check_package_cache_flag($self->name); - - if (defined $self->{'_package_cache_flag'} && $self->{'_package_cache_flag'} == $current) { - return $self->{'methods'}; - } - - $self->{_package_cache_flag} = $current; - - my $map = $self->{'methods'}; - - my $class_name = $self->name; - my $method_metaclass = $self->method_metaclass; - - my %all_code = $self->get_all_package_symbols('CODE'); - - foreach my $symbol (keys %all_code) { - my $code = $all_code{$symbol}; - - next if exists $map->{$symbol} && - defined $map->{$symbol} && - $map->{$symbol}->body == $code; - - my ($pkg, $name) = Class::MOP::get_code_info($code); - - if ($pkg->can('meta') - # NOTE: - # we don't know what ->meta we are calling - # here, so we need to be careful cause it - # just might blow up at us, or just complain - # loudly (in the case of Curses.pm) so we - # just be a little overly cautious here. - # - SL - && eval { no warnings; blessed($pkg->meta) } - && $pkg->meta->isa('Moose::Meta::Role')) { - #my $role = $pkg->meta->name; - #next unless $self->does_role($role); - } - else { - - # NOTE: - # in 5.10 constant.pm the constants show up - # as being in the right package, but in pre-5.10 - # they show up as constant::__ANON__ so we - # make an exception here to be sure that things - # work as expected in both. - # - SL - unless ($pkg eq 'constant' && $name eq '__ANON__') { - next if ($pkg || '') ne $class_name || - (($name || '') ne '__ANON__' && ($pkg || '') ne $class_name); - } - - } - - $map->{$symbol} = $method_metaclass->wrap( - $code, - package_name => $class_name, - name => $symbol - ); - } - - return $map; -} - ### --------------------------------------------- sub add_attribute { @@ -280,7 +212,7 @@ sub add_override_method_modifier { (!$self->has_method($name)) || $self->throw_error("Cannot add an override method if a local method is already present"); - $self->add_method($name => Moose::Meta::Method::Overriden->new( + $self->add_method($name => Moose::Meta::Method::Overridden->new( method => $method, class => $self, package => $_super_package, # need this for roles @@ -306,7 +238,7 @@ sub _find_next_method_by_name_which_is_not_overridden { my ($self, $name) = @_; foreach my $method ($self->find_all_methods_by_name($name)) { return $method->{code} - if blessed($method->{code}) && !$method->{code}->isa('Moose::Meta::Method::Overriden'); + if blessed($method->{code}) && !$method->{code}->isa('Moose::Meta::Method::Overridden'); } return undef; } @@ -447,7 +379,7 @@ sub _find_common_ancestor { # FIXME? This doesn't account for multiple inheritance (not sure # if it needs to though). For example, is somewhere in $meta1's - # history it inherits from both ClassA and ClassB, and $meta + # history it inherits from both ClassA and ClassB, and $meta2 # inherits from ClassB & ClassA, does it matter? And what crazy # fool would do that anyway? @@ -582,7 +514,7 @@ sub _process_inherited_attribute { my ($self, $attr_name, %options) = @_; my $inherited_attr = $self->find_attribute_by_name($attr_name); (defined $inherited_attr) - || $self->throw_error("Could not find an attribute by the name of '$attr_name' to inherit from", data => $attr_name); + || $self->throw_error("Could not find an attribute by the name of '$attr_name' to inherit from in ${\$self->name}", data => $attr_name); if ($inherited_attr->isa('Moose::Meta::Attribute')) { return $inherited_attr->clone_and_inherit_options(%options); } @@ -704,163 +636,116 @@ Moose::Meta::Class - The Moose metaclass =head1 DESCRIPTION -This is a subclass of L with Moose specific -extensions. +This class is a subclass of L that provides +additional Moose-specific functionality. -For the most part, the only time you will ever encounter an -instance of this class is if you are doing some serious deep -introspection. To really understand this class, you need to refer -to the L documentation. +To really understand this class, you will probably need to start with +the L documentation. This class can be understood +as a set of additional features on top of the basic feature provided +by that parent class. =head1 METHODS =over 4 -=item B - -=item B +=item B<< Moose::Meta::Class->initialize($package_name, %options) >> -Overrides original to accept a list of roles to apply to -the created class. +This overrides the parent's method in order to provide its own +defaults for the C, C, and +C options. - my $metaclass = Moose::Meta::Class->create( 'New::Class', roles => [...] ); +These all default to the appropriate Moose class. -=item B +=item B<< Moose::Meta::Class->create($package_name, %options) >> -Overrides original to support roles and caching. +This overrides the parent's method in order to accept a C +option. This should be an array reference containing one more roles +that the class does. - my $metaclass = Moose::Meta::Class->create_anon_class( - superclasses => ['Foo'], - roles => [qw/Some Roles Go Here/], - cache => 1, - ); + my $metaclass = Moose::Meta::Class->create( 'New::Class', roles => [...] ); -=item B +=item B<< Moose::Meta::Class->create_anon_class >> -Override original to add default options for inlining destructor -and altering the Constructor metaclass. +This overrides the parent's method to accept a C option, just +as C does. -=item B +It also accepts a C option. If this is true, then the anonymous +class will be cached based on its superclasses and roles. If an +existing anonymous class in the cache has the same superclasses and +roles, it will be reused. -Override original to lock C and memoize C + my $metaclass = Moose::Meta::Class->create_anon_class( + superclasses => ['Foo'], + roles => [qw/Some Roles Go Here/], + cache => 1, + ); -=item B +=item B<< $metaclass->make_immutable(%options) >> -We override this method to support the C attribute option. +This overrides the parent's method to add a few options. Specifically, +it uses the Moose-specific constructor and destructor classes, and +enables inlining the destructor. -=item B +Also, since Moose always inlines attributes, it sets the +C option to false. -This provides some Moose specific extensions to this method, you -almost never call this method directly unless you really know what -you are doing. +=item B<< $metaclass->new_object(%params) >> -This method makes sure to handle the moose weak-ref, type-constraint -and type coercion features. +This overrides the parent's method in order to add support for +attribute triggers. -=item B +=item B<< $metaclass->add_override_method_modifier($name, $sub) >> -This accommodates Moose::Meta::Role::Method instances, which are -aliased, instead of added, but still need to be counted as valid -methods. +This adds an C method modifier to the package. -=item B +=item B<< $metaclass->add_augment_method_modifier($name, $sub) >> -This will create an C method modifier for you, and install -it in the package. +This adds an C method modifier to the package. -=item B +=item B<< $metaclass->calculate_all_roles >> -This will create an C method modifier for you, and install -it in the package. +This will return a unique array of C instances +which are attached to this class. -=item B +=item B<< $metaclass->add_role($role) >> -=item B +This takes a L object, and adds it to the class's +list of roles. This I actually apply the role to the class. -This will return an array of C instances which are -attached to this class. +=item B<< $metaclass->does_role($role_name) >> -=item B +This returns a boolean indicating whether or not the class does the +specified role. This tests both the class and its parents. -This takes an instance of C in C<$role>, and adds it -to the list of associated roles. +=item B<< $metaclass->excludes_role($role_name) >> -=item B +A class excludes a role if it has already composed a role which +excludes the named role. This tests both the class and its parents. -This will test if this class C a given C<$role_name>. It will -not only check it's local roles, but ask them as well in order to -cascade down the role hierarchy. +=item B<< $metaclass->add_attribute($attr_name, %params|$params) >> -=item B +This overrides the parent's method in order to allow the parameters to +be provided as a hash reference. -This will test if this class C a given C<$role_name>. It will -not only check it's local roles, but ask them as well in order to -cascade down the role hierarchy. +=item B<< $metaclass->constructor_class ($class_name) >> -=item B - -This method does the same thing as L, but adds -support for taking the C<$params> as a HASH ref. - -=item B - -=item B +=item B<< $metaclass->destructor_class ($class_name) >> These are the names of classes used when making a class immutable. These default to L and L respectively. These accessors are read-write, so you can use them to change the class name. -=item B +=item B<< $metaclass->error_class($class_name) >> -The name of the class used to throw errors. This default to +The name of the class used to throw errors. This defaults to L, which generates an error with a stacktrace just like C. -=item B - -Moose overrides this method from C and attempts to -fix some incompatibilities before doing the check. - -=item B +=item B<< $metaclass->throw_error($message, %extra) >> Throws the error created by C using C -=item B - -Creates an error message or object. - -The default behavior is C. - -If C is set uses C. Otherwise uses -C (a code reference or variant name), and calls the appropriate -C method. - -=item B - -Get or set the error builder. Defaults to C. - -=item B - -Get or set the error class. Has no default. - -=item B - -Creates an error using L - -=item B - -Creates an error using L - -=item B - -Calls C on the C parameter in C<%args>. Usable with C -to support custom error objects for your meta class. - -=item B - -Dies with an error object or string. - =back =head1 BUGS @@ -875,7 +760,7 @@ Stevan Little Estevan@iinteractive.comE =head1 COPYRIGHT AND LICENSE -Copyright 2006-2008 by Infinity Interactive, Inc. +Copyright 2006-2009 by Infinity Interactive, Inc. L