Adding cookie service

  - Browser.cookies()
  - MockBrowser
  - $cookie service
  - $sessionStore

Author: mhevery

src/AngularPublic.js

@@ -6,6 +6,7 @@ angularService('$browser', function browserFactory(){
         jqLite(window.document),
         jqLite(window.document.getElementsByTagName('head')[0]));
     browserSingleton.startUrlWatcher();
+    browserSingleton.startCookieWatcher();
     browserSingleton.bind();
   }
   return browserSingleton;

src/Browser.js

@@ -22,8 +22,50 @@ function Browser(location, document, head) {
 
   this.location = location;
   this.document = document;
+  var rawDocument = document[0];
   this.head = head;
   this.idCounter = 0;
+
+  this.cookies = cookies;
+  this.watchCookies = function(fn){ cookieListeners.push(fn); };
+
+  // functions
+  var lastCookies = {};
+  var lastCookieString = '';
+  var cookieListeners = [];
+  /**
+   * cookies() -> hash of all cookies
+   * cookies(name, value) -> set name to value
+   *   if value is undefined delete it
+   * cookies(name) -> should get value, but deletes (no one calls it right now that way)
+   */
+  function cookies(name, value){
+    if (name) {
+      if (value === _undefined) {
+        delete lastCookies[name];
+        rawDocument.cookie = escape(name) + "=;expires=Thu, 01 Jan 1970 00:00:00 GMT";
+      } else {
+        rawDocument.cookie = escape(name) + '=' + escape(lastCookies[name] = ''+value);
+      }
+    } else {
+      if (rawDocument.cookie !== lastCookieString) {
+        lastCookieString = rawDocument.cookie;
+        var cookieArray = lastCookieString.split("; ");
+        lastCookies = {};
+
+        for (var i = 0; i < cookieArray.length; i++) {
+          var keyValue = cookieArray[i].split("=");
+          if (keyValue.length === 2) { //ignore nameless cookies
+            lastCookies[unescape(keyValue[0])] = unescape(keyValue[1]);
+          }
+        }
+        foreach(cookieListeners, function(fn){
+          fn(lastCookies);
+        });
+      }
+      return lastCookies;
+    }
+  }
 }
 
 Browser.prototype = {
@@ -132,6 +174,14 @@ Browser.prototype = {
    })();
   },
 
+  startCookieWatcher: function() {
+    var self = this;
+    (function poll() {
+      self.cookies();
+      self.setTimeout(poll, self.delay);
+    })();
+  },
+
   setUrl: function(url) {
    var existingURL = this.location.href;
    if (!existingURL.match(/#/)) existingURL += '#';

src/services.js

@@ -392,3 +392,67 @@ angularService('$resource', function($xhr){
   var resource = new ResourceFactory($xhr);
   return bind(resource, resource.route);
 }, {inject: ['$xhr.cache']});
+
+
+angularService('$cookies', function($browser) {
+  var cookies = {}, rootScope = this;
+  $browser.watchCookies(function(newCookies){
+    copy(newCookies, cookies);
+    rootScope.$eval();
+  });
+  this.$onEval(PRIORITY_FIRST, update);
+  this.$onEval(PRIORITY_LAST, update);
+  return cookies;
+
+  function update(){
+    var name, browserCookies = $browser.cookies();
+    for(name in cookies) {
+      if (browserCookies[name] !== cookies[name]) {
+        $browser.cookies(name, browserCookies[name] = cookies[name]);
+      }
+    }
+    for(name in browserCookies) {
+      if (browserCookies[name] !== cookies[name]) {
+        $browser.cookies(name, _undefined);
+        //TODO: write test for this delete
+        //delete cookies[name];
+      }
+    }
+  };
+}, {inject: ['$browser']});
+
+
+angularService('$sessionStore', function($store) {
+
+  function SessionStore() {}
+
+  SessionStore.prototype.get = function(key) {
+    return fromJson($store[key]);
+  };
+
+  SessionStore.prototype.getAll = function() {
+    var all = {},
+        key;
+
+    for (key in $store) {
+      if (!$store.hasOwnProperty(key)) continue;
+      all[key] = fromJson($store[key]);
+    }
+
+    return all;
+  };
+
+
+  SessionStore.prototype.put = function(key, value) {
+    $store[key] = toJson(value);
+  };
+
+
+  SessionStore.prototype.remove = function(key) {
+    delete $store[key];
+  };
+
+
+  return new SessionStore();
+
+}, {inject: ['$cookies']});

test/BrowserSpecs.js

@@ -27,6 +27,25 @@ describe('browser', function(){
     browser.startUrlWatcher();
   });
 
+  it('should contain cookie cruncher', function() {
+    expect(browser.cookies).toBeDefined();
+  });
+
+  it('should be able to start cookie watcher', function() {
+    browser.delay = 1;
+    expectAsserts(2);
+    browser.watchCookies(function(cookies){
+      assertEquals({'foo':'bar'}, cookies);
+    });
+    browser.setTimeout = function(fn, delay){
+      assertEquals(1, delay);
+      document.cookie = 'foo=bar';
+      browser.setTimeout = function(fn, delay) {};
+      fn();
+    };
+    browser.startCookieWatcher();
+  });
+
   describe('outstading requests', function(){
     it('should process callbacks immedietly with no outstanding requests', function(){
       var callback = jasmine.createSpy('callback');
@@ -67,4 +86,193 @@ describe('browser', function(){
     });
   });
 
+
+  describe('cookies', function() {
+
+    function deleteAllCookies() {
+      var cookies = document.cookie.split(";");
+
+      for (var i = 0; i < cookies.length; i++) {
+        var cookie = cookies[i];
+        var eqPos = cookie.indexOf("=");
+        var name = eqPos > -1 ? cookie.substr(0, eqPos) : cookie;
+        document.cookie = name + "=;expires=Thu, 01 Jan 1970 00:00:00 GMT";
+      }
+    };
+
+    var browser;
+
+    beforeEach(function() {
+      deleteAllCookies();
+      browser = new Browser({}, jqLite(document));
+      expect(document.cookie).toEqual('');
+    });
+
+
+    afterEach(function() {
+      deleteAllCookies();
+      expect(document.cookie).toEqual('');
+    });
+
+
+    describe('remove all via (null)', function() {
+
+      it('should do nothing when no cookies are set', function() {
+        browser.cookies(null);
+        expect(document.cookie).toEqual('');
+        expect(browser.cookies()).toEqual({});
+      });
+
+    });
+
+    describe('remove via (cookieName, undefined)', function() {
+
+      it('should remove a cookie when it is present', function() {
+        document.cookie = 'foo=bar';
+
+        browser.cookies('foo', undefined);
+
+        expect(document.cookie).toEqual('');
+        expect(browser.cookies()).toEqual({});
+      });
+
+
+      it('should do nothing when an nonexisting cookie is being removed', function() {
+        browser.cookies('doesntexist', undefined);
+        expect(document.cookie).toEqual('');
+        expect(browser.cookies()).toEqual({});
+      });
+    });
+
+
+    describe('put via (cookieName, string)', function() {
+
+      it('should create and store a cookie', function() {
+        browser.cookies('cookieName', 'cookieValue');
+        expect(document.cookie).toEqual('cookieName=cookieValue');
+        expect(browser.cookies()).toEqual({'cookieName':'cookieValue'});
+      });
+
+
+      it('should overwrite an existing unsynced cookie', function() {
+        document.cookie = "cookie=new";
+
+        var oldVal = browser.cookies('cookie', 'newer');
+
+        expect(document.cookie).toEqual('cookie=newer');
+        expect(browser.cookies()).toEqual({'cookie':'newer'});
+        expect(oldVal).not.toBeDefined();
+      });
+
+      it('should escape both name and value', function() {
+        browser.cookies('cookie1=', 'val;ue');
+        browser.cookies('cookie2=bar;baz', 'val=ue');
+
+        var rawCookies = document.cookie.split("; "); //order is not guaranteed, so we need to parse
+        expect(rawCookies.length).toEqual(2);
+        expect(rawCookies).toContain('cookie1%3D=val%3Bue');
+        expect(rawCookies).toContain('cookie2%3Dbar%3Bbaz=val%3Due');
+      });
+    });
+
+
+    describe('get via (cookieName)', function() {
+
+      it('should return undefined for nonexistent cookie', function() {
+        expect(browser.cookies('nonexistent')).not.toBeDefined();
+      });
+
+
+      it ('should return a value for an existing cookie', function() {
+        document.cookie = "foo=bar";
+        browser.cookies(true);
+        expect(browser.cookies().foo).toEqual('bar');
+      });
+
+
+      it ('should unescape cookie values that were escaped by puts', function() {
+        document.cookie = "cookie2%3Dbar%3Bbaz=val%3Due";
+        browser.cookies(true);
+        expect(browser.cookies()['cookie2=bar;baz']).toEqual('val=ue');
+      });
+
+
+      it('should preserve leading & trailing spaces in names and values', function() {
+        browser.cookies(' cookie name ', ' cookie value ');
+        expect(browser.cookies()[' cookie name ']).toEqual(' cookie value ');
+        expect(browser.cookies()['cookie name']).not.toBeDefined();
+      });
+    });
+
+
+    describe('getAll', function() {
+
+      it('should return cookies as hash', function() {
+        document.cookie = "foo1=bar1";
+        document.cookie = "foo2=bar2";
+        expect(browser.cookies()).toEqual({'foo1':'bar1', 'foo2':'bar2'});
+      });
+
+
+      it('should return empty hash if no cookies exist', function() {
+        expect(browser.cookies()).toEqual({});
+      });
+    });
+
+
+    describe('watch', function() {
+
+      it('should allow listeners to be registered', function() {
+        expectAsserts(1);
+
+        browser.watchCookies(function(cookies) {
+          assertEquals({'aaa':'bbb'}, cookies);
+        });
+
+        browser.cookies('aaa','bbb');
+        browser.cookies();
+      });
+
+
+      it('should fire listeners when cookie changes are discovered', function() {
+        expectAsserts(1);
+
+        browser.watchCookies(function(cookies) {
+          assertEquals({'foo':'bar'}, cookies);
+        });
+
+        document.cookie = 'foo=bar';
+        browser.cookies();
+      });
+
+
+      it('should not fire listeners when no cookies were changed', function() {
+        expectAsserts(0);
+
+        browser.cookies(function(cookies) {
+          assertEquals({'shouldnt':'fire'}, cookies);
+        });
+
+        browser.cookies(true);
+      });
+    });
+
+
+    it('should pick up external changes made to browser cookies', function() {
+      browser.cookies('oatmealCookie', 'drool');
+      expect(browser.cookies()).toEqual({'oatmealCookie':'drool'});
+
+      document.cookie = 'oatmealCookie=changed';
+      browser.cookies(true);
+      expect(browser.cookies().oatmealCookie).toEqual('changed');
+    });
+
+
+    it('should initialize cookie cache with existing cookies', function() {
+      document.cookie = "existingCookie=existingValue";
+      expect(browser.cookies()).toEqual({'existingCookie':'existingValue'});
+    });
+
+  });
 });
+