Page MenuHomeCode
Files F881513

files.js
No OneTemporary
Actions

files.js
View Options

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);
}
});
}
}
}

File Metadata

Mime Type
text/html
Expires
Wed, Apr 2, 06:21 (4 w, 1 d ago)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
27123
Default Alt Text
files.js (12 KB)

Event Timeline