alazyreader/cowsay
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

more fuzzed fixes

Browse Source
This commit is contained in:
David
2024-03-30 20:10:41 -04:00
parent 6aa1219f2e
commit 377c3b02b7
12 changed files with 152 additions and 33 deletions
Download Patch File Download Diff File Expand all files Collapse all files

80
main.go
View File

@@ -14,6 +14,8 @@ import (
"golang.org/x/term"
)
const DEBUG = false
var (
// upper-left, upper-right, left side, right side, bottom-left, bottom-right
SAY_BORDER = []rune{'/', '\\', '|', '|', '\\', '/'}
@@ -103,7 +105,7 @@ func main() {
if err != nil {
log.Fatalf("error reading from stdin: %v", err)
}
input = strings.TrimSpace(string(pipedInput))
input = string(bytes.TrimSpace(pipedInput))
}
if input == "" {
@@ -115,7 +117,7 @@ func main() {
log.Fatal(err)
}
generateCow(string(b), input, opts)
fmt.Print(generateCow(string(b), input, opts))
}
func generateCow(cow, say string, opt options) string {
@@ -157,21 +159,73 @@ func generateCow(cow, say string, opt options) string {
return out.String()
}
// this is an attempt to emulate the rather poorly-documented behavior of Text::Wrap::fill
// from CPAN: https://github.com/ap/Text-Tabs/blob/master/lib.modern/Text/Wrap.pm
// The basic idea is: take an input. Format each "paragraph" of text independently,
// then merge with empty lines between.
//
// What is under-defined in the documentation is what fill() considers a "paragraph".
// From testing and reviewing the rather obtuse code, a paragraph is any number of lines
// that start with a line that has optional whitespace at its start, then all subsequent lines
// that have no whitespace at the start, until either reaching another line that has leading
// whitespace, or a blank line. fill() also "destroy[s] any whitespace in the original text",
// by which it appearently means all tabs and multiple-spaces are replaced with single-spaces.
//
// So, for example, `text\ntext` is one paragraph, `text\n text` is two paragraphs. Since for
// our purposes we don't want any indentation of paragraphs, the output of these two examples
// should be `text text` and `text\n\ntext`, respectively.
//
// This is a pretty gnarly! Might be easier in a multi-pass model: collect together each paragraph,
// collapse them into single strings and format in a sub-function, then merge them all together.
// That's closer to how the perl module does it.
func wordWrap(text []string, column int) ([]string, int) {
out := []string{}
length := 0
var b strings.Builder
for _, line := range text {
b = strings.Builder{}
var inParagraph bool
for beginning, line := range text {
// remove control character whitespace
line = strings.ReplaceAll(line, "\t", " ")
line = strings.ReplaceAll(line, "\v", " ")
line = strings.ReplaceAll(line, "\f", " ")
line = strings.ReplaceAll(line, "\r", " ")
words := strings.Split(line, " ")
// skip empty newlines if not in a paragraph, but start a new paragraph if we are.
if strings.TrimSpace(line) == "" {
if inParagraph {
length = max(length, b.Len()-1)
out = append(out, b.String()[0:b.Len()-1])
out = append(out, "")
b = strings.Builder{}
inParagraph = false
}
continue
}
// we -1 all over the place to clean up the loose space on the end of the builder
for _, word := range words { // split into words
if b.Len() > 0 && word == "" {
// skip multiple spaces in a row
for i, word := range words { // split into words
if DEBUG {
log.Printf("%d, `%s`", i, b.String())
}
if inParagraph && i == 0 && word == "" && len(words) != 0 {
// we've found a new paragraph while we were still processing the old one.
// (that is, the new line we're parsing had leading whitespace)
length = max(length, b.Len()-1)
out = append(out, b.String()[0:b.Len()-1])
out = append(out, "")
b = strings.Builder{}
log.Println("here")
}
// bizarrely, cowsay allows for indentation to survive in the /first/ paragraph,
// but only up to two spaces worth.
if beginning == 0 && (b.Len() == 0 || b.String() == " ") && word == "" {
b.WriteRune(' ')
}
if b.Len() == 0 && word != "" {
inParagraph = true
}
if b.Len() >= 0 && word == "" && i+1 != len(words) {
// skip multiple spaces in a row...
// ...but a single trailing space on a line is OK??
continue
}
if b.Len() > 0 && b.Len()+len(word)+1 > column {
@@ -182,8 +236,9 @@ func wordWrap(text []string, column int) ([]string, int) {
out = append(out, b.String()[0:b.Len()-1])
b = strings.Builder{}
}
if b.Len() == 0 && len(word) >= column {
for b.Len() == 0 && len(word) >= column {
// our word is longer than our maximum column size. let's break it up.
// we loop until we've consumed the full overly-long word.
length = max(length, column-1)
out = append(out, word[0:column-1])
word = word[column-1:]
@@ -192,11 +247,14 @@ func wordWrap(text []string, column int) ([]string, int) {
// actually append the word and a space
b.WriteString(word)
b.WriteRune(' ')
if DEBUG {
log.Printf("%d, `%s`", i, b.String())
}
}
// out of words in the line, so save it off and start on the next one
length = max(length, b.Len()-1)
out = append(out, b.String()[0:b.Len()-1])
}
// out of words! save off our last line.
length = max(length, b.Len()-1)
out = append(out, b.String()[0:b.Len()-1])
return out, length
}

36
main_test.go
View File

@@ -43,28 +43,37 @@ func TestGenerateCow(t *testing.T) {
expected: string(must(os.ReadFile("./testdata/basic.cow"))),
},
{
name: "multiline test",
name: "single-paragraph test",
args: args{
cow: string(must(os.ReadFile("./cows/default.cow"))),
say: "test\ntext",
opt: defaultOptions,
},
expected: string(must(os.ReadFile("./testdata/multiline.cow"))),
expected: string(must(os.ReadFile("./testdata/one_paragraph.cow"))),
},
{
name: "multiline with wordwrap test",
args: args{
cow: string(must(os.ReadFile("./cows/default.cow"))),
say: "this is a long block of text.\n\n\nIt goes over many lines! It'll even word-wrap for us.",
say: "this is a long block of text.\nIt goes over many lines! It'll even word-wrap for us.",
opt: defaultOptions,
},
expected: string(must(os.ReadFile("./testdata/longer_multiline.cow"))),
},
{
name: "two-paragraph multiline with wordwrap test",
args: args{
cow: string(must(os.ReadFile("./cows/default.cow"))),
say: "this is a long block of text.\n\nIt goes over many lines! It'll even word-wrap for us.",
opt: defaultOptions,
},
expected: string(must(os.ReadFile("./testdata/two_paragraph_multiline.cow"))),
},
{
name: "offset bubble",
args: args{
cow: string(must(os.ReadFile("./cows/dragon-and-cow.cow"))),
say: "this is a long block of text.\n\n\nIt goes over many lines! It'll even word-wrap for us.",
say: "this is a long block of text.\nIt goes over many lines! It'll even word-wrap for us.",
opt: defaultOptions,
},
expected: string(must(os.ReadFile("./testdata/dragon.cow"))),
@@ -105,6 +114,25 @@ func TestGenerateCow(t *testing.T) {
},
expected: string(must(os.ReadFile("./testdata/too_long.cow"))),
},
{
name: "fortune cow",
args: args{
cow: string(must(os.ReadFile("./cows/default.cow"))),
say: `Most people eat as though they were fattening themselves for market.
-- E.W. Howe`,
opt: defaultOptions,
},
expected: string(must(os.ReadFile("./testdata/fortune.cow"))),
},
{
name: "trailing space cow",
args: args{
cow: string(must(os.ReadFile("./cows/default.cow"))),
say: `test `,
opt: defaultOptions,
},
expected: string(must(os.ReadFile("./testdata/trailing_space.cow"))),
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {

12
testdata/dragon.cow vendored
View File

@@ -1,10 +1,8 @@
_____________________________________
/ this is a long block of text. \
| |
| |
| It goes over many lines! It'll even |
\ word-wrap for us. /
-------------------------------------
_______________________________________
/ this is a long block of text. It goes \
| over many lines! It'll even word-wrap |
\ for us. /
---------------------------------------
\ ^ /^
\ / \ // \
\ |\___/| / \// .\

11
testdata/fortune.cow vendored Normal file
View File

@@ -0,0 +1,11 @@
_____________________________________
/ Most people eat as though they were \
| fattening themselves for market. |
| |
\ -- E.W. Howe /
-------------------------------------
\ ^__^
\ (oo)\_______
(__)\ )\/\
||----w |
|| ||

2
testdata/fuzz/FuzzCow/7b9a589d5aa859e5 vendored Normal file
View File

@@ -0,0 +1,2 @@
go test fuzz v1
string("0 \n0")

2
testdata/fuzz/FuzzCow/93d7daf11243d295 vendored Normal file
View File

@@ -0,0 +1,2 @@
go test fuzz v1
string("0000000000000000000000000000000000000000000000000000000000000000000000000000000")

2
testdata/fuzz/FuzzCow/ceaa3f997e266d98 vendored Normal file
View File

@@ -0,0 +1,2 @@
go test fuzz v1
string("0 \n 0")

2
testdata/fuzz/FuzzCow/dde7a120ccdf11af vendored Normal file
View File

@@ -0,0 +1,2 @@
go test fuzz v1
string("0\r0")

12
testdata/longer_multiline.cow vendored
View File

@@ -1,10 +1,8 @@
_____________________________________
/ this is a long block of text. \
| |
| |
| It goes over many lines! It'll even |
\ word-wrap for us. /
-------------------------------------
_______________________________________
/ this is a long block of text. It goes \
| over many lines! It'll even word-wrap |
\ for us. /
---------------------------------------
\ ^__^
\ (oo)\_______
(__)\ )\/\

8
testdata/one_paragraph.cow vendored Normal file
View File

@@ -0,0 +1,8 @@
___________
< test text >
-----------
\ ^__^
\ (oo)\_______
(__)\ )\/\
||----w |
|| ||

7
testdata/multiline.cow → testdata/trailing_space.cow vendored
View File

@@ -1,7 +1,6 @@
______
/ test \
\ text /
------
_______
< test >
-------
\ ^__^
\ (oo)\_______
(__)\ )\/\

11
testdata/two_paragraph_multiline.cow vendored Normal file
View File

@@ -0,0 +1,11 @@
_____________________________________
/ this is a long block of text. \
| |
| It goes over many lines! It'll even |
\ word-wrap for us. /
-------------------------------------
\ ^__^
\ (oo)\_______
(__)\ )\/\
||----w |
|| ||