use strict;
use warnings;
+use Class::MOP;
+
use Carp 'confess';
-use Scalar::Util 'weaken', 'blessed';
+use Scalar::Util 'weaken', 'blessed', 'reftype';
-our $VERSION = '0.04';
+our $VERSION = '0.06';
use base 'Class::MOP::Class';
+__PACKAGE__->meta->add_attribute('roles' => (
+ reader => 'roles',
+ default => sub { [] }
+));
+
+sub initialize {
+ my $class = shift;
+ my $pkg = shift;
+ $class->SUPER::initialize($pkg,
+ ':attribute_metaclass' => 'Moose::Meta::Attribute',
+ ':instance_metaclass' => 'Moose::Meta::Instance',
+ @_);
+}
+
+sub add_role {
+ my ($self, $role) = @_;
+ (blessed($role) && $role->isa('Moose::Meta::Role'))
+ || confess "Roles must be instances of Moose::Meta::Role";
+ push @{$self->roles} => $role;
+}
+
+sub does_role {
+ my ($self, $role_name) = @_;
+ (defined $role_name)
+ || confess "You must supply a role name to look for";
+ foreach my $class ($self->class_precedence_list) {
+ foreach my $role (@{$class->meta->roles}) {
+ return 1 if $role->does_role($role_name);
+ }
+ }
+ return 0;
+}
+
+sub excludes_role {
+ my ($self, $role_name) = @_;
+ (defined $role_name)
+ || confess "You must supply a role name to look for";
+ foreach my $class ($self->class_precedence_list) {
+ foreach my $role (@{$class->meta->roles}) {
+ return 1 if $role->excludes_role($role_name);
+ }
+ }
+ return 0;
+}
+
+sub new_object {
+ my ($class, %params) = @_;
+ my $self = $class->SUPER::new_object(%params);
+ foreach my $attr ($class->compute_all_applicable_attributes()) {
+ next unless $params{$attr->init_arg} && $attr->can('has_trigger') && $attr->has_trigger;
+ $attr->trigger->($self, $params{$attr->init_arg}, $attr);
+ }
+ return $self;
+}
+
sub construct_instance {
my ($class, %params) = @_;
- my $instance = $params{'__INSTANCE__'} || {};
+ my $meta_instance = $class->get_meta_instance;
+ # FIXME:
+ # the code below is almost certainly incorrect
+ # but this is foreign inheritence, so we might
+ # have to kludge it in the end.
+ my $instance = $params{'__INSTANCE__'} || $meta_instance->create_instance();
foreach my $attr ($class->compute_all_applicable_attributes()) {
- my $init_arg = $attr->init_arg();
- # try to fetch the init arg from the %params ...
- my $val;
- if (exists $params{$init_arg}) {
- $val = $params{$init_arg};
- }
- else {
- # skip it if it's lazy
- next if $attr->is_lazy;
- # and die if it is required
- confess "Attribute (" . $attr->name . ") is required"
- if $attr->is_required
- }
- # if nothing was in the %params, we can use the
- # attribute's default value (if it has one)
- if (!defined $val && $attr->has_default) {
- $val = $attr->default($instance);
- }
- if (defined $val) {
- if ($attr->has_type_constraint) {
- if ($attr->should_coerce && $attr->type_constraint->has_coercion) {
- $val = $attr->type_constraint->coercion->coerce($val);
- }
- (defined($attr->type_constraint->check($val)))
- || confess "Attribute (" . $attr->name . ") does not pass the type contraint with '$val'";
- }
- }
- $instance->{$attr->name} = $val;
- if (defined $val && $attr->is_weak_ref) {
- weaken($instance->{$attr->name});
- }
+ $attr->initialize_instance_slot($meta_instance, $instance, \%params)
}
return $instance;
}
return $self->SUPER::has_method($method_name);
}
-
sub add_override_method_modifier {
my ($self, $name, $method, $_super_package) = @_;
+ (!$self->has_method($name))
+ || confess "Cannot add an override method if a local method is already present";
# need this for roles ...
$_super_package ||= $self->name;
my $super = $self->find_next_method_by_name($name);
sub add_augment_method_modifier {
my ($self, $name, $method) = @_;
+ (!$self->has_method($name))
+ || confess "Cannot add an augment method if a local method is already present";
my $super = $self->find_next_method_by_name($name);
(defined $super)
|| confess "You cannot augment '$name' because it has no super method";
=over 4
+=item B<initialize>
+
+=item B<new_object>
+
+We override this method to support the C<trigger> attribute option.
+
=item B<construct_instance>
This provides some Moose specific extensions to this method, you
=item B<add_override_method_modifier ($name, $method)>
+This will create an C<override> method modifier for you, and install
+it in the package.
+
=item B<add_augment_method_modifier ($name, $method)>
+This will create an C<augment> method modifier for you, and install
+it in the package.
+
+=item B<roles>
+
+This will return an array of C<Moose::Meta::Role> instances which are
+attached to this class.
+
+=item B<add_role ($role)>
+
+This takes an instance of C<Moose::Meta::Role> in C<$role>, and adds it
+to the list of associated roles.
+
+=item B<does_role ($role_name)>
+
+This will test if this class C<does> a given C<$role_name>. It will
+not only check it's local roles, but ask them as well in order to
+cascade down the role hierarchy.
+
+=item B<excludes_role ($role_name)>
+
+This will test if this class C<excludes> a given C<$role_name>. It will
+not only check it's local roles, but ask them as well in order to
+cascade down the role hierarchy.
+
+=item B<add_attribute $attr_name, %params>
+
+This method does the same thing as L<Class::MOP::Class/add_attribute>, but adds
+suport for delegation.
+
+=back
+
+=head1 INTERNAL METHODS
+
+=over 4
+
+=item compute_delegation
+
+=item generate_delegation_list
+
+=item generate_delgate_method
+
+=item get_delegatable_methods
+
+=item filter_delegations
+
=back
=head1 BUGS
This library is free software; you can redistribute it and/or modify
it under the same terms as Perl itself.
-=cut
\ No newline at end of file
+=cut
+