DISCLAIMER

Sorry for my English ...

NAME

Callable - make different things callable

SYNOPSIS

    my $db = DBI->connect( ... );
    my $router = My::Router->new(
        # use subroutine as handler
        '/' => Callable->(
            sub { my ($db, $request) = @_; ... },

            # inject default arguments to handler
            $db
        ),

        # use subroutine by name as handler
        '/profile' => Callable->new(
            # call handler as package method
            'Controller::Profile->home',

            # inject default arguments to handler
            db => $db,
            authenticated_only => 1
        ),

        # create class instance and use it as handler
        '/admin' => Callable->new(
            [
                # class_name => method
                'Controller::Admin' => 'home',

                # inject arguments to constructor
                db => $db
            ],

            # inject default arguments to handler
            restrictions => {role => 'admin'}
        ),
    );

    my $handler = $router->match($ENV{REQUEST_URI});

    # send additional arguments when calling handler
    my $response = $handler->(Request->new(%ENV));
    print $response->dump();

DESCRIPTION

Callable is a simple wrapper for make subroutines from different sources. Can be used in applications with configurable callback maps (e.g. website router config). Inspired by PHP's callable

METHODS

new($source[, @default_args])

Create instance. Arguments:

$source

See "SOURCES"

@default_args

Default arguments that will be sent to handler

    my $hello = Callable->new(sub { join ', ', @_; }, 'Hello');
    print $hello->('World'); # Hello, World
    print $hello->('Bro'); # Hello, Bro
    print "$hello, World"; # Hello, World

overload '&{}'

Callable instance can be called like a subroutine reference:

    my $foo = Callable->new( ... );
    my $result = $foo->();

overload '""'

Callable instance can be interpolated:

    my $foo = Callable->new( ... );
    my $result = "Foo: $foo."; # same as 'Foo: ' . $foo->() . '.'

SOURCES

subroutine reference

    my $foo = Callable->new(sub { ... });

subroutine name

    my $foo = Callable->new('foo::bar');

Finds subroutine reference by it's name (\&{$name}). Name can be: Fully-qualified (Module::Name::sub_name) names used as is, not qualified names (sub_name) will be prefixed with package, where callable was called from (see caller):

    {
        package Foo;
        sub foo { 'Foo' }
        sub bar { Callable->new('Foo::foo') }
        sub baz { Callable->new('foo') }
    }

    package main;

    # ok, fully-qualified name 'Foo::foo', subroutine found
    print Foo::bar->();

    # not ok, 'foo' has no package name, so it will be interpreted as 'main::foo'
    print Foo::baz->();

package method

Same as "subroutine name", but with -> before subroutine name:

    # Fully-qualified
    my $foo = Callable->new('Module::Name->sub_name');

    # Not qualified
    my $foo = Callable->new('->sub_name');

object method

    my $obj = My::Class->new( ... );
    my $foo = Callable->new([$obj => 'method_name']);

class and method

    my $foo = Callable->new(['My::Class' => 'method_name']);

$foo->() creates My::Class instance and calls ->metod_name.

Constructor name can be specified:

    my $foo = Callable->new(['My::Class->constructor_name' => 'method_name']);

$Callable::DEFAULT_CLASS_CONSTRUCTOR is used when no constructor name given (new by default)

callable

Callable instance can be cloned from another callable instance:

    my $source = Callable->new(sub { ... });
    my $foo = Callable->new($source);

Usable for re-create class instance ("class and method") and/or for resetting default "Arguments"

ARGUMENTS

Send arguments when calling:

    my $foo = Callable->new(sub { join ',', @_ });
    print $foo->(qw(Hello , World)); # prints Hello,World

Send default arguments when create instance:

    my $foo = Callable->new(sub { join ',', @_ }, 'Hello');
    print $foo->(qw(, World)); # prints Hello,World
    print $foo->(qw(, Bro)); # prints Hello,Bro

Send arguments to class constructor:

    {
        package My::Class;
        sub new {
            my $class = shift;
            return bless \@_, $class;
        }

        sub foo {
            my $self = shift;
            return join ' ', @{$self}, @_;
        }
    }

    my $foo = Callable->new(['My::Class', 'foo', 'Hello'], ',');
    print $foo->('World'); # prints Hello , World
    print $foo->('Bro'); # prints Hello , Bro

LICENSE

Copyright (C) Al Tom.

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

AUTHOR

Al Tom <al-tom.ru@yandex.ru>

cpanm Callable

perl -MCPAN -e shell
install Callable