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