Skip to content

Commit ca5a857

Browse files
ITaluoneITaluone
committed
Cleanup with Rider "Full Clean-up"
1 parent 9482990 commit ca5a857

1 file changed

Lines changed: 98 additions & 61 deletions

File tree

‎src/Fallout.Utilities.IO.Compression/CompressionExtensions.cs‎

Lines changed: 98 additions & 61 deletions
Original file line numberDiff line numberDiff line change
@@ -3,65 +3,101 @@
33
using System.IO;
44
using System.IO.Compression;
55
using System.Linq;
6+
using Fallout.Common.Utilities.Collections;
67
using ICSharpCode.SharpZipLib.BZip2;
78
using ICSharpCode.SharpZipLib.GZip;
89
using ICSharpCode.SharpZipLib.Tar;
910
using ICSharpCode.SharpZipLib.Zip;
1011
using SharpCompress.Common;
1112
using SharpCompress.Readers;
12-
using Fallout.Common.Utilities.Collections;
13+
using ZipFile = ICSharpCode.SharpZipLib.Zip.ZipFile;
1314

1415
namespace Fallout.Common.IO;
1516

1617
public static class CompressionExtensions
1718
{
1819
/// <summary>
19-
/// Compresses <paramref name="directory"/> into <paramref name="archiveFile"/>, choosing the compression format based on the archive file's extension.
20+
/// Compresses <paramref name="directory" /> into <paramref name="archiveFile" />, choosing the compression format based on the
21+
/// archive file's extension.
2022
/// </summary>
2123
/// <param name="directory">The directory whose contents should be compressed.</param>
22-
/// <param name="archiveFile">The archive file to create. Its extension determines the compression format (e.g. <c>.zip</c>, <c>.tar.gz</c>, <c>.tar.bz2</c>).</param>
23-
/// <param name="filter">An optional predicate used to filter which files are included in the archive. If <c>null</c>, all files are included.</param>
24+
/// <param name="archiveFile">
25+
/// The archive file to create. Its extension determines the compression format (e.g. <c>.zip</c>,
26+
/// <c>.tar.gz</c>, <c>.tar.bz2</c>).
27+
/// </param>
28+
/// <param name="filter">
29+
/// An optional predicate used to filter which files are included in the archive. If <c>null</c>, all files are
30+
/// included.
31+
/// </param>
2432
public static void CompressTo(this AbsolutePath directory, AbsolutePath archiveFile, Func<AbsolutePath, bool> filter = null)
2533
{
2634
if (archiveFile.HasExtension(".zip"))
35+
{
2736
directory.ZipTo(archiveFile, filter);
37+
}
2838
else if (archiveFile.HasExtension(".tar.gz", ".tgz"))
39+
{
2940
directory.TarGZipTo(archiveFile, filter);
41+
}
3042
else if (archiveFile.HasExtension(".tar.bz2", ".tbz2", ".tbz"))
43+
{
3144
directory.TarBZip2To(archiveFile, filter);
45+
}
3246
else if (archiveFile.HasExtension(".tar.xz", ".txz"))
33-
Assert.Fail($"Compressing a .tar.xz archive currently not supported. Archive file: '{Path.GetFileName(archiveFile)}'");
47+
{
48+
Assert.Fail(
49+
$"Compressing a .tar.xz archive currently not supported. Archive file: '{Path.GetFileName(archiveFile)}'");
50+
}
3451
else
52+
{
3553
Assert.Fail($"Unknown archive extension for archive '{Path.GetFileName(archiveFile)}'");
54+
}
3655
}
3756

3857
/// <summary>
39-
/// Uncompresses <paramref name="archiveFile"/> into <paramref name="directory"/>, choosing the decompression format based on the archive file's extension.
58+
/// Uncompresses <paramref name="archiveFile" /> into <paramref name="directory" />, choosing the decompression format based on
59+
/// the archive file's extension.
4060
/// </summary>
41-
/// <param name="archiveFile">The archive file to extract. Its extension determines the decompression format (e.g. <c>.zip</c>, <c>.tar.gz</c>, <c>.tar.bz2</c>, <c>.tar.xz</c>).</param>
61+
/// <param name="archiveFile">
62+
/// The archive file to extract. Its extension determines the decompression format (e.g. <c>.zip</c>,
63+
/// <c>.tar.gz</c>, <c>.tar.bz2</c>, <c>.tar.xz</c>).
64+
/// </param>
4265
/// <param name="directory">The directory into which the archive's contents are extracted.</param>
4366
public static void UncompressTo(this AbsolutePath archiveFile, AbsolutePath directory)
4467
{
4568
if (archiveFile.HasExtension(".zip"))
69+
{
4670
archiveFile.UnZipTo(directory);
71+
}
4772
else if (archiveFile.HasExtension(".tar.gz", ".tgz"))
73+
{
4874
archiveFile.UnTarGZipTo(directory);
75+
}
4976
else if (archiveFile.HasExtension(".tar.bz2", ".tbz2", ".tbz"))
77+
{
5078
archiveFile.UnTarBZip2To(directory);
79+
}
5180
else if (archiveFile.HasExtension(".tar.xz", ".txz"))
81+
{
5282
archiveFile.UnTarXzTo(directory);
83+
}
5384
else
85+
{
5486
Assert.Fail($"Unknown archive extension for archive '{Path.GetFileName(archiveFile)}'");
87+
}
5588
}
5689

5790
/// <summary>
58-
/// Compresses <paramref name="directory"/> into a ZIP archive at <paramref name="archiveFile"/>.
91+
/// Compresses <paramref name="directory" /> into a ZIP archive at <paramref name="archiveFile" />.
5992
/// </summary>
6093
/// <param name="directory">The directory whose contents should be added to the ZIP archive.</param>
6194
/// <param name="archiveFile">The ZIP archive file to create.</param>
62-
/// <param name="filter">An optional predicate used to filter which files are included in the archive. If <c>null</c>, all files are included.</param>
95+
/// <param name="filter">
96+
/// An optional predicate used to filter which files are included in the archive. If <c>null</c>, all files are
97+
/// included.
98+
/// </param>
6399
/// <param name="compressionLevel">The compression level to use for the archive entries.</param>
64-
/// <param name="fileMode">The <see cref="FileMode"/> used to open the archive file.</param>
100+
/// <param name="fileMode">The <see cref="FileMode" /> used to open the archive file.</param>
65101
public static void ZipTo(
66102
this AbsolutePath directory,
67103
AbsolutePath archiveFile,
@@ -72,143 +108,142 @@ public static void ZipTo(
72108
archiveFile.Parent.CreateDirectory();
73109

74110
filter ??= _ => true;
75-
var files = directory.GetFiles(depth: int.MaxValue).Where(filter).ToList();
111+
List<AbsolutePath> files = directory.GetFiles(depth: int.MaxValue).Where(filter).ToList();
76112

77-
using var fileStream = File.Open(archiveFile, fileMode, FileAccess.ReadWrite);
78-
using var zipArchive = new ZipArchive(fileStream, ZipArchiveMode.Create);
113+
using FileStream fileStream = File.Open(archiveFile, fileMode, FileAccess.ReadWrite);
114+
using ZipArchive zipArchive = new(fileStream, ZipArchiveMode.Create);
79115

80116
void AddFile(AbsolutePath file)
81117
{
82-
var relativePath = directory.GetRelativePathTo(file);
83-
var entryName = ZipEntry.CleanName(relativePath);
118+
RelativePath relativePath = directory.GetRelativePathTo(file);
119+
string entryName = ZipEntry.CleanName(relativePath);
84120
zipArchive.CreateEntryFromFile(file, entryName, compressionLevel);
85121
}
86122

87123
files.ForEach(AddFile);
88124
}
89125

90126
/// <summary>
91-
/// Extracts the contents of a ZIP archive at <paramref name="archiveFile"/> into <paramref name="directory"/>.
127+
/// Extracts the contents of a ZIP archive at <paramref name="archiveFile" /> into <paramref name="directory" />.
92128
/// </summary>
93129
/// <param name="archiveFile">The ZIP archive file to extract.</param>
94130
/// <param name="directory">The directory into which the archive's contents are extracted.</param>
95131
public static void UnZipTo(this AbsolutePath archiveFile, AbsolutePath directory)
96132
{
97-
using var fileStream = File.OpenRead(archiveFile);
98-
using var zipFile = new ICSharpCode.SharpZipLib.Zip.ZipFile(fileStream);
133+
using FileStream fileStream = File.OpenRead(archiveFile);
134+
using ZipFile zipFile = new(fileStream);
99135

100-
var entries = zipFile.Cast<ZipEntry>().Where(x => !x.IsDirectory);
136+
IEnumerable<ZipEntry> entries = zipFile.Cast<ZipEntry>().Where(x => !x.IsDirectory);
101137

102138
void HandleEntry(ZipEntry entry)
103139
{
104-
var file = directory / entry.Name;
140+
AbsolutePath file = directory / entry.Name;
105141
Directory.CreateDirectory(file.Parent.NotNull());
106142

107-
using var entryStream = zipFile.GetInputStream(entry);
108-
using var outputStream = File.Open(file, FileMode.Create);
143+
using Stream entryStream = zipFile.GetInputStream(entry);
144+
using FileStream outputStream = File.Open(file, FileMode.Create);
109145
entryStream.CopyTo(outputStream);
110146
}
111147

112148
entries.ForEach(HandleEntry);
113149
}
114150

115151
/// <summary>
116-
/// Compresses the given <paramref name="files"/> into a gzip-compressed tar archive at <paramref name="archiveFile"/>.
152+
/// Compresses the given <paramref name="files" /> into a gzip-compressed tar archive at <paramref name="archiveFile" />.
117153
/// </summary>
118154
/// <param name="baseDirectory">The base directory used to compute the relative entry names of the archived files.</param>
119155
/// <param name="archiveFile">The tar.gz archive file to create.</param>
120156
/// <param name="files">The files to add to the archive.</param>
121-
/// <param name="fileMode">The <see cref="FileMode"/> used to open the archive file.</param>
157+
/// <param name="fileMode">The <see cref="FileMode" /> used to open the archive file.</param>
122158
public static void TarGZipTo(
123159
this AbsolutePath baseDirectory,
124160
AbsolutePath archiveFile,
125161
IEnumerable<AbsolutePath> files,
126-
FileMode fileMode = FileMode.CreateNew)
127-
{
162+
FileMode fileMode = FileMode.CreateNew) =>
128163
CompressTar(baseDirectory, archiveFile, files.ToList(), fileMode, x => new GZipOutputStream(x));
129-
}
130164

131165
/// <summary>
132-
/// Compresses <paramref name="directory"/> into a gzip-compressed tar archive at <paramref name="archiveFile"/>.
166+
/// Compresses <paramref name="directory" /> into a gzip-compressed tar archive at <paramref name="archiveFile" />.
133167
/// </summary>
134168
/// <param name="directory">The directory whose contents should be added to the archive.</param>
135169
/// <param name="archiveFile">The tar.gz archive file to create.</param>
136-
/// <param name="filter">An optional predicate used to filter which files are included in the archive. If <c>null</c>, all files are included.</param>
137-
/// <param name="fileMode">The <see cref="FileMode"/> used to open the archive file.</param>
170+
/// <param name="filter">
171+
/// An optional predicate used to filter which files are included in the archive. If <c>null</c>, all files are
172+
/// included.
173+
/// </param>
174+
/// <param name="fileMode">The <see cref="FileMode" /> used to open the archive file.</param>
138175
public static void TarGZipTo(
139176
this AbsolutePath directory,
140177
AbsolutePath archiveFile,
141178
Func<AbsolutePath, bool> filter = null,
142179
FileMode fileMode = FileMode.CreateNew)
143180
{
144181
filter ??= _ => true;
145-
var files = directory.GetFiles(depth: int.MaxValue).Where(filter);
182+
IEnumerable<AbsolutePath> files = directory.GetFiles(depth: int.MaxValue).Where(filter);
146183
directory.TarGZipTo(archiveFile, files, fileMode);
147184
}
148185

149186
/// <summary>
150-
/// Compresses the given <paramref name="files"/> into a bzip2-compressed tar archive at <paramref name="archiveFile"/>.
187+
/// Compresses the given <paramref name="files" /> into a bzip2-compressed tar archive at <paramref name="archiveFile" />.
151188
/// </summary>
152189
/// <param name="directory">The base directory used to compute the relative entry names of the archived files.</param>
153190
/// <param name="archiveFile">The tar.bz2 archive file to create.</param>
154191
/// <param name="files">The files to add to the archive.</param>
155-
/// <param name="fileMode">The <see cref="FileMode"/> used to open the archive file.</param>
192+
/// <param name="fileMode">The <see cref="FileMode" /> used to open the archive file.</param>
156193
public static void TarBZip2To(
157194
this AbsolutePath directory,
158195
AbsolutePath archiveFile,
159196
IEnumerable<AbsolutePath> files,
160-
FileMode fileMode = FileMode.CreateNew)
161-
{
197+
FileMode fileMode = FileMode.CreateNew) =>
162198
CompressTar(directory, archiveFile, files.ToList(), fileMode, x => new BZip2OutputStream(x));
163-
}
164199

165200
/// <summary>
166-
/// Compresses <paramref name="directory"/> into a bzip2-compressed tar archive at <paramref name="archiveFile"/>.
201+
/// Compresses <paramref name="directory" /> into a bzip2-compressed tar archive at <paramref name="archiveFile" />.
167202
/// </summary>
168203
/// <param name="directory">The directory whose contents should be added to the archive.</param>
169204
/// <param name="archiveFile">The tar.bz2 archive file to create.</param>
170-
/// <param name="filter">An optional predicate used to filter which files are included in the archive. If <c>null</c>, all files are included.</param>
171-
/// <param name="fileMode">The <see cref="FileMode"/> used to open the archive file.</param>
205+
/// <param name="filter">
206+
/// An optional predicate used to filter which files are included in the archive. If <c>null</c>, all files are
207+
/// included.
208+
/// </param>
209+
/// <param name="fileMode">The <see cref="FileMode" /> used to open the archive file.</param>
172210
public static void TarBZip2To(
173211
this AbsolutePath directory,
174212
AbsolutePath archiveFile,
175213
Func<AbsolutePath, bool> filter = null,
176214
FileMode fileMode = FileMode.CreateNew)
177215
{
178216
filter ??= _ => true;
179-
var files = directory.GetFiles(depth: int.MaxValue).Where(filter);
217+
IEnumerable<AbsolutePath> files = directory.GetFiles(depth: int.MaxValue).Where(filter);
180218
directory.TarBZip2To(archiveFile, files, fileMode);
181219
}
182220

183221
/// <summary>
184-
/// Extracts the contents of a gzip-compressed tar archive at <paramref name="archiveFile"/> into <paramref name="directory"/>.
222+
/// Extracts the contents of a gzip-compressed tar archive at <paramref name="archiveFile" /> into <paramref name="directory" />.
185223
/// </summary>
186224
/// <param name="archiveFile">The tar.gz archive file to extract.</param>
187225
/// <param name="directory">The directory into which the archive's contents are extracted.</param>
188-
public static void UnTarGZipTo(this AbsolutePath archiveFile, AbsolutePath directory)
189-
{
226+
public static void UnTarGZipTo(this AbsolutePath archiveFile, AbsolutePath directory) =>
190227
UncompressTar(archiveFile, directory, x => new GZipInputStream(x));
191-
}
192228

193229
/// <summary>
194-
/// Extracts the contents of a bzip2-compressed tar archive at <paramref name="archiveFile"/> into <paramref name="directory"/>.
230+
/// Extracts the contents of a bzip2-compressed tar archive at <paramref name="archiveFile" /> into <paramref name="directory" />
231+
/// .
195232
/// </summary>
196233
/// <param name="archiveFile">The tar.bz2 archive file to extract.</param>
197234
/// <param name="directory">The directory into which the archive's contents are extracted.</param>
198-
public static void UnTarBZip2To(this AbsolutePath archiveFile, AbsolutePath directory)
199-
{
235+
public static void UnTarBZip2To(this AbsolutePath archiveFile, AbsolutePath directory) =>
200236
UncompressTar(archiveFile, directory, x => new BZip2InputStream(x));
201-
}
202237

203238
/// <summary>
204-
/// Extracts the contents of an xz-compressed tar archive at <paramref name="archive"/> into <paramref name="directory"/>.
239+
/// Extracts the contents of an xz-compressed tar archive at <paramref name="archive" /> into <paramref name="directory" />.
205240
/// </summary>
206241
/// <param name="archive">The tar.xz archive file to extract.</param>
207242
/// <param name="directory">The directory into which the archive's contents are extracted.</param>
208243
public static void UnTarXzTo(this AbsolutePath archive, AbsolutePath directory)
209244
{
210245
using Stream stream = File.OpenRead(archive);
211-
using var reader = ReaderFactory.OpenReader(stream);
246+
using IReader reader = ReaderFactory.OpenReader(stream);
212247

213248
while (reader.MoveToNextEntry())
214249
{
@@ -226,12 +261,13 @@ public static void UnTarXzTo(this AbsolutePath archive, AbsolutePath directory)
226261
}
227262

228263
/// <summary>
229-
/// Compresses the given <paramref name="files"/> into a tar archive at <paramref name="archiveFile"/>, wrapping the underlying file stream with the compression stream produced by <paramref name="outputStreamFactory"/>.
264+
/// Compresses the given <paramref name="files" /> into a tar archive at <paramref name="archiveFile" />, wrapping the underlying
265+
/// file stream with the compression stream produced by <paramref name="outputStreamFactory" />.
230266
/// </summary>
231267
/// <param name="baseDirectory">The base directory used to compute the relative entry names of the archived files.</param>
232268
/// <param name="archiveFile">The archive file to create.</param>
233269
/// <param name="files">The files to add to the archive.</param>
234-
/// <param name="fileMode">The <see cref="FileMode"/> used to open the archive file.</param>
270+
/// <param name="fileMode">The <see cref="FileMode" /> used to open the archive file.</param>
235271
/// <param name="outputStreamFactory">A factory that wraps the raw archive file stream with the desired compression stream.</param>
236272
private static void CompressTar(
237273
AbsolutePath baseDirectory,
@@ -242,32 +278,33 @@ private static void CompressTar(
242278
{
243279
archiveFile.Parent.CreateDirectory();
244280

245-
using var fileStream = File.Open(archiveFile, fileMode, FileAccess.ReadWrite);
246-
using var outputStream = outputStreamFactory(fileStream);
247-
using var tarArchive = TarArchive.CreateOutputTarArchive(outputStream);
281+
using FileStream fileStream = File.Open(archiveFile, fileMode, FileAccess.ReadWrite);
282+
using Stream outputStream = outputStreamFactory(fileStream);
283+
using TarArchive tarArchive = TarArchive.CreateOutputTarArchive(outputStream);
248284

249285
void AddFile(AbsolutePath file)
250286
{
251-
var entry = TarEntry.CreateEntryFromFile(file);
287+
TarEntry entry = TarEntry.CreateEntryFromFile(file);
252288
entry.Name = baseDirectory.GetUnixRelativePathTo(file);
253289

254-
tarArchive.WriteEntry(entry, recurse: false);
290+
tarArchive.WriteEntry(entry, false);
255291
}
256292

257293
files.ForEach(AddFile);
258294
}
259295

260296
/// <summary>
261-
/// Extracts the contents of a tar archive at <paramref name="archiveFile"/> into <paramref name="directory"/>, wrapping the underlying file stream with the decompression stream produced by <paramref name="inputStreamFactory"/>.
297+
/// Extracts the contents of a tar archive at <paramref name="archiveFile" /> into <paramref name="directory" />, wrapping the
298+
/// underlying file stream with the decompression stream produced by <paramref name="inputStreamFactory" />.
262299
/// </summary>
263300
/// <param name="archiveFile">The archive file to extract.</param>
264301
/// <param name="directory">The directory into which the archive's contents are extracted.</param>
265302
/// <param name="inputStreamFactory">A factory that wraps the raw archive file stream with the desired decompression stream.</param>
266303
private static void UncompressTar(AbsolutePath archiveFile, AbsolutePath directory, Func<Stream, Stream> inputStreamFactory)
267304
{
268-
using var fileStream = File.OpenRead(archiveFile);
269-
using var inputStream = inputStreamFactory(fileStream);
270-
using var tarArchive = TarArchive.CreateInputTarArchive(inputStream, nameEncoding: null);
305+
using FileStream fileStream = File.OpenRead(archiveFile);
306+
using Stream inputStream = inputStreamFactory(fileStream);
307+
using TarArchive tarArchive = TarArchive.CreateInputTarArchive(inputStream, null);
271308

272309
directory.CreateDirectory();
273310

0 commit comments

Comments
 (0)