use Sub::Name 'subname';
use Devel::GlobalDestruction 'in_global_destruction';
-our $VERSION = '0.80';
+our $VERSION = '0.89_02';
$VERSION = eval $VERSION;
our $AUTHORITY = 'cpan:STEVAN';
default => 'Moose::Meta::Role::Method::Conflicting',
);
+$META->add_attribute(
+ 'application_to_class_class',
+ reader => 'application_to_class_class',
+ default => 'Moose::Meta::Role::Application::ToClass',
+);
+
+$META->add_attribute(
+ 'application_to_role_class',
+ reader => 'application_to_role_class',
+ default => 'Moose::Meta::Role::Application::ToRole',
+);
+
+$META->add_attribute(
+ 'application_to_instance_class',
+ reader => 'application_to_instance_class',
+ default => 'Moose::Meta::Role::Application::ToInstance',
+);
+
+$META->add_attribute(
+ 'composition_class_roles',
+ reader => 'composition_class_roles',
+ predicate => 'has_composition_class_roles',
+);
+
## some things don't always fit, so they go here ...
sub add_attribute {
my $self = shift;
my $name = shift;
- unless ( defined $name && $name ) {
+ unless ( defined $name ) {
require Moose;
Moose->throw_error("You must provide a name for the attribute");
}
$META->add_method("get_${modifier_type}_method_modifiers" => sub {
my ($self, $method_name) = @_;
#return () unless exists $self->$attr_reader->{$method_name};
- @{$self->$attr_reader->{$method_name}};
+ my $mm = $self->$attr_reader->{$method_name};
+ $mm ? @$mm : ();
});
$META->add_method("has_${modifier_type}_method_modifiers" => sub {
return 0;
}
-## ------------------------------------------------------------------
-## methods
-
-sub get_method_map {
- my $self = shift;
-
- my $current = Class::MOP::check_package_cache_flag($self->name);
-
- if (defined $self->{'_package_cache_flag'} && $self->{'_package_cache_flag'} == $current) {
- return $self->{'methods'} ||= {};
- }
-
- $self->{_package_cache_flag} = $current;
-
- my $map = $self->{'methods'} ||= {};
-
- my $role_name = $self->name;
- my $method_metaclass = $self->method_metaclass;
-
- my $all_code = $self->get_all_package_symbols('CODE');
-
- foreach my $symbol (keys %{ $all_code }) {
- my $code = $all_code->{$symbol};
-
- next if exists $map->{$symbol} &&
- defined $map->{$symbol} &&
- $map->{$symbol}->body == $code;
-
- my ($pkg, $name) = Class::MOP::get_code_info($code);
- my $meta = Class::MOP::class_of($pkg);
-
- if ($meta && $meta->isa('Moose::Meta::Role')) {
- my $role = $meta->name;
- next unless $self->does_role($role);
- }
- else {
- # NOTE:
- # in 5.10 constant.pm the constants show up
- # as being in the right package, but in pre-5.10
- # they show up as constant::__ANON__ so we
- # make an exception here to be sure that things
- # work as expected in both.
- # - SL
- unless ($pkg eq 'constant' && $name eq '__ANON__') {
- next if ($pkg || '') ne $role_name ||
- (($name || '') ne '__ANON__' && ($pkg || '') ne $role_name);
- }
- }
-
- $map->{$symbol} = $method_metaclass->wrap(
- $code,
- package_name => $role_name,
- name => $name
- );
- }
-
- return $map;
-}
-
-sub get_method {
- my ($self, $name) = @_;
- $self->get_method_map->{$name};
-}
-
-sub has_method {
- my ($self, $name) = @_;
- exists $self->get_method_map->{$name} ? 1 : 0
-}
-
-# FIXME this is copy-pasted from Class::MOP::Class
-# refactor to inherit from some common base
-sub wrap_method_body {
- my ( $self, %args ) = @_;
-
- ('CODE' eq ref $args{body})
- || Moose->throw_error("Your code block must be a CODE reference");
-
- $self->method_metaclass->wrap(
- package_name => $self->name,
- %args,
- );
-}
-
-sub add_method {
- my ($self, $method_name, $method) = @_;
- (defined $method_name && $method_name)
- || Moose->throw_error("You must define a method name");
-
- my $body;
- if (blessed($method)) {
- $body = $method->body;
- if ($method->package_name ne $self->name) {
- $method = $method->clone(
- package_name => $self->name,
- name => $method_name
- ) if $method->can('clone');
- }
- }
- else {
- $body = $method;
- $method = $self->wrap_method_body( body => $body, name => $method_name );
- }
-
- $method->attach_to_class($self);
-
- $self->get_method_map->{$method_name} = $method;
-
- my $full_method_name = ($self->name . '::' . $method_name);
- $self->add_package_symbol(
- { sigil => '&', type => 'CODE', name => $method_name },
- subname($full_method_name => $body)
- );
-
- $self->update_package_cache_flag; # still valid, since we just added the method to the map, and if it was invalid before that then get_method_map updated it
-}
-
sub find_method_by_name { (shift)->get_method(@_) }
-sub get_method_list {
- my $self = shift;
- grep { !/^meta$/ } keys %{$self->get_method_map};
-}
-
sub alias_method {
Carp::cluck("The alias_method method is deprecated. Use add_method instead.\n");
(blessed($other))
|| Moose->throw_error("You must pass in an blessed instance");
+ my $application_class;
if ($other->isa('Moose::Meta::Role')) {
- require Moose::Meta::Role::Application::ToRole;
- return Moose::Meta::Role::Application::ToRole->new(@args)->apply($self, $other);
+ $application_class = $self->application_to_role_class;
}
elsif ($other->isa('Moose::Meta::Class')) {
- require Moose::Meta::Role::Application::ToClass;
- return Moose::Meta::Role::Application::ToClass->new(@args)->apply($self, $other);
+ $application_class = $self->application_to_class_class;
}
else {
- require Moose::Meta::Role::Application::ToInstance;
- return Moose::Meta::Role::Application::ToInstance->new(@args)->apply($self, $other);
+ $application_class = $self->application_to_instance_class;
}
+
+ Class::MOP::load_class($application_class);
+ return $application_class->new(@args)->apply($self, $other);
}
sub combine {
my ($class, @role_specs) = @_;
- require Moose::Meta::Role::Application::RoleSummation;
require Moose::Meta::Role::Composite;
my (@roles, %role_params);
}
my $c = Moose::Meta::Role::Composite->new(roles => \@roles);
- Moose::Meta::Role::Application::RoleSummation->new(
- role_params => \%role_params
- )->apply($c);
-
- return $c;
+ return $c->apply_params(\%role_params);
}
sub _role_for_combination {
#####################################################################
#
# has 'roles' => (
-# metaclass => 'Collection::Array',
+# metaclass => 'Array',
# reader => 'get_roles',
# isa => 'ArrayRef[Moose::Meta::Role]',
# default => sub { [] },
# );
#
# has 'excluded_roles_map' => (
-# metaclass => 'Collection::Hash',
+# metaclass => 'Hash',
# reader => 'get_excluded_roles_map',
# isa => 'HashRef[Str]',
# provides => {
# );
#
# has 'attribute_map' => (
-# metaclass => 'Collection::Hash',
+# metaclass => 'Hash',
# reader => 'get_attribute_map',
# isa => 'HashRef[Str]',
# provides => {
# );
#
# has 'required_methods' => (
-# metaclass => 'Collection::Hash',
+# metaclass => 'Hash',
# reader => 'get_required_methods_map',
# isa => 'HashRef[Moose::Meta::Role::Method::Required]',
# provides => {
# # CODE refs to apply in that order
#
# has 'before_method_modifiers' => (
-# metaclass => 'Collection::Hash',
+# metaclass => 'Hash',
# reader => 'get_before_method_modifiers_map',
# isa => 'HashRef[ArrayRef[CodeRef]]',
# provides => {
# );
#
# has 'after_method_modifiers' => (
-# metaclass => 'Collection::Hash',
+# metaclass => 'Hash',
# reader =>'get_after_method_modifiers_map',
# isa => 'HashRef[ArrayRef[CodeRef]]',
# provides => {
# );
#
# has 'around_method_modifiers' => (
-# metaclass => 'Collection::Hash',
+# metaclass => 'Hash',
# reader =>'get_around_method_modifiers_map',
# isa => 'HashRef[ArrayRef[CodeRef]]',
# provides => {
# # but instead just a single name->code mapping
#
# has 'override_method_modifiers' => (
-# metaclass => 'Collection::Hash',
+# metaclass => 'Hash',
# reader =>'get_override_method_modifiers_map',
# isa => 'HashRef[CodeRef]',
# provides => {
This method accepts a list of array references. Each array reference
should contain a role name as its first element. The second element is
-an optional hash reference. The hash reference can contain C<exclude>
-and C<alias> keys to control how methods are composed from the role.
+an optional hash reference. The hash reference can contain C<-excludes>
+and C<-alias> keys to control how methods are composed from the role.
The return value is a new L<Moose::Meta::Role::Composite> that
represents the combined roles.
=item B<< $metarole->get_method_list >>
-=item B<< $metarole->get_method_map >>
-
=item B<< $metarole->find_method_by_name($name) >>
These methods are all identical to the methods of the same name in
-L<Class::MOP::Class>
+L<Class::MOP::Package>
=back
projects / gitmo/Moose.git / blobdiff