File Coverage

blib/lib/MooseX/Event/Role.pm

Criterion	Covered	Total	%
statement	77	111	69.3
branch	12	28	42.8
condition	7	10	70.0
subroutine	12	12	100.0
pod	6	6	100.0
total	114	167	68.2

# ABSTRACT: A Node style event Role for Moose
package MooseX::Event::Role;
{
  $MooseX::Event::Role::VERSION = 'v0.2.0';
}
use MooseX::Event ();
use Any::Moose 'Role';

has '_listeners'    => (isa=>'HashRef', is=>'ro', default=>sub{ {} });
has '_aliases'      => (isa=>'HashRef', is=>'ro', default=>sub{ {} });


has 'current_event' => (isa=>'Str|Undef', is=>'rw');


MooseX::Event::has_event('new_listener');


sub event_exists {
    my $self = shift;
    my( $event ) = @_;
    return $self->can("event:$event");
}


sub on {
    my $self = shift;
    my( $event, $listener, @wrappers ) = @_;
    if ( ! $self->event_exists($event) ) {
        die "Event $event does not exist";
    }
    $self->_listeners->{$event} ||= [];
    $self->_aliases->{$event} ||= {};
    if ( ! @{$self->_listeners->{$event}} and $self->can('activate_event') ) {
        $self->activate_event($event);
    }
    my @aliases;
    my $wrapped = $listener;
    for ( reverse(@wrappers), reverse(@MooseX::Event::listener_wrappers) ) {
        push @aliases, 0+$wrapped;
        $wrapped = $_->( $wrapped );
    }
    $self->_aliases->{$event}{0+$wrapped} = \@aliases;
    for ( @aliases ) {
        $self->_aliases->{$event}{$_} = $wrapped;
    }
    $self->emit('new_listener', $event, $wrapped);
    push @{ $self->_listeners->{$event} }, $wrapped;
    return $wrapped;
}


sub once {
    my $self = shift;
    $self->on( @_, sub {
        my($listener) = @_;
        my $wrapped;
        $wrapped = sub {
            my $self = shift;
            $self->remove_listener($self->current_event=>$wrapped);
            $wrapped=undef;
            goto $listener;
        };
        return $wrapped;
    });
}

BEGIN {


    my $emit_stock = sub {
        my $self = shift;
        my( $event, @args ) = @_;
        if ( ! $self->event_exists($event) ) {
            die "Event $event does not exist";
        }
        return unless exists $self->_listeners->{$event};
        my $ce = $self->current_event;
        $self->current_event( $event );
        foreach ( @{ $self->_listeners->{$event} } ) {
            $_->($self,@args);
        }
        $self->current_event($ce);
        return;
    };


    my $emit_coro = sub {
        my $self = shift;
        my( $event, @args ) = @_;
        if ( ! $self->event_exists($event) ) {
            die "Event $event does not exist";
        }
        return unless exists $self->_listeners->{$event};

        foreach my $todo ( @{ $self->_listeners->{$event} } ) {
            my $ce;
            &Coro::async( sub {
                &Coro::on_enter( sub {
                    $ce  = $self->current_event;
                    $self->current_event($event);
                });
                $todo->(@_);
                &Coro::on_leave( sub {
                    $self->current_event($ce);
                });
            }, $self, @args );
        }
        Coro::cede();

        return;
    };


    sub emit {
        no warnings 'redefine';
        if ( defined *Coro::async{CODE} ) {
            *emit = $emit_coro;
            goto $emit_coro;
        }
        else {
            *emit = $emit_stock;
            goto $emit_stock;
        }
    }

}


sub remove_all_listeners {
    my $self = shift;
    if ( @_ ) {
        my( $event ) = @_;
        delete $self->_listeners->{$event};
        delete $self->_aliases->{$event};
        if ( $self->can('deactivate_event') ) {
            $self->deactivate_event($event);
        }
    }
    else {
        if ( $self->can('deactivate_event') ) {
            for ( keys %{$self->_listeners} ) {
                $self->deactivate_event($_);
            }
        }
        %{ $self->_listeners } = ();
        %{ $self->_aliases } = ();
    }
}


sub remove_listener {
    my $self = shift;
    my( $event, $listener ) = @_;
    if ( ! $self->event_exists($event) ) {
        die "Event $event does not exist";
    }
    return unless exists $self->_listeners->{$event};

    my $aliases = $self->_aliases->{$event}{0+$listener};
    delete $self->_aliases->{$event}{0+$listener};

    if ( ref $aliases eq "ARRAY" ) {
        for ( @$aliases ) {
            delete $self->_aliases->{$event}{$_};
        }
    }
    else {
        $listener = $aliases;
    }

    $self->_listeners->{$event} =
        [ grep { $_ != $listener } @{ $self->_listeners->{$event} } ];

    if ( ! @{$self->_listeners->{$event}} and $self->can('deactivate_event') ) {
        $self->deactivate_event($event);
    }
}

1;


__END__