use Sub::Name 'subname';
use overload ();
-our $VERSION = '0.17';
+our $VERSION = '0.22';
our $AUTHORITY = 'cpan:STEVAN';
use Moose::Meta::Method::Accessor;
predicate => 'has_documentation',
));
+# 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;
+
sub new {
my ($class, $name, %options) = @_;
$class->_process_options($name, \%options);
my ($self, %options) = @_;
# you can change default, required, coerce, documentation and lazy
my %actual_options;
- foreach my $legal_option (qw(default coerce required documentation lazy)) {
+ foreach my $legal_option (qw(default coerce required documentation lazy handles builder)) {
if (exists $options{$legal_option}) {
$actual_options{$legal_option} = $options{$legal_option};
delete $options{$legal_option};
}
}
- # handles can only be added, not changed
- if ($options{handles}) {
- confess "You can only add the 'handles' option, you cannot change it"
- if $self->has_handles;
- $actual_options{handles} = $options{handles};
- delete $options{handles};
- }
-
- # isa can be changed, but only if the
- # new type is a subtype
if ($options{isa}) {
my $type_constraint;
if (blessed($options{isa}) && $options{isa}->isa('Moose::Meta::TypeConstraint')) {
(defined $type_constraint)
|| confess "Could not find the type constraint '" . $options{isa} . "'";
}
- # NOTE:
- # check here to see if the new type
- # is a subtype of the old one
- ($type_constraint->is_subtype_of($self->type_constraint->name))
- || confess "New type constraint setting must be a subtype of inherited one"
- # iff we have a type constraint that is ...
- if $self->has_type_constraint;
- # then we use it :)
+
$actual_options{type_constraint} = $type_constraint;
delete $options{isa};
}
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} && $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;
}
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
- ? overload::StrVal($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;
}
## 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);
- }
+ }
$type_constraint->_compiled_type_constraint->($value)
- || confess "Attribute ($attr_name) does not pass the type constraint ("
- . $type_constraint->name
- . ") with "
- . (defined($value)
- ? ("'" . overload::StrVal($value) . "'")
- : "undef")
- if defined($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);
+ $self->set_initial_value($instance, $instance->$builder);
}
else {
confess(blessed($instance)
}
}
else {
- $self->set_value($instance, undef);
+ $self->set_initial_value($instance, undef);
}
}
}
$associated_class->add_method($handle => 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 => subname $name, sub {
my $proxy = (shift)->$accessor();
- @_ = ($proxy, @_);
- goto &{ $proxy->can($method_to_call) || return };
+ (defined $proxy)
+ || confess "Cannot delegate $handle to $method_to_call because " .
+ "the value of " . $self->name . " is not defined";
+ $proxy->$method_to_call(@_);
});
}
}
=item B<new>
+=item B<does>
+
=item B<initialize_instance_slot>
=item B<install_accessors>