strings: run v fmt (#7438)

cmd/tools/vtest-cleancode.v

@@ -58,6 +58,8 @@ const (
 		'vlib/v/vmod/',
 		'vlib/gg/gg.v',
 		'vlib/os/',
+		'vlib/semver/',
+		'vlib/strings/',
 		'vlib/time/',
 		'vlib/builtin/array_test.v',
 	]

vlib/strings/builder.js.v

@@ -1,7 +1,6 @@
 // Copyright (c) 2019-2020 Alexander Medvednikov. All rights reserved.
 // Use of this source code is governed by an MIT license
 // that can be found in the LICENSE file.
-
 module strings
 
 pub struct Builder {

vlib/strings/builder.v

@@ -3,8 +3,11 @@
 // that can be found in the LICENSE file.
 module strings
 
+// strings.Builder is used to efficiently append many strings to a large 
+// dynamically growing buffer, then use the resulting large string. Using
+// a string builder is much better for performance/memory usage than doing
+// constantly string concatenation.
 pub struct Builder {
-	// TODO
 pub mut:
 	buf          []byte
 	str_calls    int
@@ -12,6 +15,7 @@ pub mut:
 	initial_size int = 1
 }
 
+// new_builder returns a new string builder, with an initial capacity of `initial_size`
 pub fn new_builder(initial_size int) Builder {
 	return Builder{
 		// buf: make(0, initial_size)
@@ -22,16 +26,19 @@ pub fn new_builder(initial_size int) Builder {
 	}
 }
 
+// write_bytes appends `bytes` to the accumulated buffer
 pub fn (mut b Builder) write_bytes(bytes byteptr, howmany int) {
 	b.buf.push_many(bytes, howmany)
 	b.len += howmany
 }
 
+// write_b appends a single `data` byte to the accumulated buffer
 pub fn (mut b Builder) write_b(data byte) {
 	b.buf << data
 	b.len++
 }
 
+// write appends the string `s` to the buffer
 [inline]
 pub fn (mut b Builder) write(s string) {
 	if s == '' {
@@ -45,6 +52,7 @@ pub fn (mut b Builder) write(s string) {
 	b.len += s.len
 }
 
+// go_back discards the last `n` bytes from the buffer
 pub fn (mut b Builder) go_back(n int) {
 	b.buf.trim(b.buf.len - n)
 	b.len -= n
@@ -57,6 +65,7 @@ fn bytes2string(b []byte) string {
 	return res
 }
 
+// cut_last cuts the last `n` bytes from the buffer and returns them
 pub fn (mut b Builder) cut_last(n int) string {
 	res := bytes2string(b.buf[b.len - n..])
 	b.buf.trim(b.buf.len - n)
@@ -72,12 +81,14 @@ pub fn (mut b Builder) cut_to(pos int) string {
 	return res
 }
 */
-
+// go_back_to resets the buffer to the given position `pos`
+// NB: pos should be < than the existing buffer length.
 pub fn (mut b Builder) go_back_to(pos int) {
 	b.buf.trim(pos)
 	b.len = pos
 }
 
+// writeln appends the string `s`, and then a newline character.
 [inline]
 pub fn (mut b Builder) writeln(s string) {
 	// for c in s {
@@ -107,13 +118,13 @@ pub fn (b &Builder) after(n int) string {
 	return bytes2string(b.buf[n..])
 }
 
+// str returns all of the accumulated content of the buffer.
 // NB: in order to avoid memleaks and additional memory copies, after a call to b.str(),
 // the builder b will be empty. The returned string *owns* the accumulated data so far.
 pub fn (mut b Builder) str() string {
 	b.str_calls++
 	if b.str_calls > 1 {
-		panic('builder.str() should be called just once.\n' +
-			'If you want to reuse a builder, call b.free() first.')
+		panic('builder.str() should be called just once.\nIf you want to reuse a builder, call b.free() first.')
 	}
 	b.buf << `\0`
 	s := tos(b.buf.data, b.len)
@@ -124,10 +135,9 @@ pub fn (mut b Builder) str() string {
 	return s
 }
 
+// manually free the contents of the buffer
 pub fn (mut b Builder) free() {
-	unsafe{
-		free(b.buf.data)
-	}
+	unsafe {free(b.buf.data)}
 	// b.buf = []byte{cap: b.initial_size}
 	b.len = 0
 	b.str_calls = 0

vlib/strings/builder_test.v

@@ -30,7 +30,6 @@ fn test_sb() {
 	sb = strings.new_builder(10)
 	sb.write('x = $x y = $y')
 	assert sb.str() == 'x = 10 y = 20'
-
 	$if !windows {
 		// TODO msvc bug
 		sb = strings.new_builder(10)
@@ -62,12 +61,11 @@ fn test_big_sb() {
 	assert lines[98765] == '98765'
 	println(sb2.len)
 	assert sb2.len == maxn
-
 }
 
 fn test_byte_write() {
 	mut sb := strings.new_builder(100)
-	temp_str := "byte testing"
+	temp_str := 'byte testing'
 	mut count := 0
 	for word in temp_str {
 		sb.write_b(word)

vlib/strings/similarity.v

@@ -1,4 +1,5 @@
 module strings
+
 // #-js
 // use levenshtein distance algorithm to calculate
 // the distance between between two strings (lower is closer)
@@ -15,8 +16,7 @@ pub fn levenshtein_distance(a string, b string) int {
 			mut mn := if f[j] + 1 <= f[j - 1] + 1 { f[j] + 1 } else { f[j - 1] + 1 }
 			if cb != ca {
 				mn = if mn <= fj1 + 1 { mn } else { fj1 + 1 }
-			}
-			else {
+			} else {
 				mn = if mn <= fj1 { mn } else { fj1 }
 			}
 			fj1 = f[j]
@@ -50,7 +50,7 @@ pub fn dice_coefficient(s1 string, s2 string) f32 {
 	}
 	a := if s1.len > s2.len { s1 } else { s2 }
 	b := if a == s1 { s2 } else { s1 }
-	mut first_bigrams := map[string]int
+	mut first_bigrams := map[string]int{}
 	for i in 0 .. a.len - 1 {
 		bigram := a[i..i + 2]
 		q := if bigram in first_bigrams { first_bigrams[bigram] + 1 } else { 1 }
@@ -67,4 +67,3 @@ pub fn dice_coefficient(s1 string, s2 string) f32 {
 	}
 	return (2.0 * f32(intersection_size)) / (f32(a.len) + f32(b.len) - 2)
 }
-

vlib/strings/strings.v

@@ -1,7 +1,6 @@
 module strings
 
 // import rand
-
 // random returns a random string with `n` characters
 /*
 pub fn random(n int) string {
@@ -12,4 +11,3 @@ pub fn random(n int) string {
 	return tos(buf)
 }
 */
-