use strict;
use warnings;
-use Scalar::Util 'blessed', 'weaken', 'reftype';
+use Scalar::Util 'blessed', 'weaken';
use Carp 'confess';
use overload ();
-our $VERSION = '0.24';
+our $VERSION = '0.56';
our $AUTHORITY = 'cpan:STEVAN';
use Moose::Meta::Method::Accessor;
predicate => 'has_applied_traits',
));
-# NOTE:
# we need to have a ->does method in here to
# more easily support traits, and the introspection
-# of those traits. So in order to do this we
-# just alias Moose::Object's version of it.
-# - SL
-*does = \&Moose::Object::does;
+# of those traits. We extend the does check to look
+# for metatrait aliases.
+sub does {
+ my ($self, $role_name) = @_;
+ my $name = eval {
+ Moose::Util::resolve_metatrait_alias(Attribute => $role_name)
+ };
+ return 0 if !defined($name); # failed to load class
+ return Moose::Object::does($self, $name);
+}
sub new {
my ($class, $name, %options) = @_;
return ( wantarray ? ( $class, @traits ) : $class );
}
+# ...
+
+my @legal_options_for_inheritance = qw(
+ default coerce required
+ documentation lazy handles
+ builder type_constraint
+);
+
+sub legal_options_for_inheritance { @legal_options_for_inheritance }
+
+# NOTE/TODO
+# This method *must* be able to handle
+# Class::MOP::Attribute instances as
+# well. Yes, I know that is wrong, but
+# apparently we didn't realize it was
+# doing that and now we have some code
+# which is dependent on it. The real
+# solution of course is to push this
+# feature back up into Class::MOP::Attribute
+# but I not right now, I am too lazy.
+# However if you are reading this and
+# looking for something to do,.. please
+# be my guest.
+# - stevan
sub clone_and_inherit_options {
my ($self, %options) = @_;
+
my %copy = %options;
- # you can change default, required, coerce, documentation, lazy, handles, builder, type_constraint (explicitly or using isa/does), metaclass and traits
+
my %actual_options;
- foreach my $legal_option (qw(default coerce required documentation lazy handles builder type_constraint)) {
+
+ # NOTE:
+ # we may want to extends a Class::MOP::Attribute
+ # in which case we need to be able to use the
+ # core set of legal options that have always
+ # been here. But we allows Moose::Meta::Attribute
+ # instances to changes them.
+ # - SL
+ my @legal_options = $self->can('legal_options_for_inheritance')
+ ? $self->legal_options_for_inheritance
+ : @legal_options_for_inheritance;
+
+ foreach my $legal_option (@legal_options) {
if (exists $options{$legal_option}) {
$actual_options{$legal_option} = $options{$legal_option};
delete $options{$legal_option};
}
- }
+ }
if ($options{isa}) {
my $type_constraint;
my ($class, $name, $options) = @_;
if (exists $options->{is}) {
+
+ ### -------------------------
+ ## is => ro, writer => _foo # turns into (reader => foo, writer => _foo) as before
+ ## is => rw, writer => _foo # turns into (reader => foo, writer => _foo)
+ ## is => rw, accessor => _foo # turns into (accessor => _foo)
+ ## is => ro, accessor => _foo # error, accesor is rw
+ ### -------------------------
+
if ($options->{is} eq 'ro') {
+ confess "Cannot define an accessor name on a read-only attribute, accessors are read/write"
+ if exists $options->{accessor};
$options->{reader} ||= $name;
- (!exists $options->{trigger})
- || confess "Cannot have a trigger on a read-only attribute $name";
}
elsif ($options->{is} eq 'rw') {
- $options->{accessor} = $name;
- ((reftype($options->{trigger}) || '') eq 'CODE')
- || confess "Trigger must be a CODE ref"
- if exists $options->{trigger};
+ if ($options->{writer}) {
+ $options->{reader} ||= $name;
+ }
+ else {
+ $options->{accessor} ||= $name;
+ }
}
else {
- confess "I do not understand this option (is => " . $options->{is} . ") on attribute $name"
+ confess "I do not understand this option (is => " . $options->{is} . ") on attribute ($name)"
}
}
if (exists $options->{does}) {
if (eval { $options->{isa}->can('does') }) {
($options->{isa}->does($options->{does}))
- || confess "Cannot have an isa option and a does option if the isa does not do the does on attribute $name";
+ || confess "Cannot have an isa option and a does option if the isa does not do the does on attribute ($name)";
}
else {
- confess "Cannot have an isa option which cannot ->does() on attribute $name";
+ confess "Cannot have an isa option which cannot ->does() on attribute ($name)";
}
}
if (exists $options->{coerce} && $options->{coerce}) {
(exists $options->{type_constraint})
- || confess "You cannot have coercion without specifying a type constraint on attribute $name";
- confess "You cannot have a weak reference to a coerced value on attribute $name"
+ || confess "You cannot have coercion without specifying a type constraint on attribute ($name)";
+ confess "You cannot have a weak reference to a coerced value on attribute ($name)"
if $options->{weak_ref};
}
+ if (exists $options->{trigger}) {
+ ('CODE' eq ref $options->{trigger})
+ || confess "Trigger must be a CODE ref on attribute ($name)";
+ }
+
if (exists $options->{auto_deref} && $options->{auto_deref}) {
(exists $options->{type_constraint})
- || confess "You cannot auto-dereference without specifying a type constraint on attribute $name";
+ || confess "You cannot auto-dereference without specifying a type constraint on attribute ($name)";
($options->{type_constraint}->is_a_type_of('ArrayRef') ||
$options->{type_constraint}->is_a_type_of('HashRef'))
- || confess "You cannot auto-dereference anything other than a ArrayRef or HashRef on attribute $name";
+ || confess "You cannot auto-dereference anything other than a ArrayRef or HashRef on attribute ($name)";
}
if (exists $options->{lazy_build} && $options->{lazy_build} == 1) {
- confess("You can not use lazy_build and default for the same attribute $name")
+ confess("You can not use lazy_build and default for the same attribute ($name)")
if exists $options->{default};
$options->{lazy} = 1;
$options->{required} = 1;
}
sub set_value {
- my ($self, $instance, $value) = @_;
+ my ($self, $instance, @args) = @_;
+ my $value = $args[0];
my $attr_name = $self->name;
- if ($self->is_required) {
- defined($value)
- || confess "Attribute ($attr_name) is required, so cannot be set to undef";
+ if ($self->is_required and not @args) {
+ confess "Attribute ($attr_name) is required";
}
if ($self->has_type_constraint) {
if ($self->has_default) {
my $default = $self->default($instance);
$self->set_initial_value($instance, $default);
- }
- if ( $self->has_builder ){
+ } elsif ( $self->has_builder ) {
if (my $builder = $instance->can($self->builder)){
$self->set_initial_value($instance, $instance->$builder);
- }
+ }
else {
confess(blessed($instance)
. " does not support builder method '"
sub install_accessors {
my $self = shift;
$self->SUPER::install_accessors(@_);
+ $self->install_delegation if $self->has_handles;
+ return;
+}
- if ($self->has_handles) {
+sub install_delegation {
+ my $self = shift;
- # NOTE:
- # Here we canonicalize the 'handles' option
- # this will sort out any details and always
- # return an hash of methods which we want
- # to delagate to, see that method for details
- my %handles = $self->_canonicalize_handles();
-
- # find the accessor method for this attribute
- my $accessor = $self->get_read_method_ref;
- # then unpack it if we need too ...
- $accessor = $accessor->body if blessed $accessor;
-
- # install the delegation ...
- my $associated_class = $self->associated_class;
- foreach my $handle (keys %handles) {
- my $method_to_call = $handles{$handle};
- my $class_name = $associated_class->name;
- my $name = "${class_name}::${handle}";
-
- (!$associated_class->has_method($handle))
- || confess "You cannot overwrite a locally defined method ($handle) with a delegation";
+ # NOTE:
+ # Here we canonicalize the 'handles' option
+ # this will sort out any details and always
+ # return an hash of methods which we want
+ # to delagate to, see that method for details
+ my %handles = $self->_canonicalize_handles;
- # NOTE:
- # handles is not allowed to delegate
- # any of these methods, as they will
- # override the ones in your class, which
- # is almost certainly not what you want.
+ # find the accessor method for this attribute
+ my $accessor = $self->_get_delegate_accessor;
- # FIXME warn when $handle was explicitly specified, but not if the source is a regex or something
- #cluck("Not delegating method '$handle' because it is a core method") and
- next if $class_name->isa("Moose::Object") and $handle =~ /^BUILD|DEMOLISH$/ || Moose::Object->can($handle);
+ # install the delegation ...
+ my $associated_class = $self->associated_class;
+ foreach my $handle (keys %handles) {
+ my $method_to_call = $handles{$handle};
+ my $class_name = $associated_class->name;
+ my $name = "${class_name}::${handle}";
- if ((reftype($method_to_call) || '') eq 'CODE') {
- $associated_class->add_method($handle => Class::MOP::subname($name, $method_to_call));
- }
- else {
- # NOTE:
- # we used to do a goto here, but the
- # goto didn't handle failure correctly
- # (it just returned nothing), so I took
- # that out. However, the more I thought
- # about it, the less I liked it doing
- # the goto, and I prefered the act of
- # delegation being actually represented
- # in the stack trace.
- # - SL
- $associated_class->add_method($handle => Class::MOP::subname($name, sub {
- my $proxy = (shift)->$accessor();
- (defined $proxy)
- || confess "Cannot delegate $handle to $method_to_call because " .
- "the value of " . $self->name . " is not defined";
- $proxy->$method_to_call(@_);
- }));
- }
- }
- }
+ (!$associated_class->has_method($handle))
+ || confess "You cannot overwrite a locally defined method ($handle) with a delegation";
- return;
+ # NOTE:
+ # handles is not allowed to delegate
+ # any of these methods, as they will
+ # override the ones in your class, which
+ # is almost certainly not what you want.
+
+ # FIXME warn when $handle was explicitly specified, but not if the source is a regex or something
+ #cluck("Not delegating method '$handle' because it is a core method") and
+ next if $class_name->isa("Moose::Object") and $handle =~ /^BUILD|DEMOLISH$/ || Moose::Object->can($handle);
+
+ if ('CODE' eq ref($method_to_call)) {
+ $associated_class->add_method($handle => Class::MOP::subname($name, $method_to_call));
+ }
+ else {
+ # NOTE:
+ # we used to do a goto here, but the
+ # goto didn't handle failure correctly
+ # (it just returned nothing), so I took
+ # that out. However, the more I thought
+ # about it, the less I liked it doing
+ # the goto, and I prefered the act of
+ # delegation being actually represented
+ # in the stack trace.
+ # - SL
+ $associated_class->add_method($handle => Class::MOP::subname($name, sub {
+ my $proxy = (shift)->$accessor();
+ (defined $proxy)
+ || confess "Cannot delegate $handle to $method_to_call because " .
+ "the value of " . $self->name . " is not defined";
+ $proxy->$method_to_call(@_);
+ }));
+ }
+ }
}
# private methods to help delegation ...
+sub _get_delegate_accessor {
+ my $self = shift;
+ # find the accessor method for this attribute
+ my $accessor = $self->get_read_method_ref;
+ # then unpack it if we need too ...
+ $accessor = $accessor->body if blessed $accessor;
+ # return the accessor
+ return $accessor;
+}
+
sub _canonicalize_handles {
my $self = shift;
my $handles = $self->handles;
}
}
+package Moose::Meta::Attribute::Custom::Moose;
+sub register_implementation { 'Moose::Meta::Attribute' }
+
1;
__END__
=item B<install_accessors>
+=item B<install_delegation>
+
=item B<accessor_metaclass>
=item B<get_value>
To check a value against a type constraint before setting it, fetch the
attribute instance using L<Class::MOP::Class/find_attribute_by_name>,
fetch the type_constraint from the attribute using L<Moose::Meta::Attribute/type_constraint>
-and call L<Moose::Meta::TypeConstraint/check>. See L<Moose::Cookbook::RecipeX>
+and call L<Moose::Meta::TypeConstraint/check>. See L<Moose::Cookbook::Basics::Recipe4>
for an example.
=back
from a superclass and allows a very specific set of changes to be made
to the attribute.
+=item B<legal_options_for_inheritance>
+
+Whitelist with options you can change. You can overload it in your custom
+metaclass to allow your options be inheritable.
+
=item B<has_type_constraint>
Returns true if this meta-attribute has a type constraint.
#If your attribute name starts with an underscore:
has '_foo' => (lazy_build => 1);
#is the same as
- has '_foo' => (lazy => 1, required => 1, predicate => '_has_foo', clearer => '_clear_foo', builder => '_build__foo);
+ has '_foo' => (lazy => 1, required => 1, predicate => '_has_foo', clearer => '_clear_foo', builder => '_build__foo');
# or
has '_foo' => (lazy => 1, required => 1, predicate => '_has_foo', clearer => '_clear_foo', default => sub{shift->_build__foo});
#If your attribute name does not start with an underscore:
has 'foo' => (lazy_build => 1);
#is the same as
- has 'foo' => (lazy => 1, required => 1, predicate => 'has_foo', clearer => 'clear_foo', builder => '_build_foo);
+ has 'foo' => (lazy => 1, required => 1, predicate => 'has_foo', clearer => 'clear_foo', builder => '_build_foo');
# or
has 'foo' => (lazy => 1, required => 1, predicate => 'has_foo', clearer => 'clear_foo', default => sub{shift->_build_foo});
projects / gitmo/Moose.git / blobdiff