srctree

const BuildFn = Router.BuildFn;

const print = std.fmt.bufPrint;

 

const routes = [_]Router.Match{

Router.GET("", index),

};

fn index(verse: *Verse) Router.Error!void {

var buffer: [2048]u8 = undefined;

const found = try print(&buffer, "{} cookies found by the server\n", .{verse.request.cookie_jar.cookies.items.len});

try verse.quickStart();

try verse.sendRawSlice(found);

}

 

};

}

 

}

};

 

};

 

for (expected, cookies) |expect, cookie| {

try std.testing.expectEqualStrings(expect, res);

}

}

return found;

}

 

/// Reduces size of cookies to it's current length.

pub fn shrink(jar: *Jar) void {

jar.cookies.shrinkAndFree(jar.alloc, jar.cookies.len);

 

 

pub const Headers = @This();

 

name: []const u8,

value: []const u8,

};

}

};

 

pub fn format(h: Headers, comptime _: []const u8, _: std.fmt.FormatOptions, out: anytype) !void {

_ = h;

_ = out;

 

const std = @import("std");

const Allocator = std.mem.Allocator;

const AnyWriter = std.io.AnyWriter;

 

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

const Headers = @import("headers.zig");

 

pub const Writer = std.io.Writer(*Response, Error, write);

 

headers: Headers,

tranfer_mode: TransferMode = .static,

// This is just bad code, but I need to give the sane implementation more thought

downstream: union(Downstream) {

http: std.io.AnyWriter,

},

cookie_jar: Cookies.Jar,

status: ?std.http.Status = null,

 

pub fn init(a: Allocator, req: *const Request) !Response {

.headers = Headers.init(a),

.downstream = switch (req.raw) {

.zwsgi => |z| .{ .zwsgi = z.*.acpt.stream.writer() },

.http => .{ .http = undefined },

},

.cookie_jar = try Cookies.Jar.init(a),

};

}

 

fn headersInit(res: *Response) !void {

 

pub fn start(res: *Response) !void {

if (res.status == null) res.status = .ok;

switch (res.downstream) {

.http => {

// I don't know why/where the writer goes invalid, but I'll probably

// fix it later?

try res.sendHeaders();

},

else => {

try res.sendHeaders();

_ = try res.write("\r\n");

},

}

 

pub fn sendHeaders(res: *Response) !void {

switch (res.downstream) {

.zwsgi, .buffer => {

try res.sendHTTPHeader();

var itr = res.headers.headers.iterator();

pub fn writer(res: *const Response) AnyWriter {

return .{

.writeFn = typeErasedWrite,

};

}

 

comptime unreachable;

try res.writeAll(chunk);

try res.writeAll(data);

try res.writeAll("\r\n");

}

 

var index: usize = 0;

while (index < data.len) {

index += try write(res, data[index..]);

}

 

pub fn typeErasedWrite(opq: *const anyopaque, data: []const u8) anyerror!usize {

}

 

/// Raw writer, use with caution! To use phase checking, use send();

return switch (res.downstream) {

.zwsgi => |*w| try w.write(data),

.http => |*w| return try w.write(data),

};

}

 

switch (res.downstream) {

.buffer => |*w| try w.flush(),

.http => |*h| h.flush(),

pub fn finish(res: *Response) !void {

switch (res.downstream) {

.http => {

},

else => {},

}

}

 

pub const UriIter = Router.UriIter;

 

pub const Auth = @import("auth.zig");

 

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

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

}

 

/// Helper function to return a default error page for a given http status code.

return Router.defaultResponse(code)(vrs);

}

 

/// Takes a any object, that can be represented by json, converts it into a

/// json string, and sends to the client.

try vrs.quickStart();

const data = std.json.stringifyAlloc(vrs.alloc, json, .{

.emit_null_optional_fields = false,