X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?p=gitmo%2FMouse.git;a=blobdiff_plain;f=lib%2FMouse%2FMeta%2FModule.pm;h=ab2fd6a92c2e4ca832989a69a0e375f6bc744bf6;hp=6079af6424abe3657fb1dfebde4674f408c32020;hb=1e5823974a557bd35b4aa4a5c1d1aecf1e5483d2;hpb=8f40866cc6380d49a06070391bba6abde2eebd2d diff --git a/lib/Mouse/Meta/Module.pm b/lib/Mouse/Meta/Module.pm index 6079af6..ab2fd6a 100755 --- a/lib/Mouse/Meta/Module.pm +++ b/lib/Mouse/Meta/Module.pm @@ -1,18 +1,20 @@ package Mouse::Meta::Module; -use strict; -use warnings; +use Mouse::Util qw/:meta get_code_package get_code_ref load_class not_supported/; # enables strict and warnings -use Carp (); -use Scalar::Util qw/blessed weaken/; +use Carp (); +use Scalar::Util (); -use Mouse::Util qw/:meta get_code_package not_supported load_class/; +my %METAS; +if(Mouse::Util::_MOUSE_XS){ + # register meta storage for performance + Mouse::Util::__register_metaclass_storage(\%METAS, 0); -my %METAS; + # ensure thread safety + *CLONE = sub { Mouse::Util::__register_metaclass_storage(\%METAS, 1) }; +} -# because Mouse doesn't introspect existing classes, we're forced to -# only pay attention to other Mouse classes -sub _metaclass_cache { +sub _metaclass_cache { # DEPRECATED my($class, $name) = @_; return $METAS{$name}; } @@ -44,9 +46,9 @@ sub get_metaclass_by_name { $METAS{$_[0]} } #sub does_metaclass_exist { defined $METAS{$_[0]} } #sub remove_metaclass_by_name { delete $METAS{$_[0]} } +sub name; - -sub name { $_[0]->{package} } +sub namespace; # The followings are Class::MOP specific methods @@ -63,79 +65,67 @@ sub name { $_[0]->{package} } # add_attribute is an abstract method -sub get_attribute_map { +sub get_attribute_map { # DEPRECATED Carp::cluck('get_attribute_map() has been deprecated'); return $_[0]->{attributes}; } sub has_attribute { exists $_[0]->{attributes}->{$_[1]} } sub get_attribute { $_[0]->{attributes}->{$_[1]} } -sub get_attribute_list{ keys %{$_[0]->{attributes}} } sub remove_attribute { delete $_[0]->{attributes}->{$_[1]} } -sub namespace{ - my $name = $_[0]->{package}; - no strict 'refs'; - return \%{ $name . '::' }; -} - -sub add_method { - my($self, $name, $code) = @_; +sub get_attribute_list{ keys %{$_[0]->{attributes}} } - if(!defined $name){ - $self->throw_error('You must pass a defined name'); - } - if(!defined $code){ - $self->throw_error('You must pass a defined code'); - } - - if(ref($code) ne 'CODE'){ - not_supported 'add_method for a method object'; - } - - $self->{methods}->{$name}++; # Moose stores meta object here. - - my $pkg = $self->name; - no strict 'refs'; - no warnings 'redefine'; - *{ $pkg . '::' . $name } = $code; -} # XXX: for backward compatibility my %foreign = map{ $_ => undef } qw( Mouse Mouse::Role Mouse::Util Mouse::Util::TypeConstraints - Carp Scalar::Util + Carp Scalar::Util List::Util ); sub _code_is_mine{ - my($self, $code) = @_; - - my $package = get_code_package($code); +# my($self, $code) = @_; - return !exists $foreign{$package}; + return !exists $foreign{ get_code_package($_[1]) }; } +sub add_method; + sub has_method { my($self, $method_name) = @_; - return 1 if $self->{methods}->{$method_name}; + defined($method_name) + or $self->throw_error('You must define a method name'); - my $code = do{ no strict 'refs'; *{$self->{package} . '::' . $method_name}{CODE} }; + return defined($self->{methods}{$method_name}) || do{ + my $code = get_code_ref($self->{package}, $method_name); + $code && $self->_code_is_mine($code); + }; +} + +sub get_method_body { + my($self, $method_name) = @_; - return $code && $self->_code_is_mine($code); + defined($method_name) + or $self->throw_error('You must define a method name'); + + return $self->{methods}{$method_name} ||= do{ + my $code = get_code_ref($self->{package}, $method_name); + $code && $self->_code_is_mine($code) ? $code : undef; + }; } sub get_method{ my($self, $method_name) = @_; - if($self->has_method($method_name)){ + if(my $code = $self->get_method_body($method_name)){ my $method_metaclass = $self->method_metaclass; load_class($method_metaclass); - my $package = $self->name; - return $method_metaclass->new( - body => $package->can($method_name), - name => $method_name, - package => $package, + return $method_metaclass->wrap( + body => $code, + name => $method_name, + package => $self->name, + associated_metaclass => $self, ); } @@ -154,36 +144,37 @@ sub get_method_list { my %IMMORTALS; sub create { - my($class, $package_name, %options) = @_; + my($self, $package_name, %options) = @_; - $class->throw_error('You must pass a package name') if @_ < 2; + my $class = ref($self) || $self; + $self->throw_error('You must pass a package name') if @_ < 2; my $superclasses; if(exists $options{superclasses}){ - if($class->isa('Mouse::Meta::Role')){ + if(Mouse::Util::is_a_metarole($self)){ delete $options{superclasses}; } else{ $superclasses = delete $options{superclasses}; (ref $superclasses eq 'ARRAY') - || $class->throw_error("You must pass an ARRAY ref of superclasses"); + || $self->throw_error("You must pass an ARRAY ref of superclasses"); } } my $attributes = delete $options{attributes}; if(defined $attributes){ (ref $attributes eq 'ARRAY' || ref $attributes eq 'HASH') - || $class->throw_error("You must pass an ARRAY ref of attributes"); + || $self->throw_error("You must pass an ARRAY ref of attributes"); } my $methods = delete $options{methods}; if(defined $methods){ (ref $methods eq 'HASH') - || $class->throw_error("You must pass a HASH ref of methods"); + || $self->throw_error("You must pass a HASH ref of methods"); } my $roles = delete $options{roles}; if(defined $roles){ (ref $roles eq 'ARRAY') - || $class->throw_error("You must pass an ARRAY ref of roles"); + || $self->throw_error("You must pass an ARRAY ref of roles"); } my $mortal; my $cache_key; @@ -211,14 +202,13 @@ sub get_method_list { ${ $package_name . '::AUTHORITY' } = delete $options{authority} if exists $options{authority}; } - my $meta = $class->initialize( $package_name, %options); + my $meta = $self->initialize( $package_name, %options); - weaken $METAS{$package_name} + Scalar::Util::weaken $METAS{$package_name} if $mortal; - # FIXME totally lame - $meta->add_method('meta' => sub { - $class->initialize(ref($_[0]) || $_[0]); + $meta->add_method(meta => sub{ + $self->initialize(ref($_[0]) || $_[0]); }); $meta->superclasses(@{$superclasses}) @@ -266,16 +256,18 @@ sub get_method_list { return if !$serial_id; - @{$self->{superclasses}} = (); # clear @ISA - %{$self->namespace} = (); # clear the stash + # @ISA is a magical variable, so we clear it manually. + @{$self->{superclasses}} = () if exists $self->{superclasses}; + + # Then, clear the symbol table hash + %{$self->namespace} = (); my $name = $self->name; delete $METAS{$name}; - $name =~ s/::\d+$//; + $name =~ s/ $serial_id \z//xms; no strict 'refs'; - delete ${$name}{ $serial_id . '::' }; return; @@ -304,6 +296,10 @@ __END__ Mouse::Meta::Module - The base class for Mouse::Meta::Class and Mouse::Meta::Role +=head1 VERSION + +This document describes Mouse version 0.40_06 + =head1 SEE ALSO L