ZIPFoundation

To add ZIPFoundation as a dependency in your Swift project, add it to the dependencies array of your Package.swift file and include it in your target's dependencies. After updating the file, run swift package resolve to fetch the library.

// swift-tools-version:5.0
import PackageDescription
let package = Package(
    name: "<Your Product Name>",
    dependencies: [
		.package(url: "https://github.com/weichsel/ZIPFoundation.git", .upToNextMajor(from: "0.9.0"))
    ],
    targets: [
        .target(
		name: "<Your Target Name>",
		dependencies: ["ZIPFoundation"]),
    ]
)

$ swift package resolve

All Archive operations accept an optional progress parameter of type Progress.

• Tracking: ZIP Foundation automatically configures totalUnitCount and updates completedUnitCount. You can observe fractionCompleted using Key-Value Observation (KVO).
• Cancellation: Call cancel() on the Progress instance to terminate an operation. This will cause the operation to throw an ArchiveError.cancelledOperation error.

Add ZIPFoundation to your project's Podfile and then run pod install. Ensure you are using use_frameworks! in your Podfile.

source 'https://github.com/CocoaPods/Specs.git'
platform :ios, '10.0'
use_frameworks!
target '<Your Target Name>' do
    pod 'ZIPFoundation', '~> 0.9'
end

$ pod install

You can consume the contents of a ZIP entry without writing them to the file system by using the extract(_:consumer:) method. This method accepts a Consumer closure that is called with chunks of data until the entry is exhausted. You can control the chunk size using the bufferSize parameter.

try archive.extract(entry, consumer: { (data) in
    print(data.count)
})

To remove an entry, you must first obtain a reference to the entry (e.g., via subscripting) and then pass it to the remove(_:) method. The archive must be opened with .create or .update AccessMode.

guard let entry = archive["file.txt"] else {
    return
}
do {
    try archive.remove(entry)
} catch {
    print("Removing entry from ZIP archive failed with error:\(error)")
}

To create a new archive, initialize an Archive object with a file URL that does not yet exist and set the accessMode to .create.

let fileManager = FileManager()
let currentWorkingPath = fileManager.currentDirectoryPath
var archiveURL = URL(fileURLWithPath: currentWorkingPath)
archiveURL.appendPathComponent("newArchive.zip")
let archive = try Archive(url: archiveURL, accessMode: .create)

To add an entry from memory, use the addEntry method with a Provider closure. The closure is called repeatedly until the amount of data provided matches the specified uncompressedSize. The closure receives the current position and the requested size to help manage the state of your data source.

let string = "abcdefghijkl"
guard let data = string.data(using: .utf8) else { return }
try? archive.addEntry(with: "fromMemory.txt", type: .file, uncompressedSize: Int64(data.count), bufferSize: 4, provider: { (position, size) -> Data in
    // This will be called until `data` is exhausted (3x in this case).
    return data.subdata(in: Data.Index(position)..<Int(position)+size)
})

Use FileManager.unzipItem(at:to:) to recursively extract all entries within a ZIP archive to a destination URL. It is recommended to ensure the destination directory exists before unzipping.

let fileManager = FileManager()
let currentWorkingPath = fileManager.currentDirectoryPath
var sourceURL = URL(fileURLWithPath: currentWorkingPath)
sourceURL.appendPathComponent("archive.zip")
var destinationURL = URL(fileURLWithPath: currentWorkingPath)
destinationURL.appendPathComponent("directory")
do {
    try fileManager.createDirectory(at: destinationURL, withIntermediateDirectories: true, attributes: nil)
    try fileManager.unzipItem(at: sourceURL, to: destinationURL)
} catch {
    print("Extraction of ZIP archive failed with error:\(error)")
}