utils: add makeNodeResolver function.

Many Firebase methods take Node.js style callbacks where the first
argument is null do indicate success or contains error information.
Angular uses promises to handle asyncronous flow. The original
[Q](https://github.com/kriskowal/q) library by kriskowal (upon which
had Angular promises are based) had a `makeNodeResolver` function
that eased integration of the two different async flows.

This utility function replicates that feature. Usage is as follows:

```javascript
var defer = $q.defer();
ref.resetPassword(
  {email:'[email protected]'},
  $util.makeNodeResolver(defer) //automatically resolves/rejects promise
);

defer.promise.then(...) // use the promise as you normally would
```

Author: jamestalmage

src/utils.js

@@ -227,6 +227,17 @@
             return def.promise;
           },
 
+          makeNodeResolver:function(deferred){
+            return function(err,result){
+              if(err){
+                deferred.reject(err);
+              }
+              else {
+                deferred.resolve(result);
+              }
+            }
+          },
+
           wait: function(fn, wait) {
             var to = $timeout(fn, wait||0);
             return function() {

tests/unit/utils.spec.js

@@ -181,4 +181,28 @@ describe('$firebaseUtils', function () {
     });
   });
 
+  describe('#makeNodeResolver', function(){
+    var deferred, callback;
+    beforeEach(function(){
+      deferred = jasmine.createSpyObj('promise',['resolve','reject']);
+      callback = $utils.makeNodeResolver(deferred);
+    });
+
+    it('should return a function', function(){
+      expect(callback).toBeA('function');
+    });
+
+    it('should reject the promise if the first argument is truthy', function(){
+      var error = new Error('blah');
+      callback(error);
+      expect(deferred.reject).toHaveBeenCalledWith(error);
+    });
+
+    it('should resolve the promise if the first argument is falsy', function(){
+      var result = {data:'hello world'};
+      callback(null,result);
+      expect(deferred.resolve).toHaveBeenCalledWith(result);
+    });
+  });
+
 });