oracular (3) Data::MethodProxy.3pm.gz

NAME

       Data::MethodProxy - Inject dynamic data into static data.

SYNOPSIS

           use Data::MethodProxy;

           my $mproxy = Data::MethodProxy->new();

           my $output = $mproxy->render({
               half_six => ['$proxy', 'main', 'half', 6],
           });
           # { half_six => 3 }

           sub half {
               my ($class, $number) = @_;
               return $number / 2;
           }

DESCRIPTION

       A method proxy is an array ref describing a class method to call and the arguments to pass to it.  The
       first value of the array ref is the scalar $proxy, followed by a package name, then a subroutine name
       which must callable in the package, and a list of any subroutine arguments.

           [ '$proxy', 'Foo::Bar', 'baz', 123, 4 ]

       The above is saying, do this:

           Foo::Bar->baz( 123, 4 );

       The "render" method is the main entry point for replacing all found method proxies in an arbitrary data
       structure with the return value of calling the methods.

   Example
       Consider this static YAML configuration:

           ---
           db:
               dsn: DBI:mysql:database=foo
               username: bar
               password: abc123

       Putting your database password inside of a configuration file is usually considered a bad practice.  You
       can use a method proxy to get around this without jumping through a bunch of hoops:

           ---
           db:
               dsn: DBI:mysql:database=foo
               username: bar
               password:
                   - $proxy
                   - MyApp::Config
                   - get_db_password
                   - foo-bar

       When "render" is called on the above data structure it will see the method proxy and will replace the
       array ref with the return value of calling the method.

       A method proxy, in Perl syntax, looks like this:

           ['$proxy', $package, $method, @args]

       The $proxy string can also be written as &proxy.  The above is then converted to a method call and
       replaced by the return value of the method call:

           $package->$method( @args );

       In the above database password example the method call would be this:

           MyApp::Config->get_db_password( 'foo-bar' );

       You'd still need to create a "MyApp::Config" package, and add a "get_db_password" method to it.

METHODS

   render
           my $output = $mproxy->render( $input );

       Traverses the supplied data looking for method proxies, calling them, and replacing them with the return
       value of the method call.  Any value may be passed, such as a hash ref, an array ref, a method proxy, an
       object, a scalar, etc.  Array and hash refs will be recursively searched for method proxies.

       If a circular reference is detected an error will be thrown.

   call
           my $return = $mproxy->call( ['$proxy', $package, $method, @args] );

       Calls the method proxy and returns its return.

   is_valid
           die unless $mproxy->is_valid( ... );

       Returns true if the passed value looks like a method proxy.

   is_callable
           die unless $mproxy->is_callable( ... );

       Returns true if the passed value looks like a method proxy, and has a package and method which exist.

SUPPORT

       Please submit bugs and feature requests to the Data-MethodProxy GitHub issue tracker:

       <https://github.com/bluefeet/Data-MethodProxy/issues>

AUTHORS

           Aran Clary Deltac <bluefeet@gmail.com>

ACKNOWLEDGEMENTS

       Thanks to ZipRecruiter <https://www.ziprecruiter.com/> for encouraging their employees to contribute back
       to the open source ecosystem.  Without their dedication to quality software development this distribution
       would not exist.

LICENSE

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