Update plugin documentation

Adds `status.lines`, `status.vcol`, `status.bytes`, `status.size`,
and exposes some functions from go-humanize to plugins.

Ref #1727

.travis.yml

@@ -1,9 +1,11 @@
 language: go
 go:
-    - "1.11.x"
+    - "1.13.x"
 os:
     - linux
     - osx
+    - windows
 script:
-    - env GO111MODULE=on make build
-    - env GO111MODULE=on make test
+    - go build ./cmd/micro
+    - go test ./internal/...
+    - go test ./cmd/...

Makefile

@@ -64,6 +64,7 @@ testgen:
 
 test:
 	go test ./internal/...
+	go test ./cmd/...
 
 bench:
 	for i in 1 2 3; do \

README.md

@@ -79,6 +79,8 @@ If you want more information about ways to install micro, see this [wiki page](h
 Use `micro -version` to get the version information after installing. It is only guaranteed that you are installing the most recent
 stable version if you install from the prebuilt binaries, Homebrew, or Snap.
 
+A desktop entry file and man page can be found in the [assets/packaging](https://github.com/zyedidia/micro/tree/master/assets/packaging) directory.
+
 ### Prebuilt binaries
 
 All you need to install micro is one file, the binary itself. It's as simple as that!
@@ -95,7 +97,9 @@ You can easily install micro by running
 curl https://getmic.ro | bash
 ```
 
-The script will place the micro binary in the current directory. See its [GitHub repository](https://github.com/benweissmann/getmic.ro) for more information.
+The script will place the micro binary in the current directory. From there, you can move it to a directory on your path of your choosing (e.g. `sudo mv micro /usr/bin`). See its [GitHub repository](https://github.com/benweissmann/getmic.ro) for more information.
+
+To uninstall micro, simply remove the binary, and the configuration directory at `~/.config/micro`.
 
 ### Package managers
 
@@ -123,7 +127,7 @@ Micro is also available through other package managers on Linux such as apt, dnf
 for other operating systems. These packages are not guaranteed to be up-to-date.
 
 * Linux: Available in distro-specific package managers.
-    * `apt install micro` (Ubuntu 20.04 `focal`, and Debian `unstable | testing | buster-backports`).
+    * `apt install micro` (Ubuntu 20.04 `focal`, and Debian `unstable | testing | buster-backports`). At the moment, this package (2.0.1-1) is outdated and has a known bug where debug mode is enabled.
     * `dnf install micro` (Fedora).
     * `yay -S micro` (Arch Linux).
     * See [wiki](https://github.com/zyedidia/micro/wiki/Installing-Micro) for details about CRUX, Termux.

cmd/micro/clean.go

@@ -114,15 +114,21 @@ func CleanConfig() {
 			fmt.Printf("Removing badly formatted files in %s\n", filepath.Join(config.ConfigDir, "buffers"))
 
 			if shouldContinue() {
+				removed := 0
 				for _, f := range badFiles {
 					err := os.Remove(f)
 					if err != nil {
 						fmt.Println(err)
 						continue
 					}
+					removed++
 				}
 
-				fmt.Println("Removed badly formatted files")
+				if removed == 0 {
+					fmt.Println("Failed to remove files")
+				} else {
+					fmt.Printf("Removed %d badly formatted files\n", removed)
+				}
 				fmt.Print("\n\n")
 			}
 		}

cmd/micro/micro.go

@@ -132,7 +132,7 @@ func DoPluginFlags() {
 
 // 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
@@ -147,7 +147,6 @@ func LoadInput() []*buffer.Buffer {
 	var filename string
 	var input []byte
 	var err error
-	args := flag.Args()
 	buffers := make([]*buffer.Buffer, 0, len(args))
 
 	btype := buffer.BTDefault
@@ -262,7 +261,12 @@ func main() {
 
 	DoPluginFlags()
 
-	screen.Init()
+	err = screen.Init()
+	if err != nil {
+		fmt.Println(err)
+		fmt.Println("Fatal: Micro could not initialize a Screen.")
+		os.Exit(1)
+	}
 
 	defer func() {
 		if err := recover(); err != nil {
@@ -270,7 +274,7 @@ func main() {
 			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())
@@ -291,7 +295,8 @@ func main() {
 		screen.TermMessage(err)
 	}
 
-	b := LoadInput()
+	args := flag.Args()
+	b := LoadInput(args)
 
 	if len(b) == 0 {
 		// No buffers to open

cmd/micro/micro_test.go

@@ -0,0 +1,341 @@
+package main
+
+import (
+	"fmt"
+	"io/ioutil"
+	"log"
+	"os"
+	"testing"
+
+	"github.com/go-errors/errors"
+	"github.com/stretchr/testify/assert"
+	"github.com/zyedidia/micro/v2/internal/action"
+	"github.com/zyedidia/micro/v2/internal/buffer"
+	"github.com/zyedidia/micro/v2/internal/config"
+	"github.com/zyedidia/micro/v2/internal/screen"
+	"github.com/zyedidia/tcell"
+)
+
+var tempDir string
+var sim tcell.SimulationScreen
+
+func init() {
+	events = make(chan tcell.Event, 8)
+}
+
+func startup(args []string) (tcell.SimulationScreen, error) {
+	var err error
+
+	tempDir, err = ioutil.TempDir("", "micro_test")
+	if err != nil {
+		return nil, err
+	}
+	err = config.InitConfigDir(tempDir)
+	if err != nil {
+		return nil, err
+	}
+
+	config.InitRuntimeFiles()
+	err = config.ReadSettings()
+	if err != nil {
+		return nil, err
+	}
+	err = config.InitGlobalSettings()
+	if err != nil {
+		return nil, err
+	}
+
+	s, err := screen.InitSimScreen()
+	if err != nil {
+		return nil, err
+	}
+
+	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()
+			}
+			// Print the stack trace too
+			log.Fatalf(errors.Wrap(err, 2).ErrorStack())
+			os.Exit(1)
+		}
+	}()
+
+	err = config.LoadAllPlugins()
+	if err != nil {
+		screen.TermMessage(err)
+	}
+
+	action.InitBindings()
+	action.InitCommands()
+
+	err = config.InitColorscheme()
+	if err != nil {
+		return nil, err
+	}
+
+	b := LoadInput(args)
+
+	if len(b) == 0 {
+		return nil, errors.New("No buffers opened")
+	}
+
+	action.InitTabs(b)
+	action.InitGlobals()
+
+	err = config.RunPluginFn("init")
+	if err != nil {
+		return nil, err
+	}
+
+	s.InjectResize()
+	handleEvent()
+
+	return s, nil
+}
+
+func cleanup() {
+	os.RemoveAll(tempDir)
+}
+
+func handleEvent() {
+	screen.Lock()
+	e := screen.Screen.PollEvent()
+	screen.Unlock()
+	if e != nil {
+		events <- e
+	}
+	DoEvent()
+}
+
+func injectKey(key tcell.Key, r rune, mod tcell.ModMask) {
+	sim.InjectKey(key, r, mod)
+	handleEvent()
+}
+
+func injectMouse(x, y int, buttons tcell.ButtonMask, mod tcell.ModMask) {
+	sim.InjectMouse(x, y, buttons, mod)
+	handleEvent()
+}
+
+func injectString(str string) {
+	// the tcell simulation screen event channel can only handle
+	// 10 events at once, so we need to divide up the key events
+	// into chunks of 10 and handle the 10 events before sending
+	// another chunk of events
+	iters := len(str) / 10
+	extra := len(str) % 10
+
+	for i := 0; i < iters; i++ {
+		s := i * 10
+		e := i*10 + 10
+		sim.InjectKeyBytes([]byte(str[s:e]))
+		for i := 0; i < 10; i++ {
+			handleEvent()
+		}
+	}
+
+	sim.InjectKeyBytes([]byte(str[len(str)-extra:]))
+	for i := 0; i < extra; i++ {
+		handleEvent()
+	}
+}
+
+func openFile(file string) {
+	injectKey(tcell.KeyCtrlE, rune(tcell.KeyCtrlE), tcell.ModCtrl)
+	injectString(fmt.Sprintf("open %s", file))
+	injectKey(tcell.KeyEnter, rune(tcell.KeyEnter), tcell.ModNone)
+}
+
+func createTestFile(name string, content string) (string, error) {
+	testf, err := ioutil.TempFile("", name)
+	if err != nil {
+		return "", err
+	}
+
+	if _, err := testf.Write([]byte(content)); err != nil {
+		return "", err
+	}
+	if err := testf.Close(); err != nil {
+		return "", err
+	}
+
+	return testf.Name(), nil
+}
+
+func TestMain(m *testing.M) {
+	var err error
+	sim, err = startup([]string{})
+	if err != nil {
+		log.Fatalln(err)
+		os.Exit(1)
+	}
+
+	retval := m.Run()
+	cleanup()
+
+	os.Exit(retval)
+}
+
+func TestSimpleEdit(t *testing.T) {
+	file, err := createTestFile("micro_simple_edit_test", "base content")
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	defer os.Remove(file)
+
+	openFile(file)
+
+	var buf *buffer.Buffer
+	for _, b := range buffer.OpenBuffers {
+		if b.Path == file {
+			buf = b
+		}
+	}
+
+	if buf == nil {
+		t.Errorf("Could not find buffer %s", file)
+		return
+	}
+
+	injectKey(tcell.KeyEnter, rune(tcell.KeyEnter), tcell.ModNone)
+	injectKey(tcell.KeyUp, 0, tcell.ModNone)
+	injectString("first line")
+
+	// test both kinds of backspace
+	for i := 0; i < len("ne"); i++ {
+		injectKey(tcell.KeyBackspace, rune(tcell.KeyBackspace), tcell.ModNone)
+	}
+	for i := 0; i < len(" li"); i++ {
+		injectKey(tcell.KeyBackspace2, rune(tcell.KeyBackspace2), tcell.ModNone)
+	}
+	injectString("foobar")
+
+	injectKey(tcell.KeyCtrlS, rune(tcell.KeyCtrlS), tcell.ModCtrl)
+
+	data, err := ioutil.ReadFile(file)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+
+	assert.Equal(t, "firstfoobar\nbase content\n", string(data))
+}
+
+func TestMouse(t *testing.T) {
+	file, err := createTestFile("micro_mouse_test", "base content")
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	defer os.Remove(file)
+
+	openFile(file)
+
+	// buffer:
+	// base content
+	// the selections need to happen at different locations to avoid a double click
+	injectMouse(3, 0, tcell.Button1, tcell.ModNone)
+	injectKey(tcell.KeyLeft, 0, tcell.ModNone)
+	injectMouse(0, 0, tcell.ButtonNone, tcell.ModNone)
+	injectString("secondline")
+	// buffer:
+	// secondlinebase content
+	injectKey(tcell.KeyEnter, rune(tcell.KeyEnter), tcell.ModNone)
+	// buffer:
+	// secondline
+	// base content
+	injectMouse(2, 0, tcell.Button1, tcell.ModNone)
+	injectMouse(0, 0, tcell.ButtonNone, tcell.ModNone)
+	injectKey(tcell.KeyEnter, rune(tcell.KeyEnter), tcell.ModNone)
+	// buffer:
+	//
+	// secondline
+	// base content
+	injectKey(tcell.KeyUp, 0, tcell.ModNone)
+	injectString("firstline")
+	// buffer:
+	// firstline
+	// secondline
+	// base content
+	injectKey(tcell.KeyCtrlS, rune(tcell.KeyCtrlS), tcell.ModCtrl)
+
+	data, err := ioutil.ReadFile(file)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+
+	assert.Equal(t, "firstline\nsecondline\nbase content\n", string(data))
+}
+
+var srTestStart = `foo
+foo
+foofoofoo
+Ernleȝe foo æðelen
+`
+var srTest2 = `test_string
+test_string
+test_stringtest_stringtest_string
+Ernleȝe test_string æðelen
+`
+var srTest3 = `test_foo
+test_string
+test_footest_stringtest_foo
+Ernleȝe test_string æðelen
+`
+
+func TestSearchAndReplace(t *testing.T) {
+	file, err := createTestFile("micro_search_replace_test", srTestStart)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	defer os.Remove(file)
+
+	openFile(file)
+
+	injectKey(tcell.KeyCtrlE, rune(tcell.KeyCtrlE), tcell.ModCtrl)
+	injectString(fmt.Sprintf("replaceall %s %s", "foo", "test_string"))
+	injectKey(tcell.KeyEnter, rune(tcell.KeyEnter), tcell.ModNone)
+
+	injectKey(tcell.KeyCtrlS, rune(tcell.KeyCtrlS), tcell.ModCtrl)
+
+	data, err := ioutil.ReadFile(file)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+
+	assert.Equal(t, srTest2, string(data))
+
+	injectKey(tcell.KeyCtrlE, rune(tcell.KeyCtrlE), tcell.ModCtrl)
+	injectString(fmt.Sprintf("replace %s %s", "string", "foo"))
+	injectKey(tcell.KeyEnter, rune(tcell.KeyEnter), tcell.ModNone)
+	injectString("ynyny")
+	injectKey(tcell.KeyEscape, 0, tcell.ModNone)
+
+	injectKey(tcell.KeyCtrlS, rune(tcell.KeyCtrlS), tcell.ModCtrl)
+
+	data, err = ioutil.ReadFile(file)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+
+	assert.Equal(t, srTest3, string(data))
+}
+
+func TestMultiCursor(t *testing.T) {
+	// TODO
+}
+
+func TestSettingsPersistence(t *testing.T) {
+	// TODO
+}
+
+// more tests (rendering, tabs, plugins)?

go.mod

@@ -17,7 +17,7 @@ require (
 	github.com/zyedidia/highlight v0.0.0-20170330143449-201131ce5cf5
 	github.com/zyedidia/json5 v0.0.0-20200102012142-2da050b1a98d
 	github.com/zyedidia/pty v2.0.0+incompatible // indirect
-	github.com/zyedidia/tcell v1.4.7
+	github.com/zyedidia/tcell v1.4.8
 	github.com/zyedidia/terminal v0.0.0-20180726154117-533c623e2415
 	golang.org/x/text v0.3.2
 	gopkg.in/sourcemap.v1 v1.0.5 // indirect

go.sum

@@ -52,8 +52,8 @@ github.com/zyedidia/poller v1.0.1 h1:Tt9S3AxAjXwWGNiC2TUdRJkQDZSzCBNVQ4xXiQ7440s
 github.com/zyedidia/poller v1.0.1/go.mod h1:vZXJOHGDcuK08GXhF6IAY0ZFd2WcgOR5DOTp84Uk5eE=
 github.com/zyedidia/pty v2.0.0+incompatible h1:Ou5vXL6tvjst+RV8sUFISbuKDnUJPhnpygApMFGweqw=
 github.com/zyedidia/pty v2.0.0+incompatible/go.mod h1:4y9l9yJZNxRa7GB/fB+mmDmGkG3CqmzLf4vUxGGotEA=
-github.com/zyedidia/tcell v1.4.7 h1:bKXRjv8RglPyOFqofzUUJkrdsLs9p9mT89W2ShFFlco=
-github.com/zyedidia/tcell v1.4.7/go.mod h1:HhlbMSCcGX15rFDB+Q1Lk3pKEOocsCUAQC3zhZ9sadA=
+github.com/zyedidia/tcell v1.4.8 h1:s4zYGOyCNDK4cdrgNVME0SxGizuT/oKY3OyB4Ls2Qpg=
+github.com/zyedidia/tcell v1.4.8/go.mod h1:HhlbMSCcGX15rFDB+Q1Lk3pKEOocsCUAQC3zhZ9sadA=
 github.com/zyedidia/terminal v0.0.0-20180726154117-533c623e2415 h1:752dTQ5OatJ9M5ULK2+9lor+nzyZz+LYDo3WGngg3Rc=
 github.com/zyedidia/terminal v0.0.0-20180726154117-533c623e2415/go.mod h1:8leT8G0Cm8NoJHdrrKHyR9MirWoF4YW7pZh06B6H+1E=
 golang.org/x/sys v0.0.0-20190204203706-41f3e6584952/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=

internal/action/actions.go

@@ -816,6 +816,30 @@ func (h *BufPane) FindLiteral() bool {
 	return h.find(false)
 }
 
+// Search searches for a given string/regex in the buffer and selects the next
+// match if a match is found
+// This function affects lastSearch and lastSearchRegex (saved searches) for
+// use with FindNext and FindPrevious
+func (h *BufPane) Search(str string, useRegex bool, searchDown bool) error {
+	match, found, err := h.Buf.FindNext(str, h.Buf.Start(), h.Buf.End(), h.Cursor.Loc, searchDown, useRegex)
+	if err != nil {
+		return err
+	}
+	if found {
+		h.Cursor.SetSelectionStart(match[0])
+		h.Cursor.SetSelectionEnd(match[1])
+		h.Cursor.OrigSelection[0] = h.Cursor.CurSelection[0]
+		h.Cursor.OrigSelection[1] = h.Cursor.CurSelection[1]
+		h.Cursor.GotoLoc(h.Cursor.CurSelection[1])
+		h.lastSearch = str
+		h.lastSearchRegex = useRegex
+		h.Relocate()
+	} else {
+		h.Cursor.ResetSelection()
+	}
+	return nil
+}
+
 func (h *BufPane) find(useRegex bool) bool {
 	h.searchOrig = h.Cursor.Loc
 	prompt := "Find: "

internal/action/defaults_darwin.go

@@ -30,8 +30,9 @@ func DefaultBindings() map[string]string {
 		"Alt-{":          "ParagraphPrevious",
 		"Alt-}":          "ParagraphNext",
 		"Enter":          "InsertNewline",
-		"Ctrl-h":         "Backspace",
+		"CtrlH":          "Backspace",
 		"Backspace":      "Backspace",
+		"OldBackspace":   "Backspace",
 		"Alt-CtrlH":      "DeleteWordLeft",
 		"Alt-Backspace":  "DeleteWordLeft",
 		"Tab":            "Autocomplete|IndentSelection|InsertTab",

internal/action/defaults_other.go

@@ -32,8 +32,9 @@ func DefaultBindings() map[string]string {
 		"Alt-{":          "ParagraphPrevious",
 		"Alt-}":          "ParagraphNext",
 		"Enter":          "InsertNewline",
-		"Ctrl-h":         "Backspace",
+		"CtrlH":          "Backspace",
 		"Backspace":      "Backspace",
+		"OldBackspace":   "Backspace",
 		"Alt-CtrlH":      "DeleteWordLeft",
 		"Alt-Backspace":  "DeleteWordLeft",
 		"Tab":            "Autocomplete|IndentSelection|InsertTab",

internal/buffer/backup.go

@@ -28,29 +28,53 @@ The backup was created on %s, and the file is
 
 Options: [r]ecover, [i]gnore: `
 
+var backupRequestChan chan *Buffer
+
+func backupThread() {
+	for {
+		time.Sleep(time.Second * 8)
+
+		for len(backupRequestChan) > 0 {
+			b := <-backupRequestChan
+			b.Backup()
+		}
+	}
+}
+
+func init() {
+	backupRequestChan = make(chan *Buffer, 10)
+
+	go backupThread()
+}
+
+func (b *Buffer) RequestBackup() {
+	if !b.requestedBackup {
+		select {
+		case backupRequestChan <- b:
+		default:
+			// channel is full
+		}
+		b.requestedBackup = true
+	}
+}
+
 // Backup saves the current buffer to ConfigDir/backups
-func (b *Buffer) Backup(checkTime bool) error {
+func (b *Buffer) Backup() error {
 	if !b.Settings["backup"].(bool) || b.Path == "" || b.Type != BTDefault {
 		return nil
 	}
 
-	if checkTime {
-		sub := time.Now().Sub(b.lastbackup)
-		if sub < time.Duration(backupTime)*time.Millisecond {
-			return nil
-		}
+	backupdir, err := util.ReplaceHome(b.Settings["backupdir"].(string))
+	if len(backupdir) == 0 || err != nil {
+		backupdir = filepath.Join(config.ConfigDir, "backups")
 	}
-
-	b.lastbackup = time.Now()
-
-	backupdir := filepath.Join(config.ConfigDir, "backups")
 	if _, err := os.Stat(backupdir); os.IsNotExist(err) {
 		os.Mkdir(backupdir, os.ModePerm)
 	}
 
 	name := filepath.Join(backupdir, util.EscapePath(b.AbsPath))
 
-	err := overwriteFile(name, encoding.Nop, func(file io.Writer) (e error) {
+	err = overwriteFile(name, encoding.Nop, func(file io.Writer) (e error) {
 		if len(b.lines) == 0 {
 			return
 		}
@@ -74,12 +98,14 @@ func (b *Buffer) Backup(checkTime bool) error {
 		return
 	}, false)
 
+	b.requestedBackup = false
+
 	return err
 }
 
 // RemoveBackup removes any backup file associated with this buffer
 func (b *Buffer) RemoveBackup() {
-	if !b.Settings["backup"].(bool) || b.Path == "" || b.Type != BTDefault {
+	if !b.Settings["backup"].(bool) || b.Settings["permbackup"].(bool) || b.Path == "" || b.Type != BTDefault {
 		return
 	}
 	f := filepath.Join(config.ConfigDir, "backups", util.EscapePath(b.AbsPath))
@@ -89,7 +115,7 @@ func (b *Buffer) RemoveBackup() {
 // ApplyBackup applies the corresponding backup file to this buffer (if one exists)
 // Returns true if a backup was applied
 func (b *Buffer) ApplyBackup(fsize int64) bool {
-	if b.Settings["backup"].(bool) && len(b.Path) > 0 && b.Type == BTDefault {
+	if b.Settings["backup"].(bool) && !b.Settings["permbackup"].(bool) && len(b.Path) > 0 && b.Type == BTDefault {
 		backupfile := filepath.Join(config.ConfigDir, "backups", util.EscapePath(b.AbsPath))
 		if info, err := os.Stat(backupfile); err == nil {
 			backup, err := os.Open(backupfile)

internal/buffer/buffer.go

@@ -102,9 +102,7 @@ type SharedBuffer struct {
 	diffLock          sync.RWMutex
 	diff              map[int]DiffStatus
 
-	// counts the number of edits
-	// resets every backupTime edits
-	lastbackup time.Time
+	requestedBackup bool
 
 	// ReloadDisabled allows the user to disable reloads if they
 	// are viewing a file that is constantly changing
@@ -271,6 +269,7 @@ func NewBuffer(r io.Reader, size int64, path string, startcursor Loc, btype BufT
 		}
 	}
 
+	hasBackup := false
 	if !found {
 		b.SharedBuffer = new(SharedBuffer)
 		b.Type = btype
@@ -293,7 +292,7 @@ func NewBuffer(r io.Reader, size int64, path string, startcursor Loc, btype BufT
 			b.Settings["encoding"] = "utf-8"
 		}
 
-		hasBackup := b.ApplyBackup(size)
+		hasBackup = b.ApplyBackup(size)
 
 		if !hasBackup {
 			reader := bufio.NewReader(transform.NewReader(r, enc.NewDecoder()))
@@ -356,7 +355,9 @@ func NewBuffer(r io.Reader, size int64, path string, startcursor Loc, btype BufT
 		if size > LargeFileThreshold {
 			// If the file is larger than LargeFileThreshold fastdirty needs to be on
 			b.Settings["fastdirty"] = true
-		} else {
+		} else if !hasBackup {
+			// since applying a backup does not save the applied backup to disk, we should
+			// not calculate the original hash based on the backup data
 			calcHash(b, &b.origHash)
 		}
 	}
@@ -425,7 +426,7 @@ func (b *Buffer) Insert(start Loc, text string) {
 		b.EventHandler.active = b.curCursor
 		b.EventHandler.Insert(start, text)
 
-		go b.Backup(true)
+		b.RequestBackup()
 	}
 }
 
@@ -436,7 +437,7 @@ func (b *Buffer) Remove(start, end Loc) {
 		b.EventHandler.active = b.curCursor
 		b.EventHandler.Remove(start, end)
 
-		go b.Backup(true)
+		b.RequestBackup()
 	}
 }
 
@@ -533,6 +534,22 @@ func (b *Buffer) Modified() bool {
 	return buff != b.origHash
 }
 
+// Size returns the number of bytes in the current buffer
+func (b *Buffer) Size() int {
+	nb := 0
+	for i := 0; i < b.LinesNum(); i++ {
+		nb += len(b.LineBytes(i))
+
+		if i != b.LinesNum()-1 {
+			if b.Endings == FFDos {
+				nb++ // carriage return
+			}
+			nb++ // newline
+		}
+	}
+	return nb
+}
+
 // calcHash calculates md5 hash of all lines in the buffer
 func calcHash(b *Buffer, out *[md5.Size]byte) error {
 	h := md5.New()

internal/buffer/line_array.go

@@ -191,10 +191,15 @@ func (la *LineArray) newlineBelow(y int) {
 func (la *LineArray) insert(pos Loc, value []byte) {
 	x, y := runeToByteIndex(pos.X, la.lines[pos.Y].data), pos.Y
 	for i := 0; i < len(value); i++ {
-		if value[i] == '\n' {
+		if value[i] == '\n' || (value[i] == '\r' && i < len(value)-1 && value[i+1] == '\n') {
 			la.split(Loc{x, y})
 			x = 0
 			y++
+
+			if value[i] == '\r' {
+				i++
+			}
+
 			continue
 		}
 		la.insertByte(Loc{x, y}, value[i])

internal/config/settings.go

@@ -27,7 +27,8 @@ var (
 	GlobalSettings map[string]interface{}
 
 	// This is the raw parsed json
-	parsedSettings map[string]interface{}
+	parsedSettings     map[string]interface{}
+	settingsParseError bool
 
 	// ModifiedSettings is a map of settings which should be written to disk
 	// because they have been modified by the user in this session
@@ -56,12 +57,14 @@ func ReadSettings() error {
 	if _, e := os.Stat(filename); e == nil {
 		input, err := ioutil.ReadFile(filename)
 		if err != nil {
+			settingsParseError = true
 			return errors.New("Error reading settings.json file: " + err.Error())
 		}
 		if !strings.HasPrefix(string(input), "null") {
 			// Unmarshal the input into the parsed map
 			err = json5.Unmarshal(input, &parsedSettings)
 			if err != nil {
+				settingsParseError = true
 				return errors.New("Error reading settings.json: " + err.Error())
 			}
 
@@ -151,6 +154,14 @@ func InitLocalSettings(settings map[string]interface{}, path string) error {
 
 // WriteSettings writes the settings to the specified filename as JSON
 func WriteSettings(filename string) error {
+	if settingsParseError {
+		// Don't write settings if there was a parse error
+		// because this will delete the settings.json if it
+		// is invalid. Instead we should allow the user to fix
+		// it manually.
+		return nil
+	}
+
 	var err error
 	if _, e := os.Stat(ConfigDir); e == nil {
 		defaults := DefaultGlobalSettings()
@@ -205,7 +216,7 @@ func OverwriteSettings(filename string) error {
 // RegisterCommonOptionPlug creates a new option (called pl.name). This is meant to be called by plugins to add options.
 func RegisterCommonOptionPlug(pl string, name string, defaultvalue interface{}) error {
 	name = pl + "." + name
-	if v, ok := GlobalSettings[name]; !ok {
+	if _, ok := GlobalSettings[name]; !ok {
 		defaultCommonSettings[name] = defaultvalue
 		GlobalSettings[name] = defaultvalue
 		err := WriteSettings(filepath.Join(ConfigDir, "settings.json"))
@@ -213,7 +224,7 @@ func RegisterCommonOptionPlug(pl string, name string, defaultvalue interface{})
 			return errors.New("Error writing settings.json file: " + err.Error())
 		}
 	} else {
-		defaultCommonSettings[name] = v
+		defaultCommonSettings[name] = defaultvalue
 	}
 	return nil
 }
@@ -247,6 +258,7 @@ var defaultCommonSettings = map[string]interface{}{
 	"autoindent":     true,
 	"autosu":         false,
 	"backup":         true,
+	"backupdir":      "",
 	"basename":       false,
 	"colorcolumn":    float64(0),
 	"cursorline":     true,
@@ -261,6 +273,7 @@ var defaultCommonSettings = map[string]interface{}{
 	"keepautoindent": false,
 	"matchbrace":     true,
 	"mkparents":      false,
+	"permbackup":     false,
 	"readonly":       false,
 	"rmtrailingws":   false,
 	"ruler":          true,

internal/lua/lua.go

@@ -18,6 +18,7 @@ import (
 	"time"
 	"unicode/utf8"
 
+	humanize "github.com/dustin/go-humanize"
 	lua "github.com/yuin/gopher-lua"
 	luar "layeh.com/gopher-luar"
 )
@@ -69,6 +70,8 @@ func Import(pkg string) *lua.LTable {
 		return importTime()
 	case "unicode/utf8", "utf8":
 		return importUtf8()
+	case "humanize":
+		return importHumanize()
 	default:
 		return nil
 	}
@@ -556,3 +559,14 @@ func importUtf8() *lua.LTable {
 
 	return pkg
 }
+
+func importHumanize() *lua.LTable {
+	pkg := L.NewTable()
+
+	L.SetField(pkg, "Bytes", luar.New(L, humanize.Bytes))
+	L.SetField(pkg, "Ordinal", luar.New(L, humanize.Ordinal))
+	L.SetField(pkg, "Ftoa", luar.New(L, humanize.Ftoa))
+	L.SetField(pkg, "FtoaWithDigits", luar.New(L, humanize.FtoaWithDigits))
+
+	return pkg
+}

internal/screen/screen.go

@@ -1,7 +1,7 @@
 package screen
 
 import (
-	"fmt"
+	"errors"
 	"os"
 	"sync"
 	"unicode"
@@ -131,7 +131,7 @@ func TempStart(screenWasNil bool) {
 }
 
 // Init creates and initializes the tcell screen
-func Init() {
+func Init() error {
 	drawChan = make(chan bool, 8)
 
 	// Should we enable true color?
@@ -151,13 +151,10 @@ func Init() {
 	var err error
 	Screen, err = tcell.NewScreen()
 	if err != nil {
-		fmt.Println(err)
-		fmt.Println("Fatal: Micro could not initialize a Screen.")
-		os.Exit(1)
+		return err
 	}
 	if err = Screen.Init(); err != nil {
-		fmt.Println(err)
-		os.Exit(1)
+		return err
 	}
 
 	// restore TERM
@@ -168,4 +165,30 @@ func Init() {
 	if config.GetGlobalOption("mouse").(bool) {
 		Screen.EnableMouse()
 	}
+
+	return nil
+}
+
+// InitSimScreen initializes a simulation screen for testing purposes
+func InitSimScreen() (tcell.SimulationScreen, error) {
+	drawChan = make(chan bool, 8)
+
+	// Initilize tcell
+	var err error
+	s := tcell.NewSimulationScreen("")
+	if s == nil {
+		return nil, errors.New("Failed to get a simulation screen")
+	}
+	if err = s.Init(); err != nil {
+		return nil, err
+	}
+
+	s.SetSize(80, 24)
+	Screen = s
+
+	if config.GetGlobalOption("mouse").(bool) {
+		Screen.EnableMouse()
+	}
+
+	return s, nil
 }

runtime/help/options.md

@@ -37,21 +37,26 @@ Here are the available options:
    closed cleanly. In the case of a system crash or a micro crash, the contents
    of the buffer can be recovered automatically by opening the file that was
    being edited before the crash, or manually by searching for the backup in
-   the backup directory. Backups are made in the background when a buffer is
-   modified and the latest backup is more than 8 seconds old, or when micro
-   detects a crash. It is highly recommended that you leave this feature
-   enabled.
+   the backup directory. Backups are made in the background for newly modified
+   buffers every 8 seconds, or when micro detects a crash.
 
     default value: `true`
 
+* `backupdir`: the directory micro should place backups in. For the default
+   value of `""` (empty string), the backup directory will be
+   `ConfigDir/backups`, which is `~/.config/micro/backups` by default. The
+   directory specified for backups will be created if it does not exist.
+
+    default value: `""` (empty string)
+
 * `basename`: in the infobar and tabbar, show only the basename of the file
    being edited rather than the full path.
 
     default value: `false`
 
 * `colorcolumn`: if this is not set to 0, it will display a column at the
-  specified column. This is useful if you want column 80 to be highlighted
-  special for example.
+   specified column. This is useful if you want column 80 to be highlighted
+   special for example.
 
 	default value: `0`
 
@@ -200,6 +205,13 @@ Here are the available options:
 
     default value: `false`
 
+* `permbackup`: this option causes backups (see `backup` option) to be
+   permanently saved. With permanent backups, micro will not remove backups when
+   files are closed and will never apply them to existing files. Use this option
+   if you are interested in manually managing your backup files.
+
+    default value: `false`
+
 * `pluginchannels`: list of URLs pointing to plugin channels for downloading and
    installing plugins. A plugin channel consists of a json file with links to
    plugin repos, which store information about plugin versions and download URLs.

runtime/help/plugins.md

@@ -359,6 +359,14 @@ library documentation at https://golang.org/pkg/ (for the packages
 exposed to micro plugins). The Lua standard library is also available
 to plugins though it is rather small.
 
+The following functions are also available from the go-humanize package:
+
+The `humanize` package exposes:
+* `Bytes`
+* `Ordinal`
+* `Ftoa`
+* `FtoaWithDigits`
+
 ## Adding help files, syntax files, or colorschemes in your plugin
 
 You can use the `AddRuntimeFile(name string, type config.RTFiletype,

runtime/plugins/status/help/status.md

@@ -6,10 +6,14 @@ Using the `statusformatl` and `statusformatr` options, the exact contents
 of the status line can be modified. Please see the documentation for
 those options (`> help options`) for more information.
 
-This plugin provides the three functions that can be used in the status
-line format:
+This plugin provides functions that can be used in the status line format:
 
 * `status.branch`: returns the name of the current git branch.
 * `status.hash`: returns the hash of the current git commit.
 * `status.paste`: returns "" if the paste option is disabled and "PASTE"
    if it is enabled.
+* `status.lines`: returns the number of lines in the buffer.
+* `status.vcol`: returns the visual column number of the cursor.
+* `status.bytes`: returns the number of bytes in the current buffer.
+* `status.size`: returns the size of the current buffer in a human-readable
+   format.

runtime/plugins/status/status.lua

@@ -3,14 +3,35 @@ VERSION = "1.0.0"
 local micro = import("micro")
 local buffer = import("micro/buffer")
 local config = import("micro/config")
+local humanize = import("humanize")
 
 function init()
     micro.SetStatusInfoFn("status.branch")
     micro.SetStatusInfoFn("status.hash")
     micro.SetStatusInfoFn("status.paste")
+    micro.SetStatusInfoFn("status.vcol")
+    micro.SetStatusInfoFn("status.lines")
+    micro.SetStatusInfoFn("status.bytes")
+    micro.SetStatusInfoFn("status.size")
     config.AddRuntimeFile("status", config.RTHelp, "help/status.md")
 end
 
+function lines(b)
+    return tostring(b:LinesNum())
+end
+
+function vcol(b)
+    return tostring(b:GetActiveCursor():GetVisualX())
+end
+
+function bytes(b)
+    return tostring(b:Size())
+end
+
+function size(b)
+    return humanize.Bytes(b:Size())
+end
+
 function branch(b)
     if b.Type.Kind ~= buffer.BTInfo then
         local shell = import("micro/shell")

runtime/syntax/crontab.yaml

@@ -14,16 +14,16 @@ rules:
       #              month          0-12 (or names, see below)
       #              day of week    0-7 (0 or 7 is Sun, or use names)
 
-    - statement: "^([\\*0-9,\\-\\/]+)\\s+([\\*0-9,\\-\\/]+)\\s+([\\*0-9,\\-\\/]+)\\s+([\\*0-9,\\-\\/]+)\\s+([\\*0-9,\\-\\/]+)\\s+(.*)$\\n?"
-    - constant: "^([\\*0-9,\\-\\/]+)\\s+([\\*0-9,\\-\\/]+)\\s+([\\*0-9,\\-\\/]+)\\s+([\\*0-9,\\-\\/]+)\\s+([\\*0-9,\\-\\/]+)"
+    - statement: "^([\\*0-9,\\-\\/]+)\\s+([\\*0-9,\\-\\/]+)\\s+([\\*0-9,\\-\\/]+)\\s+(([\\*0-9,\\-\\/]+)|(\\b(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\\b))\\s+(([\\*0-9,\\-\\/]+)|(\\b(sun|mon|tue|wed|thu|fri|sat)\\b))\\s+(.*)$\\n?"
+    - constant:  "^([\\*0-9,\\-\\/]+)\\s+([\\*0-9,\\-\\/]+)\\s+([\\*0-9,\\-\\/]+)\\s+(([\\*0-9,\\-\\/]+)|(\\b(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\\b))\\s+(([\\*0-9,\\-\\/]+)|(\\b(sun|mon|tue|wed|thu|fri|sat)\\b))"
     
       # Shell Values
     - type: "^[A-Z]+\\="
 
       # Months and weekday keywords
-    - type: "jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec"
-    - constant: "sun|mon|tue|wed|thu|fri|sat"
-    - type: "\\@(reboot|yearly|annually|monthly|weekly|daily|midnight|hourly)"
+    - constant: "\\b(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\\b"
+    - constant: "\\b(sun|mon|tue|wed|thu|fri|sat)\\b"
+    - type: "\\@(reboot|yearly|annually|monthly|weekly|daily|midnight|hourly)\\b"
 
       # Conditionals
     - special: "(\\{|\\}|\\(|\\)|\\;|\\]|\\[|`|\\\\|\\$|<|>|^|!|=|&|\\|)"