vfmt

src/api.v

···
 
 import veb
 import auth
-import entity { Site, User, Post, Like, LikeCache }
+import entity { Like, LikeCache, Post, Site, User }
 
 ////// Users //////
 
···
 
 	salt := auth.generate_salt()
 	mut user := User{
-		username: username
-		password: auth.hash_password_with_salt(password, salt)
+		username:      username
+		password:      auth.hash_password_with_salt(password, salt)
 		password_salt: salt
 	}
 
···
 
 @['/api/user/get_name']
 fn (mut app App) api_user_get_name(mut ctx Context, username string) veb.Result {
-	user := app.get_user_by_name(username) or {
-		return ctx.server_error('no such user')
-	}
+	user := app.get_user_by_name(username) or { return ctx.server_error('no such user') }
 	return ctx.text(user.get_name())
 }
 
···
 
 	post := Post{
 		author_id: user.id
-		title: title
-		body: body
+		title:     title
+		body:      body
 	}
 
 	sql app.db {
···
 
 @['/api/post/like']
 fn (mut app App) api_post_like(mut ctx Context, id int) veb.Result {
-	user := app.whoami(mut ctx) or {
-		return ctx.unauthorized('not logged in')
-	}
+	user := app.whoami(mut ctx) or { return ctx.unauthorized('not logged in') }
 
-	post := app.get_post_by_id(id) or {
-		return ctx.server_error('post does not exist')
-	}
+	post := app.get_post_by_id(id) or { return ctx.server_error('post does not exist') }
 
 	if app.does_user_like_post(user.id, post.id) {
 		sql app.db {
···
 
 @['/api/post/dislike']
 fn (mut app App) api_post_dislike(mut ctx Context, id int) veb.Result {
-	user := app.whoami(mut ctx) or {
-		return ctx.unauthorized('not logged in')
-	}
+	user := app.whoami(mut ctx) or { return ctx.unauthorized('not logged in') }
 
-	post := app.get_post_by_id(id) or {
-		return ctx.server_error('post does not exist')
-	}
+	post := app.get_post_by_id(id) or { return ctx.server_error('post does not exist') }
 
 	if app.does_user_dislike_post(user.id, post.id) {
 		sql app.db {

src/app.v

···
 import veb
 import db.pg
 import auth
-import entity { Site, User, Post, Like, LikeCache }
+import entity { LikeCache, Like, Post, Site, User }
 
 pub struct App {
 	veb.StaticHandler
···
 	db         pg.DB
 	auth       auth.Auth[pg.DB]
 	validators struct {
-	pub:
+	pub mut:
 		username   StringValidator
 		password   StringValidator
 		nickname   StringValidator
···
 }
 
 pub fn (app &App) whoami(mut ctx Context) ?User {
-	token := ctx.get_cookie('token') or {
-		return none
-	}.trim_space()
+	token := ctx.get_cookie('token') or { return none }.trim_space()
 	if token == '' {
 		return none
 	}
···
 }
 
 pub fn (app &App) get_unknown_user() User {
-	return User{ username: 'unknown' }
+	return User{
+		username: 'unknown'
+	}
 }
 
 pub fn (app &App) logged_in_as(mut ctx Context, id int) bool {
···
 		}
 
 		// cache
-		cached := LikeCache {
+		cached := LikeCache{
 			post_id: post_id
-			likes: likes
+			likes:   likes
 		}
 		sql app.db {
 			insert cached into LikeCache
···
 
 pub fn (app &App) get_or_create_site_config() Site {
 	configs := sql app.db {
-		select from entity.Site
+		select from Site
 	} or { [] }
 	if configs.len == 0 {
 		// make the site config
-		site_config := entity.Site{ }
+		site_config := Site{}
 		sql app.db {
-			insert site_config into entity.Site
-		} or {
-			panic('failed to create site config (${err})')
-		}
+			insert site_config into Site
+		} or { panic('failed to create site config (${err})') }
 	} else if configs.len > 1 {
 		// this should never happen
 		panic('there are multiple site configs')

src/config.v

···
 pub mut:
 	dev_mode    bool
 	static_path string
-	instance struct {
+	instance    struct {
 	pub mut:
 		name                 string
 		welcome              string
 		default_theme        string
 		allow_changing_theme bool
 	}
-	http struct {
+	http        struct {
 	pub mut:
 		port int
 	}
-	postgres struct {
+	postgres    struct {
 	pub mut:
-		host string
-		port int
-		user string
+		host     string
+		port     int
+		user     string
 		password string
-		db string
+		db       string
 	}
-	post struct {
+	post        struct {
 	pub mut:
 		title_min_len int
 		title_max_len int
 		title_pattern string
-		body_min_len int
-		body_max_len int
-		body_pattern string
+		body_min_len  int
+		body_max_len  int
+		body_pattern  string
 	}
-	user struct {
+	user        struct {
 	pub mut:
 		username_min_len int
 		username_max_len int

src/entity/likes.v

···
 // Stores total likes per post
 pub struct LikeCache {
 pub mut:
-	id       int @[primary; sql: serial]
-	post_id  int
-	likes    int
+	id      int @[primary; sql: serial]
+	post_id int
+	likes   int
 }

src/entity/post.v

···
 	id        int @[primary; sql: serial]
 	author_id int
 
-	title  string
-	body   string
+	title string
+	body  string
 
 	pinned bool
 

src/entity/site.v

···
 
 pub struct Site {
 pub mut:
-	id   int    @[primary; sql: serial]
+	id   int @[primary; sql: serial]
 	motd string
 }

src/main.v

···
 
 	mut app := &App{
 		config: config
-		db: db
-		auth: auth.new(db)
-		validators: struct {
-			username:   StringValidator.new(config.user.username_min_len, config.user.username_max_len, config.user.username_pattern)
-			password:   StringValidator.new(config.user.username_min_len, config.user.username_max_len, config.user.username_pattern)
-			nickname:   StringValidator.new(config.user.nickname_min_len, config.user.nickname_max_len, config.user.nickname_pattern)
-			user_bio:   StringValidator.new(config.user.bio_min_len, config.user.bio_max_len, config.user.bio_pattern)
-			pronouns:   StringValidator.new(config.user.pronouns_min_len, config.user.pronouns_max_len, config.user.pronouns_pattern)
-			post_title: StringValidator.new(config.post.title_min_len, config.post.title_max_len, config.post.title_pattern)
-			post_body:  StringValidator.new(config.post.body_min_len, config.post.body_max_len, config.post.body_pattern)
-		}
+		db:     db
+		auth:   auth.new(db)
 	}
+
+	// vfmt off
+	app.validators.username = StringValidator.new(config.user.username_min_len, config.user.username_max_len, config.user.username_pattern)
+	app.validators.password = StringValidator.new(config.user.username_min_len, config.user.username_max_len, config.user.username_pattern)
+	app.validators.nickname = StringValidator.new(config.user.nickname_min_len, config.user.nickname_max_len, config.user.nickname_pattern)
+	app.validators.user_bio = StringValidator.new(config.user.bio_min_len, config.user.bio_max_len, config.user.bio_pattern)
+	app.validators.pronouns = StringValidator.new(config.user.pronouns_min_len, config.user.pronouns_max_len, config.user.pronouns_pattern)
+	app.validators.post_title = StringValidator.new(config.post.title_min_len, config.post.title_max_len, config.post.title_pattern)
+	app.validators.post_body = StringValidator.new(config.post.body_min_len, config.post.body_max_len, config.post.body_pattern)
+	// vfmt on
 
 	app.mount_static_folder_at(app.config.static_path, '/static')!
 	init_db(db)!

src/pages.v

···
 module main
 
 import veb
-import entity { User, Post }
+import entity { User }
 
 fn (mut app App) index(mut ctx Context) veb.Result {
 	ctx.title = app.config.instance.name

src/validation.v

···
 
 @[inline]
 pub fn (validator StringValidator) validate(str string) bool {
-	return str.len > validator.min_len && str.len < validator.max_len && validator.pattern.matches_string(str)
+	return str.len > validator.min_len && str.len < validator.max_len
+		&& validator.pattern.matches_string(str)
 }
 
 pub fn StringValidator.new(min int, max int, pattern string) StringValidator {