lib/Moo.pm

   1 package Moo;
   2
   3 use strictures 1;
   4 use Moo::_Utils;
   5 use B 'perlstring';
   6 use Sub::Defer ();
   7
   8 our $VERSION = '0.091014'; # 0.91.14
   9 $VERSION = eval $VERSION;
  10
  11 require Moo::sification;
  12
  13 our %MAKERS;
  14
  15 sub _install_tracked {
  16   my ($target, $name, $code) = @_;
  17   $MAKERS{$target}{exports}{$name} = $code;
  18   _install_coderef "${target}::${name}" => "Moo::${name}" => $code;
  19 }
  20
  21 sub import {
  22   my $target = caller;
  23   my $class = shift;
  24   strictures->import;
  25   return if $MAKERS{$target}; # already exported into this package
  26   $MAKERS{$target} = {};
  27   _install_tracked $target => extends => sub {
  28     $class->_set_superclasses($target, @_);
  29     $class->_maybe_reset_handlemoose($target);
  30     return;
  31   };
  32   _install_tracked $target => with => sub {
  33     require Moo::Role;
  34     Moo::Role->apply_roles_to_package($target, @_);
  35     $class->_maybe_reset_handlemoose($target);
  36   };
  37   _install_tracked $target => has => sub {
  38     my ($name, %spec) = @_;
  39     $class->_constructor_maker_for($target)
  40           ->register_attribute_specs($name, \%spec);
  41     $class->_accessor_maker_for($target)
  42           ->generate_method($target, $name, \%spec);
  43     $class->_maybe_reset_handlemoose($target);
  44     return;
  45   };
  46   foreach my $type (qw(before after around)) {
  47     _install_tracked $target => $type => sub {
  48       require Class::Method::Modifiers;
  49       _install_modifier($target, $type, @_);
  50       return;
  51     };
  52   }
  53   {
  54     no strict 'refs';
  55     @{"${target}::ISA"} = do {
  56       require Moo::Object; ('Moo::Object');
  57     } unless @{"${target}::ISA"};
  58   }
  59   if ($INC{'Moo/HandleMoose.pm'}) {
  60     Moo::HandleMoose::inject_fake_metaclass_for($target);
  61   }
  62 }
  63
  64 sub unimport {
  65   my $target = caller;
  66   _unimport_coderefs($target, $MAKERS{$target});
  67 }
  68
  69 sub _set_superclasses {
  70   my $class = shift;
  71   my $target = shift;
  72   for (@_) {
  73     _load_module($_);
  74     if ($INC{"Role/Tiny.pm"} && $Role::Tiny::INFO{$_}) {
  75       require Carp;
  76       Carp::croak("Can't extend role '$_'");
  77     }
  78   }
  79   # Can't do *{...} = \@_ or 5.10.0's mro.pm stops seeing @ISA
  80   @{*{_getglob("${target}::ISA")}{ARRAY}} = @_;
  81   if (my $old = delete $Moo::MAKERS{$target}{constructor}) {
  82     delete _getstash($target)->{new};
  83     Moo->_constructor_maker_for($target)
  84        ->register_attribute_specs(%{$old->all_attribute_specs});
  85   }
  86   no warnings 'once'; # piss off. -- mst
  87   $Moo::HandleMoose::MOUSE{$target} = [
  88     grep defined, map Mouse::Util::find_meta($_), @_
  89   ] if $INC{"Mouse.pm"};
  90 }
  91
  92 sub _maybe_reset_handlemoose {
  93   my ($class, $target) = @_;
  94   if ($INC{"Moo/HandleMoose.pm"}) {
  95     Moo::HandleMoose::maybe_reinject_fake_metaclass_for($target);
  96   }
  97 }
  98
  99 sub _accessor_maker_for {
 100   my ($class, $target) = @_;
 101   return unless $MAKERS{$target};
 102   $MAKERS{$target}{accessor} ||= do {
 103     my $maker_class = do {
 104       if (my $m = do {
 105             if (my $defer_target =
 106                   (Sub::Defer::defer_info($target->can('new'))||[])->[0]
 107               ) {
 108               my ($pkg) = ($defer_target =~ /^(.*)::[^:]+$/);
 109               $MAKERS{$pkg} && $MAKERS{$pkg}{accessor};
 110             } else {
 111               undef;
 112             }
 113           }) {
 114         ref($m);
 115       } else {
 116         require Method::Generate::Accessor;
 117         'Method::Generate::Accessor'
 118       }
 119     };
 120     $maker_class->new;
 121   }
 122 }
 123
 124 sub _constructor_maker_for {
 125   my ($class, $target, $select_super) = @_;
 126   return unless $MAKERS{$target};
 127   $MAKERS{$target}{constructor} ||= do {
 128     require Method::Generate::Constructor;
 129     require Sub::Defer;
 130     my ($moo_constructor, $con);
 131
 132     if ($select_super && $MAKERS{$select_super}) {
 133       $moo_constructor = 1;
 134       $con = $MAKERS{$select_super}{constructor};
 135     } else {
 136       my $t_new = $target->can('new');
 137       if ($t_new) {
 138         if ($t_new == Moo::Object->can('new')) {
 139           $moo_constructor = 1;
 140         } elsif (my $defer_target = (Sub::Defer::defer_info($t_new)||[])->[0]) {
 141           my ($pkg) = ($defer_target =~ /^(.*)::[^:]+$/);
 142           if ($MAKERS{$pkg}) {
 143             $moo_constructor = 1;
 144             $con = $MAKERS{$pkg}{constructor};
 145           }
 146         }
 147       } else {
 148         $moo_constructor = 1; # no other constructor, make a Moo one
 149       }
 150     };
 151     ($con ? ref($con) : 'Method::Generate::Constructor')
 152       ->new(
 153         package => $target,
 154         accessor_generator => $class->_accessor_maker_for($target),
 155         construction_string => (
 156           $moo_constructor
 157             ? ($con ? $con->construction_string : undef)
 158             : ('$class->'.$target.'::SUPER::new(@_)')
 159         ),
 160         subconstructor_handler => (
 161           '      if ($Moo::MAKERS{$class}) {'."\n"
 162           .'        '.$class.'->_constructor_maker_for($class,'.perlstring($target).');'."\n"
 163           .'        return $class->new(@_)'.";\n"
 164           .'      } elsif ($INC{"Moose.pm"} and my $meta = Class::MOP::get_metaclass_by_name($class)) {'."\n"
 165           .'        return $meta->new_object(@_);'."\n"
 166           .'      }'."\n"
 167         ),
 168       )
 169       ->install_delayed
 170       ->register_attribute_specs(%{$con?$con->all_attribute_specs:{}})
 171   }
 172 }
 173
 174 1;
 175 =pod
 176
 177 =encoding utf-8
 178
 179 =head1 NAME
 180
 181 Moo - Minimalist Object Orientation (with Moose compatiblity)
 182
 183 =head1 SYNOPSIS
 184
 185  package Cat::Food;
 186
 187  use Moo;
 188  use Sub::Quote;
 189
 190  sub feed_lion {
 191    my $self = shift;
 192    my $amount = shift || 1;
 193
 194    $self->pounds( $self->pounds - $amount );
 195  }
 196
 197  has taste => (
 198    is => 'ro',
 199  );
 200
 201  has brand => (
 202    is  => 'ro',
 203    isa => sub {
 204      die "Only SWEET-TREATZ supported!" unless $_[0] eq 'SWEET-TREATZ'
 205    },
 206 );
 207
 208  has pounds => (
 209    is  => 'rw',
 210    isa => quote_sub q{ die "$_[0] is too much cat food!" unless $_[0] < 15 },
 211  );
 212
 213  1;
 214
 215 and else where
 216
 217  my $full = Cat::Food->new(
 218     taste  => 'DELICIOUS.',
 219     brand  => 'SWEET-TREATZ',
 220     pounds => 10,
 221  );
 222
 223  $full->feed_lion;
 224
 225  say $full->pounds;
 226
 227 =head1 DESCRIPTION
 228
 229 This module is an extremely light-weight, high-performance L<Moose> replacement.
 230 It also avoids depending on any XS modules to allow simple deployments.  The
 231 name C<Moo> is based on the idea that it provides almost -but not quite- two
 232 thirds of L<Moose>.
 233
 234 Unlike C<Mouse> this module does not aim at full L<Moose> compatibility.  See
 235 L</INCOMPATIBILITIES> for more details.
 236
 237 =head1 WHY MOO EXISTS
 238
 239 If you want a full object system with a rich Metaprotocol, L<Moose> is
 240 already wonderful.
 241
 242 I've tried several times to use L<Mouse> but it's 3x the size of Moo and
 243 takes longer to load than most of my Moo based CGI scripts take to run.
 244
 245 If you don't want L<Moose>, you don't want "less metaprotocol" like L<Mouse>,
 246 you want "as little as possible" - which means "no metaprotocol", which is
 247 what Moo provides.
 248
 249 By Moo 1.0 I intend to have Moo's equivalent of L<Any::Moose> built in -
 250 if Moose gets loaded, any Moo class or role will act as a Moose equivalent
 251 if treated as such.
 252
 253 Hence - Moo exists as its name - Minimal Object Orientation - with a pledge
 254 to make it smooth to upgrade to L<Moose> when you need more than minimal
 255 features.
 256
 257 =head1 Moo and Moose
 258
 259 If L<Moo> detects L<Moose> being loaded, it will automatically register
 260 metaclasses for your L<Moo> and L<Moo::Role> packages, so you should be able
 261 to use them in L<Moose> code without anybody ever noticing you aren't using
 262 L<Moose> everywhere.
 263
 264 Extending a L<Moose> class or consuming a L<Moose::Role> will also work.
 265
 266 So will extending a L<Mouse> class or consuming a L<Mouse::Role> - but note
 267 that we don't provide L<Mouse> metaclasses or metaroles so the other way
 268 around doesn't work. This feature exists for L<Any::Moose> users porting to
 269 L<Moo>, enabling L<Mouse> users to use L<Moo> classes is not a priority for us.
 270
 271 This means that there is no need for anything like L<Any::Moose> for Moo
 272 code - Moo and Moose code should simply interoperate without problem. To
 273 handle L<Mouse> code, you'll likely need an empty Moo role or class consuming
 274 or extending the L<Mouse> stuff since it doesn't register true L<Moose>
 275 metaclasses like we do.
 276
 277 If you need to disable the metaclass creation, add:
 278
 279   no Moo::sification;
 280
 281 to your code before Moose is loaded, but bear in mind that this switch is
 282 currently global and turns the mechanism off entirely so don't put this
 283 in library code.
 284
 285 =head1 IMPORTED METHODS
 286
 287 =head2 new
 288
 289  Foo::Bar->new( attr1 => 3 );
 290
 291 or
 292
 293  Foo::Bar->new({ attr1 => 3 });
 294
 295 =head2 BUILDARGS
 296
 297  sub BUILDARGS {
 298    my ( $class, @args ) = @_;
 299
 300    unshift @args, "attr1" if @args % 2 == 1;
 301
 302    return { @args };
 303  };
 304
 305  Foo::Bar->new( 3 );
 306
 307 The default implementation of this method accepts a hash or hash reference of
 308 named parameters. If it receives a single argument that isn't a hash reference
 309 it throws an error.
 310
 311 You can override this method in your class to handle other types of options
 312 passed to the constructor.
 313
 314 This method should always return a hash reference of named options.
 315
 316 =head2 BUILD
 317
 318 Define a C<BUILD> method on your class and the constructor will automatically
 319 call the C<BUILD> method from parent down to child after the object has
 320 been instantiated.  Typically this is used for object validation or possibly
 321 logging.
 322
 323 =head2 DEMOLISH
 324
 325 If you have a C<DEMOLISH> method anywhere in your inheritance hierarchy,
 326 a C<DESTROY> method is created on first object construction which will call
 327 C<< $instance->DEMOLISH($in_global_destruction) >> for each C<DEMOLISH>
 328 method from child upwards to parents.
 329
 330 Note that the C<DESTROY> method is created on first construction of an object
 331 of your class in order to not add overhead to classes without C<DEMOLISH>
 332 methods; this may prove slightly surprising if you try and define your own.
 333
 334 =head2 does
 335
 336  if ($foo->does('Some::Role1')) {
 337    ...
 338  }
 339
 340 Returns true if the object composes in the passed role.
 341
 342 =head1 IMPORTED SUBROUTINES
 343
 344 =head2 extends
 345
 346  extends 'Parent::Class';
 347
 348 Declares base class. Multiple superclasses can be passed for multiple
 349 inheritance (but please use roles instead).
 350
 351 Calling extends more than once will REPLACE your superclasses, not add to
 352 them like 'use base' would.
 353
 354 =head2 with
 355
 356  with 'Some::Role1';
 357
 358 or
 359
 360  with 'Some::Role1', 'Some::Role2';
 361
 362 Composes one or more L<Moo::Role> (or L<Role::Tiny>) roles into the current
 363 class.  An error will be raised if these roles have conflicting methods.
 364
 365 =head2 has
 366
 367  has attr => (
 368    is => 'ro',
 369  );
 370
 371 Declares an attribute for the class.
 372
 373 The options for C<has> are as follows:
 374
 375 =over 2
 376
 377 =item * is
 378
 379 B<required>, may be C<ro>, C<lazy>, C<rwp> or C<rw>.
 380
 381 C<ro> generates an accessor that dies if you attempt to write to it - i.e.
 382 a getter only - by defaulting C<reader> to the name of the attribute.
 383
 384 C<lazy> generates a reader like C<ro>, but also sets C<lazy> to 1 and
 385 C<builder> to C<_build_${attribute_name}> to allow on-demand generated
 386 attributes.  This feature was my attempt to fix my incompetence when
 387 originally designing C<lazy_build>, and is also implemented by
 388 L<MooseX::AttributeShortcuts>.
 389
 390 C<rwp> generates a reader like C<ro>, but also sets C<writer> to
 391 C<_set_${attribute_name}> for attributes that are designed to be written
 392 from inside of the class, but read-only from outside.
 393 This feature comes from L<MooseX::AttributeShortcuts>.
 394
 395 C<rw> generates a normal getter/setter by defaulting C<accessor> to the
 396 name of the attribute.
 397
 398 =item * isa
 399
 400 Takes a coderef which is meant to validate the attribute.  Unlike L<Moose> Moo
 401 does not include a basic type system, so instead of doing C<< isa => 'Num' >>,
 402 one should do
 403
 404  isa => quote_sub q{
 405    die "$_[0] is not a number!" unless looks_like_number $_[0]
 406  },
 407
 408 L<Sub::Quote aware|/SUB QUOTE AWARE>
 409
 410 Since L<Moo> does B<not> run the C<isa> check before C<coerce> if a coercion
 411 subroutine has been supplied, C<isa> checks are not structural to your code
 412 and can, if desired, be omitted on non-debug builds (although if this results
 413 in an uncaught bug causing your program to break, the L<Moo> authors guarantee
 414 nothing except that you get to keep both halves).
 415
 416 If you want L<MooseX::Types> style named types, look at
 417 L<MooX::Types::MooseLike>.
 418
 419 To cause your C<isa> entries to be automatically mapped to named
 420 L<Moose::Meta::TypeConstraint> objects (rather than the default behaviour
 421 of creating an anonymous type), set:
 422
 423   $Moo::HandleMoose::TYPE_MAP{$isa_coderef} = sub {
 424     require MooseX::Types::Something;
 425     return MooseX::Types::Something::TypeName();
 426   };
 427
 428 Note that this example is purely illustrative; anything that returns a
 429 L<Moose::Meta::TypeConstraint> object or something similar enough to it to
 430 make L<Moose> happy is fine.
 431
 432 =item * coerce
 433
 434 Takes a coderef which is meant to coerce the attribute.  The basic idea is to
 435 do something like the following:
 436
 437  coerce => quote_sub q{
 438    $_[0] + 1 unless $_[0] % 2
 439  },
 440
 441 Note that L<Moo> will always fire your coercion - this is to permit
 442 isa entries to be used purely for bug trapping, whereas coercions are
 443 always structural to your code. We do, however, apply any supplied C<isa>
 444 check after the coercion has run to ensure that it returned a valid value.
 445
 446 L<Sub::Quote aware|/SUB QUOTE AWARE>
 447
 448 =item * handles
 449
 450 Takes a string
 451
 452   handles => 'RobotRole'
 453
 454 Where C<RobotRole> is a role (L<Moo::Role>) that defines an interface which
 455 becomes the list of methods to handle.
 456
 457 Takes a list of methods
 458
 459  handles => [ qw( one two ) ]
 460
 461 Takes a hashref
 462
 463  handles => {
 464    un => 'one',
 465  }
 466
 467 =item * trigger
 468
 469 Takes a coderef which will get called any time the attribute is set. This
 470 includes the constructor. Coderef will be invoked against the object with the
 471 new value as an argument.
 472
 473 If you set this to just C<1>, it generates a trigger which calls the
 474 C<_trigger_${attr_name}> method on C<$self>. This feature comes from
 475 L<MooseX::AttributeShortcuts>.
 476
 477 Note that Moose also passes the old value, if any; this feature is not yet
 478 supported.
 479
 480 L<Sub::Quote aware|/SUB QUOTE AWARE>
 481
 482 =item * default
 483
 484 Takes a coderef which will get called with $self as its only argument
 485 to populate an attribute if no value is supplied to the constructor - or
 486 if the attribute is lazy, when the attribute is first retrieved if no
 487 value has yet been provided.
 488
 489 Note that if your default is fired during new() there is no guarantee that
 490 other attributes have been populated yet so you should not rely on their
 491 existence.
 492
 493 L<Sub::Quote aware|/SUB QUOTE AWARE>
 494
 495 =item * predicate
 496
 497 Takes a method name which will return true if an attribute has a value.
 498
 499 If you set this to just C<1>, the predicate is automatically named
 500 C<has_${attr_name}> if your attribute's name does not start with an
 501 underscore, or <_has_${attr_name_without_the_underscore}> if it does.
 502 This feature comes from L<MooseX::AttributeShortcuts>.
 503
 504 =item * builder
 505
 506 Takes a method name which will be called to create the attribute - functions
 507 exactly like default except that instead of calling
 508
 509   $default->($self);
 510
 511 Moo will call
 512
 513   $self->$builder;
 514
 515 If you set this to just C<1>, the predicate is automatically named
 516 C<_build_${attr_name}>.  This feature comes from L<MooseX::AttributeShortcuts>.
 517
 518 =item * clearer
 519
 520 Takes a method name which will clear the attribute.
 521
 522 If you set this to just C<1>, the clearer is automatically named
 523 C<clear_${attr_name}> if your attribute's name does not start with an
 524 underscore, or <_clear_${attr_name_without_the_underscore}> if it does.
 525 This feature comes from L<MooseX::AttributeShortcuts>.
 526
 527 =item * lazy
 528
 529 B<Boolean>.  Set this if you want values for the attribute to be grabbed
 530 lazily.  This is usually a good idea if you have a L</builder> which requires
 531 another attribute to be set.
 532
 533 =item * required
 534
 535 B<Boolean>.  Set this if the attribute must be passed on instantiation.
 536
 537 =item * reader
 538
 539 The value of this attribute will be the name of the method to get the value of
 540 the attribute.  If you like Java style methods, you might set this to
 541 C<get_foo>
 542
 543 =item * writer
 544
 545 The value of this attribute will be the name of the method to set the value of
 546 the attribute.  If you like Java style methods, you might set this to
 547 C<set_foo>
 548
 549 =item * weak_ref
 550
 551 B<Boolean>.  Set this if you want the reference that the attribute contains to
 552 be weakened; use this when circular references are possible, which will cause
 553 leaks.
 554
 555 =item * init_arg
 556
 557 Takes the name of the key to look for at instantiation time of the object.  A
 558 common use of this is to make an underscored attribute have a non-underscored
 559 initialization name. C<undef> means that passing the value in on instantiation
 560 is ignored.
 561
 562 =back
 563
 564 =head2 before
 565
 566  before foo => sub { ... };
 567
 568 See L<< Class::Method::Modifiers/before method(s) => sub { ... } >> for full
 569 documentation.
 570
 571 =head2 around
 572
 573  around foo => sub { ... };
 574
 575 See L<< Class::Method::Modifiers/around method(s) => sub { ... } >> for full
 576 documentation.
 577
 578 =head2 after
 579
 580  after foo => sub { ... };
 581
 582 See L<< Class::Method::Modifiers/after method(s) => sub { ... } >> for full
 583 documentation.
 584
 585 =head1 SUB QUOTE AWARE
 586
 587 L<Sub::Quote/quote_sub> allows us to create coderefs that are "inlineable,"
 588 giving us a handy, XS-free speed boost.  Any option that is L<Sub::Quote>
 589 aware can take advantage of this.
 590
 591 =head1 INCOMPATIBILITIES WITH MOOSE
 592
 593 There is no built in type system.  C<isa> is verified with a coderef, if you
 594 need complex types, just make a library of coderefs, or better yet, functions
 595 that return quoted subs. L<MooX::Types::MooseLike> provides a similar API
 596 to L<MooseX::Types::Moose> so that you can write
 597
 598   has days_to_live => (is => 'ro', isa => Int);
 599
 600 and have it work with both; it is hoped that providing only subrefs as an
 601 API will encourage the use of other type systems as well, since it's
 602 probably the weakest part of Moose design-wise.
 603
 604 C<initializer> is not supported in core since the author considers it to be a
 605 bad idea but may be supported by an extension in future. Meanwhile C<trigger> or
 606 C<coerce> are more likely to be able to fulfill your needs.
 607
 608 There is no meta object.  If you need this level of complexity you wanted
 609 L<Moose> - Moo succeeds at being small because it explicitly does not
 610 provide a metaprotocol. However, if you load L<Moose>, then
 611
 612   Class::MOP::class_of($moo_class_or_role)
 613
 614 will return an appropriate metaclass pre-populated by L<Moo>.
 615
 616 No support for C<super>, C<override>, C<inner>, or C<augment> - the author
 617 considers augment to be a bad idea, and override can be translated:
 618
 619   override foo => sub {
 620     ...
 621     super();
 622     ...
 623   };
 624
 625   around foo => sub {
 626     my ($orig, $self) = (shift, shift);
 627     ...
 628     $self->$orig(@_);
 629     ...
 630   };
 631
 632 The C<dump> method is not provided by default. The author suggests loading
 633 L<Devel::Dwarn> into C<main::> (via C<perl -MDevel::Dwarn ...> for example) and
 634 using C<$obj-E<gt>$::Dwarn()> instead.
 635
 636 L</default> only supports coderefs, because doing otherwise is usually a
 637 mistake anyway.
 638
 639 C<lazy_build> is not supported; you are instead encouraged to use the
 640 C<is => 'lazy'> option supported by L<Moo> and L<MooseX::AttributeShortcuts>.
 641
 642 C<auto_deref> is not supported since the author considers it a bad idea.
 643
 644 C<documentation> will show up in a L<Moose> metaclass created from your class
 645 but is otherwise ignored. Then again, L<Moose> ignores it as well, so this
 646 is arguably not an incompatibility.
 647
 648 Since C<coerce> does not require C<isa> to be defined but L<Moose> does
 649 require it, the metaclass inflation for coerce-alone is a trifle insane
 650 and if you attempt to subtype the result will almost certainly break.
 651
 652 Handling of warnings: when you C<use Moo> we enable FATAL warnings.  The nearest
 653 similar invocation for L<Moose> would be:
 654
 655   use Moose;
 656   use warnings FATAL => "all";
 657
 658 Additionally, L<Moo> supports a set of attribute option shortcuts intended to
 659 reduce common boilerplate.  The set of shortcuts is the same as in the L<Moose>
 660 module L<MooseX::AttributeShortcuts> as of its version 0.009+.  So if you:
 661
 662     package MyClass;
 663     use Moo;
 664
 665 The nearest L<Moose> invocation would be:
 666
 667     package MyClass;
 668
 669     use Moose;
 670     use warnings FATAL => "all";
 671     use MooseX::AttributeShortcuts;
 672
 673 or, if you're inheriting from a non-Moose class,
 674
 675     package MyClass;
 676
 677     use Moose;
 678     use MooseX::NonMoose;
 679     use warnings FATAL => "all";
 680     use MooseX::AttributeShortcuts;
 681
 682 Finally, Moose requires you to call
 683
 684     __PACKAGE__->meta->make_immutable;
 685
 686 at the end of your class to get an inlined (i.e. not horribly slow)
 687 constructor. Moo does it automatically the first time ->new is called
 688 on your class.
 689
 690 =head1 SUPPORT
 691
 692 Users' IRC: #moose on irc.perl.org
 693
 694 Development and contribution IRC: #web-simple on irc.perl.org
 695
 696 =head1 AUTHOR
 697
 698 mst - Matt S. Trout (cpan:MSTROUT) <mst@shadowcat.co.uk>
 699
 700 =head1 CONTRIBUTORS
 701
 702 dg - David Leadbeater (cpan:DGL) <dgl@dgl.cx>
 703
 704 frew - Arthur Axel "fREW" Schmidt (cpan:FREW) <frioux@gmail.com>
 705
 706 hobbs - Andrew Rodland (cpan:ARODLAND) <arodland@cpan.org>
 707
 708 jnap - John Napiorkowski (cpan:JJNAPIORK) <jjn1056@yahoo.com>
 709
 710 ribasushi - Peter Rabbitson (cpan:RIBASUSHI) <ribasushi@cpan.org>
 711
 712 chip - Chip Salzenberg (cpan:CHIPS) <chip@pobox.com>
 713
 714 ajgb - Alex J. G. Burzyński (cpan:AJGB) <ajgb@cpan.org>
 715
 716 doy - Jesse Luehrs (cpan:DOY) <doy at tozt dot net>
 717
 718 perigrin - Chris Prather (cpan:PERIGRIN) <chris@prather.org>
 719
 720 Mithaldu - Christian Walde (cpan:MITHALDU) <walde.christian@googlemail.com>
 721
 722 ilmari - Dagfinn Ilmari Mannsåker (cpan:ILMARI) <ilmari@ilmari.org>
 723
 724 =head1 COPYRIGHT
 725
 726 Copyright (c) 2010-2011 the Moo L</AUTHOR> and L</CONTRIBUTORS>
 727 as listed above.
 728
 729 =head1 LICENSE
 730
 731 This library is free software and may be distributed under the same terms
 732 as perl itself.
 733
 734 =cut