File Coverage

blib/lib/Text/Xslate/Bridge.pm

Criterion	Covered	Total	%
statement	51	59	86.4
branch	5	10	50.0
condition	5	6	83.3
subroutine	8	9	88.8
pod	1	4	25.0
total	70	88	79.5

package Text::Xslate::Bridge;
use strict;
use warnings;
use Carp ();
use Text::Xslate::Util qw(p);

my %storage;

sub bridge {
    my $class = shift;
    while(my($type, $table) = splice @_, 0, 2) {
        $storage{$class}{$type} = $table;
    }
    return;
}

sub export_into_xslate {
    my($class, $funcs_ref, @args) = @_;
    push @{$funcs_ref}, $class->methods(@args);
    return;
}

sub methods {
    my($class, %args) = @_;

    if(!exists $storage{$class}) {
        Carp::croak("$class has no methods (possibly not a bridge class)");
    }

    if(exists $args{-exclude}) {
        my $exclude = $args{-exclude};
        my $methods = $class->_functions;
        my @export;

        if(ref($exclude) eq 'ARRAY') {
            $exclude = { map { $_ => 1 } @{$exclude} };
        }

        if(ref($exclude) eq 'HASH') {
            @export = grep { !$exclude->{$_} } keys %{$methods};
        }
        elsif(ref($exclude) eq 'Regexp'){
            @export = grep { $_ !~ $exclude } keys %{$methods};
        }
        else {
            @export = grep { $_ ne $exclude } keys %{$methods};
        }
        return map { $_ => $methods->{$_} } @export;
    }
    else {
        return %{ $class->_functions };
    }
}

sub _functions {
    my($class) = @_;

    my $st    = $storage{$class} ||= {};
    my $funcs = $st->{_funcs}    ||= {};

    # for methods
    foreach my $type (qw(scalar hash array)) {
        my $table = $st->{$type} || next;

        foreach my $name(keys %{$table}) {
            $funcs->{$type . '::' . $name} = $table->{$name};
        }
    }

    # for functions
    my $table = $st->{function};
    foreach my $name(keys %{$table}) {
        $funcs->{$name} = $table->{$name};
    }
    return $funcs;
}

sub dump {
    p(\%storage);
}

1;
__END__