srctree

return try ctx.sendJSON([0]Repo{});

},

};

 

const head = switch (gitrepo.HEAD(ctx.alloc) catch return error.Unknown) {

.branch => |b| b.sha,

 

return try ctx.sendJSON([1]Repo{.{

.name = req.name,

.updated = "undefined",

}});

}

return try ctx.sendJSON([0]RepoBranches{});

},

};

 

return try ctx.sendJSON([1]RepoBranches{.{

.name = req.name,

return try ctx.sendJSON([0]RepoTags{});

},

};

 

const repotags = gitrepo.tags orelse return try ctx.sendJSON([1]RepoTags{.{

.name = req.name,

 

repo: []const u8,

title: []const u8,

date: DateTime,

 

pub fn toContext(self: Commit, a: Allocator) !Template.Context {

var jctx = Template.Context.init(a);

"<span>{Y-m-d}</span><span>{day}</span><span>{time}</span>",

.{ self.date, self.date, self.date },

));

return jctx;

}

};

const HeatMapArray = [HeatMapSize]u16;

 

pub const HeatMap = struct {

hits: HeatMapArray,

};

 

seen: *std.BufSet,

until: i64,

root_cmt: Git.Commit,

email: []const u8,

) !*HeatMapArray {

var commit = root_cmt;

while (true) {

var commit_time = commit.author.timestamp;

if (DateTime.tzToSec(commit.author.tzstr) catch @as(?i32, 0)) |tzs| {

commit_time += tzs;

hits[day_off] += 1;

}

for (commit.parent[1..], 1..) |par, pidx| {

//defer parent.raze(a);

}

}

error.NoParent => {

return hits;

},

const repo_dir = try std.fs.cwd().openDir(gitdir, .{});

var repo = try Git.Repo.init(repo_dir);

try repo.loadData(a);

 

var lseen = std.BufSet.init(a);

const until = (DateTime.fromEpoch(DateTime.now().timestamp - DAY * 90)).timestamp;

var commit = try repo.headCommit(a);

 

while (true) {

var commit_time = commit.author.timestamp;

if (DateTime.tzToSec(commit.author.tzstr) catch @as(?i32, 0)) |tzs| {

commit_time += tzs;

.name = try Bleach.sanitizeAlloc(a, commit.author.name, .{}),

.title = try Bleach.sanitizeAlloc(a, commit.title, .{}),

.date = DateTime.fromEpoch(commit_time),

.repo = try a.dupe(u8, gitdir[8..]),

});

}

 

error.NoParent => break,

else => |e| return e,

};

const repo_dir = try std.fs.cwd().openDir(gitdir, .{});

var repo = try Git.Repo.init(repo_dir);

try repo.loadData(a);

 

// TODO return empty hits here

const commit = repo.headCommit(a) catch unreachable;

@memset(hits[0..], 0);

}

 

@memset(hits[0..], 0);

}

 

return hits;

 

const rdir = idir.openDir(file.name, .{}) catch continue;

var rpo = Git.Repo.init(rdir) catch continue;

rpo.loadData(ctx.alloc) catch return error.Unknown;

rpo.repo_name = ctx.alloc.dupe(u8, file.name) catch null;

 

if (rpo.tags != null) {

std.sort.heap(Git.Tag, rpo.tags.?, {}, tagSorter);

}

 

const repos_compiled = try ctx.alloc.alloc(Template.Structs.Repolist, repos.items.len);

for (repos.items, repos_compiled) |*repo, *compiled| {

compiled.* = repoBlock(ctx.alloc, repo.repo_name orelse "unknown", repo.*) catch {

return error.Unknown;

};

const dir = cwd.openDir(filename, .{}) catch return error.Unknown;

var repo = Git.Repo.init(dir) catch return error.Unknown;

repo.loadData(ctx.alloc) catch return error.Unknown;

 

if (Repos.hasUpstream(ctx.alloc, repo) catch return error.Unknown) |up| {

var upstream = [_]Template.Context{

try ctx.putContext("OpenGraph", .{ .block = opengraph[0..] });

 

const cmt = repo.headCommit(ctx.alloc) catch return newRepo(ctx);

if (rd.verb) |blb| {

if (std.mem.eql(u8, blb, "blob")) {

return blob(ctx, &repo, files);

} else if (std.mem.eql(u8, blb, "tree")) {

return tree(ctx, &repo, &files);

} else if (std.mem.eql(u8, blb, "")) { // There's a better way to do this

} else return error.InvalidURI;

return tree(ctx, &repo, &files);

}

 

const fname = try aPrint(ctx.alloc, "./repos/{s}", .{rd.name});

const dir = cwd.openDir(fname, .{}) catch return error.Unknown;

var repo = Git.Repo.init(dir) catch return error.Unknown;

 

var actions = repo.getAgent(ctx.alloc);

actions.cwd = cwd.openDir(fname, .{}) catch unreachable;

 

var files = pfiles;

search: while (ctx.uri.next()) |bname| {

if (std.mem.eql(u8, bname, obj.name)) {

blb = obj;

if (obj.isFile()) {

if (ctx.uri.next()) |_| return error.InvalidURI;

break :search;

}

continue :search;

}

} else return error.InvalidURI;

}

 

var formatted: []const u8 = undefined;

if (Highlighting.Language.guessFromFilename(blb.name)) |lang| {

formatted = pre[28..][0 .. pre.len - 38];

} else if (excludedExt(blb.name)) {

formatted = "This file type is currently unsupported";

} else {

}

 

var dom = DOM.new(ctx.alloc);

try ctx.sendPage(&page);

}

 

var files: Git.Tree = pfiles;

if (std.mem.eql(u8, udir, obj.name)) {

return try mkTree(a, repo, uri, files);

}

};

 

// I know... I KNOW!!!

dom = dom.open(HTML.div(null, null));

dom.push(try HTML.aHrefAlloc(a, ch.commit_title, commit_href));

dom.dupe(HTML.span(try aPrint(a, "{}", .{Humanize.unix(ch.timestamp)}), null));

dom = dom.close();

 

fn tree(ctx: *Context, repo: *Git.Repo, files: *Git.Tree) Error!void {

const head = if (repo.head) |h| switch (h) {

.branch => |b| b.name,

else => "unknown",

} else "unknown";

dom.push(HTML.span(c.title[0..@min(c.title.len, 50)], null));

const commit_time = try aPrint(ctx.alloc, " {}", .{Humanize.unix(c.committer.timestamp)});

dom = dom.open(HTML.span(null, &HTML.Attr.class("muted")));

dom.push(HTML.text(commit_time));

dom = dom.close();

dom = dom.close();

 

}

try files.pushPath(ctx.alloc, uri_base);

if (files.changedSet(ctx.alloc, repo)) |changed| {

for (changed) |ch| {

if (std.mem.eql(u8, ch.name, obj.name)) {

dom = try drawFileLine(ctx.alloc, dom, rd.name, uri_base, obj, ch);

const repo_data = dom.done();

 

var readme: ?[]const u8 = null;

if (isReadme(obj.name)) {

readme = try std.fmt.allocPrint(ctx.alloc, "{pretty}", .{readme_html[0]});

break;

}

const dir = cwd.openDir(filename, .{}) catch return error.Unknown;

var repo = Git.Repo.init(dir) catch return error.Unknown;

repo.loadData(ctx.alloc) catch return error.Unknown;

 

std.sort.heap(Git.Tag, repo.tags.?, {}, tagSorter);

 

const tstack = try ctx.alloc.alloc(Template.Structs.Tags, repo.tags.?.len);

 

return error.Abusive;

}

 

// TODO return 404

var fallback: Git.Commit = repo.headCommit(ctx.alloc) catch return error.Unknown;

}

break :cmt fallback;

};

var current: Git.Commit = repo.headCommit(ctx.alloc) catch return error.Unknown;

var acts = repo.getAgent(ctx.alloc);

if (std.mem.indexOf(u8, sha, ".patch")) |tail| {

}

 

var diff = acts.show(sha[0..tail]) catch return error.Unknown;

const dir = cwd.openDir(filename, .{}) catch return error.Unknown;

var repo = Git.Repo.init(dir) catch return error.Unknown;

repo.loadData(ctx.alloc) catch return error.Unknown;

 

if (std.mem.endsWith(u8, sha, ".patch"))

return commitPatch(ctx, sha, repo)

// TODO leaks on err

if (par_cmt == null) continue;

par.* = .{

};

}

 

return .{

.author = Bleach.sanitizeAlloc(a, c.author.name, .{}) catch unreachable,

.parents = try commitCtxParents(a, c, repo),

//.sha = try a.dupe(u8, c.sha),

.title = Bleach.sanitizeAlloc(a, c.title, .{}) catch unreachable,

.body = Bleach.sanitizeAlloc(a, c.body, .{}) catch unreachable,

fn commitContext(a: Allocator, c: Git.Commit, repo: []const u8, comptime _: bool) !Template.Context {

var ctx = Template.Context.init(a);

 

// TODO handle error.NotImplemented

try ctx.putSlice("Msg_title", Bleach.sanitizeAlloc(a, c.title, .{}) catch unreachable);

try ctx.putSlice("Msg", Bleach.sanitizeAlloc(a, c.body, .{}) catch unreachable);

var pctx = Template.Context.init(a);

if (par_cmt == null) continue;

 

par.* = pctx;

}

try ctx.putBlock("Parents", parents);

name: []const u8,

before: ?[]const u8,

elms: []Template.Context,

) ![]Template.Context {

}

 

fn buildListBetween(

left: ?[]const u8,

right: ?[]const u8,

elms: []Template.Context,

) ![]Template.Context {

var current: Git.Commit = repo.headCommit(a) catch return error.Unknown;

if (right) |r| {

std.debug.assert(r.len <= 40);

std.debug.print("unable to build commit history\n", .{});

return elms[0..0];

};

}

std.debug.print("unable to build commit history\n", .{});

return elms[0..0];

};

var count: usize = 0;

for (elms, 1..) |*c, i| {

count = i;

c.* = try commitContext(a, current, name, false);

if (left) |l| {

}

break;

};

}

const dir = cwd.openDir(filename, .{}) catch return error.Unknown;

var repo = Git.Repo.init(dir) catch return error.Unknown;

repo.loadData(ctx.alloc) catch return error.Unknown;

 

const commits_b = try ctx.alloc.alloc(Template.Context, 50);

const cmts_list = try buildList(ctx.alloc, repo, rd.name, commitish, commits_b, &last_sha);

 

return sendCommits(ctx, cmts_list, before_txt);

}

 

 

const zlib = std.compress.zlib;

const hexLower = std.fmt.fmtSliceHexLower;

const bufPrint = std.fmt.bufPrint;

const AnyReader = std.io.AnyReader;

 

pub const Actor = @import("git/actor.zig");

NotAGitRepo,

RefMissing,

CommitMissing,

BlobMissing,

TreeMissing,

ObjectMissing,

OutOfMemory,

NotImplemented,

EndOfStream,

PackCorrupt,

AmbiguousRef,

};

 

};

 

pub const Kind = enum {

blob,

tree,

commit,

};

};

 

pub const Repo = struct {

bare: bool,

dir: std.fs.Dir,

packs: []Pack,

}

 

pub fn loadData(self: *Repo, a: Allocator) !void {

_ = try self.HEAD(a);

}

 

var fb = [_]u8{0} ** 2048;

};

}

 

for (self.packs) |pack| {

if (pack.contains(sha)) |offset| {

}

}

return null;

}

 

for (self.packs) |pack| {

}

}

return null;

}

 

 

return null;

}

 

}

}

 

/// TODO binary search lol

}

 

var dir = try self.dir.openDir("./objects/pack", .{ .iterate = true });

defer dir.close();

var itr = dir.iterate();

while (try itr.next()) |file| {

if (!std.mem.eql(u8, file.name[file.name.len - 4 ..], ".idx")) continue;

 

i += 1;

}

}

 

var list = std.ArrayList(Ref).init(a);

var idir = try self.dir.openDir("refs/heads", .{ .iterate = true });

defer idir.close();

std.debug.assert(read == 40);

try list.append(Ref{ .branch = .{

.name = try a.dupe(u8, file.name),

.repo = self,

} });

}

if (std.mem.indexOf(u8, line, "refs/heads")) |_| {

try list.append(Ref{ .branch = .{

.name = try a.dupe(u8, line[52..]),

.repo = self,

} });

}

if (std.mem.eql(u8, head[0..5], "ref: ")) {

self.head = Ref{

.branch = Branch{

.name = try a.dupe(u8, head[5 .. head.len - 1]),

.repo = self,

},

};

} else if (head.len == 41 and head[40] == '\n') {

self.head = Ref{

};

} else {

std.debug.print("unexpected HEAD {s}\n", .{head});

return self.head.?;

}

 

var tagdir = try self.dir.openDir("refs/tags", .{ .iterate = true });

const pk_refs: ?[]const u8 = self.dir.readFileAlloc(a, "packed-refs", 0xffff) catch |err| switch (err) {

error.FileNotFound => null,

var lines = splitScalar(u8, pkrefs, '\n');

while (lines.next()) |line| {

if (indexOf(u8, line, "refs/tags/") != null) {

index += 1;

}

}

std.debug.print("unexpected tag format for {s}\n", .{fname});

return error.InvalidTagFound;

}

index += 1;

}

if (index != self.tags.?.len) return error.UnexpectedError;

return error.NotImplemented;

}

 

else

}

 

pub fn headCommit(self: *const Repo, a: Allocator) !Commit {

.sha => |s| s,

.branch => |b| try self.ref(b.name["refs/heads/".len..]),

.tag => return error.CommitMissing,

return try self.commit(a, resolv);

}

 

}

 

pub fn description(self: Repo, a: Allocator) ![]u8 {

return error.NoDescription;

}

 

 

// TODO self.tags leaks, badly

}

 

 

pub fn toCommit(self: Branch, a: Allocator) !Commit {

const repo = self.repo orelse return error.NoConnectedRepo;

}

};

 

return .{

.name = "[lightweight tag]",

.sha = sha,

.type = .lightweight,

.tagger = actor orelse unreachable,

.message = "",

};

}

 

test fromSlice {

const blob =

\\object 73751d1c0e9eaeaafbf38a938afd652d98ee9772

\\

;

const t_msg = "Yet another bugfix release for 0.7.0, especially for Samsung phones.\n";

try std.testing.expectEqualStrings("v0.7.3", t.name);

try std.testing.expectEqualStrings("73751d1c0e9eaeaafbf38a938afd652d98ee9772", t.object);

try std.testing.expectEqual(TagType.commit, t.type);

}

 

pub const ChangeSet = struct {

name: []const u8,

// Index into commit slice

commit_title: []const u8,

commit: []const u8,

timestamp: i64,

 

const commit = try a.dupe(u8, msg);

return ChangeSet{

.name = try a.dupe(u8, name),

.commit = commit,

.commit_title = if (std.mem.indexOf(u8, commit, "\n\n")) |i| commit[0..i] else commit,

.timestamp = ts,

};

}

 

}

};

 

test "hex tranlations" {

const one = "370303630b3fc631a0cb3942860fb6f77446e9c1";

try std.testing.expectEqualStrings(&binbuf, "\x37\x03\x03\x63\x0b\x3f\xc6\x31\xa0\xcb\x39\x42\x86\x0f\xb6\xf7\x74\x46\xe9\xc1");

try std.testing.expectEqualStrings(&hexbuf, one);

 

const two = "0000000000000000000000000000000000000000";

 

try std.testing.expectEqualStrings(&binbuf, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00");

try std.testing.expectEqualStrings(&hexbuf, two);

var d = zlib.decompressor(file.reader());

const count = try d.read(&b);

//std.debug.print("{s}\n", .{b[0..count]});

//std.debug.print("{}\n", .{commit});

}

 

test "file" {

var file = try cwd.openFile("./.git/objects/37/0303630b3fc631a0cb3942860fb6f77446e9c1", .{});

var d = zlib.decompressor(file.reader());

const dz = try d.reader().readAllAlloc(a, 0xffff);

//std.debug.print("{}\n", .{commit});

}

 

test "not gpg" {

const blob_invalid_0 =

\\tree 0000bb21f5276fd4f3611a890d12312312415434

\\author Some Dude <some@email.com> 1687200000 -0700

\\committer Some Dude <some@email.com> 1687200000 -0700

\\gpgsig -----BEGIN SSH SIGNATURE-----

\\

\\commit message

;

}

 

test "toParent" {

 

const cwd = try std.fs.cwd().openDir(".", .{});

var repo = try Repo.init(cwd);

try repo.loadData(a);

var commit = try repo.headCommit(a);

 

while (true) {

count += 1;

if (commit.parent[0]) |_| {

commit.raze();

commit = parent;

} else break;

}

try std.testing.expect(count >= 31); // LOL SORRY!

}

 

test "tree decom" {

var a = std.testing.allocator;

 

var d = zlib.decompressor(file.reader());

const count = try d.read(&b);

const buf = try a.dupe(u8, b[0..count]);

}

if (false) std.debug.print("{}\n", .{tree});

}

var cwd = std.fs.cwd();

const dir = try cwd.openDir("repos/hastur", .{});

var repo = try Repo.init(dir);

 

var lol: []u8 = "";

 

for (repo.packs, 0..) |pack, pi| {

}

}

}

}

 

test "pack contains" {

var cwd = std.fs.cwd();

const dir = try cwd.openDir("repos/srctree", .{});

var repo = try Repo.init(dir);

 

 

var found: bool = false;

for (repo.packs) |pack| {

if (found) break;

}

try std.testing.expect(found);

 

found = false;

for (repo.packs) |pack| {

if (found) break;

}

try std.testing.expect(found);

 

try std.testing.expectError(error.AmbiguousRef, err);

 

//var long_obj = try repo.findObj(a, lol);

var cwd = std.fs.cwd();

const dir = try cwd.openDir("repos/hastur", .{});

var repo = try Repo.init(dir);

try repo.loadData(a);

 

var head = try repo.headCommit(a);

defer head.raze();

 

if (false) std.debug.print("{}\n", .{tree});

}

 

const a = std.testing.allocator;

const cwd = try std.fs.cwd().openDir(".", .{});

var repo = try Repo.init(cwd);

 

try repo.loadData(a);

 

const cmt = try repo.headCommit(a);

defer cmt.raze();

if (false) std.debug.print("tree {}\n", .{tree});

if (false) for (tree.objects) |obj| std.debug.print(" {}\n", .{obj});

}

 

const cwd = try std.fs.cwd().openDir(".", .{});

var repo = try Repo.init(cwd);

try repo.loadData(a);

 

const cmtt = try repo.headCommit(a);

defer cmtt.raze();

 

 

var timer = try std.time.Timer.start();

var lap = timer.lap();

const found = try tree.changedSet(a, &repo);

if (false) std.debug.print("found {any}\n", .{found});

a.free(found);

lap = timer.lap();

if (false) std.debug.print("timer {}\n", .{lap});

 

const cwd = try std.fs.cwd().openDir(".", .{});

var repo = try Repo.init(cwd);

 

try repo.loadData(a);

 

const cmtt = try repo.headCommit(a);

defer cmtt.raze();

 

 

if (std.mem.eql(u8, obj.name, "src")) break :blb obj;

} else return error.ExpectedBlobMissing;

if (false) std.debug.print("{any}\n", .{subtree});

if (false) std.debug.print("{any}\n", .{obj});

}

 

}

 

test "commit mk sub tree" {

 

const cwd = try std.fs.cwd().openDir(".", .{});

var repo = try Repo.init(cwd);

 

try repo.loadData(a);

 

const cmtt = try repo.headCommit(a);

defer cmtt.raze();

 

 

if (std.mem.eql(u8, obj.name, "src")) break :blb obj;

} else return error.ExpectedBlobMissing;

if (false) std.debug.print("{any}\n", .{subtree});

if (false) std.debug.print("{any}\n", .{obj});

}

 

if (false) std.debug.print("{any}\n", .{csubtree});

 

if (false) std.debug.print("{any}\n", .{csubtree2});

if (false) for (csubtree2.objects) |obj|

std.debug.print("{any}\n", .{obj});

 

const changed = try csubtree2.changedSet(a, &repo);

if (false) std.debug.print("{s} {s}\n", .{ o.name, c.sha });

}

a.free(changed);

}

 

////var repo = try Repo.init(cwd);

//var timer = try std.time.Timer.start();

 

//try repo.loadPacks(a);

 

const dir = cwd.openDir("repos/hastur", .{}) catch return error.skip;

 

var repo = try Repo.init(dir);

 

try repo.loadData(a);

 

const cmtt = try repo.headCommit(a);

defer cmtt.raze();

 

 

var timer = try std.time.Timer.start();

var lap = timer.lap();

const found = try tree.changedSet(a, &repo);

if (false) std.debug.print("found {any}\n", .{found});

a.free(found);

lap = timer.lap();

if (false) std.debug.print("timer {}\n", .{lap});

var new_repo = try Repo.createNew(a, tdir.dir, "new_repo");

_ = try tdir.dir.openDir("new_repo", .{});

try new_repo.loadData(a);

}

 

test "updated at" {

 

const cwd = try std.fs.cwd().openDir(".", .{});

var repo = try Repo.init(cwd);

 

try repo.loadData(a);

const oldest = try repo.updatedAt(a);

 

 

pub const Blob = @This();

 

mode: [6]u8,

name: []const u8,

 

pub fn isFile(self: Blob) bool {

return self.mode[0] != 48;

return error.NotImplemented;

}

 

if (self.isFile()) return error.NotATree;

}

 

pub fn format(self: Blob, comptime _: []const u8, _: std.fmt.FormatOptions, out: anytype) !void {

try out.print("Blob{{ ", .{});

try if (self.isFile()) out.print("File", .{}) else out.print("Tree", .{});

}

 

const std = @import("std");

const Allocator = std.mem.Allocator;

 

const Git = @import("../git.zig");

const SHA = Git.SHA;

pub const GPGSig = struct {};

 

alloc: ?Allocator = null,

sha: SHA,

tree: SHA,

/// 9 ought to be enough for anyone... or at least robinli ... at least for a while

message: []const u8,

title: []const u8,

body: []const u8,

gpgsig: ?GPGSig,

 

ptr_parent: ?*Commit = null, // TOOO multiple parents

fn header(self: *Commit, data: []const u8) !void {

if (std.mem.indexOf(u8, data, " ")) |brk| {

const name = data[0..brk];

} else if (std.mem.eql(u8, name, "parent")) {

for (&self.parent) |*parr| {

if (parr.* == null) {

return;

}

}

} else if (std.mem.eql(u8, name, "committer")) {

self.committer = try Actor.make(payload);

} else {

return error.UnknownHeader;

}

} else return error.MalformedHeader;

return error.InvalidGpgsig;

}

 

pub fn init(sha: SHA, data: []const u8) !Commit {

var lines = std.mem.split(u8, data, "\n");

var self: Commit = undefined;

// I don't like it either, but... lazy

self.parent = .{ null, null, null, null, null, null, null, null, null };

while (lines.next()) |line| {

if (std.mem.startsWith(u8, line, "gpgsig")) {

self.gpgSig(&lines) catch |e| {

return self;

}

 

}

 

if (idx >= self.parent.len) return error.NoParent;

if (self.parent[idx]) |parent| {

}

return error.NoParent;

}

 

}

 

 

if (itr.rest().len == 0) {

return out;

} else {

defer root = tree;

continue :iter;

}

}

 

/// Warning; this function is probably unsafe

pub fn raze(self: Commit) void {

}

 

pub fn format(

\\commit {s}

\\tree {s}

\\

for (self.parent) |par| {

if (par) |p|

}

try out.print(

\\author {}

 

const zlib = std.compress.zlib;

const PROT = std.posix.PROT;

const MAP_TYPE = std.os.linux.MAP_TYPE;

 

const Git = @import("../git.zig");

const Error = Git.Error;

const Repo = Git.Repo;

 

const SHA = Git.SHA;

 

pub const Pack = @This();

 

pack: []u8,

idx: []u8,

pack_fd: std.fs.File,

fanout: [256]u32,

};

 

invalid = 0,

commit = 1,

tree = 2,

ref_delta = 7,

};

 

};

 

/// assumes name ownership

std.debug.assert(name.len <= 45);

var filename: [50]u8 = undefined;

var pack = Pack{

.pack = try mmap(pfd),

.idx = try mmap(ifd),

.pack_fd = pfd,

}

 

pub fn contains(self: Pack, sha: SHA) ?u32 {

}

 

const count: usize = self.fanOutCount(sha[0]);

if (count == 0) return null;

 

return null;

}

 

if (offset > self.pack.len) return error.WTF;

return self.pack[offset];

}

 

var byte: usize = 0;

byte = reader.readByte() catch unreachable;

.size = byte & 0b1111,

.kind = @enumFromInt((byte & 0b01110000) >> 4),

};

return h;

}

 

}

 

var base: usize = byte & 0x7F;

while (byte >= 0x80) {

base += 1;

base = (base << 7) + (byte & 0x7F);

}

//std.debug.print("varint = {}\n", .{base});

return base;

}

 

const readb: usize = try reader.readByte();

if (readb == 0) {

std.debug.print("INVALID INSTRUCTION 0x00\n", .{});

}

}

 

var buf: [20]u8 = undefined;

 

 

defer a.free(inst);

var inst_fbs = std.io.fixedBufferStream(inst);

// We don't actually need these when zlib works :)

_ = try readVarInt(&inst_reader);

_ = try readVarInt(&inst_reader);

var buffer = std.ArrayList(u8).init(a);

while (true) {

break;

};

}

}

 

// fd pos is offset + 2-ish because of the header read

const srclen = try readVarInt(reader);

 

defer a.free(inst);

var inst_fbs = std.io.fixedBufferStream(inst);

// We don't actually need these when zlib works :)

_ = try readVarInt(&inst_reader);

_ = try readVarInt(&inst_reader);

 

const baseobj_offset = offset - srclen;

 

var buffer = std.ArrayList(u8).init(a);

while (true) {

break;

};

}

}

 

var fbs = std.io.fixedBufferStream(self.pack[offset..]);

const h = parseObjHeader(&reader);

 

},

}

 

self.pack_fd.close();

self.idx_fd.close();

munmap(@alignCast(self.pack));

munmap(@alignCast(self.idx));

}

 

const std = @import("std");

const Allocator = std.mem.Allocator;

const hexLower = std.fmt.fmtSliceHexLower;

 

const Git = @import("../git.zig");

const SHA = Git.SHA;

 

const Tree = @This();

 

path: ?[]const u8 = null,

blob: []const u8,

 

pub fn pushPath(self: *Tree, a: Allocator, path: []const u8) !void {

const spath = self.path orelse {

a.free(spath);

}

 

var self: Tree = .{

.blob = blob,

};

 

var i: usize = 0;

}

var obj_i: usize = 0;

while (std.mem.indexOfScalarPos(u8, blob, i, 0)) |index| {

obj_i += 1;

if (blob[i] == '1') {

obj.name = blob[i + 7 .. index];

} else if (blob[i] == '4') {

obj.name = blob[i + 6 .. index];

} else std.debug.print("panic {s} ", .{blob[i..index]});

 

i = index + 21;

}

}

return self;

}

 

}

 

const cmtt = try repo.headCommit(a);

defer cmtt.raze();

dst.* = src;

}

defer a.free(search_list);

 

var par = try repo.headCommit(a);

 

var old = par;

var oldtree = ptree;

var found: usize = 0;

while (found < search_list.len) {

old = par;

oldtree = ptree;

for (search_list, 0..) |search_ish, i| {

if (search_ish) |search| {

found += 1;

}

}

old.raze();

break;

},

else => |e| return e,

};

for (search_list, 0..) |search_ish, i| {

if (search_ish) |search| {

found += 1;

}

}

old.raze();

break;

},

else => |e| return e,

}

}

old.raze();

}

 

par.raze();

return changed;

}

 

}

 

pub fn format(self: Tree, comptime _: []const u8, _: std.fmt.FormatOptions, out: anytype) !void {

 

const dirname = std.fmt.bufPrint(&name_buffer, "repos/{s}", .{rname}) catch return;

const dir = std.fs.cwd().openDir(dirname, .{}) catch continue;

var repo = Git.Repo.init(dir) catch continue;

repo.loadData(a) catch {

std.debug.print("Warning, unable to load data for repo {s}\n", .{rname});

};