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