dojox/dtl/_base.js

  • Provides:

    • dojox.dtl._base

  • Requires:

    • dojox.string.Builder in common
    • dojox.string.tokenize in common
    • dojox.string.Builder in common

  • dojox.dtl.TOKEN_BLOCK

    • summary
  • dojox.dtl.TOKEN_VAR
       
    • summary
  • dojox.dtl.TOKEN_COMMENT
       
    • summary
  • dojox.dtl.TOKEN_TEXT
       
    • summary
  • dojox.dtl._Context
       
    • type
      Function
    • parameters: 
      • dict: (typeof )
    • source: [view] 
                    
      

                      if(dict){
         dojo._mixin(this, dict);
         if(dict.get){
          // Preserve passed getter and restore prototype get
          this._getter = dict.get;
          delete this.get;
         }
        }
                    
      
                    
    • summary
      Pass one of these when rendering a template to tell the template what values to use.
  • dojox.dtl.Template
       
    • type
      Function
    • parameters: 
      • template: (typeof String|dojo._Url)
        The string or location of the string to
use as a template
      • isString: (typeof Boolean)
    • source: [view] 
                    
      

                      var str = isString ? template : ddt._resolveTemplateArg(template, true) || "";
        var tokens = ddt.tokenize(str);
        var parser = new dd._Parser(tokens);
        this.nodelist = parser.parse();
                    
      
                    
    • summary
  • dojox.dtl._QuickNodeList
       
    • type
      Function
    • parameters: 
      • contents: (typeof )
    • source: [view] 
                    
      

                      this.contents = contents;
                    
      
                    
    • summary
  • dojox.dtl._Filter
       
    • type
      Function
    • parameters: 
      • token: (typeof )
    • source: [view] 
                    
      

                      if(!token) throw new Error("Filter must be called with variable name");
        this.contents = token;


        var cache = this._cache[token];
        if(cache){
         this.key = cache[0];
         this.filters = cache[1];
        }else{
         this.filters = [];
         dojox.string.tokenize(token, this._re, this._tokenize, this);
         this._cache[token] = [this.key, this.filters];
        }
                    
      
                    
    • summary
      Uses a string to find (and manipulate) a variable
  • dojox.dtl._TextNode
       
    • summary
  • dojox.dtl._NodeList
       
    • type
      Function
    • parameters: 
      • nodes: (typeof Node[])
    • source: [view] 
                    
      

                      this.contents = nodes || [];
        this.last = "";
                    
      
                    
    • summary
      Allows us to render a group of nodes
  • dojox.dtl._VarNode
       
    • type
      Function
    • parameters: 
      • str: (typeof )
    • source: [view] 
                    
      

                      this.contents = new dd._Filter(str);
                    
      
                    
    • summary
      A node to be processed as a variable
  • dojox.dtl._noOpNode
       
    • summary
  • dojox.dtl._Parser
       
    • type
      Function
    • parameters: 
      • tokens: (typeof )
    • source: [view] 
                    
      

                      this.contents = tokens;
                    
      
                    
    • summary
      Parser used during initialization and for tag groups.
  • dojox.dtl.register
       
    • type
      Object
    • summary
  • dojox.dtl.mark_safe
       
    • summary
  • dojox.dtl.Token
       
    • type
      Function
    • parameters: 
      • token_type: (typeof )
      • contents: (typeof )
    • source: [view] 
                    
      

                      this.token_type = token_type;
        this.contents = new String(dojo.trim(contents));
        this.contents.split = split;
        this.split = function(){
         return String.prototype.split.apply(this.contents, arguments);
        }
                    
      
                    
    • chains: 
      • String.prototype.split: (call)
    • summary
  • dojox.dtl.Token.token_type
       
    • summary
  • dojox.dtl.Token.contents
       
    • summary
  • dojox.dtl.Token.contents.split
       
    • summary
  • dojox.dtl.Token.split
       
    • type
      Function
    • source: [view] 
                    
      

                       return String.prototype.split.apply(this.contents, arguments);
                    
      
                    
    • chains: 
      • String.prototype.split: (call)
    • summary
  • dojox.dtl.Token.split_contents
       
    • type
      Function
    • parameters: 
      • limit: (typeof Integer)
    • source: [view] 
                    
      

                      var bit, bits = [], i = 0;
        limit = limit || 999;
        while(i++ < limit && (bit = smart_split_re.exec(this.contents))){
         bit = bit[0];
         if(bit.charAt(0) == '"' && bit.slice(-1) == '"'){
          bits.push('"' + bit.slice(1, -1).replace('\\"', '"').replace('\\\\', '\\') + '"');
         }else if(bit.charAt(0) == "'" && bit.slice(-1) == "'"){
          bits.push("'" + bit.slice(1, -1).replace("\\'", "'").replace('\\\\', '\\') + "'");
         }else{
          bits.push(bit);
         }
        }
        return bits;
                    
      
                    
    • summary
  • dojox.dtl.quickFilter
       
    • type
      Function
    • parameters: 
      • str: (typeof )
    • source: [view] 
                    
      

                      if(!str){
         return new dd._NodeList();
        }


        if(str.indexOf("{%") == -1){
         return new dd._QuickNodeList(dojox.string.tokenize(str, qfRe, function(token){
          return new dd._Filter(token);
         }));
        }
                    
      
                    
    • summary
  • dojox.dtl._base.escape
       
    • type
      Function
    • parameters: 
      • value: (typeof )
    • source: [view] 
                    
      

                      return dd.mark_safe(value.replace(escapeamp, '&').replace(escapelt, '<').replace(escapegt, '>').replace(escapedblqt, '"').replace(escapeqt, '''));
                    
      
                    
    • summary
      Escapes a string's HTML
  • dojox.dtl._base.safe
       
    • type
      Function
    • parameters: 
      • value: (typeof )
    • source: [view] 
                    
      

                      if(typeof value == "string"){
         value = new String(value);
        }
        if(typeof value == "object"){
         value.safe = true;
        }
        return value;
                    
      
                    
    • summary
  • dojox.dtl.text._get
       
    • type
      Function
    • parameters: 
      • module: (typeof )
      • name: (typeof )
      • errorless: (typeof )
    • source: [view] 
                    
      

                       var params = dd.register.get(module, name.toLowerCase(), errorless);
         if(!params){
          if(!errorless){
           throw new Error("No tag found for " + name);
          }
          return null;
         }


         var fn = params[1];
         var require = params[2];


         var parts;
         if(fn.indexOf(":") != -1){
          parts = fn.split(":");
          fn = parts.pop();
         }


         dojo["require"](require);


         var parent = dojo.getObject(require);


         return parent[fn || name] || parent[name + "_"] || parent[fn + "_"];
                    
      
                    
    • summary
      Used to find both tags and filters
  • dojox.dtl.text.getTag
       
    • type
      Function
    • parameters: 
      • name: (typeof )
      • errorless: (typeof )
    • source: [view] 
                    
      

                       return ddt._get("tag", name, errorless);
                    
      
                    
    • summary
  • dojox.dtl.text.getFilter
       
    • type
      Function
    • parameters: 
      • name: (typeof )
      • errorless: (typeof )
    • source: [view] 
                    
      

                       return ddt._get("filter", name, errorless);
                    
      
                    
    • summary
  • dojox.dtl.text.getTemplate
       
    • type
      Function
    • parameters: 
      • file: (typeof )
    • source: [view] 
                    
      

                       return new dd.Template(ddt.getTemplateString(file));
                    
      
                    
    • summary
  • dojox.dtl.text.getTemplateString
       
    • type
      Function
    • parameters: 
      • file: (typeof )
    • source: [view] 
                    
      

                       return dojo._getText(file.toString()) || "";
                    
      
                    
    • summary
  • dojox.dtl.text._resolveLazy
       
    • type
      Function
    • parameters: 
      • location: (typeof )
      • sync: (typeof )
      • json: (typeof )
    • source: [view] 
                    
      

                       if(sync){
          if(json){
           return dojo.fromJson(dojo._getText(location)) || {};
          }else{
           return dd.text.getTemplateString(location);
          }
         }else{
          return dojo.xhrGet({
           handleAs: (json) ? "json" : "text",
           url: location
          });
         }
                    
      
                    
    • summary
  • dojox.dtl.text._resolveTemplateArg
       
    • type
      Function
    • parameters: 
      • arg: (typeof )
      • sync: (typeof )
    • source: [view] 
                    
      

                       if(ddt._isTemplate(arg)){
          if(!sync){
           var d = new dojo.Deferred();
           d.callback(arg);
           return d;
          }
          return arg;
         }
         return ddt._resolveLazy(arg, sync);
                    
      
                    
    • summary
  • dojox.dtl.text._isTemplate
       
    • type
      Function
    • parameters: 
      • arg: (typeof )
    • source: [view] 
                    
      

                       return (typeof arg == "undefined") || (typeof arg == "string" && (arg.match(/^\s*[<{]/) || arg.indexOf(" ") != -1));
                    
      
                    
    • summary
  • dojox.dtl.text._resolveContextArg
       
    • type
      Function
    • parameters: 
      • arg: (typeof )
      • sync: (typeof )
    • source: [view] 
                    
      

                       if(arg.constructor == Object){
          if(!sync){
           var d = new dojo.Deferred;
           d.callback(arg);
           return d;
          }
          return arg;
         }
         return ddt._resolveLazy(arg, sync, true);
                    
      
                    
    • summary
  • dojox.dtl.text._re
       
    • summary
  • dojox.dtl.text.tokenize
       
    • type
      Function
    • parameters: 
      • str: (typeof )
    • source: [view] 
                    
      

                       return dojox.string.tokenize(str, ddt._re, ddt._parseDelims);
                    
      
                    
    • summary
  • dojox.dtl.text._parseDelims
       
    • type
      Function
    • parameters: 
      • varr: (typeof )
      • load: (typeof )
      • tag: (typeof )
    • source: [view] 
                    
      

                       if(varr){
          return [dd.TOKEN_VAR, varr];
         }else if(load){
          var parts = dojo.trim(tag).split(/\s+/g);
          for(var i = 0, part; part = parts[i]; i++){
           dojo["require"](part);
          }
         }else{
          return [dd.TOKEN_BLOCK, tag];
         }
                    
      
                    
    • summary
  • dojox.dtl.text
       
    • type
      Object
    • summary
  • dojox.dtl.register._registry.attributes
       
    • summary
  • dojox.dtl.register._registry.tags
       
    • summary
  • dojox.dtl.register._registry.filters
       
    • summary
  • dojox.dtl.register._registry
       
    • type
      Object
    • summary
  • dojox.dtl.register.get
       
    • type
      Function
    • parameters: 
      • module: (typeof String)
      • name: (typeof String)
    • source: [view] 
                    
      

                       var registry = dd.register._registry[module + "s"];
         for(var i = 0, entry; entry = registry[i]; i++){
          if(typeof entry[0] == "string"){
           if(entry[0] == name){
            return entry;
           }
          }else if(name.match(entry[0])){
           return entry;
          }
         }
                    
      
                    
    • summary
  • dojox.dtl.register.getAttributeTags
       
    • type
      Function
    • source: [view] 
                    
      

                       var tags = [];
         var registry = dd.register._registry.attributes;
         for(var i = 0, entry; entry = registry[i]; i++){
          if(entry.length == 3){
           tags.push(entry);
          }else{
           var fn = dojo.getObject(entry[1]);
           if(fn && dojo.isFunction(fn)){
            entry.push(fn);
            tags.push(entry);
           }
          }
         }
         return tags;
                    
      
                    
    • summary
  • dojox.dtl.register._any
       
    • type
      Function
    • parameters: 
      • type: (typeof )
      • base: (typeof )
      • locations: (typeof )
    • source: [view] 
                    
      

                       for(var path in locations){
          for(var i = 0, fn; fn = locations[path][i]; i++){
           var key = fn;
           if(dojo.isArray(fn)){
            key = fn[0];
            fn = fn[1];
           }
           if(typeof key == "string"){
            if(key.substr(0, 5) == "attr:"){
             var attr = fn;
             if(attr.substr(0, 5) == "attr:"){
              attr = attr.slice(5);
             }
             dd.register._registry.attributes.push([attr.toLowerCase(), base + "." + path + "." + attr]);
            }
            key = key.toLowerCase()
           }
           dd.register._registry[type].push([
            key,
            fn,
            base + "." + path
           ]);
          }
         }
                    
      
                    
    • summary
  • dojox.dtl.register.tags
       
    • type
      Function
    • parameters: 
      • base: (typeof String)
      • locations: (typeof Object)
    • source: [view] 
                    
      

                       dd.register._any("tags", base, locations);
                    
      
                    
    • summary
  • dojox.dtl.register.filters
       
    • type
      Function
    • parameters: 
      • base: (typeof String)
      • locations: (typeof Object)
    • source: [view] 
                    
      

                       dd.register._any("filters", base, locations);
                    
      
                    
    • summary
  • dojox.dtl._Context._getter
       
    • summary
  • dojox.dtl._Context.push
       
    • type
      Function
    • source: [view] 
                    
      

                       var last = this;
         var context = dojo.delegate(this);
         context.pop = function(){ return last; }
         return context;
                    
      
                    
    • summary
  • dojox.dtl._Context.pop
       
    • type
      Function
    • source: [view] 
                    
      

                       throw new Error("pop() called on empty Context");
                    
      
                    
    • summary
  • dojox.dtl._Context.get
       
    • type
      Function
    • parameters: 
      • key: (typeof )
      • otherwise: (typeof )
    • source: [view] 
                    
      

                       var n = this._normalize;


         if(this._getter){
          var got = this._getter(key);
          if(typeof got != "undefined"){
           return n(got);
          }
         }


         if(typeof this[key] != "undefined"){
          return n(this[key]);
         }


         return otherwise;
                    
      
                    
    • summary
  • dojox.dtl._Context._normalize
       
    • type
      Function
    • parameters: 
      • value: (typeof )
    • source: [view] 
                    
      

                       if(value instanceof Date){
          value.year = value.getFullYear();
          value.month = value.getMonth() + 1;
          value.day = value.getDate();
          value.date = value.year + "-" + ("0" + value.month).slice(-2) + "-" + ("0" + value.day).slice(-2);
          value.hour = value.getHours();
          value.minute = value.getMinutes();
          value.second = value.getSeconds();
          value.microsecond = value.getMilliseconds();
         }
         return value;
                    
      
                    
    • summary
  • dojox.dtl._Context.update
       
    • type
      Function
    • parameters: 
      • dict: (typeof )
    • source: [view] 
                    
      

                       var context = this.push();
         if(dict){
          dojo._mixin(this, dict);
         }
         return context;
                    
      
                    
    • summary
  • dojox.dtl.Template.nodelist
       
    • summary
  • dojox.dtl.Template.update
       
    • type
      Function
    • parameters: 
      • node: (typeof DOMNode|String|dojo.NodeList)
        A node reference or set of nodes
      • context: (typeof dojo._Url|String|Object)
        The context object or location
    • source: [view] 
                    
      

                       return ddt._resolveContextArg(context).addCallback(this, function(contextObject){
          var content = this.render(new dd._Context(contextObject));
          if(node.forEach){
           node.forEach(function(item){
            item.innerHTML = content;
           });
          }else{
           dojo.byId(node).innerHTML = content;
          }
          return this;
         });
                    
      
                    
    • summary
  • dojox.dtl.Template.render
       
    • type
      Function
    • parameters: 
      • context: (typeof )
      • buffer: (typeof concatenatable)
    • source: [view] 
                    
      

                       buffer = buffer || this.getBuffer();
         context = context || new dd._Context({});
         return this.nodelist.render(context, buffer) + "";
                    
      
                    
    • summary
  • dojox.dtl.Template.getBuffer
       
    • type
      Function
    • source: [view] 
                    
      

                       dojo.require("dojox.string.Builder");
         return new dojox.string.Builder();
                    
      
                    
    • summary
  • dojox.dtl._QuickNodeList.contents
       
    • summary
  • dojox.dtl._QuickNodeList.render
       
    • type
      Function
    • parameters: 
      • context: (typeof )
      • buffer: (typeof )
    • source: [view] 
                    
      

                       for(var i=0, l=this.contents.length; i    if(this.contents[i].resolve){
           buffer = buffer.concat(this.contents[i].resolve(context));
          }else{
           buffer = buffer.concat(this.contents[i]);
          }
         }
         return buffer;
                    
      
                    
    • summary
  • dojox.dtl._QuickNodeList.dummyRender
       
    • type
      Function
    • parameters: 
      • context: (typeof )
    • source: [view] 
                    
      

                      dummyRender: function(context){ return this.render(context, dd.Template.prototype.getBuffer()).toString(); 
                    
      
                    
    • summary
  • dojox.dtl._QuickNodeList.clone
       
    • type
      Function
    • parameters: 
      • buffer: (typeof )
    • source: [view] 
                    
      

                      clone: function(buffer){ return this; 
                    
      
                    
    • summary
  • dojox.dtl._Filter.contents
       
    • summary
  • dojox.dtl._Filter.key
       
    • summary
  • dojox.dtl._Filter.filters
       
    • summary
  • dojox.dtl._Filter._cache
       
    • type
      Object
    • summary
  • dojox.dtl._Filter._re
       
    • summary
  • dojox.dtl._Filter._values
       
    • type
      Object
    • summary
  • dojox.dtl._Filter._args
       
    • type
      Object
    • summary
  • dojox.dtl._Filter._args.4
       
    • summary
  • dojox.dtl._Filter._args.5
       
    • summary
  • dojox.dtl._Filter._args.6
       
    • summary
  • dojox.dtl._Filter._args.7
       
    • summary
  • dojox.dtl._Filter._tokenize
       
    • type
      Function
    • source: [view] 
                    
      

                       var pos, arg;


         for(var i = 0, has = []; i < arguments.length; i++){
          has[i] = (typeof arguments[i] != "undefined" && typeof arguments[i] == "string" && arguments[i]);
         }


         if(!this.key){
          for(pos in this._values){
           if(has[pos]){
            this.key = this._values[pos] + arguments[pos] + this._values[pos];
            break;
           }
          }
         }else{
          for(pos in this._args){
           if(has[pos]){
            var value = arguments[pos];
            if(this._args[pos] == "'"){
             value = value.replace(/\\'/g, "'");
            }else if(this._args[pos] == '"'){
             value = value.replace(/\\"/g, '"');
            }
            arg = [!this._args[pos], value];
            break;
           }
          }
          // Get a named filter
          var fn = ddt.getFilter(arguments[3]);
          if(!dojo.isFunction(fn)) throw new Error(arguments[3] + " is not registered as a filter");
          this.filters.push([fn, arg]);
         }
                    
      
                    
    • summary
  • dojox.dtl._Filter.getExpression
       
    • type
      Function
    • source: [view] 
                    
      

                       return this.contents;
                    
      
                    
    • summary
  • dojox.dtl._Filter.resolve
       
    • type
      Function
    • parameters: 
      • context: (typeof )
    • source: [view] 
                    
      

                       if(typeof this.key == "undefined"){
          return "";
         }


         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;
                    
      
                    
    • summary
  • dojox.dtl._Filter.resolvePath
       
    • type
      Function
    • parameters: 
      • path: (typeof )
      • context: (typeof )
    • source: [view] 
                    
      

                       var current, parts;
         var first = path.charAt(0);
         var last = path.slice(-1);
         if(!isNaN(parseInt(first))){
          current = (path.indexOf(".") == -1) ? parseInt(path) : parseFloat(path);
         }else if(first == '"' && first == last){
          current = path.slice(1, -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[0]);


          if(dojo.isFunction(current)){
           var self = context.getThis && context.getThis();
           if(current.alters_data){
            current = "";
           }else if(self){
            current = current.call(self);
           }else{
            current = "";
           }
          }


          for(var i = 1; i < parts.length; i++){
           var part = parts[i];
           if(current){
            var base = current;
            if(dojo.isObject(current) && part == "items" && typeof current[part] == "undefined"){
             var items = [];
             for(var key in current){
              items.push([key, current[key]]);
             }
             current = items;
             continue;
            }


            if(current.get && dojo.isFunction(current.get) && current.get.safe){
             current = current.get(part);
            }else if(typeof current[part] == "undefined"){
             current = current[part];
             break;
            }else{
             current = current[part];
            }


            if(dojo.isFunction(current)){
             if(current.alters_data){
              current = "";
             }else{
              current = current.call(base);
             }
            }else if(current instanceof Date){
             current = dd._Context.prototype._normalize(current);
            }
           }else{
            return "";
           }
          }
         }
         return current;
                    
      
                    
    • summary
  • dojox.dtl._Node
       
    • type
      Function
    • parameters: 
      • obj: (typeof Object)
    • source: [view] 
                    
      

                      this.contents = obj;
                    
      
                    
    • summary
      Basic catch-all node
  • dojox.dtl._Node.contents
       
    • summary
  • dojox.dtl._Node.set
       
    • type
      Function
    • parameters: 
      • data: (typeof )
    • source: [view] 
                    
      

                       this.contents = data;
         return this;
                    
      
                    
    • summary
  • dojox.dtl._Node.render
       
    • type
      Function
    • parameters: 
      • context: (typeof )
      • buffer: (typeof )
    • source: [view] 
                    
      

                       return buffer.concat(this.contents);
                    
      
                    
    • summary
      Adds content onto the buffer
  • dojox.dtl._Node.isEmpty
       
    • type
      Function
    • source: [view] 
                    
      

                       return !dojo.trim(this.contents);
                    
      
                    
    • summary
  • dojox.dtl._Node.clone
       
    • type
      Function
    • source: [view] 
                    
      

                      clone: function(){ return this; 
                    
      
                    
    • summary
  • dojox.dtl._NodeList.contents
       
    • summary
  • dojox.dtl._NodeList.last
       
    • summary
  • dojox.dtl._NodeList.push
       
    • type
      Function
    • parameters: 
      • node: (typeof )
    • source: [view] 
                    
      

                       this.contents.push(node);
         return this;
                    
      
                    
    • summary
      Add a new node to the list
  • dojox.dtl._NodeList.concat
       
    • type
      Function
    • parameters: 
      • nodes: (typeof )
    • source: [view] 
                    
      

                       this.contents = this.contents.concat(nodes);
         return this;
                    
      
                    
    • summary
  • dojox.dtl._NodeList.render
       
    • type
      Function
    • parameters: 
      • context: (typeof )
      • buffer: (typeof )
    • source: [view] 
                    
      

                       for(var i = 0; i < this.contents.length; i++){
          buffer = this.contents[i].render(context, buffer);
          if(!buffer) throw new Error("Template must return buffer");
         }
         return buffer;
                    
      
                    
    • summary
      Adds all content onto the buffer
  • dojox.dtl._NodeList.dummyRender
       
    • type
      Function
    • parameters: 
      • context: (typeof )
    • source: [view] 
                    
      

                       return this.render(context, dd.Template.prototype.getBuffer()).toString();
                    
      
                    
    • summary
  • dojox.dtl._NodeList.unrender
       
    • type
      Function
    • source: [view] 
                    
      

                      unrender: function(){ return arguments[1]; 
                    
      
                    
    • summary
  • dojox.dtl._NodeList.clone
       
    • type
      Function
    • source: [view] 
                    
      

                      clone: function(){ return this; 
                    
      
                    
    • summary
  • dojox.dtl._NodeList.rtrim
       
    • type
      Function
    • source: [view] 
                    
      

                       while(1){
          i = this.contents.length - 1;
          if(this.contents[i] instanceof dd._TextNode && this.contents[i].isEmpty()){
           this.contents.pop();
          }else{
           break;
          }
         }


         return this;
                    
      
                    
    • summary
  • dojox.dtl._VarNode.contents
       
    • summary
  • dojox.dtl._VarNode.render
       
    • type
      Function
    • parameters: 
      • context: (typeof )
      • buffer: (typeof )
    • source: [view] 
                    
      

                       var str = this.contents.resolve(context);
         if(!str.safe){
          str = dd._base.escape("" + str);
         }
         return buffer.concat(str);
                    
      
                    
    • summary
  • dojox.dtl._Parser.contents
       
    • summary
  • dojox.dtl._Parser.i
       
    • summary
  • dojox.dtl._Parser.parse
       
    • type
      Function
    • parameters: 
      • stop_at: (typeof Array)
    • source: [view] 
                    
      

                       var terminators = {}, token;
         stop_at = stop_at || [];
         for(var i = 0; i < stop_at.length; i++){
          terminators[stop_at[i]] = true;
         }


         var nodelist = new dd._NodeList();
         while(this.i < this.contents.length){
          token = this.contents[this.i++];
          if(typeof token == "string"){
           nodelist.push(new dd._TextNode(token));
          }else{
           var type = token[0];
           var text = token[1];
           if(type == dd.TOKEN_VAR){
            nodelist.push(new dd._VarNode(text));
           }else if(type == dd.TOKEN_BLOCK){
            if(terminators[text]){
             --this.i;
             return nodelist;
            }
            var cmd = text.split(/\s+/g);
            if(cmd.length){
             cmd = cmd[0];
             var fn = ddt.getTag(cmd);
             if(fn){
              nodelist.push(fn(this, new dd.Token(type, text)));
             }
            }
           }
          }
         }


         if(stop_at.length){
          throw new Error("Could not find closing tag(s): " + stop_at.toString());
         }


         this.contents.length = 0;
         return nodelist;
                    
      
                    
    • 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.
  • dojox.dtl._Parser.contents.length
       
    • summary
  • dojox.dtl._Parser.next_token
       
    • type
      Function
    • source: [view] 
                    
      

                       var token = this.contents[this.i++];
         return new dd.Token(token[0], token[1]);
                    
      
                    
    • summary
      Returns the next token in the list.
  • dojox.dtl._Parser.delete_first_token
       
    • type
      Function
    • source: [view] 
                    
      

                       this.i++;
                    
      
                    
    • summary
  • dojox.dtl._Parser.skip_past
       
    • type
      Function
    • parameters: 
      • endtag: (typeof )
    • source: [view] 
                    
      

                       while(this.i < this.contents.length){
          var token = this.contents[this.i++];
          if(token[0] == dd.TOKEN_BLOCK && token[1] == endtag){
           return;
          }
         }
         throw new Error("Unclosed tag found when looking for " + endtag);
                    
      
                    
    • summary
  • dojox.dtl._Parser.create_variable_node
       
    • type
      Function
    • parameters: 
      • expr: (typeof )
    • source: [view] 
                    
      

                       return new dd._VarNode(expr);
                    
      
                    
    • summary
  • dojox.dtl._Parser.create_text_node
       
    • type
      Function
    • parameters: 
      • expr: (typeof )
    • source: [view] 
                    
      

                       return new dd._TextNode(expr || "");
                    
      
                    
    • summary
  • dojox.dtl._Parser.getTemplate
       
    • type
      Function
    • parameters: 
      • file: (typeof )
    • source: [view] 
                    
      

                       return new dd.Template(file);
                    
      
                    
    • summary
  • dojox.dtl._base
       
    • type
      Object
    • summary
  • dojox.dtl
       
    • type
      Object
    • summary
  • dojox
       
    • type
      Object
    • summary