Git/Repo.cs

   1 //Widgit is free software; you can redistribute it and/or modify
   2 //it under the terms of the GNU General Public License as published by
   3 //the Free Software Foundation; either version 2 of the License, or
   4 //(at your option) any later version.
   5
   6 //Widgit is distributed in the hope that it will be useful,
   7 //but WITHOUT ANY WARRANTY; without even the implied warranty of
   8 //MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   9 //GNU General Public License for more details.
  10
  11 //You should have received a copy of the GNU General Public License
  12 //along with Widgit; if not, write to the Free Software
  13 //Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USAusing System;
  14
  15 using System;
  16 using System.Collections.Generic;
  17 using System.Text;
  18
  19 namespace Git
  20 {
  21     using PathToGitFile = Dictionary<string, Git.File>;
  22     public class Repo
  23     {
  24         Branch m_CurrentBranch = null;
  25         public Branch CurrentBranch { get { return m_CurrentBranch; } }
  26
  27         List<Branch> m_branches = new List<Branch>();
  28         public List<Branch> Branches { get { return new List<Branch>(m_branches); } }
  29
  30         Tree m_workingSet = null;
  31         public Tree WorkingSet { get { return m_workingSet; } }
  32
  33         List<Remote> m_remotes = new List<Remote>();
  34         public List<Remote> Remotes { get { return new List<Remote>(m_remotes); } }
  35
  36         List<Tag> m_tags = new List<Tag>();
  37         public List<Tag> Tags { get { return new List<Tag>(m_tags); } }
  38
  39         string m_path;
  40         public string Path { get { return m_path; } }
  41
  42         public static string DirectorySeparator { get { return "/"; } } //git-ls always uses "/"
  43
  44         protected static bool m_mono = Type.GetType ("Mono.Runtime") != null;
  45         public static bool Mono { get { return m_mono; } }
  46
  47         protected static string[] m_lineSep = { System.Environment.NewLine };
  48         public static string[] LineSeparator { get { return m_lineSep; } }
  49
  50         protected PathToGitFile m_knownFiles;
  51
  52         protected string m_gitDir;
  53         public string GitDir
  54         {
  55             get
  56             {
  57                 if (String.IsNullOrEmpty(m_gitDir))
  58                 {
  59                     if (!ValidateRepo())
  60                     {
  61                         return null;
  62                     }
  63                 }
  64                 return m_gitDir;
  65             }
  66         }
  67
  68         public Repo(string path)
  69         {
  70             m_path = path;
  71             if (UpdateBranches())
  72             {
  73                 UpdateTags();
  74             }
  75         }
  76
  77         protected bool ValidateRepo()
  78         {
  79             return ValidateRepo(m_path, out m_gitDir);
  80         }
  81
  82         public static bool ValidateRepo(string path)
  83         {
  84             string output;
  85             return ValidateRepo(path, out output);
  86         }
  87
  88         public static bool ValidateRepo(string path, out string dir)
  89         {
  90             Executioner e = Executioner.GetExecutioner(path, false);
  91             string error;
  92             bool retval = 0 == e.Execute("git-rev-parse", "--git-dir", "", out dir, out error);
  93             dir = dir.Trim();
  94             return retval;
  95         }
  96
  97         public bool Init()
  98         {
  99             if (ValidateRepo())
 100             {
 101                 return true;
 102             }
 103             Executioner e = Executioner.GetExecutioner(m_path);
 104             return 0 == e.Execute("git-init-db");
 105         }
 106
 107         public bool Commit(string message, string[] signedOff, out Commit commited)
 108         {
 109             throw new NotImplementedException();
 110         }
 111
 112         public bool GetFiles(List<string> paths, out List<File> files)
 113         {
 114             if (paths.Count < 1)
 115             {
 116                 files = new List<Git.File>();
 117                 return true;
 118             }
 119
 120             paths[0] = "\"" + paths[0];
 121             paths[paths.Count - 1] = paths[paths.Count - 1] + "\"";
 122             string pathset = String.Join("\" \"", paths.ToArray());
 123             string input = "-c -d -m -o -t -z -k " + pathset;
 124             string output, error;
 125             Dictionary<string, File> filesMap = new Dictionary<string, File>();
 126             Executioner e = Executioner.GetExecutioner(m_path);
 127             if (0 == e.Execute("git-ls-files", input, "", out output, out error))
 128             {
 129                 ParseLSOutput(output, filesMap);
 130                 DiffIndex(filesMap, pathset);
 131                 files = new List<Git.File>(filesMap.Values);
 132                 return true;
 133             }
 134             files = null;
 135             return false;
 136         }
 137
 138         public bool Add(List<string> paths, out List<File> files)
 139         {
 140             Executioner e = Executioner.GetExecutioner(m_path);
 141             files = null;
 142             string input = String.Join("\n", paths.ToArray());
 143             string output, error;
 144             if (e.Execute("git-update-index", "--add --stdin", input, out output, out error) == 0)
 145             {
 146                 return GetFiles(paths, out files);
 147             }
 148             return false;
 149         }
 150
 151         protected string GetPathsList(List<string> paths)
 152         {
 153             List<string> pathsCopy = new List<string>(paths);
 154             pathsCopy[0] = " \"" + pathsCopy[0];
 155             pathsCopy[paths.Count - 1] = pathsCopy[paths.Count - 1] + "\"";
 156             return String.Join("\" \"", pathsCopy.ToArray());
 157         }
 158
 159         public bool Revert(List<string> paths, out List<File> files)
 160         {
 161             if (paths.Count < 1)
 162             {
 163                 files = new List<File>();
 164                 return true;
 165             }
 166             Executioner e = Executioner.GetExecutioner(m_path);
 167
 168             string input = String.Join("\n", paths.ToArray());
 169             string output, error;
 170
 171             if (e.Execute("git-update-index", "--add --remove --stdin", input, out output, out error) == 0 &&
 172                 e.Execute("git-update-index", "--refresh") == 0)
 173             {
 174                 return GetFiles(paths, out files);
 175             }
 176             files = null;
 177             return false;
 178         }
 179
 180         public bool Remove(List<string> paths, out List<File> files)
 181         {
 182             if (paths.Count < 1)
 183             {
 184                 files = new List<File>();
 185                 return true;
 186             }
 187             Executioner e = Executioner.GetExecutioner(m_path);
 188
 189             string input = GetPathsList(paths);
 190             if (e.Execute("git-rm", "--cached -f " + input) == 0)
 191             {
 192                 return GetFiles(paths, out files);
 193             }
 194             files = null;
 195             return false;
 196         }
 197
 198         public bool Checkout(Treeish t)
 199         {
 200             if (!t.Verify())
 201             {
 202                 return false;
 203             }
 204             Executioner e = Executioner.GetExecutioner(m_path);
 205             return 0 == e.Execute("git-checkout", t.ID);
 206         }
 207
 208         public bool Checkout(Tag t, string newBranchName)
 209         {
 210             if (!t.Verify())
 211             {
 212                 return false;
 213             }
 214             Executioner e = Executioner.GetExecutioner(m_path);
 215             if (0 == e.Execute("git-checkout", "-b " + newBranchName + " " + t.Name))
 216             {
 217                 UpdateBranches();
 218                 return true;
 219             }
 220             return false;
 221         }
 222
 223         protected bool UpdateBranches()
 224         {
 225             Executioner e = Executioner.GetExecutioner(m_path, false);
 226             string output, error;
 227             if (0 == e.Execute("git-branch", "-v --no-abbrev", "", out output, out error))
 228             {
 229                 m_branches.Clear();
 230                 foreach (string s in output.Split(m_lineSep, StringSplitOptions.RemoveEmptyEntries))
 231                 {
 232                     string flag = s.Substring(0, 1);
 233                     int idx = s.IndexOf(" ", 3);
 234                     string name = s.Substring(2, idx - 2);
 235                     while (s[idx] == ' ') ++idx;
 236                     int idx2 = s.IndexOf(" ", idx);
 237                     string hash = s.Substring(idx, (idx2 - idx));
 238                     Branch b = new Branch(m_path, name);
 239                     b.ID = hash;
 240                     m_branches.Add(b);
 241                     if (flag == "*")
 242                     {
 243                         m_CurrentBranch = b;
 244                     }
 245                 }
 246                 return true;
 247             }
 248             return false;
 249         }
 250
 251         protected bool UpdateTags()
 252         {
 253             Executioner e = Executioner.GetExecutioner(m_path, false);
 254             string output = null, error = null;
 255             if (0 == e.Execute("git-show-ref", "--tags", "", out output, out error))
 256             {
 257                 m_tags.Clear();
 258                 foreach (string s in output.Split(m_lineSep, StringSplitOptions.RemoveEmptyEntries))
 259                 {
 260                     string hash = s.Substring(0, 40);
 261                     string name = s.Substring(41);
 262                     Tag t = new Tag(name, m_path);
 263                     t.ID = hash;
 264                     m_tags.Add(t);
 265                 }
 266                 return true;
 267             }
 268             return false;
 269         }
 270
 271         public bool NewBranch(string name, Branch startPoint, Remote remote, bool bForce)
 272         {
 273             Executioner e = Executioner.GetExecutioner(m_path);
 274             string arguments = name;
 275             if (bForce)
 276             {
 277                 arguments = arguments + " -f";
 278             }
 279             if (null != startPoint)
 280             {
 281                 arguments = arguments + " " + startPoint.Name;
 282             }
 283             if (null != remote)
 284             {
 285                 arguments = arguments + " --track " + remote.Name;
 286             }
 287             bool retval = 0 == e.Execute("git-branch", arguments);
 288             UpdateBranches();
 289             return retval;
 290         }
 291
 292         public bool RenameBranch(Branch b, string newName, bool bForce)
 293         {
 294             Executioner e = Executioner.GetExecutioner(m_path);
 295             bool retval = 0 == e.Execute("git-branch", bForce ? "-M " : "-m " + b.Name + " " + newName);
 296             UpdateBranches();
 297             return retval;
 298         }
 299
 300         public bool DeleteBranch(Branch b, bool bForce)
 301         {
 302             Executioner e = Executioner.GetExecutioner(m_path);
 303             bool retval =  0 == e.Execute("git-branch", bForce ? "-D " : "-d " + b.Name);
 304             UpdateBranches();
 305             return retval;
 306         }
 307
 308         public List<File> ListFiles(bool bJustUnmanaged)
 309         {
 310             Executioner e = Executioner.GetExecutioner(m_path, true);
 311             string output, error;
 312             Dictionary<string, File> files = new Dictionary<string, File>();
 313             string args = bJustUnmanaged ? "-t -o -z" : "-c -d -m -o -k -t -z";
 314             if (0 == e.Execute("git-ls-files", args, "", out output, out error))
 315             {
 316                 ParseLSOutput(output, files);
 317             }
 318             return new List<File>(files.Values);
 319         }
 320
 321         public void DiffIndex(Dictionary<string, File> filesMap, string paths)
 322         {
 323             Executioner e = Executioner.GetExecutioner(m_path, true);
 324             string output, error;
 325             if (0 == e.Execute("git-diff-index", "-B -M -C -z --name-status HEAD " + paths, "", out output, out error))
 326             {
 327                 string[] lines = output.Split("\0".ToCharArray());
 328                 for (int i = 0; i < lines.Length - 1; i += 2)
 329                 {
 330                     string front = lines[i][0].ToString();
 331                     string file = lines[i + 1].Trim();
 332                     if (file.StartsWith("\""))
 333                     {
 334                         file = file.Substring(1);
 335                     }
 336                     if (file.EndsWith("\""))
 337                     {
 338                         file = file.Substring(0, file.Length - 1);
 339                     }
 340                     UpdateMap(filesMap, front, file);
 341                     if (front == "R")
 342                     {
 343                         string file2 = lines[i + 2];
 344                         UpdateMap(filesMap, "R", file2);
 345                         ++i;
 346                     }
 347                     if (front == "C")
 348                     {
 349                         string file2 = lines[i + 2];
 350                         UpdateMap(filesMap, "A", file2);
 351                         ++i;
 352                     }
 353                 }
 354             }
 355         }
 356
 357         private Git.File UpdateMap(Dictionary<string, File> filesMap, string type, string file)
 358         {
 359             Git.File f;
 360             if (!filesMap.TryGetValue(file, out f))
 361             {
 362                 f = new Git.File(m_path, file);
 363                 filesMap.Add(file, f);
 364             }
 365             f.SetState(type);
 366             return f;
 367         }
 368
 369         private void ParseLSOutput(string output, Dictionary<string, File> files)
 370         {
 371             string[] lines = output.Split("\0".ToCharArray());
 372             System.Console.WriteLine("path: " + m_path + " files: " + lines.Length);
 373             foreach (string oneline in lines)
 374             {
 375                 string line = oneline.Trim();
 376                 if (line.Length < 3)
 377                 {
 378                     continue;
 379                 }
 380
 381                 string front = line[0].ToString();
 382                 line = line.Substring(2);
 383                 if (line.StartsWith("\""))
 384                 {
 385                     line = line.Substring(1);
 386                 }
 387                 if (line.EndsWith("\""))
 388                 {
 389                     line = line.Substring(0, line.Length - 1);
 390                 }
 391                 File f;
 392                 if (!files.TryGetValue(line, out f))//work around git reporting files twice sometimes
 393                 {
 394                     f = new File(m_path, line);
 395                     files.Add(line, f);
 396                 }
 397                 if (front == "?")
 398                 {
 399                     f.State = FileState.Unknown;
 400                 }
 401                 else
 402                 {
 403                     f.State = FileState.Normal;
 404                 }
 405             }
 406         }
 407
 408         public bool Reset(string commit)
 409         {
 410             Executioner e = Executioner.GetExecutioner(m_path);
 411             string id = null == commit ? "HEAD" : commit;
 412             return (0 == e.Execute("git-read-tree", "--reset -u " + id));
 413         }
 414
 415         public bool GetLog(ILogFilter f, out List<Commit> commits)
 416         {
 417             Executioner e = Executioner.GetExecutioner(m_path, true);
 418             string args = "-n " + f.Max + Git.Commit.FormatString;
 419             if (null != f.Treeish)
 420             {
 421                 args += f.Treeish.ID;
 422             }
 423             if (!String.IsNullOrEmpty(f.After))
 424             {
 425                 args += " --since=\"" + f.After + "\"";
 426             }
 427             if (!String.IsNullOrEmpty(f.Before))
 428             {
 429                 args += " --until=\"" + f.Before + "\"";
 430             }
 431             foreach (string author in f.Authors)
 432             {
 433                 args += " --author=\"" + author + "\"";
 434             }
 435             foreach (string path in f.Paths)
 436             {
 437                 args += " \"" + path + "\"";
 438             }
 439             string output, error;
 440             if (0 == e.Execute("git-log", args, "", out output, out error))
 441             {
 442                 string[] records = output.Split(Repo.LineSeparator, StringSplitOptions.RemoveEmptyEntries);
 443                 commits = new List<Commit>();
 444                 foreach (string record in records)
 445                 {
 446                     Commit c = Git.Commit.GetCommit(m_path, record);
 447                     commits.Add(c);
 448                 }
 449                 return true;
 450             }
 451             commits = null;
 452             return false;
 453         }
 454
 455         public bool GetFilesMap(out PathToGitFile map, bool bForceUpdate)
 456         {
 457             if (null == m_knownFiles || bForceUpdate)
 458             {
 459                 m_knownFiles = new PathToGitFile();
 460                 List<Git.File> unmanagedFiles = ListFiles(true);
 461                 foreach (Git.File f in unmanagedFiles)
 462                 {
 463                     m_knownFiles.Add(f.PathWithName, f);
 464                 }
 465                 DiffIndex(m_knownFiles, "");
 466             }
 467             map = new PathToGitFile(m_knownFiles);
 468             return true;
 469         }
 470     }
 471 }