This is an automated email from the git hooks/post-receive script.

gregoa pushed a commit to branch master
in repository libmoo-perl.

commit 2bf53554b6feb20924cea6bd45aca3bd258dd3ae
Merge: cfaf753 9f1310d
Author: gregor herrmann <gre...@debian.org>
Date:   Mon Dec 26 18:45:49 2016 +0100

    New upstream version 2.003000

 Changes                            |   8 +
 MANIFEST                           |   7 -
 META.json                          |   4 +-
 META.yml                           |   4 +-
 Makefile.PL                        |   2 +
 README                             |  48 +--
 lib/Method/Generate/Accessor.pm    |  26 +-
 lib/Method/Generate/Constructor.pm |  16 +-
 lib/Moo.pm                         |  35 ++-
 lib/Moo/HandleMoose.pm             |   1 +
 lib/Moo/Role.pm                    |  46 +--
 lib/Moo/_Utils.pm                  |   3 +-
 lib/Sub/Defer.pm                   | 202 ------------
 lib/Sub/Quote.pm                   | 454 ---------------------------
 t/accessor-generator-extension.t   |  26 ++
 t/accessor-handles.t               |   9 +
 t/accessor-mixed.t                 |  31 ++
 t/accessor-reader-writer.t         |  16 -
 t/compose-roles.t                  |  18 +-
 t/croak-locations.t                |  26 --
 t/sub-defer-no-subname.t           |   9 -
 t/sub-defer-threads.t              |  41 ---
 t/sub-defer.t                      | 161 ----------
 t/sub-quote-threads.t              |  52 ----
 t/sub-quote.t                      | 612 -------------------------------------
 25 files changed, 179 insertions(+), 1678 deletions(-)

diff --cc MANIFEST
index 6728560,0000000..ded41df
mode 100644,000000..100644
--- a/MANIFEST
+++ b/MANIFEST
@@@ -1,151 -1,0 +1,144 @@@
 +Changes
 +lib/Method/Generate/Accessor.pm
 +lib/Method/Generate/BuildAll.pm
 +lib/Method/Generate/Constructor.pm
 +lib/Method/Generate/DemolishAll.pm
 +lib/Moo.pm
 +lib/Moo/_mro.pm
 +lib/Moo/_strictures.pm
 +lib/Moo/_Utils.pm
 +lib/Moo/HandleMoose.pm
 +lib/Moo/HandleMoose/_TypeMap.pm
 +lib/Moo/HandleMoose/FakeMetaClass.pm
 +lib/Moo/Object.pm
 +lib/Moo/Role.pm
 +lib/Moo/sification.pm
 +lib/oo.pm
- lib/Sub/Defer.pm
- lib/Sub/Quote.pm
 +maint/Makefile.PL.include
 +Makefile.PL
 +MANIFEST                      This list of files
 +t/accessor-coerce.t
 +t/accessor-default.t
 +t/accessor-generator-extension.t
 +t/accessor-handles.t
 +t/accessor-isa.t
 +t/accessor-mixed.t
 +t/accessor-pred-clear.t
 +t/accessor-reader-writer.t
 +t/accessor-roles.t
 +t/accessor-shortcuts.t
 +t/accessor-trigger.t
 +t/accessor-weaken-pre-5_8_3.t
 +t/accessor-weaken.t
 +t/buildall-subconstructor.t
 +t/buildall.t
 +t/buildargs-error.t
 +t/buildargs.t
 +t/coerce-1.t
 +t/compose-conflicts.t
 +t/compose-non-role.t
 +t/compose-roles.t
 +t/constructor-modify.t
 +t/croak-locations.t
 +t/demolish-basics.t
 +t/demolish-bugs-eats_exceptions.t
 +t/demolish-bugs-eats_mini.t
 +t/demolish-global_destruction.t
 +t/demolish-throw.t
 +t/does.t
 +t/extend-constructor.t
 +t/extends-non-moo.t
 +t/extends-role.t
 +t/foreignbuildargs.t
 +t/global-destruction-helper.pl
 +t/global_underscore.t
 +t/has-array.t
 +t/has-before-extends.t
 +t/has-plus.t
 +t/init-arg.t
 +t/isa-interfere.t
 +t/lazy_isa.t
 +t/lib/ErrorLocation.pm
 +t/lib/InlineModule.pm
 +t/lib/TestEnv.pm
 +t/load_module.t
 +t/load_module_error.t
 +t/load_module_role_tiny.t
 +t/long-package-name.t
 +t/method-generate-accessor.t
 +t/method-generate-constructor.t
 +t/modify_lazy_handlers.t
 +t/moo-accessors.t
 +t/moo-c3.t
 +t/moo-object.t
 +t/moo-utils-_name_coderef.t
 +t/moo-utils-_subname.t
 +t/moo-utils.t
 +t/moo.t
 +t/mutual-requires.t
 +t/no-build.t
 +t/no-moo.t
 +t/non-moo-extends-c3.t
 +t/non-moo-extends.t
 +t/not-both.t
 +t/overloaded-coderefs.t
 +t/overridden-core-funcs.t
 +t/perl-56-like.t
 +t/strictures.t
 +t/sub-and-handles.t
- t/sub-defer-no-subname.t
- t/sub-defer-threads.t
- t/sub-defer.t
- t/sub-quote-threads.t
- t/sub-quote.t
 +t/subconstructor.t
 +t/undef-bug.t
 +t/use-after-no.t
 +t/zzz-check-breaks.t
 +xt/bless-override.t
 +xt/class-tiny.t
 +xt/croak-locations.t
 +xt/fakemetaclass.t
 +xt/global-destruct-jenga-helper.pl
 +xt/global-destruct-jenga.t
 +xt/handle_moose.t
 +xt/has-after-meta.t
 +xt/implicit-moose-types.t
 +xt/inflate-our-classes.t
 +xt/inflate-undefer.t
 +xt/jenga.t
 +xt/moo-attr-handles-moose-role.t
 +xt/moo-consume-moose-role-coerce.t
 +xt/moo-consume-moose-role-multiple.t
 +xt/moo-consume-mouse-role-coerce.t
 +xt/moo-does-moose-role.t
 +xt/moo-does-mouse-role.t
 +xt/moo-inflate.t
 +xt/moo-object-meta-can.t
 +xt/moo-role-types.t
 +xt/moo-roles-into-moose-class-attr-override-with-autoclean.t
 +xt/moo-roles-into-moose-class.t
 +xt/moo-sification-handlemoose.t
 +xt/moo-sification-meta.t
 +xt/moo-sification.t
 +xt/moose-accessor-isa.t
 +xt/moose-autoclean-lazy-attr-builders.t
 +xt/moose-consume-moo-role-after-consumed-by-moo.t
 +xt/moose-consume-moo-role-no-moo-loaded.t
 +xt/moose-does-moo-role.t
 +xt/moose-extend-moo.t
 +xt/moose-handles-moo-class.t
 +xt/moose-inflate-error-recurse.t
 +xt/moose-lazy.t
 +xt/moose-method-modifiers.t
 +xt/moose-override-attribute-from-moo-role.t
 +xt/moose-override-attribute-with-plus-syntax.t
 +xt/more-jenga.t
 +xt/release/kwalitee.t
 +xt/role-tiny-inflate.t
 +xt/super-jenga.t
 +xt/test-my-dependents.t
 +xt/type-inflate-coercion.t
 +xt/type-inflate-threads.t
 +xt/type-inflate-type-tiny.t
 +xt/type-inflate.t
 +xt/type-tiny-coerce.t
 +xt/withautoclean.t
 +META.yml                                 Module YAML meta-data (added by 
MakeMaker)
 +META.json                                Module JSON meta-data (added by 
MakeMaker)
 +README                                   README file (added by Distar)
diff --cc META.json
index 80b9288,0000000..12b4211
mode 100644,000000..100644
--- a/META.json
+++ b/META.json
@@@ -1,106 -1,0 +1,108 @@@
 +{
 +   "abstract" : "Minimalist Object Orientation (with Moose compatibility)",
 +   "author" : [
 +      "mst - Matt S. Trout (cpan:MSTROUT) <m...@shadowcat.co.uk>"
 +   ],
 +   "dynamic_config" : 1,
 +   "generated_by" : "ExtUtils::MakeMaker version 7.24, CPAN::Meta::Converter 
version 2.150005",
 +   "license" : [
 +      "perl_5"
 +   ],
 +   "meta-spec" : {
 +      "url" : "http://search.cpan.org/perldoc?CPAN::Meta::Spec";,
 +      "version" : "2"
 +   },
 +   "name" : "Moo",
 +   "no_index" : {
 +      "directory" : [
 +         "t",
 +         "xt"
 +      ]
 +   },
 +   "prereqs" : {
 +      "build" : {
 +         "requires" : {}
 +      },
 +      "configure" : {
 +         "requires" : {
 +            "ExtUtils::MakeMaker" : "0"
 +         }
 +      },
 +      "develop" : {
 +         "requires" : {
 +            "Class::Tiny" : "1.001",
 +            "Moose" : "0",
 +            "MooseX::Types::Common::Numeric" : "0",
 +            "Mouse" : "0",
 +            "Type::Tiny" : "0",
 +            "bareword::filehandles" : "0",
 +            "indirect" : "0",
 +            "multidimensional" : "0",
 +            "namespace::autoclean" : "0",
 +            "namespace::clean" : "0",
 +            "strictures" : "2"
 +         }
 +      },
 +      "runtime" : {
 +         "recommends" : {
 +            "Class::XSAccessor" : "1.18",
 +            "Sub::Name" : "0.08",
 +            "strictures" : "2"
 +         },
 +         "requires" : {
 +            "Class::Method::Modifiers" : "1.1",
 +            "Devel::GlobalDestruction" : "0.11",
 +            "Exporter" : "5.57",
 +            "Module::Runtime" : "0.014",
 +            "Role::Tiny" : "2.000004",
 +            "Scalar::Util" : "0",
++            "Sub::Defer" : "2.003001",
++            "Sub::Quote" : "2.003001",
 +            "perl" : "5.006"
 +         }
 +      },
 +      "test" : {
 +         "recommends" : {
 +            "CPAN::Meta" : "0",
 +            "CPAN::Meta::Requirements" : "0"
 +         },
 +         "requires" : {
 +            "Test::Fatal" : "0.003",
 +            "Test::More" : "0.94"
 +         }
 +      }
 +   },
 +   "release_status" : "stable",
 +   "resources" : {
 +      "bugtracker" : {
 +         "mailto" : "bug-...@rt.cpan.org",
 +         "web" : "https://rt.cpan.org/Public/Dist/Display.html?Name=Moo";
 +      },
 +      "license" : [
 +         "http://dev.perl.org/licenses/";
 +      ],
 +      "repository" : {
 +         "type" : "git",
 +         "url" : "https://github.com/moose/Moo.git";,
 +         "web" : "https://github.com/moose/Moo";
 +      },
 +      "x_IRC" : "irc://irc.perl.org/#moose"
 +   },
-    "version" : "2.002005",
++   "version" : "2.003000",
 +   "x_authority" : "cpan:MSTROUT",
 +   "x_breaks" : {
 +      "App::Commando" : "<= 0.012",
 +      "File::DataClass" : "<= 0.54.1",
 +      "HTML::Restrict" : "== 2.1.5",
 +      "MooX::Emulate::Class::Accessor::Fast" : "<= 0.02",
 +      "MySQL::Workbench::Parser" : "<= 0.05",
 +      "WebService::Shutterstock" : "<= 0.006"
 +   },
 +   "x_cpants" : {
 +      "ignore" : {
 +         "use_strict" : "internal module used to apply strict",
 +         "use_warnings" : "internal module used to apply warnings"
 +      }
 +   },
 +   "x_serialization_backend" : "JSON::PP version 2.27300"
 +}
diff --cc META.yml
index e6294e9,0000000..c015aca
mode 100644,000000..100644
--- a/META.yml
+++ b/META.yml
@@@ -1,51 -1,0 +1,53 @@@
 +---
 +abstract: 'Minimalist Object Orientation (with Moose compatibility)'
 +author:
 +  - 'mst - Matt S. Trout (cpan:MSTROUT) <m...@shadowcat.co.uk>'
 +build_requires:
 +  Test::Fatal: '0.003'
 +  Test::More: '0.94'
 +configure_requires:
 +  ExtUtils::MakeMaker: '0'
 +dynamic_config: 1
 +generated_by: 'ExtUtils::MakeMaker version 7.24, CPAN::Meta::Converter 
version 2.150005'
 +license: perl
 +meta-spec:
 +  url: http://module-build.sourceforge.net/META-spec-v1.4.html
 +  version: '1.4'
 +name: Moo
 +no_index:
 +  directory:
 +    - t
 +    - xt
 +recommends:
 +  Class::XSAccessor: '1.18'
 +  Sub::Name: '0.08'
 +  strictures: '2'
 +requires:
 +  Class::Method::Modifiers: '1.1'
 +  Devel::GlobalDestruction: '0.11'
 +  Exporter: '5.57'
 +  Module::Runtime: '0.014'
 +  Role::Tiny: '2.000004'
 +  Scalar::Util: '0'
++  Sub::Defer: '2.003001'
++  Sub::Quote: '2.003001'
 +  perl: '5.006'
 +resources:
 +  IRC: irc://irc.perl.org/#moose
 +  bugtracker: https://rt.cpan.org/Public/Dist/Display.html?Name=Moo
 +  license: http://dev.perl.org/licenses/
 +  repository: https://github.com/moose/Moo.git
- version: '2.002005'
++version: '2.003000'
 +x_authority: cpan:MSTROUT
 +x_breaks:
 +  App::Commando: '<= 0.012'
 +  File::DataClass: '<= 0.54.1'
 +  HTML::Restrict: '== 2.1.5'
 +  MooX::Emulate::Class::Accessor::Fast: '<= 0.02'
 +  MySQL::Workbench::Parser: '<= 0.05'
 +  WebService::Shutterstock: '<= 0.006'
 +x_cpants:
 +  ignore:
 +    use_strict: 'internal module used to apply strict'
 +    use_warnings: 'internal module used to apply warnings'
 +x_serialization_backend: 'CPAN::Meta::YAML version 0.018'
diff --cc README
index 1597a7a,0000000..e728a06
mode 100644,000000..100644
--- a/README
+++ b/README
@@@ -1,792 -1,0 +1,776 @@@
 +NAME
 +    Moo - Minimalist Object Orientation (with Moose compatibility)
 +
 +SYNOPSIS
 +      package Cat::Food;
 +
 +      use Moo;
 +      use strictures 2;
 +      use namespace::clean;
 +
 +      sub feed_lion {
 +        my $self = shift;
 +        my $amount = shift || 1;
 +
 +        $self->pounds( $self->pounds - $amount );
 +      }
 +
 +      has taste => (
 +        is => 'ro',
 +      );
 +
 +      has brand => (
 +        is  => 'ro',
 +        isa => sub {
 +          die "Only SWEET-TREATZ supported!" unless $_[0] eq 'SWEET-TREATZ'
 +        },
 +      );
 +
 +      has pounds => (
 +        is  => 'rw',
 +        isa => sub { die "$_[0] is too much cat food!" unless $_[0] < 15 },
 +      );
 +
 +      1;
 +
 +    And elsewhere:
 +
 +      my $full = Cat::Food->new(
 +          taste  => 'DELICIOUS.',
 +          brand  => 'SWEET-TREATZ',
 +          pounds => 10,
 +      );
 +
 +      $full->feed_lion;
 +
 +      say $full->pounds;
 +
 +DESCRIPTION
 +    "Moo" is an extremely light-weight Object Orientation system. It allows
 +    one to concisely define objects and roles with a convenient syntax that
 +    avoids the details of Perl's object system. "Moo" contains a subset of
 +    Moose and is optimised for rapid startup.
 +
 +    "Moo" avoids depending on any XS modules to allow for simple
 +    deployments. The name "Moo" is based on the idea that it provides almost
 +    -- but not quite -- two thirds of Moose.
 +
 +    Unlike Mouse this module does not aim at full compatibility with Moose's
 +    surface syntax, preferring instead to provide full interoperability via
 +    the metaclass inflation capabilities described in "MOO AND MOOSE".
 +
 +    For a full list of the minor differences between Moose and Moo's surface
 +    syntax, see "INCOMPATIBILITIES WITH MOOSE".
 +
 +WHY MOO EXISTS
 +    If you want a full object system with a rich Metaprotocol, Moose is
 +    already wonderful.
 +
 +    But if you don't want to use Moose, you may not want "less metaprotocol"
 +    like Mouse offers, but you probably want "no metaprotocol", which is
 +    what Moo provides. "Moo" is ideal for some situations where deployment
 +    or startup time precludes using Moose and Mouse:
 +
 +    a command line or CGI script where fast startup is essential
 +    code designed to be deployed as a single file via App::FatPacker
 +    a CPAN module that may be used by others in the above situations
 +
 +    "Moo" maintains transparent compatibility with Moose so if you install
 +    and load Moose you can use Moo classes and roles in Moose code without
 +    modification.
 +
 +    Moo -- Minimal Object Orientation -- aims to make it smooth to upgrade
 +    to Moose when you need more than the minimal features offered by Moo.
 +
 +MOO AND MOOSE
 +    If Moo detects Moose being loaded, it will automatically register
 +    metaclasses for your Moo and Moo::Role packages, so you should be able
 +    to use them in Moose code without modification.
 +
 +    Moo will also create Moose type constraints for Moo classes and roles,
 +    so that in Moose classes "isa => 'MyMooClass'" and "isa => 'MyMooRole'"
 +    work the same as for Moose classes and roles.
 +
 +    Extending a Moose class or consuming a Moose::Role will also work.
 +
 +    Extending a Mouse class or consuming a Mouse::Role will also work. But
 +    note that we don't provide Mouse metaclasses or metaroles so the other
 +    way around doesn't work. This feature exists for Any::Moose users
 +    porting to Moo; enabling Mouse users to use Moo classes is not a
 +    priority for us.
 +
 +    This means that there is no need for anything like Any::Moose for Moo
 +    code - Moo and Moose code should simply interoperate without problem. To
 +    handle Mouse code, you'll likely need an empty Moo role or class
 +    consuming or extending the Mouse stuff since it doesn't register true
 +    Moose metaclasses like Moo does.
 +
 +    If you need to disable the metaclass creation, add:
 +
 +      no Moo::sification;
 +
 +    to your code before Moose is loaded, but bear in mind that this switch
 +    is global and turns the mechanism off entirely so don't put this in
 +    library code.
 +
 +MOO AND CLASS::XSACCESSOR
 +    If a new enough version of Class::XSAccessor is available, it will be
 +    used to generate simple accessors, readers, and writers for better
 +    performance. Simple accessors are those without lazy defaults, type
 +    checks/coercions, or triggers. Readers and writers generated by
 +    Class::XSAccessor will behave slightly differently: they will reject
 +    attempts to call them with the incorrect number of parameters.
 +
 +MOO VERSUS ANY::MOOSE
 +    Any::Moose will load Mouse normally, and Moose in a program using Moose
 +    - which theoretically allows you to get the startup time of Mouse
 +    without disadvantaging Moose users.
 +
 +    Sadly, this doesn't entirely work, since the selection is load order
 +    dependent - Moo's metaclass inflation system explained above in "MOO AND
 +    MOOSE" is significantly more reliable.
 +
 +    So if you want to write a CPAN module that loads fast or has only pure
 +    perl dependencies but is also fully usable by Moose users, you should be
 +    using Moo.
 +
 +    For a full explanation, see the article
 +    <http://shadow.cat/blog/matt-s-trout/moo-versus-any-moose> which
 +    explains the differing strategies in more detail and provides a direct
 +    example of where Moo succeeds and Any::Moose fails.
 +
 +PUBLIC METHODS
 +    Moo provides several methods to any class using it.
 +
 +  new
 +      Foo::Bar->new( attr1 => 3 );
 +
 +    or
 +
 +      Foo::Bar->new({ attr1 => 3 });
 +
 +    The constructor for the class. By default it will accept attributes
 +    either as a hashref, or a list of key value pairs. This can be
 +    customized with the "BUILDARGS" method.
 +
 +  does
 +      if ($foo->does('Some::Role1')) {
 +        ...
 +      }
 +
 +    Returns true if the object composes in the passed role.
 +
 +  DOES
 +      if ($foo->DOES('Some::Role1') || $foo->DOES('Some::Class1')) {
 +        ...
 +      }
 +
 +    Similar to "does", but will also return true for both composed roles and
 +    superclasses.
 +
 +  meta
 +      my $meta = Foo::Bar->meta;
 +      my @methods = $meta->get_method_list;
 +
 +    Returns an object that will behave as if it is a Moose metaclass object
 +    for the class. If you call anything other than "make_immutable" on it,
 +    the object will be transparently upgraded to a genuine
 +    Moose::Meta::Class instance, loading Moose in the process if required.
 +    "make_immutable" itself is a no-op, since we generate metaclasses that
 +    are already immutable, and users converting from Moose had an
 +    unfortunate tendency to accidentally load Moose by calling it.
 +
 +LIFECYCLE METHODS
 +    There are several methods that you can define in your class to control
 +    construction and destruction of objects. They should be used rather than
 +    trying to modify "new" or "DESTROY" yourself.
 +
 +  BUILDARGS
 +      around BUILDARGS => sub {
 +        my ( $orig, $class, @args ) = @_;
 +
 +        return { attr1 => $args[0] }
 +          if @args == 1 && !ref $args[0];
 +
 +        return $class->$orig(@args);
 +      };
 +
 +      Foo::Bar->new( 3 );
 +
 +    This class method is used to transform the arguments to "new" into a
 +    hash reference of attribute values.
 +
 +    The default implementation accepts a hash or hash reference of named
 +    parameters. If it receives a single argument that isn't a hash reference
 +    it will throw an error.
 +
 +    You can override this method in your class to handle other types of
 +    options passed to the constructor.
 +
 +    This method should always return a hash reference of named options.
 +
 +  FOREIGNBUILDARGS
 +      sub FOREIGNBUILDARGS {
 +        my ( $class, $options ) = @_;
 +        return $options->{foo};
 +      }
 +
 +    If you are inheriting from a non-Moo class, the arguments passed to the
 +    parent class constructor can be manipulated by defining a
 +    "FOREIGNBUILDARGS" method. It will receive the same arguments as
 +    "BUILDARGS", and should return a list of arguments to pass to the parent
 +    class constructor.
 +
 +  BUILD
 +      sub BUILD {
 +        my ($self, $args) = @_;
 +        die "foo and bar cannot be used at the same time"
 +          if exists $args->{foo} && exists $args->{bar};
 +      }
 +
 +    On object creation, any "BUILD" methods in the class's inheritance
 +    hierarchy will be called on the object and given the results of
 +    "BUILDARGS". They each will be called in order from the parent classes
 +    down to the child, and thus should not themselves call the parent's
 +    method. Typically this is used for object validation or possibly
 +    logging.
 +
 +  DEMOLISH
 +      sub DEMOLISH {
 +        my ($self, $in_global_destruction) = @_;
 +        ...
 +      }
 +
 +    When an object is destroyed, any "DEMOLISH" methods in the inheritance
 +    hierarchy will be called on the object. They are given boolean to inform
 +    them if global destruction is in progress, and are called from the child
 +    class upwards to the parent. This is similar to "BUILD" methods but in
 +    the opposite order.
 +
 +    Note that this is implemented by a "DESTROY" method, which is only
 +    created on on the first construction of an object of your class. This
 +    saves on overhead for classes that are never instantiated or those
 +    without "DEMOLISH" methods. If you try to define your own "DESTROY",
 +    this will cause undefined results.
 +
 +IMPORTED SUBROUTINES
 +  extends
 +      extends 'Parent::Class';
 +
 +    Declares a base class. Multiple superclasses can be passed for multiple
 +    inheritance but please consider using roles instead. The class will be
 +    loaded but no errors will be triggered if the class can't be found and
 +    there are already subs in the class.
 +
 +    Calling extends more than once will REPLACE your superclasses, not add
 +    to them like 'use base' would.
 +
 +  with
 +      with 'Some::Role1';
 +
 +    or
 +
 +      with 'Some::Role1', 'Some::Role2';
 +
 +    Composes one or more Moo::Role (or Role::Tiny) roles into the current
 +    class. An error will be raised if these roles cannot be composed because
 +    they have conflicting method definitions. The roles will be loaded using
 +    the same mechanism as "extends" uses.
 +
 +  has
 +      has attr => (
 +        is => 'ro',
 +      );
 +
 +    Declares an attribute for the class.
 +
 +      package Foo;
 +      use Moo;
 +      has 'attr' => (
 +        is => 'ro'
 +      );
 +
 +      package Bar;
 +      use Moo;
 +      extends 'Foo';
 +      has '+attr' => (
 +        default => sub { "blah" },
 +      );
 +
 +    Using the "+" notation, it's possible to override an attribute.
 +
 +      has [qw(attr1 attr2 attr3)] => (
 +        is => 'ro',
 +      );
 +
 +    Using an arrayref with multiple attribute names, it's possible to
 +    declare multiple attributes with the same options.
 +
 +    The options for "has" are as follows:
 +
-     * "is"
- 
++    "is"
 +      required, may be "ro", "lazy", "rwp" or "rw".
 +
 +      "ro" stands for "read-only" and generates an accessor that dies if you
 +      attempt to write to it - i.e. a getter only - by defaulting "reader"
 +      to the name of the attribute.
 +
 +      "lazy" generates a reader like "ro", but also sets "lazy" to 1 and
 +      "builder" to "_build_${attribute_name}" to allow on-demand generated
 +      attributes. This feature was my attempt to fix my incompetence when
 +      originally designing "lazy_build", and is also implemented by
 +      MooseX::AttributeShortcuts. There is, however, nothing to stop you
 +      using "lazy" and "builder" yourself with "rwp" or "rw" - it's just
 +      that this isn't generally a good idea so we don't provide a shortcut
 +      for it.
 +
 +      "rwp" stands for "read-write protected" and generates a reader like
 +      "ro", but also sets "writer" to "_set_${attribute_name}" for
 +      attributes that are designed to be written from inside of the class,
 +      but read-only from outside. This feature comes from
 +      MooseX::AttributeShortcuts.
 +
 +      "rw" stands for "read-write" and generates a normal getter/setter by
 +      defaulting the "accessor" to the name of the attribute specified.
 +
-     * "isa"
- 
++    "isa"
 +      Takes a coderef which is used to validate the attribute. Unlike Moose,
 +      Moo does not include a basic type system, so instead of doing "isa =>
 +      'Num'", one should do
 +
 +        use Scalar::Util qw(looks_like_number);
 +        ...
 +        isa => sub {
 +          die "$_[0] is not a number!" unless looks_like_number $_[0]
 +        },
 +
 +      Note that the return value for "isa" is discarded. Only if the sub
 +      dies does type validation fail.
 +
 +      Sub::Quote aware
 +
 +      Since Moo does not run the "isa" check before "coerce" if a coercion
 +      subroutine has been supplied, "isa" checks are not structural to your
 +      code and can, if desired, be omitted on non-debug builds (although if
 +      this results in an uncaught bug causing your program to break, the Moo
 +      authors guarantee nothing except that you get to keep both halves).
 +
 +      If you want Moose compatible or MooseX::Types style named types, look
 +      at Type::Tiny.
 +
 +      To cause your "isa" entries to be automatically mapped to named
 +      Moose::Meta::TypeConstraint objects (rather than the default behaviour
 +      of creating an anonymous type), set:
 +
 +        $Moo::HandleMoose::TYPE_MAP{$isa_coderef} = sub {
 +          require MooseX::Types::Something;
 +          return MooseX::Types::Something::TypeName();
 +        };
 +
 +      Note that this example is purely illustrative; anything that returns a
 +      Moose::Meta::TypeConstraint object or something similar enough to it
 +      to make Moose happy is fine.
 +
-     * "coerce"
- 
++    "coerce"
 +      Takes a coderef which is meant to coerce the attribute. The basic idea
 +      is to do something like the following:
 +
 +       coerce => sub {
 +         $_[0] % 2 ? $_[0] : $_[0] + 1
 +       },
 +
 +      Note that Moo will always execute your coercion: this is to permit
 +      "isa" entries to be used purely for bug trapping, whereas coercions
 +      are always structural to your code. We do, however, apply any supplied
 +      "isa" check after the coercion has run to ensure that it returned a
 +      valid value.
 +
 +      Sub::Quote aware
 +
 +      If the "isa" option is a blessed object providing a "coerce" or
 +      "coercion" method, then the "coerce" option may be set to just 1.
 +
-     * "handles"
- 
++    "handles"
 +      Takes a string
 +
 +        handles => 'RobotRole'
 +
 +      Where "RobotRole" is a role that defines an interface which becomes
 +      the list of methods to handle.
 +
 +      Takes a list of methods
 +
 +        handles => [ qw( one two ) ]
 +
 +      Takes a hashref
 +
 +        handles => {
 +          un => 'one',
 +        }
 +
-     * "trigger"
- 
++    "trigger"
 +      Takes a coderef which will get called any time the attribute is set.
 +      This includes the constructor, but not default or built values. The
 +      coderef will be invoked against the object with the new value as an
 +      argument.
 +
 +      If you set this to just 1, it generates a trigger which calls the
 +      "_trigger_${attr_name}" method on $self. This feature comes from
 +      MooseX::AttributeShortcuts.
 +
 +      Note that Moose also passes the old value, if any; this feature is not
 +      yet supported.
 +
 +      Sub::Quote aware
 +
-     * "default"
- 
++    "default"
 +      Takes a coderef which will get called with $self as its only argument
 +      to populate an attribute if no value for that attribute was supplied
 +      to the constructor. Alternatively, if the attribute is lazy, "default"
 +      executes when the attribute is first retrieved if no value has yet
 +      been provided.
 +
 +      If a simple scalar is provided, it will be inlined as a string. Any
 +      non-code reference (hash, array) will result in an error - for that
 +      case instead use a code reference that returns the desired value.
 +
 +      Note that if your default is fired during new() there is no guarantee
 +      that other attributes have been populated yet so you should not rely
 +      on their existence.
 +
 +      Sub::Quote aware
 +
-     * "predicate"
- 
++    "predicate"
 +      Takes a method name which will return true if an attribute has a
 +      value.
 +
 +      If you set this to just 1, the predicate is automatically named
 +      "has_${attr_name}" if your attribute's name does not start with an
 +      underscore, or "_has_${attr_name_without_the_underscore}" if it does.
 +      This feature comes from MooseX::AttributeShortcuts.
 +
-     * "builder"
- 
++    "builder"
 +      Takes a method name which will be called to create the attribute -
 +      functions exactly like default except that instead of calling
 +
 +        $default->($self);
 +
 +      Moo will call
 +
 +        $self->$builder;
 +
 +      The following features come from MooseX::AttributeShortcuts:
 +
 +      If you set this to just 1, the builder is automatically named
 +      "_build_${attr_name}".
 +
 +      If you set this to a coderef or code-convertible object, that variable
 +      will be installed under "$class::_build_${attr_name}" and the builder
 +      set to the same name.
 +
-     * "clearer"
- 
++    "clearer"
 +      Takes a method name which will clear the attribute.
 +
 +      If you set this to just 1, the clearer is automatically named
 +      "clear_${attr_name}" if your attribute's name does not start with an
 +      underscore, or "_clear_${attr_name_without_the_underscore}" if it
 +      does. This feature comes from MooseX::AttributeShortcuts.
 +
 +      NOTE: If the attribute is "lazy", it will be regenerated from
 +      "default" or "builder" the next time it is accessed. If it is not
 +      lazy, it will be "undef".
 +
-     * "lazy"
- 
++    "lazy"
 +      Boolean. Set this if you want values for the attribute to be grabbed
 +      lazily. This is usually a good idea if you have a "builder" which
 +      requires another attribute to be set.
 +
-     * "required"
- 
++    "required"
 +      Boolean. Set this if the attribute must be passed on object
 +      instantiation.
 +
-     * "reader"
- 
++    "reader"
 +      The name of the method that returns the value of the attribute. If you
 +      like Java style methods, you might set this to "get_foo"
 +
-     * "writer"
- 
++    "writer"
 +      The value of this attribute will be the name of the method to set the
 +      value of the attribute. If you like Java style methods, you might set
 +      this to "set_foo".
 +
-     * "weak_ref"
- 
++    "weak_ref"
 +      Boolean. Set this if you want the reference that the attribute
 +      contains to be weakened. Use this when circular references, which
 +      cause memory leaks, are possible.
 +
-     * "init_arg"
- 
++    "init_arg"
 +      Takes the name of the key to look for at instantiation time of the
 +      object. A common use of this is to make an underscored attribute have
 +      a non-underscored initialization name. "undef" means that passing the
 +      value in on instantiation is ignored.
 +
-     * "moosify"
- 
++    "moosify"
 +      Takes either a coderef or array of coderefs which is meant to
 +      transform the given attributes specifications if necessary when
 +      upgrading to a Moose role or class. You shouldn't need this by
 +      default, but is provided as a means of possible extensibility.
 +
 +  before
 +      before foo => sub { ... };
 +
 +    See "before method(s) => sub { ... };" in Class::Method::Modifiers for
 +    full documentation.
 +
 +  around
 +      around foo => sub { ... };
 +
 +    See "around method(s) => sub { ... };" in Class::Method::Modifiers for
 +    full documentation.
 +
 +  after
 +      after foo => sub { ... };
 +
 +    See "after method(s) => sub { ... };" in Class::Method::Modifiers for
 +    full documentation.
 +
 +SUB QUOTE AWARE
 +    "quote_sub" in Sub::Quote allows us to create coderefs that are
 +    "inlineable," giving us a handy, XS-free speed boost. Any option that is
 +    Sub::Quote aware can take advantage of this.
 +
 +    To do this, you can write
 +
 +      use Sub::Quote;
 +
 +      use Moo;
 +      use namespace::clean;
 +
 +      has foo => (
 +        is => 'ro',
 +        isa => quote_sub(q{ die "Not <3" unless $_[0] < 3 })
 +      );
 +
 +    which will be inlined as
 +
 +      do {
 +        local @_ = ($_[0]->{foo});
 +        die "Not <3" unless $_[0] < 3;
 +      }
 +
 +    or to avoid localizing @_,
 +
 +      has foo => (
 +        is => 'ro',
 +        isa => quote_sub(q{ my ($val) = @_; die "Not <3" unless $val < 3 })
 +      );
 +
 +    which will be inlined as
 +
 +      do {
 +        my ($val) = ($_[0]->{foo});
 +        die "Not <3" unless $val < 3;
 +      }
 +
 +    See Sub::Quote for more information, including how to pass lexical
 +    captures that will also be compiled into the subroutine.
 +
 +CLEANING UP IMPORTS
 +    Moo will not clean up imported subroutines for you; you will have to do
 +    that manually. The recommended way to do this is to declare your imports
 +    first, then "use Moo", then "use namespace::clean". Anything imported
 +    before namespace::clean will be scrubbed. Anything imported or declared
 +    after will be still be available.
 +
 +      package Record;
 +
 +      use Digest::MD5 qw(md5_hex);
 +
 +      use Moo;
 +      use namespace::clean;
 +
 +      has name => (is => 'ro', required => 1);
 +      has id => (is => 'lazy');
 +      sub _build_id {
 +        my ($self) = @_;
 +        return md5_hex($self->name);
 +      }
 +
 +      1;
 +
 +    If you were to import "md5_hex" after namespace::clean you would be able
 +    to call "->md5_hex()" on your "Record" instances (and it probably
 +    wouldn't do what you expect!).
 +
 +    Moo::Roles behave slightly differently. Since their methods are composed
 +    into the consuming class, they can do a little more for you
 +    automatically. As long as you declare your imports before calling "use
 +    Moo::Role", those imports and the ones Moo::Role itself provides will
 +    not be composed into consuming classes so there's usually no need to use
 +    namespace::clean.
 +
 +    On namespace::autoclean: Older versions of namespace::autoclean would
 +    inflate Moo classes to full Moose classes, losing the benefits of Moo.
 +    If you want to use namespace::autoclean with a Moo class, make sure you
 +    are using version 0.16 or newer.
 +
 +INCOMPATIBILITIES WITH MOOSE
 +    There is no built-in type system. "isa" is verified with a coderef; if
 +    you need complex types, Type::Tiny can provide types, type libraries,
 +    and will work seamlessly with both Moo and Moose. Type::Tiny can be
 +    considered the successor to MooseX::Types and provides a similar API, so
 +    that you can write
 +
 +      use Types::Standard qw(Int);
 +      has days_to_live => (is => 'ro', isa => Int);
 +
 +    "initializer" is not supported in core since the author considers it to
 +    be a bad idea and Moose best practices recommend avoiding it. Meanwhile
 +    "trigger" or "coerce" are more likely to be able to fulfill your needs.
 +
 +    There is no meta object. If you need this level of complexity you need
 +    Moose - Moo is small because it explicitly does not provide a
 +    metaprotocol. However, if you load Moose, then
 +
 +      Class::MOP::class_of($moo_class_or_role)
 +
 +    will return an appropriate metaclass pre-populated by Moo.
 +
 +    No support for "super", "override", "inner", or "augment" - the author
 +    considers augment to be a bad idea, and override can be translated:
 +
 +      override foo => sub {
 +        ...
 +        super();
 +        ...
 +      };
 +
 +      around foo => sub {
 +        my ($orig, $self) = (shift, shift);
 +        ...
 +        $self->$orig(@_);
 +        ...
 +      };
 +
 +    The "dump" method is not provided by default. The author suggests
 +    loading Devel::Dwarn into "main::" (via "perl -MDevel::Dwarn ..." for
 +    example) and using "$obj->$::Dwarn()" instead.
 +
 +    "default" only supports coderefs and plain scalars, because passing a
 +    hash or array reference as a default is almost always incorrect since
 +    the value is then shared between all objects using that default.
 +
 +    "lazy_build" is not supported; you are instead encouraged to use the "is
 +    => 'lazy'" option supported by Moo and MooseX::AttributeShortcuts.
 +
 +    "auto_deref" is not supported since the author considers it a bad idea
 +    and it has been considered best practice to avoid it for some time.
 +
 +    "documentation" will show up in a Moose metaclass created from your
 +    class but is otherwise ignored. Then again, Moose ignores it as well, so
 +    this is arguably not an incompatibility.
 +
 +    Since "coerce" does not require "isa" to be defined but Moose does
 +    require it, the metaclass inflation for coerce alone is a trifle insane
 +    and if you attempt to subtype the result will almost certainly break.
 +
 +    Handling of warnings: when you "use Moo" we enable strict and warnings,
 +    in a similar way to Moose. The authors recommend the use of
 +    "strictures", which enables FATAL warnings, and several extra pragmas
 +    when used in development: indirect, multidimensional, and
 +    bareword::filehandles.
 +
 +    Additionally, Moo supports a set of attribute option shortcuts intended
 +    to reduce common boilerplate. The set of shortcuts is the same as in the
 +    Moose module MooseX::AttributeShortcuts as of its version 0.009+. So if
 +    you:
 +
 +      package MyClass;
 +      use Moo;
 +      use strictures 2;
 +
 +    The nearest Moose invocation would be:
 +
 +      package MyClass;
 +
 +      use Moose;
 +      use warnings FATAL => "all";
 +      use MooseX::AttributeShortcuts;
 +
 +    or, if you're inheriting from a non-Moose class,
 +
 +      package MyClass;
 +
 +      use Moose;
 +      use MooseX::NonMoose;
 +      use warnings FATAL => "all";
 +      use MooseX::AttributeShortcuts;
 +
 +    Finally, Moose requires you to call
 +
 +      __PACKAGE__->meta->make_immutable;
 +
 +    at the end of your class to get an inlined (i.e. not horribly slow)
 +    constructor. Moo does it automatically the first time ->new is called on
 +    your class. ("make_immutable" is a no-op in Moo to ease migration.)
 +
 +    An extension MooX::late exists to ease translating Moose packages to Moo
 +    by providing a more Moose-like interface.
 +
 +SUPPORT
 +    Users' IRC: #moose on irc.perl.org
 +
 +    Development and contribution IRC: #web-simple on irc.perl.org
 +
 +    Bugtracker: <https://rt.cpan.org/Public/Dist/Display.html?Name=Moo>
 +
 +    Git repository: <git://github.com/moose/Moo.git>
 +
 +    Git browser: <https://github.com/moose/Moo>
 +
 +AUTHOR
 +    mst - Matt S. Trout (cpan:MSTROUT) <m...@shadowcat.co.uk>
 +
 +CONTRIBUTORS
 +    dg - David Leadbeater (cpan:DGL) <d...@dgl.cx>
 +
 +    frew - Arthur Axel "fREW" Schmidt (cpan:FREW) <fri...@gmail.com>
 +
 +    hobbs - Andrew Rodland (cpan:ARODLAND) <arodl...@cpan.org>
 +
 +    jnap - John Napiorkowski (cpan:JJNAPIORK) <jjn1...@yahoo.com>
 +
 +    ribasushi - Peter Rabbitson (cpan:RIBASUSHI) <ribasu...@cpan.org>
 +
 +    chip - Chip Salzenberg (cpan:CHIPS) <c...@pobox.com>
 +
 +    ajgb - Alex J. G. Burzyński (cpan:AJGB) <a...@cpan.org>
 +
 +    doy - Jesse Luehrs (cpan:DOY) <doy at tozt dot net>
 +
 +    perigrin - Chris Prather (cpan:PERIGRIN) <ch...@prather.org>
 +
 +    Mithaldu - Christian Walde (cpan:MITHALDU)
 +    <walde.christ...@googlemail.com>
 +
 +    ilmari - Dagfinn Ilmari Mannsåker (cpan:ILMARI) <ilm...@ilmari.org>
 +
 +    tobyink - Toby Inkster (cpan:TOBYINK) <toby...@cpan.org>
 +
 +    haarg - Graham Knop (cpan:HAARG) <ha...@cpan.org>
 +
 +    mattp - Matt Phillips (cpan:MATTP) <ma...@cpan.org>
 +
 +    bluefeet - Aran Deltac (cpan:BLUEFEET) <bluef...@gmail.com>
 +
 +    bubaflub - Bob Kuo (cpan:BUBAFLUB) <bubaf...@cpan.org>
 +
 +    ether = Karen Etheridge (cpan:ETHER) <et...@cpan.org>
 +
 +COPYRIGHT
 +    Copyright (c) 2010-2015 the Moo "AUTHOR" and "CONTRIBUTORS" as listed
 +    above.
 +
 +LICENSE
 +    This library is free software and may be distributed under the same
 +    terms as perl itself. See <http://dev.perl.org/licenses/>.
 +

-- 
Alioth's /usr/local/bin/git-commit-notice on 
/srv/git.debian.org/git/pkg-perl/packages/libmoo-perl.git

_______________________________________________
Pkg-perl-cvs-commits mailing list
Pkg-perl-cvs-commits@lists.alioth.debian.org
http://lists.alioth.debian.org/cgi-bin/mailman/listinfo/pkg-perl-cvs-commits

Reply via email to