Changed GitBranch.vala

[gitlive] / GitBranch.vala

/**
represent a git branch..
Branching / Gitlive:

Does repo require branching? - flag in config?
** list of repo's ?? with ability to turn on/off

Start editing without branch?
-> show prompt to start branch
-> flag a ticket? optional ??

Once editing branch...
-> merge with squash / ticket...
** show list of repo's with 'working' branches?
** select some/all to merge with a issue fix..

?? closing ticket in system ??
-> done by the ui?

need to push all? / fetch all?


list of repo's


*/

public class GitBranch : Object
{
        public GitRepo repo;
        
        public bool active = false;
        public string lastrev = "";
        public string name = "";
        public bool is_remote;
        public string remote = "";
        public string remoterev = "";
        
        public string toString()
        {
                return 
                        "active: " + (active ? "true" : "false") + "\n" +
                        "is_remote: " + (is_remote ? "true" : "false") + "\n" +                 
                        "lastrev: " + lastrev + "\n" +
                        "name: " + name + "\n" +
                        "remote: " + remote + "\n" +
                        "remoterev: " + remoterev + "\n";
        }
        
        
        public GitBranch(GitRepo repo)
        {
                this.repo = repo;
        }

        public static  void loadBranches(GitRepo repo)
        {
                repo.branches = new Gee.HashMap<string,GitBranch>();
        
        var branches =  new Gee.HashMap<string,GitBranch>();
        var local =  new Gee.HashMap<string,GitBranch>();
        var remotes  =  new Gee.HashMap<string,GitBranch>();
        
      //         repo.git( { "fetch",  "-a" } ); == done async before...
        
        string[] cmd = { "branch",   "--no-color", "--verbose", "--no-abbrev" , "-a"  };
        var res = repo.git( cmd );
        var lines = res.split("\n");
        for (var i = 0; i < lines.length ; i++) {
                var br = new GitBranch(repo);
                if (!br.parseBranchListItem(lines[i])) {
                        continue;
                }
                GLib.debug("add branch %s", br.realName());
                if (!br.is_remote) {
                        local.set(br.name, br);
                } else {
                        remotes.set(br.remote, br);
                        }
                 
                branches.set(br.realName(), br);
                if (br.active) {
                        repo.currentBranch = br;
                }
        }
        
         var bl = repo.git({
                "for-each-ref",
                "--format",   "%(refname:short):remotes/%(upstream:short)",
                "refs/heads"
                }).split("\n");
        
        foreach(var line in bl) {
                if (line.length < 1) continue;
                
                var ar = line.split(":remotes/");
                var lname= ar[0];
            var rname = "remotes/" + ar[1];
            
                //print(rname);
                // we should always have a local version of it.
            if (branches.has_key(lname)) {      
                    branches.get(lname).remote = rname;
            }
            
            if (!branches.has_key(rname)) {
                    continue;
            }
            branches.get(lname).remoterev =  branches.get(rname).lastrev;
                // flag it for not adding..
                
            branches.get(rname).name = lname;
        }
        foreach(var br in branches.values) {
                if (br.name.length > 0 || ! /^remotes\/origin\//.match(br.remote)) {
                        continue;
                }
                var newname = br.remote.replace("/remotes/origin/","");
                if (branches.has_key(newname)) {
                        continue;
                        }
                repo.get( { "branch" "--track", newname, "origin/" + newname} ); 
                //GLib.debug("BRANCH:\n%s\n" , br.toString());
        }
        
        /*
        this bit of the code tries to turn a local branch into a track of a remote one.
        -- that's probably not a good idea.
        var r_replace = new Regex("^remotes/");
        var o_replace = new Regex("^origin/");
        foreach(var r in remotes.values) {
                if (r.name.length >0) {
                        return;
                }
                var name = r_replace.replace(r.name, r.name.length,0, "");
                name = o_replace.replace(name, name.length,0, "");
                name = name.replace("/", ".");
                
        }
        */
        repo.branches = local;
        
    
        
        }


        public bool parseBranchListItem(string str)
        {
                if (str.length  < 1) {
                        return false;
                }
                this.active = str[0] == '*';
                
                var parts = Regex.split_simple ("[ \t]+", str.substring(2).strip());
                if (parts[1] == "->") { // it's an alias.. eg. remotes/origin/HEAD -> origin/master..
                        return false;
                }
                this.is_remote = false;
                this.lastrev = parts[1];
                if (parts[0].has_prefix("remotes/")) {
                        this.is_remote  = true;
                        this.remote = parts[0];
                } else {
                        this.name = parts[0];
                }
            return true;
        }
        public string  realName()
        {
                return this.is_remote ? this.remote : this.name;
        }
        
        public void create()
        {
        
        }
        
}