Tarball viewer - chung-leong/zigar GitHub Wiki

const std = @import("std");

pub fn main() !void {
    const path = "/home/cleong/Downloads/zig-0.1.1.tar.gz";
    var file = try std.fs.openFileAbsolute(path, .{});
    defer file.close();
    var read_buffer: [4096]u8 = undefined;
    var reader = file.reader(&read_buffer);
    var decompress_buffer: [std.compress.flate.max_window_len]u8 = undefined;
    var decompressor: std.compress.flate.Decompress = .init(&reader.interface, .gzip, &decompress_buffer);
    var file_name_buffer: [std.fs.max_path_bytes]u8 = undefined;
    var link_name_buffer: [std.fs.max_path_bytes]u8 = undefined;
    var iter: std.tar.Iterator = .init(&decompressor.reader, .{
        .file_name_buffer = &file_name_buffer,
        .link_name_buffer = &link_name_buffer,
    });
    while (try iter.next()) |f| {
        std.debug.print("{s}\n", .{f.name});
    }
}

const std = @import("std");

fn extract(file: std.fs.File) !Iterator {
    return .{ .file = file };
}

const Iterator = struct {
    file: std.fs.File,
    started: bool = false,
    reader: std.fs.File.Reader = undefined,
    read_buffer: [4096]u8 = undefined,
    decompressor: std.compress.flate.Decompress = undefined,
    decompress_buffer: [std.compress.flate.max_window_len]u8 = undefined,
    file_name_buffer: [std.fs.max_path_bytes]u8 = undefined,
    link_name_buffer: [std.fs.max_path_bytes]u8 = undefined,
    tar_iter: std.tar.Iterator = undefined,

    pub fn next(self: *@This(), allocator: std.mem.Allocator) !?File {
        if (!self.started) {
            // create file reader
            self.reader = self.file.reader(&self.read_buffer);
            // create decompressor
            self.decompressor = .init(&self.reader.interface, .gzip, &self.decompress_buffer);
            // obtain the tar iterator
            self.tar_iter = .init(&self.decompressor.reader, .{
                .file_name_buffer = &self.file_name_buffer,
                .link_name_buffer = &self.link_name_buffer,
            });
            self.started = true;
        }
        // get next item
        const f = try self.tar_iter.next() orelse return null;
        const name = try allocator.dupe(u8, f.name);
        errdefer allocator.free(name);
        const link_name = try allocator.dupe(u8, f.link_name);
        errdefer allocator.free(link_name);
        // read file content
        const data = try allocator.alloc(u8, f.size);
        errdefer allocator.free(data);
        var data_writer: std.Io.Writer = .fixed(data);
        try self.tar_iter.streamRemaining(f, &data_writer);
        return .{
            .name = name,
            .link_name = link_name,
            .size = f.size,
            .mode = f.mode,
            .kind = f.kind,
            .data = data,
        };
    }
};

const File = struct {
    name: []const u8,
    link_name: []const u8,
    size: u64,
    mode: u32,
    kind: std.tar.FileKind,
    data: []const u8,
};

pub fn main() !void {
    var gpa: std.heap.DebugAllocator(.{}) = .init;
    defer _ = gpa.detectLeaks();
    const allocator = gpa.allocator();
    const path = "/home/cleong/Downloads/zig-0.1.1.tar.gz";
    var file = try std.fs.openFileAbsolute(path, .{});
    defer file.close();
    var iter = try extract(file);
    while (try iter.next(allocator)) |f| {
        defer {
            allocator.free(f.name);
            allocator.free(f.link_name);
            allocator.free(f.data);
        }
        std.debug.print("{s}\n", .{f.name});
    }
}

const worker = struct {
    pub fn extract(reader: std.io.AnyReader) !Iterator {
        // ...
    }

    const Iterator = struct {
        // ...
    };

    const File = struct {
        // ...
    };
};

const std = @import("std");
const zigar = @import("zigar");

var work_queue: zigar.thread.WorkQueue(thread_ns) = .{};

pub const shutdown = work_queue.promisify(.shutdown);
pub const extract = work_queue.asyncify(worker.extract);

pub const shutdown = work_queue.promisify(.shutdown);

pub fn shutdown(promise: Promise(void)) void {
    return work_queue.deinitAsync(promise);
}

pub const extract = work_queue.asyncify(worker.extract);

pub fn extract(
    reader: std.io.AnyReader,
    generator: zigar.function.GeneratorOf(worker.extract),
) !void {
    try work_queue.push(worker.extract, .{reader}, generator);
}

import react from '@vitejs/plugin-react-swc';
import zigar from 'rollup-plugin-zigar';
import { defineConfig } from 'vite';

// https://vitejs.dev/config/
export default defineConfig({
  plugins: [react(), zigar({ multithreaded: true, optimize: 'ReleaseSmall' })],
  server: {
    host: true,
    headers: {
      'Cross-Origin-Opener-Policy': 'same-origin',
      'Cross-Origin-Embedder-Policy': 'require-corp',
    }
  },
})

            // read file content
            const len: usize = @intCast(f.size);
            const data = try allocator.alloc(u8, len);
            errdefer allocator.free(data);