X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FClass%2FMOP.pm;h=9b341f73b2a7baa8cbcbbce8f87f007aaa8fb837;hb=2367814a108bbb85efbf76b57fc58bf464d68455;hp=f40f794b3280ed81cec19869e32ee1dfcbd2904a;hpb=651955fb509042e19195fe9c926a84c4e8b8bfe1;p=gitmo%2FClass-MOP.git

diff --git a/lib/Class/MOP.pm b/lib/Class/MOP.pm
index f40f794..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
@@ -147,14 +360,136 @@ Class::MOP::Attribute->meta->add_method('new' => sub {
         
     (defined $name && $name)
         || confess "You must provide a name for the attribute";
-    (!exists $options{reader} && !exists $options{writer})
-        || confess "You cannot declare an accessor and reader and/or writer functions"
-            if exists $options{accessor};
-    $options{init_arg} = $name if not exists $options{init_arg};
+    $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};        
 
-    bless $class->meta->construct_instance(name => $name, %options) => blessed($class) || $class;
+    # return the new object
+    $class->meta->new_object(name => $name, %options);
 });
 
+Class::MOP::Attribute->meta->add_method('clone' => sub {
+    my $self  = shift;
+    $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__
@@ -182,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<SEE ALSO> 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. 
@@ -249,6 +590,49 @@ B<any> drain at all upon your code's performance. In fact, by itself
 it does nothing to affect your existing code. So you only pay for 
 what you actually use.
 
+=head2 About Metaclass compatibility
+
+This module makes sure that all metaclasses created are both upwards 
+and downwards compatible. The topic of metaclass compatibility is 
+highly esoteric and is something only encountered when doing deep and 
+involved metaclass hacking. There are two basic kinds of metaclass 
+incompatibility; upwards and downwards. 
+
+Upwards metaclass compatibility means that the metaclass of a 
+given class is either the same as (or a subclass of) all of the 
+class's ancestors.
+
+Downward metaclass compatibility means that the metaclasses of a 
+given class's anscestors are all either the same as (or a subclass 
+of) that metaclass.
+
+Here is a diagram showing a set of two classes (C<A> and C<B>) and 
+two metaclasses (C<Meta::A> and C<Meta::B>) which have correct  
+metaclass compatibility both upwards and downwards.
+
+    +---------+     +---------+
+    | Meta::A |<----| Meta::B |      <....... (instance of  )
+    +---------+     +---------+      <------- (inherits from)  
+         ^               ^
+         :               :
+    +---------+     +---------+
+    |    A    |<----|    B    |
+    +---------+     +---------+
+
+As I said this is a highly esoteric topic and one you will only run 
+into if you do a lot of subclassing of B<Class::MOP::Class>. If you 
+are interested in why this is an issue see the paper 
+I<Uniform and safe metaclass composition> linked to in the 
+L<SEE ALSO> 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:
@@ -284,6 +668,42 @@ See L<Class::MOP::Method> for more details.
 
 =back
 
+=head1 FUNCTIONS
+
+Class::MOP holds a cache of metaclasses, the following are functions 
+(B<not methods>) 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<get_all_metaclasses>
+
+This will return an hash of all the metaclass instances that have 
+been cached by B<Class::MOP::Class> keyed by the package name. 
+
+=item B<get_all_metaclass_instances>
+
+This will return an array of all the metaclass instances that have 
+been cached by B<Class::MOP::Class>.
+
+=item B<get_all_metaclass_names>
+
+This will return an array of all the metaclass names that have 
+been cached by B<Class::MOP::Class>.
+
+=item B<get_metaclass_by_name ($name)>
+
+=item B<store_metaclass_by_name ($name, $meta)>
+
+=item B<weaken_metaclass ($name)>
+
+=item B<does_metaclass_exist ($name)>
+
+=item B<remove_metaclass_by_name ($name)>
+
+=back
+
 =head1 SEE ALSO
 
 =head2 Books
@@ -305,6 +725,29 @@ email me and let me know, I would love to hear about them.
 
 =back
 
+=head2 Papers
+
+=over 4
+
+=item Uniform and safe metaclass composition
+
+An excellent paper by the people who brought us the original Traits paper. 
+This paper is on how Traits can be used to do safe metaclass composition, 
+and offers an excellent introduction section which delves into the topic of 
+metaclass compatibility.
+
+L<http://www.iam.unibe.ch/~scg/Archive/Papers/Duca05ySafeMetaclassTrait.pdf>
+
+=item Safe Metaclass Programming
+
+This paper seems to precede the above paper, and propose a mix-in based 
+approach as opposed to the Traits based approach. Both papers have similar 
+information on the metaclass compatibility problem space. 
+
+L<http://citeseer.ist.psu.edu/37617.html>
+
+=back
+
 =head2 Prior Art
 
 =over 4
@@ -321,36 +764,24 @@ email me and let me know, I would love to hear about them.
 
 =back
 
-=head1 SIMILAR MODULES
+=head2 Article 
 
-As I have said above, this module is a class-builder-builder, so it is 
-not the same thing as modules like L<Class::Accessor> and 
-L<Class::MethodMaker>. That being said there are very few modules on CPAN 
-with similar goals to this module. The one I have found which is most 
-like this module is L<Class::Meta>, although it's philosophy is very 
-different from this module. 
+=over 4
 
-To start with, it provides wrappers around common Perl data types, and even 
-extends those types with more specific subtypes. This module does not 
-go into that area at all. 
+=item CPAN Module Review of Class::MOP 
 
-L<Class::Meta> also seems to create it's own custom meta-object protocol, 
-which is both more restrictive and more featureful than the vanilla 
-Perl 5 one. This module attempts to model the existing Perl 5 MOP as it is.
+L<http://www.oreillynet.com/onlamp/blog/2006/06/cpan_module_review_classmop.html>
 
-It's introspection capabilities also seem to be heavily rooted in this 
-custom MOP, so that you can only introspect classes which are already 
-created with L<Class::Meta>. This module does not make such restictions.
+=back
 
-Now, all this said, L<Class::Meta> is much more featureful than B<Class::MOP> 
-would ever try to be. But B<Class::MOP> has some features which L<Class::Meta>
-could not easily implement. It would be very possible to completely re-implement 
-L<Class::Meta> using B<Class::MOP> and bring some of these features to 
-L<Class::Meta> though. 
+=head1 SIMILAR MODULES
 
-But in the end, this module's admitedly ambitious goals have no direct equal 
-on CPAN since surely no one has been crazy enough to try something as silly 
-as this ;) until now.
+As I have said above, this module is a class-builder-builder, so it is 
+not the same thing as modules like L<Class::Accessor> and 
+L<Class::MethodMaker>. That being said there are very few modules on CPAN 
+with similar goals to this module. The one I have found which is most 
+like this module is L<Class::Meta>, although it's philosophy and the MOP it 
+creates are very different from this modules. 
 
 =head1 BUGS
 
@@ -358,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<Devel::Cover> to test the code coverage of my tests, below is the 
+L<Devel::Cover> 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 E<lt>rob@iinteractive.comE<gt>
+=item Rob Kinyon
 
 Thanks to Rob for actually getting the development of this module kick-started. 
 
 =back
 
-=head1 AUTHOR
+=head1 AUTHORS
 
 Stevan Little E<lt>stevan@iinteractive.comE<gt>
 
+Yuval Kogman E<lt>nothingmuch@woobling.comE<gt>
+
 =head1 COPYRIGHT AND LICENSE
 
-Copyright 2006 by Infinity Interactive, Inc.
+Copyright 2006, 2007 by Infinity Interactive, Inc.
 
 L<http://www.iinteractive.com>