srctree

}

};

 

const uri_api = vrs.uri.next() orelse return heartbeat;

if (!std.mem.eql(u8, uri_api, "api")) return heartbeat;

const rd = APIRouteData.init(vrs.alloc) catch @panic("OOM");

sha: []const u8,

};

 

return try vrs.sendJSON([0]Diff{}, .ok);

}

 

nice: usize = 0,

};

 

return try vrs.sendJSON(HeartBeat{ .nice = 69 }, .ok);

}

 

index: usize,

};

 

return try vrs.sendJSON([0]Issue{}, .ok);

}

 

networks: []RemotePeer,

};

 

return try vrs.sendJSON(Network{ .networks = [0].{} }, .ok);

}

 

patch: []const u8,

};

 

return try vrs.sendJSON(Patch{ .patch = [0].{} }, .ok);

}

 

};

};

 

return try vrs.sendJSON([0]Flex{}, .ok);

}

 

email: []const u8,

};

 

return try vrs.sendJSON([0]User{}, .ok);

}

 

ROUTE("tags", repoTags),

};

 

const uri_api = ctx.uri.next() orelse return repo;

if (!std.mem.eql(u8, uri_api, "repo")) return repo;

 

return gitrepo;

}

 

const req = try ctx.request.data.validate(RepoRequest);

 

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

branches: []const Branch,

};

 

const req = try ctx.request.data.validate(RepoRequest);

 

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

tags: []const []const u8,

};

 

const req = try ctx.request.data.validate(RepoRequest);

 

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

 

const Verse = @import("verse");

const Route = Verse.Router;

const Template = Verse.Template;

 

const Error = Route.Error;

const UriIter = Route.UriIter;

/// TODO fix me

const btns = [1]Template.Structs.NavButtons{.{ .name = "inbox", .extra = 0, .url = "/inbox" }};

 

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

const action = "/admin/post";

dom = dom.open(HTML.form(null, &[_]HTML.Attr{

try ctx.sendPage(&page);

}

 

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

const action = "/admin/clone-upstream";

dom = dom.open(HTML.form(null, &[_]HTML.Attr{

repo_uri: []const u8,

};

 

 

const udata = ctx.request.data.post.?.validate(CloneUpstreamReq) catch return error.BadData;

std.debug.print("repo uri {s}\n", .{udata.repo_uri});

try ctx.sendPage(&page);

}

 

// TODO ini repo dir

var valid = if (ctx.request.data.post) |p|

p.validator()

try ctx.sendPage(&page);

}

 

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

const action = "/admin/new-repo";

dom = dom.open(HTML.form(null, &[_]HTML.Attr{

try ctx.sendPage(&page);

}

 

if (ctx.request.data.post) |pd| {

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

return newRepo(ctx);

 

 

const UserCommitsPage = Template.PageData("user_commits.html");

 

const monthAtt = HTML.Attr.class("month");

 

var nowish = DateTime.now();

 

const Verse = @import("verse");

const Template = Verse.Template;

const S = Template.Structs;

 

const Route = Verse.Router;

 

POST("post", post),

};

 

if (!std.mem.eql(u8, ctx.uri.next() orelse "", "gist")) return error.Unrouteable;

 

if (ctx.uri.peek()) |peek| {

new_file: ?[]const u8,

};

 

 

const udata = RequestData(GistPost).initMap(ctx.alloc, ctx.request.data) catch return error.BadData;

 

if (udata.file_name.len != udata.file_blob.len) return error.BadData;

else

"public";

 

return ctx.redirect("/gist/" ++ hash_str, true) catch unreachable;

}

 

const files = [1]Template.Structs.GistFiles{.{}};

return edit(ctx, &files);

}

 

var page = GistNewPage.init(.{

.meta_head = .{

.open_graph = .{

return out;

}

 

// TODO move this back into context somehow

var btns = [1]Template.Structs.NavButtons{.{ .name = "inbox", .extra = 0, .url = "/inbox" }};

 

 

 

const Verse = @import("verse");

const Template = Verse.Template;

 

const Route = Verse.Router;

const Error = Route.Error;

 

const NetworkPage = Template.PageData("network.html");

 

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

 

const list = try Repos.allNames(ctx.alloc);

defer repo.raze();

if (repo.findRemote("upstream") catch continue) |remote| {

if (remote.url) |_| {

const purl = try allocPrint(ctx.alloc, "{link}", .{remote});

dom = dom.close();

}

}

 

const Verse = @import("verse");

const Request = Verse.Request;

const Template = Verse.Template;

const Route = Verse.Router;

const S = Template.Structs;

const elm = HTML.element;

}

};

 

const rd = RouteData.make(&ctx.uri) orelse unreachable;

if (!rd.exists()) unreachable;

var i_count: usize = 0;

return btns;

}

 

const rd = RouteData.make(&ctx.uri) orelse return list;

 

if (rd.exists()) {

sort: ?[]const u8,

};

 

var cwd = std.fs.cwd();

 

const udata = ctx.request.data.query.validate(RepoSortReq) catch return error.BadData;

}, repoSorterNew);

 

var repo_buttons: []const u8 = "";

repo_buttons =

\\<div class="act-btns"><a class="btn" href="/admin/clone-upstream">New Upstream</a></div>

;

}

 

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

ctx.status = .ok;

 

return error.NotImplemented;

}

 

const rd = RouteData.make(&ctx.uri) orelse return error.Unrouteable;

_ = ctx.uri.next();

 

 

const BlamePage = Template.PageData("blame.html");

 

const rd = RouteData.make(&ctx.uri) orelse return error.Unrouteable;

std.debug.assert(std.mem.eql(u8, rd.verb orelse "", "blame"));

_ = ctx.uri.next();

 

const BlobPage = Template.PageData("blob.html");

 

var blb: Git.Blob = undefined;

 

var files = pfiles;

 

const TreePage = Template.PageData("tree.html");

 

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

// .sha => |s| s.hex[0..],

// .branch => |b| b.name,

 

const TagPage = Template.PageData("repo-tags.html");

 

const rd = RouteData.make(&ctx.uri) orelse return error.Unrouteable;

 

var cwd = std.fs.cwd();

 

text: []const u8,

};

 

const rd = RouteData.make(&ctx.uri) orelse return commitsView;

if (rd.verb != null and std.mem.eql(u8, "commit", rd.verb.?))

return viewCommit;

return commitsView;

}

 

if (ctx.request.data.post) |post| {

_ = post.validate(AddComment) catch return error.BadData;

}

return try patch.diffsVerseSlice(a);

}

 

if (!Git.commitish(sha)) {

std.debug.print("Abusive ''{s}''\n", .{sha});

return error.Abusive;

return ctx.sendPage(&page) catch unreachable;

}

 

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

if (endsWith(u8, sha, ".patch")) {

var rbuf: [0xff]u8 = undefined;

}

}

 

const rd = RouteData.make(&ctx.uri) orelse return error.Unrouteable;

if (rd.verb == null) return commitsView(ctx);

 

return commits;

}

 

const rd = RouteData.make(&ctx.uri) orelse return error.Unrouteable;

 

if (ctx.uri.next()) |next| {

return sendCommits(ctx, cmts_list, rd.name, last_sha.hex[0..8]);

}

 

const rd = RouteData.make(&ctx.uri) orelse return error.Unrouteable;

 

std.debug.assert(std.mem.eql(u8, "after", ctx.uri.next().?));

return sendCommits(ctx, cmts_list, rd.name, last_sha[0..]);

}

 

const meta_head = S.MetaHeadHtml{ .open_graph = .{} };

 

var page = CommitsListPage.init(.{

 

return std.fmt.parseInt(usize, input, 16) catch null;

}

 

if (!eql(u8, "diffs", ctx.uri.next() orelse return error.Unrouteable))

return error.Unrouteable;

const verb = ctx.uri.peek() orelse return Route.router(ctx, &routes);

desc: []const u8,

};

 

var network: ?S.Network = null;

var patchuri: ?S.PatchUri = .{};

var title: ?[]const u8 = null;

//},

};

 

const rd = Repos.RouteData.make(&vrs.uri) orelse return error.Unrouteable;

if (vrs.request.data.post) |post| {

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

rd.name,

udata.title,

udata.desc,

else

try allocPrint(vrs.alloc, "REMOTE_ADDR {s}", .{remote_addr}),

) catch unreachable;

return try new(vrs);

}

 

const rd = Repos.RouteData.make(&ctx.uri) orelse return error.Unrouteable;

var buf: [2048]u8 = undefined;

if (ctx.request.data.post) |post| {

if (msg.value.len < 2) return ctx.redirect(loc, true) catch unreachable;

 

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

else

"public";

var thread = delta.loadThread(ctx.alloc) catch unreachable;

return error.Unknown;

}

 

_ = ctx.uri.next().?;

_ = ctx.uri.next().?;

std.debug.print("{s}\n", .{ctx.uri.next().?});

 

const DiffViewPage = Template.PageData("delta-diff.html");

 

const rd = Repos.RouteData.make(&ctx.uri) orelse return error.Unrouteable;

 

var cwd = std.fs.cwd();

@panic("oops");

}

 

else

"public";

 

}

 

const DeltaListPage = Template.PageData("delta-list.html");

const rd = Repos.RouteData.make(&ctx.uri) orelse return error.Unrouteable;

 

const last = Delta.last(rd.name) + 1;

 

return std.fmt.parseInt(usize, input, 16) catch null;

}

 

std.debug.assert(std.mem.eql(u8, "issues", ctx.uri.next().?));

const verb = ctx.uri.peek() orelse return Route.router(ctx, &routes);

 

 

const IssueNewPage = Template.PageData("issue-new.html");

 

const meta_head = S.MetaHeadHtml{ .open_graph = .{} };

var page = IssueNewPage.init(.{

.meta_head = meta_head,

desc: []const u8,

};

 

const rd = Repos.RouteData.make(&ctx.uri) orelse return error.Unrouteable;

var buf: [2048]u8 = undefined;

if (ctx.request.data.post) |post| {

rd.name,

valid.title,

valid.desc,

else

try allocPrint(ctx.alloc, "remote_address", .{}),

) catch unreachable;

return ctx.redirect(loc, true) catch unreachable;

}

 

const rd = Repos.RouteData.make(&ctx.uri) orelse return error.Unrouteable;

if (ctx.request.data.post) |post| {

var valid = post.validator();

rd.name,

issue_index,

) catch unreachable orelse return error.Unrouteable;

else

"public";

 

 

const DeltaIssuePage = Template.PageData("delta-issue.html");

 

const rd = Repos.RouteData.make(&ctx.uri) orelse return error.Unrouteable;

const delta_id = ctx.uri.next().?;

const index = isHex(delta_id) orelse return error.Unrouteable;

 

const DeltaListHtml = Template.PageData("delta-list.html");

 

const rd = Repos.RouteData.make(&ctx.uri) orelse return error.Unrouteable;

 

const last = Delta.last(rd.name) + 1;

 

ROUTE("inbox", inbox),

};

 

return Routes.router(ctx, &routes);

}

 

q: ?[]const u8,

};

 

return custom(ctx, "owner:me");

}

 

const udata = ctx.request.data.query.validate(SearchReq) catch return error.BadData;

 

const query_str = udata.q orelse "null";

 

const DeltaListPage = Template.PageData("delta-list.html");

 

var rules = std.ArrayList(Delta.SearchRule).init(ctx.alloc);

 

var itr = splitScalar(u8, search_str, ' ');

 

 

const SettingsPage = Template.PageData("settings.html");

 

 

var blocks: []S.ConfigBlocks = &[0]S.ConfigBlocks{};

 

block_text: [][]const u8,

};

 

 

const udata = RequestData(SettingsReq).initMap(vrs.alloc, vrs.request.data) catch return error.BadData;

 

 

Router.ANY("git-upload-pack", gitUploadPack),

};

 

std.debug.print("gitweb router {s}\n{any}, {any} \n", .{ ctx.ctx.uri.peek().?, ctx.ctx.uri, ctx.request.method });

return Router.router(ctx, &endpoints);

}

 

ctx.uri.reset();

_ = ctx.uri.first();

const name = ctx.uri.next() orelse return error.Unknown;

_ = child.wait() catch unreachable;

}

 

std.debug.print("gitweb objects\n", .{});

 

const rd = @import("endpoints/repos.zig").RouteData.make(&ctx.uri) orelse return error.Unrouteable;

ctx.sendRawSlice(data) catch return Error.Unknown;

}

 

std.debug.print("gitweb info\n", .{});

 

const rd = @import("endpoints/repos.zig").RouteData.make(&ctx.uri) orelse return error.Unrouteable;

 

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

const Verse = @import("verse");

const Response = Verse.Response;

 

pub const Patch = @This();

 

 

 

const E404Page = Template.PageData("4XX.html");

 

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

vrs.status = .not_found;

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

vrs.sendPage(&page) catch unreachable;

}

 

// var i_count: usize = 0;

// var itr = Types.Delta.iterator(vrs.alloc, "");

// while (itr.next()) |it| {

return Router.router(vrs, &routes);

}

 

return error.Abusive;

}

 

const bh = vrs.alloc.create(Template.Structs.BodyHeaderHtml) catch unreachable;

const btns = [1]Template.Structs.NavButtons{.{ .name = "inbox", .extra = 0, .url = "/inbox" }};

bh.* = .{ .nav = .{ .nav_auth = "Public2", .nav_buttons = &btns } };