lib/Moose/Meta/Attribute.pm

   1
   2 package Moose::Meta::Attribute;
   3
   4 use strict;
   5 use warnings;
   6
   7 use Scalar::Util 'blessed', 'weaken', 'reftype';
   8 use Carp         'confess';
   9 use overload     ();
  10
  11 our $VERSION   = '0.24';
  12 our $AUTHORITY = 'cpan:STEVAN';
  13
  14 use Moose::Meta::Method::Accessor;
  15 use Moose::Util ();
  16 use Moose::Util::TypeConstraints ();
  17
  18 use base 'Class::MOP::Attribute';
  19
  20 # options which are not directly used
  21 # but we store them for metadata purposes
  22 __PACKAGE__->meta->add_attribute('isa'  => (reader    => '_isa_metadata'));
  23 __PACKAGE__->meta->add_attribute('does' => (reader    => '_does_metadata'));
  24 __PACKAGE__->meta->add_attribute('is'   => (reader    => '_is_metadata'));
  25
  26 # these are actual options for the attrs
  27 __PACKAGE__->meta->add_attribute('required'   => (reader => 'is_required'      ));
  28 __PACKAGE__->meta->add_attribute('lazy'       => (reader => 'is_lazy'          ));
  29 __PACKAGE__->meta->add_attribute('lazy_build' => (reader => 'is_lazy_build'    ));
  30 __PACKAGE__->meta->add_attribute('coerce'     => (reader => 'should_coerce'    ));
  31 __PACKAGE__->meta->add_attribute('weak_ref'   => (reader => 'is_weak_ref'      ));
  32 __PACKAGE__->meta->add_attribute('auto_deref' => (reader => 'should_auto_deref'));
  33 __PACKAGE__->meta->add_attribute('type_constraint' => (
  34     reader    => 'type_constraint',
  35     predicate => 'has_type_constraint',
  36 ));
  37 __PACKAGE__->meta->add_attribute('trigger' => (
  38     reader    => 'trigger',
  39     predicate => 'has_trigger',
  40 ));
  41 __PACKAGE__->meta->add_attribute('handles' => (
  42     reader    => 'handles',
  43     predicate => 'has_handles',
  44 ));
  45 __PACKAGE__->meta->add_attribute('documentation' => (
  46     reader    => 'documentation',
  47     predicate => 'has_documentation',
  48 ));
  49 __PACKAGE__->meta->add_attribute('traits' => (
  50     reader    => 'applied_traits',
  51     predicate => 'has_applied_traits',
  52 ));
  53
  54 # NOTE:
  55 # we need to have a ->does method in here to
  56 # more easily support traits, and the introspection
  57 # of those traits. So in order to do this we
  58 # just alias Moose::Object's version of it.
  59 # - SL
  60 *does = \&Moose::Object::does;
  61
  62 sub new {
  63     my ($class, $name, %options) = @_;
  64     $class->_process_options($name, \%options) unless $options{__hack_no_process_options}; # used from clone()... YECHKKK FIXME ICKY YUCK GROSS
  65     return $class->SUPER::new($name, %options);
  66 }
  67
  68 sub interpolate_class_and_new {
  69     my ($class, $name, @args) = @_;
  70
  71     my ( $new_class, @traits ) = $class->interpolate_class(@args);
  72
  73     $new_class->new($name, @args, ( scalar(@traits) ? ( traits => \@traits ) : () ) );
  74 }
  75
  76 sub interpolate_class {
  77     my ($class, %options) = @_;
  78
  79     $class = ref($class) || $class;
  80
  81     if ( my $metaclass_name = delete $options{metaclass} ) {
  82         my $new_class = Moose::Util::resolve_metaclass_alias( Attribute => $metaclass_name );
  83
  84         if ( $class ne $new_class ) {
  85             if ( $new_class->can("interpolate_class") ) {
  86                 return $new_class->interpolate_class(%options);
  87             } else {
  88                 $class = $new_class;
  89             }
  90         }
  91     }
  92
  93     my @traits;
  94
  95     if (my $traits = $options{traits}) {
  96         if ( @traits = grep { not $class->does($_) } map {
  97             Moose::Util::resolve_metatrait_alias( Attribute => $_ )
  98                 or
  99             $_
 100         } @$traits ) {
 101             my $anon_class = Moose::Meta::Class->create_anon_class(
 102                 superclasses => [ $class ],
 103                 roles        => [ @traits ],
 104                 cache        => 1,
 105             );
 106
 107             $class = $anon_class->name;
 108         }
 109     }
 110
 111     return ( wantarray ? ( $class, @traits ) : $class );
 112 }
 113
 114 sub clone_and_inherit_options {
 115     my ($self, %options) = @_;
 116     my %copy = %options;
 117     # you can change default, required, coerce, documentation, lazy, handles, builder, type_constraint (explicitly or using isa/does), metaclass and traits
 118     my %actual_options;
 119     foreach my $legal_option (qw(default coerce required documentation lazy handles builder type_constraint)) {
 120         if (exists $options{$legal_option}) {
 121             $actual_options{$legal_option} = $options{$legal_option};
 122             delete $options{$legal_option};
 123         }
 124     }
 125
 126     if ($options{isa}) {
 127         my $type_constraint;
 128         if (blessed($options{isa}) && $options{isa}->isa('Moose::Meta::TypeConstraint')) {
 129             $type_constraint = $options{isa};
 130         }
 131         else {
 132             $type_constraint = Moose::Util::TypeConstraints::find_or_create_isa_type_constraint($options{isa});
 133             (defined $type_constraint)
 134                 || confess "Could not find the type constraint '" . $options{isa} . "'";
 135         }
 136
 137         $actual_options{type_constraint} = $type_constraint;
 138         delete $options{isa};
 139     }
 140
 141     if ($options{does}) {
 142         my $type_constraint;
 143         if (blessed($options{does}) && $options{does}->isa('Moose::Meta::TypeConstraint')) {
 144             $type_constraint = $options{does};
 145         }
 146         else {
 147             $type_constraint = Moose::Util::TypeConstraints::find_or_create_does_type_constraint($options{does});
 148             (defined $type_constraint)
 149                 || confess "Could not find the type constraint '" . $options{does} . "'";
 150         }
 151
 152         $actual_options{type_constraint} = $type_constraint;
 153         delete $options{does};
 154     }
 155
 156     # NOTE:
 157     # this doesn't apply to Class::MOP::Attributes,
 158     # so we can ignore it for them.
 159     # - SL
 160     if ($self->can('interpolate_class')) {
 161         ( $actual_options{metaclass}, my @traits ) = $self->interpolate_class(%options);
 162
 163         my %seen;
 164         my @all_traits = grep { $seen{$_}++ } @{ $self->applied_traits || [] }, @traits;
 165         $actual_options{traits} = \@all_traits if @all_traits;
 166
 167         delete @options{qw(metaclass traits)};
 168     }
 169
 170     (scalar keys %options == 0)
 171         || confess "Illegal inherited options => (" . (join ', ' => keys %options) . ")";
 172
 173
 174     $self->clone(%actual_options);
 175 }
 176
 177 sub clone {
 178     my ( $self, %params ) = @_;
 179
 180     my $class = $params{metaclass} || ref $self;
 181
 182     if ( 0 and $class eq ref $self ) {
 183         return $self->SUPER::clone(%params);
 184     } else {
 185         my ( @init, @non_init );
 186
 187         foreach my $attr ( grep { $_->has_value($self) } $self->meta->compute_all_applicable_attributes ) {
 188             push @{ $attr->has_init_arg ? \@init : \@non_init }, $attr;
 189         }
 190
 191         my %new_params = ( ( map { $_->init_arg => $_->get_value($self) } @init ), %params );
 192
 193         my $name = delete $new_params{name};
 194
 195         my $clone = $class->new($name, %new_params, __hack_no_process_options => 1 );
 196
 197         foreach my $attr ( @non_init ) {
 198             $attr->set_value($clone, $attr->get_value($self));
 199         }
 200
 201
 202         return $clone;
 203     }
 204 }
 205
 206 sub _process_options {
 207     my ($class, $name, $options) = @_;
 208
 209     if (exists $options->{is}) {
 210         if ($options->{is} eq 'ro') {
 211             $options->{reader} ||= $name;
 212         }
 213         elsif ($options->{is} eq 'rw') {
 214             $options->{accessor} = $name;
 215         }
 216         else {
 217             confess "I do not understand this option (is => " . $options->{is} . ") on attribute $name"
 218         }
 219     }
 220
 221     if (exists $options->{isa}) {
 222         if (exists $options->{does}) {
 223             if (eval { $options->{isa}->can('does') }) {
 224                 ($options->{isa}->does($options->{does}))
 225                     || confess "Cannot have an isa option and a does option if the isa does not do the does on attribute $name";
 226             }
 227             else {
 228                 confess "Cannot have an isa option which cannot ->does() on attribute $name";
 229             }
 230         }
 231
 232         # allow for anon-subtypes here ...
 233         if (blessed($options->{isa}) && $options->{isa}->isa('Moose::Meta::TypeConstraint')) {
 234             $options->{type_constraint} = $options->{isa};
 235         }
 236         else {
 237             $options->{type_constraint} = Moose::Util::TypeConstraints::find_or_create_isa_type_constraint($options->{isa});
 238         }
 239     }
 240     elsif (exists $options->{does}) {
 241         # allow for anon-subtypes here ...
 242         if (blessed($options->{does}) && $options->{does}->isa('Moose::Meta::TypeConstraint')) {
 243                 $options->{type_constraint} = $options->{does};
 244         }
 245         else {
 246             $options->{type_constraint} = Moose::Util::TypeConstraints::find_or_create_does_type_constraint($options->{does});
 247         }
 248     }
 249
 250     if (exists $options->{coerce} && $options->{coerce}) {
 251         (exists $options->{type_constraint})
 252             || confess "You cannot have coercion without specifying a type constraint on attribute $name";
 253         confess "You cannot have a weak reference to a coerced value on attribute $name"
 254             if $options->{weak_ref};
 255     }
 256
 257     if (exists $options->{trigger}) {
 258         (reftype($options->{trigger}) || '') eq 'CODE'
 259             || confess "Trigger must be a CODE ref";
 260     }
 261
 262     if (exists $options->{auto_deref} && $options->{auto_deref}) {
 263         (exists $options->{type_constraint})
 264             || confess "You cannot auto-dereference without specifying a type constraint on attribute $name";
 265         ($options->{type_constraint}->is_a_type_of('ArrayRef') ||
 266          $options->{type_constraint}->is_a_type_of('HashRef'))
 267             || confess "You cannot auto-dereference anything other than a ArrayRef or HashRef on attribute $name";
 268     }
 269
 270     if (exists $options->{lazy_build} && $options->{lazy_build} == 1) {
 271         confess("You can not use lazy_build and default for the same attribute $name")
 272             if exists $options->{default};
 273         $options->{lazy}      = 1;
 274         $options->{required}  = 1;
 275         $options->{builder} ||= "_build_${name}";
 276         if ($name =~ /^_/) {
 277             $options->{clearer}   ||= "_clear${name}";
 278             $options->{predicate} ||= "_has${name}";
 279         }
 280         else {
 281             $options->{clearer}   ||= "clear_${name}";
 282             $options->{predicate} ||= "has_${name}";
 283         }
 284     }
 285
 286     if (exists $options->{lazy} && $options->{lazy}) {
 287         (exists $options->{default} || defined $options->{builder} )
 288             || confess "You cannot have lazy attribute ($name) without specifying a default value for it";
 289     }
 290
 291     if ( $options->{required} && !( ( !exists $options->{init_arg} || defined $options->{init_arg} ) || exists $options->{default} || defined $options->{builder} ) ) {
 292         confess "You cannot have a required attribute ($name) without a default, builder, or an init_arg";
 293     }
 294
 295 }
 296
 297 sub initialize_instance_slot {
 298     my ($self, $meta_instance, $instance, $params) = @_;
 299     my $init_arg = $self->init_arg();
 300     # try to fetch the init arg from the %params ...
 301
 302     my $val;
 303     my $value_is_set;
 304     if ( defined($init_arg) and exists $params->{$init_arg}) {
 305         $val = $params->{$init_arg};
 306         $value_is_set = 1;
 307     }
 308     else {
 309         # skip it if it's lazy
 310         return if $self->is_lazy;
 311         # and die if it's required and doesn't have a default value
 312         confess "Attribute (" . $self->name . ") is required"
 313             if $self->is_required && !$self->has_default && !$self->has_builder;
 314
 315         # if nothing was in the %params, we can use the
 316         # attribute's default value (if it has one)
 317         if ($self->has_default) {
 318             $val = $self->default($instance);
 319             $value_is_set = 1;
 320         }
 321         elsif ($self->has_builder) {
 322             if (my $builder = $instance->can($self->builder)){
 323                 $val = $instance->$builder;
 324                 $value_is_set = 1;
 325             }
 326             else {
 327                 confess(blessed($instance)." does not support builder method '".$self->builder."' for attribute '" . $self->name . "'");
 328             }
 329         }
 330     }
 331
 332     return unless $value_is_set;
 333
 334     if ($self->has_type_constraint) {
 335         my $type_constraint = $self->type_constraint;
 336         if ($self->should_coerce && $type_constraint->has_coercion) {
 337             $val = $type_constraint->coerce($val);
 338         }
 339         $type_constraint->check($val)
 340             || confess "Attribute ("
 341                      . $self->name
 342                      . ") does not pass the type constraint because: "
 343                      . $type_constraint->get_message($val);
 344     }
 345
 346     $self->set_initial_value($instance, $val);
 347     $meta_instance->weaken_slot_value($instance, $self->name)
 348         if ref $val && $self->is_weak_ref;
 349 }
 350
 351 ## Slot management
 352
 353 # FIXME:
 354 # this duplicates too much code from
 355 # Class::MOP::Attribute, we need to
 356 # refactor these bits eventually.
 357 # - SL
 358 sub _set_initial_slot_value {
 359     my ($self, $meta_instance, $instance, $value) = @_;
 360
 361     my $slot_name = $self->name;
 362
 363     return $meta_instance->set_slot_value($instance, $slot_name, $value)
 364         unless $self->has_initializer;
 365
 366     my ($type_constraint, $can_coerce);
 367     if ($self->has_type_constraint) {
 368         $type_constraint = $self->type_constraint;
 369         $can_coerce      = ($self->should_coerce && $type_constraint->has_coercion);
 370     }
 371
 372     my $callback = sub {
 373         my $val = shift;
 374         if ($type_constraint) {
 375             $val = $type_constraint->coerce($val)
 376                 if $can_coerce;
 377             $type_constraint->check($val)
 378                 || confess "Attribute ("
 379                          . $slot_name
 380                          . ") does not pass the type constraint because: "
 381                          . $type_constraint->get_message($val);
 382         }
 383         $meta_instance->set_slot_value($instance, $slot_name, $val);
 384     };
 385
 386     my $initializer = $self->initializer;
 387
 388     # most things will just want to set a value, so make it first arg
 389     $instance->$initializer($value, $callback, $self);
 390 }
 391
 392 sub set_value {
 393     my ($self, $instance, $value) = @_;
 394
 395     my $attr_name = $self->name;
 396
 397     if ($self->is_required) {
 398         defined($value)
 399             || confess "Attribute ($attr_name) is required, so cannot be set to undef";
 400     }
 401
 402     if ($self->has_type_constraint) {
 403
 404         my $type_constraint = $self->type_constraint;
 405
 406         if ($self->should_coerce) {
 407             $value = $type_constraint->coerce($value);
 408         }
 409         $type_constraint->_compiled_type_constraint->($value)
 410             || confess "Attribute ("
 411                      . $self->name
 412                      . ") does not pass the type constraint because "
 413                      . $type_constraint->get_message($value);
 414     }
 415
 416     my $meta_instance = Class::MOP::Class->initialize(blessed($instance))
 417                                          ->get_meta_instance;
 418
 419     $meta_instance->set_slot_value($instance, $attr_name, $value);
 420
 421     if (ref $value && $self->is_weak_ref) {
 422         $meta_instance->weaken_slot_value($instance, $attr_name);
 423     }
 424
 425     if ($self->has_trigger) {
 426         $self->trigger->($instance, $value, $self);
 427     }
 428 }
 429
 430 sub get_value {
 431     my ($self, $instance) = @_;
 432
 433     if ($self->is_lazy) {
 434         unless ($self->has_value($instance)) {
 435             if ($self->has_default) {
 436                 my $default = $self->default($instance);
 437                 $self->set_initial_value($instance, $default);
 438             }
 439             if ( $self->has_builder ){
 440                 if (my $builder = $instance->can($self->builder)){
 441                     $self->set_initial_value($instance, $instance->$builder);
 442                 }
 443                 else {
 444                     confess(blessed($instance)
 445                           . " does not support builder method '"
 446                           . $self->builder
 447                           . "' for attribute '"
 448                           . $self->name
 449                           . "'");
 450                 }
 451             }
 452             else {
 453                 $self->set_initial_value($instance, undef);
 454             }
 455         }
 456     }
 457
 458     if ($self->should_auto_deref) {
 459
 460         my $type_constraint = $self->type_constraint;
 461
 462         if ($type_constraint->is_a_type_of('ArrayRef')) {
 463             my $rv = $self->SUPER::get_value($instance);
 464             return unless defined $rv;
 465             return wantarray ? @{ $rv } : $rv;
 466         }
 467         elsif ($type_constraint->is_a_type_of('HashRef')) {
 468             my $rv = $self->SUPER::get_value($instance);
 469             return unless defined $rv;
 470             return wantarray ? %{ $rv } : $rv;
 471         }
 472         else {
 473             confess "Can not auto de-reference the type constraint '" . $type_constraint->name . "'";
 474         }
 475
 476     }
 477     else {
 478
 479         return $self->SUPER::get_value($instance);
 480     }
 481 }
 482
 483 ## installing accessors
 484
 485 sub accessor_metaclass { 'Moose::Meta::Method::Accessor' }
 486
 487 sub install_accessors {
 488     my $self = shift;
 489     $self->SUPER::install_accessors(@_);
 490
 491     if ($self->has_handles) {
 492
 493         # NOTE:
 494         # Here we canonicalize the 'handles' option
 495         # this will sort out any details and always
 496         # return an hash of methods which we want
 497         # to delagate to, see that method for details
 498         my %handles = $self->_canonicalize_handles();
 499
 500         # find the accessor method for this attribute
 501         my $accessor = $self->get_read_method_ref;
 502         # then unpack it if we need too ...
 503         $accessor = $accessor->body if blessed $accessor;
 504
 505         # install the delegation ...
 506         my $associated_class = $self->associated_class;
 507         foreach my $handle (keys %handles) {
 508             my $method_to_call = $handles{$handle};
 509             my $class_name = $associated_class->name;
 510             my $name = "${class_name}::${handle}";
 511
 512             (!$associated_class->has_method($handle))
 513                 || confess "You cannot overwrite a locally defined method ($handle) with a delegation";
 514
 515             # NOTE:
 516             # handles is not allowed to delegate
 517             # any of these methods, as they will
 518             # override the ones in your class, which
 519             # is almost certainly not what you want.
 520
 521             # FIXME warn when $handle was explicitly specified, but not if the source is a regex or something
 522             #cluck("Not delegating method '$handle' because it is a core method") and
 523             next if $class_name->isa("Moose::Object") and $handle =~ /^BUILD|DEMOLISH$/ || Moose::Object->can($handle);
 524
 525             if ((reftype($method_to_call) || '') eq 'CODE') {
 526                 $associated_class->add_method($handle => Class::MOP::subname($name, $method_to_call));
 527             }
 528             else {
 529                 # NOTE:
 530                 # we used to do a goto here, but the
 531                 # goto didn't handle failure correctly
 532                 # (it just returned nothing), so I took
 533                 # that out. However, the more I thought
 534                 # about it, the less I liked it doing
 535                 # the goto, and I prefered the act of
 536                 # delegation being actually represented
 537                 # in the stack trace.
 538                 # - SL
 539                 $associated_class->add_method($handle => Class::MOP::subname($name, sub {
 540                     my $proxy = (shift)->$accessor();
 541                     (defined $proxy)
 542                         || confess "Cannot delegate $handle to $method_to_call because " .
 543                                    "the value of " . $self->name . " is not defined";
 544                     $proxy->$method_to_call(@_);
 545                 }));
 546             }
 547         }
 548     }
 549
 550     return;
 551 }
 552
 553 # private methods to help delegation ...
 554
 555 sub _canonicalize_handles {
 556     my $self    = shift;
 557     my $handles = $self->handles;
 558     if (my $handle_type = ref($handles)) {
 559         if ($handle_type eq 'HASH') {
 560             return %{$handles};
 561         }
 562         elsif ($handle_type eq 'ARRAY') {
 563             return map { $_ => $_ } @{$handles};
 564         }
 565         elsif ($handle_type eq 'Regexp') {
 566             ($self->has_type_constraint)
 567                 || confess "Cannot delegate methods based on a RegExpr without a type constraint (isa)";
 568             return map  { ($_ => $_) }
 569                    grep { /$handles/ } $self->_get_delegate_method_list;
 570         }
 571         elsif ($handle_type eq 'CODE') {
 572             return $handles->($self, $self->_find_delegate_metaclass);
 573         }
 574         else {
 575             confess "Unable to canonicalize the 'handles' option with $handles";
 576         }
 577     }
 578     else {
 579         my $role_meta = eval { $handles->meta };
 580         if ($@) {
 581             confess "Unable to canonicalize the 'handles' option with $handles because : $@";
 582         }
 583
 584         (blessed $role_meta && $role_meta->isa('Moose::Meta::Role'))
 585             || confess "Unable to canonicalize the 'handles' option with $handles because ->meta is not a Moose::Meta::Role";
 586
 587         return map { $_ => $_ } (
 588             $role_meta->get_method_list,
 589             $role_meta->get_required_method_list
 590         );
 591     }
 592 }
 593
 594 sub _find_delegate_metaclass {
 595     my $self = shift;
 596     if (my $class = $self->_isa_metadata) {
 597         # if the class does have
 598         # a meta method, use it
 599         return $class->meta if $class->can('meta');
 600         # otherwise we might be
 601         # dealing with a non-Moose
 602         # class, and need to make
 603         # our own metaclass
 604         return Moose::Meta::Class->initialize($class);
 605     }
 606     elsif (my $role = $self->_does_metadata) {
 607         # our role will always have
 608         # a meta method
 609         return $role->meta;
 610     }
 611     else {
 612         confess "Cannot find delegate metaclass for attribute " . $self->name;
 613     }
 614 }
 615
 616 sub _get_delegate_method_list {
 617     my $self = shift;
 618     my $meta = $self->_find_delegate_metaclass;
 619     if ($meta->isa('Class::MOP::Class')) {
 620         return map  { $_->{name}                     }  # NOTE: !never! delegate &meta
 621                grep { $_->{class} ne 'Moose::Object' && $_->{name} ne 'meta' }
 622                     $meta->compute_all_applicable_methods;
 623     }
 624     elsif ($meta->isa('Moose::Meta::Role')) {
 625         return $meta->get_method_list;
 626     }
 627     else {
 628         confess "Unable to recognize the delegate metaclass '$meta'";
 629     }
 630 }
 631
 632 1;
 633
 634 __END__
 635
 636 =pod
 637
 638 =head1 NAME
 639
 640 Moose::Meta::Attribute - The Moose attribute metaclass
 641
 642 =head1 DESCRIPTION
 643
 644 This is a subclass of L<Class::MOP::Attribute> with Moose specific
 645 extensions.
 646
 647 For the most part, the only time you will ever encounter an
 648 instance of this class is if you are doing some serious deep
 649 introspection. To really understand this class, you need to refer
 650 to the L<Class::MOP::Attribute> documentation.
 651
 652 =head1 METHODS
 653
 654 =head2 Overridden methods
 655
 656 These methods override methods in L<Class::MOP::Attribute> and add
 657 Moose specific features. You can safely assume though that they
 658 will behave just as L<Class::MOP::Attribute> does.
 659
 660 =over 4
 661
 662 =item B<new>
 663
 664 =item B<clone>
 665
 666 =item B<does>
 667
 668 =item B<initialize_instance_slot>
 669
 670 =item B<install_accessors>
 671
 672 =item B<accessor_metaclass>
 673
 674 =item B<get_value>
 675
 676 =item B<set_value>
 677
 678   eval { $point->meta->get_attribute('x')->set_value($point, 'fourty-two') };
 679   if($@) {
 680     print "Oops: $@\n";
 681   }
 682
 683 I<Attribute (x) does not pass the type constraint (Int) with 'fourty-two'>
 684
 685 Before setting the value, a check is made on the type constraint of
 686 the attribute, if it has one, to see if the value passes it. If the
 687 value fails to pass, the set operation dies with a L<Carp/confess>.
 688
 689 Any coercion to convert values is done before checking the type constraint.
 690
 691 To check a value against a type constraint before setting it, fetch the
 692 attribute instance using L<Class::MOP::Class/find_attribute_by_name>,
 693 fetch the type_constraint from the attribute using L<Moose::Meta::Attribute/type_constraint>
 694 and call L<Moose::Meta::TypeConstraint/check>. See L<Moose::Cookbook::RecipeX>
 695 for an example.
 696
 697 =back
 698
 699 =head2 Additional Moose features
 700
 701 Moose attributes support type-constraint checking, weak reference
 702 creation and type coercion.
 703
 704 =over 4
 705
 706 =item B<interpolate_class_and_new>
 707
 708 =item B<interpolate_class>
 709
 710 When called as a class method causes interpretation of the C<metaclass> and
 711 C<traits> options.
 712
 713 =item B<clone_and_inherit_options>
 714
 715 This is to support the C<has '+foo'> feature, it clones an attribute
 716 from a superclass and allows a very specific set of changes to be made
 717 to the attribute.
 718
 719 =item B<has_type_constraint>
 720
 721 Returns true if this meta-attribute has a type constraint.
 722
 723 =item B<type_constraint>
 724
 725 A read-only accessor for this meta-attribute's type constraint. For
 726 more information on what you can do with this, see the documentation
 727 for L<Moose::Meta::TypeConstraint>.
 728
 729 =item B<has_handles>
 730
 731 Returns true if this meta-attribute performs delegation.
 732
 733 =item B<handles>
 734
 735 This returns the value which was passed into the handles option.
 736
 737 =item B<is_weak_ref>
 738
 739 Returns true if this meta-attribute produces a weak reference.
 740
 741 =item B<is_required>
 742
 743 Returns true if this meta-attribute is required to have a value.
 744
 745 =item B<is_lazy>
 746
 747 Returns true if this meta-attribute should be initialized lazily.
 748
 749 NOTE: lazy attributes, B<must> have a C<default> or C<builder> field set.
 750
 751 =item B<is_lazy_build>
 752
 753 Returns true if this meta-attribute should be initialized lazily through
 754 the builder generated by lazy_build. Using C<lazy_build =E<gt> 1> will
 755 make your attribute required and lazy. In addition it will set the builder, clearer
 756 and predicate options for you using the following convention.
 757
 758    #If your attribute name starts with an underscore:
 759    has '_foo' => (lazy_build => 1);
 760    #is the same as
 761    has '_foo' => (lazy => 1, required => 1, predicate => '_has_foo', clearer => '_clear_foo', builder => '_build__foo);
 762    # or
 763    has '_foo' => (lazy => 1, required => 1, predicate => '_has_foo', clearer => '_clear_foo', default => sub{shift->_build__foo});
 764
 765    #If your attribute name does not start with an underscore:
 766    has 'foo' => (lazy_build => 1);
 767    #is the same as
 768    has 'foo' => (lazy => 1, required => 1, predicate => 'has_foo', clearer => 'clear_foo', builder => '_build_foo);
 769    # or
 770    has 'foo' => (lazy => 1, required => 1, predicate => 'has_foo', clearer => 'clear_foo', default => sub{shift->_build_foo});
 771
 772 The reason for the different naming of the C<builder> is that the C<builder>
 773 method is a private method while the C<clearer> and C<predicate> methods
 774 are public methods.
 775
 776 NOTE: This means your class should provide a method whose name matches the value
 777 of the builder part, in this case _build__foo or _build_foo.
 778
 779 =item B<should_coerce>
 780
 781 Returns true if this meta-attribute should perform type coercion.
 782
 783 =item B<should_auto_deref>
 784
 785 Returns true if this meta-attribute should perform automatic
 786 auto-dereferencing.
 787
 788 NOTE: This can only be done for attributes whose type constraint is
 789 either I<ArrayRef> or I<HashRef>.
 790
 791 =item B<has_trigger>
 792
 793 Returns true if this meta-attribute has a trigger set.
 794
 795 =item B<trigger>
 796
 797 This is a CODE reference which will be executed every time the
 798 value of an attribute is assigned. The CODE ref will get two values,
 799 the invocant and the new value. This can be used to handle I<basic>
 800 bi-directional relations.
 801
 802 =item B<documentation>
 803
 804 This is a string which contains the documentation for this attribute.
 805 It serves no direct purpose right now, but it might in the future
 806 in some kind of automated documentation system perhaps.
 807
 808 =item B<has_documentation>
 809
 810 Returns true if this meta-attribute has any documentation.
 811
 812 =item B<applied_traits>
 813
 814 This will return the ARRAY ref of all the traits applied to this
 815 attribute, or if no traits have been applied, it returns C<undef>.
 816
 817 =item B<has_applied_traits>
 818
 819 Returns true if this meta-attribute has any traits applied.
 820
 821 =back
 822
 823 =head1 BUGS
 824
 825 All complex software has bugs lurking in it, and this module is no
 826 exception. If you find a bug please either email me, or add the bug
 827 to cpan-RT.
 828
 829 =head1 AUTHOR
 830
 831 Stevan Little E<lt>stevan@iinteractive.comE<gt>
 832
 833 Yuval Kogman E<lt>nothingmuch@woobling.comE<gt>
 834
 835 =head1 COPYRIGHT AND LICENSE
 836
 837 Copyright 2006-2008 by Infinity Interactive, Inc.
 838
 839 L<http://www.iinteractive.com>
 840
 841 This library is free software; you can redistribute it and/or modify
 842 it under the same terms as Perl itself.
 843
 844 =cut