Page MenuHomeCode
Files F886127

_base.js
No OneTemporary
Actions

_base.js
View Options

if(!dojo._hasResource["dojox.dtl._base"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
dojo._hasResource["dojox.dtl._base"] = true;
dojo.provide("dojox.dtl._base");
dojo.require("dojox.string.Builder");
dojo.require("dojox.string.tokenize");
dojox.dtl.Context = function(dict){
dojo.mixin(this, dict || {});
this._dicts = [];
this._this = {};
}
dojo.extend(dojox.dtl.Context, {
_dicts: [],
_this: {},
extend: function(/*dojox.dtl.Context|Object*/ obj){
// summary: Returns a clone of this context object, with the items from the
// passed objecct mixed in.
var context = new dojox.dtl.Context();
var keys = this.getKeys();
for(var i = 0, key; key = keys[i]; i++){
if(typeof obj[key] != "undefined"){
context[key] = obj[key];
}else{
context[key] = this[key];
}
}
if(obj instanceof dojox.dtl.Context){
keys = obj.getKeys();
}else if(typeof obj == "object"){
keys = [];
for(var key in obj){
keys.push(key);
}
}
for(var i = 0, key; key = keys[i]; i++){
context[key] = obj[key];
}
return context;
},
filter: function(/*dojox.dtl.Context|Object|String...*/ filter){
// summary: Returns a clone of this context, only containing the items
// defined in the filter.
var context = new dojox.dtl.Context();
var keys = [];
if(filter instanceof dojox.dtl.Context){
keys = filter.getKeys();
}else if(typeof filter == "object"){
for(var key in filter){
keys.push(key);
}
}else{
for(var i = 0, arg; arg = arguments[i]; i++){
if(typeof arg == "string"){
keys.push(arg);
}
}
}
for(var i = 0, key; key = keys[i]; i++){
context[key] = this[key];
}
return context;
},
setThis: function(/*Object*/ _this){
this._this = _this;
},
getThis: function(){
return this._this;
},
push: function(){
var dict = {};
var keys = this.getKeys();
for(var i = 0, key; key = keys[i]; i++){
dict[key] = this[key];
delete this[key];
}
this._dicts.unshift(dict);
},
pop: function(){
if(!this._dicts.length){
throw new Error("pop() has been called more times than push() on the Context");
}
var dict = this._dicts.shift();
dojo.mixin(this, dict);
},
hasKey: function(key){
if(typeof this[key] != "undefined"){
return true;
}
for(var i = 0, dict; dict = this._dicts[i]; i++){
if(typeof dict[key] != "undefined"){
return true;
}
}
return false;
},
getKeys: function(){
var keys = [];
for(var key in this){
if(isNaN(key)){
var found = false;
for(var protoKey in dojox.dtl.Context.prototype){
if(key == protoKey){
found = true;
break;
}
}
if(!found){
keys.push(key);
}
}
}
return keys;
},
get: function(key, otherwise){
if(typeof this[key] != "undefined"){
return this[key];
}
for(var i = 0, dict; dict = this._dicts[i]; i++){
if(typeof dict[key] != "undefined"){
return dict[key];
}
}
return otherwise;
},
update: function(dict){
this.push();
if(dict){
dojo.mixin(this, dict);
}
},
toString: function(){ return "dojox.dtl.Context"; }
});
dojox.dtl.text = {
types: {tag: -1, varr: -2, text: 3},
pySplit: function(str){
// summary: Split a string according to Python's split function
str = str.replace(/^\s+|\s+$/, "");
if(!str.length){
return [];
}
return str.split(/\s+/g);
},
urlquote: function(/*String*/ url, /*String?*/ safe){
if(!safe){
safe = "/";
}
return dojox.string.tokenize(url, /([^\w-_.])/g, function(token){
if(safe.indexOf(token) == -1){
if(token == " "){
return "+";
}else{
return "%" + token.charCodeAt(0).toString(16).toUpperCase();
}
}
return token;
}).join("");
},
_get: function(module, name, errorless){
// summary: Used to find both tags and filters
var params = dojox.dtl.register.get(module, name, errorless);
if(!params) return;
var require = params.getRequire();
var obj = params.getObj();
var fn = params.getFn();
if(fn.indexOf(":") != -1){
var parts = fn.split(":");
fn = parts.pop();
}
dojo.requireIf(true, require);
var parent = window;
var parts = obj.split(".");
for(var i = 0, part; part = parts[i]; i++){
if(!parent[part]) return;
parent = parent[part];
}
return parent[fn || name] || parent[name + "_"];
},
getTag: function(name, errorless){
return dojox.dtl.text._get("tag", name, errorless);
},
getFilter: function(name, errorless){
return dojox.dtl.text._get("filter", name, errorless);
},
getTemplate: function(file){
return new dojox.dtl.Template(dojox.dtl.getTemplateString(file));
},
getTemplateString: function(file){
return dojo._getText(file.toString()) || "";
},
_re: /(?:\{\{\s*(.+?)\s*\}\}|\{%\s*(.+?)\s*%\})/g,
tokenize: function(str){
return dojox.string.tokenize(str, dojox.dtl.text._re, dojox.dtl.text._parseDelims);
},
_parseDelims: function(varr, tag){
var types = dojox.dtl.text.types;
if(varr){
return [types.varr, varr];
}else{
return [types.tag, tag];
}
}
}
dojox.dtl.Template = function(str){
var st = dojox.dtl;
var tokens = st.text.tokenize(str);
var parser = new st.Parser(tokens);
this.nodelist = parser.parse();
}
dojo.extend(dojox.dtl.Template, {
render: function(context, /*concatenatable?*/ buffer){
context = context || new dojox.dtl.Context({});
if(!buffer){
dojo.require("dojox.string.Builder");
buffer = new dojox.string.Builder();
}
return this.nodelist.render(context, buffer) + "";
},
toString: function(){ return "dojox.dtl.Template"; }
});
dojox.dtl.Filter = function(token){
// summary: Uses a string to find (and manipulate) a variable
if(!token) throw new Error("Filter must be called with variable name");
this.contents = token;
var key = null;
var re = this._re;
var matches, filter, arg, fn;
var filters = [];
while(matches = re.exec(token)){
if(key === null){
if(this._exists(matches, 3)){
// variable
key = matches[3];
}else if(this._exists(matches, 1)){
// _("text")
key = '"' + matches[1] + '"';
}else if(this._exists(matches, 2)){
// "text"
key = '"' + matches[2] + '"';
}else if(this._exists(matches, 9)){
// 'text'
key = '"' + matches[9] + '"';
}
}else{
if(this._exists(matches, 7)){
// :variable
arg = [true, matches[7]];
}else if(this._exists(matches, 5)){
// :_("text")
arg = [false, dojox.dtl.replace(matches[5], '\\"', '"')];
}else if(this._exists(matches, 6)){
// :"text"
arg = [false, dojox.dtl.replace(matches[6], '\\"', '"')];
}else if(this._exists(matches, 8)){
// :"text"
arg = [false, dojox.dtl.replace(matches[8], "\\'", "'")];
}
// Get a named filter
fn = dojox.dtl.text.getFilter(matches[4]);
if(typeof fn != "function") throw new Error(matches[4] + " is not registered as a filter");
filters.push([fn, arg]);
}
}
this.key = key;
this.filters = filters;
}
dojo.extend(dojox.dtl.Filter, {
_re: /(?:^_\("([^\\"]*(?:\\.[^\\"])*)"\)|^"([^\\"]*(?:\\.[^\\"]*)*)"|^([a-zA-Z0-9_.]+)|\|(\w+)(?::(?:_\("([^\\"]*(?:\\.[^\\"])*)"\)|"([^\\"]*(?:\\.[^\\"]*)*)"|([a-zA-Z0-9_.]+)|'([^\\']*(?:\\.[^\\']*)*)'))?|^'([^\\']*(?:\\.[^\\']*)*)')/g,
_exists: function(arr, index){
if(typeof arr[index] != "undefined" && arr[index] !== ""){
return true;
}
return false;
},
resolve: function(context){
var str = this.resolvePath(this.key, context);
for(var i = 0, filter; filter = this.filters[i]; i++){
// Each filter has the function in [0], a boolean in [1][0] of whether it's a variable or a string
// and [1][1] is either the variable name of the string content.
if(filter[1]){
if(filter[1][0]){
str = filter[0](str, this.resolvePath(filter[1][1], context));
}else{
str = filter[0](str, filter[1][1]);
}
}else{
str = filter[0](str);
}
}
return str;
},
resolvePath: function(path, context){
var current, parts;
var first = path.charAt(0);
var last = path.charAt(path.length - 1);
if(!isNaN(parseInt(first))){
current = (path.indexOf(".") == -1) ? parseInt(path) : parseFloat(path);
}else if(first == '"' && first == last){
current = path.substring(1, path.length - 1);
}else{;
if(path == "true") return true;
if(path == "false") return false;
if(path == "null" || path == "None") return null;
parts = path.split(".");
current = context.get(parts.shift());
while(parts.length){
if(current && typeof current[parts[0]] != "undefined"){
current = current[parts[0]];
if(typeof current == "function"){
if(current.alters_data){
current = "";
}else{
current = current();
}
}
}else{
return "";
}
parts.shift();
}
}
return current;
},
toString: function(){ return "dojox.dtl.Filter"; }
});
dojox.dtl.Node = function(/*Object*/ obj){
// summary: Basic catch-all node
this.contents = obj;
}
dojo.extend(dojox.dtl.Node, {
render: function(context, buffer){
// summary: Adds content onto the buffer
return buffer.concat(this.contents);
},
toString: function(){ return "dojox.dtl.Node"; }
});
dojox.dtl.NodeList = function(/*Node[]*/ nodes){
// summary: Allows us to render a group of nodes
this.contents = nodes || [];
}
dojo.extend(dojox.dtl.NodeList, {
push: function(node){
// summary: Add a new node to the list
this.contents.push(node);
},
render: function(context, buffer){
// summary: Adds all content onto the buffer
for(var i = 0; i < this.contents.length; i++){
buffer = this.contents[i].render(context, buffer);
if(!buffer) throw new Error("Template node render functions must return their buffer");
}
return buffer;
},
unrender: function(context, buffer){ return buffer; },
clone: function(){ return this; },
toString: function(){ return "dojox.dtl.NodeList"; }
});
dojox.dtl.TextNode = dojox.dtl.Node;
dojox.dtl.VarNode = function(str){
// summary: A node to be processed as a variable
this.contents = new dojox.dtl.Filter(str);
}
dojo.extend(dojox.dtl.VarNode, {
render: function(context, buffer){
var str = this.contents.resolve(context);
return buffer.concat(str);
},
toString: function(){ return "dojox.dtl.VarNode"; }
});
dojox.dtl.Parser = function(tokens){
// summary: Parser used during initialization and for tag groups.
this.contents = tokens;
}
dojo.extend(dojox.dtl.Parser, {
parse: function(/*Array?*/ stop_at){
// summary: Turns tokens into nodes
// description: Steps into tags are they're found. Blocks use the parse object
// to find their closing tag (the stop_at array). stop_at is inclusive, it
// returns the node that matched.
var st = dojox.dtl;
var types = st.text.types;
var terminators = {};
var tokens = this.contents;
stop_at = stop_at || [];
for(var i = 0; i < stop_at.length; i++){
terminators[stop_at[i]] = true;
}
var nodelist = new st.NodeList();
while(tokens.length){
token = tokens.shift();
if(typeof token == "string"){
nodelist.push(new st.TextNode(token));
}else{
var type = token[0];
var text = token[1];
if(type == types.varr){
nodelist.push(new st.VarNode(text));
}else if(type == types.tag){
if(terminators[text]){
tokens.unshift(token);
return nodelist;
}
var cmd = text.split(/\s+/g);
if(cmd.length){
cmd = cmd[0];
var fn = dojox.dtl.text.getTag(cmd);
if(fn){
nodelist.push(fn(this, text));
}
}
}
}
}
if(stop_at.length){
throw new Error("Could not find closing tag(s): " + stop_at.toString());
}
return nodelist;
},
next: function(){
// summary: Returns the next token in the list.
var token = this.contents.shift();
return {type: token[0], text: token[1]};
},
skipPast: function(endtag){
var types = dojox.dtl.text.types;
while(this.contents.length){
var token = this.contents.shift();
if(token[0] == types.tag && token[1] == endtag){
return;
}
}
throw new Error("Unclosed tag found when looking for " + endtag);
},
getVarNode: function(){
return dojox.dtl.VarNode;
},
getTextNode: function(){
return dojox.dtl.TextNode;
},
getTemplate: function(file){
return new dojox.dtl.Template(file);
},
toString: function(){ return "dojox.dtl.Parser"; }
});
dojox.dtl.register = function(module, cols, args, /*Function*/ normalize){
// summary: Used to create dojox.dtl.register[module] function, and as a namespace
// expand: Used if the call structure is reformatted for a more compact view.
// Should return an array of normalized arguments.
// description: The function produced will accept a "name"
// as the first parameter and all other parameters will
// be associated with the parameter names listed in cols.
var ddr = dojox.dtl.register;
var registry = ddr._mod[module] = {
params: [],
Getter: function(params){
ddr._params = params || {};
}
};
cols.unshift("name");
for(var i = 0, col; col = cols[i]; i++){
registry.Getter.prototype["get" + col.substring(0, 1).toUpperCase() + col.substring(1, col.length)] = ddr._ret(i);
}
ddr[module] = function(/*String*/ name, /*mixed...*/ parameters){
if(normalize){
var normalized = normalize(arguments);
}else{
var normalized = [arguments];
}
for(var i = 0, args; args = normalized[i]; i++){
var params = [];
for(var j = 0; j < cols.length; j++){
params.push(args[j] || null);
}
if(typeof args[0] == "string"){
// Strings before regexes for speed
registry.params.unshift(params);
}else{
// break
// module RegExp
registry.params.push(params);
}
}
}
ddr[module].apply(null, args);
}
dojo.mixin(dojox.dtl.register, {
_mod: {},
_ret: function(i){
// summary: Just lets use i and _params within a closure
return function(){
return dojox.dtl.register._params[i] || "";
}
},
get: function(/*String*/ module, /*String*/ name, /*Boolean*/ errorless){
// summary: Returns a "Getter", based on the registry
// description: The getter functions correspond with the registered cols
// used in dojo.register
var registry = this._mod[module] || {};
if(registry.params){
for(var i = 0, param; param = registry.params[i]; i++){
var search = param[0];
if(typeof search == "string"){
if(search == name){
return new registry.Getter(param);
}
}else if(name.match(search)){
var matches = search.exec(name);
var mixin = [];
dojo.mixin(mixin, param);
mixin[0] = matches[1];
return new registry.Getter(param);
}
}
}
if(!errorless) throw new Error("'" + module + "' of name '" + name + "' does not exist");
},
_normalize: function(args){
// summary:
// Translates to the signature (/*String*/ name, /*String*/ require, /*String*/ obj, /*String*/ fn)
var items = args[2];
var output = [];
for(var i = 0, item; item = items[i]; i++){
if(typeof item == "string"){
output.push([item, args[0], args[1], item]);
}else{
output.push([item[0], args[0], args[1], item[1]]);
}
}
return output;
},
tag: function(/*String*/ require, /*String*/ obj, /*String[]|[RegExp, String][]*/ fns){
// summary:
// Specify the location of a given tag function.
// require:
// The file this function is in
// obj:
// The base object to use for lookups
// fn:
// List of functions within obj to use
// description:
// When we are looking up a tag as specified in a template, we either use a
// string in the fns array, or the RegExp item of the [RegExp, String] pair.
// When that string is found, it requires the file specified in the require
// parameter, uses the base object as a starting point and checks for obj.fn
// or obj.fn_ in case fn is a reserved word.
this("tag", ["require", "obj", "fn"], arguments, this._normalize);
},
filter: function(/*String*/ require, /*String*/ obj, /*String[]|[RegExp, String][]*/ fns){
// summary:
// Specify the location of a given filter function.
// require:
// The file this function is in
// obj:
// The base object to use for lookups
// fn:
// List of functions within obj to use
// description:
// When we are looking up a tag as specified in a template, we either use a
// string in the fns array, or the RegExp item of the [RegExp, String] pair.
// When that string is found, it requires the file specified in the require
// parameter, uses the base object as a starting point and checks for obj.fn
// or obj.fn_ in case fn is a reserved word.
this("filter", ["require", "obj", "fn"], arguments, this._normalize);
}
});
(function(){
var register = dojox.dtl.register;
var dtt = "dojox.dtl.tag";
register.tag(dtt + ".logic", dtt + ".logic", ["if", "for"]);
register.tag(dtt + ".loader", dtt + ".loader", ["extends", "block"]);
register.tag(dtt + ".misc", dtt + ".misc", ["comment", "debug", "filter"]);
register.tag(dtt + ".loop", dtt + ".loop", ["cycle"]);
var dtf = "dojox.dtl.filter";
register.filter(dtf + ".dates", dtf + ".dates", ["date", "time", "timesince", "timeuntil"]);
register.filter(dtf + ".htmlstrings", dtf + ".htmlstrings", ["escape", "linebreaks", "linebreaksbr", "removetags", "striptags"]);
register.filter(dtf + ".integers", dtf + ".integers", ["add", "get_digit"]);
register.filter(dtf + ".lists", dtf + ".lists", ["dictsort", "dictsortreversed", "first", "join", "length", "length_is", "random", "slice", "unordered_list"]);
register.filter(dtf + ".logic", dtf + ".logic", ["default", "default_if_none", "divisibleby", "yesno"]);
register.filter(dtf + ".misc", dtf + ".misc", ["filesizeformat", "pluralize", "phone2numeric", "pprint"]);
register.filter(dtf + ".strings", dtf + ".strings", ["addslashes", "capfirst", "center", "cut", "fix_ampersands", "floatformat", "iriencode", "linenumbers", "ljust", "lower", "make_list", "rjust", "slugify", "stringformat", "title", "truncatewords", "truncatewords_html", "upper", "urlencode", "urlize", "urlizetrunc", "wordcount", "wordwrap"]);
})();
dojox.dtl.replace = function(str, token, repl){
repl = repl || "";
var pos, len = token.length;
while(1){
pos = str.indexOf(token);
if(pos == -1) break;
str = str.substring(0, pos) + repl + str.substring(pos + len);
}
return str;
}
dojox.dtl.resolveVariable = function(token, context){
// summary: Quickly resolve a variables
var filter = new dojox.dtl.Filter(token);
return filter.resolve(context);
}
}

File Metadata

Mime Type
text/plain
Expires
Sun, Apr 6, 22:39 (2 w, 2 d ago)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
26888
Default Alt Text
_base.js (18 KB)

Event Timeline