| New file |
|---|
| 0,0 → 1,632 |
|---|
| 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); |
| } |
| |
| } |