srctree

const Comment = Types.Comment;

switch (msg) {

.date = try allocPrint(ctx.alloc, "{}", .{Humanize.unix(cmt.updated)}),

const Comment = Types.Comment;

const c = Comment.new(username, msg.value) catch unreachable;

_ = delta.loadThread(ctx.alloc) catch unreachable;

delta.addComment(ctx.alloc, c) catch unreachable;

switch (msg) {

.date = try allocPrint(ctx.alloc, "{}", .{Humanize.unix(comment.updated)}),

.direct_reply = .{ .uri = try allocPrint(ctx.alloc, "{}/direct_reply/{x}", .{ index, fmtSliceHexLower(comment.hash[0..]) }) },

const Comment = Types.Comment;

_ = delta.loadThread(ctx.alloc) catch unreachable;

const c = Comment.new(username, msg.value) catch unreachable;

delta.addComment(ctx.alloc, c) catch {};

switch (msg) {

.date = try allocPrint(ctx.alloc, "{}", .{Humanize.unix(comment.updated)}),

.direct_reply = .{ .uri = try allocPrint(ctx.alloc, "{}/direct_reply/{x}", .{ index, fmtSliceHexLower(comment.hash[0..]) }) },

pub const Comment = @import("types/comment.zig");

Comment,

const std = @import("std");

const builtin = @import("builtin");

const Allocator = std.mem.Allocator;

const endian = builtin.cpu.arch.endian();

const sha256 = std.crypto.hash.sha2.Sha256;

const allocPrint = std.fmt.allocPrint;

const bufPrint = std.fmt.bufPrint;

const AnyWriter = std.io.AnyWriter;

const fmtSliceHexLower = std.fmt.fmtSliceHexLower;

 

const Humanize = @import("../humanize.zig");

const Types = @import("../types.zig");

const Bleach = @import("../bleach.zig");

const Template = @import("../template.zig");

 

pub const Comment = @This();

const CMMT_VERSION: usize = 0;

pub const TYPE_PREFIX = "messages";

var datad: Types.Storage = undefined;

 

state: usize = 0,

tz: i32 = 0,

created: i64 = 0,

updated: i64 = 0,

target: Targets = .{ .nos = {} },

hash: [sha256.digest_length]u8 = undefined,

 

author: []const u8,

message: []const u8,

replies: ?usize = null,

 

pub fn init(_: []const u8) !void {}

pub fn initType(stor: Types.Storage) !void {

datad = stor;

}

 

pub fn raze() void {

datad.close();

}

 

pub fn charToKind(c: u8) TargetKind {

return switch (c) {

'C' => .commit,

'D' => .diff,

'I' => .issue,

'r' => .reply,

else => .nos,

};

}

 

fn readVersioned(a: Allocator, file: std.fs.File, hash: []const u8) !Comment {

var reader = file.reader();

const ver: usize = try reader.readInt(usize, endian);

return switch (ver) {

0 => return Comment{

.state = try reader.readInt(usize, endian),

.created = try reader.readInt(i64, endian),

.updated = try reader.readInt(i64, endian),

.tz = try reader.readInt(i32, endian),

.hash = hash[0..sha256.digest_length].*,

.target = switch (try reader.readInt(u8, endian)) {

0 => .{ .diff = try reader.readInt(usize, endian) },

'D' => .{ .diff = try reader.readInt(usize, endian) },

'I' => .{ .issue = try reader.readInt(usize, endian) },

'r' => .{ .reply = .{

.to = switch (try reader.readInt(u8, endian)) {

'c' => .{ .comment = try reader.readInt(usize, endian) },

'C' => .{ .commit = .{

.number = try reader.readInt(usize, endian),

.meta = try reader.readInt(usize, endian),

} },

'd' => .{ .diff = .{

.number = try reader.readInt(usize, endian),

.file = try reader.readInt(usize, endian),

.revision = try reader.readInt(usize, endian),

} },

else => return error.CommentCorrupted,

},

} },

else => return error.CommentCorrupted,

},

.author = try reader.readUntilDelimiterAlloc(a, 0, 0xFFFF),

.message = try reader.readAllAlloc(a, 0xFFFF),

.replies = reader.readInt(usize, endian) catch null,

},

else => error.UnsupportedVersion,

};

}

 

pub const TargetKind = enum(u7) {

nos = 0,

commit = 'C',

diff = 'D',

issue = 'I',

reply = 'r',

};

 

/// Comments can be directly attached to a commit, or a diff, but are

/// replies when referencing a specific line/target within them.

const ReplyKinds = enum(u7) {

nothing = 0,

comment = 'c',

commit = 'C',

diff = 'd',

};

 

pub const Reply = struct {

to: union(ReplyKinds) {

nothing: void,

comment: usize,

commit: CommitLine,

diff: DiffLine,

},

};

 

pub const CommitLine = struct {

number: usize,

meta: usize,

};

 

pub const DiffLine = struct {

number: usize,

file: usize,

revision: usize, // surely no one will ever need to use more than a u16

// number of revisions... right? I'll just shrink this... WCGW?!

};

 

pub const Targets = union(TargetKind) {

nos: void,

commit: [20]u8,

diff: usize,

issue: usize,

reply: Reply,

};

 

pub fn toHash(self: *Comment) *const [sha256.digest_length]u8 {

var h = sha256.init(.{});

h.update(self.author);

h.update(self.message);

h.update(std.mem.asBytes(&self.created));

h.update(std.mem.asBytes(&self.updated));

h.final(&self.hash);

return &self.hash;

}

 

pub fn writeNew(self: *Comment, d: std.fs.Dir) !void {

var buf: [2048]u8 = undefined;

_ = self.toHash();

const filename = try bufPrint(&buf, "{x}.comment", .{fmtSliceHexLower(&self.hash)});

var file = try d.createFile(filename, .{});

defer file.close();

const w = file.writer().any();

try self.writeOut(w);

}

 

pub fn commit(self: Comment) !void {

var file = try openFile(self.hash[0..]);

defer file.close();

const writer = file.writer().any();

try self.writeOut(writer);

}

 

fn writeOut(self: Comment, w: AnyWriter) !void {

try w.writeInt(usize, CMMT_VERSION, endian);

try w.writeInt(usize, self.state, endian);

try w.writeInt(i64, self.created, endian);

try w.writeInt(i64, self.updated, endian);

try w.writeInt(i32, self.tz, endian);

try w.writeInt(u8, @intFromEnum(self.target), endian);

switch (self.target) {

.nos => try w.writeInt(usize, 0, endian),

.commit => |c| try w.writeAll(&c),

.diff => try w.writeInt(usize, self.target.diff, endian),

.issue => try w.writeInt(usize, self.target.issue, endian),

.reply => unreachable,

}

 

try w.writeAll(self.author);

try w.writeAll("\x00");

try w.writeAll(self.message);

if (self.replies) |r| try w.writeInt(usize, r, endian);

}

 

pub fn readFile(a: std.mem.Allocator, file: std.fs.File, hash: []const u8) !Comment {

return readVersioned(a, file, hash);

}

 

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

return Template.Context.initBuildable(a, self);

}

 

pub fn builder(self: Comment) Template.Context.Builder(Comment) {

return Template.Context.Builder(Comment).init(self);

}

 

pub fn contextBuilder(self: Comment, a: Allocator, ctx: *Template.Context) !void {

try ctx.putSlice("Author", try Bleach.sanitizeAlloc(a, self.author, .{}));

try ctx.putSlice("Message", try Bleach.sanitizeAlloc(a, self.message, .{}));

try ctx.putSlice("Date", try allocPrint(a, "{}", .{Humanize.unix(self.updated)}));

}

 

fn openFile(hash: []const u8) !std.fs.File {

var buf: [2048]u8 = undefined;

const filename = try bufPrint(&buf, "{x}.comment", .{fmtSliceHexLower(hash)});

return try datad.openFile(filename, .{ .mode = .read_write });

}

 

pub fn open(a: Allocator, hash: []const u8) !Comment {

var file = try openFile(hash);

defer file.close();

return try Comment.readFile(a, file, hash);

}

 

pub fn new(ath: []const u8, msg: []const u8) !Comment {

var c = Comment{

.author = ath,

.message = msg,

.created = std.time.timestamp(),

.updated = std.time.timestamp(),

};

try c.writeNew(datad);

 

return c;

}

 

test "comment" {

var a = std.testing.allocator;

 

var c = Comment{

.author = "grayhatter",

.message = "test comment, please ignore",

};

 

// zig fmt: off

const hash = c.toHash();

try std.testing.expectEqualSlices(

u8,

&[_]u8{

0x21, 0x78, 0x05, 0xE5, 0xB5, 0x0C, 0x05, 0xF5,

0x22, 0xAC, 0xFE, 0xBA, 0xEA, 0xA4, 0xAC, 0xC2,

0xD6, 0x50, 0xD1, 0xDD, 0x48, 0xFC, 0x34, 0x0E,

0xBB, 0x53, 0x94, 0x60, 0x56, 0x93, 0xC9, 0xC8

},

hash,

);

// zig fmt: on

 

var dir = std.testing.tmpDir(.{});

defer dir.cleanup();

 

try c.writeNew(dir.dir);

 

var buf: [2048]u8 = undefined;

const filename = try std.fmt.bufPrint(&buf, "{x}.comment", .{std.fmt.fmtSliceHexLower(hash)});

try std.testing.expectEqualStrings(

"217805e5b50c05f522acfebaeaa4acc2d650d1dd48fc340ebb5394605693c9c8.comment",

filename,

);

const blob = try dir.dir.readFileAlloc(a, filename, 0xFF);

defer a.free(blob);

 

// zig fmt: off

try std.testing.expectEqualSlices(

u8,

&[_]u8{

0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0,

103, 114, 97, 121, 104, 97, 116, 116, 101, 114,

0, 116, 101, 115, 116, 32, 99, 111, 109, 109,

101, 110, 116, 44, 32, 112, 108, 101, 97, 115,

101, 32, 105, 103, 110, 111, 114, 101,

},

blob,

);

// zig fmt: on

}

 

test Comment {

const a = std.testing.allocator;

var tempdir = std.testing.tmpDir(.{});

defer tempdir.cleanup();

try Types.init(try tempdir.dir.makeOpenPath("datadir", .{ .iterate = true }));

 

var c = try Comment.new("author", "message");

 

// LOL, you thought

const mask: i64 = ~@as(i64, 0xffffff);

c.created = std.time.timestamp() & mask;

c.updated = std.time.timestamp() & mask;

 

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

defer out.clearAndFree();

const outw = out.writer().any();

try c.writeOut(outw);

 

const v0: Comment = undefined;

const v0_bin: []const u8 = &[_]u8{

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x67, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x67, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x61, 0x75, 0x74,

0x68, 0x6F, 0x72, 0x00, 0x6D, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,

};

try std.testing.expectEqualSlices(u8, v0_bin, out.items);

const v1: Comment = undefined;

// TODO... eventually

_ = v0;

_ = v1;

 

const v1_bin: []const u8 = &[_]u8{

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x67, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x67, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x61, 0x75, 0x74,

0x68, 0x6F, 0x72, 0x00, 0x6D, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,

};

try std.testing.expectEqualSlices(u8, v1_bin, out.items);

}

const Comment = Types.Comment;

fn readVersioned(a: Allocator, idx: usize, reader: *std.io.AnyReader) !Delta {

pub fn addComment(self: *Delta, a: Allocator, c: Comment) !void {

if (self.thread) |thread| {

return thread.addComment(a, c);

}

return error.ThreadNotLoaded;

}

for (msgs) |m| switch (m) {

.comment => |c| {

cmtnew = cmtnew or c.updated > ts;

const Comment = @import("comment.zig");

pub fn readFile(a: std.mem.Allocator, idx: usize, file: std.fs.File) !Diff {

var diff: Diff = try readVersioned(a, idx, file);

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

if (diff.comment_data) |cd| {

const count = cd.len / 32;

for (0..count) |i| {

try list.append(Comment.open(a, cd[i * 32 .. (i + 1) * 32]) catch continue);

}

diff.comments = try list.toOwnedSlice();

}

return diff;

}

pub fn getComments(self: *Diff, a: Allocator) ![]Comment {

if (self.comments) |_| return self.comments.?;

 

if (self.comment_data) |cd| {

self.comments = try Comment.loadFromData(a, cd);

}

return &[0]Comment{};

}

 

pub fn addComment(self: *Diff, a: Allocator, c: Comment) !void {

const target = (self.comments orelse &[0]Comment{}).len;

if (self.comments) |*comments| {

if (a.resize(comments.*, target + 1)) {

comments.*.len = target + 1;

} else {

self.comments = try a.realloc(comments.*, target + 1);

}

} else {

self.comments = try a.alloc(Comment, target + 1);

}

self.comments.?[target] = c;

try self.writeOut();

}

const Comment = @import("comment.zig");

 

comments: ?[]Comment = null,

pub fn getComments(self: *Issue, a: Allocator) ![]Comment {

if (self.comments) |_| return self.comments.?;

 

if (self.comment_data) |cd| {

self.comments = try Comment.loadFromData(a, cd);

}

return &[0]Comment{};

}

 

pub fn addComment(self: *Issue, a: Allocator, c: Comment) !void {

const target = (self.comments orelse &[0]Comment{}).len;

if (self.comments) |*comments| {

if (a.resize(comments.*, target + 1)) {

comments.*.len = target + 1;

} else {

self.comments = try a.realloc(comments.*, target + 1);

}

} else {

self.comments = try a.alloc(Comment, target + 1);

}

self.comments.?[target] = c;

try self.writeOut();

}

const Comment = @import("comment.zig");

index: usize,

delta_hash: [32]u8 = [_]u8{0} ** 32,

hash: [32]u8 = [_]u8{0} ** 32,

pub const MessageTypes = enum {

comment,

unknown,

};

 

pub const Message = union(MessageTypes) {

comment: Comment,

unknown: void,

};

 

for (msgs) |msg| switch (msg) {

.comment => |cmt| cmt.commit() catch continue,

.unknown => {},

};

for (msgs) |*msg| switch (msg.*) {

.comment => |*c| try writer.writeAll(c.toHash()),

.unknown => {},

};

c.* = .{ .comment = Comment.open(a, data[0..32]) catch |err| {

} };

pub fn addComment(self: *Thread, a: Allocator, c: Comment) !void {

self.messages.?[self.messages.?.len - 1] = .{ .comment = c };

fn openFile(index: usize) !std.fs.File {