File Coverage

blib/lib/Sprocket/Util/Observable.pm

Criterion	Covered	Total	%
statement	47	57	82.4
branch	12	20	60.0
condition	1	3	33.3
subroutine	12	13	92.3
pod	5	6	83.3
total	77	99	77.7

package Sprocket::Util::Observable;

use Sprocket::Event;
use Sprocket::Common;

use Scalar::Util qw( reftype );

use strict;
use warnings;

our $observable = {};
our $hooks = {};

sub CALLBACK() { 0 }
sub UUID() { 1 }

sub new {
    my $class = shift;

    my $self = bless( { @_ }, ref $class || $class );

    # auto add a cleanup
    ( $self->isa( 'Sprocket' ) ? $self : Sprocket->new() )->attach_hook(
        'sprocket.shutdown',
        sub {
            $self->clear_hooks();
        }
    );

    return $self;
}

sub register_hook {
    my $self = shift;
    my $hook_names =_array_ref( shift );

    $observable->{ $_ }++
        foreach ( @$hook_names );

    return;
}

sub attach_hook {
    my ( $self, $callback ) = @_[ 0, 2 ];
    my $hook_names =_array_ref( $_[ 1 ] );

    unless ( reftype( $callback ) eq 'CODE' ) {
        # XXX log
        warn "invalid callback: $callback in Sprocket attach_hook, IGNORED!";
        return;
    }

    $hook_names = _array_ref( $hook_names );

    my $uuid = new_uuid();

    $hooks->{ "$self" } = {} unless ( exists( $hooks->{ $self } ) );

    foreach ( @$hook_names ) {
        if ( my $list = $hooks->{ $self }->{ $_ } ) {
            push( @$list, [ $callback, $uuid ] );
        } else {
            $hooks->{$self}->{ $_ } = [ [ $callback, $uuid ] ];
        }
    }

    return $uuid;
}

sub remove_hook {
    my ( $self, $uuid ) = @_;

    return undef unless ( $hooks->{ $self } );

    foreach ( keys %{$hooks->{ $self }} ) {
        next unless ( $hooks->{ $self }->{ $_ }->[ UUID ] eq $uuid );
        my $h = delete $hooks->{ $self }->{ $_ };
        return $h->[ CALLBACK ];
    }

    return undef;
}

sub broadcast {
    my ( $self, $hook_name, $data ) = @_;

    warn "unscheduled broadcast on event hook: $hook_name"
        unless( $observable->{ $hook_name } );

    $data = Sprocket::Event->new( $data )
        unless ( UNIVERSAL::isa( $data, 'Sprocket::Event' ) );

    $data->hook( $hook_name );

    if ( $hooks->{ $self }->{ $hook_name } ) {
        $_->[ CALLBACK ]->( $data )
            foreach ( @{ $hooks->{ $self }->{ $hook_name } } );
    }

    return $data;
}

sub clear_hooks {
    my $self = shift;
    delete $hooks->{ $self };
    return;
}

sub _array_ref {
    return ( ref( $_[0] ) eq 'ARRAY' ) ? $_[0] : [ $_[0] ];
}

1;

__END__