[gitmo/Moose.git] / t / metaclasses / moose_exporter.t

#!/usr/bin/perl

use strict;
use warnings;

use Test::More;
use Test::Fatal;
use Test::Moose;

use Test::Requires {
    'Test::Output' => '0.01', # skip all if not installed
};

{
    package HasOwnImmutable;

    use Moose;

    no Moose;

    ::stderr_is( sub { eval q[sub make_immutable { return 'foo' }] },
                  '',
                  'no warning when defining our own make_immutable sub' );
}

{
    is( HasOwnImmutable->make_immutable(), 'foo',
        'HasOwnImmutable->make_immutable does not get overwritten' );
}

{
    package MooseX::Empty;

    use Moose ();
    Moose::Exporter->setup_import_methods( also => 'Moose' );
}

{
    package WantsMoose;

    MooseX::Empty->import();

    sub foo { 1 }

    ::can_ok( 'WantsMoose', 'has' );
    ::can_ok( 'WantsMoose', 'with' );
    ::can_ok( 'WantsMoose', 'foo' );

    MooseX::Empty->unimport();
}

{
    # Note: it's important that these methods be out of scope _now_,
    # after unimport was called. We tried a
    # namespace::clean(0.08)-based solution, but had to abandon it
    # because it cleans the namespace _later_ (when the file scope
    # ends).
    ok( ! WantsMoose->can('has'),  'WantsMoose::has() has been cleaned' );
    ok( ! WantsMoose->can('with'), 'WantsMoose::with() has been cleaned' );
    can_ok( 'WantsMoose', 'foo' );

    # This makes sure that Moose->init_meta() happens properly
    isa_ok( WantsMoose->meta(), 'Moose::Meta::Class' );
    isa_ok( WantsMoose->new(), 'Moose::Object' );

}

{
    package MooseX::Sugar;

    use Moose ();

    sub wrapped1 {
        my $meta = shift;
        return $meta->name . ' called wrapped1';
    }

    Moose::Exporter->setup_import_methods(
        with_meta => ['wrapped1'],
        also      => 'Moose',
    );
}

{
    package WantsSugar;

    MooseX::Sugar->import();

    sub foo { 1 }

    ::can_ok( 'WantsSugar', 'has' );
    ::can_ok( 'WantsSugar', 'with' );
    ::can_ok( 'WantsSugar', 'wrapped1' );
    ::can_ok( 'WantsSugar', 'foo' );
    ::is( wrapped1(), 'WantsSugar called wrapped1',
          'wrapped1 identifies the caller correctly' );

    MooseX::Sugar->unimport();
}

{
    ok( ! WantsSugar->can('has'),  'WantsSugar::has() has been cleaned' );
    ok( ! WantsSugar->can('with'), 'WantsSugar::with() has been cleaned' );
    ok( ! WantsSugar->can('wrapped1'), 'WantsSugar::wrapped1() has been cleaned' );
    can_ok( 'WantsSugar', 'foo' );
}

{
    package MooseX::MoreSugar;

    use Moose ();

    sub wrapped2 {
        my $caller = shift->name;
        return $caller . ' called wrapped2';
    }

    sub as_is1 {
        return 'as_is1';
    }

    Moose::Exporter->setup_import_methods(
        with_meta => ['wrapped2'],
        as_is     => ['as_is1'],
        also      => 'MooseX::Sugar',
    );
}

{
    package WantsMoreSugar;

    MooseX::MoreSugar->import();

    sub foo { 1 }

    ::can_ok( 'WantsMoreSugar', 'has' );
    ::can_ok( 'WantsMoreSugar', 'with' );
    ::can_ok( 'WantsMoreSugar', 'wrapped1' );
    ::can_ok( 'WantsMoreSugar', 'wrapped2' );
    ::can_ok( 'WantsMoreSugar', 'as_is1' );
    ::can_ok( 'WantsMoreSugar', 'foo' );
    ::is( wrapped1(), 'WantsMoreSugar called wrapped1',
          'wrapped1 identifies the caller correctly' );
    ::is( wrapped2(), 'WantsMoreSugar called wrapped2',
          'wrapped2 identifies the caller correctly' );
    ::is( as_is1(), 'as_is1',
          'as_is1 works as expected' );

    MooseX::MoreSugar->unimport();
}

{
    ok( ! WantsMoreSugar->can('has'),  'WantsMoreSugar::has() has been cleaned' );
    ok( ! WantsMoreSugar->can('with'), 'WantsMoreSugar::with() has been cleaned' );
    ok( ! WantsMoreSugar->can('wrapped1'), 'WantsMoreSugar::wrapped1() has been cleaned' );
    ok( ! WantsMoreSugar->can('wrapped2'), 'WantsMoreSugar::wrapped2() has been cleaned' );
    ok( ! WantsMoreSugar->can('as_is1'), 'WantsMoreSugar::as_is1() has been cleaned' );
    can_ok( 'WantsMoreSugar', 'foo' );
}

{
    package My::Metaclass;
    use Moose;
    BEGIN { extends 'Moose::Meta::Class' }

    package My::Object;
    use Moose;
    BEGIN { extends 'Moose::Object' }

    package HasInitMeta;

    use Moose ();

    sub init_meta {
        shift;
        return Moose->init_meta( @_,
                                 metaclass  => 'My::Metaclass',
                                 base_class => 'My::Object',
                               );
    }

    Moose::Exporter->setup_import_methods( also => 'Moose' );
}

{
    package NewMeta;

    HasInitMeta->import();
}

{
    isa_ok( NewMeta->meta(), 'My::Metaclass' );
    isa_ok( NewMeta->new(), 'My::Object' );
}

{
    package MooseX::CircularAlso;

    use Moose ();

    ::like(
        ::exception{ Moose::Exporter->setup_import_methods(
                also => [ 'Moose', 'MooseX::CircularAlso' ],
            );
            },
        qr/\QCircular reference in 'also' parameter to Moose::Exporter between MooseX::CircularAlso and MooseX::CircularAlso/,
        'a circular reference in also dies with an error'
    );
}

{
    package MooseX::NoAlso;

    use Moose ();

    ::like(
        ::exception{ Moose::Exporter->setup_import_methods(
                also => ['NoSuchThing'],
            );
            },
        qr/\QPackage in also (NoSuchThing) does not seem to use Moose::Exporter (is it loaded?) at /,
        'a package which does not use Moose::Exporter in also dies with an error'
    );
}

{
    package MooseX::NotExporter;

    use Moose ();

    ::like(
        ::exception{ Moose::Exporter->setup_import_methods(
                also => ['Moose::Meta::Method'],
            );
            },
        qr/\QPackage in also (Moose::Meta::Method) does not seem to use Moose::Exporter at /,
        'a package which does not use Moose::Exporter in also dies with an error'
    );
}

{
    package MooseX::OverridingSugar;

    use Moose ();

    sub has {
        my $caller = shift->name;
        return $caller . ' called has';
    }

    Moose::Exporter->setup_import_methods(
        with_meta => ['has'],
        also      => 'Moose',
    );
}

{
    package WantsOverridingSugar;

    MooseX::OverridingSugar->import();

    ::can_ok( 'WantsOverridingSugar', 'has' );
    ::can_ok( 'WantsOverridingSugar', 'with' );
    ::is( has('foo'), 'WantsOverridingSugar called has',
          'has from MooseX::OverridingSugar is called, not has from Moose' );

    MooseX::OverridingSugar->unimport();
}

{
    ok( ! WantsOverridingSugar->can('has'),  'WantsSugar::has() has been cleaned' );
    ok( ! WantsOverridingSugar->can('with'), 'WantsSugar::with() has been cleaned' );
}

{
    package MooseX::OverridingSugar::PassThru;

    sub with {
        my $caller = shift->name;
        return $caller . ' called with';
    }

    Moose::Exporter->setup_import_methods(
        with_meta => ['with'],
        also      => 'MooseX::OverridingSugar',
    );
}

{

    package WantsOverridingSugar::PassThru;

    MooseX::OverridingSugar::PassThru->import();

    ::can_ok( 'WantsOverridingSugar::PassThru', 'has' );
    ::can_ok( 'WantsOverridingSugar::PassThru', 'with' );
    ::is(
        has('foo'),
        'WantsOverridingSugar::PassThru called has',
        'has from MooseX::OverridingSugar is called, not has from Moose'
    );

    ::is(
        with('foo'),
        'WantsOverridingSugar::PassThru called with',
        'with from MooseX::OverridingSugar::PassThru is called, not has from Moose'
    );


    MooseX::OverridingSugar::PassThru->unimport();
}

{
    ok( ! WantsOverridingSugar::PassThru->can('has'),  'WantsOverridingSugar::PassThru::has() has been cleaned' );
    ok( ! WantsOverridingSugar::PassThru->can('with'), 'WantsOverridingSugar::PassThru::with() has been cleaned' );
}

{

    package NonExistentExport;

    use Moose ();

    ::stderr_like {
        Moose::Exporter->setup_import_methods(
            also => ['Moose'],
            with_meta => ['does_not_exist'],
        );
    } qr/^Trying to export undefined sub NonExistentExport::does_not_exist/,
      "warns when a non-existent method is requested to be exported";
}

{
    package WantsNonExistentExport;

    NonExistentExport->import;

    ::ok(!__PACKAGE__->can('does_not_exist'),
         "undefined subs do not get exported");
}

{
    package AllOptions;
    use Moose ();
    use Moose::Deprecated -api_version => '0.88';
    use Moose::Exporter;

    Moose::Exporter->setup_import_methods(
        also        => ['Moose'],
        with_meta   => [ 'with_meta1', 'with_meta2' ],
        with_caller => [ 'with_caller1', 'with_caller2' ],
        as_is       => ['as_is1'],
    );

    sub with_caller1 {
        return @_;
    }

    sub with_caller2 (&) {
        return @_;
    }

    sub as_is1 {2}

    sub with_meta1 {
        return @_;
    }

    sub with_meta2 (&) {
        return @_;
    }
}

{
    package UseAllOptions;

    AllOptions->import();
}

{
    can_ok( 'UseAllOptions', $_ )
        for qw( with_meta1 with_meta2 with_caller1 with_caller2 as_is1 );

    {
        my ( $caller, $arg1 ) = UseAllOptions::with_caller1(42);
        is( $caller, 'UseAllOptions', 'with_caller wrapped sub gets the right caller' );
        is( $arg1, 42, 'with_caller wrapped sub returns argument it was passed' );
    }

    {
        my ( $meta, $arg1 ) = UseAllOptions::with_meta1(42);
        isa_ok( $meta, 'Moose::Meta::Class', 'with_meta first argument' );
        is( $arg1, 42, 'with_meta1 returns argument it was passed' );
    }

    is(
        prototype( UseAllOptions->can('with_caller2') ),
        prototype( AllOptions->can('with_caller2') ),
        'using correct prototype on with_meta function'
    );

    is(
        prototype( UseAllOptions->can('with_meta2') ),
        prototype( AllOptions->can('with_meta2') ),
        'using correct prototype on with_meta function'
    );
}

{
    package UseAllOptions;
    AllOptions->unimport();
}

{
    ok( ! UseAllOptions->can($_), "UseAllOptions::$_ has been unimported" )
        for qw( with_meta1 with_meta2 with_caller1 with_caller2 as_is1 );
}

{
    package InitMetaError;
    use Moose::Exporter;
    use Moose ();
    Moose::Exporter->setup_import_methods(also => ['Moose']);
    sub init_meta {
        my $package = shift;
        my %options = @_;
        Moose->init_meta(%options, metaclass => 'Not::Loaded');
    }
}

{
    package InitMetaError::Role;
    use Moose::Exporter;
    use Moose::Role ();
    Moose::Exporter->setup_import_methods(also => ['Moose::Role']);
    sub init_meta {
        my $package = shift;
        my %options = @_;
        Moose::Role->init_meta(%options, metaclass => 'Not::Loaded');
    }
}

{
    package WantsInvalidMetaclass;
    ::like(
        ::exception { InitMetaError->import },
        qr/The Metaclass Not::Loaded must be loaded\. \(Perhaps you forgot to 'use Not::Loaded'\?\)/,
        "error when wanting a nonexistent metaclass"
    );
}

{
    package WantsInvalidMetaclass::Role;
    ::like(
        ::exception { InitMetaError::Role->import },
        qr/The Metaclass Not::Loaded must be loaded\. \(Perhaps you forgot to 'use Not::Loaded'\?\)/,
        "error when wanting a nonexistent metaclass"
    );
}

{
    my @init_metas_called;

    BEGIN {
        package MultiLevelExporter1;
        use Moose::Exporter;

        sub foo  { 1 }
        sub bar  { 1 }
        sub baz  { 1 }
        sub quux { 1 }

        Moose::Exporter->setup_import_methods(
            with_meta => [qw(foo bar baz quux)],
        );

        sub init_meta {
            push @init_metas_called, 1;
        }

        $INC{'MultiLevelExporter1.pm'} = __FILE__;
    }

    BEGIN {
        package MultiLevelExporter2;
        use Moose::Exporter;

        sub bar  { 2 }
        sub baz  { 2 }
        sub quux { 2 }

        Moose::Exporter->setup_import_methods(
            also      => ['MultiLevelExporter1'],
            with_meta => [qw(bar baz quux)],
        );

        sub init_meta {
            push @init_metas_called, 2;
        }

        $INC{'MultiLevelExporter2.pm'} = __FILE__;
    }

    BEGIN {
        package MultiLevelExporter3;
        use Moose::Exporter;

        sub baz  { 3 }
        sub quux { 3 }

        Moose::Exporter->setup_import_methods(
            also      => ['MultiLevelExporter2'],
            with_meta => [qw(baz quux)],
        );

        sub init_meta {
            push @init_metas_called, 3;
        }

        $INC{'MultiLevelExporter3.pm'} = __FILE__;
    }

    BEGIN {
        package MultiLevelExporter4;
        use Moose::Exporter;

        sub quux { 4 }

        Moose::Exporter->setup_import_methods(
            also      => ['MultiLevelExporter3'],
            with_meta => [qw(quux)],
        );

        sub init_meta {
            push @init_metas_called, 4;
        }

        $INC{'MultiLevelExporter4.pm'} = __FILE__;
    }

    BEGIN { @init_metas_called = () }
    {
        package UsesMulti1;
        use Moose;
        use MultiLevelExporter1;
        ::is(foo(), 1);
        ::is(bar(), 1);
        ::is(baz(), 1);
        ::is(quux(), 1);
    }
    use Data::Dumper;
    BEGIN { is_deeply(\@init_metas_called, [ 1 ]) || diag(Dumper(\@init_metas_called)) }

    BEGIN { @init_metas_called = () }
    {
        package UsesMulti2;
        use Moose;
        use MultiLevelExporter2;
        ::is(foo(), 1);
        ::is(bar(), 2);
        ::is(baz(), 2);
        ::is(quux(), 2);
    }
    BEGIN { is_deeply(\@init_metas_called, [ 2, 1 ]) || diag(Dumper(\@init_metas_called)) }

    BEGIN { @init_metas_called = () }
    {
        package UsesMulti3;
        use Moose;
        use MultiLevelExporter3;
        ::is(foo(), 1);
        ::is(bar(), 2);
        ::is(baz(), 3);
        ::is(quux(), 3);
    }
    BEGIN { is_deeply(\@init_metas_called, [ 3, 2, 1 ]) || diag(Dumper(\@init_metas_called)) }

    BEGIN { @init_metas_called = () }
    {
        package UsesMulti4;
        use Moose;
        use MultiLevelExporter4;
        ::is(foo(), 1);
        ::is(bar(), 2);
        ::is(baz(), 3);
        ::is(quux(), 4);
    }
    BEGIN { is_deeply(\@init_metas_called, [ 4, 3, 2, 1 ]) || diag(Dumper(\@init_metas_called)) }
}

# Using "also => [ 'MooseX::UsesAlsoMoose', 'MooseX::SomethingElse' ]" should
# continue to work. The init_meta order needs to be MooseX::CurrentExporter,
# MooseX::UsesAlsoMoose, Moose, MooseX::SomethingElse. This is a pretty ugly
# and messed up use case, but necessary until we come up with a better way to
# do it.

{
    my @init_metas_called;

    BEGIN {
        package AlsoTest::Role1;
        use Moose::Role;

        $INC{'AlsoTest/Role1.pm'} = __FILE__;
    }

    BEGIN {
        package AlsoTest1;
        use Moose::Exporter;

        Moose::Exporter->setup_import_methods(
            also => [ 'Moose' ],
        );

        sub init_meta {
            shift;
            my %opts = @_;
            ::ok(!Class::MOP::class_of($opts{for_class}));
            push @init_metas_called, 1;
        }

        $INC{'AlsoTest1.pm'} = __FILE__;
    }

    BEGIN {
        package AlsoTest2;
        use Moose::Exporter;
        use Moose::Util::MetaRole ();

        Moose::Exporter->setup_import_methods;

        sub init_meta {
            shift;
            my %opts = @_;
            ::ok(Class::MOP::class_of($opts{for_class}));
            Moose::Util::MetaRole::apply_metaroles(
                for => $opts{for_class},
                class_metaroles => {
                    class => ['AlsoTest::Role1'],
                },
            );
            push @init_metas_called, 2;
        }

        $INC{'AlsoTest2.pm'} = __FILE__;
    }

    BEGIN {
        package AlsoTest3;
        use Moose::Exporter;

        Moose::Exporter->setup_import_methods(
            also => [ 'AlsoTest1', 'AlsoTest2' ],
        );

        sub init_meta {
            shift;
            my %opts = @_;
            ::ok(!Class::MOP::class_of($opts{for_class}));
            push @init_metas_called, 3;
        }

        $INC{'AlsoTest3.pm'} = __FILE__;
    }

    BEGIN { @init_metas_called = () }
    {
        package UsesAlsoTest3;
        use AlsoTest3;
    }
    use Data::Dumper;
    BEGIN {
        is_deeply(\@init_metas_called, [ 3, 1, 2 ])
            || diag(Dumper(\@init_metas_called));
        isa_ok(Class::MOP::class_of('UsesAlsoTest3'), 'Moose::Meta::Class');
        does_ok(Class::MOP::class_of('UsesAlsoTest3'), 'AlsoTest::Role1');
    }

}

done_testing;
Commit	Line	Data
4403da90	1	#!/usr/bin/perl
	2
	3	use strict;
	4	use warnings;
	5
3d659f7f	6	use Test::More;
b10dde3a	7	use Test::Fatal;
ef2f720e	8	use Test::Moose;
b30e7781	9
4d438a84	10	use Test::Requires {
	11	'Test::Output' => '0.01', # skip all if not installed
	12	};
b30e7781	13
	14	{
	15	package HasOwnImmutable;
	16
	17	use Moose;
	18
	19	no Moose;
	20
8b23f9f8	21	::stderr_is( sub { eval q[sub make_immutable { return 'foo' }] },
b30e7781	22	'',
	23	'no warning when defining our own make_immutable sub' );
	24	}
	25
	26	{
	27	is( HasOwnImmutable->make_immutable(), 'foo',
	28	'HasOwnImmutable->make_immutable does not get overwritten' );
	29	}
2c9c8797	30
4403da90	31	{
	32	package MooseX::Empty;
	33
	34	use Moose ();
aedcb7d9	35	Moose::Exporter->setup_import_methods( also => 'Moose' );
4403da90	36	}
	37
	38	{
	39	package WantsMoose;
	40
2c9c8797	41	MooseX::Empty->import();
4403da90	42
	43	sub foo { 1 }
	44
2c9c8797	45	::can_ok( 'WantsMoose', 'has' );
	46	::can_ok( 'WantsMoose', 'with' );
	47	::can_ok( 'WantsMoose', 'foo' );
4403da90	48
2c9c8797	49	MooseX::Empty->unimport();
4403da90	50	}
	51
	52	{
2c9c8797	53	# Note: it's important that these methods be out of scope _now_,
	54	# after unimport was called. We tried a
	55	# namespace::clean(0.08)-based solution, but had to abandon it
	56	# because it cleans the namespace _later_ (when the file scope
	57	# ends).
4403da90	58	ok( ! WantsMoose->can('has'), 'WantsMoose::has() has been cleaned' );
	59	ok( ! WantsMoose->can('with'), 'WantsMoose::with() has been cleaned' );
	60	can_ok( 'WantsMoose', 'foo' );
42c391b1	61
	62	# This makes sure that Moose->init_meta() happens properly
	63	isa_ok( WantsMoose->meta(), 'Moose::Meta::Class' );
	64	isa_ok( WantsMoose->new(), 'Moose::Object' );
	65
4403da90	66	}
	67
	68	{
	69	package MooseX::Sugar;
	70
	71	use Moose ();
	72
	73	sub wrapped1 {
0661fc1a	74	my $meta = shift;
0661fc1a	75	return $meta->name . ' called wrapped1';
4403da90	76	}
4403da90	77
aedcb7d9	78	Moose::Exporter->setup_import_methods(
0661fc1a	79	with_meta => ['wrapped1'],
0661fc1a	80	also => 'Moose',
2c9c8797	81	);
4403da90	82	}
	83
	84	{
	85	package WantsSugar;
	86
2c9c8797	87	MooseX::Sugar->import();
4403da90	88
	89	sub foo { 1 }
	90
2c9c8797	91	::can_ok( 'WantsSugar', 'has' );
	92	::can_ok( 'WantsSugar', 'with' );
	93	::can_ok( 'WantsSugar', 'wrapped1' );
	94	::can_ok( 'WantsSugar', 'foo' );
	95	::is( wrapped1(), 'WantsSugar called wrapped1',
	96	'wrapped1 identifies the caller correctly' );
4403da90	97
2c9c8797	98	MooseX::Sugar->unimport();
4403da90	99	}
	100
	101	{
	102	ok( ! WantsSugar->can('has'), 'WantsSugar::has() has been cleaned' );
	103	ok( ! WantsSugar->can('with'), 'WantsSugar::with() has been cleaned' );
	104	ok( ! WantsSugar->can('wrapped1'), 'WantsSugar::wrapped1() has been cleaned' );
	105	can_ok( 'WantsSugar', 'foo' );
	106	}
	107
	108	{
	109	package MooseX::MoreSugar;
	110
	111	use Moose ();
	112
	113	sub wrapped2 {
3b400403	114	my $caller = shift->name;
4403da90	115	return $caller . ' called wrapped2';
	116	}
	117
	118	sub as_is1 {
	119	return 'as_is1';
	120	}
	121
aedcb7d9	122	Moose::Exporter->setup_import_methods(
3b400403	123	with_meta => ['wrapped2'],
	124	as_is => ['as_is1'],
	125	also => 'MooseX::Sugar',
2c9c8797	126	);
4403da90	127	}
	128
	129	{
	130	package WantsMoreSugar;
	131
2c9c8797	132	MooseX::MoreSugar->import();
4403da90	133
	134	sub foo { 1 }
	135
2c9c8797	136	::can_ok( 'WantsMoreSugar', 'has' );
	137	::can_ok( 'WantsMoreSugar', 'with' );
	138	::can_ok( 'WantsMoreSugar', 'wrapped1' );
	139	::can_ok( 'WantsMoreSugar', 'wrapped2' );
	140	::can_ok( 'WantsMoreSugar', 'as_is1' );
	141	::can_ok( 'WantsMoreSugar', 'foo' );
	142	::is( wrapped1(), 'WantsMoreSugar called wrapped1',
	143	'wrapped1 identifies the caller correctly' );
	144	::is( wrapped2(), 'WantsMoreSugar called wrapped2',
	145	'wrapped2 identifies the caller correctly' );
	146	::is( as_is1(), 'as_is1',
	147	'as_is1 works as expected' );
	148
	149	MooseX::MoreSugar->unimport();
4403da90	150	}
	151
	152	{
	153	ok( ! WantsMoreSugar->can('has'), 'WantsMoreSugar::has() has been cleaned' );
	154	ok( ! WantsMoreSugar->can('with'), 'WantsMoreSugar::with() has been cleaned' );
	155	ok( ! WantsMoreSugar->can('wrapped1'), 'WantsMoreSugar::wrapped1() has been cleaned' );
	156	ok( ! WantsMoreSugar->can('wrapped2'), 'WantsMoreSugar::wrapped2() has been cleaned' );
	157	ok( ! WantsMoreSugar->can('as_is1'), 'WantsMoreSugar::as_is1() has been cleaned' );
	158	can_ok( 'WantsMoreSugar', 'foo' );
	159	}
	160
	161	{
085fba61	162	package My::Metaclass;
	163	use Moose;
	164	BEGIN { extends 'Moose::Meta::Class' }
	165
	166	package My::Object;
	167	use Moose;
	168	BEGIN { extends 'Moose::Object' }
	169
	170	package HasInitMeta;
	171
	172	use Moose ();
	173
	174	sub init_meta {
	175	shift;
	176	return Moose->init_meta( @_,
	177	metaclass => 'My::Metaclass',
	178	base_class => 'My::Object',
	179	);
	180	}
	181
aedcb7d9	182	Moose::Exporter->setup_import_methods( also => 'Moose' );
085fba61	183	}
	184
	185	{
	186	package NewMeta;
	187
2c9c8797	188	HasInitMeta->import();
085fba61	189	}
	190
	191	{
	192	isa_ok( NewMeta->meta(), 'My::Metaclass' );
	193	isa_ok( NewMeta->new(), 'My::Object' );
	194	}
	195
	196	{
4403da90	197	package MooseX::CircularAlso;
	198
	199	use Moose ();
	200
b10dde3a	201	::like(
b10dde3a	202	::exception{ Moose::Exporter->setup_import_methods(
4403da90	203	also => [ 'Moose', 'MooseX::CircularAlso' ],
4403da90	204	);
b10dde3a	205	},
b822369d	206	qr/\QCircular reference in 'also' parameter to Moose::Exporter between MooseX::CircularAlso and MooseX::CircularAlso/,
b10dde3a	207	'a circular reference in also dies with an error'
4403da90	208	);
	209	}
	210
	211	{
ba1a3c2f	212	package MooseX::NoAlso;
4403da90	213
	214	use Moose ();
	215
4403da90	216	::like(
b10dde3a	217	::exception{ Moose::Exporter->setup_import_methods(
	218	also => ['NoSuchThing'],
	219	);
	220	},
ba1a3c2f	221	qr/\QPackage in also (NoSuchThing) does not seem to use Moose::Exporter (is it loaded?) at /,
b10dde3a	222	'a package which does not use Moose::Exporter in also dies with an error'
ba1a3c2f	223	);
	224	}
	225
	226	{
	227	package MooseX::NotExporter;
	228
	229	use Moose ();
	230
ba1a3c2f	231	::like(
b10dde3a	232	::exception{ Moose::Exporter->setup_import_methods(
	233	also => ['Moose::Meta::Method'],
	234	);
	235	},
ba1a3c2f	236	qr/\QPackage in also (Moose::Meta::Method) does not seem to use Moose::Exporter at /,
b10dde3a	237	'a package which does not use Moose::Exporter in also dies with an error'
4403da90	238	);
4403da90	239	}
ae8817b6	240
	241	{
	242	package MooseX::OverridingSugar;
	243
	244	use Moose ();
	245
	246	sub has {
3b400403	247	my $caller = shift->name;
ae8817b6	248	return $caller . ' called has';
	249	}
	250
	251	Moose::Exporter->setup_import_methods(
3b400403	252	with_meta => ['has'],
3b400403	253	also => 'Moose',
ae8817b6	254	);
	255	}
	256
	257	{
	258	package WantsOverridingSugar;
	259
	260	MooseX::OverridingSugar->import();
	261
	262	::can_ok( 'WantsOverridingSugar', 'has' );
	263	::can_ok( 'WantsOverridingSugar', 'with' );
	264	::is( has('foo'), 'WantsOverridingSugar called has',
	265	'has from MooseX::OverridingSugar is called, not has from Moose' );
	266
	267	MooseX::OverridingSugar->unimport();
	268	}
	269
	270	{
f7d62c2e	271	ok( ! WantsOverridingSugar->can('has'), 'WantsSugar::has() has been cleaned' );
	272	ok( ! WantsOverridingSugar->can('with'), 'WantsSugar::with() has been cleaned' );
	273	}
	274
	275	{
	276	package MooseX::OverridingSugar::PassThru;
064a13a3	277
f7d62c2e	278	sub with {
	279	my $caller = shift->name;
	280	return $caller . ' called with';
	281	}
064a13a3	282
f7d62c2e	283	Moose::Exporter->setup_import_methods(
	284	with_meta => ['with'],
	285	also => 'MooseX::OverridingSugar',
	286	);
f7d62c2e	287	}
	288
	289	{
	290
	291	package WantsOverridingSugar::PassThru;
	292
	293	MooseX::OverridingSugar::PassThru->import();
	294
	295	::can_ok( 'WantsOverridingSugar::PassThru', 'has' );
	296	::can_ok( 'WantsOverridingSugar::PassThru', 'with' );
	297	::is(
	298	has('foo'),
	299	'WantsOverridingSugar::PassThru called has',
	300	'has from MooseX::OverridingSugar is called, not has from Moose'
	301	);
	302
	303	::is(
	304	with('foo'),
	305	'WantsOverridingSugar::PassThru called with',
	306	'with from MooseX::OverridingSugar::PassThru is called, not has from Moose'
	307	);
	308
	309
	310	MooseX::OverridingSugar::PassThru->unimport();
	311	}
	312
	313	{
	314	ok( ! WantsOverridingSugar::PassThru->can('has'), 'WantsOverridingSugar::PassThru::has() has been cleaned' );
	315	ok( ! WantsOverridingSugar::PassThru->can('with'), 'WantsOverridingSugar::PassThru::with() has been cleaned' );
ae8817b6	316	}
ae8817b6	317
e6a5040f	318	{
f7d62c2e	319
e6a5040f	320	package NonExistentExport;
	321
	322	use Moose ();
	323
	324	::stderr_like {
	325	Moose::Exporter->setup_import_methods(
	326	also => ['Moose'],
3b400403	327	with_meta => ['does_not_exist'],
e6a5040f	328	);
	329	} qr/^Trying to export undefined sub NonExistentExport::does_not_exist/,
	330	"warns when a non-existent method is requested to be exported";
	331	}
	332
	333	{
	334	package WantsNonExistentExport;
	335
	336	NonExistentExport->import;
	337
	338	::ok(!__PACKAGE__->can('does_not_exist'),
	339	"undefined subs do not get exported");
a584a0c8	340	}
addd05f6	341
a584a0c8	342	{
0661fc1a	343	package AllOptions;
0661fc1a	344	use Moose ();
3b400403	345	use Moose::Deprecated -api_version => '0.88';
0661fc1a	346	use Moose::Exporter;
	347
	348	Moose::Exporter->setup_import_methods(
	349	also => ['Moose'],
	350	with_meta => [ 'with_meta1', 'with_meta2' ],
	351	with_caller => [ 'with_caller1', 'with_caller2' ],
	352	as_is => ['as_is1'],
	353	);
	354
	355	sub with_caller1 {
	356	return @_;
	357	}
	358
	359	sub with_caller2 (&) {
	360	return @_;
	361	}
	362
	363	sub as_is1 {2}
	364
	365	sub with_meta1 {
	366	return @_;
	367	}
	368
	369	sub with_meta2 (&) {
	370	return @_;
	371	}
	372	}
	373
	374	{
	375	package UseAllOptions;
	376
	377	AllOptions->import();
	378	}
	379
	380	{
	381	can_ok( 'UseAllOptions', $_ )
	382	for qw( with_meta1 with_meta2 with_caller1 with_caller2 as_is1 );
	383
	384	{
	385	my ( $caller, $arg1 ) = UseAllOptions::with_caller1(42);
	386	is( $caller, 'UseAllOptions', 'with_caller wrapped sub gets the right caller' );
	387	is( $arg1, 42, 'with_caller wrapped sub returns argument it was passed' );
	388	}
	389
	390	{
	391	my ( $meta, $arg1 ) = UseAllOptions::with_meta1(42);
	392	isa_ok( $meta, 'Moose::Meta::Class', 'with_meta first argument' );
	393	is( $arg1, 42, 'with_meta1 returns argument it was passed' );
	394	}
	395
	396	is(
5a204c51	397	prototype( UseAllOptions->can('with_caller2') ),
	398	prototype( AllOptions->can('with_caller2') ),
	399	'using correct prototype on with_meta function'
	400	);
	401
	402	is(
0661fc1a	403	prototype( UseAllOptions->can('with_meta2') ),
	404	prototype( AllOptions->can('with_meta2') ),
	405	'using correct prototype on with_meta function'
	406	);
a584a0c8	407	}
0661fc1a	408
a584a0c8	409	{
	410	package UseAllOptions;
	411	AllOptions->unimport();
	412	}
0661fc1a	413
a584a0c8	414	{
0661fc1a	415	ok( ! UseAllOptions->can($_), "UseAllOptions::$_ has been unimported" )
0661fc1a	416	for qw( with_meta1 with_meta2 with_caller1 with_caller2 as_is1 );
e6a5040f	417	}
a28e50e4	418
360e6512	419	{
	420	package InitMetaError;
	421	use Moose::Exporter;
	422	use Moose ();
	423	Moose::Exporter->setup_import_methods(also => ['Moose']);
	424	sub init_meta {
	425	my $package = shift;
	426	my %options = @_;
	427	Moose->init_meta(%options, metaclass => 'Not::Loaded');
	428	}
	429	}
	430
	431	{
	432	package InitMetaError::Role;
	433	use Moose::Exporter;
	434	use Moose::Role ();
	435	Moose::Exporter->setup_import_methods(also => ['Moose::Role']);
	436	sub init_meta {
	437	my $package = shift;
	438	my %options = @_;
	439	Moose::Role->init_meta(%options, metaclass => 'Not::Loaded');
	440	}
	441	}
	442
	443	{
	444	package WantsInvalidMetaclass;
	445	::like(
	446	::exception { InitMetaError->import },
	447	qr/The Metaclass Not::Loaded must be loaded\. \(Perhaps you forgot to 'use Not::Loaded'\?\)/,
	448	"error when wanting a nonexistent metaclass"
	449	);
	450	}
	451
	452	{
	453	package WantsInvalidMetaclass::Role;
	454	::like(
	455	::exception { InitMetaError::Role->import },
	456	qr/The Metaclass Not::Loaded must be loaded\. \(Perhaps you forgot to 'use Not::Loaded'\?\)/,
	457	"error when wanting a nonexistent metaclass"
	458	);
	459	}
	460
54e41ffd	461	{
	462	my @init_metas_called;
	463
	464	BEGIN {
	465	package MultiLevelExporter1;
	466	use Moose::Exporter;
	467
	468	sub foo { 1 }
	469	sub bar { 1 }
	470	sub baz { 1 }
	471	sub quux { 1 }
	472
	473	Moose::Exporter->setup_import_methods(
	474	with_meta => [qw(foo bar baz quux)],
	475	);
	476
	477	sub init_meta {
	478	push @init_metas_called, 1;
	479	}
	480
	481	$INC{'MultiLevelExporter1.pm'} = __FILE__;
	482	}
	483
	484	BEGIN {
	485	package MultiLevelExporter2;
	486	use Moose::Exporter;
	487
	488	sub bar { 2 }
	489	sub baz { 2 }
	490	sub quux { 2 }
	491
	492	Moose::Exporter->setup_import_methods(
	493	also => ['MultiLevelExporter1'],
	494	with_meta => [qw(bar baz quux)],
	495	);
	496
	497	sub init_meta {
	498	push @init_metas_called, 2;
	499	}
	500
	501	$INC{'MultiLevelExporter2.pm'} = __FILE__;
	502	}
	503
	504	BEGIN {
	505	package MultiLevelExporter3;
	506	use Moose::Exporter;
	507
	508	sub baz { 3 }
	509	sub quux { 3 }
	510
	511	Moose::Exporter->setup_import_methods(
	512	also => ['MultiLevelExporter2'],
	513	with_meta => [qw(baz quux)],
	514	);
	515
	516	sub init_meta {
	517	push @init_metas_called, 3;
	518	}
	519
	520	$INC{'MultiLevelExporter3.pm'} = __FILE__;
	521	}
	522
	523	BEGIN {
	524	package MultiLevelExporter4;
525	use Moose::Exporter;
526
527	sub quux { 4 }
528
529	Moose::Exporter->setup_import_methods(
530	also => ['MultiLevelExporter3'],
531	with_meta => [qw(quux)],
532	);
533
534	sub init_meta {
535	push @init_metas_called, 4;
536	}
537
538	$INC{'MultiLevelExporter4.pm'} = __FILE__;
539	}
540
541	BEGIN { @init_metas_called = () }
542	{
543	package UsesMulti1;
544	use Moose;
545	use MultiLevelExporter1;
546	::is(foo(), 1);
547	::is(bar(), 1);
548	::is(baz(), 1);
549	::is(quux(), 1);
550	}
551	use Data::Dumper;
552	BEGIN { is_deeply(\@init_metas_called, [ 1 ]) \|\| diag(Dumper(\@init_metas_called)) }
553
554	BEGIN { @init_metas_called = () }
555	{
556	package UsesMulti2;
557	use Moose;
558	use MultiLevelExporter2;
559	::is(foo(), 1);
560	::is(bar(), 2);
561	::is(baz(), 2);
562	::is(quux(), 2);
563	}
564	BEGIN { is_deeply(\@init_metas_called, [ 2, 1 ]) \|\| diag(Dumper(\@init_metas_called)) }
565
566	BEGIN { @init_metas_called = () }
567	{
568	package UsesMulti3;
569	use Moose;
570	use MultiLevelExporter3;
571	::is(foo(), 1);
572	::is(bar(), 2);
573	::is(baz(), 3);
574	::is(quux(), 3);
575	}
576	BEGIN { is_deeply(\@init_metas_called, [ 3, 2, 1 ]) \|\| diag(Dumper(\@init_metas_called)) }
577
578	BEGIN { @init_metas_called = () }
579	{
580	package UsesMulti4;
581	use Moose;
582	use MultiLevelExporter4;
583	::is(foo(), 1);
584	::is(bar(), 2);
585	::is(baz(), 3);
586	::is(quux(), 4);
587	}
588	BEGIN { is_deeply(\@init_metas_called, [ 4, 3, 2, 1 ]) \|\| diag(Dumper(\@init_metas_called)) }
589	}
590
ef2f720e	591	# Using "also => [ 'MooseX::UsesAlsoMoose', 'MooseX::SomethingElse' ]" should
	592	# continue to work. The init_meta order needs to be MooseX::CurrentExporter,
	593	# MooseX::UsesAlsoMoose, Moose, MooseX::SomethingElse. This is a pretty ugly
	594	# and messed up use case, but necessary until we come up with a better way to
	595	# do it.
	596
	597	{
	598	my @init_metas_called;
	599
	600	BEGIN {
	601	package AlsoTest::Role1;
	602	use Moose::Role;
	603
	604	$INC{'AlsoTest/Role1.pm'} = __FILE__;
	605	}
	606
	607	BEGIN {
	608	package AlsoTest1;
	609	use Moose::Exporter;
	610
	611	Moose::Exporter->setup_import_methods(
	612	also => [ 'Moose' ],
	613	);
	614
	615	sub init_meta {
	616	shift;
	617	my %opts = @_;
	618	::ok(!Class::MOP::class_of($opts{for_class}));
	619	push @init_metas_called, 1;
	620	}
	621
	622	$INC{'AlsoTest1.pm'} = __FILE__;
	623	}
	624
	625	BEGIN {
	626	package AlsoTest2;
	627	use Moose::Exporter;
	628	use Moose::Util::MetaRole ();
	629
	630	Moose::Exporter->setup_import_methods;
	631
	632	sub init_meta {
	633	shift;
	634	my %opts = @_;
	635	::ok(Class::MOP::class_of($opts{for_class}));
	636	Moose::Util::MetaRole::apply_metaroles(
	637	for => $opts{for_class},
	638	class_metaroles => {
	639	class => ['AlsoTest::Role1'],
	640	},
	641	);
	642	push @init_metas_called, 2;
	643	}
	644
	645	$INC{'AlsoTest2.pm'} = __FILE__;
	646	}
	647
	648	BEGIN {
	649	package AlsoTest3;
	650	use Moose::Exporter;
	651
	652	Moose::Exporter->setup_import_methods(
	653	also => [ 'AlsoTest1', 'AlsoTest2' ],
	654	);
655
656	sub init_meta {
657	shift;
658	my %opts = @_;
659	::ok(!Class::MOP::class_of($opts{for_class}));
660	push @init_metas_called, 3;
661	}
662
663	$INC{'AlsoTest3.pm'} = __FILE__;
664	}
665
666	BEGIN { @init_metas_called = () }
667	{
668	package UsesAlsoTest3;
669	use AlsoTest3;
670	}
671	use Data::Dumper;
672	BEGIN {
673	is_deeply(\@init_metas_called, [ 3, 1, 2 ])
674	\|\| diag(Dumper(\@init_metas_called));
675	isa_ok(Class::MOP::class_of('UsesAlsoTest3'), 'Moose::Meta::Class');
676	does_ok(Class::MOP::class_of('UsesAlsoTest3'), 'AlsoTest::Role1');
677	}
678
679	}
680
a28e50e4	681	done_testing;