#include <ZipExtractor.h>

Classes
struct	Result

Static Public Member Functions
static Result	ExtractAll (const std::string &zipPath, const std::string &destPath)

static Result	ExtractFile (const std::string &zipPath, const std::string &fileInZip, const std::string &destPath)

static Result	ReadFile (const std::string &zipPath, const std::string &fileInZip, std::string &outContents)

static Result	ListContents (const std::string &zipPath, std::vector< std::string > &outFiles)

static bool	ContainsFile (const std::string &zipPath, const std::string &fileInZip)

static Result	Validate (const std::string &zipPath)

static Result	ValidateSnapshot (const std::string &zipPath)

Detailed Description

ZipExtractor - Cross-platform ZIP file extraction utility

Uses libzip to extract PEBL snapshot packages and validate their contents. Supports reading files without full extraction for validation dialogs.

Definition at line 13 of file ZipExtractor.h.

Member Function Documentation

◆ ContainsFile()

bool ZipExtractor::ContainsFile	(	const std::string &	zipPath,
		const std::string &	fileInZip
	)

static

Check if ZIP contains a specific file

Parameters

zipPath	Path to ZIP file
fileInZip	Path of file to check for

Returns: true if file exists in ZIP, false otherwise

Definition at line 247 of file ZipExtractor.cpp.

                                                           {
    int error = 0;
    zip_t* archive = zip_open(zipPath.c_str(), ZIP_RDONLY, &error);
 
    if (!archive) {
        return false;
    }
 
    zip_int64_t index = zip_name_locate(archive, fileInZip.c_str(), 0);
    zip_close(archive);
 
    return index >= 0;
}

Referenced by ValidateSnapshot().

◆ ExtractAll()

ZipExtractor::Result ZipExtractor::ExtractAll	(	const std::string &	zipPath,
		const std::string &	destPath
	)

static

Extract entire ZIP archive to destination directory Creates destination directory if it doesn't exist

Parameters

zipPath	Path to ZIP file
destPath	Destination directory (will be created)

Returns: Result with success status and error message if failed

Definition at line 18 of file ZipExtractor.cpp.

                                                                         {
    int error = 0;
    zip_t* archive = zip_open(zipPath.c_str(), ZIP_RDONLY, &error);
 
    if (!archive) {
        zip_error_t ziperror;
        zip_error_init_with_code(&ziperror, error);
        std::string msg = "Failed to open ZIP: " + std::string(zip_error_strerror(&ziperror));
        zip_error_fini(&ziperror);
        return Result(false, msg);
    }
 
    // Get number of files in archive
    zip_int64_t numEntries = zip_get_num_entries(archive, 0);
    if (numEntries < 0) {
        zip_close(archive);
        return Result(false, "Failed to get entry count");
    }
 
    // Create destination directory if it doesn't exist
    if (!CreateDirectories(destPath)) {
        zip_close(archive);
        return Result(false, "Failed to create destination directory: " + destPath);
    }
 
    // Extract each file
    for (zip_int64_t i = 0; i < numEntries; i++) {
        // Get file stats
        struct zip_stat st;
        zip_stat_init(&st);
        if (zip_stat_index(archive, i, 0, &st) != 0) {
            zip_close(archive);
            return Result(false, "Failed to stat file at index " + std::to_string(i));
        }
 
        std::string filename = st.name;
 
        // Skip directories (they end with /)
        if (filename.back() == '/') {
            // Create directory
            std::string dirPath = destPath + PATH_SEPARATOR + filename;
            CreateDirectories(dirPath);
            continue;
        }
 
        // Build destination path
        std::string destFile = destPath + PATH_SEPARATOR + filename;
 
        // Create parent directories if needed
        size_t lastSlash = destFile.find_last_of("/\\");
        if (lastSlash != std::string::npos) {
            std::string dirPath = destFile.substr(0, lastSlash);
            if (!CreateDirectories(dirPath)) {
                zip_close(archive);
                return Result(false, "Failed to create directory: " + dirPath);
            }
        }
 
        // Open file in ZIP
        zip_file_t* file = zip_fopen_index(archive, i, 0);
        if (!file) {
            zip_close(archive);
            return Result(false, "Failed to open file in ZIP: " + filename);
        }
 
        // Read file contents
        std::vector<char> buffer(st.size);
        zip_int64_t bytesRead = zip_fread(file, buffer.data(), st.size);
        zip_fclose(file);
 
        if (bytesRead != static_cast<zip_int64_t>(st.size)) {
            zip_close(archive);
            return Result(false, "Failed to read file: " + filename);
        }
 
        // Write to destination
        std::ofstream out(destFile, std::ios::binary);
        if (!out) {
            zip_close(archive);
            return Result(false, "Failed to create file: " + destFile);
        }
        out.write(buffer.data(), bytesRead);
        out.close();
    }
 
    zip_close(archive);
    return Result(true);
}

References PATH_SEPARATOR.

◆ ExtractFile()

ZipExtractor::Result ZipExtractor::ExtractFile	(	const std::string &	zipPath,
		const std::string &	fileInZip,
		const std::string &	destPath
	)

static

Extract single file from ZIP to destination path

Parameters

zipPath	Path to ZIP file
fileInZip	Path of file within ZIP (e.g., "study-info.json")
destPath	Destination file path

Returns: Result with success status and error message if failed

Definition at line 109 of file ZipExtractor.cpp.

                                                                         {
    int error = 0;
    zip_t* archive = zip_open(zipPath.c_str(), ZIP_RDONLY, &error);
 
    if (!archive) {
        return Result(false, "Failed to open ZIP");
    }
 
    // Find file by name
    zip_int64_t index = zip_name_locate(archive, fileInZip.c_str(), 0);
    if (index < 0) {
        zip_close(archive);
        return Result(false, "File not found in ZIP: " + fileInZip);
    }
 
    // Get file stats
    struct zip_stat st;
    zip_stat_init(&st);
    if (zip_stat_index(archive, index, 0, &st) != 0) {
        zip_close(archive);
        return Result(false, "Failed to stat file");
    }
 
    // Open and read file
    zip_file_t* file = zip_fopen_index(archive, index, 0);
    if (!file) {
        zip_close(archive);
        return Result(false, "Failed to open file");
    }
 
    std::vector<char> buffer(st.size);
    zip_int64_t bytesRead = zip_fread(file, buffer.data(), st.size);
    zip_fclose(file);
    zip_close(archive);
 
    if (bytesRead != static_cast<zip_int64_t>(st.size)) {
        return Result(false, "Failed to read file");
    }
 
    // Create parent directories for destination
    size_t lastSlash = destPath.find_last_of("/\\");
    if (lastSlash != std::string::npos) {
        std::string dirPath = destPath.substr(0, lastSlash);
        if (!CreateDirectories(dirPath)) {
            return Result(false, "Failed to create directory: " + dirPath);
        }
    }
 
    // Write to destination
    std::ofstream out(destPath, std::ios::binary);
    if (!out) {
        return Result(false, "Failed to create file: " + destPath);
    }
    out.write(buffer.data(), bytesRead);
    out.close();
 
    return Result(true);
}

◆ ListContents()

ZipExtractor::Result ZipExtractor::ListContents	(	const std::string &	zipPath,
		std::vector< std::string > &	outFiles
	)

static

List all files and directories in ZIP

Parameters

zipPath	Path to ZIP file
outFiles	Vector to receive list of file paths

Returns: Result with success status and error message if failed

Definition at line 219 of file ZipExtractor.cpp.

                                                                               {
    int error = 0;
    zip_t* archive = zip_open(zipPath.c_str(), ZIP_RDONLY, &error);
 
    if (!archive) {
        return Result(false, "Failed to open ZIP");
    }
 
    zip_int64_t numEntries = zip_get_num_entries(archive, 0);
    if (numEntries < 0) {
        zip_close(archive);
        return Result(false, "Failed to get entry count");
    }
 
    outFiles.clear();
    for (zip_int64_t i = 0; i < numEntries; i++) {
        const char* name = zip_get_name(archive, i, 0);
        if (name) {
            outFiles.push_back(name);
        }
    }
 
    zip_close(archive);
    return Result(true);
}

Referenced by ValidateSnapshot().

◆ ReadFile()

ZipExtractor::Result ZipExtractor::ReadFile	(	const std::string &	zipPath,
		const std::string &	fileInZip,
		std::string &	outContents
	)

static

Read file contents from ZIP without extracting Useful for validation and preview before extraction

Parameters

zipPath	Path to ZIP file
fileInZip	Path of file within ZIP
outContents	String to receive file contents

Returns: Result with success status and error message if failed

Definition at line 171 of file ZipExtractor.cpp.

                                                                   {
    int error = 0;
    zip_t* archive = zip_open(zipPath.c_str(), ZIP_RDONLY, &error);
 
    if (!archive) {
        return Result(false, "Failed to open ZIP");
    }
 
    // Find file by name
    zip_int64_t index = zip_name_locate(archive, fileInZip.c_str(), 0);
    if (index < 0) {
        zip_close(archive);
        return Result(false, "File not found in ZIP: " + fileInZip);
    }
 
    // Get file stats
    struct zip_stat st;
    zip_stat_init(&st);
    if (zip_stat_index(archive, index, 0, &st) != 0) {
        zip_close(archive);
        return Result(false, "Failed to stat file");
    }
 
    // Open and read file
    zip_file_t* file = zip_fopen_index(archive, index, 0);
    if (!file) {
        zip_close(archive);
        return Result(false, "Failed to open file");
    }
 
    std::vector<char> buffer(st.size + 1); // +1 for null terminator
    zip_int64_t bytesRead = zip_fread(file, buffer.data(), st.size);
    zip_fclose(file);
    zip_close(archive);
 
    if (bytesRead != static_cast<zip_int64_t>(st.size)) {
        return Result(false, "Failed to read file");
    }
 
    buffer[st.size] = '\0';
    outContents = std::string(buffer.data());
 
    return Result(true);
}

◆ Validate()

ZipExtractor::Result ZipExtractor::Validate ( const std::string & zipPath )

static

Validate ZIP file integrity Checks if file is a valid ZIP and not corrupted

Parameters

zipPath Path to ZIP file

Returns: Result with success status and error message if invalid

Definition at line 263 of file ZipExtractor.cpp.

                                                                  {
    int error = 0;
    zip_t* archive = zip_open(zipPath.c_str(), ZIP_RDONLY | ZIP_CHECKCONS, &error);
 
    if (!archive) {
        zip_error_t ziperror;
        zip_error_init_with_code(&ziperror, error);
        std::string msg = std::string(zip_error_strerror(&ziperror));
        zip_error_fini(&ziperror);
        return Result(false, "Invalid or corrupted ZIP: " + msg);
    }
 
    zip_close(archive);
    return Result(true);
}

Referenced by ValidateSnapshot().

◆ ValidateSnapshot()

ZipExtractor::Result ZipExtractor::ValidateSnapshot ( const std::string & zipPath )

static

Validate that ZIP is a PEBL snapshot package Checks for required files: study-info.json, tests/ directory

Parameters

zipPath Path to ZIP file

Returns: Result with success status and error message if not valid snapshot

Definition at line 280 of file ZipExtractor.cpp.

                                                                          {
    // First validate as ZIP
    Result validZip = Validate(zipPath);
    if (!validZip.success) {
        return validZip;
    }
 
    // Check for required files
    if (!ContainsFile(zipPath, "study-info.json")) {
        return Result(false, "Not a PEBL snapshot: missing study-info.json");
    }
 
    // Check for tests directory (at least one file starting with "tests/")
    std::vector<std::string> files;
    Result listResult = ListContents(zipPath, files);
    if (!listResult.success) {
        return listResult;
    }
 
    bool hasTests = false;
    for (const auto& file : files) {
        if (file.find("tests/") == 0) {
            hasTests = true;
            break;
        }
    }
 
    if (!hasTests) {
        return Result(false, "Not a PEBL snapshot: missing tests/ directory");
    }
 
    return Result(true);
}

References ContainsFile(), ListContents(), ZipExtractor::Result::success, and Validate().

The documentation for this class was generated from the following files:

Classes

Static Public Member Functions

Detailed Description

Member Function Documentation

◆ ContainsFile()

◆ ExtractAll()

◆ ExtractFile()

◆ ListContents()

◆ ReadFile()

◆ Validate()

◆ ValidateSnapshot()