X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FClass%2FMOP.pm;h=cf8048991c0d5ae834c41197078cc6294cd3c8a1;hb=7fe2c0b65ce511286856916fc8f245d2d3bc4f9c;hp=ab68861647c6ed54568539e0c15cb7660e8e0cf3;hpb=c2b256bcad1d06cf1cfa03fd95b76faef16c70ea;p=gitmo%2FClass-MOP.git

diff --git a/lib/Class/MOP.pm b/lib/Class/MOP.pm
index ab68861..cf80489 100644
--- a/lib/Class/MOP.pm
+++ b/lib/Class/MOP.pm
@@ -9,23 +9,19 @@ use 5.008;
 use MRO::Compat;
 
 use Carp          'confess';
-use Devel::GlobalDestruction qw( in_global_destruction );
 use Scalar::Util  'weaken', 'reftype', 'blessed';
-use Sub::Name qw( subname );
 
 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 };    
+        : sub () { 1 };
 
     sub HAVE_ISAREV () {
-        warn "Class::MOP::HAVE_ISAREV is deprecated and will be removed in a future release. It has always returned 1 anyway.";
+        Carp::cluck("Class::MOP::HAVE_ISAREV is deprecated and will be removed in a future release. It has always returned 1 anyway.");
         return 1;
     }
 
@@ -33,10 +29,10 @@ BEGIN {
     *check_package_cache_flag = \&mro::get_pkg_gen;
 }
 
-our $VERSION   = '0.80';
+our $VERSION   = '0.89';
 our $XS_VERSION = $VERSION;
 $VERSION = eval $VERSION;
-our $AUTHORITY = 'cpan:STEVAN';    
+our $AUTHORITY = 'cpan:STEVAN';
 
 require XSLoader;
 XSLoader::load( __PACKAGE__, $XS_VERSION );
@@ -47,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         }
@@ -58,10 +53,11 @@ 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};
     }
@@ -96,10 +92,10 @@ sub load_first_existing_class {
     my $found;
     my %exceptions;
     for my $class (@classes) {
-        my $pmfile = _class_to_pmfile($class);
         my $e = _try_load_one_class($class);
 
         if ($e) {
+            my $pmfile = _class_to_pmfile($class);
             $exceptions{$class} = $e;
             last if $e !~ /^Can't locate \Q$pmfile\E in \@INC/;
         }
@@ -134,6 +130,7 @@ sub _try_load_one_class {
 
     return do {
         local $@;
+        local $SIG{__DIE__};
         eval { require($file) };
         $@;
     };
@@ -156,6 +153,18 @@ sub _is_valid_class_name {
     return 0;
 }
 
+sub subname {
+    require Sub::Name;
+    Carp::carp("Class::MOP::subname is deprecated. Please use Sub::Name directly.");
+    goto \&Sub::Name::subname;
+}
+
+sub in_global_destruction {
+    require Devel::GlobalDestruction;
+    Carp::carp("Class::MOP::in_global_destruction is deprecated. Please use Devel::GlobalDestruction directly.");
+    goto \&Devel::GlobalDestruction::in_global_destruction;
+}
+
 ## ----------------------------------------------------------------------------
 ## Setting up our environment ...
 ## ----------------------------------------------------------------------------
@@ -350,12 +359,37 @@ Class::MOP::Class->meta->add_attribute(
 );
 
 Class::MOP::Class->meta->add_attribute(
-    Class::MOP::Attribute->new('immutable_transformer' => (
+    Class::MOP::Attribute->new('immutable_trait' => (
         reader   => {
-            'immutable_transformer' => \&Class::MOP::Class::immutable_transformer
+            'immutable_trait' => \&Class::MOP::Class::immutable_trait
         },
-        writer   => {
-            '_set_immutable_transformer' => \&Class::MOP::Class::_set_immutable_transformer
+        default => "Class::MOP::Class::Immutable::Trait",
+    ))
+);
+
+Class::MOP::Class->meta->add_attribute(
+    Class::MOP::Attribute->new('constructor_name' => (
+        reader   => {
+            'constructor_name' => \&Class::MOP::Class::constructor_name,
+        },
+        default => "new",
+    ))
+);
+
+Class::MOP::Class->meta->add_attribute(
+    Class::MOP::Attribute->new('constructor_class' => (
+        reader   => {
+            'constructor_class' => \&Class::MOP::Class::constructor_class,
+        },
+        default => "Class::MOP::Method::Constructor",
+    ))
+);
+
+
+Class::MOP::Class->meta->add_attribute(
+    Class::MOP::Attribute->new('destructor_class' => (
+        reader   => {
+            'destructor_class' => \&Class::MOP::Class::destructor_class,
         },
     ))
 );
@@ -473,6 +507,14 @@ Class::MOP::Attribute->meta->add_attribute(
     ))
 );
 
+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->meta->add_method('clone' => sub {
     my $self  = shift;
     $self->meta->clone_object($self, @_);
@@ -546,6 +588,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
 
@@ -639,8 +691,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/
@@ -655,6 +706,7 @@ $_->meta->make_immutable(
     Class::MOP::Object
 
     Class::MOP::Method::Generated
+    Class::MOP::Method::Inlined
 
     Class::MOP::Method::Accessor
     Class::MOP::Method::Constructor
@@ -872,9 +924,11 @@ Note that these are all called as B<functions, not methods>.
 
 =item B<Class::MOP::load_class($class_name)>
 
-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<is_class_loaded>). This function can be used
 in place of tricks like C<eval "use $module"> or using C<require>
-unconditionally. This will return the metaclass of C<$class_name>.
+unconditionally. This will return the metaclass of C<$class_name> if
+one exists, otherwise it will return C<$class_name>.
 
 =item B<Class::MOP::is_class_loaded($class_name)>
 
@@ -884,7 +938,9 @@ 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<IO> modules will
+cause most of the rest of the core L<IO> modules to falsely report
+having been loaded, due to the way the base L<IO> module works.
 
 =item B<Class::MOP::get_code_info($code)>
 
@@ -895,9 +951,9 @@ from.
 
 =item B<Class::MOP::class_of($instance_or_class_name)>
 
-This will return the metaclass of the given instance or class name.
-Even if the class lacks a metaclass, no metaclass will be initialized
-and C<undef> will be returned.
+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<undef> will be
+returned.
 
 =item B<Class::MOP::check_package_cache_flag($pkg)>
 
@@ -1055,8 +1111,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<bug-class-mop@rt.cpan.org>, or through the
+web interface at L<http://rt.cpan.org>.
+
+You can also discuss feature requests or possible bugs on the Moose
+mailing list (moose@perl.org) or on IRC at
+L<irc://irc.perl.org/#moose>.
 
 =head1 ACKNOWLEDGEMENTS
 
@@ -1080,6 +1142,8 @@ Florian (rafl) Ragwitz
 
 Guillermo (groditi) Roditi
 
+Dave (autarch) Rolsky
+
 Matt (mst) Trout
 
 Rob (robkinyon) Kinyon
@@ -1088,6 +1152,8 @@ Yuval (nothingmuch) Kogman
 
 Scott (konobi) McWhirter
 
+Dylan Hardison
+
 =head1 COPYRIGHT AND LICENSE
 
 Copyright 2006-2009 by Infinity Interactive, Inc.