use Mouse::Meta::TypeConstraint;
use Mouse::Meta::Method::Accessor;
-#my %valid_attrs = map{ $_ => undef } qw(
-# name
-# reader writer accessor clearer predicate
-# builder init_arg default initializer definition_context
-#
-# is
-# isa does
-# required
-# lazy
-# lazy_build
-# coerce
-# weak_ref
-# auto_deref
-# type_constraint
-# trigger
-# handles
-# documentation
-# traits
-#);
+sub BUILDARGS{
+ my $class = shift;
+ my $name = shift;
+ my %args = (@_ == 1) ? %{$_[0]} : @_;
+
+ $args{name} = $name;
+
+ # XXX: for backward compatibility (with method modifiers)
+ if($class->can('canonicalize_args') != \&canonicalize_args){
+ %args = $class->canonicalize_args($name, %args);
+ }
+
+ return \%args;
+}
sub new {
- my ($class, $name, %options) = @_;
+ my $class = shift;
+ my $args = $class->BUILDARGS(@_);
+
+ my $name = $args->{name};
# taken from Class::MOP::Attribute::new
defined($name)
or $class->throw_error('You must provide a name for the attribute');
- $options{name} = $name;
- if(!exists $options{init_arg}){
- $options{init_arg} = $name;
+ if(!exists $args->{init_arg}){
+ $args->{init_arg} = $name;
}
# 'required' requires eigher 'init_arg', 'builder', or 'default'
- my $can_be_required = defined( $options{init_arg} );
+ my $can_be_required = defined( $args->{init_arg} );
- if(exists $options{builder}){
+ if(exists $args->{builder}){
$class->throw_error('builder must be a defined scalar value which is a method name')
- if ref $options{builder} || !(defined $options{builder});
+ if ref $args->{builder} || !(defined $args->{builder});
$can_be_required++;
}
- elsif(exists $options{default}){
- if(ref $options{default} && ref($options{default}) ne 'CODE'){
+ elsif(exists $args->{default}){
+ if(ref $args->{default} && ref($args->{default}) ne 'CODE'){
$class->throw_error("References are not allowed as default values, you must "
. "wrap the default of '$name' in a CODE reference (ex: sub { [] } and not [])");
}
$can_be_required++;
}
- if( $options{required} && !$can_be_required ) {
+ if( $args->{required} && !$can_be_required ) {
$class->throw_error("You cannot have a required attribute ($name) without a default, builder, or an init_arg");
}
- # taken from Mouse::Meta::Attribute->new and _process_options
+ # taken from Mouse::Meta::Attribute->new and _process_args->
- if(exists $options{is}){
- my $is = $options{is};
+ if(exists $args->{is}){
+ my $is = $args->{is};
if($is eq 'ro'){
- $options{reader} ||= $name;
+ $args->{reader} ||= $name;
}
elsif($is eq 'rw'){
- if(exists $options{writer}){
- $options{reader} ||= $name;
+ if(exists $args->{writer}){
+ $args->{reader} ||= $name;
}
else{
- $options{accessor} ||= $name;
+ $args->{accessor} ||= $name;
}
}
elsif($is eq 'bare'){
}
my $tc;
- if(exists $options{isa}){
- $options{type_constraint} = Mouse::Util::TypeConstraints::find_or_create_isa_type_constraint($options{isa});
+ if(exists $args->{isa}){
+ $args->{type_constraint} = Mouse::Util::TypeConstraints::find_or_create_isa_type_constraint($args->{isa});
}
- elsif(exists $options{does}){
- $options{type_constraint} = Mouse::Util::TypeConstraints::find_or_create_does_type_constraint($options{does});
+ elsif(exists $args->{does}){
+ $args->{type_constraint} = Mouse::Util::TypeConstraints::find_or_create_does_type_constraint($args->{does});
}
- $tc = $options{type_constraint};
+ $tc = $args->{type_constraint};
- if($options{coerce}){
+ if($args->{coerce}){
defined($tc)
|| $class->throw_error("You cannot have coercion without specifying a type constraint on attribute ($name)");
- $options{weak_ref}
+ $args->{weak_ref}
&& $class->throw_error("You cannot have a weak reference to a coerced value on attribute ($name)");
}
- if ($options{lazy_build}) {
- exists($options{default})
+ if ($args->{lazy_build}) {
+ exists($args->{default})
&& $class->throw_error("You can not use lazy_build and default for the same attribute ($name)");
- $options{lazy} = 1;
- $options{builder} ||= "_build_${name}";
+ $args->{lazy} = 1;
+ $args->{builder} ||= "_build_${name}";
if ($name =~ /^_/) {
- $options{clearer} ||= "_clear${name}";
- $options{predicate} ||= "_has${name}";
+ $args->{clearer} ||= "_clear${name}";
+ $args->{predicate} ||= "_has${name}";
}
else {
- $options{clearer} ||= "clear_${name}";
- $options{predicate} ||= "has_${name}";
+ $args->{clearer} ||= "clear_${name}";
+ $args->{predicate} ||= "has_${name}";
}
}
- if ($options{auto_deref}) {
+ if ($args->{auto_deref}) {
defined($tc)
|| $class->throw_error("You cannot auto-dereference without specifying a type constraint on attribute ($name)");
|| $class->throw_error("You cannot auto-dereference anything other than a ArrayRef or HashRef on attribute ($name)");
}
- if (exists $options{trigger}) {
- ('CODE' eq ref $options{trigger})
+ if (exists $args->{trigger}) {
+ ('CODE' eq ref $args->{trigger})
|| $class->throw_error("Trigger must be a CODE ref on attribute ($name)");
}
- if ($options{lazy}) {
- (exists $options{default} || defined $options{builder})
+ if ($args->{lazy}) {
+ (exists $args->{default} || defined $args->{builder})
|| $class->throw_error("You cannot have lazy attribute ($name) without specifying a default value for it");
}
- if(my $metaclass = delete $options{metaclass}){
- $class = Mouse::Util::resolve_metaclass_alias( Attribute => $metaclass );
- }
-
- if(my $traits_ref = delete $options{traits}){
- my @traits;
- for (my $i = 9; $i < @{$traits_ref}; $i++) {
- my $trait = Mouse::Util::resolve_metaclass_alias(Attribute => $traits_ref->[$i], trait => 1);
-
- next if $class->does($trait);
-
- push @traits, $trait;
-
- # are there options?
- push @traits, $traits_ref->[++$i]
- if ref($traits_ref->[$i+1]);
- }
+ my $instance = bless $args, $class;
- if (@traits) {
- $class = Mouse::Meta::Class->create_anon_class(
- superclasses => [ $class ],
- roles => [ @traits ],
- cache => 1,
- )->name;
- }
+ # extra attributes
+ if($class ne __PACKAGE__){
+ $class->meta->_initialize_instance($instance, $args);
}
# XXX: there is no fast way to check attribute validity
-# my @bad = grep{ !exists $valid_attrs{$_} } keys %options;
+# my @bad = ...;
# if(@bad){
# @bad = sort @bad;
# Carp::cluck("Found unknown argument(s) passed to '$name' attribute constructor in '$class': @bad");
# }
- return bless \%options, $class;
+ 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} }
sub should_auto_deref { $_[0]->{auto_deref} }
sub should_coerce { $_[0]->{coerce} }
+sub get_read_method { $_[0]->{reader} || $_[0]->{accessor} }
+sub get_write_method { $_[0]->{writer} || $_[0]->{accessor} }
+
# predicates
sub has_accessor { exists $_[0]->{accessor} }
sub has_trigger { exists $_[0]->{trigger} }
sub has_builder { exists $_[0]->{builder} }
+sub has_read_method { exists $_[0]->{reader} || exists $_[0]->{accessor} }
+sub has_write_method { exists $_[0]->{writer} || exists $_[0]->{accessor} }
+
sub _create_args {
$_[0]->{_create_args} = $_[1] if @_ > 1;
$_[0]->{_create_args}
sub accessor_metaclass { 'Mouse::Meta::Method::Accessor' }
-sub create {
- my ($self, $class, $name, %args) = @_;
+sub interpolate_class_and_new{
+ my($class, $name, $args) = @_;
- my $attribute = $self->new($name, %args);
+ if(my $metaclass = delete $args->{metaclass}){
+ $class = Mouse::Util::resolve_metaclass_alias( Attribute => $metaclass );
+ }
- $attribute->_create_args(\%args);
- $class->add_attribute($attribute);
- weaken($attribute->{associated_class} = $class);
+ if(my $traits_ref = delete $args->{traits}){
+ my @traits;
+ for (my $i = 0; $i < @{$traits_ref}; $i++) {
+ my $trait = Mouse::Util::resolve_metaclass_alias(Attribute => $traits_ref->[$i], trait => 1);
- my $associated_methods = 0;
+ next if $class->does($trait);
- my $generator_class = $self->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}, $class);
- $associated_methods++;
+ push @traits, $trait;
+
+ # are there options?
+ push @traits, $traits_ref->[++$i]
+ if ref($traits_ref->[$i+1]);
}
- }
- if($associated_methods == 0 && ($attribute->_is_metadata || '') ne 'bare'){
- Carp::cluck(qq{Attribute ($name) of class }.$class->name.qq{ has no associated methods (did you mean to provide an "is" argument?)});
+ if (@traits) {
+ $class = Mouse::Meta::Class->create_anon_class(
+ superclasses => [ $class ],
+ roles => \@traits,
+ cache => 1,
+ )->name;
+ $args->{traits} = \@traits;
+ }
}
- return $attribute;
+ return $class->new($name, $args);
+}
+
+sub canonicalize_args{
+ my ($self, $name, %args) = @_;
+
+ Carp::cluck("$self->canonicalize_args has been deprecated."
+ . "Use \$self->BUILDARGS instead.");
+
+ return %args;
+}
+
+sub create {
+ my ($self, $class, $name, %args) = @_;
+
+ Carp::cluck("$self->create has been deprecated."
+ . "Use \$meta->add_attribute and \$attr->install_accessors instead.");
+
+ # noop
+ return $self;
}
sub verify_against_type_constraint {
}
}
+sub clone_and_inherit_options{
+ my $self = shift;
+ my $name = shift;
+
+ return ref($self)->new($name, %{$self}, @_ == 1 ? %{$_[0]} : @_);
+}
+
sub clone_parent {
my $self = shift;
my $class = shift;
my $name = shift;
my %args = ($self->get_parent_args($class, $name), @_);
+ Carp::cluck("$self->clone_parent has been deprecated."
+ . "Use \$meta->add_attribute and \$attr->install_accessors instead.");
+
+
$self->create($class, $name, %args);
}
$self->throw_error("Could not find an attribute by the name of '$name' to inherit from");
}
+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);
+ $attribute->{associated_methods}++;
+ }
+ }
+
+ if($attribute->can('create') != \&create){
+ $attribute->create($metaclass, $attribute->name, %{$attribute});
+ }
+
+ return;
+}
+
sub throw_error{
my $self = shift;
$self->linearized_isa;
}
-sub add_attribute {
+sub _process_attribute{
my $self = shift;
+ my $name = shift;
- if (@_ == 1 && blessed($_[0])) {
- my $attr = shift @_;
- $self->{'attributes'}{$attr->name} = $attr;
- }
- else {
- my $names = shift @_;
- $names = [$names] if !ref($names);
- my $metaclass = 'Mouse::Meta::Attribute';
- my %options = (@_ == 1 ? %{$_[0]} : @_);
-
- if ( my $metaclass_name = delete $options{metaclass} ) {
- my $new_class = Mouse::Util::resolve_metaclass_alias(
- 'Attribute',
- $metaclass_name
- );
- if ( $metaclass ne $new_class ) {
- $metaclass = $new_class;
- }
- }
+ my $args = (@_ == 1) ? $_[0] : { @_ };
- for my $name (@$names) {
- if ($name =~ s/^\+//) {
- $metaclass->clone_parent($self, $name, %options);
- }
- else {
- $metaclass->create($self, $name, %options);
- }
+ defined($name)
+ or $self->throw_error('You must provide a name for the attribute');
+
+ if ($name =~ s/^\+//) {
+ my $inherited_attr;
+
+ foreach my $class($self->linearized_isa){
+ my $meta = Mouse::Meta::Module::get_metaclass_by_name($class) or next;
+ $inherited_attr = $meta->get_attribute($name) and last;
}
+
+ defined($inherited_attr)
+ or $self->throw_error("Could not find an attribute by the name of '$name' to inherit from in ".$self->name);
+
+ return $inherited_attr->clone_and_inherit_options($name, $args);
+ }
+ else{
+ return Mouse::Meta::Attribute->interpolate_class_and_new($name, $args);
+ }
+}
+
+sub add_attribute {
+ my $self = shift;
+
+ my $attr = blessed($_[0]) ? $_[0] : $self->_process_attribute(@_);
+
+ $attr->isa('Mouse::Meta::Attribute')
+ || $self->throw_error("Your attribute must be an instance of Mouse::Meta::Attribute (or a subclass)");
+
+ weaken( $attr->{associated_class} = $self );
+
+ $self->{attributes}{$attr->name} = $attr;
+ $attr->install_accessors();
+
+ if(!$attr->{associated_methods} && ($attr->{is} || '') ne 'bare'){
+ Carp::cluck(qq{Attribute (}.$attr->name.qq{) of class }.$self->name.qq{ has no associated methods (did you mean to provide an "is" argument?)});
}
+ return $attr;
}
sub compute_all_applicable_attributes { shift->get_all_attributes(@_) }
my $instance = bless {}, $self->name;
+ $self->_initialize_instance($instance, \%args);
+ return $instance;
+}
+
+sub _initialize_instance{
+ my($self, $instance, $args) = @_;
+
my @triggers_queue;
foreach my $attribute ($self->get_all_attributes) {
my $from = $attribute->init_arg;
my $key = $attribute->name;
- if (defined($from) && exists($args{$from})) {
- $args{$from} = $attribute->coerce_constraint($args{$from})
+ if (defined($from) && exists($args->{$from})) {
+ $args->{$from} = $attribute->coerce_constraint($args->{$from})
if $attribute->should_coerce;
- $attribute->verify_against_type_constraint($args{$from});
- $instance->{$key} = $args{$from};
+ $attribute->verify_against_type_constraint($args->{$from});
+
+ $instance->{$key} = $args->{$from};
weaken($instance->{$key})
if ref($instance->{$key}) && $attribute->is_weak_ref;
if ($attribute->has_trigger) {
- push @triggers_queue, [ $attribute->trigger, $args{$from} ];
+ push @triggers_queue, [ $attribute->trigger, $args->{$from} ];
}
}
else {
projects / gitmo/Mouse.git / commitdiff