X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FMouse%2FMeta%2FAttribute.pm;h=0d7f8241eb4d47f44af5c4e08a079fa076ccc980;hb=d16fe7d79e7f254ed479b58681d716e78b3e8caf;hp=6a8c88800169c127fef73039f5f222292e75dc95;hpb=58af95b87869e95b132806405054324491903fa1;p=gitmo%2FMouse.git diff --git a/lib/Mouse/Meta/Attribute.pm b/lib/Mouse/Meta/Attribute.pm index 6a8c888..0d7f824 100644 --- a/lib/Mouse/Meta/Attribute.pm +++ b/lib/Mouse/Meta/Attribute.pm @@ -1,5 +1,5 @@ #!/usr/bin/env perl -package Mouse::Attribute; +package Mouse::Meta::Attribute; use strict; use warnings; @@ -10,27 +10,32 @@ sub new { my $class = shift; my %args = @_; - $args{init_arg} = $args{name} + my $name = $args{name}; + + $args{init_arg} = $name unless exists $args{init_arg}; + $args{is} ||= ''; bless \%args, $class; } -sub name { $_[0]->{name} } -sub class { $_[0]->{class} } -sub _is_metadata { $_[0]->{is} } -sub is_required { $_[0]->{required} } -sub default { $_[0]->{default} } -sub is_lazy { $_[0]->{lazy} } -sub predicate { $_[0]->{predicate} } -sub clearer { $_[0]->{clearer} } -sub handles { $_[0]->{handles} } -sub is_weak_ref { $_[0]->{weak_ref} } -sub init_arg { $_[0]->{init_arg} } -sub type_constraint { $_[0]->{type_constraint} } -sub trigger { $_[0]->{trigger} } -sub builder { $_[0]->{builder} } +sub name { $_[0]->{name} } +sub associated_class { $_[0]->{associated_class} } +sub _is_metadata { $_[0]->{is} } +sub is_required { $_[0]->{required} } +sub default { $_[0]->{default} } +sub is_lazy { $_[0]->{lazy} } +sub is_lazy_build { $_[0]->{lazy_build} } +sub predicate { $_[0]->{predicate} } +sub clearer { $_[0]->{clearer} } +sub handles { $_[0]->{handles} } +sub is_weak_ref { $_[0]->{weak_ref} } +sub init_arg { $_[0]->{init_arg} } +sub type_constraint { $_[0]->{type_constraint} } +sub trigger { $_[0]->{trigger} } +sub builder { $_[0]->{builder} } +sub should_auto_deref { $_[0]->{auto_deref} } sub has_default { exists $_[0]->{default} } sub has_predicate { exists $_[0]->{predicate} } @@ -40,17 +45,26 @@ sub has_type_constraint { exists $_[0]->{type_constraint} } sub has_trigger { exists $_[0]->{trigger} } sub has_builder { exists $_[0]->{builder} } +sub _create_args { + $_[0]->{_create_args} = $_[1] if @_ > 1; + $_[0]->{_create_args} +} + sub generate_accessor { my $attribute = shift; my $name = $attribute->name; my $key = $name; my $default = $attribute->default; - my $trigger = $attribute->trigger; my $type = $attribute->type_constraint; my $constraint = $attribute->find_type_constraint; my $builder = $attribute->builder; + my $trigger = $attribute->trigger; + my $before = $trigger->{before}; + my $after = $trigger->{after}; + my $around = $trigger->{around}; + my $accessor = 'sub { my $self = shift;'; @@ -58,21 +72,36 @@ sub generate_accessor { $accessor .= 'if (@_) { local $_ = $_[0];'; - if ($constraint) { - $accessor .= 'do { - my $display = defined($_) ? overload::StrVal($_) : "undef"; - Carp::confess("Attribute ($name) does not pass the type constraint because: Validation failed for \'$type\' failed with value $display") unless $constraint->(); - };' + if ($before) { + $accessor .= '$before->($self, $_, $attribute);'; + } + + if ($around) { + $accessor .= '$around->(sub { + my $self = shift; + $_ = $_[0]; + '; } - $accessor .= '$self->{$key} = $_;'; + if ($constraint) { + $accessor .= 'unless ($constraint->()) { + my $display = defined($_) ? overload::StrVal($_) : "undef"; + Carp::confess("Attribute ($name) does not pass the type constraint because: Validation failed for \'$type\' failed with value $display"); + }' + } - if ($attribute->is_weak_ref) { - $accessor .= 'Scalar::Util::weaken($self->{$key}) if ref($self->{$key});'; + $accessor .= '$self->{$key} = $_;'; + + if ($attribute->is_weak_ref) { + $accessor .= 'Scalar::Util::weaken($self->{$key}) if ref($self->{$key});'; + } + + if ($around) { + $accessor .= '}, $self, $_, $attribute);'; } - if ($trigger) { - $accessor .= '$trigger->($self, $_, $attribute);'; + if ($after) { + $accessor .= '$after->($self, $_, $attribute);'; } $accessor .= '}'; @@ -93,7 +122,20 @@ sub generate_accessor { $accessor .= ' if !exists($self->{$key});'; } - $accessor .= 'return $self->{$key} + if ($attribute->should_auto_deref) { + if ($attribute->type_constraint eq 'ArrayRef') { + $accessor .= 'if (wantarray) { + return @{ $self->{$key} || [] }; + }'; + } + else { + $accessor .= 'if (wantarray) { + return %{ $self->{$key} || {} }; + }'; + } + } + + $accessor .= 'return $self->{$key}; }'; return eval $accessor; @@ -141,17 +183,18 @@ sub generate_handles { sub create { my ($self, $class, $name, %args) = @_; - confess "You cannot have lazy attribute ($name) without specifying a default value for it" - if $args{lazy} && !exists($args{default}) && !exists($args{builder}); + $args{name} = $name; + $args{associated_class} = $class; - confess "References are not allowed as default values, you must wrap the default of '$name' in a CODE reference (ex: sub { [] } and not [])" - if ref($args{default}) - && ref($args{default}) ne 'CODE'; + %args = $self->canonicalize_args($name, %args); + $self->validate_args($name, \%args); $args{type_constraint} = delete $args{isa} if exists $args{isa}; - my $attribute = $self->new(%args, name => $name, class => $class); + my $attribute = $self->new(%args); + $attribute->_create_args(\%args); + my $meta = $class->meta; $meta->add_attribute($attribute); @@ -184,6 +227,68 @@ sub create { return $attribute; } +sub canonicalize_args { + my $self = shift; + my $name = shift; + my %args = @_; + + if ($args{lazy_build}) { + $args{lazy} = 1; + $args{required} = 1; + $args{builder} = "_build_${name}" + if !exists($args{builder}); + if ($name =~ /^_/) { + $args{clearer} = "_clear${name}" if !exists($args{clearer}); + $args{predicate} = "_has${name}" if !exists($args{predicate}); + } + else { + $args{clearer} = "clear_${name}" if !exists($args{clearer}); + $args{predicate} = "has_${name}" if !exists($args{predicate}); + } + } + + return %args; +} + +sub validate_args { + my $self = shift; + my $name = shift; + my $args = shift; + + confess "You can not use lazy_build and default for the same attribute ($name)" + if $args->{lazy_build} && exists $args->{default}; + + confess "You cannot have lazy attribute ($name) without specifying a default value for it" + if $args->{lazy} + && !exists($args->{default}) + && !exists($args->{builder}); + + confess "References are not allowed as default values, you must wrap the default of '$name' in a CODE reference (ex: sub { [] } and not [])" + if ref($args->{default}) + && ref($args->{default}) ne 'CODE'; + + confess "You cannot auto-dereference without specifying a type constraint on attribute ($name)" + if $args->{auto_deref} && !exists($args->{isa}); + + confess "You cannot auto-dereference anything other than a ArrayRef or HashRef on attribute ($name)" + if $args->{auto_deref} + && $args->{isa} ne 'ArrayRef' + && $args->{isa} ne 'HashRef'; + + if ($args->{trigger}) { + if (ref($args->{trigger}) eq 'CODE') { + $args->{trigger} = { + after => $args->{trigger}, + }; + } + + confess "Trigger must be a CODE or HASH ref on attribute ($name)" + if ref($args->{trigger}) ne 'HASH'; + } + + return 1; +} + sub find_type_constraint { my $self = shift; my $type = $self->type_constraint; @@ -226,28 +331,51 @@ sub _canonicalize_handles { } } +sub clone_parent { + my $self = shift; + my $class = shift; + my $name = shift; + my %args = ($self->get_parent_args($class, $name), @_); + + $self->create($class, $name, %args); +} + +sub get_parent_args { + my $self = shift; + my $class = shift; + my $name = shift; + + for my $super ($class->meta->linearized_isa) { + my $super_attr = $super->can("meta") && $super->meta->get_attribute($name) + or next; + return %{ $super_attr->_create_args }; + } + + confess "Could not find an attribute by the name of '$name' to inherit from"; +} + 1; __END__ =head1 NAME -Mouse::Attribute - attribute metaclass +Mouse::Meta::Attribute - attribute metaclass =head1 METHODS -=head2 new %args -> Mouse::Attribute +=head2 new %args -> Mouse::Meta::Attribute -Instantiates a new Mouse::Attribute. Does nothing else. +Instantiates a new Mouse::Meta::Attribute. Does nothing else. -=head2 create OwnerClass, AttributeName, %args -> Mouse::Attribute +=head2 create OwnerClass, AttributeName, %args -> Mouse::Meta::Attribute Creates a new attribute in OwnerClass. Accessors and helper methods are installed. Some error checking is done. =head2 name -> AttributeName -=head2 class -> OwnerClass +=head2 associated_class -> OwnerClass =head2 is_required -> Bool @@ -285,6 +413,10 @@ installed. Some error checking is done. =head2 has_builder -> Bool +=head2 is_lazy_build => Bool + +=head2 should_auto_deref -> Bool + Informational methods. =head2 generate_accessor -> CODE @@ -313,5 +445,25 @@ this attribute's type constraint; Checks that the given value passes this attribute's type constraint. Returns 1 on success, otherwise Ces. +=head2 canonicalize_args Name, %args -> %args + +Canonicalizes some arguments to create. In particular, C is +canonicalized into C, C, etc. + +=head2 validate_args Name, \%args -> 1 | ERROR + +Checks that the arguments to create the attribute (ie those specified by +C) are valid. + +=head2 clone_parent OwnerClass, AttributeName, %args -> 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 + +Returns the options that the parent class of C used for attribute +C. + =cut