private static void SaveCommitMessageToFile(GitInitializer initializer, GitSettingsJson gitSettings, string message)
{
try
{
string settingsFolder = initializer.GitSettingsFolderPath;
if (!Directory.Exists(settingsFolder))
{
Directory.CreateDirectory(settingsFolder);
}
var commitMessageFilePath = initializer.GetCommitMessageFilePath(gitSettings.ActiveSubModule);
var commitMessageFileDirectory = Path.GetDirectoryName(commitMessageFilePath);
if (!Directory.Exists(commitMessageFileDirectory))
{
Directory.CreateDirectory(commitMessageFileDirectory);
}
File.WriteAllText(commitMessageFileDirectory, message);
}
catch (UnauthorizedAccessException e)
{
Debug.LogWarning("Commit message file is forced to read only.");
}
catch (Exception e)
{
#if UNITY_EDITOR
Debug.LogError("Could not save commit message to file. Saving to Prefs");
Debug.LogException(e);
#endif
}
}
public GitDiffWindowCommitRenderer(GitSettingsJson gitSettings, GitManager gitManager, GitOverlay gitOverlay, GitInitializer initializer)
{
this.gitSettings = gitSettings;
this.gitManager = gitManager;
this.gitOverlay = gitOverlay;
this.initializer = initializer;
}
private void Construct(GitManager gitManager,
GitReflectionHelper reflectionHelper,
UniGitData data,
ILogger logger,
GitSettingsJson gitSettings,
GitCallbacks gitCallbacks,
GitInitializer initializer,
GitSettingsManager settingsManager,
UniGitPaths paths,
IGitResourceManager resourceManager)
{
this.resourceManager = resourceManager;
this.paths = paths;
this.settingsManager = settingsManager;
this.logger = logger;
this.gitSettings = gitSettings;
this.initializer = initializer;
if (gitManager == null)
{
logger.Log(LogType.Error, "Git manager cannot be null.");
return;
}
if (this.gitCallbacks != null)
{
Unsubscribe(this.gitCallbacks);
}
this.data = data;
this.gitManager = gitManager;
this.gitManager.AddWatcher(this);
this.reflectionHelper = reflectionHelper;
Subscribe(gitCallbacks);
}
public GitLfsManager(GitManager gitManager, GitCallbacks gitCallbacks, ILogger logger, GitSettingsJson gitSettings)
{
this.gitManager = gitManager;
this.gitCallbacks = gitCallbacks;
this.logger = logger;
this.gitSettings = gitSettings;
gitCallbacks.UpdateRepository += OnUpdateRepository;
gitManager.AddSettingsAffector(this);
try
{
version = GitHelper.RunExeOutput(gitManager.GetCurrentRepoPath(), "git-lfs", "version", null);
isInstalled = true;
}
catch (Exception)
{
isInstalled = false;
return;
}
UpdateInitilized();
if (Initilized)
{
RegisterFilter();
Update();
}
}
public GitExternalManager(ICollection <IExternalAdapter> adapters, ILogger logger, GitSettingsJson gitSettings)
{
this.adapters = adapters.OrderBy(GetAdapterPriority).ToArray();
adapterNames = adapters.Select(a => new GUIContent(GetAdapterName(a))).ToArray();
this.logger = logger;
this.gitSettings = gitSettings;
}
private static void Rebuild(InjectionHelper injectionHelper)
{
GitCallbacks = injectionHelper.GetInstance <GitCallbacks>();
var settingsManager = injectionHelper.GetInstance <GitSettingsManager>();
settingsManager.LoadGitSettings();
//delayed called must be used for serialized properties to be loaded
EditorApplication.delayCall += () =>
{
settingsManager.LoadOldSettingsFile();
};
GitManager = injectionHelper.GetInstance <GitManager>();
injectionHelper.GetInstance <GitReflectionHelper>();
GitSettings = injectionHelper.GetInstance <GitSettingsJson>();
GitCallbacks.OnLogEntry += OnLogEntry;
GitCallbacks.OnBeforeAssemblyReload += OnBeforeAssemblyReload;
injectionHelper.CreateNonLazy();
injectionHelper.InjectStatic(typeof(GitProjectContextMenus));
injectionHelper.InjectStatic(typeof(GitUnityMenu));
}
public StatusTreeClass(GitSettingsJson gitSettings, GitManager gitManager, bool cullNonAssetPaths, UniGitPaths paths)
{
this.paths = paths;
this.gitManager = gitManager;
this.cullNonAssetPaths = cullNonAssetPaths;
this.gitSettings = gitSettings;
}
private static void LoadGitSettings()
{
string settingsFilePath = SettingsFilePath;
GitSettingsJson settingsJson = null;
if (File.Exists(settingsFilePath))
{
try
{
settingsJson = JsonUtility.FromJson <GitSettingsJson>(File.ReadAllText(settingsFilePath));
}
catch (Exception e)
{
Debug.LogError("Could not deserialize git settings. Creating new settings.");
Debug.LogException(e);
}
}
if (settingsJson == null)
{
settingsJson = new GitSettingsJson();
var oldSettingsFile = EditorGUIUtility.Load("UniGit/Git-Settings.asset") as GitSettings;
if (oldSettingsFile != null)
{
//must be delayed call for unity to deserialize settings file properly
EditorApplication.delayCall += LoadOldSettingsFile;
}
else
{
SaveSettingsToFile(settingsJson);
}
}
gitSettings = settingsJson;
}
public GitSettingsManager(GitSettingsJson settings, string settingsPath, GitCallbacks gitCallbacks)
{
this.settings = settings;
this.settingsPath = settingsPath;
this.gitCallbacks = gitCallbacks;
gitCallbacks.EditorUpdate += OnEditorUpdate;
}
public GitSettingsManager(UniGitPaths paths, GitSettingsJson settings, GitCallbacks gitCallbacks, ILogger logger, GitInitializer initializer)
{
this.paths = paths;
this.settings = settings;
this.gitCallbacks = gitCallbacks;
this.logger = logger;
this.initializer = initializer;
gitCallbacks.EditorUpdate += OnEditorUpdate;
}
public GitManager(string repoPath, GitCallbacks callbacks, GitSettingsJson settings, IGitPrefs prefs, GitAsyncManager asyncManager)
{
this.repoPath = repoPath;
this.callbacks = callbacks;
this.prefs = prefs;
this.asyncManager = asyncManager;
gitSettings = settings;
gitPath = UniGitPath.Combine(repoPath, ".git");
Initialize();
}
public GitDiffWindowToolbarRenderer(GitManager gitManager, GitDiffElementContextFactory contextFactory,
UniGitData data, InjectionHelper injectionHelper, GitSettingsJson gitSettings, GitOverlay gitOverlay, IGitPrefs prefs)
{
this.gitManager = gitManager;
this.contextFactory = contextFactory;
this.data = data;
this.injectionHelper = injectionHelper;
this.gitSettings = gitSettings;
this.gitOverlay = gitOverlay;
this.prefs = prefs;
searchField = new SearchField();
}
public GitCredentialsManager(GitManager gitManager, GitSettingsJson gitSettings, List <ICredentialsAdapter> adapters, GitCallbacks gitCallbacks)
{
this.gitSettings = gitSettings;
this.gitManager = gitManager;
this.adapters = adapters.ToArray();
this.gitCallbacks = gitCallbacks;
adapterNames = adapters.Select(a => new GUIContent(GetAdapterName(a))).ToArray();
adapterIds = adapters.Select(GetAdapterId).ToArray();
gitCallbacks.EditorUpdate += EditorUpdate;
LoadGitCredentials();
}
public GitLog(UniGitPaths paths, UniGitData data, GitSettingsJson gitSettings, GitCallbacks gitCallbacks)
{
this.paths = paths;
this.data = data;
this.gitSettings = gitSettings;
this.gitCallbacks = gitCallbacks;
logTypeRegex = new Regex(@"\[.*?\]", RegexOptions.Compiled);
lineAndNumberRegex = new Regex(@"\(at((.*?):(.*?))\)", RegexOptions.Compiled);
if (data.LogInitialized)
{
data.LogInitialized = true;
data.LogEntries.Clear();
LoadLines();
}
}
public GitAutoFetcher(GitManager gitManager,
GitCredentialsManager credentialsManager,
GitCallbacks gitCallbacks,
GitSettingsJson gitSettings,
ILogger logger,
GitInitializer initializer)
{
this.gitManager = gitManager;
this.credentialsManager = credentialsManager;
this.gitCallbacks = gitCallbacks;
this.logger = logger;
this.gitSettings = gitSettings;
this.initializer = initializer;
gitCallbacks.EditorUpdate += OnEditorUpdate;
needsFetch = !EditorApplication.isPlayingOrWillChangePlaymode && !EditorApplication.isCompiling && !EditorApplication.isUpdating;
}
private static void SaveSettingsToFile(GitSettingsJson settings)
{
ValidateSettingsPath();
string settingsFilePath = SettingsFilePath;
try
{
string json = JsonUtility.ToJson(settings);
File.WriteAllText(settingsFilePath, json);
}
catch (Exception e)
{
Debug.LogError("Could not serialize GitSettingsJson to json file at: " + settingsFilePath);
Debug.LogException(e);
}
}
public GitProjectOverlay(GitManager gitManager, GitCallbacks gitCallbacks, GitSettingsJson gitSettings, GitAsyncManager asyncManager)
{
if (iconStyle == null)
{
iconStyle = new GUIStyle
{
imagePosition = ImagePosition.ImageOnly,
alignment = TextAnchor.LowerLeft,
padding = new RectOffset(2, 2, 2, 2)
};
}
this.gitManager = gitManager;
this.gitSettings = gitSettings;
this.asyncManager = asyncManager;
this.gitCallbacks = gitCallbacks;
gitCallbacks.ProjectWindowItemOnGUI += CustomIcons;
gitCallbacks.UpdateRepository += OnUpdateRepository;
}
private void Construct(GitManager gitManager,
GitCredentialsManager credentialsManager,
GitExternalManager externalManager,
ILogger logger,
GitSettingsJson gitSettings,
GitInitializer initializer)
{
this.logger = logger;
this.gitManager = gitManager;
this.credentialsManager = credentialsManager;
this.externalManager = externalManager;
this.gitSettings = gitSettings;
this.initializer = initializer;
remotes = gitManager.Repository.Network != null && gitManager.Repository.Network.Remotes != null?gitManager.Repository.Network.Remotes.ToArray() : new Remote[0];
remoteNames = remotes.Select(r => new GUIContent(r.Name)).ToArray();
branchNames = gitManager.Repository.Branches.Select(b => b.CanonicalName).ToArray();
branchFriendlyNames = gitManager.Repository.Branches.Select(b => b.FriendlyName).ToArray();
}
public GitManager(
GitCallbacks callbacks,
GitSettingsJson settings,
IGitPrefs prefs,
GitAsyncManager asyncManager,
UniGitData gitData,
ILogger logger,
GitInitializer initializer,
UniGitPaths paths)
{
this.paths = paths;
this.gitData = gitData;
this.callbacks = callbacks;
this.prefs = prefs;
this.asyncManager = asyncManager;
this.logger = logger;
this.initializer = initializer;
gitSettings = settings;
Initialize();
}
public GitFileWatcher(GitManager gitManager,
GitCallbacks gitCallbacks,
GitSettingsJson gitSettings,
UniGitPaths paths,
[UniGitInjectOptional] bool trackAssetsPath)
{
this.paths = paths;
this.gitManager = gitManager;
this.gitSettings = gitSettings;
this.gitCallbacks = gitCallbacks;
fileWatchers = new List <FileSystemWatcher>();
string regexPattern = @".*.git$";
if (!trackAssetsPath)
{
regexPattern += "|.*Assets$";
}
ignoreFoldersRegex = new Regex(regexPattern);
gitCallbacks.OnSettingsChange += OnSettingsChange;
gitCallbacks.OnRepositoryLoad += OnRepositoryLoad;
}
public GitProjectOverlay(GitManager gitManager,
GitCallbacks gitCallbacks,
GitSettingsJson gitSettings,
GitAsyncManager asyncManager,
GitReflectionHelper reflectionHelper,
GitOverlay gitOverlay,
IGitPrefs prefs,
UniGitData data,
ILogger logger,
InjectionHelper injectionHelper,
[UniGitInjectOptional] bool cullNonAssetPaths = true)
{
if (iconStyle == null)
{
iconStyle = new GUIStyle
{
imagePosition = ImagePosition.ImageOnly,
alignment = TextAnchor.LowerLeft,
padding = new RectOffset(2, 2, 2, 2)
};
lineStyle = new GUIStyle(EditorGUIUtility.GetBuiltinSkin(EditorSkin.Inspector).FindStyle("IN Title"))
{
padding = new RectOffset(),
margin = new RectOffset(),
contentOffset = Vector2.zero,
fixedHeight = 0,
fixedWidth = 0,
border = { left = 0, right = 0 }
};
}
this.logger = logger;
this.data = data;
this.gitManager = gitManager;
this.gitSettings = gitSettings;
this.asyncManager = asyncManager;
this.gitCallbacks = gitCallbacks;
this.reflectionHelper = reflectionHelper;
this.gitOverlay = gitOverlay;
this.prefs = prefs;
this.cullNonAssetPaths = cullNonAssetPaths;
this.injectionHelper = injectionHelper;
gitManager.AddWatcher(this);
gitCallbacks.EditorUpdate += OnEditorUpdate;
gitCallbacks.ProjectWindowItemOnGUI += CustomIcons;
gitCallbacks.UpdateRepository += OnUpdateRepository;
//project browsers only get created before delay call but not before constructor
gitCallbacks.DelayCall += () =>
{
projectWindows = new List <EditorWindow>(Resources.FindObjectsOfTypeAll(reflectionHelper.ProjectWindowType).Cast <EditorWindow>());
};
//shortcut to getting instance id without loading asset
var method = typeof(AssetDatabase).GetMethod("GetMainAssetOrInProgressProxyInstanceID", BindingFlags.NonPublic | BindingFlags.Static);
if (method != null)
{
GetMainAssetOrInProgressProxyInstanceID = (Func <string, int>)Delegate.CreateDelegate(typeof(Func <string, int>), method);
}
}
public StatusTreeClass(GitSettingsJson gitSettings)
{
this.gitSettings = gitSettings;
}
public StatusTreeClass(GitSettingsJson gitSettings, IEnumerable <GitStatusEntry> status) : this(gitSettings)
{
Build(status);
}
internal static void SetCommitMessage(GitInitializer initializer, GitManager gitManager, GitSettingsJson gitSettings, string commitMessage)
{
if (gitSettings.ReadFromFile)
{
SaveCommitMessageToFile(initializer, gitSettings, commitMessage);
}
gitManager.Prefs.SetString(CommitMessageKey, commitMessage);
}
private void Construct(GitSettingsJson settings)
{
this.settings = settings;
Refresh();
}
