/// <summary> /// Gets the absolute input path that contains the specified file or directory. If the provided /// file or directory path is absolute, this returns the input path that contains the specified /// path (note that the specified file or directory does not need to exist and this just returns /// the input path that would contain the file or directory based only on path information). If /// the provided path is relative, this checks all input paths for the existence of the file /// or directory and returns the first one where it exists. /// </summary> /// <param name="fileSystem">The file system.</param> /// <param name="path">The file path.</param> /// <returns>The input path that contains the specified file, /// or <c>null</c> if no input path does.</returns> public static NormalizedPath GetContainingInputPath(this IReadOnlyFileSystem fileSystem, NormalizedPath path) { _ = fileSystem ?? throw new ArgumentNullException(nameof(fileSystem)); path.ThrowIfNull(nameof(path)); if (path.IsAbsolute) { return(fileSystem.GetContainingInputPathForAbsolutePath(path)); } // Try to find a file first IFile file = fileSystem.GetInputFile(path); if (file.Exists) { return(fileSystem.GetContainingInputPath(file.Path)); } // Then try to find a directory IEnumerable <(NormalizedPath x, IDirectory)> rootDirectories = fileSystem.InputPaths .Reverse() .Select(x => (x, fileSystem.GetRootDirectory(x.Combine(path)))); IEnumerable <(NormalizedPath x, IDirectory)> existingRootDirectories = rootDirectories.Where(x => x.Item2.Exists); return(existingRootDirectories.Select(x => fileSystem.RootPath.Combine(x.Item1)).FirstOrDefault()); }
/// <summary> /// Gets a file representing an input. /// </summary> /// <param name="fileSystem">The file system.</param> /// <param name="path"> /// The path of the input file. If this is an absolute path, /// then a file representing the specified path is returned. /// If it's a relative path, then operations will search all /// current input paths. /// </param> /// <returns>An input file.</returns> public static IFile GetInputFile(this IReadOnlyFileSystem fileSystem, NormalizedPath path) { _ = fileSystem ?? throw new ArgumentNullException(nameof(fileSystem)); path.ThrowIfNull(nameof(path)); if (path.IsRelative) { IFile notFound = null; foreach (NormalizedPath inputPath in fileSystem.InputPaths.Reverse()) { IFile file = fileSystem.GetFile(fileSystem.RootPath.Combine(inputPath).Combine(path)); if (notFound == null) { notFound = file; } if (file.Exists) { return(file); } } if (notFound == null) { throw new InvalidOperationException("The input paths collection must have at least one path"); } return(notFound); } return(fileSystem.GetFile(path)); }
internal DocumentFile(DocumentFileProvider fileProvider, NormalizedPath path) { _fileProvider = fileProvider ?? throw new ArgumentNullException(nameof(fileProvider)); path.ThrowIfNull(nameof(path)); if (!fileProvider.Files.TryGetValue(path, out _document)) { _document = null; } Path = path; }
/// <inheritdoc/> public IDirectory GetDirectory(NormalizedPath path) { path.ThrowIfNull(nameof(path)); if (!path.IsRelative) { throw new ArgumentException("Path must be relative", nameof(path)); } return(new VirtualInputDirectory(_fileSystem, Path.Combine(path))); }
/// <inheritdoc/> public IFile GetFile(NormalizedPath path) { path.ThrowIfNull(nameof(path)); if (!path.IsRelative) { throw new ArgumentException("Path must be relative", nameof(path)); } return(_fileSystem.GetInputFile(Path.Combine(path))); }
public IFile GetFile(NormalizedPath path) { path.ThrowIfNull(nameof(path)); if (!path.IsRelative) { throw new ArgumentException("Path must be relative", nameof(path)); } return(new DocumentFile(_fileProvider, Path.Combine(path))); }
public IDirectory GetDirectory(NormalizedPath directory) { directory.ThrowIfNull(nameof(directory)); if (!directory.IsRelative) { throw new ArgumentException("Path must be relative", nameof(directory)); } return(new DocumentDirectory(_fileProvider, Path.Combine(directory))); }
public VirtualInputDirectory(IReadOnlyFileSystem fileSystem, NormalizedPath path) { path.ThrowIfNull(nameof(path)); if (!path.IsRelative) { throw new ArgumentException("Virtual input paths should always be relative", nameof(path)); } _fileSystem = fileSystem ?? throw new ArgumentNullException(nameof(fileSystem)); Path = path; }
internal static NormalizedPath GetContainingInputPathForAbsolutePath(this IReadOnlyFileSystem fileSystem, NormalizedPath path) { _ = fileSystem ?? throw new ArgumentNullException(nameof(fileSystem)); path.ThrowIfNull(nameof(path)); if (!path.IsAbsolute) { throw new ArgumentException("Path must be absolute"); } return(fileSystem.InputPaths .Reverse() .Select(x => fileSystem.RootPath.Combine(x)) .FirstOrDefault(x => path.Segments.StartsWith(x.Segments))); }
public static IFile CreateZipFile(IExecutionContext context, NormalizedPath directory) { directory.ThrowIfNull(nameof(directory)); IDirectory sourceDirectory = context.FileSystem.GetRootDirectory(directory); if (!sourceDirectory.Exists) { throw new DirectoryNotFoundException("Source zip directory does not exist"); } IFile zipFile = context.FileSystem.GetTempFile(); context.LogDebug($"Creating zip file from {sourceDirectory.Path.FullPath} at {zipFile.Path.FullPath}"); ZipFile.CreateFromDirectory(sourceDirectory.Path.FullPath, zipFile.Path.FullPath); return(zipFile); }
public static NormalizedPath Resolve(NormalizedPath source, NormalizedPath target) { source.ThrowIfNull(nameof(source)); target.ThrowIfNull(nameof(target)); // Make sure they're both either relative or absolute if (source.IsAbsolute != target.IsAbsolute) { throw new ArgumentException("Paths must both be relative or both be absolute"); } // Check if they're the same path if (source.FullPath == target.FullPath) { return(NormalizedPath.Empty); } // Special case if source is just root if (source.IsAbsolute && source == NormalizedPath.AbsoluteRoot) { return(new NormalizedPath(string.Join(NormalizedPath.Slash, target.Segments))); } // Check if they share the same root if (target.Segments.Length == 0 || !source.Segments[0].SequenceEqual(target.Segments[0])) { return(target); } int minimumSegmentsLength = Math.Min(source.Segments.Length, target.Segments.Length); int lastCommonRoot = -1; // Find common root for (int x = 0; x < minimumSegmentsLength; x++) { if (!source.Segments[x].SequenceEqual(target.Segments[x])) { break; } lastCommonRoot = x; } if (lastCommonRoot == -1) { return(target); } // Add relative folders in from path List <ReadOnlyMemory <char> > relativeSegments = new List <ReadOnlyMemory <char> >(); for (int x = lastCommonRoot + 1; x < source.Segments.Length; x++) { if (source.Segments[x].Length > 0) { relativeSegments.Add(NormalizedPath.DotDot.AsMemory()); } } // Add to folders to path for (int x = lastCommonRoot + 1; x < target.Segments.Length; x++) { relativeSegments.Add(target.Segments[x]); } // Create relative path return(new NormalizedPath(string.Join("/", relativeSegments))); }
internal DocumentDirectory(DocumentFileProvider fileProvider, NormalizedPath path) { _fileProvider = fileProvider ?? throw new ArgumentNullException(nameof(fileProvider)); path.ThrowIfNull(nameof(path)); Path = path; }