look: fixes festering look bugs

- selection no longer expands when clicking inside of a partial word
- add tests for selections and looks
- add edit refresh (experiment)
- document look behavior

Author: as

addr.go

@@ -0,0 +1,47 @@
+package main
+
+import (
+	"github.com/as/text"
+	"github.com/as/text/find"
+)
+
+type q int64
+
+func (a q) In(a1 Addr) bool { return text.Region3(int64(a), int64(a1.s-1), int64(a1.e)) == 0 }
+
+type Addr struct {
+	s q
+	e q
+}
+
+type a = Addr
+
+func d2a(q0, q1 int64) Addr { return Addr{q(q0), q(q1)} }
+
+func (a Addr) Empty() bool { return a.s == a.e }
+func (a Addr) Len() int    { return int(a.e - a.s) }
+func (a Addr) In(a1 Addr) bool {
+	if a.Empty() {
+		return a.e.In(a1)
+	}
+	return a.Len() <= a1.Len() && text.Region5(int64(a.s), int64(a.e), int64(a1.s), int64(a1.e)) == 0
+}
+func (a Addr) Dot() (q0, q1 int64) { return int64(a.s), int64(a.e) }
+
+func expandAddr(a Addr, ed text.Editor) Addr {
+	if !a.Empty() {
+		return a
+	}
+	a0 := d2a(ed.Dot())
+	if a.In(a0) {
+		return a0
+	}
+	return a
+}
+
+func expandFile(a Addr, ed text.Editor) Addr {
+	if !a.Empty() {
+		return a
+	}
+	return d2a(find.ExpandFile(ed.Bytes(), int64(a.s)))
+}

cmd.go

@@ -89,6 +89,7 @@ func acmd(e event.Cmd) {
 		if strings.HasPrefix(s, "Edit ") {
 			s = s[5:]
 			editcmd(e.To[0], abs, s)
+			editRefresh(e.To[0])
 		} else if strings.HasPrefix(s, "Install ") {
 			s = s[8:]
 			g.Install(actTag, s)

edit.go

@@ -5,6 +5,22 @@ import (
 	"github.com/as/text"
 )
 
+func editRefresh(ed text.Editor) {
+	type r interface {
+		Refresh()
+	}
+	type u interface {
+		Upload()
+	}
+
+	if ed, ok := ed.(r); ok {
+		ed.Refresh()
+	}
+	if ed, ok := ed.(u); ok {
+		ed.Upload()
+	}
+}
+
 func (g *Grid) EditRun(prog string, ed text.Editor) (ok bool) {
 	//TODO(as): danger, edit needs a way to ensure it will only jump to an address
 	if prog == "" {

look.go

@@ -13,6 +13,7 @@ import (
 	"github.com/as/text"
 	"github.com/as/text/action"
 	"github.com/as/text/find"
+	"github.com/as/ui/col"
 	"github.com/as/ui/tag"
 	"github.com/as/ui/win"
 )
@@ -107,10 +108,24 @@ func (e *Looker) LookGrid(g *Grid) (error) {
 }
 */
 
+type vis struct {
+}
+
+func (v *vis) Look(e event.Look) {
+}
+
 func (g *Grid) cwd() string {
 	s, _ := os.Getwd()
 	return s
 }
+
+// hiclick returns true if the nil address (q0,q1) intersects
+// the highlighted selection (r0:r1)
+func hiclick(r0, r1, q0, q1 int64) bool {
+	x := r0 == r1 && text.Region3(r0, q0-1, q1) == 0
+	return x
+}
+
 func (g *Grid) Look(e event.Look) {
 	if g.meta(g.Tag) {
 		return
@@ -119,9 +134,27 @@ func (g *Grid) Look(e event.Look) {
 	ed := e.To[0]
 	t, _ := ed.(*tag.Tag)
 
-	e.Q0, e.Q1 = expand3(ed, e.Q0, e.Q1)
+	p0, p1 := e.From.Dot() // pre-sweep
+	// e.Q0 and e.Q1 is post sweep
+
+	if e.Q0 == e.Q1 && !hiclick(e.Q0, e.Q1, p0, p1) {
+		// one click outside old selection
+		// expand the address
+		a1 := expandFile(d2a(e.Q0, e.Q1), e.From)
+		e.Q0, e.Q1 = a1.Dot()
+	} else if e.Q0 == e.Q1 {
+		// click inside old selection
+		// use the old selection
+		e.Q0, e.Q1 = p0, p1
+	} else {
+		// selection overlaps old selection
+		// we don't care about that
+	}
+
+	//fmt.Printf("name and dot %q %d %d\n", e.P, e.Q0, e.Q1)
+	e.P = e.P[e.Q0:e.Q1] //ed.Bytes()
+
 	name, addr := action.SplitPath(string(e.P))
-	//	e.P = ed.Bytes()[e.Q0:e.Q1]
 	if name == "" && addr == "" {
 		return
 	}
@@ -185,7 +218,7 @@ func (g *Grid) Look(e event.Look) {
 	}
 
 	//TODO(as): fix this so it doesn't compare hard coded coordinates
-	if e.To[0].(*win.Win) == nil || e.To[0].(Plane).Loc().Max.Y < 48 {
+	if e.To[0].(*win.Win) == nil {
 		VisitAll(g, func(p Named) {
 			if p == nil {
 				return
@@ -200,7 +233,26 @@ func (g *Grid) Look(e event.Look) {
 		}
 	}
 }
+
+func stub(g *Grid, p Plane) bool {
+	if p == nil {
+		return false
+	}
+	if p == g.Tag {
+		return true
+	}
+	l := g.Kids()
+	for i := range l {
+		c, _ := l[i].(*col.Col)
+		if c != nil && p == c.Tag {
+			return true
+		}
+	}
+	return false
+}
+
 func (g *Grid) afinderr(wd string, name string) *tag.Tag {
+
 	name = strings.TrimSpace(name)
 	if !strings.HasSuffix(name, "+Errors") {
 		name += "+Errors"
@@ -236,16 +288,6 @@ func (g *Grid) aout(fm string, i ...interface{}) {
 	ajump(t.Body, cursorNop)
 }
 
-// expand3 return (r0:r1) if and only if that range is wide and
-// not inside ed's dot, otherwise it returns dot
-func expand3(ed text.Editor, r0, r1 int64) (int64, int64) {
-	q0, q1 := ed.Dot()
-	if r0 == r1 && text.Region3(r0, q0, q1) == 0 {
-		return q0, q1
-	}
-	return r0, r1
-}
-
 func lookliteraltag(ed text.Editor, q0, q1 int64, what []byte) {
 	q0, q1 = ed.Dot()
 	s0, s1 := find.FindNext(ed, q0, q1, what)
@@ -262,16 +304,14 @@ func lookliteral(ed text.Editor, e event.Look, mouseFunc func(image.Point)) {
 	// If the found range is identical to the starting point, no result has been found
 
 	t0, t1 := ed.Dot()
-	//	g.aerr("lookliteral:  dot(%d:%d)", t0, t1)
-	//	g.aerr("lookliteral: find(%d:%d) [%q]", e.Q0, e.Q1, e.P)
-	q0, q1 := find.FindNext(ed, e.Q0, e.Q1, e.P)
-	//	g.aerr("lookliteral: next(%d:%d)", q0, q1)
+
+	q0, q1 := find.FindNext(ed, e.Q1, e.Q1, e.P)
+	//fmt.Printf("after q0,q1: %d,%d\n\n\t%q\n", e.Q0, e.Q1, e.P)
+
 	if q0 == e.Q0 && q1 == e.Q1 {
-		//		g.aerr("lookliteral: not found, same output(%d:%d)", q0, q1)
 		ed.Select(t0, t1)
 		return
 	}
-	//	g.aerr("lookliteral: found, diff output(%d:%d) != input(%d:%d)", q0, q1, e.Q0, e.Q1)
 	ed.Select(q0, q1)
 	ajump(ed, mouseFunc)
 }

look_test.go

@@ -19,59 +19,157 @@ const (
 	LJump                    // Expect the look to jump to a window
 	LNew                     // Expect the look to open a new window
 	LWrap                    // Expect the look to wrap around
+	LLabel                   // The user looked from the label
 )
 
-var testText = "the quick brown fox jumps over the lazy dog"
+func (f LFlag) On(bit LFlag) bool {
+	return f&LLabel != 0
+}
+
+type ent struct {
+	pre   Addr
+	sweep Addr
+	post  Addr
+	flags LFlag
+	data  string
+}
+
+// Window Resolver
+// Filesystem Resolver
+// Look Resolver
 
 func TestLook(t *testing.T) {
 	etch := ui.NewEtch()
-	type a struct {
-		s, e int64
-	}
-	for name, tc := range map[string]struct {
-		pre   a // pre-sweep selection
-		sweep a // selection after sweep complete
-		post  a // selection after look
-		flags LFlag
 
-		data string
+	sentence := "the quick brown fox jumps over the lazy dog"
+	norm := LScav | LMatch | LJump
+
+	//exampleURL :=  "http://example.com"
+	type a = Addr
+	for name, tc := range map[string]struct {
+		label ent
+		ent
+		onlabel bool
 	}{
-		"the0": {a{0, 2}, a{}, a{31, 33}, LScav | LMatch | LJump, testText},
-		"the1": {a{31, 33}, a{}, a{0, 2}, LScav | LMatch | LJump | LWrap, testText},
-		//	"the3": {a{0, 0}, a{0, 2}, a{31, 33}, LScav | LMatch | LJump, testText},
-		// TODO(as): break it with selected look above
+		// Null selection in body, select letters of "the"
+		"the0/0": {ent: ent{a{0, 0}, a{}, a{31, 34}, norm, sentence}},
+		"the0/1": {ent: ent{a{0, 0}, a{0, 1}, a{31, 32}, norm, sentence}},
+		"the0/2": {ent: ent{a{0, 0}, a{0, 2}, a{31, 33}, norm, sentence}},
+
+		// Partial selection of "th"
+		"the2/0": {ent: ent{a{0, 2}, a{}, a{31, 33}, norm, sentence}},
+		"the2/1": {ent: ent{a{0, 2}, a{0, 1}, a{31, 32}, norm, sentence}},
+		"the2/2": {ent: ent{a{0, 2}, a{0, 2}, a{31, 33}, norm, sentence}},
+
+		//
+		"h/0": {ent: ent{a{1, 2}, a{1, 1}, a{32, 33}, norm, sentence}},
+
+		// Wrap-around test
+		"the1": {ent: ent{a{31, 33}, a{5, 5}, a{31, 33}, norm | LWrap, sentence}},
+
+		// Clicked on the tag label instead
+		"dog":  {ent: ent{a{0, 0}, a{}, a{40, 43}, norm | LLabel, sentence}},
+		"dog1": {ent: ent{a{0, 0}, a{0, 1}, a{40, 41}, norm | LLabel, sentence}},
+		"dog2": {ent: ent{a{0, 0}, a{0, 2}, a{40, 42}, norm | LLabel, sentence}},
+
+		// If it's clicking in the label
+		"label/the": {
+			label:   ent{a{0, 0}, a{0, 3}, a{0, 3}, 0, "the"},
+			ent:     ent{a{0, 0}, a{0, 0}, a{0, 3}, norm | LLabel, sentence},
+			onlabel: true,
+		},
 	} {
 		t.Run(name, func(t *testing.T) {
 
 			// TODO(as): wow, this is a lot of code to initialize one grid
 			g := NewGrid(etch, GridConfig)
 			c := col.New(etch, ColConfig)
+
+			if tc.label.data == "" {
+				tc.label.data = "dog"
+			}
+
 			tag := tag.New(etch, nil)
-			tag.Body.Insert([]byte(tc.data), 0)
+			tag.Win.Insert([]byte(tc.label.data), 0)
+
 			w := tag.Body
-			w.Select(tc.pre.s, tc.pre.e)
+			w.Insert([]byte(tc.data), 0)
+			w.Select(int64(tc.pre.s), int64(tc.pre.e))
+
 			col.Attach(g, c, image.ZP)
 			col.Attach(c, tag, image.ZP)
 
+			from := w
+			if tc.flags.On(LLabel) {
+				from = tag.Win
+			} else if name == "dog" {
+				t.Fatal("bad test")
+			}
+
+			a1 := tc.sweep
+			if a1.Empty() {
+				a1 = expandAddr(a1, from)
+			}
+			if a1.Empty() {
+				a1 = expandFile(a1, from)
+			}
+
 			// TODO(as): wow, this is a lot of code to express one look
 			ev := event.Look{
-				Name: "w", From: w,
+				Name: "w", From: from,
 				To: []event.Editor{w},
 				Rec: event.Rec{
-					Q0: tc.pre.s, Q1: tc.pre.e,
-					P: w.Bytes()[tc.pre.s:tc.pre.e],
+					Q0: int64(a1.s), Q1: int64(a1.e),
+					P: from.Bytes(),
 				},
 			}
-
+			t.Logf("looking for %s", from.Bytes()[int64(a1.s):int64(a1.e)])
 			g.Look(ev)
 
 			q0, q1 := w.Dot()
-			have := a{q0, q1}
+			have := a{q(q0), q(q1)}
 			if have != tc.post {
 				t.Fatalf("have %v, want %v", have, tc.post)
 			}
 		})
-
 	}
 
 }
+
+func TestExpand(t *testing.T) {
+	etch := ui.NewEtch()
+
+	sentence := "stall install reinstall installing stalling"
+	g := NewGrid(etch, GridConfig)
+	c := col.New(etch, ColConfig)
+	tag := tag.New(etch, nil)
+	w := tag.Body
+	w.Insert([]byte(sentence), 0)
+	w.Select(int64(0), int64(0))
+	col.Attach(g, c, image.ZP)
+	col.Attach(c, tag, image.ZP)
+
+	a1 := a{0, q(len("stall"))}
+
+	for i := 0; i < 10; i++ {
+		if a1.Empty() {
+			a1 = expandAddr(a1, w)
+		}
+		if a1.Empty() {
+			a1 = expandFile(a1, w)
+		}
+		ev := event.Look{
+			Name: "w", From: w,
+			To: []event.Editor{w},
+			Rec: event.Rec{
+				Q0: int64(a1.s), Q1: int64(a1.e),
+				P: w.Bytes(),
+			},
+		}
+		g.Look(ev)
+		q0, q1 := w.Dot()
+		if have := string(w.Bytes()[q0:q1]); have != "stall" {
+			t.Fatalf("have %v, want %v", have, "stall")
+		}
+	}
+}