File Coverage

blib/lib/ONE.pm

Criterion	Covered	Total	%
statement	63	72	87.5
branch	11	22	50.0
condition	4	8	50.0
subroutine	17	18	94.4
pod	4	6	66.6
total	99	126	78.5

# ABSTRACT: A Node.js style AnyEvent class, using MooseX::Event
package ONE;
{
  $ONE::VERSION = 'v0.2.0';
}
use AnyEvent;
use ONE::Collect;
use MooseX::Event;

with 'MooseX::Event::Role::ClassMethods';


sub collect (&) {
    my $collect = ONE::Collect->new();
    my $wrapper = MooseX::Event->add_listener_wrapper( sub {
        my( $todo ) = @_;
        $collect->listener( $todo );
    } );
    $_[0]->();
    MooseX::Event->remove_listener_wrapper( $wrapper );
    $collect->complete;
}

has '_loop_cv' => (is=>'rw', init_arg=>undef);
has '_idle_cv' => (is=>'rw', init_arg=>undef );
has '_signal'  => (is=>'rw', default=>sub{{}}, init_arg=>undef);



has_events qw(
    idle
    SIGHUP   SIGINT  SIGQUIT SIGILL  SIGTRAP SIGABRT SIGBUS    SIGFPE    SIGKILL
    SIGUSR1  SIGSEGV SIGUSR2 SIGPIPE SIGALRM SIGTERM SIGSTKFLT SIGCHLD   SIGCONT
    SIGSTOP  SIGTSTP SIGTTIN SIGTTOU SIGURG  SIGXCPU SIGXFSZ   SIGVTALRM SIGPROF
    SIGWINCH SIGIO   SIGPWR  SIGSYS );




# We would just use MooseX::Singleton, but it's nice to maintain compatibility with Mouse
BEGIN {
    my $instance;
    sub instance {
        my $class = shift;
        return $instance ||= $class->new(@_);
    }
}



sub activate_event {
    my $self = shift;
    my( $event ) = @_;
    if ( $event eq 'idle' ) {
        $self->_idle_cv( AE::idle( sub { $self->emit('idle'); } ) );
    }
    elsif ( $event =~ /^SIG([\w\d]+)$/ ) {
        my $sig  = $1;
        $self->_signal->{$sig} = AE::signal $sig, sub { $self->emit("SIG$sig") };
    }
}


sub deactivate_event {
    my $self = shift;
    my( $event ) = @_;
    if ( $event eq 'idle' ) {
        $self->_idle_cv( undef );
    }
    elsif ( $event =~ /^SIG([\w\d]+)$/ ) {
        delete $self->_signal->{$1};
    }
}


sub loop {
    my $cors = shift;
    my $self = ref $cors ? $cors : $cors->instance;
    if ( defined $self->_loop_cv ) {
        $self->_loop_cv->send();
    }
    my $cv = AE::cv;
    $self->_loop_cv( $cv );
    $cv->recv();
}


sub stop {
    my $cors = shift;
    my $self = ref $cors ? $cors : $cors->instance;
    return unless defined $self->_loop_cv;
    $self->_loop_cv->send();
    delete $self->{'_loop_cv'};
}

sub import {
    my $class = shift;
    my $caller = caller;

    for (@_) {
        my($module,$args) = split /=/;
        my @args = split /[:]/, $args || "";

        local $@;
        eval "require ONE::$module;";
        if ( $@ ) {
            require Carp;
            Carp::croak( $@ );
        }
        eval "package $caller; ONE::$module->import(\@args);" if @args or !/=/;
        if ( $@ ) {
            require Carp;
            Carp::croak( $@ );
        }
    }

    no strict 'refs';
    *{$caller.'::collect'} = $class->can('collect');
}


sub unimport {
    my $caller = caller;
    no strict 'refs';
    delete ${$caller.'::'}{'collect'};
}

__PACKAGE__->meta->make_immutable();
no MooseX::Event;

1;


__END__