listenTo equivalents for Commands and Requests.

Author: jamesplease

src/backbone.radio.js

@@ -233,6 +233,25 @@ Radio.Commands = {
   }
 };
 
+// listenTo equivalent for Commands
+var listenMethods = {complyFor: 'comply', complyForOnce: 'complyOnce'};
+_.each(listenMethods, function(implementation, method) {
+  Radio.Commands[method] = function(obj, name, callback) {
+    var listeningTo = this._listeningTo || (this._listeningTo = {});
+    var id = obj._commandId || (obj._commandId = _.uniqueId('c'));
+    listeningTo[id] = obj;
+    if (!callback && typeof name === 'object') { callback = this; }
+    if (implementation === 'once') {
+      callback = _.compose(function(result) {
+        this.stopListening(_.rest(arguments));
+        return result;
+      }, callback);
+    }
+    obj[implementation](name, callback, this);
+    return this;
+  };
+});
+
 //
 // Backbone.Radio.Requests
 // A messaging system for requesting data.
@@ -322,6 +341,25 @@ Radio.Requests = {
   }
 };
 
+// listenTo equivalent for Requests
+var listenMethods = {replyFor: 'reply', replyForOnce: 'replyOnce'};
+_.each(listenMethods, function(implementation, method) {
+  Radio.Requests[method] = function(obj, name, callback) {
+    var listeningTo = this._listeningTo || (this._listeningTo = {});
+    var id = obj._requestId || (obj._requestId = _.uniqueId('r'));
+    listeningTo[id] = obj;
+    if (!callback && typeof name === 'object') { callback = this; }
+    if (implementation === 'once') {
+      callback = _.compose(function(result) {
+        this.stopListening(_.rest(arguments));
+        return result;
+      }, callback);
+    }
+    obj[implementation](name, callback, this);
+    return this;
+  };
+});
+
 //
 // Backbone.Radio.channel
 // Get a reference to a channel by name.

test/spec/commands.js

@@ -475,4 +475,61 @@ describe('Commands:', function() {
         .and.calledWith('commandTwo');
     });
   });
+
+  describe('when registering a command with `complyFor`, then executing it', function() {
+    beforeEach(function() {
+      this.CommandsTwo = _.clone(Backbone.Radio.Commands);
+      this.callback = stub();
+      this.Commands.complyFor(this.CommandsTwo, 'myCommand', this.callback);
+      this.CommandsTwo.command('myCommand');
+    });
+
+    it('should execute the callback with the correct context', function() {
+      expect(this.callback)
+        .to.have.been.calledOnce
+        .and.to.have.always.been.calledOn(this.Commands);
+    });
+  });
+
+  describe('when registering a command with `complyFor` and an event map, and then executing one of the commands', function() {
+    beforeEach(function() {
+      this.CommandsTwo = _.clone(Backbone.Radio.Commands);
+      this.callbackOne = stub();
+      this.callbackTwo = stub();
+      this.Commands.complyFor(this.CommandsTwo, {
+        commandOne: this.callbackOne,
+        commandTwo: this.callbackTwo
+      });
+      this.CommandsTwo.command('commandOne');
+    });
+
+    it('should execute the callback with the correct context', function() {
+      expect(this.callbackOne)
+        .to.have.been.calledOnce
+        .and.to.have.always.been.calledOn(this.Commands);
+    });
+
+    it('should not execute the callbacks not specified', function() {
+      expect(this.callbackTwo).to.not.have.been.called;
+    });
+  });
+
+  describe('`complyForOnce` should clean up after itself', function() {
+    beforeEach(function() {
+      this.CommandsTwo = _.clone(Backbone.Radio.Commands);
+      this.callback = stub();
+      this.Commands.complyForOnce(this.CommandsTwo, 'myCommand', this.callback);
+      this.CommandsTwo.command('myCommand');
+    });
+
+    it('should execute the callback with the correct context', function() {
+      expect(this.callback)
+        .to.have.been.calledOnce
+        .and.to.have.always.been.calledOn(this.Commands);
+    });
+
+    it('should remove the reference from the original object', function() {
+      expect(this.CommandsTwo._commands).to.deep.equal({});
+    });
+  });
 });