Adding more tests

Author: grantnelson-wf

playground/internal/cmd/precompile/precompile.go

@@ -63,9 +63,14 @@ func run() error {
 			return fmt.Errorf("failed to get build package for %s: %w", path, err)
 		}
 
-		if _, err = s.LoadPackages(pkg); err != nil {
+		var srcs *sources.Sources
+		if srcs, err = s.LoadPackages(pkg); err != nil {
 			return fmt.Errorf("failed to prepackaged package %q: %w", pkg, err)
 		}
+
+		if _, err := s.PrepareAndCompilePackages(srcs); err != nil {
+			return fmt.Errorf("failed to compile package %q: %w", pkg, err)
+		}
 	}
 
 	target, err := targetDir(s)

playground/internal/editor/editor.go

@@ -309,14 +309,15 @@ func (ce *codeEditor) handleMultilineComment(shift, ctrl bool) bool {
 		return false
 	}
 
+	code := ce.Code()
 	sel := ce.GetSelection()
 	if !sel.IsCaret() {
 		// If a selection, just prerform default behavior.
 		return false
 	}
 	caret := sel.Start
 
-	if caret <= 0 || ce.Code()[caret-1] != '/' {
+	if caret <= 0 || code[caret-1] != '/' {
 		// Not preceded by '/', allow default behavior.
 		return false
 	}
@@ -350,7 +351,7 @@ func (ce *codeEditor) handleNewline(shift, ctrl bool) bool {
 	if inRange(sel.End, 0, len(code)-1) {
 		switch code[sel.End] {
 		case '}', ')', ']':
-			if opening := ce.findMatchingOpeningBrace(sel.End); opening >= 0 {
+			if opening := findMatchingOpeningBrace(code, sel.End); opening >= 0 {
 				after = "\n" + ce.indentAt(opening)
 			}
 		}
@@ -626,8 +627,7 @@ func (ce *codeEditor) indentAt(start int) string {
 // for the closing brace at the given caret position.
 // Currently this does not account for braces inside strings or comments.
 // It returns -1 if no matching opening brace is found.
-func (ce *codeEditor) findMatchingOpeningBrace(caret int) int {
-	code := ce.Code()
+func findMatchingOpeningBrace(code string, caret int) int {
 	if caret <= 0 || caret > len(code) {
 		return -1
 	}

playground/internal/editor/editor_test.go

@@ -401,7 +401,97 @@ func Test_Editor_ProcessKeyDown_Tab(t *testing.T) {
 	})
 }
 
-// TODO(grantnelson-wf): Add tests for findMatchingOpeningBrace
+func Test_Editor_findMatchingOpeningBrace(t *testing.T) {
+	tests := []struct {
+		name  string
+		code  string
+		caret int
+		exp   int
+	}{
+		{
+			name:  `empty code`,
+			code:  ``,
+			caret: 0,
+			exp:   -1,
+		},
+		{
+			name:  `no braces`,
+			code:  `fmt.Println("Hello")`,
+			caret: 4, // after `fmt.`
+			exp:   -1,
+		},
+		{
+			name:  `adjacent parenthesis`,
+			code:  `func main()`,
+			caret: 10, // before `)`
+			exp:   9,  // before `(`
+		},
+		{
+			name:  `simple parenthesis`,
+			code:  `fmt.Println("Hello")`,
+			caret: 19, // before `)`
+			exp:   11, // before `(`
+		},
+		{
+			name: `nested braces`,
+			code: lines(
+				`func main() {`,
+				`	if true {`,
+				`		fmt.Println("Hello")`,
+				`	}`,
+				`}`),
+			caret: 51, // before last `}` on line 5
+			exp:   12, // before `{` on line 1
+		},
+		{
+			name:  `too many`,
+			code:  `{[()]})`,
+			caret: 6,  // before last `)`
+			exp:   -1, // no matching opening parenthesis
+		},
+		{
+			name:  `just right outter`,
+			code:  `({[()]})`,
+			caret: 7, // before last `)`
+			exp:   0, // before first `(`
+		},
+		{
+			name:  `just right inner`,
+			code:  `({[()]})`,
+			caret: 5, // before `]`
+			exp:   2, // before `[`
+		},
+		{
+			name:  `mismatched at end`,
+			code:  `[{[()]})`,
+			caret: 7,  // before last `)`
+			exp:   -1, // no matching opening parenthesis
+		},
+		{
+			name:  `mismatched in middle`,
+			code:  `({[{)]})`,
+			caret: 7,  // before last `)`
+			exp:   -1, // no matching opening parenthesis
+		},
+		{
+			// This is a known limitation since we don't parse strings.
+			// Since the brace matching is to help with indents,
+			// this is acceptable for now. It won't be hit too often in
+			// practice without unmatched braces in multiple strings.
+			name:  `quotes do not work yet`,
+			code:  `fmt.Println("(")`,
+			caret: 15, // before `)`
+			exp:   13, // incorrectly before `(` in quotes
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := findMatchingOpeningBrace(tt.code, tt.caret)
+			check(t, `position`, got, tt.exp)
+		})
+	}
+}
 
 func Test_Editor_ProcessKeyDown_Newline(t *testing.T) {
 	runKeyDownTest(t, testKeyDown{
@@ -693,15 +783,15 @@ func Test_Editor_ProcessKeyDown_SelectedLines(t *testing.T) {
 			}
 			ce := &codeEditor{CodeBoxWrapper: cb}
 			lineSel := ce.getSelectedLines()
-			check(t, "startLine", lineSel.Start, tt.wantStartLine)
-			check(t, "endLine", lineSel.End, tt.wantEndLine)
+			check(t, `startLine`, lineSel.Start, tt.wantStartLine)
+			check(t, `endLine`, lineSel.End, tt.wantEndLine)
 
 			gotSelectedLines := []string{}
 			ce.foreachLine(lineSel, func(line string, _ Selection) bool {
 				gotSelectedLines = append(gotSelectedLines, line)
 				return true
 			})
-			check(t, "selectedLines", gotSelectedLines, tt.wantSelectedLines)
+			check(t, `selectedLines`, gotSelectedLines, tt.wantSelectedLines)
 		})
 	}
 }
@@ -1224,11 +1314,11 @@ func runKeyDownTest(t *testing.T, tt testKeyDown) {
 			initSelectionEnd:   tt.selectionEnd,
 		}
 		gotPreventDefault := ProcessKeyDown(cb, tt.key, tt.shift, tt.ctrl)
-		check(t, "code", cb.gotCode, tt.wantCode)
-		check(t, "selectedStart", cb.gotSelectionStart, tt.wantSelectionStart)
-		check(t, "selectedEnd", cb.gotSelectionEnd, tt.wantSelectionEnd)
-		check(t, "preventDefault", gotPreventDefault, tt.wantPrefentDefault)
-		check(t, "eventCalls", cb.gotEventCalls, tt.wantEventCalls)
+		check(t, `code`, cb.gotCode, tt.wantCode)
+		check(t, `selectedStart`, cb.gotSelectionStart, tt.wantSelectionStart)
+		check(t, `selectedEnd`, cb.gotSelectionEnd, tt.wantSelectionEnd)
+		check(t, `preventDefault`, gotPreventDefault, tt.wantPrefentDefault)
+		check(t, `eventCalls`, cb.gotEventCalls, tt.wantEventCalls)
 	})
 }
 

playground/internal/editor/undo.go

@@ -1,12 +1,111 @@
 package editor
 
+import "time"
+
+const undoRedoJoinDuration = time.Second
+
+type undoRedoState struct {
+	prefix  int
+	suffix  int
+	oldCode string
+	newCode string
+	oldSel  Selection
+	newSel  Selection
+}
+
+type UndoRedoStack struct {
+	undos   []*undoRedoState
+	redos   []*undoRedoState
+	getTime func() time.Time
+
+	lastChange time.Time
+	lastSel    Selection
+}
+
+func NewUndoRedoStack() *UndoRedoStack {
+	return &UndoRedoStack{getTime: time.Now}
+}
+
+func (s *UndoRedoStack) PerformUndo(cb CodeBoxWrapper) {
+	// TODO(grantnelson-wf): Finish implmementing
+}
+
+func (s *UndoRedoStack) PerformRedo(cb CodeBoxWrapper) {
+	// TODO(grantnelson-wf): Finish implmementing
+}
+
+func (s *UndoRedoStack) RecordSelectionChange(cb CodeBoxWrapper) {
+	// TODO(grantnelson-wf): Finish implmementing
+
+}
+
+func (s *UndoRedoStack) RecordCodeChange(cb CodeBoxWrapper, priorCode string) {
+	//now := s.getTime()
+
+	// TODO(grantnelson-wf): Finish implmementing
+
+	s.redos = nil // clear redo stack on new code change
+}
+
 /*
-type undoState struct {
-	code string
+func (s *UndoRedoStack) joinStates(older, newer *undoRedoState) bool {
+	if newer.start.Sub(older.start) > undoRedoJoinDuration {
+		return false // changes happened too far apart in time to join
+	}
+
+	if older.prefix > newer.prefix+len(newer.newCode) ||
+		older.suffix > newer.suffix+len(newer.newCode) {
+		return false // changes don't overlap so are too far apart in code to join
+	}
 
-	beforeStartSel int
-	beforeStopSel  int
-	afterStartSel  int
-	afterStopSel   int
+	// TODO(grantnelson-wf): Finish implmementing
+
+	return true
+}
+
+func newState(priorCode, newCode string, priorSel, afterSel Selection, start time.Time) *undoRedoState {
+	prefixLen, suffixLen := diffTrim(priorCode, newCode)
+	return &undoRedoState{
+		prefix:  prefixLen,
+		suffix:  suffixLen,
+		newCode: newCode[prefixLen : len(newCode)-suffixLen],
+		prior:   priorSel,
+		after:   afterSel,
+		start:   start,
+	}
 }
 */
+
+// diffTrim returns the lengths of the common prefix and suffix between
+// prior and after strings.
+func diffTrim(prior, after string) (int, int) {
+	priorLen, afterLen := len(prior), len(after)
+	minLen := min(priorLen, afterLen)
+
+	prefixLen := 0
+	for prefixLen < minLen && prior[prefixLen] == after[prefixLen] {
+		prefixLen++
+	}
+	if prefixLen >= minLen {
+		return prefixLen, 0
+	}
+
+	suffixLen := 0
+	minLen -= prefixLen
+	priorMax, afterMax := priorLen-1, afterLen-1
+	for suffixLen < minLen && prior[priorMax] == after[afterMax] {
+		suffixLen++
+		priorMax--
+		afterMax--
+	}
+	return prefixLen, suffixLen
+}
+
+// TODO(grantnelson-wf): Remove when `min` is available in go1.21.
+// See https://pkg.go.dev/builtin#min
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}