feat: StringBuilder uses builder pattern

linkdotnet · linkdotnet · commit 202a72f07c44 · 2023-08-21T07:43:59.000+02:00
diff --git a/stringbuilder.go b/stringbuilder.go
@@ -22,7 +22,7 @@ func NewStringBuilderFromString(text string) *StringBuilder {
 }
 
 // Appends a text to the StringBuilder instance
-func (s *StringBuilder) Append(text string) {
+func (s *StringBuilder) Append(text string) *StringBuilder {
 	textRunes := []rune(text)
 	newLen := s.position + len(textRunes)
 	if newLen > cap(s.data) {
@@ -31,23 +31,29 @@ func (s *StringBuilder) Append(text string) {
 
 	copy(s.data[s.position:], textRunes)
 	s.position = newLen
+
+	return s
 }
 
 // Appends a text and a new line character to the StringBuilder instance
-func (s *StringBuilder) AppendLine(text string) {
+func (s *StringBuilder) AppendLine(text string) *StringBuilder {
 	s.Append(text)
 	s.Append("\n")
+
+	return s
 }
 
 // Appends a single character to the StringBuilder instance
-func (s *StringBuilder) AppendRune(char rune) {
+func (s *StringBuilder) AppendRune(char rune) *StringBuilder {
 	newLen := s.position + 1
 	if newLen > cap(s.data) {
 		s.grow(newLen)
 	}
 
 	s.data[s.position] = char
 	s.position++
+
+	return s
 }
 
 // Returns the current length of the represented string
@@ -60,41 +66,41 @@ func (s *StringBuilder) ToString() string {
 	return string(s.data[:s.position])
 }
 
-func (s *StringBuilder) Remove(start int, length int) error {
+func (s *StringBuilder) Remove(start int, length int) (*StringBuilder, error) {
 	if start >= s.position {
-		return fmt.Errorf("start is after the end of the string")
+		return s, fmt.Errorf("start is after the end of the string")
 	}
 	if start < 0 {
-		return fmt.Errorf("start can't be a negative value")
+		return s, fmt.Errorf("start can't be a negative value")
 	}
 	if length < 0 {
-		return fmt.Errorf("length can't be a negative value")
+		return s, fmt.Errorf("length can't be a negative value")
 	}
 
 	endIndex := start + length - 1
 
 	if endIndex > s.position {
-		return fmt.Errorf("can't delete after the end of the string")
+		return s, fmt.Errorf("can't delete after the end of the string")
 	}
 
 	if length == 0 {
-		return nil
+		return s, nil
 	}
 
 	x := start + length
 	copy(s.data[start:], s.data[x:])
 	s.position -= length
 
-	return nil
+	return s, nil
 }
 
-func (s *StringBuilder) Insert(index int, text string) error {
+func (s *StringBuilder) Insert(index int, text string) (*StringBuilder, error) {
 	if index < 0 {
-		return fmt.Errorf("index can't be negative")
+		return s, fmt.Errorf("index can't be negative")
 	}
 
 	if index > s.position {
-		return fmt.Errorf("can't write outside the buffer")
+		return s, fmt.Errorf("can't write outside the buffer")
 	}
 
 	runeText := []rune(text)
@@ -106,7 +112,7 @@ func (s *StringBuilder) Insert(index int, text string) error {
 	s.data = append(s.data[:index], append(runeText, s.data[index:]...)...)
 	s.position = newLen
 
-	return nil
+	return s, nil
 }
 
 // Removes all characters from the current instance. This sets the internal size to 0.
@@ -142,18 +148,20 @@ func (s *StringBuilder) FindAll(text string) []int {
 }
 
 // Replaces all occurrences of oldValue with newValue
-func (s *StringBuilder) ReplaceRune(oldValue rune, newValue rune) {
+func (s *StringBuilder) ReplaceRune(oldValue rune, newValue rune) *StringBuilder {
 	occurrences := s.FindAll(string(oldValue))
 
 	for _, v := range occurrences {
 		s.data[v] = newValue
 	}
+
+	return s
 }
 
 // Replaces all occurrences of oldValue with newValue
-func (s *StringBuilder) Replace(oldValue string, newValue string) {
+func (s *StringBuilder) Replace(oldValue string, newValue string) *StringBuilder {
 	if oldValue == newValue {
-		return
+		return s
 	}
 
 	occurrences := s.FindAll(oldValue)
@@ -183,6 +191,8 @@ func (s *StringBuilder) Replace(oldValue string, newValue string) {
 			s.Insert(index+oldLen, string(newValueRunes[len(oldValueRunes):]))
 		}
 	}
+
+	return s
 }
 
 // Implements the io.Writer interface so the StringBuilder can be used with fmt.Printf
diff --git a/stringbuilder_test.go b/stringbuilder_test.go
@@ -92,7 +92,7 @@ func TestNewFromString(t *testing.T) {
 func TestRemovePartOfString(t *testing.T) {
 	sb := NewStringBuilderFromString("Hello")
 
-	if err := sb.Remove(3, 2); err != nil {
+	if _, err := sb.Remove(3, 2); err != nil {
 		t.Errorf("Remove threw an error: %v", err)
 	}
 
@@ -104,31 +104,31 @@ func TestRemovePartOfString(t *testing.T) {
 func TestRemoveWhenStartIndexOutOfBounds(t *testing.T) {
 	sb := NewStringBuilderFromString("Hello")
 
-	if err := sb.Remove(100, 1); err == nil {
+	if _, err := sb.Remove(100, 1); err == nil {
 		t.Error("Should throw error but did not")
 	}
 }
 
 func TestRemoveWhenStartIndexNegative(t *testing.T) {
 	sb := NewStringBuilderFromString("Hello")
 
-	if err := sb.Remove(-1, 1); err == nil {
+	if _, err := sb.Remove(-1, 1); err == nil {
 		t.Error("Should throw error but did not")
 	}
 }
 
 func TestRemoveWhenLengthNegative(t *testing.T) {
 	sb := NewStringBuilderFromString("Hello")
 
-	if err := sb.Remove(1, -1); err == nil {
+	if _, err := sb.Remove(1, -1); err == nil {
 		t.Error("Should throw error but did not")
 	}
 }
 
 func TestRemoveWhenEndIndexOutOfBounds(t *testing.T) {
 	sb := NewStringBuilderFromString("Hello")
 
-	if err := sb.Remove(4, 4); err == nil {
+	if _, err := sb.Remove(4, 4); err == nil {
 		t.Error("Should throw error but did not")
 	}
 }
@@ -137,7 +137,7 @@ func TestRemoveWhenLengthZero(t *testing.T) {
 	const expected string = "Hello"
 	sb := NewStringBuilderFromString(expected)
 
-	if err := sb.Remove(0, 0); err != nil {
+	if _, err := sb.Remove(0, 0); err != nil {
 		t.Errorf("Remove threw an error: %v", err)
 	}
 
@@ -150,7 +150,7 @@ func TestRemoveInTheMiddle(t *testing.T) {
 	const expected string = "Hlo World"
 	sb := NewStringBuilderFromString("Hello World")
 
-	if err := sb.Remove(1, 2); err != nil {
+	if _, err := sb.Remove(1, 2); err != nil {
 		t.Errorf("Remove threw an error: %v", err)
 	}
 
@@ -163,7 +163,7 @@ func TestInsertAtIndex(t *testing.T) {
 	const expected string = "Hello my dear and beautiful World"
 	sb := NewStringBuilderFromString("Hello World")
 
-	if err := sb.Insert(5, " my dear and beautiful"); err != nil {
+	if _, err := sb.Insert(5, " my dear and beautiful"); err != nil {
 		t.Errorf("Insert threw an error: %v", err)
 	}
 
@@ -175,15 +175,15 @@ func TestInsertAtIndex(t *testing.T) {
 func TestInsertShouldThrowIfNegativeIndex(t *testing.T) {
 	sb := StringBuilder{}
 
-	if err := sb.Insert(-1, "Test"); err == nil {
+	if _, err := sb.Insert(-1, "Test"); err == nil {
 		t.Error("Should throw error but did not")
 	}
 }
 
 func TestInsertShouldThrowErrirIfOutOfRange(t *testing.T) {
 	sb := StringBuilder{}
 
-	if err := sb.Insert(1, "Test"); err == nil {
+	if _, err := sb.Insert(1, "Test"); err == nil {
 		t.Error("Should throw error but did not")
 	}
 }

Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ func NewStringBuilderFromString(text string) *StringBuilder {`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`// Appends a text to the StringBuilder instance`
`25`		`-func (s *StringBuilder) Append(text string) {`
	`25`	`+func (s StringBuilder) Append(text string) StringBuilder {`
`26`	`26`	`textRunes := []rune(text)`
`27`	`27`	`newLen := s.position + len(textRunes)`
`28`	`28`	`if newLen > cap(s.data) {`
`@@ -31,23 +31,29 @@ func (s *StringBuilder) Append(text string) {`
`31`	`31`
`32`	`32`	`copy(s.data[s.position:], textRunes)`
`33`	`33`	`s.position = newLen`
	`34`	`+`
	`35`	`+ return s`
`34`	`36`	`}`
`35`	`37`
`36`	`38`	`// Appends a text and a new line character to the StringBuilder instance`
`37`		`-func (s *StringBuilder) AppendLine(text string) {`
	`39`	`+func (s StringBuilder) AppendLine(text string) StringBuilder {`
`38`	`40`	`s.Append(text)`
`39`	`41`	`s.Append("\n")`
	`42`	`+`
	`43`	`+ return s`
`40`	`44`	`}`
`41`	`45`
`42`	`46`	`// Appends a single character to the StringBuilder instance`
`43`		`-func (s *StringBuilder) AppendRune(char rune) {`
	`47`	`+func (s StringBuilder) AppendRune(char rune) StringBuilder {`
`44`	`48`	`newLen := s.position + 1`
`45`	`49`	`if newLen > cap(s.data) {`
`46`	`50`	`s.grow(newLen)`
`47`	`51`	`}`
`48`	`52`
`49`	`53`	`s.data[s.position] = char`
`50`	`54`	`s.position++`
	`55`	`+`
	`56`	`+ return s`
`51`	`57`	`}`
`52`	`58`
`53`	`59`	`// Returns the current length of the represented string`
`@@ -60,41 +66,41 @@ func (s *StringBuilder) ToString() string {`
`60`	`66`	`return string(s.data[:s.position])`
`61`	`67`	`}`
`62`	`68`
`63`		`-func (s *StringBuilder) Remove(start int, length int) error {`
	`69`	`+func (s StringBuilder) Remove(start int, length int) (StringBuilder, error) {`
`64`	`70`	`if start >= s.position {`
`65`		`- return fmt.Errorf("start is after the end of the string")`
	`71`	`+ return s, fmt.Errorf("start is after the end of the string")`
`66`	`72`	`}`
`67`	`73`	`if start < 0 {`
`68`		`- return fmt.Errorf("start can't be a negative value")`
	`74`	`+ return s, fmt.Errorf("start can't be a negative value")`
`69`	`75`	`}`
`70`	`76`	`if length < 0 {`
`71`		`- return fmt.Errorf("length can't be a negative value")`
	`77`	`+ return s, fmt.Errorf("length can't be a negative value")`
`72`	`78`	`}`
`73`	`79`
`74`	`80`	`endIndex := start + length - 1`
`75`	`81`
`76`	`82`	`if endIndex > s.position {`
`77`		`- return fmt.Errorf("can't delete after the end of the string")`
	`83`	`+ return s, fmt.Errorf("can't delete after the end of the string")`
`78`	`84`	`}`
`79`	`85`
`80`	`86`	`if length == 0 {`
`81`		`- return nil`
	`87`	`+ return s, nil`
`82`	`88`	`}`
`83`	`89`
`84`	`90`	`x := start + length`
`85`	`91`	`copy(s.data[start:], s.data[x:])`
`86`	`92`	`s.position -= length`
`87`	`93`
`88`		`- return nil`
	`94`	`+ return s, nil`
`89`	`95`	`}`
`90`	`96`
`91`		`-func (s *StringBuilder) Insert(index int, text string) error {`
	`97`	`+func (s StringBuilder) Insert(index int, text string) (StringBuilder, error) {`
`92`	`98`	`if index < 0 {`
`93`		`- return fmt.Errorf("index can't be negative")`
	`99`	`+ return s, fmt.Errorf("index can't be negative")`
`94`	`100`	`}`
`95`	`101`
`96`	`102`	`if index > s.position {`
`97`		`- return fmt.Errorf("can't write outside the buffer")`
	`103`	`+ return s, fmt.Errorf("can't write outside the buffer")`
`98`	`104`	`}`
`99`	`105`
`100`	`106`	`runeText := []rune(text)`
`@@ -106,7 +112,7 @@ func (s *StringBuilder) Insert(index int, text string) error {`
`106`	`112`	`s.data = append(s.data[:index], append(runeText, s.data[index:]...)...)`
`107`	`113`	`s.position = newLen`
`108`	`114`
`109`		`- return nil`
	`115`	`+ return s, nil`
`110`	`116`	`}`
`111`	`117`
`112`	`118`	`// Removes all characters from the current instance. This sets the internal size to 0.`
`@@ -142,18 +148,20 @@ func (s *StringBuilder) FindAll(text string) []int {`
`142`	`148`	`}`
`143`	`149`
`144`	`150`	`// Replaces all occurrences of oldValue with newValue`
`145`		`-func (s *StringBuilder) ReplaceRune(oldValue rune, newValue rune) {`
	`151`	`+func (s StringBuilder) ReplaceRune(oldValue rune, newValue rune) StringBuilder {`
`146`	`152`	`occurrences := s.FindAll(string(oldValue))`
`147`	`153`
`148`	`154`	`for _, v := range occurrences {`
`149`	`155`	`s.data[v] = newValue`
`150`	`156`	`}`
	`157`	`+`
	`158`	`+ return s`
`151`	`159`	`}`
`152`	`160`
`153`	`161`	`// Replaces all occurrences of oldValue with newValue`
`154`		`-func (s *StringBuilder) Replace(oldValue string, newValue string) {`
	`162`	`+func (s StringBuilder) Replace(oldValue string, newValue string) StringBuilder {`
`155`	`163`	`if oldValue == newValue {`
`156`		`- return`
	`164`	`+ return s`
`157`	`165`	`}`
`158`	`166`
`159`	`167`	`occurrences := s.FindAll(oldValue)`
`@@ -183,6 +191,8 @@ func (s *StringBuilder) Replace(oldValue string, newValue string) {`
`183`	`191`	`s.Insert(index+oldLen, string(newValueRunes[len(oldValueRunes):]))`
`184`	`192`	`}`
`185`	`193`	`}`
	`194`	`+`
	`195`	`+ return s`
`186`	`196`	`}`
`187`	`197`
`188`	`198`	`// Implements the io.Writer interface so the StringBuilder can be used with fmt.Printf`
Original file line number	Diff line number	Diff line change
`@@ -92,7 +92,7 @@ func TestNewFromString(t *testing.T) {`
`92`	`92`	`func TestRemovePartOfString(t *testing.T) {`
`93`	`93`	`sb := NewStringBuilderFromString("Hello")`
`94`	`94`
`95`		`- if err := sb.Remove(3, 2); err != nil {`
	`95`	`+ if _, err := sb.Remove(3, 2); err != nil {`
`96`	`96`	`t.Errorf("Remove threw an error: %v", err)`
`97`	`97`	`}`
`98`	`98`
`@@ -104,31 +104,31 @@ func TestRemovePartOfString(t *testing.T) {`
`104`	`104`	`func TestRemoveWhenStartIndexOutOfBounds(t *testing.T) {`
`105`	`105`	`sb := NewStringBuilderFromString("Hello")`
`106`	`106`
`107`		`- if err := sb.Remove(100, 1); err == nil {`
	`107`	`+ if _, err := sb.Remove(100, 1); err == nil {`
`108`	`108`	`t.Error("Should throw error but did not")`
`109`	`109`	`}`
`110`	`110`	`}`
`111`	`111`
`112`	`112`	`func TestRemoveWhenStartIndexNegative(t *testing.T) {`
`113`	`113`	`sb := NewStringBuilderFromString("Hello")`
`114`	`114`
`115`		`- if err := sb.Remove(-1, 1); err == nil {`
	`115`	`+ if _, err := sb.Remove(-1, 1); err == nil {`
`116`	`116`	`t.Error("Should throw error but did not")`
`117`	`117`	`}`
`118`	`118`	`}`
`119`	`119`
`120`	`120`	`func TestRemoveWhenLengthNegative(t *testing.T) {`
`121`	`121`	`sb := NewStringBuilderFromString("Hello")`
`122`	`122`
`123`		`- if err := sb.Remove(1, -1); err == nil {`
	`123`	`+ if _, err := sb.Remove(1, -1); err == nil {`
`124`	`124`	`t.Error("Should throw error but did not")`
`125`	`125`	`}`
`126`	`126`	`}`
`127`	`127`
`128`	`128`	`func TestRemoveWhenEndIndexOutOfBounds(t *testing.T) {`
`129`	`129`	`sb := NewStringBuilderFromString("Hello")`
`130`	`130`
`131`		`- if err := sb.Remove(4, 4); err == nil {`
	`131`	`+ if _, err := sb.Remove(4, 4); err == nil {`
`132`	`132`	`t.Error("Should throw error but did not")`
`133`	`133`	`}`
`134`	`134`	`}`
`@@ -137,7 +137,7 @@ func TestRemoveWhenLengthZero(t *testing.T) {`
`137`	`137`	`const expected string = "Hello"`
`138`	`138`	`sb := NewStringBuilderFromString(expected)`
`139`	`139`
`140`		`- if err := sb.Remove(0, 0); err != nil {`
	`140`	`+ if _, err := sb.Remove(0, 0); err != nil {`
`141`	`141`	`t.Errorf("Remove threw an error: %v", err)`
`142`	`142`	`}`
`143`	`143`
`@@ -150,7 +150,7 @@ func TestRemoveInTheMiddle(t *testing.T) {`
`150`	`150`	`const expected string = "Hlo World"`
`151`	`151`	`sb := NewStringBuilderFromString("Hello World")`
`152`	`152`
`153`		`- if err := sb.Remove(1, 2); err != nil {`
	`153`	`+ if _, err := sb.Remove(1, 2); err != nil {`
`154`	`154`	`t.Errorf("Remove threw an error: %v", err)`
`155`	`155`	`}`
`156`	`156`
`@@ -163,7 +163,7 @@ func TestInsertAtIndex(t *testing.T) {`
`163`	`163`	`const expected string = "Hello my dear and beautiful World"`
`164`	`164`	`sb := NewStringBuilderFromString("Hello World")`
`165`	`165`
`166`		`- if err := sb.Insert(5, " my dear and beautiful"); err != nil {`
	`166`	`+ if _, err := sb.Insert(5, " my dear and beautiful"); err != nil {`
`167`	`167`	`t.Errorf("Insert threw an error: %v", err)`
`168`	`168`	`}`
`169`	`169`
`@@ -175,15 +175,15 @@ func TestInsertAtIndex(t *testing.T) {`
`175`	`175`	`func TestInsertShouldThrowIfNegativeIndex(t *testing.T) {`
`176`	`176`	`sb := StringBuilder{}`
`177`	`177`
`178`		`- if err := sb.Insert(-1, "Test"); err == nil {`
	`178`	`+ if _, err := sb.Insert(-1, "Test"); err == nil {`
`179`	`179`	`t.Error("Should throw error but did not")`
`180`	`180`	`}`
`181`	`181`	`}`
`182`	`182`
`183`	`183`	`func TestInsertShouldThrowErrirIfOutOfRange(t *testing.T) {`
`184`	`184`	`sb := StringBuilder{}`
`185`	`185`
`186`		`- if err := sb.Insert(1, "Test"); err == nil {`
	`186`	`+ if _, err := sb.Insert(1, "Test"); err == nil {`
`187`	`187`	`t.Error("Should throw error but did not")`
`188`	`188`	`}`
`189`	`189`	`}`