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=227313e4bb060b3a85a2a1fb065f153bacd7acae;hp=51e1a6d116fd611e74ab90984788af0cc8eff117;hb=034587d897c53d4df84085a9229334bd2d51f1c6;hpb=8e64d0fa5da64639074f77d3da9b2f7aa20cce93 diff --git a/lib/Mouse/Meta/Module.pm b/lib/Mouse/Meta/Module.pm index 51e1a6d..227313e 100755 --- a/lib/Mouse/Meta/Module.pm +++ b/lib/Mouse/Meta/Module.pm @@ -1,71 +1,67 @@ package Mouse::Meta::Module; -use strict; -use warnings; +use Mouse::Util qw/:meta get_code_package load_class not_supported/; # enables strict and warnings use Carp (); use Scalar::Util qw/blessed weaken/; -use Mouse::Util qw/get_code_info not_supported load_class/; +my %METAS; -{ - my %METACLASS_CACHE; - - # because Mouse doesn't introspect existing classes, we're forced to - # only pay attention to other Mouse classes - sub _metaclass_cache { - my($class, $name) = @_; - return $METACLASS_CACHE{$name}; - } - - sub initialize { - my($class, $package_name, @args) = @_; +sub _metaclass_cache { # DEPRECATED + my($class, $name) = @_; + return $METAS{$name}; +} - ($package_name && !ref($package_name)) - || $class->throw_error("You must pass a package name and it cannot be blessed"); +sub initialize { + my($class, $package_name, @args) = @_; - return $METACLASS_CACHE{$package_name} - ||= $class->_construct_meta(package => $package_name, @args); - } + ($package_name && !ref($package_name)) + || $class->throw_error("You must pass a package name and it cannot be blessed"); - sub class_of{ - my($class_or_instance) = @_; - return undef unless defined $class_or_instance; - return $METACLASS_CACHE{ blessed($class_or_instance) || $class_or_instance }; - } - - # Means of accessing all the metaclasses that have - # been initialized thus far - sub get_all_metaclasses { %METACLASS_CACHE } - sub get_all_metaclass_instances { values %METACLASS_CACHE } - sub get_all_metaclass_names { keys %METACLASS_CACHE } - sub get_metaclass_by_name { $METACLASS_CACHE{$_[0]} } - sub store_metaclass_by_name { $METACLASS_CACHE{$_[0]} = $_[1] } - sub weaken_metaclass { weaken($METACLASS_CACHE{$_[0]}) } - sub does_metaclass_exist { defined $METACLASS_CACHE{$_[0]} } - sub remove_metaclass_by_name { delete $METACLASS_CACHE{$_[0]} } + return $METAS{$package_name} + ||= $class->_construct_meta(package => $package_name, @args); +} +sub class_of{ + my($class_or_instance) = @_; + return undef unless defined $class_or_instance; + return $METAS{ ref($class_or_instance) || $class_or_instance }; } -sub meta{ Mouse::Meta::Class->initialize(ref $_[0] || $_[0]) } +# Means of accessing all the metaclasses that have +# been initialized thus far +#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 { defined $METAS{$_[0]} } +#sub remove_metaclass_by_name { delete $METAS{$_[0]} } + -sub _new{ Carp::croak("Mouse::Meta::Module is an abstract class") } sub name { $_[0]->{package} } -sub version { no strict 'refs'; ${shift->name.'::VERSION'} } -sub authority { no strict 'refs'; ${shift->name.'::AUTHORITY'} } -sub identifier { - my $self = shift; - return join '-' => ( - $self->name, - ($self->version || ()), - ($self->authority || ()), - ); -} +# The followings are Class::MOP specific methods + +#sub version { no strict 'refs'; ${shift->name.'::VERSION'} } +#sub authority { no strict 'refs'; ${shift->name.'::AUTHORITY'} } +#sub identifier { +# my $self = shift; +# return join '-' => ( +# $self->name, +# ($self->version || ()), +# ($self->authority || ()), +# ); +#} # add_attribute is an abstract method -sub get_attribute_map { $_[0]->{attributes} } +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}} } @@ -81,38 +77,71 @@ sub add_method { my($self, $name, $code) = @_; if(!defined $name){ - $self->throw_error("You must pass a 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'; + $code = \&{$code}; # coerce } - $self->{methods}->{$name}++; # Moose stores meta object here. + $self->{methods}->{$name} = $code; # Moose stores meta object here. my $pkg = $self->name; no strict 'refs'; - no warnings 'redefine'; + no warnings 'redefine', 'once'; *{ $pkg . '::' . $name } = $code; } -sub _code_is_mine { # taken from Class::MOP::Class - my ( $self, $code ) = @_; +# XXX: for backward compatibility +my %foreign = map{ $_ => undef } qw( + Mouse Mouse::Role Mouse::Util Mouse::Util::TypeConstraints + Carp Scalar::Util +); +sub _code_is_mine{ + my($self, $code) = @_; - my ( $code_package, $code_name ) = get_code_info($code); + my $package = get_code_package($code); - return $code_package && $code_package eq $self->name - || ( $code_package eq 'constant' && $code_name eq '__ANON__' ); + return !exists $foreign{$package}; } sub has_method { my($self, $method_name) = @_; - return 1 if $self->{methods}->{$method_name}; - my $code = $self->name->can($method_name); + defined($method_name) + or $self->throw_error('You must define a method name'); + + return 1 if $self->{methods}{$method_name}; + + my $code = do{ + no strict 'refs'; + no warnings 'once'; + *{ $self->{package} . '::' . $method_name }{CODE}; + }; return $code && $self->_code_is_mine($code); } +sub get_method_body{ + my($self, $method_name) = @_; + + defined($method_name) + or $self->throw_error('You must define a method name'); + + return $self->{methods}{$method_name} ||= do{ + my $code = do{ + no strict 'refs'; + no warnings 'once'; + *{$self->{package} . '::' . $method_name}{CODE}; + }; + + ($code && $self->_code_is_mine($code)) ? $code : undef; + }; +} + sub get_method{ my($self, $method_name) = @_; @@ -139,43 +168,42 @@ sub get_method_list { { my $ANON_SERIAL = 0; - my $ANON_PREFIX = 'Mouse::Meta::Module::__ANON__::'; my %IMMORTALS; sub create { - my ($class, $package_name, %options) = @_; - - $class->throw_error('You must pass a package name') if @_ == 1; + my($self, $package_name, %options) = @_; + 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::Class')){ - (ref $options{superclasses} eq 'ARRAY') - || $class->throw_error("You must pass an ARRAY ref of superclasses"); - } - else{ # role + if($self->isa('Mouse::Meta::Role')){ delete $options{superclasses}; } + else{ + $superclasses = delete $options{superclasses}; + (ref $superclasses eq 'ARRAY') + || $self->throw_error("You must pass an ARRAY ref of superclasses"); + } } - my $attributes; - if(exists $options{attributes}){ - $attributes = delete $options{attributes}; - (ref $attributes eq 'ARRAY' || ref $attributes eq 'HASH') - || $class->throw_error("You must pass an ARRAY ref of attributes") - } - - (ref $options{methods} eq 'HASH') - || $class->throw_error("You must pass a HASH ref of methods") - if exists $options{methods}; - - (ref $options{roles} eq 'ARRAY') - || $class->throw_error("You must pass an ARRAY ref of roles") - if exists $options{roles}; - - - my @extra_options; + my $attributes = delete $options{attributes}; + if(defined $attributes){ + (ref $attributes eq 'ARRAY' || ref $attributes eq 'HASH') + || $self->throw_error("You must pass an ARRAY ref of attributes"); + } + my $methods = delete $options{methods}; + if(defined $methods){ + (ref $methods eq 'HASH') + || $self->throw_error("You must pass a HASH ref of methods"); + } + my $roles = delete $options{roles}; + if(defined $roles){ + (ref $roles eq 'ARRAY') + || $self->throw_error("You must pass an ARRAY ref of roles"); + } my $mortal; my $cache_key; @@ -186,14 +214,13 @@ sub get_method_list { if(!$mortal){ # something like Super::Class|Super::Class::2=Role|Role::1 $cache_key = join '=' => ( - join('|', @{$options{superclasses} || []}), - join('|', sort @{$options{roles} || []}), + join('|', @{$superclasses || []}), + join('|', sort @{$roles || []}), ); return $IMMORTALS{$cache_key} if exists $IMMORTALS{$cache_key}; } - $package_name = $ANON_PREFIX . ++$ANON_SERIAL; - - push @extra_options, (anon_serial_id => $ANON_SERIAL); + $options{anon_serial_id} = ++$ANON_SERIAL; + $package_name = $class . '::__ANON__::' . $ANON_SERIAL; } # instantiate a module @@ -203,26 +230,17 @@ sub get_method_list { ${ $package_name . '::AUTHORITY' } = delete $options{authority} if exists $options{authority}; } - my %initialize_options = %options; - delete @initialize_options{qw( - package - superclasses - attributes - methods - roles - )}; - my $meta = $class->initialize( $package_name, %initialize_options, @extra_options); - - Mouse::Meta::Module::weaken_metaclass($package_name) + my $meta = $self->initialize( $package_name, %options); + + 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(@{$options{superclasses}}) - if exists $options{superclasses}; + $meta->superclasses(@{$superclasses}) + if defined $superclasses; # NOTE: # process attributes first, so that they can @@ -231,26 +249,28 @@ sub get_method_list { # I think this should be the order of things. if (defined $attributes) { if(ref($attributes) eq 'ARRAY'){ + # array of Mouse::Meta::Attribute foreach my $attr (@{$attributes}) { - $meta->add_attribute($attr->{name} => $attr); + $meta->add_attribute($attr); } } else{ + # hash map of name and attribute spec pairs while(my($name, $attr) = each %{$attributes}){ $meta->add_attribute($name => $attr); } } } - if (exists $options{methods}) { - foreach my $method_name (keys %{$options{methods}}) { - $meta->add_method($method_name, $options{methods}->{$method_name}); + if (defined $methods) { + while(my($method_name, $method_body) = each %{$methods}){ + $meta->add_method($method_name, $method_body); } } - if (exists $options{roles}){ - Mouse::Util::apply_all_roles($package_name, @{$options{roles}}); + if (defined $roles){ + Mouse::Util::apply_all_roles($package_name, @{$roles}); } - if(!$mortal && exists $meta->{anon_serial_id}){ + if($cache_key){ $IMMORTALS{$cache_key} = $meta; } @@ -264,14 +284,19 @@ sub get_method_list { return if !$serial_id; - my $stash = $self->namespace; - + # @ISA is a magical variable, so we clear it manually. @{$self->{superclasses}} = () if exists $self->{superclasses}; - %{$stash} = (); - Mouse::Meta::Module::remove_metaclass_by_name($self->name); + + # Then, clear the symbol table hash + %{$self->namespace} = (); + + my $name = $self->name; + delete $METAS{$name}; + + $name =~ s/ $serial_id \z//xms; no strict 'refs'; - delete ${$ANON_PREFIX}{ $serial_id . '::' }; + delete ${$name}{ $serial_id . '::' }; return; } @@ -297,6 +322,19 @@ __END__ =head1 NAME -Mouse::Meta::Module - Common base class for Mouse::Meta::Class and Mouse::Meta::Role +Mouse::Meta::Module - The base class for Mouse::Meta::Class and Mouse::Meta::Role + +=head1 VERSION + +This document describes Mouse version 0.40 + +=head1 SEE ALSO + +L + +L + +L =cut +