Merge branch 'dev'

Author: tomasf

Package.swift

@@ -9,6 +9,7 @@ let package = Package(
     ],
     targets: [
         .target(name: "Zip", dependencies: ["Miniz"]),
-        .target(name: "Miniz", path: "Sources/miniz", publicHeadersPath: ".")
+        .target(name: "Miniz", path: "Sources/miniz", publicHeadersPath: "."),
+        .testTarget(name: "Tests", dependencies: ["Zip"])
     ]
 )

README.md

@@ -6,7 +6,7 @@ Zip runs on macOS, Windows and Linux.
 
 [![Swift](https://github.com/tomasf/Zip/actions/workflows/swift.yml/badge.svg)](https://github.com/tomasf/Zip/actions/workflows/swift.yml)
 
-![Platforms](https://img.shields.io/badge/Platforms-macOS_|_Linux_|_Windows-cc9529?logo=swift&logoColor=white)
+![Platforms](https://img.shields.io/badge/Platforms-macOS_%7C_Linux_%7C_Windows-47D?logo=swift&logoColor=white)
 
 ## Features
 
@@ -21,26 +21,42 @@ Add the package to your project using Swift Package Manager. In your `Package.sw
 
 ```swift
 dependencies: [
-    .package(url: "https://github.com/tomasf/Zip.git", from: "1.0.0")
+    .package(url: "https://github.com/tomasf/Zip.git", from: "2.0.0")
 ]
 ```
 
 ## Examples
-### Writing to a file-based archive
+### Making a new memory-based archive
 
 ```swift
-import Zip
-
-let archive = try FileZipArchive(forWritingTo: URL(fileURLWithPath: "example.zip"))
-archive.addFile(name: "hello.txt", data: Data("Hello, Zip!".utf8))
-try archive.finalize()
+let archive = ZipArchive()
+try archive.addFile(at: "content.json", data: jsonData)
+let zipData = try archive.finalize()
 ```
 
-### Reading from a memory-based archive
+### Reading from an existing archive in memory
 
 ```swift
-let archive = try MemoryZipArchive(data: zipData)
-if let data = archive.readFile(name: "hello.txt"), let text = String(data: data, encoding: .utf8) {
-    print("File content: \(text)")
+let newArchive = try ZipArchive(data: zipData)
+
+let data = try archive.fileContents(at: "hello.txt")
+if let text = String(data: data, encoding: .utf8) {
+    print("Hello.txt contains: \(text)")
 }
 ```
+
+### Writing a file-based archive
+
+```swift
+let archive = try ZipArchive(url: archiveURL)
+try archive.addFile(at: "hello.txt", data: Data("Hello, Zip!".utf8))
+try archive.finalize() // Writes Zip data to disk
+```
+
+## Contributions
+
+Contributions are welcome! If you have ideas, suggestions, or bug reports, feel free to open an issue on GitHub. Pull requests are also appreciated.
+
+## License
+
+This project is licensed under the MIT License. See the LICENSE file for details.

Sources/Zip/FileZipArchive.swift

@@ -0,0 +1,27 @@
+import Foundation
+import Miniz
+
+internal extension ZipArchive {
+    func get<P: _Pointer>(_ body: (inout mz_zip_archive) -> P?) throws(ZipError) -> P {
+        guard let result = body(&archive) else {
+            throw ZipError(mzError: mz_zip_get_last_error(&archive))
+        }
+        return result
+    }
+
+    @discardableResult
+    func get<I: BinaryInteger>(with success: Success = .positive, _ body: (inout mz_zip_archive) -> I) throws(ZipError) -> I {
+        let result = body(&archive)
+
+        if result < 0 || (success == .positive && result == 0) {
+            throw ZipError(mzError: mz_zip_get_last_error(&archive))
+        }
+
+        return result
+    }
+
+    enum Success {
+        case positive
+        case nonNegative
+    }
+}

Sources/Zip/MemoryZipArchive.swift

@@ -0,0 +1,68 @@
+import Foundation
+import Miniz
+
+public extension ZipArchive<Data> {
+
+    /// Creates a memory-based `ZipArchive` instance from the provided zip archive data.
+    ///
+    /// - Parameter data: The zip archive data used to initialize the archive.
+    /// - Throws: An error if the archive initialization fails.
+    convenience init(data: Data) throws {
+        self.init(archive: .init())
+
+        // mz_zip_writer_init_from_reader_v2 sets m_pWrite to mz_zip_heap_write_func
+        // This means miniz takes ownership of that memory and will free it.
+
+        guard let input = malloc(data.count) else {
+            throw ZipError.allocFailed
+        }
+        data.withUnsafeBytes {
+            guard let pointer = $0.baseAddress else { return }
+            memcpy(input, pointer, data.count)
+        }
+
+        try get {
+            mz_zip_reader_init_mem(&$0, input, data.count, mz_uint32(MZ_ZIP_FLAG_WRITE_ALLOW_READING.rawValue))
+        }
+
+        try get {
+            mz_zip_writer_init_from_reader_v2(&$0, nil, 0)
+        }
+    }
+
+    /// Creates an empty `ZipArchive` instance.
+    ///
+    /// This initializer sets up an empty memory-based archive,
+    /// allowing both reading and writing of entries.
+    convenience init() {
+        self.init(archive: .init())
+
+        try! get {
+            mz_zip_writer_init_heap_v2(&$0, 0, 0, mz_uint32(MZ_ZIP_FLAG_WRITE_ALLOW_READING.rawValue))
+        }
+    }
+
+    /// Finalizes the archive and returns the resulting zip archive data.
+    ///
+    /// This method ensures that all changes made to the archive are finalized and retrieves the
+    /// completed archive data.
+    ///
+    /// - Returns: The finalized zip archive data.
+    /// - Throws: An error if finalization fails or if the resulting data is invalid.
+    func finalize() throws -> Data {
+        var buffer: UnsafeMutableRawPointer?
+        var size: Int = 0
+
+        try get {
+            mz_zip_writer_finalize_heap_archive(&$0, &buffer, &size)
+        }
+
+        guard let buffer else {
+            throw ZipError.invalidData
+        }
+
+        mz_zip_writer_end(&archive)
+        defer { mz_free(buffer) }
+        return Data(bytes: buffer, count: size)
+    }
+}

Sources/Zip/ZipArchive+Get.swift

@@ -0,0 +1,44 @@
+import Foundation
+import Miniz
+
+public extension ZipArchive<URL> {
+    /// Creates a `ZipArchive` instance for a disk-based zip archive at the specified file URL.
+    ///
+    /// If the file does not exist, a new archive is created at the specified location.
+    ///
+    /// - Parameter fileURL: The file URL of the zip archive to be read or created.
+    /// - Throws: An error if the initialization fails, such as if the file cannot be read or written.
+    convenience init(url fileURL: URL) throws {
+        self.init(archive: .init())
+        try fileURL.withUnsafeFileSystemRepresentation { path in
+            do {
+                try get { mz_zip_reader_init_file(&$0, path, mz_uint32(MZ_ZIP_FLAG_WRITE_ALLOW_READING.rawValue)) }
+                try get { mz_zip_writer_init_from_reader_v2(&$0, path, 0) }
+            } catch ZipError.fileOpenFailed {
+                try get { mz_zip_writer_init_file_v2(&$0, path, 0, mz_uint32(MZ_ZIP_FLAG_WRITE_ALLOW_READING.rawValue)) }
+            }
+        }
+    }
+
+    /// Closes the zip archive without writing the central directory to disk.
+    ///
+    /// This method ends the zip archive session without finalizing changes. Use this if you haven't
+    /// made changes and do not need to save the archive.
+    ///
+    /// After calling this method, the archive is no longer usable, and you must not perform additional
+    /// operations on it.
+    func close() {
+        mz_zip_writer_end(&archive)
+    }
+
+    /// Finalizes the zip archive and writes it to disk.
+    ///
+    /// This method ensures all changes are saved and closes the archive. After this method is called,
+    /// no further modifications to the archive can be made.
+    ///
+    /// - Throws: An error if the finalization process fails.
+    func finalize() throws {
+        try get { mz_zip_writer_finalize_archive(&$0) }
+        mz_zip_writer_end(&archive)
+    }
+}