-{
+{
# test no conflicts here
package Role::A;
use Moose::Role;
package Role::C;
use Moose::Role;
-
+
::lives_ok {
with qw(Role::A Role::B); # no conflict here
} "define role C";
::lives_ok {
with qw(Role::C);
} "define class A";
-
+
sub zot { 'Class::A::zot' }
}
{
# check that when a role is added to another role
# and they conflict and the method they conflicted
- # with is then required.
-
+ # with is then required.
+
package Role::A::Conflict;
use Moose::Role;
-
+
with 'Role::A';
-
+
sub bar { 'Role::A::Conflict::bar' }
-
+
package Class::A::Conflict;
use Moose;
-
+
::throws_ok {
with 'Role::A::Conflict';
} qr/requires.*'bar'/, '... did not fufill the requirement of &bar method';
-
+
package Class::A::Resolved;
use Moose;
-
+
::lives_ok {
with 'Role::A::Conflict';
- } '... did fufill the requirement of &bar method';
-
+ } '... did fufill the requirement of &bar method';
+
sub bar { 'Class::A::Resolved::bar' }
}
{
# check that when two roles are composed, they conflict
# but the composing role can resolve that conflict
-
+
package Role::D;
use Moose::Role;
sub foo { 'Role::D::foo' }
- sub bar { 'Role::D::bar' }
+ sub bar { 'Role::D::bar' }
package Role::E;
use Moose::Role;
::lives_ok {
with qw(Role::D Role::E); # conflict between 'foo's here
} "define role Role::F";
-
+
sub foo { 'Role::F::foo' }
- sub zot { 'Role::F::zot' }
-
+ sub zot { 'Role::F::zot' }
+
package Class::B;
use Moose;
-
+
::lives_ok {
with qw(Role::F);
} "define class Class::B";
-
+
sub zot { 'Class::B::zot' }
}
{
# check that a conflict can be resolved
- # by a role, but also new ones can be
+ # by a role, but also new ones can be
# created just as easily ...
-
+
package Role::D::And::E::Conflict;
use Moose::Role;
::lives_ok {
with qw(Role::D Role::E); # conflict between 'foo's here
} "... define role Role::D::And::E::Conflict";
-
+
sub foo { 'Role::D::And::E::Conflict::foo' } # this overrides ...
-
- # but these conflict
- sub xxy { 'Role::D::And::E::Conflict::xxy' }
- sub bar { 'Role::D::And::E::Conflict::bar' }
+
+ # but these conflict
+ sub xxy { 'Role::D::And::E::Conflict::xxy' }
+ sub bar { 'Role::D::And::E::Conflict::bar' }
}
{
# conflict propagation
-
+
package Role::H;
use Moose::Role;
sub foo { 'Role::H::foo' }
- sub bar { 'Role::H::bar' }
+ sub bar { 'Role::H::bar' }
package Role::J;
use Moose::Role;
::lives_ok {
with qw(Role::J Role::H); # conflict between 'foo's here
} "define role Role::I";
-
+
sub zot { 'Role::I::zot' }
+ sub zzy { 'Role::I::zzy' }
package Class::C;
use Moose;
-
+
::throws_ok {
with qw(Role::I);
} qr/requires.*'foo'/, "defining class Class::C fails";
::lives_ok {
with qw(Role::I);
- } "resolved with method";
+ } "resolved with method";
sub foo { 'Class::E::foo' }
- sub zot { 'Class::E::zot' }
+ sub zot { 'Class::E::zot' }
}
can_ok( Class::E->new, qw(foo bar xxy zot) );
ok(Role::I->meta->requires_method('foo'), '... Role::I still have the &foo requirement');
{
- # fix these later ...
- TODO: {
- local $TODO = "add support for attribute methods fufilling reqs";
+ lives_ok {
+ package Class::D;
+ use Moose;
- lives_ok {
- package Class::D;
- use Moose;
+ has foo => ( default => __PACKAGE__ . "::foo", is => "rw" );
- has foo => ( default => __PACKAGE__ . "::foo", is => "rw" );
+ sub zot { 'Class::D::zot' }
- sub zot { 'Class::D::zot' }
+ with qw(Role::I);
- with qw(Role::I);
-
- } "resolved with attr";
+ } "resolved with attr";
- can_ok( Class::D->new, qw(foo bar xxy zot) );
- is( eval { Class::D->new->bar }, "Role::H::bar", "bar" );
- is( eval { Class::D->new->xxy }, "Role::I::xxy", "xxy" );
- }
+ can_ok( Class::D->new, qw(foo bar xxy zot) );
+ is( eval { Class::D->new->bar }, "Role::H::bar", "bar" );
+ is( eval { Class::D->new->zzy }, "Role::I::zzy", "zzy" );
is( eval { Class::D->new->foo }, "Class::D::foo", "foo" );
is( eval { Class::D->new->zot }, "Class::D::zot", "zot" );