public static void BackupAssetsFolder(string backupLabel)
{
backupLabel = PathUtility.MakeSafeFilename(backupLabel, '_');
PathUtility.CreateDirectoryIfNeeded(Paths.backups);
var fileName = $"Assets_{backupLabel}.zip";
var addEntryIndex = 0;
var saveEntryIndex = 0;
using (var zip = new ZipFile())
{
zip.UseZip64WhenSaving = Zip64Option.AsNecessary;
zip.AddProgress += (sender, e) => { EditorUtility.DisplayProgressBar("Creating Backup...", e.CurrentEntry != null ? e.CurrentEntry.FileName : "...", (float)(addEntryIndex++) / e.EntriesTotal); };
zip.SaveProgress += (sender, e) => { EditorUtility.DisplayProgressBar("Creating Backup...", e.CurrentEntry != null ? e.CurrentEntry.FileName : "...", (float)(saveEntryIndex++) / e.EntriesTotal); };
zip.AddDirectory(Paths.assets);
var zipPath = Path.Combine(Paths.backups, fileName);
VersionControlUtility.Unlock(zipPath);
zip.Save(zipPath);
EditorUtility.ClearProgressBar();
}
}
public void GenerateProviderScripts()
{
if (Directory.Exists(LudiqCore.Paths.propertyProviders))
{
foreach (var file in Directory.GetFiles(LudiqCore.Paths.propertyProviders))
{
File.Delete(file);
}
}
if (Directory.Exists(LudiqCore.Paths.propertyProvidersEditor))
{
foreach (var file in Directory.GetFiles(LudiqCore.Paths.propertyProvidersEditor))
{
File.Delete(file);
}
}
PathUtility.CreateDirectoryIfNeeded(LudiqCore.Paths.propertyProviders);
PathUtility.CreateDirectoryIfNeeded(LudiqCore.Paths.propertyProvidersEditor);
foreach (var type in typeset.Where(SerializedPropertyUtility.HasCustomDrawer))
{
var directory = Codebase.IsEditorType(type) ? LudiqCore.Paths.propertyProvidersEditor : LudiqCore.Paths.propertyProviders;
var path = Path.Combine(directory, GetProviderScriptName(type) + ".cs");
VersionControlUtility.Unlock(path);
File.WriteAllText(path, GenerateProviderSource(type));
}
AssetDatabase.Refresh();
}
public static void DeleteStubScript()
{
if (File.Exists(aotStubsPath))
{
VersionControlUtility.Unlock(aotStubsPath);
File.Delete(aotStubsPath);
}
}
public static void DeleteLinker()
{
if (File.Exists(linkerPath))
{
VersionControlUtility.Unlock(linkerPath);
File.Delete(linkerPath);
}
}
public static void Run(IEnumerable <string> paths, IEnumerable <ScriptReferenceReplacement> replacements, Mode mode)
{
if (!canRun)
{
var message = "Cannot run missing script resolver with the current serialization mode.\nSet the project serialization mode to 'Force Text' and try again.";
if (mode == Mode.Dialog)
{
EditorUtility.DisplayDialog("Script Reference Resolver", message, "OK");
}
else if (mode == Mode.Console)
{
Debug.LogWarning(message);
}
return;
}
// Doing a naive approach here: replacing the exact string by regex instead of parsing the YAML,
// since Unity sometimes breaks YAML specifications. This is whitespace dependant, but it should work.
var newContents = new Dictionary <string, string[]>();
var _paths = paths.ToArray();
var pathIndex = 0;
foreach (var path in _paths)
{
if (newContents.ContainsKey(path))
{
// Duplicate path
continue;
}
var replaced = false;
var fileContents = new List <string>();
if (mode == Mode.Dialog)
{
ProgressUtility.DisplayProgressBar("Script Reference Resolver", $"Analyzing '{path}'...", pathIndex++ / (float)_paths.Length);
}
foreach (var line in File.ReadAllLines(path))
{
var newLine = line;
foreach (var replacement in replacements)
{
var previousReferenceRegex = new Regex($@"\{{fileID: {replacement.previousReference.fileID}, guid: {replacement.previousReference.guid}, type: 3\}}");
newLine = previousReferenceRegex.Replace(newLine, (match) =>
{
replaced = true;
return($@"{{fileID: {replacement.newReference.fileID}, guid: {replacement.newReference.guid}, type: 3}}");
});
}
fileContents.Add(newLine);
}
if (replaced)
{
newContents.Add(path, fileContents.ToArray());
}
}
pathIndex = 0;
if (newContents.Count > 0)
{
var pathMaxLength = 40;
var fileLimit = 15;
var fileList = newContents.Keys.Select(p => StringUtility.PathEllipsis(PathUtility.FromProject(p), pathMaxLength)).Take(fileLimit).ToLineSeparatedString();
if (newContents.Count > fileLimit)
{
fileList += "\n...";
}
var replace = true;
if (mode == Mode.Dialog)
{
var message = $"Missing script references have been found in {newContents.Count} file{(newContents.Count > 1 ? "s" : "")}: \n\n{fileList}\n\nProceed with replacement?";
replace = EditorUtility.DisplayDialog("Script Reference Resolver", message, "Replace References", "Cancel");
}
if (replace)
{
foreach (var newContent in newContents)
{
if (mode == Mode.Dialog)
{
ProgressUtility.DisplayProgressBar("Script Reference Resolver", $"Fixing '{newContent.Key}'...", pathIndex++ / (float)_paths.Length);
}
VersionControlUtility.Unlock(newContent.Key);
File.WriteAllLines(newContent.Key, newContent.Value);
}
if (mode == Mode.Dialog)
{
EditorUtility.DisplayDialog("Script Reference Resolver", "Script references have been successfully replaced.", "OK");
}
else if (mode == Mode.Console)
{
Debug.Log($"Missing script references have been replaced in {newContents.Count} file{(newContents.Count > 1 ? "s" : "")}: \n{fileList}\n");
}
AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
}
}
else
{
var message = "No missing script reference was found.";
if (mode == Mode.Dialog)
{
EditorUtility.DisplayDialog("Script Reference Resolver", message, "OK");
}
else if (mode == Mode.Console)
{
// Debug.Log(message);
}
}
if (mode == Mode.Dialog)
{
ProgressUtility.ClearProgressBar();
}
}
