readline/operation.go

419 lines
8.1 KiB
Go
Raw Normal View History

2015-09-21 08:30:10 +03:00
package readline
2015-09-30 09:16:46 +03:00
import (
"errors"
2015-09-30 09:16:46 +03:00
"fmt"
"io"
"golang.org/x/crypto/ssh/terminal"
)
2015-09-21 08:30:10 +03:00
var (
ErrInterrupt = errors.New("Interrupt")
)
2015-09-21 08:30:10 +03:00
type Operation struct {
2015-09-22 13:16:24 +03:00
cfg *Config
2015-09-21 08:30:10 +03:00
t *Terminal
buf *RuneBuffer
outchan chan []rune
errchan chan error
2015-09-29 12:49:58 +03:00
w io.Writer
2015-09-24 19:16:49 +03:00
2015-09-22 13:16:24 +03:00
*opHistory
2015-09-22 18:01:15 +03:00
*opSearch
2015-09-25 17:56:00 +03:00
*opCompleter
2015-11-20 15:56:42 +03:00
*opPassword
2015-10-01 17:44:43 +03:00
*opVim
2015-09-21 08:30:10 +03:00
}
type wrapWriter struct {
r *Operation
2015-09-24 19:16:49 +03:00
t *Terminal
2015-09-21 08:30:10 +03:00
target io.Writer
}
func (w *wrapWriter) Write(b []byte) (int, error) {
2015-09-28 19:26:49 +03:00
if !w.t.IsReading() {
return w.target.Write(b)
2015-09-24 19:16:49 +03:00
}
2015-09-28 19:26:49 +03:00
var (
n int
err error
)
w.r.buf.Refresh(func() {
n, err = w.target.Write(b)
})
if w.r.IsSearchMode() {
w.r.SearchRefresh(-1)
}
2015-09-25 17:56:00 +03:00
if w.r.IsInCompleteMode() {
w.r.CompleteRefresh()
}
2015-09-21 08:30:10 +03:00
return n, err
}
2015-09-22 13:16:24 +03:00
func NewOperation(t *Terminal, cfg *Config) *Operation {
2015-09-21 08:30:10 +03:00
op := &Operation{
2015-10-04 10:23:00 +03:00
t: t,
2015-11-20 15:56:42 +03:00
buf: NewRuneBuffer(t, cfg.Prompt, cfg.MaskRune),
2015-10-04 10:23:00 +03:00
outchan: make(chan []rune),
errchan: make(chan error),
2015-09-21 08:30:10 +03:00
}
2015-09-29 12:49:58 +03:00
op.w = op.buf.w
2015-11-20 15:56:42 +03:00
op.SetConfig(cfg)
op.opVim = newVimMode(op)
2015-09-25 17:56:00 +03:00
op.opCompleter = newOpCompleter(op.buf.w, op)
2015-11-20 15:56:42 +03:00
op.opPassword = newOpPassword(op)
2015-09-21 08:30:10 +03:00
go op.ioloop()
return op
}
2015-09-27 13:54:26 +03:00
func (o *Operation) SetPrompt(s string) {
o.buf.SetPrompt(s)
}
2015-11-20 15:56:42 +03:00
func (o *Operation) SetMaskRune(r rune) {
o.buf.SetMask(r)
}
2015-09-23 08:52:26 +03:00
func (o *Operation) ioloop() {
2015-09-21 08:30:10 +03:00
for {
2015-09-22 18:01:15 +03:00
keepInSearchMode := false
2015-09-25 17:56:00 +03:00
keepInCompleteMode := false
2015-09-23 08:52:26 +03:00
r := o.t.ReadRune()
2015-11-20 15:56:42 +03:00
isUpdateHistory := true
2015-09-25 17:56:00 +03:00
if o.IsInCompleteSelectMode() {
keepInCompleteMode = o.HandleCompleteSelect(r)
if keepInCompleteMode {
continue
}
2015-09-27 05:12:15 +03:00
o.buf.Refresh(nil)
2015-09-25 17:56:00 +03:00
switch r {
2015-09-25 20:01:20 +03:00
case CharEnter, CharCtrlJ:
o.UpdateHistory(o.buf.Runes(), false)
fallthrough
case CharInterrupt:
2015-09-25 17:56:00 +03:00
o.t.KickRead()
fallthrough
2015-10-01 17:44:43 +03:00
case CharBell:
continue
}
}
if o.IsEnableVimMode() {
2015-10-02 05:37:21 +03:00
r = o.HandleVim(r, o.t.ReadRune)
if r == 0 {
2015-09-25 17:56:00 +03:00
continue
}
}
2015-09-21 08:30:10 +03:00
switch r {
2015-10-01 17:44:43 +03:00
case CharBell:
2015-09-23 08:52:26 +03:00
if o.IsSearchMode() {
o.ExitSearchMode(true)
2015-09-27 05:12:15 +03:00
o.buf.Refresh(nil)
2015-09-22 18:01:15 +03:00
}
2015-09-25 17:56:00 +03:00
if o.IsInCompleteMode() {
o.ExitCompleteMode(true)
2015-09-27 05:12:15 +03:00
o.buf.Refresh(nil)
2015-09-25 17:56:00 +03:00
}
2015-09-25 07:59:36 +03:00
case CharTab:
2015-10-03 09:15:19 +03:00
if o.cfg.AutoComplete == nil {
o.t.Bell()
2015-09-25 07:59:36 +03:00
break
}
2015-09-25 17:56:00 +03:00
o.OnComplete()
keepInCompleteMode = true
2015-09-22 18:01:15 +03:00
case CharBckSearch:
2015-09-23 08:52:26 +03:00
o.SearchMode(S_DIR_BCK)
2015-09-22 18:01:15 +03:00
keepInSearchMode = true
2015-09-28 06:13:39 +03:00
case CharCtrlU:
o.buf.KillFront()
2015-09-22 18:01:15 +03:00
case CharFwdSearch:
2015-09-23 08:52:26 +03:00
o.SearchMode(S_DIR_FWD)
2015-09-22 18:01:15 +03:00
keepInSearchMode = true
2015-09-21 17:51:48 +03:00
case CharKill:
2015-09-23 08:52:26 +03:00
o.buf.Kill()
2015-09-25 17:56:00 +03:00
keepInCompleteMode = true
2015-10-01 17:44:43 +03:00
case MetaForward:
2015-09-23 08:52:26 +03:00
o.buf.MoveToNextWord()
2015-09-23 08:03:13 +03:00
case CharTranspose:
2015-09-23 08:52:26 +03:00
o.buf.Transpose()
2015-10-01 17:44:43 +03:00
case MetaBackward:
2015-09-23 08:52:26 +03:00
o.buf.MoveToPrevWord()
2015-09-21 08:30:10 +03:00
case MetaDelete:
2015-09-23 08:52:26 +03:00
o.buf.DeleteWord()
2015-09-21 08:30:10 +03:00
case CharLineStart:
2015-09-23 08:52:26 +03:00
o.buf.MoveToLineStart()
2015-09-21 08:30:10 +03:00
case CharLineEnd:
2015-09-23 08:52:26 +03:00
o.buf.MoveToLineEnd()
2015-09-23 06:46:56 +03:00
case CharBackspace, CharCtrlH:
2015-09-23 08:52:26 +03:00
if o.IsSearchMode() {
o.SearchBackspace()
2015-09-22 18:01:15 +03:00
keepInSearchMode = true
2015-09-25 17:56:00 +03:00
break
}
2015-09-25 20:01:20 +03:00
if o.buf.Len() == 0 {
2015-10-01 17:44:43 +03:00
o.t.Bell()
2015-09-25 20:01:20 +03:00
break
}
2015-09-25 17:56:00 +03:00
o.buf.Backspace()
if o.IsInCompleteMode() {
o.OnComplete()
2015-09-22 18:01:15 +03:00
}
2015-09-23 06:46:56 +03:00
case MetaBackspace, CharCtrlW:
2015-09-23 08:52:26 +03:00
o.buf.BackEscapeWord()
2015-09-23 06:46:56 +03:00
case CharEnter, CharCtrlJ:
2015-09-23 08:52:26 +03:00
if o.IsSearchMode() {
o.ExitSearchMode(false)
2015-09-23 06:10:36 +03:00
}
2015-09-23 08:52:26 +03:00
o.buf.MoveToLineEnd()
2016-02-15 05:05:39 +03:00
var data []rune
if !o.cfg.UniqueEditLine {
o.buf.WriteRune('\n')
data = o.buf.Reset()
data = data[:len(data)-1] // trim \n
} else {
o.buf.Clean()
data = o.buf.Reset()
}
2015-09-23 08:52:26 +03:00
o.outchan <- data
o.NewHistory(data)
2015-09-21 08:30:10 +03:00
case CharBackward:
2015-09-23 08:52:26 +03:00
o.buf.MoveBackward()
2015-09-21 08:30:10 +03:00
case CharForward:
2015-09-23 08:52:26 +03:00
o.buf.MoveForward()
2015-09-21 08:30:10 +03:00
case CharPrev:
2015-09-23 08:52:26 +03:00
buf := o.PrevHistory()
2015-09-21 08:30:10 +03:00
if buf != nil {
2015-09-23 08:52:26 +03:00
o.buf.Set(buf)
2015-10-01 17:44:43 +03:00
} else {
o.t.Bell()
2015-09-21 08:30:10 +03:00
}
case CharNext:
2015-09-23 08:52:26 +03:00
buf, ok := o.NextHistory()
2015-09-21 16:00:48 +03:00
if ok {
2015-09-23 08:52:26 +03:00
o.buf.Set(buf)
2015-10-01 17:44:43 +03:00
} else {
o.t.Bell()
2015-09-21 08:30:10 +03:00
}
case CharDelete:
if o.buf.Len() > 0 || !o.IsNormalMode() {
o.t.KickRead()
if !o.buf.Delete() {
o.t.Bell()
}
break
}
// treat as EOF
o.buf.WriteString(o.cfg.EOFPrompt + "\n")
o.buf.Reset()
2015-11-20 15:56:42 +03:00
isUpdateHistory = false
o.RevertHistory()
o.errchan <- io.EOF
2015-09-23 06:46:56 +03:00
case CharInterrupt:
2015-09-23 08:52:26 +03:00
if o.IsSearchMode() {
o.t.KickRead()
o.ExitSearchMode(true)
break
2015-09-22 18:01:15 +03:00
}
2015-09-25 17:56:00 +03:00
if o.IsInCompleteMode() {
o.t.KickRead()
o.ExitCompleteMode(true)
2015-09-27 05:12:15 +03:00
o.buf.Refresh(nil)
2015-09-25 17:56:00 +03:00
break
}
2015-09-23 08:52:26 +03:00
o.buf.MoveToLineEnd()
2015-09-27 05:12:15 +03:00
o.buf.Refresh(nil)
o.buf.WriteString(o.cfg.InterruptPrompt + "\n")
o.buf.Reset()
2015-11-20 15:56:42 +03:00
isUpdateHistory = false
o.RevertHistory()
o.errchan <- ErrInterrupt
2015-09-21 08:30:10 +03:00
default:
2015-09-23 08:52:26 +03:00
if o.IsSearchMode() {
o.SearchChar(r)
2015-09-22 18:01:15 +03:00
keepInSearchMode = true
2015-09-25 17:56:00 +03:00
break
}
o.buf.WriteRune(r)
if o.IsInCompleteMode() {
o.OnComplete()
keepInCompleteMode = true
2015-09-22 18:01:15 +03:00
}
}
2015-09-28 06:13:39 +03:00
2015-11-20 15:56:42 +03:00
if o.cfg.Listener != nil {
newLine, newPos, ok := o.cfg.Listener.OnChange(o.buf.Runes(), o.buf.Pos(), r)
if ok {
o.buf.SetWithIdx(newPos, newLine)
}
}
2015-09-23 08:52:26 +03:00
if !keepInSearchMode && o.IsSearchMode() {
o.ExitSearchMode(false)
2015-09-27 05:12:15 +03:00
o.buf.Refresh(nil)
2015-09-25 17:56:00 +03:00
} else if o.IsInCompleteMode() {
if !keepInCompleteMode {
o.ExitCompleteMode(false)
2015-11-20 15:56:42 +03:00
o.Refresh()
2015-09-25 17:56:00 +03:00
} else {
2015-09-27 05:12:15 +03:00
o.buf.Refresh(nil)
2015-09-25 17:56:00 +03:00
o.CompleteRefresh()
}
2015-09-21 08:30:10 +03:00
}
2015-11-20 15:56:42 +03:00
if isUpdateHistory && !o.IsSearchMode() {
2015-09-23 08:52:26 +03:00
o.UpdateHistory(o.buf.Runes(), false)
2015-09-23 06:10:36 +03:00
}
2015-09-21 08:30:10 +03:00
}
}
2015-09-23 08:52:26 +03:00
func (o *Operation) Stderr() io.Writer {
return &wrapWriter{target: o.cfg.Stderr, r: o, t: o.t}
2015-09-24 19:16:49 +03:00
}
func (o *Operation) Stdout() io.Writer {
return &wrapWriter{target: o.cfg.Stdout, r: o, t: o.t}
2015-09-21 08:30:10 +03:00
}
2015-09-23 08:52:26 +03:00
func (o *Operation) String() (string, error) {
r, err := o.Runes()
2015-09-21 08:30:10 +03:00
if err != nil {
return "", err
}
return string(r), nil
}
2015-09-23 08:52:26 +03:00
func (o *Operation) Runes() ([]rune, error) {
o.t.EnterRawMode()
defer o.t.ExitRawMode()
2015-11-20 15:56:42 +03:00
if o.cfg.Listener != nil {
o.cfg.Listener.OnChange(nil, 0, 0)
}
2015-09-27 05:12:15 +03:00
o.buf.Refresh(nil) // print prompt
2015-09-24 19:16:49 +03:00
o.t.KickRead()
select {
case r := <-o.outchan:
return r, nil
case err := <-o.errchan:
return nil, err
2015-09-21 08:30:10 +03:00
}
}
2015-11-20 15:56:42 +03:00
func (o *Operation) PasswordEx(prompt string, l Listener) ([]byte, error) {
cfg := o.GenPasswordConfig()
cfg.Prompt = prompt
cfg.Listener = l
return o.PasswordWithConfig(cfg)
}
func (o *Operation) GenPasswordConfig() *Config {
return o.opPassword.PasswordConfig()
}
func (o *Operation) PasswordWithConfig(cfg *Config) ([]byte, error) {
2015-11-20 16:00:05 +03:00
if err := o.opPassword.EnterPasswordMode(cfg); err != nil {
return nil, err
}
2015-11-20 15:56:42 +03:00
defer o.opPassword.ExitPasswordMode()
return o.Slice()
}
2015-09-30 09:16:46 +03:00
func (o *Operation) Password(prompt string) ([]byte, error) {
w := o.Stdout()
if prompt != "" {
fmt.Fprintf(w, prompt)
}
o.t.EnterRawMode()
defer o.t.ExitRawMode()
2015-12-23 08:39:23 +03:00
b, err := terminal.ReadPassword(int(o.cfg.Stdin.Fd()))
2015-09-30 09:16:46 +03:00
fmt.Fprint(w, "\r\n")
return b, err
}
2015-09-29 12:49:58 +03:00
func (o *Operation) SetTitle(t string) {
o.w.Write([]byte("\033[2;" + t + "\007"))
}
2015-09-23 08:52:26 +03:00
func (o *Operation) Slice() ([]byte, error) {
r, err := o.Runes()
2015-09-21 08:30:10 +03:00
if err != nil {
return nil, err
}
return []byte(string(r)), nil
}
2015-09-22 13:16:24 +03:00
2015-09-23 08:52:26 +03:00
func (o *Operation) Close() {
2015-10-04 10:23:00 +03:00
o.opHistory.CloseHistory()
}
func (o *Operation) SetHistoryPath(path string) {
if o.opHistory != nil {
o.opHistory.CloseHistory()
}
o.cfg.HistoryFile = path
o.opHistory = newOpHistory(o.cfg)
2015-09-22 13:16:24 +03:00
}
func (o *Operation) IsNormalMode() bool {
return !o.IsInCompleteMode() && !o.IsSearchMode()
}
2015-11-20 15:56:42 +03:00
func (op *Operation) SetConfig(cfg *Config) (*Config, error) {
if op.cfg == cfg {
return op.cfg, nil
}
if err := cfg.Init(); err != nil {
return op.cfg, err
}
old := op.cfg
op.cfg = cfg
op.SetPrompt(cfg.Prompt)
op.SetMaskRune(cfg.MaskRune)
if cfg.opHistory == nil {
op.SetHistoryPath(cfg.HistoryFile)
cfg.opHistory = op.opHistory
cfg.opSearch = newOpSearch(op.buf.w, op.buf, op.opHistory)
}
op.opHistory = cfg.opHistory
// SetHistoryPath will close opHistory which already exists
// so if we use it next time, we need to reopen it by `InitHistory()`
op.opHistory.InitHistory()
op.opSearch = cfg.opSearch
return old, nil
}
func (o *Operation) Refresh() {
if o.t.IsReading() {
o.buf.Refresh(nil)
}
}
func FuncListener(f func(line []rune, pos int, key rune) (newLine []rune, newPos int, ok bool)) Listener {
return &DumpListener{f: f}
}
type DumpListener struct {
f func(line []rune, pos int, key rune) (newLine []rune, newPos int, ok bool)
}
func (d *DumpListener) OnChange(line []rune, pos int, key rune) (newLine []rune, newPos int, ok bool) {
return d.f(line, pos, key)
}
type Listener interface {
OnChange(line []rune, pos int, key rune) (newLine []rune, newPos int, ok bool)
}