use strict;
use warnings;
-our $VERSION = '0.62';
+our $VERSION = '0.76';
$VERSION = eval $VERSION;
our $AUTHORITY = 'cpan:STEVAN';
my ( $exports, $is_removable )
= $class->_make_sub_exporter_params(
- [ $exporting_package, @exports_from ], $export_recorder );
+ [ @exports_from, $exporting_package ], $export_recorder );
my $exporter = Sub::Exporter::build_exporter(
{
}
sub _make_wrapper {
- shift;
+ my $class = shift;
my $caller = shift;
my $sub = shift;
my $fq_name = shift;
- return sub { $sub->($caller, @_) };
+ my $wrapper = sub { $sub->($caller, @_) };
+ if (my $proto = prototype $sub) {
+ # XXX - Perl's prototype sucks. Use & to make set_prototype
+ # ignore the fact that we're passing a "provate variable"
+ &Scalar::Util::set_prototype($wrapper, $proto);
+ }
+ return $wrapper;
}
sub _make_import_sub {
my $traits;
( $traits, @_ ) = _strip_traits(@_);
+ my $metaclass;
+ ( $metaclass, @_ ) = _strip_metaclass(@_);
+
# Normally we could look at $_[0], but in some weird cases
# (involving goto &Moose::import), $_[0] ends as something
# else (like Squirrel).
# Moose::Exporter, which in turn sets $CALLER, so we need
# to protect against that.
local $CALLER = $CALLER;
- $c->init_meta( for_class => $CALLER );
+ $c->init_meta( for_class => $CALLER, metaclass => $metaclass );
$did_init_meta = 1;
}
_apply_meta_traits( $CALLER, $traits );
}
elsif ( @{$traits} ) {
+ require Moose;
Moose->throw_error(
"Cannot provide traits when $class does not have an init_meta() method"
);
return ( $traits, @_ );
}
+sub _strip_metaclass {
+ my $idx = first_index { $_ eq '-metaclass' } @_;
+
+ return ( undef, @_ ) unless $idx >= 0 && $#_ >= $idx + 1;
+
+ my $metaclass = $_[ $idx + 1 ];
+
+ splice @_, $idx, 2;
+
+ return ( $metaclass, @_ );
+}
+
sub _apply_meta_traits {
my ( $class, $traits ) = @_;
return unless @{$traits};
- my $meta = $class->meta();
+ my $meta = Class::MOP::class_of($class);
my $type = ( split /::/, ref $meta )[-1]
or Moose->throw_error(
This module provides two public methods:
-=head2 Moose::Exporter->setup_import_methods(...)
+=over 4
+
+=item B<< Moose::Exporter->setup_import_methods(...) >>
When you call this method, C<Moose::Exporter> build custom C<import>
and C<unimport> methods for your module. The import method will export
This method accepts the following parameters:
-=over 4
+=over 8
=item * with_caller => [ ... ]
This is a list of modules which contain functions that the caller
wants to export. These modules must also use C<Moose::Exporter>. The
most common use case will be to export the functions from C<Moose.pm>.
+Functions specified by C<with_caller> or C<as_is> take precedence over
+functions exported by modules specified by C<also>, so that a module
+can selectively override functions exported by another module.
C<Moose::Exporter> also makes sure all these functions get removed
when C<unimport> is called.
=back
-=head2 Moose::Exporter->build_import_methods(...)
+=item B<< Moose::Exporter->build_import_methods(...) >>
Returns two code refs, one for import and one for unimport.
Used by C<setup_import_methods>.
+=back
+
=head1 IMPORTING AND init_meta
If you want to set an alternative base object class or metaclass
=head1 COPYRIGHT AND LICENSE
-Copyright 2008 by Infinity Interactive, Inc.
+Copyright 2009 by Infinity Interactive, Inc.
L<http://www.iinteractive.com>