Add the possibility to bind multiple interfaces in one call

Add the auto execute process to fill up the version service data based on the git information

Author: CoderGamester

Editor.meta

@@ -0,0 +1,88 @@
+using System;
+using System.Diagnostics;
+
+namespace GameLovers.Services.Editor
+{
+	/// <summary>
+	/// Run git commands processes that would otherwise be used in the terminal.
+	/// </summary>
+	/// <author>
+	/// https://blog.somewhatabstract.com/2015/06/22/getting-information-about-your-git-repository-with-c/
+	/// </author>
+	public class GitEditorProcess : IDisposable
+	{
+		private const string DefaultPathToGitBinary = "git";
+
+		private readonly Process Process;
+
+		/// <summary>
+		/// <inheritdoc cref="Process.ExitCode"/>
+		/// </summary>
+		public int ExitCode => Process.ExitCode;
+
+		public GitEditorProcess(string workingDir, string pathToGitBinary = DefaultPathToGitBinary)
+		{
+			var startInfo = new ProcessStartInfo
+			{
+				UseShellExecute = false,
+				RedirectStandardOutput = true,
+				FileName = pathToGitBinary,
+				CreateNoWindow = true,
+				WorkingDirectory = workingDir
+			};
+
+			Process = new Process { StartInfo = startInfo };
+		}
+
+		/// <summary>
+		/// Is this unity project a git repo?
+		/// </summary>
+		public bool IsValidRepo()
+		{
+			return ExecuteCommand("rev-parse --is-inside-work-tree") == "true";
+		}
+
+		/// <summary>
+		/// Get the git branch name of the unity project.
+		/// </summary>
+		public string GetBranch()
+		{
+			return ExecuteCommand("rev-parse --abbrev-ref HEAD");
+		}
+
+		/// <summary>
+		/// Get the git commit hash of the unity project.
+		/// </summary>
+		public string GetCommitHash()
+		{
+			return ExecuteCommand($"rev-parse HEAD");
+		}
+
+		/// <summary>
+		/// Get the diff of the working directory in its current state from the state it was at at
+		/// a given commit.
+		/// </summary>
+		public string GetDiffFromCommit(string commitHash)
+		{
+			return ExecuteCommand($"diff --word-diff=porcelain {commitHash} -- {Process.StartInfo.WorkingDirectory}");
+		}
+
+		/// <inheritdoc/>
+		public void Dispose()
+		{
+			Process?.Dispose();
+		}
+		
+		/// <summary>
+		/// Execute a command eg. "status --verbose"
+		/// </summary>
+		private string ExecuteCommand(string args)
+		{
+			Process.StartInfo.Arguments = args;
+			Process.Start();
+			var output = Process.StandardOutput.ReadToEnd().Trim();
+			Process.WaitForExit();
+			return output;
+		}
+	}
+}

Editor/GitEditorProcess.cs

@@ -0,0 +1,141 @@
+using System;
+using System.IO;
+using UnityEditor;
+using UnityEngine;
+
+namespace GameLovers.Services.Editor
+{
+	/// <summary>
+	/// Set the internal version in any VersionService instances in the project before building
+	/// and whenever the project loads.
+	/// </summary>
+	public static class VersionEditorUtils
+	{
+		private const int ShortenedCommitLength = 8;
+
+		/// <summary>
+		/// Set the internal version before building the app.
+		/// </summary>
+		public static void SetAndSaveInternalVersion(bool isStoreBuild)
+		{
+			var newVersionData = GenerateInternalVersionSuffix(isStoreBuild);
+			var newVersionDataSerialized = JsonUtility.ToJson(newVersionData);
+			var oldVersionDataSerialized = LoadVersionDataSerializedSync();
+			if (newVersionDataSerialized.Equals(oldVersionDataSerialized, StringComparison.Ordinal))
+			{
+				return;
+			}
+
+			Debug.Log($"Saving new version data: {newVersionDataSerialized}");
+			SaveVersionData(newVersionDataSerialized);
+		}
+
+		/// <summary>
+		/// Loads the game version saved in disk into string format
+		/// </summary>
+		public static string LoadVersionDataSerializedSync()
+		{
+			var textAsset = Resources.Load<TextAsset>(VersionServices.VersionDataFilename);
+			if (!textAsset)
+			{
+				Debug.LogError("Could not load internal version from Resources.");
+				return string.Empty;
+			}
+
+			var serialized = textAsset.text;
+			Resources.UnloadAsset(textAsset);
+			return serialized;
+		}
+
+		/// <summary>
+		/// Set the internal version for when the app plays in editor.
+		/// </summary>
+		[InitializeOnLoadMethod]
+		private static void OnEditorLoad()
+		{
+			SetAndSaveInternalVersion(false);
+		}
+
+		private static VersionServices.VersionData GenerateInternalVersionSuffix(bool isStoreBuild)
+		{
+			var data = new VersionServices.VersionData();
+
+			using (var repo = new GitEditorProcess(Application.dataPath))
+			{
+				try
+				{
+					if (!repo.IsValidRepo())
+					{
+						Debug.LogWarning("Project is not a git repo. Internal version not set.");
+					}
+					else
+					{
+						var branch = repo.GetBranch();
+						if (string.IsNullOrEmpty(branch))
+						{
+							Debug.LogWarning("Could not get git branch for internal version");
+						}
+						else
+						{
+							data.BranchName = branch;
+						}
+
+						var commitHash = repo.GetCommitHash();
+						if (string.IsNullOrEmpty(commitHash))
+						{
+							Debug.LogWarning("Could not get git commit for internal version");
+						}
+						else
+						{
+							data.Commit = commitHash.Substring(0, ShortenedCommitLength);
+						}
+					}
+				}
+				catch (Exception e)
+				{
+					Debug.LogException(e);
+					Debug.LogWarning("Could not execute git commands. Internal version not set.");
+				}
+			}
+
+			data.BuildNumber = PlayerSettings.iOS.buildNumber;
+			data.BuildType = isStoreBuild ? "prod" : "dev";
+
+			return data;
+		}
+
+		/// <summary>
+		/// Set the internal version of this application and save it in resources. This should be
+		/// called at edit/build time.
+		/// </summary>
+		private static void SaveVersionData(string serializedData)
+		{
+			const string assets = "Assets";
+			const string resources = "Build/Resources";
+
+			var absDirPath = Path.Combine(Application.dataPath, resources);
+			if (!Directory.Exists(absDirPath))
+			{
+				Directory.CreateDirectory(absDirPath);
+			}
+
+			// delete old file with incorrect extension
+			const string assetExtension = ".asset";
+			var absFilePath = Path.Combine(absDirPath, VersionServices.VersionDataFilename);
+			if (File.Exists(Path.ChangeExtension(absFilePath, assetExtension)))
+			{
+				AssetDatabase.DeleteAsset(
+					Path.Combine(assets, resources,
+						Path.ChangeExtension(VersionServices.VersionDataFilename, assetExtension)));
+			}
+
+			// create new text file
+			const string textExtension = ".txt";
+			File.WriteAllText(Path.ChangeExtension(absFilePath, textExtension), serializedData);
+
+			AssetDatabase.ImportAsset(
+				Path.Combine(assets, resources,
+					Path.ChangeExtension(VersionServices.VersionDataFilename, textExtension)));
+		}
+	}
+}