srctree

};

 

fn diff(vrs: *Verse) Router.Error!void {

}

 

const HeartBeat = struct {

};

 

fn heartbeat(vrs: *Verse) Router.Error!void {

}

 

const Issue = struct {

};

 

fn issue(vrs: *Verse) Router.Error!void {

}

 

/// Likely to be renamed

};

 

fn network(vrs: *Verse) Router.Error!void {

}

 

const Patch = struct {

};

 

fn patch(vrs: *Verse) Router.Error!void {

}

 

const Flex = struct {

};

 

fn flex(vrs: *Verse) Router.Error!void {

}

 

const User = struct {

};

 

fn user(vrs: *Verse) Router.Error!void {

}

 

var gitrepo = openRepo(ctx.alloc, req.name) catch |err| switch (err) {

error.InvalidName => return error.Abusive,

error.FileNotFound => {

},

else => {

},

};

defer gitrepo.raze();

.name = req.name,

.head = head.hex[0..],

.updated = "undefined",

}

 

pub const RepoBranches = struct {

var gitrepo = openRepo(ctx.alloc, req.name) catch |err| switch (err) {

error.InvalidName => return error.Abusive,

error.FileNotFound => {

},

else => {

},

};

defer gitrepo.raze();

.name = req.name,

.updated = "undefined",

.branches = branches[0..],

}

 

pub const RepoTags = struct {

var gitrepo = openRepo(ctx.alloc, req.name) catch |err| switch (err) {

error.InvalidName => return error.Abusive,

error.FileNotFound => {

},

else => {

},

};

defer gitrepo.raze();

.name = req.name,

.updated = "undefined",

.tags = &.{},

 

const tstack = try ctx.alloc.alloc([]const u8, repotags.len);

 

.name = req.name,

.updated = "undefined",

.tags = tstack,

}

 

 

const hash_str: [64]u8 = Gist.new(username, files) catch return error.Unknown;

 

}

 

fn new(ctx: *Verse) Error!void {

 

const splitScalar = std.mem.splitScalar;

 

const Verse = @import("verse");

const Request = Verse.Request;

const Template = Verse.Template;

const HTML = Template.HTML;

 

const NewRepoPage = Template.PageData("repo-new.html");

fn newRepo(ctx: *Verse) Error!void {

 

return error.NotImplemented;

}

.blame_lines = wrapped_blames,

});

 

try ctx.sendPage(&page);

}

 

_ = ctx.uri.next();

const uri_filename = Bleach.Html.sanitizeAlloc(ctx.alloc, ctx.uri.rest()) catch return error.Unknown;

 

 

var btns = navButtons(ctx) catch return error.Unknown;

 

 

const Verse = @import("verse");

const DOM = Verse.DOM;

const HTML = Verse.HTML;

const Route = Verse.Router;

const Template = Verse.Template;

const RequestData = Verse.RequestData;

.patch = Diffs.patchStruct(ctx.alloc, &patch, !inline_html) catch return error.Unknown,

});

 

return ctx.sendPage(&page) catch unreachable;

}

 

//if (std.mem.indexOf(u8, diff, "diff")) |i| {

// diff = diff[i..];

//}

}

}

 

 

//},

};

 

const udata = post.validate(DiffCreateReq) catch return error.BadData;

if (udata.title.len == 0) return error.BadData;

 

var remote_addr: []const u8 = "unknown";

 

if (inNetwork(udata.patch_uri)) {

 

std.debug.print(

"src {s}\ntitle {s}\ndesc {s}\naction {s}\n",

rd.name,

udata.title,

udata.desc,

else

) catch unreachable;

delta.commit() catch unreachable;

std.debug.print("commit id {x}\n", .{delta.index});

 

rd.name,

delta.index,

}) catch unreachable;

file.writer().writeAll(data.blob) catch unreachable;

var buf: [2048]u8 = undefined;

const loc = try std.fmt.bufPrint(&buf, "/repo/{s}/diffs/{x}", .{ rd.name, delta.index });

}

}

 

}

 

fn newComment(ctx: *Verse) Error!void {

const loc = try std.fmt.bufPrint(&buf, "/repo/{s}/diffs/{x}", .{ rd.name, delta_index });

 

const msg = try valid.require("comment");

 

var delta = Delta.open(ctx.alloc, rd.name, delta_index) catch unreachable orelse return error.Unrouteable;

const username = if (ctx.auth.valid())

thread.newComment(ctx.alloc, .{ .author = username, .message = msg.value }) catch unreachable;

// TODO record current revision at comment time

delta.commit() catch unreachable;

}

return error.Unknown;

}

 

delta.commit() catch unreachable;

 

const loc = try std.fmt.bufPrint(&buf, "/repo/{s}/issues/{x}", .{ rd.name, delta.index });

}

 

const loc = try std.fmt.bufPrint(&buf, "/repo/{s}/issue/new", .{rd.name});

}

 

fn newComment(ctx: *Verse) Error!void {

delta.commit() catch unreachable;

var buf: [2048]u8 = undefined;

const loc = try std.fmt.bufPrint(&buf, "/repo/{s}/issues/{x}", .{ rd.name, issue_index });

return;

}

return error.Unknown;

 

std.debug.print("block data:\nname '{s}'\ntext '''{s}'''\n", .{ name, text });

}

 

}

 

const POLL = std.posix.POLL;

 

const Verse = @import("verse");

const Request = Verse.Request;

const HTML = Verse.HTML;

const elm = HTML.element;

child.env_map = ↦

child.expand_arg0 = .no_expand;

 

 

child.spawn() catch unreachable;

 

const amt = std.posix.read(poll_fd[0].fd, buf) catch unreachable;

if (amt == 0) break;

if (headers_required) {

headers_required = false;

}

} else if (poll_fd[0].revents & err_mask != 0) {

break;

}

 

//var data = repo.findBlob(ctx.alloc, &sha) catch unreachable;

 

}

 

fn __info(ctx: *Verse) Error!void {

 

const data = try adata.toOwnedSlice();

 

}

 

fn notFound(ctx: *Verse) Router.Error!void {

// TODO fix this

@import("std").debug.print("404 for route\n", .{});

var page = E404Page.init(.{});

ctx.sendPage(&page) catch unreachable;

}

pub fn builder(ctx: *Verse, call: BuildFn) void {

return call(ctx) catch |err| switch (err) {

error.InvalidURI => builder(ctx, notFound), // TODO catch inline

error.Unrouteable => {

std.debug.print("Unrouteable", .{});

if (@errorReturnTrace()) |trace| {