use warnings;
use Carp ();
-use Scalar::Util qw(weaken);
-use Mouse::Util;
+use Mouse::Util qw(:meta);
use Mouse::Meta::TypeConstraint;
use Mouse::Meta::Method::Accessor;
$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};
return $instance
}
-sub does {
- my ($self, $role_name) = @_;
- my $meta = Mouse::Meta::Class->initialize(ref($self) || $self);
-
- (defined $role_name)
- || $meta->throw_error("You must supply a role name to does()");
-
- return $meta->does_role($role_name);
-};
-
# readers
sub name { $_[0]->{name} }
$_[0]->{_create_args}
}
-sub accessor_metaclass { 'Mouse::Meta::Method::Accessor' }
-
sub interpolate_class{
my($class, $name, $args) = @_;
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 {
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 {
. "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 {
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});
}
=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<reader>, C<writer>, or
+C<accessor> names. If the attribute is read-only ('ro') then it will
+have a C<reader> method with the same attribute as the name.
-=head2 is_required -> Bool
+If it is read-write ('rw') then it will have an C<accessor> method
+with the same name. If you provide an explicit C<writer> for a
+read-write attribute, then you will have a C<reader> with the same
+name as the attribute, and a C<writer> 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<Moose::Meta::TypeConstraint> object.
-=head2 has_predicate -> Bool
+If you I<also> provide a C<does> option, then your C<isa> option must
+be a class name, and that class must do the role specified with
+C<does>.
-=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<This option is not yet supported.>
-=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<isa>). 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<weak_ref> 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<default> or C<builder>,
+which will satisfy its required-ness.
-=head2 builder => MethodName | Undef
+A required attribute must have a C<default>, C<builder> or a
+non-C<undef> C<init_arg>
-=head2 has_builder -> Bool
+=item * C<< lazy => Bool >>
-=head2 is_lazy_build => Bool
+A lazy attribute must have a C<default> or C<builder>. 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 C<confess>es.
+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 >>
+
+Setting this to true makes the attribute lazy and provides a number of
+default methods.
-=head2 canonicalize_args Name, %args -> %args
+ has 'size' => (
+ is => 'ro',
+ lazy_build => 1,
+ );
-Canonicalizes some arguments to create. In particular, C<lazy_build> is
-canonicalized into C<lazy>, C<builder>, etc.
+is equivalent to this:
-=head2 validate_args Name, \%args -> 1 | ERROR
+ has 'size' => (
+ is => 'ro',
+ lazy => 1,
+ builder => '_build_size',
+ clearer => 'clear_size',
+ predicate => 'has_size',
+ );
-Checks that the arguments to create the attribute (ie those specified by
-C<has>) are valid.
+=back
+
+=head2 C<< verify_against_type_constraint(Item) -> TRUE | ERROR >>
+
+Checks that the given value passes this attribute's type constraint. Returns C<true>
+on success, otherwise C<confess>es.
-=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<OwnerClass> used for attribute
-C<AttributeName>.
+L<Moose::Meta::Attribute>
=cut
projects / gitmo/Mouse.git / blobdiff