X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FClass%2FMOP.pm;h=d3fdf355dbb8d20ff28fc95f4d0aff30b96c1751;hb=db130c70dd57d254d55a30d0a6c58df44505ce8a;hp=91a65f6699485690ccd813ff1340307a6f532884;hpb=ec52b37ad0cba41a9770c8971ee16f54bbfdfc89;p=gitmo%2FClass-MOP.git diff --git a/lib/Class/MOP.pm b/lib/Class/MOP.pm index 91a65f6..d3fdf35 100644 --- a/lib/Class/MOP.pm +++ b/lib/Class/MOP.pm @@ -10,8 +10,12 @@ use MRO::Compat; use Carp 'confess'; use Scalar::Util 'weaken', 'reftype', 'blessed'; +use Data::OptList; use Try::Tiny; +use Class::MOP::Mixin::AttributeCore; +use Class::MOP::Mixin::HasAttributes; +use Class::MOP::Mixin::HasMethods; use Class::MOP::Class; use Class::MOP::Attribute; use Class::MOP::Method; @@ -25,7 +29,7 @@ BEGIN { *check_package_cache_flag = \&mro::get_pkg_gen; } -our $VERSION = '0.97'; +our $VERSION = '1.05'; our $XS_VERSION = $VERSION; $VERSION = eval $VERSION; our $AUTHORITY = 'cpan:STEVAN'; @@ -33,7 +37,6 @@ our $AUTHORITY = 'cpan:STEVAN'; require XSLoader; XSLoader::load( __PACKAGE__, $XS_VERSION ); - { # Metaclasses are singletons, so we cache them here. # there is no need to worry about destruction though @@ -75,12 +78,13 @@ sub _class_to_pmfile { } sub load_first_existing_class { - my @classes = @_ + my $classes = Data::OptList::mkopt(\@_) or return; - foreach my $class (@classes) { - unless ( _is_valid_class_name($class) ) { - my $display = defined($class) ? $class : 'undef'; + foreach my $class (@{ $classes }) { + my $name = $class->[0]; + unless ( _is_valid_class_name($name) ) { + my $display = defined($name) ? $name : 'undef'; confess "Invalid class name ($display)"; } } @@ -88,34 +92,48 @@ sub load_first_existing_class { my $found; my %exceptions; - for my $class (@classes) { - my $file = _class_to_pmfile($class); + for my $class (@{ $classes }) { + my ($name, $options) = @{ $class }; - return $class if is_class_loaded($class);; + if ($options) { + return $name if is_class_loaded($name, $options); + if (is_class_loaded($name)) { + # we already know it's loaded and too old, but we call + # ->VERSION anyway to generate the exception for us + $name->VERSION($options->{-version}); + } + } + else { + return $name if is_class_loaded($name); + } - return $class if try { + my $file = _class_to_pmfile($name); + return $name if try { local $SIG{__DIE__}; require $file; + $name->VERSION($options->{-version}) + if defined $options->{-version}; return 1; } catch { unless (/^Can't locate \Q$file\E in \@INC/) { - confess "Couldn't load class ($class) because: $_"; + confess "Couldn't load class ($name) because: $_"; } return; }; } - if ( @classes > 1 ) { - confess "Can't locate any of @classes in \@INC (\@INC contains: @INC)."; + if ( @{ $classes } > 1 ) { + my @list = map { $_->[0] } @{ $classes }; + confess "Can't locate any of @list in \@INC (\@INC contains: @INC)."; } else { - confess "Can't locate " . _class_to_pmfile($classes[0]) . " in \@INC (\@INC contains: @INC)."; + confess "Can't locate " . _class_to_pmfile($classes->[0]->[0]) . " in \@INC (\@INC contains: @INC)."; } } sub load_class { - load_first_existing_class($_[0]); + load_first_existing_class($_[0], ref $_[1] ? $_[1] : ()); # This is done to avoid breaking code which checked the return value. Said # code is dumb. The return value was _always_ true, since it dies on @@ -160,68 +178,101 @@ sub _is_valid_class_name { # inherit them using _construct_instance ## -------------------------------------------------------- -## Class::MOP::Package +## Class::MOP::Mixin::HasMethods -Class::MOP::Package->meta->add_attribute( - Class::MOP::Attribute->new('package' => ( +Class::MOP::Mixin::HasMethods->meta->add_attribute( + Class::MOP::Attribute->new('_methods' => ( reader => { - # NOTE: we need to do this in order - # for the instance meta-object to - # not fall into meta-circular death - # + # NOTE: # we just alias the original method # rather than re-produce it here - 'name' => \&Class::MOP::Package::name + '_full_method_map' => \&Class::MOP::Mixin::HasMethods::_full_method_map }, + default => sub { {} } )) ); -Class::MOP::Package->meta->add_attribute( - Class::MOP::Attribute->new('namespace' => ( - reader => { +Class::MOP::Mixin::HasMethods->meta->add_attribute( + Class::MOP::Attribute->new('method_metaclass' => ( + reader => { # NOTE: # we just alias the original method # rather than re-produce it here - 'namespace' => \&Class::MOP::Package::namespace + 'method_metaclass' => \&Class::MOP::Mixin::HasMethods::method_metaclass }, - init_arg => undef, - default => sub { \undef } + default => 'Class::MOP::Method', )) ); -Class::MOP::Package->meta->add_attribute( - Class::MOP::Attribute->new('_methods' => ( +Class::MOP::Mixin::HasMethods->meta->add_attribute( + Class::MOP::Attribute->new('wrapped_method_metaclass' => ( reader => { # NOTE: # we just alias the original method # rather than re-produce it here - '_full_method_map' => \&Class::MOP::Package::_full_method_map + 'wrapped_method_metaclass' => \&Class::MOP::Mixin::HasMethods::wrapped_method_metaclass }, - default => sub { {} } + default => 'Class::MOP::Method::Wrapped', )) ); -Class::MOP::Package->meta->add_attribute( - Class::MOP::Attribute->new('method_metaclass' => ( +## -------------------------------------------------------- +## Class::MOP::Mixin::HasMethods + +Class::MOP::Mixin::HasAttributes->meta->add_attribute( + Class::MOP::Attribute->new('attributes' => ( + reader => { + # NOTE: we need to do this in order + # for the instance meta-object to + # not fall into meta-circular death + # + # we just alias the original method + # rather than re-produce it here + '_attribute_map' => \&Class::MOP::Mixin::HasAttributes::_attribute_map + }, + default => sub { {} } + )) +); + +Class::MOP::Mixin::HasAttributes->meta->add_attribute( + Class::MOP::Attribute->new('attribute_metaclass' => ( reader => { # NOTE: # we just alias the original method # rather than re-produce it here - 'method_metaclass' => \&Class::MOP::Package::method_metaclass + 'attribute_metaclass' => \&Class::MOP::Mixin::HasAttributes::attribute_metaclass }, - default => 'Class::MOP::Method', + default => 'Class::MOP::Attribute', )) ); +## -------------------------------------------------------- +## Class::MOP::Package + Class::MOP::Package->meta->add_attribute( - Class::MOP::Attribute->new('wrapped_method_metaclass' => ( + Class::MOP::Attribute->new('package' => ( reader => { + # NOTE: we need to do this in order + # for the instance meta-object to + # not fall into meta-circular death + # + # we just alias the original method + # rather than re-produce it here + 'name' => \&Class::MOP::Package::name + }, + )) +); + +Class::MOP::Package->meta->add_attribute( + Class::MOP::Attribute->new('namespace' => ( + reader => { # NOTE: # we just alias the original method # rather than re-produce it here - 'wrapped_method_metaclass' => \&Class::MOP::Package::wrapped_method_metaclass + 'namespace' => \&Class::MOP::Package::namespace }, - default => 'Class::MOP::Method::Wrapped', + init_arg => undef, + default => sub { \undef } )) ); @@ -274,21 +325,6 @@ Class::MOP::Module->meta->add_attribute( ## Class::MOP::Class Class::MOP::Class->meta->add_attribute( - Class::MOP::Attribute->new('attributes' => ( - reader => { - # NOTE: we need to do this in order - # for the instance meta-object to - # not fall into meta-circular death - # - # we just alias the original method - # rather than re-produce it here - '_attribute_map' => \&Class::MOP::Class::_attribute_map - }, - default => sub { {} } - )) -); - -Class::MOP::Class->meta->add_attribute( Class::MOP::Attribute->new('superclasses' => ( accessor => { # NOTE: @@ -302,18 +338,6 @@ Class::MOP::Class->meta->add_attribute( ); Class::MOP::Class->meta->add_attribute( - Class::MOP::Attribute->new('attribute_metaclass' => ( - reader => { - # NOTE: - # we just alias the original method - # rather than re-produce it here - 'attribute_metaclass' => \&Class::MOP::Class::attribute_metaclass - }, - default => 'Class::MOP::Attribute', - )) -); - -Class::MOP::Class->meta->add_attribute( Class::MOP::Attribute->new('instance_metaclass' => ( reader => { # NOTE: we need to do this in order @@ -371,9 +395,8 @@ Class::MOP::Class->meta->add_attribute( # _construct_class_instance method. ## -------------------------------------------------------- -## Class::MOP::Attribute - -Class::MOP::Attribute->meta->add_attribute( +## Class::MOP::Mixin::AttributeCore +Class::MOP::Mixin::AttributeCore->meta->add_attribute( Class::MOP::Attribute->new('name' => ( reader => { # NOTE: we need to do this in order @@ -382,106 +405,108 @@ Class::MOP::Attribute->meta->add_attribute( # # we just alias the original method # rather than re-produce it here - 'name' => \&Class::MOP::Attribute::name + 'name' => \&Class::MOP::Mixin::AttributeCore::name } )) ); -Class::MOP::Attribute->meta->add_attribute( - Class::MOP::Attribute->new('associated_class' => ( - reader => { - # NOTE: we need to do this in order - # for the instance meta-object to - # not fall into meta-circular death - # - # we just alias the original method - # rather than re-produce it here - 'associated_class' => \&Class::MOP::Attribute::associated_class - } - )) -); - -Class::MOP::Attribute->meta->add_attribute( +Class::MOP::Mixin::AttributeCore->meta->add_attribute( Class::MOP::Attribute->new('accessor' => ( - reader => { 'accessor' => \&Class::MOP::Attribute::accessor }, - predicate => { 'has_accessor' => \&Class::MOP::Attribute::has_accessor }, + reader => { 'accessor' => \&Class::MOP::Mixin::AttributeCore::accessor }, + predicate => { 'has_accessor' => \&Class::MOP::Mixin::AttributeCore::has_accessor }, )) ); -Class::MOP::Attribute->meta->add_attribute( +Class::MOP::Mixin::AttributeCore->meta->add_attribute( Class::MOP::Attribute->new('reader' => ( - reader => { 'reader' => \&Class::MOP::Attribute::reader }, - predicate => { 'has_reader' => \&Class::MOP::Attribute::has_reader }, + reader => { 'reader' => \&Class::MOP::Mixin::AttributeCore::reader }, + predicate => { 'has_reader' => \&Class::MOP::Mixin::AttributeCore::has_reader }, )) ); -Class::MOP::Attribute->meta->add_attribute( +Class::MOP::Mixin::AttributeCore->meta->add_attribute( Class::MOP::Attribute->new('initializer' => ( - reader => { 'initializer' => \&Class::MOP::Attribute::initializer }, - predicate => { 'has_initializer' => \&Class::MOP::Attribute::has_initializer }, + reader => { 'initializer' => \&Class::MOP::Mixin::AttributeCore::initializer }, + predicate => { 'has_initializer' => \&Class::MOP::Mixin::AttributeCore::has_initializer }, )) ); -Class::MOP::Attribute->meta->add_attribute( +Class::MOP::Mixin::AttributeCore->meta->add_attribute( Class::MOP::Attribute->new('definition_context' => ( - reader => { 'definition_context' => \&Class::MOP::Attribute::definition_context }, + reader => { 'definition_context' => \&Class::MOP::Mixin::AttributeCore::definition_context }, )) ); -Class::MOP::Attribute->meta->add_attribute( +Class::MOP::Mixin::AttributeCore->meta->add_attribute( Class::MOP::Attribute->new('writer' => ( - reader => { 'writer' => \&Class::MOP::Attribute::writer }, - predicate => { 'has_writer' => \&Class::MOP::Attribute::has_writer }, + reader => { 'writer' => \&Class::MOP::Mixin::AttributeCore::writer }, + predicate => { 'has_writer' => \&Class::MOP::Mixin::AttributeCore::has_writer }, )) ); -Class::MOP::Attribute->meta->add_attribute( +Class::MOP::Mixin::AttributeCore->meta->add_attribute( Class::MOP::Attribute->new('predicate' => ( - reader => { 'predicate' => \&Class::MOP::Attribute::predicate }, - predicate => { 'has_predicate' => \&Class::MOP::Attribute::has_predicate }, + reader => { 'predicate' => \&Class::MOP::Mixin::AttributeCore::predicate }, + predicate => { 'has_predicate' => \&Class::MOP::Mixin::AttributeCore::has_predicate }, )) ); -Class::MOP::Attribute->meta->add_attribute( +Class::MOP::Mixin::AttributeCore->meta->add_attribute( Class::MOP::Attribute->new('clearer' => ( - reader => { 'clearer' => \&Class::MOP::Attribute::clearer }, - predicate => { 'has_clearer' => \&Class::MOP::Attribute::has_clearer }, + reader => { 'clearer' => \&Class::MOP::Mixin::AttributeCore::clearer }, + predicate => { 'has_clearer' => \&Class::MOP::Mixin::AttributeCore::has_clearer }, )) ); -Class::MOP::Attribute->meta->add_attribute( +Class::MOP::Mixin::AttributeCore->meta->add_attribute( Class::MOP::Attribute->new('builder' => ( - reader => { 'builder' => \&Class::MOP::Attribute::builder }, - predicate => { 'has_builder' => \&Class::MOP::Attribute::has_builder }, + reader => { 'builder' => \&Class::MOP::Mixin::AttributeCore::builder }, + predicate => { 'has_builder' => \&Class::MOP::Mixin::AttributeCore::has_builder }, )) ); -Class::MOP::Attribute->meta->add_attribute( +Class::MOP::Mixin::AttributeCore->meta->add_attribute( Class::MOP::Attribute->new('init_arg' => ( - reader => { 'init_arg' => \&Class::MOP::Attribute::init_arg }, - predicate => { 'has_init_arg' => \&Class::MOP::Attribute::has_init_arg }, + reader => { 'init_arg' => \&Class::MOP::Mixin::AttributeCore::init_arg }, + predicate => { 'has_init_arg' => \&Class::MOP::Mixin::AttributeCore::has_init_arg }, )) ); -Class::MOP::Attribute->meta->add_attribute( +Class::MOP::Mixin::AttributeCore->meta->add_attribute( Class::MOP::Attribute->new('default' => ( # default has a custom 'reader' method ... - predicate => { 'has_default' => \&Class::MOP::Attribute::has_default }, + predicate => { 'has_default' => \&Class::MOP::Mixin::AttributeCore::has_default }, )) ); +Class::MOP::Mixin::AttributeCore->meta->add_attribute( + Class::MOP::Attribute->new('insertion_order' => ( + reader => { 'insertion_order' => \&Class::MOP::Mixin::AttributeCore::insertion_order }, + writer => { '_set_insertion_order' => \&Class::MOP::Mixin::AttributeCore::_set_insertion_order }, + predicate => { 'has_insertion_order' => \&Class::MOP::Mixin::AttributeCore::has_insertion_order }, + )) +); + +## -------------------------------------------------------- +## Class::MOP::Attribute Class::MOP::Attribute->meta->add_attribute( - Class::MOP::Attribute->new('associated_methods' => ( - reader => { 'associated_methods' => \&Class::MOP::Attribute::associated_methods }, - default => sub { [] } + Class::MOP::Attribute->new('associated_class' => ( + reader => { + # NOTE: we need to do this in order + # for the instance meta-object to + # not fall into meta-circular death + # + # we just alias the original method + # rather than re-produce it here + 'associated_class' => \&Class::MOP::Attribute::associated_class + } )) ); Class::MOP::Attribute->meta->add_attribute( - Class::MOP::Attribute->new('insertion_order' => ( - reader => { 'insertion_order' => \&Class::MOP::Attribute::insertion_order }, - writer => { '_set_insertion_order' => \&Class::MOP::Attribute::_set_insertion_order }, - predicate => { 'has_insertion_order' => \&Class::MOP::Attribute::has_insertion_order }, + Class::MOP::Attribute->new('associated_methods' => ( + reader => { 'associated_methods' => \&Class::MOP::Attribute::associated_methods }, + default => sub { [] } )) ); @@ -523,13 +548,6 @@ Class::MOP::Method->meta->add_attribute( )) ); -Class::MOP::Method->meta->add_method('clone' => sub { - my $self = shift; - my $clone = $self->meta->clone_object($self, @_); - $clone->_set_original_method($self); - return $clone; -}); - ## -------------------------------------------------------- ## Class::MOP::Method::Wrapped @@ -684,6 +702,17 @@ $_->meta->make_immutable( Class::MOP::Method::Wrapped /; +$_->meta->make_immutable( + inline_constructor => 0, + constructor_name => undef, + inline_accessors => 0, +) for qw/ + Class::MOP::Mixin + Class::MOP::Mixin::AttributeCore + Class::MOP::Mixin::HasAttributes + Class::MOP::Mixin::HasMethods +/; + 1; __END__ @@ -811,6 +840,18 @@ metaclass compatibility both upwards and downwards. | A |<----| B | +---------+ +---------+ +In actuality, I of a class's metaclasses must be compatible, +not just the class metaclass. That includes the instance, attribute, +and method metaclasses, as well as the constructor and destructor +classes. + +C will attempt to fix some simple types of +incompatibilities. If all the metaclasses for the parent class are +I of the child's metaclasses then we can simply replace +the child's metaclasses with the parent's. In addition, if the child +is missing a metaclass that the parent has, we can also just make the +child use the parent's metaclass. + As I said this is a highly esoteric topic and one you will only run into if you do a lot of subclassing of L. If you are interested in why this is an issue see the paper I. =over 4 -=item B +=item B This will load the specified C<$class_name>, if it is not already loaded (as reported by C). This function can be used @@ -902,9 +943,15 @@ unconditionally. If the module cannot be loaded, an exception is thrown. +You can pass a hash reference with options as second argument. The +only option currently recognised is C<-version>, which will ensure +that the loaded class has at least the required version. + +See also L. + For historical reasons, this function explicitly returns a true value. -=item B +=item B Returns a boolean indicating whether or not C<$class_name> has been loaded. @@ -916,6 +963,12 @@ positives. In particular, loading any of the core L modules will cause most of the rest of the core L modules to falsely report having been loaded, due to the way the base L module works. +You can pass a hash reference with options as second argument. The +only option currently recognised is C<-version>, which will ensure +that the loaded class has at least the required version. + +See also L. + =item B This function returns two values, the name of the package the C<$code> @@ -942,6 +995,8 @@ variable which is not package specific. =item B +=item B + B Given a list of class names, this function will attempt to load each @@ -950,6 +1005,13 @@ one in turn. If it finds a class it can load, it will return that class' name. If none of the classes can be loaded, it will throw an exception. +Additionally, you can pass a hash reference with options after each +class name. Currently, only C<-version> is recognised and will ensure +that the loaded class has at least the required version. If the class +version is not sufficient, an exception will be raised. + +See also L. + =back =head2 Metaclass cache functions @@ -1003,6 +1065,17 @@ This will remove the metaclass stored in the C<$name> key. =back +=head2 Class Loading Options + +=over 4 + +=item -version + +Can be used to pass a minimum required version that will be checked +against the class version after it was loaded. + +=back + =head1 SEE ALSO =head2 Books @@ -1130,7 +1203,7 @@ Dylan Hardison =head1 COPYRIGHT AND LICENSE -Copyright 2006-2009 by Infinity Interactive, Inc. +Copyright 2006-2010 by Infinity Interactive, Inc. L