NAME

       MooX::HandlesVia - NativeTrait-like behavior for Moo.

VERSION

       version 0.001009

SYNOPSIS

         {
           package Hashy;
           use Moo;
           use MooX::HandlesVia;

           has hash => (
             is => 'rw',
             handles_via => 'Hash',
             handles => {
               get_val => 'get',
               set_val => 'set',
               all_keys => 'keys'
             }
           );
         }

         my $h = Hashy->new(hash => { a => 1, b => 2});

         $h->get_val('b'); # 2

         $h->set_val('a', 'BAR'); # sets a to BAR

         my @keys = $h->all_keys; # returns a, b

DESCRIPTION

       MooX::HandlesVia is an extension of Moo's 'handles' attribute functionality. It provides a
       means of proxying functionality from an external class to the given attribute. This is
       most commonly used as a way to emulate 'Native Trait' behavior that has become commonplace
       in Moose code, for which there was no Moo alternative.

SHORTCOMINGS

       Due to current Moo implementation details there are some deficiencies in how
       MooX::HandlesVia in comparison to what you would expect from Moose native traits.

       •   methods delegated via the Moo 'handles' interface are passed the attribue value
           directly. and there is no way to access the parent class. This means if an attribute
           is updated any triggers or type coercions WILL NOT fire.

       •   Moo attribute method delegations are passed the attribute value. This is fine for
           references (objects, arrays, hashrefs..) it means simple scalar types are READ ONLY.
           This unfortunately means Number, String, Counter, Bool cannot modify the attributes
           value, rendering them largely useless.

       If these are issues for you, consider Sub::HandlesVia, which uses a different
       architecture, respecting triggers and coercions, and allowing read-write access to non-
       reference values. It should be possible to use Sub::HandlesVia as a drop-in replacement
       for MooX::HandlesVia.

PROVIDED INTERFACE/FUNCTIONS

       process_has(@_)
           MooX::HandlesVia preprocesses arguments passed to has() attribute declarations via the
           process_has function. In a given Moo class, If 'handles_via' is set to a ClassName
           string, and 'handles' is set with a hashref mapping of desired moo class methods that
           should map to ClassName methods, process_has() will create the appropriate binding to
           create the mapping IF ClassName provides that named method.

             has options => (
               is => 'rw',
               handles_via => 'Array',
               handles => {
                 mixup => 'shuffle',
                 unique_options => 'uniq',
                 all_options => 'elements'
               }
             );

       The following handles_via keywords are reserved as shorthand for mapping to Data::Perl:

       •   Hash maps to Data::Perl::Collection::Hash::MooseLike

       •   Array maps to Data::Perl::Collection::Array::MooseLike

       •   String maps to Data::Perl::String::MooseLike

       •   Number maps to Data::Perl::Number::MooseLike

       •   Bool maps to Data::Perl::Bool::MooseLike

       •   Code maps to Data::Perl::Code

SEE ALSO

       •   Moo

       •   MooX::late

       •   Sub::HandlesVia

ORIGINAL AUTHOR

       Matthew Phillips <mattp@cpan.org>

AUTHOR

       Toby Inkster <tobyink@cpan.org>

COPYRIGHT AND LICENSE

       This software is copyright (c) 2020 by Matthew Phillips <mattp@cpan.org>.

       This is free software; you can redistribute it and/or modify it under the same terms as
       the Perl 5 programming language system itself.