git.roojs.org Git - app.Builder.js/blob - JsRender/NodeToJs.vala

   1 /**
   2  *
   3  * Code to convert node tree to Javascript...
   4  *
   5  * usage : x = (new JsRender.NodeToJs(node)).munge();
   6  *
   7 */
   8
   9
  10
  11
  12 public class JsRender.NodeToJs : Object {
  13
  14         JsRender.Node node;
  15         Gee.ArrayList<string>  doubleStringProps;
  16         string pad;
  17
  18         public NodeToJs(JsRender.Node node, Gee.ArrayList<string> doubleStringProps)
  19         {
  20                 this.node = node;
  21                 this.doubleStringProps = doubleStringProps;
  22                 this.pad = "    ";
  23         }
  24
  25         public string munge ( )
  26         {
  27                 return this.mungeToString(this.node);
  28         }
  29
  30
  31
  32
  33         public string buildEls ( JsRender cnode)
  34         {
  35
  36
  37                 pad = pad.length < 1 ? "        " : pad;
  38
  39
  40
  41
  42                 var els = new Gee.ArrayList<string>();
  43                 var skip = new Gee.ArrayList<string>();
  44                 if (this.hasXnsType() ) {
  45                                 // this.mungeXtype(obj['|xns'] + '.' + obj['xtype'], els); ??????
  46
  47
  48                            //skip.add("|xns");
  49                            //skip.add("xtype");
  50
  51                 }
  52                 //var newitems = new Gee.ArrayList<JsRender.Node>();
  53
  54
  55
  56                 // look throught he chilren == looking for * prop.. -- fixme might not work..
  57
  58                 var ar_props = new Gee.HashMap<string,string>();
  59
  60
  61                 if (this.hasChildren()) {
  62                         // look for '*props'
  63
  64                         for (var ii =0; ii< this.items.size; ii++) {
  65                                 var pl = this.items.get(ii);
  66                                 if (!pl.props.has_key("* prop")) {
  67                                         //newitems.add(pl);
  68                                         continue;
  69                                 }
  70
  71                                 //print(JSON.stringify(pl,null,4));
  72                                 // we have a prop...
  73                                 //var prop = pl['*prop'] + '';
  74                                 //delete pl['*prop'];
  75                                 var prop = pl.get("* prop");
  76                                 print("got prop "+ prop + "\n");
  77
  78                                 // name ends in [];
  79                                 if (! Regex.match_simple("\\[\\]$", prop)) {
  80                                         // it's a standard prop..
  81
  82                                         // munge property..??
  83                                         els.add( prop  + " : " + pl.mungeToString (  pad + "    ",  doubleStringProps));
  84
  85
  86                                         //keys.push(prop);
  87                                         continue;
  88                                 }
  89
  90
  91
  92
  93                                 var sprop  = prop.replace("[]", "");
  94                                 print("sprop is : " + sprop + "\n");
  95
  96                                 // it's an array type..
  97                                 var old = "";
  98                                 if (!ar_props.has_key(sprop)) {
  99
 100                                         ar_props.set(sprop, "");
 101
 102                                 } else {
 103                                         old = ar_props.get(sprop);
 104                                 }
 105                                 var nstr  = old += old.length > 0 ? ",\n" : "";
 106                                 nstr += pl.mungeToString (  pad + "             ",  doubleStringProps);
 107
 108                                 ar_props.set(sprop, nstr);
 109
 110
 111                         }
 112
 113
 114                 }
 115
 116                 string left;
 117                 Regex func_regex ;
 118                 try {
 119                         func_regex = new Regex("^\\s+|\\s+$");
 120                 } catch (Error e) {
 121                         print("failed to build regex");
 122                         return "";
 123                 }
 124                 var piter = this.props.map_iterator();
 125                 while (piter.next() ) {
 126                         var k = piter.get_key();
 127                         var v = piter.get_value();
 128
 129                         if (skip.contains(k) ) {
 130                                 continue;
 131                         }
 132                         if (  Regex.match_simple("\\[\\]$", k)) {
 133
 134
 135
 136                         }
 137
 138                         string leftv = k[0] == '$' ? k.substring(2) : k;
 139                         // skip builder stuff. prefixed with  '.' .. just like unix fs..
 140                         if (leftv[0] == '.') { // |. or . -- do not output..
 141                                 continue;
 142                         }
 143                          if (k[0] == '*') {
 144                                 // ignore '*prop';
 145                                 continue;
 146                          }
 147
 148
 149                         if (Lang.isKeyword(leftv) || Lang.isBuiltin(leftv)) {
 150                                 left = "'" + leftv + "'";
 151                         } else if (Regex.match_simple("[^A-Za-z_]+",leftv)) { // not plain a-z... - quoted.
 152                                 var val = this.quoteString(leftv);
 153
 154                                 left = "'" + val.substring(1, val.length-2).replace("'", "\\'") + "'";
 155                         } else {
 156                                 left = leftv;
 157                         }
 158                         left += " : ";
 159
 160
 161
 162                         // next.. is it a function..
 163                         if (k[0] == '|') {
 164                                 // does not hapepnd with arrays..
 165                                 if (v.length < 1) {  //if (typeof(el) == 'string' && !obj[i].length) { //skip empty.
 166                                         continue;
 167                                 }
 168                                 /*
 169                                 print(v);
 170                                 string str = "";
 171                                 try {
 172                                         str = func_regex.replace(v,v.length, 0, "");
 173                                 } catch(Error e) {
 174                                         print("regex failed");
 175                                         return "";
 176                                 }
 177                                 */
 178                                 var str = v.strip();
 179
 180                                 var lines = str.split("\n");
 181                                 var nstr = "" + str;
 182                                 if (lines.length > 0) {
 183                                         nstr =  string.joinv("\n" + pad, lines);
 184                                 }
 185                                 //print("==> " +  str + "\n");
 186                                 els.add(left + nstr);
 187                                 continue;
 188                         }
 189                         // standard..
 190
 191
 192                         if (Lang.isNumber(v) || Lang.isBoolean(v)) { // boolean or number...?
 193                                 els.add(left + v.down() );
 194                                 continue;
 195                         }
 196
 197                         // strings..
 198                         if (doubleStringProps.size < 1) {
 199                                 els.add(left + this.quoteString(v));
 200                                 continue;
 201                         }
 202
 203                         if (doubleStringProps.index_of(k) > -1) {
 204                                 els.add(left + this.quoteString(v));
 205                                 continue;
 206                         }
 207                         var vv = this.quoteString(v);
 208                         // single quote.. v.substring(1, v.length-1).replace("'", "\\'") + "'";
 209                         els.add(left + "'" + vv.substring(1, vv.length-2).replace("'", "\\'") + "'");
 210
 211
 212
 213
 214
 215                 }
 216                 // handle the childitems  that are arrays.. eg. button[] = {  }...
 217
 218
 219                 var iter = ar_props.map_iterator();
 220                 while (iter.next()) {
 221                         var k = iter.get_key();
 222                         var right = iter.get_value();
 223
 224                         string leftv = k[0] == '|' ? k.substring(1) : k;
 225                         if (Lang.isKeyword(leftv) || Lang.isBuiltin(leftv)) {
 226                                 left = "'" + leftv + "'";
 227                         } else if (Regex.match_simple("[^A-Za-z_]+",leftv)) { // not plain a-z... - quoted.
 228                                 var val = this.quoteString(leftv);
 229
 230                                 left = "'" + val.substring(1, val.length-2).replace("'", "\\'") + "'";
 231                         } else {
 232                                 left = leftv;
 233                         }
 234                         left += " : ";
 235
 236
 237
 238
 239                         if (right.length > 0){
 240                                 els.add(left + "[\n" +  pad + "  " +  right + "\n" + pad + "]");
 241                         }
 242
 243
 244                 }
 245
 246
 247                 if (this.listeners.size > 0) {
 248                         // munge the listeners.
 249                         //print("ADDING listeners?");
 250
 251                         var liter = this.listeners.map_iterator();
 252
 253                         var itms = "listeners : {\n";
 254                         var i =0;
 255                         while (liter.next()) {
 256
 257                                 itms += i >0 ? ",\n" : "";
 258                                 //
 259                                 var str = liter.get_value().strip();
 260                                 var lines = str.split("\n");
 261                                 if (lines.length > 0) {
 262                                         str = string.joinv("\n" + pad + "          ", lines);
 263                                 }
 264
 265
 266
 267                                 itms +=  pad + "        "  + liter.get_key().replace("|", "")  + " : " + str;
 268
 269                                 i++;
 270
 271
 272                         }
 273                         itms += "\n" + pad + "}";
 274                         //print ( "ADD " + itms);
 275                         els.add(itms);
 276
 277                 }
 278
 279
 280
 281                 // finally munge the children...
 282                 if (this.items.size> 0) {
 283                         var itms = "items : [\n";
 284                         var n = 0;
 285                         for(var i = 0; i < this.items.size;i++) {
 286
 287                                 if (this.items.get(i).props.has_key("* prop")) {
 288                                         continue;
 289                                 }
 290                                 if (n > 0) {
 291                                          itms += ",\n";
 292                                 }
 293                                 n++;
 294                                 itms += pad + " "  +
 295                                         this.items.get(i).mungeToString( pad + "                ",  doubleStringProps);
 296
 297
 298                         }
 299                         itms +=  "\n"+  pad + "]"  + "\n";
 300                         els.add(itms);
 301                 }
 302
 303                 // finally output listeners...
 304
 305
 306
 307
 308
 309
 310
 311                 if (els.size < 1) {
 312                         return "";
 313                 }
 314                 // oprops...
 315
 316                 var spad = pad.substring(0, pad.length-4);
 317                 var str_props = gLibStringListJoin(",\n" + pad , els) ;
 318                 //print ("STR PROPS: " + str_props);
 319
 320                 return   "{\n" +
 321                         pad  + str_props +
 322                         "\n" + spad +  "}";
 323
 324
 325
 326
 327
 328         }
 329
 330
 331
 332
 333