File Coverage

blib/lib/Slack/RTM/Bot.pm

Criterion	Covered	Total	%
statement	42	114	36.8
branch	8	38	21.0
condition	6	6	100.0
subroutine	12	16	75.0
pod	5	6	83.3
total	73	180	40.5

package Slack::RTM::Bot;

use 5.008001;
use strict;
use warnings;

use POSIX qw/sys_wait_h/;

use JSON;
use Slack::RTM::Bot::Client;

our $VERSION = "1.15";

pipe(READH, WRITEH);
select(WRITEH);$|=1;
pipe(READH2, WRITEH2);
select(WRITEH2);$|=1;
select(STDOUT);

sub new {
	my $pkg = shift;
	my $self = {
		@_
	};
	die 'need token!' unless $self->{token};
	return bless $self, $pkg;
}

sub start_RTM {
	my $self = shift;
	my ($sub) = @_;
	$self->_connect($self->{options});

	my $parent = $$;

	if ($^O ne 'MSWin32') {
		my @children = ();

		my $pid = fork;
		push @children, $pid;
		unless ($pid) {
			while (1) {
				unless (kill 0, $pid) {
					kill 9, $pid;
					waitpid($pid, WUNTRACED);
					last;
				}
				print WRITEH "\n";
				sleep 1;
			}
		} else {
			my $pid = fork;
			push @children, $pid;
			unless ($pid) {
				$self->{client}->{pids} = [$parent, @children];
				my $i = 0;
				while (1) {
					unless (kill 0, $parent) {
						kill 9, $pid;
						waitpid($pid, WUNTRACED);
						last;
					}
					if ($self->{client}->read) {
						print WRITEH2 "\n";
					}
					(my $buffer = ) =~ s/\n.*$//;
					if ($buffer) {
						$self->{client}->write(
							%{JSON::from_json(Encode::decode_utf8($buffer))}
						);
					}
					if (++$i % 30 == 0) {
						$self->{client}->write(
							id   => $i,
							type => 'ping'
						);
					}
				}
			} else {
				$self->{children} = \@children;
				# wait until connected
				;
				&$sub($self) if $sub;
			}
		};
	} else {
		require threads;
		require Thread::Queue;

		threads->create(
			sub {
				while (kill 0, $parent) {
					print WRITEH "\n";
					sleep 1;
				}
			}
		)->detach;

		threads->create(
			sub {
				my $i = 0;
				while (kill 0, $parent) {
					if ($self->{client}->read) {
						print WRITEH2 "\n";
					}
					(my $buffer = ) =~ s/\n.*$//;
					if ($buffer) {
						$self->{client}->write(
							%{JSON::from_json(Encode::decode_utf8($buffer))}
						);
					}
					if (++$i % 30 == 0) {
						$self->{client}->write(
							id   => $i,
							type => 'ping'
						);
					}
				}
			}
		)->detach;

		$self->{queue} = Thread::Queue->new();
		$self->{worker} = threads->create(sub {
			while (defined(my $req = $self->{queue}->dequeue())) {
				print WRITEH $req;
			}
		});

		# wait until connected
		;
		&$sub($self) if $sub;
	}
}

sub stop_RTM {
	my $self = shift;

	sleep 1;
	$self->{client}->disconnect;
	undef $self->{client};

	if ($^O ne 'MSWin32') {
		for my $child (@{$self->{children}}) {
			kill 9, $child;
			waitpid($child, WUNTRACED);
		}
		undef $self->{children};
	} else {
		$self->{queue}->end();
		$self->{worker}->join();
	}
}

sub _connect {
	my $self = shift;

	my $client = Slack::RTM::Bot::Client->new(
		token   => $self->{token},
		actions => $self->{actions},
		options => $self->{options}
	);
	$client->connect($self->{token});

	$self->{client} = $client;
}

sub say {
	my $self = shift;
	my $args;
	if(!@_ || scalar @_ % 2 != 0) {
		die "argument is not a HASH or ARRAY."
	}
	$args = {@_};
	if(!defined $args->{text} || !defined $args->{channel}) {
		die "argument needs keys 'text' and 'channel'.";
	}

	die "RTM not started." unless $self->{client};

	my $request = JSON::to_json({
		type    => 'message',
		subtype => 'bot_message',
		bot_id  => $self->{client}->{info}->{self}->{id},
		%$args,
		channel => $self->{client}->find_conversation_id($args->{channel})
	})."\n";
	print WRITEH $request;
}

sub on {
	my $self = shift;
	die "RTM already started." if $self->{info};
	my ($events, $routine) = @_;
	push @{$self->{actions}}, {
			events  => $events,
			routine => $routine
		};
}

sub add_action {
	my $self = shift;
	$self->on(@_);
}

1;
__END__