srctree

 

const Verse = @import("verse");

const Route = Verse.Router;

const DOM = HTML.DOM;

 

const Error = Route.Error;

 

const global_config = &@import("../main.zig").global_config;

 

const Verse = @import("verse");

const S = Template.Structs;

 

const Route = Verse.Router;

 

const allocPrint = std.fmt.allocPrint;

 

const Verse = @import("verse");

const S = Template.Structs;

const RequestData = Verse.RequestData.RequestData;

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

 

const allocPrint = std.fmt.allocPrint;

 

const Verse = @import("verse");

 

const Route = Verse.Router;

const Error = Route.Error;

ROUTE("", default),

};

 

 

fn default(ctx: *Verse.Frame) Error!void {

var dom = DOM.new(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();

}

}

for (htmllist, data) |*l, e| l.* = try std.fmt.allocPrint(ctx.alloc, "{}", .{e});

const value = try std.mem.join(ctx.alloc, "", htmllist);

 

var page = NetworkPage.init(.{

.meta_head = .{ .open_graph = .{} },

.body_header = .{ .nav = .{ .nav_buttons = &btns } },

 

 

const Verse = @import("verse");

const Request = Verse.Request;

const Route = Verse.Router;

const Error = Route.Error;

const ROUTE = Route.ROUTE;

const POST = Route.POST;

const GET = Route.GET;

return null;

}

 

const index = uri.index;

defer uri.index = index;

uri.reset();

}

};

 

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

if (!rd.exists()) unreachable;

var i_count: usize = 0;

dlt.raze(ctx.alloc);

}

 

.{

.name = "issues",

.extra = i_count,

return std.mem.lessThan(u8, l, r);

}

 

var desc: ?[]const u8 = try repo.description(a);

if (std.mem.startsWith(u8, desc.?, "Unnamed repository; edit this file")) {

desc = null;

);

} else |_| {}

 

 

if (repo.tags) |tags| {

tag = .{

};

}

 

 

const RepoSortReq = struct {

sort: ?[]const u8,

;

}

 

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

defer repo.raze();

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

};

}

 

// .name = "inbox",

// .extra = 0,

// .url = "/inbox",

return out;

}

 

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

ctx.status = .ok;

 

};

}

 

 

fn blame(ctx: *Verse.Frame) Error!void {

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

return false;

}

 

 

fn blob(vrs: *Verse.Frame, repo: *Git.Repo, pfiles: Git.Tree) Error!void {

var blb: Git.Blob = undefined;

try vrs.sendPage(&page);

}

 

var files: Git.Tree = pfiles;

if (uri.next()) |udir| for (files.blobs) |obj| {

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

return files;

}

 

var dom = DOM.new(a);

 

const clean = Bleach.Html.sanitizeAlloc(a, readme) catch return error.Unknown;

const translated = try Highlight.translate(a, .markdown, clean);

var litr = std.mem.splitScalar(u8, translated, '\n');

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

}

dom = dom.close();

dom = dom.close();

}

 

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

const commit_href = try allocPrint(a, "/repo/{s}/commit/{s}", .{ rname, ch.sha.hex[0..8] });

dom = dom.close();

return dom.close();

}

 

fn drawBlob(a: Allocator, ddom: *DOM, rname: []const u8, base: []const u8, obj: Git.Blob) !*DOM {

const file_link = try allocPrint(a, "/repo/{s}/blob/{s}{s}", .{ rname, base, obj.name });

 

.key = "href",

.value = file_link,

}};

 

return dom;

}

 

fn drawTree(a: Allocator, ddom: *DOM, rname: []const u8, base: []const u8, obj: Git.Blob) !*DOM {

const file_link = try allocPrint(a, "/repo/{s}/tree/{s}{s}/", .{ rname, base, obj.name });

 

.key = "href",

.value = file_link,

}};

return dom;

}

 

 

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

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

 

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

 

 

const branches = try allocPrint(ctx.alloc, "{} branches", .{repo.refs.len});

 

const c = repo.headCommit(ctx.alloc) catch return error.Unknown;

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

const commit_href = try allocPrint(ctx.alloc, "/repo/{s}/commit/{s}", .{ rd.name, c.sha.hex[0..8] });

dom = dom.close();

dom = dom.close();

 

if (uri_base.len > 0) {

const end = std.mem.lastIndexOf(u8, uri_base[0 .. uri_base.len - 1], "/") orelse 0;

.key = "href",

.value = try allocPrint(

ctx.alloc,

.{ rd.name, uri_base[0..end] },

),

}};

dom = dom.close();

}

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

}

} else |err| switch (err) {

error.PathNotFound => {

},

else => return error.Unrouteable,

}

try ctx.sendPage(&page);

}

 

 

fn tagsList(ctx: *Verse.Frame) Error!void {

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

 

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

 

 

}

 

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

 

const DOM = Verse.DOM;

const HTML = Verse.HTML;

const Route = Verse.Router;

const RequestData = Verse.RequestData;

 

const Diffs = @import("diffs.zig");

 

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

const Patch = @import("../../patch.zig");

const Route = Verse.Router;

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

const Highlighting = @import("../../syntax-highlight.zig");

 

 

const Route = Verse.Router;

const DOM = Verse.DOM;

const HTML = Verse.HTML;

const Error = Route.Error;

const UriIter = Route.Error;

const ROUTE = Route.ROUTE;

 

 

const Verse = @import("verse");

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

const Routes = Verse.Router;

const Error = Routes.Error;

const ROUTE = Routes.ROUTE;

 

const std = @import("std");

const Verse = @import("verse");

const Router = Verse.Router;

const RequestData = Verse.RequestData.RequestData;

const global_ini = &@import("../main.zig").root_ini;

 

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

const Verse = @import("verse");

const Response = Verse.Response;

 

pub const Patch = @This();

 

 

const eql = std.mem.eql;

const Verse = @import("verse");

const Router = Verse.Router;

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

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