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