revert local $\@ around require to avoid eating errors

[gitmo/Moo.git] / lib / Moo.pm

diff --git a/lib/Moo.pm b/lib/Moo.pm
index c146af8..aea43e1 100644 (file)
--- a/lib/Moo.pm
+++ b/lib/Moo.pm
@@ -4,7 +4,7 @@ use strictures 1;
 use Moo::_Utils;
 use B 'perlstring';
 
-our $VERSION = '0.009012'; # 0.9.12
+our $VERSION = '0.009013'; # 0.9.13
 $VERSION = eval $VERSION;
 
 our %MAKERS;
@@ -20,7 +20,7 @@ sub import {
     @{*{_getglob("${target}::ISA")}{ARRAY}} = @_;
   };
   *{_getglob("${target}::with")} = sub {
-    { local $@; require Moo::Role; }
+    require Moo::Role;
     die "Only one role supported at a time by with" if @_ > 1;
     Moo::Role->apply_role_to_package($target, $_[0]);
   };
@@ -28,7 +28,7 @@ sub import {
   *{_getglob("${target}::has")} = sub {
     my ($name, %spec) = @_;
     ($MAKERS{$target}{accessor} ||= do {
-      { local $@; require Method::Generate::Accessor; }
+      require Method::Generate::Accessor;
       Method::Generate::Accessor->new
     })->generate_method($target, $name, \%spec);
     $class->_constructor_maker_for($target)
@@ -36,14 +36,14 @@ sub import {
   };
   foreach my $type (qw(before after around)) {
     *{_getglob "${target}::${type}"} = sub {
-      { local $@; require Class::Method::Modifiers; }
+      require Class::Method::Modifiers;
       _install_modifier($target, $type, @_);
     };
   }
   {
     no strict 'refs';
     @{"${target}::ISA"} = do {
-      {; local $@; require Moo::Object; } ('Moo::Object');
+      require Moo::Object; ('Moo::Object');
     } unless @{"${target}::ISA"};
   }
 }
@@ -52,11 +52,8 @@ sub _constructor_maker_for {
   my ($class, $target, $select_super) = @_;
   return unless $MAKERS{$target};
   $MAKERS{$target}{constructor} ||= do {
-    {
-      local $@;
-      require Method::Generate::Constructor;
-      require Sub::Defer;
-    }
+    require Method::Generate::Constructor;
+    require Sub::Defer;
     my ($moo_constructor, $con);
 
     if ($select_super && $MAKERS{$select_super}) {
@@ -82,7 +79,7 @@ sub _constructor_maker_for {
       ->new(
         package => $target,
         accessor_generator => do {
-          { local $@; require Method::Generate::Accessor; }
+          require Method::Generate::Accessor;
           Method::Generate::Accessor->new;
         },
         construction_string => (
@@ -214,14 +211,14 @@ passed to the constructor.
 
 This method should always return a hash reference of named options.
 
-=head2 BUILDALL
+=head2 BUILD
 
-Don't override (or probably even call) this method.  Instead, you can define
-a C<BUILD> method on your class and the constructor will automatically call the
-C<BUILD> method from parent down to child after the object has been
-instantiated.  Typically this is used for object validation or possibly logging.
+Define a C<BUILD> method on your class and the constructor will automatically
+call the C<BUILD> method from parent down to child after the object has
+been instantiated.  Typically this is used for object validation or possibly
+logging.
 
-=head2 DESTROY
+=head2 DEMOLISH
 
 If you have a C<DEMOLISH> method anywhere in your inheritance hierarchy,
 a C<DESTROY> method is created on first object construction which will call
@@ -303,6 +300,25 @@ Coerce does not require C<isa> to be defined.
 
 L<Sub::Quote aware|/SUB QUOTE AWARE>
 
+=item * handles
+
+Takes a string
+
+  handles => 'RobotRole'
+
+Where C<RobotRole> is a role (L<Moo::Role>) that defines an interface which
+becomes the list of methods to handle.
+
+Takes a list of methods
+
+ handles => [ qw( one two ) ]
+
+Takes a hashref
+
+ handles => {
+   un => 'one',
+ }
+
 =item * trigger
 
 Takes a coderef which will get called any time the attribute is set. Coderef
@@ -441,6 +457,27 @@ C<auto_deref> is not supported since the author considers it a bad idea.
 
 C<documentation> is not supported since it's a very poor replacement for POD.
 
+Handling of warnings: when you C<use Moo> we enable FATAL warnings.  The nearest
+similar invocation for L<Moose> would be:
+
+  use Moose;
+  use warnings FATAL => "all";
+
+Additionally, L<Moo> supports a set of attribute option shortcuts intended to
+reduce common boilerplate.  The set of shortcuts is the same as in the L<Moose>
+module L<MooseX::AttributeShortcuts>.  So if you:
+
+    package MyClass;
+    use Moo;
+
+The nearest L<Moose> invocation would be:
+
+    package MyClass;
+
+    use Moose;
+    use warnings FATAL => "all";
+    use MooseX::AttributeShortcuts;
+
 =head1 AUTHOR
 
 mst - Matt S. Trout (cpan:MSTROUT) <mst@shadowcat.co.uk>