src/Project/Gtk.vala
[app.Builder.js] / src / Project / Gtk.vala
1 //<Script type="text/javascript">
2 /**
3  * Gtk projects - normally vala based now..
4  * 
5  * should have a few extra features..
6  * 
7  * like:
8  *   compile flags etc..
9  *   different versions (eg. different files can compile different versions - eg. for testing.
10  *   
11  * If we model this like adjuta - then we would need a 'project' file that is actually in 
12  * the directory somewhere... - and is revision controlled etc..
13  * 
14  * builder.config ??
15  * 
16  * 
17  * 
18  * 
19  */
20  
21
22 namespace Project {
23         static int gtk_id = 1;
24  
25
26         public class Gtk : Project
27         {
28           
29                 public Gtk(string path) {
30                   
31                   
32                         base(path);
33                         this.xtype = "Gtk";
34                         var gid = "project-gtk-%d".printf(gtk_id++);
35                         this.id = gid;
36                         this.loadConfig();
37                 
38                 }
39                 public Gee.HashMap<string,GtkValaSettings> compilegroups;
40                 
41                 public void loadConfig() throws GLib.Error 
42                 {
43                         // load a builder.config JSON file.
44                         // 
45                         this.compilegroups = new  Gee.HashMap<string,GtkValaSettings>();
46                         
47                         
48                         var fn = this.firstPath() + "/config1.builder";
49                         GLib.debug("load: " + fn );
50                         
51                         if (!FileUtils.test(fn, FileTest.EXISTS)) {
52                                 this.compilegroups.set("_default_", new GtkValaSettings("_default_") );
53                                 return;
54                         }
55
56                         var pa = new Json.Parser();
57                         pa.load_from_file(fn);
58                         var node = pa.get_root();
59
60                         // should be an array really.
61                         if (node.get_node_type () != Json.NodeType.ARRAY) {
62                                 throw new Error.INVALID_FORMAT ("Unexpected element type %s", node.type_name ());
63                         }
64                         
65                         var obj = node.get_array ();
66                         for(var i= 0;i<obj.get_length();i++) {
67                                 var el = obj.get_object_element(i);
68                                 var vs = new GtkValaSettings.from_json(el);
69                                 if (vs.name != "_default_") {
70                                         vs.parent = this.compilegroups.get("_default_");
71                                 }
72                                 this.compilegroups.set(vs.name,vs);
73                         }
74                         GLib.debug("%s\n",this.configToString ());
75                         
76                 }
77                 public string configToString()
78                 {
79                         var ar = new Json.Array();
80                         var iter = this.compilegroups.map_iterator();
81                         while(iter.next()) {
82                                  
83                                 ar.add_object_element(iter.get_value().toJson());
84                         }
85
86                         var generator = new Json.Generator ();
87                         generator.indent = 4;
88                         generator.pretty = true;
89                         var node = new Json.Node(Json.NodeType.ARRAY);
90                         node.set_array(ar);
91                         generator.set_root(node);
92                         return generator.to_data(null);
93                 }
94                 
95                 public void writeConfig()
96                 {
97                         var fn = this.firstPath() + "/config1.builder";
98                         GLib.debug("write: " + fn );
99
100                          
101                         var f = GLib.File.new_for_path(fn);
102                         var data_out = new GLib.DataOutputStream(
103                                         f.replace(null, false, GLib.FileCreateFlags.NONE, null)
104                         );
105                         data_out.put_string(this.configToString(), null);
106                         data_out.close(null);
107                         
108                         return ;
109                          
110                 }
111                 /**
112                  *  perhaps we should select the default in the window somewhere...
113                  */ 
114                 public string firstBuildModule()
115                 {
116                         var iter = this.compilegroups.map_iterator();
117                         while(iter.next()) {
118                                  
119                                  if (iter.get_value().name == "__default__") {
120                                          continue;
121                                  }
122                                  
123                                  return iter.get_value().name;
124                         }
125                         return "";
126                 }
127                 
128                 
129                 public string relPath(string target)
130                 {
131                         var basename = this.firstPath();
132                         // eg. base = /home/xxx/fred/blogs
133                         // target = /home/xxx/fred/jones
134                         
135                         // this does not work correctly...
136                         var bb = basename;
137                         var prefix = "";
138                         while (true) {
139                                 if (    bb.length < target.length &&
140                                         target.substring(0, bb.length) == bb) {
141                                         
142                                         return prefix + target.substring(bb.length +1);
143                                 }
144                                 if (bb.length < 1) {
145                                         throw new Error.INVALID_FORMAT ("Could not work out relative path %s to %s",
146                                                                         basename, target);
147                                 }
148                                 bb = GLib.Path.get_dirname(bb);
149                                 prefix += "../";
150                                 
151                         }
152          
153                 }
154                 /**
155                  * get a list of files for a folder..
156                  * 
157                  * - in the project manager this has to list all possible compilable 
158                  *   files  - eg. exclue XXX.vala.c or XXX.c with the same name as 
159                  *   a vala file (so to ignore the generated files)
160                  * 
161                  * - for the editor navigation - this should exclude all files that
162                  *   are vala based on a bjs file..
163                  *  
164                  */
165                 
166                 public Gee.ArrayList<string> filesAll(string in_path)
167                 {
168                         var ret =  new Gee.ArrayList<string>();
169                         
170                         var dirname = this.resolve_path(
171                                 this.resolve_path_combine_path(this.firstPath(),in_path));
172                         
173                         GLib.debug("SCAN %s", dirname);
174                                 // scan the directory for files -- ending with vala || c
175                         
176
177                         var dir = File.new_for_path(dirname);
178                         if (!dir.query_exists()) {
179                                 GLib.debug("SCAN %s - skip - does not exist\n", dirname);
180                                 return ret;
181                         }
182           
183            
184                         try {
185                                 var file_enum = dir.enumerate_children(
186                                         "standard::*", 
187                                         GLib.FileQueryInfoFlags.NONE, 
188                                         null
189                                 );
190                 
191                  
192                                 FileInfo next_file; 
193                                 while ((next_file = file_enum.next_file(null)) != null) {
194                                         var fn = next_file.get_display_name();
195                                         
196                                         if (next_file.get_file_type () == GLib.FileType.DIRECTORY) {
197                                          
198                                                 GLib.debug("SKIP %s not regular  ", fn);
199                                                 continue;
200                                         }
201                                         if (Regex.match_simple("^text\/", next_file.get_content_type()) {
202                                                 continue;
203                                         }
204                                         GLib.debug("SCAN ADD %s : %s", fn, next_file.get_content_type());
205                                         ret.add(in_path + "/" + fn);
206                                          
207                                         // any other valid types???
208                                 
209                                 }
210                                 
211                         } catch(Error e) {
212                                 GLib.warning("oops - something went wrong scanning the projects\n");
213                         }       
214                         
215                         return ret;
216                 }
217                 
218                 public Gee.ArrayList<string> filesForCompile(string in_path)
219                 {
220                         var allfiles = this.filesAll(in_path);
221                         var ret =  new Gee.ArrayList<string>();
222                         
223                         
224                         for (var i = 0; i < allfiles.size; i ++) {
225                                 var fn = allfiles.get(i);
226                                 try {
227                                         if (Regex.match_simple("\\.vala$", fn)) {
228                                                 ret.add( fn);
229                                                 continue;
230                                         }
231                                         // vala.c -- ignore..
232                                         if (Regex.match_simple("\\.vala\\.c$", fn)) {
233                                                 continue;
234                                         }
235                                         // not a c file...
236                                         if (!Regex.match_simple("\\.c$", fn)) {
237                                                 continue;
238                                         }
239                                         
240                                         // is the c file the same as a vala file...
241                                         
242                                          
243                                         
244                                         var vv = (new Regex("\\.c$")).replace( fn, fn.length, 0, ".vala");
245                                 
246                                         
247                                                 
248                                         if (allfiles.index_of( vv) > -1) {
249                                                 continue;
250                                         }
251                                         // add the 'c' file..
252                                         ret.add(fn);
253                                 } catch (Error e) {
254                                         continue;
255                                 }
256                         }
257                         // sort.
258                         ret.sort((fa,fb) => {
259                                 return ((string)fa).collate((string) fb);
260                         });
261                         return ret;
262                         
263                 }
264                 
265                 public Gee.ArrayList<string> filesForOpen(string in_path)
266                 {
267                         var allfiles = this.filesAll(in_path);
268                         var ret =  new Gee.ArrayList<string>();
269                         GLib.debug("SCAN %s - %d files",in_path, allfiles.size);
270                         
271                         for (var i = 0; i < allfiles.size; i ++) {
272                                 var fn = allfiles.get(i);
273                                 try {
274                                         
275                                         if (Regex.match_simple("\\.vala\\.c$", fn)) {
276                                                 GLib.debug("SKIP %s - vala.c",fn);
277
278                                                 continue;
279                                         }
280                                         
281                                         if (Regex.match_simple("\\.bjs$", fn)) {
282                                                 GLib.debug("SKIP %s - .bjs",fn);
283                                                 continue;
284                                         }
285                                         if (Regex.match_simple("\\.o$", fn)) {
286                                                 GLib.debug("SKIP %s - .o",fn);
287                                                 continue;
288                                         }
289                                         if (Regex.match_simple("\\~$", fn)) {
290                                                 GLib.debug("SKIP %s - ~",fn);
291                                                 continue;
292                                         }
293                                         
294                                         if (Regex.match_simple("^\\.", GLib.Path.get_basename(fn))) {
295                                                 GLib.debug("SKIP %s - hidden",fn);
296                                                 continue;
297                                         }
298                                         if (Regex.match_simple("\\.vala$", fn)) {
299                                                 var vv = (new Regex("\\.vala$")).replace( fn, fn.length, 0, ".bjs");
300                                                 if (allfiles.index_of( vv) > -1) {
301                                                         GLib.debug("SKIP %s - .vala (got bjs)",fn);
302                                                         continue;
303                                                 }
304                                                 GLib.debug("ADD %s",fn);
305                                                 ret.add( fn);
306                                                 continue;
307                                         }
308                                         // vala.c -- ignore..
309                                         
310                                         // not a c file...
311                                         if (Regex.match_simple("\\.c$", fn)) {
312                                                 
313                                                 var vv = (new Regex("\\.c$")).replace( fn, fn.length, 0, ".vala");
314                                                 if (allfiles.index_of( vv) > -1) {
315                                                         GLib.debug("SKIP %s - .c (got vala)",fn);
316                                                         continue;
317                                                 }
318                                                 GLib.debug("ADD %s",fn);                                                
319                                                 ret.add( fn);
320                                                 continue;
321                                         }
322                                         
323                                         if (GLib.Path.get_basename( fn) == "config1.builder") {
324                                                 continue;
325                                         }
326                                         // not .c / not .vala /not .bjs.. -- other type of file..
327                                         // allow ???
328                                         GLib.debug("ADD %s",fn);
329                                         // add the 'c' file..
330                                         ret.add(fn);
331                                 } catch (Error e) {
332                                         GLib.debug("Exception %s",e.message);
333                                         continue;
334                                 }
335                         }
336                         // sort.
337                         ret.sort((fa,fb) => {
338                                 return ((string)fa).collate((string) fb);
339                         });
340                         return ret;
341                         
342                 }
343                 
344                 
345                  
346  
347
348                 public   string  resolve_path_combine_path(string first, string second)
349                 {
350                         string ret = first;
351                         if (first.length > 0 && second.length > 0 && !first.has_suffix("/") && !second.has_prefix("/"))
352                         {
353                                 ret += "/";
354                         }
355                         //print("combined path = %s",  ret + second);
356                         return ret + second;
357                 }
358                 public   string  resolve_path_times(string part, int times, string? clue = null)
359                 {
360                         string ret = "";
361                         for (int i = 0; i < times; i++)
362                         {
363                                 if (clue != null && i > 0)
364                                 {
365                                         ret += clue;
366                                 }
367                                 ret += part;
368                         }
369                         return ret;
370                 }
371                 public   string resolve_path(string _path, string? relative = null)
372                 {
373                         string path = _path;
374                         if (relative != null)
375                         {
376                                 path = this.resolve_path_combine_path(path, relative);
377                         }
378                         string[] parts = path.split("/");
379                         string[] ret = {};
380                         int relative_parts = 0;
381                                         
382                         foreach (var part in parts)
383                         {
384                                 if (part.length < 1 || part == ".")
385                                 {
386                                         continue;
387                                 }
388                                 
389                                 if (part == "..")
390                                 {
391                                         if (ret.length > 0)
392                                         {
393                                                 ret = ret[0: ret.length -1];
394                                         }
395                                         else
396                                         {
397                                                 relative_parts++;
398                                         }
399                                         continue;
400                                 }
401                                 
402                                 ret += part;
403                         }
404                         
405                         path =  this.resolve_path_combine_path(this.resolve_path_times("..", relative_parts, "/"), string.joinv("/", ret));
406                         if (_path.has_prefix("/"))
407                         {
408                                 path = "/" + path;
409                         }
410                         return path;
411                 }
412                 
413                 public string[] vapidirs()
414                 {
415                         string[] ret = {};
416                         var sources = this.compilegroups.get("_default_").sources;
417                         for(var i =0; i< sources.size; i++) {
418                                 
419                                 var path = this.resolve_path( this.firstPath(), sources.get(i));
420                                 
421                                 if (Path.get_basename (path) == "vapi") {
422                                         GLib.debug("Adding VAPIDIR: %s\n", path);
423                                         ret += path;
424                                 }
425                                 
426                         }
427                         return ret;
428                         
429                 }
430                         
431
432         }
433         // an object describing a build config (or generic ...)
434         public class GtkValaSettings : Object {
435                 public string name;
436                 public GtkValaSettings? parent;
437                 
438                 public string compile_flags; // generic to all.
439                 public Gee.ArrayList<string> packages; // list of packages?? some might be genericly named?
440                 public Gee.ArrayList<string> sources; // list of files+dirs (relative to project)
441                 public string target_bin;
442
443
444                 public GtkValaSettings(string name) 
445                 {
446                         this.name = name;
447                         this.compile_flags = "";
448                         this.target_bin = "";
449                         this.packages = new Gee.ArrayList<string>();
450                         this.sources = new Gee.ArrayList<string>();
451                                 
452                 }
453                 
454                 
455                 public GtkValaSettings.from_json(Json.Object el) {
456
457                         
458                         this.name = el.get_string_member("name");
459                         this.compile_flags = el.get_string_member("compile_flags");
460                         this.target_bin = el.get_string_member("target_bin");
461                         // sources and packages.
462                         this.sources = this.readArray(el.get_array_member("sources"));
463                         this.packages = this.readArray(el.get_array_member("packages"));
464                         
465                 }
466                 
467                 
468                 
469                 public Gee.ArrayList<string> readArray(Json.Array ar) 
470                 {
471                         var ret = new Gee.ArrayList<string>();
472                         for(var i =0; i< ar.get_length(); i++) {
473                                 ret.add(ar.get_string_element(i));
474                         }
475                         return ret;
476                 }
477                 
478                 public Json.Object toJson()
479                 {
480                         var ret = new Json.Object();
481                         ret.set_string_member("name", this.name);
482                         ret.set_string_member("compile_flags", this.compile_flags);
483                         ret.set_string_member("target_bin", this.target_bin);
484                         ret.set_array_member("sources", this.writeArray(this.sources));
485                         ret.set_array_member("packages", this.writeArray(this.packages));
486                         return ret;
487                 }
488                 public Json.Array writeArray(Gee.ArrayList<string> ar) {
489                         var ret = new Json.Array();
490                         for(var i =0; i< ar.size; i++) {
491                                 ret.add_string_element(ar.get(i));
492                         }
493                         return ret;
494                 }
495                 
496                 
497         }
498  
499    
500 }