Asset.Path.cs

// Copyright (C) 2021-2023 Steffen Itterheim
// Refer to included LICENSE file for terms and conditions.
 
using System;
using System.Diagnostics.CodeAnalysis;
using UnityEditor;
using UnityEngine;
using Object = UnityEngine.Object;
 
namespace CodeSmileEditor
{
    public sealed partial class Asset
    {
        public partial class Path : IEquatable<Path>, IEquatable<String>
        {
            private const String DefaultExtension = "asset";
 
            private String m_RelativePath = String.Empty;
 
            public GUID Guid => GetGuid(this, AssetPathToGUIDOptions.OnlyExistingAssets);
 
            public Boolean Exists
            {
                get
                {
#if UNITY_2023_2_OR_NEWER
                    return AssetDatabase.AssetPathExists(m_RelativePath);
#else
                    return AssetDatabase.AssetPathToGUID(m_RelativePath, AssetPathToGUIDOptions.OnlyExistingAssets).Length > 0;
#endif
                }
            }
 
            public Boolean ExistsInFileSystem => FileExists(this) || FolderExists(this);
 
            [ExcludeFromCodeCoverage] // simple relay
            public Path MetaPath => ToMeta(this);
 
            [ExcludeFromCodeCoverage] // simple relay
            public Path AssetPath => FromMeta(this);
 
            public String Extension => System.IO.Path.GetExtension(m_RelativePath);
 
            [ExcludeFromCodeCoverage] // simple relay
            public String FileName => System.IO.Path.GetFileName(m_RelativePath);
 
            [ExcludeFromCodeCoverage] // simple relay
            public String FileNameWithoutExtension => System.IO.Path.GetFileNameWithoutExtension(m_RelativePath);
 
            public String FullPath => System.IO.Path.GetFullPath(m_RelativePath).ToForwardSlashes();
 
            [ExcludeFromCodeCoverage] // simple relay
            public String[] SubFolders => GetSubFolders(this);
 
            public Path FolderPath
            {
                get
                {
                    var dirName = System.IO.Path.GetDirectoryName(m_RelativePath);
                    return String.IsNullOrEmpty(dirName) ? null : dirName;
                }
            }
 
            public Path UniqueFilePath => UniquifyFileName(this);
 
            [ExcludeFromCodeCoverage] private Path() {} // disallowed parameterless ctor
 
            public Path([NotNull] String fullOrRelativePath)
            {
                ThrowIf.NullOrWhitespace(fullOrRelativePath, nameof(fullOrRelativePath));
                m_RelativePath = ToRelative(fullOrRelativePath.ToForwardSlashes());
            }
 
            public Path([NotNull] String folderPath, [NotNull] String fileName, [NotNull] String extension = DefaultExtension)
            {
                ThrowIf.NullOrWhitespace(folderPath, nameof(folderPath));
                ThrowIf.NullOrWhitespace(fileName, nameof(fileName));
                ThrowIf.NullOrWhitespace(extension, nameof(extension));
                ThrowIf.ContainsPathSeparators(fileName, nameof(fileName));
 
                var relativeDir = ToRelative(folderPath.ToForwardSlashes());
                m_RelativePath = $"{relativeDir}/{fileName}.{extension.TrimStart('.').ToLower()}";
            }
 
            public Path([NotNull] Object asset)
            {
                ThrowIf.ArgumentIsNull(asset, nameof(asset));
                ThrowIf.NotInDatabase(asset);
 
                m_RelativePath = Get(asset);
            }
 
            public Boolean Equals(Path other)
            {
                if (ReferenceEquals(other, null))
                    return false;
                if (ReferenceEquals(this, other))
                    return true;
 
                return m_RelativePath.Equals(other.m_RelativePath);
            }
 
            public Boolean Equals(String other) => m_RelativePath.Equals(new Path(other).m_RelativePath);
 
            public static implicit operator String(Path path) => path != null ? path.m_RelativePath : null;
 
            public static implicit operator Path(String path) => path != null ? new Path(path) : null;
 
            public static Boolean operator ==(Path path1, Path path2)
            {
                if (ReferenceEquals(path1, path2))
                    return true;
                if (ReferenceEquals(path1, null))
                    return false;
                if (ReferenceEquals(path2, null))
                    return false;
 
                return path1.Equals(path2);
            }
 
            public static Boolean operator !=(Path path1, Path path2) => !(path1 == path2);
 
            public static Boolean operator ==(Path path1, System.Object other) =>
                other is String str ? path1.Equals(str) : path1.Equals(other as Path);
 
            public static Boolean operator !=(Path path1, System.Object other) => !(path1 == other);
 
            public static Boolean operator ==(System.Object other, Path path) => path == other;
 
            public static Boolean operator !=(System.Object other, Path path) => !(path == other);
 
            [ExcludeFromCodeCoverage] // cannot be tested
            public void OpenExternal() => Application.OpenURL(System.IO.Path.GetFullPath(FolderPath));
 
            public void Rename(String newFileOrFolderName)
            {
                if (String.IsNullOrEmpty(newFileOrFolderName) == false)
                    m_RelativePath = $"{FolderPath}/{System.IO.Path.GetFileName(newFileOrFolderName)}";
            }
 
            public GUID CreateFolders() => CreateFolders(this);
 
            public override String ToString() => m_RelativePath;
 
            public override Boolean Equals(System.Object obj)
            {
                if (obj is Path path)
                    return Equals(path);
                if (obj is String str)
                    return Equals(str);
 
                return false;
            }
 
            public override Int32 GetHashCode() => m_RelativePath.GetHashCode();
        }
    }
}