Add Moose package

CPAN/Moose/Meta/Role/Composite.pm

@@ -0,0 +1,320 @@
+package Moose::Meta::Role::Composite;
+our $VERSION = '2.2207';
+
+use strict;
+use warnings;
+use metaclass;
+
+use Scalar::Util 'blessed';
+use Moose::Util 'throw_exception';
+use parent 'Moose::Meta::Role';
+
+# NOTE:
+# we need to override the ->name
+# method from Class::MOP::Package
+# since we don't have an actual
+# package for this.
+# - SL
+__PACKAGE__->meta->add_attribute('name' => (
+    reader => 'name',
+    Class::MOP::_definition_context(),
+));
+
+# NOTE:
+# Again, since we don't have a real
+# package to store our methods in,
+# we use a HASH ref instead.
+# - SL
+__PACKAGE__->meta->add_attribute('_methods' => (
+    reader  => '_method_map',
+    default => sub { {} },
+    Class::MOP::_definition_context(),
+));
+
+__PACKAGE__->meta->add_attribute('_overloads' => (
+    reader  => '_overload_map',
+    default => sub { {} },
+    Class::MOP::_definition_context(),
+));
+
+__PACKAGE__->meta->add_attribute('_overload_fallback' => (
+    accessor  => '_overload_fallback',
+    Class::MOP::_definition_context(),
+));
+
+__PACKAGE__->meta->add_attribute(
+    'application_role_summation_class',
+    reader  => 'application_role_summation_class',
+    default => 'Moose::Meta::Role::Application::RoleSummation',
+    Class::MOP::_definition_context(),
+);
+
+sub new {
+    my ($class, %params) = @_;
+
+    # the roles param is required ...
+    foreach ( @{$params{roles}} ) {
+        unless ( $_->isa('Moose::Meta::Role') ) {
+            throw_exception( RolesListMustBeInstancesOfMooseMetaRole => params => \%params,
+                                                                        role   => $_,
+                                                                        class  => $class
+                           );
+        }
+    }
+
+    my @composition_roles = map {
+        $_->composition_class_roles
+    } @{ $params{roles} };
+
+    if (@composition_roles) {
+        my $meta = Moose::Meta::Class->create_anon_class(
+            superclasses => [ $class ],
+            roles        => [ @composition_roles ],
+            cache        => 1,
+        );
+        $class = $meta->name;
+    }
+
+    # and the name is created from the
+    # roles if one has not been provided
+    $params{name} ||= (join "|" => map { $_->name } @{$params{roles}});
+    $class->_new(\%params);
+}
+
+# There's no such thing as an anonymous composite role since composites are an
+# artifact of Moose's internals. However, a composite role that contains an
+# anon role may _look_ like an anon role since $self->name =~ /$anon_key/ can
+# return true if the first role in the composite is anonymous itself.
+sub is_anon { 0 }
+
+# This is largely a copy of what's in Moose::Meta::Role (itself
+# largely a copy of Class::MOP::Class). However, we can't actually
+# call add_package_symbol, because there's no package into which to
+# add the symbol.
+sub add_method {
+    my ($self, $method_name, $method) = @_;
+
+    unless ( defined $method_name && $method_name ) {
+        throw_exception( MustDefineAMethodName => instance => $self );
+    }
+
+    my $body;
+    if (blessed($method)) {
+        $body = $method->body;
+        if ($method->package_name ne $self->name) {
+            $method = $method->clone(
+                package_name => $self->name,
+                name         => $method_name
+            ) if $method->can('clone');
+        }
+    }
+    else {
+        $body = $method;
+        $method = $self->wrap_method_body( body => $body, name => $method_name );
+    }
+
+    $self->_method_map->{$method_name} = $method;
+}
+
+sub get_method_list {
+    my $self = shift;
+    return keys %{ $self->_method_map };
+}
+
+sub _get_local_methods {
+    my $self = shift;
+    return values %{ $self->_method_map };
+}
+
+sub has_method {
+    my ($self, $method_name) = @_;
+
+    return exists $self->_method_map->{$method_name};
+}
+
+sub get_method {
+    my ($self, $method_name) = @_;
+
+    return $self->_method_map->{$method_name};
+}
+
+sub is_overloaded {
+    my ($self) = @_;
+    return keys %{ $self->_overload_map };
+}
+
+sub add_overloaded_operator {
+    my ( $self, $op_name, $overload ) = @_;
+
+    unless ( defined $op_name && $op_name ) {
+        throw_exception(
+            'MustDefineAnOverloadOperator',
+            instance => $self,
+        );
+    }
+
+    $self->_overload_map->{$op_name} = $overload;
+}
+
+sub get_overload_fallback_value {
+    my ($self) = @_;
+    return $self->_overload_fallback;
+}
+
+sub set_overload_fallback_value {
+    my $self = shift;
+    $self->_overload_fallback(shift);
+}
+
+sub get_all_overloaded_operators {
+    my ( $self, $method_name ) = @_;
+    return values %{ $self->_overload_map };
+}
+
+sub apply_params {
+    my ($self, $role_params) = @_;
+    Moose::Util::_load_user_class($self->application_role_summation_class);
+
+    $self->application_role_summation_class->new(
+        role_params => $role_params,
+    )->apply($self);
+
+    return $self;
+}
+
+sub reinitialize {
+    my ( $class, $old_meta, @args ) = @_;
+
+    throw_exception( CannotInitializeMooseMetaRoleComposite => old_meta       => $old_meta,
+                                                               args           => \@args,
+                                                               role_composite => $class
+                   )
+        if !blessed $old_meta
+            || !$old_meta->isa('Moose::Meta::Role::Composite');
+
+    my %existing_classes = map { $_ => $old_meta->$_() } qw(
+        application_role_summation_class
+    );
+
+    return $old_meta->meta->clone_object( $old_meta, %existing_classes, @args );
+}
+
+1;
+
+# ABSTRACT: An object to represent the set of roles
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Moose::Meta::Role::Composite - An object to represent the set of roles
+
+=head1 VERSION
+
+version 2.2207
+
+=head1 DESCRIPTION
+
+A composite is a role that consists of a set of two or more roles.
+
+The API of a composite role is almost identical to that of a regular
+role.
+
+=head1 INHERITANCE
+
+C<Moose::Meta::Role::Composite> is a subclass of L<Moose::Meta::Role>.
+
+=head1 METHODS
+
+=head2 Moose::Meta::Role::Composite->new(%options)
+
+This returns a new composite role object. It accepts the same
+options as its parent class, with a few changes:
+
+=over 4
+
+=item * roles
+
+This option is an array reference containing a list of
+L<Moose::Meta::Role> object. This is a required option.
+
+=item * name
+
+If a name is not given, one is generated from the roles provided.
+
+=item * apply_params(\%role_params)
+
+Creates a new RoleSummation role application with C<%role_params> and applies
+the composite role to it. The RoleSummation role application class used is
+determined by the composite role's C<application_role_summation_class>
+attribute.
+
+=item * reinitialize($metaclass)
+
+Like C<< Class::MOP::Package->reinitialize >>, but doesn't allow passing a
+string with the package name, as there is no real package for composite roles.
+
+=back
+
+=head1 BUGS
+
+See L<Moose/BUGS> for details on reporting bugs.
+
+=head1 AUTHORS
+
+=over 4
+
+=item *
+
+Stevan Little <stevan@cpan.org>
+
+=item *
+
+Dave Rolsky <autarch@urth.org>
+
+=item *
+
+Jesse Luehrs <doy@cpan.org>
+
+=item *
+
+Shawn M Moore <sartak@cpan.org>
+
+=item *
+
+יובל קוג'מן (Yuval Kogman) <nothingmuch@woobling.org>
+
+=item *
+
+Karen Etheridge <ether@cpan.org>
+
+=item *
+
+Florian Ragwitz <rafl@debian.org>
+
+=item *
+
+Hans Dieter Pearcey <hdp@cpan.org>
+
+=item *
+
+Chris Prather <chris@prather.org>
+
+=item *
+
+Matt S Trout <mstrout@cpan.org>
+
+=back
+
+=head1 COPYRIGHT AND LICENSE
+
+This software is copyright (c) 2006 by Infinity Interactive, Inc.
+
+This is free software; you can redistribute it and/or modify it under
+the same terms as the Perl 5 programming language system itself.
+
+=cut