sub _process_options{
my($class, $name, $args) = @_;
+
+ # XXX: for backward compatibility (with method modifiers)
+ if($class->can('canonicalize_args') != \&canonicalize_args){
+ %{$args} = $class->canonicalize_args($name, %{$args});
+ }
+
# taken from Class::MOP::Attribute::new
defined($name)
my $can_be_required = defined( $args->{init_arg} );
if(exists $args->{builder}){
+ # XXX:
+ # Moose refuses a CODE ref builder, but Mouse doesn't for backward compatibility
+ # This feature will be changed in a future. (gfx)
$class->throw_error('builder must be a defined scalar value which is a method name')
- if ref $args->{builder} || !(defined $args->{builder});
+ #if ref $args->{builder} || !defined $args->{builder};
+ if !defined $args->{builder};
$can_be_required++;
}
$args->{type_constraint} = Mouse::Util::TypeConstraints::find_or_create_isa_type_constraint($args->{isa});
}
elsif(exists $args->{does}){
- $args->{type_constraint} = Mouse::Util::TypeConstraints::find_or_create_does_type_constraint($args->{does});
+ # TODO
+ # $args->{type_constraint} = Mouse::Util::TypeConstraints::find_or_create_does_type_constraint($args->{does});
}
$tc = $args->{type_constraint};
|| $class->throw_error("You cannot have lazy attribute ($name) without specifying a default value for it");
}
- # XXX: for backward compatibility (with method modifiers)
- if($class->can('canonicalize_args') != \&canonicalize_args){
- %{$args} = $class->canonicalize_args($name, %{$args});
- }
return;
}
$args{name} = $name;
- my $instance = bless \%args, $class;
+ my $self = bless \%args, $class;
# extra attributes
if($class ne __PACKAGE__){
- $class->meta->_initialize_instance($instance,\%args);
+ $class->meta->_initialize_object($self, \%args);
}
# XXX: there is no fast way to check attribute validity
# Carp::cluck("Found unknown argument(s) passed to '$name' attribute constructor in '$class': @bad");
# }
- return $instance
+ return $self;
}
# readers
sub should_auto_deref { $_[0]->{auto_deref} }
sub should_coerce { $_[0]->{coerce} }
-sub get_read_method { $_[0]->{reader} || $_[0]->{accessor} }
-sub get_write_method { $_[0]->{writer} || $_[0]->{accessor} }
-
# predicates
sub has_accessor { exists $_[0]->{accessor} }
sub has_read_method { exists $_[0]->{reader} || exists $_[0]->{accessor} }
sub has_write_method { exists $_[0]->{writer} || exists $_[0]->{accessor} }
-sub _create_args {
+sub _create_args { # DEPRECATED
$_[0]->{_create_args} = $_[1] if @_ > 1;
$_[0]->{_create_args}
}
-sub accessor_metaclass { 'Mouse::Meta::Method::Accessor' }
-
sub interpolate_class{
my($class, $name, $args) = @_;
return( $class, @traits );
}
-sub canonicalize_args{
+sub canonicalize_args{ # DEPRECATED
my ($self, $name, %args) = @_;
Carp::cluck("$self->canonicalize_args has been deprecated."
- . "Use \$self->_process_options instead.");
+ . "Use \$self->_process_options instead.")
+ if _MOUSE_VERBOSE;
return %args;
}
my ($self, $class, $name, %args) = @_;
Carp::cluck("$self->create has been deprecated."
- . "Use \$meta->add_attribute and \$attr->install_accessors instead.");
+ . "Use \$meta->add_attribute and \$attr->install_accessors instead.")
+ if _MOUSE_VERBOSE;
# noop
return $self;
}
+sub _coerce_and_verify {
+ my($self, $value, $instance) = @_;
+
+ my $type_constraint = $self->{type_constraint};
+
+ return $value if !$type_constraint;
+
+ if ($self->should_coerce && $type_constraint->has_coercion) {
+ $value = $type_constraint->coerce($value);
+ }
+
+ return $value if $type_constraint->check($value);
+
+ $self->verify_against_type_constraint($value);
+
+ return $value;
+}
+
sub verify_against_type_constraint {
my ($self, $value) = @_;
- my $tc = $self->type_constraint;
- return 1 unless $tc;
- local $_ = $value;
- return 1 if $tc->check($value);
+ my $type_constraint = $self->{type_constraint};
+ return 1 if !$type_constraint;;
+ return 1 if $type_constraint->check($value);
- $self->verify_type_constraint_error($self->name, $value, $tc);
+ $self->verify_type_constraint_error($self->name, $value, $type_constraint);
}
sub verify_type_constraint_error {
$self->throw_error("Attribute ($name) does not pass the type constraint because: " . $type->get_message($value));
}
-sub coerce_constraint { ## my($self, $value) = @_;
+sub coerce_constraint { # DEPRECATED
my $type = $_[0]->{type_constraint}
or return $_[1];
- return Mouse::Util::TypeConstraints->typecast_constraints($_[0]->associated_class->name, $_[0]->type_constraint, $_[1]);
+
+ Carp::cluck("coerce_constraint() has been deprecated, which was an internal utility anyway");
+
+ return Mouse::Util::TypeConstraints->typecast_constraints($_[0]->associated_class->name, $type, $_[1]);
}
sub _canonicalize_handles {
my $self = shift;
my $name = shift;
- return ref($self)->new($name, %{$self}, @_ == 1 ? %{$_[0]} : @_);
+ return ref($self)->new($name, %{$self}, (@_ == 1) ? %{$_[0]} : @_);
}
-sub clone_parent {
+sub clone_parent { # DEPRECATED
my $self = shift;
my $class = shift;
my $name = shift;
my %args = ($self->get_parent_args($class, $name), @_);
Carp::cluck("$self->clone_parent has been deprecated."
- . "Use \$meta->add_attribute and \$attr->install_accessors instead.");
+ . "Use \$meta->add_attribute and \$attr->install_accessors instead.")
+ if _MOUSE_VERBOSE;
-
- $self->create($class, $name, %args);
+ $self->clone_and_inherited_args($class, $name, %args);
}
-sub get_parent_args {
+sub get_parent_args { # DEPRECATED
my $self = shift;
my $class = shift;
my $name = shift;
$self->throw_error("Could not find an attribute by the name of '$name' to inherit from");
}
+
+sub get_read_method { # DEPRECATED
+ $_[0]->{reader} || $_[0]->{accessor}
+}
+sub get_write_method { # DEPRECATED
+ $_[0]->{writer} || $_[0]->{accessor}
+}
+
+sub get_read_method_ref{
+ my($self) = @_;
+
+ $self->{_read_method_ref} ||= do{
+ my $metaclass = $self->associated_class
+ or $self->throw_error('No asocciated class for ' . $self->name);
+
+ my $reader = $self->{reader} || $self->{accessor};
+ if($reader){
+ $metaclass->name->can($reader);
+ }
+ else{
+ Mouse::Meta::Method::Accessor->_generate_reader($self, undef, $metaclass);
+ }
+ };
+}
+
+sub get_write_method_ref{
+ my($self) = @_;
+
+ $self->{_write_method_ref} ||= do{
+ my $metaclass = $self->associated_class
+ or $self->throw_error('No asocciated class for ' . $self->name);
+
+ my $reader = $self->{writer} || $self->{accessor};
+ if($reader){
+ $metaclass->name->can($reader);
+ }
+ else{
+ Mouse::Meta::Method::Accessor->_generate_writer($self, undef, $metaclass);
+ }
+ };
+}
+
+sub associate_method{
+ my ($attribute, $method) = @_;
+ $attribute->{associated_methods}++;
+ return;
+}
+
sub install_accessors{
my($attribute) = @_;
my $metaclass = $attribute->{associated_class};
- my $generator_class = $attribute->accessor_metaclass;
foreach my $type(qw(accessor reader writer predicate clearer handles)){
if(exists $attribute->{$type}){
- my $installer = '_install_' . $type;
- $generator_class->$installer($attribute, $attribute->{$type}, $metaclass);
+ my $installer = '_generate_' . $type;
+
+ Mouse::Meta::Method::Accessor->$installer($attribute, $attribute->{$type}, $metaclass);
+
$attribute->{associated_methods}++;
}
}
if($attribute->can('create') != \&create){
+ # backword compatibility
$attribute->create($metaclass, $attribute->name, %{$attribute});
}
=head1 NAME
-Mouse::Meta::Attribute - attribute metaclass
+Mouse::Meta::Attribute - The Mouse attribute metaclass
=head1 METHODS
=over 4
-=item * C<< is => 'ro', 'rw', 'bare' >>
+=item C<< is => 'ro', 'rw', 'bare' >>
This provides a shorthand for specifying the C<reader>, C<writer>, or
C<accessor> names. If the attribute is read-only ('ro') then it will
Moose will issue a deprecation warning when this attribute is added to a
metaclass.
-=item * C<< isa => Type >>
+=item C<< isa => Type >>
This option accepts a type. The type can be a string, which should be
a type name. If the type name is unknown, it is assumed to be a class
be a class name, and that class must do the role specified with
C<does>.
-=item * C<< does => Role >>
+=item C<< does => Role >>
This is short-hand for saying that the attribute's type must be an
object which does the named role.
B<This option is not yet supported.>
-=item * C<< coerce => Bool >>
+=item C<< coerce => Bool >>
This option is only valid for objects with a type constraint
(C<isa>). If this is true, then coercions will be applied whenever
You can make both this and the C<weak_ref> option true.
-=item * C<< trigger => CodeRef >>
+=item C<< trigger => CodeRef >>
This option accepts a subroutine reference, which will be called after
the attribute is set.
-=item * C<< required => Bool >>
+=item C<< required => Bool >>
An attribute which is required must be provided to the constructor. An
attribute which is required can also have a C<default> or C<builder>,
A required attribute must have a C<default>, C<builder> or a
non-C<undef> C<init_arg>
-=item * C<< lazy => Bool >>
+=item C<< lazy => Bool >>
A lazy attribute must have a C<default> or C<builder>. When an
attribute is lazy, the default value will not be calculated until the
attribute is read.
-=item * C<< weak_ref => Bool >>
+=item C<< weak_ref => Bool >>
If this is true, the attribute's value will be stored as a weak
reference.
-=item * C<< auto_deref => Bool >>
+=item C<< auto_deref => Bool >>
If this is true, then the reader will dereference the value when it is
called. The attribute must have a type constraint which defines the
attribute as an array or hash reference.
-=item * C<< lazy_build => Bool >>
+=item C<< lazy_build => Bool >>
Setting this to true makes the attribute lazy and provides a number of
default methods.
=back
+=head2 C<< associate_method(Method) >>
+
+Associates a method with the attribute. Typically, this is called internally
+when an attribute generates its accessors.
+
+Currently the argument I<Method> is ignored in Mouse.
+
=head2 C<< verify_against_type_constraint(Item) -> TRUE | ERROR >>
Checks that the given value passes this attribute's type constraint. Returns C<true>
=head2 C<< clone_and_inherit_options(options) -> Mouse::Meta::Attribute >>
-Creates a new attribute in OwnerClass, inheriting options from parent classes.
+Creates a new attribute in the owner class, inheriting options from parent classes.
Accessors and helper methods are installed. Some error checking is done.
+=head2 C<< get_read_method_ref >>\r
+\r
+=head2 C<< get_write_method_ref >>\r
+\r
+Returns the subroutine reference of a method suitable for reading or\r
+writing the attribute's value in the associated class. These methods\r
+always return a subroutine reference, regardless of whether or not the\r
+attribute is read- or write-only.
+
=head1 SEE ALSO
L<Moose::Meta::Attribute>
+L<Class::MOP::Attribute>
+
=cut