use List::MoreUtils qw( any all uniq );
use Scalar::Util 'weaken', 'blessed';
-our $VERSION = '0.73';
+our $VERSION = '0.77';
$VERSION = eval $VERSION;
our $AUTHORITY = 'cpan:STEVAN';
use Moose::Meta::Method::Overridden;
use Moose::Meta::Method::Augmented;
use Moose::Error::Default;
+use Moose::Meta::Class::Immutable::Trait;
+use Moose::Meta::Method::Constructor;
+use Moose::Meta::Method::Destructor;
use base 'Class::MOP::Class';
default => sub { [] }
));
+
+__PACKAGE__->meta->add_attribute(
+ Class::MOP::Attribute->new('immutable_trait' => (
+ accessor => "immutable_trait",
+ default => 'Moose::Meta::Class::Immutable::Trait',
+ ))
+);
+
__PACKAGE__->meta->add_attribute('constructor_class' => (
accessor => 'constructor_class',
default => 'Moose::Meta::Method::Constructor',
default => 'Moose::Error::Default',
));
-
sub initialize {
my $class = shift;
my $pkg = shift;
- return Class::MOP::get_metaclass_by_name($pkg)
+ return Class::MOP::get_metaclass_by_name($pkg)
|| $class->SUPER::initialize($pkg,
'attribute_metaclass' => 'Moose::Meta::Attribute',
'method_metaclass' => 'Moose::Meta::Method',
'instance_metaclass' => 'Moose::Meta::Instance',
@_
- );
+ );
+}
+
+sub _immutable_options {
+ my ( $self, @args ) = @_;
+
+ $self->SUPER::_immutable_options(
+ inline_destructor => 1,
+
+ # Moose always does this when an attribute is created
+ inline_accessors => 0,
+
+ @args,
+ );
}
sub create {
my ($self, $package_name, %options) = @_;
-
+
(ref $options{roles} eq 'ARRAY')
|| $self->throw_error("You must pass an ARRAY ref of roles", data => $options{roles})
if exists $options{roles};
if ($roles) {
Moose::Util::apply_all_roles( $class, @$roles );
}
-
+
return $class;
}
-sub check_metaclass_compatibility {
+sub _check_metaclass_compatibility {
my $self = shift;
if ( my @supers = $self->superclasses ) {
$self->_fix_metaclass_incompatibility(@supers);
}
- $self->SUPER::check_metaclass_compatibility(@_);
+ $self->SUPER::_check_metaclass_compatibility(@_);
}
my %ANON_CLASSES;
my ($self, %options) = @_;
my $cache_ok = delete $options{cache};
-
+
# something like Super::Class|Super::Class::2=Role|Role::1
my $cache_key = join '=' => (
join('|', @{$options{superclasses} || []}),
join('|', sort @{$options{roles} || []}),
);
-
+
if ($cache_ok && defined $ANON_CLASSES{$cache_key}) {
return $ANON_CLASSES{$cache_key};
}
-
+
my $new_class = $self->SUPER::create_anon_class(%options);
$ANON_CLASSES{$cache_key} = $new_class
my $params = @_ == 1 ? $_[0] : {@_};
my $self = $class->SUPER::new_object($params);
- foreach my $attr ( $class->compute_all_applicable_attributes() ) {
+ foreach my $attr ( $class->get_all_attributes() ) {
next unless $attr->can('has_trigger') && $attr->has_trigger;
? $attr->get_read_method_ref->($self)
: $params->{$init_arg}
),
- $attr
);
}
return $self;
}
-sub construct_instance {
+sub _construct_instance {
my $class = shift;
my $params = @_ == 1 ? $_[0] : {@_};
my $meta_instance = $class->get_meta_instance;
# but this is foreign inheritance, so we might
# have to kludge it in the end.
my $instance = $params->{'__INSTANCE__'} || $meta_instance->create_instance();
- foreach my $attr ($class->compute_all_applicable_attributes()) {
+ foreach my $attr ($class->get_all_attributes()) {
$attr->initialize_instance_slot($meta_instance, $instance, $params);
}
return $instance;
}
+sub superclasses {
+ my $self = shift;
+ my @supers = @_;
+ foreach my $super (@supers) {
+ my $meta = Class::MOP::load_class($super);
+ Moose->throw_error("You cannot inherit from a Moose Role ($super)")
+ if $meta && $meta->isa('Moose::Meta::Role')
+ }
+ return $self->SUPER::superclasses(@supers);
+}
+
### ---------------------------------------------
sub add_attribute {
my $self = shift;
$self->SUPER::add_attribute(
(blessed $_[0] && $_[0]->isa('Class::MOP::Attribute')
- ? $_[0]
- : $self->_process_attribute(@_))
+ ? $_[0]
+ : $self->_process_attribute(@_))
);
}
# I don't want to have to type this >1 time
my @MetaClassTypes =
- qw( attribute_metaclass method_metaclass instance_metaclass
- constructor_class destructor_class error_class );
+ qw( attribute_metaclass
+ method_metaclass
+ wrapped_method_metaclass
+ instance_metaclass
+ constructor_class
+ destructor_class
+ error_class );
sub _reconcile_with_superclass_meta {
my ($self, $super) = @_;
return $self;
}
-# NOTE:
-# this was crap anyway, see
-# Moose::Util::apply_all_roles
-# instead
-sub _apply_all_roles {
- Carp::croak 'DEPRECATED: use Moose::Util::apply_all_roles($meta, @roles) instead'
-}
-
sub _process_attribute {
my ( $self, $name, @args ) = @_;
## -------------------------------------------------
-use Moose::Meta::Method::Constructor;
-use Moose::Meta::Method::Destructor;
-
-
-sub _default_immutable_transformer_options {
- my $self = shift;
-
- my %options = $self->SUPER::_default_immutable_transformer_options;
-
- # We need to copy the references as we do not want to alter the
- # superclass's references.
- $options{cannot_call} = [ @{ $options{cannot_call} }, 'add_role' ];
- $options{memoize} = {
- %{ $options{memoize} },
- calculate_all_roles => 'ARRAY',
- };
-
- %options = (
- %options,
- constructor_class => $self->constructor_class,
- destructor_class => $self->destructor_class,
- inline_destructor => 1,
-
- # Moose always does this when an attribute is created
- inline_accessors => 0,
- );
-
- return %options
-}
-
our $error_level;
sub throw_error {
projects / gitmo/Moose.git / blobdiff