+package Moose::Cookbook::Extending::Recipe3;
+
+# ABSTRACT: Providing an alternate base object class
+
+__END__
+
=pod
-=head1 NAME
+=begin testing-SETUP
-Moose::Cookbook::Extending::Recipe1 - Providing an alternate base object class
+use Test::Requires {
+ 'Test::Output' => '0',
+};
+
+=end testing-SETUP
=head1 SYNOPSIS
sub init_meta {
shift;
- Moose->init_meta( @_, base_class => 'MyApp::Object' );
+ return Moose->init_meta( @_, base_class => 'MyApp::Base' );
}
=head1 DESCRIPTION
-Often you find that you want to share some behavior between all your
-classes. One way to do that is to make a base class and simply add
-C<S<extends 'MyApp::Base'>> to every class in your
-application. However, that can get tedious. Instead, you can simply
-create your Moose-alike module that sets the base object class to
-C<MyApp::Base> for you.
+A common extension is to provide an alternate base class. One way to
+do that is to make a C<MyApp::Base> and add C<S<extends
+'MyApp::Base'>> to every class in your application. That's pretty
+tedious. Instead, you can create a Moose-alike module that sets the
+base object class to C<MyApp::Base> for you.
Then, instead of writing C<S<use Moose>> you can write C<S<use
MyApp::UseMyBase>>.
In this particular example, our base class issues some debugging
-output every time a new object is created, but you can surely think of
-some more interesting things to do with your own base class.
+output every time a new object is created, but you can think of some
+more interesting things to do with your own base class.
-This all works because of the magic of L<Moose::Exporter>. When we
-call C<< Moose::Exporter->setup_import_methods( also => 'Moose' ) >>
-it builds an C<import> and C<unimport> method for you. The C<< also =>
-'Moose' >> bit says that we want to export everything that Moose does.
+This uses the magic of L<Moose::Exporter>. When we call C<<
+Moose::Exporter->setup_import_methods( also => 'Moose' ) >> it builds
+C<import> and C<unimport> methods for you. The C<< also => 'Moose' >>
+bit says that we want to export everything that Moose does.
The C<import> method that gets created will call our C<init_meta>
-method, passing it C<< for_caller => $caller >> as its arguments. The
-C<$caller> is set to the class that actually imported us in the first
-place.
+method, passing it C<< for_caller => $caller >> as its
+arguments. The C<$caller> is set to the class that actually imported
+us in the first place.
See the L<Moose::Exporter> docs for more details on its API.
no MyApp::UseMyBase;
-=head1 AUTHOR
+=head1 CONCLUSION
+
+This is an awful lot of magic for a simple base class. You will often
+want to combine a metaclass trait with a base class extension, and
+that's when this technique is useful.
+
+=begin testing
+
+{
+ package Foo;
+
+ MyApp::UseMyBase->import;
+
+ has( 'size' => ( is => 'rw' ) );
+}
-Dave Rolsky E<lt>autarch@urth.orgE<gt>
+ok( Foo->isa('MyApp::Base'), 'Foo isa MyApp::Base' );
-=head1 COPYRIGHT AND LICENSE
+ok( Foo->can('size'), 'Foo has a size method' );
-Copyright 2006-2008 by Infinity Interactive, Inc.
+my $foo;
+stderr_like(
+ sub { $foo = Foo->new( size => 2 ) },
+ qr/^Making a new Foo/,
+ 'got expected warning when calling Foo->new'
+);
-L<http://www.iinteractive.com>
+is( $foo->size(), 2, '$foo->size is 2' );
-This library is free software; you can redistribute it and/or modify
-it under the same terms as Perl itself.
+=end testing
=cut