Subversion Repositories Applications.papyrus

if(!dojo._hasResource["dojox.off.files"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
dojo._hasResource["dojox.off.files"] = true;
dojo.provide("dojox.off.files");

// Author: Brad Neuberg, bkn3@columbia.edu, http://codinginparadise.org

// summary:
//      Helps maintain resources that should be
//      available offline, such as CSS files.
// description:
//      dojox.off.files makes it easy to indicate
//      what resources should be available offline,
//      such as CSS files, JavaScript, HTML, etc.
dojox.off.files = {
        // versionURL: String
        //      An optional file, that if present, records the version
        //      of our bundle of files to make available offline. If this
        //      file is present, and we are not currently debugging,
        //      then we only refresh our offline files if the version has
        //      changed. 
        versionURL: "version.js",
        
        // listOfURLs: Array
        //      For advanced usage; most developers can ignore this.
        //      Our list of URLs that will be cached and made available
        //      offline.
        listOfURLs: [],
        
        // refreshing: boolean
        //      For advanced usage; most developers can ignore this.
        //      Whether we are currently in the middle
        //      of refreshing our list of offline files.
        refreshing: false,

        _cancelID: null,
        
        _error: false,
        _errorMessages: [],
        _currentFileIndex: 0,
        _store: null,
        _doSlurp: false,
        
        slurp: function(){
                // summary:
                //      Autoscans the page to find all resources to
                //      cache. This includes scripts, images, CSS, and hyperlinks
                //      to pages that are in the same scheme/port/host as this
                //      page. We also scan the embedded CSS of any stylesheets
                //      to find @import statements and url()'s.
                //  You should call this method from the top-level, outside of
                //      any functions and before the page loads:
                //
                //      <script>
                //              dojo.require("dojox.sql");
                //              dojo.require("dojox.off");
                //              dojo.require("dojox.off.ui");
                //              dojo.require("dojox.off.sync");
                //
                //              // configure how we should work offline
                //
                //              // set our application name
                //              dojox.off.ui.appName = "Moxie";
                //
                //              // automatically "slurp" the page and
                //              // capture the resources we need offline
                //              dojox.off.files.slurp();
                //
                //              // tell Dojo Offline we are ready for it to initialize itself now
                //              // that we have finished configuring it for our application
                //              dojox.off.initialize();
                //      </script>
                //
                //      Note that inline styles on elements are not handled (i.e.
                //      if you somehow have an inline style that uses a URL);
                //      object and embed tags are not scanned since their format
                //      differs based on type; and elements created by JavaScript
                //      after page load are not found. For these you must manually
                //      add them with a dojox.off.files.cache() method call.
                
                // just schedule the slurp once the page is loaded and
                // Dojo Offline is ready to slurp; dojox.off will call
                // our _slurp() method before indicating it is finished
                // loading
                this._doSlurp = true;
        },
        
        cache: function(urlOrList){ /* void */
                // summary:
                //              Caches a file or list of files to be available offline. This
                //              can either be a full URL, such as http://foobar.com/index.html,
                //              or a relative URL, such as ../index.html. This URL is not
                //              actually cached until dojox.off.sync.synchronize() is called.
                // urlOrList: String or Array[]
                //              A URL of a file to cache or an Array of Strings of files to
                //              cache
                
                //console.debug("dojox.off.files.cache, urlOrList="+urlOrList);
                
                if(dojo.isString(urlOrList)){
                        var url = this._trimAnchor(urlOrList+"");
                        if(!this.isAvailable(url)){ 
                                this.listOfURLs.push(url); 
                        }
                }else if(urlOrList instanceof dojo._Url){
                        var url = this._trimAnchor(urlOrList.uri);
                        if(!this.isAvailable(url)){ 
                                this.listOfURLs.push(url); 
                        }
                }else{
                        dojo.forEach(urlOrList, function(url){
                                url = this._trimAnchor(url);
                                if(!this.isAvailable(url)){ 
                                        this.listOfURLs.push(url); 
                                }
                        }, this);
                }
        },
        
        printURLs: function(){
                // summary:
                //      A helper function that will dump and print out
                //      all of the URLs that are cached for offline
                //      availability. This can help with debugging if you
                //      are trying to make sure that all of your URLs are
                //      available offline
                console.debug("The following URLs are cached for offline use:");
                dojo.forEach(this.listOfURLs, function(i){
                        console.debug(i);
                });     
        },
        
        remove: function(url){ /* void */
                // summary:
                //              Removes a URL from the list of files to cache.
                // description:
                //              Removes a URL from the list of URLs to cache. Note that this
                //              does not actually remove the file from the offline cache;
                //              instead, it just prevents us from refreshing this file at a
                //              later time, so that it will naturally time out and be removed
                //              from the offline cache
                // url: String
                //              The URL to remove
                for(var i = 0; i < this.listOfURLs.length; i++){
                        if(this.listOfURLs[i] == url){
                                this.listOfURLs = this.listOfURLs.splice(i, 1);
                                break;
                        }
                }
        },
        
        isAvailable: function(url){ /* boolean */
                // summary:
                //              Determines whether the given resource is available offline.
                // url: String
                //      The URL to check
                for(var i = 0; i < this.listOfURLs.length; i++){
                        if(this.listOfURLs[i] == url){
                                return true;
                        }
                }
                
                return false;
        },
        
        refresh: function(callback){ /* void */
                //console.debug("dojox.off.files.refresh");
                // summary:
                //      For advanced usage; most developers can ignore this.
                //      Refreshes our list of offline resources,
                //      making them available offline.
                // callback: Function
                //      A callback that receives two arguments: whether an error
                //      occurred, which is a boolean; and an array of error message strings
                //      with details on errors encountered. If no error occured then message is
                //      empty array with length 0.
                try{
                        if(djConfig.isDebug){
                                this.printURLs();
                        }
                        
                        this.refreshing = true;
                        
                        if(this.versionURL){
                                this._getVersionInfo(function(oldVersion, newVersion, justDebugged){
                                        //console.warn("getVersionInfo, oldVersion="+oldVersion+", newVersion="+newVersion
                                        //                              + ", justDebugged="+justDebugged+", isDebug="+djConfig.isDebug);
                                        if(djConfig.isDebug || !newVersion || justDebugged 
                                                        || !oldVersion || oldVersion != newVersion){
                                                console.warn("Refreshing offline file list");
                                                this._doRefresh(callback, newVersion);
                                        }else{
                                                console.warn("No need to refresh offline file list");
                                                callback(false, []);
                                        }
                                });
                        }else{
                                console.warn("Refreshing offline file list");
                                this._doRefresh(callback);
                        }
                }catch(e){
                        this.refreshing = false;
                       
                        // can't refresh files -- core operation --
                        // fail fast
                        dojox.off.coreOpFailed = true;
                        dojox.off.enabled = false;
                        dojox.off.onFrameworkEvent("coreOperationFailed");
                }
        },
        
        abortRefresh: function(){
                // summary:
                //      For advanced usage; most developers can ignore this.
                //      Aborts and cancels a refresh.
                if(!this.refreshing){
                        return;
                }
                
                this._store.abortCapture(this._cancelID);
                this.refreshing = false;
        },
        
        _slurp: function(){
                if(!this._doSlurp){
                        return;
                }
                
                var handleUrl = dojo.hitch(this, function(url){
                        if(this._sameLocation(url)){
                                this.cache(url);
                        }
                });
                
                handleUrl(window.location.href);
                
                dojo.query("script").forEach(function(i){
                        try{
                                handleUrl(i.getAttribute("src"));
                        }catch(exp){
                                //console.debug("dojox.off.files.slurp 'script' error: " 
                                //                              + exp.message||exp);
                        }
                });
                
                dojo.query("link").forEach(function(i){
                        try{
                                if(!i.getAttribute("rel")
                                        || i.getAttribute("rel").toLowerCase() != "stylesheet"){
                                        return;
                                }
                        
                                handleUrl(i.getAttribute("href"));
                        }catch(exp){
                                //console.debug("dojox.off.files.slurp 'link' error: " 
                                //                              + exp.message||exp);
                        }
                });
                
                dojo.query("img").forEach(function(i){
                        try{
                                handleUrl(i.getAttribute("src"));
                        }catch(exp){
                                //console.debug("dojox.off.files.slurp 'img' error: " 
                                //                              + exp.message||exp);
                        }
                });
                
                dojo.query("a").forEach(function(i){
                        try{
                                handleUrl(i.getAttribute("href"));
                        }catch(exp){
                                //console.debug("dojox.off.files.slurp 'a' error: " 
                                //                              + exp.message||exp);
                        }
                });
                
                // FIXME: handle 'object' and 'embed' tag
                
                // parse our style sheets for inline URLs and imports
                dojo.forEach(document.styleSheets, function(sheet){
                        try{
                                if(sheet.cssRules){ // Firefox
                                        dojo.forEach(sheet.cssRules, function(rule){
                                                var text = rule.cssText;
                                                if(text){
                                                        var matches = text.match(/url\(\s*([^\) ]*)\s*\)/i);
                                                        if(!matches){
                                                                return;
                                                        }
                                                        
                                                        for(var i = 1; i < matches.length; i++){
                                                                handleUrl(matches[i])
                                                        }
                                                }
                                        });
                                }else if(sheet.cssText){ // IE
                                        var matches;
                                        var text = sheet.cssText.toString();
                                        // unfortunately, using RegExp.exec seems to be flakey
                                        // for looping across multiple lines on IE using the
                                        // global flag, so we have to simulate it
                                        var lines = text.split(/\f|\r|\n/);
                                        for(var i = 0; i < lines.length; i++){
                                                matches = lines[i].match(/url\(\s*([^\) ]*)\s*\)/i);
                                                if(matches && matches.length){
                                                        handleUrl(matches[1]);
                                                }
                                        }
                                }
                        }catch(exp){
                                //console.debug("dojox.off.files.slurp stylesheet parse error: " 
                                //                              + exp.message||exp);
                        }
                });
                
                //this.printURLs();
        },
        
        _sameLocation: function(url){
                if(!url){ return false; }
                
                // filter out anchors
                if(url.length && url.charAt(0) == "#"){
                        return false;
                }
                
                // FIXME: dojo._Url should be made public;
                // it's functionality is very useful for
                // parsing URLs correctly, which is hard to
                // do right
                url = new dojo._Url(url);
                
                // totally relative -- ../../someFile.html
                if(!url.scheme && !url.port && !url.host){ 
                        return true;
                }
                
                // scheme relative with port specified -- brad.com:8080
                if(!url.scheme && url.host && url.port
                                && window.location.hostname == url.host
                                && window.location.port == url.port){
                        return true;
                }
                
                // scheme relative with no-port specified -- brad.com
                if(!url.scheme && url.host && !url.port
                        && window.location.hostname == url.host
                        && window.location.port == 80){
                        return true;
                }
                
                // else we have everything
                return  window.location.protocol == (url.scheme + ":")
                                && window.location.hostname == url.host
                                && (window.location.port == url.port || !window.location.port && !url.port);
        },
        
        _trimAnchor: function(url){
                return url.replace(/\#.*$/, "");
        },
        
        _doRefresh: function(callback, newVersion){
                // get our local server
                var localServer;
                try{
                        localServer = google.gears.factory.create("beta.localserver", "1.0");
                }catch(exp){
                        dojo.setObject("google.gears.denied", true);
                        dojox.off.onFrameworkEvent("coreOperationFailed");
                        throw "Google Gears must be allowed to run";
                }
                
                var storeName = "dot_store_" 
                                                        + window.location.href.replace(/[^0-9A-Za-z_]/g, "_");
                        
                // refresh everything by simply removing
                // any older stores
                localServer.removeStore(storeName);
                
                // open/create the resource store
                localServer.openStore(storeName);
                var store = localServer.createStore(storeName);
                this._store = store;

                // add our list of files to capture
                var self = this;
                this._currentFileIndex = 0;
                this._cancelID = store.capture(this.listOfURLs, function(url, success, captureId){
                        //console.debug("store.capture, url="+url+", success="+success);
                        if(!success && self.refreshing){
                                self._cancelID = null;
                                self.refreshing = false;
                                var errorMsgs = [];
                                errorMsgs.push("Unable to capture: " + url);
                                callback(true, errorMsgs);
                                return;
                        }else if(success){
                                self._currentFileIndex++;
                        }
                        
                        if(success && self._currentFileIndex >= self.listOfURLs.length){
                                self._cancelID = null;
                                self.refreshing = false;
                                if(newVersion){
                                        dojox.storage.put("oldVersion", newVersion, null,
                                                                        dojox.off.STORAGE_NAMESPACE);
                                }
                                dojox.storage.put("justDebugged", djConfig.isDebug, null,
                                                                        dojox.off.STORAGE_NAMESPACE);
                                callback(false, []);
                        }
                });
        },
        
        _getVersionInfo: function(callback){
                var justDebugged = dojox.storage.get("justDebugged", 
                                                                        dojox.off.STORAGE_NAMESPACE);
                var oldVersion = dojox.storage.get("oldVersion",
                                                                        dojox.off.STORAGE_NAMESPACE);
                var newVersion = null;
                
                callback = dojo.hitch(this, callback);
                
                dojo.xhrGet({
                                url: this.versionURL + "?browserbust=" + new Date().getTime(),
                                timeout: 5 * 1000,
                                handleAs: "javascript",
                                error: function(err){
                                        //console.warn("dojox.off.files._getVersionInfo, err=",err);
                                        dojox.storage.remove("oldVersion", dojox.off.STORAGE_NAMESPACE);
                                        dojox.storage.remove("justDebugged", dojox.off.STORAGE_NAMESPACE);
                                        callback(oldVersion, newVersion, justDebugged);
                                },
                                load: function(data){
                                        //console.warn("dojox.off.files._getVersionInfo, load=",data);
                                        
                                        // some servers incorrectly return 404's
                                        // as a real page
                                        if(data){
                                                newVersion = data;
                                        }
                                        
                                        callback(oldVersion, newVersion, justDebugged);
                                }
                });
        }
}

}