Get all callbacks working in an approximation of a "good" way.

eg/eg-06-moose-roles.pl

@@ -11,6 +11,7 @@
 {
 	package Reflex::UdpPeer::Echo;
 	use Moose;
+	extends 'Reflex::Object';
 	with 'Reflex::Role::UdpPeer';
 
 	sub on_my_datagram {

eg/eg-15-handle.pl

@@ -60,4 +60,6 @@
 	}
 }
 
-exit UdpPeer->new( port => 12345 )->run_all();
+my $port = 12345;
+print "Starting UDP echo service on port $port.\n";
+exit UdpPeer->new( port => $port )->run_all();

eg/eg-22-rcb-object.pl

@@ -117,7 +117,7 @@
 
 		$self->callback_thing(
 			ThingWithCallbacks->new(
-				cb_object($self, { on_event => "handle_event" }),
+				cb_object($self, { event => "handle_event" }),
 			)
 		);
 	}

eg/eg-23-rcb-class.pl

@@ -117,7 +117,7 @@
 
 		$self->callback_thing(
 			ThingWithCallbacks->new(
-				cb_class(__PACKAGE__, { on_event => "handle_event" }),
+				cb_class(__PACKAGE__, { event => "handle_event" }),
 			)
 		);
 	}

eg/eg-32-promise-tiny.pl

@@ -1,5 +1,9 @@
 #!/usr/bin/env perl
 
+# This is pretty close to the final syntax.
+# TODO - Provide a way to wait() on multiple objects at once.
+# TODO - Clean out all previous promise-like examples.
+
 use warnings;
 use strict;
 

eg/eg-33-all-callbacks.pl

@@ -0,0 +1,133 @@
+#!/usr/bin/env perl
+
+# This is pretty close to the final syntax.
+# TODO - Provide a way to wait() on multiple objects at once.
+# TODO - Clean out all previous promise-like examples.
+
+use warnings;
+use strict;
+
+use lib qw(../lib);
+
+use Reflex::Timer;
+use ExampleHelpers qw(eg_say);
+
+### Handle timer ticks with coderefs.
+
+use Reflex::Callbacks qw(cb_coderef);
+my $ct = Reflex::Timer->new(
+	interval    => 1 + rand(),
+	auto_repeat => 1,
+	on_tick     => cb_coderef( sub { eg_say("coderef callback triggered") } ),
+);
+
+### Handle timer ticks with object methods.  Class methods work, too.
+
+{
+	package MethodHandler;
+	use Moose;
+	extends 'Reflex::Object';
+	use Reflex::Callbacks qw(cb_method);
+	use ExampleHelpers qw(eg_say);
+
+	has ticker => (
+		isa     => 'Maybe[Reflex::Timer]',
+		is      => 'rw',
+	);
+
+	sub BUILD {
+		my $self = shift;
+		$self->ticker(
+			Reflex::Timer->new(
+				interval    => 1 + rand(),
+				auto_repeat => 1,
+				on_tick     => cb_method($self, "callback"),
+			)
+		);
+	}
+
+	sub callback {
+		eg_say("method callback triggered");
+	}
+}
+
+my $mh = MethodHandler->new();
+
+### Handle timer ticks with objects.
+### This is a convenience wrapper for mapping several events to
+### methods in one go.
+
+{
+	package ObjectHandler;
+	use Moose;
+	extends 'Reflex::Object';
+	use Reflex::Callbacks qw(cb_object);
+	use ExampleHelpers qw(eg_say);
+
+	has ticker => (
+		isa     => 'Maybe[Reflex::Timer]',
+		is      => 'rw',
+	);
+
+	sub BUILD {
+		my $self = shift;
+		$self->ticker(
+			Reflex::Timer->new(
+				interval    => 1 + rand(),
+				auto_repeat => 1,
+				cb_object($self, { tick => "callback" }),
+			)
+		);
+	}
+
+	sub callback {
+		eg_say("object callback triggered");
+	}
+}
+
+my $oh = ObjectHandler->new();
+
+### Handle timer ticks with role-based method names.
+
+{
+	package RoleHandler;
+	use Moose;
+	extends 'Reflex::Object';
+	use Reflex::Callbacks qw(cb_role);
+	use ExampleHelpers qw(eg_say);
+
+	has ticker => (
+		isa     => 'Maybe[Reflex::Timer]',
+		is      => 'rw',
+	);
+
+	sub BUIILD {
+		my $self = shift;
+		$self->ticker(
+			Reflex::Timer->new(
+				interval    => 1 + rand(),
+				auto_repeat => 1,
+				cb_role($self, "timer"),
+			)
+		);
+	}
+
+	sub on_timer_tick {
+		eg_say("object callback triggered");
+	}
+}
+
+my $rh = RoleHandler->new();
+
+### Poll for events with a condvar-like promise construct.  Goes last
+### because the while() loop will "block".  Meanwhile, wait() is also
+### allowing the other timers to run.
+
+my $pt = Reflex::Timer->new(
+	interval    => 1 + rand(),
+	auto_repeat => 1,
+);
+
+while (my $event = $pt->wait()) {
+	eg_say("promise timer returned an event (@$event)");
+}

lib/Reflex/Callback.pm

@@ -1,5 +1,13 @@
 package Reflex::Callback;
 
 use Moose;
+use Reflex::Object;
+
+# It's a class if it's a Str.
+has object => (
+	is        => 'ro',
+	isa       => 'Object|Str',  # TODO - Reflex::Object|Str
+	weak_ref  => 1,
+);
 
 1;

lib/Reflex/Callback/Method.pm

@@ -3,13 +3,6 @@ package Reflex::Callback::Method;
 use Moose;
 extends 'Reflex::Callback';
 
-# It's a class if it's a Str.
-has object => (
-	is        => 'ro',
-	isa       => 'Object|Str',
-	weak_ref  => 1,
-);
-
 has method_name => (
 	is        => 'ro',
 	isa       => 'Str',

lib/Reflex/Callback/Promise.pm

@@ -1,8 +1,7 @@
 package Reflex::Callback::Promise;
 
 use Moose;
-extends 'Reflex::Callback';
-extends 'Reflex::Callbacks';
+extends qw(Reflex::Callbacks Reflex::Callback);
 
 has queue => (
 	is      => 'rw',

lib/Reflex/Callbacks.pm

@@ -77,12 +77,13 @@ sub cb_object {
 	# They passed us a scalar.  Emulate cb_methods().
 	return($methods => cb_method(@_)) unless ref $methods;
 
+	# Events match method names.
 	return( map { ($_ => cb_method($object, $_)) } @$methods ) if (
 		ref($methods) eq "ARRAY"
 	);
 
 	return (
-		map { ($_ => cb_method($object, $methods->{$_})) }
+		map { ("on_$_" => cb_method($object, $methods->{$_})) }
 		keys %$methods
 	) if ref($methods) eq "HASH";
 
@@ -124,7 +125,6 @@ sub cb_promise {
 	my $promise_ref = shift;
 
 	$$promise_ref = Reflex::Callback::Promise->new();
-
 	return( on_promise => $$promise_ref );
 }
 

lib/Reflex/Role/Object.pm

@@ -229,6 +229,24 @@ sub BUILD {
 		$watcher->observe($self, @$observer);
 	}
 
+	# Discrete callbacks.
+
+	CALLBACK: while (my ($param, $value) = each %$args) {
+		next unless $param =~ /^on_(\S+)/;
+
+		# There is an object, so we have a watcher.
+		if ($value->object()) {
+			$value->object()->observe($self, $1 => $value);
+			next CALLBACK;
+		}
+
+		# TODO - Who is the watcher?
+		if ($value->object()) {
+			$self->observe($self, $1 => $value);
+			next CALLBACK;
+		}
+	}
+
 	# Clear observers; we're done with them.
 	# TODO - Moose probably has a better way of validating parameters.
 	$self->observers([]);
@@ -244,14 +262,15 @@ sub observe {
 	my ($self, $observed, %args) = @_;
 
 	while (my ($event, $callback) = each %args) {
+		$event =~ s/^on_//;
+
 		my $observation = {
 			callback  => $callback,
 			event     => $event,
 			observed  => $observed,
 		};
 
 		weaken $observation->{observed};
-
 		unless (exists $self->watched_objects()->{$observed}) {
 			$self->watched_objects()->{$observed} = $observed;
 			weaken $self->watched_objects()->{$observed};
@@ -346,7 +365,7 @@ sub emit {
 			return;
 		}
 
-		$deliver_event = "on_promise";
+		$deliver_event = "promise";
 		return unless exists $self->watchers_by_event()->{$deliver_event};
 		# Fall through.
 	}

lib/Reflex/Timer.pm

@@ -1,6 +1,3 @@
-#calls a method (to be overriden in client) at an interval
-#either this happens only once, or repeats
-
 package Reflex::Timer;
 
 use Moose;
@@ -22,11 +19,6 @@ has auto_repeat => (
 	is => 'rw',
 );
 
-has event_name => (
-	isa => 'Str|Undef',
-	is => 'rw',
-);
-
 sub BUILD {
 	my $self = shift;
 	$self->repeat();
@@ -60,12 +52,7 @@ sub repeat {
 sub _deliver {
 	my $self = shift;
 	$self->alarm_id(0);
-	if(defined($self->event_name())) {
-		$self->emit( event=> $self->event_name());
-	}
-	else {
-		$self->emit( event => "tick" );
-	}
+	$self->emit( event => "tick" );
 	$self->repeat() if $self->auto_repeat();
 }
 

lib/Reflex/UdpPeer.pm

@@ -1,5 +1,6 @@
 package Reflex::UdpPeer;
 use Moose;
+extends 'Reflex::Object';
 with 'Reflex::Role::UdpPeer';
 
 # Composes Reflex::Role::udpPeer into a class.