using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
namespace GitForce
{
/// <summary>
/// Class containing a single repository and a set of functions operating on it
/// </summary>
[Serializable]
public class ClassRepo : IComparable
{
/// <summary>
/// Root local directory of the repository
/// </summary>
private string Root;
/// <summary>
/// User.name configuration setting for this repo
/// </summary>
public string UserName;
/// <summary>
/// User.email coniguration setting for this repo
/// </summary>
public string UserEmail;
/// <summary>
/// Set of remotes associated with this repository
/// </summary>
public readonly ClassRemotes Remotes = new ClassRemotes();
/// <summary>
/// Set of active commits currently existing for this repo
/// </summary>
public readonly ClassCommits Commits = new ClassCommits();
/// <summary>
/// Set of branches for the current repo
/// </summary>
public readonly ClassBranches Branches = new ClassBranches();
/// <summary>
/// Current format can be tree view or list view
/// </summary>
public bool IsTreeView = true;
/// <summary>
/// Current sorting rule for the view
/// </summary>
public GitDirectoryInfo.SortBy SortBy = GitDirectoryInfo.SortBy.Name;
/// <summary>
/// Stores a set of paths that are expanded in the left pane view.
/// Although used only by the view, keeping it here saves it across
/// the sessions.
/// WAR: This is marked as Non-Serialized since Mono 2.6.7 does not support serialization of HashSet.
/// </summary>
[NonSerialized]
private HashSet<string> viewExpansionSet = new HashSet<string>();
/// <summary>
/// Stats of all files known to git in this repo. This status is refreshed
/// on every App global refresh, so it does not need to be preserved across sessions.
/// </summary>
[NonSerialized]
public ClassStatus Status;
/// <summary>
/// Class constructor
/// </summary>
public ClassRepo(string newRoot)
{
Root = newRoot;
}
/// <summary>
/// Returns or sets the directory path of the repo
/// </summary>
/// <returns>Path to the git repository</returns>
public string Path
{
get { return ClassUtils.GetCleanPath(Root); }
set { Root = ClassUtils.GetCleanPath(value); }
}
/// <summary>
/// Initializes repo class with user.name and user.email fields.
/// Returns True if the repo appears valid and these settings are read.
/// </summary>
public bool Init()
{
// We assume that a valid git repo will always have core.bare entry
if (ClassConfig.GetLocal(this, "core.bare") == string.Empty)
return false;
UserName = ClassConfig.GetLocal(this, "user.name");
UserEmail = ClassConfig.GetLocal(this, "user.email");
Status = new ClassStatus(this);
return true;
}
/// <summary>
/// ToString override returns the repository root path.
/// </summary>
public override string ToString()
{
return Root;
}
/// <summary>
/// Implement default comparator so these classes can be sorted by their (root) name
/// </summary>
public int CompareTo(object obj)
{
if (obj == null) return 1;
ClassRepo a = obj as ClassRepo;
return a != null ? ToString().CompareTo(a.ToString()) : 1;
}
/// <summary>
/// Mark a specific path as expanded in the view
/// </summary>
public void ExpansionSet(string path)
{
viewExpansionSet.Add(path);
}
/// <summary>
/// Mark a specific path as collapsed in the view,
/// or remove all paths from the list of expanded paths (if the path given is null)
/// </summary>
public void ExpansionReset(string path)
{
if (path == null)
viewExpansionSet = new HashSet<string>();
else
viewExpansionSet.Remove(path);
}
/// <summary>
/// Return true if the path is marked as expanded
/// </summary>
public bool IsExpanded(string path)
{
return viewExpansionSet.Contains(path);
}
/// <summary>
/// Converts a list of (relative) files into a quoted list,
/// further flattened into a string suitable to send to a git command.
/// </summary>
private string QuoteAndFlattenPaths(List<string> files)
{
List<string> quoted = files.Select(file => "\"" + file + "\"").ToList();
return string.Join(" ", quoted.ToArray());
}
/// <summary>
/// Add untracked files to Git repository
/// </summary>
public void GitAdd(List<string> files)
{
string list = QuoteAndFlattenPaths(files);
App.PrintStatusMessage("Adding " + list, MessageType.General);
RunCmd("add -- " + list);
// Any git command that adds/updates files in the index might cause file check for TABs
ClassTabCheck.CheckForTabs(files);
}
/// <summary>
/// Update modified files
/// </summary>
public void GitUpdate(List<string> files)
{
string list = QuoteAndFlattenPaths(files);
App.PrintStatusMessage("Updating " + list, MessageType.General);
RunCmd("add -- " + list);
// Any git command that adds/updates files in the index might cause file check for TABs
ClassTabCheck.CheckForTabs(files);
}
/// <summary>
/// Delete a list of files
/// </summary>
public void GitDelete(List<string> files) { GitDelete("", files); }
public void GitDelete(string tag, List<string> files)
{
string list = QuoteAndFlattenPaths(files);
App.PrintStatusMessage("Removing " + list, MessageType.General);
RunCmd("rm " + tag + " -- " + list);
}
/// <summary>
/// Rename a list of files
/// </summary>
public void GitRename(List<string> files)
{
string list = QuoteAndFlattenPaths(files);
App.PrintStatusMessage("Renaming " + list, MessageType.General);
RunCmd("add -- " + list);
// Any git command that adds/updates files in the index might cause file check for TABs
ClassTabCheck.CheckForTabs(files);
}
/// <summary>
/// Moves a file to a different name or different location
/// </summary>
public void GitMove(string srcFile, string dstFile)
{
App.PrintStatusMessage(string.Format("Moving {0} to {1}", srcFile, dstFile), MessageType.General);
RunCmd("mv \"" + srcFile + "\" \"" + dstFile + "\"");
}
/// <summary>
/// Checkout a list of files
/// </summary>
public void GitCheckout(string options, List<string> files)
{
string list = QuoteAndFlattenPaths(files);
App.PrintStatusMessage("Checkout " + options + " " + list, MessageType.General);
RunCmd("checkout " + options + " -- " + list);
}
/// <summary>
/// Revert a list of files
/// </summary>
public void GitRevert(List<string> files)
{
string list = QuoteAndFlattenPaths(files);
App.PrintStatusMessage("Reverting " + list, MessageType.General);
RunCmd("checkout -- " + list);
}
/// <summary>
/// Reset a list of files to a specific head.
/// Returns true if a git command succeeded, false otherwise.
/// </summary>
public bool GitReset(string head, List<string> files)
{
string list = QuoteAndFlattenPaths(files);
App.PrintStatusMessage(string.Format("Resetting to {0}: {1}", head, list), MessageType.General);
return RunCmd("reset " + head + " -- " + list).Success();
}
/// <summary>
/// Run the external diff command on a given file or a list of files
/// </summary>
public void GitDiff(string tag, List<string> files)
{
string list = QuoteAndFlattenPaths(files);
if (list == "\"\"") // For now, we don't want to match all paths but only diff selected files
{
App.PrintStatusMessage("Diffing: No files selected and we don't want to match all paths.", MessageType.General);
return;
}
App.PrintStatusMessage("Diffing " + list, MessageType.General);
RunCmd("difftool " + ClassDiff.GetDiffCmd() + " " + tag + " -- " + list, true);
}
/// <summary>
/// Commit a list of files.
/// Returns true if commit succeeded, false otherwise.
/// </summary>
public bool GitCommit(string cmd, bool isAmend, List<string> files)
{
ExecResult result;
string list = QuoteAndFlattenPaths(files);
App.PrintStatusMessage("Submit " + list, MessageType.General);
// See below Run() for the description of the problem with long commands.
// The Run() function breaks any command into chunks of 2000 characters or less
// and issues them separately. This can be done on every command except 'commit'
// since that would introduce multiple commits, which is probably not what the user
// wants. Hence, we break commit at this level into an initial commit of a single
// file (the first file on the list), and append for each successive chunk.
if (isAmend == false && list.Length >= 2000)
{
result = RunCmd("commit " + cmd + " -- " + "\"" + files[0] + "\"");
if (result.Success() == false)
return false;
isAmend = true;
files.RemoveAt(0);
list = QuoteAndFlattenPaths(files);
}
result = RunCmd(string.Format("commit {0} {1} -- {2}", cmd, isAmend ? "--amend" : "", list));
return result.Success();
}
/// <summary>
/// Repo class function that runs a git command in the context of a repository.
/// Use this function with all user-initiated commands in order to have them printed into the status window.
/// NOTE: C# 4.0 is currently not supported on MSVC 2008
/// </summary>
public ExecResult RunCmd(string args) { return RunCmd(args, false); }
public ExecResult RunCmd(string args, bool async)
{
// Print the actual command line to the status window only if user selected that setting
if (Properties.Settings.Default.logCommands)
App.PrintStatusMessage("git " + args, MessageType.Command);
// Run the command and print the response to the status window in any case
ExecResult result = Run(args, async);
if (result.stdout.Length > 0)
App.PrintStatusMessage(result.stdout, MessageType.Output);
// If the command caused an error, print it also
if (result.Success() == false)
App.PrintStatusMessage(result.stderr, MessageType.Error);
return result;
}
/// <summary>
/// Repo class function that runs a git command in the context of a repository.
/// NOTE: C# 4.0 is currently not supported on MSVC 2008
/// </summary>
public ExecResult Run(string args) { return Run(args, false); }
public ExecResult Run(string args, bool async)
{
ExecResult output = new ExecResult();
try
{
Directory.SetCurrentDirectory(Root);
// Set the HTTPS password
string password = Remotes.GetPassword("");
ClassUtils.AddEnvar("PASSWORD", password);
// The Windows limit to the command line argument length is about 8K
// We may hit that limit when doing operations on a large number of files.
//
// However, when sending a long list of files, git was hanging unless
// the total length was much less than that, so I set it to about 2000 chars
// which seemed to work fine.
if (args.Length < 2000)
return ClassGit.Run(args, async);
// Partition the args into "[command] -- [set of file chunks < 2000 chars]"
// Basically we have to rebuild the command into multiple instances with
// same command but with file lists not larger than about 2K
int i = args.IndexOf(" -- ") + 3;
string cmd = args.Substring(0, i + 1);
args = args.Substring(i); // We separate git command up to and until the list of files
App.PrintLogMessage("Processing large amount of files: please wait...", MessageType.General);
// Add files individually up to the length limit using the starting " file delimiter
string[] files = args.Split(new [] {" \""}, StringSplitOptions.RemoveEmptyEntries);
// Note: files in the list are now stripped from their initial " character!
i = 0;
do
{
StringBuilder batch = new StringBuilder(2100);
while (batch.Length < 2000 && i < files.Length)
batch.Append("\"" + files[i++] + " ");
output = ClassGit.Run(cmd + batch, async);
if (output.Success() == false)
break;
} while (i < files.Length);
}
catch (Exception ex)
{
App.PrintLogMessage(ex.Message, MessageType.Error);
}
return output;
}
}
}
