git.roojs.org Git - app.Builder.js/blob - src/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  *  We are changing this to output as we go.
   9  *   However... since line-endings on properties have ',' (not ;) like vala.
  10  *           we have to be a bit smarter about how to output.
  11  *
  12  *
  13  *
  14 */
  15
  16
  17
  18
  19 public class JsRender.NodeToJs : Object {
  20
  21         static uint indent = 1;
  22         static string indent_str = " ";
  23
  24
  25
  26         Node node;
  27         Gee.ArrayList<string>  doubleStringProps;  // need to think if this is a good idea like this
  28         string pad;
  29         public JsRender renderer;
  30
  31         Gee.HashMap<string,string> out_props;
  32         Gee.HashMap<string,string> out_listeners;
  33         Gee.HashMap<string,Node> out_nodeprops;
  34         Gee.ArrayList<Node> out_children;
  35         Gee.HashMap<string,Gee.ArrayList<Node>> out_props_array;
  36         Gee.HashMap<string,Gee.ArrayList<string>> out_props_array_plain;
  37
  38         NodeToJs top;
  39         public string ret;
  40
  41         public int cur_line;
  42
  43
  44         public NodeToJs( Node node, Gee.ArrayList<string> doubleStringProps, string pad, NodeToJs? parent)
  45         {
  46                 this.node = node;
  47                 this.doubleStringProps = doubleStringProps;
  48                 this.pad = pad;
  49
  50                 //this.els = new Gee.ArrayList<string>();
  51                 //this.ar_props = new Gee.HashMap<string,string>();
  52
  53
  54
  55                 // this is the bit that causes issues - we have to output as we go, otherwise we
  56                 // can not work out which line is which...
  57
  58                 this.out_props = new Gee.HashMap<string,string>();
  59                 this.out_listeners = new Gee.HashMap<string,string>();
  60
  61
  62                 this.out_nodeprops = new Gee.HashMap<string,Node>() ;
  63                 this.out_children = new Gee.ArrayList<Node> ();
  64
  65                 this.out_props_array = new Gee.HashMap<string,Gee.ArrayList<Node>>(); // filled in by 'checkChildren'
  66                 this.out_props_array_plain = new Gee.HashMap<string,Gee.ArrayList<string>>() ;
  67
  68
  69
  70                 this.cur_line = parent == null ? 0 : parent.cur_line  ; //-1 as we usuall concat onto the existin gline?
  71                 if (parent != null) {
  72                         this.renderer = parent.renderer;
  73                 }
  74                 this.ret = "";
  75                 this.top = parent == null ? this : parent.top;
  76                 // reset the maps...
  77                 if (parent == null) {
  78                         node.node_lines = new Gee.ArrayList<int>();
  79                         node.node_lines_map = new Gee.HashMap<int,Node>();
  80                  }
  81         }
  82
  83
  84
  85
  86
  87
  88         public string munge ( )
  89         {
  90                 //return this.mungeToString(this.node);
  91
  92
  93                 this.checkChildren();
  94                 this.readProps();
  95                 //this.readArrayProps();
  96                 this.readListeners();
  97
  98                 if (!this.node.props.has_key("* xinclude")) {
  99                         this.iterChildren();
 100                 }
 101
 102
 103
 104                 // no properties to output...
 105                 //if (this.els.size < 1) {
 106                 //      return "";
 107                 //}
 108
 109                 this.mungeOut();
 110                 return this.ret;
 111
 112         }
 113                 /**
 114
 115         This currently works by creating a key/value array of this.els, which is just an array of properties..
 116         this is so that join() works...
 117
 118         how this could work:
 119         a) output header
 120         b) output plan properties.
 121         c) output listeners..
 122         c) output *prop
 123         g) output prop_arrays..
 124         d) output children
 125         e)
 126
 127
 128
 129         */
 130
 131         public Gee.ArrayList<string> orderedPropKeys() {
 132
 133                 var ret = new Gee.ArrayList<string> ();
 134                 var niter = this.out_props.map_iterator();
 135                 while(niter.next()) {
 136                         ret.add(niter.get_key());
 137                 }
 138
 139                 ret.sort((  a,  b) => {
 140                         return ((string)a).collate((string)b);
 141                         //if (a == b) return 0;
 142                         //return a < b ? -1 : 1;
 143                 });
 144                 return ret;
 145         }
 146         public Gee.ArrayList<string> orderedListenerKeys() {
 147
 148                 var ret = new Gee.ArrayList<string> ();
 149                 var niter = this.out_listeners.map_iterator();
 150                 while(niter.next()) {
 151                         ret.add(niter.get_key());
 152                 }
 153
 154                 ret.sort((  a,  b) => {
 155                         return ((string)a).collate((string)b);
 156                         //if (a == b) return 0;
 157                         //return a < b ? -1 : 1;
 158                 });
 159                 return ret;
 160         }
 161
 162
 163         public string mungeOut()
 164         {
 165                 this.node.line_start = this.cur_line;
 166                 this.top.node.setNodeLine(this.cur_line, this.node);
 167                 var spad = this.pad.substring(0, this.pad.length-indent);
 168
 169                 if (this.node.props.has_key("* xinclude")) {
 170                         this.addLine("Roo.apply(" + this.node.props.get("* xinclude") + "._tree(), {",0 );
 171
 172                 } else {
 173                         this.addLine("{", 0);
 174                 }
 175                 var suffix = "";
 176                 // output the items...
 177                 // work out remaining items...
 178
 179                 // output xns / xtype first..
 180                 if (this.out_props.has_key("xtype")) {
 181                         var v = this.out_props.get("xtype");
 182                         this.node.setLine(this.cur_line, "p","xtype");
 183                         this.addLine(this.pad + "xtype" + " : " + v + suffix, ',');
 184                 }
 185
 186                 // plain properties.
 187                 var iter = this.orderedPropKeys().list_iterator();
 188                 while(iter.next()) {
 189
 190
 191                         var k = iter.get();
 192                         if (k == "xns" || k == "xtype") {
 193                                 continue;
 194                         }
 195
 196                         var v = this.out_props.get(k);
 197                         this.node.setLine(this.cur_line, "p",k);
 198                         this.addLine(this.pad + k + " : " + v + suffix, ',');
 199
 200                         this.node.setLine(this.cur_line, "e", "");
 201
 202                 }
 203
 204                 // listeners..
 205
 206                 if (this.out_listeners.size > 0 ) {
 207
 208                         this.addLine(this.pad + "listeners : {", 0);
 209                         iter = this.orderedListenerKeys().list_iterator();
 210
 211                         while(iter.next()) {
 212
 213                                 var k = iter.get();
 214                                 var v = this.out_listeners.get(k);
 215                                 this.node.setLine(this.cur_line, "l",k); //listener
 216                                 this.addLine(this.pad + indent_str + k + " : " + v , ',');
 217                                 this.node.setLine(this.cur_line, "e", "");
 218                         }
 219
 220                         this.closeLine();
 221                         this.addLine(this.pad + "}" ,',');
 222
 223                 }
 224
 225                 //------- at this point it is the end of the code relating directly to the object..
 226
 227                 if (this.out_props.has_key("xns")) {
 228                         var v = this.out_props.get("xns");
 229                         this.node.setLine(this.cur_line, "p","xns");
 230                         this.addLine(this.pad + "xns" + " : " + v + suffix, ',');
 231                         this.node.setLine(this.cur_line, "p","| xns");
 232                         this.addLine(this.pad + "'|xns' : '" + v + "'", ',');
 233                         this.node.setLine(this.cur_line, "e", "");
 234                 }
 235
 236                 this.node.line_end = this.cur_line;
 237
 238                 // * prop
 239
 240                 var niter = this.out_nodeprops.map_iterator();
 241
 242                 while(niter.next()) {
 243                         var addstr = this.mungeChildNew(this.pad + indent_str, niter.get_value());
 244                         //print("add str: %s\n", addstr);
 245                         this.node.setLine(this.cur_line, "p",niter.get_key());
 246                         this.addLine(this.pad + niter.get_key() + " : " + addstr, ',');
 247
 248                         this.node.setLine(this.cur_line, "e", "");
 249                 }
 250                 // prop arrays...
 251
 252                 var piter = this.out_props_array.map_iterator();
 253
 254                 while(piter.next()) {
 255                         this.node.setLine(this.cur_line, "p",piter.get_key());
 256                         this.addLine(this.pad + piter.get_key() + " : [", 0);
 257
 258                         var pliter = piter.get_value().list_iterator();
 259                         while (pliter.next()) {
 260                                 var addstr = this.mungeChildNew(this.pad + indent_str  + indent_str, pliter.get());
 261                                 this.addLine(this.pad + indent_str + addstr, ',');
 262                                 this.node.setLine(this.cur_line, "e", "");
 263                         }
 264                         this.closeLine();
 265                         this.addLine(this.pad + "]" , ',');
 266                 }
 267
 268                 // children..
 269                 if (this.out_children.size > 0) {
 270                         this.addLine(this.pad + "items  : [" , 0);
 271                         var cniter = this.out_children.list_iterator();
 272                         while (cniter.next()) {
 273                                 suffix = cniter.has_next()  ? "," : "";
 274                                 var addstr = this.mungeChildNew(this.pad + indent_str  + indent_str, cniter.get());
 275                                 this.addLine(this.pad + indent_str + addstr, ',');
 276                                 this.node.setLine(this.cur_line, "e", "");
 277
 278                         }
 279                         this.closeLine();
 280                         this.addLine(this.pad +   "]",',');
 281                 }
 282                 this.node.setLine(this.cur_line, "e", "");
 283                 this.closeLine();
 284                 if (this.node.props.has_key("* xinclude")) {
 285                         this.addLine(spad + "})",0);
 286
 287                 } else {
 288                         this.addLine( spad + "}", 0);
 289                 }
 290
 291                 this.node.sortLines();
 292
 293
 294
 295                 return this.ret;
 296
 297         }
 298
 299         /**
 300         * Line endings
 301         *     if we end with a ','
 302         *
 303         */
 304
 305         char last_line_end = '!';
 306
 307         /**
 308         * add a line - note we will end up with an extra line break
 309         *     at beginning of nodes doing this..
 310         *
 311         * @param str = text to add..
 312         * @param line_end = 0  (just add a line break)
 313         *        line_end = ','  and ","
 314         *
 315         */
 316         public void addLine(string str, char line_end)
 317         {
 318                 if (this.last_line_end != '!') {
 319                         this.ret += (this.last_line_end == 0 ? "" : this.last_line_end.to_string()) + "\n";
 320                 }
 321                 this.last_line_end = line_end;
 322                 this.cur_line += str.split("\n").length;
 323                 this.ret += str;
 324
 325
 326                 //this.ret +=  "/*%d(%d-%d)*/ ".printf(this.cur_line -1, this.node.line_start,this.node.line_end) + str + "\n";
 327
 328
 329         }
 330         public void closeLine() // send this before '}' or ']' to block output of ',' ...
 331         {
 332                 this.last_line_end = 0;
 333         }
 334
 335 /*      public void addMultiLine(str= "")
 336         {
 337
 338                 //this.ret +=   "/ * %d(%d-%d) * / ".printf(this.cur_line, this.node.line_start,this.node.line_end)+ str + "\n";
 339                 this.ret +=   str + "\n";
 340                 this.cur_line += str.split("\n").length;
 341         }
 342  */
 343         public string mungeChildNew(string pad ,  Node cnode )
 344         {
 345                 var x = new  NodeToJs(cnode, this.doubleStringProps, pad, this);
 346
 347                 x.munge();
 348                 return x.ret;
 349         }
 350
 351         /**
 352         * loop through items[] array see if any of the children have '* prop'
 353         * -- which means they are a property of this node.
 354         * -- ADD TO : this.opt_props_array
 355         *
 356         */
 357
 358         public void checkChildren ()
 359         {
 360
 361
 362                 // look throught he chilren == looking for * prop.. -- fixme might not work..
 363
 364
 365                 if (!this.node.hasChildren()) {
 366                         return;
 367                 }
 368                 // look for '*props'
 369
 370                 for (var ii =0; ii< this.node.items.size; ii++) {
 371                         var pl = this.node.items.get(ii);
 372                         if (!pl.props.has_key("* prop")) {
 373                                 //newitems.add(pl);
 374                                 continue;
 375                         }
 376
 377                         //print(JSON.stringify(pl,null,4));
 378                         // we have a prop...
 379                         //var prop = pl['*prop'] + '';
 380                         //delete pl['*prop'];
 381                         var prop = pl.get("* prop");
 382                         //print("got prop "+ prop + "\n");
 383
 384                         // name ends in [];
 385                         if (! Regex.match_simple("\\[\\]$", prop)) {
 386                                 // it's a standard prop..
 387
 388                                 // munge property..??
 389
 390                                 this.out_nodeprops.set(prop, pl);
 391
 392                                 continue;
 393                         }
 394
 395
 396
 397
 398                         var sprop  = prop.replace("[]", "");
 399                         //print("sprop is : " + sprop + "\n");
 400
 401                         // it's an array type..
 402                         //var old = "";
 403                         if (!this.out_props_array.has_key(sprop)) {
 404                                 this.out_props_array.set(sprop, new Gee.ArrayList<Node>());
 405                         }
 406
 407
 408                         this.out_props_array.get(sprop).add( pl);
 409                         //this.ar_props.set(sprop, nstr);
 410
 411
 412                 }
 413
 414         }
 415         /*
 416  * Standardize this crap...
 417  *
 418  * standard properties (use to set)
 419  *          If they are long values show the dialog..
 420  *
 421  * someprop : ....
 422  * bool is_xxx  :: can show a pulldown.. (true/false)
 423  * string html
 424  * $ string html  = string with value interpolated eg. baseURL + ".."
 425  *  Clutter.ActorAlign x_align  (typed)  -- shows pulldowns if type is ENUM?
 426  * $ untypedvalue = javascript untyped value...
 427  * _ string html ... = translatable..
 428
 429  *
 430  * object properties (not part of the GOjbect being wrapped?
 431  * # Gee.ArrayList<Xcls_fileitem> fileitems
 432  *
 433  * signals
 434  * @ void open
 435  *
 436  * methods -- always text editor..
 437  * | void clearFiles
 438  * | someJSmethod
 439  *
 440  * specials
 441  * * prop -- string
 442  * * args  -- string
 443  * * ctor -- string
 444  * * init -- big string?
 445  *
 446  * event handlers (listeners)
 447  *   just shown
 448  *
 449  * -----------------
 450  * special ID values
 451  *  +XXXX -- indicates it's a instance property / not glob...
 452  *  *XXXX -- skip writing glob property (used as classes that can be created...)
 453  *
 454  *
 455  */
 456         public void readProps()
 457         {
 458                 string left;
 459                 Regex func_regex ;
 460
 461                 try {
 462                         func_regex = new Regex("^\\s+|\\s+$");
 463                 } catch (RegexError e) {
 464                         print("failed to build regex");
 465                         return;
 466                 }
 467                 // sort the key's so they always get rendered in the same order..
 468
 469                 var keys = new Gee.ArrayList<string>();
 470                 var piter = this.node.props.map_iterator();
 471                 while (piter.next() ) {
 472                         string k;
 473                         string ktype;
 474                         string kflag;
 475                         this.node.normalize_key(piter.get_key(), out k, out kflag, out ktype);
 476
 477                         keys.add(k);
 478                 }
 479
 480                 keys.sort((  a,  b) => {
 481                         return ((string)a).collate((string)b);
 482                         //if (a == b) return 0;
 483                         //return a < b ? -1 : 1;
 484                 });
 485
 486                 var has_cms = this.node.has("cms-id");
 487
 488                 for (var i = 0; i< keys.size; i++) {
 489                         var key = this.node.get_key(keys.get(i));
 490                         //("ADD KEY %s\n", key);
 491                         string k;
 492                         string ktype;
 493                         string kflag;
 494
 495                         this.node.normalize_key(key, out k, out kflag, out ktype);
 496
 497
 498                         var v = this.node.get(key);
 499
 500
 501                         //if (this.skip.contains(k) ) {
 502                         //      continue;
 503                         //}
 504                         if (  Regex.match_simple("\\[\\]$", k)) {
 505                                 // array .. not supported... here?
 506
 507
 508                         }
 509
 510                         string leftv = k;
 511                         // skip builder stuff. prefixed with  '.' .. just like unix fs..
 512                         if (kflag == ".") { // |. or . -- do not output..
 513                                 continue;
 514                         }
 515                         if (kflag == "*") {
 516                                 // ignore '* prop'; ???
 517                                 continue;
 518                         }
 519
 520                         // handle cms-id // html
 521                         if (has_cms && k == "cms-id") {
 522                                 continue; // ignore it...
 523                         }
 524                         // html must not be a dynamic property...
 525                         // note - we do not translate this either...
 526                         if (has_cms && k == "html" && kflag != "$") {
 527
 528
 529                                 this.out_props.set("html", "Pman.Cms.content(" +
 530                                         this.node.quoteString(this.renderer.name + "::" + this.node.get("cms-id")) +
 531                                          ", " +
 532                                         this.node.quoteString(v) +
 533                                          ")");
 534
 535                                 continue;
 536                         }
 537
 538
 539
 540
 541                         if (Lang.isKeyword(leftv) || Lang.isBuiltin(leftv)) {
 542                                 left = "'" + leftv + "'";
 543                         } else if (Regex.match_simple("[^A-Za-z_]+",leftv)) { // not plain a-z... - quoted.
 544                                 var val = this.node.quoteString(leftv);
 545
 546                                 left = "'" + val.substring(1, val.length-2).replace("'", "\\'") + "'";
 547                         } else {
 548                                 left = leftv;
 549                         }
 550
 551
 552                         // next.. is it a function.. or a raw string..
 553                         if (
 554                                 kflag == "|"
 555                                 ||
 556                                 kflag == "$"
 557                                 ||
 558                                 ktype == "function"
 559
 560                                 // ??? any others that are raw output..
 561                                 ) {
 562                                 // does not hapepnd with arrays..
 563                                 if (v.length < 1) {  //if (typeof(el) == 'string' && !obj[i].length) { //skip empty.
 564                                         continue;
 565                                 }
 566                                 /*
 567                                 print(v);
 568                                 string str = "";
 569                                 try {
 570                                         str = func_regex.replace(v,v.length, 0, "");
 571                                 } catch(Error e) {
 572                                         print("regex failed");
 573                                         return "";
 574                                 }
 575                                 */
 576                                 var str = v.strip();
 577
 578                                 var lines = str.split("\n");
 579                                 var nstr = "" + str;
 580                                 if (lines.length > 0) {
 581                                         nstr =  string.joinv("\n" + this.pad, lines);
 582                                         //nstr =  string.joinv("\n", lines);
 583                                 }
 584                                 this.out_props.set(left, nstr);
 585
 586
 587
 588
 589
 590                                 //print("==> " +  str + "\n");
 591                                 //this.els.add(left + " : "+  nstr);
 592                                 continue;
 593                         }
 594                         // standard..
 595
 596
 597                         if (
 598                                 Lang.isNumber(v)
 599                                 ||
 600                                 Lang.isBoolean(v)
 601                                 ||
 602                                 ktype.down() == "boolean"
 603                                 ||
 604                                 ktype.down() == "bool"
 605                                 ||
 606                                 ktype.down() == "number"
 607                                 ||
 608                                 ktype.down() == "int"
 609                             ) { // boolean or number...?
 610                             this.out_props.set(left, v.down());
 611                                 //this.els.add(left + " : " + v.down() );
 612                                 continue;
 613                         }
 614
 615                         // is it a translated string?
 616
 617
 618
 619
 620                         // strings..
 621                         //if (this.doubleStringProps.size < 1) {
 622                         //      this.els.add(left + this.node.quoteString(v));
 623                         //      continue;
 624                         //}
 625
 626                         if ((this.doubleStringProps.index_of(k) > -1) ||
 627                                 (ktype.down() == "string" && k[0] == '_')
 628
 629                         ) {
 630                                 // then use the translated version...
 631
 632                                 var com = " /* " +
 633                                         (v.split("\n").length > 1 ?
 634                                                 ("\n" + this.pad +  string.joinv(this.pad +  "\n", v.split("\n")).replace("*/", "* - /") + "\n" + this.pad + "*/ ") :
 635                                                 (v.replace("*/", "* - /") + " */")
 636                                         );
 637
 638                                 //this.els.add(left + " : _this._strings['" +
 639                                 //      GLib.Checksum.compute_for_string (ChecksumType.MD5, v) +
 640                                 //      "']"
 641                                 //);
 642                                 this.out_props.set(left, "_this._strings['" +
 643                                         GLib.Checksum.compute_for_string (ChecksumType.MD5, v.strip()) +
 644                                         "']" + com);
 645                                 continue;
 646                         }
 647
 648                         // otherwise it needs to be encapsulated.. as single quotes..
 649
 650                         var vv = this.node.quoteString(v);
 651                         // single quote.. v.substring(1, v.length-1).replace("'", "\\'") + "'";
 652                         //this.els.add(left + " : " +  "'" + vv.substring(1, vv.length-2).replace("'", "\\'") + "'");
 653                         this.out_props.set(left,  "'" + vv.substring(1, vv.length-2).replace("'", "\\'") + "'");
 654
 655
 656
 657
 658                 }
 659         }
 660
 661         public void readListeners()
 662         {
 663
 664                 if (this.node.listeners.size < 1) {
 665                         return;
 666                 }
 667                 // munge the listeners.
 668                 //print("ADDING listeners?");
 669
 670
 671
 672
 673                 var keys = new Gee.ArrayList<string>();
 674                 var piter = this.node.listeners.map_iterator();
 675                 while (piter.next() ) {
 676
 677                         keys.add(piter.get_key());
 678                 }
 679                 keys.sort((  a,  b) => {
 680                         return ((string)a).collate((string)b);
 681                         //if (a == b) return 0;
 682                         //return a < b ? -1 : 1;
 683                 });
 684
 685
 686                 for (var i = 0; i< keys.size; i++) {
 687                         var key = keys.get(i);
 688                         var val = this.node.listeners.get(key);
 689
 690
 691                          //
 692                         var str = val.strip();
 693                         var lines = str.split("\n");
 694                         if (lines.length > 0) {
 695                                 //str = string.joinv("\n" + this.pad + "           ", lines);
 696                                 str = string.joinv("\n" + this.pad + indent_str + indent_str , lines);
 697                         }
 698
 699                         this.out_listeners.set(key.replace("|", "") ,str);
 700
 701
 702                 }
 703
 704
 705
 706         }
 707
 708         public void iterChildren()
 709         {
 710
 711
 712                 // finally munge the children...
 713                 if (this.node.items.size < 1) {
 714                         return;
 715                 }
 716                 var itms = "items : [\n";
 717                 //var n = 0;
 718                 for(var i = 0; i < this.node.items.size;i++) {
 719                         var ele = this.node.items.get(i);
 720                         if (ele.props.has_key("* prop")) {
 721                                 continue;
 722                         }
 723
 724                         this.out_children.add(ele);
 725
 726                 }
 727                 itms +=  "\n"+  this.pad + "]"  + "\n";
 728                 //this.els.add(itms);
 729         }
 730
 731                 // finally output listeners...
 732
 733         public void xIncludeToString()
 734         {
 735
 736
 737         }
 738
 739 }
 740
 741
 742
 743