package main
import (
- "bytes"
"fmt"
- "io"
"os"
- "os/exec"
- "os/signal"
"path/filepath"
"regexp"
"runtime"
"strings"
humanize "github.com/dustin/go-humanize"
- "github.com/mitchellh/go-homedir"
+ "github.com/zyedidia/micro/cmd/micro/shellwords"
)
// A Command contains a action (a function to call) as well as information about how to autocomplete the command
"Set": Set,
"SetLocal": SetLocal,
"Show": Show,
+ "ShowKey": ShowKey,
"Run": Run,
"Bind": Bind,
"Quit": Quit,
"Pwd": Pwd,
"Open": Open,
"TabSwitch": TabSwitch,
+ "Term": Term,
"MemUsage": MemUsage,
+ "Retab": Retab,
+ "Raw": Raw,
}
}
// DefaultCommands returns a map containing micro's default commands
func DefaultCommands() map[string]StrCommand {
return map[string]StrCommand{
- "set": {"Set", []Completion{OptionCompletion, NoCompletion}},
- "setlocal": {"SetLocal", []Completion{OptionCompletion, NoCompletion}},
+ "set": {"Set", []Completion{OptionCompletion, OptionValueCompletion}},
+ "setlocal": {"SetLocal", []Completion{OptionCompletion, OptionValueCompletion}},
"show": {"Show", []Completion{OptionCompletion, NoCompletion}},
+ "showkey": {"ShowKey", []Completion{NoCompletion}},
"bind": {"Bind", []Completion{NoCompletion}},
"run": {"Run", []Completion{NoCompletion}},
"quit": {"Quit", []Completion{NoCompletion}},
"pwd": {"Pwd", []Completion{NoCompletion}},
"open": {"Open", []Completion{FileCompletion}},
"tabswitch": {"TabSwitch", []Completion{NoCompletion}},
+ "term": {"Term", []Completion{NoCompletion}},
"memusage": {"MemUsage", []Completion{NoCompletion}},
+ "retab": {"Retab", []Completion{NoCompletion}},
+ "raw": {"Raw", []Completion{NoCompletion}},
+ }
+}
+
+// CommandEditAction returns a bindable function that opens a prompt with
+// the given string and executes the command when the user presses
+// enter
+func CommandEditAction(prompt string) func(*View, bool) bool {
+ return func(v *View, usePlugin bool) bool {
+ input, canceled := messenger.Prompt("> ", prompt, "Command", CommandCompletion)
+ if !canceled {
+ HandleCommand(input)
+ }
+ return false
+ }
+}
+
+// CommandAction returns a bindable function which executes the
+// given command
+func CommandAction(cmd string) func(*View, bool) bool {
+ return func(v *View, usePlugin bool) bool {
+ HandleCommand(cmd)
+ return false
}
}
continue
}
}
- if !IsSpaces(removed) {
+ if !IsSpaces([]byte(removed)) {
messenger.Message("Removed ", removed)
} else {
messenger.Error("The requested plugins do not exist")
}
}
+// Retab changes all spaces to tabs or all tabs to spaces
+// depending on the user's settings
+func Retab(args []string) {
+ CurView().Retab(true)
+}
+
+// Raw opens a new raw view which displays the escape sequences micro
+// is receiving in real-time
+func Raw(args []string) {
+ buf := NewBufferFromString("", "Raw events")
+
+ view := NewView(buf)
+ view.Buf.Insert(view.Cursor.Loc, "Warning: Showing raw event escape codes\n")
+ view.Buf.Insert(view.Cursor.Loc, "Use CtrlQ to exit\n")
+ view.Type = vtRaw
+ tab := NewTabFromView(view)
+ tab.SetNum(len(tabs))
+ tabs = append(tabs, tab)
+ curTab = len(tabs) - 1
+ if len(tabs) == 2 {
+ for _, t := range tabs {
+ for _, v := range t.views {
+ v.ToggleTabbar()
+ }
+ }
+ }
+}
+
// TabSwitch switches to a given tab either by name or by number
func TabSwitch(args []string) {
if len(args) > 0 {
// Cd changes the current working directory
func Cd(args []string) {
if len(args) > 0 {
- home, _ := homedir.Dir()
- path := strings.Replace(args[0], "~", home, 1)
- os.Chdir(path)
+ path := ReplaceHome(args[0])
+ err := os.Chdir(path)
+ if err != nil {
+ messenger.Error("Error with cd: ", err)
+ return
+ }
+ wd, _ := os.Getwd()
for _, tab := range tabs {
for _, view := range tab.views {
- wd, _ := os.Getwd()
+ if len(view.Buf.name) == 0 {
+ continue
+ }
+
view.Buf.Path, _ = MakeRelative(view.Buf.AbsPath, wd)
if p, _ := filepath.Abs(view.Buf.Path); !strings.Contains(p, wd) {
view.Buf.Path = view.Buf.AbsPath
if len(args) > 0 {
filename := args[0]
// the filename might or might not be quoted, so unquote first then join the strings.
- filename = strings.Join(SplitCommandArgs(filename), " ")
+ args, err := shellwords.Split(filename)
+ if err != nil {
+ messenger.Error("Error parsing args ", err)
+ return
+ }
+ filename = strings.Join(args, " ")
CurView().Open(filename)
} else {
CurView().VSplit(NewBufferFromString("", ""))
} else {
filename := args[0]
- home, _ := homedir.Dir()
- filename = strings.Replace(filename, "~", home, 1)
+ filename = ReplaceHome(filename)
file, err := os.Open(filename)
fileInfo, _ := os.Stat(filename)
CurView().HSplit(NewBufferFromString("", ""))
} else {
filename := args[0]
- home, _ := homedir.Dir()
- filename = strings.Replace(filename, "~", home, 1)
+ filename = ReplaceHome(filename)
file, err := os.Open(filename)
fileInfo, _ := os.Stat(filename)
CurView().AddTab(true)
} else {
filename := args[0]
- home, _ := homedir.Dir()
- filename = strings.Replace(filename, "~", home, 1)
+ filename = ReplaceHome(filename)
file, err := os.Open(filename)
fileInfo, _ := os.Stat(filename)
messenger.Message(option)
}
+// ShowKey displays the action that a key is bound to
+func ShowKey(args []string) {
+ if len(args) < 1 {
+ messenger.Error("Please provide a key to show")
+ return
+ }
+
+ if action, ok := bindingsStr[args[0]]; ok {
+ messenger.Message(action)
+ } else {
+ messenger.Message(args[0], " has no binding")
+ }
+}
+
// Bind creates a new keybinding
func Bind(args []string) {
if len(args) < 2 {
// Run runs a shell command in the background
func Run(args []string) {
// Run a shell command in the background (openTerm is false)
- HandleShellCommand(JoinCommandArgs(args...), false, true)
+ HandleShellCommand(shellwords.Join(args...), false, true)
}
// Quit closes the main view
// Replace runs search and replace
func Replace(args []string) {
- if len(args) < 2 || len(args) > 3 {
+ if len(args) < 2 || len(args) > 4 {
// We need to find both a search and replace expression
messenger.Error("Invalid replace statement: " + strings.Join(args, " "))
return
}
- allAtOnce := false
- if len(args) == 3 {
- // user added -a flag
- if args[2] == "-a" {
- allAtOnce = true
- } else {
- messenger.Error("Invalid replace flag: " + args[2])
- return
+ all := false
+ noRegex := false
+
+ if len(args) > 2 {
+ for _, arg := range args[2:] {
+ switch arg {
+ case "-a":
+ all = true
+ case "-l":
+ noRegex = true
+ default:
+ messenger.Error("Invalid flag: " + arg)
+ return
+ }
}
}
search := string(args[0])
+
+ if noRegex {
+ search = regexp.QuoteMeta(search)
+ }
+
replace := string(args[1])
regex, err := regexp.Compile("(?m)" + search)
view := CurView()
found := 0
- if allAtOnce {
- // var deltas []Delta
+ replaceAll := func() {
+ var deltas []Delta
+ deltaXOffset := Count(replace) - Count(search)
for i := 0; i < view.Buf.LinesNum(); i++ {
- // view.Buf.lines[i].data = regex.ReplaceAll(view.Buf.lines[i].data, []byte(replace))
- for {
- m := regex.FindIndex(view.Buf.lines[i].data)
+ matches := regex.FindAllIndex(view.Buf.lines[i].data, -1)
+ str := string(view.Buf.lines[i].data)
- if m != nil {
- from := Loc{m[0], i}
- to := Loc{m[1], i}
+ if matches != nil {
+ xOffset := 0
+ for _, m := range matches {
+ from := Loc{runePos(m[0], str) + xOffset, i}
+ to := Loc{runePos(m[1], str) + xOffset, i}
- // deltas = append(deltas, Delta{replace, from, to})
- view.Buf.Replace(from, to, replace)
+ xOffset += deltaXOffset
+
+ deltas = append(deltas, Delta{replace, from, to})
found++
- } else {
- break
}
}
}
- // view.Buf.MultipleReplace(deltas)
+ view.Buf.MultipleReplace(deltas)
+ }
+ if all {
+ replaceAll()
} else {
for {
// The 'check' flag was used
}
view.Relocate()
RedrawAll()
- choice, canceled := messenger.YesNoPrompt("Perform replacement? (y,n)")
+ choice, canceled := messenger.LetterPrompt("Perform replacement? (y,n,a)", 'y', 'n', 'a')
if canceled {
if view.Cursor.HasSelection() {
view.Cursor.Loc = view.Cursor.CurSelection[0]
}
messenger.Reset()
break
- } else if choice {
+ } else if choice == 'a' {
+ if view.Cursor.HasSelection() {
+ view.Cursor.Loc = view.Cursor.CurSelection[0]
+ view.Cursor.ResetSelection()
+ }
+ messenger.Reset()
+ replaceAll()
+ break
+ } else if choice == 'y' {
view.Cursor.DeleteSelection()
view.Buf.Insert(view.Cursor.Loc, replace)
view.Cursor.ResetSelection()
messenger.Reset()
found++
+ }
+ if view.Cursor.HasSelection() {
+ searchStart = view.Cursor.CurSelection[1]
} else {
- if view.Cursor.HasSelection() {
- searchStart = ToCharPos(view.Cursor.CurSelection[1], view.Buf)
- } else {
- searchStart = ToCharPos(view.Cursor.Loc, view.Buf)
- }
+ searchStart = view.Cursor.Loc
}
}
}
Replace(append(args, "-a"))
}
-// RunShellCommand executes a shell command and returns the output/error
-func RunShellCommand(input string) (string, error) {
- inputCmd := SplitCommandArgs(input)[0]
- args := SplitCommandArgs(input)[1:]
-
- cmd := exec.Command(inputCmd, args...)
- outputBytes := &bytes.Buffer{}
- cmd.Stdout = outputBytes
- cmd.Stderr = outputBytes
- cmd.Start()
- err := cmd.Wait() // wait for command to finish
- outstring := outputBytes.String()
- return outstring, err
-}
-
-// HandleShellCommand runs the shell command
-// The openTerm argument specifies whether a terminal should be opened (for viewing output
-// or interacting with stdin)
-func HandleShellCommand(input string, openTerm bool, waitToFinish bool) string {
- inputCmd := SplitCommandArgs(input)[0]
- if !openTerm {
- // Simply run the command in the background and notify the user when it's done
- messenger.Message("Running...")
- go func() {
- output, err := RunShellCommand(input)
- totalLines := strings.Split(output, "\n")
-
- if len(totalLines) < 3 {
- if err == nil {
- messenger.Message(inputCmd, " exited without error")
- } else {
- messenger.Message(inputCmd, " exited with error: ", err, ": ", output)
- }
- } else {
- messenger.Message(output)
- }
- // We have to make sure to redraw
- RedrawAll()
- }()
+// Term opens a terminal in the current view
+func Term(args []string) {
+ var err error
+ if len(args) == 0 {
+ err = CurView().StartTerminal([]string{os.Getenv("SHELL"), "-i"}, true, false, "")
} else {
- // Shut down the screen because we're going to interact directly with the shell
- screen.Fini()
- screen = nil
-
- args := SplitCommandArgs(input)[1:]
-
- // Set up everything for the command
- var outputBuf bytes.Buffer
- cmd := exec.Command(inputCmd, args...)
- cmd.Stdin = os.Stdin
- cmd.Stdout = io.MultiWriter(os.Stdout, &outputBuf)
- cmd.Stderr = os.Stderr
-
- // This is a trap for Ctrl-C so that it doesn't kill micro
- // Instead we trap Ctrl-C to kill the program we're running
- c := make(chan os.Signal, 1)
- signal.Notify(c, os.Interrupt)
- go func() {
- for range c {
- cmd.Process.Kill()
- }
- }()
-
- cmd.Start()
- err := cmd.Wait()
-
- output := outputBuf.String()
- if err != nil {
- output = err.Error()
- }
-
- if waitToFinish {
- // This is just so we don't return right away and let the user press enter to return
- TermMessage("")
- }
-
- // Start the screen back up
- InitScreen()
-
- return output
+ err = CurView().StartTerminal(args, true, false, "")
+ }
+ if err != nil {
+ messenger.Error(err)
}
- return ""
}
// HandleCommand handles input from the user
func HandleCommand(input string) {
- args := SplitCommandArgs(input)
+ args, err := shellwords.Split(input)
+ if err != nil {
+ messenger.Error("Error parsing args ", err)
+ return
+ }
+
inputCmd := args[0]
if _, ok := commands[inputCmd]; !ok {
projects / micro.git / blobdiff