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=14990eef7b39f4f87962dd588d8b598051469f36;hp=3069250c9ea82985882bb9be69eda2abaef5a2bd;hb=70a922201a3b13a22b86ea918f53d3b964c377c7;hpb=71e7b544ac5b18ce7b09b9a95723b1a4e28b4321 diff --git a/lib/Mouse/Meta/Module.pm b/lib/Mouse/Meta/Module.pm index 3069250..14990ee 100755 --- a/lib/Mouse/Meta/Module.pm +++ b/lib/Mouse/Meta/Module.pm @@ -1,13 +1,22 @@ package Mouse::Meta::Module; -use Mouse::Util qw/:meta get_code_package load_class not_supported/; # enables strict and warnings +use Mouse::Util qw/:meta get_code_package get_code_ref not_supported/; # enables strict and warnings -use Carp (); -use Scalar::Util qw/blessed weaken/; +use Carp (); +use Scalar::Util (); my %METAS; +if(Mouse::Util::MOUSE_XS){ + # register meta storage for performance + Mouse::Util::__register_metaclass_storage(\%METAS, 0); + + # ensure thread safety + *CLONE = sub { Mouse::Util::__register_metaclass_storage(\%METAS, 1) }; +} + sub _metaclass_cache { # DEPRECATED my($class, $name) = @_; + Carp::cluck('_metaclass_cache() has been deprecated. Use Mouse::Util::get_metaclass_by_name() instead'); return $METAS{$name}; } @@ -21,7 +30,19 @@ sub initialize { ||= $class->_construct_meta(package => $package_name, @args); } -sub class_of{ +sub reinitialize { + my($class, $package_name, @args) = @_; + + $package_name = $package_name->name if ref $package_name; + + ($package_name && !ref($package_name)) + || $class->throw_error("You must pass a package name and it cannot be blessed"); + + delete $METAS{$package_name}; + return $class->initialize($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 }; @@ -29,123 +50,78 @@ sub class_of{ # 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 _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 name { $_[0]->{package} } +sub name; -# 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 || ()), -# ); -#} +sub namespace; # add_attribute is an abstract method sub get_attribute_map { # DEPRECATED - Carp::cluck('get_attribute_map() has been deprecated'); + Carp::cluck('get_attribute_map() has been deprecated. Use get_attribute_list() and get_attribute() instead'); 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) = @_; - - 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'){ - $code = \&{$code}; # coerce - } - - $self->{methods}->{$name} = $code; # Moose stores meta object here. - - my $pkg = $self->name; - no strict 'refs'; - no warnings 'redefine'; - *{ $pkg . '::' . $name } = $code; -} +sub get_attribute_list{ keys %{$_[0]->{attributes}} } # 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($self, $code) = @_; - my $package = get_code_package($code); - - return !exists $foreign{$package}; + return !exists $foreign{ get_code_package($_[1]) }; } +sub add_method; + sub has_method { my($self, $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'; *{$self->{package} . '::' . $method_name}{CODE} }; - - return $code && $self->_code_is_mine($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{ +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'; *{$self->{package} . '::' . $method_name}{CODE} }; - - $code && $self->_code_is_mine($code) && $code; + 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)){ - 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, + if(my $code = $self->get_method_body($method_name)){ + return Mouse::Util::load_class($self->method_metaclass)->wrap( + body => $code, + name => $method_name, + package => $self->name, + associated_metaclass => $self, ); } @@ -158,140 +134,170 @@ sub get_method_list { return grep { $self->has_method($_) } keys %{ $self->namespace }; } -{ - my $ANON_SERIAL = 0; +sub _collect_methods { # Mouse specific + my($meta, @args) = @_; - my %IMMORTALS; - - sub create { - 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($self->isa('Mouse::Meta::Role')){ - delete $options{superclasses}; + my @methods; + foreach my $arg(@args){ + if(my $type = ref $arg){ + if($type eq 'Regexp'){ + push @methods, grep { $_ =~ $arg } $meta->get_all_method_names; + } + elsif($type eq 'ARRAY'){ + push @methods, @{$arg}; } else{ - $superclasses = delete $options{superclasses}; - (ref $superclasses eq 'ARRAY') - || $self->throw_error("You must pass an ARRAY ref of superclasses"); + my $subname = ( caller(1) )[3]; + $meta->throw_error( + sprintf( + 'Methods passed to %s must be provided as a list, ArrayRef or regular expression, not %s', + $subname, + $type, + ) + ); } - } + } + else{ + push @methods, $arg; + } + } + return @methods; +} - 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 $ANON_SERIAL = 0; # anonymous class/role id +my %IMMORTALS; # immortal anonymous classes + +sub create { + 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(Mouse::Util::is_a_metarole($self)){ + delete $options{superclasses}; } - my $mortal; - my $cache_key; - - if(!defined $package_name){ # anonymous - $mortal = !$options{cache}; - - # anonymous but immortal - if(!$mortal){ - # something like Super::Class|Super::Class::2=Role|Role::1 - $cache_key = join '=' => ( - join('|', @{$superclasses || []}), - join('|', sort @{$roles || []}), - ); - return $IMMORTALS{$cache_key} if exists $IMMORTALS{$cache_key}; - } - $options{anon_serial_id} = ++$ANON_SERIAL; - $package_name = $class . '::__ANON__::' . $ANON_SERIAL; + else{ + $superclasses = delete $options{superclasses}; + (ref $superclasses eq 'ARRAY') + || $self->throw_error("You must pass an ARRAY ref of superclasses"); } + } - # instantiate a module - { - no strict 'refs'; - ${ $package_name . '::VERSION' } = delete $options{version} if exists $options{version}; - ${ $package_name . '::AUTHORITY' } = delete $options{authority} if exists $options{authority}; + 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; + + if(!defined $package_name){ # anonymous + $mortal = !$options{cache}; + + # anonymous but immortal + if(!$mortal){ + # something like Super::Class|Super::Class::2=Role|Role::1 + $cache_key = join '=' => ( + join('|', @{$superclasses || []}), + join('|', sort @{$roles || []}), + ); + return $IMMORTALS{$cache_key} if exists $IMMORTALS{$cache_key}; } + $options{anon_serial_id} = ++$ANON_SERIAL; + $package_name = $class . '::__ANON__::' . $ANON_SERIAL; + } - my $meta = $self->initialize( $package_name, %options); - - weaken $METAS{$package_name} - if $mortal; - - $meta->add_method(meta => sub{ - $self->initialize(ref($_[0]) || $_[0]); - }); - - $meta->superclasses(@{$superclasses}) - if defined $superclasses; - - # NOTE: - # process attributes first, so that they can - # install accessors, but locally defined methods - # can then overwrite them. It is maybe a little odd, but - # 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); - } - } - else{ - # hash map of name and attribute spec pairs - while(my($name, $attr) = each %{$attributes}){ - $meta->add_attribute($name => $attr); - } + # instantiate a module + { + no strict 'refs'; + ${ $package_name . '::VERSION' } = delete $options{version} if exists $options{version}; + ${ $package_name . '::AUTHORITY' } = delete $options{authority} if exists $options{authority}; + } + + my $meta = $self->initialize( $package_name, %options); + + Scalar::Util::weaken $METAS{$package_name} + if $mortal; + + $meta->add_method(meta => sub{ + $self->initialize(ref($_[0]) || $_[0]); + }); + + $meta->superclasses(@{$superclasses}) + if defined $superclasses; + + # NOTE: + # process attributes first, so that they can + # install accessors, but locally defined methods + # can then overwrite them. It is maybe a little odd, but + # 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); } } - if (defined $methods) { - while(my($method_name, $method_body) = each %{$methods}){ - $meta->add_method($method_name, $method_body); + else{ + # hash map of name and attribute spec pairs + while(my($name, $attr) = each %{$attributes}){ + $meta->add_attribute($name => $attr); } } - if (defined $roles){ - Mouse::Util::apply_all_roles($package_name, @{$roles}); - } - - if($cache_key){ - $IMMORTALS{$cache_key} = $meta; + } + if (defined $methods) { + while(my($method_name, $method_body) = each %{$methods}){ + $meta->add_method($method_name, $method_body); } + } + if (defined $roles){ + Mouse::Util::apply_all_roles($package_name, @{$roles}); + } - return $meta; + if($cache_key){ + $IMMORTALS{$cache_key} = $meta; } - sub DESTROY{ - my($self) = @_; + return $meta; +} + +sub DESTROY{ + my($self) = @_; - my $serial_id = $self->{anon_serial_id}; + return if $Mouse::Util::in_global_destruction; - return if !$serial_id; + my $serial_id = $self->{anon_serial_id}; - # @ISA is a magical variable, so we clear it manually. - @{$self->{superclasses}} = () if exists $self->{superclasses}; + return if !$serial_id; + # mortal anonymous class - # Then, clear the symbol table hash - %{$self->namespace} = (); + # @ISA is a magical variable, so we clear it manually. + @{$self->{superclasses}} = () if exists $self->{superclasses}; - my $name = $self->name; - delete $METAS{$name}; + # Then, clear the symbol table hash + %{$self->namespace} = (); - $name =~ s/ $serial_id \z//xms; + my $name = $self->name; + delete $METAS{$name}; - no strict 'refs'; - delete ${$name}{ $serial_id . '::' }; + $name =~ s/ $serial_id \z//xms; - return; - } + no strict 'refs'; + delete ${$name}{ $serial_id . '::' }; + + return; } sub throw_error{ @@ -309,13 +315,16 @@ sub throw_error{ } 1; - __END__ =head1 NAME Mouse::Meta::Module - The base class for Mouse::Meta::Class and Mouse::Meta::Role +=head1 VERSION + +This document describes Mouse version 0.50_03 + =head1 SEE ALSO L