allow single-value enums

[gitmo/Moose.git] / lib / Moose / Cookbook / Extending / Recipe3.pod

diff --git a/lib/Moose/Cookbook/Extending/Recipe3.pod b/lib/Moose/Cookbook/Extending/Recipe3.pod
index 3abe740..ea75547 100644 (file)
--- a/lib/Moose/Cookbook/Extending/Recipe3.pod
+++ b/lib/Moose/Cookbook/Extending/Recipe3.pod
@@ -1,9 +1,19 @@
+package Moose::Cookbook::Extending::Recipe3;
+
+# ABSTRACT: Providing an alternate base object class
+
+__END__
+
 
 =pod
 
-=head1 NAME
+=begin testing-SETUP
 
-Moose::Cookbook::Extending::Recipe3 - Providing an alternate base object class
+use Test::Requires {
+    'Test::Output' => '0',
+};
+
+=end testing-SETUP
 
 =head1 SYNOPSIS
 
@@ -24,34 +34,33 @@ Moose::Cookbook::Extending::Recipe3 - Providing an alternate base object class
 
   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.
 
@@ -69,17 +78,35 @@ class.
 
   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