srctree

const Allocator = std.mem.Allocator;

 

pub const Routes = @import("routes.zig");

 

const ROUTE = Routes.ROUTE;

 

}

};

 

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

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

const rd = try APIRouteData.init(ctx.alloc);

sha: []const u8,

};

 

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

}

 

nice: usize = 0,

};

 

return try ctx.sendJSON(HeartBeat{ .nice = 69 });

}

 

index: usize,

};

 

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

}

 

networks: []RemotePeer,

};

 

return try ctx.sendJSON(Network{ .networks = [0].{} });

}

 

patch: []const u8,

};

 

return try ctx.sendJSON(Patch{ .patch = [0].{} });

}

 

};

};

 

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

}

 

email: []const u8,

};

 

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

}

 

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.reqdata.validate(RepoRequest);

 

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

branches: []const Branch,

};

 

const req = try ctx.reqdata.validate(RepoRequest);

 

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

tags: []const []const u8,

};

 

const req = try ctx.reqdata.validate(RepoRequest);

 

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

 

 

const Allocator = std.mem.Allocator;

 

const Route = @import("../routes.zig");

const HTML = @import("../html.zig");

const DOM = @import("../dom.zig");

/// TODO fix me

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

 

try ctx.request.auth.validOrError();

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

const action = "/admin/post";

try ctx.sendPage(&page);

}

 

try ctx.request.auth.validOrError();

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

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

repo_uri: []const u8,

};

 

try ctx.request.auth.validOrError();

 

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

try ctx.sendPage(&page);

}

 

try ctx.request.auth.validOrError();

// TODO ini repo dir

var valid = if (ctx.reqdata.post) |p|

try ctx.sendPage(&page);

}

 

try ctx.request.auth.validOrError();

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

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

try ctx.sendPage(&page);

}

 

try ctx.request.auth.validOrError();

if (ctx.reqdata.post) |pd| {

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

 

 

const DOM = @import("../dom.zig");

const HTML = @import("../html.zig");

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

const S = Template.Structs;

 

 

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

 

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

 

var nowish = DateTime.now();

 

const std = @import("std");

const allocPrint = std.fmt.allocPrint;

 

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

const RequestData = @import("../request_data.zig").RequestData;

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

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,

};

 

try ctx.request.auth.validOrError();

 

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

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

}

 

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

return edit(ctx, &files);

}

 

// TODO move this back into context somehow

var btns = [1]Template.Structs.NavButtons{

.{ .name = "inbox", .extra = 0, .url = "/inbox" },

return out;

}

 

// TODO move this back into context somehow

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

 

 

const allocPrint = std.fmt.allocPrint;

 

const DOM = @import("../dom.zig");

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

 

const Route = @import("../routes.zig");

 

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

 

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

 

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

 

const startsWith = std.mem.startsWith;

const splitScalar = std.mem.splitScalar;

 

const Response = @import("../response.zig");

const Request = @import("../request.zig");

const HTML = @import("../html.zig");

}

};

 

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()) {

//const issuecnt = try std.fmt.allocPrint(ctx.alloc, "{}", .{i_count});

//const diffcnt = try std.fmt.allocPrint(ctx.alloc, "{}", .{d_count});

//const diffurl = try std.fmt.allocPrint(ctx.alloc, "/repos/{s}/diffs/", .{rd.name});

// .{ .name = "Name", .value = "issues" },

// .{ .name = "Url", .value = issueurl },

// .{ .name = "Extra", .value = issuecnt },

// }) catch return error.OutOfMemory,

// .{ .name = "Name", .value = "diffs" },

// .{ .name = "Url", .value = diffurl },

// .{ .name = "Extra", .value = diffcnt },

// }) catch return error.OutOfMemory,

//});

 

if (rd.verb) |_| {

_ = ctx.uri.next();

sort: ?[]const u8,

};

 

var cwd = std.fs.cwd();

 

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

}

 

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

ctx.response.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,

// else => "unknown",

//} else "unknown";

 

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

ctx.uri.reset();

 

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

 

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

 

var cwd = std.fs.cwd();

 

const Repos = @import("../repos.zig");

 

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

const DOM = @import("../../dom.zig");

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

const HTML = @import("../../html.zig");

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.reqdata.post) |post| {

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

}

return error.BadData;

}

 

patch.parse(a) catch |err| {

if (std.mem.indexOf(u8, patch.blob, "\nMerge: ") == null) {

std.debug.print("'''\n{s}\n'''\n", .{patch.blob});

return error.PatchInvalid;

};

 

}

 

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 dom.done();

}

 

var parcount: usize = 0;

for (c.parent) |p| {

if (p != null) parcount += 1;

}

var found: usize = 0;

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

found = i;

outsha.* = current.sha;

if (left) |l| if (current.sha.eqlIsh(l)) break;

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().?));

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

 

const before: Git.SHA = if (ctx.uri.next()) |bf| Git.SHA.initPartial(bf);

var last_sha: Git.SHA = undefined;

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

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

}

 

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

 

var page = CommitsListPage.init(.{

 

 

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

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

const DOM = @import("../../dom.zig");

const HTML = @import("../../html.zig");

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

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(&ctx.uri) orelse return error.Unrouteable;

if (ctx.reqdata.post) |post| {

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

return try new(ctx);

}

 

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

var buf: [2048]u8 = undefined;

if (ctx.reqdata.post) |post| {

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();

}

 

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;

 

const Route = @import("../../routes.zig");

const DOM = @import("../../dom.zig");

const HTML = @import("../../html.zig");

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

const Error = Route.Error;

const UriIter = Route.Error;

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.reqdata.post) |post| {

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

}

 

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

if (ctx.reqdata.post) |post| {

var valid = post.validator();

 

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;

 

const splitScalar = std.mem.splitScalar;

const allocPrint = std.fmt.allocPrint;

 

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

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

const Route = @import("../routes.zig");

ROUTE("inbox", inbox),

};

 

return Route.router(ctx, &routes);

}

 

q: ?[]const u8,

};

 

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

}

 

const udata = ctx.reqdata.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 std = @import("std");

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

const Route = @import("../routes.zig");

const RequestData = @import("../request_data.zig").RequestData;

 

 

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

 

try ctx.request.auth.validOrError();

 

var blocks = try ctx.alloc.alloc(Template.Structs.ConfigBlocks, ctx.cfg.?.ns.len);

block_text: [][]const u8,

};

 

try ctx.request.auth.validOrError();

 

const udata = RequestData(SettingsReq).initMap(ctx.alloc, ctx.reqdata) catch return error.BadData;

 

 

const DOM = @import("../dom.zig");

const HTML = @import("../html.zig");

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

const Route = @import("../routes.zig");

const UriIter = Route.UriIter;

 

 

const Allocator = std.mem.Allocator;

 

const Response = @import("response.zig");

const Request = @import("request.zig");

const HTML = @import("html.zig");

.{ .name = "git-upload-pack", .methods = .{ .POST = true }, .match = .{ .call = gitUploadPack } },

};

 

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

return Route.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("../../REPO.RouteData.make(ctx.uri) orelse return error.Unrouteable.zig");

ctx.response.finish() catch return Error.Unknown;

}

 

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

 

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

 

const Allocator = std.mem.Allocator;

const Server = std.http.Server;

 

const Request = @import("request.zig");

const Response = @import("response.zig");

const Router = @import("routes.zig");

var request = try Request.init(alloc, http_resp);

const response = Response.init(alloc, &request);

 

alloc,

request,

response,

 

const Response = @import("response.zig");

const HTML = @import("html.zig");

const DOM = @import("dom.zig");

 

pub const Patch = @This();

 

}

}

 

if (self.diffs) |diffs| {

for (diffs, diffs_ctx) |diff, *dctx| {

switch (diff.header.change) {

.none => try ctx.putSlice("Filename", diff.filename orelse "Malformed Patch"),

.newfile => {

 

const Allocator = std.mem.Allocator;

 

const api = @import("api.zig");

const Response = @import("response.zig");

const Request = @import("request.zig");

const HTML = @import("html.zig");

 

pub const UriIter = std.mem.SplitIterator(u8, .scalar);

 

 

pub const DEBUG: bool = false;

 

};

}

 

ctx.response.status = .not_found;

const E4XX = @embedFile("../templates/4XX.html");

return ctx.sendRawSlice(E4XX);

}

 

ctx.response.status = .internal_server_error;

const E5XX = @embedFile("../templates/5XX.html");

return ctx.sendRawSlice(E5XX);

}

 

const index = @embedFile("../templates/index.html");

return ctx.sendRawSlice(index);

}

 

const search = ctx.uri.peek() orelse {

if (DEBUG) std.debug.print("No endpoint found: URI is empty.\n", .{});

return notFound;

ROUTE("", default),

};

 

if (DEBUG) std.debug.print("baserouter {s}\n", .{ctx.uri.peek().?});

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

if (first.len > 0) {

const root_with_static = root ++

[_]Match{.{ .name = "static", .match = .{ .call = StaticFile.file } }};

 

if (DEBUG) std.debug.print("baserouter {s}\n", .{ctx.uri.peek().?});

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

if (first.len > 0) {

 

const Routes = @import("routes.zig");

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

const Api = @import("api.zig");

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

 

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

 

// TODO fix this

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

ctx.response.status = .not_found;

ctx.sendPage(&page) catch unreachable;

}

 

// var i_count: usize = 0;

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

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

}

 

// TODO replace with better API

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

error.InvalidURI,

error.Unrouteable,

 

const std = @import("std");

 

const Route = @import("routes.zig");

 

_ = ctx.uri.next(); // clear /static

const fname = ctx.uri.next() orelse return error.Unrouteable;

if (fname.len == 0) return error.Unrouteable;

 

return .{ .count = 0, .new = false };

}

 

pub fn raze(_: Delta, _: std.mem.Allocator) void {

// TODO implement raze

}

 

 

const Error = @import("errors.zig").Error;

 

 

alloc: Allocator,

request: Request,

[]const u8,

};

 

std.debug.assert(req.uri[0] == '/');

//const reqheader = req.headers

.alloc = a,

.request = req,

.response = res,

};

}

 

ctx.response.start() catch |err| switch (err) {

error.BrokenPipe => return error.NetworkCrash,

else => unreachable,

};

}

 

ctx.response.send(slice) catch unreachable;

}

 

return Routes.defaultResponse(code)(ctx);

}

 

ctx.response.start() catch |err| switch (err) {

error.BrokenPipe => return error.NetworkCrash,

else => unreachable,

 

const Allocator = std.mem.Allocator;

const Server = std.net.Server;

 

const Request = @import("request.zig");

const Response = @import("response.zig");

const Router = @import("routes.zig");

buildfn: BuildFn,

runmode: RunMode = .unix,

 

// TODO provide default for this?

 

const uProtoHeader = packed struct {

mod1: u8 = 0,

defer arena.deinit();

const a = arena.allocator();

 

 

defer {

std.log.err("zWSGI: [{d:.3}] {s} - {s}: {s} -- \"{s}\"", .{

 

var hreq = try hsrv.receiveHead();

 

var ipbuf: [0x20]u8 = undefined;

const ipport = try std.fmt.bufPrint(&ipbuf, "{}", .{conn.address});

if (std.mem.indexOf(u8, ipport, ":")) |i| {

return find(list, search) orelse "[missing]";

}

 

var post_data: ?RequestData.PostData = null;

var reqdata: RequestData = undefined;

switch (request.raw_request) {

}

 

const response = try Response.init(a, request);

}

 

fn readHttpHeaders(a: Allocator, req: *std.http.Server.Request) !Request {

return try Request.init(a, req);

}

 

var request = try readHttpHeaders(a, req);

std.debug.print("http target -> {s}\n", .{request.uri});

}

 

fn readuWSGIHeader(a: Allocator, acpt: Server.Connection) !Request {

);

}

 

var request = try readuWSGIHeader(a, conn.*);

 

}