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

VERSION
    version 0.001005

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 atttribute. 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.

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

AUTHOR
    Matthew Phillips <mattp@cpan.org>

COPYRIGHT AND LICENSE
    This software is copyright (c) 2013 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.

