Asset.Path.Static.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.IO;
using System.Linq;
using UnityEditor;
using UnityEngine;
using Object = UnityEngine.Object;
 
namespace CodeSmileEditor
{
    public sealed partial class Asset
    {
        public partial class Path
        {
            // all lowercase
            private static readonly String[] s_AllowedAssetSubfolders =
                { "assets", "library", "logs", "packages", "projectsettings", "temp", "usersettings" };
 
            public static String FullAssetsPath => Application.dataPath;
 
            public static String FullPackagesPath => $"{FullProjectPath}/Packages";
 
            [ExcludeFromCodeCoverage] // returns string interpolation
            public static String FullLibraryPath => $"{FullProjectPath}/Library";
 
            [ExcludeFromCodeCoverage] // returns string interpolation
            public static String FullLogsPath => $"{FullProjectPath}/Logs";
 
            [ExcludeFromCodeCoverage] // returns string interpolation
            public static String FullProjectSettingsPath => $"{FullProjectPath}/ProjectSettings";
 
            [ExcludeFromCodeCoverage] // returns string interpolation
            public static String FullUserSettingsPath => $"{FullProjectPath}/UserSettings";
 
            [ExcludeFromCodeCoverage] // returns string interpolation
            public static String FullProjectTempPath => $"{FullProjectPath}/Temp";
 
            public static String FullProjectPath => FullAssetsPath.Substring(0, Application.dataPath.Length - 6);
 
            public static Path Get([NotNull] Object asset)
            {
                var path = AssetDatabase.GetAssetPath(asset);
                return String.IsNullOrEmpty(path) ? null : (Path)path;
            }
 
            public static Path Get(GUID guid)
            {
                var path = AssetDatabase.GUIDToAssetPath(guid);
                return String.IsNullOrEmpty(path) ? null : (Path)path;
            }
 
            public static String[] Get([NotNull] Object[] assets)
            {
                ThrowIf.ArgumentIsNull(assets, nameof(assets));
 
                var objectCount = assets.Length;
                var paths = new String[objectCount];
                for (var i = 0; i < objectCount; i++)
                    paths[i] = Get(assets[i]);
 
                return paths;
            }
 
            public static GUID GetGuid([NotNull] Path path,
                AssetPathToGUIDOptions options = AssetPathToGUIDOptions.IncludeRecentlyDeletedAssets) =>
                new(AssetDatabase.AssetPathToGUID(path, options));
 
            [ExcludeFromCodeCoverage] // simple relay
            public static Path ToMeta([NotNull] Path path) => AssetDatabase.GetTextMetaFilePathFromAssetPath(path);
 
            [ExcludeFromCodeCoverage] // simple relay
            public static Path FromMeta([NotNull] Path path) => AssetDatabase.GetAssetPathFromTextMetaFilePath(path);
 
            public static Path GetScene([NotNull] Object instanceOrAsset) => AssetDatabase.GetAssetOrScenePath(instanceOrAsset);
 
            public static Boolean IsValid([NotNull] String path)
            {
                var isValid = true;
 
                try
                {
                    // System.IO will throw for most illegal chars, plus some extra checks
                    var fileName = System.IO.Path.GetFileName(path);
                    var folderName = System.IO.Path.GetDirectoryName(path);
 
                    // check folder name for some chars that System.IO allows in GetDirectoryName
                    var testIllegalChars = new Func<Char, Boolean>(c => c == '*' || c == '?' || c == ':');
                    isValid = folderName.Any(testIllegalChars) == false;
 
                    if (isValid)
                    {
                        // check filename for some chars that System.IO allows in GetFileName
                        fileName = path.Substring(folderName.Length, path.Length - folderName.Length);
                        isValid = fileName.Any(testIllegalChars) == false;
                    }
                }
                catch (Exception ex)
                {
                    SetLastErrorMessage($"{ex.Message} => \"{path}\"");
                    isValid = false;
                }
 
                return isValid;
            }
 
            public static Boolean FileExists([NotNull] Path path) => System.IO.File.Exists(path.m_RelativePath);
 
            public static Boolean FolderExists([NotNull] Path path) => Directory.Exists(path.m_RelativePath);
 
            public static GUID CreateFolders([NotNull] Path path)
            {
                ThrowIf.ArgumentIsNull(path, nameof(path));
                ThrowIf.PathIsNotValid(path);
 
                if (FileExists(path))
                    return path.FolderPath.Guid;
 
                // if the last part has an extension we assume the path points to a file
                var isPresumablyFilePath = String.IsNullOrEmpty(path.Extension) == false;
                var folderPath = isPresumablyFilePath ? path.FolderPath : path;
                if (FolderExists(folderPath))
                    return folderPath.Guid;
 
                var folderNames = ((String)folderPath).Split(new[] { '/' });
                var folderGuid = GuidForExistingPath(folderNames[0]); // first is "Assets"
                var partialPath = folderNames[0];
                for (var i = 1; i < folderNames.Length; i++)
                {
                    partialPath += $"/{folderNames[i]}";
                    if (FolderExists(partialPath))
                    {
                        folderGuid = GuidForExistingPath(partialPath);
                        continue;
                    }
 
                    folderGuid = CreateSubFolder(Get(folderGuid), folderNames[i]);
                }
 
                return folderGuid;
            }
 
            [ExcludeFromCodeCoverage] // simple relay
            public static String[] GetSubFolders([NotNull] Path path) => AssetDatabase.GetSubFolders(path);
 
            public static Path UniquifyFileName([NotNull] Path path)
            {
                var uniquePath = AssetDatabase.GenerateUniqueAssetPath(path);
                return String.IsNullOrEmpty(uniquePath) ? path : uniquePath;
            }
 
            public static String[] ToStrings([NotNull] IEnumerable<Path> paths) => paths.Select(path => (String)path).ToArray();
 
            internal static Path UniquifyAsNeeded([NotNull] Path path, Boolean overwriteExisting) =>
                overwriteExisting ? path : path.UniqueFilePath;
 
            private static GUID CreateSubFolder([NotNull] Path parentFolder, [NotNull] String subFolderName) =>
                new(AssetDatabase.CreateFolder(parentFolder, subFolderName));
 
            private static String ToRelative([NotNull] String fullOrRelativePath)
            {
                var relativePath = fullOrRelativePath;
                if (IsRelative(relativePath) == false)
                {
                    ThrowIf.NotAProjectPath(fullOrRelativePath);
                    relativePath = MakeRelative(fullOrRelativePath);
                }
 
                relativePath = relativePath.Trim('/');
 
                ThrowIf.PathIsNotValid(relativePath);
                return relativePath;
            }
 
            private static Boolean IsRelative([NotNull] String path)
            {
                path = path.TrimStart('/').ToLower();
 
                // path must start with given project root subfolder names (eg 'Assets', 'Packages', 'Library' ..)
                // and bei either just the subfolder (length equals) or be followed by a path separator
                foreach (var allowedSubfolder in s_AllowedAssetSubfolders)
                {
                    var doesStartsWith = path.StartsWith(allowedSubfolder);
                    var subfolderLength = allowedSubfolder.Length;
                    var lengthMatches = path.Length == subfolderLength;
                    if (doesStartsWith && (lengthMatches || path[subfolderLength].Equals('/')))
                        return true;
                }
 
                return false;
            }
 
            private static String MakeRelative([NotNull] String fullOrRelativePath) =>
                fullOrRelativePath.Substring(FullProjectPath.Length).Trim('/');
 
            private static GUID GuidForExistingPath([NotNull] String path) =>
                new(AssetDatabase.AssetPathToGUID(path, AssetPathToGUIDOptions.OnlyExistingAssets));
        }
    }
}