[gitmo/Mouse.git] / lib / Mouse / Meta / Attribute.pm

#!/usr/bin/env perl
package Mouse::Meta::Attribute;
use strict;
use warnings;

use Carp 'confess';
use Scalar::Util 'blessed';

sub new {
    my $class = shift;
    my %args  = @_;

    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 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}       }
sub has_clearer         { exists $_[0]->{clearer}         }
sub has_handles         { exists $_[0]->{handles}         }
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 $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;';

    if ($attribute->_is_metadata eq 'rw') {
        $accessor .= 'if (@_) {
            local $_ = $_[0];';

        if ($before) {
            $accessor .= '$before->($self, $_, $attribute);';
        }

        if ($around) {
            $accessor .= '$around->(sub {
                my $self = shift;
                $_ = $_[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->();
                };'
            }

            $accessor .= '$self->{$key} = $_;';

            if ($attribute->is_weak_ref) {
                $accessor .= 'Scalar::Util::weaken($self->{$key}) if ref($self->{$key});';
            }

        if ($around) {
            $accessor .= '}, $self, $_, $attribute);';
        }

        if ($after) {
            $accessor .= '$after->($self, $_, $attribute);';
        }

        $accessor .= '}';
    }
    else {
        $accessor .= 'confess "Cannot assign a value to a read-only accessor" if @_;';
    }

    if ($attribute->is_lazy) {
        $accessor .= '$self->{$key} = ';

        $accessor .= $attribute->has_builder
                   ? '$self->$builder'
                     : ref($default) eq 'CODE'
                     ? '$default->($self)'
                     : '$default';

        $accessor .= ' if !exists($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;
}

sub generate_predicate {
    my $attribute = shift;
    my $key = $attribute->name;

    my $predicate = 'sub { exists($_[0]->{$key}) }';

    return eval $predicate;
}

sub generate_clearer {
    my $attribute = shift;
    my $key = $attribute->name;

    my $predicate = 'sub { delete($_[0]->{$key}) }';

    return eval $predicate;
}

sub generate_handles {
    my $attribute = shift;
    my $reader = $attribute->name;
    my %handles = $attribute->_canonicalize_handles($attribute->handles);

    my %method_map;

    for my $local_method (keys %handles) {
        my $remote_method = $handles{$local_method};

        my $method = 'sub {
            my $self = shift;
            $self->$reader->$remote_method(@_)
        }';

        $method_map{$local_method} = eval $method;
    }

    return \%method_map;
}

sub create {
    my ($self, $class, $name, %args) = @_;

    $args{name} = $name;
    $args{class} = $class;

    %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);
    $attribute->_create_args(\%args);

    my $meta = $class->meta;

    $meta->add_attribute($attribute);

    # install an accessor
    if ($attribute->_is_metadata eq 'rw' || $attribute->_is_metadata eq 'ro') {
        my $accessor = $attribute->generate_accessor;
        no strict 'refs';
        *{ $class . '::' . $name } = $accessor;
    }

    for my $method (qw/predicate clearer/) {
        my $predicate = "has_$method";
        if ($attribute->$predicate) {
            my $generator = "generate_$method";
            my $coderef = $attribute->$generator;
            no strict 'refs';
            *{ $class . '::' . $attribute->$method } = $coderef;
        }
    }

    if ($attribute->has_handles) {
        my $method_map = $attribute->generate_handles;
        for my $method_name (keys %$method_map) {
            no strict 'refs';
            *{ $class . '::' . $method_name } = $method_map->{$method_name};
        }
    }

    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 $args->{trigger}
            && ref($args->{trigger}) ne 'HASH';
    }

    return 1;
}

sub find_type_constraint {
    my $self = shift;
    my $type = $self->type_constraint;

    return unless $type;

    my $checker = Mouse::TypeRegistry->optimized_constraints->{$type};
    return $checker if $checker;

    return sub { blessed($_) && blessed($_) eq $type };
}

sub verify_type_constraint {
    my $self = shift;
    local $_ = shift;

    my $type = $self->type_constraint
        or return 1;
    my $constraint = $self->find_type_constraint;

    return 1 if $constraint->($_);

    my $name = $self->name;
    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");
}

sub _canonicalize_handles {
    my $self    = shift;
    my $handles = shift;

    if (ref($handles) eq 'HASH') {
        return %$handles;
    }
    elsif (ref($handles) eq 'ARRAY') {
        return map { $_ => $_ } @$handles;
    }
    else {
        confess "Unable to canonicalize the 'handles' option with $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::Meta::Attribute - attribute metaclass

=head1 METHODS

=head2 new %args -> Mouse::Meta::Attribute

Instantiates a new Mouse::Meta::Attribute. Does nothing else.

=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 is_required -> Bool

=head2 default -> Item

=head2 has_default -> Bool

=head2 is_lazy -> Bool

=head2 predicate -> MethodName | Undef

=head2 has_predicate -> Bool

=head2 clearer -> MethodName | Undef

=head2 has_clearer -> Bool

=head2 handles -> { LocalName => RemoteName }

=head2 has_handles -> Bool

=head2 is_weak_ref -> Bool

=head2 init_arg -> Str

=head2 type_constraint -> Str

=head2 has_type_constraint -> Bool

=head2 trigger => CODE | Undef

=head2 has_trigger -> Bool

=head2 builder => MethodName | Undef

=head2 has_builder -> Bool

=head2 is_lazy_build => Bool

=head2 should_auto_deref -> Bool

Informational methods.

=head2 generate_accessor -> CODE

Creates a new code reference for the attribute's accessor.

=head2 generate_predicate -> CODE

Creates a new code reference for the attribute's predicate.

=head2 generate_clearer -> CODE

Creates a new code reference for the attribute's clearer.

=head2 generate_handles -> { MethodName => CODE }

Creates a new code reference for each of the attribute's handles methods.

=head2 find_type_constraint -> CODE

Returns a code reference which can be used to check that a given value passes
this attribute's type constraint;

=head2 verify_type_constraint Item -> 1 | ERROR

Checks that the given value passes this attribute's type constraint. Returns 1
on success, otherwise C<confess>es.

=head2 canonicalize_args Name, %args -> %args

Canonicalizes some arguments to create. In particular, C<lazy_build> is
canonicalized into C<lazy>, C<builder>, etc.

=head2 validate_args Name, \%args -> 1 | ERROR

Checks that the arguments to create the attribute (ie those specified by
C<has>) 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<OwnerClass> used for attribute
C<AttributeName>.

=cut
Commit	Line	Data
c3398f5b	1	#!/usr/bin/env perl
306290e8	2	package Mouse::Meta::Attribute;
c3398f5b	3	use strict;
	4	use warnings;
	5
	6	use Carp 'confess';
3301fa54	7	use Scalar::Util 'blessed';
c3398f5b	8
	9	sub new {
	10	my $class = shift;
	11	my %args = @_;
	12
2e7e86c6	13	my $name = $args{name};
	14
	15	$args{init_arg} = $name
7ee01d77	16	unless exists $args{init_arg};
45959ffa	17
c3398f5b	18	$args{is} \|\|= '';
	19
	20	bless \%args, $class;
	21	}
	22
3cf68001	23	sub name { $_[0]->{name} }
	24	sub class { $_[0]->{class} }
	25	sub _is_metadata { $_[0]->{is} }
	26	sub is_required { $_[0]->{required} }
	27	sub default { $_[0]->{default} }
	28	sub is_lazy { $_[0]->{lazy} }
a5fe4015	29	sub is_lazy_build { $_[0]->{lazy_build} }
3cf68001	30	sub predicate { $_[0]->{predicate} }
	31	sub clearer { $_[0]->{clearer} }
	32	sub handles { $_[0]->{handles} }
	33	sub is_weak_ref { $_[0]->{weak_ref} }
	34	sub init_arg { $_[0]->{init_arg} }
	35	sub type_constraint { $_[0]->{type_constraint} }
	36	sub trigger { $_[0]->{trigger} }
	37	sub builder { $_[0]->{builder} }
	38	sub should_auto_deref { $_[0]->{auto_deref} }
c3398f5b	39
ccea8101	40	sub has_default { exists $_[0]->{default} }
	41	sub has_predicate { exists $_[0]->{predicate} }
	42	sub has_clearer { exists $_[0]->{clearer} }
	43	sub has_handles { exists $_[0]->{handles} }
ccea8101	44	sub has_type_constraint { exists $_[0]->{type_constraint} }
de9a434a	45	sub has_trigger { exists $_[0]->{trigger} }
de9a434a	46	sub has_builder { exists $_[0]->{builder} }
ccea8101	47
1bfebf5f	48	sub _create_args {
	49	$_[0]->{_create_args} = $_[1] if @_ > 1;
	50	$_[0]->{_create_args}
	51	}
	52
c3398f5b	53	sub generate_accessor {
	54	my $attribute = shift;
	55
2434d21b	56	my $name = $attribute->name;
f3c1ccc8	57	my $key = $name;
2434d21b	58	my $default = $attribute->default;
2434d21b	59	my $type = $attribute->type_constraint;
5aa30ced	60	my $constraint = $attribute->find_type_constraint;
9367e029	61	my $builder = $attribute->builder;
c3398f5b	62
4e757c98	63	my $trigger = $attribute->trigger;
	64	my $before = $trigger->{before};
	65	my $after = $trigger->{after};
	66	my $around = $trigger->{around};
	67
c3398f5b	68	my $accessor = 'sub {
	69	my $self = shift;';
	70
2434d21b	71	if ($attribute->_is_metadata eq 'rw') {
c3398f5b	72	$accessor .= 'if (@_) {
a707f587	73	local $_ = $_[0];';
a707f587	74
4e757c98	75	if ($before) {
	76	$accessor .= '$before->($self, $_, $attribute);';
	77	}
	78
cbdd0fa4	79	if ($around) {
	80	$accessor .= '$around->(sub {
	81	my $self = shift;
	82	$_ = $_[0];
	83	';
a707f587	84	}
a707f587	85
cbdd0fa4	86	if ($constraint) {
	87	$accessor .= 'do {
	88	my $display = defined($_) ? overload::StrVal($_) : "undef";
	89	Carp::confess("Attribute ($name) does not pass the type constraint because: Validation failed for \'$type\' failed with value $display") unless $constraint->();
	90	};'
	91	}
c3398f5b	92
cbdd0fa4	93	$accessor .= '$self->{$key} = $_;';
	94
	95	if ($attribute->is_weak_ref) {
	96	$accessor .= 'Scalar::Util::weaken($self->{$key}) if ref($self->{$key});';
	97	}
	98
	99	if ($around) {
	100	$accessor .= '}, $self, $_, $attribute);';
c3398f5b	101	}
c3398f5b	102
4e757c98	103	if ($after) {
4e757c98	104	$accessor .= '$after->($self, $_, $attribute);';
c3398f5b	105	}
	106
	107	$accessor .= '}';
	108	}
	109	else {
636c002e	110	$accessor .= 'confess "Cannot assign a value to a read-only accessor" if @_;';
c3398f5b	111	}
c3398f5b	112
2434d21b	113	if ($attribute->is_lazy) {
c3398f5b	114	$accessor .= '$self->{$key} = ';
9367e029	115
	116	$accessor .= $attribute->has_builder
	117	? '$self->$builder'
	118	: ref($default) eq 'CODE'
	119	? '$default->($self)'
	120	: '$default';
	121
c3398f5b	122	$accessor .= ' if !exists($self->{$key});';
	123	}
	124
3cf68001	125	if ($attribute->should_auto_deref) {
	126	if ($attribute->type_constraint eq 'ArrayRef') {
	127	$accessor .= 'if (wantarray) {
	128	return @{ $self->{$key} \|\| [] };
	129	}';
	130	}
	131	else {
	132	$accessor .= 'if (wantarray) {
	133	return %{ $self->{$key} \|\| {} };
	134	}';
	135	}
	136	}
	137
	138	$accessor .= 'return $self->{$key};
c3398f5b	139	}';
	140
	141	return eval $accessor;
	142	}
	143
	144	sub generate_predicate {
	145	my $attribute = shift;
f3c1ccc8	146	my $key = $attribute->name;
c3398f5b	147
	148	my $predicate = 'sub { exists($_[0]->{$key}) }';
	149
	150	return eval $predicate;
	151	}
	152
	153	sub generate_clearer {
	154	my $attribute = shift;
f3c1ccc8	155	my $key = $attribute->name;
c3398f5b	156
	157	my $predicate = 'sub { delete($_[0]->{$key}) }';
	158
	159	return eval $predicate;
	160	}
	161
	162	sub generate_handles {
	163	my $attribute = shift;
2434d21b	164	my $reader = $attribute->name;
c3cc3642	165	my %handles = $attribute->_canonicalize_handles($attribute->handles);
c3398f5b	166
	167	my %method_map;
	168
c3cc3642	169	for my $local_method (keys %handles) {
c3cc3642	170	my $remote_method = $handles{$local_method};
c3398f5b	171
	172	my $method = 'sub {
	173	my $self = shift;
	174	$self->$reader->$remote_method(@_)
	175	}';
	176
	177	$method_map{$local_method} = eval $method;
	178	}
	179
	180	return \%method_map;
	181	}
	182
	183	sub create {
	184	my ($self, $class, $name, %args) = @_;
	185
1bfebf5f	186	$args{name} = $name;
	187	$args{class} = $class;
	188
93d190e0	189	%args = $self->canonicalize_args($name, %args);
1bbaa8ed	190	$self->validate_args($name, \%args);
45ea8620	191
c021207d	192	$args{type_constraint} = delete $args{isa}
c021207d	193	if exists $args{isa};
186657a9	194
1bfebf5f	195	my $attribute = $self->new(%args);
	196	$attribute->_create_args(\%args);
	197
c3398f5b	198	my $meta = $class->meta;
c3398f5b	199
b2500191	200	$meta->add_attribute($attribute);
b2500191	201
c3398f5b	202	# install an accessor
2434d21b	203	if ($attribute->_is_metadata eq 'rw' \|\| $attribute->_is_metadata eq 'ro') {
c3398f5b	204	my $accessor = $attribute->generate_accessor;
	205	no strict 'refs';
	206	*{ $class . '::' . $name } = $accessor;
	207	}
	208
c3398f5b	209	for my $method (qw/predicate clearer/) {
2434d21b	210	my $predicate = "has_$method";
2434d21b	211	if ($attribute->$predicate) {
c3398f5b	212	my $generator = "generate_$method";
	213	my $coderef = $attribute->$generator;
	214	no strict 'refs';
2434d21b	215	*{ $class . '::' . $attribute->$method } = $coderef;
c3398f5b	216	}
	217	}
	218
2434d21b	219	if ($attribute->has_handles) {
c3398f5b	220	my $method_map = $attribute->generate_handles;
	221	for my $method_name (keys %$method_map) {
	222	no strict 'refs';
	223	*{ $class . '::' . $method_name } = $method_map->{$method_name};
	224	}
	225	}
	226
	227	return $attribute;
	228	}
	229
93d190e0	230	sub canonicalize_args {
	231	my $self = shift;
	232	my $name = shift;
	233	my %args = @_;
	234
	235	if ($args{lazy_build}) {
	236	$args{lazy} = 1;
	237	$args{required} = 1;
	238	$args{builder} = "_build_${name}"
	239	if !exists($args{builder});
	240	if ($name =~ /^_/) {
	241	$args{clearer} = "_clear${name}" if !exists($args{clearer});
	242	$args{predicate} = "_has${name}" if !exists($args{predicate});
	243	}
	244	else {
	245	$args{clearer} = "clear_${name}" if !exists($args{clearer});
	246	$args{predicate} = "has_${name}" if !exists($args{predicate});
	247	}
	248	}
	249
	250	return %args;
	251	}
	252
8fd9e611	253	sub validate_args {
	254	my $self = shift;
	255	my $name = shift;
1bbaa8ed	256	my $args = shift;
8fd9e611	257
93d190e0	258	confess "You can not use lazy_build and default for the same attribute ($name)"
1bbaa8ed	259	if $args->{lazy_build} && exists $args->{default};
93d190e0	260
8fd9e611	261	confess "You cannot have lazy attribute ($name) without specifying a default value for it"
1bbaa8ed	262	if $args->{lazy}
	263	&& !exists($args->{default})
	264	&& !exists($args->{builder});
8fd9e611	265
8fd9e611	266	confess "References are not allowed as default values, you must wrap the default of '$name' in a CODE reference (ex: sub { [] } and not [])"
1bbaa8ed	267	if ref($args->{default})
1bbaa8ed	268	&& ref($args->{default}) ne 'CODE';
8fd9e611	269
8fd9e611	270	confess "You cannot auto-dereference without specifying a type constraint on attribute $name"
1bbaa8ed	271	if $args->{auto_deref} && !exists($args->{isa});
8fd9e611	272
8fd9e611	273	confess "You cannot auto-dereference anything other than a ArrayRef or HashRef on attribute $name"
1bbaa8ed	274	if $args->{auto_deref}
	275	&& $args->{isa} ne 'ArrayRef'
	276	&& $args->{isa} ne 'HashRef';
8fd9e611	277
506db557	278	if ($args->{trigger}) {
	279	if (ref($args->{trigger}) eq 'CODE') {
	280	$args->{trigger} = {
	281	after => $args->{trigger},
	282	};
	283	}
	284
	285	confess "Trigger must be a CODE or HASH ref on attribute ($name)"
	286	if $args->{trigger}
	287	&& ref($args->{trigger}) ne 'HASH';
	288	}
6c5498d0	289
8fd9e611	290	return 1;
	291	}
	292
5aa30ced	293	sub find_type_constraint {
	294	my $self = shift;
	295	my $type = $self->type_constraint;
	296
	297	return unless $type;
	298
	299	my $checker = Mouse::TypeRegistry->optimized_constraints->{$type};
	300	return $checker if $checker;
	301
3301fa54	302	return sub { blessed($_) && blessed($_) eq $type };
5aa30ced	303	}
	304
	305	sub verify_type_constraint {
	306	my $self = shift;
	307	local $_ = shift;
	308
	309	my $type = $self->type_constraint
	310	or return 1;
af745d5a	311	my $constraint = $self->find_type_constraint;
5aa30ced	312
	313	return 1 if $constraint->($_);
	314
	315	my $name = $self->name;
f3e05dfd	316	my $display = defined($_) ? overload::StrVal($_) : 'undef';
f3e05dfd	317	Carp::confess("Attribute ($name) does not pass the type constraint because: Validation failed for \'$type\' failed with value $display");
5aa30ced	318	}
5aa30ced	319
af745d5a	320	sub _canonicalize_handles {
	321	my $self = shift;
	322	my $handles = shift;
	323
	324	if (ref($handles) eq 'HASH') {
	325	return %$handles;
	326	}
	327	elsif (ref($handles) eq 'ARRAY') {
	328	return map { $_ => $_ } @$handles;
	329	}
	330	else {
	331	confess "Unable to canonicalize the 'handles' option with $handles";
	332	}
	333	}
	334
1bfebf5f	335	sub clone_parent {
	336	my $self = shift;
	337	my $class = shift;
	338	my $name = shift;
	339	my %args = ($self->get_parent_args($class, $name), @_);
	340
	341	$self->create($class, $name, %args);
	342	}
	343
	344	sub get_parent_args {
	345	my $self = shift;
	346	my $class = shift;
	347	my $name = shift;
	348
	349	for my $super ($class->meta->linearized_isa) {
bb733405	350	my $super_attr = $super->can("meta") && $super->meta->get_attribute($name)
1bfebf5f	351	or next;
	352	return %{ $super_attr->_create_args };
	353	}
	354
	355	confess "Could not find an attribute by the name of '$name' to inherit from";
	356	}
	357
c3398f5b	358	1;
	359
	360	__END__
	361
	362	=head1 NAME
	363
306290e8	364	Mouse::Meta::Attribute - attribute metaclass
c3398f5b	365
	366	=head1 METHODS
	367
306290e8	368	=head2 new %args -> Mouse::Meta::Attribute
c3398f5b	369
306290e8	370	Instantiates a new Mouse::Meta::Attribute. Does nothing else.
c3398f5b	371
306290e8	372	=head2 create OwnerClass, AttributeName, %args -> Mouse::Meta::Attribute
c3398f5b	373
	374	Creates a new attribute in OwnerClass. Accessors and helper methods are
	375	installed. Some error checking is done.
	376
	377	=head2 name -> AttributeName
	378
	379	=head2 class -> OwnerClass
	380
ab27a55e	381	=head2 is_required -> Bool
c3398f5b	382
ab27a55e	383	=head2 default -> Item
c3398f5b	384
ab27a55e	385	=head2 has_default -> Bool
	386
	387	=head2 is_lazy -> Bool
	388
	389	=head2 predicate -> MethodName \| Undef
	390
	391	=head2 has_predicate -> Bool
	392
	393	=head2 clearer -> MethodName \| Undef
	394
	395	=head2 has_clearer -> Bool
c3398f5b	396
	397	=head2 handles -> { LocalName => RemoteName }
	398
ab27a55e	399	=head2 has_handles -> Bool
ab27a55e	400
3645b316	401	=head2 is_weak_ref -> Bool
c3398f5b	402
	403	=head2 init_arg -> Str
	404
ab27a55e	405	=head2 type_constraint -> Str
	406
	407	=head2 has_type_constraint -> Bool
	408
	409	=head2 trigger => CODE \| Undef
	410
	411	=head2 has_trigger -> Bool
	412
	413	=head2 builder => MethodName \| Undef
	414
	415	=head2 has_builder -> Bool
	416
93f08899	417	=head2 is_lazy_build => Bool
93f08899	418
0fff36e6	419	=head2 should_auto_deref -> Bool
0fff36e6	420
c3398f5b	421	Informational methods.
	422
	423	=head2 generate_accessor -> CODE
	424
	425	Creates a new code reference for the attribute's accessor.
	426
	427	=head2 generate_predicate -> CODE
	428
	429	Creates a new code reference for the attribute's predicate.
	430
	431	=head2 generate_clearer -> CODE
	432
	433	Creates a new code reference for the attribute's clearer.
	434
	435	=head2 generate_handles -> { MethodName => CODE }
	436
	437	Creates a new code reference for each of the attribute's handles methods.
	438
fb706f5c	439	=head2 find_type_constraint -> CODE
	440
	441	Returns a code reference which can be used to check that a given value passes
	442	this attribute's type constraint;
	443
	444	=head2 verify_type_constraint Item -> 1 \| ERROR
	445
	446	Checks that the given value passes this attribute's type constraint. Returns 1
	447	on success, otherwise C<confess>es.
	448
93d190e0	449	=head2 canonicalize_args Name, %args -> %args
	450
	451	Canonicalizes some arguments to create. In particular, C<lazy_build> is
	452	canonicalized into C<lazy>, C<builder>, etc.
	453
1bbaa8ed	454	=head2 validate_args Name, \%args -> 1 \| ERROR
93d190e0	455
	456	Checks that the arguments to create the attribute (ie those specified by
	457	C<has>) are valid.
	458
f7b11a21	459	=head2 clone_parent OwnerClass, AttributeName, %args -> Mouse::Meta::Attribute
	460
	461	Creates a new attribute in OwnerClass, inheriting options from parent classes.
	462	Accessors and helper methods are installed. Some error checking is done.
	463
	464	=head2 get_parent_args OwnerClass, AttributeName -> Hash
	465
	466	Returns the options that the parent class of C<OwnerClass> used for attribute
	467	C<AttributeName>.
	468
c3398f5b	469	=cut
c3398f5b	470