use List::MoreUtils qw( any all uniq );
use Scalar::Util 'weaken', 'blessed';
-our $VERSION = '0.75';
+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;
}
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 $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) = @_;
## -------------------------------------------------
-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 {