use Sub::Name 'subname';
use Devel::GlobalDestruction 'in_global_destruction';
-our $VERSION = '0.79';
+our $VERSION = '0.89_02';
$VERSION = eval $VERSION;
our $AUTHORITY = 'cpan:STEVAN';
use Moose::Meta::Class;
use Moose::Meta::Role::Method;
use Moose::Meta::Role::Method::Required;
+use Moose::Meta::Role::Method::Conflicting;
use base 'Class::MOP::Module';
attr_reader => 'get_excluded_roles_map' ,
methods => {
add => 'add_excluded_roles',
- get_list => 'get_excluded_roles_list',
+ get_keys => 'get_excluded_roles_list',
existence => 'excludes_role',
}
},
name => 'required_methods',
attr_reader => 'get_required_methods_map',
methods => {
- remove => 'remove_required_methods',
- get_list => 'get_required_method_list',
- existence => 'requires_method',
+ remove => 'remove_required_methods',
+ get_values => 'get_required_method_list',
+ existence => 'requires_method',
}
},
{
attr_reader => 'get_attribute_map',
methods => {
get => 'get_attribute',
- get_list => 'get_attribute_list',
+ get_keys => 'get_attribute_list',
existence => 'has_attribute',
remove => 'remove_attribute',
}
$self->$attr_reader->{$_} = undef foreach @values;
}) if exists $methods->{add};
- $META->add_method($methods->{get_list} => sub {
+ $META->add_method($methods->{get_keys} => sub {
my ($self) = @_;
keys %{$self->$attr_reader};
- }) if exists $methods->{get_list};
+ }) if exists $methods->{get_keys};
+
+ $META->add_method($methods->{get_values} => sub {
+ my ($self) = @_;
+ values %{$self->$attr_reader};
+ }) if exists $methods->{get_values};
$META->add_method($methods->{get} => sub {
my ($self, $name) = @_;
default => 'Moose::Meta::Role::Method::Required',
);
+$META->add_attribute(
+ 'conflicting_method_metaclass',
+ reader => 'conflicting_method_metaclass',
+ 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',
+);
+
## 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");
}
for (@_) {
my $method = $_;
- if (!ref($method)) {
+ if (!blessed($method)) {
$method = $self->required_method_metaclass->new(
name => $method,
);
}
}
+sub add_conflicting_method {
+ my $self = shift;
+
+ my $method;
+ if (@_ == 1 && blessed($_[0])) {
+ $method = shift;
+ }
+ else {
+ $method = $self->conflicting_method_metaclass->new(@_);
+ }
+
+ $self->add_required_methods($method);
+}
+
## ------------------------------------------------------------------
## method modifiers
$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 {
(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::Roles]',
+# isa => 'ArrayRef[Moose::Meta::Role]',
# default => sub { [] },
# provides => {
# 'push' => 'add_role',
# );
#
# 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[Str]',
+# isa => 'HashRef[Moose::Meta::Role::Method::Required]',
# provides => {
# # not exactly set, or delete since it works for multiple
# 'set' => 'add_required_methods',
# # 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->remove_required_methods(@names) >>
-Removes the named methods to the role's list of required methods.
+Removes the named methods from the role's list of required methods.
+
+=item B<< $metarole->add_conflicting_method(%params) >>
+
+Instantiate the parameters as a L<Moose::Meta::Role::Method::Conflicting>
+object, then add it to the required method list.
=back
projects / gitmo/Moose.git / blobdiff