Update plugin documentation

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

Ref #1727

.github/ISSUE_TEMPLATE

@@ -2,7 +2,7 @@
 
 ## Specifications
 
-You can use `micro -version` to get the commit hash.
+<!-- You can use `micro -version` to get the commit hash. -->
 
 Commit hash:
 OS:

.gitignore

@@ -11,8 +11,10 @@ todo.txt
 test.txt
 log.txt
 *.old
+benchmark_results*
 tools/build-version
 tools/build-date
 tools/info-plist
 tools/bindata
+tools/vscode-tests/
 *.hdr

.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

@@ -8,14 +8,16 @@ DATE = $(shell GOOS=$(shell go env GOHOSTOS) GOARCH=$(shell go env GOHOSTARCH) \
 ADDITIONAL_GO_LINKER_FLAGS = $(shell GOOS=$(shell go env GOHOSTOS) \
 	GOARCH=$(shell go env GOHOSTARCH))
 GOBIN ?= $(shell go env GOPATH)/bin
-GOVARS = -X github.com/zyedidia/micro/internal/util.Version=$(VERSION) -X github.com/zyedidia/micro/internal/util.CommitHash=$(HASH) -X 'github.com/zyedidia/micro/internal/util.CompileDate=$(DATE)' -X github.com/zyedidia/micro/internal/util.Debug=OFF
+GOVARS = -X github.com/zyedidia/micro/v2/internal/util.Version=$(VERSION) -X github.com/zyedidia/micro/v2/internal/util.CommitHash=$(HASH) -X 'github.com/zyedidia/micro/v2/internal/util.CompileDate=$(DATE)'
+DEBUGVAR = -X github.com/zyedidia/micro/v2/internal/util.Debug=ON
+VSCODE_TESTS_BASE_URL = 'https://raw.githubusercontent.com/microsoft/vscode/e6a45f4242ebddb7aa9a229f85555e8a3bd987e2/src/vs/editor/test/common/model/'
 
 # Builds micro after checking dependencies but without updating the runtime
 build:
 	go build -ldflags "-s -w $(GOVARS) $(ADDITIONAL_GO_LINKER_FLAGS)" ./cmd/micro
 
 build-dbg:
-	go build -ldflags "-s -w $(ADDITIONAL_GO_LINKER_FLAGS)" ./cmd/micro
+	go build -ldflags "-s -w $(ADDITIONAL_GO_LINKER_FLAGS) $(DEBUGVAR)" ./cmd/micro
 
 build-tags: fetch-tags
 	go build -ldflags "-s -w $(GOVARS) $(ADDITIONAL_GO_LINKER_FLAGS)" ./cmd/micro
@@ -44,14 +46,42 @@ fetch-tags:
 # Builds the runtime
 runtime:
 	git submodule update --init
+	rm -f runtime/syntax/*.hdr
 	go run runtime/syntax/make_headers.go runtime/syntax
 	go build -o tools/bindata ./tools/go-bindata
 	tools/bindata -pkg config -nomemcopy -nometadata -o runtime.go runtime/...
 	mv runtime.go internal/config
 	gofmt -w internal/config/runtime.go
 
+testgen:
+	mkdir -p tools/vscode-tests
+	cd tools/vscode-tests && \
+	curl --remote-name-all $(VSCODE_TESTS_BASE_URL){editableTextModelAuto,editableTextModel,model.line}.test.ts
+	tsc tools/vscode-tests/*.ts > /dev/null; true
+	go run tools/testgen.go tools/vscode-tests/*.js > buffer_generated_test.go
+	mv buffer_generated_test.go internal/buffer
+	gofmt -w internal/buffer/buffer_generated_test.go
+
 test:
 	go test ./internal/...
+	go test ./cmd/...
+
+bench:
+	for i in 1 2 3; do \
+		go test -bench=. ./internal/...; \
+	done > benchmark_results
+	benchstat benchmark_results
+
+bench-baseline:
+	for i in 1 2 3; do \
+		go test -bench=. ./internal/...; \
+	done > benchmark_results_baseline
+
+bench-compare:
+	for i in 1 2 3; do \
+		go test -bench=. ./internal/...; \
+	done > benchmark_results
+	benchstat -alpha 0.15 benchmark_results_baseline benchmark_results
 
 clean:
 	rm -f micro

README.md

@@ -44,7 +44,7 @@ You can also check out the website for Micro at https://micro-editor.github.io.
 - Easy to use and install.
 - No dependencies or external files are needed — just the binary you can download further down the page.
 - Multiple cursors.
-- Common keybindings (<kbd>Ctrl+S</kbd>, <kbd>Ctrl+C</kbd>, <kbd>Ctrl+V</kbd>, <kbd>Ctrl+Z</kbd>, …).
+- Common keybindings (<kbd>Ctrl-s</kbd>, <kbd>Ctrl-c</kbd>, <kbd>Ctrl-v</kbd>, <kbd>Ctrl-z</kbd>, …).
   - Keybindings can be rebound to your liking.
 - Sane defaults.
   - You shouldn't have to configure much out of the box (and it is extremely easy to configure).
@@ -53,13 +53,13 @@ You can also check out the website for Micro at https://micro-editor.github.io.
 - Extremely good mouse support.
   - This means mouse dragging to create a selection, double click to select by word, and triple click to select by line.
 - Cross-platform (it should work on all the platforms Go runs on).
-  - Note that while Windows is supported Mingw/Cygwin is not (see below)
+  - Note that while Windows is supported Mingw/Cygwin is not (see below).
 - Plugin system (plugins are written in Lua).
   - micro has a built-in plugin manager to automatically install, remove, and update plugins.
-- Built-in diff gutter
-- Simple autocompletion
+- Built-in diff gutter.
+- Simple autocompletion.
 - Persistent undo.
-- Automatic linting and error notifications
+- Automatic linting and error notifications.
 - Syntax highlighting for over [130 languages](runtime/syntax).
 - Color scheme support.
   - By default, micro comes with 16, 256, and true color themes.
@@ -76,28 +76,30 @@ To install micro, you can download a [prebuilt binary](https://github.com/zyedid
 
 If you want more information about ways to install micro, see this [wiki page](https://github.com/zyedidia/micro/wiki/Installing-Micro).
 
+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!
 
 Download the binary from the [releases](https://github.com/zyedidia/micro/releases) page.
 
-On that page you'll see the nightly release, which contains binaries for micro which are built every night,
-and you'll see all the stable releases with the corresponding binaries.
-
-Running `micro -version` will give you the version information.
-
 ### Installation script
 
 There is a script which can install micro for you by downloading the latest prebuilt binary. You can find it at <https://getmic.ro>.
 
-Then you can easily install micro:
+You can easily install micro by running
 
 ```bash
 curl https://getmic.ro | bash
 ```
 
-The script will install the micro binary to 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
 
@@ -107,27 +109,35 @@ You can install micro using Homebrew on Mac:
 brew install micro
 ```
 
+**Note for Mac:** All micro keybindings use the control or alt (option) key, not the command
+key. By default, macOS terminals do not forward alt key events. To fix this, please see
+the section on [macOS terminals](https://github.com/zyedidia/micro#macos-terminal) further below.
+
 On Linux, you can install micro through [snap](https://snapcraft.io/docs/core/install)
 
 ```
 snap install micro --classic
 ```
 
-On Debian `unstable | testing | buster-backports` and Ubuntu `focal` (20.04), micro is available
-via `apt`:
+**Note for Linux:** for interfacing with the local system clipboard, `xclip` or `xsel`
+must be installed. Please see the section on [Linux clipboard support](https://github.com/zyedidia/micro#linux-clipboard-support)
+further below.
 
-```
-sudo apt install micro
-```
+Micro is also available through other package managers on Linux such as apt, dnf, AUR, Nix, and package managers
+for other operating systems. These packages are not guaranteed to be up-to-date.
 
-Micro is also available through other package managers on Linux such as AUR, Nix, and package managers
-for other operating systems:
-
-* Windows: [Chocolatey](https://chocolatey.org) and [Scoop](https://github.com/lukesampson/scoop)
-    * `choco install micro`
-    * `scoop install micro`
-* OpenBSD: Available in the ports tree and also available as a binary package
-    * `pkd_add -v micro`
+* Linux: Available in distro-specific package managers.
+    * `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.
+* Windows: [Chocolatey](https://chocolatey.org) and [Scoop](https://github.com/lukesampson/scoop).
+    * `choco install micro`.
+    * `scoop install micro`.
+* OpenBSD: Available in the ports tree and also available as a binary package.
+    * `pkd_add -v micro`.
+* NetBSD, macOS, Linux, Illumos, etc. with [pkgsrc](http://www.pkgsrc.org/)-current:
+    * `pkg_add micro`
 
 ### Building from source
 
@@ -163,7 +173,7 @@ CGO_ENABLED=0 make build
 
 ### macOS terminal
 
-If you are using macOS, you should consider using [iTerm2](http://iterm2.com/) instead of the default terminal (Terminal.app). The iTerm2 terminal has much better mouse support as well as better handling of key events. For best keybinding behavior, choose `xterm defaults` under `Preferences->Profiles->Keys->Load Preset`. The newest versions also support true color.
+If you are using macOS, you should consider using [iTerm2](http://iterm2.com/) instead of the default terminal (Terminal.app). The iTerm2 terminal has much better mouse support as well as better handling of key events. For best keybinding behavior, choose `xterm defaults` under `Preferences->Profiles->Keys->Presets...`, and select `Esc+` for `Left Option Key` in the same menu. The newest versions also support true color.
 
 If you still insist on using the default Mac terminal, be sure to set `Use Option key as Meta key` under
 `Preferences->Profiles->Keyboard` to use <kbd>option</kbd> as <kbd>alt</kbd>.
@@ -181,7 +191,7 @@ If you don't have these commands, micro will use an internal clipboard for copy
 
 If you open micro and it doesn't seem like syntax highlighting is working, this is probably because
 you are using a terminal which does not support 256 color mode. Try changing the color scheme to `simple`
-by pressing <kbd>Ctrl+E</kbd> in micro and typing `set colorscheme simple`.
+by pressing <kbd>Ctrl-e</kbd> in micro and typing `set colorscheme simple`.
 
 If you are using the default Ubuntu terminal, to enable 256 make sure your `TERM` variable is set
 to `xterm-256color`.
@@ -222,7 +232,7 @@ click to enable line selection.
 
 ## Documentation and Help
 
-micro has a built-in help system which you can access by pressing <kbd>Ctrl+E</kbd> and typing `help`. Additionally, you can
+micro has a built-in help system which you can access by pressing <kbd>Ctrl-e</kbd> and typing `help`. Additionally, you can
 view the help files here:
 
 - [main help](https://github.com/zyedidia/micro/tree/master/runtime/help/help.md)
@@ -243,3 +253,5 @@ You can use the [GitHub issue tracker](https://github.com/zyedidia/micro/issues)
 to report bugs, ask questions, or suggest new features.
 
 For a more informal setting to discuss the editor, you can join the [Gitter chat](https://gitter.im/zyedidia/micro).
+
+Sometimes I am unresponsive, and I apologize! If that happens, please ping me.

cmd/micro/clean.go

@@ -10,8 +10,8 @@ import (
 	"sort"
 	"strings"
 
-	"github.com/zyedidia/micro/internal/buffer"
-	"github.com/zyedidia/micro/internal/config"
+	"github.com/zyedidia/micro/v2/internal/buffer"
+	"github.com/zyedidia/micro/v2/internal/config"
 )
 
 func shouldContinue() bool {
@@ -41,6 +41,9 @@ func CleanConfig() {
 		return
 	}
 
+	fmt.Println("Cleaning default settings")
+	config.WriteSettings(filepath.Join(config.ConfigDir, "settings.json"))
+
 	// detect unused options
 	var unusedOptions []string
 	defaultSettings := config.DefaultAllSettings()
@@ -111,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/debug.go

@@ -4,7 +4,7 @@ import (
 	"log"
 	"os"
 
-	"github.com/zyedidia/micro/internal/util"
+	"github.com/zyedidia/micro/v2/internal/util"
 )
 
 // NullWriter simply sends writes into the void

cmd/micro/initlua.go

@@ -6,14 +6,14 @@ import (
 	lua "github.com/yuin/gopher-lua"
 	luar "layeh.com/gopher-luar"
 
-	"github.com/zyedidia/micro/internal/action"
-	"github.com/zyedidia/micro/internal/buffer"
-	"github.com/zyedidia/micro/internal/config"
-	"github.com/zyedidia/micro/internal/display"
-	ulua "github.com/zyedidia/micro/internal/lua"
-	"github.com/zyedidia/micro/internal/screen"
-	"github.com/zyedidia/micro/internal/shell"
-	"github.com/zyedidia/micro/internal/util"
+	"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/display"
+	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"
 )
 
 func init() {
@@ -53,6 +53,9 @@ func luaImportMicro() *lua.LTable {
 	ulua.L.SetField(pkg, "CurTab", luar.New(ulua.L, func() *action.Tab {
 		return action.MainTab()
 	}))
+	ulua.L.SetField(pkg, "Tabs", luar.New(ulua.L, func() *action.TabList {
+		return action.Tabs
+	}))
 
 	return pkg
 }
@@ -83,6 +86,7 @@ func luaImportMicroConfig() *lua.LTable {
 	ulua.L.SetField(pkg, "GetGlobalOption", luar.New(ulua.L, config.GetGlobalOption))
 	ulua.L.SetField(pkg, "SetGlobalOption", luar.New(ulua.L, action.SetGlobalOption))
 	ulua.L.SetField(pkg, "SetGlobalOptionNative", luar.New(ulua.L, action.SetGlobalOptionNative))
+	ulua.L.SetField(pkg, "ConfigDir", luar.New(ulua.L, config.ConfigDir))
 
 	return pkg
 }
@@ -141,6 +145,7 @@ func luaImportMicroUtil() *lua.LTable {
 	ulua.L.SetField(pkg, "GetLeadingWhitespace", luar.New(ulua.L, util.LuaGetLeadingWhitespace))
 	ulua.L.SetField(pkg, "IsWordChar", luar.New(ulua.L, util.LuaIsWordChar))
 	ulua.L.SetField(pkg, "String", luar.New(ulua.L, util.String))
+	ulua.L.SetField(pkg, "CharacterCountInString", luar.New(ulua.L, util.CharacterCountInString))
 	ulua.L.SetField(pkg, "RuneStr", luar.New(ulua.L, func(r rune) string {
 		return string(r)
 	}))

cmd/micro/micro.go

@@ -5,19 +5,21 @@ import (
 	"fmt"
 	"io/ioutil"
 	"os"
+	"regexp"
 	"runtime"
 	"sort"
+	"strconv"
 	"time"
 
 	"github.com/go-errors/errors"
 	isatty "github.com/mattn/go-isatty"
 	lua "github.com/yuin/gopher-lua"
-	"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"
+	"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/micro/v2/internal/shell"
+	"github.com/zyedidia/micro/v2/internal/util"
 	"github.com/zyedidia/tcell"
 )
 
@@ -43,7 +45,8 @@ func InitFlags() {
 		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("-options")
 		fmt.Println("    \tShow all option help")
@@ -129,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
@@ -144,14 +147,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
@@ -168,17 +204,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")
@@ -201,7 +242,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 {
@@ -217,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 {
@@ -225,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())
@@ -246,7 +295,8 @@ func main() {
 		screen.TermMessage(err)
 	}
 
-	b := LoadInput()
+	args := flag.Args()
+	b := LoadInput(args)
 
 	if len(b) == 0 {
 		// No buffers to open
@@ -335,6 +385,9 @@ func DoEvent() {
 	case <-shell.CloseTerms:
 	case event = <-events:
 	case <-screen.DrawChan():
+		for len(screen.DrawChan()) > 0 {
+			<-screen.DrawChan()
+		}
 	}
 
 	if action.InfoBar.HasPrompt {

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

@@ -1,4 +1,4 @@
-module github.com/zyedidia/micro
+module github.com/zyedidia/micro/v2
 
 require (
 	github.com/blang/semver v3.5.1+incompatible
@@ -8,19 +8,25 @@ require (
 	github.com/mattn/go-isatty v0.0.11
 	github.com/mattn/go-runewidth v0.0.7
 	github.com/mitchellh/go-homedir v1.1.0
+	github.com/robertkrimen/otto v0.0.0-20191219234010-c382bd3c16ff
 	github.com/sergi/go-diff v1.1.0
 	github.com/stretchr/testify v1.4.0
 	github.com/yuin/gopher-lua v0.0.0-20191220021717-ab39c6098bdb
-	github.com/zyedidia/clipboard v0.0.0-20190823154308-241f98e9b197
+	github.com/zyedidia/clipboard v0.0.0-20200421031010-7c45b8673834
 	github.com/zyedidia/glob v0.0.0-20170209203856-dd4023a66dc3
 	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.4
+	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
 	gopkg.in/yaml.v2 v2.2.7
 	layeh.com/gopher-luar v1.0.7
 )
 
+replace github.com/kballard/go-shellquote => github.com/zyedidia/go-shellquote v0.0.0-20200613203517-eccd813c0655
+
+replace github.com/mattn/go-runewidth => github.com/p-e-w/go-runewidth v0.0.10-0.20200613030200-3e1705c5c059
+
 go 1.11

go.sum

@@ -12,8 +12,6 @@ github.com/gdamore/encoding v1.0.0 h1:+7OoQ1Bc6eTm5niUzBa0Ctsh6JbMW6Ra+YNuAtDBdk
 github.com/gdamore/encoding v1.0.0/go.mod h1:alR0ol34c49FCSBLjhosxzcPHQbf2trDkoo5dl+VrEg=
 github.com/go-errors/errors v1.0.1 h1:LUHzmkK3GUKUrL/1gfBUxAHzcev3apQlezX/+O7ma6w=
 github.com/go-errors/errors v1.0.1/go.mod h1:f4zRHt4oKfwPJE5k8C9vpYG+aDHdBFUsgrm6/TyX73Q=
-github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 h1:Z9n2FFNUXsshfwJMBgNA0RU6/i7WVaAegv3PtuIHPMs=
-github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51/go.mod h1:CzGEWj7cYgsdH8dAjBGEr58BoE7ScuLd+fwFZ44+/x8=
 github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
@@ -23,12 +21,14 @@ github.com/lucasb-eyer/go-colorful v1.0.3 h1:QIbQXiugsb+q10B+MI+7DI1oQLdmnep86tW
 github.com/lucasb-eyer/go-colorful v1.0.3/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
 github.com/mattn/go-isatty v0.0.11 h1:FxPOTFNqGkuDUGi3H/qkUbQO4ZiBa2brKq5r0l8TGeM=
 github.com/mattn/go-isatty v0.0.11/go.mod h1:PhnuNfih5lzO57/f3n+odYbM4JtupLOxQOAqxQCu2WE=
-github.com/mattn/go-runewidth v0.0.7 h1:Ei8KR0497xHyKJPAv59M1dkC+rOZCMBJ+t3fZ+twI54=
-github.com/mattn/go-runewidth v0.0.7/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
 github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y=
 github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
+github.com/p-e-w/go-runewidth v0.0.10-0.20200613030200-3e1705c5c059 h1:/+h2b6i15wh4EWsFkfdNdBE1jjGA872tpXEyhPM5aYg=
+github.com/p-e-w/go-runewidth v0.0.10-0.20200613030200-3e1705c5c059/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/robertkrimen/otto v0.0.0-20191219234010-c382bd3c16ff h1:+6NUiITWwE5q1KO6SAfUX918c+Tab0+tGAM/mtdlUyA=
+github.com/robertkrimen/otto v0.0.0-20191219234010-c382bd3c16ff/go.mod h1:xvqspoSXJTIpemEonrMDFq6XzwHYYgToXWj5eRX1OtY=
 github.com/sergi/go-diff v1.1.0 h1:we8PVUC3FE2uYfodKH/nBHMSetSfHDR6scGdBi+erh0=
 github.com/sergi/go-diff v1.1.0/go.mod h1:STckp+ISIX8hZLjrqAeVduY0gWCT9IjLuqbuNXdaHfM=
 github.com/stretchr/objx v0.1.0 h1:4G4v2dO3VZwixGIRoQ5Lfboy6nUhCyYzaqnIAPPhYs4=
@@ -38,10 +38,12 @@ github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81P
 github.com/yuin/gopher-lua v0.0.0-20190206043414-8bfc7677f583/go.mod h1:gqRgreBUhTSL0GeU64rtZ3Uq3wtjOa/TB2YfrtkCbVQ=
 github.com/yuin/gopher-lua v0.0.0-20191220021717-ab39c6098bdb h1:ZkM6LRnq40pR1Ox0hTHlnpkcOTuFIDQpZ1IN8rKKhX0=
 github.com/yuin/gopher-lua v0.0.0-20191220021717-ab39c6098bdb/go.mod h1:gqRgreBUhTSL0GeU64rtZ3Uq3wtjOa/TB2YfrtkCbVQ=
-github.com/zyedidia/clipboard v0.0.0-20190823154308-241f98e9b197 h1:gYTNnAW6azuB3BbA6QYWO/H4F2ABSOjjw3Z03tlXd2c=
-github.com/zyedidia/clipboard v0.0.0-20190823154308-241f98e9b197/go.mod h1:WDk3p8GiZV9+xFWlSo8qreeoLhW6Ik692rqXk+cNeRY=
+github.com/zyedidia/clipboard v0.0.0-20200421031010-7c45b8673834 h1:0nOfq3JwYRiY3+nwfWVQYEaXDmGCQgj3RKoqTifLzP4=
+github.com/zyedidia/clipboard v0.0.0-20200421031010-7c45b8673834/go.mod h1:zykFnZUXX0ErxqvYLUFEq7QDJKId8rmh2FgD0/Y8cjA=
 github.com/zyedidia/glob v0.0.0-20170209203856-dd4023a66dc3 h1:oMHjjTLfGXVuyOQBYj5/td9WC0mw4g1xDBPovIqmHew=
 github.com/zyedidia/glob v0.0.0-20170209203856-dd4023a66dc3/go.mod h1:YKbIYP//Eln8eDgAJGI3IDvR3s4Tv9Z9TGIOumiyQ5c=
+github.com/zyedidia/go-shellquote v0.0.0-20200613203517-eccd813c0655 h1:Z3RhH6hvcSx7eX6Q/pP6YVsgea/1eMDG99vtWwi3nK4=
+github.com/zyedidia/go-shellquote v0.0.0-20200613203517-eccd813c0655/go.mod h1:1sTqqO+kcYzZp43M5VsJe1tns9IzlSeC9jB6c2+o/5Y=
 github.com/zyedidia/highlight v0.0.0-20170330143449-201131ce5cf5 h1:Zs6mpwXvlqpF9zHl5XaN0p5V4J9XvP+WBuiuXyIgqvc=
 github.com/zyedidia/highlight v0.0.0-20170330143449-201131ce5cf5/go.mod h1:c1r+Ob9tUTPB0FKWO1+x+Hsc/zNa45WdGq7Y38Ybip0=
 github.com/zyedidia/json5 v0.0.0-20200102012142-2da050b1a98d h1:zmDMkh22zXOB7gz8jFaI4GpI7llsPgzm38/jG0UgxjE=
@@ -50,10 +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.3 h1:s0nmxj22Jj+vyt4nVmnB6kbnwRxEay1zfS0j8IsbtfI=
-github.com/zyedidia/tcell v1.4.3/go.mod h1:HhlbMSCcGX15rFDB+Q1Lk3pKEOocsCUAQC3zhZ9sadA=
-github.com/zyedidia/tcell v1.4.4 h1:o34LXujNuSueuyTy+5eoQW+rQr8g0UbY8k1NczZyskQ=
-github.com/zyedidia/tcell v1.4.4/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=
@@ -67,6 +67,8 @@ golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGm
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/sourcemap.v1 v1.0.5 h1:inv58fC9f9J3TK2Y2R1NPntXEn3/wjWHkonhIUODNTI=
+gopkg.in/sourcemap.v1 v1.0.5/go.mod h1:2RlvNNSMglmRrcvhfuzp4hQHwOtjxlbjX7UPY/GXb78=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.7 h1:VUgggvou5XRW9mHwD/yXxIYSMtY0zoKQf/v226p2nyo=

internal/action/actions.go

@@ -5,15 +5,14 @@ import (
 	"runtime"
 	"strings"
 	"time"
-	"unicode/utf8"
 
 	shellquote "github.com/kballard/go-shellquote"
 	"github.com/zyedidia/clipboard"
-	"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"
+	"github.com/zyedidia/micro/v2/internal/buffer"
+	"github.com/zyedidia/micro/v2/internal/config"
+	"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"
 )
 
@@ -175,7 +174,7 @@ func (h *BufPane) CursorRight() bool {
 		if tabstospaces && tabmovement {
 			tabsize := int(h.Buf.Settings["tabsize"].(float64))
 			line := h.Buf.LineBytes(h.Cursor.Y)
-			if h.Cursor.X+tabsize < utf8.RuneCount(line) && util.IsSpaces(line[h.Cursor.X:h.Cursor.X+tabsize]) && util.IsBytesWhitespace(line[0:h.Cursor.X]) {
+			if h.Cursor.X+tabsize < util.CharacterCount(line) && util.IsSpaces(line[h.Cursor.X:h.Cursor.X+tabsize]) && util.IsBytesWhitespace(line[0:h.Cursor.X]) {
 				for i := 0; i < tabsize; i++ {
 					h.Cursor.Right()
 				}
@@ -291,6 +290,19 @@ func (h *BufPane) StartOfText() bool {
 	return true
 }
 
+// StartOfTextToggle toggles the cursor between the start of the text of the line
+// and the start of the line
+func (h *BufPane) StartOfTextToggle() bool {
+	h.Cursor.Deselect(true)
+	if h.Cursor.IsStartOfText() {
+		h.Cursor.Start()
+	} else {
+		h.Cursor.StartOfText()
+	}
+	h.Relocate()
+	return true
+}
+
 // StartOfLine moves the cursor to the start of the line
 func (h *BufPane) StartOfLine() bool {
 	h.Cursor.Deselect(true)
@@ -325,6 +337,22 @@ func (h *BufPane) SelectToStartOfText() bool {
 	return true
 }
 
+// SelectToStartOfTextToggle toggles the selection between the start of the text
+// on the current line and the start of the line
+func (h *BufPane) SelectToStartOfTextToggle() bool {
+	if !h.Cursor.HasSelection() {
+		h.Cursor.OrigSelection[0] = h.Cursor.Loc
+	}
+	if h.Cursor.IsStartOfText() {
+		h.Cursor.Start()
+	} else {
+		h.Cursor.StartOfText()
+	}
+	h.Cursor.SelectTo(h.Cursor.Loc)
+	h.Relocate()
+	return true
+}
+
 // SelectToStartOfLine selects to the start of the current line
 func (h *BufPane) SelectToStartOfLine() bool {
 	if !h.Cursor.HasSelection() {
@@ -457,7 +485,7 @@ func (h *BufPane) InsertNewline() bool {
 		// Remove the whitespaces if keepautoindent setting is off
 		if util.IsSpacesOrTabs(h.Buf.LineBytes(h.Cursor.Y-1)) && !h.Buf.Settings["keepautoindent"].(bool) {
 			line := h.Buf.LineBytes(h.Cursor.Y - 1)
-			h.Buf.Remove(buffer.Loc{X: 0, Y: h.Cursor.Y - 1}, buffer.Loc{X: utf8.RuneCount(line), Y: h.Cursor.Y - 1})
+			h.Buf.Remove(buffer.Loc{X: 0, Y: h.Cursor.Y - 1}, buffer.Loc{X: util.CharacterCount(line), Y: h.Cursor.Y - 1})
 		}
 	}
 	h.Cursor.LastVisualX = h.Cursor.GetVisualX()
@@ -482,7 +510,7 @@ func (h *BufPane) Backspace() bool {
 		// tab (tabSize number of spaces)
 		lineStart := util.SliceStart(h.Buf.LineBytes(h.Cursor.Y), h.Cursor.X)
 		tabSize := int(h.Buf.Settings["tabsize"].(float64))
-		if h.Buf.Settings["tabstospaces"].(bool) && util.IsSpaces(lineStart) && len(lineStart) != 0 && utf8.RuneCount(lineStart)%tabSize == 0 {
+		if h.Buf.Settings["tabstospaces"].(bool) && util.IsSpaces(lineStart) && len(lineStart) != 0 && util.CharacterCount(lineStart)%tabSize == 0 {
 			loc := h.Cursor.Loc
 			h.Buf.Remove(loc.Move(-tabSize, h.Buf), loc)
 		} else {
@@ -635,7 +663,12 @@ func (h *BufPane) Autocomplete() bool {
 		return false
 	}
 
-	if !util.IsNonAlphaNumeric(h.Cursor.RuneUnder(h.Cursor.X)) {
+	if h.Cursor.X == 0 {
+		return false
+	}
+	r := h.Cursor.RuneUnder(h.Cursor.X)
+	prev := h.Cursor.RuneUnder(h.Cursor.X - 1)
+	if !util.IsAutocomplete(prev) || !util.IsNonAlphaNumeric(r) {
 		// don't autocomplete if cursor is on alpha numeric character (middle of a word)
 		return false
 	}
@@ -699,6 +732,7 @@ func (h *BufPane) Save() bool {
 }
 
 // SaveAsCB performs a save as and does a callback at the very end (after all prompts have been resolved)
+// The callback is only called if the save was successful
 func (h *BufPane) SaveAsCB(action string, callback func()) bool {
 	InfoBar.Prompt("Filename: ", "", "Save", nil, func(resp string, canceled bool) {
 		if !canceled {
@@ -729,6 +763,7 @@ func (h *BufPane) SaveAs() bool {
 
 // This function saves the buffer to `filename` and changes the buffer's path and name
 // to `filename` if the save is successful
+// The callback is only called if the save was successful
 func (h *BufPane) saveBufToFile(filename string, action string, callback func()) bool {
 	err := h.Buf.SaveAs(filename)
 	if err != nil {
@@ -741,6 +776,9 @@ func (h *BufPane) saveBufToFile(filename string, action string, callback func())
 					h.Buf.Path = filename
 					h.Buf.SetName(filename)
 					InfoBar.Message("Saved " + filename)
+					if callback != nil {
+						callback()
+					}
 				}
 			}
 			if h.Buf.Settings["autosu"].(bool) {
@@ -751,9 +789,6 @@ func (h *BufPane) saveBufToFile(filename string, action string, callback func())
 						saveWithSudo()
 						h.completeAction(action)
 					}
-					if callback != nil {
-						callback()
-					}
 				})
 				return false
 			}
@@ -764,19 +799,56 @@ func (h *BufPane) saveBufToFile(filename string, action string, callback func())
 		h.Buf.Path = filename
 		h.Buf.SetName(filename)
 		InfoBar.Message("Saved " + filename)
-	}
-	if callback != nil {
-		callback()
+		if callback != nil {
+			callback()
+		}
 	}
 	return true
 }
 
 // Find opens a prompt and searches forward for the input
 func (h *BufPane) Find() bool {
+	return h.find(true)
+}
+
+// FindLiteral is the same as Find() but does not support regular expressions
+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
-	InfoBar.Prompt("Find: ", "", "Find", func(resp string) {
+	prompt := "Find: "
+	if useRegex {
+		prompt = "Find (regex): "
+	}
+	InfoBar.Prompt(prompt, "", "Find", func(resp string) {
 		// Event callback
-		match, found, _ := h.Buf.FindNext(resp, h.Buf.Start(), h.Buf.End(), h.searchOrig, true, true)
+		match, found, _ := h.Buf.FindNext(resp, h.Buf.Start(), h.Buf.End(), h.searchOrig, true, useRegex)
 		if found {
 			h.Cursor.SetSelectionStart(match[0])
 			h.Cursor.SetSelectionEnd(match[1])
@@ -791,7 +863,7 @@ func (h *BufPane) Find() bool {
 	}, func(resp string, canceled bool) {
 		// Finished callback
 		if !canceled {
-			match, found, err := h.Buf.FindNext(resp, h.Buf.Start(), h.Buf.End(), h.searchOrig, true, true)
+			match, found, err := h.Buf.FindNext(resp, h.Buf.Start(), h.Buf.End(), h.searchOrig, true, useRegex)
 			if err != nil {
 				InfoBar.Error(err)
 			}
@@ -802,6 +874,7 @@ func (h *BufPane) Find() bool {
 				h.Cursor.OrigSelection[1] = h.Cursor.CurSelection[1]
 				h.Cursor.GotoLoc(h.Cursor.CurSelection[1])
 				h.lastSearch = resp
+				h.lastSearchRegex = useRegex
 			} else {
 				h.Cursor.ResetSelection()
 				InfoBar.Message("No matches found")
@@ -825,7 +898,7 @@ func (h *BufPane) FindNext() bool {
 	if h.Cursor.HasSelection() {
 		searchLoc = h.Cursor.CurSelection[1]
 	}
-	match, found, err := h.Buf.FindNext(h.lastSearch, h.Buf.Start(), h.Buf.End(), searchLoc, true, true)
+	match, found, err := h.Buf.FindNext(h.lastSearch, h.Buf.Start(), h.Buf.End(), searchLoc, true, h.lastSearchRegex)
 	if err != nil {
 		InfoBar.Error(err)
 	}
@@ -852,7 +925,7 @@ func (h *BufPane) FindPrevious() bool {
 	if h.Cursor.HasSelection() {
 		searchLoc = h.Cursor.CurSelection[0]
 	}
-	match, found, err := h.Buf.FindNext(h.lastSearch, h.Buf.Start(), h.Buf.End(), searchLoc, false, true)
+	match, found, err := h.Buf.FindNext(h.lastSearch, h.Buf.Start(), h.Buf.End(), searchLoc, false, h.lastSearchRegex)
 	if err != nil {
 		InfoBar.Error(err)
 	}
@@ -900,6 +973,25 @@ func (h *BufPane) Copy() bool {
 	return true
 }
 
+// Copy the current line to the clipboard
+func (h *BufPane) CopyLine() bool {
+	if h.Cursor.HasSelection() {
+		return false
+	} else {
+		h.Cursor.SelectLine()
+		h.Cursor.CopySelection("clipboard")
+		h.freshClip = true
+		if clipboard.Unsupported {
+			InfoBar.Message("Copied line (install xclip for external clipboard)")
+		} else {
+			InfoBar.Message("Copied line")
+		}
+	}
+	h.Cursor.Deselect(true)
+	h.Relocate()
+	return true
+}
+
 // CutLine cuts the current line to the clipboard
 func (h *BufPane) CutLine() bool {
 	h.Cursor.SelectLine()
@@ -979,15 +1071,26 @@ func (h *BufPane) MoveLinesUp() bool {
 		}
 		start := h.Cursor.CurSelection[0].Y
 		end := h.Cursor.CurSelection[1].Y
+		sel := 1
 		if start > end {
 			end, start = start, end
+			sel = 0
+		}
+
+		compensate := false
+		if h.Cursor.CurSelection[sel].X != 0 {
+			end++
+		} else {
+			compensate = true
 		}
 
 		h.Buf.MoveLinesUp(
 			start,
 			end,
 		)
-		h.Cursor.CurSelection[1].Y -= 1
+		if compensate {
+			h.Cursor.CurSelection[sel].Y -= 1
+		}
 	} else {
 		if h.Cursor.Loc.Y == 0 {
 			InfoBar.Message("Cannot move further up")
@@ -1012,8 +1115,14 @@ func (h *BufPane) MoveLinesDown() bool {
 		}
 		start := h.Cursor.CurSelection[0].Y
 		end := h.Cursor.CurSelection[1].Y
+		sel := 1
 		if start > end {
 			end, start = start, end
+			sel = 0
+		}
+
+		if h.Cursor.CurSelection[sel].X != 0 {
+			end++
 		}
 
 		h.Buf.MoveLinesDown(
@@ -1120,6 +1229,16 @@ func (h *BufPane) OpenFile() bool {
 	return true
 }
 
+// OpenFile opens a new file in the buffer
+func (h *BufPane) JumpLine() bool {
+	InfoBar.Prompt("> ", "goto ", "Command", nil, func(resp string, canceled bool) {
+		if !canceled {
+			h.HandleCommand(resp)
+		}
+	})
+	return true
+}
+
 // Start moves the viewport to the start of the buffer
 func (h *BufPane) Start() bool {
 	v := h.GetView()
@@ -1407,8 +1526,9 @@ func (h *BufPane) AddTab() bool {
 
 // PreviousTab switches to the previous tab in the tab list
 func (h *BufPane) PreviousTab() bool {
-	a := Tabs.Active()
-	Tabs.SetActive(util.Clamp(a-1, 0, len(Tabs.List)-1))
+	tabsLen := len(Tabs.List)
+	a := Tabs.Active() + tabsLen
+	Tabs.SetActive((a - 1) % tabsLen)
 
 	return true
 }
@@ -1416,7 +1536,8 @@ func (h *BufPane) PreviousTab() bool {
 // NextTab switches to the next tab in the tab list
 func (h *BufPane) NextTab() bool {
 	a := Tabs.Active()
-	Tabs.SetActive(util.Clamp(a+1, 0, len(Tabs.List)-1))
+	Tabs.SetActive((a + 1) % len(Tabs.List))
+
 	return true
 }
 

internal/action/actions_posix.go

@@ -5,7 +5,7 @@ package action
 import (
 	"syscall"
 
-	"github.com/zyedidia/micro/internal/screen"
+	"github.com/zyedidia/micro/v2/internal/screen"
 )
 
 // Suspend sends micro to the background. This is the same as pressing CtrlZ in most unix programs.

internal/action/bindings.go

@@ -10,8 +10,8 @@ import (
 	"unicode"
 
 	"github.com/zyedidia/json5"
-	"github.com/zyedidia/micro/internal/config"
-	"github.com/zyedidia/micro/internal/screen"
+	"github.com/zyedidia/micro/v2/internal/config"
+	"github.com/zyedidia/micro/v2/internal/screen"
 	"github.com/zyedidia/tcell"
 )
 
@@ -249,6 +249,7 @@ func UnbindKey(k string) error {
 		if a, ok := defaults[k]; ok {
 			BindKey(k, a)
 		} else if _, ok := config.Bindings[k]; ok {
+			BufUnmap(key)
 			delete(config.Bindings, k)
 		}
 

internal/action/bufpane.go

@@ -7,11 +7,11 @@ import (
 	luar "layeh.com/gopher-luar"
 
 	lua "github.com/yuin/gopher-lua"
-	"github.com/zyedidia/micro/internal/buffer"
-	"github.com/zyedidia/micro/internal/config"
-	"github.com/zyedidia/micro/internal/display"
-	ulua "github.com/zyedidia/micro/internal/lua"
-	"github.com/zyedidia/micro/internal/screen"
+	"github.com/zyedidia/micro/v2/internal/buffer"
+	"github.com/zyedidia/micro/v2/internal/config"
+	"github.com/zyedidia/micro/v2/internal/display"
+	ulua "github.com/zyedidia/micro/v2/internal/lua"
+	"github.com/zyedidia/micro/v2/internal/screen"
 	"github.com/zyedidia/tcell"
 )
 
@@ -103,7 +103,7 @@ func BufMapKey(k Event, action string) {
 			afn = f
 			names = append(names, a)
 		} else {
-			screen.TermMessage("Error:", a, "does not exist")
+			screen.TermMessage("Error in bindings: action", a, "does not exist")
 			continue
 		}
 		actionfns = append(actionfns, afn)
@@ -124,6 +124,8 @@ func BufMapKey(k Event, action string) {
 					break
 				}
 			}
+			// if the action changed the current pane, update the reference
+			h = MainTab().CurPane()
 		}
 		return true
 	}
@@ -139,6 +141,17 @@ func BufMapMouse(k MouseEvent, action string) {
 	}
 }
 
+// BufUnmap unmaps a key or mouse event from any action
+func BufUnmap(k Event) {
+	delete(BufKeyBindings, k)
+	delete(BufKeyStrings, k)
+
+	switch e := k.(type) {
+	case MouseEvent:
+		delete(BufMouseBindings, e)
+	}
+}
+
 // The BufPane connects the buffer and the window
 // It provides a cursor (or multiple) and defines a set of actions
 // that can be taken on the buffer
@@ -179,7 +192,8 @@ type BufPane struct {
 	tripleClick bool
 
 	// Last search stores the last successful search for FindNext and FindPrev
-	lastSearch string
+	lastSearch      string
+	lastSearchRegex bool
 	// Should the current multiple cursor selection search based on word or
 	// based on selection (false for selection, true for word)
 	multiWord bool
@@ -270,7 +284,11 @@ func (h *BufPane) SetID(i uint64) {
 }
 
 func (h *BufPane) Name() string {
-	return h.Buf.GetName()
+	n := h.Buf.GetName()
+	if h.Buf.Modified() {
+		n += " +"
+	}
+	return n
 }
 
 // HandleEvent executes the tcell event properly
@@ -314,7 +332,7 @@ func (h *BufPane) HandleEvent(event tcell.Event) {
 		switch e.Buttons() {
 		case tcell.Button1:
 			_, my := e.Position()
-			if h.Buf.Settings["statusline"].(bool) && my >= h.GetView().Y+h.GetView().Height-1 {
+			if h.Buf.Type.Kind != buffer.BTInfo.Kind && h.Buf.Settings["statusline"].(bool) && my >= h.GetView().Y+h.GetView().Height-1 {
 				cancel = true
 			}
 		case tcell.ButtonNone:
@@ -339,10 +357,11 @@ func (h *BufPane) HandleEvent(event tcell.Event) {
 				// release the mouse
 
 				// if !h.doubleClick && !h.tripleClick {
-				// 	h.Cursor.Loc = mouseLoc
 				// 	h.Cursor.SetSelectionEnd(h.Cursor.Loc)
-				// 	h.Cursor.CopySelection("primary")
 				// }
+				if h.Cursor.HasSelection() {
+					h.Cursor.CopySelection("primary")
+				}
 				h.mouseReleased = true
 			}
 		}
@@ -512,106 +531,111 @@ func (h *BufPane) SetActive(b bool) {
 
 // BufKeyActions contains the list of all possible key actions the bufhandler could execute
 var BufKeyActions = map[string]BufKeyAction{
-	"CursorUp":               (*BufPane).CursorUp,
-	"CursorDown":             (*BufPane).CursorDown,
-	"CursorPageUp":           (*BufPane).CursorPageUp,
-	"CursorPageDown":         (*BufPane).CursorPageDown,
-	"CursorLeft":             (*BufPane).CursorLeft,
-	"CursorRight":            (*BufPane).CursorRight,
-	"CursorStart":            (*BufPane).CursorStart,
-	"CursorEnd":              (*BufPane).CursorEnd,
-	"SelectToStart":          (*BufPane).SelectToStart,
-	"SelectToEnd":            (*BufPane).SelectToEnd,
-	"SelectUp":               (*BufPane).SelectUp,
-	"SelectDown":             (*BufPane).SelectDown,
-	"SelectLeft":             (*BufPane).SelectLeft,
-	"SelectRight":            (*BufPane).SelectRight,
-	"WordRight":              (*BufPane).WordRight,
-	"WordLeft":               (*BufPane).WordLeft,
-	"SelectWordRight":        (*BufPane).SelectWordRight,
-	"SelectWordLeft":         (*BufPane).SelectWordLeft,
-	"DeleteWordRight":        (*BufPane).DeleteWordRight,
-	"DeleteWordLeft":         (*BufPane).DeleteWordLeft,
-	"SelectLine":             (*BufPane).SelectLine,
-	"SelectToStartOfLine":    (*BufPane).SelectToStartOfLine,
-	"SelectToStartOfText":    (*BufPane).SelectToStartOfText,
-	"SelectToEndOfLine":      (*BufPane).SelectToEndOfLine,
-	"ParagraphPrevious":      (*BufPane).ParagraphPrevious,
-	"ParagraphNext":          (*BufPane).ParagraphNext,
-	"InsertNewline":          (*BufPane).InsertNewline,
-	"Backspace":              (*BufPane).Backspace,
-	"Delete":                 (*BufPane).Delete,
-	"InsertTab":              (*BufPane).InsertTab,
-	"Save":                   (*BufPane).Save,
-	"SaveAll":                (*BufPane).SaveAll,
-	"SaveAs":                 (*BufPane).SaveAs,
-	"Find":                   (*BufPane).Find,
-	"FindNext":               (*BufPane).FindNext,
-	"FindPrevious":           (*BufPane).FindPrevious,
-	"Center":                 (*BufPane).Center,
-	"Undo":                   (*BufPane).Undo,
-	"Redo":                   (*BufPane).Redo,
-	"Copy":                   (*BufPane).Copy,
-	"Cut":                    (*BufPane).Cut,
-	"CutLine":                (*BufPane).CutLine,
-	"DuplicateLine":          (*BufPane).DuplicateLine,
-	"DeleteLine":             (*BufPane).DeleteLine,
-	"MoveLinesUp":            (*BufPane).MoveLinesUp,
-	"MoveLinesDown":          (*BufPane).MoveLinesDown,
-	"IndentSelection":        (*BufPane).IndentSelection,
-	"OutdentSelection":       (*BufPane).OutdentSelection,
-	"Autocomplete":           (*BufPane).Autocomplete,
-	"CycleAutocompleteBack":  (*BufPane).CycleAutocompleteBack,
-	"OutdentLine":            (*BufPane).OutdentLine,
-	"IndentLine":             (*BufPane).IndentLine,
-	"Paste":                  (*BufPane).Paste,
-	"PastePrimary":           (*BufPane).PastePrimary,
-	"SelectAll":              (*BufPane).SelectAll,
-	"OpenFile":               (*BufPane).OpenFile,
-	"Start":                  (*BufPane).Start,
-	"End":                    (*BufPane).End,
-	"PageUp":                 (*BufPane).PageUp,
-	"PageDown":               (*BufPane).PageDown,
-	"SelectPageUp":           (*BufPane).SelectPageUp,
-	"SelectPageDown":         (*BufPane).SelectPageDown,
-	"HalfPageUp":             (*BufPane).HalfPageUp,
-	"HalfPageDown":           (*BufPane).HalfPageDown,
-	"StartOfText":            (*BufPane).StartOfText,
-	"StartOfLine":            (*BufPane).StartOfLine,
-	"EndOfLine":              (*BufPane).EndOfLine,
-	"ToggleHelp":             (*BufPane).ToggleHelp,
-	"ToggleKeyMenu":          (*BufPane).ToggleKeyMenu,
-	"ToggleDiffGutter":       (*BufPane).ToggleDiffGutter,
-	"ToggleRuler":            (*BufPane).ToggleRuler,
-	"ClearStatus":            (*BufPane).ClearStatus,
-	"ShellMode":              (*BufPane).ShellMode,
-	"CommandMode":            (*BufPane).CommandMode,
-	"ToggleOverwriteMode":    (*BufPane).ToggleOverwriteMode,
-	"Escape":                 (*BufPane).Escape,
-	"Quit":                   (*BufPane).Quit,
-	"QuitAll":                (*BufPane).QuitAll,
-	"AddTab":                 (*BufPane).AddTab,
-	"PreviousTab":            (*BufPane).PreviousTab,
-	"NextTab":                (*BufPane).NextTab,
-	"NextSplit":              (*BufPane).NextSplit,
-	"PreviousSplit":          (*BufPane).PreviousSplit,
-	"Unsplit":                (*BufPane).Unsplit,
-	"VSplit":                 (*BufPane).VSplitAction,
-	"HSplit":                 (*BufPane).HSplitAction,
-	"ToggleMacro":            (*BufPane).ToggleMacro,
-	"PlayMacro":              (*BufPane).PlayMacro,
-	"Suspend":                (*BufPane).Suspend,
-	"ScrollUp":               (*BufPane).ScrollUpAction,
-	"ScrollDown":             (*BufPane).ScrollDownAction,
-	"SpawnMultiCursor":       (*BufPane).SpawnMultiCursor,
-	"SpawnMultiCursorUp":     (*BufPane).SpawnMultiCursorUp,
-	"SpawnMultiCursorDown":   (*BufPane).SpawnMultiCursorDown,
-	"SpawnMultiCursorSelect": (*BufPane).SpawnMultiCursorSelect,
-	"RemoveMultiCursor":      (*BufPane).RemoveMultiCursor,
-	"RemoveAllMultiCursors":  (*BufPane).RemoveAllMultiCursors,
-	"SkipMultiCursor":        (*BufPane).SkipMultiCursor,
-	"JumpToMatchingBrace":    (*BufPane).JumpToMatchingBrace,
-	"None":                   (*BufPane).None,
+	"CursorUp":                  (*BufPane).CursorUp,
+	"CursorDown":                (*BufPane).CursorDown,
+	"CursorPageUp":              (*BufPane).CursorPageUp,
+	"CursorPageDown":            (*BufPane).CursorPageDown,
+	"CursorLeft":                (*BufPane).CursorLeft,
+	"CursorRight":               (*BufPane).CursorRight,
+	"CursorStart":               (*BufPane).CursorStart,
+	"CursorEnd":                 (*BufPane).CursorEnd,
+	"SelectToStart":             (*BufPane).SelectToStart,
+	"SelectToEnd":               (*BufPane).SelectToEnd,
+	"SelectUp":                  (*BufPane).SelectUp,
+	"SelectDown":                (*BufPane).SelectDown,
+	"SelectLeft":                (*BufPane).SelectLeft,
+	"SelectRight":               (*BufPane).SelectRight,
+	"WordRight":                 (*BufPane).WordRight,
+	"WordLeft":                  (*BufPane).WordLeft,
+	"SelectWordRight":           (*BufPane).SelectWordRight,
+	"SelectWordLeft":            (*BufPane).SelectWordLeft,
+	"DeleteWordRight":           (*BufPane).DeleteWordRight,
+	"DeleteWordLeft":            (*BufPane).DeleteWordLeft,
+	"SelectLine":                (*BufPane).SelectLine,
+	"SelectToStartOfLine":       (*BufPane).SelectToStartOfLine,
+	"SelectToStartOfText":       (*BufPane).SelectToStartOfText,
+	"SelectToStartOfTextToggle": (*BufPane).SelectToStartOfTextToggle,
+	"SelectToEndOfLine":         (*BufPane).SelectToEndOfLine,
+	"ParagraphPrevious":         (*BufPane).ParagraphPrevious,
+	"ParagraphNext":             (*BufPane).ParagraphNext,
+	"InsertNewline":             (*BufPane).InsertNewline,
+	"Backspace":                 (*BufPane).Backspace,
+	"Delete":                    (*BufPane).Delete,
+	"InsertTab":                 (*BufPane).InsertTab,
+	"Save":                      (*BufPane).Save,
+	"SaveAll":                   (*BufPane).SaveAll,
+	"SaveAs":                    (*BufPane).SaveAs,
+	"Find":                      (*BufPane).Find,
+	"FindLiteral":               (*BufPane).FindLiteral,
+	"FindNext":                  (*BufPane).FindNext,
+	"FindPrevious":              (*BufPane).FindPrevious,
+	"Center":                    (*BufPane).Center,
+	"Undo":                      (*BufPane).Undo,
+	"Redo":                      (*BufPane).Redo,
+	"Copy":                      (*BufPane).Copy,
+	"CopyLine":                  (*BufPane).CopyLine,
+	"Cut":                       (*BufPane).Cut,
+	"CutLine":                   (*BufPane).CutLine,
+	"DuplicateLine":             (*BufPane).DuplicateLine,
+	"DeleteLine":                (*BufPane).DeleteLine,
+	"MoveLinesUp":               (*BufPane).MoveLinesUp,
+	"MoveLinesDown":             (*BufPane).MoveLinesDown,
+	"IndentSelection":           (*BufPane).IndentSelection,
+	"OutdentSelection":          (*BufPane).OutdentSelection,
+	"Autocomplete":              (*BufPane).Autocomplete,
+	"CycleAutocompleteBack":     (*BufPane).CycleAutocompleteBack,
+	"OutdentLine":               (*BufPane).OutdentLine,
+	"IndentLine":                (*BufPane).IndentLine,
+	"Paste":                     (*BufPane).Paste,
+	"PastePrimary":              (*BufPane).PastePrimary,
+	"SelectAll":                 (*BufPane).SelectAll,
+	"OpenFile":                  (*BufPane).OpenFile,
+	"Start":                     (*BufPane).Start,
+	"End":                       (*BufPane).End,
+	"PageUp":                    (*BufPane).PageUp,
+	"PageDown":                  (*BufPane).PageDown,
+	"SelectPageUp":              (*BufPane).SelectPageUp,
+	"SelectPageDown":            (*BufPane).SelectPageDown,
+	"HalfPageUp":                (*BufPane).HalfPageUp,
+	"HalfPageDown":              (*BufPane).HalfPageDown,
+	"StartOfText":               (*BufPane).StartOfText,
+	"StartOfTextToggle":         (*BufPane).StartOfTextToggle,
+	"StartOfLine":               (*BufPane).StartOfLine,
+	"EndOfLine":                 (*BufPane).EndOfLine,
+	"ToggleHelp":                (*BufPane).ToggleHelp,
+	"ToggleKeyMenu":             (*BufPane).ToggleKeyMenu,
+	"ToggleDiffGutter":          (*BufPane).ToggleDiffGutter,
+	"ToggleRuler":               (*BufPane).ToggleRuler,
+	"ClearStatus":               (*BufPane).ClearStatus,
+	"ShellMode":                 (*BufPane).ShellMode,
+	"CommandMode":               (*BufPane).CommandMode,
+	"ToggleOverwriteMode":       (*BufPane).ToggleOverwriteMode,
+	"Escape":                    (*BufPane).Escape,
+	"Quit":                      (*BufPane).Quit,
+	"QuitAll":                   (*BufPane).QuitAll,
+	"AddTab":                    (*BufPane).AddTab,
+	"PreviousTab":               (*BufPane).PreviousTab,
+	"NextTab":                   (*BufPane).NextTab,
+	"NextSplit":                 (*BufPane).NextSplit,
+	"PreviousSplit":             (*BufPane).PreviousSplit,
+	"Unsplit":                   (*BufPane).Unsplit,
+	"VSplit":                    (*BufPane).VSplitAction,
+	"HSplit":                    (*BufPane).HSplitAction,
+	"ToggleMacro":               (*BufPane).ToggleMacro,
+	"PlayMacro":                 (*BufPane).PlayMacro,
+	"Suspend":                   (*BufPane).Suspend,
+	"ScrollUp":                  (*BufPane).ScrollUpAction,
+	"ScrollDown":                (*BufPane).ScrollDownAction,
+	"SpawnMultiCursor":          (*BufPane).SpawnMultiCursor,
+	"SpawnMultiCursorUp":        (*BufPane).SpawnMultiCursorUp,
+	"SpawnMultiCursorDown":      (*BufPane).SpawnMultiCursorDown,
+	"SpawnMultiCursorSelect":    (*BufPane).SpawnMultiCursorSelect,
+	"RemoveMultiCursor":         (*BufPane).RemoveMultiCursor,
+	"RemoveAllMultiCursors":     (*BufPane).RemoveAllMultiCursors,
+	"SkipMultiCursor":           (*BufPane).SkipMultiCursor,
+	"JumpToMatchingBrace":       (*BufPane).JumpToMatchingBrace,
+	"JumpLine":                  (*BufPane).JumpLine,
+	"None":                      (*BufPane).None,
 
 	// This was changed to InsertNewline but I don't want to break backwards compatibility
 	"InsertEnter": (*BufPane).InsertNewline,
@@ -628,54 +652,57 @@ var BufMouseActions = map[string]BufMouseAction{
 // Generally actions that modify global editor state like quitting or
 // saving should not be included in this list
 var MultiActions = map[string]bool{
-	"CursorUp":            true,
-	"CursorDown":          true,
-	"CursorPageUp":        true,
-	"CursorPageDown":      true,
-	"CursorLeft":          true,
-	"CursorRight":         true,
-	"CursorStart":         true,
-	"CursorEnd":           true,
-	"SelectToStart":       true,
-	"SelectToEnd":         true,
-	"SelectUp":            true,
-	"SelectDown":          true,
-	"SelectLeft":          true,
-	"SelectRight":         true,
-	"WordRight":           true,
-	"WordLeft":            true,
-	"SelectWordRight":     true,
-	"SelectWordLeft":      true,
-	"DeleteWordRight":     true,
-	"DeleteWordLeft":      true,
-	"SelectLine":          true,
-	"SelectToStartOfLine": true,
-	"SelectToStartOfText": true,
-	"SelectToEndOfLine":   true,
-	"ParagraphPrevious":   true,
-	"ParagraphNext":       true,
-	"InsertNewline":       true,
-	"Backspace":           true,
-	"Delete":              true,
-	"InsertTab":           true,
-	"FindNext":            true,
-	"FindPrevious":        true,
-	"Cut":                 true,
-	"CutLine":             true,
-	"DuplicateLine":       true,
-	"DeleteLine":          true,
-	"MoveLinesUp":         true,
-	"MoveLinesDown":       true,
-	"IndentSelection":     true,
-	"OutdentSelection":    true,
-	"OutdentLine":         true,
-	"IndentLine":          true,
-	"Paste":               true,
-	"PastePrimary":        true,
-	"SelectPageUp":        true,
-	"SelectPageDown":      true,
-	"StartOfLine":         true,
-	"StartOfText":         true,
-	"EndOfLine":           true,
-	"JumpToMatchingBrace": true,
+	"CursorUp":                  true,
+	"CursorDown":                true,
+	"CursorPageUp":              true,
+	"CursorPageDown":            true,
+	"CursorLeft":                true,
+	"CursorRight":               true,
+	"CursorStart":               true,
+	"CursorEnd":                 true,
+	"SelectToStart":             true,
+	"SelectToEnd":               true,
+	"SelectUp":                  true,
+	"SelectDown":                true,
+	"SelectLeft":                true,
+	"SelectRight":               true,
+	"WordRight":                 true,
+	"WordLeft":                  true,
+	"SelectWordRight":           true,
+	"SelectWordLeft":            true,
+	"DeleteWordRight":           true,
+	"DeleteWordLeft":            true,
+	"SelectLine":                true,
+	"SelectToStartOfLine":       true,
+	"SelectToStartOfText":       true,
+	"SelectToStartOfTextToggle": true,
+	"SelectToEndOfLine":         true,
+	"ParagraphPrevious":         true,
+	"ParagraphNext":             true,
+	"InsertNewline":             true,
+	"Backspace":                 true,
+	"Delete":                    true,
+	"InsertTab":                 true,
+	"FindNext":                  true,
+	"FindPrevious":              true,
+	"CopyLine":                  true,
+	"Cut":                       true,
+	"CutLine":                   true,
+	"DuplicateLine":             true,
+	"DeleteLine":                true,
+	"MoveLinesUp":               true,
+	"MoveLinesDown":             true,
+	"IndentSelection":           true,
+	"OutdentSelection":          true,
+	"OutdentLine":               true,
+	"IndentLine":                true,
+	"Paste":                     true,
+	"PastePrimary":              true,
+	"SelectPageUp":              true,
+	"SelectPageDown":            true,
+	"StartOfLine":               true,
+	"StartOfText":               true,
+	"StartOfTextToggle":         true,
+	"EndOfLine":                 true,
+	"JumpToMatchingBrace":       true,
 }

internal/action/command.go

@@ -10,14 +10,13 @@ import (
 	"regexp"
 	"strconv"
 	"strings"
-	"unicode/utf8"
 
 	shellquote "github.com/kballard/go-shellquote"
-	"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"
+	"github.com/zyedidia/micro/v2/internal/buffer"
+	"github.com/zyedidia/micro/v2/internal/config"
+	"github.com/zyedidia/micro/v2/internal/screen"
+	"github.com/zyedidia/micro/v2/internal/shell"
+	"github.com/zyedidia/micro/v2/internal/util"
 )
 
 // A Command contains information about how to execute a command
@@ -56,6 +55,7 @@ func InitCommands() {
 		"cd":         {(*BufPane).CdCmd, buffer.FileComplete},
 		"pwd":        {(*BufPane).PwdCmd, nil},
 		"open":       {(*BufPane).OpenCmd, buffer.FileComplete},
+		"tabmove":    {(*BufPane).TabMoveCmd, nil},
 		"tabswitch":  {(*BufPane).TabSwitchCmd, nil},
 		"term":       {(*BufPane).TermCmd, nil},
 		"memusage":   {(*BufPane).MemUsageCmd, nil},
@@ -155,6 +155,56 @@ func (h *BufPane) TextFilterCmd(args []string) {
 	h.Buf.Insert(h.Cursor.Loc, bout.String())
 }
 
+// TabMoveCmd moves the current tab to a given index (starts at 1). The
+// displaced tabs are moved up.
+func (h *BufPane) TabMoveCmd(args []string) {
+	if len(args) <= 0 {
+		InfoBar.Error("Not enough arguments: provide an index, starting at 1")
+		return
+	}
+
+	if len(args[0]) <= 0 {
+		InfoBar.Error("Invalid argument: empty string")
+		return
+	}
+
+	num, err := strconv.Atoi(args[0])
+	if err != nil {
+		InfoBar.Error("Invalid argument: ", err)
+		return
+	}
+
+	// Preserve sign for relative move, if one exists
+	var shiftDirection byte
+	if strings.Contains("-+", string([]byte{args[0][0]})) {
+		shiftDirection = args[0][0]
+	}
+
+	// Relative positions -> absolute positions
+	idxFrom := Tabs.Active()
+	idxTo := 0
+	offset := util.Abs(num)
+	if shiftDirection == '-' {
+		idxTo = idxFrom - offset
+	} else if shiftDirection == '+' {
+		idxTo = idxFrom + offset
+	} else {
+		idxTo = offset - 1
+	}
+
+	// Restrain position to within the valid range
+	idxTo = util.Clamp(idxTo, 0, len(Tabs.List)-1)
+
+	activeTab := Tabs.List[idxFrom]
+	Tabs.RemoveTab(activeTab.ID())
+	Tabs.List = append(Tabs.List, nil)
+	copy(Tabs.List[idxTo+1:], Tabs.List[idxTo:])
+	Tabs.List[idxTo] = activeTab
+	Tabs.UpdateNames()
+	Tabs.SetActive(idxTo)
+	// InfoBar.Message(fmt.Sprintf("Moved tab from slot %d to %d", idxFrom+1, idxTo+1))
+}
+
 // TabSwitchCmd switches to a given tab either by name or by number
 func (h *BufPane) TabSwitchCmd(args []string) {
 	if len(args) > 0 {
@@ -289,7 +339,10 @@ func ReloadConfig() {
 	if err != nil {
 		screen.TermMessage(err)
 	}
-	config.InitGlobalSettings()
+	err = config.InitGlobalSettings()
+	if err != nil {
+		screen.TermMessage(err)
+	}
 	InitBindings()
 	InitCommands()
 
@@ -427,6 +480,7 @@ func SetGlobalOptionNative(option string, nativeValue interface{}) error {
 
 	if !local {
 		config.GlobalSettings[option] = nativeValue
+		config.ModifiedSettings[option] = true
 
 		if option == "colorscheme" {
 			// LoadSyntaxFiles()
@@ -651,8 +705,11 @@ func (h *BufPane) GotoCmd(args []string) {
 				InfoBar.Error(err)
 				return
 			}
+			if line < 0 {
+				line = h.Buf.LinesNum() + 1 + line
+			}
 			line = util.Clamp(line-1, 0, h.Buf.LinesNum()-1)
-			col = util.Clamp(col-1, 0, utf8.RuneCount(h.Buf.LineBytes(line)))
+			col = util.Clamp(col-1, 0, util.CharacterCount(h.Buf.LineBytes(line)))
 			h.Cursor.GotoLoc(buffer.Loc{col, line})
 		} else {
 			line, err := strconv.Atoi(args[0])
@@ -660,6 +717,9 @@ func (h *BufPane) GotoCmd(args []string) {
 				InfoBar.Error(err)
 				return
 			}
+			if line < 0 {
+				line = h.Buf.LinesNum() + 1 + line
+			}
 			line = util.Clamp(line-1, 0, h.Buf.LinesNum()-1)
 			h.Cursor.GotoLoc(buffer.Loc{0, line})
 		}
@@ -733,7 +793,8 @@ func (h *BufPane) ReplaceCmd(args []string) {
 	nreplaced := 0
 	start := h.Buf.Start()
 	end := h.Buf.End()
-	if h.Cursor.HasSelection() {
+	selection := h.Cursor.HasSelection()
+	if selection {
 		start = h.Cursor.CurSelection[0]
 		end = h.Cursor.CurSelection[1]
 	}
@@ -744,7 +805,7 @@ func (h *BufPane) ReplaceCmd(args []string) {
 			return l.GreaterEqual(start) && l.LessEqual(end)
 		}
 
-		searchLoc := start
+		searchLoc := h.Cursor.Loc
 		var doReplacement func()
 		doReplacement = func() {
 			locs, found, err := h.Buf.FindNext(search, start, end, searchLoc, true, !noRegex)
@@ -755,11 +816,15 @@ func (h *BufPane) ReplaceCmd(args []string) {
 			if !found || !inRange(locs[0]) || !inRange(locs[1]) {
 				h.Cursor.ResetSelection()
 				h.Buf.RelocateCursors()
+
 				return
 			}
 
 			h.Cursor.SetSelectionStart(locs[0])
 			h.Cursor.SetSelectionEnd(locs[1])
+			h.Cursor.GotoLoc(locs[0])
+
+			h.Relocate()
 
 			InfoBar.YNPrompt("Perform replacement (y,n,esc)", func(yes, canceled bool) {
 				if !canceled && yes {
@@ -767,12 +832,14 @@ func (h *BufPane) ReplaceCmd(args []string) {
 
 					searchLoc = locs[0]
 					searchLoc.X += nrunes + locs[0].Diff(locs[1], h.Buf)
-					end.Move(nrunes, h.Buf)
+					if end.Y == locs[1].Y {
+						end = end.Move(nrunes, h.Buf)
+					}
 					h.Cursor.Loc = searchLoc
 					nreplaced++
 				} else if !canceled && !yes {
 					searchLoc = locs[0]
-					searchLoc.X += utf8.RuneCount(replace)
+					searchLoc.X += util.CharacterCount(replace)
 				} else if canceled {
 					h.Cursor.ResetSelection()
 					h.Buf.RelocateCursors()
@@ -785,14 +852,22 @@ func (h *BufPane) ReplaceCmd(args []string) {
 	}
 
 	h.Buf.RelocateCursors()
+	h.Relocate()
 
+	var s string
 	if nreplaced > 1 {
-		InfoBar.Message("Replaced ", nreplaced, " occurrences of ", search)
+		s = fmt.Sprintf("Replaced %d occurrences of %s", nreplaced, search)
 	} else if nreplaced == 1 {
-		InfoBar.Message("Replaced ", nreplaced, " occurrence of ", search)
+		s = fmt.Sprintf("Replaced 1 occurrence of %s", search)
 	} else {
-		InfoBar.Message("Nothing matched ", search)
+		s = fmt.Sprintf("Nothing matched %s", search)
 	}
+
+	if selection {
+		s += " in selection"
+	}
+
+	InfoBar.Message(s)
 }
 
 // ReplaceAllCmd replaces search term all at once
@@ -821,7 +896,11 @@ func (h *BufPane) TermCmd(args []string) {
 
 	term := func(i int, newtab bool) {
 		t := new(shell.Terminal)
-		t.Start(args, false, true, nil, nil)
+		err := t.Start(args, false, true, nil, nil)
+		if err != nil {
+			InfoBar.Error(err)
+			return
+		}
 
 		id := h.ID()
 		if newtab {

internal/action/defaults_darwin.go

@@ -17,10 +17,10 @@ func DefaultBindings() map[string]string {
 		"AltDown":        "MoveLinesDown",
 		"AltShiftRight":  "SelectWordRight",
 		"AltShiftLeft":   "SelectWordLeft",
-		"CtrlLeft":       "StartOfText",
+		"CtrlLeft":       "StartOfTextToggle",
 		"CtrlRight":      "EndOfLine",
-		"CtrlShiftLeft":  "SelectToStartOfText",
-		"ShiftHome":      "SelectToStartOfText",
+		"CtrlShiftLeft":  "SelectToStartOfTextToggle",
+		"ShiftHome":      "SelectToStartOfTextToggle",
 		"CtrlShiftRight": "SelectToEndOfLine",
 		"ShiftEnd":       "SelectToEndOfLine",
 		"CtrlUp":         "CursorStart",
@@ -32,27 +32,28 @@ func DefaultBindings() map[string]string {
 		"Enter":          "InsertNewline",
 		"CtrlH":          "Backspace",
 		"Backspace":      "Backspace",
+		"OldBackspace":   "Backspace",
 		"Alt-CtrlH":      "DeleteWordLeft",
 		"Alt-Backspace":  "DeleteWordLeft",
 		"Tab":            "Autocomplete|IndentSelection|InsertTab",
 		"Backtab":        "CycleAutocompleteBack|OutdentSelection|OutdentLine",
-		"CtrlO":          "OpenFile",
-		"CtrlS":          "Save",
-		"CtrlF":          "Find",
-		"CtrlN":          "FindNext",
-		"CtrlP":          "FindPrevious",
-		"CtrlZ":          "Undo",
-		"CtrlY":          "Redo",
-		"CtrlC":          "Copy",
-		"CtrlX":          "Cut",
-		"CtrlK":          "CutLine",
-		"CtrlD":          "DuplicateLine",
-		"CtrlV":          "Paste",
-		"CtrlA":          "SelectAll",
-		"CtrlT":          "AddTab",
-		"Alt,":           "PreviousTab",
-		"Alt.":           "NextTab",
-		"Home":           "StartOfText",
+		"Ctrl-o":         "OpenFile",
+		"Ctrl-s":         "Save",
+		"Ctrl-f":         "Find",
+		"Ctrl-n":         "FindNext",
+		"Ctrl-p":         "FindPrevious",
+		"Ctrl-z":         "Undo",
+		"Ctrl-y":         "Redo",
+		"Ctrl-c":         "CopyLine|Copy",
+		"Ctrl-x":         "Cut",
+		"Ctrl-k":         "CutLine",
+		"Ctrl-d":         "DuplicateLine",
+		"Ctrl-v":         "Paste",
+		"Ctrl-a":         "SelectAll",
+		"Ctrl-t":         "AddTab",
+		"Alt-,":          "PreviousTab",
+		"Alt-.":          "NextTab",
+		"Home":           "StartOfTextToggle",
 		"End":            "EndOfLine",
 		"CtrlHome":       "CursorStart",
 		"CtrlEnd":        "CursorEnd",
@@ -60,17 +61,17 @@ func DefaultBindings() map[string]string {
 		"PageDown":       "CursorPageDown",
 		"CtrlPageUp":     "PreviousTab",
 		"CtrlPageDown":   "NextTab",
-		"CtrlG":          "ToggleHelp",
+		"Ctrl-g":         "ToggleHelp",
 		"Alt-g":          "ToggleKeyMenu",
-		"CtrlR":          "ToggleRuler",
-		"CtrlL":          "command-edit:goto ",
+		"Ctrl-r":         "ToggleRuler",
+		"Ctrl-l":         "command-edit:goto ",
 		"Delete":         "Delete",
-		"CtrlB":          "ShellMode",
-		"CtrlQ":          "Quit",
-		"CtrlE":          "CommandMode",
-		"CtrlW":          "NextSplit",
-		"CtrlU":          "ToggleMacro",
-		"CtrlJ":          "PlayMacro",
+		"Ctrl-b":         "ShellMode",
+		"Ctrl-q":         "Quit",
+		"Ctrl-e":         "CommandMode",
+		"Ctrl-w":         "NextSplit",
+		"Ctrl-u":         "ToggleMacro",
+		"Ctrl-j":         "PlayMacro",
 		"Insert":         "ToggleOverwriteMode",
 
 		// Emacs-style keybindings

internal/action/defaults_other.go

@@ -19,10 +19,10 @@ func DefaultBindings() map[string]string {
 		"AltDown":        "MoveLinesDown",
 		"CtrlShiftRight": "SelectWordRight",
 		"CtrlShiftLeft":  "SelectWordLeft",
-		"AltLeft":        "StartOfText",
+		"AltLeft":        "StartOfTextToggle",
 		"AltRight":       "EndOfLine",
-		"AltShiftLeft":   "SelectToStartOfText",
-		"ShiftHome":      "SelectToStartOfText",
+		"AltShiftLeft":   "SelectToStartOfTextToggle",
+		"ShiftHome":      "SelectToStartOfTextToggle",
 		"AltShiftRight":  "SelectToEndOfLine",
 		"ShiftEnd":       "SelectToEndOfLine",
 		"CtrlUp":         "CursorStart",
@@ -34,27 +34,28 @@ func DefaultBindings() map[string]string {
 		"Enter":          "InsertNewline",
 		"CtrlH":          "Backspace",
 		"Backspace":      "Backspace",
+		"OldBackspace":   "Backspace",
 		"Alt-CtrlH":      "DeleteWordLeft",
 		"Alt-Backspace":  "DeleteWordLeft",
 		"Tab":            "Autocomplete|IndentSelection|InsertTab",
 		"Backtab":        "CycleAutocompleteBack|OutdentSelection|OutdentLine",
-		"CtrlO":          "OpenFile",
-		"CtrlS":          "Save",
-		"CtrlF":          "Find",
-		"CtrlN":          "FindNext",
-		"CtrlP":          "FindPrevious",
-		"CtrlZ":          "Undo",
-		"CtrlY":          "Redo",
-		"CtrlC":          "Copy",
-		"CtrlX":          "Cut",
-		"CtrlK":          "CutLine",
-		"CtrlD":          "DuplicateLine",
-		"CtrlV":          "Paste",
-		"CtrlA":          "SelectAll",
-		"CtrlT":          "AddTab",
-		"Alt,":           "PreviousTab",
-		"Alt.":           "NextTab",
-		"Home":           "StartOfText",
+		"Ctrl-o":         "OpenFile",
+		"Ctrl-s":         "Save",
+		"Ctrl-f":         "Find",
+		"Ctrl-n":         "FindNext",
+		"Ctrl-p":         "FindPrevious",
+		"Ctrl-z":         "Undo",
+		"Ctrl-y":         "Redo",
+		"Ctrl-c":         "CopyLine|Copy",
+		"Ctrl-x":         "Cut",
+		"Ctrl-k":         "CutLine",
+		"Ctrl-d":         "DuplicateLine",
+		"Ctrl-v":         "Paste",
+		"Ctrl-a":         "SelectAll",
+		"Ctrl-t":         "AddTab",
+		"Alt-,":          "PreviousTab",
+		"Alt-.":          "NextTab",
+		"Home":           "StartOfTextToggle",
 		"End":            "EndOfLine",
 		"CtrlHome":       "CursorStart",
 		"CtrlEnd":        "CursorEnd",
@@ -62,17 +63,17 @@ func DefaultBindings() map[string]string {
 		"PageDown":       "CursorPageDown",
 		"CtrlPageUp":     "PreviousTab",
 		"CtrlPageDown":   "NextTab",
-		"CtrlG":          "ToggleHelp",
+		"Ctrl-g":         "ToggleHelp",
 		"Alt-g":          "ToggleKeyMenu",
-		"CtrlR":          "ToggleRuler",
-		"CtrlL":          "command-edit:goto ",
+		"Ctrl-r":         "ToggleRuler",
+		"Ctrl-l":         "command-edit:goto ",
 		"Delete":         "Delete",
-		"CtrlB":          "ShellMode",
-		"CtrlQ":          "Quit",
-		"CtrlE":          "CommandMode",
-		"CtrlW":          "NextSplit",
-		"CtrlU":          "ToggleMacro",
-		"CtrlJ":          "PlayMacro",
+		"Ctrl-b":         "ShellMode",
+		"Ctrl-q":         "Quit",
+		"Ctrl-e":         "CommandMode",
+		"Ctrl-w":         "NextSplit",
+		"Ctrl-u":         "ToggleMacro",
+		"Ctrl-j":         "PlayMacro",
 		"Insert":         "ToggleOverwriteMode",
 
 		// Emacs-style keybindings

internal/action/globals.go

@@ -1,6 +1,6 @@
 package action
 
-import "github.com/zyedidia/micro/internal/buffer"
+import "github.com/zyedidia/micro/v2/internal/buffer"
 
 var InfoBar *InfoPane
 var LogBufPane *BufPane

internal/action/infocomplete.go

@@ -5,9 +5,9 @@ import (
 	"sort"
 	"strings"
 
-	"github.com/zyedidia/micro/internal/buffer"
-	"github.com/zyedidia/micro/internal/config"
-	"github.com/zyedidia/micro/internal/util"
+	"github.com/zyedidia/micro/v2/internal/buffer"
+	"github.com/zyedidia/micro/v2/internal/config"
+	"github.com/zyedidia/micro/v2/internal/util"
 )
 
 // This file is meant (for now) for autocompletion in command mode, not

internal/action/infopane.go

@@ -4,9 +4,10 @@ import (
 	"bytes"
 	"strings"
 
-	"github.com/zyedidia/micro/internal/display"
-	"github.com/zyedidia/micro/internal/info"
-	"github.com/zyedidia/micro/internal/util"
+	"github.com/zyedidia/micro/v2/internal/buffer"
+	"github.com/zyedidia/micro/v2/internal/display"
+	"github.com/zyedidia/micro/v2/internal/info"
+	"github.com/zyedidia/micro/v2/internal/util"
 	"github.com/zyedidia/tcell"
 )
 
@@ -186,14 +187,17 @@ func (h *InfoPane) Autocomplete() {
 	args := bytes.Split(l, []byte{' '})
 	cmd := string(args[0])
 
-	if len(args) == 1 {
-		b.Autocomplete(CommandComplete)
-	} else {
-		if action, ok := commands[cmd]; ok {
+	if h.PromptType == "Command" {
+		if len(args) == 1 {
+			b.Autocomplete(CommandComplete)
+		} else if action, ok := commands[cmd]; ok {
 			if action.completer != nil {
 				b.Autocomplete(action.completer)
 			}
 		}
+	} else {
+		// by default use filename autocompletion
+		b.Autocomplete(buffer.FileComplete)
 	}
 }
 

internal/action/pane.go

@@ -1,7 +1,7 @@
 package action
 
 import (
-	"github.com/zyedidia/micro/internal/display"
+	"github.com/zyedidia/micro/v2/internal/display"
 )
 
 type Pane interface {

internal/action/rawpane.go

@@ -4,8 +4,8 @@ import (
 	"fmt"
 	"reflect"
 
-	"github.com/zyedidia/micro/internal/buffer"
-	"github.com/zyedidia/micro/internal/display"
+	"github.com/zyedidia/micro/v2/internal/buffer"
+	"github.com/zyedidia/micro/v2/internal/display"
 	"github.com/zyedidia/tcell"
 )
 
@@ -35,6 +35,13 @@ func (h *RawPane) HandleEvent(event tcell.Event) {
 	}
 
 	h.Buf.Insert(h.Cursor.Loc, reflect.TypeOf(event).String()[7:])
+
+	switch e := event.(type) {
+	case *tcell.EventKey:
+		h.Buf.Insert(h.Cursor.Loc, fmt.Sprintf(": %s", e.Name()))
+	}
+
 	h.Buf.Insert(h.Cursor.Loc, fmt.Sprintf(": %q\n", event.EscSeq()))
+
 	h.Relocate()
 }

internal/action/tab.go

@@ -1,11 +1,11 @@
 package action
 
 import (
-	"github.com/zyedidia/micro/internal/buffer"
-	"github.com/zyedidia/micro/internal/config"
-	"github.com/zyedidia/micro/internal/display"
-	"github.com/zyedidia/micro/internal/screen"
-	"github.com/zyedidia/micro/internal/views"
+	"github.com/zyedidia/micro/v2/internal/buffer"
+	"github.com/zyedidia/micro/v2/internal/config"
+	"github.com/zyedidia/micro/v2/internal/display"
+	"github.com/zyedidia/micro/v2/internal/screen"
+	"github.com/zyedidia/micro/v2/internal/views"
 	"github.com/zyedidia/tcell"
 )
 
@@ -166,6 +166,8 @@ type Tab struct {
 	active int
 
 	resizing *views.Node // node currently being resized
+	// captures whether the mouse is released
+	release bool
 }
 
 // NewTabFromBuffer creates a new tab from the given buffer
@@ -203,6 +205,8 @@ func (t *Tab) HandleEvent(event tcell.Event) {
 		mx, my := e.Position()
 		switch e.Buttons() {
 		case tcell.Button1:
+			wasReleased := t.release
+			t.release = false
 			if t.resizing != nil {
 				var size int
 				if t.resizing.Kind == views.STVert {
@@ -215,22 +219,25 @@ func (t *Tab) HandleEvent(event tcell.Event) {
 				return
 			}
 
-			resizeID := t.GetMouseSplitID(buffer.Loc{mx, my})
-			if resizeID != 0 {
-				t.resizing = t.GetNode(uint64(resizeID))
-				return
-			}
+			if wasReleased {
+				resizeID := t.GetMouseSplitID(buffer.Loc{mx, my})
+				if resizeID != 0 {
+					t.resizing = t.GetNode(uint64(resizeID))
+					return
+				}
 
-			for i, p := range t.Panes {
-				v := p.GetView()
-				inpane := mx >= v.X && mx < v.X+v.Width && my >= v.Y && my < v.Y+v.Height
-				if inpane {
-					t.SetActive(i)
-					break
+				for i, p := range t.Panes {
+					v := p.GetView()
+					inpane := mx >= v.X && mx < v.X+v.Width && my >= v.Y && my < v.Y+v.Height
+					if inpane {
+						t.SetActive(i)
+						break
+					}
 				}
 			}
 		case tcell.ButtonNone:
 			t.resizing = nil
+			t.release = true
 		default:
 			for _, p := range t.Panes {
 				v := p.GetView()

internal/action/terminal_supported.go

@@ -4,7 +4,7 @@ package action
 
 import (
 	shellquote "github.com/kballard/go-shellquote"
-	"github.com/zyedidia/micro/internal/shell"
+	"github.com/zyedidia/micro/v2/internal/shell"
 )
 
 // TermEmuSupported is a constant that marks if the terminal emulator is supported

internal/action/termpane.go

@@ -5,9 +5,9 @@ import (
 	"runtime"
 
 	"github.com/zyedidia/clipboard"
-	"github.com/zyedidia/micro/internal/display"
-	"github.com/zyedidia/micro/internal/screen"
-	"github.com/zyedidia/micro/internal/shell"
+	"github.com/zyedidia/micro/v2/internal/display"
+	"github.com/zyedidia/micro/v2/internal/screen"
+	"github.com/zyedidia/micro/v2/internal/shell"
 	"github.com/zyedidia/tcell"
 	"github.com/zyedidia/terminal"
 )

internal/buffer/autocomplete.go

@@ -6,9 +6,8 @@ import (
 	"os"
 	"sort"
 	"strings"
-	"unicode/utf8"
 
-	"github.com/zyedidia/micro/internal/util"
+	"github.com/zyedidia/micro/v2/internal/util"
 )
 
 // A Completer is a function that takes a buffer and returns info
@@ -54,7 +53,7 @@ func (b *Buffer) CycleAutocomplete(forward bool) {
 	start := c.Loc
 	end := c.Loc
 	if prevSuggestion < len(b.Suggestions) && prevSuggestion >= 0 {
-		start = end.Move(-utf8.RuneCountInString(b.Completions[prevSuggestion]), b)
+		start = end.Move(-util.CharacterCountInString(b.Completions[prevSuggestion]), b)
 	} else {
 		// end = start.Move(1, b)
 	}
@@ -82,7 +81,7 @@ func GetWord(b *Buffer) ([]byte, int) {
 
 	args := bytes.FieldsFunc(l, util.IsNonAlphaNumeric)
 	input := args[len(args)-1]
-	return input, c.X - utf8.RuneCount(input)
+	return input, c.X - util.CharacterCount(input)
 }
 
 // GetArg gets the most recent word (separated by ' ' only)
@@ -98,7 +97,7 @@ func GetArg(b *Buffer) (string, int) {
 		if i == len(args)-1 {
 			break
 		}
-		argstart += utf8.RuneCount(a) + 1
+		argstart += util.CharacterCount(a) + 1
 	}
 
 	return input, argstart
@@ -162,7 +161,7 @@ func BufferComplete(b *Buffer) ([]string, []string) {
 		return []string{}, []string{}
 	}
 
-	inputLen := utf8.RuneCount(input)
+	inputLen := util.CharacterCount(input)
 
 	suggestionsSet := make(map[string]struct{})
 
@@ -171,7 +170,7 @@ func BufferComplete(b *Buffer) ([]string, []string) {
 		l := b.LineBytes(i)
 		words := bytes.FieldsFunc(l, util.IsNonAlphaNumeric)
 		for _, w := range words {
-			if bytes.HasPrefix(w, input) && utf8.RuneCount(w) > inputLen {
+			if bytes.HasPrefix(w, input) && util.CharacterCount(w) > inputLen {
 				strw := string(w)
 				if _, ok := suggestionsSet[strw]; !ok {
 					suggestionsSet[strw] = struct{}{}
@@ -184,7 +183,7 @@ func BufferComplete(b *Buffer) ([]string, []string) {
 		l := b.LineBytes(i)
 		words := bytes.FieldsFunc(l, util.IsNonAlphaNumeric)
 		for _, w := range words {
-			if bytes.HasPrefix(w, input) && utf8.RuneCount(w) > inputLen {
+			if bytes.HasPrefix(w, input) && util.CharacterCount(w) > inputLen {
 				strw := string(w)
 				if _, ok := suggestionsSet[strw]; !ok {
 					suggestionsSet[strw] = struct{}{}

internal/buffer/backup.go

@@ -7,9 +7,9 @@ import (
 	"path/filepath"
 	"time"
 
-	"github.com/zyedidia/micro/internal/config"
-	"github.com/zyedidia/micro/internal/screen"
-	"github.com/zyedidia/micro/internal/util"
+	"github.com/zyedidia/micro/v2/internal/config"
+	"github.com/zyedidia/micro/v2/internal/screen"
+	"github.com/zyedidia/micro/v2/internal/util"
 	"golang.org/x/text/encoding"
 )
 
@@ -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

@@ -5,25 +5,25 @@ import (
 	"bytes"
 	"crypto/md5"
 	"errors"
+	"fmt"
 	"io"
 	"io/ioutil"
-	"log"
 	"os"
+	"path"
 	"path/filepath"
 	"strconv"
 	"strings"
 	"sync"
 	"time"
-	"unicode/utf8"
 
 	luar "layeh.com/gopher-luar"
 
 	dmp "github.com/sergi/go-diff/diffmatchpatch"
-	"github.com/zyedidia/micro/internal/config"
-	ulua "github.com/zyedidia/micro/internal/lua"
-	"github.com/zyedidia/micro/internal/screen"
-	"github.com/zyedidia/micro/internal/util"
-	"github.com/zyedidia/micro/pkg/highlight"
+	"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/util"
+	"github.com/zyedidia/micro/v2/pkg/highlight"
 	"golang.org/x/text/encoding/htmlindex"
 	"golang.org/x/text/encoding/unicode"
 	"golang.org/x/text/transform"
@@ -60,6 +60,9 @@ var (
 	BTRaw = BufType{4, false, true, false}
 	// BTInfo is a buffer for inputting information
 	BTInfo = BufType{5, false, true, false}
+	// BTStdout is a buffer that only writes to stdout
+	// when closed
+	BTStdout = BufType{6, false, true, true}
 
 	// ErrFileTooLarge is returned when the file is too large to hash
 	// (fastdirty is automatically enabled)
@@ -75,6 +78,32 @@ type SharedBuffer struct {
 	// Type of the buffer (e.g. help, raw, scratch etc..)
 	Type BufType
 
+	// Path to the file on disk
+	Path string
+	// Absolute path to the file on disk
+	AbsPath string
+	// Name of the buffer on the status line
+	name string
+
+	toStdout bool
+
+	// Settings customized by the user
+	Settings map[string]interface{}
+
+	Suggestions   []string
+	Completions   []string
+	CurSuggestion int
+
+	Messages []*Message
+
+	updateDiffTimer   *time.Timer
+	diffBase          []byte
+	diffBaseLineCount int
+	diffLock          sync.RWMutex
+	diff              map[int]DiffStatus
+
+	requestedBackup bool
+
 	// ReloadDisabled allows the user to disable reloads if they
 	// are viewing a file that is constantly changing
 	ReloadDisabled bool
@@ -84,8 +113,13 @@ type SharedBuffer struct {
 	// it changes based on how the buffer has changed
 	HasSuggestions bool
 
-	// Modifications is the list of modified regions for syntax highlighting
-	Modifications []Loc
+	// The Highlighter struct actually performs the highlighting
+	Highlighter *highlight.Highlighter
+	// SyntaxDef represents the syntax highlighting definition being used
+	// This stores the highlighting rules and filetype detection info
+	SyntaxDef *highlight.Def
+
+	ModifiedThisFrame bool
 
 	// Hash of the original buffer -- empty if fastdirty is on
 	origHash [md5.Size]byte
@@ -96,17 +130,35 @@ func (b *SharedBuffer) insert(pos Loc, value []byte) {
 	b.HasSuggestions = false
 	b.LineArray.insert(pos, value)
 
-	// b.Modifications is cleared every screen redraw so it's
-	// ok to append duplicates
-	b.Modifications = append(b.Modifications, Loc{pos.Y, pos.Y + bytes.Count(value, []byte{'\n'})})
+	inslines := bytes.Count(value, []byte{'\n'})
+	b.MarkModified(pos.Y, pos.Y+inslines)
 }
 func (b *SharedBuffer) remove(start, end Loc) []byte {
 	b.isModified = true
 	b.HasSuggestions = false
-	b.Modifications = append(b.Modifications, Loc{start.Y, start.Y})
+	defer b.MarkModified(start.Y, end.Y)
 	return b.LineArray.remove(start, end)
 }
 
+// MarkModified marks the buffer as modified for this frame
+// and performs rehighlighting if syntax highlighting is enabled
+func (b *SharedBuffer) MarkModified(start, end int) {
+	b.ModifiedThisFrame = true
+
+	if !b.Settings["syntax"].(bool) || b.SyntaxDef == nil {
+		return
+	}
+
+	start = util.Clamp(start, 0, len(b.lines)-1)
+	end = util.Clamp(end, 0, len(b.lines)-1)
+
+	l := -1
+	for i := start; i <= end; i++ {
+		l = util.Max(b.Highlighter.ReHighlightStates(b, i), l)
+	}
+	b.Highlighter.HighlightMatches(b, start, l)
+}
+
 // DisableReload disables future reloads of this sharedbuffer
 func (b *SharedBuffer) DisableReload() {
 	b.ReloadDisabled = true
@@ -135,48 +187,24 @@ type Buffer struct {
 	cursors     []*Cursor
 	curCursor   int
 	StartCursor Loc
-
-	// Path to the file on disk
-	Path string
-	// Absolute path to the file on disk
-	AbsPath string
-	// Name of the buffer on the status line
-	name string
-
-	// SyntaxDef represents the syntax highlighting definition being used
-	// This stores the highlighting rules and filetype detection info
-	SyntaxDef *highlight.Def
-	// The Highlighter struct actually performs the highlighting
-	Highlighter   *highlight.Highlighter
-	HighlightLock sync.Mutex
-
-	// Settings customized by the user
-	Settings map[string]interface{}
-
-	Suggestions   []string
-	Completions   []string
-	CurSuggestion int
-
-	Messages []*Message
-
-	updateDiffTimer   *time.Timer
-	diffBase          []byte
-	diffBaseLineCount int
-	diffLock          sync.RWMutex
-	diff              map[int]DiffStatus
-
-	// counts the number of edits
-	// resets every backupTime edits
-	lastbackup time.Time
 }
 
-// NewBufferFromFile opens a new buffer using the given path
-// It will also automatically handle `~`, and line/column with filename:l:c
-// It will return an empty buffer if the path does not exist
-// and an error if the file is a directory
-func NewBufferFromFile(path string, btype BufType) (*Buffer, error) {
+// NewBufferFromFileAtLoc opens a new buffer with a given cursor location
+// If cursorLoc is {-1, -1} the location does not overwrite what the cursor location
+// would otherwise be (start of file, or saved cursor position if `savecursor` is
+// enabled)
+func NewBufferFromFileAtLoc(path string, btype BufType, cursorLoc Loc) (*Buffer, error) {
 	var err error
-	filename, cursorPos := util.GetPathAndCursorPosition(path)
+	filename := path
+	if config.GetGlobalOption("parsecursor").(bool) && cursorLoc.X == -1 && cursorLoc.Y == -1 {
+		var cursorPos []string
+		filename, cursorPos = util.GetPathAndCursorPosition(filename)
+		cursorLoc, err = ParseCursorLocation(cursorPos)
+		if err != nil {
+			cursorLoc = Loc{-1, -1}
+		}
+	}
+
 	filename, err = util.ReplaceHome(filename)
 	if err != nil {
 		return nil, err
@@ -191,11 +219,6 @@ func NewBufferFromFile(path string, btype BufType) (*Buffer, error) {
 
 	defer file.Close()
 
-	cursorLoc, cursorerr := ParseCursorLocation(cursorPos)
-	if cursorerr != nil {
-		cursorLoc = Loc{-1, -1}
-	}
-
 	var buf *Buffer
 	if err != nil {
 		// File does not exist -- create an empty buffer with that name
@@ -207,6 +230,19 @@ func NewBufferFromFile(path string, btype BufType) (*Buffer, error) {
 	return buf, nil
 }
 
+// NewBufferFromFile opens a new buffer using the given path
+// It will also automatically handle `~`, and line/column with filename:l:c
+// It will return an empty buffer if the path does not exist
+// and an error if the file is a directory
+func NewBufferFromFile(path string, btype BufType) (*Buffer, error) {
+	return NewBufferFromFileAtLoc(path, btype, Loc{-1, -1})
+}
+
+// NewBufferFromStringAtLoc creates a new buffer containing the given string with a cursor loc
+func NewBufferFromStringAtLoc(text, path string, btype BufType, cursorLoc Loc) *Buffer {
+	return NewBuffer(strings.NewReader(text), int64(len(text)), path, cursorLoc, btype)
+}
+
 // NewBufferFromString creates a new buffer containing the given string
 func NewBufferFromString(text, path string, btype BufType) *Buffer {
 	return NewBuffer(strings.NewReader(text), int64(len(text)), path, Loc{-1, -1}, btype)
@@ -222,23 +258,6 @@ func NewBuffer(r io.Reader, size int64, path string, startcursor Loc, btype BufT
 
 	b := new(Buffer)
 
-	b.Settings = config.DefaultCommonSettings()
-	for k, v := range config.GlobalSettings {
-		if _, ok := config.DefaultGlobalOnlySettings[k]; !ok {
-			// make sure setting is not global-only
-			b.Settings[k] = v
-		}
-	}
-	config.InitLocalSettings(b.Settings, path)
-
-	enc, err := htmlindex.Get(b.Settings["encoding"].(string))
-	if err != nil {
-		enc = unicode.UTF8
-		b.Settings["encoding"] = "utf-8"
-	}
-
-	reader := bufio.NewReader(transform.NewReader(r, enc.NewDecoder()))
-
 	found := false
 	if len(path) > 0 {
 		for _, buf := range OpenBuffers {
@@ -250,28 +269,59 @@ func NewBuffer(r io.Reader, size int64, path string, startcursor Loc, btype BufT
 		}
 	}
 
-	b.Path = path
-	b.AbsPath = absPath
-
+	hasBackup := false
 	if !found {
 		b.SharedBuffer = new(SharedBuffer)
 		b.Type = btype
 
-		hasBackup := b.ApplyBackup(size)
+		b.AbsPath = absPath
+		b.Path = path
+
+		b.Settings = config.DefaultCommonSettings()
+		for k, v := range config.GlobalSettings {
+			if _, ok := config.DefaultGlobalOnlySettings[k]; !ok {
+				// make sure setting is not global-only
+				b.Settings[k] = v
+			}
+		}
+		config.InitLocalSettings(b.Settings, path)
+
+		enc, err := htmlindex.Get(b.Settings["encoding"].(string))
+		if err != nil {
+			enc = unicode.UTF8
+			b.Settings["encoding"] = "utf-8"
+		}
+
+		hasBackup = b.ApplyBackup(size)
 
 		if !hasBackup {
-			b.LineArray = NewLineArray(uint64(size), FFAuto, reader)
+			reader := bufio.NewReader(transform.NewReader(r, enc.NewDecoder()))
+
+			var ff FileFormat = FFAuto
+
+			if size == 0 {
+				// for empty files, use the fileformat setting instead of
+				// autodetection
+				switch b.Settings["fileformat"] {
+				case "unix":
+					ff = FFUnix
+				case "dos":
+					ff = FFDos
+				}
+			}
+
+			b.LineArray = NewLineArray(uint64(size), ff, reader)
 		}
 		b.EventHandler = NewEventHandler(b.SharedBuffer, b.cursors)
+
+		// The last time this file was modified
+		b.UpdateModTime()
 	}
 
 	if b.Settings["readonly"].(bool) && b.Type == BTDefault {
 		b.Type.Readonly = true
 	}
 
-	// The last time this file was modified
-	b.UpdateModTime()
-
 	switch b.Endings {
 	case FFUnix:
 		b.Settings["fileformat"] = "unix"
@@ -280,6 +330,7 @@ func NewBuffer(r io.Reader, size int64, path string, startcursor Loc, btype BufT
 	}
 
 	b.UpdateRules()
+	// init local settings again now that we know the filetype
 	config.InitLocalSettings(b.Settings, b.Path)
 
 	if _, err := os.Stat(filepath.Join(config.ConfigDir, "buffers")); os.IsNotExist(err) {
@@ -300,22 +351,22 @@ func NewBuffer(r io.Reader, size int64, path string, startcursor Loc, btype BufT
 	b.AddCursor(NewCursor(b, b.StartCursor))
 	b.GetActiveCursor().Relocate()
 
-	if !b.Settings["fastdirty"].(bool) {
+	if !b.Settings["fastdirty"].(bool) && !found {
 		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)
 		}
 	}
 
-	err = config.RunPluginFn("onBufferOpen", luar.New(ulua.L, b))
+	err := config.RunPluginFn("onBufferOpen", luar.New(ulua.L, b))
 	if err != nil {
 		screen.TermMessage(err)
 	}
 
-	b.Modifications = make([]Loc, 0, 10)
-
 	OpenBuffers = append(OpenBuffers, b)
 
 	return b
@@ -341,18 +392,26 @@ func (b *Buffer) Fini() {
 		b.Serialize()
 	}
 	b.RemoveBackup()
+
+	if b.Type == BTStdout {
+		fmt.Fprint(util.Stdout, string(b.Bytes()))
+	}
 }
 
 // GetName returns the name that should be displayed in the statusline
 // for this buffer
 func (b *Buffer) GetName() string {
-	if b.name == "" {
+	name := b.name
+	if name == "" {
 		if b.Path == "" {
 			return "No name"
 		}
-		return b.Path
+		name = b.Path
 	}
-	return b.name
+	if b.Settings["basename"].(bool) {
+		return path.Base(name)
+	}
+	return name
 }
 
 //SetName changes the name for this buffer
@@ -367,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()
 	}
 }
 
@@ -378,20 +437,10 @@ func (b *Buffer) Remove(start, end Loc) {
 		b.EventHandler.active = b.curCursor
 		b.EventHandler.Remove(start, end)
 
-		go b.Backup(true)
+		b.RequestBackup()
 	}
 }
 
-// ClearModifications clears the list of modified lines in this buffer
-// The list of modified lines is used for syntax highlighting so that
-// we can selectively highlight only the necessary lines
-// This function should be called every time this buffer is drawn to
-// the screen
-func (b *Buffer) ClearModifications() {
-	// clear slice without resetting the cap
-	b.Modifications = b.Modifications[:0]
-}
-
 // FileType returns the buffer's filetype
 func (b *Buffer) FileType() string {
 	return b.Settings["filetype"].(string)
@@ -456,7 +505,7 @@ func (b *Buffer) RuneAt(loc Loc) rune {
 	if len(line) > 0 {
 		i := 0
 		for len(line) > 0 {
-			r, size := utf8.DecodeRune(line)
+			r, _, size := util.DecodeCharacter(line)
 			line = line[size:]
 			i++
 
@@ -485,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()
@@ -530,7 +595,37 @@ func (b *Buffer) UpdateRules() {
 		return
 	}
 	syntaxFile := ""
+	foundDef := false
 	var header *highlight.Header
+	// search for the syntax file in the user's custom syntax files
+	for _, f := range config.ListRealRuntimeFiles(config.RTSyntax) {
+		data, err := f.Data()
+		if err != nil {
+			screen.TermMessage("Error loading syntax file " + f.Name() + ": " + err.Error())
+			continue
+		}
+
+		header, err = highlight.MakeHeaderYaml(data)
+		file, err := highlight.ParseFile(data)
+		if err != nil {
+			screen.TermMessage("Error parsing syntax file " + f.Name() + ": " + err.Error())
+			continue
+		}
+
+		if ((ft == "unknown" || ft == "") && highlight.MatchFiletype(header.FtDetect, b.Path, b.lines[0].data)) || header.FileType == ft {
+			syndef, err := highlight.ParseDef(file, header)
+			if err != nil {
+				screen.TermMessage("Error parsing syntax file " + f.Name() + ": " + err.Error())
+				continue
+			}
+			b.SyntaxDef = syndef
+			syntaxFile = f.Name()
+			foundDef = true
+			break
+		}
+	}
+
+	// search in the default syntax files
 	for _, f := range config.ListRuntimeFiles(config.RTSyntaxHeader) {
 		data, err := f.Data()
 		if err != nil {
@@ -555,34 +650,8 @@ func (b *Buffer) UpdateRules() {
 		}
 	}
 
-	if syntaxFile == "" {
-		// search for the syntax file in the user's custom syntax files
-		for _, f := range config.ListRealRuntimeFiles(config.RTSyntax) {
-			log.Println("real runtime file", f.Name())
-			data, err := f.Data()
-			if err != nil {
-				screen.TermMessage("Error loading syntax file " + f.Name() + ": " + err.Error())
-				continue
-			}
-
-			header, err = highlight.MakeHeaderYaml(data)
-			file, err := highlight.ParseFile(data)
-			if err != nil {
-				screen.TermMessage("Error parsing syntax file " + f.Name() + ": " + err.Error())
-				continue
-			}
-
-			if ((ft == "unknown" || ft == "") && highlight.MatchFiletype(header.FtDetect, b.Path, b.lines[0].data)) || header.FileType == ft {
-				syndef, err := highlight.ParseDef(file, header)
-				if err != nil {
-					screen.TermMessage("Error parsing syntax file " + f.Name() + ": " + err.Error())
-					continue
-				}
-				b.SyntaxDef = syndef
-				break
-			}
-		}
-	} else {
+	if syntaxFile != "" && !foundDef {
+		// we found a syntax file using a syntax header file
 		for _, f := range config.ListRuntimeFiles(config.RTSyntax) {
 			if f.Name() == syntaxFile {
 				data, err := f.Data()
@@ -776,7 +845,6 @@ func (b *Buffer) ClearCursors() {
 	b.UpdateCursors()
 	b.curCursor = 0
 	b.GetActiveCursor().ResetSelection()
-	log.Println("Cleared cursors:", len(b.cursors))
 }
 
 // MoveLinesUp moves the range of lines up one row
@@ -786,19 +854,18 @@ func (b *Buffer) MoveLinesUp(start int, end int) {
 	}
 	l := string(b.LineBytes(start - 1))
 	if end == len(b.lines) {
-		b.Insert(
+		b.insert(
 			Loc{
-				utf8.RuneCount(b.lines[end-1].data),
+				util.CharacterCount(b.lines[end-1].data),
 				end - 1,
 			},
-			"\n"+l,
-		)
-	} else {
-		b.Insert(
-			Loc{0, end},
-			l+"\n",
+			[]byte{'\n'},
 		)
 	}
+	b.Insert(
+		Loc{0, end},
+		l+"\n",
+	)
 	b.Remove(
 		Loc{0, start - 1},
 		Loc{0, start},
@@ -807,7 +874,7 @@ func (b *Buffer) MoveLinesUp(start int, end int) {
 
 // MoveLinesDown moves the range of lines down one row
 func (b *Buffer) MoveLinesDown(start int, end int) {
-	if start < 0 || start >= end || end >= len(b.lines)-1 {
+	if start < 0 || start >= end || end >= len(b.lines) {
 		return
 	}
 	l := string(b.LineBytes(end))
@@ -922,7 +989,7 @@ func (b *Buffer) Retab() {
 
 		l = bytes.TrimLeft(l, " \t")
 		b.lines[i].data = append(ws, l...)
-		b.Modifications = append(b.Modifications, Loc{i, i})
+		b.MarkModified(i, i)
 		dirty = true
 	}
 

internal/buffer/buffer_test.go

@@ -0,0 +1,322 @@
+package buffer
+
+import (
+	"math/rand"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	lua "github.com/yuin/gopher-lua"
+	"github.com/zyedidia/micro/v2/internal/config"
+	ulua "github.com/zyedidia/micro/v2/internal/lua"
+	"github.com/zyedidia/micro/v2/internal/util"
+)
+
+type operation struct {
+	start Loc
+	end   Loc
+	text  []string
+}
+
+func init() {
+	ulua.L = lua.NewState()
+	config.InitGlobalSettings()
+	config.GlobalSettings["backup"] = false
+	config.GlobalSettings["fastdirty"] = true
+}
+
+func check(t *testing.T, before []string, operations []operation, after []string) {
+	assert := assert.New(t)
+
+	b := NewBufferFromString(strings.Join(before, "\n"), "", BTDefault)
+
+	assert.NotEqual("", b.GetName())
+	assert.Equal(false, b.ExternallyModified())
+	assert.Equal(false, b.Modified())
+	assert.Equal(1, b.NumCursors())
+
+	checkText := func(lines []string) {
+		assert.Equal([]byte(strings.Join(lines, "\n")), b.Bytes())
+		assert.Equal(len(lines), b.LinesNum())
+		for i, s := range lines {
+			assert.Equal(s, b.Line(i))
+			assert.Equal([]byte(s), b.LineBytes(i))
+		}
+	}
+
+	checkText(before)
+
+	var cursors []*Cursor
+
+	for _, op := range operations {
+		cursor := NewCursor(b, op.start)
+		cursor.SetSelectionStart(op.start)
+		cursor.SetSelectionEnd(op.end)
+		b.AddCursor(cursor)
+		cursors = append(cursors, cursor)
+	}
+
+	assert.Equal(1+len(operations), b.NumCursors())
+
+	for i, op := range operations {
+		cursor := cursors[i]
+		b.SetCurCursor(cursor.Num)
+		cursor.DeleteSelection()
+		b.Insert(cursor.Loc, strings.Join(op.text, "\n"))
+	}
+
+	checkText(after)
+
+	// must have exactly two events per operation (delete and insert)
+	for range operations {
+		b.UndoOneEvent()
+		b.UndoOneEvent()
+	}
+
+	checkText(before)
+
+	for i, op := range operations {
+		cursor := cursors[i]
+		if op.start == op.end {
+			assert.Equal(op.start, cursor.Loc)
+		} else {
+			assert.Equal(op.start, cursor.CurSelection[0])
+			assert.Equal(op.end, cursor.CurSelection[1])
+		}
+	}
+
+	for range operations {
+		b.RedoOneEvent()
+		b.RedoOneEvent()
+	}
+
+	checkText(after)
+
+	b.Close()
+}
+
+const maxLineLength = 200
+
+var alphabet = []rune(" abcdeäم📚")
+
+func randomString(length int) string {
+	runes := make([]rune, length)
+	for i := range runes {
+		runes[i] = alphabet[rand.Intn(len(alphabet))]
+	}
+	return string(runes)
+}
+
+func randomText(nLines int) string {
+	lines := make([]string, nLines)
+	for i := range lines {
+		lines[i] = randomString(rand.Intn(maxLineLength + 1))
+	}
+	return strings.Join(lines, "\n")
+}
+
+func benchCreateAndClose(testingB *testing.B, nLines int) {
+	rand.Seed(int64(nLines))
+
+	text := randomText(nLines)
+
+	testingB.ResetTimer()
+
+	for i := 0; i < testingB.N; i++ {
+		b := NewBufferFromString(text, "", BTDefault)
+		b.Close()
+	}
+}
+
+func benchRead(testingB *testing.B, nLines int) {
+	rand.Seed(int64(nLines))
+
+	b := NewBufferFromString(randomText(nLines), "", BTDefault)
+
+	testingB.ResetTimer()
+
+	for i := 0; i < testingB.N; i++ {
+		b.Bytes()
+		for j := 0; j < b.LinesNum(); j++ {
+			b.Line(j)
+			b.LineBytes(j)
+		}
+	}
+
+	testingB.StopTimer()
+
+	b.Close()
+}
+
+func benchEdit(testingB *testing.B, nLines, nCursors int) {
+	rand.Seed(int64(nLines + nCursors))
+
+	b := NewBufferFromString(randomText(nLines), "", BTDefault)
+
+	regionSize := nLines / nCursors
+
+	operations := make([]operation, nCursors)
+	for i := range operations {
+		startLine := (i * regionSize) + rand.Intn(regionSize-5)
+		startColumn := rand.Intn(util.CharacterCountInString(b.Line(startLine)) + 1)
+		endLine := startLine + 1 + rand.Intn(5)
+		endColumn := rand.Intn(util.CharacterCountInString(b.Line(endLine)) + 1)
+
+		operations[i] = operation{
+			start: Loc{startColumn, startLine},
+			end:   Loc{endColumn, endLine},
+			text:  []string{randomText(2 + rand.Intn(4))},
+		}
+	}
+
+	testingB.ResetTimer()
+
+	for i := 0; i < testingB.N; i++ {
+		b.SetCursors([]*Cursor{})
+
+		var cursors []*Cursor
+
+		for _, op := range operations {
+			cursor := NewCursor(b, op.start)
+			cursor.SetSelectionStart(op.start)
+			cursor.SetSelectionEnd(op.end)
+			b.AddCursor(cursor)
+			cursors = append(cursors, cursor)
+		}
+
+		for j, op := range operations {
+			cursor := cursors[j]
+			b.SetCurCursor(cursor.Num)
+			cursor.DeleteSelection()
+			b.Insert(cursor.Loc, op.text[0])
+		}
+
+		for b.UndoStack.Peek() != nil {
+			b.UndoOneEvent()
+		}
+	}
+
+	testingB.StopTimer()
+
+	b.Close()
+}
+
+func BenchmarkCreateAndClose10Lines(b *testing.B) {
+	benchCreateAndClose(b, 10)
+}
+
+func BenchmarkCreateAndClose100Lines(b *testing.B) {
+	benchCreateAndClose(b, 100)
+}
+
+func BenchmarkCreateAndClose1000Lines(b *testing.B) {
+	benchCreateAndClose(b, 1000)
+}
+
+func BenchmarkCreateAndClose10000Lines(b *testing.B) {
+	benchCreateAndClose(b, 10000)
+}
+
+func BenchmarkCreateAndClose100000Lines(b *testing.B) {
+	benchCreateAndClose(b, 100000)
+}
+
+func BenchmarkCreateAndClose1000000Lines(b *testing.B) {
+	benchCreateAndClose(b, 1000000)
+}
+
+func BenchmarkRead10Lines(b *testing.B) {
+	benchRead(b, 10)
+}
+
+func BenchmarkRead100Lines(b *testing.B) {
+	benchRead(b, 100)
+}
+
+func BenchmarkRead1000Lines(b *testing.B) {
+	benchRead(b, 1000)
+}
+
+func BenchmarkRead10000Lines(b *testing.B) {
+	benchRead(b, 10000)
+}
+
+func BenchmarkRead100000Lines(b *testing.B) {
+	benchRead(b, 100000)
+}
+
+func BenchmarkRead1000000Lines(b *testing.B) {
+	benchRead(b, 1000000)
+}
+
+func BenchmarkEdit10Lines1Cursor(b *testing.B) {
+	benchEdit(b, 10, 1)
+}
+
+func BenchmarkEdit100Lines1Cursor(b *testing.B) {
+	benchEdit(b, 100, 1)
+}
+
+func BenchmarkEdit100Lines10Cursors(b *testing.B) {
+	benchEdit(b, 100, 10)
+}
+
+func BenchmarkEdit1000Lines1Cursor(b *testing.B) {
+	benchEdit(b, 1000, 1)
+}
+
+func BenchmarkEdit1000Lines10Cursors(b *testing.B) {
+	benchEdit(b, 1000, 10)
+}
+
+func BenchmarkEdit1000Lines100Cursors(b *testing.B) {
+	benchEdit(b, 1000, 100)
+}
+
+func BenchmarkEdit10000Lines1Cursor(b *testing.B) {
+	benchEdit(b, 10000, 1)
+}
+
+func BenchmarkEdit10000Lines10Cursors(b *testing.B) {
+	benchEdit(b, 10000, 10)
+}
+
+func BenchmarkEdit10000Lines100Cursors(b *testing.B) {
+	benchEdit(b, 10000, 100)
+}
+
+func BenchmarkEdit10000Lines1000Cursors(b *testing.B) {
+	benchEdit(b, 10000, 1000)
+}
+
+func BenchmarkEdit100000Lines1Cursor(b *testing.B) {
+	benchEdit(b, 100000, 1)
+}
+
+func BenchmarkEdit100000Lines10Cursors(b *testing.B) {
+	benchEdit(b, 100000, 10)
+}
+
+func BenchmarkEdit100000Lines100Cursors(b *testing.B) {
+	benchEdit(b, 100000, 100)
+}
+
+func BenchmarkEdit100000Lines1000Cursors(b *testing.B) {
+	benchEdit(b, 100000, 1000)
+}
+
+func BenchmarkEdit1000000Lines1Cursor(b *testing.B) {
+	benchEdit(b, 1000000, 1)
+}
+
+func BenchmarkEdit1000000Lines10Cursors(b *testing.B) {
+	benchEdit(b, 1000000, 10)
+}
+
+func BenchmarkEdit1000000Lines100Cursors(b *testing.B) {
+	benchEdit(b, 1000000, 100)
+}
+
+func BenchmarkEdit1000000Lines1000Cursors(b *testing.B) {
+	benchEdit(b, 1000000, 1000)
+}

internal/buffer/cursor.go

@@ -1,15 +1,13 @@
 package buffer
 
 import (
-	"unicode/utf8"
-
 	"github.com/zyedidia/clipboard"
-	"github.com/zyedidia/micro/internal/util"
+	"github.com/zyedidia/micro/v2/internal/util"
 )
 
 // InBounds returns whether the given location is a valid character position in the given buffer
 func InBounds(pos Loc, buf *Buffer) bool {
-	if pos.Y < 0 || pos.Y >= len(buf.lines) || pos.X < 0 || pos.X > utf8.RuneCount(buf.LineBytes(pos.Y)) {
+	if pos.Y < 0 || pos.Y >= len(buf.lines) || pos.X < 0 || pos.X > util.CharacterCount(buf.LineBytes(pos.Y)) {
 		return false
 	}
 
@@ -76,9 +74,6 @@ func (c *Cursor) GetVisualX() int {
 
 	bytes := c.buf.LineBytes(c.Y)
 	tabsize := int(c.buf.Settings["tabsize"].(float64))
-	if c.X > utf8.RuneCount(bytes) {
-		c.X = utf8.RuneCount(bytes) - 1
-	}
 
 	return util.StringWidth(bytes, c.X, tabsize)
 }
@@ -102,16 +97,29 @@ func (c *Cursor) Start() {
 func (c *Cursor) StartOfText() {
 	c.Start()
 	for util.IsWhitespace(c.RuneUnder(c.X)) {
-		if c.X == utf8.RuneCount(c.buf.LineBytes(c.Y)) {
+		if c.X == util.CharacterCount(c.buf.LineBytes(c.Y)) {
 			break
 		}
 		c.Right()
 	}
 }
 
+// IsStartOfText returns whether the cursor is at the first
+// non-whitespace rune of the line it is on
+func (c *Cursor) IsStartOfText() bool {
+	x := 0
+	for util.IsWhitespace(c.RuneUnder(x)) {
+		if x == util.CharacterCount(c.buf.LineBytes(c.Y)) {
+			break
+		}
+		x++
+	}
+	return c.X == x
+}
+
 // End moves the cursor to the end of the line it is on
 func (c *Cursor) End() {
-	c.X = utf8.RuneCount(c.buf.LineBytes(c.Y))
+	c.X = util.CharacterCount(c.buf.LineBytes(c.Y))
 	c.LastVisualX = c.GetVisualX()
 }
 
@@ -229,8 +237,14 @@ func (c *Cursor) UpN(amount int) {
 	bytes := c.buf.LineBytes(proposedY)
 	c.X = c.GetCharPosInLine(bytes, c.LastVisualX)
 
-	if c.X > utf8.RuneCount(bytes) || (amount < 0 && proposedY == c.Y) {
-		c.X = utf8.RuneCount(bytes)
+	if c.X > util.CharacterCount(bytes) || (amount < 0 && proposedY == c.Y) {
+		c.X = util.CharacterCount(bytes)
+		c.StoreVisualX()
+	}
+
+	if c.X < 0 || (amount > 0 && proposedY == c.Y) {
+		c.X = 0
+		c.StoreVisualX()
 	}
 
 	c.Y = proposedY
@@ -272,7 +286,7 @@ func (c *Cursor) Right() {
 	if c.Loc == c.buf.End() {
 		return
 	}
-	if c.X < utf8.RuneCount(c.buf.LineBytes(c.Y)) {
+	if c.X < util.CharacterCount(c.buf.LineBytes(c.Y)) {
 		c.X++
 	} else {
 		c.Down()
@@ -293,8 +307,8 @@ func (c *Cursor) Relocate() {
 
 	if c.X < 0 {
 		c.X = 0
-	} else if c.X > utf8.RuneCount(c.buf.LineBytes(c.Y)) {
-		c.X = utf8.RuneCount(c.buf.LineBytes(c.Y))
+	} else if c.X > util.CharacterCount(c.buf.LineBytes(c.Y)) {
+		c.X = util.CharacterCount(c.buf.LineBytes(c.Y))
 	}
 }
 
@@ -320,7 +334,7 @@ func (c *Cursor) SelectWord() {
 	c.SetSelectionStart(Loc{backward, c.Y})
 	c.OrigSelection[0] = c.CurSelection[0]
 
-	lineLen := utf8.RuneCount(c.buf.LineBytes(c.Y)) - 1
+	lineLen := util.CharacterCount(c.buf.LineBytes(c.Y)) - 1
 	for forward < lineLen && util.IsWordChar(c.RuneUnder(forward+1)) {
 		forward++
 	}
@@ -352,7 +366,7 @@ func (c *Cursor) AddWordToSelection() {
 	if c.Loc.GreaterThan(c.OrigSelection[1]) {
 		forward := c.X
 
-		lineLen := utf8.RuneCount(c.buf.LineBytes(c.Y)) - 1
+		lineLen := util.CharacterCount(c.buf.LineBytes(c.Y)) - 1
 		for forward < lineLen && util.IsWordChar(c.RuneUnder(forward+1)) {
 			forward++
 		}
@@ -379,7 +393,7 @@ func (c *Cursor) SelectTo(loc Loc) {
 // WordRight moves the cursor one word to the right
 func (c *Cursor) WordRight() {
 	for util.IsWhitespace(c.RuneUnder(c.X)) {
-		if c.X == utf8.RuneCount(c.buf.LineBytes(c.Y)) {
+		if c.X == util.CharacterCount(c.buf.LineBytes(c.Y)) {
 			c.Right()
 			return
 		}
@@ -387,7 +401,7 @@ func (c *Cursor) WordRight() {
 	}
 	c.Right()
 	for util.IsWordChar(c.RuneUnder(c.X)) {
-		if c.X == utf8.RuneCount(c.buf.LineBytes(c.Y)) {
+		if c.X == util.CharacterCount(c.buf.LineBytes(c.Y)) {
 			return
 		}
 		c.Right()
@@ -416,14 +430,14 @@ func (c *Cursor) WordLeft() {
 // RuneUnder returns the rune under the given x position
 func (c *Cursor) RuneUnder(x int) rune {
 	line := c.buf.LineBytes(c.Y)
-	if len(line) == 0 || x >= utf8.RuneCount(line) {
+	if len(line) == 0 || x >= util.CharacterCount(line) {
 		return '\n'
 	} else if x < 0 {
 		x = 0
 	}
 	i := 0
 	for len(line) > 0 {
-		r, size := utf8.DecodeRune(line)
+		r, _, size := util.DecodeCharacter(line)
 		line = line[size:]
 
 		if i == x {

internal/buffer/eventhandler.go

@@ -3,12 +3,12 @@ package buffer
 import (
 	"bytes"
 	"time"
-	"unicode/utf8"
 
 	dmp "github.com/sergi/go-diff/diffmatchpatch"
-	"github.com/zyedidia/micro/internal/config"
-	ulua "github.com/zyedidia/micro/internal/lua"
-	"github.com/zyedidia/micro/internal/screen"
+	"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/util"
 	luar "layeh.com/gopher-luar"
 )
 
@@ -41,6 +41,73 @@ type Delta struct {
 	End   Loc
 }
 
+// DoTextEvent runs a text event
+func (eh *EventHandler) DoTextEvent(t *TextEvent, useUndo bool) {
+	oldl := eh.buf.LinesNum()
+
+	if useUndo {
+		eh.Execute(t)
+	} else {
+		ExecuteTextEvent(t, eh.buf)
+	}
+
+	if len(t.Deltas) != 1 {
+		return
+	}
+
+	text := t.Deltas[0].Text
+	start := t.Deltas[0].Start
+	lastnl := -1
+	var endX int
+	var textX int
+	if t.EventType == TextEventInsert {
+		linecount := eh.buf.LinesNum() - oldl
+		textcount := util.CharacterCount(text)
+		lastnl = bytes.LastIndex(text, []byte{'\n'})
+		if lastnl >= 0 {
+			endX = util.CharacterCount(text[lastnl+1:])
+			textX = endX
+		} else {
+			endX = start.X + textcount
+			textX = textcount
+		}
+		t.Deltas[0].End = clamp(Loc{endX, start.Y + linecount}, eh.buf.LineArray)
+	}
+	end := t.Deltas[0].End
+
+	for _, c := range eh.cursors {
+		move := func(loc Loc) Loc {
+			if t.EventType == TextEventInsert {
+				if start.Y != loc.Y && loc.GreaterThan(start) {
+					loc.Y += end.Y - start.Y
+				} else if loc.Y == start.Y && loc.GreaterEqual(start) {
+					loc.Y += end.Y - start.Y
+					if lastnl >= 0 {
+						loc.X += textX - start.X
+					} else {
+						loc.X += textX
+					}
+				}
+				return loc
+			} else {
+				if loc.Y != end.Y && loc.GreaterThan(end) {
+					loc.Y -= end.Y - start.Y
+				} else if loc.Y == end.Y && loc.GreaterEqual(end) {
+					loc = loc.MoveLA(-DiffLA(start, end, eh.buf.LineArray), eh.buf.LineArray)
+				}
+				return loc
+			}
+		}
+		c.Loc = move(c.Loc)
+		c.CurSelection[0] = move(c.CurSelection[0])
+		c.CurSelection[1] = move(c.CurSelection[1])
+		c.OrigSelection[0] = move(c.OrigSelection[0])
+		c.OrigSelection[1] = move(c.OrigSelection[1])
+		c.Relocate()
+		c.LastVisualX = c.GetVisualX()
+	}
+}
+
 // ExecuteTextEvent runs a text event
 func ExecuteTextEvent(t *TextEvent, buf *SharedBuffer) {
 	if t.EventType == TextEventInsert {
@@ -56,7 +123,7 @@ func ExecuteTextEvent(t *TextEvent, buf *SharedBuffer) {
 			t.Deltas[i].Text = buf.remove(d.Start, d.End)
 			buf.insert(d.Start, d.Text)
 			t.Deltas[i].Start = d.Start
-			t.Deltas[i].End = Loc{d.Start.X + utf8.RuneCount(d.Text), d.Start.Y}
+			t.Deltas[i].End = Loc{d.Start.X + util.CharacterCount(d.Text), d.Start.Y}
 		}
 		for i, j := 0, len(t.Deltas)-1; i < j; i, j = i+1, j-1 {
 			t.Deltas[i], t.Deltas[j] = t.Deltas[j], t.Deltas[i]
@@ -65,9 +132,9 @@ func ExecuteTextEvent(t *TextEvent, buf *SharedBuffer) {
 }
 
 // UndoTextEvent undoes a text event
-func UndoTextEvent(t *TextEvent, buf *SharedBuffer) {
+func (eh *EventHandler) UndoTextEvent(t *TextEvent) {
 	t.EventType = -t.EventType
-	ExecuteTextEvent(t, buf)
+	eh.DoTextEvent(t, false)
 }
 
 // EventHandler executes text manipulations and allows undoing and redoing
@@ -99,12 +166,12 @@ func (eh *EventHandler) ApplyDiff(new string) {
 	loc := eh.buf.Start()
 	for _, d := range diff {
 		if d.Type == dmp.DiffDelete {
-			eh.Remove(loc, loc.MoveLA(utf8.RuneCountInString(d.Text), eh.buf.LineArray))
+			eh.Remove(loc, loc.MoveLA(util.CharacterCountInString(d.Text), eh.buf.LineArray))
 		} else {
 			if d.Type == dmp.DiffInsert {
 				eh.Insert(loc, d.Text)
 			}
-			loc = loc.MoveLA(utf8.RuneCountInString(d.Text), eh.buf.LineArray)
+			loc = loc.MoveLA(util.CharacterCountInString(d.Text), eh.buf.LineArray)
 		}
 	}
 }
@@ -117,6 +184,9 @@ func (eh *EventHandler) Insert(start Loc, textStr string) {
 
 // InsertBytes creates an insert text event and executes it
 func (eh *EventHandler) InsertBytes(start Loc, text []byte) {
+	if len(text) == 0 {
+		return
+	}
 	start = clamp(start, eh.buf.LineArray)
 	e := &TextEvent{
 		C:         *eh.cursors[eh.active],
@@ -124,50 +194,14 @@ func (eh *EventHandler) InsertBytes(start Loc, text []byte) {
 		Deltas:    []Delta{{text, start, Loc{0, 0}}},
 		Time:      time.Now(),
 	}
-	oldl := eh.buf.LinesNum()
-	eh.Execute(e)
-	linecount := eh.buf.LinesNum() - oldl
-	textcount := utf8.RuneCount(text)
-	lastnl := bytes.LastIndex(text, []byte{'\n'})
-	var endX int
-	var textX int
-	if lastnl >= 0 {
-		endX = utf8.RuneCount(text[lastnl+1:])
-		textX = endX
-	} else {
-		endX = start.X + textcount
-		textX = textcount
-	}
-
-	e.Deltas[0].End = clamp(Loc{endX, start.Y + linecount}, eh.buf.LineArray)
-	end := e.Deltas[0].End
-
-	for _, c := range eh.cursors {
-		move := func(loc Loc) Loc {
-			if start.Y != end.Y && loc.GreaterThan(start) {
-				loc.Y += end.Y - start.Y
-			} else if loc.Y == start.Y && loc.GreaterEqual(start) {
-				loc.Y += end.Y - start.Y
-				if lastnl >= 0 {
-					loc.X = textX
-				} else {
-					loc.X += textX
-				}
-			}
-			return loc
-		}
-		c.Loc = move(c.Loc)
-		c.Relocate()
-		c.CurSelection[0] = move(c.CurSelection[0])
-		c.CurSelection[1] = move(c.CurSelection[1])
-		c.OrigSelection[0] = move(c.OrigSelection[0])
-		c.OrigSelection[1] = move(c.OrigSelection[1])
-		c.LastVisualX = c.GetVisualX()
-	}
+	eh.DoTextEvent(e, true)
 }
 
 // Remove creates a remove text event and executes it
 func (eh *EventHandler) Remove(start, end Loc) {
+	if start == end {
+		return
+	}
 	start = clamp(start, eh.buf.LineArray)
 	end = clamp(end, eh.buf.LineArray)
 	e := &TextEvent{
@@ -176,24 +210,7 @@ func (eh *EventHandler) Remove(start, end Loc) {
 		Deltas:    []Delta{{[]byte{}, start, end}},
 		Time:      time.Now(),
 	}
-	eh.Execute(e)
-
-	for _, c := range eh.cursors {
-		move := func(loc Loc) Loc {
-			if start.Y != end.Y && loc.GreaterThan(end) {
-				loc.Y -= end.Y - start.Y
-			} else if loc.Y == end.Y && loc.GreaterEqual(end) {
-				loc = loc.MoveLA(-DiffLA(start, end, eh.buf.LineArray), eh.buf.LineArray)
-			}
-			return loc
-		}
-		c.Loc = move(c.Loc)
-		c.CurSelection[0] = move(c.CurSelection[0])
-		c.CurSelection[1] = move(c.CurSelection[1])
-		c.OrigSelection[0] = move(c.OrigSelection[0])
-		c.OrigSelection[1] = move(c.OrigSelection[1])
-		c.LastVisualX = c.GetVisualX()
-	}
+	eh.DoTextEvent(e, true)
 }
 
 // MultipleReplace creates an multiple insertions executes them
@@ -264,10 +281,9 @@ func (eh *EventHandler) UndoOneEvent() {
 	if t == nil {
 		return
 	}
-
 	// Undo it
 	// Modifies the text event
-	UndoTextEvent(t, eh.buf)
+	eh.UndoTextEvent(t)
 
 	// Set the cursor in the right place
 	teCursor := t.C
@@ -313,9 +329,6 @@ func (eh *EventHandler) RedoOneEvent() {
 		return
 	}
 
-	// Modifies the text event
-	UndoTextEvent(t, eh.buf)
-
 	teCursor := t.C
 	if teCursor.Num >= 0 && teCursor.Num < len(eh.cursors) {
 		t.C = *eh.cursors[teCursor.Num]
@@ -324,5 +337,8 @@ func (eh *EventHandler) RedoOneEvent() {
 		teCursor.Num = -1
 	}
 
+	// Modifies the text event
+	eh.UndoTextEvent(t)
+
 	eh.UndoStack.Push(t)
 }

internal/buffer/line_array.go

@@ -2,11 +2,12 @@ package buffer
 
 import (
 	"bufio"
+	"bytes"
 	"io"
 	"sync"
-	"unicode/utf8"
 
-	"github.com/zyedidia/micro/pkg/highlight"
+	"github.com/zyedidia/micro/v2/internal/util"
+	"github.com/zyedidia/micro/v2/pkg/highlight"
 )
 
 // Finds the byte index of the nth rune in a byte slice
@@ -18,7 +19,7 @@ func runeToByteIndex(n int, txt []byte) int {
 	count := 0
 	i := 0
 	for len(txt) > 0 {
-		_, size := utf8.DecodeRune(txt)
+		_, _, size := util.DecodeCharacter(txt)
 
 		txt = txt[size:]
 		count += size
@@ -86,6 +87,8 @@ func NewLineArray(size uint64, endings FileFormat, reader io.Reader) *LineArray
 	br := bufio.NewReader(reader)
 	var loaded int
 
+	la.Endings = endings
+
 	n := 0
 	for {
 		data, err := br.ReadBytes('\n')
@@ -152,17 +155,19 @@ func NewLineArray(size uint64, endings FileFormat, reader io.Reader) *LineArray
 // Bytes returns the string that should be written to disk when
 // the line array is saved
 func (la *LineArray) Bytes() []byte {
-	str := make([]byte, 0, la.initsize+1000) // initsize should provide a good estimate
+	b := new(bytes.Buffer)
+	// initsize should provide a good estimate
+	b.Grow(int(la.initsize + 4096))
 	for i, l := range la.lines {
-		str = append(str, l.data...)
+		b.Write(l.data)
 		if i != len(la.lines)-1 {
 			if la.Endings == FFDos {
-				str = append(str, '\r')
+				b.WriteByte('\r')
 			}
-			str = append(str, '\n')
+			b.WriteByte('\n')
 		}
 	}
-	return str
+	return b.Bytes()
 }
 
 // newlineBelow adds a newline below the given line number
@@ -186,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])
@@ -296,7 +306,7 @@ func (la *LineArray) Start() Loc {
 // End returns the location of the last character in the buffer
 func (la *LineArray) End() Loc {
 	numlines := len(la.lines)
-	return Loc{utf8.RuneCount(la.lines[numlines-1].data), numlines - 1}
+	return Loc{util.CharacterCount(la.lines[numlines-1].data), numlines - 1}
 }
 
 // LineBytes returns line n as an array of bytes

internal/buffer/line_array_test.go

@@ -46,14 +46,15 @@ func TestInsert(t *testing.T) {
 
 	assert.Equal(t, []byte("Uppen Sevarne staþe, foobar sel þar him þuhte,"), sub1)
 
-	la.insert(Loc{25, 2}, []byte("ಮಣ್ಣಾಗಿ"))
+	la.insert(Loc{25, 2}, []byte("H̼̥̯͇͙̕͘͞e̸̦̞̠̣̰͙̼̥̦̼̖̬͕͕̰̯̫͇̕ĺ̜̠̩̯̯͙̼̭̠͕̮̞͜l̶͓̫̞̮͈͞ͅo̸͔͙̳̠͈̮̼̳͙̥̲͜͠"))
+
 	sub2 := la.Substr(Loc{0, 2}, Loc{60, 2})
-	assert.Equal(t, []byte("He wonede at Ernleȝe at æಮಣ್ಣಾಗಿðelen are chirechen,"), sub2)
+	assert.Equal(t, []byte("He wonede at Ernleȝe at æH̼̥̯͇͙̕͘͞e̸̦̞̠̣̰͙̼̥̦̼̖̬͕͕̰̯̫͇̕ĺ̜̠̩̯̯͙̼̭̠͕̮̞͜l̶͓̫̞̮͈͞ͅo̸͔͙̳̠͈̮̼̳͙̥̲͜͠ðelen are chirechen,"), sub2)
 }
 
 func TestRemove(t *testing.T) {
 	la.remove(Loc{20, 3}, Loc{27, 3})
-	la.remove(Loc{25, 2}, Loc{32, 2})
+	la.remove(Loc{25, 2}, Loc{30, 2})
 
 	bytes := la.Bytes()
 	assert.Equal(t, unicode_txt, string(bytes))

internal/buffer/loc.go

@@ -1,9 +1,7 @@
 package buffer
 
 import (
-	"unicode/utf8"
-
-	"github.com/zyedidia/micro/internal/util"
+	"github.com/zyedidia/micro/v2/internal/util"
 )
 
 // Loc stores a location
@@ -68,9 +66,9 @@ func DiffLA(a, b Loc, buf *LineArray) int {
 	loc := 0
 	for i := a.Y + 1; i < b.Y; i++ {
 		// + 1 for the newline
-		loc += utf8.RuneCount(buf.LineBytes(i)) + 1
+		loc += util.CharacterCount(buf.LineBytes(i)) + 1
 	}
-	loc += utf8.RuneCount(buf.LineBytes(a.Y)) - a.X + b.X + 1
+	loc += util.CharacterCount(buf.LineBytes(a.Y)) - a.X + b.X + 1
 	return loc
 }
 
@@ -80,7 +78,7 @@ func (l Loc) right(buf *LineArray) Loc {
 		return Loc{l.X + 1, l.Y}
 	}
 	var res Loc
-	if l.X < utf8.RuneCount(buf.LineBytes(l.Y)) {
+	if l.X < util.CharacterCount(buf.LineBytes(l.Y)) {
 		res = Loc{l.X + 1, l.Y}
 	} else {
 		res = Loc{0, l.Y + 1}
@@ -97,7 +95,7 @@ func (l Loc) left(buf *LineArray) Loc {
 	if l.X > 0 {
 		res = Loc{l.X - 1, l.Y}
 	} else {
-		res = Loc{utf8.RuneCount(buf.LineBytes(l.Y - 1)), l.Y - 1}
+		res = Loc{util.CharacterCount(buf.LineBytes(l.Y - 1)), l.Y - 1}
 	}
 	return res
 }

internal/buffer/message.go

@@ -1,7 +1,7 @@
 package buffer
 
 import (
-	"github.com/zyedidia/micro/internal/config"
+	"github.com/zyedidia/micro/v2/internal/config"
 	"github.com/zyedidia/tcell"
 )
 

internal/buffer/save.go

@@ -11,11 +11,10 @@ import (
 	"path/filepath"
 	"runtime"
 	"unicode"
-	"unicode/utf8"
 
-	"github.com/zyedidia/micro/internal/config"
-	"github.com/zyedidia/micro/internal/screen"
-	"github.com/zyedidia/micro/internal/util"
+	"github.com/zyedidia/micro/v2/internal/config"
+	"github.com/zyedidia/micro/v2/internal/screen"
+	"github.com/zyedidia/micro/v2/internal/util"
 	"golang.org/x/text/encoding"
 	"golang.org/x/text/encoding/htmlindex"
 	"golang.org/x/text/transform"
@@ -97,12 +96,11 @@ func (b *Buffer) saveToFile(filename string, withSudo bool) error {
 		return errors.New("Save with sudo not supported on Windows")
 	}
 
-	b.UpdateRules()
 	if b.Settings["rmtrailingws"].(bool) {
 		for i, l := range b.lines {
-			leftover := utf8.RuneCount(bytes.TrimRightFunc(l.data, unicode.IsSpace))
+			leftover := util.CharacterCount(bytes.TrimRightFunc(l.data, unicode.IsSpace))
 
-			linelen := utf8.RuneCount(l.data)
+			linelen := util.CharacterCount(l.data)
 			b.Remove(Loc{leftover, i}, Loc{linelen, i})
 		}
 
@@ -111,8 +109,8 @@ func (b *Buffer) saveToFile(filename string, withSudo bool) error {
 
 	if b.Settings["eofnewline"].(bool) {
 		end := b.End()
-		if b.RuneAt(Loc{end.X - 1, end.Y}) != '\n' {
-			b.Insert(end, "\n")
+		if b.RuneAt(Loc{end.X, end.Y}) != '\n' {
+			b.insert(end, []byte{'\n'})
 		}
 	}
 
@@ -196,5 +194,6 @@ func (b *Buffer) saveToFile(filename string, withSudo bool) error {
 	absPath, _ := filepath.Abs(filename)
 	b.AbsPath = absPath
 	b.isModified = false
+	b.UpdateRules()
 	return err
 }

internal/buffer/search.go

@@ -2,12 +2,18 @@ package buffer
 
 import (
 	"regexp"
-	"unicode/utf8"
 
-	"github.com/zyedidia/micro/internal/util"
+	"github.com/zyedidia/micro/v2/internal/util"
 )
 
 func (b *Buffer) findDown(r *regexp.Regexp, start, end Loc) ([2]Loc, bool) {
+	lastcn := util.CharacterCount(b.LineBytes(b.LinesNum() - 1))
+	if start.Y > b.LinesNum()-1 {
+		start.X = lastcn - 1
+	}
+	if end.Y > b.LinesNum()-1 {
+		end.X = lastcn
+	}
 	start.Y = util.Clamp(start.Y, 0, b.LinesNum()-1)
 	end.Y = util.Clamp(end.Y, 0, b.LinesNum()-1)
 
@@ -20,19 +26,19 @@ func (b *Buffer) findDown(r *regexp.Regexp, start, end Loc) ([2]Loc, bool) {
 		charpos := 0
 
 		if i == start.Y && start.Y == end.Y {
-			nchars := utf8.RuneCount(l)
+			nchars := util.CharacterCount(l)
 			start.X = util.Clamp(start.X, 0, nchars)
 			end.X = util.Clamp(end.X, 0, nchars)
 			l = util.SliceStart(l, end.X)
 			l = util.SliceEnd(l, start.X)
 			charpos = start.X
 		} else if i == start.Y {
-			nchars := utf8.RuneCount(l)
+			nchars := util.CharacterCount(l)
 			start.X = util.Clamp(start.X, 0, nchars)
 			l = util.SliceEnd(l, start.X)
 			charpos = start.X
 		} else if i == end.Y {
-			nchars := utf8.RuneCount(l)
+			nchars := util.CharacterCount(l)
 			end.X = util.Clamp(end.X, 0, nchars)
 			l = util.SliceStart(l, end.X)
 		}
@@ -49,6 +55,13 @@ func (b *Buffer) findDown(r *regexp.Regexp, start, end Loc) ([2]Loc, bool) {
 }
 
 func (b *Buffer) findUp(r *regexp.Regexp, start, end Loc) ([2]Loc, bool) {
+	lastcn := util.CharacterCount(b.LineBytes(b.LinesNum() - 1))
+	if start.Y > b.LinesNum()-1 {
+		start.X = lastcn - 1
+	}
+	if end.Y > b.LinesNum()-1 {
+		end.X = lastcn
+	}
 	start.Y = util.Clamp(start.Y, 0, b.LinesNum()-1)
 	end.Y = util.Clamp(end.Y, 0, b.LinesNum()-1)
 
@@ -61,19 +74,19 @@ func (b *Buffer) findUp(r *regexp.Regexp, start, end Loc) ([2]Loc, bool) {
 		charpos := 0
 
 		if i == start.Y && start.Y == end.Y {
-			nchars := utf8.RuneCount(l)
+			nchars := util.CharacterCount(l)
 			start.X = util.Clamp(start.X, 0, nchars)
 			end.X = util.Clamp(end.X, 0, nchars)
 			l = util.SliceStart(l, end.X)
 			l = util.SliceEnd(l, start.X)
 			charpos = start.X
 		} else if i == start.Y {
-			nchars := utf8.RuneCount(l)
+			nchars := util.CharacterCount(l)
 			start.X = util.Clamp(start.X, 0, nchars)
 			l = util.SliceEnd(l, start.X)
 			charpos = start.X
 		} else if i == end.Y {
-			nchars := utf8.RuneCount(l)
+			nchars := util.CharacterCount(l)
 			end.X = util.Clamp(end.X, 0, nchars)
 			l = util.SliceStart(l, end.X)
 		}
@@ -133,7 +146,7 @@ func (b *Buffer) FindNext(s string, start, end, from Loc, down bool, useRegex bo
 
 // ReplaceRegex replaces all occurrences of 'search' with 'replace' in the given area
 // and returns the number of replacements made and the number of runes
-// added or removed
+// added or removed on the last line of the range
 func (b *Buffer) ReplaceRegex(start, end Loc, search *regexp.Regexp, replace []byte) (int, int) {
 	if start.GreaterThan(end) {
 		start, end = end, start
@@ -163,12 +176,14 @@ func (b *Buffer) ReplaceRegex(start, end Loc, search *regexp.Regexp, replace []b
 				result = search.Expand(result, replace, in, submatches)
 			}
 			found++
-			netrunes += utf8.RuneCount(in) - utf8.RuneCount(result)
+			if i == end.Y {
+				netrunes += util.CharacterCount(result) - util.CharacterCount(in)
+			}
 			return result
 		})
 
 		from := Loc{charpos, i}
-		to := Loc{charpos + utf8.RuneCount(l), i}
+		to := Loc{charpos + util.CharacterCount(l), i}
 
 		deltas = append(deltas, Delta{newText, from, to})
 	}

internal/buffer/serialize.go

@@ -10,8 +10,8 @@ import (
 
 	"golang.org/x/text/encoding"
 
-	"github.com/zyedidia/micro/internal/config"
-	"github.com/zyedidia/micro/internal/util"
+	"github.com/zyedidia/micro/v2/internal/config"
+	"github.com/zyedidia/micro/v2/internal/util"
 )
 
 // The SerializedBuffer holds the types that get serialized when a buffer is saved

internal/buffer/settings.go

@@ -1,8 +1,8 @@
 package buffer
 
 import (
-	"github.com/zyedidia/micro/internal/config"
-	"github.com/zyedidia/micro/internal/screen"
+	"github.com/zyedidia/micro/v2/internal/config"
+	"github.com/zyedidia/micro/v2/internal/screen"
 )
 
 func (b *Buffer) SetOptionNative(option string, nativeValue interface{}) error {

internal/config/colorscheme.go

@@ -151,6 +151,9 @@ func StringToStyle(str string) tcell.Style {
 	if strings.Contains(str, "bold") {
 		style = style.Bold(true)
 	}
+	if strings.Contains(str, "italic") {
+		style = style.Italic(true)
+	}
 	if strings.Contains(str, "reverse") {
 		style = style.Reverse(true)
 	}

internal/config/plugin.go

@@ -5,7 +5,7 @@ import (
 	"log"
 
 	lua "github.com/yuin/gopher-lua"
-	ulua "github.com/zyedidia/micro/internal/lua"
+	ulua "github.com/zyedidia/micro/v2/internal/lua"
 )
 
 // ErrNoSuchFunction is returned when Call is executed on a function that does not exist

internal/config/plugin_installer.go

@@ -16,8 +16,8 @@ import (
 	"github.com/blang/semver"
 	lua "github.com/yuin/gopher-lua"
 	"github.com/zyedidia/json5"
-	ulua "github.com/zyedidia/micro/internal/lua"
-	"github.com/zyedidia/micro/internal/util"
+	ulua "github.com/zyedidia/micro/v2/internal/lua"
+	"github.com/zyedidia/micro/v2/internal/util"
 )
 
 var (

internal/config/settings.go

@@ -3,6 +3,7 @@ package config
 import (
 	"encoding/json"
 	"errors"
+	"fmt"
 	"io/ioutil"
 	"os"
 	"path/filepath"
@@ -12,7 +13,7 @@ import (
 
 	"github.com/zyedidia/glob"
 	"github.com/zyedidia/json5"
-	"github.com/zyedidia/micro/internal/util"
+	"github.com/zyedidia/micro/v2/internal/util"
 	"golang.org/x/text/encoding/htmlindex"
 )
 
@@ -26,10 +27,16 @@ 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
+	ModifiedSettings map[string]bool
 )
 
 func init() {
+	ModifiedSettings = make(map[string]bool)
 	parsedSettings = make(map[string]interface{})
 }
 
@@ -50,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())
 			}
 
@@ -75,16 +84,33 @@ func ReadSettings() error {
 	return nil
 }
 
+func verifySetting(option string, value reflect.Type, def reflect.Type) bool {
+	var interfaceArr []interface{}
+	switch option {
+	case "pluginrepos", "pluginchannels":
+		return value.AssignableTo(reflect.TypeOf(interfaceArr))
+	default:
+		return def.AssignableTo(value)
+	}
+}
+
 // InitGlobalSettings initializes the options map and sets all options to their default values
 // Must be called after ReadSettings
-func InitGlobalSettings() {
+func InitGlobalSettings() error {
+	var err error
 	GlobalSettings = DefaultGlobalSettings()
 
 	for k, v := range parsedSettings {
 		if !strings.HasPrefix(reflect.TypeOf(v).String(), "map") {
+			if _, ok := GlobalSettings[k]; ok && !verifySetting(k, reflect.TypeOf(v), reflect.TypeOf(GlobalSettings[k])) {
+				err = errors.New(fmt.Sprintf("Global Error: setting '%s' has incorrect type (%s), using default value: %v (%s)", k, reflect.TypeOf(v), GlobalSettings[k], reflect.TypeOf(GlobalSettings[k])))
+				continue
+			}
+
 			GlobalSettings[k] = v
 		}
 	}
+	return err
 }
 
 // InitLocalSettings scans the json in settings.json and sets the options locally based
@@ -97,6 +123,10 @@ func InitLocalSettings(settings map[string]interface{}, path string) error {
 			if strings.HasPrefix(k, "ft:") {
 				if settings["filetype"].(string) == k[3:] {
 					for k1, v1 := range v.(map[string]interface{}) {
+						if _, ok := settings[k1]; ok && !verifySetting(k1, reflect.TypeOf(v1), reflect.TypeOf(settings[k1])) {
+							parseError = errors.New(fmt.Sprintf("Error: setting '%s' has incorrect type (%s), using default value: %v (%s)", k, reflect.TypeOf(v1), settings[k1], reflect.TypeOf(settings[k1])))
+							continue
+						}
 						settings[k1] = v1
 					}
 				}
@@ -109,6 +139,10 @@ func InitLocalSettings(settings map[string]interface{}, path string) error {
 
 				if g.MatchString(path) {
 					for k1, v1 := range v.(map[string]interface{}) {
+						if _, ok := settings[k1]; ok && !verifySetting(k1, reflect.TypeOf(v1), reflect.TypeOf(settings[k1])) {
+							parseError = errors.New(fmt.Sprintf("Error: setting '%s' has incorrect type (%s), using default value: %v (%s)", k, reflect.TypeOf(v1), settings[k1], reflect.TypeOf(settings[k1])))
+							continue
+						}
 						settings[k1] = v1
 					}
 				}
@@ -120,10 +154,35 @@ 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()
+
+		// remove any options froms parsedSettings that have since been marked as default
+		for k, v := range parsedSettings {
+			if !strings.HasPrefix(reflect.TypeOf(v).String(), "map") {
+				cur, okcur := GlobalSettings[k]
+				if def, ok := defaults[k]; ok && okcur && reflect.DeepEqual(cur, def) {
+					delete(parsedSettings, k)
+				}
+			}
+		}
+
+		// add any options to parsedSettings that have since been marked as non-default
 		for k, v := range GlobalSettings {
-			parsedSettings[k] = v
+			if def, ok := defaults[k]; !ok || !reflect.DeepEqual(v, def) {
+				if _, wr := ModifiedSettings[k]; wr {
+					parsedSettings[k] = v
+				}
+			}
 		}
 
 		txt, _ := json.MarshalIndent(parsedSettings, "", "    ")
@@ -132,10 +191,23 @@ func WriteSettings(filename string) error {
 	return err
 }
 
+// OverwriteSettings writes the current settings to settings.json and
+// resets any user configuration of local settings present in settings.json
 func OverwriteSettings(filename string) error {
+	settings := make(map[string]interface{})
+
 	var err error
 	if _, e := os.Stat(ConfigDir); e == nil {
-		txt, _ := json.MarshalIndent(GlobalSettings, "", "    ")
+		defaults := DefaultGlobalSettings()
+		for k, v := range GlobalSettings {
+			if def, ok := defaults[k]; !ok || !reflect.DeepEqual(v, def) {
+				if _, wr := ModifiedSettings[k]; wr {
+					settings[k] = v
+				}
+			}
+		}
+
+		txt, _ := json.MarshalIndent(settings, "", "    ")
 		err = ioutil.WriteFile(filename, append(txt, '\n'), 0644)
 	}
 	return err
@@ -144,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"))
@@ -152,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
 }
@@ -186,12 +258,13 @@ var defaultCommonSettings = map[string]interface{}{
 	"autoindent":     true,
 	"autosu":         false,
 	"backup":         true,
+	"backupdir":      "",
 	"basename":       false,
 	"colorcolumn":    float64(0),
 	"cursorline":     true,
 	"diffgutter":     false,
 	"encoding":       "utf-8",
-	"eofnewline":     false,
+	"eofnewline":     true,
 	"fastdirty":      false,
 	"fileformat":     "unix",
 	"filetype":       "unknown",
@@ -200,9 +273,11 @@ var defaultCommonSettings = map[string]interface{}{
 	"keepautoindent": false,
 	"matchbrace":     true,
 	"mkparents":      false,
+	"permbackup":     false,
 	"readonly":       false,
 	"rmtrailingws":   false,
 	"ruler":          true,
+	"relativeruler":  false,
 	"savecursor":     false,
 	"saveundo":       false,
 	"scrollbar":      false,
@@ -248,9 +323,12 @@ func DefaultCommonSettings() map[string]interface{} {
 var DefaultGlobalOnlySettings = map[string]interface{}{
 	"autosave":       float64(0),
 	"colorscheme":    "default",
+	"divchars":       "|-",
+	"divreverse":     true,
 	"infobar":        true,
 	"keymenu":        false,
 	"mouse":          true,
+	"parsecursor":    false,
 	"paste":          false,
 	"savehistory":    true,
 	"sucmd":          "sudo",

internal/display/bufwindow.go

@@ -2,13 +2,12 @@ package display
 
 import (
 	"strconv"
-	"unicode/utf8"
 
 	runewidth "github.com/mattn/go-runewidth"
-	"github.com/zyedidia/micro/internal/buffer"
-	"github.com/zyedidia/micro/internal/config"
-	"github.com/zyedidia/micro/internal/screen"
-	"github.com/zyedidia/micro/internal/util"
+	"github.com/zyedidia/micro/v2/internal/buffer"
+	"github.com/zyedidia/micro/v2/internal/config"
+	"github.com/zyedidia/micro/v2/internal/screen"
+	"github.com/zyedidia/micro/v2/internal/util"
 	"github.com/zyedidia/tcell"
 )
 
@@ -73,9 +72,9 @@ func (w *BufWindow) getStartInfo(n, lineN int) ([]byte, int, int, *tcell.Style)
 	curStyle := config.DefStyle
 	var s *tcell.Style
 	for len(b) > 0 {
-		r, size := utf8.DecodeRune(b)
+		r, _, size := util.DecodeCharacter(b)
 
-		curStyle, found := w.getStyle(curStyle, bloc, r)
+		curStyle, found := w.getStyle(curStyle, bloc)
 		if found {
 			s = &curStyle
 		}
@@ -237,7 +236,7 @@ func (w *BufWindow) LocFromVisual(svloc buffer.Loc) buffer.Loc {
 				return bloc
 			}
 
-			r, size := utf8.DecodeRune(line)
+			r, _, size := util.DecodeCharacter(line)
 			draw()
 			width := 0
 
@@ -336,7 +335,14 @@ func (w *BufWindow) drawDiffGutter(backgroundStyle tcell.Style, softwrapped bool
 }
 
 func (w *BufWindow) drawLineNum(lineNumStyle tcell.Style, softwrapped bool, maxLineNumLength int, vloc *buffer.Loc, bloc *buffer.Loc) {
-	lineNum := strconv.Itoa(bloc.Y + 1)
+	cursorLine := w.Buf.GetActiveCursor().Loc.Y
+	var lineInt int
+	if w.Buf.Settings["relativeruler"] == false || cursorLine == bloc.Y {
+		lineInt = bloc.Y + 1
+	} else {
+		lineInt = bloc.Y - cursorLine
+	}
+	lineNum := strconv.Itoa(util.Abs(lineInt))
 
 	// Write the spaces before the line number if necessary
 	for i := 0; i < maxLineNumLength-len(lineNum); i++ {
@@ -360,7 +366,7 @@ func (w *BufWindow) drawLineNum(lineNumStyle tcell.Style, softwrapped bool, maxL
 
 // getStyle returns the highlight style for the given character position
 // If there is no change to the current highlight style it just returns that
-func (w *BufWindow) getStyle(style tcell.Style, bloc buffer.Loc, r rune) (tcell.Style, bool) {
+func (w *BufWindow) getStyle(style tcell.Style, bloc buffer.Loc) (tcell.Style, bool) {
 	if group, ok := w.Buf.Match(bloc.Y)[bloc.X]; ok {
 		s := config.GetColor(group.String())
 		return s, true
@@ -397,21 +403,7 @@ func (w *BufWindow) displayBuffer() {
 		bufWidth--
 	}
 
-	if len(b.Modifications) > 0 {
-		if b.Settings["syntax"].(bool) && b.SyntaxDef != nil {
-			for _, r := range b.Modifications {
-				rx := util.Clamp(r.X, 0, b.LinesNum())
-				ry := util.Clamp(r.Y, 0, b.LinesNum())
-				final := -1
-				for i := rx; i <= ry; i++ {
-					final = util.Max(b.Highlighter.ReHighlightStates(b, i), final)
-				}
-				b.Highlighter.HighlightMatches(b, rx, final+1)
-			}
-		}
-
-		b.ClearModifications()
-
+	if b.ModifiedThisFrame {
 		if b.Settings["diffgutter"].(bool) {
 			b.UpdateDiff(func(synchronous bool) {
 				// If the diff was updated asynchronously, the outer call to
@@ -426,6 +418,7 @@ func (w *BufWindow) displayBuffer() {
 				}
 			})
 		}
+		b.ModifiedThisFrame = false
 	}
 
 	var matchingBraces []buffer.Loc
@@ -523,8 +516,15 @@ func (w *BufWindow) displayBuffer() {
 		}
 		bloc.X = bslice
 
-		draw := func(r rune, style tcell.Style, showcursor bool) {
+		draw := func(r rune, combc []rune, style tcell.Style, showcursor bool) {
 			if nColsBeforeStart <= 0 {
+				_, origBg, _ := style.Decompose()
+				_, defBg, _ := config.DefStyle.Decompose()
+
+				// syntax highlighting with non-default background takes precedence
+				// over cursor-line and color-column
+				dontOverrideBackground := origBg != defBg
+
 				for _, c := range cursors {
 					if c.HasSelection() &&
 						(bloc.GreaterEqual(c.CurSelection[0]) && bloc.LessThan(c.CurSelection[1]) ||
@@ -537,7 +537,7 @@ func (w *BufWindow) displayBuffer() {
 						}
 					}
 
-					if b.Settings["cursorline"].(bool) && w.active &&
+					if b.Settings["cursorline"].(bool) && w.active && !dontOverrideBackground &&
 						!c.HasSelection() && c.Y == bloc.Y {
 						if s, ok := config.Colorscheme["cursor-line"]; ok {
 							fg, _, _ := s.Decompose()
@@ -569,7 +569,7 @@ func (w *BufWindow) displayBuffer() {
 				}
 
 				if s, ok := config.Colorscheme["color-column"]; ok {
-					if colorcolumn != 0 && vloc.X-w.gutterOffset == colorcolumn {
+					if colorcolumn != 0 && vloc.X-w.gutterOffset+w.StartCol == colorcolumn && !dontOverrideBackground {
 						fg, _, _ := s.Decompose()
 						style = style.Background(fg)
 					}
@@ -581,7 +581,7 @@ func (w *BufWindow) displayBuffer() {
 					}
 				}
 
-				screen.SetContent(w.X+vloc.X, w.Y+vloc.Y, r, nil, style)
+				screen.SetContent(w.X+vloc.X, w.Y+vloc.Y, r, combc, style)
 
 				if showcursor {
 					for _, c := range cursors {
@@ -597,10 +597,11 @@ func (w *BufWindow) displayBuffer() {
 
 		totalwidth := w.StartCol - nColsBeforeStart
 		for len(line) > 0 {
-			r, size := utf8.DecodeRune(line)
-			curStyle, _ = w.getStyle(curStyle, bloc, r)
+			r, combc, size := util.DecodeCharacter(line)
 
-			draw(r, curStyle, true)
+			curStyle, _ = w.getStyle(curStyle, bloc)
+
+			draw(r, combc, curStyle, true)
 
 			width := 0
 
@@ -617,7 +618,7 @@ func (w *BufWindow) displayBuffer() {
 			// Draw any extra characters either spaces for tabs or @ for incomplete wide runes
 			if width > 1 {
 				for i := 1; i < width; i++ {
-					draw(char, curStyle, false)
+					draw(char, nil, curStyle, false)
 				}
 			}
 			bloc.X++
@@ -663,7 +664,7 @@ func (w *BufWindow) displayBuffer() {
 		for i := vloc.X; i < bufWidth; i++ {
 			curStyle := style
 			if s, ok := config.Colorscheme["color-column"]; ok {
-				if colorcolumn != 0 && i-w.gutterOffset == colorcolumn {
+				if colorcolumn != 0 && i-w.gutterOffset+w.StartCol == colorcolumn {
 					fg, _, _ := s.Decompose()
 					curStyle = style.Background(fg)
 				}
@@ -672,7 +673,8 @@ func (w *BufWindow) displayBuffer() {
 		}
 
 		if vloc.X != bufWidth {
-			draw(' ', curStyle, true)
+			// Display newline within a selection
+			draw(' ', nil, config.DefStyle, true)
 		}
 
 		bloc.X = w.StartCol
@@ -695,8 +697,27 @@ func (w *BufWindow) displayStatusLine() {
 		w.sline.Display()
 	} else if w.Y+w.Height != infoY {
 		w.drawStatus = true
+
+		divchars := config.GetGlobalOption("divchars").(string)
+		if util.CharacterCountInString(divchars) != 2 {
+			divchars = "|-"
+		}
+
+		_, _, size := util.DecodeCharacterInString(divchars)
+		divchar, combc, _ := util.DecodeCharacterInString(divchars[size:])
+
+		dividerStyle := config.DefStyle
+		if style, ok := config.Colorscheme["divider"]; ok {
+			dividerStyle = style
+		}
+
+		divreverse := config.GetGlobalOption("divreverse").(bool)
+		if divreverse {
+			dividerStyle = dividerStyle.Reverse(true)
+		}
+
 		for x := w.X; x < w.X+w.Width; x++ {
-			screen.SetContent(x, w.Y+w.Height-1, '-', nil, config.DefStyle.Reverse(true))
+			screen.SetContent(x, w.Y+w.Height-1, divchar, combc, dividerStyle)
 		}
 	} else {
 		w.drawStatus = false

internal/display/infowindow.go

@@ -1,14 +1,12 @@
 package display
 
 import (
-	"unicode/utf8"
-
 	runewidth "github.com/mattn/go-runewidth"
-	"github.com/zyedidia/micro/internal/buffer"
-	"github.com/zyedidia/micro/internal/config"
-	"github.com/zyedidia/micro/internal/info"
-	"github.com/zyedidia/micro/internal/screen"
-	"github.com/zyedidia/micro/internal/util"
+	"github.com/zyedidia/micro/v2/internal/buffer"
+	"github.com/zyedidia/micro/v2/internal/config"
+	"github.com/zyedidia/micro/v2/internal/info"
+	"github.com/zyedidia/micro/v2/internal/screen"
+	"github.com/zyedidia/micro/v2/internal/util"
 	"github.com/zyedidia/tcell"
 )
 
@@ -70,7 +68,7 @@ func (i *InfoWindow) IsActive() bool   { return true }
 func (i *InfoWindow) LocFromVisual(vloc buffer.Loc) buffer.Loc {
 	c := i.Buffer.GetActiveCursor()
 	l := i.Buffer.LineBytes(0)
-	n := utf8.RuneCountInString(i.Msg)
+	n := util.CharacterCountInString(i.Msg)
 	return buffer.Loc{c.GetCharPosInLine(l, vloc.X-n), 0}
 }
 
@@ -86,13 +84,13 @@ func (i *InfoWindow) displayBuffer() {
 	activeC := b.GetActiveCursor()
 
 	blocX := 0
-	vlocX := utf8.RuneCountInString(i.Msg)
+	vlocX := util.CharacterCountInString(i.Msg)
 
 	tabsize := 4
 	line, nColsBeforeStart, bslice := util.SliceVisualEnd(line, blocX, tabsize)
 	blocX = bslice
 
-	draw := func(r rune, style tcell.Style) {
+	draw := func(r rune, combc []rune, style tcell.Style) {
 		if nColsBeforeStart <= 0 {
 			bloc := buffer.Loc{X: blocX, Y: 0}
 			if activeC.HasSelection() &&
@@ -112,8 +110,9 @@ func (i *InfoWindow) displayBuffer() {
 				c := r
 				if j > 0 {
 					c = ' '
+					combc = nil
 				}
-				screen.SetContent(vlocX, i.Y, c, nil, style)
+				screen.SetContent(vlocX, i.Y, c, combc, style)
 			}
 			vlocX++
 		}
@@ -124,9 +123,9 @@ func (i *InfoWindow) displayBuffer() {
 	for len(line) > 0 {
 		curVX := vlocX
 		curBX := blocX
-		r, size := utf8.DecodeRune(line)
+		r, combc, size := util.DecodeCharacter(line)
 
-		draw(r, i.defStyle())
+		draw(r, combc, i.defStyle())
 
 		width := 0
 
@@ -146,7 +145,7 @@ func (i *InfoWindow) displayBuffer() {
 		// Draw any extra characters either spaces for tabs or @ for incomplete wide runes
 		if width > 1 {
 			for j := 1; j < width; j++ {
-				draw(char, i.defStyle())
+				draw(char, nil, i.defStyle())
 			}
 		}
 		if activeC.X == curBX {
@@ -191,7 +190,7 @@ func (i *InfoWindow) scrollToSuggestion() {
 	s := i.totalSize()
 
 	for j, n := range i.Suggestions {
-		c := utf8.RuneCountInString(n)
+		c := util.CharacterCountInString(n)
 		if j == i.CurSuggestion {
 			if x+c >= i.hscroll+i.Width {
 				i.hscroll = util.Clamp(x+c+1-i.Width, 0, s-i.Width)
@@ -209,13 +208,13 @@ func (i *InfoWindow) scrollToSuggestion() {
 }
 
 func (i *InfoWindow) Display() {
-	i.Clear()
-	x := 0
-	if config.GetGlobalOption("keymenu").(bool) {
-		i.displayKeyMenu()
-	}
-
 	if i.HasPrompt || config.GlobalSettings["infobar"].(bool) {
+		i.Clear()
+		x := 0
+		if config.GetGlobalOption("keymenu").(bool) {
+			i.displayKeyMenu()
+		}
+
 		if !i.HasPrompt && !i.HasMessage && !i.HasError {
 			return
 		}

internal/display/statusline.go

@@ -3,21 +3,19 @@ package display
 import (
 	"bytes"
 	"fmt"
-	"path"
 	"regexp"
 	"strconv"
 	"strings"
-	"unicode/utf8"
 
 	luar "layeh.com/gopher-luar"
 
 	runewidth "github.com/mattn/go-runewidth"
 	lua "github.com/yuin/gopher-lua"
-	"github.com/zyedidia/micro/internal/buffer"
-	"github.com/zyedidia/micro/internal/config"
-	ulua "github.com/zyedidia/micro/internal/lua"
-	"github.com/zyedidia/micro/internal/screen"
-	"github.com/zyedidia/micro/internal/util"
+	"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/util"
 )
 
 // StatusLine represents the information line at the bottom
@@ -32,9 +30,6 @@ type StatusLine struct {
 
 var statusInfo = map[string]func(*buffer.Buffer) string{
 	"filename": func(b *buffer.Buffer) string {
-		if b.Settings["basename"].(bool) {
-			return path.Base(b.GetName())
-		}
 		return b.GetName()
 	},
 	"line": func(b *buffer.Buffer) string {
@@ -172,34 +167,36 @@ func (s *StatusLine) Display() {
 		statusLineStyle = style
 	}
 
-	leftLen := util.StringWidth(leftText, utf8.RuneCount(leftText), 1)
-	rightLen := util.StringWidth(rightText, utf8.RuneCount(rightText), 1)
+	leftLen := util.StringWidth(leftText, util.CharacterCount(leftText), 1)
+	rightLen := util.StringWidth(rightText, util.CharacterCount(rightText), 1)
 
 	winX := s.win.X
 	for x := 0; x < s.win.Width; x++ {
 		if x < leftLen {
-			r, size := utf8.DecodeRune(leftText)
+			r, combc, size := util.DecodeCharacter(leftText)
 			leftText = leftText[size:]
 			rw := runewidth.RuneWidth(r)
 			for j := 0; j < rw; j++ {
 				c := r
 				if j > 0 {
 					c = ' '
+					combc = nil
 					x++
 				}
-				screen.SetContent(winX+x, y, c, nil, statusLineStyle)
+				screen.SetContent(winX+x, y, c, combc, statusLineStyle)
 			}
 		} else if x >= s.win.Width-rightLen && x < rightLen+s.win.Width-rightLen {
-			r, size := utf8.DecodeRune(rightText)
+			r, combc, size := util.DecodeCharacter(rightText)
 			rightText = rightText[size:]
 			rw := runewidth.RuneWidth(r)
 			for j := 0; j < rw; j++ {
 				c := r
 				if j > 0 {
 					c = ' '
+					combc = nil
 					x++
 				}
-				screen.SetContent(winX+x, y, c, nil, statusLineStyle)
+				screen.SetContent(winX+x, y, c, combc, statusLineStyle)
 			}
 		} else {
 			screen.SetContent(winX+x, y, ' ', nil, statusLineStyle)

internal/display/tabwindow.go

@@ -1,13 +1,11 @@
 package display
 
 import (
-	"unicode/utf8"
-
 	runewidth "github.com/mattn/go-runewidth"
-	"github.com/zyedidia/micro/internal/buffer"
-	"github.com/zyedidia/micro/internal/config"
-	"github.com/zyedidia/micro/internal/screen"
-	"github.com/zyedidia/micro/internal/util"
+	"github.com/zyedidia/micro/v2/internal/buffer"
+	"github.com/zyedidia/micro/v2/internal/config"
+	"github.com/zyedidia/micro/v2/internal/screen"
+	"github.com/zyedidia/micro/v2/internal/util"
 )
 
 type TabWindow struct {
@@ -34,7 +32,7 @@ func (w *TabWindow) LocFromVisual(vloc buffer.Loc) int {
 
 	for i, n := range w.Names {
 		x++
-		s := utf8.RuneCountInString(n)
+		s := util.CharacterCountInString(n)
 		if vloc.Y == w.Y && vloc.X < x+s {
 			return i
 		}
@@ -75,7 +73,7 @@ func (w *TabWindow) SetActive(a int) {
 	s := w.TotalSize()
 
 	for i, n := range w.Names {
-		c := utf8.RuneCountInString(n)
+		c := util.CharacterCountInString(n)
 		if i == a {
 			if x+c >= w.hscroll+w.Width {
 				w.hscroll = util.Clamp(x+c+1-w.Width, 0, s-w.Width)
@@ -96,6 +94,11 @@ func (w *TabWindow) Display() {
 	x := -w.hscroll
 	done := false
 
+	tabBarStyle := config.DefStyle.Reverse(true)
+	if style, ok := config.Colorscheme["tabbar"]; ok {
+		tabBarStyle = style
+	}
+
 	draw := func(r rune, n int) {
 		for i := 0; i < n; i++ {
 			rw := runewidth.RuneWidth(r)
@@ -105,13 +108,13 @@ func (w *TabWindow) Display() {
 					c = ' '
 				}
 				if x == w.Width-1 && !done {
-					screen.SetContent(w.Width-1, w.Y, '>', nil, config.DefStyle.Reverse(true))
+					screen.SetContent(w.Width-1, w.Y, '>', nil, tabBarStyle)
 					x++
 					break
 				} else if x == 0 && w.hscroll > 0 {
-					screen.SetContent(0, w.Y, '<', nil, config.DefStyle.Reverse(true))
+					screen.SetContent(0, w.Y, '<', nil, tabBarStyle)
 				} else if x >= 0 && x < w.Width {
-					screen.SetContent(x, w.Y, c, nil, config.DefStyle.Reverse(true))
+					screen.SetContent(x, w.Y, c, nil, tabBarStyle)
 				}
 				x++
 			}

internal/display/termwindow.go

@@ -1,12 +1,11 @@
 package display
 
 import (
-	"unicode/utf8"
-
-	"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/v2/internal/buffer"
+	"github.com/zyedidia/micro/v2/internal/config"
+	"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"
 	"github.com/zyedidia/terminal"
 )
@@ -98,12 +97,12 @@ func (w *TermWindow) Display() {
 		}
 
 		text := []byte(w.Name())
-		textLen := utf8.RuneCount(text)
+		textLen := util.CharacterCount(text)
 		for x := 0; x < w.Width; x++ {
 			if x < textLen {
-				r, size := utf8.DecodeRune(text)
+				r, combc, size := util.DecodeCharacter(text)
 				text = text[size:]
-				screen.SetContent(w.X+x, w.Y+w.Height, r, nil, statusLineStyle)
+				screen.SetContent(w.X+x, w.Y+w.Height, r, combc, statusLineStyle)
 			} else {
 				screen.SetContent(w.X+x, w.Y+w.Height, ' ', nil, statusLineStyle)
 			}

internal/display/uiwindow.go

@@ -1,10 +1,11 @@
 package display
 
 import (
-	"github.com/zyedidia/micro/internal/buffer"
-	"github.com/zyedidia/micro/internal/config"
-	"github.com/zyedidia/micro/internal/screen"
-	"github.com/zyedidia/micro/internal/views"
+	"github.com/zyedidia/micro/v2/internal/buffer"
+	"github.com/zyedidia/micro/v2/internal/config"
+	"github.com/zyedidia/micro/v2/internal/screen"
+	"github.com/zyedidia/micro/v2/internal/util"
+	"github.com/zyedidia/micro/v2/internal/views"
 )
 
 type UIWindow struct {
@@ -24,11 +25,23 @@ func (w *UIWindow) drawNode(n *views.Node) {
 		dividerStyle = style
 	}
 
+	divchars := config.GetGlobalOption("divchars").(string)
+	if util.CharacterCountInString(divchars) != 2 {
+		divchars = "|-"
+	}
+
+	divchar, combc, _ := util.DecodeCharacterInString(divchars)
+
+	divreverse := config.GetGlobalOption("divreverse").(bool)
+	if divreverse {
+		dividerStyle = dividerStyle.Reverse(true)
+	}
+
 	for i, c := range cs {
 		if c.IsLeaf() && c.Kind == views.STVert {
 			if i != len(cs)-1 {
 				for h := 0; h < c.H; h++ {
-					screen.SetContent(c.X+c.W, c.Y+h, '|', nil, dividerStyle.Reverse(true))
+					screen.SetContent(c.X+c.W, c.Y+h, divchar, combc, dividerStyle)
 				}
 			}
 		} else {

internal/display/window.go

@@ -1,7 +1,7 @@
 package display
 
 import (
-	"github.com/zyedidia/micro/internal/buffer"
+	"github.com/zyedidia/micro/v2/internal/buffer"
 )
 
 type View struct {

internal/info/history.go

@@ -5,7 +5,7 @@ import (
 	"os"
 	"path/filepath"
 
-	"github.com/zyedidia/micro/internal/config"
+	"github.com/zyedidia/micro/v2/internal/config"
 )
 
 // LoadHistory attempts to load user history from configDir/buffers/history

internal/info/infobuffer.go

@@ -3,7 +3,7 @@ package info
 import (
 	"fmt"
 
-	"github.com/zyedidia/micro/internal/buffer"
+	"github.com/zyedidia/micro/v2/internal/buffer"
 )
 
 // The InfoBuf displays messages and other info at the bottom of the screen.
@@ -146,7 +146,7 @@ func (i *InfoBuf) DonePrompt(canceled bool) {
 				h := i.History[i.PromptType]
 				h[len(h)-1] = resp
 			}
-			i.PromptCallback = nil
+			// i.PromptCallback = nil
 		}
 		i.Replace(i.Start(), i.End(), "")
 	}

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,12 +1,13 @@
 package screen
 
 import (
-	"fmt"
+	"errors"
 	"os"
 	"sync"
+	"unicode"
 
-	"github.com/zyedidia/micro/internal/config"
-	"github.com/zyedidia/micro/internal/util"
+	"github.com/zyedidia/micro/v2/internal/config"
+	"github.com/zyedidia/micro/v2/internal/util"
 	"github.com/zyedidia/tcell"
 )
 
@@ -97,6 +98,10 @@ func ShowCursor(x, y int) {
 // SetContent sets a cell at a point on the screen and makes sure that it is
 // synced with the last cursor location
 func SetContent(x, y int, mainc rune, combc []rune, style tcell.Style) {
+	if !unicode.IsPrint(mainc) {
+		mainc = '<27>'
+	}
+
 	Screen.SetContent(x, y, mainc, combc, style)
 	if util.FakeCursor && lastCursor.x == x && lastCursor.y == y {
 		lastCursor.r = mainc
@@ -126,8 +131,8 @@ func TempStart(screenWasNil bool) {
 }
 
 // Init creates and initializes the tcell screen
-func Init() {
-	drawChan = make(chan bool)
+func Init() error {
+	drawChan = make(chan bool, 8)
 
 	// Should we enable true color?
 	truecolor := os.Getenv("MICRO_TRUECOLOR") == "1"
@@ -146,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
@@ -163,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
 }

internal/shell/shell.go

@@ -11,7 +11,7 @@ import (
 	"strings"
 
 	shellquote "github.com/kballard/go-shellquote"
-	"github.com/zyedidia/micro/internal/screen"
+	"github.com/zyedidia/micro/v2/internal/screen"
 )
 
 // ExecCommand executes a command using exec

internal/shell/terminal.go

@@ -5,8 +5,8 @@ import (
 	"os/exec"
 	"strconv"
 
-	"github.com/zyedidia/micro/internal/buffer"
-	"github.com/zyedidia/micro/internal/screen"
+	"github.com/zyedidia/micro/v2/internal/buffer"
+	"github.com/zyedidia/micro/v2/internal/screen"
 	"github.com/zyedidia/terminal"
 )
 

internal/util/lua.go

@@ -1,15 +1,11 @@
 package util
 
-import (
-	"unicode/utf8"
-)
-
 // LuaRuneAt is a helper function for lua plugins to return the rune
 // at an index within a string
 func LuaRuneAt(str string, runeidx int) string {
 	i := 0
 	for len(str) > 0 {
-		r, size := utf8.DecodeRuneInString(str)
+		r, _, size := DecodeCharacterInString(str)
 
 		str = str[size:]
 
@@ -26,7 +22,7 @@ func LuaRuneAt(str string, runeidx int) string {
 func LuaGetLeadingWhitespace(s string) string {
 	ws := []byte{}
 	for len(s) > 0 {
-		r, size := utf8.DecodeRuneInString(s)
+		r, _, size := DecodeCharacterInString(s)
 		if r == ' ' || r == '\t' {
 			ws = append(ws, byte(r))
 		} else {
@@ -40,6 +36,6 @@ func LuaGetLeadingWhitespace(s string) string {
 
 // LuaIsWordChar returns true if the first rune in a string is a word character
 func LuaIsWordChar(s string) bool {
-	r, _ := utf8.DecodeRuneInString(s)
+	r, _, _ := DecodeCharacterInString(s)
 	return IsWordChar(r)
 }

internal/util/unicode.go

@@ -0,0 +1,96 @@
+package util
+
+import (
+	"unicode"
+	"unicode/utf8"
+)
+
+// Unicode is annoying. A "code point" (rune in Go-speak) may need up to
+// 4 bytes to represent it. In general, a code point will represent a
+// complete character, but this is not always the case. A character with
+// accents may be made up of multiple code points (the code point for the
+// original character, and additional code points for each accent/marking).
+// The functions below are meant to help deal with these additional "combining"
+// code points. In underlying operations (search, replace, etc...), micro will
+// treat a character with combining code points as just the original code point.
+// For rendering, micro will display the combining characters. It's not perfect
+// but it's pretty good.
+
+var minMark = rune(unicode.Mark.R16[0].Lo)
+
+func isMark(r rune) bool {
+	// Fast path
+	if r < minMark {
+		return false
+	}
+	return unicode.In(r, unicode.Mark)
+}
+
+// DecodeCharacter returns the next character from an array of bytes
+// A character is a rune along with any accompanying combining runes
+func DecodeCharacter(b []byte) (rune, []rune, int) {
+	r, size := utf8.DecodeRune(b)
+	b = b[size:]
+	c, s := utf8.DecodeRune(b)
+
+	var combc []rune
+	for isMark(c) {
+		combc = append(combc, c)
+		size += s
+
+		b = b[s:]
+		c, s = utf8.DecodeRune(b)
+	}
+
+	return r, combc, size
+}
+
+// DecodeCharacterInString returns the next character from a string
+// A character is a rune along with any accompanying combining runes
+func DecodeCharacterInString(str string) (rune, []rune, int) {
+	r, size := utf8.DecodeRuneInString(str)
+	str = str[size:]
+	c, s := utf8.DecodeRuneInString(str)
+
+	var combc []rune
+	for isMark(c) {
+		combc = append(combc, c)
+		size += s
+
+		str = str[s:]
+		c, s = utf8.DecodeRuneInString(str)
+	}
+
+	return r, combc, size
+}
+
+// CharacterCount returns the number of characters in a byte array
+// Similar to utf8.RuneCount but for unicode characters
+func CharacterCount(b []byte) int {
+	s := 0
+
+	for len(b) > 0 {
+		r, size := utf8.DecodeRune(b)
+		if !isMark(r) {
+			s++
+		}
+
+		b = b[size:]
+	}
+
+	return s
+}
+
+// CharacterCount returns the number of characters in a string
+// Similar to utf8.RuneCountInString but for unicode characters
+func CharacterCountInString(str string) int {
+	s := 0
+
+	for _, r := range str {
+		if !isMark(r) {
+			s++
+		}
+	}
+
+	return s
+}

internal/util/util.go

@@ -1,6 +1,7 @@
 package util
 
 import (
+	"bytes"
 	"errors"
 	"fmt"
 	"os"
@@ -12,7 +13,6 @@ import (
 	"strings"
 	"time"
 	"unicode"
-	"unicode/utf8"
 
 	"github.com/blang/semver"
 	runewidth "github.com/mattn/go-runewidth"
@@ -30,10 +30,13 @@ var (
 	// CompileDate is the date this binary was compiled on
 	CompileDate = "Unknown"
 	// Debug logging
-	Debug = "ON"
+	Debug = "OFF"
 	// FakeCursor is used to disable the terminal cursor and have micro
 	// draw its own (enabled for windows consoles where the cursor is slow)
 	FakeCursor = false
+
+	// Stdout is a buffer that is written to stdout when micro closes
+	Stdout *bytes.Buffer
 )
 
 func init() {
@@ -46,6 +49,7 @@ func init() {
 	if runtime.GOOS == "windows" {
 		FakeCursor = true
 	}
+	Stdout = new(bytes.Buffer)
 }
 
 // SliceEnd returns a byte slice where the index is a rune index
@@ -59,7 +63,7 @@ func SliceEnd(slc []byte, index int) []byte {
 			return slc[totalSize:]
 		}
 
-		_, size := utf8.DecodeRune(slc[totalSize:])
+		_, _, size := DecodeCharacter(slc[totalSize:])
 		totalSize += size
 		i++
 	}
@@ -77,7 +81,7 @@ func SliceEndStr(str string, index int) string {
 			return str[totalSize:]
 		}
 
-		_, size := utf8.DecodeRuneInString(str[totalSize:])
+		_, _, size := DecodeCharacterInString(str[totalSize:])
 		totalSize += size
 		i++
 	}
@@ -96,7 +100,7 @@ func SliceStart(slc []byte, index int) []byte {
 			return slc[:totalSize]
 		}
 
-		_, size := utf8.DecodeRune(slc[totalSize:])
+		_, _, size := DecodeCharacter(slc[totalSize:])
 		totalSize += size
 		i++
 	}
@@ -114,7 +118,7 @@ func SliceStartStr(str string, index int) string {
 			return str[:totalSize]
 		}
 
-		_, size := utf8.DecodeRuneInString(str[totalSize:])
+		_, _, size := DecodeCharacterInString(str[totalSize:])
 		totalSize += size
 		i++
 	}
@@ -130,7 +134,7 @@ func SliceVisualEnd(b []byte, n, tabsize int) ([]byte, int, int) {
 	width := 0
 	i := 0
 	for len(b) > 0 {
-		r, size := utf8.DecodeRune(b)
+		r, _, size := DecodeCharacter(b)
 
 		w := 0
 		switch r {
@@ -167,7 +171,7 @@ func StringWidth(b []byte, n, tabsize int) int {
 	i := 0
 	width := 0
 	for len(b) > 0 {
-		r, size := utf8.DecodeRune(b)
+		r, _, size := DecodeCharacter(b)
 		b = b[size:]
 
 		switch r {
@@ -260,7 +264,7 @@ func IsBytesWhitespace(b []byte) bool {
 // RunePos returns the rune index of a given byte index
 // Make sure the byte index is not between code points
 func RunePos(b []byte, i int) int {
-	return utf8.RuneCount(b[:i])
+	return CharacterCount(b[:i])
 }
 
 // MakeRelative will attempt to make a relative path between path and base
@@ -339,7 +343,7 @@ func EscapePath(path string) string {
 func GetLeadingWhitespace(b []byte) []byte {
 	ws := []byte{}
 	for len(b) > 0 {
-		r, size := utf8.DecodeRune(b)
+		r, _, size := DecodeCharacter(b)
 		if r == ' ' || r == '\t' {
 			ws = append(ws, byte(r))
 		} else {
@@ -365,7 +369,7 @@ func GetCharPosInLine(b []byte, visualPos int, tabsize int) int {
 	i := 0     // char pos
 	width := 0 // string visual width
 	for len(b) > 0 {
-		r, size := utf8.DecodeRune(b)
+		r, _, size := DecodeCharacter(b)
 		b = b[size:]
 
 		switch r {
@@ -411,7 +415,11 @@ func Clamp(val, min, max int) int {
 }
 
 func IsNonAlphaNumeric(c rune) bool {
-	return !unicode.IsLetter(c) && !unicode.IsNumber(c)
+	return !unicode.IsLetter(c) && !unicode.IsNumber(c) && c != '_'
+}
+
+func IsAutocomplete(c rune) bool {
+	return c == '.' || !IsNonAlphaNumeric(c)
 }
 
 func ParseSpecial(s string) string {

pkg/highlight/highlighter.go

@@ -3,7 +3,6 @@ package highlight
 import (
 	"regexp"
 	"strings"
-	"unicode/utf8"
 )
 
 func sliceStart(slc []byte, index int) []byte {
@@ -15,7 +14,7 @@ func sliceStart(slc []byte, index int) []byte {
 			return slc[totalSize:]
 		}
 
-		_, size := utf8.DecodeRune(slc[totalSize:])
+		_, _, size := DecodeCharacter(slc[totalSize:])
 		totalSize += size
 		i++
 	}
@@ -32,7 +31,7 @@ func sliceEnd(slc []byte, index int) []byte {
 			return slc[:totalSize]
 		}
 
-		_, size := utf8.DecodeRune(slc[totalSize:])
+		_, _, size := DecodeCharacter(slc[totalSize:])
 		totalSize += size
 		i++
 	}
@@ -47,9 +46,9 @@ func runePos(p int, str []byte) int {
 		return 0
 	}
 	if p >= len(str) {
-		return utf8.RuneCount(str)
+		return CharacterCount(str)
 	}
-	return utf8.RuneCount(str[:p])
+	return CharacterCount(str[:p])
 }
 
 func combineLineMatch(src, dst LineMatch) LineMatch {
@@ -112,7 +111,7 @@ func findIndex(regex *regexp.Regexp, skip *regexp.Regexp, str []byte, canMatchSt
 	var strbytes []byte
 	if skip != nil {
 		strbytes = skip.ReplaceAllFunc(str, func(match []byte) []byte {
-			res := make([]byte, utf8.RuneCount(match))
+			res := make([]byte, CharacterCount(match))
 			return res
 		})
 	} else {
@@ -148,7 +147,7 @@ func findAllIndex(regex *regexp.Regexp, str []byte, canMatchStart, canMatchEnd b
 }
 
 func (h *Highlighter) highlightRegion(highlights LineMatch, start int, canMatchEnd bool, lineNum int, line []byte, curRegion *region, statesOnly bool) LineMatch {
-	lineLen := utf8.RuneCount(line)
+	lineLen := CharacterCount(line)
 	if start == 0 {
 		if !statesOnly {
 			if _, ok := highlights[0]; !ok {
@@ -236,7 +235,7 @@ func (h *Highlighter) highlightRegion(highlights LineMatch, start int, canMatchE
 }
 
 func (h *Highlighter) highlightEmptyRegion(highlights LineMatch, start int, canMatchEnd bool, lineNum int, line []byte, statesOnly bool) LineMatch {
-	lineLen := utf8.RuneCount(line)
+	lineLen := CharacterCount(line)
 	if lineLen == 0 {
 		if canMatchEnd {
 			h.lastRegion = nil
@@ -336,11 +335,11 @@ func (h *Highlighter) HighlightStates(input LineStates) {
 	}
 }
 
-// HighlightMatches sets the matches for each line in between startline and endline
+// HighlightMatches sets the matches for each line from startline to endline
 // It sets all other matches in the buffer to nil to conserve memory
 // This assumes that all the states are set correctly
 func (h *Highlighter) HighlightMatches(input LineStates, startline, endline int) {
-	for i := startline; i < endline; i++ {
+	for i := startline; i <= endline; i++ {
 		if i >= input.LinesNum() {
 			break
 		}

pkg/highlight/unicode.go

@@ -0,0 +1,85 @@
+package highlight
+
+import (
+	"unicode"
+	"unicode/utf8"
+)
+
+var minMark = rune(unicode.Mark.R16[0].Lo)
+
+func isMark(r rune) bool {
+	// Fast path
+	if r < minMark {
+		return false
+	}
+	return unicode.In(r, unicode.Mark)
+}
+
+// DecodeCharacter returns the next character from an array of bytes
+// A character is a rune along with any accompanying combining runes
+func DecodeCharacter(b []byte) (rune, []rune, int) {
+	r, size := utf8.DecodeRune(b)
+	b = b[size:]
+	c, s := utf8.DecodeRune(b)
+
+	var combc []rune
+	for isMark(c) {
+		combc = append(combc, c)
+		size += s
+
+		b = b[s:]
+		c, s = utf8.DecodeRune(b)
+	}
+
+	return r, combc, size
+}
+
+// DecodeCharacterInString returns the next character from a string
+// A character is a rune along with any accompanying combining runes
+func DecodeCharacterInString(str string) (rune, []rune, int) {
+	r, size := utf8.DecodeRuneInString(str)
+	str = str[size:]
+	c, s := utf8.DecodeRuneInString(str)
+
+	var combc []rune
+	for isMark(c) {
+		combc = append(combc, c)
+		size += s
+
+		str = str[s:]
+		c, s = utf8.DecodeRuneInString(str)
+	}
+
+	return r, combc, size
+}
+
+// CharacterCount returns the number of characters in a byte array
+// Similar to utf8.RuneCount but for unicode characters
+func CharacterCount(b []byte) int {
+	s := 0
+
+	for len(b) > 0 {
+		r, size := utf8.DecodeRune(b)
+		if !isMark(r) {
+			s++
+		}
+
+		b = b[size:]
+	}
+
+	return s
+}
+
+// CharacterCount returns the number of characters in a string
+// Similar to utf8.RuneCountInString but for unicode characters
+func CharacterCountInString(str string) int {
+	s := 0
+
+	for _, r := range str {
+		if !isMark(r) {
+			s++
+		}
+	}
+
+	return s
+}

runtime/colorschemes/dukedark-tc.micro

@@ -0,0 +1,34 @@
+color-link color-column "#001e28"
+color-link comment "#608b4e,#001e28"
+color-link constant.bool "#fd971f,#001e28"
+color-link constant "#fd971f,#001e28"
+color-link constant.string "#a0f000,#001e28"
+color-link constant.string.char "#a0f000,#001e28"
+color-link constant.string.url "#a0f000,#001e28"
+color-link current-line-number "bold #fd971f,#001e28"
+color-link cursor-line "#001923"
+color-link default "#ffffff,#001e28"
+color-link diff-added "#00c8a0,#001e28"
+color-link diff-modified "#fd971f,#001e28"
+color-link diff-deleted "#cb4b16,#001e28"
+color-link divider "#001e28,#d0d0d0"
+color-link error "#cb4b16,#001e28"
+color-link gutter-error "#cb4b16,#001e28"
+color-link gutter-warning "#fce94f,#001e28"
+color-link identifier "#00c8a0,#001e28"
+color-link identifier.class "#00c8a0,#001e28"
+color-link indent-char "#a0a0a0,#001e28"
+color-link line-number "#a0a0a0,#001923"
+color-link preproc "bold #5aaae6,#001e28"
+color-link special "#a6e22e,#001e28"
+color-link statement "bold #5aaae6,#001e28"
+color-link statusline "#ffffff,#0078c8"
+color-link symbol "#00c8a0,#001e28"
+color-link symbol.brackets "#ffffff,#001e28"
+color-link symbol.tag "bold #5aaae6,#001e28"
+color-link tabbar "#001e28,#ffffff"
+color-link todo "#fce94f,#001e28"
+color-link type "bold #3cc83c,#001e28"
+color-link type.keyword "bold #5aaae6,#001e28"
+color-link type.extended "#ffffff,#001e28"
+color-link underlined "#608b4e,#001e28"

runtime/colorschemes/dukelight-tc.micro

@@ -0,0 +1,34 @@
+color-link color-column "#f0f0f0"
+color-link comment "#3f7f5f,#f0f0f0"
+color-link constant.bool "#641e00,#f0f0f0"
+color-link constant "#641e00,#f0f0f0"
+color-link constant.string "#0000ff,#f0f0f0"
+color-link constant.string.char "#0000ff,#f0f0f0"
+color-link constant.string.url "#0000ff,#f0f0f0"
+color-link current-line-number "bold #004080,#f0f0f0"
+color-link cursor-line "#e6e6e6"
+color-link default "#000000,#f0f0f0"
+color-link diff-added "#008040,#f0f0f0"
+color-link diff-modified "#641e00,#f0f0f0"
+color-link diff-deleted "#500000,#f0f0f0"
+color-link divider "#f0f0f0,#004080"
+color-link error "#500000,#f0f0f0"
+color-link gutter-error "#500000,#f0f0f0"
+color-link gutter-warning "#dcc800,#f0f0f0"
+color-link identifier "bold #0078a0,#f0f0f0"
+color-link identifier.class "bold #0078a0,#f0f0f0"
+color-link indent-char "#404040,#f0f0f0"
+color-link line-number "#404040,#e6e6e6"
+color-link preproc "bold #780050,#f0f0f0"
+color-link special "bold #0078a0,#f0f0f0"
+color-link statement "bold #780050,#f0f0f0"
+color-link statusline "#ffffff,#0078c8"
+color-link symbol "bold #0078a0,#f0f0f0"
+color-link symbol.brackets "#000000,#f0f0f0"
+color-link symbol.tag "bold #780050,#f0f0f0"
+color-link tabbar "#f0f0f0,#004080"
+color-link todo "#dcc800,#f0f0f0"
+color-link type "bold #004080,#f0f0f0"
+color-link type.keyword "bold #780050,#f0f0f0"
+color-link type.extended "#000000,#f0f0f0"
+color-link underlined "#3f7f5f,#f0f0f0"

runtime/colorschemes/dukeubuntu-tc.micro

@@ -0,0 +1,34 @@
+color-link color-column "#2d0023"
+color-link comment "#886484,#2d0023"
+color-link constant.bool "#fd971f,#2d0023"
+color-link constant "#fd971f,#2d0023"
+color-link constant.string "#a0f000,#2d0023"
+color-link constant.string.char "#a0f000,#2d0023"
+color-link constant.string.url "#a0f000,#2d0023"
+color-link current-line-number "bold #fd971f,#2d0023"
+color-link cursor-line "#230019"
+color-link default "#ffffff,#2d0023"
+color-link diff-added "#00c8a0,#2d0023"
+color-link diff-modified "#fd971f,#2d0023"
+color-link diff-deleted "#cb4b16,#2d0023"
+color-link divider "#2d0023,#d0d0d0"
+color-link error "#cb4b16,#2d0023"
+color-link gutter-error "#cb4b16,#2d0023"
+color-link gutter-warning "#fce94f,#2d0023"
+color-link identifier "#00c8a0,#2d0023"
+color-link identifier.class "#00c8a0,#2d0023"
+color-link indent-char "#a0a0a0,#2d0023"
+color-link line-number "#a0a0a0,#230019"
+color-link preproc "bold #5aaae6,#2d0023"
+color-link special "#a6e22e,#2d0023"
+color-link statement "bold #5aaae6,#2d0023"
+color-link statusline "#ffffff,#0078c8"
+color-link symbol "#00c8a0,#2d0023"
+color-link symbol.brackets "#ffffff,#2d0023"
+color-link symbol.tag "bold #5aaae6,#2d0023"
+color-link tabbar "#2d0023,#ffffff"
+color-link todo "#fce94f,#2d0023"
+color-link type "bold #3cc83c,#2d0023"
+color-link type.keyword "bold #5aaae6,#2d0023"
+color-link type.extended "#ffffff,#2d0023"
+color-link underlined "#886484,#2d0023"

runtime/colorschemes/railscast.micro

@@ -11,7 +11,7 @@ color-link todo "bold #cc7833,#2b2b2b"
 color-link error "bold #cc7833,#2b2b2b"
 color-link gutter-error "#cc7833,#11151C"
 color-link indent-char "#414141,#2b2b2b"
-color-link line-number "#a1a1a1,#353535"
+color-link line-number "#a1a1a1,#232323"
 color-link current-line-number "#e6e1dc,#2b2b2b"
 color-link diff-added "#00AF00"
 color-link diff-modified "#FFAF00"
@@ -19,8 +19,8 @@ color-link diff-deleted "#D70000"
 color-link gutter-warning "#a5c261,#11151C"
 color-link symbol "#edb753,#2b2b2b"
 color-link identifier "#edb753,#2b2b2b"
-color-link statusline "#a1a1a1,#414141"
-color-link tabbar "bold #a1a1a1,#414141"
+color-link statusline "#b1b1b1,#232323"
+color-link tabbar "bold #b1b1b1,#232323"
 color-link cursor-line "#353535"
 color-link color-column "#353535"
 color-link space "underline #e6e1dc,#2b2b2b"

runtime/help/colors.md

@@ -8,7 +8,7 @@ This help page aims to cover two aspects of micro's syntax highlighting engine:
 
 ## Colorschemes
 
-To change your colorscheme, press CtrlE in micro to bring up the command
+To change your colorscheme, press Ctrl-e in micro to bring up the command
 prompt, and type:
 
 ```
@@ -132,7 +132,7 @@ If you would like no foreground you can just use a comma with nothing in front:
 color-link comment ",blue"
 ```
 
-You can also put bold, or underline in front of the color:
+You can also put bold, italic, or underline in front of the color:
 
 ```
 color-link comment "bold red"

runtime/help/commands.md

@@ -1,6 +1,6 @@
 # Command bar
 
-The command bar is opened by pressing CtrlE. It is a single-line buffer,
+The command bar is opened by pressing Ctrl-e. It is a single-line buffer,
 meaning that all keybindings from a normal buffer are supported (as well
 as mouse and selection).
 
@@ -13,7 +13,7 @@ does not look up environment variables.
 # Commands
 
 Micro provides the following commands that can be executed at the command-bar
-by pressing `CtrlE` and entering the command. Arguments are placed in single
+by pressing `Ctrl-e` and entering the command. Arguments are placed in single
 quotes here but these are not necessary when entering the command in micro.
 
 * `bind 'key' 'action'`: creates a keybinding from key to action. See the
@@ -62,6 +62,11 @@ quotes here but these are not necessary when entering the command in micro.
 
 * `tab 'filename'`: opens the given file in a new tab.
 
+* `tabmove '[-+]?n'`: Moves the active tab to another slot. `n` is an integer.
+   If `n` is prefixed with `-` or `+`, then it represents a relative position
+   (e.g. `tabmove +2` moves the tab to the right by `2`). If `n` has no prefix,
+   it represents an absolute position (e.g. `tabmove 2` moves the tab to slot `2`).
+
 * `tabswitch 'tab'`: This command will switch to the specified tab. The `tab`
    can either be a tab number, or a name of a tab.
 
@@ -104,7 +109,7 @@ quotes here but these are not necessary when entering the command in micro.
    is most useful for debugging keybindings.
 
 * `showkey`: Show the action(s) bound to a given key. For example
-   running `> showkey CtrlC` will display `Copy`.
+   running `> showkey Ctrl-c` will display `Copy`.
 
 * `term exec?`: Open a terminal emulator running the given executable. If no
    executable is given, this will open the default shell in the terminal

runtime/help/defaultkeys.md

@@ -11,115 +11,115 @@ can change it!
 
 | Key       | Description of function                                                                           |
 |---------- |-------------------------------------------------------------------------------------------------- |
-| Ctrl+E    | Open a command prompt for running commands (see `> help commands` for a list of valid commands).  |
+| Ctrl-e    | Open a command prompt for running commands (see `> help commands` for a list of valid commands).  |
 | Tab       | In command prompt, it will autocomplete if possible.                                              |
-| Ctrl+B    | Run a shell command (this will close micro while your command executes).                          |
+| Ctrl-b    | Run a shell command (this will close micro while your command executes).                          |
 
 ### Navigation
 
 | Key                         | Description of function                                                                   |
 |---------------------------- |------------------------------------------------------------------------------------------ |
 | Arrows                      | Move the cursor around                                                                    |
-| Shift+arrows                | Move and select text                                                                      |
-| Alt(Ctrl on Mac)+LeftArrow  | Move to the beginning of the current line                                                 |
-| Alt(Ctrl on Mac)+RightArrow | Move to the end of the current line                                                       |
-| Home                        | Move to the beginning of the current line                                                 |
+| Shift-arrows                | Move and select text                                                                      |
+| Alt(Ctrl on Mac)-LeftArrow  | Move to the beginning of the current line                                                 |
+| Alt(Ctrl on Mac)-RightArrow | Move to the end of the current line                                                       |
+| Home                        | Move to the beginning of text on the current line                                                 |
 | End                         | Move to the end of the current line                                                       |
-| Ctrl(Alt on Mac)+LeftArrow  | Move cursor one word left                                                                 |
-| Ctrl(Alt on Mac)+RightArrow | Move cursor one word right                                                                |
-| Alt+{                       | Move cursor to previous empty line, or beginning of document                              |
-| Alt+}                       | Move cursor to next empty line, or end of document                                        |
+| Ctrl(Alt on Mac)-LeftArrow  | Move cursor one word left                                                                 |
+| Ctrl(Alt on Mac)-RightArrow | Move cursor one word right                                                                |
+| Alt-{                       | Move cursor to previous empty line, or beginning of document                              |
+| Alt-}                       | Move cursor to next empty line, or end of document                                        |
 | PageUp                      | Move cursor up one page                                                                   |
 | PageDown                    | Move cursor down one page                                                                 |
-| Ctrl+Home or Ctrl+UpArrow   | Move cursor to start of document                                                          |
-| Ctrl+End or Ctrl+DownArrow  | Move cursor to end of document                                                            |
-| Ctrl+L                      | Jump to a line in the file (prompts with #)                                               |
-| Ctrl+W                      | Cycle between splits in the current tab (use `> vsplit` or `> hsplit` to create a split)  |
+| Ctrl-Home or Ctrl-UpArrow   | Move cursor to start of document                                                          |
+| Ctrl-End or Ctrl-DownArrow  | Move cursor to end of document                                                            |
+| Ctrl-l                      | Jump to a line in the file (prompts with #)                                               |
+| Ctrl-w                      | Cycle between splits in the current tab (use `> vsplit` or `> hsplit` to create a split)  |
 
 ### Tabs
 
 | Key     | Description of function   |
 |-------- |-------------------------  |
-| Ctrl+T  | Open a new tab            |
-| Alt+,   | Previous tab              |
-| Alt+.   | Next tab                  |
+| Ctrl-t  | Open a new tab            |
+| Alt-,   | Previous tab              |
+| Alt-.   | Next tab                  |
 
 ### Find Operations
 
 | Key       | Description of function                   |
 |---------- |------------------------------------------ |
-| Ctrl+F    | Find (opens prompt)                       |
-| Ctrl+N    | Find next instance of current search      |
-| Ctrl+P    | Find previous instance of current search  |
+| Ctrl-f    | Find (opens prompt)                       |
+| Ctrl-n    | Find next instance of current search      |
+| Ctrl-p    | Find previous instance of current search  |
 
 ### File Operations
 
 | Key       | Description of function                                           |
 |---------- |------------------------------------------------------------------ |
-| Ctrl+Q    | Close current file (quits micro if this is the last file open)    |
-| Ctrl+O    | Open a file (prompts for filename)                                |
-| Ctrl+S    | Save current file                                                 |
+| Ctrl-q    | Close current file (quits micro if this is the last file open)    |
+| Ctrl-o    | Open a file (prompts for filename)                                |
+| Ctrl-s    | Save current file                                                 |
 
 ### Text operations
 
 | Key                                 | Description of function                   |
 |------------------------------------ |------------------------------------------ |
-| Ctrl(Alt on Mac)+Shift+RightArrow   | Select word right                         |
-| Ctrl(Alt on Mac)+Shift+LeftArrow    | Select word left                          |
-| Alt(Ctrl on Mac)+Shift+LeftArrow    | Select to start of current line           |
-| Alt(Ctrl on Mac)+Shift+RightArrow   | Select to end of current line             |
-| Shift+Home                          | Select to start of current line           |
-| Shift+End                           | Select to end of current line             |
-| Ctrl+Shift+UpArrow                  | Select to start of file                   |
-| Ctrl+Shift+DownArrow                | Select to end of file                     |
-| Ctrl+X                              | Cut selected text                         |
-| Ctrl+C                              | Copy selected text                        |
-| Ctrl+V                              | Paste                                     |
-| Ctrl+K                              | Cut current line                          |
-| Ctrl+D                              | Duplicate current line                    |
-| Ctrl+Z                              | Undo                                      |
-| Ctrl+Y                              | Redo                                      |
-| Alt+UpArrow                         | Move current line or selected lines up    |
-| Alt+DownArrow                       | Move current line of selected lines down  |
-| Alt+Backspace or Alt+Ctrl+H         | Delete word left                          |
-| Ctrl+A                              | Select all                                |
+| Ctrl(Alt on Mac)-Shift-RightArrow   | Select word right                         |
+| Ctrl(Alt on Mac)-Shift-LeftArrow    | Select word left                          |
+| Alt(Ctrl on Mac)-Shift-LeftArrow    | Select to start of current line           |
+| Alt(Ctrl on Mac)-Shift-RightArrow   | Select to end of current line             |
+| Shift-Home                          | Select to start of current line           |
+| Shift-End                           | Select to end of current line             |
+| Ctrl-Shift-UpArrow                  | Select to start of file                   |
+| Ctrl-Shift-DownArrow                | Select to end of file                     |
+| Ctrl-x                              | Cut selected text                         |
+| Ctrl-c                              | Copy selected text                        |
+| Ctrl-v                              | Paste                                     |
+| Ctrl-k                              | Cut current line                          |
+| Ctrl-d                              | Duplicate current line                    |
+| Ctrl-z                              | Undo                                      |
+| Ctrl-y                              | Redo                                      |
+| Alt-UpArrow                         | Move current line or selected lines up    |
+| Alt-DownArrow                       | Move current line or selected lines down  |
+| Alt-Backspace or Alt-Ctrl-h         | Delete word left                          |
+| Ctrl-a                              | Select all                                |
 
 ### Macros
 
 | Key       | Description of function                                                           |
 |---------- |---------------------------------------------------------------------------------- |
-| Ctrl+U    | Toggle macro recording (press Ctrl+U to start recording and press again to stop)  |
-| Ctrl+J    | Run latest recorded macro                                                         |
+| Ctrl-u    | Toggle macro recording (press Ctrl-u to start recording and press again to stop)  |
+| Ctrl-j    | Run latest recorded macro                                                         |
 
 ### Multiple cursors
 
 | Key               | Description of function                                                                       |
 |------------------ |---------------------------------------------------------------------------------------------- |
-| Alt+N             | Create new multiple cursor from selection (will select current word if no current selection)  |
-| AltShiftUp        | Spawn a new cursor on the line above the current one                                          |
-| AltShiftDown      | Spawn a new cursor on the line below the current one                                          |
-| Alt+P             | Remove latest multiple cursor                                                                 |
-| Alt+C             | Remove all multiple cursors (cancel)                                                          |
-| Alt+X             | Skip multiple cursor selection                                                                |
-| Alt+M             | Spawn a new cursor at the beginning of every line in the current selection                    |
-| Ctrl+MouseLeft    | Place a multiple cursor at any location                                                       |
+| Alt-n             | Create new multiple cursor from selection (will select current word if no current selection)  |
+| Alt-Shift-Up      | Spawn a new cursor on the line above the current one                                          |
+| Alt-Shift-Down    | Spawn a new cursor on the line below the current one                                          |
+| Alt-p             | Remove latest multiple cursor                                                                 |
+| Alt-c             | Remove all multiple cursors (cancel)                                                          |
+| Alt-x             | Skip multiple cursor selection                                                                |
+| Alt-m             | Spawn a new cursor at the beginning of every line in the current selection                    |
+| Ctrl-MouseLeft    | Place a multiple cursor at any location                                                       |
 
 ### Other
 
 | Key       | Description of function                                                               |
 |---------- |-------------------------------------------------------------------------------------- |
-| Ctrl+G    | Open help file                                                                        |
-| Ctrl+H    | Backspace (old terminals do not support the backspace key and use Ctrl+H instead)     |
-| Ctrl+R    | Toggle the line number ruler                                                          |
+| Ctrl-g    | Open help file                                                                        |
+| Ctrl-h    | Backspace (old terminals do not support the backspace key and use Ctrl+H instead)     |
+| Ctrl-r    | Toggle the line number ruler                                                          |
 
 ### Emacs style actions
 
 | Key       | Description of function   |
 |---------- |-------------------------- |
-| Alt+F     | Next word                 |
-| Alt+B     | Previous word             |
-| Alt+A     | Move to start of line     |
-| Alt+E     | Move to end of line       |
+| Alt-f     | Next word                 |
+| Alt-b     | Previous word             |
+| Alt-a     | Move to start of line     |
+| Alt-e     | Move to end of line       |
 
 ### Function keys.
 

runtime/help/help.md

@@ -4,9 +4,9 @@ Micro is a terminal-based text editor that aims to be easy to use and
 intuitive, while also taking advantage of the full capabilities of modern
 terminals.
 
-To open the command bar, press CtrlE. This enables a `>` prompt for typing
+To open the command bar, press Ctrl-e. This enables a `>` prompt for typing
 commands. From now on when the documentation says to run a command such as `>
-help`, this means press CtrlE and type `help` (and press enter to execute the
+help`, this means press Ctrl-e and type `help` (and press enter to execute the
 command).
 
 For a list of the default keybindings run `> help defaultkeys`.
@@ -14,7 +14,7 @@ For more information on keybindings see `> help keybindings`.
 
 ## Quick-start
 
-Press Ctrl-q to quit, and Ctrl-s to save. Press CtrlE to start typing commands
+Press Ctrl-q to quit, and Ctrl-s to save. Press Ctrl-e to start typing commands
 and you can see which commands are available by pressing tab, or by viewing the
 help topic `> help commands`.
 
@@ -34,7 +34,7 @@ Press Ctrl-w to move between splits, and type `> vsplit filename` or
 
 Micro has a built-in help system which can be accessed with the `help` command.
 
-To use it, press CtrlE to access command mode and type in `help` followed by a
+To use it, press Ctrl-e to access command mode and type in `help` followed by a
 topic. Typing `help` followed by nothing will open this page.
 
 Here are the possible help topics that you can read:

runtime/help/keybindings.md

@@ -30,11 +30,17 @@ following in the `bindings.json` file.
 
 ```json
 {
-	"CtrlY": "Undo",
-	"CtrlZ": "Redo"
+	"Ctrl-y": "Undo",
+	"Ctrl-z": "Redo"
 }
 ```
 
+**Note:** The syntax `<Modifier><key>` is equivalent to `<Modifier>-<key>`. In
+addition, Ctrl-Shift bindings are not supported by terminals, and are the same
+as simply Ctrl bindings. This means that `CtrlG`, `Ctrl-G`, and `Ctrl-g` all
+mean the same thing. However, for Alt this is not the case: `AltG` and `Alt-G`
+mean `Alt-Shift-g`, while `Alt-g` does not require the Shift modifier.
+
 In addition to editing your `~/.config/micro/bindings.json`, you can run
 `>bind <keycombo> <action>` For a list of bindable actions, see below.
 
@@ -73,21 +79,27 @@ You can also bind a key to execute a command in command mode (see
 }
 ```
 
+**Note for macOS**: By default, macOS terminals do not forward alt events and
+instead insert unicode characters. To fix this, do the following:
+
+* iTerm2: select `Esc+` for `Left Option Key` in `Preferences->Profiles->Keys`.
+* Terminal.app: Enable `Use Option key as Meta key` in `Preferences->Profiles->Keyboard`.
+
 Now when you press `Alt-p` the `pwd` command will be executed which will show
 your working directory in the infobar.
 
 You can also bind an "editable" command with `command-edit:`. This means that 
 micro won't immediately execute the command when you press the binding, but
 instead just place the string in the infobar in command mode. For example, 
-you could rebind `CtrlG` to `> help`:
+you could rebind `Ctrl-g` to `> help`:
 
 ```json
 {
-    "CtrlG": "command-edit:help "
+    "Ctrl-g": "command-edit:help "
 }
 ```
 
-Now when you press `CtrlG`, `help` will appear in the command bar and your
+Now when you press `Ctrl-g`, `help` will appear in the command bar and your
 cursor will be placed after it (note the space in the json that controls the
 cursor placement).
 
@@ -162,6 +174,8 @@ SelectUp
 SelectDown
 SelectLeft
 SelectRight
+SelectToStartOfText
+SelectToStartOfTextToggle
 WordRight
 WordLeft
 SelectWordRight
@@ -183,11 +197,13 @@ Save
 SaveAll
 SaveAs
 Find
+FindLiteral
 FindNext
 FindPrevious
 Undo
 Redo
 Copy
+CopyLine
 Cut
 CutLine
 DuplicateLine
@@ -209,6 +225,8 @@ HalfPageUp
 HalfPageDown
 StartOfLine
 EndOfLine
+StartOfText
+StartOfTextToggle
 ParagraphPrevious
 ParagraphNext
 ToggleHelp
@@ -245,6 +263,9 @@ JumpToMatchingBrace
 Autocomplete
 ```
 
+The `StartOfTextToggle` and `SelectToStartOfTextToggle` actions toggle between
+jumping to the start of the text (first) and start of the line.
+
 You can also bind some mouse actions (these must be bound to mouse buttons)
 
 ```
@@ -342,32 +363,32 @@ F62
 F63
 F64
 CtrlSpace
-CtrlA
-CtrlB
-CtrlC
-CtrlD
-CtrlE
-CtrlF
-CtrlG
-CtrlH
-CtrlI
-CtrlJ
-CtrlK
-CtrlL
-CtrlM
-CtrlN
-CtrlO
-CtrlP
-CtrlQ
-CtrlR
-CtrlS
-CtrlT
-CtrlU
-CtrlV
-CtrlW
-CtrlX
-CtrlY
-CtrlZ
+Ctrl-a
+Ctrl-b
+Ctrl-c
+Ctrl-d
+Ctrl-e
+Ctrl-f
+Ctrl-g
+Ctrl-h
+Ctrl-i
+Ctrl-j
+Ctrl-k
+Ctrl-l
+Ctrl-m
+Ctrl-n
+Ctrl-o
+Ctrl-p
+Ctrl-q
+Ctrl-r
+Ctrl-s
+Ctrl-t
+Ctrl-u
+Ctrl-v
+Ctrl-w
+Ctrl-x
+Ctrl-y
+Ctrl-z
 CtrlLeftSq
 CtrlBackslash
 CtrlRightSq
@@ -410,21 +431,21 @@ conventions for text editing defaults.
     "ShiftDown":      "SelectDown",
     "ShiftLeft":      "SelectLeft",
     "ShiftRight":     "SelectRight",
-    "AltLeft":        "WordLeft",
-    "AltRight":       "WordRight",
+    "AltLeft":        "WordLeft", (Mac)
+    "AltRight":       "WordRight", (Mac)
     "AltUp":          "MoveLinesUp",
     "AltDown":        "MoveLinesDown",
     "CtrlShiftRight": "SelectWordRight",
     "CtrlShiftLeft":  "SelectWordLeft",
-    "AltLeft":        "StartOfLine",
+    "AltLeft":        "StartOfTextToggle",
     "AltRight":       "EndOfLine",
     "AltShiftRight":  "SelectWordRight", (Mac)
     "AltShiftLeft":   "SelectWordLeft", (Mac)
     "CtrlLeft":       "StartOfText", (Mac)
     "CtrlRight":      "EndOfLine", (Mac)
-    "AltShiftLeft":   "SelectToStartOfLine",
-    "CtrlShiftLeft":  "SelectToStartOfText", (Mac)
-    "ShiftHome":      "SelectToStartOfLine",
+    "AltShiftLeft":   "SelectToStartOfTextToggle",
+    "CtrlShiftLeft":  "SelectToStartOfTextToggle", (Mac)
+    "ShiftHome":      "SelectToStartOfTextToggle",
     "AltShiftRight":  "SelectToEndOfLine",
     "CtrlShiftRight": "SelectToEndOfLine", (Mac)
     "ShiftEnd":       "SelectToEndOfLine",
@@ -435,29 +456,29 @@ conventions for text editing defaults.
     "Alt-{":          "ParagraphPrevious",
     "Alt-}":          "ParagraphNext",
     "Enter":          "InsertNewline",
-    "CtrlH":          "Backspace",
+    "Ctrl-h":          "Backspace",
     "Backspace":      "Backspace",
     "Alt-CtrlH":      "DeleteWordLeft",
     "Alt-Backspace":  "DeleteWordLeft",
     "Tab":            "Autocomplete|IndentSelection|InsertTab",
     "Backtab":        "OutdentSelection|OutdentLine",
-    "CtrlO":          "OpenFile",
-    "CtrlS":          "Save",
-    "CtrlF":          "Find",
-    "CtrlN":          "FindNext",
-    "CtrlP":          "FindPrevious",
-    "CtrlZ":          "Undo",
-    "CtrlY":          "Redo",
-    "CtrlC":          "Copy",
-    "CtrlX":          "Cut",
-    "CtrlK":          "CutLine",
-    "CtrlD":          "DuplicateLine",
-    "CtrlV":          "Paste",
-    "CtrlA":          "SelectAll",
-    "CtrlT":          "AddTab",
-    "Alt,":           "PreviousTab",
-    "Alt.":           "NextTab",
-    "Home":           "StartOfLine",
+    "Ctrl-o":          "OpenFile",
+    "Ctrl-s":          "Save",
+    "Ctrl-f":          "Find",
+    "Ctrl-n":          "FindNext",
+    "Ctrl-p":          "FindPrevious",
+    "Ctrl-z":          "Undo",
+    "Ctrl-y":          "Redo",
+    "Ctrl-c":          "CopyLine|Copy",
+    "Ctrl-x":          "Cut",
+    "Ctrl-k":          "CutLine",
+    "Ctrl-d":          "DuplicateLine",
+    "Ctrl-v":          "Paste",
+    "Ctrl-a":          "SelectAll",
+    "Ctrl-t":          "AddTab",
+    "Alt-,":           "PreviousTab",
+    "Alt-.":           "NextTab",
+    "Home":           "StartOfText",
     "End":            "EndOfLine",
     "CtrlHome":       "CursorStart",
     "CtrlEnd":        "CursorEnd",
@@ -465,17 +486,17 @@ conventions for text editing defaults.
     "PageDown":       "CursorPageDown",
     "CtrlPageUp":     "PreviousTab",
     "CtrlPageDown":   "NextTab",
-    "CtrlG":          "ToggleHelp",
+    "Ctrl-g":          "ToggleHelp",
     "Alt-g":          "ToggleKeyMenu",
-    "CtrlR":          "ToggleRuler",
-    "CtrlL":          "command-edit:goto ",
+    "Ctrl-r":          "ToggleRuler",
+    "Ctrl-l":          "command-edit:goto ",
     "Delete":         "Delete",
-    "CtrlB":          "ShellMode",
-    "CtrlQ":          "Quit",
-    "CtrlE":          "CommandMode",
-    "CtrlW":          "NextSplit",
-    "CtrlU":          "ToggleMacro",
-    "CtrlJ":          "PlayMacro",
+    "Ctrl-b":          "ShellMode",
+    "Ctrl-q":          "Quit",
+    "Ctrl-e":          "CommandMode",
+    "Ctrl-w":          "NextSplit",
+    "Ctrl-u":          "ToggleMacro",
+    "Ctrl-j":          "PlayMacro",
     "Insert":         "ToggleOverwriteMode",
 
     // Emacs-style keybindings
@@ -511,7 +532,7 @@ conventions for text editing defaults.
 
 ## Final notes
 
-Note: On some old terminal emulators and on Windows machines, `CtrlH` should be
+Note: On some old terminal emulators and on Windows machines, `Ctrl-h` should be
 used for backspace.
 
 Additionally, alt keys can be bound by using `Alt-key`. For example `Alt-a` or

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`
 
-* `basename`: in the infobar, show only the basename of the file being edited
-   rather than the full path.
+* `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`
 
@@ -80,14 +85,30 @@ Here are the available options:
 
 	default value: `false`
 
+* `divchars`: specifies the "divider" characters used for the dividing line
+   between vertical/horizontal splits. The first character is for vertical
+   dividers, and the second is for horizontal dividers. By default, for
+   horizontal splits the statusline serves as a divider, but if the statusline
+   is disabled the horizontal divider character will be used.
+
+    default value: `|-`
+
+* `divreverse`: colorschemes provide the color (foreground and background) for
+   the characters displayed in split dividers. With this option enabled, the
+   colors specified by the colorscheme will be reversed (foreground and
+   background colors swapped).
+
+    default value: `true`
+
 * `encoding`: the encoding to open and save files with. Supported encodings
    are listed at https://www.w3.org/TR/encoding/.
 
     default value: `utf-8`
 
-* `eofnewline`: micro will automatically add a newline to the file.
+* `eofnewline`: micro will automatically add a newline to the end of the
+   file if one does not exist.
 
-	default value: `false`
+	default value: `true`
 
 * `fastdirty`: this determines what kind of algorithm micro uses to determine
    if a buffer is modified or not. When `fastdirty` is on, micro just uses a
@@ -101,12 +122,15 @@ Here are the available options:
 	default value: `false`
 
 * `fileformat`: this determines what kind of line endings micro will use for
-   the file. UNIX line endings are just `\n` (linefeed) whereas dos line
+   the file. Unix line endings are just `\n` (linefeed) whereas dos line
    endings are `\r\n` (carriage return + linefeed). The two possible values for
    this option are `unix` and `dos`. The fileformat will be automatically
    detected (when you open an existing file) and displayed on the statusline,
    but this option is useful if you would like to change the line endings or if
-   you are starting a new file.
+   you are starting a new file. Changing this option while editing a file will
+   change its line endings. Opening a file with this option set will only have
+   an effect if the file is empty/newly created, because otherwise the fileformat
+   will be automatically detected from the existing line endings.
 
 	default value: `unix`
 
@@ -162,7 +186,7 @@ Here are the available options:
 
 	default value: `true`
 
-* `paste`: Treat characters sent from the terminal in a single chunk as a paste
+* `paste`: treat characters sent from the terminal in a single chunk as a paste
    event rather than a series of manual key presses. If you are pasting using
    the terminal keybinding (not Ctrl-v, which is micro's default paste
    keybinding) then it is a good idea to enable this option during the paste
@@ -171,6 +195,23 @@ Here are the available options:
 
     default value: `false`
 
+* `parsecursor`: if enabled, this will cause micro to parse filenames such as
+   file.txt:10:5 as requesting to open `file.txt` with the cursor at line 10
+   and column 5. The column number can also be dropped to open the file at a
+   given line and column 0. Note that with this option enabled it is not possible
+   to open a file such as `file.txt:10:5`, where `:10:5` is part of the filename.
+   It is also possible to open a file with a certain cursor location by using the
+   `+LINE,COL` flag syntax. See `micro -help` for the command line 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.
@@ -198,6 +239,12 @@ Here are the available options:
 
 	default value: `true`
 
+* `relativeruler`: make line numbers display relatively. If set to true, all lines except
+	for the line that the cursor is located will display the distance from the 
+	cursor's line. 
+
+	default value: `false` 
+
 * `savecursor`: remember where the cursor was last time the file was opened and
    put it there when you open the file again. Information is saved to
    `~/.config/micro/buffers/`

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/help/tutorial.md

@@ -16,8 +16,8 @@ the settings and their values. To change an option, you can either change the
 value in the `settings.json` file, or you can type it in directly while using
 micro.
 
-Press CtrlE to go to command mode, and type `set option value` (in the
-future, I will use `> set option value` to indicate pressing CtrlE). The change
+Press Ctrl-e to go to command mode, and type `set option value` (in the
+future, I will use `> set option value` to indicate pressing Ctrl-e). The change
 will take effect immediately and will also be saved to the `settings.json` file
 so that the setting will stick even after you close micro.
 
@@ -48,12 +48,12 @@ If you would like to know more about all the available options, see the
 Keybindings work in much the same way as options. You configure them using the
 `~/.config/micro/bindings.json` file.
 
-For example if you would like to bind `CtrlR` to redo you could put the
+For example if you would like to bind `Ctrl-r` to redo you could put the
 following in `bindings.json`:
 
 ```json
 {
-    "CtrlR": "redo"
+    "Ctrl-r": "redo"
 }
 ```
 
@@ -74,7 +74,7 @@ micro starts and is essentially a one-file plugin. The plugin name is
 `initlua`.
 
 This example will show you how to use the `init.lua` file by creating a binding
-to `CtrlR` which will execute the bash command `go run` on the current file,
+to `Ctrl-r` which will execute the bash command `go run` on the current file,
 given that the current file is a Go file.
 
 You can do that by putting the following in `init.lua`:
@@ -84,9 +84,9 @@ local config = import("micro/config")
 local shell = import("micro/shell")
 
 function init()
-    -- true means overwrite any existing binding to CtrlR
+    -- true means overwrite any existing binding to Ctrl-r
     -- this will modify the bindings.json file
-    config.TryBindKey("CtrlR", "lua:initlua.gorun", true)
+    config.TryBindKey("Ctrl-r", "lua:initlua.gorun", true)
 end
 
 function gorun(bp)
@@ -104,7 +104,7 @@ the `bindings.json` file:
 
 ```json
 {
-    "CtrlR": "lua:initlua.gorun"
+    "Ctrl-r": "lua:initlua.gorun"
 }
 ```
 

runtime/plugins/autoclose/autoclose.lua

@@ -28,7 +28,7 @@ function onRune(bp, r)
         if r == charAt(autoclosePairs[i], 1) then
             local curLine = bp.Buf:Line(bp.Cursor.Y)
 
-            if bp.Cursor.X == utf8.RuneCountInString(curLine) or not uutil.IsWordChar(charAt(curLine, bp.Cursor.X+1)) then
+            if bp.Cursor.X == uutil.CharacterCountInString(curLine) or not uutil.IsWordChar(charAt(curLine, bp.Cursor.X+1)) then
                 -- the '-' here is to derefence the pointer to bp.Cursor.Loc which is automatically made
                 -- when converting go structs to lua
                 -- It needs to be dereferenced because the function expects a non pointer struct

runtime/plugins/comment/comment.lua

@@ -6,23 +6,58 @@ local buffer = import("micro/buffer")
 
 local ft = {}
 
+ft["apacheconf"] = "# %s"
+ft["bat"] = ":: %s"
 ft["c"] = "// %s"
 ft["c++"] = "// %s"
+ft["cmake"] = "# %s"
+ft["conf"] = "# %s"
+ft["crystal"] = "# %s"
+ft["css"] = "/* %s */"
+ft["d"] = "// %s"
+ft["dart"] = "// %s"
+ft["dockerfile"] = "# %s"
+ft["elm"] = "-- %s"
+ft["fish"] = "# %s"
+ft["gdscript"] = "# %s"
+ft["glsl"] = "// %s"
 ft["go"] = "// %s"
-ft["python"] = "# %s"
-ft["python3"] = "# %s"
+ft["haskell"] = "-- %s"
 ft["html"] = "<!-- %s -->"
+ft["ini"] = "; %s"
 ft["java"] = "// %s"
+ft["javascript"] = "// %s"
+ft["jinja2"] = "{# %s #}"
 ft["julia"] = "# %s"
+ft["kotlin"] = "// %s"
+ft["lua"] = "-- %s"
+ft["markdown"] = "<!-- %s -->"
+ft["nginx"] = "# %s"
+ft["nim"] = "# %s"
+ft["objc"] = "// %s"
+ft["pascal"] = "{ %s }"
 ft["perl"] = "# %s"
 ft["php"] = "// %s"
-ft["rust"] = "// %s"
-ft["shell"] = "# %s"
-ft["lua"] = "-- %s"
-ft["javascript"] = "// %s"
+ft["pony"] = "// %s"
+ft["powershell"] = "# %s"
+ft["proto"] = "// %s"
+ft["python"] = "# %s"
+ft["python3"] = "# %s"
 ft["ruby"] = "# %s"
-ft["d"] = "// %s"
+ft["rust"] = "// %s"
+ft["scala"] = "// %s"
+ft["shell"] = "# %s"
+ft["sql"] = "-- %s"
 ft["swift"] = "// %s"
+ft["tex"] = "% %s"
+ft["toml"] = "# %s"
+ft["twig"] = "{# %s #}"
+ft["v"] = "// %s"
+ft["xml"] = "<!-- %s -->"
+ft["yaml"] = "# %s"
+ft["zig"] = "// %s"
+ft["zscript"] = "// %s"
+ft["zsh"] = "# %s"
 
 function onBufferOpen(buf)
     if buf.Settings["commenttype"] == nil then
@@ -37,7 +72,7 @@ end
 function commentLine(bp, lineN)
     local line = bp.Buf:Line(lineN)
     local commentType = bp.Buf.Settings["commenttype"]
-    local commentRegex = "^%s*" .. commentType:gsub("%*", "%*"):gsub("%-", "%-"):gsub("%.", "%."):gsub("%+", "%+"):gsub("%]", "%]"):gsub("%[", "%["):gsub("%%s", "(.*)")
+    local commentRegex = "^%s*" .. commentType:gsub("%%","%%%%"):gsub("%$","%$"):gsub("%)","%)"):gsub("%(","%("):gsub("%?","%?"):gsub("%*", "%*"):gsub("%-", "%-"):gsub("%.", "%."):gsub("%+", "%+"):gsub("%]", "%]"):gsub("%[", "%["):gsub("%%%%s", "(.*)")
     local sel = -bp.Cursor.CurSelection
     local curpos = -bp.Cursor.Loc
     local index = string.find(commentType, "%%s") - 1
@@ -97,7 +132,8 @@ function comment(bp, args)
 end
 
 function trim(s)
-    return (s:gsub("^%s*(.-)%s*$", "%1"))
+    local trimmed = s:gsub("^%s*(.-)%s*$", "%1"):gsub("%%","%%%%")
+    return trimmed
 end
 
 function string.starts(String,Start)
@@ -107,5 +143,6 @@ end
 function init()
     config.MakeCommand("comment", comment, config.NoComplete)
     config.TryBindKey("Alt-/", "lua:comment.comment", false)
+    config.TryBindKey("CtrlUnderscore", "lua:comment.comment", false)
     config.AddRuntimeFile("comment", config.RTHelp, "help/comment.md")
 end

runtime/plugins/comment/help/comment.md

@@ -1,8 +1,10 @@
 # Comment Plugin
 
 The comment plugin provides auto commenting/uncommenting.
-The default binding to comment/uncomment a line is `Alt-/`,
-but you can easily modify that in your `bindings.json` file:
+The default binding to comment/uncomment a line is `Alt-/`
+and `CtrlUnderscore`, which is equivalent in most terminals
+to `Ctrl-/`. You can easily modify that in your `bindings.json`
+file:
 
 ```json
 {
@@ -23,23 +25,58 @@ selected.
 The comment type will be auto detected based on the filetype,
 but it is only available for certain filetypes:
 
+* apacheconf: `# %s`
+* bat: `:: %s`
 * c: `// %s`
 * c++: `// %s`
+* cmake: `# %s`
+* conf: `# %s`
+* crystal: `# %s`
+* css: `/* %s */`
 * d: `// %s`
+* dart: `// %s`
+* dockerfile: `# %s`
+* elm: `-- %s`
+* fish: `# %s`
+* gdscript: `# %s`
+* glsl: `// %s`
 * go: `// %s`
+* haskell: `-- %s`
 * html: `<!-- %s -->`
+* ini: `; %s`
 * java: `// %s`
 * javascript: `// %s`
+* jinja2: `{# %s #}`
 * julia: `# %s`
+* kotlin: `// %s`
 * lua: `-- %s`
+* markdown: `<!-- %s -->`
+* nginx: `# %s`
+* nim: `# %s`
+* objc: `// %s`
+* pascal: `{ %s }`
 * perl: `# %s`
 * php: `// %s`
+* pony: `// %s`
+* powershell: `# %s`
+* proto: `// %s`
 * python: `# %s`
 * python3: `# %s`
 * ruby: `# %s`
 * rust: `// %s`
+* scala: `// %s`
 * shell: `# %s`
+* sql: `-- %s`
 * swift: `// %s`
+* tex: `% %s`
+* toml: `# %s`
+* twig: `{# %s #}`
+* v: `// %s`
+* xml: `<!-- %s -->`
+* yaml: `# %s`
+* zig: `// %s`
+* zscript: `// %s`
+* zsh: `# %s`
 
 If your filetype is not available here, you can simply modify
 the `commenttype` option:
@@ -57,4 +94,3 @@ Or in your `settings.json`:
     }
 }
 ```
-

runtime/plugins/linter/linter.lua

@@ -6,6 +6,8 @@ local filepath = import("path/filepath")
 local shell = import("micro/shell")
 local buffer = import("micro/buffer")
 local config = import("micro/config")
+local util = import("micro/util")
+local os = import("os")
 
 local linters = {}
 
@@ -64,10 +66,11 @@ function init()
     end
 
     makeLinter("gcc", "c", "gcc", {"-fsyntax-only", "-Wall", "-Wextra", "%f"}, "%f:%l:%c:.+: %m")
-    makeLinter("gcc", "c++", "gcc", {"-fsyntax-only","-std=c++14", "-Wall", "-Wextra", "%f"}, "%f:%l:%c:.+: %m")
+    makeLinter("g++", "c++", "gcc", {"-fsyntax-only","-std=c++14", "-Wall", "-Wextra", "%f"}, "%f:%l:%c:.+: %m")
     makeLinter("dmd", "d", "dmd", {"-color=off", "-o-", "-w", "-wi", "-c", "%f"}, "%f%(%l%):.+: %m")
-    makeLinter("gobuild", "go", "go", {"build", "-o", devnull}, "%f:%l:%c:? %m")
+    makeLinter("gobuild", "go", "go", {"build", "-o", devnull, "%d"}, "%f:%l:%c:? %m")
     -- makeLinter("golint", "go", "golint", {"%f"}, "%f:%l:%c: %m")
+    makeLinter("hlint", "haskell", "hlint", {"%f"}, "%f:%l:%c.-: %m")
     makeLinter("javac", "java", "javac", {"-d", "%d", "%f"}, "%f:%l: error: %m")
     makeLinter("jshint", "javascript", "jshint", {"%f"}, "%f: line %l,.+, %m")
     makeLinter("literate", "literate", "lit", {"-c", "%f"}, "%f:%l:%m", {}, false, true)
@@ -102,7 +105,7 @@ end
 function runLinter(buf)
     local ft = buf:FileType()
     local file = buf.Path
-    local dir = filepath.Dir(file)
+    local dir = "." .. util.RuneStr(os.PathSeparator) .. filepath.Dir(file)
 
     for k, v in pairs(linters) do
         local ftmatch = ft == v.filetype

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/c++.yaml

@@ -1,28 +0,0 @@
-filetype: c++
-
-detect: 
-    filename: "\\.c(c|pp|xx)$|\\.h(h|pp|xx)$|\\.ii?$|\\.(def)$"
-
-rules:
-    - identifier: "\\b[A-Z_][0-9A-Z_]+\\b"
-    - type: "\\b(auto|float|double|bool|char|int|short|long|sizeof|enum|void|static|const|constexpr|struct|union|typedef|extern|(un)?signed|inline)\\b"
-    - type: "\\b((s?size)|((u_?)?int(8|16|32|64|ptr)))_t\\b"
-    - statement: "\\b(class|namespace|template|public|protected|private|typename|this|friend|virtual|using|mutable|volatile|register|explicit)\\b"
-    - statement: "\\b(for|if|while|do|else|case|default|switch)\\b"
-    - statement: "\\b(try|throw|catch|operator|new|delete)\\b"
-    - special: "\\b(goto|continue|break|return)\\b"
-    - preproc: "^[[:space:]]*#[[:space:]]*(define|pragma|include|(un|ifn?)def|endif|el(if|se)|if|warning|error)"
-    - constant: "'([^'\\\\]|(\\\\[\"'abfnrtv\\\\]))'|'\\\\(([0-3]?[0-7]{1,2}))'|'\\\\x[0-9A-Fa-f]{1,2}'"
-    - statement: "__attribute__[[:space:]]*\\(\\([^)]*\\)\\)|__(aligned|asm|builtin|hidden|inline|packed|restrict|section|typeof|weak)__"
-    - symbol.operator: "[.:;,+*|=!\\%]|<|>|/|-|&"
-    - symbol.brackets: "[(){}]|\\[|\\]"
-    - constant.number: "\\b[0-9]+\\b|\\b0x[0-9A-Fa-f]+\\b"
-    - constant.bool: "\\b(true|false)\\b|NULL"
-    - constant.string: "\"(\\\\.|[^\"])*\""
-    - comment: "//.*"
-    - comment:
-        start: "/\\*"
-        end: "\\*/"
-        rules: []
-
-    - indent-char.whitespace: "[[:space:]]+$"

runtime/syntax/coffeescript.yaml

@@ -12,6 +12,9 @@ rules:
     - statement:  "\\b(debugger|switch|while|do|class|extends|super)\\b"
     - statement:  "\\b(undefined|then|unless|until|loop|of|by|when)\\b"
     - constant.bool:  "\\b(true|false|yes|no|on|off)\\b"
+    - constant.number: "\\b[-+]?([1-9][0-9]*|0[0-7]*|0x[0-9a-fA-F]+)([uU][lL]?|[lL][uU]?)?\\b"
+    - constant.number: "\\b[-+]?([0-9]+\\.[0-9]*|[0-9]*\\.[0-9]+)([EePp][+-]?[0-9]+)?[fFlL]?"
+    - constant.number: "\\b[-+]?([0-9]+[EePp][+-]?[0-9]+)[fFlL]?"
     - identifier: "@[A-Za-z0-9_]*"
 
     - constant.string:
@@ -20,10 +23,23 @@ rules:
         skip: "\\\\."
         rules:
             - constant.specialChar: "\\\\."
+     
+    - constant.string:
+        start: "'"
+        end: "'"
+        skip: "\\\\."
+        rules:
+            - constant.specialChar: "\\\\."
+      
 
     - comment:
         start: "#"
         end: "$"
         rules:
             - todo: "(TODO|XXX|FIXME):?"
+    - comment:
+        start: "###"
+        end: "###"
+        rules:  
+            - todo: "(TODO|XXX|FIXME)"
 

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: "(\\{|\\}|\\(|\\)|\\;|\\]|\\[|`|\\\\|\\$|<|>|^|!|=|&|\\|)"

runtime/syntax/csx.yaml

@@ -0,0 +1,8 @@
+filetype: csharp-script
+detect:
+    filename: "\\.csx$"
+    header: "^#!.*/(env +)?dotnet-script( |$)"
+    
+rules:
+    - include: "csharp"
+    - preproc: "\\B(\\#!|\\#[r|load|]+\\b)"

runtime/syntax/git-commit.yaml

@@ -26,7 +26,7 @@ rules:
 
     # Diffs (i.e. git commit --verbose)
     - default:
-        start: "^diff"
+        start: "^diff --git"
         # Diff output puts a space before file contents on each line so this
         # should never match valid diff output and extend highlighting to the
         # end of the file

runtime/syntax/julia.yaml

@@ -8,13 +8,14 @@ rules:
 
     # built-in objects
     - constant.bool: "\\b(true|false)\\b"
+    - constant: "\\b(nothing|missing)\\b"
       # built-in attributes
     - constant: "__[A-Za-z0-9_]+__"
       # definitions
     - identifier: "[A-Za-z_][A-Za-z0-9_]*[[:space:]]*[(]"
       # keywords
     - statement: "\\b(baremodule|begin|break|catch|const|continue|do|else|elseif|end|export|finally|for|function|global|if|import|let|local|macro|module|quote|return|struct|try|using|while)\\b"
-    - statement: "\\b(abstract type|primitive type|mutable struct\\b)"
+    - statement: "\\b(abstract\\s+type|primitive\\s+type|mutable\\s+struct)\\b"
       # decorators
     - identifier.macro: "@[A-Za-z0-9_]+"
       # operators
@@ -22,7 +23,7 @@ rules:
       # parentheses
     - symbol.brackets: "([(){}]|\\[|\\])"
       # numbers
-    - constant.number: "\\b([0-9]+(_[0-9]+)*|0x[0-9a-fA-F]+(_[0-9a-fA-F]+)*|0b[01]+(_[01]+)*|0o[0-7]+(_[0-7]+)*)\\b"
+    - constant.number: "\\b([0-9]+(_[0-9]+)*|0x[0-9a-fA-F]+(_[0-9a-fA-F]+)*|0b[01]+(_[01]+)*|0o[0-7]+(_[0-7]+)*|Inf(16|32|64)?|NaN(16|32|64)?)\\b"
 
     - constant.string: "\"(\\\\.|[^\"])*\"|'(\\\\.|[^']){1}'"
 

runtime/syntax/python2.yaml

@@ -1,8 +1,8 @@
-filetype: python
+filetype: python2
 
 detect:
-    filename: "\\.py$"
-    header: "^#!.*/(env +)?python( |$)"
+    filename: "\\.py2$"
+    header: "^#!.*/(env +)?python2$"
 
 rules:
 

runtime/syntax/python3.yaml

@@ -1,8 +1,8 @@
-filename: python3
+filetype: python
 
 detect:
-    filename: "\\.py3$"
-    header: "^#!.*/(env +)?python3$"
+    filename: "\\.py(3)?$"
+    header: "^#!.*/(env +)?python(3)?$"
 
 rules:
     # built-in objects
@@ -18,7 +18,7 @@ rules:
       # definitions
     - identifier: "def [a-zA-Z_0-9]+"
       # keywords
-    - statement: "\\b(and|as|assert|await|break|class|continue|def|del|elif|else|except|finally|for|from|global|if|import|in|is|lambda|nonlocal|not|or|pass|raise|return|try|while|with|yield)\\b"
+    - statement: "\\b(and|as|assert|async|await|break|class|continue|def|del|elif|else|except|finally|for|from|global|if|import|in|is|lambda|nonlocal|not|or|pass|raise|return|try|while|with|yield)\\b"
       # decorators
     - brightgreen: "@.*[(]"
       # operators

runtime/syntax/ruby.yaml

@@ -1,7 +1,7 @@
 filetype: ruby
 
 detect: 
-    filename: "\\.(rb|rake|gemspec)$|^(Gemfile|config.ru|Rakefile|Capfile|Vagrantfile|Guardfile)$"
+    filename: "\\.(rb|rake|gemspec)$|^(Gemfile|config.ru|Rakefile|Capfile|Vagrantfile|Guardfile|Appfile|Fastfile|Pluginfile|Podfile)$"
     header: "^#!.*/(env +)?ruby( |$)"
 
 rules:

runtime/syntax/sage.yaml

@@ -0,0 +1,60 @@
+filetype: sage
+
+detect:
+    filename: "\\.sage$"
+    header: "^#!.*/(env +)?sage( |$)"
+
+rules:
+
+    # built-in objects
+    - constant: "\\b(None|self|True|False)\\b"
+      # built-in attributes
+    - constant: "\\b(__bases__|__builtin__|__class__|__debug__|__dict__|__doc__|__file__|__members__|__methods__|__name__|__self__)\\b"
+      # built-in functions
+    - identifier: "\\b(abs|apply|callable|chr|cmp|compile|delattr|dir|divmod|eval|exec|execfile|filter|format|getattr|globals|hasattr|hash|help|hex|id|input|intern|isinstance|issubclass|len|locals|max|min|next|oct|open|ord|pow|range|raw_input|reduce|reload|repr|round|setattr|unichr|vars|zip|__import__)\\b"
+      # special method names
+    - identifier: "\\b(__abs__|__add__|__and__|__call__|__cmp__|__coerce__|__complex__|__concat__|__contains__|__del__|__delattr__|__delitem__|__dict__|__delslice__|__div__|__divmod__|__float__|__getattr__|__getitem__|__getslice__|__hash__|__hex__|__init__|__int__|__inv__|__invert__|__len__|__long__|__lshift__|__mod__|__mul__|__neg__|__nonzero__|__oct__|__or__|__pos__|__pow__|__radd__|__rand__|__rcmp__|__rdiv__|__rdivmod__|__repeat__|__repr__|__rlshift__|__rmod__|__rmul__|__ror__|__rpow__|__rrshift__|__rshift__|__rsub__|__rxor__|__setattr__|__setitem__|__setslice__|__str__|__sub__|__xor__)\\b"
+      # types
+    - type: "\\b(basestring|bool|buffer|bytearray|bytes|classmethod|complex|dict|enumerate|file|float|frozenset|int|list|long|map|memoryview|object|property|reversed|set|slice|staticmethod|str|super|tuple|type|unicode|xrange)\\b"
+      # definitions
+    - identifier: "def [a-zA-Z_0-9]+"
+      # keywords
+    - statement: "\\b(and|as|assert|break|class|continue|def|del|elif|else|except|finally|for|from|global|if|import|in|is|lambda|not|or|pass|print|raise|return|try|while|with|yield)\\b"
+      # decorators
+    - brightgreen: "@.*[(]"
+      # operators
+    - statement: "([.:;,+*|=!\\%@]|<|>|/|-|&)"
+      # parentheses
+    - statement: "([(){}]|\\[|\\])"
+      # numbers
+    - constant.number: "\\b[0-9]+\\b"
+
+    - comment:
+        start: "\"\"\""
+        end: "\"\"\""
+        rules: []
+
+    - comment:
+        start: "'''"
+        end: "'''"
+        rules: []
+
+    - constant.string:
+        start: "\""
+        end: "\""
+        skip: "\\\\."
+        rules:
+            - constant.specialChar: "\\\\."
+
+    - constant.string:
+        start: "'"
+        end: "'"
+        skip: "\\\\."
+        rules:
+            - constant.specialChar: "\\\\."
+
+    - comment:
+        start: "#"
+        end: "$"
+        rules: []
+

runtime/syntax/sh.yaml

@@ -1,8 +1,8 @@
 filetype: shell
 
 detect:
-    filename: "(\\.sh$|\\.bash|\\.ash|\\.bashrc|bashrc|\\.bash_aliases|bash_aliases|\\.bash_functions|bash_functions|\\.bash_profile|bash_profile|\\.profile|profile|Pkgfile|pkgmk.conf|profile|rc.conf|PKGBUILD|.ebuild\\$|APKBUILD)"
-    header: "^#!.*/(env +)?(ba)?(a)?sh( |$)"
+    filename: "(\\.sh$|\\.bash|\\.ash|bashrc|bash_aliases|bash_functions|profile|bash-fc\\.|Pkgfile|pkgmk.conf|rc.conf|PKGBUILD|.ebuild\\$|APKBUILD)"
+    header: "^#!.*/(env +)?(ba)?(a)?(mk)?sh( |$)"
 
 rules:
     # Numbers

runtime/syntax/toml.yaml

@@ -4,39 +4,53 @@ detect:
     filename: "\\.toml"
 
 rules:
-    - statement: "(.*)[[:space:]]="
-    - special: "="
-
-      # Bracket thingies
-    - special: "(\\[|\\])"
-
-      # Numbers and strings
-    - constant.number: "\\b([0-9]+|0x[0-9a-fA-F]*)\\b|'.'"
-    - constant.number: "\\\\([0-7]{3}|x[A-Fa-f0-9]{2}|u[A-Fa-f0-9]{4}|U[A-Fa-f0-9]{8})"
-
+    # Punctuation
+    - symbol: '[=,\.]'
+    - symbol.brackets: '[{\[\]}]'
+    # Strings
     - constant.string:
-        start: "\""
-        end: "\""
-        skip: "\\\\."
+        start: '"""'
+        end: '\"{3,5}'
+        skip: '\\.'
         rules:
-            - constant.specialChar: "\\\\."
-
+            - constant.specialChar: '\\u[[:xdigit:]]{4}'
+            - constant.specialChar: '\\U[[:xdigit:]]{8}'
+            - constant.specialChar: '\\[btnfr"\\]'
+    - constant.string:
+        start: '"'
+        end: '"'
+        skip: '\\.'
+        rules:
+            - constant.specialChar: '\\u[[:xdigit:]]{4}'
+            - constant.specialChar: '\\U[[:xdigit:]]{8}'
+            - constant.specialChar: '\\[btnfr"\\]'
+    - constant.string:
+        start: "'''"
+        end: "'{3,5}"
+        rules: []
     - constant.string:
         start: "'"
         end: "'"
-        skip: "\\\\."
-        rules:
-            - constant.specialChar: "\\\\."
-
-    - constant.string:
-        start: "`"
-        end: "`"
-        rules:
-            - constant.specialChar: "\\\\."
-
+        rules: []
+    # Integer
+    - constant.number: '[+-]?(\d+_)*\d+\b'
+    - constant.number: '(0x([[:xdigit:]]+_)*[[:xdigit:]]+|0o([0-7]_)*[0-7]+|0b([01]+_)*[01]+)'
+    # Float
+    - constant.number: '[+-]?(\d+_)*\d+\.(\d+_)*\d+'
+    - constant.number: '[+-]?(\d+_)*\d+(\.(\d+_)*\d+)?[Ee][+-]?(\d+_)*\d+'
+    - constant.number: '(\+|-)(inf|nan)'
+    # Bare key, keys starting with a digit or dash are ambiguous with numbers and are skipped
+    - identifier: '\b[A-Za-z_][A-Za-z0-9_-]*\b'
+    # Boolean and inf, nan without sign
+    - constant.bool.true: '\btrue\b'
+    - constant.bool.false: '\bfalse\b'
+    - constant.number: '\b(inf|nan)\b'
+    # Date and Time
+    - constant: '\d+-\d{2}-\d{2}([T ]\d{2}:\d{2}:\d{2}(\.\d+)?([+-]\d{2}:\d{2}|Z)?)?'
+    - constant: '\d{2}:\d{2}:\d{2}(\.\d+)?'
+    # Comments
     - comment:
         start: "#"
         end: "$"
         rules:
             - todo: "(TODO|XXX|FIXME):?"
-

tools/build-version.go

@@ -53,7 +53,7 @@ func main() {
 	}
 
 	// If we don't have any tag assume "dev"
-	if tag == "" {
+	if tag == "" || strings.HasPrefix(tag, "nightly") {
 		tag = "dev"
 	}
 	// Get the most likely next version:

tools/nightly-release.sh

@@ -1,161 +1,43 @@
 # This script creates the nightly release on Github for micro
-# You must have the correct Github access token to run this script
+# Must be run from inside the micro git repository
 
-commitID=$(git rev-parse HEAD)
-info=$(github-release info -u zyedidia -r micro -t nightly)
+commitID=$(git rev-parse --short HEAD)
+# info=$(github-release info -u zyedidia -r micro -t nightly)
 
-if [[ $info = *$commitID* ]]; then
-    echo "No new commits since last nightly"
-    exit 1
-fi
+# if [[ $info = *$commitID* ]]; then
+#     echo "No new commits since last nightly"
+#     exit 1
+# fi
 
-echo "Deleting old release"
-github-release delete \
-    --user zyedidia \
-    --repo micro \
-    --tag nightly
+go run remove-nightly-assets.go
 
-echo "Moving tag"
-git tag --force nightly $commitID
-git push --force --tags
-
-echo "Creating new release"
-github-release release \
-    --user zyedidia \
-    --repo micro \
-    --tag nightly \
-    --name "Nightly build" \
-    --description "Autogenerated nightly build of micro. If you don't see anything here that probably means it's building right now!" \
-    --pre-release
+# echo "Moving tag"
+# hub push origin :refs/tags/nightly
+# git tag -f nightly $commitID
+# hub push --tags
 
 echo "Cross compiling binaries"
 ./cross-compile.sh $1
 mv ../binaries .
 
-echo "Uploading OSX binary"
-github-release upload \
-    --user zyedidia \
-    --repo micro \
-    --tag nightly \
-    --name "micro-$1-osx.tar.gz" \
-    --file binaries/micro-$1-osx.tar.gz
+MESSAGE=$'Nightly build\n\nAutogenerated nightly build of micro'
 
-echo "Uploading Linux 64 binary"
-github-release upload \
-    --user zyedidia \
-    --repo micro \
-    --tag nightly \
-    --name "micro-$1-linux64.tar.gz" \
-    --file binaries/micro-$1-linux64.tar.gz
-
-echo "Uploading Linux 64 static binary"
-github-release upload \
-    --user zyedidia \
-    --repo micro \
-    --tag nightly \
-    --name "micro-$1-linux64-static.tar.gz" \
-    --file binaries/micro-$1-linux64-static.tar.gz
-
-echo "Uploading Linux 32 binary"
-github-release upload \
-    --user zyedidia \
-    --repo micro \
-    --tag nightly \
-    --name "micro-$1-linux32.tar.gz" \
-    --file binaries/micro-$1-linux32.tar.gz
-
-echo "Uploading Linux Arm 32 binary"
-github-release upload \
-    --user zyedidia \
-    --repo micro \
-    --tag nightly \
-    --name "micro-$1-linux-arm.tar.gz" \
-    --file binaries/micro-$1-linux-arm.tar.gz
-
-echo "Uploading Linux Arm 64 binary"
-github-release upload \
-    --user zyedidia \
-    --repo micro \
-    --tag nightly \
-    --name "micro-$1-linux-arm64.tar.gz" \
-    --file binaries/micro-$1-linux-arm64.tar.gz
-
-echo "Uploading FreeBSD 64 binary"
-github-release upload \
-    --user zyedidia \
-    --repo micro \
-    --tag nightly \
-    --name "micro-$1-freebsd64.tar.gz" \
-    --file binaries/micro-$1-freebsd64.tar.gz
-
-echo "Uploading FreeBSD 32 binary"
-github-release upload \
-    --user zyedidia \
-    --repo micro \
-    --tag nightly \
-    --name "micro-$1-freebsd32.tar.gz" \
-    --file binaries/micro-$1-freebsd32.tar.gz
-
-echo "Uploading OpenBSD 64 binary"
-github-release upload \
-    --user zyedidia \
-    --repo micro \
-    --tag nightly \
-    --name "micro-$1-openbsd64.tar.gz" \
-    --file binaries/micro-$1-openbsd64.tar.gz
-
-echo "Uploading OpenBSD 32 binary"
-github-release upload \
-    --user zyedidia \
-    --repo micro \
-    --tag nightly \
-    --name "micro-$1-openbsd32.tar.gz" \
-    --file binaries/micro-$1-openbsd32.tar.gz
-
-echo "Uploading NetBSD 64 binary"
-github-release upload \
-    --user zyedidia \
-    --repo micro \
-    --tag nightly \
-    --name "micro-$1-netbsd64.tar.gz" \
-    --file binaries/micro-$1-netbsd64.tar.gz
-
-echo "Uploading NetBSD 32 binary"
-github-release upload \
-    --user zyedidia \
-    --repo micro \
-    --tag nightly \
-    --name "micro-$1-netbsd32.tar.gz" \
-    --file binaries/micro-$1-netbsd32.tar.gz
-
-echo "Uploading Windows 64 binary"
-github-release upload \
-    --user zyedidia \
-    --repo micro \
-    --tag nightly \
-    --name "micro-$1-win64.zip" \
-    --file binaries/micro-$1-win64.zip
-
-echo "Uploading Windows 32 binary"
-github-release upload \
-    --user zyedidia \
-    --repo micro \
-    --tag nightly \
-    --name "micro-$1-win32.zip" \
-    --file binaries/micro-$1-win32.zip
-
-# echo "Uploading vendored tarball"
-# github-release upload \
-#     --user zyedidia \
-#     --repo micro \
-#     --tag nightly \
-#     --name "micro-$1-src.tar.gz" \
-#     --file binaries/micro-$1-src.tar.gz
-#
-# echo "Uploading vendored zip"
-# github-release upload \
-#     --user zyedidia \
-#     --repo micro \
-#     --tag nightly \
-#     --name "micro-$1-src.zip" \
-#     --file binaries/micro-$1-src.zip
+echo "Creating new release"
+hub release edit nightly \
+    --prerelease \
+    --draft=false \
+    --message "$MESSAGE. Assets uploaded on $(date) for commit $commitID." \
+    --attach "binaries/micro-$1-osx.tar.gz" \
+    --attach "binaries/micro-$1-linux64.tar.gz" \
+    --attach "binaries/micro-$1-linux64-static.tar.gz" \
+    --attach "binaries/micro-$1-linux32.tar.gz" \
+    --attach "binaries/micro-$1-linux-arm.tar.gz" \
+    --attach "binaries/micro-$1-linux-arm64.tar.gz" \
+    --attach "binaries/micro-$1-freebsd64.tar.gz" \
+    --attach "binaries/micro-$1-freebsd32.tar.gz" \
+    --attach "binaries/micro-$1-openbsd64.tar.gz" \
+    --attach "binaries/micro-$1-openbsd32.tar.gz" \
+    --attach "binaries/micro-$1-netbsd64.tar.gz" \
+    --attach "binaries/micro-$1-netbsd32.tar.gz" \
+    --attach "binaries/micro-$1-win64.zip" \
+    --attach "binaries/micro-$1-win32.zip"

tools/pre-release.sh

@@ -8,145 +8,29 @@ tag="v$1"
 
 echo "Creating tag"
 git tag $tag $commitID
-git push --tags
-
-echo "Creating new release"
-github-release release \
-    --user zyedidia \
-    --repo micro \
-    --tag $tag \
-    --name "$1" \
-    --description "$2" \
-    --pre-release
+hub push --tags
 
 echo "Cross compiling binaries"
 ./cross-compile.sh $1
 mv ../binaries .
 
-echo "Uploading OSX binary"
-github-release upload \
-    --user zyedidia \
-    --repo micro \
-    --tag $tag \
-    --name "micro-$1-osx.tar.gz" \
-    --file binaries/micro-$1-osx.tar.gz
+NL=$'\n'
 
-echo "Uploading Linux 64 binary"
-github-release upload \
-    --user zyedidia \
-    --repo micro \
-    --tag $tag \
-    --name "micro-$1-linux64.tar.gz" \
-    --file binaries/micro-$1-linux64.tar.gz
-
-echo "Uploading Linux 64 static binary"
-github-release upload \
-    --user zyedidia \
-    --repo micro \
-    --tag $tag \
-    --name "micro-$1-linux64-static.tar.gz" \
-    --file binaries/micro-$1-linux64-static.tar.gz
-
-echo "Uploading Linux 32 binary"
-github-release upload \
-    --user zyedidia \
-    --repo micro \
-    --tag $tag \
-    --name "micro-$1-linux32.tar.gz" \
-    --file binaries/micro-$1-linux32.tar.gz
-
-echo "Uploading Linux Arm 32 binary"
-github-release upload \
-    --user zyedidia \
-    --repo micro \
-    --tag $tag \
-    --name "micro-$1-linux-arm.tar.gz" \
-    --file binaries/micro-$1-linux-arm.tar.gz
-
-echo "Uploading Linux Arm 64 binary"
-github-release upload \
-    --user zyedidia \
-    --repo micro \
-    --tag $tag \
-    --name "micro-$1-linux-arm64.tar.gz" \
-    --file binaries/micro-$1-linux-arm64.tar.gz
-
-echo "Uploading FreeBSD 64 binary"
-github-release upload \
-    --user zyedidia \
-    --repo micro \
-    --tag $tag \
-    --name "micro-$1-freebsd64.tar.gz" \
-    --file binaries/micro-$1-freebsd64.tar.gz
-
-echo "Uploading FreeBSD 32 binary"
-github-release upload \
-    --user zyedidia \
-    --repo micro \
-    --tag $tag \
-    --name "micro-$1-freebsd32.tar.gz" \
-    --file binaries/micro-$1-freebsd32.tar.gz
-
-echo "Uploading OpenBSD 64 binary"
-github-release upload \
-    --user zyedidia \
-    --repo micro \
-    --tag $tag \
-    --name "micro-$1-openbsd64.tar.gz" \
-    --file binaries/micro-$1-openbsd64.tar.gz
-
-echo "Uploading OpenBSD 32 binary"
-github-release upload \
-    --user zyedidia \
-    --repo micro \
-    --tag $tag \
-    --name "micro-$1-openbsd32.tar.gz" \
-    --file binaries/micro-$1-openbsd32.tar.gz
-
-echo "Uploading NetBSD 64 binary"
-github-release upload \
-    --user zyedidia \
-    --repo micro \
-    --tag $tag \
-    --name "micro-$1-netbsd64.tar.gz" \
-    --file binaries/micro-$1-netbsd64.tar.gz
-
-echo "Uploading NetBSD 32 binary"
-github-release upload \
-    --user zyedidia \
-    --repo micro \
-    --tag $tag \
-    --name "micro-$1-netbsd32.tar.gz" \
-    --file binaries/micro-$1-netbsd32.tar.gz
-
-echo "Uploading Windows 64 binary"
-github-release upload \
-    --user zyedidia \
-    --repo micro \
-    --tag $tag \
-    --name "micro-$1-win64.zip" \
-    --file binaries/micro-$1-win64.zip
-
-echo "Uploading Windows 32 binary"
-github-release upload \
-    --user zyedidia \
-    --repo micro \
-    --tag $tag \
-    --name "micro-$1-win32.zip" \
-    --file binaries/micro-$1-win32.zip
-
-# echo "Uploading vendored tarball"
-# github-release upload \
-#     --user zyedidia \
-#     --repo micro \
-#     --tag $tag \
-#     --name "micro-$1-src.tar.gz" \
-#     --file binaries/micro-$1-src.tar.gz
-#
-# echo "Uploading vendored zip"
-# github-release upload \
-#     --user zyedidia \
-#     --repo micro \
-#     --tag $tag \
-#     --name "micro-$1-src.zip" \
-#     --file binaries/micro-$1-src.zip
+echo "Creating new release"
+hub release create $tag \
+    --prerelease \
+    --message "$1${NL}${NL}$2" \
+    --attach "binaries/micro-$1-osx.tar.gz" \
+    --attach "binaries/micro-$1-linux64.tar.gz" \
+    --attach "binaries/micro-$1-linux64-static.tar.gz" \
+    --attach "binaries/micro-$1-linux32.tar.gz" \
+    --attach "binaries/micro-$1-linux-arm.tar.gz" \
+    --attach "binaries/micro-$1-linux-arm64.tar.gz" \
+    --attach "binaries/micro-$1-freebsd64.tar.gz" \
+    --attach "binaries/micro-$1-freebsd32.tar.gz" \
+    --attach "binaries/micro-$1-openbsd64.tar.gz" \
+    --attach "binaries/micro-$1-openbsd32.tar.gz" \
+    --attach "binaries/micro-$1-netbsd64.tar.gz" \
+    --attach "binaries/micro-$1-netbsd32.tar.gz" \
+    --attach "binaries/micro-$1-win64.zip" \
+    --attach "binaries/micro-$1-win32.zip"

tools/release.sh

@@ -8,144 +8,28 @@ tag="v$1"
 
 echo "Creating tag"
 git tag $tag $commitID
-git push --tags
+hub push --tags
 
-echo "Creating new release"
-github-release release \
-    --user zyedidia \
-    --repo micro \
-    --tag $tag \
-    --name "$1" \
-    --description "$2" \
+NL=$'\n'
 
 echo "Cross compiling binaries"
 ./cross-compile.sh $1
 mv ../binaries .
 
-echo "Uploading OSX binary"
-github-release upload \
-    --user zyedidia \
-    --repo micro \
-    --tag $tag \
-    --name "micro-$1-osx.tar.gz" \
-    --file binaries/micro-$1-osx.tar.gz
-
-echo "Uploading Linux 64 binary"
-github-release upload \
-    --user zyedidia \
-    --repo micro \
-    --tag $tag \
-    --name "micro-$1-linux64.tar.gz" \
-    --file binaries/micro-$1-linux64.tar.gz
-
-echo "Uploading Linux 64 static binary"
-github-release upload \
-    --user zyedidia \
-    --repo micro \
-    --tag $tag \
-    --name "micro-$1-linux64-static.tar.gz" \
-    --file binaries/micro-$1-linux64-static.tar.gz
-
-echo "Uploading Linux 32 binary"
-github-release upload \
-    --user zyedidia \
-    --repo micro \
-    --tag $tag \
-    --name "micro-$1-linux32.tar.gz" \
-    --file binaries/micro-$1-linux32.tar.gz
-
-echo "Uploading Linux Arm 32 binary"
-github-release upload \
-    --user zyedidia \
-    --repo micro \
-    --tag $tag \
-    --name "micro-$1-linux-arm.tar.gz" \
-    --file binaries/micro-$1-linux-arm.tar.gz
-
-echo "Uploading Linux Arm 64 binary"
-github-release upload \
-    --user zyedidia \
-    --repo micro \
-    --tag $tag \
-    --name "micro-$1-linux-arm64.tar.gz" \
-    --file binaries/micro-$1-linux-arm64.tar.gz
-
-echo "Uploading FreeBSD 64 binary"
-github-release upload \
-    --user zyedidia \
-    --repo micro \
-    --tag $tag \
-    --name "micro-$1-freebsd64.tar.gz" \
-    --file binaries/micro-$1-freebsd64.tar.gz
-
-echo "Uploading FreeBSD 32 binary"
-github-release upload \
-    --user zyedidia \
-    --repo micro \
-    --tag $tag \
-    --name "micro-$1-freebsd32.tar.gz" \
-    --file binaries/micro-$1-freebsd32.tar.gz
-
-echo "Uploading OpenBSD 64 binary"
-github-release upload \
-    --user zyedidia \
-    --repo micro \
-    --tag $tag \
-    --name "micro-$1-openbsd64.tar.gz" \
-    --file binaries/micro-$1-openbsd64.tar.gz
-
-echo "Uploading OpenBSD 32 binary"
-github-release upload \
-    --user zyedidia \
-    --repo micro \
-    --tag $tag \
-    --name "micro-$1-openbsd32.tar.gz" \
-    --file binaries/micro-$1-openbsd32.tar.gz
-
-echo "Uploading NetBSD 64 binary"
-github-release upload \
-    --user zyedidia \
-    --repo micro \
-    --tag $tag \
-    --name "micro-$1-netbsd64.tar.gz" \
-    --file binaries/micro-$1-netbsd64.tar.gz
-
-echo "Uploading NetBSD 32 binary"
-github-release upload \
-    --user zyedidia \
-    --repo micro \
-    --tag $tag \
-    --name "micro-$1-netbsd32.tar.gz" \
-    --file binaries/micro-$1-netbsd32.tar.gz
-
-echo "Uploading Windows 64 binary"
-github-release upload \
-    --user zyedidia \
-    --repo micro \
-    --tag $tag \
-    --name "micro-$1-win64.zip" \
-    --file binaries/micro-$1-win64.zip
-
-echo "Uploading Windows 32 binary"
-github-release upload \
-    --user zyedidia \
-    --repo micro \
-    --tag $tag \
-    --name "micro-$1-win32.zip" \
-    --file binaries/micro-$1-win32.zip
-
-# echo "Uploading vendored tarball"
-# github-release upload \
-#     --user zyedidia \
-#     --repo micro \
-#     --tag $tag \
-#     --name "micro-$1-src.tar.gz" \
-#     --file binaries/micro-$1-src.tar.gz
-#
-# echo "Uploading vendored zip"
-# github-release upload \
-#     --user zyedidia \
-#     --repo micro \
-#     --tag $tag \
-#     --name "micro-$1-src.zip" \
-#     --file binaries/micro-$1-src.zip
+echo "Creating new release"
+hub release create $tag \
+    --message "$1${NL}${NL}$2" \
+    --attach "binaries/micro-$1-osx.tar.gz" \
+    --attach "binaries/micro-$1-linux64.tar.gz" \
+    --attach "binaries/micro-$1-linux64-static.tar.gz" \
+    --attach "binaries/micro-$1-linux32.tar.gz" \
+    --attach "binaries/micro-$1-linux-arm.tar.gz" \
+    --attach "binaries/micro-$1-linux-arm64.tar.gz" \
+    --attach "binaries/micro-$1-freebsd64.tar.gz" \
+    --attach "binaries/micro-$1-freebsd32.tar.gz" \
+    --attach "binaries/micro-$1-openbsd64.tar.gz" \
+    --attach "binaries/micro-$1-openbsd32.tar.gz" \
+    --attach "binaries/micro-$1-netbsd64.tar.gz" \
+    --attach "binaries/micro-$1-netbsd32.tar.gz" \
+    --attach "binaries/micro-$1-win64.zip" \
+    --attach "binaries/micro-$1-win32.zip"

tools/remove-nightly-assets.go

@@ -0,0 +1,39 @@
+package main
+
+import (
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"os/exec"
+	"strings"
+
+	"github.com/zyedidia/json5"
+)
+
+func main() {
+	resp, err := http.Get("https://api.github.com/repos/zyedidia/micro/releases")
+	if err != nil {
+		fmt.Println(err.Error())
+		return
+	}
+	defer resp.Body.Close()
+	body, err := ioutil.ReadAll(resp.Body)
+
+	var data interface{}
+
+	err = json5.Unmarshal(body, &data)
+
+	for _, val := range data.([]interface{}) {
+		m := val.(map[string]interface{})
+		releaseName := m["name"].(string)
+		assets := m["assets"].([]interface{})
+		for _, asset := range assets {
+			assetInfo := asset.(map[string]interface{})
+			url := assetInfo["url"].(string)
+			if strings.Contains(strings.ToLower(releaseName), "nightly") {
+				cmd := exec.Command("hub", "api", "-X", "DELETE", url)
+				cmd.Run()
+			}
+		}
+	}
+}