X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=cmd%2Fmicro%2Fmicro.go;h=a4d22b70e5db8f95e194c532e0499c33957b49cd;hb=b8fbbf5c83862cc47fac7edc2c26a6d79a9c9df0;hp=94ea6383de487680681630fbe54beedd2df9d39c;hpb=fc706bc404042e4733f4008bcb627f795fea2e81;p=micro.git diff --git a/cmd/micro/micro.go b/cmd/micro/micro.go index 94ea6383..a4d22b70 100644 --- a/cmd/micro/micro.go +++ b/cmd/micro/micro.go @@ -5,16 +5,22 @@ import ( "fmt" "io/ioutil" "os" + "regexp" + "runtime" "sort" + "strconv" + "time" "github.com/go-errors/errors" isatty "github.com/mattn/go-isatty" - "github.com/zyedidia/micro/internal/action" - "github.com/zyedidia/micro/internal/buffer" - "github.com/zyedidia/micro/internal/config" - "github.com/zyedidia/micro/internal/screen" - "github.com/zyedidia/micro/internal/shell" - "github.com/zyedidia/micro/internal/util" + lua "github.com/yuin/gopher-lua" + "github.com/zyedidia/micro/v2/internal/action" + "github.com/zyedidia/micro/v2/internal/buffer" + "github.com/zyedidia/micro/v2/internal/config" + ulua "github.com/zyedidia/micro/v2/internal/lua" + "github.com/zyedidia/micro/v2/internal/screen" + "github.com/zyedidia/micro/v2/internal/shell" + "github.com/zyedidia/micro/v2/internal/util" "github.com/zyedidia/tcell" ) @@ -27,22 +33,43 @@ var ( flagVersion = flag.Bool("version", false, "Show the version number and information") flagConfigDir = flag.String("config-dir", "", "Specify a custom location for the configuration directory") flagOptions = flag.Bool("options", false, "Show all option help") + flagDebug = flag.Bool("debug", false, "Enable debug mode (prints debug info to ./log.txt)") + flagPlugin = flag.String("plugin", "", "Plugin command") + flagClean = flag.Bool("clean", false, "Clean configuration directory") optionFlags map[string]*string ) func InitFlags() { flag.Usage = func() { fmt.Println("Usage: micro [OPTIONS] [FILE]...") + fmt.Println("-clean") + fmt.Println(" \tCleans the configuration directory") fmt.Println("-config-dir dir") fmt.Println(" \tSpecify a custom location for the configuration directory") - fmt.Println("[FILE]:LINE:COL") + fmt.Println("[FILE]:LINE:COL (if the `parsecursor` option is enabled)") + fmt.Println("+LINE:COL") fmt.Println(" \tSpecify a line and column to start the cursor at when opening a buffer") - fmt.Println(" \tThis can also be done by opening file:LINE:COL") fmt.Println("-options") fmt.Println(" \tShow all option help") + fmt.Println("-debug") + fmt.Println(" \tEnable debug mode (enables logging to ./log.txt)") fmt.Println("-version") fmt.Println(" \tShow the version number and information") + fmt.Print("\nMicro's plugin's can be managed at the command line with the following commands.\n") + fmt.Println("-plugin install [PLUGIN]...") + fmt.Println(" \tInstall plugin(s)") + fmt.Println("-plugin remove [PLUGIN]...") + fmt.Println(" \tRemove plugin(s)") + fmt.Println("-plugin update [PLUGIN]...") + fmt.Println(" \tUpdate plugin(s) (if no argument is given, updates all plugins)") + fmt.Println("-plugin search [PLUGIN]...") + fmt.Println(" \tSearch for a plugin") + fmt.Println("-plugin list") + fmt.Println(" \tList installed plugins") + fmt.Println("-plugin available") + fmt.Println(" \tList available plugins") + fmt.Print("\nMicro's options can also be set via command line arguments for quick\nadjustments. For real configuration, please use the settings.json\nfile (see 'help options').\n\n") fmt.Println("-option value") fmt.Println(" \tSet `option` to `value` for this session") @@ -81,11 +108,32 @@ func InitFlags() { } os.Exit(0) } + + if util.Debug == "OFF" && *flagDebug { + util.Debug = "ON" + } +} + +// DoPluginFlags parses and executes any flags that require LoadAllPlugins (-plugin and -clean) +func DoPluginFlags() { + if *flagClean || *flagPlugin != "" { + config.LoadAllPlugins() + + if *flagPlugin != "" { + args := flag.Args() + + config.PluginCommand(os.Stdout, *flagPlugin, args) + } else if *flagClean { + CleanConfig() + } + + os.Exit(0) + } } // LoadInput determines which files should be loaded into buffers // based on the input stored in flag.Args() -func LoadInput() []*buffer.Buffer { +func LoadInput(args []string) []*buffer.Buffer { // There are a number of ways micro should start given its input // 1. If it is given a files in flag.Args(), it should open those @@ -100,14 +148,47 @@ func LoadInput() []*buffer.Buffer { var filename string var input []byte var err error - args := flag.Args() buffers := make([]*buffer.Buffer, 0, len(args)) - if len(args) > 0 { + btype := buffer.BTDefault + if !isatty.IsTerminal(os.Stdout.Fd()) { + btype = buffer.BTStdout + } + + files := make([]string, 0, len(args)) + flagStartPos := buffer.Loc{-1, -1} + flagr := regexp.MustCompile(`^\+(\d+)(?::(\d+))?$`) + for _, a := range args { + match := flagr.FindStringSubmatch(a) + if len(match) == 3 && match[2] != "" { + line, err := strconv.Atoi(match[1]) + if err != nil { + screen.TermMessage(err) + continue + } + col, err := strconv.Atoi(match[2]) + if err != nil { + screen.TermMessage(err) + continue + } + flagStartPos = buffer.Loc{col - 1, line - 1} + } else if len(match) == 3 && match[2] == "" { + line, err := strconv.Atoi(match[1]) + if err != nil { + screen.TermMessage(err) + continue + } + flagStartPos = buffer.Loc{0, line - 1} + } else { + files = append(files, a) + } + } + + if len(files) > 0 { // Option 1 // We go through each file and load it - for i := 0; i < len(args); i++ { - buf, err := buffer.NewBufferFromFile(args[i], buffer.BTDefault) + for i := 0; i < len(files); i++ { + buf, err := buffer.NewBufferFromFileAtLoc(files[i], btype, flagStartPos) if err != nil { screen.TermMessage(err) continue @@ -124,17 +205,22 @@ func LoadInput() []*buffer.Buffer { screen.TermMessage("Error reading from stdin: ", err) input = []byte{} } - buffers = append(buffers, buffer.NewBufferFromString(string(input), filename, buffer.BTDefault)) + buffers = append(buffers, buffer.NewBufferFromStringAtLoc(string(input), filename, btype, flagStartPos)) } else { // Option 3, just open an empty buffer - buffers = append(buffers, buffer.NewBufferFromString(string(input), filename, buffer.BTDefault)) + buffers = append(buffers, buffer.NewBufferFromStringAtLoc(string(input), filename, btype, flagStartPos)) } return buffers } func main() { - defer os.Exit(0) + defer func() { + if util.Stdout.Len() > 0 { + fmt.Fprint(os.Stdout, util.Stdout.String()) + } + os.Exit(0) + }() // runtime.SetCPUProfileRate(400) // f, _ := os.Create("micro.prof") @@ -143,10 +229,10 @@ func main() { var err error - InitLog() - InitFlags() + InitLog() + err = config.InitConfigDir(*flagConfigDir) if err != nil { screen.TermMessage(err) @@ -157,7 +243,10 @@ func main() { if err != nil { screen.TermMessage(err) } - config.InitGlobalSettings() + err = config.InitGlobalSettings() + if err != nil { + screen.TermMessage(err) + } // flag options for k, v := range optionFlags { @@ -171,35 +260,22 @@ func main() { } } - action.InitBindings() - action.InitCommands() - - err = config.InitColorscheme() - if err != nil { - screen.TermMessage(err) - } + DoPluginFlags() - err = config.LoadAllPlugins() + err = screen.Init() if err != nil { - screen.TermMessage(err) + fmt.Println(err) + fmt.Println("Fatal: Micro could not initialize a Screen.") + os.Exit(1) } - err = config.RunPluginFn("init") - if err != nil { - screen.TermMessage(err) - } - - screen.Init() - // If we have an error, we can exit cleanly and not completely - // mess up the terminal being worked in - // In other words we need to shut down tcell before the program crashes defer func() { if err := recover(); err != nil { screen.Screen.Fini() fmt.Println("Micro encountered an error:", err) // backup all open buffers for _, b := range buffer.OpenBuffers { - b.Backup(false) + b.Backup() } // Print the stack trace too fmt.Print(errors.Wrap(err, 2).ErrorStack()) @@ -207,13 +283,40 @@ func main() { } }() - b := LoadInput() + err = config.LoadAllPlugins() + if err != nil { + screen.TermMessage(err) + } + + action.InitBindings() + action.InitCommands() + + err = config.InitColorscheme() + if err != nil { + screen.TermMessage(err) + } + + args := flag.Args() + b := LoadInput(args) + + if len(b) == 0 { + // No buffers to open + screen.Screen.Fini() + runtime.Goexit() + } + action.InitTabs(b) action.InitGlobals() + err = config.RunPluginFn("init") + if err != nil { + screen.TermMessage(err) + } + + events = make(chan tcell.Event) + // Here is the event loop which runs in a separate thread go func() { - events = make(chan tcell.Event) for { screen.Lock() e := screen.Screen.PollEvent() @@ -224,38 +327,79 @@ func main() { } }() + // clear the drawchan so we don't redraw excessively + // if someone requested a redraw before we started displaying + for len(screen.DrawChan()) > 0 { + <-screen.DrawChan() + } + + // wait for initial resize event + select { + case event := <-events: + action.Tabs.HandleEvent(event) + case <-time.After(10 * time.Millisecond): + // time out after 10ms + } + + // Since this loop is very slow (waits for user input every time) it's + // okay to be inefficient and run it via a function every time + // We do this so we can recover from panics without crashing the editor for { - // Display everything - screen.Screen.Fill(' ', config.DefStyle) - screen.Screen.HideCursor() - action.Tabs.Display() - for _, ep := range action.MainTab().Panes { - ep.Display() - } - action.MainTab().Display() - action.InfoBar.Display() - screen.Screen.Show() - - var event tcell.Event - - // Check for new events - select { - case f := <-shell.Jobs: - // If a new job has finished while running in the background we should execute the callback - f.Function(f.Output, f.Args...) - case <-config.Autosave: - for _, b := range buffer.OpenBuffers { - b.Save() + DoEvent() + } +} + +// DoEvent runs the main action loop of the editor +func DoEvent() { + var event tcell.Event + + // recover from errors without crashing the editor + defer func() { + if err := recover(); err != nil { + if e, ok := err.(*lua.ApiError); ok { + screen.TermMessage("Lua API error:", e) + } else { + screen.TermMessage("Micro encountered an error:", errors.Wrap(err, 2).ErrorStack(), "\nIf you can reproduce this error, please report it at https://github.com/zyedidia/micro/issues") } - case <-shell.CloseTerms: - case event = <-events: - case <-screen.DrawChan: } - - if action.InfoBar.HasPrompt { - action.InfoBar.HandleEvent(event) - } else { - action.Tabs.HandleEvent(event) + }() + // Display everything + screen.Screen.Fill(' ', config.DefStyle) + screen.Screen.HideCursor() + action.Tabs.Display() + for _, ep := range action.MainTab().Panes { + ep.Display() + } + action.MainTab().Display() + action.InfoBar.Display() + screen.Screen.Show() + + // Check for new events + select { + case f := <-shell.Jobs: + // If a new job has finished while running in the background we should execute the callback + ulua.Lock.Lock() + f.Function(f.Output, f.Args) + ulua.Lock.Unlock() + case <-config.Autosave: + ulua.Lock.Lock() + for _, b := range buffer.OpenBuffers { + b.Save() + } + ulua.Lock.Unlock() + case <-shell.CloseTerms: + case event = <-events: + case <-screen.DrawChan(): + for len(screen.DrawChan()) > 0 { + <-screen.DrawChan() } } + + ulua.Lock.Lock() + if action.InfoBar.HasPrompt { + action.InfoBar.HandleEvent(event) + } else { + action.Tabs.HandleEvent(event) + } + ulua.Lock.Unlock() }