upgraded to jasmine 2.0 with newer grunt-contrib-jasmine stack

Author: nmccready

dist/angular-google-maps.js

@@ -1,4 +1,4 @@
-/*! angular-google-maps 1.1.1-SNAPSHOT 2014-05-25
+/*! angular-google-maps 1.1.1-SNAPSHOT 2014-05-26
  *  AngularJS directives for Google Maps
  *  git: https://github.com/nlaplante/angular-google-maps.git
  */
@@ -242,14 +242,21 @@ Nicholas McCready - https://twitter.com/nmccready
   var async;
 
   async = {
-    each: function(array, callback, doneCallBack, pausedCallBack, chunk, index) {
+    each: function(array, callback, doneCallBack, pausedCallBack, chunk, index, pause) {
       var doChunk;
       if (chunk == null) {
-        chunk = 100;
+        chunk = 20;
       }
       if (index == null) {
         index = 0;
       }
+      if (pause == null) {
+        pause = 1;
+      }
+      if (!pause) {
+        throw "pause (delay) must be set from _async!";
+        return;
+      }
       if (array === void 0 || (array != null ? array.length : void 0) <= 0) {
         doneCallBack();
         return;
@@ -258,18 +265,22 @@ Nicholas McCready - https://twitter.com/nmccready
         var cnt, i;
         cnt = chunk;
         i = index;
-        while (cnt-- && i < array.length) {
-          callback(array[i]);
+        while (cnt-- && i < (array ? array.length : i + 1)) {
+          callback(array[i], i);
           ++i;
         }
-        if (i < array.length) {
-          index = i;
-          if (pausedCallBack != null) {
-            pausedCallBack();
+        if (array) {
+          if (i < array.length) {
+            index = i;
+            if (pausedCallBack != null) {
+              pausedCallBack();
+            }
+            return setTimeout(doChunk, pause);
+          } else {
+            if (doneCallBack) {
+              return doneCallBack();
+            }
           }
-          return setTimeout(doChunk, 1);
-        } else {
-          return doneCallBack();
         }
       };
       return doChunk();

dist/angular-google-maps.min.js

@@ -25,15 +25,15 @@
     "grunt-contrib-concat": "~0.3.0",
     "grunt-contrib-connect": "~0.5.0",
     "grunt-contrib-copy": "~0.4.1",
-    "grunt-contrib-jasmine": "~0.5.2",
+    "grunt-contrib-jasmine": "~0.6.4",
     "grunt-contrib-jshint": "~0.7.2",
     "grunt-contrib-uglify": "~0.2.6",
     "grunt-contrib-watch": "~0.5.3",
     "grunt-conventional-changelog": "~1.1.0",
     "grunt-mkdir": "~0.1.1",
     "grunt-open": "~0.2.2",
-    "grunt-template-jasmine-istanbul": "~0.2.5",
-    "grunt-template-jasmine-requirejs": "~0.1.8",
+    "grunt-template-jasmine-istanbul": "~0.3.1",
+    "grunt-template-jasmine-requirejs": "~0.2.0",
     "lodash": "^2.4.1",
     "mocha": "~1.9.0",
     "should": "~1.2.0"

package.json

@@ -2,76 +2,59 @@ describe "_async", ->
     beforeEach ->
         @subject = _async
 
-    it "handle array of 101 outputs 101 elements equal to the original, with 1 pauses", ->
+    it "handle callback passes an index", (done) ->
+        _async.each [1], (thing,index)->
+          expect(thing).toEqual 1
+          expect(index).toEqual 0
+          done()
+
+    it "handle array of 101 outputs 101 elements equal to the original, with 1 pauses", (done) ->
         known = _.range(101)
         test = []
         pauses = 1
-        running =  true
-        runs ->
-            @subject.each(known,((num) -> test.push(num)),(()-> running = false),(()-> pauses++))
-
-        waitsFor =>
-            return !running
-        ,'Failed to wait!',1000
-        runs ->
-            expect(running).toEqual(false)
+        @subject.each(known,((num) -> test.push(num)),()->
+            done()
             expect(pauses).toEqual(2)
             expect(test.length).toEqual(known.length)
             expect(test).toEqual(known)
+        ,(()-> pauses++),100)
 
-    it "handle array of 200 outputs 200 elements equal to the original, with 2 pauses", ->
+    it "handle array of 200 outputs 200 elements equal to the original, with 2 pauses", (done) ->
         known = _.range(200)
         test = []
         pauses = 1
         running =  true
-        runs ->
-            @subject.each(known,((num) -> test.push(num)),(()-> running = false),(()-> pauses++))
-        waitsFor =>
-            return !running
-        ,'Failed to wait!',1000
-        runs ->
-            expect(running).toEqual(false)
+        @subject.each(known,((num) -> test.push(num)),()->
+            done()
             expect(pauses).toEqual(2)
             expect(test.length).toEqual(known.length)
             expect(test).toEqual(known)
+        ,(()-> pauses++),100)
 
-
-    it "handle array of 1000 outputs 1000 elements equal to the original, with 10 pauses", ->
+    it "handle array of 1000 outputs 1000 elements equal to the original, with 10 pauses", (done) ->
         known = _.range(1000)
         test = []
         pauses = 1
-        running = true
-        runs ->
-            @subject.each(known,((num) -> test.push(num)),(()-> running = false),(()-> pauses++))
-        waitsFor =>
-            !running
-        ,1000
-        runs ->
-            expect(running).toEqual(false)
+        @subject.each(known,((num) -> test.push(num)),()->
+            done()
             expect(pauses).toEqual(10)
             expect(test.length).toEqual(known.length)
             expect(test).toEqual(known)
-            
-    it "handle map of 1000 outputs 1000 elements equal to the original, with 10 pauses", ->
+        ,(()-> pauses++),100)
+
+
+    it "handle map of 1000 outputs 1000 elements equal to the original, with 10 pauses", (done) ->
         known = _.range(1000)
         test = []
         pauses = 1
         running = true
-        runs( ->
-            @subject.map(known,((num) ->
-                num += 1
-                "$#{num.toString()}"),(mapped)->
-                    test = mapped
-                    running = false
-                ,(()-> pauses++))
-        )
-        waitsFor =>
-            !running
-        ,1000
-        runs ->
-
-            expect(running).toEqual(false)
+        @subject.map(known,((num) ->
+            num += 1
+            "$#{num.toString()}"),(mapped)->
+            test = mapped
+            done()
             expect(pauses).toEqual(10)
             expect(test[999]).toEqual("$1000")
             expect(test.length).toEqual(known.length)
-            expect(test).toEqual(_.map(known,((n)-> n+=1; "$#{n.toString()}")))
+            expect(test).toEqual(_.map(known,((n)-> n+=1; "$#{n.toString()}")))
+        ,(()-> pauses++),100)

spec/coffee/directives/api/utils/_async.spec.coffee

@@ -34,11 +34,11 @@ describe "PropMap tests", ->
       @propMap.put('baz', 'biz')
       values = @propMap.values()
       expected = ['bar', 'biz']
-      @expect(values[i]).toEqual(item) for item, i in expected
+      expect(values[i]).toEqual(item) for item, i in expected
 
     it "should return all put keys", ->
       @propMap.put('foo', 'bar')
       @propMap.put('baz', 'biz')
       keys = @propMap.keys()
       expected = ['foo', 'baz']
-      @expect(keys[i]).toEqual(item) for item, i in expected
+      expect(keys[i]).toEqual(item) for item, i in expected

spec/coffee/directives/api/utils/prop-map.spec.coffee

@@ -117,4 +117,4 @@ describe "_.intersectionObjects", ->
                     ]
                     interArray = _.intersectionObjects @objArray,difArray
                     expect(interArray.length).toEqual(1)
-                    expect(interArray.length).toNotEqual(@objArray.length)
+                    expect(interArray.length).not.toEqual(@objArray.length)

spec/coffee/usage/underscore.intersection.spec.coffee

@@ -9,39 +9,44 @@
     TODO: Handle Object iteration like underscore and lodash as well.. not that important right now
 ###
 async =
-    each: (array, callback, doneCallBack, pausedCallBack, chunk = 100, index = 0) ->
-        if array == undefined or array?.length <= 0
-            doneCallBack()
-            return
-        # set this to whatever number of items you can process at once
-        doChunk = () ->
-            cnt = chunk
-            i = index
+  each: (array, callback, doneCallBack, pausedCallBack, chunk = 20, index = 0, pause = 1) ->
+    unless pause
+      throw "pause (delay) must be set from _async!"
+      return
+    if array == undefined or array?.length <= 0
+      doneCallBack()
+      return
+    # set this to whatever number of items you can process at once
+    doChunk = () ->
+      cnt = chunk
+      i = index
 
-            while cnt-- and i < array.length
-                # process array[index] here
-                callback(array[i])
-                ++i
-            if i < array.length
-                index = i
-                pausedCallBack() if pausedCallBack?
-                setTimeout(doChunk, 1)
-            else
-                doneCallBack()
-        doChunk()
+      while cnt-- and i < (if array then array.length  else i + 1)
+        # process array[index] here
+        callback(array[i],i)
+        ++i
 
-    #copied from underscore but to use the async each above
-    map: (objs, iterator, doneCallBack, pausedCallBack, chunk) ->
-        results = []
-        return results  unless objs?
-        _async.each objs, (o) ->
-            results.push iterator o
-        , () ->
-            doneCallBack(results)
-        , pausedCallBack, chunk
+      if array
+        if i < array.length
+          index = i
+          pausedCallBack() if pausedCallBack?
+          setTimeout(doChunk, pause)
+        else
+          doneCallBack() if doneCallBack
+    doChunk()
+
+#copied from underscore but w/ async each above
+  map: (objs, iterator, doneCallBack, pausedCallBack, chunk) ->
+    results = []
+    return results  unless objs?
+    _async.each objs, (o) ->
+      results.push iterator o
+    , () ->
+      doneCallBack(results)
+    , pausedCallBack, chunk
 
 window._async = async
 
 angular.module("google-maps.directives.api.utils")
 .factory "async", ->
-    window._async
+    window._async