git.roojs.org Git - gnome.introspection-doc-generator/blob - JSDOC/Packer.js

   1 // <script type="text/javascript">
   2 XObject         = imports.XObject.XObject;
   3 File            = imports.File.File;
   4
   5 TextStream      = imports['JSDOC/TextStream.js'].TextStream;
   6 TokenReader     = imports['JSDOC/TokenReader.js'].TokenReader;
   7 ScopeParser     = imports['JSDOC/ScopeParser.js'].ScopeParser;
   8 TokenStream     = imports['JSDOC/TokenStream.js'].TokenStream;
   9 CompressWhite   = imports['JSDOC/CompressWhite.js'].CompressWhite;
  10
  11 GLib = imports.gi.GLib;
  12 /**
  13  * @namespace JSDOC
  14  * @class  Packer
  15  * Create a new packer
  16  *
  17  * Use with pack.js
  18  *
  19  *
  20  * Usage:
  21  * <code>
  22  *
  23 Packer = imports['JSDOC/Packer.js'].Packer;
  24 var x = new  Packer({
  25
  26     files : [ "/location/of/file1.js", "/location/of/file2.js", ... ],
  27     target : "/tmp/output.js",
  28     debugTarget : "/tmp/output.debug.js", // merged file without compression.
  29     translateJSON: "/tmp/translate.json",
  30
  31
  32 );
  33 x.packFiles(
  34     "/location/of/temp_batch_dir",
  35     "/location/of/output-compacted-file.js",
  36     "/location/of/output-debug-merged-file.js"
  37 );
  38
  39  *</code>
  40  *
  41  * Notes for improving compacting:
  42  *  if you add a jsdoc comment
  43  * <code>
  44  * /**
  45  *   eval:var:avarname
  46  *   eval:var:bvarname
  47  *   ....
  48  * </code>
  49  * directly before an eval statement, it will compress all the code around the eval,
  50  * and not rename the variables 'avarname'
  51  *
  52  * Dont try running this on a merged uncompressed large file - it's used to be horrifically slow. not sure about now..
  53  * Best to use lot's of small classes, and use it to merge, as it will cache the compaction
  54  *
  55  *
  56  *
  57  * Notes for translation
  58  *  - translation relies on you using double quotes for strings if they need translating
  59  *  - single quoted strings are ignored.
  60  *
  61  * Generation of indexFiles
  62  *   - translateIndex = the indexfile
  63  *
  64  *
  65  *
  66  *
  67
  68  */
  69 Packer = function(cfg)
  70 {
  71
  72     XObject.extend(this, cfg);
  73
  74     if (this.srcfile) {
  75         this.loadSourceFile();
  76     }
  77
  78     if (!this.files) {
  79         throw "No Files";
  80     }
  81
  82
  83     this.timer =  new Date() * 1;
  84     this.packAll();
  85
  86
  87 }
  88 Packer.prototype = {
  89     /**
  90      * @prop srcfiles {String} file containing a list of files/or classes to use.
  91      */
  92     srcfiles : false,
  93
  94     /**
  95      * @prop files {Array} list of files to compress (must be full path)
  96      */
  97     files : false,
  98     /**
  99      * @prop target {String} target to write files to - must be full path.
 100      */
 101     target : '',
 102     /**
 103      * @prop debugTarget {String} target to write files debug version to (uncompacted)- must be full path.
 104      */
 105     debugTarget : '', // merged file without compression.
 106     /**
 107      * @prop tmpDir {String} (optional) where to put the temporary files.
 108      *      if you set this, then files will not be cleaned up
 109      */
 110     tmpDir : '/tmp',
 111
 112     translateJSON : '', // json based list of strings in all files.
 113
 114     /**
 115      * @prop cleanup {Boolean} (optional) clean up temp files after done -
 116      *    Defaults to false if you set tmpDir, otherwise true.
 117      */
 118     cleanup : true,
 119
 120     /**
 121      * @prop prefix {String} (optional) prefix of directory to be stripped of when
 122      *    Calculating md5 of filename
 123      */
 124     prefix : '',
 125     out : '', // if no target is specified - then this will contain the result
 126
 127
 128     loadSourceFile : function()
 129     {
 130         var lines = File.read(this.srcfile).split("\n");
 131         var _this = this;
 132         lines.forEach(function(f) {
 133
 134             if (/^\s*\//.test(f) || !/[a-z]+/i.test(f)) { // skip comments..
 135                 return;
 136             }
 137             if (/\.js$/.test(f)) {
 138                 _this.files.push( f);
 139                 // js file..
 140                 return;
 141             }
 142
 143             //println("ADD"+ f.replace(/\./g, '/'));
 144             var add = f.replace(/\./g, '/').replace(/\s+/g,'')+'.js';
 145             if (_this.files.indexOf(f) > -1) {
 146                 return;
 147             }
 148             _this.files.push( add );
 149
 150         })
 151     },
 152
 153
 154     packAll : function()  // do the packing (run from constructor)
 155     {
 156
 157         //this.transOrigFile= bpath + '/../lang.en.js'; // needs better naming...
 158         //File.write(this.transfile, "");
 159         if (this.target) {
 160             File.write(this.target, "");
 161         }
 162
 163         if (this.debugTarget) {
 164             File.write(this.debugTarget, "");
 165         }
 166
 167         for(var i=0; i < this.files.length; i++)  {
 168             var file = this.files[i];
 169
 170             print("reading " +file );
 171             if (!File.isFile(file)) {
 172                 print("SKIP (is not a file) " + file);
 173                 continue;
 174             }
 175
 176             if (this.debugTarget) {
 177                 File.append(this.debugTarget, File.read(file));
 178             }
 179             // it's a good idea to check with 0 compression to see if the code can parse!!
 180
 181             // debug file..
 182             //File.append(dout, str +"\n");
 183
 184
 185
 186             var minfile = this.tmpDir + '/' +file.replace(/\//g, '.');
 187
 188
 189             // let's see if we have a min file already?
 190             // this might happen if tmpDir is set ..
 191             if (true && File.exists(minfile)) {
 192                 var mt = File.mtime(minfile);
 193                 var ot = File.mtime(file);
 194                 print("compare : " + mt + "=>" + ot);
 195                 if (mt >= ot) {
 196                     continue;
 197                     /*
 198                     // then the min'files time is > than original..
 199                     var str = File.read(minfile);
 200                     print("using MIN FILE  "+ minfile);
 201                     if (str.length) {
 202                         File.append(outpath, str + "\n");
 203                     }
 204
 205                     continue;
 206                     */
 207                 }
 208
 209             }
 210
 211             print("COMPRESSING ");
 212             //var codeComp = pack(str, 10, 0, 0);
 213             if (File.exists(minfile)) {
 214                 File.remove(minfile);
 215             }
 216             var str = File.read(file);
 217             var str = this.pack(str, file, minfile);
 218             if (str.length) {
 219                 File.write(minfile, str);
 220             }
 221
 222
 223
 224         }
 225         if (this.translateJSON) {
 226
 227
 228             print("MERGING LANGUAGE");
 229             var out = "if (typeof(_T) == 'undefined') { _T={};}\n"
 230             if (this.target) {
 231                 File.write(this.target, out);
 232             } else {
 233                 this.out += out;
 234             }
 235
 236
 237
 238             File.write(this.translateJSON, "");
 239             for(var i=0; i < this.files.length; i++)  {
 240                 var file = this.files[i];
 241                 var transfile= this.tmpDir + '/' +file.replace(/\//g, '.') +'.lang.trans';
 242                 var transmd5 = this.tmpDir  + '/' +file.replace(/\//g, '.') +'.lang';
 243                 if (File.exists(transmd5)) {
 244                     var str = File.read(transmd5);
 245                     if (str.length) {
 246                         if (this.target) {
 247                             File.append(this.target, str + "\n");
 248                         } else {
 249                             this.out += str + "\n";
 250                         }
 251
 252                     }
 253                     if (this.cleanup) {
 254                         File.remove(transmd5);
 255                     }
 256                 }
 257                 if (File.exists(transfile)) {
 258                     var str = File.read(transfile);
 259                     if (str.length) {
 260                         File.append(this.translateJSON, str);
 261                     }
 262                     if (this.cleanup) {
 263                         File.remove(transfile);
 264                     }
 265                 }
 266
 267
 268             }
 269         }
 270
 271         print("MERGING SOURCE");
 272
 273         for(var i=0; i < this.files.length; i++)  {
 274             var file = this.files[i];
 275             var minfile = this.tmpDir + '/' + file.replace(/\//g, '.');
 276
 277
 278             if (!File.exists(minfile)) {
 279                 continue;
 280             }
 281             var str = File.read(minfile);
 282             print("using MIN FILE  "+ minfile);
 283             if (str.length) {
 284                 if (this.target) {
 285                     File.append(this.target, str + "\n");
 286                 } else {
 287                     this.out += str + "\n";
 288                 }
 289
 290             }
 291             if (this.cleanup) {
 292                 File.remove(minfile);
 293             }
 294
 295         }
 296
 297
 298
 299
 300     },
 301     /**
 302      * Core packing routine  for a file
 303      *
 304      * @param str - str source text..
 305      * @param fn - filename (for reference?)
 306      * @param minfile - min file location...
 307      *
 308      */
 309
 310     pack : function (str,fn,minfile)
 311     {
 312
 313         var tr = new  TokenReader(  { keepDocs :true, keepWhite : true,  keepComments : true, sepIdents : true });
 314         this.timerPrint("START" + fn);
 315
 316         // we can load translation map here...
 317
 318         var toks = tr.tokenize(new TextStream(str)); // dont merge xxx + . + yyyy etc.
 319
 320         // at this point we can write a language file...
 321         if (this.translateJSON) {
 322
 323             this.writeTranslateFile(fn, minfile, toks);
 324         }
 325
 326         this.activeFile = fn;
 327
 328         // and replace if we are generating a different language..
 329
 330         this.timerPrint("Tokenized");
 331         //return;//
 332         var sp = new ScopeParser(new TokenStream(toks));
 333         this.timerPrint("Converted to Parser");
 334         sp.packer = this;
 335         sp.buildSymbolTree();
 336         this.timerPrint("Built Sym tree");
 337         sp.mungeSymboltree();
 338         this.timerPrint("Munged Sym tree");
 339         print(sp.warnings.join("\n"));
 340         var out = CompressWhite(sp.ts, this);
 341         this.timerPrint("Compressed");
 342         return out;
 343
 344
 345
 346     },
 347
 348     timerPrint: function (str) {
 349         var ntime = new Date() * 1;
 350         var tdif =  ntime -this.timer;
 351         this.timer = ntime;
 352         print('['+tdif+']'+str);
 353     },
 354
 355     /**
 356      *
 357      * Translation concept...
 358      * -> replace text strings with _T....
 359      * -> this file will need inserting at the start of the application....
 360      * -> we need to generate 2 files,
 361      * -> a reference used to do the translation, and the _T file..
 362      *
 363      */
 364
 365     writeTranslateFile : function(fn, minfile, toks)
 366     {
 367
 368         var map = {};
 369         var _this = this;
 370         toks.forEach(function (t) {
 371             if (t.type == 'STRN' && t.name == 'DOUBLE_QUOTE') {
 372                 var sval = t.data.substring(1,t.data.length-1);
 373                 var ffn = fn.substring(_this.prefix.length);
 374                 map[sval] = _this.md5(ffn + '-' + sval);
 375             }
 376         })
 377
 378         var transfile = minfile + '.lang.trans';
 379         var transmd5 = minfile + '.lang';
 380         print("writeTranslateFile "  + transfile);
 381         var i = 0;
 382         var v = '';
 383         if (File.exists(transfile)) {
 384             File.remove(transfile);
 385         }
 386         if (File.exists(transmd5)) {
 387             File.remove(transmd5);
 388         }
 389         for(v in map) { i++; break };
 390         if (!i ) {
 391             return; // no strings in file...
 392         }
 393         var ffn = fn.substring(this.prefix.length);
 394
 395
 396         File.write(transfile, "\n'" + ffn  + "' : {");
 397         var l = '';
 398         var _tout = {}
 399
 400         File.write(transmd5, '');
 401         for(v in map) {
 402             File.append(transfile, l + "\n\t \"" + v + '" : "' + v + '"');
 403             l = ',';
 404             // strings are raw... - as the where encoded to start with!!!
 405             File.append(transmd5, '_T["' + this.md5(ffn + '-' + v) + '"]="'+v+"\";\n");
 406         }
 407         File.append(transfile, "\n},"); // always one trailing..
 408
 409
 410     },
 411     md5 : function (string)
 412     {
 413
 414         return GLib.compute_checksum_for_string(GLib.ChecksumType.MD5, string, string.length);
 415
 416     },
 417     stringHandler : function(tok)
 418     {
 419         //print("STRING HANDLER");
 420        // callback when outputing compressed file,
 421        var data = tok.data;
 422         if (!this.translateJSON) {
 423          //   print("TURNED OFF");
 424             return data;
 425         }
 426         if (tok.name == 'SINGLE_QUOTE') {
 427             return data;
 428         }
 429
 430         var sval = data.substring(1,data.length-1);
 431         // we do not clean up... quoting here!??!!?!?!?!?
 432
 433
 434         // blank with tabs or spaces..
 435         //if (!sval.replace(new RegExp("(\\\\n|\\\\t| )+",'g'), '').length) {
 436        //     return tok.outData;
 437        // }
 438
 439         var sval = tok.data.substring(1,data.length-1);
 440         var fn = this.activeFile.substring(this.prefix.length);
 441
 442
 443         return '_T["' + this.md5(fn + '-' + sval) + '"]';
 444
 445
 446     }
 447
 448
 449 };