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