75b433e930ca401b5df9975a2c10bf3ce6ca1126
[gitmo/Moose.git] / lib / Moose / Exporter.pm
1 package Moose::Exporter;
2
3 use strict;
4 use warnings;
5
6 use XSLoader;
7
8 BEGIN {
9     XSLoader::load(
10         'Moose',
11         $Moose::Exporter::{VERSION} ? ${ $Moose::Exporter::{VERSION} } : ()
12     );
13 }
14
15 use Class::MOP;
16 use List::MoreUtils qw( first_index uniq );
17 use Moose::Util::MetaRole;
18 use Scalar::Util qw(reftype);
19 use Sub::Exporter 0.980;
20 use Sub::Name qw(subname);
21
22 my %EXPORT_SPEC;
23
24 sub setup_import_methods {
25     my ( $class, %args ) = @_;
26
27     my $exporting_package = $args{exporting_package} ||= caller();
28
29     $class->build_import_methods(
30         %args,
31         install => [qw(import unimport init_meta)]
32     );
33 }
34
35 sub build_import_methods {
36     my ( $class, %args ) = @_;
37
38     my $exporting_package = $args{exporting_package} ||= caller();
39
40     $EXPORT_SPEC{$exporting_package} = \%args;
41
42     my @exports_from = $class->_follow_also($exporting_package);
43
44     my $export_recorder = {};
45     my $is_reexport     = {};
46
47     my $exports = $class->_make_sub_exporter_params(
48         [ @exports_from, $exporting_package ],
49         $export_recorder,
50         $is_reexport,
51     );
52
53     my $exporter = $class->_make_exporter($exports, $is_reexport);
54
55     my %methods;
56     $methods{import} = $class->_make_import_sub(
57         $exporting_package,
58         $exporter,
59         \@exports_from,
60         $is_reexport
61     );
62
63     $methods{unimport} = $class->_make_unimport_sub(
64         $exporting_package,
65         $exports,
66         $export_recorder,
67         $is_reexport
68     );
69
70     $methods{init_meta} = $class->_make_init_meta(
71         $exporting_package,
72         \%args
73     );
74
75     my $package = Class::MOP::Package->initialize($exporting_package);
76     for my $to_install ( @{ $args{install} || [] } ) {
77         my $symbol = '&' . $to_install;
78         next
79             unless $methods{$to_install}
80                 && !$package->has_package_symbol($symbol);
81         $package->add_package_symbol( $symbol, $methods{$to_install} );
82     }
83
84     return ( $methods{import}, $methods{unimport}, $methods{init_meta} );
85 }
86
87 sub _make_exporter {
88     my ($class, $exports, $is_reexport) = @_;
89
90     return Sub::Exporter::build_exporter(
91         {
92             exports   => $exports,
93             groups    => { default => [':all'] },
94             installer => sub {
95                 my ($arg, $to_export) = @_;
96                 my $meta = Class::MOP::class_of($arg->{into});
97
98                 goto &Sub::Exporter::default_installer unless $meta;
99
100                 # don't overwrite existing symbols with our magically flagged
101                 # version of it if we would install the same sub that's already
102                 # in the importer
103
104                 my @filtered_to_export;
105                 my %installed;
106                 for (my $i = 0; $i < @{ $to_export }; $i += 2) {
107                     my ($as, $cv) = @{ $to_export }[$i, $i + 1];
108
109                     next if !ref($as)
110                          && $meta->has_package_symbol('&' . $as)
111                          && $meta->get_package_symbol('&' . $as) == $cv;
112
113                     push @filtered_to_export, $as, $cv;
114                     $installed{$as} = 1 unless ref $as;
115                 }
116
117                 Sub::Exporter::default_installer($arg, \@filtered_to_export);
118
119                 for my $name ( keys %{$is_reexport} ) {
120                     no strict 'refs';
121                     no warnings 'once';
122                     next unless exists $installed{$name};
123                     _flag_as_reexport( \*{ join q{::}, $arg->{into}, $name } );
124                 }
125             },
126         }
127     );
128 }
129
130 {
131     my $seen = {};
132
133     sub _follow_also {
134         my $class             = shift;
135         my $exporting_package = shift;
136
137         local %$seen = ( $exporting_package => 1 );
138
139         return uniq( _follow_also_real($exporting_package) );
140     }
141
142     sub _follow_also_real {
143         my $exporting_package = shift;
144
145         if ( !exists $EXPORT_SPEC{$exporting_package} ) {
146             my $loaded = Class::MOP::is_class_loaded($exporting_package);
147
148             die "Package in also ($exporting_package) does not seem to "
149                 . "use Moose::Exporter"
150                 . ( $loaded ? "" : " (is it loaded?)" );
151         }
152
153         my $also = $EXPORT_SPEC{$exporting_package}{also};
154
155         return unless defined $also;
156
157         my @also = ref $also ? @{$also} : $also;
158
159         for my $package (@also) {
160             die
161                 "Circular reference in 'also' parameter to Moose::Exporter between $exporting_package and $package"
162                 if $seen->{$package};
163
164             $seen->{$package} = 1;
165         }
166
167         return @also, map { _follow_also_real($_) } @also;
168     }
169 }
170
171 sub _parse_trait_aliases {
172     my $class   = shift;
173     my ($package, $aliases) = @_;
174
175     my @ret;
176     for my $alias (@$aliases) {
177         my $name;
178         if (ref($alias)) {
179             reftype($alias) eq 'ARRAY'
180                 or Moose->throw_error(reftype($alias) . " references are not "
181                                     . "valid arguments to the 'trait_aliases' "
182                                     . "option");
183
184             ($alias, $name) = @$alias;
185         }
186         else {
187             ($name = $alias) =~ s/.*:://;
188         }
189         push @ret, subname "${package}::${name}" => sub () { $alias };
190     }
191
192     return @ret;
193 }
194
195 sub _make_sub_exporter_params {
196     my $class           = shift;
197     my $packages        = shift;
198     my $export_recorder = shift;
199     my $is_reexport  = shift;
200
201     my %exports;
202
203     for my $package ( @{$packages} ) {
204         my $args = $EXPORT_SPEC{$package}
205             or die "The $package package does not use Moose::Exporter\n";
206
207         for my $name ( @{ $args->{with_meta} } ) {
208             my $sub = $class->_sub_from_package( $package, $name )
209                 or next;
210
211             my $fq_name = $package . '::' . $name;
212
213             $exports{$name} = $class->_make_wrapped_sub_with_meta(
214                 $fq_name,
215                 $sub,
216                 $export_recorder,
217             );
218         }
219
220         for my $name ( @{ $args->{with_caller} } ) {
221             my $sub = $class->_sub_from_package( $package, $name )
222                 or next;
223
224             my $fq_name = $package . '::' . $name;
225
226             $exports{$name} = $class->_make_wrapped_sub(
227                 $fq_name,
228                 $sub,
229                 $export_recorder,
230             );
231         }
232
233         my @extra_exports = $class->_parse_trait_aliases(
234             $package, $args->{trait_aliases},
235         );
236         for my $name ( @{ $args->{as_is} }, @extra_exports ) {
237             my ( $sub, $coderef_name );
238
239             if ( ref $name ) {
240                 $sub = $name;
241
242                 my $coderef_pkg;
243                 ( $coderef_pkg, $coderef_name )
244                     = Class::MOP::get_code_info($name);
245
246                 if ( $coderef_pkg ne $package ) {
247                     $is_reexport->{$coderef_name} = 1;
248                 }
249             }
250             else {
251                 $sub = $class->_sub_from_package( $package, $name )
252                     or next;
253
254                 $coderef_name = $name;
255             }
256
257             $export_recorder->{$sub} = 1;
258
259             $exports{$coderef_name} = sub {$sub};
260         }
261     }
262
263     return \%exports;
264 }
265
266 sub _sub_from_package {
267     my $sclass  = shift;
268     my $package = shift;
269     my $name    = shift;
270
271     my $sub = do {
272         no strict 'refs';
273         \&{ $package . '::' . $name };
274     };
275
276     return $sub if defined &$sub;
277
278     Carp::cluck "Trying to export undefined sub ${package}::${name}";
279
280     return;
281 }
282
283 our $CALLER;
284
285 sub _make_wrapped_sub {
286     my $self            = shift;
287     my $fq_name         = shift;
288     my $sub             = shift;
289     my $export_recorder = shift;
290
291     # We need to set the package at import time, so that when
292     # package Foo imports has(), we capture "Foo" as the
293     # package. This lets other packages call Foo::has() and get
294     # the right package. This is done for backwards compatibility
295     # with existing production code, not because this is a good
296     # idea ;)
297     return sub {
298         my $caller = $CALLER;
299
300         my $wrapper = $self->_curry_wrapper( $sub, $fq_name, $caller );
301
302         my $sub = subname( $fq_name => $wrapper );
303
304         $export_recorder->{$sub} = 1;
305
306         return $sub;
307     };
308 }
309
310 sub _make_wrapped_sub_with_meta {
311     my $self            = shift;
312     my $fq_name         = shift;
313     my $sub             = shift;
314     my $export_recorder = shift;
315
316     return sub {
317         my $caller = $CALLER;
318
319         my $wrapper = $self->_late_curry_wrapper(
320             $sub, $fq_name,
321             sub { Class::MOP::class_of(shift) } => $caller
322         );
323
324         my $sub = subname( $fq_name => $wrapper );
325
326         $export_recorder->{$sub} = 1;
327
328         return $sub;
329     };
330 }
331
332 sub _curry_wrapper {
333     my $class   = shift;
334     my $sub     = shift;
335     my $fq_name = shift;
336     my @extra   = @_;
337
338     my $wrapper = sub { $sub->( @extra, @_ ) };
339     if ( my $proto = prototype $sub ) {
340
341         # XXX - Perl's prototype sucks. Use & to make set_prototype
342         # ignore the fact that we're passing "private variables"
343         &Scalar::Util::set_prototype( $wrapper, $proto );
344     }
345     return $wrapper;
346 }
347
348 sub _late_curry_wrapper {
349     my $class   = shift;
350     my $sub     = shift;
351     my $fq_name = shift;
352     my $extra   = shift;
353     my @ex_args = @_;
354
355     my $wrapper = sub {
356
357         # resolve curried arguments at runtime via this closure
358         my @curry = ( $extra->(@ex_args) );
359         return $sub->( @curry, @_ );
360     };
361
362     if ( my $proto = prototype $sub ) {
363
364         # XXX - Perl's prototype sucks. Use & to make set_prototype
365         # ignore the fact that we're passing "private variables"
366         &Scalar::Util::set_prototype( $wrapper, $proto );
367     }
368     return $wrapper;
369 }
370
371 sub _make_import_sub {
372     shift;
373     my $exporting_package = shift;
374     my $exporter          = shift;
375     my $exports_from      = shift;
376     my $is_reexport    = shift;
377
378     return sub {
379
380         # I think we could use Sub::Exporter's collector feature
381         # to do this, but that would be rather gross, since that
382         # feature isn't really designed to return a value to the
383         # caller of the exporter sub.
384         #
385         # Also, this makes sure we preserve backwards compat for
386         # _get_caller, so it always sees the arguments in the
387         # expected order.
388         my $traits;
389         ( $traits, @_ ) = _strip_traits(@_);
390
391         my $metaclass;
392         ( $metaclass, @_ ) = _strip_metaclass(@_);
393         $metaclass
394             = Moose::Util::resolve_metaclass_alias( 'Class' => $metaclass )
395             if defined $metaclass && length $metaclass;
396
397         my $meta_name;
398         ( $meta_name, @_ ) = _strip_meta_name(@_);
399
400         # Normally we could look at $_[0], but in some weird cases
401         # (involving goto &Moose::import), $_[0] ends as something
402         # else (like Squirrel).
403         my $class = $exporting_package;
404
405         $CALLER = _get_caller(@_);
406
407         # this works because both pragmas set $^H (see perldoc
408         # perlvar) which affects the current compilation -
409         # i.e. the file who use'd us - which is why we don't need
410         # to do anything special to make it affect that file
411         # rather than this one (which is already compiled)
412
413         strict->import;
414         warnings->import;
415
416         my $did_init_meta;
417         for my $c ( grep { $_->can('init_meta') } $class, @{$exports_from} ) {
418
419             # init_meta can apply a role, which when loaded uses
420             # Moose::Exporter, which in turn sets $CALLER, so we need
421             # to protect against that.
422             local $CALLER = $CALLER;
423             $c->init_meta(
424                 for_class => $CALLER,
425                 metaclass => $metaclass,
426                 meta_name => $meta_name,
427             );
428             $did_init_meta = 1;
429         }
430
431         if ( $did_init_meta && @{$traits} ) {
432
433             # The traits will use Moose::Role, which in turn uses
434             # Moose::Exporter, which in turn sets $CALLER, so we need
435             # to protect against that.
436             local $CALLER = $CALLER;
437             _apply_meta_traits( $CALLER, $traits );
438         }
439         elsif ( @{$traits} ) {
440             require Moose;
441             Moose->throw_error(
442                 "Cannot provide traits when $class does not have an init_meta() method"
443             );
444         }
445
446         my ( undef, @args ) = @_;
447         my $extra = shift @args if ref $args[0] eq 'HASH';
448
449         $extra ||= {};
450         if ( !$extra->{into} ) {
451             $extra->{into_level} ||= 0;
452             $extra->{into_level}++;
453         }
454
455         $class->$exporter( $extra, @args );
456     };
457 }
458
459 sub _strip_traits {
460     my $idx = first_index { ( $_ || '' ) eq '-traits' } @_;
461
462     return ( [], @_ ) unless $idx >= 0 && $#_ >= $idx + 1;
463
464     my $traits = $_[ $idx + 1 ];
465
466     splice @_, $idx, 2;
467
468     $traits = [$traits] unless ref $traits;
469
470     return ( $traits, @_ );
471 }
472
473 sub _strip_metaclass {
474     my $idx = first_index { ( $_ || '' ) eq '-metaclass' } @_;
475
476     return ( undef, @_ ) unless $idx >= 0 && $#_ >= $idx + 1;
477
478     my $metaclass = $_[ $idx + 1 ];
479
480     splice @_, $idx, 2;
481
482     return ( $metaclass, @_ );
483 }
484
485 sub _strip_meta_name {
486     my $idx = first_index { ( $_ || '' ) eq '-meta_name' } @_;
487
488     return ( 'meta', @_ ) unless $idx >= 0 && $#_ >= $idx + 1;
489
490     my $meta_name = $_[ $idx + 1 ];
491
492     splice @_, $idx, 2;
493
494     return ( $meta_name, @_ );
495 }
496
497 sub _apply_meta_traits {
498     my ( $class, $traits ) = @_;
499
500     return unless @{$traits};
501
502     my $meta = Class::MOP::class_of($class);
503
504     my $type = ( split /::/, ref $meta )[-1]
505         or Moose->throw_error(
506         'Cannot determine metaclass type for trait application . Meta isa '
507             . ref $meta );
508
509     my @resolved_traits = map {
510         ref $_
511             ? $_
512             : Moose::Util::resolve_metatrait_alias( $type => $_ )
513     } @$traits;
514
515     return unless @resolved_traits;
516
517     my %args = ( for => $class );
518
519     if ( $meta->isa('Moose::Meta::Role') ) {
520         $args{role_metaroles} = { role => \@resolved_traits };
521     }
522     else {
523         $args{class_metaroles} = { class => \@resolved_traits };
524     }
525
526     Moose::Util::MetaRole::apply_metaroles(%args);
527 }
528
529 sub _get_caller {
530
531     # 1 extra level because it's called by import so there's a layer
532     # of indirection
533     my $offset = 1;
534
535     return
536           ( ref $_[1] && defined $_[1]->{into} ) ? $_[1]->{into}
537         : ( ref $_[1] && defined $_[1]->{into_level} )
538         ? caller( $offset + $_[1]->{into_level} )
539         : caller($offset);
540 }
541
542 sub _make_unimport_sub {
543     shift;
544     my $exporting_package = shift;
545     my $exports           = shift;
546     my $export_recorder   = shift;
547     my $is_reexport    = shift;
548
549     return sub {
550         my $caller = scalar caller();
551         Moose::Exporter->_remove_keywords(
552             $caller,
553             [ keys %{$exports} ],
554             $export_recorder,
555             $is_reexport,
556         );
557     };
558 }
559
560 sub _remove_keywords {
561     shift;
562     my $package          = shift;
563     my $keywords         = shift;
564     my $recorded_exports = shift;
565     my $is_reexport   = shift;
566
567     no strict 'refs';
568
569     foreach my $name ( @{$keywords} ) {
570         if ( defined &{ $package . '::' . $name } ) {
571             my $sub = \&{ $package . '::' . $name };
572
573             # make sure it is from us
574             next unless $recorded_exports->{$sub};
575
576             if ( $is_reexport->{$name} ) {
577                 no strict 'refs';
578                 next
579                     unless _export_is_flagged(
580                             \*{ join q{::} => $package, $name } );
581             }
582
583             # and if it is from us, then undef the slot
584             delete ${ $package . '::' }{$name};
585         }
586     }
587 }
588
589 sub _make_init_meta {
590     shift;
591     my $class = shift;
592     my $args  = shift;
593
594     my %old_style_roles;
595     for my $role (
596         map {"${_}_roles"}
597         qw(
598         metaclass
599         attribute_metaclass
600         method_metaclass
601         wrapped_method_metaclass
602         instance_metaclass
603         constructor_class
604         destructor_class
605         error_class
606         )
607         ) {
608         $old_style_roles{$role} = $args->{$role}
609             if exists $args->{$role};
610     }
611
612     my %base_class_roles;
613     %base_class_roles = ( roles => $args->{base_class_roles} )
614         if exists $args->{base_class_roles};
615
616     my %new_style_roles = map { $_ => $args->{$_} }
617         grep { exists $args->{$_} } qw( class_metaroles role_metaroles );
618
619     return unless %new_style_roles || %old_style_roles || %base_class_roles;
620
621     return sub {
622         shift;
623         my %options = @_;
624
625         return unless Class::MOP::class_of( $options{for_class} );
626
627         if ( %new_style_roles || %old_style_roles ) {
628             Moose::Util::MetaRole::apply_metaroles(
629                 for => $options{for_class},
630                 %new_style_roles,
631                 %old_style_roles,
632             );
633         }
634
635         Moose::Util::MetaRole::apply_base_class_roles(
636             for_class => $options{for_class},
637             %base_class_roles,
638             )
639             if Class::MOP::class_of( $options{for_class} )
640                 ->isa('Moose::Meta::Class');
641
642         return Class::MOP::class_of( $options{for_class} );
643     };
644 }
645
646 sub import {
647     strict->import;
648     warnings->import;
649 }
650
651 1;
652
653 # ABSTRACT: make an import() and unimport() just like Moose.pm
654
655 __END__
656
657 =head1 SYNOPSIS
658
659   package MyApp::Moose;
660
661   use Moose ();
662   use Moose::Exporter;
663
664   Moose::Exporter->setup_import_methods(
665       with_meta => [ 'has_rw', 'sugar2' ],
666       as_is     => [ 'sugar3', \&Some::Random::thing ],
667       also      => 'Moose',
668   );
669
670   sub has_rw {
671       my ( $meta, $name, %options ) = @_;
672       $meta->add_attribute(
673           $name,
674           is => 'rw',
675           %options,
676       );
677   }
678
679   # then later ...
680   package MyApp::User;
681
682   use MyApp::Moose;
683
684   has 'name';
685   has_rw 'size';
686   thing;
687
688   no MyApp::Moose;
689
690 =head1 DESCRIPTION
691
692 This module encapsulates the exporting of sugar functions in a
693 C<Moose.pm>-like manner. It does this by building custom C<import>,
694 C<unimport>, and C<init_meta> methods for your module, based on a spec you
695 provide.
696
697 It also lets you "stack" Moose-alike modules so you can export Moose's sugar
698 as well as your own, along with sugar from any random C<MooseX> module, as
699 long as they all use C<Moose::Exporter>. This feature exists to let you bundle
700 a set of MooseX modules into a policy module that developers can use directly
701 instead of using Moose itself.
702
703 To simplify writing exporter modules, C<Moose::Exporter> also imports
704 C<strict> and C<warnings> into your exporter module, as well as into
705 modules that use it.
706
707 =head1 METHODS
708
709 This module provides two public methods:
710
711 =over 4
712
713 =item  B<< Moose::Exporter->setup_import_methods(...) >>
714
715 When you call this method, C<Moose::Exporter> builds custom C<import>,
716 C<unimport>, and C<init_meta> methods for your module. The C<import> method
717 will export the functions you specify, and can also re-export functions
718 exported by some other module (like C<Moose.pm>).
719
720 The C<unimport> method cleans the caller's namespace of all the exported
721 functions. This includes any functions you re-export from other
722 packages. However, if the consumer of your package also imports those
723 functions from the original package, they will I<not> be cleaned.
724
725 If you pass any parameters for L<Moose::Util::MetaRole>, this method will
726 generate an C<init_meta> for you as well (see below for details). This
727 C<init_meta> will call C<Moose::Util::MetaRole::apply_metaroles> and
728 C<Moose::Util::MetaRole::apply_base_class_roles> as needed.
729
730 Note that if any of these methods already exist, they will not be
731 overridden, you will have to use C<build_import_methods> to get the
732 coderef that would be installed.
733
734 This method accepts the following parameters:
735
736 =over 8
737
738 =item * with_meta => [ ... ]
739
740 This list of function I<names only> will be wrapped and then exported. The
741 wrapper will pass the metaclass object for the caller as its first argument.
742
743 Many sugar functions will need to use this metaclass object to do something to
744 the calling package.
745
746 =item * as_is => [ ... ]
747
748 This list of function names or sub references will be exported as-is. You can
749 identify a subroutine by reference, which is handy to re-export some other
750 module's functions directly by reference (C<\&Some::Package::function>).
751
752 If you do export some other package's function, this function will never be
753 removed by the C<unimport> method. The reason for this is we cannot know if
754 the caller I<also> explicitly imported the sub themselves, and therefore wants
755 to keep it.
756
757 =item * trait_aliases => [ ... ]
758
759 This is a list of package names which should have shortened aliases exported,
760 similar to the functionality of L<aliased>. Each element in the list can be
761 either a package name, in which case the export will be named as the last
762 namespace component of the package, or an arrayref, whose first element is the
763 package to alias to, and second element is the alias to export.
764
765 =item * also => $name or \@names
766
767 This is a list of modules which contain functions that the caller
768 wants to export. These modules must also use C<Moose::Exporter>. The
769 most common use case will be to export the functions from C<Moose.pm>.
770 Functions specified by C<with_meta> or C<as_is> take precedence over
771 functions exported by modules specified by C<also>, so that a module
772 can selectively override functions exported by another module.
773
774 C<Moose::Exporter> also makes sure all these functions get removed
775 when C<unimport> is called.
776
777 =back
778
779 You can also provide parameters for C<Moose::Util::MetaRole::apply_metaroles>
780 and C<Moose::Util::MetaRole::base_class_roles>. Specifically, valid parameters
781 are "class_metaroles", "role_metaroles", and "base_class_roles".
782
783 =item B<< Moose::Exporter->build_import_methods(...) >>
784
785 Returns two or three code refs, one for C<import>, one for
786 C<unimport>, and optionally one for C<init_meta>, if the appropriate
787 options are passed in.
788
789 Accepts the additional C<install> option, which accepts an arrayref of method
790 names to install into your exporting package. The valid options are C<import>,
791 C<unimport>, and C<init_meta>. Calling C<setup_import_methods> is equivalent
792 to calling C<build_import_methods> with C<< install => [qw(import unimport
793 init_meta)] >> except that it doesn't also return the methods.
794
795 Used by C<setup_import_methods>.
796
797 =back
798
799 =head1 IMPORTING AND init_meta
800
801 If you want to set an alternative base object class or metaclass class, see
802 above for details on how this module can call L<Moose::Util::MetaRole> for
803 you.
804
805 If you want to do something that is not supported by this module, simply
806 define an C<init_meta> method in your class. The C<import> method that
807 C<Moose::Exporter> generates for you will call this method (if it exists). It
808 will always pass the caller to this method via the C<for_class> parameter.
809
810 Most of the time, your C<init_meta> method will probably just call C<<
811 Moose->init_meta >> to do the real work:
812
813   sub init_meta {
814       shift; # our class name
815       return Moose->init_meta( @_, metaclass => 'My::Metaclass' );
816   }
817
818 Keep in mind that C<build_import_methods> will return an C<init_meta>
819 method for you, which you can also call from within your custom
820 C<init_meta>:
821
822   my ( $import, $unimport, $init_meta ) =
823       Moose::Exporter->build_import_methods( ... );
824
825   sub import {
826      my $class = shift;
827
828      ...
829
830      $class->$import(...);
831
832      ...
833   }
834
835   sub unimport { goto &$unimport }
836
837   sub init_meta {
838      my $class = shift;
839
840      ...
841
842      $class->$init_meta(...);
843
844      ...
845   }
846
847 =head1 METACLASS TRAITS
848
849 The C<import> method generated by C<Moose::Exporter> will allow the
850 user of your module to specify metaclass traits in a C<-traits>
851 parameter passed as part of the import:
852
853   use Moose -traits => 'My::Meta::Trait';
854
855   use Moose -traits => [ 'My::Meta::Trait', 'My::Other::Trait' ];
856
857 These traits will be applied to the caller's metaclass
858 instance. Providing traits for an exporting class that does not create
859 a metaclass for the caller is an error.
860
861 =head1 BUGS
862
863 See L<Moose/BUGS> for details on reporting bugs.
864
865 =cut