use Scalar::Util 'blessed', 'weaken', 'reftype';
use Carp 'confess';
+use Sub::Name 'subname';
use overload ();
-our $VERSION = '0.15';
+our $VERSION = '0.22';
our $AUTHORITY = 'cpan:STEVAN';
use Moose::Meta::Method::Accessor;
$actual_options{handles} = $options{handles};
delete $options{handles};
}
+
+ # handles can only be added, not changed
+ if ($options{builder}) {
+ confess "You can only add the 'builder' option, you cannot change it"
+ if $self->has_builder;
+ $actual_options{builder} = $options{builder};
+ delete $options{builder};
+ }
# isa can be changed, but only if the
# new type is a subtype
elsif (exists $options->{does}) {
# allow for anon-subtypes here ...
if (blessed($options->{does}) && $options->{does}->isa('Moose::Meta::TypeConstraint')) {
- $options->{type_constraint} = $options->{isa};
+ $options->{type_constraint} = $options->{does};
}
else {
$options->{type_constraint} = Moose::Util::TypeConstraints::find_or_create_type_constraint(
$options->{does} => {
parent => Moose::Util::TypeConstraints::find_type_constraint('Role'),
- constraint => sub { $_[0]->does($options->{does}) }
+ constraint => sub {
+ Moose::Util::does_role($_[0], $options->{does})
+ }
}
);
}
if (exists $options->{lazy_build} && $options->{lazy_build} == 1) {
confess("You can not use lazy_build and default for the same attribute")
if exists $options->{default};
- $options->{lazy} = 1;
- $options->{required} = 1;
- $options->{builder} ||= "_build_${name}";
- if($name =~ /^_/){
+ $options->{lazy} = 1;
+ $options->{required} = 1;
+ $options->{builder} ||= "_build_${name}";
+ if ($name =~ /^_/) {
$options->{clearer} ||= "_clear${name}";
$options->{predicate} ||= "_has${name}";
- } else {
+ }
+ else {
$options->{clearer} ||= "clear_${name}";
$options->{predicate} ||= "has_${name}";
}
}
if (exists $options->{lazy} && $options->{lazy}) {
- (exists $options->{default} || exists $options->{builder} )
+ (exists $options->{default} || defined $options->{builder} )
|| confess "You cannot have lazy attribute without specifying a default value for it";
}
+ if ( $options->{required} && !( ( !exists $options->{init_arg} || defined $options->{init_arg} ) || exists $options->{default} || defined $options->{builder} ) ) {
+ confess "You cannot have a required attribute without a default, builder, or an init_arg";
+ }
+
}
sub initialize_instance_slot {
my $val;
my $value_is_set;
- if (exists $params->{$init_arg}) {
+ if ( defined($init_arg) and exists $params->{$init_arg}) {
$val = $params->{$init_arg};
- $value_is_set = 1;
+ $value_is_set = 1;
}
else {
# skip it if it's lazy
if ($self->has_default) {
$val = $self->default($instance);
$value_is_set = 1;
- } elsif ($self->has_builder) {
- if(my $builder = $instance->can($self->builder)){
+ }
+ elsif ($self->has_builder) {
+ if (my $builder = $instance->can($self->builder)){
$val = $instance->$builder;
$value_is_set = 1;
- } else {
+ }
+ else {
confess(blessed($instance)." does not support builder method '".$self->builder."' for attribute '" . $self->name . "'");
}
}
if ($self->should_coerce && $type_constraint->has_coercion) {
$val = $type_constraint->coerce($val);
}
- (defined($type_constraint->check($val)))
- || confess "Attribute (" .
- $self->name .
- ") does not pass the type constraint (" .
- $type_constraint->name .
- ") with '" .
- (defined $val
- ? (blessed($val) && overload::Overloaded($val)
- ? overload::StrVal($val)
- : $val)
- : 'undef') .
- "'";
+ $type_constraint->check($val)
+ || confess "Attribute ("
+ . $self->name
+ . ") does not pass the type constraint because: "
+ . $type_constraint->get_message($val);
}
- $meta_instance->set_slot_value($instance, $self->name, $val);
+ $self->set_initial_value($instance, $val);
$meta_instance->weaken_slot_value($instance, $self->name)
- if ref $val && $self->is_weak_ref;
+ if ref $val && $self->is_weak_ref;
}
## Slot management
+# FIXME:
+# this duplicates too much code from
+# Class::MOP::Attribute, we need to
+# refactor these bits eventually.
+# - SL
+sub _set_initial_slot_value {
+ my ($self, $meta_instance, $instance, $value) = @_;
+
+ my $slot_name = $self->name;
+
+ return $meta_instance->set_slot_value($instance, $slot_name, $value)
+ unless $self->has_initializer;
+
+ my ($type_constraint, $can_coerce);
+ if ($self->has_type_constraint) {
+ $type_constraint = $self->type_constraint;
+ $can_coerce = ($self->should_coerce && $type_constraint->has_coercion);
+ }
+
+ my $callback = sub {
+ my $val = shift;
+ if ($type_constraint) {
+ $val = $type_constraint->coerce($val)
+ if $can_coerce;
+ $type_constraint->check($val)
+ || confess "Attribute ("
+ . $slot_name
+ . ") does not pass the type constraint because: "
+ . $type_constraint->get_message($val);
+ }
+ $meta_instance->set_slot_value($instance, $slot_name, $val);
+ };
+
+ my $initializer = $self->initializer;
+
+ # most things will just want to set a value, so make it first arg
+ $instance->$initializer($value, $callback, $self);
+}
+
sub set_value {
my ($self, $instance, $value) = @_;
if ($self->should_coerce) {
$value = $type_constraint->coerce($value);
- }
- defined($type_constraint->_compiled_type_constraint->($value))
- || confess "Attribute ($attr_name) does not pass the type constraint ("
- . $type_constraint->name
- . ") with "
- . (defined($value)
- ? ("'" .
- (blessed($value) && overload::Overloaded($value)
- ? overload::StrVal($value)
- : $value)
- . "'")
- : "undef")
- if defined($value);
+ }
+ $type_constraint->_compiled_type_constraint->($value)
+ || confess "Attribute ("
+ . $self->name
+ . ") does not pass the type constraint because "
+ . $type_constraint->get_message($value);
}
my $meta_instance = Class::MOP::Class->initialize(blessed($instance))
unless ($self->has_value($instance)) {
if ($self->has_default) {
my $default = $self->default($instance);
- $self->set_value($instance, $default);
+ $self->set_initial_value($instance, $default);
}
if ( $self->has_builder ){
- if(my $builder = $instance->can($self->builder)){
- $self->set_value($instance, $instance->$builder);
- } else {
- confess(blessed($instance)." does not support builder method '".$self->builder."' for attribute '" . $self->name . "'");
+ if (my $builder = $instance->can($self->builder)){
+ $self->set_initial_value($instance, $instance->$builder);
+ }
+ else {
+ confess(blessed($instance)
+ . " does not support builder method '"
+ . $self->builder
+ . "' for attribute '"
+ . $self->name
+ . "'");
}
- } else {
- $self->set_value($instance, undef);
+ }
+ else {
+ $self->set_initial_value($instance, undef);
}
}
}
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";
# any of these methods, as they will
# override the ones in your class, which
# is almost certainly not what you want.
- next if $handle =~ /^BUILD|DEMOLISH$/ || Moose::Object->can($handle);
+
+ # 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 ((reftype($method_to_call) || '') eq 'CODE') {
- $associated_class->add_method($handle => $method_to_call);
+ $associated_class->add_method($handle => subname $name, $method_to_call);
}
else {
- $associated_class->add_method($handle => sub {
- # FIXME
- # we should check for lack of
- # a callable return value from
- # the accessor here
+ # 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 => subname $name, sub {
my $proxy = (shift)->$accessor();
- @_ = ($proxy, @_);
- goto &{ $proxy->can($method_to_call) };
+ (defined $proxy)
+ || confess "Cannot delegate $handle to $method_to_call because " .
+ "the value of " . $self->name . " is not defined";
+ $proxy->$method_to_call(@_);
});
}
}
Any coercion to convert values is done before checking the type constraint.
To check a value against a type constraint before setting it, fetch the
-attribute instance using L<Moose::Meta::Attribute/find_attribute_by_name>,
+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>
for an example.
=head1 COPYRIGHT AND LICENSE
-Copyright 2006, 2007 by Infinity Interactive, Inc.
+Copyright 2006-2008 by Infinity Interactive, Inc.
L<http://www.iinteractive.com>
projects / gitmo/Moose.git / blobdiff