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

   1 //<Script type="text/javascript">
   2
   3 /**
   4  * Project Object
   5  *
   6  * Projects can only contain one directory... - it can import other projects..(later)
   7  *
   8  * we need to sort out that - paths is currently a key/value array..
   9  *
  10  *
  11  *
  12  */
  13 namespace Project {
  14          public errordomain Error {
  15                     INVALID_TYPE,
  16                     NEED_IMPLEMENTING,
  17                         MISSING_FILE,
  18                         INVALID_VALUE
  19                 }
  20
  21         public class Project : Object {
  22
  23                 public signal void on_changed ();
  24
  25                 public string id;
  26                 public string fn = "";
  27                 public string name = "";
  28                 public string runhtml = "";
  29                 public Gee.HashMap<string,string> paths;
  30                 public Gee.HashMap<string,JsRender.JsRender> files ;
  31                 //tree : false,
  32                 public  string xtype;
  33
  34
  35
  36
  37                 public Project (string path) {
  38
  39                     //this.name = name;
  40
  41
  42                     this.paths = new Gee.HashMap<string,string>();
  43                     this.files = new Gee.HashMap<string,JsRender.JsRender>();
  44                     //XObject.extend(this, cfg);
  45                     //this.files = { };
  46                     this.paths.set(path, "dir");
  47
  48
  49                 }
  50
  51                 public static Project factory(string xtype, string path)
  52                 {
  53                         switch(xtype) {
  54                                 case "Gtk":
  55                                         return new Gtk(path);
  56                                 case "Roo":
  57                                         return new Roo(path);
  58                         }
  59                         throw new Error.INVALID_TYPE("invalid project type");
  60
  61                 }
  62
  63                 /*
  64                 public load
  65
  66
  67                     load : function (o)  // is this used??
  68                     {
  69                         if (!this.fetchTree) {
  70                             console.log("Project.getTree tree called on base object?!?!");
  71                             return false;
  72                         }
  73
  74                         if (this.files) {
  75                             return o.success.apply(o.scope || this, [this]);
  76                         }
  77                         return this.fetchTree(o);
  78
  79                     },
  80                 */
  81            // public Palete  getPalete ()
  82                 //{
  83                         //print("Project.Base: GET PROVIDER FOR " + this.xtype);
  84            //         return  ProjectManager.getPalete(this.xtype);
  85            // }
  86
  87                 public void save()
  88                 {
  89                                 // fixme..
  90                 }
  91
  92
  93                 public string toJSON(bool show_all)
  94                 {
  95
  96                     var builder = new Json.Builder ();
  97
  98                     builder.begin_object ();
  99
 100                     builder.set_member_name ("name");
 101                     builder.add_string_value (this.name);
 102
 103
 104                     builder.set_member_name ("fn");
 105                     builder.add_string_value (this.fn);
 106
 107                     builder.set_member_name ("xtype");
 108                     builder.add_string_value (this.xtype);
 109
 110                     // file ??? try/false?
 111                     builder.set_member_name ("paths");
 112
 113
 114                     builder.begin_array ();
 115
 116
 117                     var iter = this.paths.map_iterator();
 118                     while (iter.next()) {
 119                         builder.add_string_value (iter.get_key());
 120                     }
 121                     builder.end_array ();
 122                         if (show_all) {
 123                                 builder.set_member_name ("files");
 124                                 builder.begin_array ();
 125                                 var fiter = this.files.map_iterator();
 126                                 while (fiter.next()) {
 127                                     builder.add_string_value (fiter.get_key());
 128                                 }
 129
 130
 131                                 builder.end_array ();
 132                         }
 133
 134
 135                     builder.end_object ();
 136
 137                     var  generator = new Json.Generator ();
 138                     var  root = builder.get_root ();
 139                     generator.set_root (root);
 140                         if (show_all) {
 141                                 generator.pretty = true;
 142                                 generator.indent = 4;
 143                         }
 144
 145                     return  generator.to_data (null);
 146
 147
 148                 }
 149                 public string firstPath()
 150                 {
 151                     var iter = this.paths.map_iterator();
 152                     while (iter.next()) {
 153                         return iter.get_key();
 154                     }
 155
 156                     return "";
 157                 }
 158
 159                 // returns the first path
 160                 public string getName()
 161                 {
 162                     var iter = this.paths.map_iterator();
 163                     while (iter.next()) {
 164                         return GLib.Path.get_basename(iter.get_key());
 165                     }
 166
 167                     return "";
 168                 }
 169                 /**
 170                  *
 171                  * to tree - > should
 172                  */
 173
 174                 public GLib.List<JsRender.JsRender> toTree ()
 175                 {
 176
 177
 178
 179                     var files = new Gee.HashMap<string,JsRender.JsRender>();
 180
 181                         var fiter = this.files.map_iterator();
 182                     while(fiter.next()) {
 183                         var fo = fiter.get_value();
 184
 185                         fo.hasParent = false;
 186                         fo.cn = new GLib.List<JsRender.JsRender>();
 187
 188                         if (fo.fullname.length > 0) {
 189                             files.set(fo.fullname, fo);
 190                         }
 191                     }
 192
 193                     var iter = files.map_iterator();
 194                     while (iter.next()) {
 195                         var f = iter.get_value();
 196
 197                         var par = f.parent;
 198                         if (par.length < 1) {
 199                             continue;
 200                         }
 201                         if (!files.has_key(par)) {
 202                             continue;
 203                         }
 204                         files.get(par).cn.append(f);
 205                         f.hasParent = true;
 206
 207                     };
 208
 209                     var ret = new GLib.List<JsRender.JsRender>();
 210                     iter = files.map_iterator();
 211                     while (iter.next()) {
 212                         var f = iter.get_value();
 213
 214                         //   f.sortCn();
 215                         if (f.hasParent) {
 216                             continue;
 217                         }
 218                         if (files.has_key(f.fullname)) {
 219
 220                             ret.append(f);
 221                         }
 222                     }
 223                     ret.sort( (a,b) => {
 224                         return a.path > b.path ? 1 : -1;
 225                     });
 226
 227
 228                     //print(JSON.stringify(ret,null,4));
 229
 230                     return ret;
 231
 232
 233                 }
 234
 235
 236
 237                 public JsRender.JsRender? getById(string id)
 238                 {
 239
 240                         var fiter = files.map_iterator();
 241                     while(fiter.next()) {
 242
 243                         var f = fiter.get_value();
 244
 245
 246                         //console.log(f.id + '?=' + id);
 247                         if (f.id == id) {
 248                             return f;
 249                         }
 250                     };
 251                     return null;
 252                 }
 253
 254                 public JsRender.JsRender loadFileOnly (string path)
 255                 {
 256                     var xt = this.xtype;
 257                     return JsRender.JsRender.factory(xt, this, path);
 258
 259                 }
 260
 261                 public JsRender.JsRender create(string filename)
 262                 {
 263                     var ret = this.loadFileOnly(filename);
 264                     ret.save();
 265                     this.addFile(ret);
 266                     return ret;
 267
 268                 }
 269
 270
 271                 public void addFile(JsRender.JsRender pfile) { // add a single file, and trigger changed.
 272
 273
 274                     this.files.set(pfile.path, pfile); // duplicate check?
 275                     this.on_changed();
 276                 }
 277
 278                 public void add(string path, string type)
 279                 {
 280                     this.paths.set(path,type);
 281                     //Seed.print(" type is '" + type + "'");
 282                     if (type == "dir") {
 283                         this.scanDir(path);
 284                     //    console.dump(this.files);
 285                     }
 286                     if (type == "file" ) {
 287
 288                         this.files.set(path,this.loadFileOnly( path ));
 289                     }
 290                     this.on_changed();
 291
 292                 }
 293                 public void  scanDirs()
 294                 {
 295                     var iter = this.paths.map_iterator();
 296                     while (iter.next()) {
 297                                 //print("path: " + iter.get_key() + " : " + iter.get_value() +"\n");
 298                         if (iter.get_value() != "dir") {
 299                             continue;
 300                         }
 301                         this.scanDir(iter.get_key());
 302                     }
 303                     //console.dump(this.files);
 304
 305                 }
 306                     // list files.
 307                 public void scanDir(string dir, int dp =0 )
 308                 {
 309                     //dp = dp || 0;
 310                     //print("Project.Base: Running scandir on " + dir +"\n");
 311                     if (dp > 5) { // no more than 5 deep?
 312                         return;
 313                     }
 314                     // this should be done async -- but since we are getting the proto up ...
 315
 316                     var subs = new GLib.List<string>();;
 317                     var f = File.new_for_path(dir);
 318                     try {
 319                         var file_enum = f.enumerate_children(GLib.FileAttribute.STANDARD_DISPLAY_NAME, GLib.FileQueryInfoFlags.NONE, null);
 320
 321
 322                         FileInfo next_file;
 323                         while ((next_file = file_enum.next_file(null)) != null) {
 324                             var fn = next_file.get_display_name();
 325
 326
 327                             //print("trying"  + dir + "/" + fn +"\n");
 328
 329                             if (fn[0] == '.') { // skip hidden
 330                                 continue;
 331                             }
 332
 333                             if (FileUtils.test(dir  + "/" + fn, GLib.FileTest.IS_DIR)) {
 334                                 subs.append(dir  + "/" + fn);
 335                                 continue;
 336                             }
 337
 338                             if (!Regex.match_simple("\\.bjs$", fn)) {
 339                                                 //print("no a bjs\n");
 340                                 continue;
 341                             }
 342                             /*
 343                             var parent = "";
 344                             //if (dp > 0 ) {
 345
 346                             var sp = dir.split("/");
 347                             var parent = "";
 348                             for (var i = 0; i < sp.length; i++) {
 349
 350                             }
 351
 352                             /*
 353                             sp = sp.splice(sp.length - (dp +1), (dp +1));
 354                             parent = sp.join('.');
 355
 356
 357                             if (typeof(_this.files[dir  + '/' + fn]) != 'undefined') {
 358                                 // we already have it..
 359                                 _this.files[dir  + '/' + fn].parent = parent;
 360                                 return;
 361                             }
 362                             */
 363                             var xt = this.xtype;
 364                                         var el = JsRender.JsRender.factory(xt,this, dir + "/" + fn);
 365                             this.files.set( dir + "/" + fn, el);
 366                             // parent ??
 367
 368
 369                         }
 370                     } catch (Error e) {
 371                         print("Project::scanDirs failed : " + e.message + "\n");
 372                     }
 373                     for (var i = 0; i < subs.length(); i++) {
 374
 375                          this.scanDir(subs.nth_data(i), dp+1);
 376                     }
 377
 378                 }
 379
 380         }
 381 }
 382