public IEnumerator RepositoryHandlesLockedFileWhenWithIgnoreStatus()
{
File.AppendAllText(injectionHelper.GetInstance <GitInitializer>().GitIgnoreFilePath, "testFile.txt");
string lockedFilePathName = "testFile.txt";
string lockedFilePath = UniGitPathHelper.Combine(gitManager.GetCurrentRepoPath(), lockedFilePathName);
using (var lockFileStream = File.CreateText(lockedFilePath))
{
lockFileStream.WriteLine("This is a locked test file");
}
injectionHelper.Bind <GitProjectOverlay>().WithArguments(new InjectionArgument("cullNonAssetPaths", false));
var projectOverlays = injectionHelper.GetInstance <GitProjectOverlay>();
var prefs = injectionHelper.GetInstance <IGitPrefs>();
prefs.SetBool(GitProjectOverlay.ForceUpdateKey, true);
Assert.IsTrue(File.Exists(lockedFilePath));
GitCommands.Stage(gitManager.Repository, lockedFilePathName);
FileStream lockedFileStream = new FileStream(lockedFilePath, FileMode.Open, FileAccess.Read, FileShare.None);
try
{
gitManager.MarkDirty();
yield return(null);
Assert.AreEqual(FileStatus.Ignored, projectOverlays.StatusTree.GetStatus(lockedFilePathName).State);
}
finally
{
lockedFileStream.Dispose();
}
}
private void BuildChangeSections(Commit commit)
{
int lastIndexFileLine = 0;
Stream indexFileContent;
string indexFilePath = UniGitPathHelper.Combine(gitManager.GetCurrentRepoPath(), localPath);
if (File.Exists(indexFilePath))
{
indexFileContent = File.OpenRead(indexFilePath);
}
else
{
indexFileContent = new MemoryStream();
}
StreamReader indexFileReader = new StreamReader(indexFileContent);
var lines = GetLines(commit);
try
{
ProcessChanges(lines, indexFileReader, ref lastIndexFileLine);
}
catch (Exception e)
{
logger.Log(LogType.Error, "There was a problem while loading changes");
logger.LogException(e);
}
finally
{
indexFileContent.Dispose();
indexFileReader.Dispose();
}
}
internal static string GetFullPath(string fileName)
{
if (File.Exists(fileName))
{
return(Path.GetFullPath(fileName));
}
var variables = Environment.GetEnvironmentVariable("PATH", EnvironmentVariableTarget.Machine);
if (variables == null)
{
return(null);
}
var values = variables.Split(';');
foreach (var path in values)
{
var fullPath = UniGitPathHelper.Combine(path, fileName);
if (File.Exists(fullPath))
{
return(fullPath);
}
}
return(null);
}
public string GetCommitMessageFilePath(string subModule)
{
if (!string.IsNullOrEmpty(subModule))
{
return(UniGitPathHelper.Combine(paths.GitPath, "UniGit", "Settings", $"CommitMessage_{UniGitPathHelper.GetFriendlyNameFromPath(subModule)}.txt"));
}
return(UniGitPathHelper.Combine(paths.GitPath, "UniGit", "Settings", "CommitMessage.txt"));
}
public string GetCurrentDotGitFolder()
{
if (inSubModule)
{
return(dotGitDirCached);
}
return(UniGitPathHelper.Combine(paths.RepoPath, ".git"));
}
/// <summary>
/// If in sub module returns it's repo path
/// </summary>
/// <returns></returns>
public string GetCurrentRepoPath()
{
if (inSubModule)
{
return(UniGitPathHelper.Combine(paths.RepoPath, gitSettings.ActiveSubModule));
}
return(paths.RepoPath);
}
public void SwitchToSubModule(string path)
{
if (gitSettings.ActiveSubModule != path && Repository.IsValid(UniGitPathHelper.Combine(paths.RepoProjectRelativePath, path)))
{
gitSettings.ActiveSubModule = path;
gitSettings.MarkDirty();
MarkDirty(true);
}
}
public void SaveTracking()
{
using (StreamWriter file = File.CreateText(UniGitPathHelper.Combine(gitManager.GetCurrentRepoPath(), ".gitattributes")))
{
foreach (var info in trackedInfo)
{
file.WriteLine(info.ToString());
}
}
Update();
}
public string ToProjectPath(string localPath)
{
if (!string.IsNullOrEmpty(paths.RepoProjectRelativePath))
{
localPath = UniGitPathHelper.Combine(paths.RepoProjectRelativePath, localPath);
}
if (inSubModule)
{
return(UniGitPathHelper.Combine(gitSettings.ActiveSubModule, localPath));
}
return(localPath);
}
public bool Initialize()
{
string output = GitHelper.RunExeOutput(gitManager.GetCurrentRepoPath(), "git-lfs", "install", null);
if (!Directory.Exists(UniGitPathHelper.Combine(gitManager.GetCurrentDotGitFolder(), "lfs")))
{
logger.Log(LogType.Error, "Git-LFS install failed! (Try manually)");
logger.Log(LogType.Error, output);
return(false);
}
EditorUtility.DisplayDialog("Git LFS Initialized", output, "Ok");
UpdateInitilized();
return(true);
}
public void Update()
{
RegisterFilter();
if (File.Exists(UniGitPathHelper.Combine(gitManager.GetCurrentRepoPath(), ".gitattributes")))
{
using (TextReader file = File.OpenText(UniGitPathHelper.Combine(gitManager.GetCurrentRepoPath(), ".gitattributes")))
{
trackedInfo = file.ReadToEnd().Split(UniGitPathHelper.NewLineChar).Select(GitLfsTrackedInfo.Parse).Where(l => l != null).ToArray();
}
}
UpdateInitilized();
}
public bool IsDirectory(string localPath)
{
string projectPath = ToProjectPath(localPath);
if (IsSubModule(ToProjectPath(localPath)))
{
return(false);
}
if (Path.IsPathRooted(projectPath))
{
return(Directory.Exists(UniGitPathHelper.Combine(paths.RepoPath, projectPath)));
}
return(Directory.Exists(projectPath));
}
private void LoadFileLines()
{
var asset = AssetDatabase.LoadAssetAtPath <MonoScript>(manager.ToProjectPath(blameLocalPath));
if (asset != null)
{
lines = asset.text.Split(new[] { UniGitPathHelper.NewLineChar }, StringSplitOptions.None);
}
else
{
lines = File.ReadAllLines(UniGitPathHelper.Combine(manager.GetCurrentRepoPath(), blameLocalPath));
}
commitLog = manager.Repository.Commits.QueryBy(blameLocalPath).Where(e => blameHunk.Any(h => h.FinalCommit.Sha == e.Commit.Sha)).ToArray();
}
public void SetRepoPath(string repoPath)
{
this.RepoPath = repoPath;
if (!UniGitPathHelper.PathsEqual(repoPath, ProjectPath))
{
RepoProjectRelativePath = UniGitPathHelper.SubtractDirectory(repoPath, ProjectPath);
}
SettingsFolderPath = UniGitPathHelper.Combine(repoPath, ".git", "UniGit");
SettingsFilePath = UniGitPathHelper.Combine(SettingsFolderPath, "Settings.json");
LogsFolderPath = SettingsFolderPath;
LogsFilePath = UniGitPathHelper.Combine(LogsFolderPath, "log.txt");
CredentialsFilePath = UniGitPathHelper.Combine(SettingsFolderPath, "Credentials.json");
GitPath = UniGitPathHelper.Combine(RepoPath, ".git");
}
private Repository CreateRepository(string activeModule)
{
var mainRepository = new Repository(paths.RepoPath);
if (!string.IsNullOrEmpty(activeModule))
{
var subModule = mainRepository.Submodules[activeModule];
if (subModule != null && Repository.IsValid(UniGitPathHelper.Combine(paths.RepoProjectRelativePath, subModule.Path)))
{
var subModuleRepo = new Repository(UniGitPathHelper.Combine(paths.RepoProjectRelativePath, subModule.Path));
mainRepository.Dispose();
inSubModule = true;
dotGitDirCached = subModuleRepo.Info.Path;
return(subModuleRepo);
}
}
inSubModule = false;
dotGitDirCached = mainRepository.Info.Path;
return(mainRepository);
}
internal void Build(IEnumerable <GitStatusEntry> status, IEnumerable <GitStatusSubModuleEntry> subModules)
{
foreach (var entry in status)
{
currentProjectPath = gitManager.ToProjectPath(entry.LocalPath);
currentPathArray = currentProjectPath.Split('\\');
currentStatus = !gitSettings.ShowEmptyFolders && gitManager.IsEmptyFolderMeta(currentProjectPath) ? FileStatus.Ignored : entry.Status;
if (cullNonAssetPaths && !UniGitPathHelper.IsPathInAssetFolder(currentProjectPath) && !UniGitPathHelper.IsPathInPackagesFolder(currentProjectPath))
{
continue;
}
AddRecursive(0, entries);
}
foreach (var module in subModules)
{
currentPathArray = UniGitPathHelper.Combine(paths.RepoProjectRelativePath, module.Path).Split('\\');
currentSubModuleStatus = module.Status;
AddSubModuleRecursive(0, entries);
}
}
public int Compare(StatusListEntry x, StatusListEntry y)
{
int stateCompare = window.IsGrouping() ? GetPriority(x.State).CompareTo(GetPriority(y.State)) : 0;
if (stateCompare == 0)
{
var settings = window.GitDiffSettings;
if (settings.sortDir == GitDiffWindow.SortDir.Descending)
{
var oldLeft = x;
x = y;
y = oldLeft;
}
if (settings.unstagedChangesPriority)
{
bool canStageX = GitManager.CanStage(x.State);
bool canUnstageX = GitManager.CanUnstage(x.State);
bool canStageY = GitManager.CanStage(y.State);
bool canUnstageY = GitManager.CanUnstage(y.State);
//prioritize upsaged changes that are pending
if ((canStageX && canUnstageX) && !(canStageY && canUnstageY))
{
return(-1);
}
if (!(canStageX && canUnstageX) && (canStageY && canUnstageY))
{
return(1);
}
}
switch (settings.sortType)
{
case GitDiffWindow.SortType.Name:
stateCompare = string.Compare(x.Name, y.Name, StringComparison.InvariantCultureIgnoreCase);
break;
case GitDiffWindow.SortType.Path:
stateCompare = string.Compare(x.LocalPath, y.LocalPath, StringComparison.InvariantCultureIgnoreCase);
break;
case GitDiffWindow.SortType.ModificationDate:
//todo cache modification dates
DateTime modifedTimeLeft = GetClosest(gitManager.GetPathWithMeta(x.LocalPath).Select(p => File.GetLastWriteTime(UniGitPathHelper.Combine(gitManager.GetCurrentRepoPath(), p))));
DateTime modifedRightTime = GetClosest(gitManager.GetPathWithMeta(x.LocalPath).Select(p => File.GetLastWriteTime(UniGitPathHelper.Combine(gitManager.GetCurrentRepoPath(), p))));
stateCompare = DateTime.Compare(modifedRightTime, modifedTimeLeft);
break;
case GitDiffWindow.SortType.CreationDate:
//todo cache creation dates
DateTime createdTimeLeft = GetClosest(gitManager.GetPathWithMeta(x.LocalPath).Select(p => File.GetCreationTime(UniGitPathHelper.Combine(gitManager.GetCurrentRepoPath(), p))));
DateTime createdRightTime = GetClosest(gitManager.GetPathWithMeta(y.LocalPath).Select(p => File.GetCreationTime(UniGitPathHelper.Combine(gitManager.GetCurrentRepoPath(), p))));
stateCompare = DateTime.Compare(createdRightTime, createdTimeLeft);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
if (stateCompare == 0)
{
stateCompare = String.Compare(x.LocalPath, y.LocalPath, StringComparison.Ordinal);
}
return(stateCompare);
}
static UniGitLoader()
{
HandlePaths();
GitProfilerProxy.BeginSample("UniGit Initialization");
try
{
GitWindows.OnWindowAddedEvent += OnWindowAdded;
EditorApplication.update += OnEditorUpdate;
injectionHelper = new InjectionHelper();
GitWindows.Init();
uniGitData = CreateUniGitData(); //data must be created manually to not call unity methods from constructors
string projectPath = UniGitPathHelper.FixUnityPath(
Application.dataPath.Replace(UniGitPathHelper.UnityDeirectorySeparatorChar + "Assets", ""));
string repoPath = projectPath;
if (EditorPrefs.HasKey(RepoPathKey))
{
repoPath = UniGitPathHelper.FixUnityPath(UniGitPathHelper.Combine(repoPath, EditorPrefs.GetString(RepoPathKey)));
}
injectionHelper.Bind <UniGitPaths>().FromInstance(new UniGitPaths(repoPath, projectPath));
injectionHelper.Bind <GitInitializer>().NonLazy();
injectionHelper.Bind <UniGitData>().FromMethod(c => uniGitData); //must have a getter so that it can be injected
injectionHelper.Bind <GitCallbacks>().FromMethod(GetGitCallbacks);
injectionHelper.Bind <IGitPrefs>().To <UnityEditorGitPrefs>();
injectionHelper.Bind <GitManager>().NonLazy();
injectionHelper.Bind <GitSettingsJson>();
injectionHelper.Bind <GitSettingsManager>();
injectionHelper.Bind <GitAsyncManager>();
injectionHelper.Bind <GitFileWatcher>().NonLazy();
injectionHelper.Bind <GitReflectionHelper>();
injectionHelper.Bind <IGitResourceManager>().To <GitResourceManager>();
injectionHelper.Bind <GitOverlay>();
injectionHelper.Bind <GitAutoFetcher>().NonLazy();
injectionHelper.Bind <GitLog>();
injectionHelper.Bind <ILogger>().FromMethod(c => new Logger(c.injectionHelper.GetInstance <GitLog>()));
injectionHelper.Bind <GitAnimation>();
injectionHelper.Bind <ICredentialsAdapter>().To <WincredCredentialsAdapter>();
injectionHelper.Bind <GitCredentialsManager>().NonLazy();
injectionHelper.Bind <IExternalAdapter>().To <GitExtensionsAdapter>();
injectionHelper.Bind <IExternalAdapter>().To <TortoiseGitAdapter>();
injectionHelper.Bind <GitExternalManager>();
injectionHelper.Bind <GitLfsManager>().NonLazy(); //must be non lazy as it add itself as a filter
injectionHelper.Bind <GitPushHookBase>().To <GitLfsPrePushHook>();
injectionHelper.Bind <GitHookManager>().NonLazy();
injectionHelper.Bind <GitLfsHelper>();
injectionHelper.Bind <FileLinesReader>();
injectionHelper.Bind <GitProjectOverlay>().NonLazy();
injectionHelper.Bind <GitConflictsHandler>();
//diff window
injectionHelper.Bind <GitDiffWindowToolbarRenderer>().AsTransient();
injectionHelper.Bind <GitDiffElementContextFactory>().AsTransient();
injectionHelper.Bind <GitDiffWindowCommitRenderer>().AsTransient();
injectionHelper.Bind <GitDiffWindowDiffElementRenderer>().AsTransient();
Rebuild(injectionHelper);
}
finally
{
GitProfilerProxy.EndSample();
}
}
public bool CheckInitialized()
{
return(Directory.Exists(UniGitPathHelper.Combine(gitManager.GetCurrentDotGitFolder(), "lfs")) && File.Exists(UniGitPathHelper.Combine(gitManager.GetCurrentDotGitFolder(), "hooks", "pre-push")));
}
private static void HandlePaths()
{
AddPath(UniGitPathHelper.Combine(Environment.CurrentDirectory, "Assets", "Plugins", "LibGit2"));
AddPath(UniGitPathHelper.Combine(Environment.CurrentDirectory, "Assets", "Plugins", "LibGit2", "x86"));
AddPath(UniGitPathHelper.Combine(Environment.CurrentDirectory, "Assets", "Plugins", "LibGit2", "x86_64"));
}
private void OpenGitIgnore()
{
Application.OpenURL(UniGitPathHelper.Combine(gitManager.GetCurrentRepoPath(), ".gitignore"));
}
