X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FClass%2FMOP.pm;h=9b341f73b2a7baa8cbcbbce8f87f007aaa8fb837;hb=2367814a108bbb85efbf76b57fc58bf464d68455;hp=e508e5927195185ca0715e19265434341417cc00;hpb=550d56db72e2f36b7fb88e6f9aa9d7f3d3fef53b;p=gitmo%2FClass-MOP.git diff --git a/lib/Class/MOP.pm b/lib/Class/MOP.pm index e508e59..9b341f7 100644 --- a/lib/Class/MOP.pm +++ b/lib/Class/MOP.pm @@ -4,33 +4,53 @@ package Class::MOP; use strict; use warnings; -use Scalar::Util 'blessed'; use Carp 'confess'; +use Scalar::Util 'weaken'; use Class::MOP::Class; use Class::MOP::Attribute; use Class::MOP::Method; -our $VERSION = '0.06'; - -sub import { - shift; - return unless @_; - if ($_[0] eq ':universal') { - *UNIVERSAL::meta = sub { - Class::MOP::Class->initialize(blessed($_[0]) || $_[0]) - }; - } - else { - my $pkg = caller(); - no strict 'refs'; - *{$pkg . '::' . $_[0]} = sub { - Class::MOP::Class->initialize(blessed($_[0]) || $_[0]) - }; - } +use Class::MOP::Immutable; + +our $VERSION = '0.37'; +our $AUTHORITY = 'cpan:STEVAN'; + +{ + # Metaclasses are singletons, so we cache them here. + # 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? + 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 } + sub get_metaclass_by_name { $METAS{$_[0]} } + 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 } + + # NOTE: + # We only cache metaclasses, meaning instances of + # Class::MOP::Class. We do not cache instance of + # Class::MOP::Package or Class::MOP::Module. Mostly + # because I don't yet see a good reason to do so. } ## ---------------------------------------------------------------------------- +## Setting up our environment ... +## ---------------------------------------------------------------------------- +## Class::MOP needs to have a few things in the global perl environment so +## that it can operate effectively. Those things are done here. +## ---------------------------------------------------------------------------- + +# ... nothing yet actually ;) + +## ---------------------------------------------------------------------------- ## Bootstrapping ## ---------------------------------------------------------------------------- ## The code below here is to bootstrap our MOP with itself. This is also @@ -45,95 +65,288 @@ sub import { # any subclass of Class::MOP::* will be able to # inherit them using &construct_instance +## -------------------------------------------------------- +## Class::MOP::Package + +Class::MOP::Package->meta->add_attribute( + 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 + }, + init_arg => 'package', + )) +); + +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 + 'namespace' => \&Class::MOP::Package::namespace + }, + # NOTE: + # protect this from silliness + init_arg => '!............( DO NOT DO THIS )............!', + default => sub { \undef } + )) +); + +# NOTE: +# use the metaclass to construct the meta-package +# which is a superclass of the metaclass itself :P +Class::MOP::Package->meta->add_method('initialize' => sub { + my $class = shift; + my $package_name = shift; + $class->meta->new_object('package' => $package_name, @_); +}); + +## -------------------------------------------------------- +## Class::MOP::Module + +# NOTE: +# yeah this is kind of stretching things a bit, +# but truthfully the version should be an attribute +# of the Module, the weirdness comes from having to +# stick to Perl 5 convention and store it in the +# $VERSION package variable. Basically if you just +# squint at it, it will look how you want it to look. +# Either as a package variable, or as a attribute of +# the metaclass, isn't abstraction great :) + +Class::MOP::Module->meta->add_attribute( + Class::MOP::Attribute->new('$!version' => ( + reader => { + # NOTE: + # we just alias the original method + # rather than re-produce it here + 'version' => \&Class::MOP::Module::version + }, + # NOTE: + # protect this from silliness + init_arg => '!............( DO NOT DO THIS )............!', + default => sub { \undef } + )) +); + +# NOTE: +# By following the same conventions as version here, +# we are opening up the possibility that people can +# use the $AUTHORITY in non-Class::MOP modules as +# well. + +Class::MOP::Module->meta->add_attribute( + Class::MOP::Attribute->new('$!authority' => ( + reader => { + # NOTE: + # we just alias the original method + # rather than re-produce it here + 'authority' => \&Class::MOP::Module::authority + }, + # NOTE: + # protect this from silliness + init_arg => '!............( DO NOT DO THIS )............!', + default => sub { \undef } + )) +); + +## -------------------------------------------------------- ## Class::MOP::Class Class::MOP::Class->meta->add_attribute( - Class::MOP::Attribute->new('$:package' => ( - reader => 'name', - init_arg => ':package', + 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 + }, + init_arg => 'attributes', + default => sub { {} } )) ); Class::MOP::Class->meta->add_attribute( - Class::MOP::Attribute->new('%:attributes' => ( - reader => 'get_attribute_map', - init_arg => ':attributes', - default => sub { {} } + Class::MOP::Attribute->new('%!methods' => ( + init_arg => '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('$:attribute_metaclass' => ( - reader => 'attribute_metaclass', - init_arg => ':attribute_metaclass', + Class::MOP::Attribute->new('@!superclasses' => ( + accessor => { + # NOTE: + # we just alias the original method + # rather than re-produce it here + 'superclasses' => \&Class::MOP::Class::superclasses + }, + # NOTE: + # protect this from silliness + init_arg => '!............( DO NOT DO THIS )............!', + default => sub { \undef } + )) +); + +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 + }, + init_arg => 'attribute_metaclass', default => 'Class::MOP::Attribute', )) ); Class::MOP::Class->meta->add_attribute( - Class::MOP::Attribute->new('$:method_metaclass' => ( - reader => 'method_metaclass', - init_arg => ':method_metaclass', + Class::MOP::Attribute->new('$!method_metaclass' => ( + reader => { + # NOTE: + # we just alias the original method + # rather than re-produce it here + 'method_metaclass' => \&Class::MOP::Class::method_metaclass + }, + init_arg => 'method_metaclass', default => 'Class::MOP::Method', )) ); +Class::MOP::Class->meta->add_attribute( + Class::MOP::Attribute->new('$!instance_metaclass' => ( + 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 + }, + init_arg => 'instance_metaclass', + default => 'Class::MOP::Instance', + )) +); + +# NOTE: +# 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. + +## -------------------------------------------------------- ## Class::MOP::Attribute Class::MOP::Attribute->meta->add_attribute( - Class::MOP::Attribute->new('name' => ( - reader => 'name' + Class::MOP::Attribute->new('$!name' => ( + init_arg => 'name', + 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::Attribute::name + } )) ); Class::MOP::Attribute->meta->add_attribute( - Class::MOP::Attribute->new('associated_class' => ( - reader => 'associated_class' + Class::MOP::Attribute->new('$!associated_class' => ( + init_arg => '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('accessor' => ( - reader => 'accessor', - predicate => 'has_accessor', + Class::MOP::Attribute->new('$!accessor' => ( + init_arg => 'accessor', + reader => { 'accessor' => \&Class::MOP::Attribute::accessor }, + predicate => { 'has_accessor' => \&Class::MOP::Attribute::has_accessor }, )) ); Class::MOP::Attribute->meta->add_attribute( - Class::MOP::Attribute->new('reader' => ( - reader => 'reader', - predicate => 'has_reader', + Class::MOP::Attribute->new('$!reader' => ( + init_arg => 'reader', + reader => { 'reader' => \&Class::MOP::Attribute::reader }, + predicate => { 'has_reader' => \&Class::MOP::Attribute::has_reader }, )) ); Class::MOP::Attribute->meta->add_attribute( - Class::MOP::Attribute->new('writer' => ( - reader => 'writer', - predicate => 'has_writer', + Class::MOP::Attribute->new('$!writer' => ( + init_arg => 'writer', + reader => { 'writer' => \&Class::MOP::Attribute::writer }, + predicate => { 'has_writer' => \&Class::MOP::Attribute::has_writer }, )) ); Class::MOP::Attribute->meta->add_attribute( - Class::MOP::Attribute->new('predicate' => ( - reader => 'predicate', - predicate => 'has_predicate', + Class::MOP::Attribute->new('$!predicate' => ( + init_arg => 'predicate', + reader => { 'predicate' => \&Class::MOP::Attribute::predicate }, + predicate => { 'has_predicate' => \&Class::MOP::Attribute::has_predicate }, )) ); Class::MOP::Attribute->meta->add_attribute( - Class::MOP::Attribute->new('init_arg' => ( - reader => 'init_arg', - predicate => 'has_init_arg', + Class::MOP::Attribute->new('$!clearer' => ( + init_arg => 'clearer', + reader => { 'clearer' => \&Class::MOP::Attribute::clearer }, + predicate => { 'has_clearer' => \&Class::MOP::Attribute::has_clearer }, )) ); Class::MOP::Attribute->meta->add_attribute( - Class::MOP::Attribute->new('default' => ( + Class::MOP::Attribute->new('$!init_arg' => ( + init_arg => 'init_arg', + reader => { 'init_arg' => \&Class::MOP::Attribute::init_arg }, + predicate => { 'has_init_arg' => \&Class::MOP::Attribute::has_init_arg }, + )) +); + +Class::MOP::Attribute->meta->add_attribute( + Class::MOP::Attribute->new('$!default' => ( + init_arg => 'default', # default has a custom 'reader' method ... - predicate => 'has_default', + predicate => { 'has_default' => \&Class::MOP::Attribute::has_default }, )) ); +Class::MOP::Attribute->meta->add_attribute( + Class::MOP::Attribute->new('@!associated_methods' => ( + init_arg => 'associated_methods', + reader => { 'associated_methods' => \&Class::MOP::Attribute::associated_methods }, + default => sub { [] } + )) +); # NOTE: (meta-circularity) # This should be one of the last things done @@ -149,6 +362,11 @@ Class::MOP::Attribute->meta->add_method('new' => sub { || confess "You must provide a name for the attribute"; $options{init_arg} = $name if not exists $options{init_arg}; + + (Class::MOP::Attribute::is_default_a_coderef(\%options)) + || confess("References are not allowed as default values, you must ". + "wrap then in a CODE reference (ex: sub { [] } and not [])") + if exists $options{default} && ref $options{default}; # return the new object $class->meta->new_object(name => $name, %options); @@ -156,16 +374,122 @@ Class::MOP::Attribute->meta->add_method('new' => sub { Class::MOP::Attribute->meta->add_method('clone' => sub { my $self = shift; - my $class = $self->associated_class; - $self->detach_from_class() if defined $class; - my $clone = $self->meta->clone_object($self, @_); - if (defined $class) { - $self->attach_to_class($class); - $clone->attach_to_class($class); - } - return $clone; + $self->meta->clone_object($self, @_); }); +## -------------------------------------------------------- +## Class::MOP::Method + +Class::MOP::Method->meta->add_attribute( + Class::MOP::Attribute->new('&!body' => ( + init_arg => 'body', + reader => { 'body' => \&Class::MOP::Method::body }, + )) +); + +## -------------------------------------------------------- +## Class::MOP::Method::Wrapped + +# NOTE: +# the way this item is initialized, this +# really does not follow the standard +# practices of attributes, but we put +# it here for completeness +Class::MOP::Method::Wrapped->meta->add_attribute( + Class::MOP::Attribute->new('%!modifier_table') +); + +## -------------------------------------------------------- +## Class::MOP::Method::Accessor + +Class::MOP::Method::Accessor->meta->add_attribute( + Class::MOP::Attribute->new('$!attribute' => ( + init_arg => 'attribute', + reader => { + 'associated_attribute' => \&Class::MOP::Method::Accessor::associated_attribute + }, + )) +); + +Class::MOP::Method::Accessor->meta->add_attribute( + Class::MOP::Attribute->new('$!accessor_type' => ( + init_arg => 'accessor_type', + reader => { 'accessor_type' => \&Class::MOP::Method::Accessor::accessor_type }, + )) +); + +Class::MOP::Method::Accessor->meta->add_attribute( + Class::MOP::Attribute->new('$!is_inline' => ( + init_arg => 'is_inline', + reader => { 'is_inline' => \&Class::MOP::Method::Accessor::is_inline }, + )) +); + +## -------------------------------------------------------- +## Class::MOP::Method::Constructor + +Class::MOP::Method::Constructor->meta->add_attribute( + Class::MOP::Attribute->new('%!options' => ( + init_arg => 'options', + reader => { + 'options' => \&Class::MOP::Method::Constructor::options + }, + )) +); + +Class::MOP::Method::Constructor->meta->add_attribute( + Class::MOP::Attribute->new('$!associated_metaclass' => ( + init_arg => 'metaclass', + reader => { + 'associated_metaclass' => \&Class::MOP::Method::Constructor::associated_metaclass + }, + )) +); + +## -------------------------------------------------------- +## Class::MOP::Instance + +# NOTE: +# these don't yet do much of anything, but are just +# included for completeness + +Class::MOP::Instance->meta->add_attribute( + Class::MOP::Attribute->new('$!meta') +); + +Class::MOP::Instance->meta->add_attribute( + Class::MOP::Attribute->new('@!slots') +); + +## -------------------------------------------------------- +## Now close all the Class::MOP::* classes + +# NOTE: +# we don't need to inline the +# constructors or the accessors +# this only lengthens the compile +# time of the MOP, and gives us +# no actual benefits. + +$_->meta->make_immutable( + inline_constructor => 0, + inline_accessors => 0, +) for qw/ + Class::MOP::Package + Class::MOP::Module + Class::MOP::Class + + Class::MOP::Attribute + Class::MOP::Method + Class::MOP::Instance + + Class::MOP::Object + + Class::MOP::Method::Accessor + Class::MOP::Method::Constructor + Class::MOP::Method::Wrapped +/; + 1; __END__ @@ -193,6 +517,12 @@ set of extensions to the Perl 5 object system. Every attempt has been made for these tools to keep to the spirit of the Perl 5 object system that we all know and love. +This documentation is admittedly sparse on details, as time permits +I will try to improve them. For now, I suggest looking at the items +listed in the L section for more information. In particular +the book "The Art of the Meta Object Protocol" was very influential +in the development of this system. + =head2 What is a Meta Object Protocol? A meta object protocol is an API to an object system. @@ -295,6 +625,14 @@ are interested in why this is an issue see the paper I linked to in the L section of this document. +=head2 Using custom metaclasses + +Always use the metaclass pragma when using a custom metaclass, this +will ensure the proper initialization order and not accidentely +create an incorrect type of metaclass for you. This is a very rare +problem, and one which can only occur if you are doing deep metaclass +programming. So in other words, don't worry about it. + =head1 PROTOCOLS The protocol is divided into 3 main sub-protocols: @@ -330,6 +668,42 @@ See L for more details. =back +=head1 FUNCTIONS + +Class::MOP holds a cache of metaclasses, the following are functions +(B) which can be used to access that cache. It is not +recommended that you mess with this, bad things could happen. But if +you are brave and willing to risk it, go for it. + +=over 4 + +=item B + +This will return an hash of all the metaclass instances that have +been cached by B keyed by the package name. + +=item B + +This will return an array of all the metaclass instances that have +been cached by B. + +=item B + +This will return an array of all the metaclass names that have +been cached by B. + +=item B + +=item B + +=item B + +=item B + +=item B + +=back + =head1 SEE ALSO =head2 Books @@ -390,6 +764,16 @@ L =back +=head2 Article + +=over 4 + +=item CPAN Module Review of Class::MOP + +L + +=back + =head1 SIMILAR MODULES As I have said above, this module is a class-builder-builder, so it is @@ -405,23 +789,47 @@ 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. +=head1 CODE COVERAGE + +I use L to test the code coverage of my tests, below is the +L report on this module's test suite. + + ---------------------------- ------ ------ ------ ------ ------ ------ ------ + File stmt bran cond sub pod time total + ---------------------------- ------ ------ ------ ------ ------ ------ ------ + Class/MOP.pm 97.7 100.0 88.9 94.7 100.0 3.2 96.6 + Class/MOP/Attribute.pm 75.5 77.9 82.4 88.3 100.0 4.0 81.5 + Class/MOP/Class.pm 96.9 88.8 72.1 98.2 100.0 35.8 91.4 + Class/MOP/Class/Immutable.pm 88.2 60.0 n/a 95.5 100.0 0.5 84.6 + Class/MOP/Instance.pm 86.4 75.0 33.3 86.2 100.0 1.2 87.5 + Class/MOP/Method.pm 97.5 75.0 61.5 80.6 100.0 12.7 89.7 + Class/MOP/Module.pm 100.0 n/a 55.6 100.0 100.0 0.1 90.7 + Class/MOP/Object.pm 73.3 n/a 20.0 80.0 100.0 0.1 66.7 + Class/MOP/Package.pm 94.6 71.7 33.3 100.0 100.0 42.2 87.0 + metaclass.pm 100.0 100.0 83.3 100.0 n/a 0.2 97.7 + ---------------------------- ------ ------ ------ ------ ------ ------ ------ + Total 91.3 80.4 69.8 91.9 100.0 100.0 88.1 + ---------------------------- ------ ------ ------ ------ ------ ------ ------ + =head1 ACKNOWLEDGEMENTS =over 4 -=item Rob Kinyon Erob@iinteractive.comE +=item Rob Kinyon Thanks to Rob for actually getting the development of this module kick-started. =back -=head1 AUTHOR +=head1 AUTHORS Stevan Little Estevan@iinteractive.comE +Yuval Kogman Enothingmuch@woobling.comE + =head1 COPYRIGHT AND LICENSE -Copyright 2006 by Infinity Interactive, Inc. +Copyright 2006, 2007 by Infinity Interactive, Inc. L