Asset.File.cs

// Copyright (C) 2021-2024 Steffen Itterheim
// Refer to included LICENSE file for terms and conditions.
 
using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Text;
using UnityEditor;
using Object = UnityEngine.Object;
 
namespace CodeSmileEditor
{
    // This file contains asset 'file operations' related method groups, in that order:
    // Create
    // Save
    // Import
    // Load
    // Find
    // Copy
    // Move
    // Rename
    // Open
    // Delete
    // Trash
 
    public sealed partial class Asset
    {
        public static class File
        {
            private static List<String> s_PathsNotDeleted = new();
 
            [ExcludeFromCodeCoverage] // trivial
            public static IList<String> PathsNotDeleted => s_PathsNotDeleted;
 
            public static void BatchEditing([NotNull] Action massAssetFileEditAction)
            {
                try
                {
                    StartAssetEditing();
 
                    massAssetFileEditAction?.Invoke();
                }
                finally
                {
                    StopAssetEditing();
                }
            }
 
            public static Object Create([NotNull] Byte[] contents, [NotNull] Path path) => CreateInternal(contents, path);
 
            public static Object CreateAsNew([NotNull] Byte[] contents, [NotNull] Path path) => CreateInternal(contents, path.UniqueFilePath);
 
            public static Object Create([NotNull] String contents, [NotNull] Path path) => CreateInternal(contents, path);
 
            public static Object CreateAsNew([NotNull] String contents, [NotNull] Path path) => CreateInternal(contents, path.UniqueFilePath);
 
            public static Object Create([NotNull] Object instance, [NotNull] Path path) => CreateInternal(instance, path);
 
            public static Object CreateAsNew([NotNull] Object instance, [NotNull] Path path) => CreateInternal(instance, path.UniqueFilePath);
 
            public static T CreateOrLoad<T>([NotNull] Path path, [NotNull] Func<T> getInstance) where T : Object =>
                LoadOrCreate(path, getInstance);
 
            public static void Save([NotNull] Object asset) => SaveInternal(asset);
 
            public static void ForceSave([NotNull] Object asset) => SaveInternal(asset, true);
 
            public static void Save(GUID guid)
            {
                ThrowIf.NotAnAssetGuid(guid);
 
                AssetDatabase.SaveAssetIfDirty(guid);
            }
 
            public static void Import([NotNull] Path path, ImportAssetOptions options = ImportAssetOptions.Default)
            {
                ThrowIf.ArgumentIsNull(path, nameof(path));
                ThrowIf.DoesNotExistInFileSystem(path);
 
                AssetDatabase.ImportAsset(path, options);
            }
 
            public static T ImportAndLoad<T>([NotNull] Path path,
                ImportAssetOptions options = ImportAssetOptions.Default)
                where T : Object => Load<T>(path);
 
            public static void
                Import([NotNull] IEnumerable<Path> paths, ImportAssetOptions options = ImportAssetOptions.Default) =>
                Import(Path.ToStrings(paths.ToArray()), options);
 
            public static void
                Import([NotNull] IEnumerable<string> paths, ImportAssetOptions options = ImportAssetOptions.Default) => BatchEditing(
                () =>
                {
                    foreach (var path in paths)
                        AssetDatabase.ImportAsset(path, options);
                });
 
            public static T Load<T>([NotNull] Path path) where T : Object
            {
                ThrowIf.ArgumentIsNull(path, nameof(path));
 
                ImportIfNotImported(path);
                return AssetDatabase.LoadAssetAtPath<T>(path);
            }
 
            public static T LoadOrCreate<T>([NotNull] Path path, [NotNull] Func<T> getInstance) where T : Object
            {
                if (path.ExistsInFileSystem == false)
                    return Create(getInstance.Invoke(), path) as T;
 
                return ImportAndLoad<T>(path);
            }
 
            public static T LoadMain<T>([NotNull] Path path) where T : Object
            {
                ThrowIf.ArgumentIsNull(path, nameof(path));
                ThrowIf.DoesNotExistInFileSystem(path);
 
                ImportIfNotImported(path);
                return AssetDatabase.LoadMainAssetAtPath(path) as T;
            }
 
            public static T LoadMain<T>(GUID guid) where T : Object
            {
                ThrowIf.NotAnAssetGuid(guid);
 
                var path = Path.Get(guid);
                ImportIfNotImported(path);
                return LoadMain<T>(path);
            }
 
            [ExcludeFromCodeCoverage] // simple relay
            public static AssetDatabaseLoadOperation LoadAsync([NotNull] Path path, Int64 localFileId)
            {
#if UNITY_2022_2_OR_NEWER
                return AssetDatabase.LoadObjectAsync(path, localFileId);
#else
                throw new NotSupportedException("AssetDatabase.LoadObjectAsync not available in this editor version");
#endif
            }
 
            [ExcludeFromCodeCoverage] // simple relay
            public static String[] Find([NotNull] String filter, String[] searchInFolders = null) => searchInFolders == null
                ? AssetDatabase.FindAssets(filter)
                : AssetDatabase.FindAssets(filter, searchInFolders);
 
            [ExcludeFromCodeCoverage] // simple relay
            public static GUID[] FindGuids([NotNull] String filter, String[] searchInFolders = null) =>
                Find(filter, searchInFolders).Select(guid => new GUID(guid)).ToArray();
 
            [ExcludeFromCodeCoverage] // simple relay
            public static Path[] FindPaths([NotNull] String filter, String[] searchInFolders = null) =>
                Find(filter, searchInFolders).Select(guid => Path.Get(new GUID(guid))).ToArray();
 
            [ExcludeFromCodeCoverage] // simple relay
            public static Path[] FindPaths([NotNull] String filter, Path[] searchInFolders = null) =>
                FindPaths(filter, Path.ToStrings(searchInFolders));
 
            public static Boolean Copy([NotNull] Path sourcePath, [NotNull] Path destinationPath) =>
                CopyInternal(sourcePath, destinationPath, true);
 
            public static Boolean CopyAsNew([NotNull] Path sourcePath, [NotNull] Path destinationPath) =>
                CopyInternal(sourcePath, destinationPath.UniqueFilePath, false);
 
            public static Boolean CanMove([NotNull] Path sourcePath, [NotNull] Path destinationPath)
            {
                if (sourcePath == null || destinationPath == null)
                    return false;
 
                return Succeeded(AssetDatabase.ValidateMoveAsset(sourcePath, destinationPath));
            }
 
            public static Boolean Move([NotNull] Path sourcePath, [NotNull] Path destinationPath)
            {
                if (sourcePath == null || destinationPath == null)
                    return false;
 
                destinationPath.CreateFolders();
                return Succeeded(AssetDatabase.MoveAsset(sourcePath, destinationPath));
            }
 
            public static Boolean Rename([NotNull] Path path, String newFileName) => String.IsNullOrEmpty(newFileName) == false &&
                                                                                     Succeeded(AssetDatabase.RenameAsset(path, newFileName));
 
            [ExcludeFromCodeCoverage] // simple relay
            public static Boolean CanOpenInEditor([NotNull] Object instance) => CanOpenInEditor(instance.GetInstanceID());
 
            [ExcludeFromCodeCoverage] // simple relay
            public static Boolean CanOpenInEditor(Int32 instanceId) => AssetDatabase.CanOpenAssetInEditor(instanceId);
 
            [ExcludeFromCodeCoverage] // cannot be tested
            public static void OpenExternal([NotNull] Object asset, Int32 lineNumber = -1, Int32 columnNumber = -1) =>
                AssetDatabase.OpenAsset(asset, lineNumber, columnNumber);
 
            [ExcludeFromCodeCoverage] // cannot be tested
            public static void OpenExternal(Int32 instanceId, Int32 lineNumber = -1, Int32 columnNumber = -1) =>
                AssetDatabase.OpenAsset(instanceId, lineNumber, columnNumber);
 
            [ExcludeFromCodeCoverage] // cannot be tested
            public static void OpenExternal([NotNull] Path path, Int32 lineNumber = -1, Int32 columnNumber = -1) =>
                OpenExternal(Load<Object>(path), lineNumber, columnNumber);
 
            public static Boolean Delete([NotNull] Path path) =>
                // path.Exists prevents Unity from spitting out an unnecessary warning message
                path != null && path.Exists && AssetDatabase.DeleteAsset(path);
 
            public static Boolean Delete([NotNull] Object asset) => Delete(Path.Get(asset));
 
            public static Boolean Delete([NotNull] IEnumerable<Path> paths) => Delete(Path.ToStrings(paths));
 
            public static Boolean Delete([NotNull] IEnumerable<String> paths) =>
                AssetDatabase.DeleteAssets(paths.ToArray(), s_PathsNotDeleted = new List<String>());
 
            public static Boolean Trash([NotNull] Path path) => path != null && AssetDatabase.MoveAssetToTrash(path);
 
            public static Boolean Trash([NotNull] Object asset) => Trash(Path.Get(asset));
 
            public static Boolean Trash([NotNull] IEnumerable<Path> paths) => Trash(Path.ToStrings(paths));
 
            public static Boolean Trash([NotNull] IEnumerable<String> paths) =>
                AssetDatabase.MoveAssetsToTrash(paths.ToArray(), s_PathsNotDeleted = new List<String>());
 
        public static Type GetMainType([NotNull] Path path) => AssetDatabase.GetMainAssetTypeAtPath(path);
 
        [ExcludeFromCodeCoverage] // simple relay
        public static Type GetMainType(GUID guid)
        {
#if UNITY_2023_2_OR_NEWER // It's also available in 2022.2 but not in the early patch versions (eg 7f1 onwards)
            return AssetDatabase.GetMainAssetTypeFromGUID(guid);
#else
            return GetMainType(Path.Get(guid));
#endif
        }
 
        [ExcludeFromCodeCoverage] // simple relay
        public static Type GetSubType([NotNull] Path path, Int64 fileId) => AssetDatabase.GetTypeFromPathAndFileID(path, fileId);
 
 
        // ValueTuple makes doxygen accept it as documented, see: https://github.com/doxygen/doxygen/issues/9618
        public static ValueTuple<GUID, Int64> GetGuidAndFileId([NotNull] Object asset)
        {
            if (asset == null)
                return (new GUID(), 0L);
 
            // explicit variable + assign because Unity 2021 has both long and int variants of the TryGetGUID* method
            var localId = Int64.MaxValue;
            return AssetDatabase.TryGetGUIDAndLocalFileIdentifier(asset, out var guid, out localId)
                ? (new GUID(guid), localId)
                : (new GUID(), 0L);
        }
 
        public static GUID GetGuid([NotNull] Object asset)
        {
            if (asset == null)
                return new GUID();
 
            // explicit variable + assign because Unity 2021 has both long and int variants of the TryGetGUID* method
            var localId = Int64.MaxValue;
            return AssetDatabase.TryGetGUIDAndLocalFileIdentifier(asset, out var guid, out localId)
                ? new GUID(guid)
                : new GUID();
        }
 
        public static Int64 GetFileId([NotNull] Object asset)
        {
            if (asset == null)
                return 0L;
 
            // explicit variable + assign because Unity 2021 has both long and int variants of the TryGetGUID* method
            var localId = Int64.MaxValue;
            return AssetDatabase.TryGetGUIDAndLocalFileIdentifier(asset, out var _, out localId) ? localId : 0L;
        }
 
            // Internal on purpose: use Asset.File.BatchEditing(Action) instead
            [ExcludeFromCodeCoverage] // untestable
            internal static void StartAssetEditing() => AssetDatabase.StartAssetEditing();
 
            // Internal on purpose: use Asset.File.BatchEditing(Action) instead
            [ExcludeFromCodeCoverage] // untestable
            internal static void StopAssetEditing() => AssetDatabase.StopAssetEditing();
 
            internal static Object CreateInternal([NotNull] Byte[] bytes, [NotNull] Path path)
            {
                ThrowIf.ArgumentIsNull(bytes, nameof(bytes));
                ThrowIf.ArgumentIsNull(path, nameof(path));
 
                path.CreateFolders();
                System.IO.File.WriteAllBytes(path, bytes);
                return ImportAndLoad<Object>(path);
            }
 
            internal static Object CreateInternal([NotNull] String contents, [NotNull] Path path)
            {
                ThrowIf.ArgumentIsNull(contents, nameof(contents));
                ThrowIf.ArgumentIsNull(path, nameof(path));
 
                path.CreateFolders();
                System.IO.File.WriteAllText(path, contents, Encoding.UTF8); // string assets ought to be UTF8
                return ImportAndLoad<Object>(path);
            }
 
            internal static Object CreateInternal([NotNull] Object instance, [NotNull] Path path)
            {
                ThrowIf.ArgumentIsNull(instance, nameof(instance));
                ThrowIf.ArgumentIsNull(path, nameof(path));
 
                path.CreateFolders();
                AssetDatabase.CreateAsset(instance, path);
                return instance;
            }
 
            internal static Boolean CopyInternal([NotNull] Path sourcePath, [NotNull] Path destinationPath,
                Boolean overwriteExisting)
            {
                ThrowIf.ArgumentIsNull(sourcePath, nameof(sourcePath));
                ThrowIf.ArgumentIsNull(destinationPath, nameof(destinationPath));
                ThrowIf.AssetPathNotInDatabase(sourcePath);
                ThrowIf.SourceAndDestPathAreEqual(sourcePath, destinationPath);
 
                destinationPath.CreateFolders();
 
#if UNITY_2022_1_OR_NEWER
                var success = AssetDatabase.CopyAsset(sourcePath, destinationPath);
                SetLastErrorMessage(success ? String.Empty : $"failed to copy {sourcePath} to {destinationPath}");
                return success;
#else
                // in Unity 2021 we have to load, clone and create instead
                // because object and file name have to match (likely a bug in that version)
                var original = LoadMain<Object>(sourcePath);
                var copy = Object.Instantiate(original);
                copy = Create(copy, destinationPath);
                return copy != null;
#endif
            }
 
            private static void SaveInternal([NotNull] Object asset, Boolean forceSave = false)
            {
                ThrowIf.ArgumentIsNull(asset, nameof(asset));
                ThrowIf.NotInDatabase(asset);
 
                if (forceSave)
                    EditorUtility.SetDirty(asset);
 
                AssetDatabase.SaveAssetIfDirty(asset);
            }
 
            private static void ImportIfNotImported([NotNull] Path path,
                ImportAssetOptions options = ImportAssetOptions.Default)
            {
                // Not in database but on disk? => Import path
                // Cannot determine if existing file has been updated though.
                if (path.Exists == false && path.ExistsInFileSystem)
                    Import(path, options);
            }
 
#if !UNITY_2022_2_OR_NEWER // dummy for LoadAsync in earlier versions
            public class AssetDatabaseLoadOperation {}
#endif
        }
    }
}