X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FClass%2FMOP.pm;h=239151968f3529db16e0e86bfa995c9d0786ca0f;hb=4154c4d09ba34bd81ce12dde18012bba797a353c;hp=33857128c62ca1ece794b249997535d76c0b17a7;hpb=1550e0820d345fd483382e2b912ba683da3bdc1d;p=gitmo%2FClass-MOP.git diff --git a/lib/Class/MOP.pm b/lib/Class/MOP.pm index 3385712..2391519 100644 --- a/lib/Class/MOP.pm +++ b/lib/Class/MOP.pm @@ -9,33 +9,30 @@ use 5.008; use MRO::Compat; use Carp 'confess'; -use Devel::GlobalDestruction qw( in_global_destruction ); -use Scalar::Util 'weaken', 'reftype'; -use Sub::Name qw( subname ); +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; -use Class::MOP::Immutable; - BEGIN { - *IS_RUNNING_ON_5_10 = ($] < 5.009_005) + *IS_RUNNING_ON_5_10 = ($] < 5.009_005) ? sub () { 0 } - : sub () { 1 }; - - *HAVE_ISAREV = defined(&mro::get_isarev) - ? sub () { 1 } : sub () { 1 }; # this is either part of core or set up appropriately by MRO::Compat *check_package_cache_flag = \&mro::get_pkg_gen; } -our $VERSION = '0.78_02'; +our $VERSION = '1.00'; our $XS_VERSION = $VERSION; $VERSION = eval $VERSION; -our $AUTHORITY = 'cpan:STEVAN'; +our $AUTHORITY = 'cpan:STEVAN'; require XSLoader; XSLoader::load( __PACKAGE__, $XS_VERSION ); @@ -46,10 +43,9 @@ XSLoader::load( __PACKAGE__, $XS_VERSION ); # there is no need to worry about destruction though # because they should die only when the program dies. # After all, do package definitions even get reaped? + # Anonymous classes manage their own destruction. my %METAS; - # means of accessing all the metaclasses that have - # been initialized thus far (for mugwumps obj browser) sub get_all_metaclasses { %METAS } sub get_all_metaclass_instances { values %METAS } sub get_all_metaclass_names { keys %METAS } @@ -57,7 +53,14 @@ XSLoader::load( __PACKAGE__, $XS_VERSION ); sub store_metaclass_by_name { $METAS{$_[0]} = $_[1] } sub weaken_metaclass { weaken($METAS{$_[0]}) } sub does_metaclass_exist { exists $METAS{$_[0]} && defined $METAS{$_[0]} } - sub remove_metaclass_by_name { $METAS{$_[0]} = undef } + sub remove_metaclass_by_name { delete $METAS{$_[0]}; return } + + # This handles instances as well as class names + sub class_of { + return unless defined $_[0]; + my $class = blessed($_[0]) || $_[0]; + return $METAS{$class}; + } # NOTE: # We only cache metaclasses, meaning instances of @@ -66,62 +69,77 @@ XSLoader::load( __PACKAGE__, $XS_VERSION ); # because I don't yet see a good reason to do so. } +sub _class_to_pmfile { + my $class = shift; + + my $file = $class . '.pm'; + $file =~ s{::}{/}g; + + return $file; +} + sub load_first_existing_class { - my @classes = @_ - or return; + 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)"; } } my $found; my %exceptions; - for my $class (@classes) { - my $e = _try_load_one_class($class); - if ($e) { - $exceptions{$class} = $e; + for my $class (@{ $classes }) { + my ($name, $options) = @{ $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 { - $found = $class; - last; + return $name if is_class_loaded($name); } - } - return $found if $found; - - confess join( - "\n", - map { - sprintf( - "Could not load class (%s) because : %s", $_, - $exceptions{$_} - ) - } @classes - ); -} - -sub _try_load_one_class { - my $class = shift; - - return if is_class_loaded($class); + 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 ($name) because: $_"; + } - my $file = $class . '.pm'; - $file =~ s{::}{/}g; + return; + }; + } - return do { - local $@; - eval { require($file) }; - $@; - }; + 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]->[0]) . " in \@INC (\@INC contains: @INC)."; + } } sub load_class { - my $class = load_first_existing_class($_[0]); - return get_metaclass_by_name($class) || $class; + 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 + # failure! + return 1; } sub _is_valid_class_name { @@ -158,7 +176,76 @@ sub _is_valid_class_name { # We need to add in the meta-attributes here so that # any subclass of Class::MOP::* will be able to -# inherit them using &construct_instance +# inherit them using _construct_instance + +## -------------------------------------------------------- +## Class::MOP::Mixin::HasMethods + +Class::MOP::Mixin::HasMethods->meta->add_attribute( + Class::MOP::Attribute->new('_methods' => ( + reader => { + # NOTE: + # we just alias the original method + # rather than re-produce it here + '_full_method_map' => \&Class::MOP::Mixin::HasMethods::_full_method_map + }, + default => sub { {} } + )) +); + +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 + 'method_metaclass' => \&Class::MOP::Mixin::HasMethods::method_metaclass + }, + default => 'Class::MOP::Method', + )) +); + +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 + 'wrapped_method_metaclass' => \&Class::MOP::Mixin::HasMethods::wrapped_method_metaclass + }, + default => 'Class::MOP::Method::Wrapped', + )) +); + +## -------------------------------------------------------- +## 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 + 'attribute_metaclass' => \&Class::MOP::Mixin::HasAttributes::attribute_metaclass + }, + default => 'Class::MOP::Attribute', + )) +); ## -------------------------------------------------------- ## Class::MOP::Package @@ -239,33 +326,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 - 'get_attribute_map' => \&Class::MOP::Class::get_attribute_map - }, - default => sub { {} } - )) -); - -Class::MOP::Class->meta->add_attribute( - Class::MOP::Attribute->new('methods' => ( - reader => { - # NOTE: - # we just alias the original method - # rather than re-produce it here - 'get_method_map' => \&Class::MOP::Class::get_method_map - }, - default => sub { {} } - )) -); - -Class::MOP::Class->meta->add_attribute( Class::MOP::Attribute->new('superclasses' => ( accessor => { # NOTE: @@ -279,63 +339,52 @@ Class::MOP::Class->meta->add_attribute( ); Class::MOP::Class->meta->add_attribute( - Class::MOP::Attribute->new('attribute_metaclass' => ( + Class::MOP::Attribute->new('instance_metaclass' => ( reader => { - # NOTE: + # 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_metaclass' => \&Class::MOP::Class::attribute_metaclass + 'instance_metaclass' => \&Class::MOP::Class::instance_metaclass }, - default => 'Class::MOP::Attribute', + default => 'Class::MOP::Instance', )) ); Class::MOP::Class->meta->add_attribute( - Class::MOP::Attribute->new('method_metaclass' => ( + Class::MOP::Attribute->new('immutable_trait' => ( reader => { - # NOTE: - # we just alias the original method - # rather than re-produce it here - 'method_metaclass' => \&Class::MOP::Class::method_metaclass + 'immutable_trait' => \&Class::MOP::Class::immutable_trait }, - default => 'Class::MOP::Method', + default => "Class::MOP::Class::Immutable::Trait", )) ); Class::MOP::Class->meta->add_attribute( - Class::MOP::Attribute->new('wrapped_method_metaclass' => ( + Class::MOP::Attribute->new('constructor_name' => ( reader => { - # NOTE: - # we just alias the original method - # rather than re-produce it here - 'wrapped_method_metaclass' => \&Class::MOP::Class::wrapped_method_metaclass + 'constructor_name' => \&Class::MOP::Class::constructor_name, }, - default => 'Class::MOP::Method::Wrapped', + default => "new", )) ); Class::MOP::Class->meta->add_attribute( - Class::MOP::Attribute->new('instance_metaclass' => ( + Class::MOP::Attribute->new('constructor_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 - 'instance_metaclass' => \&Class::MOP::Class::instance_metaclass + 'constructor_class' => \&Class::MOP::Class::constructor_class, }, - default => 'Class::MOP::Instance', + default => "Class::MOP::Method::Constructor", )) ); + Class::MOP::Class->meta->add_attribute( - Class::MOP::Attribute->new('immutable_transformer' => ( + Class::MOP::Attribute->new('destructor_class' => ( reader => { - 'immutable_transformer' => \&Class::MOP::Class::immutable_transformer - }, - writer => { - '_set_immutable_transformer' => \&Class::MOP::Class::_set_immutable_transformer + 'destructor_class' => \&Class::MOP::Class::destructor_class, }, )) ); @@ -344,12 +393,11 @@ Class::MOP::Class->meta->add_attribute( # we don't actually need to tie the knot with # Class::MOP::Class here, it is actually handled # within Class::MOP::Class itself in the -# construct_class_instance method. +# _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 @@ -358,91 +406,101 @@ 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_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 + } )) ); @@ -526,6 +584,16 @@ Class::MOP::Method::Generated->meta->add_attribute( )) ); + +## -------------------------------------------------------- +## Class::MOP::Method::Inlined + +Class::MOP::Method::Inlined->meta->add_attribute( + Class::MOP::Attribute->new('_expected_method_class' => ( + reader => { '_expected_method_class' => \&Class::MOP::Method::Inlined::_expected_method_class }, + )) +); + ## -------------------------------------------------------- ## Class::MOP::Method::Accessor @@ -604,6 +672,7 @@ Class::MOP::Instance->meta->add_attribute( ), ); +require Class::MOP::Deprecated unless our $no_deprecated; # we need the meta instance of the meta instance to be created now, in order # for the constructor to be able to use it @@ -619,8 +688,7 @@ undef Class::MOP::Instance->meta->{_package_cache_flag}; # the compile time of the MOP, and gives us no actual benefits. $_->meta->make_immutable( - inline_constructor => 1, - replace_constructor => 1, + inline_constructor => 0, constructor_name => "_new", inline_accessors => 0, ) for qw/ @@ -635,12 +703,24 @@ $_->meta->make_immutable( Class::MOP::Object Class::MOP::Method::Generated + Class::MOP::Method::Inlined Class::MOP::Method::Accessor Class::MOP::Method::Constructor 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__ @@ -842,11 +922,6 @@ We set this constant depending on what version perl we are on, this allows us to take advantage of new 5.10 features and stay backwards compatible. -=item I - -Whether or not the L pragma provides C, a much faster -way to get all the subclasses of a certain class. - =back =head2 Utility functions @@ -855,13 +930,24 @@ Note that these are all called as B. =over 4 -=item B +=item B -This will load the specified C<$class_name>. This function can be used +This will load the specified C<$class_name>, if it is not already +loaded (as reported by C). This function can be used in place of tricks like C or using C unconditionally. -=item B +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 Returns a boolean indicating whether or not C<$class_name> has been loaded. @@ -869,7 +955,15 @@ loaded. This does a basic check of the symbol table to try and determine as best it can if the C<$class_name> is loaded, it is probably correct about 99% of the time, but it can be fooled into reporting false -positives. +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 @@ -878,6 +972,12 @@ is from and the name of the C<$code> itself. This is used by several elements of the MOP to determine where a given C<$code> reference is from. +=item B + +This will return the metaclass of the given instance or class name. If the +class lacks a metaclass, no metaclass will be initialized, and C will be +returned. + =item B B @@ -891,6 +991,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 @@ -899,6 +1001,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 @@ -952,6 +1061,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 @@ -1004,7 +1124,7 @@ L =over 4 -=item L +=item L =item L @@ -1034,8 +1154,14 @@ creates are very different from this modules. =head1 BUGS All complex software has bugs lurking in it, and this module is no -exception. If you find a bug please either email me, or add the bug -to cpan-RT. +exception. + +Please report any bugs to C, or through the +web interface at L. + +You can also discuss feature requests or possible bugs on the Moose +mailing list (moose@perl.org) or on IRC at +L. =head1 ACKNOWLEDGEMENTS @@ -1059,6 +1185,8 @@ Florian (rafl) Ragwitz Guillermo (groditi) Roditi +Dave (autarch) Rolsky + Matt (mst) Trout Rob (robkinyon) Kinyon @@ -1067,9 +1195,11 @@ Yuval (nothingmuch) Kogman Scott (konobi) McWhirter +Dylan Hardison + =head1 COPYRIGHT AND LICENSE -Copyright 2006-2009 by Infinity Interactive, Inc. +Copyright 2006-2010 by Infinity Interactive, Inc. L