PrefixedFileSystem.cs

using System.Diagnostics;

using Ramstack.FileSystem.Null;
using Ramstack.FileSystem.Utilities;

namespace Ramstack.FileSystem.Prefixed;

/// <summary>
/// Represents an implementation of the <see cref="IVirtualFileSystem"/> that adds a specified prefix
/// to the file paths within the underlying file system.
/// </summary>
[DebuggerDisplay("{_prefix,nq}")]
public sealed class PrefixedFileSystem : IVirtualFileSystem
{
    private readonly string _prefix;
    private readonly IVirtualFileSystem _fs;
    private readonly VirtualDirectory[] _directories;

    /// <inheritdoc />
    public bool IsReadOnly => _fs.IsReadOnly;

    /// <summary>
    /// Initializes a new instance of the <see cref="PrefixedFileSystem" /> class.
    /// </summary>
    /// <param name="prefix">The prefix to be applied to the file paths managed by this instance.</param>
    /// <param name="fileSystem">The underlying file system that manages the files to which the prefix will be applied.</param>
    public PrefixedFileSystem(string prefix, IVirtualFileSystem fileSystem)
    {
        prefix = VirtualPath.Normalize(prefix);
        (_prefix, _fs) = (prefix, fileSystem);

        // Create an artificial directory list
        _directories = CreateArtificialDirectories(this, prefix);

        static VirtualDirectory[] CreateArtificialDirectories(PrefixedFileSystem fs, string path)
        {
            var directories = new List<VirtualDirectory>();
            VirtualDirectory? directory = null;

            while (!string.IsNullOrEmpty(path))
            {
                directory = directory is null
                    ? new PrefixedDirectory(fs, path, fs._fs.GetDirectory("/"))
                    : new ArtificialDirectory(fs, path, directory);

                directories.Add(directory);
                path = VirtualPath.GetDirectoryName(path);
            }

            return directories.ToArray();
        }
    }

    /// <inheritdoc />
    public VirtualFile GetFile(string path)
    {
        path = VirtualPath.Normalize(path);

        var underlying = TryUnwrapPrefix(path, _prefix);
        if (underlying is not null)
            return new PrefixedFile(this, path, _fs.GetFile(underlying));

        return new NotFoundFile(this, path);
    }

    /// <inheritdoc />
    public VirtualDirectory GetDirectory(string path)
    {
        path = VirtualPath.Normalize(path);

        foreach (var directory in _directories)
            if (directory.FullName == path)
                return directory;

        var underlying = TryUnwrapPrefix(path, _prefix);
        if (underlying is not null)
            return new PrefixedDirectory(this, path, _fs.GetDirectory(underlying));

        return new NotFoundDirectory(this, path);
    }

    /// <inheritdoc />
    public void Dispose() =>
        _fs.Dispose();

    /// <summary>
    /// Converts a path from the wrapped file system to a full path in this prefixed file system.
    /// </summary>
    /// <param name="underlyingPath">The path relative to the wrapped file system (must be normalized).</param>
    /// <returns>
    /// The full path including this file system's prefix.
    /// </returns>
    internal string WrapWithPrefix(string underlyingPath)
    {
        Debug.Assert(VirtualPath.IsNormalized(underlyingPath));

        if (underlyingPath == "/")
            return _prefix;

        return VirtualPath.Join(_prefix, underlyingPath);
    }

    /// <summary>
    /// Attempts to extract the underlying path by removing this file system's prefix from a full path.
    /// </summary>
    /// <param name="path">The full path that may include this file system's prefix (must be normalized).</param>
    /// <param name="prefix">The prefix to compare against the path.</param>
    /// <returns>
    /// The underlying path relative to the wrapped file system if the prefix matches;
    /// otherwise, <see langword="null"/> if the path doesn't belong to this prefixed file system.
    /// </returns>
    private static string? TryUnwrapPrefix(string path, string prefix)
    {
        Debug.Assert(VirtualPath.IsNormalized(path));

        if (path == prefix)
            return "/";

        if (path.StartsWith(prefix, StringComparison.Ordinal) && path[prefix.Length] == '/')
            return new string(path.AsSpan(prefix.Length));

        return null;
    }

    #region Inner type: ArtificialDirectory

    /// <summary>
    /// Represents an artificial directory within a file system.
    /// </summary>
    private sealed class ArtificialDirectory : VirtualDirectory
    {
        private readonly PrefixedFileSystem _fs;
        private readonly VirtualDirectory _directory;

        /// <inheritdoc />
        public override IVirtualFileSystem FileSystem => _fs;

        /// <summary>
        /// Initializes a new instance of the <see cref="ArtificialDirectory"/> class.
        /// </summary>
        /// <param name="fileSystem">The file system associated with this directory.</param>
        /// <param name="path">The path of the directory.</param>
        /// <param name="directory">The child directory.</param>
        public ArtificialDirectory(PrefixedFileSystem fileSystem, string path, VirtualDirectory directory) : base(path) =>
            (_fs, _directory) = (fileSystem, directory);

        /// <inheritdoc />
        protected override ValueTask<VirtualNodeProperties?> GetPropertiesCoreAsync(CancellationToken cancellationToken) =>
            new ValueTask<VirtualNodeProperties?>(VirtualNodeProperties.None);

        /// <inheritdoc />
        protected override ValueTask CreateCoreAsync(CancellationToken cancellationToken) =>
            default;

        /// <inheritdoc />
        protected override ValueTask DeleteCoreAsync(CancellationToken cancellationToken) =>
            throw new UnauthorizedAccessException($"Access to the path '{FullName}' is denied.");

        /// <inheritdoc />
        protected override IAsyncEnumerable<VirtualNode> GetFileNodesCoreAsync(CancellationToken cancellationToken) =>
            new VirtualNode[] { _directory }.ToAsyncEnumerable();
    }

    #endregion
}