Various

* Alt key mod now work again
* Use TrimSpace
* Remove some unused code (need to delete a LOT more)

action.go

@@ -126,6 +126,31 @@ func init() {
 	Keyseq.Compile()
 }
 
+// This is a noop action
+func doNothing(_ *Input, _ termbox.Event) {}
+
+// This is an exception to the rule. This does not get registered
+// anywhere. You just call it directly
+func doAcceptChar(i *Input, ev termbox.Event) {
+	if ev.Key == termbox.KeySpace {
+		ev.Ch = ' '
+	}
+
+	if ev.Ch > 0 {
+		if len(i.query) == i.caretPos {
+			i.query = append(i.query, ev.Ch)
+		} else {
+			buf := make([]rune, len(i.query)+1)
+			copy(buf, i.query[:i.caretPos])
+			buf[i.caretPos] = ev.Ch
+			copy(buf[i.caretPos+1:], i.query[i.caretPos:])
+			i.query = buf
+		}
+		i.caretPos++
+		i.ExecQuery()
+	}
+}
+
 func doRotateMatcher(i *Input, ev termbox.Event) {
 	i.Ctx.CurrentMatcher++
 	if i.Ctx.CurrentMatcher >= len(i.Ctx.Matchers) {

config.go

@@ -13,6 +13,9 @@ import (
 var homedirFunc = homedir
 
 type Config struct {
+	// Keymap used to be directly responsible for dispatching
+	// events against user input, but since then this has changed
+	// into something that just records the user's config input
 	Keymap        Keymap   `json:"Keymap"`
 	Matcher       string   `json:"Matcher"`
 	Style         StyleSet `json:"Style"`

input.go

@@ -45,7 +45,6 @@ func (i *Input) Loop() {
 }
 
 func (i *Input) handleInputEvent(ev termbox.Event) {
-	hasModifierMaps := i.config.Keymap.hasModifierMaps()
 	switch ev.Type {
 	case termbox.EventError:
 		//update = false
@@ -56,10 +55,6 @@ func (i *Input) handleInputEvent(ev termbox.Event) {
 		// It would be nice if termbox differentiated this for us, but
 		// we workaround it by waiting (juuuuse a few milliseconds) for
 		// extra key events. If no extra events arrive, it should be Esc
-		if !hasModifierMaps {
-			i.handleKeyEvent(ev)
-			return
-		}
 
 		// Smells like Esc or Alt. mod == nil checks for the presense
 		// of a previous timer

keymap.go

@@ -118,54 +118,29 @@ func init() {
 	//	panic(fmt.Sprintf("%#q", stringToKey))
 }
 
-func handleAcceptChar(i *Input, ev termbox.Event) {
-	if ev.Key == termbox.KeySpace {
-		ev.Ch = ' '
-	}
-
-	if ev.Ch > 0 {
-		if len(i.query) == i.caretPos {
-			i.query = append(i.query, ev.Ch)
-		} else {
-			buf := make([]rune, len(i.query)+1)
-			copy(buf, i.query[:i.caretPos])
-			buf[i.caretPos] = ev.Ch
-			copy(buf[i.caretPos+1:], i.query[i.caretPos:])
-			i.query = buf
-		}
-		i.caretPos++
-		i.ExecQuery()
-	}
-}
-
-func handleResetKeySequence(i *Input, ev termbox.Event) {
-	i.currentKeymap = i.config.Keymap
-	i.chained = false
-}
-
 func (ksk KeymapStringKey) ToKeyList() (keyseq.KeyList, error) {
 	list := keyseq.KeyList{}
 	for _, term := range strings.Split(string(ksk), ",") {
-		term = strings.Trim(term, " ")
+		term = strings.TrimSpace(term)
 
-		k, m, err := KeymapStringKey(term).ToKey()
+		k, m, ch, err := KeymapStringKey(term).ToKey()
 		if err != nil {
 			return list, err
 		}
 
-		list = append(list, keyseq.Key{m,k,rune(0)})
+		list = append(list, keyseq.Key{m,k,ch})
 	}
 	return list, nil
 }
 
-func (ksk KeymapStringKey) ToKey() (k termbox.Key, modifier int, err error) {
+func (ksk KeymapStringKey) ToKey() (k termbox.Key, modifier int, ch rune, err error) {
 	modifier = ModNone
 	key := string(ksk)
 	if strings.HasPrefix(key, "M-") {
 		modifier = ModAlt
 		key = key[2:]
 		if len(key) == 1 {
-			k = termbox.Key(key[0])
+			ch = rune(key[0])
 			return
 		}
 	}
@@ -205,37 +180,10 @@ func (km Keymap) Handler(ev termbox.Event, chained bool) Action {
 	case keyseq.ErrInSequence:
 		// TODO We're in some sort of key sequence. Remember what we have
 		// received so far
-		return ActionFunc(func(_ *Input, _ termbox.Event){})
+		return ActionFunc(doNothing)
 	default:
-		return ActionFunc(handleAcceptChar)
+		return ActionFunc(doAcceptChar)
 	}
-/*
-
-	// RawKeymap that we will be using
-	rkm := km[modifier]
-
-	switch modifier {
-	case ModAlt:
-
-		if h, ok := rkm[key]; ok {
-			return h
-		}
-	case ModNone:
-		if ev.Ch == 0 {
-			if h, ok := rkm[ev.Key]; ok {
-				return h
-			}
-		}
-	default:
-		panic("Can't get here")
-	}
-
-	if chained {
-		return ActionFunc(handleResetKeySequence)
-	} else {
-		return ActionFunc(handleAcceptChar)
-	}
-*/
 }
 
 func (km Keymap) UnmarshalJSON(buf []byte) error {
@@ -244,17 +192,13 @@ func (km Keymap) UnmarshalJSON(buf []byte) error {
 		return err
 	}
 
-	km.assignKeyHandlers(raw)
-	return nil
-}
-
-func (km Keymap) assignKeyHandlers(raw map[string]string) {
 	for ks, vs := range raw {
 		list, err := KeymapStringKey(ks).ToKeyList()
 		if err != nil {
 			fmt.Fprintf(os.Stderr, "Unknown key %s", ks)
 			continue
 		}
+
 		if vs == "-" {
 			// XXX TODO: how do we delete from a trie?
 			continue
@@ -267,37 +211,12 @@ func (km Keymap) assignKeyHandlers(raw map[string]string) {
 		}
 
 		Keyseq.Add(list, v)
-
-		/*
-
-		keymap := km[modifier]
-		switch vi.(type) {
-		case string:
-			vs := vi.(string)
-			if vs == "-" {
-				delete(keymap, k)
-				continue
-			}
-
-			keymap[k] = ActionFunc(func(i *Input, ev termbox.Event) {
-				v.Execute(i, ev)
-
-				// Reset key sequence when not-chained key was pressed
-				handleResetKeySequence(i, ev)
-			})
-		case map[string]interface{}:
-			ckm := Keymap{{}, {}}
-			ckm.assignKeyHandlers(vi.(map[string]interface{}))
-			keymap[k] = ActionFunc(func(i *Input, _ termbox.Event) {
-				// Switch Keymap for chained state
-				i.currentKeymap = ckm
-				i.chained = true
-			})
-		}
-*/
 	}
+
+	return nil
 }
 
+// TODO: this needs to be fixed.
 func (km Keymap) hasModifierMaps() bool {
 	return len(km[ModAlt]) > 0
 }