Git/Repo.cs

   1 using System;
   2 using System.Collections.Generic;
   3 using System.Text;
   4
   5 namespace Git
   6 {
   7     public class Repo
   8     {
   9         Branch m_CurrentBranch = null;
  10         public Branch CurrentBranch { get { return m_CurrentBranch; } }
  11
  12         List<Branch> m_branches = new List<Branch>();
  13         public List<Branch> Branches { get { return new List<Branch>(m_branches); } }
  14
  15         Tree m_workingSet = null;
  16         public Tree WorkingSet { get { return m_workingSet; } }
  17
  18         List<Remote> m_remotes = new List<Remote>();
  19         public List<Remote> Remotes { get { return new List<Remote>(m_remotes); } }
  20
  21         List<Tag> m_tags = new List<Tag>();
  22         public List<Tag> Tags { get { return new List<Tag>(m_tags); } }
  23
  24         string m_path;
  25         public string Path { get { return m_path; } }
  26
  27         public static string DirectorySeparator { get { return "/"; } } //git-ls always uses "/"
  28
  29         protected static bool m_mono = Type.GetType ("Mono.Runtime") != null;
  30         public static bool Mono { get { return m_mono; } }
  31
  32         protected static string[] m_lineSep = { System.Environment.NewLine };
  33         public static string[] LineSeparator { get { return m_lineSep; } }
  34
  35         public Repo(string path)
  36         {
  37             m_path = path;
  38             if (UpdateBranches())
  39             {
  40                 UpdateTags();
  41             }
  42         }
  43
  44         protected bool ValidateRepo()
  45         {
  46             return ValidateRepo(m_path);
  47         }
  48
  49         public static bool ValidateRepo(string path)
  50         {
  51             Executioner e = Executioner.GetExecutioner(path, false);
  52
  53             return 0 == e.Execute("git-rev-parse", "--git-dir");
  54         }
  55
  56         public bool Init()
  57         {
  58             if (ValidateRepo())
  59             {
  60                 return true;
  61             }
  62             Executioner e = Executioner.GetExecutioner(m_path);
  63             return 0 == e.Execute("git-init-db");
  64         }
  65
  66         public bool Commit(string message, string[] signedOff, out Commit commited)
  67         {
  68             throw new NotImplementedException();
  69         }
  70
  71         public bool GetFiles(List<string> paths, out List<File> files)
  72         {
  73             if (paths.Count < 1)
  74             {
  75                 files = new List<Git.File>();
  76                 return true;
  77             }
  78
  79             paths[0] = "\"" + paths[0];
  80             paths[paths.Count - 1] = paths[paths.Count - 1] + "\"";
  81             string pathset = String.Join("\" \"", paths.ToArray());
  82             string input = "-c -d -m -o -t -z -k " + pathset;
  83             string output, error;
  84             Dictionary<string, File> filesMap = new Dictionary<string, File>();
  85             Executioner e = Executioner.GetExecutioner(m_path);
  86             if (0 == e.Execute("git-ls-files", input, "", out output, out error))
  87             {
  88                 ParseLSOutput(output, filesMap);
  89                 UpdateFromIndex(filesMap, pathset);
  90                 files = new List<Git.File>(filesMap.Values);
  91                 return true;
  92             }
  93             files = null;
  94             return false;
  95         }
  96
  97         public bool Add(List<string> paths, out List<File> files)
  98         {
  99             Executioner e = Executioner.GetExecutioner(m_path);
 100             files = null;
 101             string input = String.Join("\n", paths.ToArray());
 102             string output, error;
 103             if (e.Execute("git-update-index", "--add --stdin", input, out output, out error) == 0)
 104             {
 105                 return GetFiles(paths, out files);
 106             }
 107             return false;
 108         }
 109
 110         public bool Revert(List<string> paths, out List<File> files)
 111         {
 112             Executioner e = Executioner.GetExecutioner(m_path);
 113             files = null;
 114             string input = String.Join("\n", paths.ToArray());
 115             string output, error;
 116             if (e.Execute("git-add", "--add --stdin", input, out output, out error) == 0)
 117             {
 118                 return GetFiles(paths, out files);
 119             }
 120             return false;
 121         }
 122
 123         public bool Remove(List<string> paths, out List<File> files)
 124         {
 125             if (paths.Count < 1)
 126             {
 127                 files = new List<File>();
 128                 return true;
 129             }
 130             Executioner e = Executioner.GetExecutioner(m_path);
 131             List<string> pathsCopy = new List<string>(paths);
 132             paths[0] = " \"" + paths[0];
 133             paths[paths.Count - 1] = paths[paths.Count - 1] + "\"";
 134             string input = String.Join("\" \"", paths.ToArray());
 135
 136             if (e.Execute("git-rm", "--cached -f " + input) == 0)
 137             {
 138                 return GetFiles(pathsCopy, out files);
 139             }
 140             files = null;
 141             return false;
 142         }
 143
 144         public bool Checkout(Treeish t)
 145         {
 146             if (!t.Verify())
 147             {
 148                 return false;
 149             }
 150             Executioner e = Executioner.GetExecutioner(m_path);
 151             return 0 == e.Execute("git-checkout", t.ID);
 152         }
 153
 154         public bool Checkout(Tag t, string newBranchName)
 155         {
 156             if (!t.Verify())
 157             {
 158                 return false;
 159             }
 160             Executioner e = Executioner.GetExecutioner(m_path);
 161             if (0 == e.Execute("git-checkout", "-b " + newBranchName + " " + t.Name))
 162             {
 163                 UpdateBranches();
 164                 return true;
 165             }
 166             return false;
 167         }
 168
 169         protected bool UpdateBranches()
 170         {
 171             Executioner e = Executioner.GetExecutioner(m_path, false);
 172             string output, error;
 173             if (0 == e.Execute("git-branch", "", "", out output, out error))
 174             {
 175                 m_branches.Clear();
 176                 foreach (string s in output.Split(m_lineSep, StringSplitOptions.RemoveEmptyEntries))
 177                 {
 178                     string branchName = s.Trim();
 179                     if (branchName.StartsWith("*"))
 180                     {
 181                         branchName = branchName.Substring(2);
 182                         branchName = branchName.Trim();
 183                         m_CurrentBranch = new Branch(m_path, branchName);
 184                         m_branches.Add(m_CurrentBranch);
 185                     }
 186                     else
 187                     {
 188                         m_branches.Add(new Branch(m_path, branchName));
 189                     }
 190                 }
 191                 return true;
 192             }
 193             return false;
 194         }
 195
 196         protected bool UpdateTags()
 197         {
 198             Executioner e = Executioner.GetExecutioner(m_path, false);
 199             string output = null, error = null;
 200             if (0 == e.Execute("git-rev-parse", "--symbolic --tags", "", out output, out error))
 201             {
 202                 m_tags.Clear();
 203                 foreach (string s in output.Split(m_lineSep, StringSplitOptions.RemoveEmptyEntries))
 204                 {
 205                     m_tags.Add(new Tag(s.Trim(), m_path));
 206                 }
 207                 return true;
 208             }
 209             return false;
 210         }
 211
 212         public bool NewBranch(string name, Branch startPoint, Remote remote, bool bForce)
 213         {
 214             Executioner e = Executioner.GetExecutioner(m_path);
 215             string arguments = name;
 216             if (bForce)
 217             {
 218                 arguments = arguments + " -f";
 219             }
 220             if (null != startPoint)
 221             {
 222                 arguments = arguments + " " + startPoint.Name;
 223             }
 224             if (null != remote)
 225             {
 226                 arguments = arguments + " --track " + remote.Name;
 227             }
 228             bool retval = 0 == e.Execute("git-branch", arguments);
 229             UpdateBranches();
 230             return retval;
 231         }
 232
 233         public bool RenameBranch(Branch b, string newName, bool bForce)
 234         {
 235             Executioner e = Executioner.GetExecutioner(m_path);
 236             bool retval = 0 == e.Execute("git-branch", bForce ? "-M " : "-m " + b.Name + " " + newName);
 237             UpdateBranches();
 238             return retval;
 239         }
 240
 241         public bool DeleteBranch(Branch b, bool bForce)
 242         {
 243             Executioner e = Executioner.GetExecutioner(m_path);
 244             bool retval =  0 == e.Execute("git-branch", bForce ? "-D " : "-d " + b.Name);
 245             UpdateBranches();
 246             return retval;
 247         }
 248
 249         public List<File> ListFiles()
 250         {
 251             Executioner e = Executioner.GetExecutioner(m_path, true);
 252             string output, error;
 253             Dictionary<string, File> files = new Dictionary<string, File>();
 254             if (0 == e.Execute("git-ls-files", "-c -d -m -o -k -t -z", "", out output, out error))
 255             {
 256                 ParseLSOutput(output, files);
 257             }
 258             UpdateFromIndex(files, "");
 259             return new List<File>(files.Values);
 260         }
 261
 262         private void UpdateFromIndex(Dictionary<string, File> filesMap, string paths)
 263         {
 264             Executioner e = Executioner.GetExecutioner(m_path, true);
 265             string output, error;
 266             if (0 == e.Execute("git-diff-index", "-B -M -C -z --name-status HEAD " + paths, "", out output, out error))
 267             {
 268                 string[] lines = output.Split("\0".ToCharArray());
 269                 for (int i = 0; i < lines.Length - 1; i += 2)
 270                 {
 271                     string front = lines[i][0].ToString();
 272                     string file = lines[i + 1].Trim();
 273                     if (file.StartsWith("\""))
 274                     {
 275                         file = file.Substring(1);
 276                     }
 277                     if (file.EndsWith("\""))
 278                     {
 279                         file = file.Substring(0, file.Length - 1);
 280                     }
 281                     Git.File f;
 282                     if (filesMap.TryGetValue(file, out f))
 283                     {
 284                         f.SetState(front);
 285                     }
 286                 }
 287             }
 288         }
 289
 290         private void ParseLSOutput(string output, Dictionary<string, File> files)
 291         {
 292             string[] lines = output.Split("\0".ToCharArray());
 293             System.Console.WriteLine("path: " + m_path + " files: " + lines.Length);
 294             foreach (string oneline in lines)
 295             {
 296                 string line = oneline.Trim();
 297                 if (line.Length < 3)
 298                 {
 299                     continue;
 300                 }
 301
 302                 string front = line[0].ToString();
 303                 line = line.Substring(2);
 304                 if (line.StartsWith("\""))
 305                 {
 306                     line = line.Substring(1);
 307                 }
 308                 if (line.EndsWith("\""))
 309                 {
 310                     line = line.Substring(0, line.Length - 1);
 311                 }
 312                 File f;
 313                 if (!files.TryGetValue(line, out f))//work around git reporting files twice sometimes
 314                 {
 315                     f = new File(null, line);
 316                     files.Add(line, f);
 317                 }
 318                 if (front == "?")
 319                 {
 320                     f.State = FileState.Unknown;
 321                 }
 322                 else
 323                 {
 324                     f.State = FileState.Normal;
 325                 }
 326             }
 327         }
 328     }
 329 }