Add IProgress support for compression operations with tests

Co-authored-by: adamhathcock <527620+adamhathcock@users.noreply.github.com>

src/SharpCompress/IO/ProgressReportingStream.cs

@@ -7,7 +7,8 @@ using SharpCompress.Common;
 namespace SharpCompress.IO;
 
 /// <summary>
-/// A stream wrapper that reports progress as data is written.
+/// A stream wrapper that reports progress as data is read from the source.
+/// Used to track compression progress by wrapping the source stream.
 /// </summary>
 internal sealed class ProgressReportingStream : Stream
 {
@@ -15,19 +16,22 @@ internal sealed class ProgressReportingStream : Stream
     private readonly IProgress<CompressionProgress> _progress;
     private readonly string _entryPath;
     private readonly long? _totalBytes;
-    private long _bytesWritten;
+    private long _bytesRead;
+    private readonly bool _leaveOpen;
 
     public ProgressReportingStream(
         Stream baseStream,
         IProgress<CompressionProgress> progress,
         string entryPath,
-        long? totalBytes
+        long? totalBytes,
+        bool leaveOpen = false
     )
     {
         _baseStream = baseStream;
         _progress = progress;
         _entryPath = entryPath;
         _totalBytes = totalBytes;
+        _leaveOpen = leaveOpen;
     }
 
     public override bool CanRead => _baseStream.CanRead;
@@ -46,65 +50,88 @@ internal sealed class ProgressReportingStream : Stream
 
     public override void Flush() => _baseStream.Flush();
 
-    public override int Read(byte[] buffer, int offset, int count) =>
-        _baseStream.Read(buffer, offset, count);
-
-    public override long Seek(long offset, SeekOrigin origin) =>
-        _baseStream.Seek(offset, origin);
-
-    public override void SetLength(long value) => _baseStream.SetLength(value);
-
-    public override void Write(byte[] buffer, int offset, int count)
+    public override int Read(byte[] buffer, int offset, int count)
     {
-        _baseStream.Write(buffer, offset, count);
-        _bytesWritten += count;
-        ReportProgress();
+        var bytesRead = _baseStream.Read(buffer, offset, count);
+        if (bytesRead > 0)
+        {
+            _bytesRead += bytesRead;
+            ReportProgress();
+        }
+        return bytesRead;
     }
 
-    public override void Write(ReadOnlySpan<byte> buffer)
+    public override int Read(Span<byte> buffer)
     {
-        _baseStream.Write(buffer);
-        _bytesWritten += buffer.Length;
-        ReportProgress();
+        var bytesRead = _baseStream.Read(buffer);
+        if (bytesRead > 0)
+        {
+            _bytesRead += bytesRead;
+            ReportProgress();
+        }
+        return bytesRead;
     }
 
-    public override async Task WriteAsync(
+    public override async Task<int> ReadAsync(
         byte[] buffer,
         int offset,
         int count,
         CancellationToken cancellationToken
     )
     {
-        await _baseStream.WriteAsync(buffer, offset, count, cancellationToken).ConfigureAwait(false);
-        _bytesWritten += count;
-        ReportProgress();
+        var bytesRead = await _baseStream
+            .ReadAsync(buffer, offset, count, cancellationToken)
+            .ConfigureAwait(false);
+        if (bytesRead > 0)
+        {
+            _bytesRead += bytesRead;
+            ReportProgress();
+        }
+        return bytesRead;
     }
 
-    public override async ValueTask WriteAsync(
-        ReadOnlyMemory<byte> buffer,
+    public override async ValueTask<int> ReadAsync(
+        Memory<byte> buffer,
         CancellationToken cancellationToken = default
     )
     {
-        await _baseStream.WriteAsync(buffer, cancellationToken).ConfigureAwait(false);
-        _bytesWritten += buffer.Length;
-        ReportProgress();
+        var bytesRead = await _baseStream
+            .ReadAsync(buffer, cancellationToken)
+            .ConfigureAwait(false);
+        if (bytesRead > 0)
+        {
+            _bytesRead += bytesRead;
+            ReportProgress();
+        }
+        return bytesRead;
     }
 
-    public override void WriteByte(byte value)
+    public override int ReadByte()
     {
-        _baseStream.WriteByte(value);
-        _bytesWritten++;
-        ReportProgress();
+        var value = _baseStream.ReadByte();
+        if (value != -1)
+        {
+            _bytesRead++;
+            ReportProgress();
+        }
+        return value;
     }
 
+    public override long Seek(long offset, SeekOrigin origin) => _baseStream.Seek(offset, origin);
+
+    public override void SetLength(long value) => _baseStream.SetLength(value);
+
+    public override void Write(byte[] buffer, int offset, int count) =>
+        _baseStream.Write(buffer, offset, count);
+
     private void ReportProgress()
     {
-        _progress.Report(new CompressionProgress(_entryPath, _bytesWritten, _totalBytes));
+        _progress.Report(new CompressionProgress(_entryPath, _bytesRead, _totalBytes));
     }
 
     protected override void Dispose(bool disposing)
     {
-        if (disposing)
+        if (disposing && !_leaveOpen)
         {
             _baseStream.Dispose();
         }
@@ -113,7 +140,10 @@ internal sealed class ProgressReportingStream : Stream
 
     public override async ValueTask DisposeAsync()
     {
-        await _baseStream.DisposeAsync().ConfigureAwait(false);
+        if (!_leaveOpen)
+        {
+            await _baseStream.DisposeAsync().ConfigureAwait(false);
+        }
         await base.DisposeAsync().ConfigureAwait(false);
     }
 }

src/SharpCompress/Writers/AbstractWriter.cs

@@ -37,7 +37,13 @@ public abstract class AbstractWriter(ArchiveType type, WriterOptions writerOptio
         }
 
         long? totalBytes = source.CanSeek ? source.Length : null;
-        return new ProgressReportingStream(source, WriterOptions.Progress, entryPath, totalBytes);
+        return new ProgressReportingStream(
+            source,
+            WriterOptions.Progress,
+            entryPath,
+            totalBytes,
+            leaveOpen: true
+        );
     }
 
     public abstract void Write(string filename, Stream source, DateTime? modificationTime);

src/SharpCompress/Writers/GZip/GZipWriter.cs

@@ -47,7 +47,8 @@ public sealed class GZipWriter : AbstractWriter
         var stream = (GZipStream)OutputStream;
         stream.FileName = filename;
         stream.LastModified = modificationTime;
-        source.CopyTo(stream);
+        var progressStream = WrapWithProgress(source, filename);
+        progressStream.CopyTo(stream);
         _wroteToStream = true;
     }
 

src/SharpCompress/Writers/Tar/TarWriter.cs

@@ -127,7 +127,8 @@ public class TarWriter : AbstractWriter
         header.Name = NormalizeFilename(filename);
         header.Size = realSize;
         header.Write(OutputStream);
-        size = source.TransferTo(OutputStream, realSize);
+        var progressStream = WrapWithProgress(source, filename);
+        size = progressStream.TransferTo(OutputStream, realSize);
         PadTo512(size.Value);
     }
 
@@ -159,7 +160,8 @@ public class TarWriter : AbstractWriter
         header.Name = NormalizeFilename(filename);
         header.Size = realSize;
         header.Write(OutputStream);
-        var written = await source
+        var progressStream = WrapWithProgress(source, filename);
+        var written = await progressStream
             .TransferToAsync(OutputStream, realSize, cancellationToken)
             .ConfigureAwait(false);
         PadTo512(written);

src/SharpCompress/Writers/Zip/ZipWriter.cs

@@ -85,7 +85,8 @@ public class ZipWriter : AbstractWriter
     public void Write(string entryPath, Stream source, ZipWriterEntryOptions zipWriterEntryOptions)
     {
         using var output = WriteToStream(entryPath, zipWriterEntryOptions);
-        source.CopyTo(output);
+        var progressStream = WrapWithProgress(source, entryPath);
+        progressStream.CopyTo(output);
     }
 
     public Stream WriteToStream(string entryPath, ZipWriterEntryOptions options)