Some API clean up from GPT 5.4

src/SharpCompress/Archives/ArchiveFactory.Async.cs

@@ -6,7 +6,6 @@
 using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Factories;
-using SharpCompress.IO;
 using SharpCompress.Readers;
 
 namespace SharpCompress.Archives;
@@ -53,20 +52,20 @@ public static async ValueTask<IAsyncArchive> OpenAsyncArchive(
     }
 
     public static async ValueTask<IAsyncArchive> OpenAsyncArchive(
-        IEnumerable<FileInfo> fileInfos,
+        IReadOnlyList<FileInfo> fileInfos,
         ReaderOptions? options = null,
         CancellationToken cancellationToken = default
     )
     {
         fileInfos.NotNull(nameof(fileInfos));
-        var filesArray = fileInfos.ToArray();
-        if (filesArray.Length == 0)
+        var filesArray = fileInfos;
+        if (filesArray.Count == 0)
         {
             throw new ArchiveOperationException("No files to open");
         }
 
         var fileInfo = filesArray[0];
-        if (filesArray.Length == 1)
+        if (filesArray.Count == 1)
         {
             return await OpenAsyncArchive(fileInfo, options, cancellationToken)
                 .ConfigureAwait(false);
@@ -83,21 +82,21 @@ public static async ValueTask<IAsyncArchive> OpenAsyncArchive(
     }
 
     public static async ValueTask<IAsyncArchive> OpenAsyncArchive(
-        IEnumerable<Stream> streams,
+        IReadOnlyList<Stream> streams,
         ReaderOptions? options = null,
         CancellationToken cancellationToken = default
     )
     {
         cancellationToken.ThrowIfCancellationRequested();
         streams.NotNull(nameof(streams));
-        var streamsArray = streams.ToArray();
-        if (streamsArray.Length == 0)
+        var streamsArray = streams;
+        if (streamsArray.Count == 0)
         {
             throw new ArchiveOperationException("No streams");
         }
 
         var firstStream = streamsArray[0];
-        if (streamsArray.Length == 1)
+        if (streamsArray.Count == 1)
         {
             return await OpenAsyncArchive(firstStream, options, cancellationToken)
                 .ConfigureAwait(false);
@@ -113,19 +112,19 @@ public static async ValueTask<IAsyncArchive> OpenAsyncArchive(
             .ConfigureAwait(false);
     }
 
-    public static ValueTask<T> FindFactoryAsync<T>(
-        string path,
+    internal static ValueTask<T> FindFactoryAsync<T>(
+        string filePath,
         CancellationToken cancellationToken = default
     )
         where T : IFactory
     {
-        path.NotNullOrEmpty(nameof(path));
-        return FindFactoryAsync<T>(new FileInfo(path), cancellationToken);
+        filePath.NotNullOrEmpty(nameof(filePath));
+        return FindFactoryAsync<T>(new FileInfo(filePath), cancellationToken);
     }
 
-    private static async ValueTask<T> FindFactoryAsync<T>(
+    internal static async ValueTask<T> FindFactoryAsync<T>(
         FileInfo finfo,
-        CancellationToken cancellationToken
+        CancellationToken cancellationToken = default
     )
         where T : IFactory
     {
@@ -134,9 +133,9 @@ CancellationToken cancellationToken
         return await FindFactoryAsync<T>(stream, cancellationToken).ConfigureAwait(false);
     }
 
-    private static async ValueTask<T> FindFactoryAsync<T>(
+    internal static async ValueTask<T> FindFactoryAsync<T>(
         Stream stream,
-        CancellationToken cancellationToken
+        CancellationToken cancellationToken = default
     )
         where T : IFactory
     {

src/SharpCompress/Archives/ArchiveFactory.cs

@@ -2,6 +2,8 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Common.Options;
 using SharpCompress.Factories;
@@ -21,7 +23,7 @@ public static IWritableArchive<TOptions> CreateArchive<TOptions>()
         where TOptions : IWriterOptions
     {
         var factory = Factory
-            .Factories.OfType<IWriteableArchiveFactory<TOptions>>()
+            .Factories.OfType<IWritableArchiveFactory<TOptions>>()
             .FirstOrDefault();
 
         if (factory != null)
@@ -46,19 +48,19 @@ public static IArchive OpenArchive(FileInfo fileInfo, ReaderOptions? options = n
     }
 
     public static IArchive OpenArchive(
-        IEnumerable<FileInfo> fileInfos,
+        IReadOnlyList<FileInfo> fileInfos,
         ReaderOptions? options = null
     )
     {
         fileInfos.NotNull(nameof(fileInfos));
-        var filesArray = fileInfos.ToArray();
-        if (filesArray.Length == 0)
+        var filesArray = fileInfos;
+        if (filesArray.Count == 0)
         {
             throw new ArchiveOperationException("No files to open");
         }
 
         var fileInfo = filesArray[0];
-        if (filesArray.Length == 1)
+        if (filesArray.Count == 1)
         {
             return OpenArchive(fileInfo, options);
         }
@@ -69,17 +71,17 @@ public static IArchive OpenArchive(
         return FindFactory<IMultiArchiveFactory>(fileInfo).OpenArchive(filesArray, options);
     }
 
-    public static IArchive OpenArchive(IEnumerable<Stream> streams, ReaderOptions? options = null)
+    public static IArchive OpenArchive(IReadOnlyList<Stream> streams, ReaderOptions? options = null)
     {
         streams.NotNull(nameof(streams));
-        var streamsArray = streams.ToArray();
-        if (streamsArray.Length == 0)
+        var streamsArray = streams;
+        if (streamsArray.Count == 0)
         {
             throw new ArchiveOperationException("No streams");
         }
 
         var firstStream = streamsArray[0];
-        if (streamsArray.Length == 1)
+        if (streamsArray.Count == 1)
         {
             return OpenArchive(firstStream, options);
         }
@@ -100,11 +102,11 @@ public static void WriteToDirectory(
         archive.WriteToDirectory(destinationDirectory, options);
     }
 
-    public static T FindFactory<T>(string path)
+    public static T FindFactory<T>(string filePath)
         where T : IFactory
     {
-        path.NotNullOrEmpty(nameof(path));
-        using Stream stream = File.OpenRead(path);
+        filePath.NotNullOrEmpty(nameof(filePath));
+        using Stream stream = File.OpenRead(filePath);
         return FindFactory<T>(stream);
     }
 
@@ -182,6 +184,46 @@ public static bool IsArchive(Stream stream, out ArchiveType? type)
         return false;
     }
 
+    public static async ValueTask<(bool IsArchive, ArchiveType? Type)> IsArchiveAsync(
+        string filePath,
+        CancellationToken cancellationToken = default
+    )
+    {
+        filePath.NotNullOrEmpty(nameof(filePath));
+        using Stream stream = File.OpenRead(filePath);
+        return await IsArchiveAsync(stream, cancellationToken).ConfigureAwait(false);
+    }
+
+    public static async ValueTask<(bool IsArchive, ArchiveType? Type)> IsArchiveAsync(
+        Stream stream,
+        CancellationToken cancellationToken = default
+    )
+    {
+        stream.NotNull(nameof(stream));
+
+        if (!stream.CanRead || !stream.CanSeek)
+        {
+            throw new ArgumentException("Stream should be readable and seekable");
+        }
+
+        var startPosition = stream.Position;
+
+        foreach (var factory in Factory.Factories)
+        {
+            var isArchive = await factory
+                .IsArchiveAsync(stream, cancellationToken: cancellationToken)
+                .ConfigureAwait(false);
+            stream.Position = startPosition;
+
+            if (isArchive)
+            {
+                return (true, factory.KnownArchiveType);
+            }
+        }
+
+        return (false, null);
+    }
+
     public static IEnumerable<string> GetFileParts(string part1)
     {
         part1.NotNullOrEmpty(nameof(part1));

src/SharpCompress/Archives/GZip/GZipArchive.Factory.cs

@@ -21,14 +21,14 @@ public partial class GZipArchive
 #endif
 {
     public static ValueTask<IWritableAsyncArchive<GZipWriterOptions>> OpenAsyncArchive(
-        string path,
+        string filePath,
         ReaderOptions? readerOptions = null,
         CancellationToken cancellationToken = default
     )
     {
         cancellationToken.ThrowIfCancellationRequested();
-        path.NotNullOrEmpty(nameof(path));
-        return OpenAsyncArchive(new FileInfo(path), readerOptions, cancellationToken);
+        filePath.NotNullOrEmpty(nameof(filePath));
+        return OpenAsyncArchive(new FileInfo(filePath), readerOptions, cancellationToken);
     }
 
     public static IWritableArchive<GZipWriterOptions> OpenArchive(
@@ -37,7 +37,7 @@ public static IWritableArchive<GZipWriterOptions> OpenArchive(
     )
     {
         filePath.NotNullOrEmpty(nameof(filePath));
-        return OpenArchive(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
+        return OpenArchive(new FileInfo(filePath), readerOptions ?? ReaderOptions.ForFilePath);
     }
 
     public static IWritableArchive<GZipWriterOptions> OpenArchive(
@@ -50,39 +50,39 @@ public static IWritableArchive<GZipWriterOptions> OpenArchive(
             new SourceStream(
                 fileInfo,
                 i => ArchiveVolumeFactory.GetFilePart(i, fileInfo),
-                readerOptions ?? new ReaderOptions()
+                readerOptions ?? ReaderOptions.ForFilePath
             )
         );
     }
 
     public static IWritableArchive<GZipWriterOptions> OpenArchive(
-        IEnumerable<FileInfo> fileInfos,
+        IReadOnlyList<FileInfo> fileInfos,
         ReaderOptions? readerOptions = null
     )
     {
         fileInfos.NotNull(nameof(fileInfos));
-        var files = fileInfos.ToArray();
+        var files = fileInfos;
         return new GZipArchive(
             new SourceStream(
                 files[0],
-                i => i < files.Length ? files[i] : null,
-                readerOptions ?? new ReaderOptions()
+                i => i < files.Count ? files[i] : null,
+                readerOptions ?? ReaderOptions.ForFilePath
             )
         );
     }
 
     public static IWritableArchive<GZipWriterOptions> OpenArchive(
-        IEnumerable<Stream> streams,
+        IReadOnlyList<Stream> streams,
         ReaderOptions? readerOptions = null
     )
     {
         streams.NotNull(nameof(streams));
-        var strms = streams.ToArray();
+        var strms = streams;
         return new GZipArchive(
             new SourceStream(
                 strms[0],
-                i => i < strms.Length ? strms[i] : null,
-                readerOptions ?? new ReaderOptions()
+                i => i < strms.Count ? strms[i] : null,
+                readerOptions ?? ReaderOptions.ForExternalStream
             )
         );
     }
@@ -100,7 +100,7 @@ public static IWritableArchive<GZipWriterOptions> OpenArchive(
         }
 
         return new GZipArchive(
-            new SourceStream(stream, _ => null, readerOptions ?? new ReaderOptions())
+            new SourceStream(stream, _ => null, readerOptions ?? ReaderOptions.ForExternalStream)
         );
     }
 

src/SharpCompress/Archives/IArchiveOpenable.cs

@@ -20,7 +20,7 @@ public static abstract TSync OpenArchive(
     public static abstract TSync OpenArchive(Stream stream, ReaderOptions? readerOptions = null);
 
     public static abstract ValueTask<TASync> OpenAsyncArchive(
-        string path,
+        string filePath,
         ReaderOptions? readerOptions = null,
         CancellationToken cancellationToken = default
     );

src/SharpCompress/Archives/IMultiArchiveOpenable.cs

@@ -12,12 +12,12 @@ public interface IMultiArchiveOpenable<TSync, TASync>
     where TASync : IAsyncArchive
 {
     public static abstract TSync OpenArchive(
-        IEnumerable<FileInfo> fileInfos,
+        IReadOnlyList<FileInfo> fileInfos,
         ReaderOptions? readerOptions = null
     );
 
     public static abstract TSync OpenArchive(
-        IEnumerable<Stream> streams,
+        IReadOnlyList<Stream> streams,
         ReaderOptions? readerOptions = null
     );
 

src/SharpCompress/Archives/IWritableArchiveExtensions.cs

@@ -1,8 +1,6 @@
 using System;
 using System.IO;
-using SharpCompress.Common;
 using SharpCompress.Common.Options;
-using SharpCompress.Writers;
 
 namespace SharpCompress.Archives;
 
@@ -11,20 +9,24 @@ public static class IWritableArchiveExtensions
     extension(IWritableArchive writableArchive)
     {
         public void AddAllFromDirectory(
-            string filePath,
+            string directoryPath,
             string searchPattern = "*.*",
             SearchOption searchOption = SearchOption.AllDirectories
         )
         {
             using (writableArchive.PauseEntryRebuilding())
             {
                 foreach (
-                    var path in Directory.EnumerateFiles(filePath, searchPattern, searchOption)
+                    var filePath in Directory.EnumerateFiles(
+                        directoryPath,
+                        searchPattern,
+                        searchOption
+                    )
                 )
                 {
-                    var fileInfo = new FileInfo(path);
+                    var fileInfo = new FileInfo(filePath);
                     writableArchive.AddEntry(
-                        path.Substring(filePath.Length),
+                        filePath.Substring(directoryPath.Length),
                         fileInfo.OpenRead(),
                         true,
                         fileInfo.Length,

src/SharpCompress/Archives/IWriteableArchiveFactory.cs → src/SharpCompress/Archives/IWritableArchiveFactory.cs

@@ -3,7 +3,7 @@
 namespace SharpCompress.Archives;
 
 /// <summary>
-/// Decorator for <see cref="Factories.Factory"/> used to declare an archive format as able to create writeable archives
+/// Decorator for <see cref="Factories.Factory"/> used to declare an archive format as able to create writable archives.
 /// </summary>
 /// <remarks>
 /// Implemented by:<br/>
@@ -12,7 +12,8 @@ namespace SharpCompress.Archives;
 /// <item><see cref="Factories.ZipFactory"/></item>
 /// <item><see cref="Factories.GZipFactory"/></item>
 /// </list>
-public interface IWriteableArchiveFactory<TOptions> : Factories.IFactory
+/// </remarks>
+public interface IWritableArchiveFactory<TOptions> : Factories.IFactory
     where TOptions : IWriterOptions
 {
     /// <summary>