X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?p=gitmo%2FMouse.git;a=blobdiff_plain;f=lib%2FMouse%2FMeta%2FAttribute.pm;h=4feac11dd03d1b2e5118ce42ee7d5d153bf715f2;hp=ec752cb08aa0fc5b6ad5d2df7b4edebdadb281b8;hb=4a29b63e8d38182682b0c13ac0260f708cb1b89f;hpb=53875581c2449e237cc1135b8c2cf1674a874aed diff --git a/lib/Mouse/Meta/Attribute.pm b/lib/Mouse/Meta/Attribute.pm index ec752cb..4feac11 100644 --- a/lib/Mouse/Meta/Attribute.pm +++ b/lib/Mouse/Meta/Attribute.pm @@ -3,7 +3,6 @@ use strict; use warnings; use Carp (); -use Scalar::Util qw(weaken); use Mouse::Util qw(:meta); @@ -73,7 +72,8 @@ sub _process_options{ $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}; @@ -204,8 +204,6 @@ sub _create_args { $_[0]->{_create_args} } -sub accessor_metaclass { 'Mouse::Meta::Method::Accessor' } - sub interpolate_class{ my($class, $name, $args) = @_; @@ -278,7 +276,7 @@ sub verify_type_constraint_error { sub coerce_constraint { ## my($self, $value) = @_; my $type = $_[0]->{type_constraint} or return $_[1]; - return Mouse::Util::TypeConstraints->typecast_constraints($_[0]->associated_class->name, $_[0]->type_constraint, $_[1]); + return Mouse::Util::TypeConstraints->typecast_constraints($_[0]->associated_class->name, $type, $_[1]); } sub _canonicalize_handles { @@ -300,7 +298,7 @@ sub clone_and_inherit_options{ 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 { @@ -313,7 +311,7 @@ sub clone_parent { . "Use \$meta->add_attribute and \$attr->install_accessors instead."); - $self->create($class, $name, %args); + $self->clone_and_inherited_args($class, $name, %args); } sub get_parent_args { @@ -334,17 +332,19 @@ 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); + + 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}); } @@ -368,85 +368,123 @@ Mouse::Meta::Attribute - attribute metaclass =head1 METHODS -=head2 new %args -> Mouse::Meta::Attribute +=head2 C<< new(%options) -> Mouse::Meta::Attribute >> Instantiates a new Mouse::Meta::Attribute. Does nothing else. -=head2 create OwnerClass, AttributeName, %args -> Mouse::Meta::Attribute +It adds the following options to the constructor: -Creates a new attribute in OwnerClass. Accessors and helper methods are -installed. Some error checking is done. +=over 4 -=head2 name -> AttributeName +=item * C<< is => 'ro', 'rw', 'bare' >> -=head2 associated_class -> OwnerClass +This provides a shorthand for specifying the C, C, or +C names. If the attribute is read-only ('ro') then it will +have a C method with the same attribute as the name. -=head2 is_required -> Bool +If it is read-write ('rw') then it will have an C method +with the same name. If you provide an explicit C for a +read-write attribute, then you will have a C with the same +name as the attribute, and a C with the name you provided. -=head2 default -> Item +Use 'bare' when you are deliberately not installing any methods +(accessor, reader, etc.) associated with this attribute; otherwise, +Moose will issue a deprecation warning when this attribute is added to a +metaclass. -=head2 has_default -> Bool +=item * C<< isa => Type >> -=head2 is_lazy -> Bool +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 +name. -=head2 predicate -> MethodName | Undef +This option can also accept a L object. -=head2 has_predicate -> Bool +If you I provide a C option, then your C option must +be a class name, and that class must do the role specified with +C. -=head2 clearer -> MethodName | Undef +=item * C<< does => Role >> -=head2 has_clearer -> Bool +This is short-hand for saying that the attribute's type must be an +object which does the named role. -=head2 handles -> { LocalName => RemoteName } +B -=head2 has_handles -> Bool +=item * C<< coerce => Bool >> -=head2 is_weak_ref -> Bool +This option is only valid for objects with a type constraint +(C). If this is true, then coercions will be applied whenever +this attribute is set. -=head2 init_arg -> Str +You can make both this and the C option true. -=head2 type_constraint -> Str +=item * C<< trigger => CodeRef >> -=head2 has_type_constraint -> Bool +This option accepts a subroutine reference, which will be called after +the attribute is set. -=head2 trigger => CODE | Undef +=item * C<< required => Bool >> -=head2 has_trigger -> Bool +An attribute which is required must be provided to the constructor. An +attribute which is required can also have a C or C, +which will satisfy its required-ness. -=head2 builder => MethodName | Undef +A required attribute must have a C, C or a +non-C C -=head2 has_builder -> Bool +=item * C<< lazy => Bool >> -=head2 is_lazy_build => Bool +A lazy attribute must have a C or C. When an +attribute is lazy, the default value will not be calculated until the +attribute is read. -=head2 should_auto_deref -> Bool +=item * C<< weak_ref => Bool >> -Informational methods. +If this is true, the attribute's value will be stored as a weak +reference. -=head2 verify_against_type_constraint Item -> 1 | ERROR +=item * C<< auto_deref => Bool >> -Checks that the given value passes this attribute's type constraint. Returns 1 -on success, otherwise Ces. +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 >> -=head2 canonicalize_args Name, %args -> %args +Setting this to true makes the attribute lazy and provides a number of +default methods. -Canonicalizes some arguments to create. In particular, C is -canonicalized into C, C, etc. + has 'size' => ( + is => 'ro', + lazy_build => 1, + ); -=head2 validate_args Name, \%args -> 1 | ERROR +is equivalent to this: -Checks that the arguments to create the attribute (ie those specified by -C) are valid. + has 'size' => ( + is => 'ro', + lazy => 1, + builder => '_build_size', + clearer => 'clear_size', + predicate => 'has_size', + ); + +=back + +=head2 C<< verify_against_type_constraint(Item) -> TRUE | ERROR >> + +Checks that the given value passes this attribute's type constraint. Returns C +on success, otherwise Ces. -=head2 clone_parent OwnerClass, AttributeName, %args -> Mouse::Meta::Attribute +=head2 C<< clone_and_inherit_options(options) -> Mouse::Meta::Attribute >> Creates a new attribute in OwnerClass, inheriting options from parent classes. Accessors and helper methods are installed. Some error checking is done. -=head2 get_parent_args OwnerClass, AttributeName -> Hash +=head1 SEE ALSO -Returns the options that the parent class of C used for attribute -C. +L =cut