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;
? sub () { 0 }
: sub () { 1 };
- sub HAVE_ISAREV () {
- Carp::cluck("Class::MOP::HAVE_ISAREV is deprecated and will be removed in a future release. It has always returned 1 anyway.");
- return 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.82_01';
+our $VERSION = '0.92_01';
our $XS_VERSION = $VERSION;
$VERSION = eval $VERSION;
our $AUTHORITY = 'cpan:STEVAN';
# 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 }
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 {
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/;
}
return do {
local $@;
+ local $SIG{__DIE__};
eval { require($file) };
$@;
};
}
sub load_class {
- my $class = load_first_existing_class($_[0]);
- return get_metaclass_by_name($class) || $class;
+ load_first_existing_class($_[0]);
+
+ # 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 {
))
);
+Class::MOP::Package->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::Package::method_metaclass
+ },
+ default => 'Class::MOP::Method',
+ ))
+);
+
+Class::MOP::Package->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::Package::wrapped_method_metaclass
+ },
+ default => 'Class::MOP::Method::Wrapped',
+ ))
+);
+
## --------------------------------------------------------
## Class::MOP::Module
);
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:
);
Class::MOP::Class->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::Class::method_metaclass
- },
- default => 'Class::MOP::Method',
- ))
-);
-
-Class::MOP::Class->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::Class::wrapped_method_metaclass
- },
- default => 'Class::MOP::Method::Wrapped',
- ))
-);
-
-Class::MOP::Class->meta->add_attribute(
Class::MOP::Attribute->new('instance_metaclass' => (
reader => {
# NOTE: we need to do this in order
))
);
+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, @_);
),
);
+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
# NOTE: we don't need to inline the the accessors this only lengthens
# the compile time of the MOP, and gives us no actual benefits.
-# this is just nitpicking to ensure Class::MOP::Class->meta == ->meta->meta
-Class::MOP::Class->meta->immutable_metaclass;
-$Class::MOP::Class::immutable_metaclass_cache{"Class::MOP::Class"}{"Class::MOP::Class::Immutable::Trait"} = Class::MOP::Class::Immutable::Class::MOP::Class->meta;
-
$_->meta->make_immutable(
- inline_constructor => 1,
- replace_constructor => 1,
+ inline_constructor => 0,
constructor_name => "_new",
inline_accessors => 0,
) for qw/
Class::MOP::Package
Class::MOP::Module
Class::MOP::Class
- Class::MOP::Class::Immutable::Trait
- Class::MOP::Class::Immutable::Class::MOP::Class
Class::MOP::Attribute
Class::MOP::Method
=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.
+
+If the module cannot be loaded, an exception is thrown.
+
+For historical reasons, this function returns explicitly returns a true value.
=item B<Class::MOP::is_class_loaded($class_name)>
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)>
=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)>
=over 4
-=item L<http://svn.openfoundry.org/pugs/perl5/Perl6-MetaModel>
+=item L<http://svn.openfoundry.org/pugs/misc/Perl-MetaModel/>
=item L<http://svn.openfoundry.org/pugs/perl5/Perl6-ObjectSpace>
=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
Guillermo (groditi) Roditi
+Dave (autarch) Rolsky
+
Matt (mst) Trout
Rob (robkinyon) Kinyon
Scott (konobi) McWhirter
+Dylan Hardison
+
=head1 COPYRIGHT AND LICENSE
Copyright 2006-2009 by Infinity Interactive, Inc.
projects / gitmo/Class-MOP.git / blobdiff