| New file |
|---|
| 0,0 → 1,278 |
|---|
| if(!dojo._hasResource["dojox.storage.WhatWGStorageProvider"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. |
| dojo._hasResource["dojox.storage.WhatWGStorageProvider"] = true; |
| dojo.provide("dojox.storage.WhatWGStorageProvider"); |
| dojo.require("dojox.storage.Provider"); |
| dojo.require("dojox.storage.manager"); |
| |
| dojo.declare("dojox.storage.WhatWGStorageProvider", [ dojox.storage.Provider ], { |
| // summary: |
| // Storage provider that uses WHAT Working Group features in Firefox 2 |
| // to achieve permanent storage. |
| // description: |
| // The WHAT WG storage API is documented at |
| // http://www.whatwg.org/specs/web-apps/current-work/#scs-client-side |
| // |
| // You can disable this storage provider with the following djConfig |
| // variable: |
| // var djConfig = { disableWhatWGStorage: true }; |
| // |
| // Authors of this storage provider- |
| // JB Boisseau, jb.boisseau@eutech-ssii.com |
| // Brad Neuberg, bkn3@columbia.edu |
| |
| initialized: false, |
| |
| _domain: null, |
| _available: null, |
| _statusHandler: null, |
| _allNamespaces: null, |
| _storageEventListener: null, |
| |
| initialize: function(){ |
| if(djConfig["disableWhatWGStorage"] == true){ |
| return; |
| } |
| |
| // get current domain |
| // see: https://bugzilla.mozilla.org/show_bug.cgi?id=357323 |
| this._domain = (location.hostname == "localhost") ? "localhost.localdomain" : location.hostname; |
| // console.debug(this._domain); |
| |
| // indicate that this storage provider is now loaded |
| this.initialized = true; |
| dojox.storage.manager.loaded(); |
| }, |
| |
| isAvailable: function(){ |
| try{ |
| // see: https://bugzilla.mozilla.org/show_bug.cgi?id=357323 |
| var myStorage = globalStorage[((location.hostname == "localhost") ? "localhost.localdomain" : location.hostname)]; |
| }catch(e){ |
| this._available = false; |
| return this._available; |
| } |
| |
| this._available = true; |
| return this._available; |
| }, |
| |
| put: function(key, value, resultsHandler, namespace){ |
| if(this.isValidKey(key) == false){ |
| throw new Error("Invalid key given: " + key); |
| } |
| namespace = namespace||this.DEFAULT_NAMESPACE; |
| |
| // get our full key name, which is namespace + key |
| key = this.getFullKey(key, namespace); |
| |
| this._statusHandler = resultsHandler; |
| |
| // serialize the value; |
| // handle strings differently so they have better performance |
| if(dojo.isString(value)){ |
| value = "string:" + value; |
| }else{ |
| value = dojo.toJson(value); |
| } |
| |
| // register for successful storage events. |
| var storageListener = dojo.hitch(this, function(evt){ |
| // remove any old storage event listener we might have added |
| // to the window on old put() requests; Firefox has a bug |
| // where it can occassionaly go into infinite loops calling |
| // our storage event listener over and over -- this is a |
| // workaround |
| // FIXME: Simplify this into a test case and submit it |
| // to Firefox |
| window.removeEventListener("storage", storageListener, false); |
| |
| // indicate we succeeded |
| if(resultsHandler){ |
| resultsHandler.call(null, this.SUCCESS, key); |
| } |
| }); |
| |
| window.addEventListener("storage", storageListener, false); |
| |
| // try to store the value |
| try{ |
| var myStorage = globalStorage[this._domain]; |
| myStorage.setItem(key, value); |
| }catch(e){ |
| // indicate we failed |
| this._statusHandler.call(null, this.FAILED, key, e.toString()); |
| } |
| }, |
| |
| get: function(key, namespace){ |
| if(this.isValidKey(key) == false){ |
| throw new Error("Invalid key given: " + key); |
| } |
| namespace = namespace||this.DEFAULT_NAMESPACE; |
| |
| // get our full key name, which is namespace + key |
| key = this.getFullKey(key, namespace); |
| |
| // sometimes, even if a key doesn't exist, Firefox |
| // will return a blank string instead of a null -- |
| // this _might_ be due to having underscores in the |
| // keyname, but I am not sure. |
| |
| // FIXME: Simplify this bug into a testcase and |
| // submit it to Firefox |
| var myStorage = globalStorage[this._domain]; |
| var results = myStorage.getItem(key); |
| |
| if(results == null || results == ""){ |
| return null; |
| } |
| |
| results = results.value; |
| |
| // destringify the content back into a |
| // real JavaScript object; |
| // handle strings differently so they have better performance |
| if(dojo.isString(results) && (/^string:/.test(results))){ |
| results = results.substring("string:".length); |
| }else{ |
| results = dojo.fromJson(results); |
| } |
| |
| return results; |
| }, |
| |
| getNamespaces: function(){ |
| var results = [ this.DEFAULT_NAMESPACE ]; |
| |
| // simply enumerate through our array and save any string |
| // that starts with __ |
| var found = {}; |
| var myStorage = globalStorage[this._domain]; |
| var tester = /^__([^_]*)_/; |
| for(var i = 0; i < myStorage.length; i++){ |
| var currentKey = myStorage.key(i); |
| if(tester.test(currentKey) == true){ |
| var currentNS = currentKey.match(tester)[1]; |
| // have we seen this namespace before? |
| if(typeof found[currentNS] == "undefined"){ |
| found[currentNS] = true; |
| results.push(currentNS); |
| } |
| } |
| } |
| |
| return results; |
| }, |
| |
| getKeys: function(namespace){ |
| namespace = namespace||this.DEFAULT_NAMESPACE; |
| |
| if(this.isValidKey(namespace) == false){ |
| throw new Error("Invalid namespace given: " + namespace); |
| } |
| |
| // create a regular expression to test the beginning |
| // of our key names to see if they match our namespace; |
| // if it is the default namespace then test for the presence |
| // of no namespace for compatibility with older versions |
| // of dojox.storage |
| var namespaceTester; |
| if(namespace == this.DEFAULT_NAMESPACE){ |
| namespaceTester = new RegExp("^([^_]{2}.*)$"); |
| }else{ |
| namespaceTester = new RegExp("^__" + namespace + "_(.*)$"); |
| } |
| |
| var myStorage = globalStorage[this._domain]; |
| var keysArray = []; |
| for(var i = 0; i < myStorage.length; i++){ |
| var currentKey = myStorage.key(i); |
| if(namespaceTester.test(currentKey) == true){ |
| // strip off the namespace portion |
| currentKey = currentKey.match(namespaceTester)[1]; |
| keysArray.push(currentKey); |
| } |
| } |
| |
| return keysArray; |
| }, |
| |
| clear: function(namespace){ |
| namespace = namespace||this.DEFAULT_NAMESPACE; |
| |
| if(this.isValidKey(namespace) == false){ |
| throw new Error("Invalid namespace given: " + namespace); |
| } |
| |
| // create a regular expression to test the beginning |
| // of our key names to see if they match our namespace; |
| // if it is the default namespace then test for the presence |
| // of no namespace for compatibility with older versions |
| // of dojox.storage |
| var namespaceTester; |
| if(namespace == this.DEFAULT_NAMESPACE){ |
| namespaceTester = new RegExp("^[^_]{2}"); |
| }else{ |
| namespaceTester = new RegExp("^__" + namespace + "_"); |
| } |
| |
| var myStorage = globalStorage[this._domain]; |
| var keys = []; |
| for(var i = 0; i < myStorage.length; i++){ |
| if(namespaceTester.test(myStorage.key(i)) == true){ |
| keys[keys.length] = myStorage.key(i); |
| } |
| } |
| |
| dojo.forEach(keys, dojo.hitch(myStorage, "removeItem")); |
| }, |
| |
| remove: function(key, namespace){ |
| // get our full key name, which is namespace + key |
| key = this.getFullKey(key, namespace); |
| |
| var myStorage = globalStorage[this._domain]; |
| myStorage.removeItem(key); |
| }, |
| |
| isPermanent: function(){ |
| return true; |
| }, |
| |
| getMaximumSize: function(){ |
| return this.SIZE_NO_LIMIT; |
| }, |
| |
| hasSettingsUI: function(){ |
| return false; |
| }, |
| |
| showSettingsUI: function(){ |
| throw new Error(this.declaredClass + " does not support a storage settings user-interface"); |
| }, |
| |
| hideSettingsUI: function(){ |
| throw new Error(this.declaredClass + " does not support a storage settings user-interface"); |
| }, |
| |
| getFullKey: function(key, namespace){ |
| namespace = namespace||this.DEFAULT_NAMESPACE; |
| |
| if(this.isValidKey(namespace) == false){ |
| throw new Error("Invalid namespace given: " + namespace); |
| } |
| |
| // don't append a namespace string for the default namespace, |
| // for compatibility with older versions of dojox.storage |
| if(namespace == this.DEFAULT_NAMESPACE){ |
| return key; |
| }else{ |
| return "__" + namespace + "_" + key; |
| } |
| } |
| }); |
| |
| dojox.storage.manager.register("dojox.storage.WhatWGStorageProvider", |
| new dojox.storage.WhatWGStorageProvider()); |
| |
| } |