srctree

 

/// `Endpoints` here is a constructed type that will do some validation, and

/// statically and recursively construct the routes supplied.

// Note index.zig sets `verse_name = .root;` which will cause the routes it

// lists to be flattened out. `/` will resolve to the function within

// `index.zig` with the name `index`.

// The remaining endpoints (only random.zig here) are declared normally, and

// will use verse_name as the route name. The file name is not semantic,

// the routing will constructed only on the verse_name variable within the

// given type.

@import("endpoint/random.zig"),

// Endpoints don't have to be files, you can define a struct inline with the

// minimum verse variables and handler functions and Verse will include them

// as a route.

/// This is commented out here, as it's included within the root endpoint,

/// but because this endpoint will be flattened out into root directory;

/// declaring it here, or there are equivalent options.

// @import("random.zig"),

pub const routes = collectRoutes(endpoints);

fn routeCount(endpoints: anytype) usize {

for (endpoints, 0..) |ep, i| {

for (@typeInfo(ep).Struct.decls) |decl| {

if (eql(u8, "index", decl.name)) count += 1;

if (@hasDecl(ep, "verse_routes")) for (ep.verse_routes) |route| {

if (route.name.len == 0) {

@compileError("route name omitted for: " ++ @typeName(ep) ++ ". To support a directory URI, define an index() instead");

}

count += 1;

};

 

if (@hasDecl(ep, "verse_endpoints")) {

count += ep.verse_endpoints.Endpoints.len;

}

 

if (i == 0 and ep.verse_name == .root) {

return count + endpoints.len - 1;

}

fn collectRoutes(EPS: anytype) [routeCount(EPS)]Router.Match {

var match: [routeCount(EPS)]Router.Match = undefined;

var idx: usize = 0;

for (EPS) |EP| {

// Only flatten when the endpoint name is root

if (EP.verse_name == .root) {

for (buildRoutes(EP)) |r| {

match[idx] = r;

idx += 1;

}

} else {

match[idx] = Router.ROUTE(@tagName(EP.verse_name), &buildRoutes(EP));

idx += 1;

}

}

return match;

}

 

fn buildRoutes(EP: type) [routeCount(.{EP})]Router.Match {

var match: [routeCount(.{EP})]Router.Match = undefined;