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         protected string GetPathsList(List<string> paths)
 111         {
 112             List<string> pathsCopy = new List<string>(paths);
 113             pathsCopy[0] = " \"" + pathsCopy[0];
 114             pathsCopy[paths.Count - 1] = pathsCopy[paths.Count - 1] + "\"";
 115             return String.Join("\" \"", pathsCopy.ToArray());
 116         }
 117
 118         public bool Revert(List<string> paths, out List<File> files)
 119         {
 120             if (paths.Count < 1)
 121             {
 122                 files = new List<File>();
 123                 return true;
 124             }
 125             Executioner e = Executioner.GetExecutioner(m_path);
 126
 127             string input = String.Join("\n", paths.ToArray());
 128             string output, error;
 129
 130             if (e.Execute("git-update-index", "--add --remove --stdin", input, out output, out error) == 0 &&
 131                 e.Execute("git-update-index", "--refresh") == 0)
 132             {
 133                 return GetFiles(paths, out files);
 134             }
 135             files = null;
 136             return false;
 137         }
 138
 139         public bool Remove(List<string> paths, out List<File> files)
 140         {
 141             if (paths.Count < 1)
 142             {
 143                 files = new List<File>();
 144                 return true;
 145             }
 146             Executioner e = Executioner.GetExecutioner(m_path);
 147
 148             string input = GetPathsList(paths);
 149             if (e.Execute("git-rm", "--cached -f " + input) == 0)
 150             {
 151                 return GetFiles(paths, out files);
 152             }
 153             files = null;
 154             return false;
 155         }
 156
 157         public bool Checkout(Treeish t)
 158         {
 159             if (!t.Verify())
 160             {
 161                 return false;
 162             }
 163             Executioner e = Executioner.GetExecutioner(m_path);
 164             return 0 == e.Execute("git-checkout", t.ID);
 165         }
 166
 167         public bool Checkout(Tag t, string newBranchName)
 168         {
 169             if (!t.Verify())
 170             {
 171                 return false;
 172             }
 173             Executioner e = Executioner.GetExecutioner(m_path);
 174             if (0 == e.Execute("git-checkout", "-b " + newBranchName + " " + t.Name))
 175             {
 176                 UpdateBranches();
 177                 return true;
 178             }
 179             return false;
 180         }
 181
 182         protected bool UpdateBranches()
 183         {
 184             Executioner e = Executioner.GetExecutioner(m_path, false);
 185             string output, error;
 186             if (0 == e.Execute("git-branch", "", "", out output, out error))
 187             {
 188                 m_branches.Clear();
 189                 foreach (string s in output.Split(m_lineSep, StringSplitOptions.RemoveEmptyEntries))
 190                 {
 191                     string branchName = s.Trim();
 192                     if (branchName.StartsWith("*"))
 193                     {
 194                         branchName = branchName.Substring(2);
 195                         branchName = branchName.Trim();
 196                         m_CurrentBranch = new Branch(m_path, branchName);
 197                         m_branches.Add(m_CurrentBranch);
 198                     }
 199                     else
 200                     {
 201                         m_branches.Add(new Branch(m_path, branchName));
 202                     }
 203                 }
 204                 return true;
 205             }
 206             return false;
 207         }
 208
 209         protected bool UpdateTags()
 210         {
 211             Executioner e = Executioner.GetExecutioner(m_path, false);
 212             string output = null, error = null;
 213             if (0 == e.Execute("git-rev-parse", "--symbolic --tags", "", out output, out error))
 214             {
 215                 m_tags.Clear();
 216                 foreach (string s in output.Split(m_lineSep, StringSplitOptions.RemoveEmptyEntries))
 217                 {
 218                     m_tags.Add(new Tag(s.Trim(), m_path));
 219                 }
 220                 return true;
 221             }
 222             return false;
 223         }
 224
 225         public bool NewBranch(string name, Branch startPoint, Remote remote, bool bForce)
 226         {
 227             Executioner e = Executioner.GetExecutioner(m_path);
 228             string arguments = name;
 229             if (bForce)
 230             {
 231                 arguments = arguments + " -f";
 232             }
 233             if (null != startPoint)
 234             {
 235                 arguments = arguments + " " + startPoint.Name;
 236             }
 237             if (null != remote)
 238             {
 239                 arguments = arguments + " --track " + remote.Name;
 240             }
 241             bool retval = 0 == e.Execute("git-branch", arguments);
 242             UpdateBranches();
 243             return retval;
 244         }
 245
 246         public bool RenameBranch(Branch b, string newName, bool bForce)
 247         {
 248             Executioner e = Executioner.GetExecutioner(m_path);
 249             bool retval = 0 == e.Execute("git-branch", bForce ? "-M " : "-m " + b.Name + " " + newName);
 250             UpdateBranches();
 251             return retval;
 252         }
 253
 254         public bool DeleteBranch(Branch b, bool bForce)
 255         {
 256             Executioner e = Executioner.GetExecutioner(m_path);
 257             bool retval =  0 == e.Execute("git-branch", bForce ? "-D " : "-d " + b.Name);
 258             UpdateBranches();
 259             return retval;
 260         }
 261
 262         public List<File> ListFiles()
 263         {
 264             Executioner e = Executioner.GetExecutioner(m_path, true);
 265             string output, error;
 266             Dictionary<string, File> files = new Dictionary<string, File>();
 267             if (0 == e.Execute("git-ls-files", "-c -d -m -o -k -t -z", "", out output, out error))
 268             {
 269                 ParseLSOutput(output, files);
 270             }
 271             UpdateFromIndex(files, "");
 272             return new List<File>(files.Values);
 273         }
 274
 275         private void UpdateFromIndex(Dictionary<string, File> filesMap, string paths)
 276         {
 277             Executioner e = Executioner.GetExecutioner(m_path, true);
 278             string output, error;
 279             if (0 == e.Execute("git-diff-index", "-B -M -C -z --name-status HEAD " + paths, "", out output, out error))
 280             {
 281                 string[] lines = output.Split("\0".ToCharArray());
 282                 for (int i = 0; i < lines.Length - 1; i += 2)
 283                 {
 284                     string front = lines[i][0].ToString();
 285                     string file = lines[i + 1].Trim();
 286                     if (file.StartsWith("\""))
 287                     {
 288                         file = file.Substring(1);
 289                     }
 290                     if (file.EndsWith("\""))
 291                     {
 292                         file = file.Substring(0, file.Length - 1);
 293                     }
 294                     Git.File f;
 295                     if (filesMap.TryGetValue(file, out f))
 296                     {
 297                         f.SetState(front);
 298                     }
 299                 }
 300             }
 301         }
 302
 303         private void ParseLSOutput(string output, Dictionary<string, File> files)
 304         {
 305             string[] lines = output.Split("\0".ToCharArray());
 306             System.Console.WriteLine("path: " + m_path + " files: " + lines.Length);
 307             foreach (string oneline in lines)
 308             {
 309                 string line = oneline.Trim();
 310                 if (line.Length < 3)
 311                 {
 312                     continue;
 313                 }
 314
 315                 string front = line[0].ToString();
 316                 line = line.Substring(2);
 317                 if (line.StartsWith("\""))
 318                 {
 319                     line = line.Substring(1);
 320                 }
 321                 if (line.EndsWith("\""))
 322                 {
 323                     line = line.Substring(0, line.Length - 1);
 324                 }
 325                 File f;
 326                 if (!files.TryGetValue(line, out f))//work around git reporting files twice sometimes
 327                 {
 328                     f = new File(null, line);
 329                     files.Add(line, f);
 330                 }
 331                 if (front == "?")
 332                 {
 333                     f.State = FileState.Unknown;
 334                 }
 335                 else
 336                 {
 337                     f.State = FileState.Normal;
 338                 }
 339             }
 340         }
 341
 342         public bool Reset(string commit)
 343         {
 344             Executioner e = Executioner.GetExecutioner(m_path);
 345             string id = null == commit ? "HEAD" : commit;
 346             return (0 == e.Execute("git-read-tree", "--reset -u " + id));
 347         }
 348
 349         public bool GetLog(Commit start, int count, out List<Commit> commits)
 350         {
 351             Executioner e = Executioner.GetExecutioner(m_path, true);
 352             string args = "-n " + count + Git.Commit.FormatString;
 353             if (null != start)
 354             {
 355                 args += start.ID;
 356             }
 357             string output, error;
 358             if (0 == e.Execute("git-log", args, "", out output, out error))
 359             {
 360                 string[] records = output.Split(Repo.LineSeparator, StringSplitOptions.RemoveEmptyEntries);
 361                 commits = new List<Commit>();
 362                 foreach (string record in records)
 363                 {
 364                     Commit c = Git.Commit.GetCommit(m_path, record);
 365                     commits.Add(c);
 366                 }
 367                 return true;
 368             }
 369             commits = null;
 370             return false;
 371         }
 372     }
 373 }