File Coverage

blib/lib/Dancer/Plugin/MemcachedFast.pm

Criterion	Covered	Total	%
statement	12	60	20.0
branch	0	62	0.0
condition	0	31	0.0
subroutine	4	21	19.0
pod			n/a
total	16	174	9.2

package Dancer::Plugin::MemcachedFast;
$Dancer::Plugin::MemcachedFast::VERSION = '0.161360';
use strict;
use warnings;

# ABSTRACT: Dancer::Plugin::MemcachedFast - Cache things using Cache::Memcached::Fast

use Dancer::Plugin;

use Cache::Memcached::Fast;

my $default_timeout = 3600;
my $ok_to_compress  = 0;
my $cache           = do {
    my $config = plugin_setting;
    $config->{servers} = [$ENV{HAVE_TEST_MEMCACHED_SERVER_LOCALHOST}]
        if exists $ENV{HAVE_TEST_MEMCACHED_SERVER_LOCALHOST};
    $default_timeout = delete $config->{default_timeout}
        if exists $config->{default_timeout};
    $ok_to_compress =
        (       defined $config->{compress_threshold}
            and int($config->{compress_threshold}) > 1
            and defined $config->{compress_method});
    Cache::Memcached::Fast->new($config);
};

register memcached_compress => sub {
    unless ($ok_to_compress) {
        warn
            "Cannot compress. Check the 'compress_threshold' and 'compress_method' configuration options";
        return;
    }
    $cache->compress(!!$_[0]);
};

register memcached_get_or_set => sub {
    $cache->get($_[0]) or do {
        my $ret;
        $cache->set(
            $_[0],
            $ret = ref $_[1] eq 'CODE' ? $_[1]->() : $_[1],
            defined $_[2] ? $_[2] : $default_timeout
        );
        $ret;
        }
        or $_[1];
};

register memcached_get => sub {
    return $cache->get($_[0]) if $#_ == 0 and !ref $_[0];
    $cache->get_multi(map { ref $_ and ref $_ eq 'ARRAY' ? @$_ : $_ } @_);
};

register memcached_gets => sub {
    return $cache->gets($_[0]) if $#_ == 0 and !ref $_[0];
    $cache->gets_multi(map { ref $_ and ref $_ eq 'ARRAY' ? @$_ : $_ } @_);
};

register memcached_set => sub {
    return $cache->set(
        $_[0],
        ref $_[1] eq 'CODE' ? $_[1]->() : $_[1],
        defined $_[2]       ? $_[2]     : $default_timeout
    ) if ref $_[0] ne 'ARRAY';
    $cache->set_multi(
        map { [
                $_->[0],
                ref $_->[1] eq 'CODE' ? $_->[1]->() : $_->[1],
                defined $_->[2]       ? $_->[2]     : $default_timeout
            ]
        } grep { ref $_ eq 'ARRAY' } @_
    );
};

register memcached_add => sub {
    return $cache->add(
        $_[0],
        ref $_[1] eq 'CODE' ? $_[1]->() : $_[1],
        defined $_[2]       ? $_[2]     : $default_timeout
    ) if ref $_[0] ne 'ARRAY';
    $cache->add_multi(
        map { [
                $_->[0],
                ref $_->[1] eq 'CODE' ? $_->[1]->() : $_->[1],
                defined $_->[2]       ? $_->[2]     : $default_timeout
            ]
        } grep { ref $_ eq 'ARRAY' } @_
    );
};

register memcached_replace => sub {
    return $cache->replace(
        $_[0],
        ref $_[1] eq 'CODE' ? $_[1]->() : $_[1],
        defined $_[2]       ? $_[2]     : $default_timeout
    ) if ref $_[0] ne 'ARRAY';
    $cache->replace_multi(
        map { [
                $_->[0],
                ref $_->[1] eq 'CODE' ? $_->[1]->() : $_->[1],
                defined $_->[2]       ? $_->[2]     : $default_timeout
            ]
        } grep { ref $_ eq 'ARRAY' } @_
    );
};

register memcached_delete => sub {
    return $cache->delete($_[0]) if $#_ == 0 and !ref $_[0];
    $cache->delete_multi(map { (ref $_ and ref $_ eq 'ARRAY') ? @$_ : $_ } @_);
};

register memcached_append => sub {
    return $cache->append(@_) if ($#_ == 1 and !ref $_[0] and !ref $_[1]);
    $cache->append_multi(grep { ref $_ eq 'ARRAY' } @_);
};

register memcached_prepend => sub {
    return $cache->prepend(@_) if ($#_ == 1 and !ref $_[0] and !ref $_[1]);
    $cache->prepend_multi(grep { ref $_ eq 'ARRAY' } @_);
};

register memcached_incr => sub {
    return $cache->incr(@_) if ($#_ <= 2 and scalar grep { !ref $_ } @_);
    $cache->incr_multi(grep { ref $_ eq 'ARRAY' } @_);
};

register memcached_decr => sub {
    return $cache->decr(@_) if ($#_ <= 2 and scalar grep { !ref $_ } @_);
    $cache->decr_multi(grep { ref $_ eq 'ARRAY' } @_);
};

register memcached_flush_all => sub {
    $cache->flush_all(@_);
};

register memcached_nowait_push => sub {
    $cache->nowait_push;
};

register memcached_server_versions => sub {
    $cache->server_versions;
};

register memcached_disconnect_all => sub {
    $cache->disconnect_all;
};

register memcached_namespace => sub {
    $cache->namespace($_[0]);
};

register_plugin;

1;

__END__