X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FMoose%2FMeta%2FRole.pm;h=3c814d8279dbd1c2f8d28644a8a83d155fd09842;hb=9610c1d2be5ceb367ec30633643d6d9bce82bfe0;hp=ccb939b3fa4d217fcb13c55a302f750c12e3d1fb;hpb=55f28f0a0a3bd06f0b4dca6692a790bfc8812ef9;p=gitmo%2FMoose.git

diff --git a/lib/Moose/Meta/Role.pm b/lib/Moose/Meta/Role.pm
index ccb939b..3c814d8 100644
--- a/lib/Moose/Meta/Role.pm
+++ b/lib/Moose/Meta/Role.pm
@@ -10,13 +10,14 @@ use Carp         'confess';
 use Sub::Name    'subname';
 use Devel::GlobalDestruction 'in_global_destruction';
 
-our $VERSION   = '0.79';
+our $VERSION   = '0.89';
 $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';
 
@@ -65,9 +66,9 @@ foreach my $action (
         name        => 'required_methods',
         attr_reader => 'get_required_methods_map',
         methods     => {
-            remove    => 'remove_required_methods',
-            get_keys  => 'get_required_method_list',
-            existence => 'requires_method',
+            remove     => 'remove_required_methods',
+            get_values => 'get_required_method_list',
+            existence  => 'requires_method',
         }
     },
     {
@@ -102,6 +103,11 @@ foreach my $action (
         keys %{$self->$attr_reader};
     }) 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) = @_;
         $self->$attr_reader->{$name}
@@ -130,12 +136,36 @@ $META->add_attribute(
     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");
     }
@@ -163,6 +193,20 @@ sub add_required_methods {
     }
 }
 
+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
 
@@ -188,7 +232,8 @@ foreach my $modifier_type (qw[ before around after ]) {
     $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 {
@@ -451,18 +496,19 @@ sub apply {
     (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 {
@@ -618,7 +664,7 @@ sub create {
 #####################################################################
 #
 # has 'roles' => (
-#     metaclass => 'Collection::Array',
+#     metaclass => 'Array',
 #     reader    => 'get_roles',
 #     isa       => 'ArrayRef[Moose::Meta::Role]',
 #     default   => sub { [] },
@@ -628,7 +674,7 @@ sub create {
 # );
 #
 # has 'excluded_roles_map' => (
-#     metaclass => 'Collection::Hash',
+#     metaclass => 'Hash',
 #     reader    => 'get_excluded_roles_map',
 #     isa       => 'HashRef[Str]',
 #     provides  => {
@@ -640,7 +686,7 @@ sub create {
 # );
 #
 # has 'attribute_map' => (
-#     metaclass => 'Collection::Hash',
+#     metaclass => 'Hash',
 #     reader    => 'get_attribute_map',
 #     isa       => 'HashRef[Str]',
 #     provides => {
@@ -654,7 +700,7 @@ sub create {
 # );
 #
 # has 'required_methods' => (
-#     metaclass => 'Collection::Hash',
+#     metaclass => 'Hash',
 #     reader    => 'get_required_methods_map',
 #     isa       => 'HashRef[Moose::Meta::Role::Method::Required]',
 #     provides  => {
@@ -671,7 +717,7 @@ sub create {
 # # 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  => {
@@ -685,7 +731,7 @@ sub create {
 # );
 #
 # has 'after_method_modifiers' => (
-#     metaclass => 'Collection::Hash',
+#     metaclass => 'Hash',
 #     reader    =>'get_after_method_modifiers_map',
 #     isa       => 'HashRef[ArrayRef[CodeRef]]',
 #     provides  => {
@@ -699,7 +745,7 @@ sub create {
 # );
 #
 # has 'around_method_modifiers' => (
-#     metaclass => 'Collection::Hash',
+#     metaclass => 'Hash',
 #     reader    =>'get_around_method_modifiers_map',
 #     isa       => 'HashRef[ArrayRef[CodeRef]]',
 #     provides  => {
@@ -717,7 +763,7 @@ sub create {
 # # 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  => {
@@ -766,8 +812,8 @@ This method creates a new role object with the provided name.
 
 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.
@@ -925,6 +971,11 @@ Adds 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
 
 =head2 Method modifiers