Use dep for dependency management

Correct the comment from # to ! as pointed out in the gitter chat on Xresources files high lighting

.github/ISSUE_TEMPLATE

@@ -0,0 +1,9 @@
+## Description of the problem or steps to reproduce
+
+## Specifications
+
+You can use `micro -version` to get the commit hash.
+
+Commit hash:
+OS:
+Terminal:

.gitignore

@@ -1,3 +1,8 @@
-./micro
+micro
 !cmd/micro
 binaries/
+tmp.sh
+test/
+.idea/
+packages/
+cmd/micro/vendor

LICENSE

@@ -1,6 +1,6 @@
 Micro is licensed under the MIT "Expat" License:
 
-Copyright (c) 2016: Zachary Yedidia.
+Copyright (c) 2016: Zachary Yedidia, et al.
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

Makefile

@@ -1,22 +1,49 @@
 .PHONY: runtime
 
-VERSION = "$(shell git rev-parse --short HEAD)"
+VERSION := $(shell GOOS=$(shell go env GOHOSTOS) GOARCH=$(shell go env GOHOSTARCH) \
+	go run tools/build-version.go)
+HASH := $(shell git rev-parse --short HEAD)
+DATE := $(shell GOOS=$(shell go env GOHOSTOS) GOARCH=$(shell go env GOHOSTARCH) \
+	go run tools/build-date.go)
+ADDITIONAL_GO_LINKER_FLAGS := $(shell GOOS=$(shell go env GOHOSTOS) \
+	GOARCH=$(shell go env GOHOSTARCH) \
+	go run tools/info-plist.go "$(VERSION)")
+GOBIN ?= $(shell go env GOPATH)/bin
 
-build: tcell
-	go build -ldflags "-X main.Version=$(VERSION)" -o micro ./cmd/micro
+# Builds micro after checking dependencies but without updating the runtime
+build: deps
+	go build -ldflags "-s -w -X main.Version=$(VERSION) -X main.CommitHash=$(HASH) -X 'main.CompileDate=$(DATE)' $(ADDITIONAL_GO_LINKER_FLAGS)" ./cmd/micro
 
-install: build
-	mv micro $(GOPATH)/bin
+# Builds micro after building the runtime and checking dependencies
+build-all: runtime build
 
-tcell:
-	git -C $(GOPATH)/src/github.com/zyedidia/tcell pull
+# Builds micro without checking for dependencies
+build-quick:
+	go build -ldflags "-s -w -X main.Version=$(VERSION) -X main.CommitHash=$(HASH) -X 'main.CompileDate=$(DATE)' $(ADDITIONAL_GO_LINKER_FLAGS)" ./cmd/micro
 
+# Same as 'build' but installs to $GOBIN afterward
+install: deps
+	go install -ldflags "-s -w -X main.Version=$(VERSION) -X main.CommitHash=$(HASH) -X 'main.CompileDate=$(DATE)' $(ADDITIONAL_GO_LINKER_FLAGS)" ./cmd/micro
+
+# Same as 'build-all' but installs to $GOBIN afterward
+install-all: runtime install
+
+# Same as 'build-quick' but installs to $GOBIN afterward
+install-quick:
+	go install -ldflags "-s -w -X main.Version=$(VERSION) -X main.CommitHash=$(HASH) -X 'main.CompileDate=$(DATE)' $(ADDITIONAL_GO_LINKER_FLAGS)"  ./cmd/micro
+
+# Checks for dependencies
 deps:
 	go get -d ./cmd/micro
 
+update:
+	git pull
+	go get -u -d ./cmd/micro
+
+# Builds the runtime
 runtime:
 	go get -u github.com/jteeuwen/go-bindata/...
-	$(GOPATH)/bin/go-bindata -nometadata -o runtime.go runtime/...
+	$(GOBIN)/go-bindata -nometadata -o runtime.go runtime/...
 	mv runtime.go cmd/micro
 
 test:

README.md

@@ -1,19 +1,24 @@
 # ![Micro](./assets/logo.png)
 
 [![Build Status](https://travis-ci.org/zyedidia/micro.svg?branch=master)](https://travis-ci.org/zyedidia/micro)
-![Go Report Card](https://goreportcard.com/badge/github.com/zyedidia/micro)
+[![Go Report Card](https://goreportcard.com/badge/github.com/zyedidia/micro)](https://goreportcard.com/report/github.com/zyedidia/micro)
 [![Join the chat at https://gitter.im/zyedidia/micro](https://badges.gitter.im/zyedidia/micro.svg)](https://gitter.im/zyedidia/micro?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 [![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/zyedidia/micro/blob/master/LICENSE)
 
-> Micro is still a work in progress
-
 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. It comes as one single, batteries-included, static binary with no dependencies, and you can download and use it right now.
 
+As the name indicates, micro aims to be somewhat of a successor to the nano editor by being easy to install and use in a pinch, but micro also aims to be
+enjoyable to use full time, whether you work in the terminal because you prefer it (like me), or because you need to (over ssh).
+
 Here is a picture of micro editing its source code.
 
 ![Screenshot](./assets/micro-solarized.png)
 
+To see more screenshots of micro, showcasing all of the default colorschemes, see [here](http://zbyedidia.webfactional.com/micro/screenshots.html).
+
+You can also check out the website for Micro at https://micro-editor.github.io.
+
 # Features
 
 * Easy to use and to install
@@ -22,53 +27,91 @@ Here is a picture of micro editing its source code.
     * 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)
+* Splits and tabs
 * 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, there are still some bugs that need to be worked out
 * Plugin system (plugins are written in Lua)
+    * Micro has a built-in plugin manager to automatically install, remove, and update all your plugins
+* Persistent undo
 * Automatic linting and error notifications
-* Syntax highlighting (for over [75 languages](runtime/syntax)!)
+* Syntax highlighting (for over [90 languages](runtime/syntax)!)
 * Colorscheme support
     * By default, micro comes with 16, 256, and true color themes.
 * True color support (set the `MICRO_TRUECOLOR` env variable to 1 to enable it)
+* Snippets
+    * The snippet plugin can be installed with `> plugin install snippets`
 * Copy and paste with the system clipboard
 * Small and simple
 * Easily configurable
-* Common editor things such as undo/redo, line numbers, unicode support...
+* Macros
+* Common editor things such as undo/redo, line numbers, Unicode support, softwrap...
+
+Although not yet implemented, I hope to add more features such as autocompletion ([#174](https://github.com/zyedidia/micro/issues/174)), and multiple cursors ([#5](https://github.com/zyedidia/micro/issues/5)) in the future.
 
 # Installation
 
-To install micro, you can download a prebuilt binary, or you can build it from source.
+To install micro, you can download a [prebuilt binary](https://github.com/zyedidia/micro/releases), or you can build it from source.
 
-You can also install micro with a few package managers (on OSX, Arch Linux, and CRUX). 
-See this [wiki page](https://github.com/zyedidia/micro/wiki/Installing-Micro) for details.
-
-Please note that micro uses the amazing [tcell library](https://github.com/gdamore/tcell), but this
-means that micro is restricted to the platforms tcell supports. As a result, micro does not support
-Plan9, NaCl, and Cygwin (although this may change in the future).
+If you want more information about ways to install micro, see this [wiki page](https://github.com/zyedidia/micro/wiki/Installing-Micro).
 
 ### Prebuilt binaries
 
 All you need to install micro is one file, the binary itself. It's as simple as that!
 
-You can download the correct binary for your operating system from the list in the [nightly build release](https://github.com/zyedidia/micro/releases/tag/nightly).
+Download the binary from the [releases](https://github.com/zyedidia/micro/releases) page.
 
-Micro has no released version, instead these binaries are compiled every night and you can find the
-commit they were compiled with by running `micro -version`.
+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.
 
-If your operating system does not have binary, but does run Go, you can build from source.
+If you'd like to see more information after installing micro, run `micro -version`.
+
+### Package Managers
+
+You can install micro using Homebrew on Mac:
+
+```
+brew install micro
+```
+
+On Windows, you can install micro through Chocolatey:
+
+```
+choco install micro
+```
+
+On Linux, you can install micro through [snap](https://snapcraft.io/docs/core/install)
+
+```
+snap install micro --beta
+```
 
 ### Building from source
 
-Make sure that you have Go version 1.5 or greater (Go 1.4 will work for the systems like support CGO then).
+If your operating system does not have a binary release, but does run Go, you can build from source.
 
-```sh
-go get -u github.com/zyedidia/micro/...
+Make sure that you have Go version 1.5 or greater (Go 1.4 will work if your version supports CGO) and that your `GOPATH` env variable is set (I recommand setting it to `~/go` if you don't have one).
+
+```
+go get -d github.com/zyedidia/micro/...
+cd $GOPATH/src/github.com/zyedidia/micro
+make install
 ```
 
-### Clipboard support
+Please make sure that when you are working with micro's code, you are working on your `GOPATH`.
 
-On Linux, clipboard support requires 'xclip' or 'xsel' command to be installed.
+The binary will then be installed to `$GOPATH/bin` (or your `$GOBIN`).
+
+You can install directly with `go get` (`go get -u github.com/zyedidia/micro/cmd/micro`) but this isn't recommended because it doesn't build micro with version information which is useful for the plugin manager.
+
+### MacOS terminal
+
+If you are using MacOS, you should consider using [iTerm2](http://iterm2.com/) instead of the default Mac terminal. The iTerm2 terminal has much better mouse support as well as better handling of key events. The newest versions also support true color.
+
+### Linux clipboard support
+
+On Linux, clipboard support requires the 'xclip' or 'xsel' commands to be installed.
 
 For Ubuntu:
 
@@ -78,6 +121,26 @@ sudo apt-get install xclip
 
 If you don't have xclip or xsel, micro will use an internal clipboard for copy and paste, but it won't work with external applications.
 
+### Colors and syntax highlighting
+
+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. Try changing the colorscheme to `simple`
+by pressing CtrlE 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`.
+
+Many of the Windows terminals don't support more than 16 colors, which means
+that micro's default colorscheme won't look very good. You can either set
+the colorscheme to `simple`, or download a better terminal emulator, like
+mintty.
+
+### Plan9, NaCl, Cygwin
+
+Please note that micro uses the amazing [tcell library](https://github.com/gdamore/tcell), but this
+means that micro is restricted to the platforms tcell supports. As a result, micro does not support
+Plan9, NaCl, and Cygwin (although this may change in the future).
+
 # Usage
 
 Once you have built the editor, simply start it by running `micro path/to/file.txt` or simply `micro` to open an empty buffer.
@@ -96,11 +159,24 @@ click to enable line selection.
 
 # Documentation and Help
 
-Micro has a built-in help system which you can access by pressing `CtrlE` and typing `help`. Additionally, you can
-view the help files online [here](https://github.com/zyedidia/micro/tree/master/runtime/help).
+Micro has a built-in help system which you can access by pressing `Ctrl-E` and typing `help`. Additionally, you can
+view the help files here:
+
+* [main help](https://github.com/zyedidia/micro/tree/master/runtime/help/help.md)
+* [keybindings](https://github.com/zyedidia/micro/tree/master/runtime/help/keybindings.md)
+* [commands](https://github.com/zyedidia/micro/tree/master/runtime/help/commands.md)
+* [colors](https://github.com/zyedidia/micro/tree/master/runtime/help/colors.md)
+* [options](https://github.com/zyedidia/micro/tree/master/runtime/help/options.md)
+* [plugins](https://github.com/zyedidia/micro/tree/master/runtime/help/plugins.md)
+
+I also recommend reading the [tutorial](https://github.com/zyedidia/micro/tree/master/runtime/help/tutorial.md) for
+a brief introduction to the more powerful configuration features micro offers.
 
 # Contributing
 
 If you find any bugs, please report them! I am also happy to accept pull requests from anyone.
 
-You can use the Github issue tracker to report bugs, ask questions, or suggest new features.
+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).

cmd/micro/Gopkg.lock

@@ -0,0 +1,123 @@
+# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
+
+
+[[projects]]
+  branch = "master"
+  name = "github.com/blang/semver"
+  packages = ["."]
+  revision = "4a1e882c79dcf4ec00d2e29fac74b9c8938d5052"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/dustin/go-humanize"
+  packages = ["."]
+  revision = "259d2a102b871d17f30e3cd9881a642961a1e486"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/gdamore/encoding"
+  packages = ["."]
+  revision = "b23993cbb6353f0e6aa98d0ee318a34728f628b9"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/go-errors/errors"
+  packages = ["."]
+  revision = "8fa88b06e5974e97fbf9899a7f86a344bfd1f105"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/lucasb-eyer/go-colorful"
+  packages = ["."]
+  revision = "9c2852a141bf4711e4276f8f119c90d0f20a556c"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/mattn/go-isatty"
+  packages = ["."]
+  revision = "fc9e8d8ef48496124e79ae0df75490096eccf6fe"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/mattn/go-runewidth"
+  packages = ["."]
+  revision = "97311d9f7767e3d6f422ea06661bc2c7a19e8a5d"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/mitchellh/go-homedir"
+  packages = ["."]
+  revision = "b8bc1bf767474819792c23f32d8286a45736f1c6"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/sergi/go-diff"
+  packages = ["diffmatchpatch"]
+  revision = "feef008d51ad2b3778f85d387ccf91735543008d"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/yuin/gopher-lua"
+  packages = [".","ast","parse","pm"]
+  revision = "b402f3114ec730d8bddb074a6c137309f561aa78"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/zyedidia/clipboard"
+  packages = ["."]
+  revision = "adacf416cec40266b051e7bc096c52951f2725e9"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/zyedidia/glob"
+  packages = ["."]
+  revision = "72567a468b2481490f359cdfb015231389e0bf9d"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/zyedidia/json5"
+  packages = ["encoding/json5"]
+  revision = "2518f8beebde6814f2d30d566260480d2ded2f76"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/zyedidia/tcell"
+  packages = [".","encoding"]
+  revision = "7095cc1c7f4173ae48314d80878e9985a0658889"
+
+[[projects]]
+  branch = "master"
+  name = "golang.org/x/net"
+  packages = ["context"]
+  revision = "007e530097ad7f954752df63046b4036f98ba6a6"
+
+[[projects]]
+  branch = "master"
+  name = "golang.org/x/sys"
+  packages = ["unix"]
+  revision = "d4feaf1a7e61e1d9e79e6c4e76c6349e9cab0a03"
+
+[[projects]]
+  branch = "master"
+  name = "golang.org/x/text"
+  packages = ["encoding","encoding/charmap","encoding/internal","encoding/internal/identifier","encoding/japanese","encoding/korean","encoding/simplifiedchinese","encoding/traditionalchinese","internal/gen","transform","unicode/cldr"]
+  revision = "506f9d5c962f284575e88337e7d9296d27e729d3"
+
+[[projects]]
+  branch = "v2"
+  name = "gopkg.in/yaml.v2"
+  packages = ["."]
+  revision = "a83829b6f1293c91addabc89d0571c246397bbf4"
+
+[[projects]]
+  branch = "master"
+  name = "layeh.com/gopher-luar"
+  packages = ["."]
+  revision = "80196fe2abc5682963fc7a5261f5a5d77509938b"
+
+[solve-meta]
+  analyzer-name = "dep"
+  analyzer-version = 1
+  inputs-digest = "aebc6aa50d78830f86e8964c1ebc1804c1f9603477ddba606717a972ca70d261"
+  solver-name = "gps-cdcl"
+  solver-version = 1

cmd/micro/Gopkg.toml

@@ -0,0 +1,123 @@
+
+## Gopkg.toml example (these lines may be deleted)
+
+## "metadata" defines metadata about the project that could be used by other independent
+## systems. The metadata defined here will be ignored by dep.
+# [metadata]
+# key1 = "value that convey data to other systems"
+# system1-data = "value that is used by a system"
+# system2-data = "value that is used by another system"
+
+## "required" lists a set of packages (not projects) that must be included in
+## Gopkg.lock. This list is merged with the set of packages imported by the current
+## project. Use it when your project needs a package it doesn't explicitly import -
+## including "main" packages.
+# required = ["github.com/user/thing/cmd/thing"]
+
+## "ignored" lists a set of packages (not projects) that are ignored when
+## dep statically analyzes source code. Ignored packages can be in this project,
+## or in a dependency.
+# ignored = ["github.com/user/project/badpkg"]
+
+## Constraints are rules for how directly imported projects
+## may be incorporated into the depgraph. They are respected by
+## dep whether coming from the Gopkg.toml of the current project or a dependency.
+# [[constraint]]
+## Required: the root import path of the project being constrained.
+# name = "github.com/user/project"
+#
+## Recommended: the version constraint to enforce for the project.
+## Only one of "branch", "version" or "revision" can be specified.
+# version = "1.0.0"
+# branch = "master"
+# revision = "abc123"
+#
+## Optional: an alternate location (URL or import path) for the project's source.
+# source = "https://github.com/myfork/package.git"
+#
+## "metadata" defines metadata about the dependency or override that could be used
+## by other independent systems. The metadata defined here will be ignored by dep.
+# [metadata]
+# key1 = "value that convey data to other systems"
+# system1-data = "value that is used by a system"
+# system2-data = "value that is used by another system"
+
+## Overrides have the same structure as [[constraint]], but supersede all
+## [[constraint]] declarations from all projects. Only [[override]] from
+## the current project's are applied.
+##
+## Overrides are a sledgehammer. Use them only as a last resort.
+# [[override]]
+## Required: the root import path of the project being constrained.
+# name = "github.com/user/project"
+#
+## Optional: specifying a version constraint override will cause all other
+## constraints on this project to be ignored; only the overridden constraint
+## need be satisfied.
+## Again, only one of "branch", "version" or "revision" can be specified.
+# version = "1.0.0"
+# branch = "master"
+# revision = "abc123"
+#
+## Optional: specifying an alternate source location as an override will
+## enforce that the alternate location is used for that project, regardless of
+## what source location any dependent projects specify.
+# source = "https://github.com/myfork/package.git"
+
+
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/blang/semver"
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/dustin/go-humanize"
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/go-errors/errors"
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/mattn/go-isatty"
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/mattn/go-runewidth"
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/mitchellh/go-homedir"
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/sergi/go-diff"
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/yuin/gopher-lua"
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/zyedidia/clipboard"
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/zyedidia/glob"
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/zyedidia/json5"
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/zyedidia/tcell"
+
+[[constraint]]
+  branch = "v2"
+  name = "gopkg.in/yaml.v2"
+
+[[constraint]]
+  branch = "master"
+  name = "layeh.com/gopher-luar"

cmd/micro/actions_linux.go

@@ -0,0 +1,36 @@
+package main
+
+import "syscall"
+
+// Suspend sends micro to the background. This is the same as pressing CtrlZ in most unix programs.
+// This only works on linux and has no default binding.
+// This code was adapted from the suspend code in nsf/godit
+func (v *View) Suspend(usePlugin bool) bool {
+	if usePlugin && !PreActionCall("Suspend", v) {
+		return false
+	}
+
+	screenWasNil := screen == nil
+
+	if !screenWasNil {
+		screen.Fini()
+		screen = nil
+	}
+
+	// suspend the process
+	pid := syscall.Getpid()
+	tid := syscall.Gettid()
+	err := syscall.Tgkill(pid, tid, syscall.SIGSTOP)
+	if err != nil {
+		TermMessage(err)
+	}
+
+	if !screenWasNil {
+		InitScreen()
+	}
+
+	if usePlugin {
+		return PostActionCall("Suspend", v)
+	}
+	return true
+}

cmd/micro/actions_other.go

@@ -0,0 +1,9 @@
+// +build !linux
+
+package main
+
+func (v *View) Suspend(usePlugin bool) bool {
+	messenger.Error("Suspend is only supported on Linux")
+
+	return false
+}

cmd/micro/autocomplete.go

@@ -8,19 +8,24 @@ import (
 	"github.com/mitchellh/go-homedir"
 )
 
+var pluginCompletions []func(string) []string
+
 // This file is meant (for now) for autocompletion in command mode, not
 // while coding. This helps micro autocomplete commands and then filenames
 // for example with `vsplit filename`.
 
 // FileComplete autocompletes filenames
 func FileComplete(input string) (string, []string) {
-	dirs := strings.Split(input, "/")
+	var sep string = string(os.PathSeparator)
+	dirs := strings.Split(input, sep)
+
 	var files []os.FileInfo
 	var err error
 	if len(dirs) > 1 {
 		home, _ := homedir.Dir()
 
-		directories := strings.Join(dirs[:len(dirs)-1], "/")
+		directories := strings.Join(dirs[:len(dirs)-1], sep) + sep
+
 		if strings.HasPrefix(directories, "~") {
 			directories = strings.Replace(directories, "~", home, 1)
 		}
@@ -28,6 +33,7 @@ func FileComplete(input string) (string, []string) {
 	} else {
 		files, err = ioutil.ReadDir(".")
 	}
+
 	var suggestions []string
 	if err != nil {
 		return "", suggestions
@@ -35,7 +41,7 @@ func FileComplete(input string) (string, []string) {
 	for _, f := range files {
 		name := f.Name()
 		if f.IsDir() {
-			name += "/"
+			name += sep
 		}
 		if strings.HasPrefix(name, dirs[len(dirs)-1]) {
 			suggestions = append(suggestions, name)
@@ -45,10 +51,14 @@ func FileComplete(input string) (string, []string) {
 	var chosen string
 	if len(suggestions) == 1 {
 		if len(dirs) > 1 {
-			chosen = strings.Join(dirs[:len(dirs)-1], "/") + "/" + suggestions[0]
+			chosen = strings.Join(dirs[:len(dirs)-1], sep) + sep + suggestions[0]
 		} else {
 			chosen = suggestions[0]
 		}
+	} else {
+		if len(dirs) > 1 {
+			chosen = strings.Join(dirs[:len(dirs)-1], sep) + sep
+		}
 	}
 
 	return chosen, suggestions
@@ -74,9 +84,9 @@ func CommandComplete(input string) (string, []string) {
 func HelpComplete(input string) (string, []string) {
 	var suggestions []string
 
-	for _, topic := range helpFiles {
+	for _, file := range ListRuntimeFiles(RTHelp) {
+		topic := file.Name()
 		if strings.HasPrefix(topic, input) {
-
 			suggestions = append(suggestions, topic)
 		}
 	}
@@ -88,6 +98,34 @@ func HelpComplete(input string) (string, []string) {
 	return chosen, suggestions
 }
 
+// ColorschemeComplete tab-completes names of colorschemes.
+func ColorschemeComplete(input string) (string, []string) {
+	var suggestions []string
+	files := ListRuntimeFiles(RTColorscheme)
+
+	for _, f := range files {
+		if strings.HasPrefix(f.Name(), input) {
+			suggestions = append(suggestions, f.Name())
+		}
+	}
+
+	var chosen string
+	if len(suggestions) == 1 {
+		chosen = suggestions[0]
+	}
+
+	return chosen, suggestions
+}
+
+func contains(s []string, e string) bool {
+	for _, a := range s {
+		if a == e {
+			return true
+		}
+	}
+	return false
+}
+
 // OptionComplete autocompletes options
 func OptionComplete(input string) (string, []string) {
 	var suggestions []string
@@ -98,7 +136,7 @@ func OptionComplete(input string) (string, []string) {
 		}
 	}
 	for option := range localSettings {
-		if strings.HasPrefix(option, input) {
+		if strings.HasPrefix(option, input) && !contains(suggestions, option) {
 			suggestions = append(suggestions, option)
 		}
 	}
@@ -109,3 +147,50 @@ func OptionComplete(input string) (string, []string) {
 	}
 	return chosen, suggestions
 }
+
+// MakeCompletion registers a function from a plugin for autocomplete commands
+func MakeCompletion(function string) Completion {
+	pluginCompletions = append(pluginCompletions, LuaFunctionComplete(function))
+	return Completion(-len(pluginCompletions))
+}
+
+// PluginComplete autocompletes from plugin function
+func PluginComplete(complete Completion, input string) (chosen string, suggestions []string) {
+	idx := int(-complete) - 1
+
+	if len(pluginCompletions) <= idx {
+		return "", nil
+	}
+	suggestions = pluginCompletions[idx](input)
+
+	if len(suggestions) == 1 {
+		chosen = suggestions[0]
+	}
+	return
+}
+
+func PluginCmdComplete(input string) (chosen string, suggestions []string) {
+	for _, cmd := range []string{"install", "remove", "search", "update", "list"} {
+		if strings.HasPrefix(cmd, input) {
+			suggestions = append(suggestions, cmd)
+		}
+	}
+
+	if len(suggestions) == 1 {
+		chosen = suggestions[0]
+	}
+	return chosen, suggestions
+}
+
+func PluginNameComplete(input string) (chosen string, suggestions []string) {
+	for _, pp := range GetAllPluginPackages() {
+		if strings.HasPrefix(pp.Name, input) {
+			suggestions = append(suggestions, pp.Name)
+		}
+	}
+
+	if len(suggestions) == 1 {
+		chosen = suggestions[0]
+	}
+	return chosen, suggestions
+}

cmd/micro/bindings.go

@@ -1,11 +1,11 @@
 package main
 
 import (
-	"encoding/json"
 	"io/ioutil"
 	"os"
 	"strings"
 
+	"github.com/zyedidia/json5/encoding/json5"
 	"github.com/zyedidia/tcell"
 )
 
@@ -41,6 +41,8 @@ var bindingActions = map[string]func(*View, bool) bool{
 	"Delete":              (*View).Delete,
 	"InsertTab":           (*View).InsertTab,
 	"Save":                (*View).Save,
+	"SaveAll":             (*View).SaveAll,
+	"SaveAs":              (*View).SaveAs,
 	"Find":                (*View).Find,
 	"FindNext":            (*View).FindNext,
 	"FindPrevious":        (*View).FindPrevious,
@@ -52,9 +54,13 @@ var bindingActions = map[string]func(*View, bool) bool{
 	"CutLine":             (*View).CutLine,
 	"DuplicateLine":       (*View).DuplicateLine,
 	"DeleteLine":          (*View).DeleteLine,
+	"MoveLinesUp":         (*View).MoveLinesUp,
+	"MoveLinesDown":       (*View).MoveLinesDown,
 	"IndentSelection":     (*View).IndentSelection,
 	"OutdentSelection":    (*View).OutdentSelection,
+	"OutdentLine":         (*View).OutdentLine,
 	"Paste":               (*View).Paste,
+	"PastePrimary":        (*View).PastePrimary,
 	"SelectAll":           (*View).SelectAll,
 	"OpenFile":            (*View).OpenFile,
 	"Start":               (*View).Start,
@@ -71,12 +77,20 @@ var bindingActions = map[string]func(*View, bool) bool{
 	"ClearStatus":         (*View).ClearStatus,
 	"ShellMode":           (*View).ShellMode,
 	"CommandMode":         (*View).CommandMode,
+	"Escape":              (*View).Escape,
 	"Quit":                (*View).Quit,
+	"QuitAll":             (*View).QuitAll,
 	"AddTab":              (*View).AddTab,
 	"PreviousTab":         (*View).PreviousTab,
 	"NextTab":             (*View).NextTab,
 	"NextSplit":           (*View).NextSplit,
 	"PreviousSplit":       (*View).PreviousSplit,
+	"Unsplit":             (*View).Unsplit,
+	"VSplit":              (*View).VSplitBinding,
+	"HSplit":              (*View).HSplitBinding,
+	"ToggleMacro":         (*View).ToggleMacro,
+	"PlayMacro":           (*View).PlayMacro,
+	"Suspend":             (*View).Suspend,
 
 	// This was changed to InsertNewline but I don't want to break backwards compatibility
 	"InsertEnter": (*View).InsertNewline,
@@ -201,12 +215,11 @@ var bindingKeys = map[string]tcell.Key{
 	"CtrlRightSq":    tcell.KeyCtrlRightSq,
 	"CtrlCarat":      tcell.KeyCtrlCarat,
 	"CtrlUnderscore": tcell.KeyCtrlUnderscore,
-	"Backspace":      tcell.KeyBackspace,
 	"Tab":            tcell.KeyTab,
 	"Esc":            tcell.KeyEsc,
 	"Escape":         tcell.KeyEscape,
 	"Enter":          tcell.KeyEnter,
-	"Backspace2":     tcell.KeyBackspace2,
+	"Backspace":      tcell.KeyBackspace2,
 
 	// I renamed these keys to PageUp and PageDown but I don't want to break someone's keybindings
 	"PgUp":   tcell.KeyPgUp,
@@ -235,7 +248,7 @@ func InitBindings() {
 			return
 		}
 
-		err = json.Unmarshal(input, &parsed)
+		err = json5.Unmarshal(input, &parsed)
 		if err != nil {
 			TermMessage("Error reading bindings.json:", err.Error())
 		}
@@ -263,7 +276,8 @@ modSearch:
 		case strings.HasPrefix(k, "-"):
 			// We optionally support dashes between modifiers
 			k = k[1:]
-		case strings.HasPrefix(k, "Ctrl"):
+		case strings.HasPrefix(k, "Ctrl") && k != "CtrlH":
+			// CtrlH technically does not have a 'Ctrl' modifier because it is really backspace
 			k = k[4:]
 			modifiers |= tcell.ModCtrl
 		case strings.HasPrefix(k, "Alt"):
@@ -329,13 +343,25 @@ func findAction(v string) (action func(*View, bool) bool) {
 func BindKey(k, v string) {
 	key, ok := findKey(k)
 	if !ok {
+		TermMessage("Unknown keybinding: " + k)
 		return
 	}
 	if v == "ToggleHelp" {
 		helpBinding = k
 	}
+	if helpBinding == k && v != "ToggleHelp" {
+		helpBinding = ""
+	}
 
 	actionNames := strings.Split(v, ",")
+	if actionNames[0] == "UnbindKey" {
+		delete(bindings, key)
+		if len(actionNames) == 1 {
+			actionNames = make([]string, 0, 0)
+		} else {
+			actionNames = append(actionNames[:0], actionNames[1:]...)
+		}
+	}
 	actions := make([]func(*View, bool) bool, 0, len(actionNames))
 	for _, actionName := range actionNames {
 		actions = append(actions, findAction(actionName))
@@ -357,24 +383,27 @@ func DefaultBindings() map[string]string {
 		"ShiftRight":     "SelectRight",
 		"AltLeft":        "WordLeft",
 		"AltRight":       "WordRight",
+		"AltUp":          "MoveLinesUp",
+		"AltDown":        "MoveLinesDown",
 		"AltShiftRight":  "SelectWordRight",
 		"AltShiftLeft":   "SelectWordLeft",
 		"CtrlLeft":       "StartOfLine",
 		"CtrlRight":      "EndOfLine",
 		"CtrlShiftLeft":  "SelectToStartOfLine",
+		"ShiftHome":      "SelectToStartOfLine",
 		"CtrlShiftRight": "SelectToEndOfLine",
+		"ShiftEnd":       "SelectToEndOfLine",
 		"CtrlUp":         "CursorStart",
 		"CtrlDown":       "CursorEnd",
 		"CtrlShiftUp":    "SelectToStart",
 		"CtrlShiftDown":  "SelectToEnd",
 		"Enter":          "InsertNewline",
-		"Space":          "InsertSpace",
+		"CtrlH":          "Backspace",
 		"Backspace":      "Backspace",
-		"Backspace2":     "Backspace",
+		"Alt-CtrlH":      "DeleteWordLeft",
 		"Alt-Backspace":  "DeleteWordLeft",
-		"Alt-Backspace2": "DeleteWordLeft",
 		"Tab":            "IndentSelection,InsertTab",
-		"Backtab":        "OutdentSelection",
+		"Backtab":        "OutdentSelection,OutdentLine",
 		"CtrlO":          "OpenFile",
 		"CtrlS":          "Save",
 		"CtrlF":          "Find",
@@ -389,21 +418,24 @@ func DefaultBindings() map[string]string {
 		"CtrlV":          "Paste",
 		"CtrlA":          "SelectAll",
 		"CtrlT":          "AddTab",
-		"CtrlRightSq":    "PreviousTab",
-		"CtrlBackslash":  "NextTab",
+		"Alt,":           "PreviousTab",
+		"Alt.":           "NextTab",
 		"Home":           "StartOfLine",
 		"End":            "EndOfLine",
+		"CtrlHome":       "CursorStart",
+		"CtrlEnd":        "CursorEnd",
 		"PageUp":         "CursorPageUp",
 		"PageDown":       "CursorPageDown",
 		"CtrlG":          "ToggleHelp",
 		"CtrlR":          "ToggleRuler",
 		"CtrlL":          "JumpLine",
 		"Delete":         "Delete",
-		"Esc":            "ClearStatus",
 		"CtrlB":          "ShellMode",
 		"CtrlQ":          "Quit",
 		"CtrlE":          "CommandMode",
 		"CtrlW":          "NextSplit",
+		"CtrlU":          "ToggleMacro",
+		"CtrlJ":          "PlayMacro",
 
 		// Emacs-style keybindings
 		"Alt-f": "WordRight",
@@ -412,5 +444,14 @@ func DefaultBindings() map[string]string {
 		"Alt-e": "EndOfLine",
 		"Alt-p": "CursorUp",
 		"Alt-n": "CursorDown",
+
+		// Integration with file managers
+		"F1":  "ToggleHelp",
+		"F2":  "Save",
+		"F3":  "Find",
+		"F4":  "Quit",
+		"F7":  "Find",
+		"F10": "Quit",
+		"Esc": "Escape",
 	}
 }

cmd/micro/buffer.go

@@ -3,13 +3,20 @@ package main
 import (
 	"bytes"
 	"encoding/gob"
+	"io"
 	"io/ioutil"
 	"os"
 	"os/exec"
 	"os/signal"
 	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
 	"time"
 	"unicode/utf8"
+
+	"github.com/mitchellh/go-homedir"
+	"github.com/zyedidia/micro/cmd/micro/highlight"
 )
 
 // Buffer stores the text for files that are loaded into the text editor
@@ -25,8 +32,10 @@ type Buffer struct {
 
 	// 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
+	name string
 
 	// Whether or not the buffer has been modified since it was opened
 	IsModified bool
@@ -36,8 +45,8 @@ type Buffer struct {
 
 	NumLines int
 
-	// Syntax highlighting rules
-	rules []SyntaxRule
+	syntaxDef   *highlight.Def
+	highlighter *highlight.Highlighter
 
 	// Buffer local settings
 	Settings map[string]interface{}
@@ -51,10 +60,24 @@ type SerializedBuffer struct {
 	ModTime      time.Time
 }
 
-// NewBuffer creates a new buffer from `txt` with path and name `path`
-func NewBuffer(txt []byte, path string) *Buffer {
+func NewBufferFromString(text, path string) *Buffer {
+	return NewBuffer(strings.NewReader(text), int64(len(text)), path)
+}
+
+// NewBuffer creates a new buffer from a given reader with a given path
+func NewBuffer(reader io.Reader, size int64, path string) *Buffer {
+	if path != "" {
+		for _, tab := range tabs {
+			for _, view := range tab.views {
+				if view.Buf.Path == path {
+					return view.Buf
+				}
+			}
+		}
+	}
+
 	b := new(Buffer)
-	b.LineArray = NewLineArray(txt)
+	b.LineArray = NewLineArray(size, reader)
 
 	b.Settings = DefaultLocalSettings()
 	for k, v := range globalSettings {
@@ -63,13 +86,10 @@ func NewBuffer(txt []byte, path string) *Buffer {
 		}
 	}
 
-	b.Path = path
-	b.Name = path
+	absPath, _ := filepath.Abs(path)
 
-	// If the file doesn't have a path to disk then we give it no name
-	if path == "" {
-		b.Name = "No name"
-	}
+	b.Path = path
+	b.AbsPath = absPath
 
 	// The last time this file was modified
 	b.ModTime, _ = GetModTime(b.Path)
@@ -77,7 +97,6 @@ func NewBuffer(txt []byte, path string) *Buffer {
 	b.EventHandler = NewEventHandler(b)
 
 	b.Update()
-	b.FindFileType()
 	b.UpdateRules()
 
 	if _, err := os.Stat(configDir + "/buffers/"); os.IsNotExist(err) {
@@ -85,10 +104,36 @@ func NewBuffer(txt []byte, path string) *Buffer {
 	}
 
 	// Put the cursor at the first spot
+	cursorStartX := 0
+	cursorStartY := 0
+	// If -startpos LINE,COL was passed, use start position LINE,COL
+	if len(*flagStartPos) > 0 {
+		positions := strings.Split(*flagStartPos, ",")
+		if len(positions) == 2 {
+			lineNum, errPos1 := strconv.Atoi(positions[0])
+			colNum, errPos2 := strconv.Atoi(positions[1])
+			if errPos1 == nil && errPos2 == nil {
+				cursorStartX = colNum
+				cursorStartY = lineNum - 1
+				// Check to avoid line overflow
+				if cursorStartY > b.NumLines {
+					cursorStartY = b.NumLines - 1
+				} else if cursorStartY < 0 {
+					cursorStartY = 0
+				}
+				// Check to avoid column overflow
+				if cursorStartX > len(b.Line(cursorStartY)) {
+					cursorStartX = len(b.Line(cursorStartY))
+				} else if cursorStartX < 0 {
+					cursorStartX = 0
+				}
+			}
+		}
+	}
 	b.Cursor = Cursor{
 		Loc: Loc{
-			X: 0,
-			Y: 0,
+			X: cursorStartX,
+			Y: cursorStartY,
 		},
 		buf: b,
 	}
@@ -98,8 +143,7 @@ func NewBuffer(txt []byte, path string) *Buffer {
 	if b.Settings["savecursor"].(bool) || b.Settings["saveundo"].(bool) {
 		// If either savecursor or saveundo is turned on, we need to load the serialized information
 		// from ~/.config/micro/buffers
-		absPath, _ := filepath.Abs(b.Path)
-		file, err := os.Open(configDir + "/buffers/" + EscapePath(absPath))
+		file, err := os.Open(configDir + "/buffers/" + EscapePath(b.AbsPath))
 		if err == nil {
 			var buffer SerializedBuffer
 			decoder := gob.NewDecoder(file)
@@ -128,15 +172,81 @@ func NewBuffer(txt []byte, path string) *Buffer {
 	return b
 }
 
+func (b *Buffer) GetName() string {
+	if b.name == "" {
+		if b.Path == "" {
+			return "No name"
+		}
+		return b.Path
+	}
+	return b.name
+}
+
 // UpdateRules updates the syntax rules and filetype for this buffer
 // This is called when the colorscheme changes
 func (b *Buffer) UpdateRules() {
-	b.rules = GetRules(b)
-}
+	rehighlight := false
+	var files []*highlight.File
+	for _, f := range ListRuntimeFiles(RTSyntax) {
+		data, err := f.Data()
+		if err != nil {
+			TermMessage("Error loading syntax file " + f.Name() + ": " + err.Error())
+		} else {
+			file, err := highlight.ParseFile(data)
+			if err != nil {
+				TermMessage("Error loading syntax file " + f.Name() + ": " + err.Error())
+				continue
+			}
+			ftdetect, err := highlight.ParseFtDetect(file)
+			if err != nil {
+				TermMessage("Error loading syntax file " + f.Name() + ": " + err.Error())
+				continue
+			}
 
-// FindFileType identifies this buffer's filetype based on the extension or header
-func (b *Buffer) FindFileType() {
-	b.Settings["filetype"] = FindFileType(b)
+			ft := b.Settings["filetype"].(string)
+			if ft == "Unknown" || ft == "" {
+				if highlight.MatchFiletype(ftdetect, b.Path, b.lines[0].data) {
+					header := new(highlight.Header)
+					header.FileType = file.FileType
+					header.FtDetect = ftdetect
+					b.syntaxDef, err = highlight.ParseDef(file, header)
+					if err != nil {
+						TermMessage("Error loading syntax file " + f.Name() + ": " + err.Error())
+						continue
+					}
+					rehighlight = true
+				}
+			} else {
+				if file.FileType == ft {
+					header := new(highlight.Header)
+					header.FileType = file.FileType
+					header.FtDetect = ftdetect
+					b.syntaxDef, err = highlight.ParseDef(file, header)
+					if err != nil {
+						TermMessage("Error loading syntax file " + f.Name() + ": " + err.Error())
+						continue
+					}
+					rehighlight = true
+				}
+			}
+			files = append(files, file)
+		}
+	}
+
+	if b.syntaxDef != nil {
+		highlight.ResolveIncludes(b.syntaxDef, files)
+	}
+	files = nil
+
+	if b.highlighter == nil || rehighlight {
+		if b.syntaxDef != nil {
+			b.Settings["filetype"] = b.syntaxDef.FileType
+			b.highlighter = highlight.NewHighlighter(b.syntaxDef)
+			if b.Settings["syntax"].(bool) {
+				b.highlighter.HighlightStates(b)
+			}
+		}
+	}
 }
 
 // FileType returns the buffer's filetype
@@ -144,6 +254,14 @@ func (b *Buffer) FileType() string {
 	return b.Settings["filetype"].(string)
 }
 
+// IndentString returns a string representing one level of indentation
+func (b *Buffer) IndentString() string {
+	if b.Settings["tabstospaces"].(bool) {
+		return Spaces(int(b.Settings["tabsize"].(float64)))
+	}
+	return "\t"
+}
+
 // CheckModTime makes sure that the file this buffer points to hasn't been updated
 // by an external program since it was last read
 // If it has, we ask the user if they would like to reload the file
@@ -200,8 +318,7 @@ func (b *Buffer) SaveWithSudo() error {
 // Serialize serializes the buffer to configDir/buffers
 func (b *Buffer) Serialize() error {
 	if b.Settings["savecursor"].(bool) || b.Settings["saveundo"].(bool) {
-		absPath, _ := filepath.Abs(b.Path)
-		file, err := os.Create(configDir + "/buffers/" + EscapePath(absPath))
+		file, err := os.Create(configDir + "/buffers/" + EscapePath(b.AbsPath))
 		if err == nil {
 			enc := gob.NewEncoder(file)
 			gob.Register(TextEvent{})
@@ -220,15 +337,35 @@ func (b *Buffer) Serialize() error {
 // SaveAs saves the buffer to a specified path (filename), creating the file if it does not exist
 func (b *Buffer) SaveAs(filename string) error {
 	b.UpdateRules()
-	b.Name = filename
-	b.Path = filename
-	data := []byte(b.String())
+	dir, _ := homedir.Dir()
+	if b.Settings["rmtrailingws"].(bool) {
+		r, _ := regexp.Compile(`[ \t]+$`)
+		for lineNum, line := range b.Lines(0, b.NumLines) {
+			indices := r.FindStringIndex(line)
+			if indices == nil {
+				continue
+			}
+			startLoc := Loc{indices[0], lineNum}
+			b.deleteToEnd(startLoc)
+		}
+		b.Cursor.Relocate()
+	}
+	if b.Settings["eofnewline"].(bool) {
+		end := b.End()
+		if b.RuneAt(Loc{end.X - 1, end.Y}) != '\n' {
+			b.Insert(end, "\n")
+		}
+	}
+	str := b.String()
+	data := []byte(str)
 	err := ioutil.WriteFile(filename, data, 0644)
 	if err == nil {
+		b.Path = strings.Replace(filename, "~", dir, 1)
 		b.IsModified = false
 		b.ModTime, _ = GetModTime(filename)
 		return b.Serialize()
 	}
+	b.ModTime, _ = GetModTime(filename)
 	return err
 }
 
@@ -236,7 +373,6 @@ func (b *Buffer) SaveAs(filename string) error {
 // with tee to use sudo so the user doesn't have to reopen micro with sudo
 func (b *Buffer) SaveAsWithSudo(filename string) error {
 	b.UpdateRules()
-	b.Name = filename
 	b.Path = filename
 
 	// The user may have already used sudo in which case we won't need the password
@@ -293,6 +429,11 @@ func (b *Buffer) remove(start, end Loc) string {
 	b.Update()
 	return sub
 }
+func (b *Buffer) deleteToEnd(start Loc) {
+	b.IsModified = true
+	b.LineArray.DeleteToEnd(start)
+	b.Update()
+}
 
 // Start returns the location of the first character in the buffer
 func (b *Buffer) Start() Loc {
@@ -301,12 +442,28 @@ func (b *Buffer) Start() Loc {
 
 // End returns the location of the last character in the buffer
 func (b *Buffer) End() Loc {
-	return Loc{utf8.RuneCount(b.lines[b.NumLines-1]), b.NumLines - 1}
+	return Loc{utf8.RuneCount(b.lines[b.NumLines-1].data), b.NumLines - 1}
+}
+
+// RuneAt returns the rune at a given location in the buffer
+func (b *Buffer) RuneAt(loc Loc) rune {
+	line := []rune(b.Line(loc.Y))
+	if len(line) > 0 {
+		return line[loc.X]
+	}
+	return '\n'
 }
 
 // Line returns a single line
 func (b *Buffer) Line(n int) string {
-	return string(b.lines[n])
+	if n >= len(b.lines) {
+		return ""
+	}
+	return string(b.lines[n].data)
+}
+
+func (b *Buffer) LinesNum() int {
+	return len(b.lines)
 }
 
 // Lines returns an array of strings containing the lines from start to end
@@ -314,7 +471,7 @@ func (b *Buffer) Lines(start, end int) []string {
 	lines := b.lines[start:end]
 	var slice []string
 	for _, line := range lines {
-		slice = append(slice, string(line))
+		slice = append(slice, string(line.data))
 	}
 	return slice
 }
@@ -323,3 +480,56 @@ func (b *Buffer) Lines(start, end int) []string {
 func (b *Buffer) Len() int {
 	return Count(b.String())
 }
+
+// MoveLinesUp moves the range of lines up one row
+func (b *Buffer) MoveLinesUp(start int, end int) {
+	// 0 < start < end <= len(b.lines)
+	if start < 1 || start >= end || end > len(b.lines) {
+		return // what to do? FIXME
+	}
+	if end == len(b.lines) {
+		b.Insert(
+			Loc{
+				utf8.RuneCount(b.lines[end-1].data),
+				end - 1,
+			},
+			"\n"+b.Line(start-1),
+		)
+	} else {
+		b.Insert(
+			Loc{0, end},
+			b.Line(start-1)+"\n",
+		)
+	}
+	b.Remove(
+		Loc{0, start - 1},
+		Loc{0, start},
+	)
+}
+
+// MoveLinesDown moves the range of lines down one row
+func (b *Buffer) MoveLinesDown(start int, end int) {
+	// 0 <= start < end < len(b.lines)
+	// if end == len(b.lines), we can't do anything here because the
+	// last line is unaccessible, FIXME
+	if start < 0 || start >= end || end >= len(b.lines)-1 {
+		return // what to do? FIXME
+	}
+	b.Insert(
+		Loc{0, start},
+		b.Line(end)+"\n",
+	)
+	end++
+	b.Remove(
+		Loc{0, end},
+		Loc{0, end + 1},
+	)
+}
+
+// ClearMatches clears all of the syntax highlighting for this buffer
+func (b *Buffer) ClearMatches() {
+	for i := range b.lines {
+		b.SetMatch(i, nil)
+		b.SetState(i, nil)
+	}
+}

cmd/micro/cellview.go

@@ -0,0 +1,207 @@
+package main
+
+import (
+	"github.com/mattn/go-runewidth"
+	"github.com/zyedidia/tcell"
+)
+
+func min(a, b int) int {
+	if a <= b {
+		return a
+	}
+	return b
+}
+
+func visualToCharPos(visualIndex int, lineN int, str string, buf *Buffer, tabsize int) (int, int, *tcell.Style) {
+	charPos := 0
+	var lineIdx int
+	var lastWidth int
+	var style *tcell.Style
+	var width int
+	var rw int
+	for i, c := range str {
+		// width := StringWidth(str[:i], tabsize)
+
+		if group, ok := buf.Match(lineN)[charPos]; ok {
+			s := GetColor(group.String())
+			style = &s
+		}
+
+		if width >= visualIndex {
+			return charPos, visualIndex - lastWidth, style
+		}
+
+		if i != 0 {
+			charPos++
+			lineIdx += rw
+		}
+		lastWidth = width
+		rw = 0
+		if c == '\t' {
+			rw = tabsize - (lineIdx % tabsize)
+			width += rw
+		} else {
+			rw = runewidth.RuneWidth(c)
+			width += rw
+		}
+	}
+
+	return -1, -1, style
+}
+
+type Char struct {
+	visualLoc Loc
+	realLoc   Loc
+	char      rune
+	// The actual character that is drawn
+	// This is only different from char if it's for example hidden character
+	drawChar rune
+	style    tcell.Style
+	width    int
+}
+
+type CellView struct {
+	lines [][]*Char
+}
+
+func (c *CellView) Draw(buf *Buffer, top, height, left, width int) {
+	tabsize := int(buf.Settings["tabsize"].(float64))
+	softwrap := buf.Settings["softwrap"].(bool)
+	indentrunes := []rune(buf.Settings["indentchar"].(string))
+	// if empty indentchar settings, use space
+	if indentrunes == nil || len(indentrunes) == 0 {
+		indentrunes = []rune(" ")
+	}
+	indentchar := indentrunes[0]
+
+	start := buf.Cursor.Y
+	if buf.Settings["syntax"].(bool) && buf.syntaxDef != nil {
+		if start > 0 && buf.lines[start-1].rehighlight {
+			buf.highlighter.ReHighlightLine(buf, start-1)
+			buf.lines[start-1].rehighlight = false
+		}
+
+		buf.highlighter.ReHighlightStates(buf, start)
+
+		buf.highlighter.HighlightMatches(buf, top, top+height)
+	}
+
+	c.lines = make([][]*Char, 0)
+
+	viewLine := 0
+	lineN := top
+
+	curStyle := defStyle
+	for viewLine < height {
+		if lineN >= len(buf.lines) {
+			break
+		}
+
+		lineStr := buf.Line(lineN)
+		line := []rune(lineStr)
+
+		colN, startOffset, startStyle := visualToCharPos(left, lineN, lineStr, buf, tabsize)
+		if colN < 0 {
+			colN = len(line)
+		}
+		viewCol := -startOffset
+		if startStyle != nil {
+			curStyle = *startStyle
+		}
+
+		// We'll either draw the length of the line, or the width of the screen
+		// whichever is smaller
+		lineLength := min(StringWidth(lineStr, tabsize), width)
+		c.lines = append(c.lines, make([]*Char, lineLength))
+
+		wrap := false
+		// We only need to wrap if the length of the line is greater than the width of the terminal screen
+		if softwrap && StringWidth(lineStr, tabsize) > width {
+			wrap = true
+			// We're going to draw the entire line now
+			lineLength = StringWidth(lineStr, tabsize)
+		}
+
+		for viewCol < lineLength {
+			if colN >= len(line) {
+				break
+			}
+			if group, ok := buf.Match(lineN)[colN]; ok {
+				curStyle = GetColor(group.String())
+			}
+
+			char := line[colN]
+
+			if viewCol >= 0 {
+				c.lines[viewLine][viewCol] = &Char{Loc{viewCol, viewLine}, Loc{colN, lineN}, char, char, curStyle, 1}
+			}
+			if char == '\t' {
+				charWidth := tabsize - (viewCol+left)%tabsize
+				if viewCol >= 0 {
+					c.lines[viewLine][viewCol].drawChar = indentchar
+					c.lines[viewLine][viewCol].width = charWidth
+
+					indentStyle := curStyle
+					if group, ok := colorscheme["indent-char"]; ok {
+						indentStyle = group
+					}
+
+					c.lines[viewLine][viewCol].style = indentStyle
+				}
+
+				for i := 1; i < charWidth; i++ {
+					viewCol++
+					if viewCol >= 0 && viewCol < lineLength {
+						c.lines[viewLine][viewCol] = &Char{Loc{viewCol, viewLine}, Loc{colN, lineN}, char, ' ', curStyle, 1}
+					}
+				}
+				viewCol++
+			} else if runewidth.RuneWidth(char) > 1 {
+				charWidth := runewidth.RuneWidth(char)
+				if viewCol >= 0 {
+					c.lines[viewLine][viewCol].width = charWidth
+				}
+				for i := 1; i < charWidth; i++ {
+					viewCol++
+					if viewCol >= 0 && viewCol < lineLength {
+						c.lines[viewLine][viewCol] = &Char{Loc{viewCol, viewLine}, Loc{colN, lineN}, char, ' ', curStyle, 1}
+					}
+				}
+				viewCol++
+			} else {
+				viewCol++
+			}
+			colN++
+
+			if wrap && viewCol >= width {
+				viewLine++
+
+				// If we go too far soft wrapping we have to cut off
+				if viewLine >= height {
+					break
+				}
+
+				nextLine := line[colN:]
+				lineLength := min(StringWidth(string(nextLine), tabsize), width)
+				c.lines = append(c.lines, make([]*Char, lineLength))
+
+				viewCol = 0
+			}
+
+		}
+		if group, ok := buf.Match(lineN)[len(line)]; ok {
+			curStyle = GetColor(group.String())
+		}
+
+		// newline
+		viewLine++
+		lineN++
+	}
+
+	for i := top; i < top+height; i++ {
+		if i >= buf.NumLines {
+			break
+		}
+		buf.SetMatch(i, nil)
+	}
+}

cmd/micro/colorscheme.go

@@ -2,11 +2,11 @@ package main
 
 import (
 	"fmt"
-	"github.com/zyedidia/tcell"
-	"io/ioutil"
 	"regexp"
 	"strconv"
 	"strings"
+
+	"github.com/zyedidia/tcell"
 )
 
 // Colorscheme is a map from string to style -- it represents a colorscheme
@@ -15,39 +15,65 @@ type Colorscheme map[string]tcell.Style
 // The current colorscheme
 var colorscheme Colorscheme
 
-var preInstalledColors = []string{"default", "solarized", "solarized-tc", "atom-dark-tc", "monokai", "gruvbox"}
+// This takes in a syntax group and returns the colorscheme's style for that group
+func GetColor(color string) tcell.Style {
+	st := defStyle
+	if color == "" {
+		return st
+	}
+	groups := strings.Split(color, ".")
+	if len(groups) > 1 {
+		curGroup := ""
+		for i, g := range groups {
+			if i != 0 {
+				curGroup += "."
+			}
+			curGroup += g
+			if style, ok := colorscheme[curGroup]; ok {
+				st = style
+			}
+		}
+	} else if style, ok := colorscheme[color]; ok {
+		st = style
+	} else {
+		st = StringToStyle(color)
+	}
+
+	return st
+}
+
+// ColorschemeExists checks if a given colorscheme exists
+func ColorschemeExists(colorschemeName string) bool {
+	return FindRuntimeFile(RTColorscheme, colorschemeName) != nil
+}
 
 // InitColorscheme picks and initializes the colorscheme when micro starts
 func InitColorscheme() {
+	colorscheme = make(Colorscheme)
+	defStyle = tcell.StyleDefault.
+		Foreground(tcell.ColorDefault).
+		Background(tcell.ColorDefault)
+	if screen != nil {
+		screen.SetStyle(defStyle)
+	}
+
 	LoadDefaultColorscheme()
 }
 
 // LoadDefaultColorscheme loads the default colorscheme from $(configDir)/colorschemes
 func LoadDefaultColorscheme() {
-	LoadColorscheme(globalSettings["colorscheme"].(string), configDir+"/colorschemes")
+	LoadColorscheme(globalSettings["colorscheme"].(string))
 }
 
 // LoadColorscheme loads the given colorscheme from a directory
-func LoadColorscheme(colorschemeName, dir string) {
-	files, _ := ioutil.ReadDir(dir)
-	for _, f := range files {
-		if f.Name() == colorschemeName+".micro" {
-			text, err := ioutil.ReadFile(dir + "/" + f.Name())
-			if err != nil {
-				fmt.Println("Error loading colorscheme:", err)
-				continue
-			}
-			colorscheme = ParseColorscheme(string(text))
-		}
-	}
-
-	for _, name := range preInstalledColors {
-		if name == colorschemeName {
-			data, err := Asset("runtime/colorschemes/" + name + ".micro")
-			if err != nil {
-				TermMessage("Unable to load pre-installed colorscheme " + name)
-				continue
-			}
+func LoadColorscheme(colorschemeName string) {
+	file := FindRuntimeFile(RTColorscheme, colorschemeName)
+	if file == nil {
+		TermMessage(colorschemeName, "is not a valid colorscheme")
+	} else {
+		if data, err := file.Data(); err != nil {
+			TermMessage("Error loading colorscheme:", err)
+		} else {
 			colorscheme = ParseColorscheme(string(data))
 		}
 	}
@@ -76,7 +102,15 @@ func ParseColorscheme(text string) Colorscheme {
 			link := string(matches[1])
 			colors := string(matches[2])
 
-			c[link] = StringToStyle(colors)
+			style := StringToStyle(colors)
+			c[link] = style
+
+			if link == "default" {
+				defStyle = style
+			}
+			if screen != nil {
+				screen.SetStyle(defStyle)
+			}
 		} else {
 			fmt.Println("Color-link statement is not valid:", line)
 		}
@@ -89,9 +123,14 @@ func ParseColorscheme(text string) Colorscheme {
 // The strings must be in the format "extra foregroundcolor,backgroundcolor"
 // The 'extra' can be bold, reverse, or underline
 func StringToStyle(str string) tcell.Style {
-	var fg string
-	bg := "default"
-	split := strings.Split(str, ",")
+	var fg, bg string
+	spaceSplit := strings.Split(str, " ")
+	var split []string
+	if len(spaceSplit) > 1 {
+		split = strings.Split(spaceSplit[1], ",")
+	} else {
+		split = strings.Split(str, ",")
+	}
 	if len(split) > 1 {
 		fg, bg = split[0], split[1]
 	} else {
@@ -100,7 +139,19 @@ func StringToStyle(str string) tcell.Style {
 	fg = strings.TrimSpace(fg)
 	bg = strings.TrimSpace(bg)
 
-	style := defStyle.Foreground(StringToColor(fg)).Background(StringToColor(bg))
+	var fgColor, bgColor tcell.Color
+	if fg == "" {
+		fgColor, _, _ = defStyle.Decompose()
+	} else {
+		fgColor = StringToColor(fg)
+	}
+	if bg == "" {
+		_, bgColor, _ = defStyle.Decompose()
+	} else {
+		bgColor = StringToColor(bg)
+	}
+
+	style := defStyle.Foreground(fgColor).Background(bgColor)
 	if strings.Contains(str, "bold") {
 		style = style.Bold(true)
 	}

cmd/micro/command.go

@@ -2,21 +2,28 @@ package main
 
 import (
 	"bytes"
-	"io/ioutil"
+	"fmt"
+	"io"
 	"os"
 	"os/exec"
 	"os/signal"
+	"path/filepath"
 	"regexp"
+	"runtime"
+	"strconv"
 	"strings"
 
+	humanize "github.com/dustin/go-humanize"
 	"github.com/mitchellh/go-homedir"
 )
 
+// A Command contains a action (a function to call) as well as information about how to autocomplete the command
 type Command struct {
 	action      func([]string)
 	completions []Completion
 }
 
+// A StrCommand is similar to a command but keeps the name of the action
 type StrCommand struct {
 	action      string
 	completions []Completion
@@ -24,18 +31,32 @@ type StrCommand struct {
 
 var commands map[string]Command
 
-var commandActions = map[string]func([]string){
-	"Set":      Set,
-	"SetLocal": SetLocal,
-	"Run":      Run,
-	"Bind":     Bind,
-	"Quit":     Quit,
-	"Save":     Save,
-	"Replace":  Replace,
-	"VSplit":   VSplit,
-	"HSplit":   HSplit,
-	"Tab":      NewTab,
-	"Help":     Help,
+var commandActions map[string]func([]string)
+
+func init() {
+	commandActions = map[string]func([]string){
+		"Set":       Set,
+		"SetLocal":  SetLocal,
+		"Show":      Show,
+		"Run":       Run,
+		"Bind":      Bind,
+		"Quit":      Quit,
+		"Save":      Save,
+		"Replace":   Replace,
+		"VSplit":    VSplit,
+		"HSplit":    HSplit,
+		"Tab":       NewTab,
+		"Help":      Help,
+		"Eval":      Eval,
+		"ToggleLog": ToggleLog,
+		"Plugin":    PluginCmd,
+		"Reload":    Reload,
+		"Cd":        Cd,
+		"Pwd":       Pwd,
+		"Open":      Open,
+		"TabSwitch": TabSwitch,
+		"MemUsage":  MemUsage,
+	}
 }
 
 // InitCommands initializes the default commands
@@ -68,20 +89,218 @@ func MakeCommand(name, function string, completions ...Completion) {
 // DefaultCommands returns a map containing micro's default commands
 func DefaultCommands() map[string]StrCommand {
 	return map[string]StrCommand{
-		"set":      StrCommand{"Set", []Completion{OptionCompletion, NoCompletion}},
-		"setlocal": StrCommand{"SetLocal", []Completion{OptionCompletion, NoCompletion}},
-		"bind":     StrCommand{"Bind", []Completion{NoCompletion}},
-		"run":      StrCommand{"Run", []Completion{NoCompletion}},
-		"quit":     StrCommand{"Quit", []Completion{NoCompletion}},
-		"save":     StrCommand{"Save", []Completion{NoCompletion}},
-		"replace":  StrCommand{"Replace", []Completion{NoCompletion}},
-		"vsplit":   StrCommand{"VSplit", []Completion{FileCompletion, NoCompletion}},
-		"hsplit":   StrCommand{"HSplit", []Completion{FileCompletion, NoCompletion}},
-		"tab":      StrCommand{"Tab", []Completion{FileCompletion, NoCompletion}},
-		"help":     StrCommand{"Help", []Completion{HelpCompletion, NoCompletion}},
+		"set":       {"Set", []Completion{OptionCompletion, NoCompletion}},
+		"setlocal":  {"SetLocal", []Completion{OptionCompletion, NoCompletion}},
+		"show":      {"Show", []Completion{OptionCompletion, NoCompletion}},
+		"bind":      {"Bind", []Completion{NoCompletion}},
+		"run":       {"Run", []Completion{NoCompletion}},
+		"quit":      {"Quit", []Completion{NoCompletion}},
+		"save":      {"Save", []Completion{NoCompletion}},
+		"replace":   {"Replace", []Completion{NoCompletion}},
+		"vsplit":    {"VSplit", []Completion{FileCompletion, NoCompletion}},
+		"hsplit":    {"HSplit", []Completion{FileCompletion, NoCompletion}},
+		"tab":       {"Tab", []Completion{FileCompletion, NoCompletion}},
+		"help":      {"Help", []Completion{HelpCompletion, NoCompletion}},
+		"eval":      {"Eval", []Completion{NoCompletion}},
+		"log":       {"ToggleLog", []Completion{NoCompletion}},
+		"plugin":    {"Plugin", []Completion{PluginCmdCompletion, PluginNameCompletion}},
+		"reload":    {"Reload", []Completion{NoCompletion}},
+		"cd":        {"Cd", []Completion{FileCompletion}},
+		"pwd":       {"Pwd", []Completion{NoCompletion}},
+		"open":      {"Open", []Completion{FileCompletion}},
+		"tabswitch": {"TabSwitch", []Completion{NoCompletion}},
+		"memusage":  {"MemUsage", []Completion{NoCompletion}},
 	}
 }
 
+// PluginCmd installs, removes, updates, lists, or searches for given plugins
+func PluginCmd(args []string) {
+	if len(args) >= 1 {
+		switch args[0] {
+		case "install":
+			installedVersions := GetInstalledVersions(false)
+			for _, plugin := range args[1:] {
+				pp := GetAllPluginPackages().Get(plugin)
+				if pp == nil {
+					messenger.Error("Unknown plugin \"" + plugin + "\"")
+				} else if err := pp.IsInstallable(); err != nil {
+					messenger.Error("Error installing ", plugin, ": ", err)
+				} else {
+					for _, installed := range installedVersions {
+						if pp.Name == installed.pack.Name {
+							if pp.Versions[0].Version.Compare(installed.Version) == 1 {
+								messenger.Error(pp.Name, " is already installed but out-of-date: use 'plugin update ", pp.Name, "' to update")
+							} else {
+								messenger.Error(pp.Name, " is already installed")
+							}
+						}
+					}
+					pp.Install()
+				}
+			}
+		case "remove":
+			removed := ""
+			for _, plugin := range args[1:] {
+				// check if the plugin exists.
+				if _, ok := loadedPlugins[plugin]; ok {
+					UninstallPlugin(plugin)
+					removed += plugin + " "
+					continue
+				}
+			}
+			if !IsSpaces(removed) {
+				messenger.Message("Removed ", removed)
+			} else {
+				messenger.Error("The requested plugins do not exist")
+			}
+		case "update":
+			UpdatePlugins(args[1:])
+		case "list":
+			plugins := GetInstalledVersions(false)
+			messenger.AddLog("----------------")
+			messenger.AddLog("The following plugins are currently installed:\n")
+			for _, p := range plugins {
+				messenger.AddLog(fmt.Sprintf("%s (%s)", p.pack.Name, p.Version))
+			}
+			messenger.AddLog("----------------")
+			if len(plugins) > 0 {
+				if CurView().Type != vtLog {
+					ToggleLog([]string{})
+				}
+			}
+		case "search":
+			plugins := SearchPlugin(args[1:])
+			messenger.Message(len(plugins), " plugins found")
+			for _, p := range plugins {
+				messenger.AddLog("----------------")
+				messenger.AddLog(p.String())
+			}
+			messenger.AddLog("----------------")
+			if len(plugins) > 0 {
+				if CurView().Type != vtLog {
+					ToggleLog([]string{})
+				}
+			}
+		case "available":
+			packages := GetAllPluginPackages()
+			messenger.AddLog("Available Plugins:")
+			for _, pkg := range packages {
+				messenger.AddLog(pkg.Name)
+			}
+			if CurView().Type != vtLog {
+				ToggleLog([]string{})
+			}
+		}
+	} else {
+		messenger.Error("Not enough arguments")
+	}
+}
+
+// TabSwitch switches to a given tab either by name or by number
+func TabSwitch(args []string) {
+	if len(args) > 0 {
+		num, err := strconv.Atoi(args[0])
+		if err != nil {
+			// Check for tab with this name
+
+			found := false
+			for _, t := range tabs {
+				v := t.views[t.CurView]
+				if v.Buf.GetName() == args[0] {
+					curTab = v.TabNum
+					found = true
+				}
+			}
+			if !found {
+				messenger.Error("Could not find tab: ", err)
+			}
+		} else {
+			num--
+			if num >= 0 && num < len(tabs) {
+				curTab = num
+			} else {
+				messenger.Error("Invalid tab index")
+			}
+		}
+	}
+}
+
+// Cd changes the current working directory
+func Cd(args []string) {
+	if len(args) > 0 {
+		home, _ := homedir.Dir()
+		path := strings.Replace(args[0], "~", home, 1)
+		os.Chdir(path)
+		for _, tab := range tabs {
+			for _, view := range tab.views {
+				wd, _ := os.Getwd()
+				view.Buf.Path, _ = MakeRelative(view.Buf.AbsPath, wd)
+				if p, _ := filepath.Abs(view.Buf.Path); !strings.Contains(p, wd) {
+					view.Buf.Path = view.Buf.AbsPath
+				}
+			}
+		}
+	}
+}
+
+// MemUsage prints micro's memory usage
+// Alloc shows how many bytes are currently in use
+// Sys shows how many bytes have been requested from the operating system
+// NumGC shows how many times the GC has been run
+// Note that Go commonly reserves more memory from the OS than is currently in-use/required
+// Additionally, even if Go returns memory to the OS, the OS does not always claim it because
+// there may be plenty of memory to spare
+func MemUsage(args []string) {
+	var mem runtime.MemStats
+	runtime.ReadMemStats(&mem)
+
+	messenger.Message(fmt.Sprintf("Alloc: %v, Sys: %v, NumGC: %v", humanize.Bytes(mem.Alloc), humanize.Bytes(mem.Sys), mem.NumGC))
+}
+
+// Pwd prints the current working directory
+func Pwd(args []string) {
+	wd, err := os.Getwd()
+	if err != nil {
+		messenger.Message(err.Error())
+	} else {
+		messenger.Message(wd)
+	}
+}
+
+// Open opens a new buffer with a given filename
+func Open(args []string) {
+	if len(args) > 0 {
+		filename := args[0]
+		// the filename might or might not be quoted, so unquote first then join the strings.
+		filename = strings.Join(SplitCommandArgs(filename), " ")
+
+		CurView().Open(filename)
+	} else {
+		messenger.Error("No filename")
+	}
+}
+
+// ToggleLog toggles the log view
+func ToggleLog(args []string) {
+	buffer := messenger.getBuffer()
+	if CurView().Type != vtLog {
+		CurView().HSplit(buffer)
+		CurView().Type = vtLog
+		RedrawAll()
+		buffer.Cursor.Loc = buffer.Start()
+		CurView().Relocate()
+		buffer.Cursor.Loc = buffer.End()
+		CurView().Relocate()
+	} else {
+		CurView().Quit(true)
+	}
+}
+
+// Reload reloads all files (syntax files, colorschemes...)
+func Reload(args []string) {
+	LoadAll()
+}
+
 // Help tries to open the given help page in a horizontal split
 func Help(args []string) {
 	if len(args) < 1 {
@@ -89,7 +308,7 @@ func Help(args []string) {
 		CurView().openHelp("help")
 	} else {
 		helpPage := args[0]
-		if _, ok := helpPages[helpPage]; ok {
+		if FindRuntimeFile(RTHelp, helpPage) != nil {
 			CurView().openHelp(helpPage)
 		} else {
 			messenger.Error("Sorry, no help for ", helpPage)
@@ -101,19 +320,27 @@ func Help(args []string) {
 // If no file is given, it opens an empty buffer in a new split
 func VSplit(args []string) {
 	if len(args) == 0 {
-		CurView().VSplit(NewBuffer([]byte{}, ""))
+		CurView().VSplit(NewBufferFromString("", ""))
 	} else {
 		filename := args[0]
 		home, _ := homedir.Dir()
 		filename = strings.Replace(filename, "~", home, 1)
-		file, err := ioutil.ReadFile(filename)
+		file, err := os.Open(filename)
+		fileInfo, _ := os.Stat(filename)
+
+		if err == nil && fileInfo.IsDir() {
+			messenger.Error(filename, " is a directory")
+			return
+		}
+
+		defer file.Close()
 
 		var buf *Buffer
 		if err != nil {
 			// File does not exist -- create an empty buffer with that name
-			buf = NewBuffer([]byte{}, filename)
+			buf = NewBufferFromString("", filename)
 		} else {
-			buf = NewBuffer(file, filename)
+			buf = NewBuffer(file, FSize(file), filename)
 		}
 		CurView().VSplit(buf)
 	}
@@ -123,24 +350,44 @@ func VSplit(args []string) {
 // If no file is given, it opens an empty buffer in a new split
 func HSplit(args []string) {
 	if len(args) == 0 {
-		CurView().HSplit(NewBuffer([]byte{}, ""))
+		CurView().HSplit(NewBufferFromString("", ""))
 	} else {
 		filename := args[0]
 		home, _ := homedir.Dir()
 		filename = strings.Replace(filename, "~", home, 1)
-		file, err := ioutil.ReadFile(filename)
+		file, err := os.Open(filename)
+		fileInfo, _ := os.Stat(filename)
+
+		if err == nil && fileInfo.IsDir() {
+			messenger.Error(filename, " is a directory")
+			return
+		}
+
+		defer file.Close()
 
 		var buf *Buffer
 		if err != nil {
 			// File does not exist -- create an empty buffer with that name
-			buf = NewBuffer([]byte{}, filename)
+			buf = NewBufferFromString("", filename)
 		} else {
-			buf = NewBuffer(file, filename)
+			buf = NewBuffer(file, FSize(file), filename)
 		}
 		CurView().HSplit(buf)
 	}
 }
 
+// Eval evaluates a lua expression
+func Eval(args []string) {
+	if len(args) >= 1 {
+		err := L.DoString(args[0])
+		if err != nil {
+			messenger.Error(err)
+		}
+	} else {
+		messenger.Error("Not enough arguments")
+	}
+}
+
 // NewTab opens the given file in a new tab
 func NewTab(args []string) {
 	if len(args) == 0 {
@@ -149,12 +396,27 @@ func NewTab(args []string) {
 		filename := args[0]
 		home, _ := homedir.Dir()
 		filename = strings.Replace(filename, "~", home, 1)
-		file, _ := ioutil.ReadFile(filename)
+		file, err := os.Open(filename)
+		fileInfo, _ := os.Stat(filename)
 
-		tab := NewTabFromView(NewView(NewBuffer(file, filename)))
+		if err == nil && fileInfo.IsDir() {
+			messenger.Error(filename, " is a directory")
+			return
+		}
+
+		defer file.Close()
+
+		var buf *Buffer
+		if err != nil {
+			buf = NewBufferFromString("", filename)
+		} else {
+			buf = NewBuffer(file, FSize(file), filename)
+		}
+
+		tab := NewTabFromView(NewView(buf))
 		tab.SetNum(len(tabs))
 		tabs = append(tabs, tab)
-		curTab++
+		curTab = len(tabs) - 1
 		if len(tabs) == 2 {
 			for _, t := range tabs {
 				for _, v := range t.views {
@@ -168,22 +430,25 @@ func NewTab(args []string) {
 // Set sets an option
 func Set(args []string) {
 	if len(args) < 2 {
+		messenger.Error("Not enough arguments")
 		return
 	}
 
-	option := strings.TrimSpace(args[0])
-	value := strings.TrimSpace(args[1])
+	option := args[0]
+	value := args[1]
 
 	SetOptionAndSettings(option, value)
 }
 
+// SetLocal sets an option local to the buffer
 func SetLocal(args []string) {
 	if len(args) < 2 {
+		messenger.Error("Not enough arguments")
 		return
 	}
 
-	option := strings.TrimSpace(args[0])
-	value := strings.TrimSpace(args[1])
+	option := args[0]
+	value := args[1]
 
 	err := SetLocalOption(option, value, CurView())
 	if err != nil {
@@ -191,10 +456,27 @@ func SetLocal(args []string) {
 	}
 }
 
+// Show shows the value of the given option
+func Show(args []string) {
+	if len(args) < 1 {
+		messenger.Error("Please provide an option to show")
+		return
+	}
+
+	option := GetOption(args[0])
+
+	if option == nil {
+		messenger.Error(args[0], " is not a valid option")
+		return
+	}
+
+	messenger.Message(option)
+}
+
 // Bind creates a new keybinding
 func Bind(args []string) {
-	if len(args) != 2 {
-		messenger.Error("Incorrect number of arguments")
+	if len(args) < 2 {
+		messenger.Error("Not enough arguments")
 		return
 	}
 	BindKey(args[0], args[1])
@@ -203,7 +485,7 @@ func Bind(args []string) {
 // Run runs a shell command in the background
 func Run(args []string) {
 	// Run a shell command in the background (openTerm is false)
-	HandleShellCommand(strings.Join(args, " "), false)
+	HandleShellCommand(JoinCommandArgs(args...), false, true)
 }
 
 // Quit closes the main view
@@ -214,48 +496,32 @@ func Quit(args []string) {
 
 // Save saves the buffer in the main view
 func Save(args []string) {
-	// Save the main view
-	CurView().Save(true)
+	if len(args) == 0 {
+		// Save the main view
+		CurView().Save(true)
+	} else {
+		CurView().Buf.SaveAs(args[0])
+	}
 }
 
 // Replace runs search and replace
 func Replace(args []string) {
-	// This is a regex to parse the replace expression
-	// We allow no quotes if there are no spaces, but if you want to search
-	// for or replace an expression with spaces, you can add double quotes
-	r := regexp.MustCompile(`"[^"\\]*(?:\\.[^"\\]*)*"|[^\s]*`)
-	replaceCmd := r.FindAllString(strings.Join(args, " "), -1)
-	if len(replaceCmd) < 2 {
+	if len(args) < 2 {
 		// We need to find both a search and replace expression
 		messenger.Error("Invalid replace statement: " + strings.Join(args, " "))
 		return
 	}
 
 	var flags string
-	if len(replaceCmd) == 3 {
+	if len(args) == 3 {
 		// The user included some flags
-		flags = replaceCmd[2]
+		flags = args[2]
 	}
 
-	search := string(replaceCmd[0])
-	replace := string(replaceCmd[1])
+	search := string(args[0])
+	replace := string(args[1])
 
-	// If the search and replace expressions have quotes, we need to remove those
-	if strings.HasPrefix(search, `"`) && strings.HasSuffix(search, `"`) {
-		search = search[1 : len(search)-1]
-	}
-	if strings.HasPrefix(replace, `"`) && strings.HasSuffix(replace, `"`) {
-		replace = replace[1 : len(replace)-1]
-	}
-
-	// We replace all escaped double quotes to real double quotes
-	search = strings.Replace(search, `\"`, `"`, -1)
-	replace = strings.Replace(replace, `\"`, `"`, -1)
-	// Replace some things so users can actually insert newlines and tabs in replacements
-	replace = strings.Replace(replace, "\\n", "\n", -1)
-	replace = strings.Replace(replace, "\\t", "\t", -1)
-
-	regex, err := regexp.Compile(search)
+	regex, err := regexp.Compile("(?m)" + search)
 	if err != nil {
 		// There was an error with the user's regex
 		messenger.Error(err.Error())
@@ -265,19 +531,14 @@ func Replace(args []string) {
 	view := CurView()
 
 	found := 0
-	for {
-		match := regex.FindStringIndex(view.Buf.String())
-		if match == nil {
-			break
-		}
-		found++
-		if strings.Contains(flags, "c") {
+	if strings.Contains(flags, "c") {
+		for {
 			// The 'check' flag was used
 			Search(search, view, true)
-			view.Relocate()
-			if view.Buf.Settings["syntax"].(bool) {
-				view.matches = Match(view)
+			if !view.Cursor.HasSelection() {
+				break
 			}
+			view.Relocate()
 			RedrawAll()
 			choice, canceled := messenger.YesNoPrompt("Perform replacement? (y,n)")
 			if canceled {
@@ -286,13 +547,14 @@ func Replace(args []string) {
 					view.Cursor.ResetSelection()
 				}
 				messenger.Reset()
-				return
+				break
 			}
 			if choice {
 				view.Cursor.DeleteSelection()
-				view.Buf.Insert(FromCharPos(match[0], view.Buf), replace)
+				view.Buf.Insert(view.Cursor.Loc, replace)
 				view.Cursor.ResetSelection()
 				messenger.Reset()
+				found++
 			} else {
 				if view.Cursor.HasSelection() {
 					searchStart = ToCharPos(view.Cursor.CurSelection[1], view.Buf)
@@ -301,16 +563,34 @@ func Replace(args []string) {
 				}
 				continue
 			}
-		} else {
-			view.Buf.Replace(FromCharPos(match[0], view.Buf), FromCharPos(match[1], view.Buf), replace)
 		}
+	} else {
+		// var deltas []Delta
+		for i := 0; i < view.Buf.LinesNum(); i++ {
+			// view.Buf.lines[i].data = regex.ReplaceAll(view.Buf.lines[i].data, []byte(replace))
+			for {
+				m := regex.FindIndex(view.Buf.lines[i].data)
+
+				if m != nil {
+					from := Loc{m[0], i}
+					to := Loc{m[1], i}
+
+					// deltas = append(deltas, Delta{replace, from, to})
+					view.Buf.Replace(from, to, replace)
+					found++
+				} else {
+					break
+				}
+			}
+		}
+		// view.Buf.MultipleReplace(deltas)
 	}
 	view.Cursor.Relocate()
 
 	if found > 1 {
-		messenger.Message("Replaced ", found, " occurences of ", search)
+		messenger.Message("Replaced ", found, " occurrences of ", search)
 	} else if found == 1 {
-		messenger.Message("Replaced ", found, " occurence of ", search)
+		messenger.Message("Replaced ", found, " occurrence of ", search)
 	} else {
 		messenger.Message("Nothing matched ", search)
 	}
@@ -318,8 +598,8 @@ func Replace(args []string) {
 
 // RunShellCommand executes a shell command and returns the output/error
 func RunShellCommand(input string) (string, error) {
-	inputCmd := strings.Split(input, " ")[0]
-	args := strings.Split(input, " ")[1:]
+	inputCmd := SplitCommandArgs(input)[0]
+	args := SplitCommandArgs(input)[1:]
 
 	cmd := exec.Command(inputCmd, args...)
 	outputBytes := &bytes.Buffer{}
@@ -334,8 +614,8 @@ func RunShellCommand(input string) (string, error) {
 // HandleShellCommand runs the shell command
 // The openTerm argument specifies whether a terminal should be opened (for viewing output
 // or interacting with stdin)
-func HandleShellCommand(input string, openTerm bool) {
-	inputCmd := strings.Split(input, " ")[0]
+func HandleShellCommand(input string, openTerm bool, waitToFinish bool) string {
+	inputCmd := SplitCommandArgs(input)[0]
 	if !openTerm {
 		// Simply run the command in the background and notify the user when it's done
 		messenger.Message("Running...")
@@ -360,12 +640,13 @@ func HandleShellCommand(input string, openTerm bool) {
 		screen.Fini()
 		screen = nil
 
-		args := strings.Split(input, " ")[1:]
+		args := SplitCommandArgs(input)[1:]
 
 		// Set up everything for the command
+		var outputBuf bytes.Buffer
 		cmd := exec.Command(inputCmd, args...)
 		cmd.Stdin = os.Stdin
-		cmd.Stdout = os.Stdout
+		cmd.Stdout = io.MultiWriter(os.Stdout, &outputBuf)
 		cmd.Stderr = os.Stderr
 
 		// This is a trap for Ctrl-C so that it doesn't kill micro
@@ -378,26 +659,35 @@ func HandleShellCommand(input string, openTerm bool) {
 			}
 		}()
 
-		// Start the command
 		cmd.Start()
-		cmd.Wait()
+		err := cmd.Wait()
 
-		// This is just so we don't return right away and let the user press enter to return
-		TermMessage("")
+		output := outputBuf.String()
+		if err != nil {
+			output = err.Error()
+		}
+
+		if waitToFinish {
+			// This is just so we don't return right away and let the user press enter to return
+			TermMessage("")
+		}
 
 		// Start the screen back up
 		InitScreen()
+
+		return output
 	}
+	return ""
 }
 
 // HandleCommand handles input from the user
 func HandleCommand(input string) {
-	inputCmd := strings.Split(input, " ")[0]
-	args := strings.Split(input, " ")[1:]
+	args := SplitCommandArgs(input)
+	inputCmd := args[0]
 
 	if _, ok := commands[inputCmd]; !ok {
-		messenger.Error("Unkown command ", inputCmd)
+		messenger.Error("Unknown command ", inputCmd)
 	} else {
-		commands[inputCmd].action(args)
+		commands[inputCmd].action(args[1:])
 	}
 }

cmd/micro/cursor.go

@@ -1,5 +1,7 @@
 package main
 
+import "github.com/zyedidia/clipboard"
+
 // The Cursor struct stores the location of the cursor in the view
 // The complicated part about the cursor is storing its location.
 // The cursor must be displayed at an x, y location, but since the buffer
@@ -27,12 +29,31 @@ func (c *Cursor) Goto(b Cursor) {
 	c.OrigSelection, c.CurSelection = b.OrigSelection, b.CurSelection
 }
 
+// CopySelection copies the user's selection to either "primary" or "clipboard"
+func (c *Cursor) CopySelection(target string) {
+	if c.HasSelection() {
+		if target != "primary" || c.buf.Settings["useprimary"].(bool) {
+			clipboard.WriteAll(c.GetSelection(), target)
+		}
+	}
+}
+
 // ResetSelection resets the user's selection
 func (c *Cursor) ResetSelection() {
 	c.CurSelection[0] = c.buf.Start()
 	c.CurSelection[1] = c.buf.Start()
 }
 
+// SetSelectionStart sets the start of the selection
+func (c *Cursor) SetSelectionStart(pos Loc) {
+	c.CurSelection[0] = pos
+}
+
+// SetSelectionEnd sets the end of the selection
+func (c *Cursor) SetSelectionEnd(pos Loc) {
+	c.CurSelection[1] = pos
+}
+
 // HasSelection returns whether or not the user has selected anything
 func (c *Cursor) HasSelection() bool {
 	return c.CurSelection[0] != c.CurSelection[1]
@@ -43,7 +64,7 @@ func (c *Cursor) DeleteSelection() {
 	if c.CurSelection[0].GreaterThan(c.CurSelection[1]) {
 		c.buf.Remove(c.CurSelection[1], c.CurSelection[0])
 		c.Loc = c.CurSelection[1]
-	} else if c.GetSelection() == "" {
+	} else if !c.HasSelection() {
 		return
 	} else {
 		c.buf.Remove(c.CurSelection[0], c.CurSelection[1])
@@ -53,21 +74,24 @@ func (c *Cursor) DeleteSelection() {
 
 // GetSelection returns the cursor's selection
 func (c *Cursor) GetSelection() string {
-	if c.CurSelection[0].GreaterThan(c.CurSelection[1]) {
-		return c.buf.Substr(c.CurSelection[1], c.CurSelection[0])
+	if InBounds(c.CurSelection[0], c.buf) && InBounds(c.CurSelection[1], c.buf) {
+		if c.CurSelection[0].GreaterThan(c.CurSelection[1]) {
+			return c.buf.Substr(c.CurSelection[1], c.CurSelection[0])
+		}
+		return c.buf.Substr(c.CurSelection[0], c.CurSelection[1])
 	}
-	return c.buf.Substr(c.CurSelection[0], c.CurSelection[1])
+	return ""
 }
 
 // SelectLine selects the current line
 func (c *Cursor) SelectLine() {
 	c.Start()
-	c.CurSelection[0] = c.Loc
+	c.SetSelectionStart(c.Loc)
 	c.End()
 	if c.buf.NumLines-1 > c.Y {
-		c.CurSelection[1] = c.Loc.Move(1, c.buf)
+		c.SetSelectionEnd(c.Loc.Move(1, c.buf))
 	} else {
-		c.CurSelection[1] = c.Loc
+		c.SetSelectionEnd(c.Loc)
 	}
 
 	c.OrigSelection = c.CurSelection
@@ -77,13 +101,13 @@ func (c *Cursor) SelectLine() {
 func (c *Cursor) AddLineToSelection() {
 	if c.Loc.LessThan(c.OrigSelection[0]) {
 		c.Start()
-		c.CurSelection[0] = c.Loc
-		c.CurSelection[1] = c.OrigSelection[1]
+		c.SetSelectionStart(c.Loc)
+		c.SetSelectionEnd(c.OrigSelection[1])
 	}
 	if c.Loc.GreaterThan(c.OrigSelection[1]) {
 		c.End()
-		c.CurSelection[1] = c.Loc.Move(1, c.buf)
-		c.CurSelection[0] = c.OrigSelection[0]
+		c.SetSelectionEnd(c.Loc.Move(1, c.buf))
+		c.SetSelectionStart(c.OrigSelection[0])
 	}
 
 	if c.Loc.LessThan(c.OrigSelection[1]) && c.Loc.GreaterThan(c.OrigSelection[0]) {
@@ -98,8 +122,8 @@ func (c *Cursor) SelectWord() {
 	}
 
 	if !IsWordChar(string(c.RuneUnder(c.X))) {
-		c.CurSelection[0] = c.Loc
-		c.CurSelection[1] = c.Loc.Move(1, c.buf)
+		c.SetSelectionStart(c.Loc)
+		c.SetSelectionEnd(c.Loc.Move(1, c.buf))
 		c.OrigSelection = c.CurSelection
 		return
 	}
@@ -110,14 +134,14 @@ func (c *Cursor) SelectWord() {
 		backward--
 	}
 
-	c.CurSelection[0] = Loc{backward, c.Y}
+	c.SetSelectionStart(Loc{backward, c.Y})
 	c.OrigSelection[0] = c.CurSelection[0]
 
 	for forward < Count(c.buf.Line(c.Y))-1 && IsWordChar(string(c.RuneUnder(forward+1))) {
 		forward++
 	}
 
-	c.CurSelection[1] = Loc{forward, c.Y}.Move(1, c.buf)
+	c.SetSelectionEnd(Loc{forward, c.Y}.Move(1, c.buf))
 	c.OrigSelection[1] = c.CurSelection[1]
 	c.Loc = c.CurSelection[1]
 }
@@ -136,8 +160,8 @@ func (c *Cursor) AddWordToSelection() {
 			backward--
 		}
 
-		c.CurSelection[0] = Loc{backward, c.Y}
-		c.CurSelection[1] = c.OrigSelection[1]
+		c.SetSelectionStart(Loc{backward, c.Y})
+		c.SetSelectionEnd(c.OrigSelection[1])
 	}
 
 	if c.Loc.GreaterThan(c.OrigSelection[1]) {
@@ -147,8 +171,8 @@ func (c *Cursor) AddWordToSelection() {
 			forward++
 		}
 
-		c.CurSelection[1] = Loc{forward, c.Y}.Move(1, c.buf)
-		c.CurSelection[0] = c.OrigSelection[0]
+		c.SetSelectionEnd(Loc{forward, c.Y}.Move(1, c.buf))
+		c.SetSelectionStart(c.OrigSelection[0])
 	}
 
 	c.Loc = c.CurSelection[1]
@@ -157,11 +181,11 @@ func (c *Cursor) AddWordToSelection() {
 // SelectTo selects from the current cursor location to the given location
 func (c *Cursor) SelectTo(loc Loc) {
 	if loc.GreaterThan(c.OrigSelection[0]) {
-		c.CurSelection[0] = c.OrigSelection[0]
-		c.CurSelection[1] = loc
+		c.SetSelectionStart(c.OrigSelection[0])
+		c.SetSelectionEnd(loc)
 	} else {
-		c.CurSelection[0] = loc
-		c.CurSelection[1] = c.OrigSelection[0]
+		c.SetSelectionStart(loc)
+		c.SetSelectionEnd(c.OrigSelection[0])
 	}
 }
 

cmd/micro/eventhandler.go

@@ -1,18 +1,22 @@
 package main
 
 import (
+	"strings"
 	"time"
 
 	dmp "github.com/sergi/go-diff/diffmatchpatch"
+	"github.com/yuin/gopher-lua"
 )
 
 const (
 	// Opposite and undoing events must have opposite values
 
-	// TextEventInsert repreasents an insertion event
+	// TextEventInsert represents an insertion event
 	TextEventInsert = 1
 	// TextEventRemove represents a deletion event
 	TextEventRemove = -1
+	// TextEventReplace represents a replace event
+	TextEventReplace = 0
 )
 
 // TextEvent holds data for a manipulation on some text that can be undone
@@ -20,18 +24,31 @@ type TextEvent struct {
 	C Cursor
 
 	EventType int
-	Text      string
-	Start     Loc
-	End       Loc
+	Deltas    []Delta
 	Time      time.Time
 }
 
+type Delta struct {
+	Text  string
+	Start Loc
+	End   Loc
+}
+
 // ExecuteTextEvent runs a text event
 func ExecuteTextEvent(t *TextEvent, buf *Buffer) {
 	if t.EventType == TextEventInsert {
-		buf.insert(t.Start, []byte(t.Text))
+		for _, d := range t.Deltas {
+			buf.insert(d.Start, []byte(d.Text))
+		}
 	} else if t.EventType == TextEventRemove {
-		t.Text = buf.remove(t.Start, t.End)
+		for i, d := range t.Deltas {
+			t.Deltas[i].Text = buf.remove(d.Start, d.End)
+		}
+	} else if t.EventType == TextEventReplace {
+		for i, d := range t.Deltas {
+			t.Deltas[i].Text = buf.remove(d.Start, d.End)
+			buf.insert(d.Start, []byte(d.Text))
+		}
 	}
 }
 
@@ -82,12 +99,11 @@ func (eh *EventHandler) Insert(start Loc, text string) {
 	e := &TextEvent{
 		C:         eh.buf.Cursor,
 		EventType: TextEventInsert,
-		Text:      text,
-		Start:     start,
+		Deltas:    []Delta{Delta{text, start, Loc{0, 0}}},
 		Time:      time.Now(),
 	}
 	eh.Execute(e)
-	e.End = start.Move(Count(text), eh.buf)
+	e.Deltas[0].End = start.Move(Count(text), eh.buf)
 }
 
 // Remove creates a remove text event and executes it
@@ -95,8 +111,18 @@ func (eh *EventHandler) Remove(start, end Loc) {
 	e := &TextEvent{
 		C:         eh.buf.Cursor,
 		EventType: TextEventRemove,
-		Start:     start,
-		End:       end,
+		Deltas:    []Delta{Delta{"", start, end}},
+		Time:      time.Now(),
+	}
+	eh.Execute(e)
+}
+
+// MultipleReplace creates an multiple insertions executes them
+func (eh *EventHandler) MultipleReplace(deltas []Delta) {
+	e := &TextEvent{
+		C:         eh.buf.Cursor,
+		EventType: TextEventReplace,
+		Deltas:    deltas,
 		Time:      time.Now(),
 	}
 	eh.Execute(e)
@@ -114,6 +140,17 @@ func (eh *EventHandler) Execute(t *TextEvent) {
 		eh.RedoStack = new(Stack)
 	}
 	eh.UndoStack.Push(t)
+
+	for pl := range loadedPlugins {
+		ret, err := Call(pl+".onBeforeTextEvent", t)
+		if err != nil && !strings.HasPrefix(err.Error(), "function does not exist") {
+			TermMessage(err)
+		}
+		if val, ok := ret.(lua.LBool); ok && val == lua.LFalse {
+			return
+		}
+	}
+
 	ExecuteTextEvent(t, eh.buf)
 }
 

cmd/micro/help.go

@@ -1,24 +0,0 @@
-package main
-
-var helpPages map[string]string
-
-var helpFiles = []string{
-	"help",
-	"keybindings",
-	"plugins",
-	"colors",
-	"options",
-	"commands",
-}
-
-// LoadHelp loads the help text from inside the binary
-func LoadHelp() {
-	helpPages = make(map[string]string)
-	for _, file := range helpFiles {
-		data, err := Asset("runtime/help/" + file + ".md")
-		if err != nil {
-			TermMessage("Unable to load help text", file)
-		}
-		helpPages[file] = string(data)
-	}
-}

cmd/micro/highlight/ftdetect.go

@@ -0,0 +1,18 @@
+package highlight
+
+import "regexp"
+
+// DetectFiletype will use the list of syntax definitions provided and the filename and first line of the file
+// to determine the filetype of the file
+// It will return the corresponding syntax definition for the filetype
+func MatchFiletype(ftdetect [2]*regexp.Regexp, filename string, firstLine []byte) bool {
+	if ftdetect[0].MatchString(filename) {
+		return true
+	}
+
+	if ftdetect[1] != nil {
+		return ftdetect[1].Match(firstLine)
+	}
+
+	return false
+}

cmd/micro/highlight/highlighter.go

@@ -0,0 +1,374 @@
+package highlight
+
+import (
+	"regexp"
+	"strings"
+	"unicode/utf8"
+)
+
+// RunePos returns the rune index of a given byte index
+// This could cause problems if the byte index is between code points
+func runePos(p int, str string) int {
+	if p < 0 {
+		return 0
+	}
+	if p >= len(str) {
+		return utf8.RuneCountInString(str)
+	}
+	return utf8.RuneCountInString(str[:p])
+}
+
+func combineLineMatch(src, dst LineMatch) LineMatch {
+	for k, v := range src {
+		if g, ok := dst[k]; ok {
+			if g == 0 {
+				dst[k] = v
+			}
+		} else {
+			dst[k] = v
+		}
+	}
+	return dst
+}
+
+// A State represents the region at the end of a line
+type State *region
+
+// LineStates is an interface for a buffer-like object which can also store the states and matches for every line
+type LineStates interface {
+	Line(n int) string
+	LinesNum() int
+	State(lineN int) State
+	SetState(lineN int, s State)
+	SetMatch(lineN int, m LineMatch)
+}
+
+// A Highlighter contains the information needed to highlight a string
+type Highlighter struct {
+	lastRegion *region
+	Def        *Def
+}
+
+// NewHighlighter returns a new highlighter from the given syntax definition
+func NewHighlighter(def *Def) *Highlighter {
+	h := new(Highlighter)
+	h.Def = def
+	return h
+}
+
+// LineMatch represents the syntax highlighting matches for one line. Each index where the coloring is changed is marked with that
+// color's group (represented as one byte)
+type LineMatch map[int]Group
+
+func findIndex(regex *regexp.Regexp, skip *regexp.Regexp, str []rune, canMatchStart, canMatchEnd bool) []int {
+	regexStr := regex.String()
+	if strings.Contains(regexStr, "^") {
+		if !canMatchStart {
+			return nil
+		}
+	}
+	if strings.Contains(regexStr, "$") {
+		if !canMatchEnd {
+			return nil
+		}
+	}
+
+	var strbytes []byte
+	if skip != nil {
+		strbytes = skip.ReplaceAllFunc([]byte(string(str)), func(match []byte) []byte {
+			res := make([]byte, utf8.RuneCount(match))
+			return res
+		})
+	} else {
+		strbytes = []byte(string(str))
+	}
+
+	match := regex.FindIndex(strbytes)
+	if match == nil {
+		return nil
+	}
+	// return []int{match.Index, match.Index + match.Length}
+	return []int{runePos(match[0], string(str)), runePos(match[1], string(str))}
+}
+
+func findAllIndex(regex *regexp.Regexp, str []rune, canMatchStart, canMatchEnd bool) [][]int {
+	regexStr := regex.String()
+	if strings.Contains(regexStr, "^") {
+		if !canMatchStart {
+			return nil
+		}
+	}
+	if strings.Contains(regexStr, "$") {
+		if !canMatchEnd {
+			return nil
+		}
+	}
+	matches := regex.FindAllIndex([]byte(string(str)), -1)
+	for i, m := range matches {
+		matches[i][0] = runePos(m[0], string(str))
+		matches[i][1] = runePos(m[1], string(str))
+	}
+	return matches
+}
+
+func (h *Highlighter) highlightRegion(highlights LineMatch, start int, canMatchEnd bool, lineNum int, line []rune, curRegion *region, statesOnly bool) LineMatch {
+	// highlights := make(LineMatch)
+
+	if start == 0 {
+		if !statesOnly {
+			if _, ok := highlights[0]; !ok {
+				highlights[0] = curRegion.group
+			}
+		}
+	}
+
+	loc := findIndex(curRegion.end, curRegion.skip, line, start == 0, canMatchEnd)
+	if loc != nil {
+		if !statesOnly {
+			highlights[start+loc[0]] = curRegion.limitGroup
+		}
+		if curRegion.parent == nil {
+			if !statesOnly {
+				highlights[start+loc[1]] = 0
+				h.highlightRegion(highlights, start, false, lineNum, line[:loc[0]], curRegion, statesOnly)
+			}
+			h.highlightEmptyRegion(highlights, start+loc[1], canMatchEnd, lineNum, line[loc[1]:], statesOnly)
+			return highlights
+		}
+		if !statesOnly {
+			highlights[start+loc[1]] = curRegion.parent.group
+			h.highlightRegion(highlights, start, false, lineNum, line[:loc[0]], curRegion, statesOnly)
+		}
+		h.highlightRegion(highlights, start+loc[1], canMatchEnd, lineNum, line[loc[1]:], curRegion.parent, statesOnly)
+		return highlights
+	}
+
+	if len(line) == 0 || statesOnly {
+		if canMatchEnd {
+			h.lastRegion = curRegion
+		}
+
+		return highlights
+	}
+
+	firstLoc := []int{len(line), 0}
+
+	var firstRegion *region
+	for _, r := range curRegion.rules.regions {
+		loc := findIndex(r.start, nil, line, start == 0, canMatchEnd)
+		if loc != nil {
+			if loc[0] < firstLoc[0] {
+				firstLoc = loc
+				firstRegion = r
+			}
+		}
+	}
+	if firstLoc[0] != len(line) {
+		highlights[start+firstLoc[0]] = firstRegion.limitGroup
+		h.highlightRegion(highlights, start, false, lineNum, line[:firstLoc[0]], curRegion, statesOnly)
+		h.highlightRegion(highlights, start+firstLoc[1], canMatchEnd, lineNum, line[firstLoc[1]:], firstRegion, statesOnly)
+		return highlights
+	}
+
+	fullHighlights := make([]Group, len([]rune(string(line))))
+	for i := 0; i < len(fullHighlights); i++ {
+		fullHighlights[i] = curRegion.group
+	}
+
+	for _, p := range curRegion.rules.patterns {
+		matches := findAllIndex(p.regex, line, start == 0, canMatchEnd)
+		for _, m := range matches {
+			for i := m[0]; i < m[1]; i++ {
+				fullHighlights[i] = p.group
+			}
+		}
+	}
+	for i, h := range fullHighlights {
+		if i == 0 || h != fullHighlights[i-1] {
+			// if _, ok := highlights[start+i]; !ok {
+			highlights[start+i] = h
+			// }
+		}
+	}
+
+	if canMatchEnd {
+		h.lastRegion = curRegion
+	}
+
+	return highlights
+}
+
+func (h *Highlighter) highlightEmptyRegion(highlights LineMatch, start int, canMatchEnd bool, lineNum int, line []rune, statesOnly bool) LineMatch {
+	if len(line) == 0 {
+		if canMatchEnd {
+			h.lastRegion = nil
+		}
+		return highlights
+	}
+
+	firstLoc := []int{len(line), 0}
+	var firstRegion *region
+	for _, r := range h.Def.rules.regions {
+		loc := findIndex(r.start, nil, line, start == 0, canMatchEnd)
+		if loc != nil {
+			if loc[0] < firstLoc[0] {
+				firstLoc = loc
+				firstRegion = r
+			}
+		}
+	}
+	if firstLoc[0] != len(line) {
+		if !statesOnly {
+			highlights[start+firstLoc[0]] = firstRegion.limitGroup
+		}
+		h.highlightEmptyRegion(highlights, start, false, lineNum, line[:firstLoc[0]], statesOnly)
+		h.highlightRegion(highlights, start+firstLoc[1], canMatchEnd, lineNum, line[firstLoc[1]:], firstRegion, statesOnly)
+		return highlights
+	}
+
+	if statesOnly {
+		if canMatchEnd {
+			h.lastRegion = nil
+		}
+
+		return highlights
+	}
+
+	fullHighlights := make([]Group, len(line))
+	for _, p := range h.Def.rules.patterns {
+		matches := findAllIndex(p.regex, line, start == 0, canMatchEnd)
+		for _, m := range matches {
+			for i := m[0]; i < m[1]; i++ {
+				fullHighlights[i] = p.group
+			}
+		}
+	}
+	for i, h := range fullHighlights {
+		if i == 0 || h != fullHighlights[i-1] {
+			// if _, ok := highlights[start+i]; !ok {
+			highlights[start+i] = h
+			// }
+		}
+	}
+
+	if canMatchEnd {
+		h.lastRegion = nil
+	}
+
+	return highlights
+}
+
+// HighlightString syntax highlights a string
+// Use this function for simple syntax highlighting and use the other functions for
+// more advanced syntax highlighting. They are optimized for quick rehighlighting of the same
+// text with minor changes made
+func (h *Highlighter) HighlightString(input string) []LineMatch {
+	lines := strings.Split(input, "\n")
+	var lineMatches []LineMatch
+
+	for i := 0; i < len(lines); i++ {
+		line := []rune(lines[i])
+		highlights := make(LineMatch)
+
+		if i == 0 || h.lastRegion == nil {
+			lineMatches = append(lineMatches, h.highlightEmptyRegion(highlights, 0, true, i, line, false))
+		} else {
+			lineMatches = append(lineMatches, h.highlightRegion(highlights, 0, true, i, line, h.lastRegion, false))
+		}
+	}
+
+	return lineMatches
+}
+
+// HighlightStates correctly sets all states for the buffer
+func (h *Highlighter) HighlightStates(input LineStates) {
+	for i := 0; i < input.LinesNum(); i++ {
+		line := []rune(input.Line(i))
+		// highlights := make(LineMatch)
+
+		if i == 0 || h.lastRegion == nil {
+			h.highlightEmptyRegion(nil, 0, true, i, line, true)
+		} else {
+			h.highlightRegion(nil, 0, true, i, line, h.lastRegion, true)
+		}
+
+		curState := h.lastRegion
+
+		input.SetState(i, curState)
+	}
+}
+
+// HighlightMatches sets the matches for each line in between startline and 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++ {
+		if i >= input.LinesNum() {
+			break
+		}
+
+		line := []rune(input.Line(i))
+		highlights := make(LineMatch)
+
+		var match LineMatch
+		if i == 0 || input.State(i-1) == nil {
+			match = h.highlightEmptyRegion(highlights, 0, true, i, line, false)
+		} else {
+			match = h.highlightRegion(highlights, 0, true, i, line, input.State(i-1), false)
+		}
+
+		input.SetMatch(i, match)
+	}
+}
+
+// ReHighlightStates will scan down from `startline` and set the appropriate end of line state
+// for each line until it comes across the same state in two consecutive lines
+func (h *Highlighter) ReHighlightStates(input LineStates, startline int) {
+	// lines := input.LineData()
+
+	h.lastRegion = nil
+	if startline > 0 {
+		h.lastRegion = input.State(startline - 1)
+	}
+	for i := startline; i < input.LinesNum(); i++ {
+		line := []rune(input.Line(i))
+		// highlights := make(LineMatch)
+
+		// var match LineMatch
+		if i == 0 || h.lastRegion == nil {
+			h.highlightEmptyRegion(nil, 0, true, i, line, true)
+		} else {
+			h.highlightRegion(nil, 0, true, i, line, h.lastRegion, true)
+		}
+		curState := h.lastRegion
+		lastState := input.State(i)
+
+		input.SetState(i, curState)
+
+		if curState == lastState {
+			break
+		}
+	}
+}
+
+// ReHighlightLine will rehighlight the state and match for a single line
+func (h *Highlighter) ReHighlightLine(input LineStates, lineN int) {
+	line := []rune(input.Line(lineN))
+	highlights := make(LineMatch)
+
+	h.lastRegion = nil
+	if lineN > 0 {
+		h.lastRegion = input.State(lineN - 1)
+	}
+
+	var match LineMatch
+	if lineN == 0 || h.lastRegion == nil {
+		match = h.highlightEmptyRegion(highlights, 0, true, lineN, line, false)
+	} else {
+		match = h.highlightRegion(highlights, 0, true, lineN, line, h.lastRegion, false)
+	}
+	curState := h.lastRegion
+
+	input.SetMatch(lineN, match)
+	input.SetState(lineN, curState)
+}

cmd/micro/highlight/parser.go

@@ -0,0 +1,314 @@
+package highlight
+
+import (
+	"fmt"
+	"regexp"
+
+	"gopkg.in/yaml.v2"
+)
+
+// A Group represents a syntax group
+type Group uint8
+
+// Groups contains all of the groups that are defined
+// You can access them in the map via their string name
+var Groups map[string]Group
+var numGroups Group
+
+// String returns the group name attached to the specific group
+func (g Group) String() string {
+	for k, v := range Groups {
+		if v == g {
+			return k
+		}
+	}
+	return ""
+}
+
+// A Def is a full syntax definition for a language
+// It has a filetype, information about how to detect the filetype based
+// on filename or header (the first line of the file)
+// Then it has the rules which define how to highlight the file
+type Def struct {
+	*Header
+
+	rules *rules
+}
+
+type Header struct {
+	FileType string
+	FtDetect [2]*regexp.Regexp
+}
+
+type File struct {
+	FileType string
+
+	yamlSrc map[interface{}]interface{}
+}
+
+// A Pattern is one simple syntax rule
+// It has a group that the rule belongs to, as well as
+// the regular expression to match the pattern
+type pattern struct {
+	group Group
+	regex *regexp.Regexp
+}
+
+// rules defines which patterns and regions can be used to highlight
+// a filetype
+type rules struct {
+	regions  []*region
+	patterns []*pattern
+	includes []string
+}
+
+// A region is a highlighted region (such as a multiline comment, or a string)
+// It belongs to a group, and has start and end regular expressions
+// A region also has rules of its own that only apply when matching inside the
+// region and also rules from the above region do not match inside this region
+// Note that a region may contain more regions
+type region struct {
+	group      Group
+	limitGroup Group
+	parent     *region
+	start      *regexp.Regexp
+	end        *regexp.Regexp
+	skip       *regexp.Regexp
+	rules      *rules
+}
+
+func init() {
+	Groups = make(map[string]Group)
+}
+
+func ParseFtDetect(file *File) (r [2]*regexp.Regexp, err error) {
+	rules := file.yamlSrc
+
+	loaded := 0
+	for k, v := range rules {
+		if k == "detect" {
+			ftdetect := v.(map[interface{}]interface{})
+			if len(ftdetect) >= 1 {
+				syntax, err := regexp.Compile(ftdetect["filename"].(string))
+				if err != nil {
+					return r, err
+				}
+
+				r[0] = syntax
+			}
+			if len(ftdetect) >= 2 {
+				header, err := regexp.Compile(ftdetect["header"].(string))
+				if err != nil {
+					return r, err
+				}
+
+				r[1] = header
+			}
+			loaded++
+		}
+
+		if loaded >= 2 {
+			break
+		}
+	}
+
+	return r, err
+}
+
+func ParseFile(input []byte) (f *File, err error) {
+	// This is just so if we have an error, we can exit cleanly and return the parse error to the user
+	defer func() {
+		if e := recover(); e != nil {
+			err = e.(error)
+		}
+	}()
+
+	var rules map[interface{}]interface{}
+	if err = yaml.Unmarshal(input, &rules); err != nil {
+		return nil, err
+	}
+
+	f = new(File)
+	f.yamlSrc = rules
+
+	for k, v := range rules {
+		if k == "filetype" {
+			filetype := v.(string)
+
+			f.FileType = filetype
+			break
+		}
+	}
+
+	return f, err
+}
+
+// ParseDef parses an input syntax file into a highlight Def
+func ParseDef(f *File, header *Header) (s *Def, err error) {
+	// This is just so if we have an error, we can exit cleanly and return the parse error to the user
+	defer func() {
+		if e := recover(); e != nil {
+			err = e.(error)
+		}
+	}()
+
+	rules := f.yamlSrc
+
+	s = new(Def)
+	s.Header = header
+
+	for k, v := range rules {
+		if k == "rules" {
+			inputRules := v.([]interface{})
+
+			rules, err := parseRules(inputRules, nil)
+			if err != nil {
+				return nil, err
+			}
+
+			s.rules = rules
+		}
+	}
+
+	return s, err
+}
+
+// ResolveIncludes will sort out the rules for including other filetypes
+// You should call this after parsing all the Defs
+func ResolveIncludes(def *Def, files []*File) {
+	resolveIncludesInDef(files, def)
+}
+
+func resolveIncludesInDef(files []*File, d *Def) {
+	for _, lang := range d.rules.includes {
+		for _, searchFile := range files {
+			if lang == searchFile.FileType {
+				searchDef, _ := ParseDef(searchFile, nil)
+				d.rules.patterns = append(d.rules.patterns, searchDef.rules.patterns...)
+				d.rules.regions = append(d.rules.regions, searchDef.rules.regions...)
+			}
+		}
+	}
+	for _, r := range d.rules.regions {
+		resolveIncludesInRegion(files, r)
+		r.parent = nil
+	}
+}
+
+func resolveIncludesInRegion(files []*File, region *region) {
+	for _, lang := range region.rules.includes {
+		for _, searchFile := range files {
+			if lang == searchFile.FileType {
+				searchDef, _ := ParseDef(searchFile, nil)
+				region.rules.patterns = append(region.rules.patterns, searchDef.rules.patterns...)
+				region.rules.regions = append(region.rules.regions, searchDef.rules.regions...)
+			}
+		}
+	}
+	for _, r := range region.rules.regions {
+		resolveIncludesInRegion(files, r)
+		r.parent = region
+	}
+}
+
+func parseRules(input []interface{}, curRegion *region) (*rules, error) {
+	rules := new(rules)
+
+	for _, v := range input {
+		rule := v.(map[interface{}]interface{})
+		for k, val := range rule {
+			group := k
+
+			switch object := val.(type) {
+			case string:
+				if k == "include" {
+					rules.includes = append(rules.includes, object)
+				} else {
+					// Pattern
+					r, err := regexp.Compile(object)
+					if err != nil {
+						return nil, err
+					}
+
+					groupStr := group.(string)
+					if _, ok := Groups[groupStr]; !ok {
+						numGroups++
+						Groups[groupStr] = numGroups
+					}
+					groupNum := Groups[groupStr]
+					rules.patterns = append(rules.patterns, &pattern{groupNum, r})
+				}
+			case map[interface{}]interface{}:
+				// region
+				region, err := parseRegion(group.(string), object, curRegion)
+				if err != nil {
+					return nil, err
+				}
+				rules.regions = append(rules.regions, region)
+			default:
+				return nil, fmt.Errorf("Bad type %T", object)
+			}
+		}
+	}
+
+	return rules, nil
+}
+
+func parseRegion(group string, regionInfo map[interface{}]interface{}, prevRegion *region) (*region, error) {
+	var err error
+
+	region := new(region)
+	if _, ok := Groups[group]; !ok {
+		numGroups++
+		Groups[group] = numGroups
+	}
+	groupNum := Groups[group]
+	region.group = groupNum
+	region.parent = prevRegion
+
+	region.start, err = regexp.Compile(regionInfo["start"].(string))
+
+	if err != nil {
+		return nil, err
+	}
+
+	region.end, err = regexp.Compile(regionInfo["end"].(string))
+
+	if err != nil {
+		return nil, err
+	}
+
+	// skip is optional
+	if _, ok := regionInfo["skip"]; ok {
+		region.skip, err = regexp.Compile(regionInfo["skip"].(string))
+
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	// limit-color is optional
+	if _, ok := regionInfo["limit-group"]; ok {
+		groupStr := regionInfo["limit-group"].(string)
+		if _, ok := Groups[groupStr]; !ok {
+			numGroups++
+			Groups[groupStr] = numGroups
+		}
+		groupNum := Groups[groupStr]
+		region.limitGroup = groupNum
+
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		region.limitGroup = region.group
+	}
+
+	region.rules, err = parseRules(regionInfo["rules"].([]interface{}), region)
+
+	if err != nil {
+		return nil, err
+	}
+
+	return region, nil
+}

cmd/micro/highlighter.go

@@ -1,496 +1,28 @@
 package main
 
-import (
-	"github.com/zyedidia/tcell"
-	"io/ioutil"
-	"path/filepath"
-	"regexp"
-	"strings"
-)
+import "github.com/zyedidia/micro/cmd/micro/highlight"
 
-// FileTypeRules represents a complete set of syntax rules for a filetype
-type FileTypeRules struct {
-	filetype string
-	filename string
-	text     string
-}
+var syntaxFiles []*highlight.File
 
-// SyntaxRule represents a regex to highlight in a certain style
-type SyntaxRule struct {
-	// What to highlight
-	regex *regexp.Regexp
-	// Any flags
-	flags string
-	// Whether this regex is a start=... end=... regex
-	startend bool
-	// How to highlight it
-	style tcell.Style
-}
-
-var syntaxFiles map[[2]*regexp.Regexp]FileTypeRules
-
-// These syntax files are pre installed and embedded in the resulting binary by go-bindata
-var preInstalledSynFiles = []string{
-	"Dockerfile",
-	"apacheconf",
-	"arduino",
-	"asciidoc",
-	"asm",
-	"awk",
-	"c",
-	"cmake",
-	"coffeescript",
-	"colortest",
-	"conf",
-	"conky",
-	"csharp",
-	"css",
-	"cython",
-	"d",
-	"dot",
-	"erb",
-	"fish",
-	"fortran",
-	"gdscript",
-	"gentoo-ebuild",
-	"gentoo-etc-portage",
-	"git-commit",
-	"git-config",
-	"git-rebase-todo",
-	"glsl",
-	"go",
-	"golo",
-	"groff",
-	"haml",
-	"haskell",
-	"html",
-	"ini",
-	"inputrc",
-	"java",
-	"javascript",
-	"json",
-	"keymap",
-	"kickstart",
-	"ledger",
-	"lilypond",
-	"lisp",
-	"lua",
-	"makefile",
-	"man",
-	"markdown",
-	"mpdconf",
-	"nanorc",
-	"nginx",
-	"ocaml",
-	"patch",
-	"peg",
-	"perl",
-	"perl6",
-	"php",
-	"pkg-config",
-	"pkgbuild",
-	"po",
-	"pov",
-	"privoxy-action",
-	"privoxy-config",
-	"privoxy-filter",
-	"puppet",
-	"python",
-	"r",
-	"reST",
-	"rpmspec",
-	"ruby",
-	"rust",
-	"scala",
-	"sed",
-	"sh",
-	"sls",
-	"sql",
-	"swift",
-	"systemd",
-	"tcl",
-	"tex",
-	"vala",
-	"vi",
-	"xml",
-	"xresources",
-	"yaml",
-	"yum",
-	"zsh",
-}
-
-// LoadSyntaxFiles loads the syntax files from the default directory (configDir)
 func LoadSyntaxFiles() {
-	// Load the user's custom syntax files, if there are any
-	LoadSyntaxFilesFromDir(configDir + "/syntax")
-
-	// Load the pre-installed syntax files from inside the binary
-	for _, filetype := range preInstalledSynFiles {
-		data, err := Asset("runtime/syntax/" + filetype + ".micro")
-		if err != nil {
-			TermMessage("Unable to load pre-installed syntax file " + filetype)
-			continue
-		}
-
-		LoadSyntaxFile(string(data), filetype+".micro")
-	}
-}
-
-// LoadSyntaxFilesFromDir loads the syntax files from a specified directory
-// To load the syntax files, we must fill the `syntaxFiles` map
-// This involves finding the regex for syntax and if it exists, the regex
-// for the header. Then we must get the text for the file and the filetype.
-func LoadSyntaxFilesFromDir(dir string) {
-	colorscheme = make(Colorscheme)
 	InitColorscheme()
-
-	// Default style
-	defStyle = tcell.StyleDefault.
-		Foreground(tcell.ColorDefault).
-		Background(tcell.ColorDefault)
-
-	// There may be another default style defined in the colorscheme
-	// In that case we should use that one
-	if style, ok := colorscheme["default"]; ok {
-		defStyle = style
-	}
-	if screen != nil {
-		screen.SetStyle(defStyle)
-	}
-
-	syntaxFiles = make(map[[2]*regexp.Regexp]FileTypeRules)
-	files, _ := ioutil.ReadDir(dir)
-	for _, f := range files {
-		if filepath.Ext(f.Name()) == ".micro" {
-			filename := dir + "/" + f.Name()
-			text, err := ioutil.ReadFile(filename)
-
-			if err != nil {
-				TermMessage("Error loading syntax file " + filename + ": " + err.Error())
-				return
-			}
-			LoadSyntaxFile(string(text), filename)
-		}
-	}
-}
-
-// JoinRule takes a syntax rule (which can be multiple regular expressions)
-// and joins it into one regular expression by ORing everything together
-func JoinRule(rule string) string {
-	split := strings.Split(rule, `" "`)
-	joined := strings.Join(split, ")|(")
-	joined = "(" + joined + ")"
-	return joined
-}
-
-// LoadSyntaxFile simply gets the filetype of a the syntax file and the source for the
-// file and creates FileTypeRules out of it. If this filetype is the one opened by the user
-// the rules will be loaded and compiled later
-// In this function we are only concerned with loading the syntax and header regexes
-func LoadSyntaxFile(text, filename string) {
-	var err error
-	lines := strings.Split(string(text), "\n")
-
-	// Regex for parsing syntax statements
-	syntaxParser := regexp.MustCompile(`syntax "(.*?)"\s+"(.*)"+`)
-	// Regex for parsing header statements
-	headerParser := regexp.MustCompile(`header "(.*)"`)
-
-	// Is there a syntax definition in this file?
-	hasSyntax := syntaxParser.MatchString(text)
-	// Is there a header definition in this file?
-	hasHeader := headerParser.MatchString(text)
-
-	var syntaxRegex *regexp.Regexp
-	var headerRegex *regexp.Regexp
-	var filetype string
-	for lineNum, line := range lines {
-		if (hasSyntax == (syntaxRegex != nil)) && (hasHeader == (headerRegex != nil)) {
-			// We found what we we're supposed to find
-			break
-		}
-
-		if strings.TrimSpace(line) == "" ||
-			strings.TrimSpace(line)[0] == '#' {
-			// Ignore this line
-			continue
-		}
-
-		if strings.HasPrefix(line, "syntax") {
-			// Syntax statement
-			syntaxMatches := syntaxParser.FindSubmatch([]byte(line))
-			if len(syntaxMatches) == 3 {
-				if syntaxRegex != nil {
-					TermError(filename, lineNum, "Syntax statement redeclaration")
-				}
-
-				filetype = string(syntaxMatches[1])
-				extensions := JoinRule(string(syntaxMatches[2]))
-
-				syntaxRegex, err = regexp.Compile(extensions)
-				if err != nil {
-					TermError(filename, lineNum, err.Error())
-					continue
-				}
-			} else {
-				TermError(filename, lineNum, "Syntax statement is not valid: "+line)
-				continue
-			}
-		} else if strings.HasPrefix(line, "header") {
-			// Header statement
-			headerMatches := headerParser.FindSubmatch([]byte(line))
-			if len(headerMatches) == 2 {
-				header := JoinRule(string(headerMatches[1]))
-
-				headerRegex, err = regexp.Compile(header)
-				if err != nil {
-					TermError(filename, lineNum, "Regex error: "+err.Error())
-					continue
-				}
-			} else {
-				TermError(filename, lineNum, "Header statement is not valid: "+line)
-				continue
-			}
-		}
-	}
-	if syntaxRegex != nil {
-		// Add the current rules to the syntaxFiles variable
-		regexes := [2]*regexp.Regexp{syntaxRegex, headerRegex}
-		syntaxFiles[regexes] = FileTypeRules{filetype, filename, text}
-	}
-}
-
-// LoadRulesFromFile loads just the syntax rules from a given file
-// Only the necessary rules are loaded when the buffer is opened.
-// If we load all the rules for every filetype when micro starts, there's a bit of lag
-// A rule just explains how to color certain regular expressions
-// Example: color comment "//.*"
-// This would color all strings that match the regex "//.*" in the comment color defined
-// by the colorscheme
-func LoadRulesFromFile(text, filename string) []SyntaxRule {
-	lines := strings.Split(string(text), "\n")
-
-	// Regex for parsing standard syntax rules
-	ruleParser := regexp.MustCompile(`color (.*?)\s+(?:\((.*?)\)\s+)?"(.*)"`)
-	// Regex for parsing syntax rules with start="..." end="..."
-	ruleStartEndParser := regexp.MustCompile(`color (.*?)\s+(?:\((.*?)\)\s+)?start="(.*)"\s+end="(.*)"`)
-
-	var rules []SyntaxRule
-	for lineNum, line := range lines {
-		if strings.TrimSpace(line) == "" ||
-			strings.TrimSpace(line)[0] == '#' ||
-			strings.HasPrefix(line, "syntax") ||
-			strings.HasPrefix(line, "header") {
-			// Ignore this line
-			continue
-		}
-
-		// Syntax rule, but it could be standard or start-end
-		if ruleParser.MatchString(line) {
-			// Standard syntax rule
-			// Parse the line
-			submatch := ruleParser.FindSubmatch([]byte(line))
-			var color string
-			var regexStr string
-			var flags string
-			if len(submatch) == 4 {
-				// If len is 4 then the user specified some additional flags to use
-				color = string(submatch[1])
-				flags = string(submatch[2])
-				regexStr = "(?" + flags + ")" + JoinRule(string(submatch[3]))
-			} else if len(submatch) == 3 {
-				// If len is 3, no additional flags were given
-				color = string(submatch[1])
-				regexStr = JoinRule(string(submatch[2]))
-			} else {
-				// If len is not 3 or 4 there is a problem
-				TermError(filename, lineNum, "Invalid statement: "+line)
-				continue
-			}
-			// Compile the regex
-			regex, err := regexp.Compile(regexStr)
-			if err != nil {
-				TermError(filename, lineNum, err.Error())
-				continue
-			}
-
-			// Get the style
-			// The user could give us a "color" that is really a part of the colorscheme
-			// in which case we should look that up in the colorscheme
-			// They can also just give us a straight up color
-			st := defStyle
-			groups := strings.Split(color, ".")
-			if len(groups) > 1 {
-				curGroup := ""
-				for i, g := range groups {
-					if i != 0 {
-						curGroup += "."
-					}
-					curGroup += g
-					if style, ok := colorscheme[curGroup]; ok {
-						st = style
-					}
-				}
-			} else if style, ok := colorscheme[color]; ok {
-				st = style
-			} else {
-				st = StringToStyle(color)
-			}
-			// Add the regex, flags, and style
-			// False because this is not start-end
-			rules = append(rules, SyntaxRule{regex, flags, false, st})
-		} else if ruleStartEndParser.MatchString(line) {
-			// Start-end syntax rule
-			submatch := ruleStartEndParser.FindSubmatch([]byte(line))
-			var color string
-			var start string
-			var end string
-			// Use m and s flags by default
-			flags := "ms"
-			if len(submatch) == 5 {
-				// If len is 5 the user provided some additional flags
-				color = string(submatch[1])
-				flags += string(submatch[2])
-				start = string(submatch[3])
-				end = string(submatch[4])
-			} else if len(submatch) == 4 {
-				// If len is 4 the user did not provide additional flags
-				color = string(submatch[1])
-				start = string(submatch[2])
-				end = string(submatch[3])
-			} else {
-				// If len is not 4 or 5 there is a problem
-				TermError(filename, lineNum, "Invalid statement: "+line)
-				continue
-			}
-
-			// Compile the regex
-			regex, err := regexp.Compile("(?" + flags + ")" + "(" + start + ").*?(" + end + ")")
-			if err != nil {
-				TermError(filename, lineNum, err.Error())
-				continue
-			}
-
-			// Get the style
-			// The user could give us a "color" that is really a part of the colorscheme
-			// in which case we should look that up in the colorscheme
-			// They can also just give us a straight up color
-			st := defStyle
-			if _, ok := colorscheme[color]; ok {
-				st = colorscheme[color]
-			} else {
-				st = StringToStyle(color)
-			}
-			// Add the regex, flags, and style
-			// True because this is start-end
-			rules = append(rules, SyntaxRule{regex, flags, true, st})
-		}
-	}
-	return rules
-}
-
-// FindFileType finds the filetype for the given buffer
-func FindFileType(buf *Buffer) string {
-	for r := range syntaxFiles {
-		if r[0] != nil && r[0].MatchString(buf.Path) {
-			// The syntax statement matches the extension
-			return syntaxFiles[r].filetype
-		} else if r[1] != nil && r[1].MatchString(buf.Line(0)) {
-			// The header statement matches the first line
-			return syntaxFiles[r].filetype
-		}
-	}
-	return "Unknown"
-}
-
-// GetRules finds the syntax rules that should be used for the buffer
-// and returns them. It also returns the filetype of the file
-func GetRules(buf *Buffer) []SyntaxRule {
-	for r := range syntaxFiles {
-		if syntaxFiles[r].filetype == buf.FileType() {
-			return LoadRulesFromFile(syntaxFiles[r].text, syntaxFiles[r].filename)
-		}
-	}
-	return nil
-}
-
-// SyntaxMatches is an alias to a map from character numbers to styles,
-// so map[3] represents the style of the third character
-type SyntaxMatches [][]tcell.Style
-
-// Match takes a buffer and returns the syntax matches: a 2d array specifying how it should be syntax highlighted
-// We match the rules from up `synLinesUp` lines and down `synLinesDown` lines
-func Match(v *View) SyntaxMatches {
-	buf := v.Buf
-	rules := v.Buf.rules
-
-	viewStart := v.Topline
-	viewEnd := v.Topline + v.height
-	if viewEnd > buf.NumLines {
-		viewEnd = buf.NumLines
-	}
-
-	lines := buf.Lines(viewStart, viewEnd)
-	matches := make(SyntaxMatches, len(lines))
-
-	for i, line := range lines {
-		matches[i] = make([]tcell.Style, len(line)+1)
-		for j := range matches[i] {
-			matches[i][j] = defStyle
-		}
-	}
-
-	// We don't actually check the entire buffer, just from synLinesUp to synLinesDown
-	totalStart := v.Topline - synLinesUp
-	totalEnd := v.Topline + v.height + synLinesDown
-	if totalStart < 0 {
-		totalStart = 0
-	}
-	if totalEnd > buf.NumLines {
-		totalEnd = buf.NumLines
-	}
-
-	str := strings.Join(buf.Lines(totalStart, totalEnd), "\n")
-	startNum := ToCharPos(Loc{0, totalStart}, v.Buf)
-
-	for _, rule := range rules {
-		if rule.startend {
-			if indicies := rule.regex.FindAllStringIndex(str, -1); indicies != nil {
-				for _, value := range indicies {
-					value[0] = runePos(value[0], str) + startNum
-					value[1] = runePos(value[1], str) + startNum
-					startLoc := FromCharPos(value[0], buf)
-					endLoc := FromCharPos(value[1], buf)
-					for curLoc := startLoc; curLoc.LessThan(endLoc); curLoc = curLoc.Move(1, buf) {
-						if curLoc.Y < v.Topline {
-							continue
-						}
-						colNum, lineNum := curLoc.X, curLoc.Y
-						if lineNum == -1 || colNum == -1 {
-							continue
-						}
-						lineNum -= viewStart
-						if lineNum >= 0 && lineNum < v.height {
-							matches[lineNum][colNum] = rule.style
-						}
-					}
-				}
-			}
+	for _, f := range ListRuntimeFiles(RTSyntax) {
+		data, err := f.Data()
+		if err != nil {
+			TermMessage("Error loading syntax file " + f.Name() + ": " + err.Error())
 		} else {
-			for lineN, line := range lines {
-				if indicies := rule.regex.FindAllStringIndex(line, -1); indicies != nil {
-					for _, value := range indicies {
-						start := runePos(value[0], line)
-						end := runePos(value[1], line)
-						// messenger.Message(start, " ", end)
-						for i := start; i < end; i++ {
-							matches[lineN][i] = rule.style
-						}
-					}
-				}
-			}
+			LoadSyntaxFile(data, f.Name())
 		}
 	}
-
-	return matches
+}
+
+func LoadSyntaxFile(text []byte, filename string) {
+	f, err := highlight.ParseFile(text)
+
+	if err != nil {
+		TermMessage("Syntax file error: " + filename + ": " + err.Error())
+		return
+	}
+
+	syntaxFiles = append(syntaxFiles, f)
 }

cmd/micro/job.go

@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"io"
 	"os/exec"
-	"strings"
 )
 
 // Jobs are the way plugins can run processes in the background
@@ -40,15 +39,17 @@ func (f *CallbackFile) Write(data []byte) (int, error) {
 	return f.Writer.Write(data)
 }
 
-// JobStart starts a process in the background with the given callbacks
+// JobStart starts a shell command in the background with the given callbacks
 // It returns an *exec.Cmd as the job id
 func JobStart(cmd string, onStdout, onStderr, onExit string, userargs ...string) *exec.Cmd {
-	split := strings.Split(cmd, " ")
-	args := split[1:]
-	cmdName := split[0]
+	return JobSpawn("sh", []string{"-c", cmd}, onStdout, onStderr, onExit, userargs...)
+}
 
+// JobSpawn starts a process with args in the background with the given callbacks
+// It returns an *exec.Cmd as the job id
+func JobSpawn(cmdName string, cmdArgs []string, onStdout, onStderr, onExit string, userargs ...string) *exec.Cmd {
 	// Set up everything correctly if the functions have been provided
-	proc := exec.Command(cmdName, args...)
+	proc := exec.Command(cmdName, cmdArgs...)
 	var outbuf bytes.Buffer
 	if onStdout != "" {
 		proc.Stdout = &CallbackFile{&outbuf, LuaFunctionJob(onStdout), userargs}

cmd/micro/lineArray.go

@@ -1,8 +1,11 @@
 package main
 
 import (
-	"bytes"
+	"bufio"
+	"io"
 	"unicode/utf8"
+
+	"github.com/zyedidia/micro/cmd/micro/highlight"
 )
 
 func runeToByteIndex(n int, txt []byte) int {
@@ -26,21 +29,74 @@ func runeToByteIndex(n int, txt []byte) int {
 	return count
 }
 
+type Line struct {
+	data []byte
+
+	state       highlight.State
+	match       highlight.LineMatch
+	rehighlight bool
+}
+
 // A LineArray simply stores and array of lines and makes it easy to insert
 // and delete in it
 type LineArray struct {
-	lines [][]byte
+	lines []Line
+}
+
+func Append(slice []Line, data ...Line) []Line {
+	l := len(slice)
+	if l+len(data) > cap(slice) { // reallocate
+		// Allocate double what's needed, for future growth.
+		newSlice := make([]Line, (l+len(data))+10000)
+		// The copy function is predeclared and works for any slice type.
+		copy(newSlice, slice)
+		slice = newSlice
+	}
+	slice = slice[0 : l+len(data)]
+	for i, c := range data {
+		slice[l+i] = c
+	}
+	return slice
 }
 
 // NewLineArray returns a new line array from an array of bytes
-func NewLineArray(text []byte) *LineArray {
+func NewLineArray(size int64, reader io.Reader) *LineArray {
 	la := new(LineArray)
-	// Split the bytes into lines
-	split := bytes.Split(text, []byte("\n"))
-	la.lines = make([][]byte, len(split))
-	for i := range split {
-		la.lines[i] = make([]byte, len(split[i]))
-		copy(la.lines[i], split[i])
+
+	la.lines = make([]Line, 0, 1000)
+
+	br := bufio.NewReader(reader)
+	var loaded int
+
+	n := 0
+	for {
+		data, err := br.ReadBytes('\n')
+
+		if n >= 1000 && loaded >= 0 {
+			totalLinesNum := int(float64(size) * (float64(n) / float64(loaded)))
+			newSlice := make([]Line, len(la.lines), totalLinesNum+10000)
+			// The copy function is predeclared and works for any slice type.
+			copy(newSlice, la.lines)
+			la.lines = newSlice
+			loaded = -1
+		}
+
+		if loaded >= 0 {
+			loaded += len(data)
+		}
+
+		if err != nil {
+			if err == io.EOF {
+				la.lines = Append(la.lines, Line{data[:len(data)], nil, nil, false})
+				// la.lines = Append(la.lines, Line{data[:len(data)]})
+			}
+			// Last line was read
+			break
+		} else {
+			// la.lines = Append(la.lines, Line{data[:len(data)-1]})
+			la.lines = Append(la.lines, Line{data[:len(data)-1], nil, nil, false})
+		}
+		n++
 	}
 
 	return la
@@ -48,19 +104,26 @@ func NewLineArray(text []byte) *LineArray {
 
 // Returns the String representation of the LineArray
 func (la *LineArray) String() string {
-	return string(bytes.Join(la.lines, []byte("\n")))
+	str := ""
+	for i, l := range la.lines {
+		str += string(l.data)
+		if i != len(la.lines)-1 {
+			str += "\n"
+		}
+	}
+	return str
 }
 
 // NewlineBelow adds a newline below the given line number
 func (la *LineArray) NewlineBelow(y int) {
-	la.lines = append(la.lines, []byte(" "))
+	la.lines = append(la.lines, Line{[]byte(" "), nil, nil, false})
 	copy(la.lines[y+2:], la.lines[y+1:])
-	la.lines[y+1] = []byte("")
+	la.lines[y+1] = Line{[]byte(""), la.lines[y].state, nil, false}
 }
 
 // inserts a byte array at a given location
 func (la *LineArray) insert(pos Loc, value []byte) {
-	x, y := runeToByteIndex(pos.X, la.lines[pos.Y]), pos.Y
+	x, y := runeToByteIndex(pos.X, la.lines[pos.Y].data), pos.Y
 	// x, y := pos.x, pos.y
 	for i := 0; i < len(value); i++ {
 		if value[i] == '\n' {
@@ -76,31 +139,36 @@ func (la *LineArray) insert(pos Loc, value []byte) {
 
 // inserts a byte at a given location
 func (la *LineArray) insertByte(pos Loc, value byte) {
-	la.lines[pos.Y] = append(la.lines[pos.Y], 0)
-	copy(la.lines[pos.Y][pos.X+1:], la.lines[pos.Y][pos.X:])
-	la.lines[pos.Y][pos.X] = value
+	la.lines[pos.Y].data = append(la.lines[pos.Y].data, 0)
+	copy(la.lines[pos.Y].data[pos.X+1:], la.lines[pos.Y].data[pos.X:])
+	la.lines[pos.Y].data[pos.X] = value
 }
 
 // JoinLines joins the two lines a and b
 func (la *LineArray) JoinLines(a, b int) {
-	la.insert(Loc{len(la.lines[a]), a}, la.lines[b])
+	la.insert(Loc{len(la.lines[a].data), a}, la.lines[b].data)
 	la.DeleteLine(b)
 }
 
 // Split splits a line at a given position
 func (la *LineArray) Split(pos Loc) {
 	la.NewlineBelow(pos.Y)
-	la.insert(Loc{0, pos.Y + 1}, la.lines[pos.Y][pos.X:])
+	la.insert(Loc{0, pos.Y + 1}, la.lines[pos.Y].data[pos.X:])
+	la.lines[pos.Y+1].state = la.lines[pos.Y].state
+	la.lines[pos.Y].state = nil
+	la.lines[pos.Y].match = nil
+	la.lines[pos.Y+1].match = nil
+	la.lines[pos.Y].rehighlight = true
 	la.DeleteToEnd(Loc{pos.X, pos.Y})
 }
 
 // removes from start to end
 func (la *LineArray) remove(start, end Loc) string {
 	sub := la.Substr(start, end)
-	startX := runeToByteIndex(start.X, la.lines[start.Y])
-	endX := runeToByteIndex(end.X, la.lines[end.Y])
+	startX := runeToByteIndex(start.X, la.lines[start.Y].data)
+	endX := runeToByteIndex(end.X, la.lines[end.Y].data)
 	if start.Y == end.Y {
-		la.lines[start.Y] = append(la.lines[start.Y][:startX], la.lines[start.Y][endX:]...)
+		la.lines[start.Y].data = append(la.lines[start.Y].data[:startX], la.lines[start.Y].data[endX:]...)
 	} else {
 		for i := start.Y + 1; i <= end.Y-1; i++ {
 			la.DeleteLine(start.Y + 1)
@@ -114,12 +182,12 @@ func (la *LineArray) remove(start, end Loc) string {
 
 // DeleteToEnd deletes from the end of a line to the position
 func (la *LineArray) DeleteToEnd(pos Loc) {
-	la.lines[pos.Y] = la.lines[pos.Y][:pos.X]
+	la.lines[pos.Y].data = la.lines[pos.Y].data[:pos.X]
 }
 
 // DeleteFromStart deletes from the start of a line to the position
 func (la *LineArray) DeleteFromStart(pos Loc) {
-	la.lines[pos.Y] = la.lines[pos.Y][pos.X+1:]
+	la.lines[pos.Y].data = la.lines[pos.Y].data[pos.X+1:]
 }
 
 // DeleteLine deletes the line number
@@ -129,21 +197,37 @@ func (la *LineArray) DeleteLine(y int) {
 
 // DeleteByte deletes the byte at a position
 func (la *LineArray) DeleteByte(pos Loc) {
-	la.lines[pos.Y] = la.lines[pos.Y][:pos.X+copy(la.lines[pos.Y][pos.X:], la.lines[pos.Y][pos.X+1:])]
+	la.lines[pos.Y].data = la.lines[pos.Y].data[:pos.X+copy(la.lines[pos.Y].data[pos.X:], la.lines[pos.Y].data[pos.X+1:])]
 }
 
 // Substr returns the string representation between two locations
 func (la *LineArray) Substr(start, end Loc) string {
-	startX := runeToByteIndex(start.X, la.lines[start.Y])
-	endX := runeToByteIndex(end.X, la.lines[end.Y])
+	startX := runeToByteIndex(start.X, la.lines[start.Y].data)
+	endX := runeToByteIndex(end.X, la.lines[end.Y].data)
 	if start.Y == end.Y {
-		return string(la.lines[start.Y][startX:endX])
+		return string(la.lines[start.Y].data[startX:endX])
 	}
 	var str string
-	str += string(la.lines[start.Y][startX:]) + "\n"
+	str += string(la.lines[start.Y].data[startX:]) + "\n"
 	for i := start.Y + 1; i <= end.Y-1; i++ {
-		str += string(la.lines[i]) + "\n"
+		str += string(la.lines[i].data) + "\n"
 	}
-	str += string(la.lines[end.Y][:endX])
+	str += string(la.lines[end.Y].data[:endX])
 	return str
 }
+
+func (la *LineArray) State(lineN int) highlight.State {
+	return la.lines[lineN].state
+}
+
+func (la *LineArray) SetState(lineN int, s highlight.State) {
+	la.lines[lineN].state = s
+}
+
+func (la *LineArray) SetMatch(lineN int, m highlight.LineMatch) {
+	la.lines[lineN].match = m
+}
+
+func (la *LineArray) Match(lineN int) highlight.LineMatch {
+	return la.lines[lineN].match
+}

cmd/micro/loc.go

@@ -28,6 +28,27 @@ func ToCharPos(start Loc, buf *Buffer) int {
 	return loc
 }
 
+// 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 >= buf.NumLines || pos.X < 0 || pos.X > Count(buf.Line(pos.Y)) {
+		return false
+	}
+
+	return true
+}
+
+// ByteOffset is just like ToCharPos except it counts bytes instead of runes
+func ByteOffset(pos Loc, buf *Buffer) int {
+	x, y := pos.X, pos.Y
+	loc := 0
+	for i := 0; i < y; i++ {
+		// + 1 for the newline
+		loc += len(buf.Line(i)) + 1
+	}
+	loc += len(buf.Line(y)[:x])
+	return loc
+}
+
 // Loc stores a location
 type Loc struct {
 	X, Y int

cmd/micro/messenger.go

@@ -6,7 +6,6 @@ import (
 	"fmt"
 	"os"
 	"strconv"
-	"strings"
 
 	"github.com/zyedidia/clipboard"
 	"github.com/zyedidia/tcell"
@@ -22,6 +21,7 @@ func TermMessage(msg ...interface{}) {
 	screenWasNil := screen == nil
 	if !screenWasNil {
 		screen.Fini()
+		screen = nil
 	}
 
 	fmt.Println(msg...)
@@ -44,6 +44,7 @@ func TermError(filename string, lineNum int, err string) {
 // Messenger is an object that makes it easy to send messages to the user
 // and get input from the user
 type Messenger struct {
+	log *Buffer
 	// Are we currently prompting the user?
 	hasPrompt bool
 	// Is there a message to print
@@ -68,37 +69,85 @@ type Messenger struct {
 	gutterMessage bool
 }
 
+func (m *Messenger) AddLog(msg string) {
+	buffer := m.getBuffer()
+	buffer.insert(buffer.End(), []byte(msg+"\n"))
+	buffer.Cursor.Loc = buffer.End()
+	buffer.Cursor.Relocate()
+}
+
+func (m *Messenger) getBuffer() *Buffer {
+	if m.log == nil {
+		m.log = NewBufferFromString("", "")
+		m.log.name = "Log"
+	}
+	return m.log
+}
+
 // Message sends a message to the user
 func (m *Messenger) Message(msg ...interface{}) {
-	buf := new(bytes.Buffer)
-	fmt.Fprint(buf, msg...)
-	m.message = buf.String()
-	m.style = defStyle
+	displayMessage := fmt.Sprint(msg...)
+	// only display a new message if there isn't an active prompt
+	// this is to prevent overwriting an existing prompt to the user
+	if m.hasPrompt == false {
+		// if there is no active prompt then style and display the message as normal
+		m.message = displayMessage
 
-	if _, ok := colorscheme["message"]; ok {
-		m.style = colorscheme["message"]
+		m.style = defStyle
+
+		if _, ok := colorscheme["message"]; ok {
+			m.style = colorscheme["message"]
+		}
+
+		m.hasMessage = true
 	}
-	m.hasMessage = true
+	// add the message to the log regardless of active prompts
+	m.AddLog(displayMessage)
 }
 
 // Error sends an error message to the user
 func (m *Messenger) Error(msg ...interface{}) {
 	buf := new(bytes.Buffer)
 	fmt.Fprint(buf, msg...)
-	m.message = buf.String()
-	m.style = defStyle.
-		Foreground(tcell.ColorBlack).
-		Background(tcell.ColorMaroon)
 
-	if _, ok := colorscheme["error-message"]; ok {
-		m.style = colorscheme["error-message"]
+	// only display a new message if there isn't an active prompt
+	// this is to prevent overwriting an existing prompt to the user
+	if m.hasPrompt == false {
+		// if there is no active prompt then style and display the message as normal
+		m.message = buf.String()
+		m.style = defStyle.
+			Foreground(tcell.ColorBlack).
+			Background(tcell.ColorMaroon)
+
+		if _, ok := colorscheme["error-message"]; ok {
+			m.style = colorscheme["error-message"]
+		}
+		m.hasMessage = true
 	}
+	// add the message to the log regardless of active prompts
+	m.AddLog(buf.String())
+}
+
+func (m *Messenger) PromptText(msg ...interface{}) {
+	displayMessage := fmt.Sprint(msg...)
+	// if there is no active prompt then style and display the message as normal
+	m.message = displayMessage
+
+	m.style = defStyle
+
+	if _, ok := colorscheme["message"]; ok {
+		m.style = colorscheme["message"]
+	}
+
 	m.hasMessage = true
+	// add the message to the log regardless of active prompts
+	m.AddLog(displayMessage)
 }
 
 // YesNoPrompt asks the user a yes or no question (waits for y or n) and returns the result
 func (m *Messenger) YesNoPrompt(prompt string) (bool, bool) {
-	m.Message(prompt)
+	m.hasPrompt = true
+	m.PromptText(prompt)
 
 	_, h := screen.Size()
 	for {
@@ -112,18 +161,63 @@ func (m *Messenger) YesNoPrompt(prompt string) (bool, bool) {
 		case *tcell.EventKey:
 			switch e.Key() {
 			case tcell.KeyRune:
-				if e.Rune() == 'y' {
+				if e.Rune() == 'y' || e.Rune() == 'Y' {
+					m.AddLog("\t--> y")
+					m.hasPrompt = false
 					return true, false
-				} else if e.Rune() == 'n' {
+				} else if e.Rune() == 'n' || e.Rune() == 'N' {
+					m.AddLog("\t--> n")
+					m.hasPrompt = false
 					return false, false
 				}
 			case tcell.KeyCtrlC, tcell.KeyCtrlQ, tcell.KeyEscape:
+				m.AddLog("\t--> (cancel)")
+				m.Clear()
+				m.Reset()
+				m.hasPrompt = false
 				return false, true
 			}
 		}
 	}
 }
 
+// LetterPrompt gives the user a prompt and waits for a one letter response
+func (m *Messenger) LetterPrompt(prompt string, responses ...rune) (rune, bool) {
+	m.hasPrompt = true
+	m.PromptText(prompt)
+
+	_, h := screen.Size()
+	for {
+		m.Clear()
+		m.Display()
+		screen.ShowCursor(Count(m.message), h-1)
+		screen.Show()
+		event := <-events
+
+		switch e := event.(type) {
+		case *tcell.EventKey:
+			switch e.Key() {
+			case tcell.KeyRune:
+				for _, r := range responses {
+					if e.Rune() == r {
+						m.AddLog("\t--> " + string(r))
+						m.Clear()
+						m.Reset()
+						m.hasPrompt = false
+						return r, false
+					}
+				}
+			case tcell.KeyCtrlC, tcell.KeyCtrlQ, tcell.KeyEscape:
+				m.AddLog("\t--> (cancel)")
+				m.Clear()
+				m.Reset()
+				m.hasPrompt = false
+				return ' ', true
+			}
+		}
+	}
+}
+
 type Completion int
 
 const (
@@ -132,13 +226,15 @@ const (
 	CommandCompletion
 	HelpCompletion
 	OptionCompletion
+	PluginCmdCompletion
+	PluginNameCompletion
 )
 
 // Prompt sends the user a message and waits for a response to be typed in
 // This function blocks the main loop while waiting for input
-func (m *Messenger) Prompt(prompt, historyType string, completionTypes ...Completion) (string, bool) {
+func (m *Messenger) Prompt(prompt, placeholder, historyType string, completionTypes ...Completion) (string, bool) {
 	m.hasPrompt = true
-	m.Message(prompt)
+	m.PromptText(prompt)
 	if _, ok := m.history[historyType]; !ok {
 		m.history[historyType] = []string{""}
 	} else {
@@ -146,7 +242,9 @@ func (m *Messenger) Prompt(prompt, historyType string, completionTypes ...Comple
 	}
 	m.historyNum = len(m.history[historyType]) - 1
 
-	response, canceled := "", true
+	response, canceled := placeholder, true
+	m.response = response
+	m.cursorx = Count(placeholder)
 
 	RedrawAll()
 	for m.hasPrompt {
@@ -160,14 +258,16 @@ func (m *Messenger) Prompt(prompt, historyType string, completionTypes ...Comple
 			switch e.Key() {
 			case tcell.KeyCtrlQ, tcell.KeyCtrlC, tcell.KeyEscape:
 				// Cancel
+				m.AddLog("\t--> (cancel)")
 				m.hasPrompt = false
 			case tcell.KeyEnter:
 				// User is done entering their response
+				m.AddLog("\t--> " + m.response)
 				m.hasPrompt = false
 				response, canceled = m.response, false
 				m.history[historyType][len(m.history[historyType])-1] = response
 			case tcell.KeyTab:
-				args := strings.Split(m.response, " ")
+				args := SplitCommandArgs(m.response)
 				currentArgNum := len(args) - 1
 				currentArg := args[currentArgNum]
 				var completionType Completion
@@ -193,13 +293,20 @@ func (m *Messenger) Prompt(prompt, historyType string, completionTypes ...Comple
 					chosen, suggestions = HelpComplete(currentArg)
 				} else if completionType == OptionCompletion {
 					chosen, suggestions = OptionComplete(currentArg)
+				} else if completionType == PluginCmdCompletion {
+					chosen, suggestions = PluginCmdComplete(currentArg)
+				} else if completionType == PluginNameCompletion {
+					chosen, suggestions = PluginNameComplete(currentArg)
+				} else if completionType < NoCompletion {
+					chosen, suggestions = PluginComplete(completionType, currentArg)
+				}
+
+				if len(suggestions) > 1 {
+					chosen = chosen + CommonSubstring(suggestions...)
 				}
 
 				if chosen != "" {
-					if len(args) > 1 {
-						chosen = " " + chosen
-					}
-					m.response = strings.Join(args[:len(args)-1], " ") + chosen
+					m.response = JoinCommandArgs(append(args[:len(args)-1], chosen)...)
 					m.cursorx = Count(m.response)
 				}
 			}
@@ -207,18 +314,19 @@ func (m *Messenger) Prompt(prompt, historyType string, completionTypes ...Comple
 
 		m.HandleEvent(event, m.history[historyType])
 
-		messenger.Clear()
+		m.Clear()
 		for _, v := range tabs[curTab].views {
 			v.Display()
 		}
 		DisplayTabs()
-		messenger.Display()
+		m.Display()
 		if len(suggestions) > 1 {
 			m.DisplaySuggestions(suggestions)
 		}
 		screen.Show()
 	}
 
+	m.Clear()
 	m.Reset()
 	return response, canceled
 }
@@ -227,36 +335,58 @@ func (m *Messenger) Prompt(prompt, historyType string, completionTypes ...Comple
 func (m *Messenger) HandleEvent(event tcell.Event, history []string) {
 	switch e := event.(type) {
 	case *tcell.EventKey:
+		if e.Key() != tcell.KeyRune || e.Modifiers() != 0 {
+			for key, actions := range bindings {
+				if e.Key() == key.keyCode {
+					if e.Key() == tcell.KeyRune {
+						if e.Rune() != key.r {
+							continue
+						}
+					}
+					if e.Modifiers() == key.modifiers {
+						for _, action := range actions {
+							funcName := FuncName(action)
+							switch funcName {
+							case "main.(*View).CursorUp":
+								if m.historyNum > 0 {
+									m.historyNum--
+									m.response = history[m.historyNum]
+									m.cursorx = Count(m.response)
+								}
+							case "main.(*View).CursorDown":
+								if m.historyNum < len(history)-1 {
+									m.historyNum++
+									m.response = history[m.historyNum]
+									m.cursorx = Count(m.response)
+								}
+							case "main.(*View).CursorLeft":
+								if m.cursorx > 0 {
+									m.cursorx--
+								}
+							case "main.(*View).CursorRight":
+								if m.cursorx < Count(m.response) {
+									m.cursorx++
+								}
+							case "main.(*View).CursorStart", "main.(*View).StartOfLine":
+								m.cursorx = 0
+							case "main.(*View).CursorEnd", "main.(*View).EndOfLine":
+								m.cursorx = Count(m.response)
+							case "main.(*View).Backspace":
+								if m.cursorx > 0 {
+									m.response = string([]rune(m.response)[:m.cursorx-1]) + string([]rune(m.response)[m.cursorx:])
+									m.cursorx--
+								}
+							case "main.(*View).Paste":
+								clip, _ := clipboard.ReadAll("clipboard")
+								m.response = Insert(m.response, m.cursorx, clip)
+								m.cursorx += Count(clip)
+							}
+						}
+					}
+				}
+			}
+		}
 		switch e.Key() {
-		case tcell.KeyUp:
-			if m.historyNum > 0 {
-				m.historyNum--
-				m.response = history[m.historyNum]
-				m.cursorx = Count(m.response)
-			}
-		case tcell.KeyDown:
-			if m.historyNum < len(history)-1 {
-				m.historyNum++
-				m.response = history[m.historyNum]
-				m.cursorx = Count(m.response)
-			}
-		case tcell.KeyLeft:
-			if m.cursorx > 0 {
-				m.cursorx--
-			}
-		case tcell.KeyRight:
-			if m.cursorx < Count(m.response) {
-				m.cursorx++
-			}
-		case tcell.KeyBackspace2, tcell.KeyBackspace:
-			if m.cursorx > 0 {
-				m.response = string([]rune(m.response)[:m.cursorx-1]) + string([]rune(m.response)[m.cursorx:])
-				m.cursorx--
-			}
-		case tcell.KeyCtrlV:
-			clip, _ := clipboard.ReadAll()
-			m.response = Insert(m.response, m.cursorx, clip)
-			m.cursorx += Count(clip)
 		case tcell.KeyRune:
 			m.response = Insert(m.response, m.cursorx, string(e.Rune()))
 			m.cursorx++
@@ -267,6 +397,23 @@ func (m *Messenger) HandleEvent(event tcell.Event, history []string) {
 		clip := e.Text()
 		m.response = Insert(m.response, m.cursorx, clip)
 		m.cursorx += Count(clip)
+	case *tcell.EventMouse:
+		x, y := e.Position()
+		x -= Count(m.message)
+		button := e.Buttons()
+		_, screenH := screen.Size()
+
+		if y == screenH-1 {
+			switch button {
+			case tcell.Button1:
+				m.cursorx = x
+				if m.cursorx < 0 {
+					m.cursorx = 0
+				} else if m.cursorx > Count(m.response) {
+					m.cursorx = Count(m.response)
+				}
+			}
+		}
 	}
 }
 
@@ -314,11 +461,14 @@ func (m *Messenger) DisplaySuggestions(suggestions []string) {
 func (m *Messenger) Display() {
 	_, h := screen.Size()
 	if m.hasMessage {
-		runes := []rune(m.message + m.response)
-		for x := 0; x < len(runes); x++ {
-			screen.SetContent(x, h-1, runes[x], nil, m.style)
+		if m.hasPrompt || globalSettings["infobar"].(bool) {
+			runes := []rune(m.message + m.response)
+			for x := 0; x < len(runes); x++ {
+				screen.SetContent(x, h-1, runes[x], nil, m.style)
+			}
 		}
 	}
+
 	if m.hasPrompt {
 		screen.ShowCursor(Count(m.message)+m.cursorx, h-1)
 		screen.Show()

cmd/micro/micro.go

@@ -5,17 +5,19 @@ import (
 	"fmt"
 	"io/ioutil"
 	"os"
+	"path/filepath"
 	"runtime"
 	"strings"
+	"time"
 
 	"github.com/go-errors/errors"
-	"github.com/layeh/gopher-luar"
 	"github.com/mattn/go-isatty"
 	"github.com/mitchellh/go-homedir"
 	"github.com/yuin/gopher-lua"
 	"github.com/zyedidia/clipboard"
 	"github.com/zyedidia/tcell"
 	"github.com/zyedidia/tcell/encoding"
+	"layeh.com/gopher-luar"
 )
 
 const (
@@ -23,6 +25,7 @@ const (
 	synLinesDown         = 75  // How many lines down to look to do syntax highlighting
 	doubleClickThreshold = 400 // How many milliseconds to wait before a second click is not a double click
 	undoThreshold        = 500 // If two events are less than n milliseconds apart, undo both of them
+	autosaveTime         = 8   // Number of seconds to wait before autosaving
 )
 
 var (
@@ -42,8 +45,10 @@ var (
 	configDir string
 
 	// Version is the version number or commit hash
-	// This should be set by the linker when compiling
-	Version = "Unknown"
+	// These variables should be set by the linker when compiling
+	Version     = "0.0.0-unknown"
+	CommitHash  = "Unknown"
+	CompileDate = "Unknown"
 
 	// L is the lua state
 	// This is the VM that runs the plugins
@@ -58,15 +63,16 @@ var (
 	// Channel of jobs running in the background
 	jobs chan JobFunction
 	// Event channel
-	events chan tcell.Event
+	events   chan tcell.Event
+	autosave chan bool
 )
 
 // LoadInput determines which files should be loaded into buffers
-// based on the input stored in os.Args
+// based on the input stored in flag.Args()
 func LoadInput() []*Buffer {
 	// There are a number of ways micro should start given its input
 
-	// 1. If it is given a files in os.Args, it should open those
+	// 1. If it is given a files in flag.Args(), it should open those
 
 	// 2. If there is no input file and the input is not a terminal, that means
 	// something is being piped in and the stdin should be opened in an
@@ -78,34 +84,51 @@ func LoadInput() []*Buffer {
 	var filename string
 	var input []byte
 	var err error
-	var buffers []*Buffer
+	args := flag.Args()
+	buffers := make([]*Buffer, 0, len(args))
 
-	if len(os.Args) > 1 {
+	if len(args) > 0 {
 		// Option 1
 		// We go through each file and load it
-		for i := 1; i < len(os.Args); i++ {
-			filename = os.Args[i]
+		for i := 0; i < len(args); i++ {
+			filename = args[i]
+
 			// Check that the file exists
+			var input *os.File
 			if _, e := os.Stat(filename); e == nil {
 				// If it exists we load it into a buffer
-				input, err = ioutil.ReadFile(filename)
+				input, err = os.Open(filename)
+				stat, _ := input.Stat()
+				defer input.Close()
 				if err != nil {
 					TermMessage(err)
 					continue
 				}
+				if stat.IsDir() {
+					TermMessage("Cannot read", filename, "because it is a directory")
+					continue
+				}
 			}
 			// If the file didn't exist, input will be empty, and we'll open an empty buffer
-			buffers = append(buffers, NewBuffer(input, filename))
+			if input != nil {
+				buffers = append(buffers, NewBuffer(input, FSize(input), filename))
+			} else {
+				buffers = append(buffers, NewBufferFromString("", filename))
+			}
 		}
 	} else if !isatty.IsTerminal(os.Stdin.Fd()) {
 		// Option 2
 		// The input is not a terminal, so something is being piped in
 		// and we should read from stdin
 		input, err = ioutil.ReadAll(os.Stdin)
-		buffers = append(buffers, NewBuffer(input, filename))
+		if err != nil {
+			TermMessage("Error reading from stdin: ", err)
+			input = []byte{}
+		}
+		buffers = append(buffers, NewBufferFromString(string(input), filename))
 	} else {
 		// Option 3, just open an empty buffer
-		buffers = append(buffers, NewBuffer(input, filename))
+		buffers = append(buffers, NewBufferFromString(string(input), filename))
 	}
 
 	return buffers
@@ -160,6 +183,10 @@ func InitScreen() {
 	screen, err = tcell.NewScreen()
 	if err != nil {
 		fmt.Println(err)
+		if err == tcell.ErrTermNotFound {
+			fmt.Println("Micro does not recognize your terminal:", oldTerm)
+			fmt.Println("Please go to https://github.com/zyedidia/mkinfo to read about how to fix this problem (it should be easy to fix).")
+		}
 		os.Exit(1)
 	}
 	if err = screen.Init(); err != nil {
@@ -179,6 +206,14 @@ func InitScreen() {
 // RedrawAll redraws everything -- all the views and the messenger
 func RedrawAll() {
 	messenger.Clear()
+
+	w, h := screen.Size()
+	for x := 0; x < w; x++ {
+		for y := 0; y < h; y++ {
+			screen.SetContent(x, y, ' ', nil, defStyle)
+		}
+	}
+
 	for _, v := range tabs[curTab].views {
 		v.Display()
 	}
@@ -187,14 +222,52 @@ func RedrawAll() {
 	screen.Show()
 }
 
+func LoadAll() {
+	// Find the user's configuration directory (probably $XDG_CONFIG_HOME/micro)
+	InitConfigDir()
+
+	// Build a list of available Extensions (Syntax, Colorscheme etc.)
+	InitRuntimeFiles()
+
+	// Load the user's settings
+	InitGlobalSettings()
+
+	InitCommands()
+	InitBindings()
+
+	InitColorscheme()
+
+	for _, tab := range tabs {
+		for _, v := range tab.views {
+			v.Buf.UpdateRules()
+		}
+	}
+}
+
 // Passing -version as a flag will have micro print out the version number
-var flagVersion = flag.Bool("version", false, "Show the version number")
+var flagVersion = flag.Bool("version", false, "Show the version number and information")
+var flagStartPos = flag.String("startpos", "", "LINE,COL to start the cursor at when opening a buffer.")
 
 func main() {
+	flag.Usage = func() {
+		fmt.Println("Usage: micro [OPTIONS] [FILE]...")
+		fmt.Print("Micro's options can be set via command line arguments for quick adjustments. For real configuration, please use the bindings.json file (see 'help options').\n\n")
+		flag.PrintDefaults()
+	}
+
+	optionFlags := make(map[string]*string)
+
+	for k, v := range DefaultGlobalSettings() {
+		optionFlags[k] = flag.String(k, "", fmt.Sprintf("The %s option. Default value: '%v'", k, v))
+	}
+
 	flag.Parse()
+
 	if *flagVersion {
 		// If -version was passed
-		fmt.Println("Micro version:", Version)
+		fmt.Println("Version:", Version)
+		fmt.Println("Commit hash:", CommitHash)
+		fmt.Println("Compiled on", CompileDate)
 		os.Exit(0)
 	}
 
@@ -209,17 +282,15 @@ func main() {
 	// Find the user's configuration directory (probably $XDG_CONFIG_HOME/micro)
 	InitConfigDir()
 
+	// Build a list of available Extensions (Syntax, Colorscheme etc.)
+	InitRuntimeFiles()
+
 	// Load the user's settings
 	InitGlobalSettings()
+
 	InitCommands()
 	InitBindings()
 
-	// Load the syntax files, including the colorscheme
-	LoadSyntaxFiles()
-
-	// Load the help files
-	LoadHelp()
-
 	// Start the screen
 	InitScreen()
 
@@ -243,6 +314,11 @@ func main() {
 
 	// Now we load the input
 	buffers := LoadInput()
+	if len(buffers) == 0 {
+		screen.Fini()
+		os.Exit(1)
+	}
+
 	for _, buf := range buffers {
 		// For each buffer we create a new tab and place the view in that tab
 		tab := NewTabFromView(NewView(buf))
@@ -251,10 +327,15 @@ func main() {
 		for _, t := range tabs {
 			for _, v := range t.views {
 				v.Center(false)
-				if globalSettings["syntax"].(bool) {
-					v.matches = Match(v)
-				}
 			}
+
+			t.Resize()
+		}
+	}
+
+	for k, v := range optionFlags {
+		if *v != "" {
+			SetOption(k, *v)
 		}
 	}
 
@@ -275,32 +356,54 @@ func main() {
 	L.SetGlobal("HandleCommand", luar.New(L, HandleCommand))
 	L.SetGlobal("HandleShellCommand", luar.New(L, HandleShellCommand))
 	L.SetGlobal("GetLeadingWhitespace", luar.New(L, GetLeadingWhitespace))
+	L.SetGlobal("MakeCompletion", luar.New(L, MakeCompletion))
+	L.SetGlobal("NewBuffer", luar.New(L, NewBufferFromString))
+	L.SetGlobal("RuneStr", luar.New(L, func(r rune) string {
+		return string(r)
+	}))
+	L.SetGlobal("Loc", luar.New(L, func(x, y int) Loc {
+		return Loc{x, y}
+	}))
+	L.SetGlobal("JoinPaths", luar.New(L, filepath.Join))
+	L.SetGlobal("DirectoryName", luar.New(L, filepath.Dir))
+	L.SetGlobal("configDir", luar.New(L, configDir))
+	L.SetGlobal("Reload", luar.New(L, LoadAll))
+	L.SetGlobal("ByteOffset", luar.New(L, ByteOffset))
+	L.SetGlobal("ToCharPos", luar.New(L, ToCharPos))
 
 	// Used for asynchronous jobs
 	L.SetGlobal("JobStart", luar.New(L, JobStart))
+	L.SetGlobal("JobSpawn", luar.New(L, JobSpawn))
 	L.SetGlobal("JobSend", luar.New(L, JobSend))
 	L.SetGlobal("JobStop", luar.New(L, JobStop))
 
-	LoadPlugins()
+	// Extension Files
+	L.SetGlobal("ReadRuntimeFile", luar.New(L, PluginReadRuntimeFile))
+	L.SetGlobal("ListRuntimeFiles", luar.New(L, PluginListRuntimeFiles))
+	L.SetGlobal("AddRuntimeFile", luar.New(L, PluginAddRuntimeFile))
+	L.SetGlobal("AddRuntimeFilesFromDirectory", luar.New(L, PluginAddRuntimeFilesFromDirectory))
+	L.SetGlobal("AddRuntimeFileFromMemory", luar.New(L, PluginAddRuntimeFileFromMemory))
 
 	jobs = make(chan JobFunction, 100)
-	events = make(chan tcell.Event)
+	events = make(chan tcell.Event, 100)
+	autosave = make(chan bool)
+
+	LoadPlugins()
 
 	for _, t := range tabs {
 		for _, v := range t.views {
-			for _, pl := range loadedPlugins {
+			for pl := range loadedPlugins {
 				_, err := Call(pl+".onViewOpen", v)
 				if err != nil && !strings.HasPrefix(err.Error(), "function does not exist") {
 					TermMessage(err)
 					continue
 				}
 			}
-			if v.Buf.Settings["syntax"].(bool) {
-				v.matches = Match(v)
-			}
 		}
 	}
 
+	InitColorscheme()
+
 	// Here is the event loop which runs in a separate thread
 	go func() {
 		for {
@@ -308,6 +411,15 @@ func main() {
 		}
 	}()
 
+	go func() {
+		for {
+			time.Sleep(autosaveTime * time.Second)
+			if globalSettings["autosave"].(bool) {
+				autosave <- true
+			}
+		}
+	}()
+
 	for {
 		// Display everything
 		RedrawAll()
@@ -320,48 +432,66 @@ func main() {
 			// If a new job has finished while running in the background we should execute the callback
 			f.function(f.output, f.args...)
 			continue
+		case <-autosave:
+			CurView().Save(true)
 		case event = <-events:
 		}
 
-		switch e := event.(type) {
-		case *tcell.EventMouse:
-			if e.Buttons() == tcell.Button1 {
-				// If the user left clicked we check a couple things
-				_, h := screen.Size()
-				x, y := e.Position()
-				if y == h-1 && messenger.message != "" {
-					// If the user clicked in the bottom bar, and there is a message down there
-					// we copy it to the clipboard.
-					// Often error messages are displayed down there so it can be useful to easily
-					// copy the message
-					clipboard.WriteAll(messenger.message)
-					continue
+		for event != nil {
+			switch e := event.(type) {
+			case *tcell.EventResize:
+				for _, t := range tabs {
+					t.Resize()
 				}
+			case *tcell.EventMouse:
+				if !searching {
+					if e.Buttons() == tcell.Button1 {
+						// If the user left clicked we check a couple things
+						_, h := screen.Size()
+						x, y := e.Position()
+						if y == h-1 && messenger.message != "" && globalSettings["infobar"].(bool) {
+							// If the user clicked in the bottom bar, and there is a message down there
+							// we copy it to the clipboard.
+							// Often error messages are displayed down there so it can be useful to easily
+							// copy the message
+							clipboard.WriteAll(messenger.message, "primary")
+							break
+						}
 
-				// We loop through each view in the current tab and make sure the current view
-				// it the one being clicked in
-				for _, v := range tabs[curTab].views {
-					if x >= v.x && x < v.x+v.width && y >= v.y && y < v.y+v.height {
-						tabs[curTab].curView = v.Num
+						if CurView().mouseReleased {
+							// We loop through each view in the current tab and make sure the current view
+							// is the one being clicked in
+							for _, v := range tabs[curTab].views {
+								if x >= v.x && x < v.x+v.Width && y >= v.y && y < v.y+v.Height {
+									tabs[curTab].CurView = v.Num
+								}
+							}
+						}
 					}
 				}
 			}
-		}
 
-		// This function checks the mouse event for the possibility of changing the current tab
-		// If the tab was changed it returns true
-		if TabbarHandleMouseEvent(event) {
-			continue
-		}
+			// This function checks the mouse event for the possibility of changing the current tab
+			// If the tab was changed it returns true
+			if TabbarHandleMouseEvent(event) {
+				break
+			}
 
-		if searching {
-			// Since searching is done in real time, we need to redraw every time
-			// there is a new event in the search bar so we need a special function
-			// to run instead of the standard HandleEvent.
-			HandleSearchEvent(event, CurView())
-		} else {
-			// Send it to the view
-			CurView().HandleEvent(event)
+			if searching {
+				// Since searching is done in real time, we need to redraw every time
+				// there is a new event in the search bar so we need a special function
+				// to run instead of the standard HandleEvent.
+				HandleSearchEvent(event, CurView())
+			} else {
+				// Send it to the view
+				CurView().HandleEvent(event)
+			}
+
+			select {
+			case event = <-events:
+			default:
+				event = nil
+			}
 		}
 	}
 }

cmd/micro/plugin.go

@@ -6,17 +6,11 @@ import (
 	"os"
 	"strings"
 
-	"github.com/layeh/gopher-luar"
 	"github.com/yuin/gopher-lua"
+	"layeh.com/gopher-luar"
 )
 
-var loadedPlugins []string
-
-var preInstalledPlugins = []string{
-	"go",
-	"linter",
-	"autoclose",
-}
+var loadedPlugins map[string]string
 
 // Call calls the lua function 'function'
 // If it does not exist nothing happens, if there is an error,
@@ -85,6 +79,30 @@ func LuaFunctionCommand(function string) func([]string) {
 	}
 }
 
+// LuaFunctionComplete returns a function which can be used for autocomplete in plugins
+func LuaFunctionComplete(function string) func(string) []string {
+	return func(input string) (result []string) {
+
+		res, err := Call(function, input)
+		if err != nil {
+			TermMessage(err)
+		}
+		if tbl, ok := res.(*lua.LTable); !ok {
+			TermMessage(function, "should return a table of strings")
+		} else {
+			for i := 1; i <= tbl.Len(); i++ {
+				val := tbl.RawGetInt(i)
+				if v, ok := val.(lua.LString); !ok {
+					TermMessage(function, "should return a table of strings")
+				} else {
+					result = append(result, string(v))
+				}
+			}
+		}
+		return result
+	}
+}
+
 func LuaFunctionJob(function string) func(string, ...string) {
 	return func(output string, args ...string) {
 		_, err := Call(function, unpack(append([]string{output}, args...))...)
@@ -94,51 +112,39 @@ func LuaFunctionJob(function string) func(string, ...string) {
 	}
 }
 
+// luaPluginName convert a human-friendly plugin name into a valid lua variable name.
+func luaPluginName(name string) string {
+	return strings.Replace(name, "-", "_", -1)
+}
+
 // LoadPlugins loads the pre-installed plugins and the plugins located in ~/.config/micro/plugins
 func LoadPlugins() {
-	files, _ := ioutil.ReadDir(configDir + "/plugins")
-	for _, plugin := range files {
-		if plugin.IsDir() {
-			pluginName := plugin.Name()
-			files, _ := ioutil.ReadDir(configDir + "/plugins/" + pluginName)
-			for _, f := range files {
-				if f.Name() == pluginName+".lua" {
-					data, _ := ioutil.ReadFile(configDir + "/plugins/" + pluginName + "/" + f.Name())
-					pluginDef := "\nlocal P = {}\n" + pluginName + " = P\nsetmetatable(" + pluginName + ", {__index = _G})\nsetfenv(1, P)\n"
 
-					if err := L.DoString(pluginDef + string(data)); err != nil {
-						TermMessage(err)
-						continue
-					}
-					loadedPlugins = append(loadedPlugins, pluginName)
-				}
-			}
-		}
-	}
+	loadedPlugins = make(map[string]string)
 
-	for _, pluginName := range preInstalledPlugins {
-		alreadyExists := false
-		for _, pl := range loadedPlugins {
-			if pl == pluginName {
-				alreadyExists = true
-				break
-			}
-		}
-		if !alreadyExists {
-			plugin := "runtime/plugins/" + pluginName + "/" + pluginName + ".lua"
-			data, err := Asset(plugin)
-			if err != nil {
-				TermMessage("Error loading pre-installed plugin: " + pluginName)
-				continue
-			}
-			pluginDef := "\nlocal P = {}\n" + pluginName + " = P\nsetmetatable(" + pluginName + ", {__index = _G})\nsetfenv(1, P)\n"
-			if err := L.DoString(pluginDef + string(data)); err != nil {
-				TermMessage(err)
-				continue
-			}
+	for _, plugin := range ListRuntimeFiles(RTPlugin) {
 
-			loadedPlugins = append(loadedPlugins, pluginName)
+		pluginName := plugin.Name()
+		if _, ok := loadedPlugins[pluginName]; ok {
+			continue
 		}
+
+		data, err := plugin.Data()
+		if err != nil {
+			TermMessage("Error loading plugin: " + pluginName)
+			continue
+		}
+
+		pluginLuaName := luaPluginName(pluginName)
+		pluginDef := "\nlocal P = {}\n" + pluginLuaName + " = P\nsetmetatable(" + pluginLuaName + ", {__index = _G})\nsetfenv(1, P)\n"
+
+		if err := L.DoString(pluginDef + string(data)); err != nil {
+			TermMessage(err)
+			continue
+		}
+
+		loadedPlugins[pluginName] = pluginLuaName
+
 	}
 
 	if _, err := os.Stat(configDir + "/init.lua"); err == nil {
@@ -147,6 +153,6 @@ func LoadPlugins() {
 		if err := L.DoString(pluginDef + string(data)); err != nil {
 			TermMessage(err)
 		}
-		loadedPlugins = append(loadedPlugins, "init")
+		loadedPlugins["init"] = "init"
 	}
 }

cmd/micro/pluginmanager.go

@@ -0,0 +1,615 @@
+package main
+
+import (
+	"archive/zip"
+	"bytes"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"sync"
+
+	"github.com/blang/semver"
+	"github.com/yuin/gopher-lua"
+	"github.com/zyedidia/json5/encoding/json5"
+)
+
+var (
+	allPluginPackages PluginPackages
+)
+
+// CorePluginName is a plugin dependency name for the micro core.
+const CorePluginName = "micro"
+
+// PluginChannel contains an url to a json list of PluginRepository
+type PluginChannel string
+
+// PluginChannels is a slice of PluginChannel
+type PluginChannels []PluginChannel
+
+// PluginRepository contains an url to json file containing PluginPackages
+type PluginRepository string
+
+// PluginPackage contains the meta-data of a plugin and all available versions
+type PluginPackage struct {
+	Name        string
+	Description string
+	Author      string
+	Tags        []string
+	Versions    PluginVersions
+}
+
+// PluginPackages is a list of PluginPackage instances.
+type PluginPackages []*PluginPackage
+
+// PluginVersion descripes a version of a PluginPackage. Containing a version, download url and also dependencies.
+type PluginVersion struct {
+	pack    *PluginPackage
+	Version semver.Version
+	Url     string
+	Require PluginDependencies
+}
+
+// PluginVersions is a slice of PluginVersion
+type PluginVersions []*PluginVersion
+
+// PluginDependency descripes a dependency to another plugin or micro itself.
+type PluginDependency struct {
+	Name  string
+	Range semver.Range
+}
+
+// PluginDependencies is a slice of PluginDependency
+type PluginDependencies []*PluginDependency
+
+func (pp *PluginPackage) String() string {
+	buf := new(bytes.Buffer)
+	buf.WriteString("Plugin: ")
+	buf.WriteString(pp.Name)
+	buf.WriteRune('\n')
+	if pp.Author != "" {
+		buf.WriteString("Author: ")
+		buf.WriteString(pp.Author)
+		buf.WriteRune('\n')
+	}
+	if pp.Description != "" {
+		buf.WriteRune('\n')
+		buf.WriteString(pp.Description)
+	}
+	return buf.String()
+}
+
+func fetchAllSources(count int, fetcher func(i int) PluginPackages) PluginPackages {
+	wgQuery := new(sync.WaitGroup)
+	wgQuery.Add(count)
+
+	results := make(chan PluginPackages)
+
+	wgDone := new(sync.WaitGroup)
+	wgDone.Add(1)
+	var packages PluginPackages
+	for i := 0; i < count; i++ {
+		go func(i int) {
+			results <- fetcher(i)
+			wgQuery.Done()
+		}(i)
+	}
+	go func() {
+		packages = make(PluginPackages, 0)
+		for res := range results {
+			packages = append(packages, res...)
+		}
+		wgDone.Done()
+	}()
+	wgQuery.Wait()
+	close(results)
+	wgDone.Wait()
+	return packages
+}
+
+// Fetch retrieves all available PluginPackages from the given channels
+func (pc PluginChannels) Fetch() PluginPackages {
+	return fetchAllSources(len(pc), func(i int) PluginPackages {
+		return pc[i].Fetch()
+	})
+}
+
+// Fetch retrieves all available PluginPackages from the given channel
+func (pc PluginChannel) Fetch() PluginPackages {
+	// messenger.AddLog(fmt.Sprintf("Fetching channel: %q", string(pc)))
+	resp, err := http.Get(string(pc))
+	if err != nil {
+		TermMessage("Failed to query plugin channel:\n", err)
+		return PluginPackages{}
+	}
+	defer resp.Body.Close()
+	decoder := json5.NewDecoder(resp.Body)
+
+	var repositories []PluginRepository
+	if err := decoder.Decode(&repositories); err != nil {
+		TermMessage("Failed to decode channel data:\n", err)
+		return PluginPackages{}
+	}
+	return fetchAllSources(len(repositories), func(i int) PluginPackages {
+		return repositories[i].Fetch()
+	})
+}
+
+// Fetch retrieves all available PluginPackages from the given repository
+func (pr PluginRepository) Fetch() PluginPackages {
+	// messenger.AddLog(fmt.Sprintf("Fetching repository: %q", string(pr)))
+	resp, err := http.Get(string(pr))
+	if err != nil {
+		TermMessage("Failed to query plugin repository:\n", err)
+		return PluginPackages{}
+	}
+	defer resp.Body.Close()
+	decoder := json5.NewDecoder(resp.Body)
+
+	var plugins PluginPackages
+	if err := decoder.Decode(&plugins); err != nil {
+		TermMessage("Failed to decode repository data:\n", err)
+		return PluginPackages{}
+	}
+	if len(plugins) > 0 {
+		return PluginPackages{plugins[0]}
+	}
+	return nil
+	// return plugins
+}
+
+// UnmarshalJSON unmarshals raw json to a PluginVersion
+func (pv *PluginVersion) UnmarshalJSON(data []byte) error {
+	var values struct {
+		Version semver.Version
+		Url     string
+		Require map[string]string
+	}
+
+	if err := json5.Unmarshal(data, &values); err != nil {
+		return err
+	}
+	pv.Version = values.Version
+	pv.Url = values.Url
+	pv.Require = make(PluginDependencies, 0)
+
+	for k, v := range values.Require {
+		// don't add the dependency if it's the core and
+		// we have a unknown version number.
+		// in that case just accept that dependency (which equals to not adding it.)
+		if k != CorePluginName || !isUnknownCoreVersion() {
+			if vRange, err := semver.ParseRange(v); err == nil {
+				pv.Require = append(pv.Require, &PluginDependency{k, vRange})
+			}
+		}
+	}
+	return nil
+}
+
+// UnmarshalJSON unmarshals raw json to a PluginPackage
+func (pp *PluginPackage) UnmarshalJSON(data []byte) error {
+	var values struct {
+		Name        string
+		Description string
+		Author      string
+		Tags        []string
+		Versions    PluginVersions
+	}
+	if err := json5.Unmarshal(data, &values); err != nil {
+		return err
+	}
+	pp.Name = values.Name
+	pp.Description = values.Description
+	pp.Author = values.Author
+	pp.Tags = values.Tags
+	pp.Versions = values.Versions
+	for _, v := range pp.Versions {
+		v.pack = pp
+	}
+	return nil
+}
+
+// GetAllPluginPackages gets all PluginPackages which may be available.
+func GetAllPluginPackages() PluginPackages {
+	if allPluginPackages == nil {
+		getOption := func(name string) []string {
+			data := GetOption(name)
+			if strs, ok := data.([]string); ok {
+				return strs
+			}
+			if ifs, ok := data.([]interface{}); ok {
+				result := make([]string, len(ifs))
+				for i, urlIf := range ifs {
+					if url, ok := urlIf.(string); ok {
+						result[i] = url
+					} else {
+						return nil
+					}
+				}
+				return result
+			}
+			return nil
+		}
+
+		channels := PluginChannels{}
+		for _, url := range getOption("pluginchannels") {
+			channels = append(channels, PluginChannel(url))
+		}
+		repos := []PluginRepository{}
+		for _, url := range getOption("pluginrepos") {
+			repos = append(repos, PluginRepository(url))
+		}
+		allPluginPackages = fetchAllSources(len(repos)+1, func(i int) PluginPackages {
+			if i == 0 {
+				return channels.Fetch()
+			}
+			return repos[i-1].Fetch()
+		})
+	}
+	return allPluginPackages
+}
+
+func (pv PluginVersions) find(ppName string) *PluginVersion {
+	for _, v := range pv {
+		if v.pack.Name == ppName {
+			return v
+		}
+	}
+	return nil
+}
+
+// Len returns the number of pluginversions in this slice
+func (pv PluginVersions) Len() int {
+	return len(pv)
+}
+
+// Swap two entries of the slice
+func (pv PluginVersions) Swap(i, j int) {
+	pv[i], pv[j] = pv[j], pv[i]
+}
+
+// Less returns true if the version at position i is greater then the version at position j (used for sorting)
+func (pv PluginVersions) Less(i, j int) bool {
+	return pv[i].Version.GT(pv[j].Version)
+}
+
+// Match returns true if the package matches a given search text
+func (pp PluginPackage) Match(text string) bool {
+	text = strings.ToLower(text)
+	for _, t := range pp.Tags {
+		if strings.ToLower(t) == text {
+			return true
+		}
+	}
+	if strings.Contains(strings.ToLower(pp.Name), text) {
+		return true
+	}
+
+	if strings.Contains(strings.ToLower(pp.Description), text) {
+		return true
+	}
+
+	return false
+}
+
+// IsInstallable returns true if the package can be installed.
+func (pp PluginPackage) IsInstallable() error {
+	_, err := GetAllPluginPackages().Resolve(GetInstalledVersions(true), PluginDependencies{
+		&PluginDependency{
+			Name:  pp.Name,
+			Range: semver.Range(func(v semver.Version) bool { return true }),
+		}})
+	return err
+}
+
+// SearchPlugin retrieves a list of all PluginPackages which match the given search text and
+// could be or are already installed
+func SearchPlugin(texts []string) (plugins PluginPackages) {
+	plugins = make(PluginPackages, 0)
+
+pluginLoop:
+	for _, pp := range GetAllPluginPackages() {
+		for _, text := range texts {
+			if !pp.Match(text) {
+				continue pluginLoop
+			}
+		}
+
+		if err := pp.IsInstallable(); err == nil {
+			plugins = append(plugins, pp)
+		}
+	}
+	return
+}
+
+func isUnknownCoreVersion() bool {
+	_, err := semver.ParseTolerant(Version)
+	return err != nil
+}
+
+func newStaticPluginVersion(name, version string) *PluginVersion {
+	vers, err := semver.ParseTolerant(version)
+
+	if err != nil {
+		if vers, err = semver.ParseTolerant("0.0.0-" + version); err != nil {
+			vers = semver.MustParse("0.0.0-unknown")
+		}
+	}
+	pl := &PluginPackage{
+		Name: name,
+	}
+	pv := &PluginVersion{
+		pack:    pl,
+		Version: vers,
+	}
+	pl.Versions = PluginVersions{pv}
+	return pv
+}
+
+// GetInstalledVersions returns a list of all currently installed plugins including an entry for
+// micro itself. This can be used to resolve dependencies.
+func GetInstalledVersions(withCore bool) PluginVersions {
+	result := PluginVersions{}
+	if withCore {
+		result = append(result, newStaticPluginVersion(CorePluginName, Version))
+	}
+
+	for name, lpname := range loadedPlugins {
+		version := GetInstalledPluginVersion(lpname)
+		if pv := newStaticPluginVersion(name, version); pv != nil {
+			result = append(result, pv)
+		}
+	}
+
+	return result
+}
+
+// GetInstalledPluginVersion returns the string of the exported VERSION variable of a loaded plugin
+func GetInstalledPluginVersion(name string) string {
+	plugin := L.GetGlobal(name)
+	if plugin != lua.LNil {
+		version := L.GetField(plugin, "VERSION")
+		if str, ok := version.(lua.LString); ok {
+			return string(str)
+
+		}
+	}
+	return ""
+}
+
+// DownloadAndInstall downloads and installs the given plugin and version
+func (pv *PluginVersion) DownloadAndInstall() error {
+	messenger.AddLog(fmt.Sprintf("Downloading %q (%s) from %q", pv.pack.Name, pv.Version, pv.Url))
+	resp, err := http.Get(pv.Url)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	data, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return err
+	}
+	zipbuf := bytes.NewReader(data)
+	z, err := zip.NewReader(zipbuf, zipbuf.Size())
+	if err != nil {
+		return err
+	}
+	targetDir := filepath.Join(configDir, "plugins", pv.pack.Name)
+	dirPerm := os.FileMode(0755)
+	if err = os.MkdirAll(targetDir, dirPerm); err != nil {
+		return err
+	}
+
+	// Check if all files in zip are in the same directory.
+	// this might be the case if the plugin zip contains the whole plugin dir
+	// instead of its content.
+	var prefix string
+	allPrefixed := false
+	for i, f := range z.File {
+		parts := strings.Split(f.Name, "/")
+		if i == 0 {
+			prefix = parts[0]
+		} else if parts[0] != prefix {
+			allPrefixed = false
+			break
+		} else {
+			// switch to true since we have at least a second file
+			allPrefixed = true
+		}
+	}
+
+	for _, f := range z.File {
+		parts := strings.Split(f.Name, "/")
+		if allPrefixed {
+			parts = parts[1:]
+		}
+
+		targetName := filepath.Join(targetDir, filepath.Join(parts...))
+		if f.FileInfo().IsDir() {
+			if err := os.MkdirAll(targetName, dirPerm); err != nil {
+				return err
+			}
+		} else {
+			content, err := f.Open()
+			if err != nil {
+				return err
+			}
+			defer content.Close()
+			target, err := os.Create(targetName)
+			if err != nil {
+				return err
+			}
+			defer target.Close()
+			if _, err = io.Copy(target, content); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func (pl PluginPackages) Get(name string) *PluginPackage {
+	for _, p := range pl {
+		if p.Name == name {
+			return p
+		}
+	}
+	return nil
+}
+
+func (pl PluginPackages) GetAllVersions(name string) PluginVersions {
+	result := make(PluginVersions, 0)
+	p := pl.Get(name)
+	if p != nil {
+		for _, v := range p.Versions {
+			result = append(result, v)
+		}
+	}
+	return result
+}
+
+func (req PluginDependencies) Join(other PluginDependencies) PluginDependencies {
+	m := make(map[string]*PluginDependency)
+	for _, r := range req {
+		m[r.Name] = r
+	}
+	for _, o := range other {
+		cur, ok := m[o.Name]
+		if ok {
+			m[o.Name] = &PluginDependency{
+				o.Name,
+				o.Range.AND(cur.Range),
+			}
+		} else {
+			m[o.Name] = o
+		}
+	}
+	result := make(PluginDependencies, 0, len(m))
+	for _, v := range m {
+		result = append(result, v)
+	}
+	return result
+}
+
+// Resolve resolves dependencies between different plugins
+func (all PluginPackages) Resolve(selectedVersions PluginVersions, open PluginDependencies) (PluginVersions, error) {
+	if len(open) == 0 {
+		return selectedVersions, nil
+	}
+	currentRequirement, stillOpen := open[0], open[1:]
+	if currentRequirement != nil {
+		if selVersion := selectedVersions.find(currentRequirement.Name); selVersion != nil {
+			if currentRequirement.Range(selVersion.Version) {
+				return all.Resolve(selectedVersions, stillOpen)
+			}
+			return nil, fmt.Errorf("unable to find a matching version for \"%s\"", currentRequirement.Name)
+		}
+		availableVersions := all.GetAllVersions(currentRequirement.Name)
+		sort.Sort(availableVersions)
+
+		for _, version := range availableVersions {
+			if currentRequirement.Range(version.Version) {
+				resolved, err := all.Resolve(append(selectedVersions, version), stillOpen.Join(version.Require))
+
+				if err == nil {
+					return resolved, nil
+				}
+			}
+		}
+		return nil, fmt.Errorf("unable to find a matching version for \"%s\"", currentRequirement.Name)
+	}
+	return selectedVersions, nil
+}
+
+func (pv PluginVersions) install() {
+	anyInstalled := false
+	currentlyInstalled := GetInstalledVersions(true)
+
+	for _, sel := range pv {
+		if sel.pack.Name != CorePluginName {
+			shouldInstall := true
+			if pv := currentlyInstalled.find(sel.pack.Name); pv != nil {
+				if pv.Version.NE(sel.Version) {
+					messenger.AddLog(fmt.Sprint("Uninstalling %q", sel.pack.Name))
+					UninstallPlugin(sel.pack.Name)
+				} else {
+					shouldInstall = false
+				}
+			}
+
+			if shouldInstall {
+				if err := sel.DownloadAndInstall(); err != nil {
+					messenger.Error(err)
+					return
+				}
+				anyInstalled = true
+			}
+		}
+	}
+	if anyInstalled {
+		messenger.Message("One or more plugins installed. Please restart micro.")
+	} else {
+		messenger.AddLog("Nothing to install / update")
+	}
+}
+
+// UninstallPlugin deletes the plugin folder of the given plugin
+func UninstallPlugin(name string) {
+	if err := os.RemoveAll(filepath.Join(configDir, "plugins", name)); err != nil {
+		messenger.Error(err)
+		return
+	}
+	delete(loadedPlugins, name)
+}
+
+// Install installs the plugin
+func (pl PluginPackage) Install() {
+	selected, err := GetAllPluginPackages().Resolve(GetInstalledVersions(true), PluginDependencies{
+		&PluginDependency{
+			Name:  pl.Name,
+			Range: semver.Range(func(v semver.Version) bool { return true }),
+		}})
+	if err != nil {
+		TermMessage(err)
+		return
+	}
+	selected.install()
+}
+
+// UpdatePlugins updates the given plugins
+func UpdatePlugins(plugins []string) {
+	// if no plugins are specified, update all installed plugins.
+	if len(plugins) == 0 {
+		for name := range loadedPlugins {
+			plugins = append(plugins, name)
+		}
+	}
+
+	messenger.AddLog("Checking for plugin updates")
+	microVersion := PluginVersions{
+		newStaticPluginVersion(CorePluginName, Version),
+	}
+
+	var updates = make(PluginDependencies, 0)
+	for _, name := range plugins {
+		pv := GetInstalledPluginVersion(name)
+		r, err := semver.ParseRange(">=" + pv) // Try to get newer versions.
+		if err == nil {
+			updates = append(updates, &PluginDependency{
+				Name:  name,
+				Range: r,
+			})
+		}
+	}
+
+	selected, err := GetAllPluginPackages().Resolve(microVersion, updates)
+	if err != nil {
+		TermMessage(err)
+		return
+	}
+	selected.install()
+}

cmd/micro/pluginmanager_test.go

@@ -0,0 +1,55 @@
+package main
+
+import (
+	"github.com/blang/semver"
+	"testing"
+
+	"github.com/zyedidia/json5/encoding/json5"
+)
+
+func TestDependencyResolving(t *testing.T) {
+	js := `
+[{
+  "Name": "Foo",
+  "Versions": [{ "Version": "1.0.0" }, { "Version": "1.5.0" },{ "Version": "2.0.0" }]
+}, {
+  "Name": "Bar",
+  "Versions": [{ "Version": "1.0.0", "Require": {"Foo": ">1.0.0 <2.0.0"} }]
+}, {
+  "Name": "Unresolvable",
+  "Versions": [{ "Version": "1.0.0", "Require": {"Foo": "<=1.0.0", "Bar": ">0.0.0"} }]
+	}]
+`
+	var all PluginPackages
+	err := json5.Unmarshal([]byte(js), &all)
+	if err != nil {
+		t.Error(err)
+	}
+	selected, err := all.Resolve(PluginVersions{}, PluginDependencies{
+		&PluginDependency{"Bar", semver.MustParseRange(">=1.0.0")},
+	})
+
+	check := func(name, version string) {
+		v := selected.find(name)
+		expected := semver.MustParse(version)
+		if v == nil {
+			t.Errorf("Failed to resolve %s", name)
+		} else if expected.NE(v.Version) {
+			t.Errorf("%s resolved in wrong version got %s", name, v)
+		}
+	}
+
+	if err != nil {
+		t.Error(err)
+	} else {
+		check("Foo", "1.5.0")
+		check("Bar", "1.0.0")
+	}
+
+	selected, err = all.Resolve(PluginVersions{}, PluginDependencies{
+		&PluginDependency{"Unresolvable", semver.MustParseRange(">0.0.0")},
+	})
+	if err == nil {
+		t.Error("Unresolvable package resolved:", selected)
+	}
+}

cmd/micro/rtfiles.go

@@ -0,0 +1,207 @@
+package main
+
+import (
+	"io/ioutil"
+	"os"
+	"path"
+	"path/filepath"
+)
+
+const (
+	RTColorscheme = "colorscheme"
+	RTSyntax      = "syntax"
+	RTHelp        = "help"
+	RTPlugin      = "plugin"
+)
+
+// RuntimeFile allows the program to read runtime data like colorschemes or syntax files
+type RuntimeFile interface {
+	// Name returns a name of the file without paths or extensions
+	Name() string
+	// Data returns the content of the file.
+	Data() ([]byte, error)
+}
+
+// allFiles contains all available files, mapped by filetype
+var allFiles map[string][]RuntimeFile
+
+// some file on filesystem
+type realFile string
+
+// some asset file
+type assetFile string
+
+// some file on filesystem but with a different name
+type namedFile struct {
+	realFile
+	name string
+}
+
+// a file with the data stored in memory
+type memoryFile struct {
+	name string
+	data []byte
+}
+
+func (mf memoryFile) Name() string {
+	return mf.name
+}
+func (mf memoryFile) Data() ([]byte, error) {
+	return mf.data, nil
+}
+
+func (rf realFile) Name() string {
+	fn := filepath.Base(string(rf))
+	return fn[:len(fn)-len(filepath.Ext(fn))]
+}
+
+func (rf realFile) Data() ([]byte, error) {
+	return ioutil.ReadFile(string(rf))
+}
+
+func (af assetFile) Name() string {
+	fn := path.Base(string(af))
+	return fn[:len(fn)-len(path.Ext(fn))]
+}
+
+func (af assetFile) Data() ([]byte, error) {
+	return Asset(string(af))
+}
+
+func (nf namedFile) Name() string {
+	return nf.name
+}
+
+// AddRuntimeFile registers a file for the given filetype
+func AddRuntimeFile(fileType string, file RuntimeFile) {
+	if allFiles == nil {
+		allFiles = make(map[string][]RuntimeFile)
+	}
+	allFiles[fileType] = append(allFiles[fileType], file)
+}
+
+// AddRuntimeFilesFromDirectory registers each file from the given directory for
+// the filetype which matches the file-pattern
+func AddRuntimeFilesFromDirectory(fileType, directory, pattern string) {
+	files, _ := ioutil.ReadDir(directory)
+	for _, f := range files {
+		if ok, _ := filepath.Match(pattern, f.Name()); !f.IsDir() && ok {
+			fullPath := filepath.Join(directory, f.Name())
+			AddRuntimeFile(fileType, realFile(fullPath))
+		}
+	}
+}
+
+// AddRuntimeFilesFromAssets registers each file from the given asset-directory for
+// the filetype which matches the file-pattern
+func AddRuntimeFilesFromAssets(fileType, directory, pattern string) {
+	files, err := AssetDir(directory)
+	if err != nil {
+		return
+	}
+	for _, f := range files {
+		if ok, _ := path.Match(pattern, f); ok {
+			AddRuntimeFile(fileType, assetFile(path.Join(directory, f)))
+		}
+	}
+}
+
+// FindRuntimeFile finds a runtime file of the given filetype and name
+// will return nil if no file was found
+func FindRuntimeFile(fileType, name string) RuntimeFile {
+	for _, f := range ListRuntimeFiles(fileType) {
+		if f.Name() == name {
+			return f
+		}
+	}
+	return nil
+}
+
+// ListRuntimeFiles lists all known runtime files for the given filetype
+func ListRuntimeFiles(fileType string) []RuntimeFile {
+	if files, ok := allFiles[fileType]; ok {
+		return files
+	}
+	return []RuntimeFile{}
+}
+
+// InitRuntimeFiles initializes all assets file and the config directory
+func InitRuntimeFiles() {
+	add := func(fileType, dir, pattern string) {
+		AddRuntimeFilesFromDirectory(fileType, filepath.Join(configDir, dir), pattern)
+		AddRuntimeFilesFromAssets(fileType, path.Join("runtime", dir), pattern)
+	}
+
+	add(RTColorscheme, "colorschemes", "*.micro")
+	add(RTSyntax, "syntax", "*.yaml")
+	add(RTHelp, "help", "*.md")
+
+	// Search configDir for plugin-scripts
+	files, _ := ioutil.ReadDir(filepath.Join(configDir, "plugins"))
+	for _, f := range files {
+		realpath, _ := filepath.EvalSymlinks(filepath.Join(configDir, "plugins", f.Name()))
+		realpathStat, _ := os.Stat(realpath)
+		if realpathStat.IsDir() {
+			scriptPath := filepath.Join(configDir, "plugins", f.Name(), f.Name()+".lua")
+			if _, err := os.Stat(scriptPath); err == nil {
+				AddRuntimeFile(RTPlugin, realFile(scriptPath))
+			}
+		}
+	}
+
+	if files, err := AssetDir("runtime/plugins"); err == nil {
+		for _, f := range files {
+			scriptPath := path.Join("runtime/plugins", f, f+".lua")
+			if _, err := AssetInfo(scriptPath); err == nil {
+				AddRuntimeFile(RTPlugin, assetFile(scriptPath))
+			}
+		}
+	}
+}
+
+// PluginReadRuntimeFile allows plugin scripts to read the content of a runtime file
+func PluginReadRuntimeFile(fileType, name string) string {
+	if file := FindRuntimeFile(fileType, name); file != nil {
+		if data, err := file.Data(); err == nil {
+			return string(data)
+		}
+	}
+	return ""
+}
+
+// PluginListRuntimeFiles allows plugins to lists all runtime files of the given type
+func PluginListRuntimeFiles(fileType string) []string {
+	files := ListRuntimeFiles(fileType)
+	result := make([]string, len(files))
+	for i, f := range files {
+		result[i] = f.Name()
+	}
+	return result
+}
+
+// PluginAddRuntimeFile adds a file to the runtime files for a plugin
+func PluginAddRuntimeFile(plugin, filetype, filePath string) {
+	fullpath := filepath.Join(configDir, "plugins", plugin, filePath)
+	if _, err := os.Stat(fullpath); err == nil {
+		AddRuntimeFile(filetype, realFile(fullpath))
+	} else {
+		fullpath = path.Join("runtime", "plugins", plugin, filePath)
+		AddRuntimeFile(filetype, assetFile(fullpath))
+	}
+}
+
+// PluginAddRuntimeFilesFromDirectory adds files from a directory to the runtime files for a plugin
+func PluginAddRuntimeFilesFromDirectory(plugin, filetype, directory, pattern string) {
+	fullpath := filepath.Join(configDir, "plugins", plugin, directory)
+	if _, err := os.Stat(fullpath); err == nil {
+		AddRuntimeFilesFromDirectory(filetype, fullpath, pattern)
+	} else {
+		fullpath = path.Join("runtime", "plugins", plugin, directory)
+		AddRuntimeFilesFromAssets(filetype, fullpath, pattern)
+	}
+}
+
+// PluginAddRuntimeFileFromMemory adds a file to the runtime files for a plugin from a given string
+func PluginAddRuntimeFileFromMemory(plugin, filetype, filename, data string) {
+	AddRuntimeFile(filetype, memoryFile{filename, []byte(data)})
+}

cmd/micro/search.go

@@ -21,12 +21,14 @@ var (
 )
 
 // BeginSearch starts a search
-func BeginSearch() {
+func BeginSearch(searchStr string) {
 	searchHistory = append(searchHistory, "")
 	messenger.historyNum = len(searchHistory) - 1
 	searching = true
-	messenger.hasPrompt = true
+	messenger.response = searchStr
+	messenger.cursorx = Count(searchStr)
 	messenger.Message("Find: ")
+	messenger.hasPrompt = true
 }
 
 // EndSearch stops the current search
@@ -41,13 +43,27 @@ func EndSearch() {
 	}
 }
 
+// exit the search mode, reset active search phrase, and clear status bar
+func ExitSearch(v *View) {
+	lastSearch = ""
+	searching = false
+	messenger.hasPrompt = false
+	messenger.Clear()
+	messenger.Reset()
+	v.Cursor.ResetSelection()
+}
+
 // HandleSearchEvent takes an event and a view and will do a real time match from the messenger's output
 // to the current buffer. It searches down the buffer.
 func HandleSearchEvent(event tcell.Event, v *View) {
 	switch e := event.(type) {
 	case *tcell.EventKey:
 		switch e.Key() {
-		case tcell.KeyCtrlQ, tcell.KeyCtrlC, tcell.KeyEscape, tcell.KeyEnter:
+		case tcell.KeyEscape:
+			// Exit the search mode
+			ExitSearch(v)
+			return
+		case tcell.KeyCtrlQ, tcell.KeyCtrlC, tcell.KeyEnter:
 			// Done
 			EndSearch()
 			return
@@ -70,6 +86,8 @@ func HandleSearchEvent(event tcell.Event, v *View) {
 
 	Search(messenger.response, v, true)
 
+	v.Relocate()
+
 	return
 }
 
@@ -125,11 +143,8 @@ func Search(searchStr string, v *View, down bool) {
 		return
 	}
 
-	v.Cursor.CurSelection[0] = FromCharPos(charPos+runePos(match[0], str), v.Buf)
-	v.Cursor.CurSelection[1] = FromCharPos(charPos+runePos(match[1], str), v.Buf)
+	v.Cursor.SetSelectionStart(FromCharPos(charPos+runePos(match[0], str), v.Buf))
+	v.Cursor.SetSelectionEnd(FromCharPos(charPos+runePos(match[1], str), v.Buf))
 	v.Cursor.Loc = v.Cursor.CurSelection[1]
-	if v.Relocate() {
-		v.matches = Match(v)
-	}
 	lastSearch = searchStr
 }

cmd/micro/settings.go

@@ -1,7 +1,6 @@
 package main
 
 import (
-	"encoding/json"
 	"errors"
 	"io/ioutil"
 	"os"
@@ -10,27 +9,44 @@ import (
 	"strings"
 
 	"github.com/zyedidia/glob"
+	"github.com/zyedidia/json5/encoding/json5"
 )
 
+type optionValidator func(string, interface{}) error
+
 // The options that the user can set
 var globalSettings map[string]interface{}
 
+// Options with validators
+var optionValidators = map[string]optionValidator{
+	"tabsize":      validatePositiveValue,
+	"scrollmargin": validateNonNegativeValue,
+	"scrollspeed":  validateNonNegativeValue,
+	"colorscheme":  validateColorscheme,
+	"colorcolumn":  validateNonNegativeValue,
+}
+
 // InitGlobalSettings initializes the options map and sets all options to their default values
 func InitGlobalSettings() {
 	defaults := DefaultGlobalSettings()
 	var parsed map[string]interface{}
 
 	filename := configDir + "/settings.json"
+	writeSettings := false
 	if _, e := os.Stat(filename); e == nil {
 		input, err := ioutil.ReadFile(filename)
-		if err != nil {
-			TermMessage("Error reading settings.json file: " + err.Error())
-			return
-		}
+		if !strings.HasPrefix(string(input), "null") {
+			if err != nil {
+				TermMessage("Error reading settings.json file: " + err.Error())
+				return
+			}
 
-		err = json.Unmarshal(input, &parsed)
-		if err != nil {
-			TermMessage("Error reading settings.json:", err.Error())
+			err = json5.Unmarshal(input, &parsed)
+			if err != nil {
+				TermMessage("Error reading settings.json:", err.Error())
+			}
+		} else {
+			writeSettings = true
 		}
 	}
 
@@ -44,7 +60,7 @@ func InitGlobalSettings() {
 		}
 	}
 
-	if _, err := os.Stat(filename); os.IsNotExist(err) {
+	if _, err := os.Stat(filename); os.IsNotExist(err) || writeSettings {
 		err := WriteSettings(filename)
 		if err != nil {
 			TermMessage("Error writing settings.json file: " + err.Error())
@@ -65,7 +81,7 @@ func InitLocalSettings(buf *Buffer) {
 			return
 		}
 
-		err = json.Unmarshal(input, &parsed)
+		err = json5.Unmarshal(input, &parsed)
 		if err != nil {
 			TermMessage("Error reading settings.json:", err.Error())
 		}
@@ -92,31 +108,36 @@ func InitLocalSettings(buf *Buffer) {
 func WriteSettings(filename string) error {
 	var err error
 	if _, e := os.Stat(configDir); e == nil {
-		var parsed map[string]interface{}
+		parsed := make(map[string]interface{})
 
 		filename := configDir + "/settings.json"
+		for k, v := range globalSettings {
+			parsed[k] = v
+		}
 		if _, e := os.Stat(filename); e == nil {
 			input, err := ioutil.ReadFile(filename)
-			if err != nil {
-				return err
-			}
+			if string(input) != "null" {
+				if err != nil {
+					return err
+				}
 
-			err = json.Unmarshal(input, &parsed)
-			if err != nil {
-				TermMessage("Error reading settings.json:", err.Error())
-			}
-		}
+				err = json5.Unmarshal(input, &parsed)
+				if err != nil {
+					TermMessage("Error reading settings.json:", err.Error())
+				}
 
-		for k, v := range parsed {
-			if !strings.HasPrefix(reflect.TypeOf(v).String(), "map") {
-				if _, ok := globalSettings[k]; ok {
-					parsed[k] = globalSettings[k]
+				for k, v := range parsed {
+					if !strings.HasPrefix(reflect.TypeOf(v).String(), "map") {
+						if _, ok := globalSettings[k]; ok {
+							parsed[k] = globalSettings[k]
+						}
+					}
 				}
 			}
 		}
 
-		txt, _ := json.MarshalIndent(parsed, "", "    ")
-		err = ioutil.WriteFile(filename, txt, 0644)
+		txt, _ := json5.MarshalIndent(parsed, "", "    ")
+		err = ioutil.WriteFile(filename, append(txt, '\n'), 0644)
 	}
 	return err
 }
@@ -150,24 +171,40 @@ func GetOption(name string) interface{} {
 	return GetGlobalOption(name)
 }
 
-// DefaultSettings returns the default settings for micro
+// DefaultGlobalSettings returns the default global settings for micro
 // Note that colorscheme is a global only option
 func DefaultGlobalSettings() map[string]interface{} {
 	return map[string]interface{}{
-		"autoindent":   true,
-		"colorscheme":  "monokai",
-		"cursorline":   false,
-		"ignorecase":   false,
-		"indentchar":   " ",
-		"ruler":        true,
-		"savecursor":   false,
-		"saveundo":     false,
-		"scrollspeed":  float64(2),
-		"scrollmargin": float64(3),
-		"statusline":   true,
-		"syntax":       true,
-		"tabsize":      float64(4),
-		"tabstospaces": false,
+		"autoindent":     true,
+		"keepautoindent": false,
+		"autosave":       false,
+		"colorcolumn":    float64(0),
+		"colorscheme":    "default",
+		"cursorline":     true,
+		"eofnewline":     false,
+		"rmtrailingws":   false,
+		"ignorecase":     false,
+		"indentchar":     " ",
+		"infobar":        true,
+		"ruler":          true,
+		"savecursor":     false,
+		"saveundo":       false,
+		"scrollspeed":    float64(2),
+		"scrollmargin":   float64(3),
+		"softwrap":       false,
+		"splitRight":     true,
+		"splitBottom":    true,
+		"statusline":     true,
+		"syntax":         true,
+		"tabmovement":    false,
+		"tabsize":        float64(4),
+		"tabstospaces":   false,
+		"termtitle":      false,
+		"pluginchannels": []string{
+			"https://raw.githubusercontent.com/micro-editor/plugin-channel/master/channel.json",
+		},
+		"pluginrepos": []string{},
+		"useprimary":  true,
 	}
 }
 
@@ -175,20 +212,30 @@ func DefaultGlobalSettings() map[string]interface{} {
 // Note that filetype is a local only option
 func DefaultLocalSettings() map[string]interface{} {
 	return map[string]interface{}{
-		"autoindent":   true,
-		"cursorline":   false,
-		"filetype":     "Unknown",
-		"ignorecase":   false,
-		"indentchar":   " ",
-		"ruler":        true,
-		"savecursor":   false,
-		"saveundo":     false,
-		"scrollspeed":  float64(2),
-		"scrollmargin": float64(3),
-		"statusline":   true,
-		"syntax":       true,
-		"tabsize":      float64(4),
-		"tabstospaces": false,
+		"autoindent":     true,
+		"keepautoindent": false,
+		"autosave":       false,
+		"colorcolumn":    float64(0),
+		"cursorline":     true,
+		"eofnewline":     false,
+		"rmtrailingws":   false,
+		"filetype":       "Unknown",
+		"ignorecase":     false,
+		"indentchar":     " ",
+		"ruler":          true,
+		"savecursor":     false,
+		"saveundo":       false,
+		"scrollspeed":    float64(2),
+		"scrollmargin":   float64(3),
+		"softwrap":       false,
+		"splitRight":     true,
+		"splitBottom":    true,
+		"statusline":     true,
+		"syntax":         true,
+		"tabmovement":    false,
+		"tabsize":        float64(4),
+		"tabstospaces":   false,
+		"useprimary":     true,
 	}
 }
 
@@ -205,35 +252,49 @@ func SetOption(option, value string) error {
 		return nil
 	}
 
+	var nativeValue interface{}
+
 	kind := reflect.TypeOf(globalSettings[option]).Kind()
 	if kind == reflect.Bool {
 		b, err := ParseBool(value)
 		if err != nil {
 			return errors.New("Invalid value")
 		}
-		globalSettings[option] = b
+		nativeValue = b
 	} else if kind == reflect.String {
-		globalSettings[option] = value
+		nativeValue = value
 	} else if kind == reflect.Float64 {
 		i, err := strconv.Atoi(value)
 		if err != nil {
 			return errors.New("Invalid value")
 		}
-		globalSettings[option] = float64(i)
+		nativeValue = float64(i)
+	} else {
+		return errors.New("Option has unsupported value type")
 	}
 
+	if err := optionIsValid(option, nativeValue); err != nil {
+		return err
+	}
+
+	globalSettings[option] = nativeValue
+
 	if option == "colorscheme" {
-		LoadSyntaxFiles()
+		// LoadSyntaxFiles()
+		InitColorscheme()
 		for _, tab := range tabs {
 			for _, view := range tab.views {
 				view.Buf.UpdateRules()
-				if view.Buf.Settings["syntax"].(bool) {
-					view.matches = Match(view)
-				}
 			}
 		}
 	}
 
+	if option == "infobar" {
+		for _, tab := range tabs {
+			tab.Resize()
+		}
+	}
+
 	if _, ok := CurView().Buf.Settings[option]; ok {
 		for _, tab := range tabs {
 			for _, view := range tab.views {
@@ -252,35 +313,48 @@ func SetLocalOption(option, value string, view *View) error {
 		return errors.New("Invalid option")
 	}
 
+	var nativeValue interface{}
+
 	kind := reflect.TypeOf(buf.Settings[option]).Kind()
 	if kind == reflect.Bool {
 		b, err := ParseBool(value)
 		if err != nil {
 			return errors.New("Invalid value")
 		}
-		buf.Settings[option] = b
+		nativeValue = b
 	} else if kind == reflect.String {
-		buf.Settings[option] = value
+		nativeValue = value
 	} else if kind == reflect.Float64 {
 		i, err := strconv.Atoi(value)
 		if err != nil {
 			return errors.New("Invalid value")
 		}
-		buf.Settings[option] = float64(i)
+		nativeValue = float64(i)
+	} else {
+		return errors.New("Option has unsupported value type")
 	}
 
+	if err := optionIsValid(option, nativeValue); err != nil {
+		return err
+	}
+
+	buf.Settings[option] = nativeValue
+
 	if option == "statusline" {
 		view.ToggleStatusLine()
-		if buf.Settings["syntax"].(bool) {
-			view.matches = Match(view)
-		}
 	}
 
 	if option == "filetype" {
-		LoadSyntaxFiles()
+		// LoadSyntaxFiles()
+		InitColorscheme()
 		buf.UpdateRules()
-		if buf.Settings["syntax"].(bool) {
-			view.matches = Match(view)
+	}
+
+	if option == "syntax" {
+		if !nativeValue.(bool) {
+			buf.ClearMatches()
+		} else {
+			buf.highlighter.HighlightStates(buf)
 		}
 	}
 
@@ -304,3 +378,55 @@ func SetOptionAndSettings(option, value string) {
 		return
 	}
 }
+
+func optionIsValid(option string, value interface{}) error {
+	if validator, ok := optionValidators[option]; ok {
+		return validator(option, value)
+	}
+
+	return nil
+}
+
+// Option validators
+
+func validatePositiveValue(option string, value interface{}) error {
+	tabsize, ok := value.(float64)
+
+	if !ok {
+		return errors.New("Expected numeric type for " + option)
+	}
+
+	if tabsize < 1 {
+		return errors.New(option + " must be greater than 0")
+	}
+
+	return nil
+}
+
+func validateNonNegativeValue(option string, value interface{}) error {
+	nativeValue, ok := value.(float64)
+
+	if !ok {
+		return errors.New("Expected numeric type for " + option)
+	}
+
+	if nativeValue < 0 {
+		return errors.New(option + " must be non-negative")
+	}
+
+	return nil
+}
+
+func validateColorscheme(option string, value interface{}) error {
+	colorscheme, ok := value.(string)
+
+	if !ok {
+		return errors.New("Expected string type for colorscheme")
+	}
+
+	if !ColorschemeExists(colorscheme) {
+		return errors.New(colorscheme + " is not a valid colorscheme")
+	}
+
+	return nil
+}

cmd/micro/split_tree.go

@@ -1,24 +1,30 @@
 package main
 
+// SplitType specifies whether a split is horizontal or vertical
 type SplitType bool
 
 const (
-	VerticalSplit   = false
+	// VerticalSplit type
+	VerticalSplit = false
+	// HorizontalSplit type
 	HorizontalSplit = true
 )
 
+// A Node on the split tree
 type Node interface {
-	VSplit(buf *Buffer)
-	HSplit(buf *Buffer)
+	VSplit(buf *Buffer, splitIndex int)
+	HSplit(buf *Buffer, splitIndex int)
 	String() string
 }
 
+// A LeafNode is an actual split so it contains a view
 type LeafNode struct {
 	view *View
 
 	parent *SplitTree
 }
 
+// NewLeafNode returns a new leaf node containing the given view
 func NewLeafNode(v *View, parent *SplitTree) *LeafNode {
 	n := new(LeafNode)
 	n.view = v
@@ -27,6 +33,7 @@ func NewLeafNode(v *View, parent *SplitTree) *LeafNode {
 	return n
 }
 
+// A SplitTree is a Node itself and it contains other nodes
 type SplitTree struct {
 	kind SplitType
 
@@ -36,64 +43,122 @@ type SplitTree struct {
 	x int
 	y int
 
-	width  int
-	height int
+	width      int
+	height     int
+	lockWidth  bool
+	lockHeight bool
 
 	tabNum int
 }
 
-func (l *LeafNode) VSplit(buf *Buffer) {
+// VSplit creates a vertical split
+func (l *LeafNode) VSplit(buf *Buffer, splitIndex int) {
+	if splitIndex < 0 {
+		splitIndex = 0
+	}
+
 	tab := tabs[l.parent.tabNum]
 	if l.parent.kind == VerticalSplit {
+		if splitIndex > len(l.parent.children) {
+			splitIndex = len(l.parent.children)
+		}
+
 		newView := NewView(buf)
 		newView.TabNum = l.parent.tabNum
-		newView.Num = len(tab.views)
-		l.parent.children = append(l.parent.children, NewLeafNode(newView, l.parent))
 
-		tab.curView++
-		tab.views = append(tab.views, newView)
+		l.parent.children = append(l.parent.children, nil)
+		copy(l.parent.children[splitIndex+1:], l.parent.children[splitIndex:])
+		l.parent.children[splitIndex] = NewLeafNode(newView, l.parent)
+
+		tab.views = append(tab.views, nil)
+		copy(tab.views[splitIndex+1:], tab.views[splitIndex:])
+		tab.views[splitIndex] = newView
+
+		tab.CurView = splitIndex
 	} else {
+		if splitIndex > 1 {
+			splitIndex = 1
+		}
+
 		s := new(SplitTree)
 		s.kind = VerticalSplit
 		s.parent = l.parent
+		s.tabNum = l.parent.tabNum
 		newView := NewView(buf)
 		newView.TabNum = l.parent.tabNum
-		newView.Num = len(tab.views)
-		s.children = []Node{l, NewLeafNode(newView, s)}
+		if splitIndex == 1 {
+			s.children = []Node{l, NewLeafNode(newView, s)}
+		} else {
+			s.children = []Node{NewLeafNode(newView, s), l}
+		}
 		l.parent.children[search(l.parent.children, l)] = s
 		l.parent = s
 
-		tab.curView++
-		tab.views = append(tab.views, newView)
+		tab.views = append(tab.views, nil)
+		copy(tab.views[splitIndex+1:], tab.views[splitIndex:])
+		tab.views[splitIndex] = newView
+
+		tab.CurView = splitIndex
 	}
+
+	tab.Resize()
 }
 
-func (l *LeafNode) HSplit(buf *Buffer) {
+// HSplit creates a horizontal split
+func (l *LeafNode) HSplit(buf *Buffer, splitIndex int) {
+	if splitIndex < 0 {
+		splitIndex = 0
+	}
+
 	tab := tabs[l.parent.tabNum]
 	if l.parent.kind == HorizontalSplit {
+		if splitIndex > len(l.parent.children) {
+			splitIndex = len(l.parent.children)
+		}
+
 		newView := NewView(buf)
 		newView.TabNum = l.parent.tabNum
-		newView.Num = len(tab.views)
-		l.parent.children = append(l.parent.children, NewLeafNode(newView, l.parent))
 
-		tab.curView++
-		tab.views = append(tab.views, newView)
+		l.parent.children = append(l.parent.children, nil)
+		copy(l.parent.children[splitIndex+1:], l.parent.children[splitIndex:])
+		l.parent.children[splitIndex] = NewLeafNode(newView, l.parent)
+
+		tab.views = append(tab.views, nil)
+		copy(tab.views[splitIndex+1:], tab.views[splitIndex:])
+		tab.views[splitIndex] = newView
+
+		tab.CurView = splitIndex
 	} else {
+		if splitIndex > 1 {
+			splitIndex = 1
+		}
+
 		s := new(SplitTree)
 		s.kind = HorizontalSplit
+		s.tabNum = l.parent.tabNum
 		s.parent = l.parent
 		newView := NewView(buf)
 		newView.TabNum = l.parent.tabNum
 		newView.Num = len(tab.views)
-		s.children = []Node{l, NewLeafNode(newView, s)}
+		if splitIndex == 1 {
+			s.children = []Node{l, NewLeafNode(newView, s)}
+		} else {
+			s.children = []Node{NewLeafNode(newView, s), l}
+		}
 		l.parent.children[search(l.parent.children, l)] = s
 		l.parent = s
 
-		tab.curView++
-		tab.views = append(tab.views, newView)
+		tab.views = append(tab.views, nil)
+		copy(tab.views[splitIndex+1:], tab.views[splitIndex:])
+		tab.views[splitIndex] = newView
+
+		tab.CurView = splitIndex
 	}
+
+	tab.Resize()
 }
 
+// Delete deletes a split
 func (l *LeafNode) Delete() {
 	i := search(l.parent.children, l)
 
@@ -110,11 +175,12 @@ func (l *LeafNode) Delete() {
 	for i, v := range tab.views {
 		v.Num = i
 	}
-	if tab.curView > 0 {
-		tab.curView--
+	if tab.CurView > 0 {
+		tab.CurView--
 	}
 }
 
+// Cleanup rearranges all the parents after a split has been deleted
 func (s *SplitTree) Cleanup() {
 	for i, node := range s.children {
 		if n, ok := node.(*SplitTree); ok {
@@ -130,43 +196,84 @@ func (s *SplitTree) Cleanup() {
 	}
 }
 
+// ResizeSplits resizes all the splits correctly
 func (s *SplitTree) ResizeSplits() {
-	for i, node := range s.children {
+	lockedWidth := 0
+	lockedHeight := 0
+	lockedChildren := 0
+	for _, node := range s.children {
 		if n, ok := node.(*LeafNode); ok {
 			if s.kind == VerticalSplit {
-				n.view.width = s.width / len(s.children)
-				n.view.height = s.height
-
-				n.view.x = s.x + n.view.width*i
-				n.view.y = s.y
+				if n.view.LockWidth {
+					lockedWidth += n.view.Width
+					lockedChildren++
+				}
 			} else {
-				n.view.height = s.height / len(s.children)
-				n.view.width = s.width
-
-				n.view.y = s.y + n.view.height*i
-				n.view.x = s.x
+				if n.view.LockHeight {
+					lockedHeight += n.view.Height
+					lockedChildren++
+				}
 			}
-			// n.view.ToggleStatusLine()
-			_, screenH := screen.Size()
-			if n.view.Buf.Settings["statusline"].(bool) || (n.view.y+n.view.height) != screenH-1 {
-				n.view.height--
+		} else if n, ok := node.(*SplitTree); ok {
+			if s.kind == VerticalSplit {
+				if n.lockWidth {
+					lockedWidth += n.width
+					lockedChildren++
+				}
+			} else {
+				if n.lockHeight {
+					lockedHeight += n.height
+					lockedChildren++
+				}
+			}
+		}
+	}
+	x, y := 0, 0
+	for _, node := range s.children {
+		if n, ok := node.(*LeafNode); ok {
+			if s.kind == VerticalSplit {
+				if !n.view.LockWidth {
+					n.view.Width = (s.width - lockedWidth) / (len(s.children) - lockedChildren)
+				}
+				n.view.Height = s.height
+
+				n.view.x = s.x + x
+				n.view.y = s.y
+				x += n.view.Width
+			} else {
+				if !n.view.LockHeight {
+					n.view.Height = (s.height - lockedHeight) / (len(s.children) - lockedChildren)
+				}
+				n.view.Width = s.width
+
+				n.view.y = s.y + y
+				n.view.x = s.x
+				y += n.view.Height
+			}
+			if n.view.Buf.Settings["statusline"].(bool) {
+				n.view.Height--
 			}
 
 			n.view.ToggleTabbar()
-			n.view.matches = Match(n.view)
 		} else if n, ok := node.(*SplitTree); ok {
 			if s.kind == VerticalSplit {
-				n.width = s.width / len(s.children)
+				if !n.lockWidth {
+					n.width = (s.width - lockedWidth) / (len(s.children) - lockedChildren)
+				}
 				n.height = s.height
 
-				n.x = s.x + n.width*i
+				n.x = s.x + x
 				n.y = s.y
+				x += n.width
 			} else {
-				n.height = s.height / len(s.children)
+				if !n.lockHeight {
+					n.height = (s.height - lockedHeight) / (len(s.children) - lockedChildren)
+				}
 				n.width = s.width
 
-				n.y = s.y + n.height*i
+				n.y = s.y + y
 				n.x = s.x
+				y += n.height
 			}
 			n.ResizeSplits()
 		}
@@ -174,7 +281,7 @@ func (s *SplitTree) ResizeSplits() {
 }
 
 func (l *LeafNode) String() string {
-	return l.view.Buf.Name
+	return l.view.Buf.GetName()
 }
 
 func search(haystack []Node, needle Node) int {
@@ -195,8 +302,11 @@ func findView(haystack []*View, needle *View) int {
 	return 0
 }
 
-func (s *SplitTree) VSplit(buf *Buffer) {}
-func (s *SplitTree) HSplit(buf *Buffer) {}
+// VSplit is here just to make SplitTree fit the Node interface
+func (s *SplitTree) VSplit(buf *Buffer, splitIndex int) {}
+
+// HSplit is here just to make SplitTree fit the Node interface
+func (s *SplitTree) HSplit(buf *Buffer, splitIndex int) {}
 
 func (s *SplitTree) String() string {
 	str := "["

cmd/micro/statusline.go

@@ -15,9 +15,9 @@ type Statusline struct {
 // Display draws the statusline to the screen
 func (sline *Statusline) Display() {
 	// We'll draw the line at the lowest line in the view
-	y := sline.view.height + sline.view.y
+	y := sline.view.Height + sline.view.y
 
-	file := sline.view.Buf.Name
+	file := sline.view.Buf.GetName()
 
 	// If the buffer is dirty (has been modified) write a little '+'
 	if sline.view.Buf.IsModified {
@@ -36,9 +36,12 @@ func (sline *Statusline) Display() {
 	// Add the filetype
 	file += " " + sline.view.Buf.FileType()
 
-	rightText := helpBinding + " for help "
-	if sline.view.Help {
-		rightText = helpBinding + " to close help "
+	rightText := ""
+	if len(helpBinding) > 0 {
+		rightText = helpBinding + " for help "
+		if sline.view.Type == vtHelp {
+			rightText = helpBinding + " to close help "
+		}
 	}
 
 	statusLineStyle := defStyle.Reverse(true)
@@ -53,11 +56,11 @@ func (sline *Statusline) Display() {
 		screen.SetContent(viewX, y, ' ', nil, statusLineStyle)
 		viewX++
 	}
-	for x := 0; x < sline.view.width; x++ {
+	for x := 0; x < sline.view.Width; x++ {
 		if x < len(fileRunes) {
 			screen.SetContent(viewX+x, y, fileRunes[x], nil, statusLineStyle)
-		} else if x >= sline.view.width-len(rightText) && x < len(rightText)+sline.view.width-len(rightText) {
-			screen.SetContent(viewX+x, y, []rune(rightText)[x-sline.view.width+len(rightText)], nil, statusLineStyle)
+		} else if x >= sline.view.Width-len(rightText) && x < len(rightText)+sline.view.Width-len(rightText) {
+			screen.SetContent(viewX+x, y, []rune(rightText)[x-sline.view.Width+len(rightText)], nil, statusLineStyle)
 		} else {
 			screen.SetContent(viewX+x, y, ' ', nil, statusLineStyle)
 		}

cmd/micro/tab.go

@@ -6,15 +6,15 @@ import (
 	"github.com/zyedidia/tcell"
 )
 
+var tabBarOffset int
+
 type Tab struct {
 	// This contains all the views in this tab
 	// There is generally only one view per tab, but you can have
 	// multiple views with splits
 	views []*View
 	// This is the current view for this tab
-	curView int
-	// Generally this is the name of the current view's buffer
-	name string
+	CurView int
 
 	tree *SplitTree
 }
@@ -31,12 +31,20 @@ func NewTabFromView(v *View) *Tab {
 
 	w, h := screen.Size()
 	t.tree.width = w
-	t.tree.height = h - 1
+	t.tree.height = h
+
+	if globalSettings["infobar"].(bool) {
+		t.tree.height--
+	}
+
+	t.Resize()
+
 	return t
 }
 
 // SetNum sets all this tab's views to have the correct tab number
 func (t *Tab) SetNum(num int) {
+	t.tree.tabNum = num
 	for _, v := range t.views {
 		v.TabNum = num
 	}
@@ -49,19 +57,28 @@ func (t *Tab) Cleanup() {
 func (t *Tab) Resize() {
 	w, h := screen.Size()
 	t.tree.width = w
-	t.tree.height = h - 1
+	t.tree.height = h
+
+	if globalSettings["infobar"].(bool) {
+		t.tree.height--
+	}
+
 	t.tree.ResizeSplits()
+
+	for i, v := range t.views {
+		v.Num = i
+	}
 }
 
 // CurView returns the current view
 func CurView() *View {
 	curTab := tabs[curTab]
-	return curTab.views[curTab.curView]
+	return curTab.views[curTab.CurView]
 }
 
 // TabbarString returns the string that should be displayed in the tabbar
 // It also returns a map containing which indicies correspond to which tab number
-// This is useful when we know that the mouse click has occured at an x location
+// This is useful when we know that the mouse click has occurred at an x location
 // but need to know which tab that corresponds to to accurately change the tab
 func TabbarString() (string, map[int]int) {
 	str := ""
@@ -72,13 +89,17 @@ func TabbarString() (string, map[int]int) {
 		} else {
 			str += " "
 		}
-		str += t.views[t.curView].Buf.Name
+		buf := t.views[t.CurView].Buf
+		str += buf.GetName()
+		if buf.IsModified {
+			str += " +"
+		}
 		if i == curTab {
 			str += "]"
 		} else {
 			str += " "
 		}
-		indicies[len(str)-1] = i + 1
+		indicies[Count(str)-1] = i + 1
 		str += " "
 	}
 	return str, indicies
@@ -103,7 +124,7 @@ func TabbarHandleMouseEvent(event tcell.Event) bool {
 				return false
 			}
 			str, indicies := TabbarString()
-			if x >= len(str) {
+			if x+tabBarOffset >= len(str) {
 				return false
 			}
 			var tabnum int
@@ -113,7 +134,7 @@ func TabbarHandleMouseEvent(event tcell.Event) bool {
 			}
 			sort.Ints(keys)
 			for _, k := range keys {
-				if x <= k {
+				if x+tabBarOffset <= k {
 					tabnum = indicies[k] - 1
 					break
 				}
@@ -132,7 +153,7 @@ func DisplayTabs() {
 		return
 	}
 
-	str, _ := TabbarString()
+	str, indicies := TabbarString()
 
 	tabBarStyle := defStyle.Reverse(true)
 	if style, ok := colorscheme["tabbar"]; ok {
@@ -142,6 +163,98 @@ func DisplayTabs() {
 	// Maybe there is a unicode filename?
 	fileRunes := []rune(str)
 	w, _ := screen.Size()
+	tooWide := (w < len(fileRunes))
+
+	// if the entire tab-bar is longer than the screen is wide,
+	// then it should be truncated appropriately to keep the
+	// active tab visible on the UI.
+	if tooWide == true {
+		// first we have to work out where the selected tab is
+		// out of the total length of the tab bar. this is done
+		// by extracting the hit-areas from the indicies map
+		// that was constructed by `TabbarString()`
+		var keys []int
+		for offset := range indicies {
+			keys = append(keys, offset)
+		}
+		// sort them to be in ascending order so that values will
+		// correctly reflect the displayed ordering of the tabs
+		sort.Ints(keys)
+		// record the offset of each tab and the previous tab so
+		// we can find the position of the tab's hit-box.
+		previousTabOffset := 0
+		currentTabOffset := 0
+		for _, k := range keys {
+			tabIndex := indicies[k] - 1
+			if tabIndex == curTab {
+				currentTabOffset = k
+				break
+			}
+			// this is +2 because there are two padding spaces that aren't accounted
+			// for in the display. please note that this is for cosmetic purposes only.
+			previousTabOffset = k + 2
+		}
+		// get the width of the hitbox of the active tab, from there calculate the offsets
+		// to the left and right of it to approximately center it on the tab bar display.
+		centeringOffset := (w - (currentTabOffset - previousTabOffset))
+		leftBuffer := previousTabOffset - (centeringOffset / 2)
+		rightBuffer := currentTabOffset + (centeringOffset / 2)
+
+		// check to make sure we haven't overshot the bounds of the string,
+		// if we have, then take that remainder and put it on the left side
+		overshotRight := rightBuffer - len(fileRunes)
+		if overshotRight > 0 {
+			leftBuffer = leftBuffer + overshotRight
+		}
+
+		overshotLeft := leftBuffer - 0
+		if overshotLeft < 0 {
+			leftBuffer = 0
+			rightBuffer = leftBuffer + (w - 1)
+		} else {
+			rightBuffer = leftBuffer + (w - 2)
+		}
+
+		if rightBuffer > len(fileRunes)-1 {
+			rightBuffer = len(fileRunes) - 1
+		}
+
+		// construct a new buffer of text to put the
+		// newly formatted tab bar text into.
+		var displayText []rune
+
+		// if the left-side of the tab bar isn't at the start
+		// of the constructed tab bar text, then show that are
+		// more tabs to the left by displaying a "+"
+		if leftBuffer != 0 {
+			displayText = append(displayText, '+')
+		}
+		// copy the runes in from the original tab bar text string
+		// into the new display buffer
+		for x := leftBuffer; x < rightBuffer; x++ {
+			displayText = append(displayText, fileRunes[x])
+		}
+		// if there is more text to the right of the right-most
+		// column in the tab bar text, then indicate there are more
+		// tabs to the right by displaying a "+"
+		if rightBuffer < len(fileRunes)-1 {
+			displayText = append(displayText, '+')
+		}
+
+		// now store the offset from zero of the left-most text
+		// that is being displayed. This is to ensure that when
+		// clicking on the tab bar, the correct tab gets selected.
+		tabBarOffset = leftBuffer
+
+		// use the constructed buffer as the display buffer to print
+		// onscreen.
+		fileRunes = displayText
+	} else {
+		tabBarOffset = 0
+	}
+
+	// iterate over the width of the terminal display and for each column,
+	// write a character into the tab display area with the appropriate style.
 	for x := 0; x < w; x++ {
 		if x < len(fileRunes) {
 			screen.SetContent(x, 0, fileRunes[x], nil, tabBarStyle)

cmd/micro/util.go

@@ -1,8 +1,11 @@
 package main
 
 import (
+	"bytes"
 	"os"
 	"path/filepath"
+	"reflect"
+	"runtime"
 	"strconv"
 	"strings"
 	"time"
@@ -20,8 +23,8 @@ func Count(s string) int {
 	return utf8.RuneCountInString(s)
 }
 
-// NumOccurences counts the number of occurences of a byte in a string
-func NumOccurences(s string, c byte) int {
+// NumOccurrences counts the number of occurrences of a byte in a string
+func NumOccurrences(s string, c byte) int {
 	var n int
 	for i := 0; i < len(s); i++ {
 		if s[i] == c {
@@ -56,13 +59,19 @@ func Max(a, b int) int {
 	return b
 }
 
+func FSize(f *os.File) int64 {
+	fi, _ := f.Stat()
+	// get the size
+	return fi.Size()
+}
+
 // IsWordChar returns whether or not the string is a 'word character'
 // If it is a unicode character, then it does not match
 // Word characters are defined as [A-Za-z0-9_]
 func IsWordChar(str string) bool {
 	if len(str) > 1 {
 		// Unicode
-		return false
+		return true
 	}
 	c := str[0]
 	return (c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c == '_')
@@ -73,6 +82,16 @@ func IsWhitespace(c rune) bool {
 	return c == ' ' || c == '\t' || c == '\n'
 }
 
+// IsStrWhitespace returns true if the given string is all whitespace
+func IsStrWhitespace(str string) bool {
+	for _, c := range str {
+		if !IsWhitespace(c) {
+			return false
+		}
+	}
+	return true
+}
+
 // Contains returns whether or not a string array contains a given string
 func Contains(list []string, a string) bool {
 	for _, b := range list {
@@ -88,6 +107,18 @@ func Insert(str string, pos int, value string) string {
 	return string([]rune(str)[:pos]) + value + string([]rune(str)[pos:])
 }
 
+// MakeRelative will attempt to make a relative path between path and base
+func MakeRelative(path, base string) (string, error) {
+	if len(path) > 0 {
+		rel, err := filepath.Rel(base, path)
+		if err != nil {
+			return path, err
+		}
+		return rel, nil
+	}
+	return path, nil
+}
+
 // GetLeadingWhitespace returns the leading whitespace of the given string
 func GetLeadingWhitespace(str string) string {
 	ws := ""
@@ -154,7 +185,19 @@ func GetModTime(path string) (time.Time, bool) {
 // StringWidth returns the width of a string where tabs count as `tabsize` width
 func StringWidth(str string, tabsize int) int {
 	sw := runewidth.StringWidth(str)
-	sw += NumOccurences(str, '\t') * (tabsize - 1)
+	lineIdx := 0
+	for _, ch := range str {
+		switch ch {
+		case '\t':
+			ts := tabsize - (lineIdx % tabsize)
+			sw += ts
+			lineIdx += ts
+		case '\n':
+			lineIdx = 0
+		default:
+			lineIdx++
+		}
+	}
 	return sw
 }
 
@@ -162,16 +205,22 @@ func StringWidth(str string, tabsize int) int {
 // that have a width larger than 1 (this also counts tabs as `tabsize` width)
 func WidthOfLargeRunes(str string, tabsize int) int {
 	count := 0
+	lineIdx := 0
 	for _, ch := range str {
 		var w int
 		if ch == '\t' {
-			w = tabsize
+			w = tabsize - (lineIdx % tabsize)
 		} else {
 			w = runewidth.RuneWidth(ch)
 		}
 		if w > 1 {
 			count += (w - 1)
 		}
+		if ch == '\n' {
+			lineIdx = 0
+		} else {
+			lineIdx += w
+		}
 	}
 	return count
 }
@@ -182,6 +231,34 @@ func runePos(p int, str string) int {
 	return utf8.RuneCountInString(str[:p])
 }
 
+func lcs(a, b string) string {
+	arunes := []rune(a)
+	brunes := []rune(b)
+
+	lcs := ""
+	for i, r := range arunes {
+		if i >= len(brunes) {
+			break
+		}
+		if r == brunes[i] {
+			lcs += string(r)
+		} else {
+			break
+		}
+	}
+	return lcs
+}
+
+func CommonSubstring(arr ...string) string {
+	commonStr := arr[0]
+
+	for _, str := range arr[1:] {
+		commonStr = lcs(commonStr, str)
+	}
+
+	return commonStr
+}
+
 // Abs is a simple absolute value function for ints
 func Abs(n int) int {
 	if n < 0 {
@@ -189,3 +266,104 @@ func Abs(n int) int {
 	}
 	return n
 }
+
+// FuncName returns the full name of a given function object
+func FuncName(i interface{}) string {
+	return runtime.FuncForPC(reflect.ValueOf(i).Pointer()).Name()
+}
+
+// ShortFuncName returns the name only of a given function object
+func ShortFuncName(i interface{}) string {
+	return strings.TrimPrefix(runtime.FuncForPC(reflect.ValueOf(i).Pointer()).Name(), "main.(*View).")
+}
+
+// SplitCommandArgs separates multiple command arguments which may be quoted.
+// The returned slice contains at least one string
+func SplitCommandArgs(input string) []string {
+	var result []string
+	var curQuote *bytes.Buffer
+
+	curArg := new(bytes.Buffer)
+	escape := false
+
+	finishQuote := func() {
+		if curQuote == nil {
+			return
+		}
+		str := curQuote.String()
+		if unquoted, err := strconv.Unquote(str); err == nil {
+			str = unquoted
+		}
+		curArg.WriteString(str)
+		curQuote = nil
+	}
+
+	appendResult := func() {
+		finishQuote()
+		escape = false
+
+		str := curArg.String()
+		result = append(result, str)
+		curArg.Reset()
+	}
+
+	for _, r := range input {
+		if r == ' ' && curQuote == nil {
+			appendResult()
+		} else {
+			runeHandled := false
+			appendRuneToBuff := func() {
+				if curQuote != nil {
+					curQuote.WriteRune(r)
+				} else {
+					curArg.WriteRune(r)
+				}
+				runeHandled = true
+			}
+
+			if r == '"' && curQuote == nil {
+				curQuote = new(bytes.Buffer)
+				appendRuneToBuff()
+			} else {
+				if curQuote != nil && !escape {
+					if r == '"' {
+						appendRuneToBuff()
+						finishQuote()
+					} else if r == '\\' {
+						appendRuneToBuff()
+						escape = true
+						continue
+					}
+				}
+			}
+			if !runeHandled {
+				appendRuneToBuff()
+			}
+		}
+
+		escape = false
+	}
+	appendResult()
+	return result
+}
+
+// JoinCommandArgs joins multiple command arguments and quote the strings if needed.
+func JoinCommandArgs(args ...string) string {
+	buf := new(bytes.Buffer)
+	first := true
+	for _, arg := range args {
+		if first {
+			first = false
+		} else {
+			buf.WriteRune(' ')
+		}
+		quoted := strconv.Quote(arg)
+		if quoted[1:len(quoted)-1] != arg || strings.ContainsRune(arg, ' ') {
+			buf.WriteString(quoted)
+		} else {
+			buf.WriteString(arg)
+		}
+	}
+
+	return buf.String()
+}

cmd/micro/util_test.go

@@ -1,6 +1,9 @@
 package main
 
-import "testing"
+import (
+	"reflect"
+	"testing"
+)
 
 func TestNumOccurences(t *testing.T) {
 	var tests = []struct {
@@ -13,7 +16,7 @@ func TestNumOccurences(t *testing.T) {
 		{"∆ƒ\tø ® \t\t", '\t', 3},
 	}
 	for _, test := range tests {
-		if got := NumOccurences(test.inputStr, test.inputChar); got != test.want {
+		if got := NumOccurrences(test.inputStr, test.inputChar); got != test.want {
 			t.Errorf("NumOccurences(%s, %c) = %d", test.inputStr, test.inputChar, got)
 		}
 	}
@@ -47,15 +50,15 @@ func TestIsWordChar(t *testing.T) {
 	if IsWordChar("_") == false {
 		t.Errorf("IsWordChar(_) = false")
 	}
+	if IsWordChar("ß") == false {
+		t.Errorf("IsWordChar(ß) = false")
+	}
 	if IsWordChar("~") == true {
 		t.Errorf("IsWordChar(~) = true")
 	}
 	if IsWordChar(" ") == true {
 		t.Errorf("IsWordChar( ) = true")
 	}
-	if IsWordChar("ß") == true {
-		t.Errorf("IsWordChar(ß) = true")
-	}
 	if IsWordChar(")") == true {
 		t.Errorf("IsWordChar()) = true")
 	}
@@ -63,3 +66,91 @@ func TestIsWordChar(t *testing.T) {
 		t.Errorf("IsWordChar(\n)) = true")
 	}
 }
+
+func TestJoinAndSplitCommandArgs(t *testing.T) {
+	tests := []struct {
+		Query  []string
+		Wanted string
+	}{
+		{[]string{`test case`}, `"test case"`},
+		{[]string{`quote "test"`}, `"quote \"test\""`},
+		{[]string{`slash\\\ test`}, `"slash\\\\\\ test"`},
+		{[]string{`path 1`, `path\" 2`}, `"path 1" "path\\\" 2"`},
+		{[]string{`foo`}, `foo`},
+		{[]string{`foo\"bar`}, `"foo\\\"bar"`},
+		{[]string{``}, ``},
+		{[]string{`"`}, `"\""`},
+		{[]string{`a`, ``}, `a `},
+		{[]string{``, ``, ``, ``}, `   `},
+		{[]string{"\n"}, `"\n"`},
+		{[]string{"foo\tbar"}, `"foo\tbar"`},
+	}
+
+	for i, test := range tests {
+		if result := JoinCommandArgs(test.Query...); test.Wanted != result {
+			t.Errorf("JoinCommandArgs failed at Test %d\nGot: %q", i, result)
+		}
+
+		if result := SplitCommandArgs(test.Wanted); !reflect.DeepEqual(test.Query, result) {
+			t.Errorf("SplitCommandArgs failed at Test %d\nGot: `%q`", i, result)
+		}
+	}
+
+	splitTests := []struct {
+		Query  string
+		Wanted []string
+	}{
+		{`"hallo""Welt"`, []string{`halloWelt`}},
+		{`"hallo" "Welt"`, []string{`hallo`, `Welt`}},
+		{`\"`, []string{`\"`}},
+		{`"foo`, []string{`"foo`}},
+		{`"foo"`, []string{`foo`}},
+		{`"\"`, []string{`"\"`}},
+		{`"C:\\"foo.txt`, []string{`C:\foo.txt`}},
+		{`"\n"new"\n"line`, []string{"\nnew\nline"}},
+	}
+
+	for i, test := range splitTests {
+		if result := SplitCommandArgs(test.Query); !reflect.DeepEqual(test.Wanted, result) {
+			t.Errorf("SplitCommandArgs failed at Split-Test %d\nGot: `%q`", i, result)
+		}
+	}
+}
+
+func TestStringWidth(t *testing.T) {
+	tabsize := 4
+	if w := StringWidth("1\t2", tabsize); w != 5 {
+		t.Error("StringWidth 1 Failed. Got", w)
+	}
+	if w := StringWidth("\t", tabsize); w != 4 {
+		t.Error("StringWidth 2 Failed. Got", w)
+	}
+	if w := StringWidth("1\t", tabsize); w != 4 {
+		t.Error("StringWidth 3 Failed. Got", w)
+	}
+	if w := StringWidth("\t\t", tabsize); w != 8 {
+		t.Error("StringWidth 4 Failed. Got", w)
+	}
+	if w := StringWidth("12\t2\t", tabsize); w != 8 {
+		t.Error("StringWidth 5 Failed. Got", w)
+	}
+}
+
+func TestWidthOfLargeRunes(t *testing.T) {
+	tabsize := 4
+	if w := WidthOfLargeRunes("1\t2", tabsize); w != 2 {
+		t.Error("WidthOfLargeRunes 1 Failed. Got", w)
+	}
+	if w := WidthOfLargeRunes("\t", tabsize); w != 3 {
+		t.Error("WidthOfLargeRunes 2 Failed. Got", w)
+	}
+	if w := WidthOfLargeRunes("1\t", tabsize); w != 2 {
+		t.Error("WidthOfLargeRunes 3 Failed. Got", w)
+	}
+	if w := WidthOfLargeRunes("\t\t", tabsize); w != 6 {
+		t.Error("WidthOfLargeRunes 4 Failed. Got", w)
+	}
+	if w := WidthOfLargeRunes("12\t2\t", tabsize); w != 3 {
+		t.Error("WidthOfLargeRunes 5 Failed. Got", w)
+	}
+}

data/com.github.zyedidia.micro.metainfo.xml

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<component>
+  <id>com.github.zyedidia.micro</id>
+  <name>Micro Text Editor</name>
+  <summary>A modern and intuitive terminal-based text editor</summary>
+  <url type="homepage">https://micro-editor.github.io</url>
+  <url type="bugtracker">https://github.com/zyedidia/micro</url>
+  <metadata_license>MIT</metadata_license>
+   <categories>
+     <category>Development</category>
+	 <category>TextEditor</category>
+   </categories>
+
+  <provides>
+​    <binary>micro</binary>
+​  </provides>
+​  <releases>
+​    <release version="1.2.0" date="2017-05-28" />
+​  </releases>
+​  <developer_name>Zachary Yedidia</developer_name>
+  <screenshots>
+​  <screenshot type="default">
+​    <caption>Micro Text Editor editing its source code.</caption>
+​    <image type="source">https://raw.githubusercontent.com/zyedidia/micro/master/assets/micro-solarized.png</image>
+​  </screenshot>
+​ </screenshots>
+​</component>

runtime/README.md

@@ -1,5 +1,5 @@
 # Runtime files for Micro
 
 This directory will be embedded in the Go binary for portability, but it may just as well be put in `~/.config/micro`. If you would like to make your own colorschemes
-and syntax files, you can put in in `~/.config/micro/colorschemes` and `~/.config/micro/syntax` respectively.
+and syntax files, you can put them in `~/.config/micro/colorschemes` and `~/.config/micro/syntax` respectively.
 

runtime/colorschemes/atom-dark-tc.micro

@@ -4,6 +4,7 @@ color-link identifier "#F9EE98,#1D1F21"
 color-link constant "#FF73FD,#1D1F21"
 color-link constant.string "#A8FF60,#1D1F21"
 color-link statement "#96CBFE,#1D1F21"
+color-link symbol "#96CBFE,#1D1F21"
 color-link preproc "#62B1FE,#1D1F21"
 color-link type "#C6C5FE,#1D1F21"
 color-link special "#A6E22E,#1D1F21"
@@ -11,9 +12,15 @@ color-link underlined "#D33682,#1D1F21"
 color-link error "bold #FF4444,#1D1F21"
 color-link todo "bold #FF8844,#1D1F21"
 color-link statusline "#1D1F21,#C5C8C6"
+color-link tabbar "#1D1F21,#C5C8C6"
 color-link indent-char "#505050,#1D1F21"
 color-link line-number "#656866,#232526"
 color-link current-line-number "#656866,#1D1F21"
 color-link gutter-error "#FF4444,#1D1F21"
 color-link gutter-warning "#EEEE77,#1D1F21"
 color-link cursor-line "#2D2F31"
+color-link color-column "#2D2F31"
+#color-link symbol.brackets "#96CBFE,#1D1F21"
+#No extended types (bool in C, etc.)
+#color-link type.extended "default"
+#Plain brackets

runtime/colorschemes/bubblegum.micro

@@ -0,0 +1,24 @@
+color-link default "241,231"
+color-link comment "246,231"
+color-link constant "130,231"
+color-link constant.string "136,231"
+color-link constant.number "131,231"
+color-link identifier "133,231"
+color-link statement "32,231"
+color-link symbol "32,231"
+color-link preproc "28,231"
+color-link type "61,231"
+color-link special "167,231"
+color-link error "231, 160"
+color-link underlined "underline 241,231"
+color-link todo "246,231"
+color-link statusline "241,254"
+color-link tabbar "241,254"
+color-link gutter-error "197,231"
+color-link gutter-warning "134,231"
+color-link line-number "246,254"
+color-link cursor-line "254"
+color-link color-column "254"
+#No extended types (bool in C, &c.) and plain brackets
+color-link type.extended "default"
+color-link symbol.brackets "default"

runtime/colorschemes/cmc-16.micro

@@ -0,0 +1,40 @@
+#CaptainMcClellan's personal color scheme.
+#16 colour version.
+color-link comment "bold black"
+color-link constant "cyan"
+color-link constant.bool "bold cyan"
+color-link constant.bool.true "bold green"
+color-link constant.bool.false "bold red"
+color-link constant.string "yellow"
+color-link constant.string.url "underline blue, white"
+#color-link constant.number "constant"
+color-link constant.specialChar "bold magenta"
+color-link identifier "bold red"
+color-link identifier.macro "bold red"
+color-link identifier.var "bold blue"
+#color-link identifier.class "bold green"
+color-link identifier.class "bold white"
+color-link statement "bold yellow"
+color-link symbol "red"
+color-link symbol.brackets "blue"
+color-link symbol.tag "bold blue"
+color-link symbol.tag.extended "bold green"
+color-link preproc "bold cyan"
+color-link type "green"
+color-link type.keyword "bold green"
+color-link special "magenta"
+color-link ignore "default"
+color-link error "bold ,brightred"
+color-link todo "underline black,brightyellow"
+color-link indent-char ",brightgreen"
+color-link line-number "green"
+color-link line-number.scrollbar "green"
+color-link statusline "white,blue"
+color-link tabbar "white,blue"
+color-link current-line-number "red"
+color-link current-line-number.scroller "red"
+color-link gutter-error ",red"
+color-link gutter-warning "red"
+color-link color-column "cyan"
+color-link underlined.url "underline blue, white"
+color-link divider "blue"

runtime/colorschemes/cmc-paper.micro

@@ -0,0 +1,37 @@
+#CaptainMcClellan's personal color scheme.
+#Paper version
+color-link default "black,white"
+color-link comment "bold black"
+color-link constant "cyan"
+color-link constant.bool "bold cyan"
+color-link constant.bool.true "bold green"
+color-link constant.bool.false "bold red"
+color-link constant.string "bold yellow"
+color-link constant.string.url "underline blue, white"
+color-link constant.number "constant"
+color-link constant.specialChar "bold magenta"
+color-link identifier "bold red"
+color-link identifier.macro "bold red"
+color-link identifier.var "bold blue"
+color-link identifier.class "bold green"
+color-link preproc "bold cyan"
+color-link statement "bold yellow"
+color-link symbol "red"
+color-link symbol.brackets "blue"
+color-link type "green"
+color-link type.keyword "bold green"
+color-link special "magenta"
+color-link ignore "default"
+color-link error ",brightred"
+color-link todo "black,brightyellow"
+color-link indent-char ",brightgreen"
+color-link line-number "green"
+color-link line-number.scrollbar "green"
+color-link statusline "white,blue"
+color-link tabbar "white,blue"
+color-link current-line-number "red"
+color-link current-line-number.scroller "red"
+color-link gutter-error ",red"
+color-link gutter-warning "red"
+color-link color-column "cyan"
+color-link underlined.url "underline blue, white"

runtime/colorschemes/cmc-tc.micro

@@ -0,0 +1,36 @@
+#CaptainMcClellan's personal colour scheme.
+#Full colour edition.
+color-link default "#aaaaaa,#1e2124"
+color-link comment "bold #555555"
+color-link constant "#008888"
+#color-link constant.string "#888800"
+color-link constant.string "#a85700"
+color-link constant.specialChar "bold #ccccff"
+color-link identifier "bold #e34234"
+color-link identifier.macro "bold #e34234"
+color-link identifier.var "bold #5757ff"
+color-link identifier.class "bold #ffffff"
+color-link statement "bold #ffff55"
+color-link symbol "#722f37"
+color-link symbol.brackets "#4169e1"
+color-link symbol.tag "#5757ff"
+color-link preproc "bold #55ffff"
+color-link type "#3eb489"
+color-link type.keyword "bold #bdecb6"
+color-link special "#b57edc"
+color-link ignore "default"
+color-link error "bold ,#e34234"
+color-link todo "bold underline #888888,#f26522"
+color-link indent-char ",#bdecb6"
+color-link line-number "#bdecb6,#36393e"
+color-link line-number.scrollbar "#3eb489"
+color-link statusline "#aaaaaa,#8a496b"
+color-link tabbar "#aaaaaa,#8a496b"
+color-link current-line-number "bold #e34234,#424549"
+color-link current-line-number.scroller "red"
+color-link gutter-error ",#e34234"
+color-link gutter-warning "#e34234"
+color-link color-column "#f26522"
+color-link constant.bool "bold #55ffff"
+color-link constant.bool.true "bold #85ff85"
+color-link constant.bool.false "bold #ff8585"

runtime/colorschemes/codeblocks-paper.micro

@@ -0,0 +1,25 @@
+#A colorscheme based on Code::Blocks IDE
+#but with a white background.
+color-link default "black,white"
+color-link comment "bold black"
+color-link constant "blue"
+color-link constant.number "bold magenta"
+color-link constant.string "bold blue"
+color-link identifier "black"
+color-link preproc "green"
+color-link statement "blue"
+color-link symbol "red"
+color-link symbol.brackets "blue"
+color-link type "blue"
+color-link special "magenta"
+color-link ignore "default"
+color-link error "bold white,brightred"
+color-link todo "bold black,brightyellow"
+color-link indent-char "bold black"
+color-link line-number "black,white"
+color-link statusline "white,red"
+color-link tabbar "white,red"
+color-link current-line-number "red,black"
+color-link gutter-error ",red"
+color-link gutter-warning "red"
+color-link color-column "black"

runtime/colorschemes/codeblocks.micro

@@ -0,0 +1,23 @@
+#Theme based on Code::Blocks IDE's default syntax highlighting.
+color-link comment "bold black"
+color-link constant "blue"
+color-link constant.string "bold blue"
+color-link constant.number "bold magenta"
+color-link identifier "default"
+color-link preproc "green"
+color-link statement "blue"
+color-link symbol "red"
+color-link symbol.brackets "blue"
+color-link type "blue"
+color-link special "magenta"
+color-link ignore "default"
+color-link error ",brightred"
+color-link todo "bold black,brightyellow"
+color-link indent-char "bold black"
+color-link line-number "black,white"
+color-link statusline "white,red"
+color-link tabbar "white,red"
+color-link current-line-number "red"
+color-link gutter-error ",red"
+color-link gutter-warning "red"
+color-link color-column "white"

runtime/colorschemes/default.micro

@@ -1,16 +1,27 @@
-color-link comment "blue"
-color-link constant "red"
-color-link identifier "cyan"
-color-link statement "yellow"
-color-link preproc "magenta"
-color-link type "green"
-color-link special "magenta"
-color-link ignore "default"
-color-link error ",brightred"
-color-link todo ",brightyellow"
-color-link indent-char "black"
-color-link line-number "yellow"
-color-link current-line-number "red"
-color-link gutter-error ",red"
-color-link gutter-warning "red"
-color-link cursor-line "white"
+# This is the monokai colorscheme
+color-link default "#F8F8F2,#282828"
+color-link comment "#75715E,#282828"
+color-link identifier "#66D9EF,#282828"
+color-link constant "#AE81FF,#282828"
+color-link constant.string "#E6DB74,#282828"
+color-link constant.string.char "#BDE6AD,#282828"
+color-link statement "#F92672,#282828"
+color-link symbol "#F92672,#282828"
+color-link preproc "#CB4B16,#282828"
+color-link type "#66D9EF,#282828"
+color-link special "#A6E22E,#282828"
+color-link underlined "#D33682,#282828"
+color-link error "bold #CB4B16,#282828"
+color-link todo "bold #D33682,#282828"
+color-link statusline "#282828,#F8F8F2"
+color-link tabbar "#282828,#f8f8f2"
+color-link indent-char "#505050,#282828"
+color-link line-number "#AAAAAA,#323232"
+color-link current-line-number "#AAAAAA,#282828"
+color-link gutter-error "#CB4B16,#282828"
+color-link gutter-warning "#E6DB74,#282828"
+color-link cursor-line "#323232"
+color-link color-column "#323232"
+#No extended types; plain brackets
+color-link type.extended "default"
+color-link symbol.brackets "default"

runtime/colorschemes/flamepoint-tc.micro

@@ -0,0 +1,30 @@
+#Flamepoint theme
+#By CaptainMcClellan
+color-link default ""
+color-link comment ""
+color-link constant ""
+color-link constant.bool ""
+color-link constant.bool.true ""
+color-link constant.bool.false ""
+color-link constant.number ""
+color-link constant.specialChar ""
+color-link constant.string ""
+color-link constant.string.url "underline"
+color-link identifier ""
+color-link identifier.var ""
+color-link preproc ""
+color-link special ""
+color-link statement ""
+color-link symbol ""
+color-link symbol.brackets ""
+color-link symbol.tag ""
+color-link type ""
+color-link type.keyword ""
+color-link error ""
+color-link todo ""
+color-link cursor-line "" 
+color-link statusline ""
+color-link tabbar ""
+color-link color-column ""
+color-link gutter-error ""
+color-link gutter-warning ""

runtime/colorschemes/funky-cactus-tc.micro

@@ -0,0 +1 @@
+#Funky Cactus theme in true colour.

runtime/colorschemes/funky-cactus.micro

@@ -0,0 +1,31 @@
+#Funky Cactus theme
+color-link comment "bold black"
+color-link constant "cyan"
+color-link constant.bool "bold cyan"
+color-link constant.bool.true "bold green"
+color-link constant.bool.false "bold red"
+color-link constant.string "yellow"
+color-link constant.number "constant"
+color-link constant.specialChar "bold magenta"
+color-link identifier "bold red"
+color-link identifier.macro "bold red"
+color-link identifier.var "bold blue"
+color-link identifier.class "bold green"
+color-link preproc "bold cyan"
+color-link statement "bold yellow"
+color-link symbol "red"
+color-link symbol.brackets "blue"
+color-link type "green"
+color-link type.keyword "bold green"
+color-link special "magenta"
+color-link ignore "default"
+color-link error "bold ,brightred"
+color-link todo "underline ,brightyellow"
+color-link indent-char "bold ,brightgreen"
+color-link line-number "green"
+color-link statusline "black,green"
+color-link tabbar "black,magenta"
+color-link current-line-number "bold magenta" 
+color-link gutter-error ",red"
+color-link gutter-warning "red"
+color-link color-column "bold green"

runtime/colorschemes/gameboy-tc.micro

@@ -0,0 +1,23 @@
+#Gameboy theme
+color-link default "#3f3f3f,#bfc180"
+color-link comment "#7d7343"
+color-link constant "#7d7343"
+color-link identifier "#ddde7d"
+color-link preproc "#ddde7d,#7d7343"
+color-link special "#7d7343"
+color-link statement "#7d7343"
+color-link symbol "#7d7343"
+color-link type "#7d7343"
+color-link error "#ddde7d,#7d7343"
+color-link todo "#7d7343,#ddde7d"
+color-link statusline "#ddde7d,#7d7343"
+color-link tabbar "#ddde7d,#7d7343"
+color-link color-column "#7d7343"
+color-link line-number "#ddde7d,#7d7343"
+color-link current-line-number "#3f3f3f,#bfc180"
+color-link gutter-error "#ddde7d,#7d7343"
+color-link gutter-warning "default"
+#3f3f3f
+#7d7343
+#bfc180
+#ddde76

runtime/colorschemes/geany-alt-tc.micro

@@ -0,0 +1,21 @@
+#Geany Alternate theme
+color-link default "#000000,#fefefe"
+color-link comment "#808080"
+color-link constant "default"
+color-link constant.bool "#003030"
+color-link constant.number "#300008"
+color-link constant.string "#008000"
+color-link identifier "default"
+color-link preproc "#bbbb77"
+color-link special "#003030"
+color-link statement "#003030"
+color-link symbol "#300008"
+color-link symbol.tag "bold #4e9d71"
+color-link type "#003030"
+color-link error "#a52a2a"
+color-link todo "#ffa500"
+color-link line-number "#000000,#d0d0d0"
+color-link current-line-number "#000000,#d0d0d0"
+color-link color-column "#c2ebc2"
+color-link cursor-line "#f0f0f0"
+color-link type.extended "default"

runtime/colorschemes/geany.micro

@@ -0,0 +1,23 @@
+#Geany
+color-link comment "red"
+color-link constant "default"
+color-link constant.number
+color-link constant.string "bold yellow"
+color-link identifier "default"
+color-link preproc "cyan"
+color-link special "blue"
+color-link statement "blue"
+color-link symbol "default"
+color-link symbol.tag "bold blue"
+color-link type "blue"
+color-link type.extended "default"
+color-link error "red"
+color-link todo "bold cyan"
+color-link indent-char "bold black"
+color-link line-number ""
+color-link current-line-number ""
+color-link statusline "black,white"
+color-link tabbar "black,white"
+color-link color-column "bold geren"
+color-link gutter-error ",red"
+color-link gutter-warning "red"

runtime/colorschemes/github-tc.micro

@@ -0,0 +1,24 @@
+#True color theme based on Github's syntax highlighting.
+#Warning, this is based on how it rendered in my Firefox!
+#Yours may look different.
+color-link comment "bold #969896"
+color-link constant "#0086B9"
+color-link constant.number "#0086B9"
+color-link constant.specialChar "bold #1836BD"
+color-link constant.string "bold #1836BD"
+color-link constant.bool "#0086B9"
+color-link identifier "#A71D5D"
+color-link preproc "bold #A71D5D"
+color-link special "#A71D5D"
+color-link statement "#A71D5D"
+color-link symbol "default"
+color-link type "#A71D5D"
+color-link error "bold ,#E34234"
+color-link todo "white"
+color-link indent-char "default"
+color-link line-number "bold #969896"
+color-link current-line-number "bold #969896"
+color-link gutter-error "bold ,#E34234"
+color-link gutter-warning "bold #f26522"
+color-link statusline "bold #c8c9cb,#24292e"
+color-link tabbar "bold #c8c9cb,#24292e"

runtime/colorschemes/github.micro

@@ -0,0 +1,24 @@
+#Theme based on Github's syntax highlighting.
+color-link comment "bold black"
+color-link constant "cyan"
+color-link constant.number "cyan"
+color-link constant.specialChar "bold blue"
+color-link constant.string "bold blue"
+color-link constant.bool "cyan"
+color-link identifier "magenta"
+color-link preproc "bold magenta"
+color-link special "magenta"
+color-link statement "magenta"
+color-link symbol "default"
+color-link type "magenta"
+color-link error "bold ,brightred"
+color-link todo "white"
+color-link indent-char "default"
+color-link line-number "bold black"
+color-link current-line-number "bold black"
+color-link gutter-error ",red"
+color-link gutter-warning "bold yellow"
+color-link statusline "bold white,black"
+color-link tabbar "bold white,black"
+#Plain brackets.
+#color-link symbol.brackets "default"

runtime/colorschemes/gruvbox-tc.micro

@@ -0,0 +1,21 @@
+color-link default "#ebdbb2,#282828"
+color-link comment "#928374,#282828"
+color-link symbol "#d79921,#282828"
+color-link constant "#d3869b,#282828"
+color-link constant.string "#b8bb26,#282828"
+color-link constant.string.char "#b8bb26,#282828"
+color-link identifier "#8ec07c,#282828"
+color-link statement "#fb4934,#282828"
+color-link preproc "#fb4934,235"
+color-link type "#fb4934,#282828"
+color-link special "#d79921,#282828"
+color-link underlined "underline #282828"
+color-link error "#9d0006,#282828"
+color-link gutter-error "#fb4934,#282828"
+color-link gutter-warning "#d79921,#282828"
+color-link line-number "#665c54,#282828"
+color-link current-line-number "#665c54,#3c3836"
+color-link cursor-line "#3c3836"
+color-link color-column "#79740e"
+color-link statusline "#ebdbb2,#665c54"
+color-link tabbar "#ebdbb2,#665c54"

runtime/colorschemes/gruvbox.micro

@@ -4,6 +4,7 @@ color-link constant "175,235"
 color-link constant.string "142,235"
 color-link identifier "109,235"
 color-link statement "124,235"
+color-link symbol "124,235"
 color-link preproc "72,235"
 color-link type "214,235"
 color-link special "172,235"
@@ -13,3 +14,6 @@ color-link todo "bold 223,235"
 color-link line-number "243,237"
 color-link current-line-number "172,237"
 color-link cursor-line "237"
+color-link color-column "237"
+color-link statusline "223,237"
+color-link tabbar "223,237"

runtime/colorschemes/mc.micro

@@ -0,0 +1,25 @@
+#Midnight Commander inspired theme.
+color-link default "white,blue"
+color-link comment "bold black"
+color-link constant "bold white"
+color-link constant.string "bold yellow"
+color-link identifier "bold red"
+color-link statement "bold cyan"
+color-link symbol "white"
+color-link symbol.brackets "white"
+color-link symbol.tag "bold green"
+color-link preproc "black,cyan"
+color-link type "green"
+color-link special "magenta"
+color-link ignore "default"
+color-link error ",brightred"
+color-link todo ",brightyellow"
+color-link indent-char ",cyan"
+color-link line-number "green"
+color-link statusline "black,cyan"
+color-link tabbar "black,cyan"
+color-link current-line-number "black,cyan"
+color-link cursor-line "black,cyan"
+color-link gutter-error ",red"
+color-link gutter-warning "red"
+color-link color-column "cyan"

runtime/colorschemes/monochrome-paper.micro

@@ -0,0 +1,5 @@
+#Monochrome Paper theme.
+#Edit your files on a white background without colors.
+color-link default "black,white"
+color-link statusline "white,black"
+color-link tabbar "white,black"

runtime/colorschemes/monochrome.micro

@@ -0,0 +1,3 @@
+#Monochrome
+#This makes micro use only the terminal's default
+# foreground and background colours.

runtime/colorschemes/monokai.micro

@@ -3,7 +3,9 @@ color-link comment "#75715E,#282828"
 color-link identifier "#66D9EF,#282828"
 color-link constant "#AE81FF,#282828"
 color-link constant.string "#E6DB74,#282828"
+color-link constant.string.char "#BDE6AD,#282828"
 color-link statement "#F92672,#282828"
+color-link symbol "#F92672,#282828"
 color-link preproc "#CB4B16,#282828"
 color-link type "#66D9EF,#282828"
 color-link special "#A6E22E,#282828"
@@ -11,9 +13,15 @@ color-link underlined "#D33682,#282828"
 color-link error "bold #CB4B16,#282828"
 color-link todo "bold #D33682,#282828"
 color-link statusline "#282828,#F8F8F2"
+color-link tabbar "#282828,#F8F8F2"
 color-link indent-char "#505050,#282828"
 color-link line-number "#AAAAAA,#323232"
 color-link current-line-number "#AAAAAA,#282828"
 color-link gutter-error "#CB4B16,#282828"
 color-link gutter-warning "#E6DB74,#282828"
 color-link cursor-line "#323232"
+color-link color-column "#323232"
+#No extended types; Plain brackets.
+color-link type.extended "default"
+#color-link symbol.brackets "default"
+color-link symbol.tag "#AE81FF,#282828"

runtime/colorschemes/nano.micro

@@ -0,0 +1,30 @@
+#Colorscheme styled after default Debian nano.
+color-link comment "bold blue"
+color-link comment.bright "cyan"
+color-link constant "red"
+color-link constant.bool "yellow"
+color-link constant.bool.true "bold green"
+color-link constant.bool.false "bold red"
+color-link constant.number "default"
+color-link constant.specialChar "bold magenta"
+color-link constant.string "bold yellow"
+color-link identifier "bold blue"
+color-link identifier.macro "bold red"
+color-link statement "bold green" 
+color-link symbol "green"
+#color-link symbol.tag "blue"
+color-link preproc "brightcyan"
+color-link type "green"
+color-link special "magenta"
+color-link ignore "default"
+color-link error "white,black"
+color-link todo "bold cyan"
+color-link indent-char ",green"
+color-link line-number "default"
+color-link current-line-number "default"
+color-link gutter-error ",white"
+color-link gutter-warning "white"
+color-link cursor-line "default"
+color-link color-column "white"
+#No extended types ( bool in C ); Plain brackets
+color-link type.extended "default"

runtime/colorschemes/nes-tc.micro

@@ -0,0 +1,30 @@
+#NES
+#A color theme only using NES pallette colours
+color-link default ""
+color-link comment ""
+color-link constant ""
+color-link constant.bool ""
+color-link constant.bool.true ""
+color-link constant.bool.false ""
+color-link constant.number ""
+color-link constant.specialChar ""
+color-link constant.string ""
+color-link constant.string.url "underline"
+color-link identifier ""
+color-link identifier.var ""
+color-link preproc ""
+color-link special ""
+color-link statement ""
+color-link symbol ""
+color-link symbol.brackets ""
+color-link symbol.tag ""
+color-link type ""
+color-link type.keyword ""
+color-link error ""
+color-link todo ""
+color-link cursor-line "" 
+color-link statusline ""
+color-link tabbar ""
+color-link color-column ""
+color-link gutter-error ""
+color-link gutter-warning ""

runtime/colorschemes/paper-tc.micro

@@ -0,0 +1,22 @@
+#Paper theme, true color edition
+#Edit on an *actual* white background!
+color-link default "#000000,#efefef"
+color-link comment ""
+color-link constant ""
+color-link constant.string ""
+color-link constant.string.url "underline #0000dd"
+color-link identifier "" 
+color-link identifier.var ""
+color-link special ""
+color-link statement ""
+color-link symbol ""
+color-link symbol.brackets ""
+color-link symbol.tag ""
+color-link type ""
+color-link statusline ""
+color-link tabbar ""
+color-link error ""
+color-link todo ""
+color-link color-column ""
+color-link gutter-error ""
+color-link gutter-warning ""

runtime/colorschemes/paper.micro

@@ -0,0 +1,27 @@
+#Paper theme, Edit on a white background.
+color-link default "black,white"
+color-link comment "bold black"
+color-link constant "cyan"
+color-link constant.string "bold green"
+color-link identifier "blue"
+color-link identifier.macro "bold red"
+color-link identifier.var "bold blue"
+color-link identifier.class "bold green"
+color-link statement "green"
+color-link symbol "red"
+color-link symbol.brackets "default"
+color-link symbol.tag "bold blue"
+color-link preproc "bold cyan"
+color-link type "green"
+color-link special "magenta"
+color-link ignore "default"
+color-link error ",brightred"
+color-link todo ",brightyellow"
+color-link indent-char ",brightgreen"
+color-link line-number "black"
+color-link statusline "white,black"
+color-link tabbar "white,black"
+color-link current-line-number "blue"
+color-link gutter-error ",red"
+color-link gutter-warning "red"
+color-link color-column "black"

runtime/colorschemes/simple.micro

@@ -0,0 +1,25 @@
+color-link comment "blue"
+color-link constant "red"
+color-link identifier "cyan"
+color-link statement "yellow"
+color-link symbol "yellow"
+color-link preproc "magenta"
+color-link type "green"
+color-link special "magenta"
+color-link ignore "default"
+color-link error ",brightred"
+color-link todo ",brightyellow"
+color-link indent-char "black"
+color-link line-number "yellow"
+color-link current-line-number "red"
+color-link gutter-error ",red"
+color-link gutter-warning "red"
+#Cursor line causes readability issues. Disabled for now.
+#color-link cursor-line "white,black"
+color-link color-column "white"
+#No extended types. (bool in C)
+color-link type.extended "default"
+#No bracket highlighting.
+color-link symbol.brackets "default"
+#Color shebangs the comment color
+color-link preproc.shebang "comment"

runtime/colorschemes/solarized-tc.micro

@@ -2,17 +2,23 @@ color-link default "#839496,#002833"
 color-link comment "#586E75,#002833"
 color-link identifier "#268BD2,#002833"
 color-link constant "#2AA198,#002833"
+color-link constant.specialChar "#DC322F,#002833"
 color-link statement "#859900,#002833"
+color-link symbol "#859900,#002833"
 color-link preproc "#CB4B16,#002833"
 color-link type "#B58900,#002833"
-color-link special "#DC322F,#002833"
+color-link special "#268BD2,#002833"
 color-link underlined "#D33682,#002833"
 color-link error "bold #CB4B16,#002833"
 color-link todo "bold #D33682,#002833"
 color-link statusline "#003541,#839496"
-color-link indent-char "#586E75,#002833"
+color-link tabbar "#003541,#839496"
+color-link indent-char "#003541,#002833"
 color-link line-number "#586E75,#003541"
 color-link current-line-number "#586E75,#002833"
 color-link gutter-error "#003541,#CB4B16"
 color-link gutter-warning "#CB4B16,#002833"
 color-link cursor-line "#003541"
+color-link color-column "#003541"
+color-link type.extended "#839496,#002833"
+color-link symbol.brackets "#839496,#002833"

runtime/colorschemes/solarized.micro

@@ -1,17 +1,23 @@
-color-link comment "brightgreen"
+color-link comment "bold brightgreen"
 color-link constant "cyan"
+color-link constant.specialChar "red"
 color-link identifier "blue"
 color-link statement "green"
+color-link symbol "green"
 color-link preproc "brightred"
 color-link type "yellow"
-color-link special "red"
+color-link special "blue"
 color-link underlined "magenta"
 color-link error "bold brightred"
 color-link todo "bold magenta"
 color-link statusline "black,brightblue"
+color-link tabbar "black,brightblue"
 color-link indent-char "black"
-color-link line-number "brightgreen,black"
-color-link current-line-number "brightgreen,default"
+color-link line-number "bold brightgreen,black"
+color-link current-line-number "bold brightgreen,default"
 color-link gutter-error "black,brightred"
 color-link gutter-warning "brightred,default"
 color-link cursor-line "black"
+color-link color-column "black"
+color-link type.extended "default"
+color-link symbol.brackets "default"

runtime/colorschemes/symbian-tc.micro

@@ -0,0 +1,23 @@
+#Symbian
+color-link default "#000000,#ff8a00"
+color-link comment "#8c0000"
+color-link constant "#8c0000"
+color-link identifier "#ffff8c"
+color-link preproc "#ffff8c,#8c0000"
+color-link special "#8c0000"
+color-link statement "#8c0000"
+color-link symbol "#8c0000"
+color-link type "#8c0000"
+color-link error "#ffff8c,#8c0000"
+color-link todo "#8c0000,#ffff8c"
+color-link statusline "#ffff8c,#8c0000"
+color-link tabbar "#ffff8c,#8c0000"
+color-link color-column "#8c0000"
+color-link line-number "#ffff8c,#8c0000"
+color-link current-line-number "#000000,#ff8a00"
+color-link gutter-error "#ffff8c,#8c0000"
+color-link gutter-warning "default"
+#000000
+#8c0000
+#ff8a00
+#ffff8c

runtime/colorschemes/zenburn.micro

@@ -0,0 +1,23 @@
+color-link default "188,237"
+color-link comment "108,237"
+color-link constant.string "174,237"
+color-link constant.number "116,237"
+color-link constant "181,237"
+color-link identifier "223,237"
+color-link statement "223,237"
+color-link symbol "223,237"
+color-link preproc "223,237"
+color-link type "187,237"
+color-link special "181,237"
+color-link underlined "188,237"
+color-link error "115,236"
+color-link todo "bold 254,237"
+color-link statusline "186,236"
+color-link tabbar "186,236"
+color-link indent-char "238,237"
+color-link line-number "248,238"
+color-link gutter-error "237,174"
+color-link gutter-warning "174,237"
+color-link cursor-line "238"
+color-link color-column "238"
+color-link current-line-number "188,237"

runtime/help/colors.md

@@ -5,36 +5,76 @@ This help page aims to cover two aspects of micro's syntax highlighting engine:
 - How to create colorschemes and use them
 - How to create syntax files to add to the list of languages micro can highlight
 
-### Colorschemes
+## Colorschemes
 
 Micro comes with a number of colorschemes by default. Here is the list:
 
-* default: this is the simplest colorscheme. It uses 16 colors which are
+* simple: this is the simplest colorscheme. It uses 16 colors which are
   set by your terminal
 
-* solarized: this is the solarized colorscheme. 
+* mc: A 16-color theme based on the look and feel of GNU Midnight Commander.
+  This will look great used in conjunction with Midnight Commander.
+  
+* nano: A 16-color theme loosely based on GNU nano's syntax highlighting.   
+  
+* monokai: this is the monokai colorscheme; you may recognize it as
+  Sublime Text's default colorscheme. It requires true color to
+  look perfect, but the 256 color approximation looks very good as well.
+  It's also the default colorscheme.
+
+* zenburn: The 'zenburn' colorscheme and works well with 256 color terminals
+
+* solarized: this is the solarized colorscheme.
   You should have the solarized color palette in your terminal to use it.
 
-* solarized-tc: this is the solarized colorscheme for true color, just 
-  make sure your terminal supports true color before using it and that the 
+* solarized-tc: this is the solarized colorscheme for true color; just
+  make sure your terminal supports true color before using it and that the
   MICRO_TRUECOLOR environment variable is set to 1 before starting micro.
 
-* monokai: this is the monokai colorscheme and is micro's default colorscheme
-  (as well as sublime text's).  It requires true color to
-  look perfect, but the 256 color approximation looks very good as well.
-
 * atom-dark-tc: this colorscheme is based off of Atom's "dark" colorscheme.
   It requires true color to look good.
 
-To enable one of these colorschemes just run the command `set colorscheme solarized`.
-(or whichever one you choose).
+* cmc-16: A very nice 16-color theme. Written by contributor CaptainMcClellan
+  (Collin Warren.) Licensed under the same license as the rest of the themes.
+
+* cmc-paper: Basically cmc-16, but on a white background. ( Actually light grey on most 
+  ANSI (16-color) terminals.)
+
+* cmc-tc: A true colour variant of the cmc theme. 
+  It requires true color to look its best. Use cmc-16 if your terminal doesn't support true color.
+
+* codeblocks: A colorscheme based on the Code::Blocks IDE's default syntax highlighting.
+
+* codeblocks-paper: Same as codeblocks, but on a white background. ( Actually light grey. )
+
+* github-tc: A colorscheme based on Github's syntax highlighting. Requires true color to look its best.
+
+* paper-tc: A nice minimalist theme with a light background, good for editing documents on.
+  Requires true color to look its best. Not to be confused with `-paper` suffixed themes.
+
+* geany: Colorscheme based on geany's default highlighting.
+
+* geany-alt-tc: Based on an alternate theme bundled with geany. 
+
+* flamepoint-tc: A fire inspired, high intensity true color theme written by CaptainMcClellan.
+  As with all the other `-tc` suffixed themes, it looks its best on a
+
+To enable one of these colorschemes just press CtrlE in micro and type `set colorscheme solarized`.
+(or whichever one you choose). You can also use `set colorscheme monochrome` if you'd prefer
+to have just the terminal's default foreground and background colors. 
+Note: This provides no syntax highlighting!
+
+See `help gimmickcolors` for a list of some true colour themes that are more 
+just for fun than for serious use. ( Though feel free if you want! )
 
 ---
 
+### Creating a Colorscheme
+
 Micro's colorschemes are also extremely simple to create. The default ones can be found
 [here](https://github.com/zyedidia/micro/tree/master/runtime/colorschemes).
 
-They are only about 18 lines in total.
+They are only about 18-30 lines in total.
 
 Basically to create the colorscheme you need to link highlight groups with actual colors.
 This is done using the `color-link` command.
@@ -81,7 +121,8 @@ If the user's terminal supports true color, then you can also specify colors exa
 their hex codes. If the terminal is not true color but micro is told to use a true color colorscheme
 it will attempt to map the colors to the available 256 colors.
 
-Generally colorschemes which require true color terminals to look good are marked with a `-tc` suffix.
+Generally colorschemes which require true color terminals to look good are marked with a `-tc` suffix
+and colorschemes which supply a white background are marked with a `-paper` suffix.
 
 ---
 
@@ -92,61 +133,172 @@ Here is a list of the colorscheme groups that you can use:
 * identifier
 * constant
 * statement
+* symbol
 * preproc
 * type
 * special
 * underlined
 * error
 * todo
-* statusline (color of the statusline)
-* indent-char (color of the character which indicates tabs if the option is enabled)
+* statusline ( Color of the statusline)
+* tabbar ( Color of the tabbar that lists open files.)
+* indent-char ( Color of the character which indicates tabs if the option is enabled)
 * line-number
 * gutter-error
 * gutter-warning
 * cursor-line
+* current-line-number
+* color-column
+* ignore
+* divider ( Color of the divider between vertical splits. )
 
-Colorschemes can be placed in the `~/.config/micro/colorschemes` directory to be used.
-
-### Syntax files
-
-The syntax files specify how to highlight certain languages.
-
-The first statement in a syntax file will probably the syntax statement. This tells micro
-what language the syntax file is for and how to detect a file in that language.
-
-Essentially, it's just
-
-```
-syntax "Name of language" "\.extension$"
-```
-
-For the extension, micro will just compare that regex to the filename and if it matches then it
-will use the syntax rules defined in the remainder of the file.
-
-There is also a possibility to use a header statement which is a regex that micro will compare
-with the first line of the file. This is almost only used for shebangs at the top of shell scripts
-which don't have any extension (see sh.micro for an example).
+Colorschemes must be placed in the `~/.config/micro/colorschemes` directory to be used.
 
 ---
 
-The rest of a syntax file is very simple and is essentially a list of regexes specifying how to highlight
-different expressions.
+In addition to the main colorscheme groups, there are subgroups that you can
+specify by adding `.subgroup` to the group. If you're creating your own
+custom syntax files, you can make use of your own subgroups.
 
-It is recommended that when creating a syntax file you use the colorscheme groups (see above) to
-highlight different expressions. You may also hard code colors, but that may not look good depending
-on what terminal colorscheme the user has installed.
+If micro can't match the subgroup, it'll default to the root group, so 
+it's safe and recommended to use subgroups in your custom syntax files.
 
-Here is an example to highlight comments (expressions starting with `//`):
+For example if `constant.string` is found in your colorscheme, micro will
+use that for highlighting strings. If it's not found, it will use constant 
+instead. Micro tries to match the largest set of groups it can find in the
+colorscheme definitions, so if, for examle `constant.bool.true` is found then
+micro will use that. If `constant.bool.true` is not found but `constant.bool`
+is found micro will use `constant.bool`. If not, it uses `constant`. 
+
+Here's a list of subgroups used in micro's built-in syntax files.
+
+* comment.bright ( Some filetypes have distinctions between types of comments.)
+* constant.bool
+* constant.bool.true
+* constant.bool.false
+* constant.number 
+* constant.specialChar
+* constant.string
+* constant.string.url 
+* identifier.class ( Also used for functions. )
+* identifier.macro
+* identifier.var
+* preproc.shebang ( The #! at the beginning of a file that tells the os what script interpreter to use. )
+* symbol.brackets ( {}()[] and sometimes <> )
+* symbol.operator ( Color operator symbols differently. )
+* symbol.tag ( For html tags, among other things.)
+* type.keyword ( If you want a special highlight for keywords like `private` )
+
+In the future, plugins may also be able to use color groups for styling.
+
+## Syntax files
+
+The syntax files is written in yaml-format and specify how to highlight languages.
+
+Micro's builtin syntax highlighting tries very hard to be sane, sensible
+and provide ample coverage of the meaningful elements of a language. Micro has
+syntax files built int for over 100 languages now. However, there may be 
+situations where you find Micro's highlighting to be insufficient or not to
+your liking. Good news is you can create syntax files (.micro extension), place them in 
+`~/.config/micro/syntax` and Micro will use those instead.
+
+### Filetype defintion
+
+You must start the syntax file by declaring the filetype:
 
 ```
-color comment "//.*"
+filetype: go
 ```
 
-This will highlight the regex `//.*` in the color that the user's colorscheme has linked to the comment
-group.
+#### Detect definition
 
-Note that this regex only matches the current line. Here is an example for multiline comments (`/* comment */`):
+Then you must provide information about how to detect the filetype:
 
 ```
-color comment start="/\*" end="\*/"
+detect:
+    filename: "\\.go$"
+```
+
+Micro will match this regex against a given filename to detect the filetype. You may also
+provide an optional `header` regex that will check the first line of the file. For example:
+
+```
+detect:
+    filename: "\\.ya?ml$"
+    header: "%YAML"
+```
+
+#### Syntax rules
+
+Next you must provide the syntax highlighting rules. There are two types of rules: patterns and regions.
+A pattern is matched on a single line and usually a single word as well. A region highlights between two
+patterns over multiple lines and may have rules of its own inside the region.
+
+Here are some example patterns in Go:
+
+```
+rules:
+    - special: "\\b(break|case|continue|default|go|goto|range|return)\\b"
+    - statement: "\\b(else|for|if|switch)\\b"
+    - preproc: "\\b(package|import|const|var|type|struct|func|go|defer|iota)\\b"
+```
+
+The order of patterns does matter as patterns lower in the file will overwrite the ones defined above them.
+
+And here are some example regions for Go:
+
+```
+- constant.string:
+    start: "\""
+    end: "\""
+    rules:
+        - constant.specialChar: "%."
+        - constant.specialChar: "\\\\[abfnrtv'\\\"\\\\]"
+        - constant.specialChar: "\\\\([0-7]{3}|x[A-Fa-f0-9]{2}|u[A-Fa-f0-9]{4}|U[A-Fa-f0-9]{8})"
+
+- comment:
+    start: "//"
+    end: "$"
+    rules:
+        - todo: "(TODO|XXX|FIXME):?"
+
+- comment:
+    start: "/\\*"
+    end: "\\*/"
+    rules:
+        - todo: "(TODO|XXX|FIXME):?"
+```
+
+Notice how the regions may contain rules inside of them. Any inner rules that are matched are then skipped when searching
+for the end of the region. For example, when highlighting `"foo \" bar"`, since `\"` is matched by an inner rule in the
+region, it is skipped. Likewise for `"foo \\" bar`, since `\\` is matched by an inner rule, it is skipped, and then the `"`
+is found and the string ends at the correct place.
+
+You may also explicitly mark skip regexes if you don't want them to be highlighted. For example:
+
+```
+- constant.string:
+    start: "\""
+    end: "\""
+    skip: "\\."
+    rules: []
+```
+
+#### Includes
+
+You may also include rules from other syntax files as embedded languages. For example, the following is possible
+for html:
+
+```
+- default:
+    start: "<script.*?>"
+    end: "</script.*?>"
+    rules:
+        - include: "javascript"
+
+- default:
+    start: "<style.*?>"
+    end: "</style.*?>"
+    rules:
+        - include: "css"
 ```

runtime/help/commands.md

@@ -5,12 +5,13 @@ Here are the possible commands that you can use.
 
 * `quit`: Quits micro.
 
-* `save`: Saves the current buffer.
+* `save filename?`: Saves the current buffer. If the filename is provided it will
+   'save as' the filename.
 
 * `replace "search" "value" flags`: This will replace `search` with `value`. 
    The `flags` are optional.
    At this point, there is only one flag: `c`, which enables `check` mode 
-   which asks if you'd like to perform the replacement each time
+   which asks if you'd like to perform the replacement each time.
 
    Note that `search` must be a valid regex.  If one of the arguments
    does not have any spaces in it, you may omit the quotes.
@@ -21,6 +22,12 @@ Here are the possible commands that you can use.
 * `setlocal option value`: sets the option to value locally (only in the current
    buffer).
 
+* `show option`: shows the current value of the given option.
+
+* `eval "expression"`: Evaluates a Lua expression. Note that micro will not
+   print anything so you should use `messenger:Message(...)` to display a
+   value.
+
 * `run sh-command`: runs the given shell command in the background. The 
    command's output will be displayed in one line when it finishes running.
 
@@ -28,19 +35,47 @@ Here are the possible commands that you can use.
    keybindings above for more info about what keys and actions are available.
 
 * `vsplit filename`: opens a vertical split with `filename`. If no filename is
-   provided, a vertical split is opened with an empty buffer
+   provided, a vertical split is opened with an empty buffer.
 
 * `hsplit filename`: same as `vsplit` but opens a horizontal split instead of
-   a vertical split
+   a vertical split.
 
 * `tab filename`: opens the given file in a new tab.
 
+* `tabswitch tab`: This command will switch to the specified tab.
+   The `tab` can either be a tab number, or a name of a tab.
+                     
+
+* `log`: opens a log of all messages and debug statements.
+
+* `plugin install plugin_name`: installs the given plugin.
+
+* `plugin remove plugin_name`: removes the given plugin.
+
+* `plugin list`: lists all installed plugins.
+
+* `plugin update`: updates all installed plugins.
+
+* `plugin search plugin_name`: searches for the given plugin.
+   Note that you can find a list of all available plugins at
+   github.com/micro-editor/plugin-channel.
+
+   You can also see more information about the plugin manager
+   in the `Plugin Manager` section of the `plugins` help topic.
+
+* `plugin available`: list plugins available for download (this includes
+   any plugins that may be already installed).
+
+* `reload`: reloads all runtime files.
+
+* `cd path`: Change the working directory to the given `path`.
+
+* `pwd`: Print the current working directory.
+
+* `open filename`: Open a file in the current buffer.
+
 ---
 
 The following commands are provided by the default plugins:
 
 * `lint`: Lint the current file for errors.
-
-* `gofmt`: Run gofmt on the current file.
-
-* `goimports`: Run goimports on the current file.

runtime/help/defaultkeys.md

@@ -0,0 +1,224 @@
+#Default Keys
+
+Below are simple charts of the default hotkeys and their functions.
+For more information about binding custom hotkeys or changing
+default bindings, please run `>help keybindings`
+
+Please remember that *all* keys here are rebindable!
+If you don't like it, you can change it!
+
+(We are not responsible for you forgetting what you bind keys to.
+ Do not open an issue because you forgot your keybindings.)
+
+#Power user
++--------+---------------------------------------------------------+
+| Key    | Description of function                                 |
++--------+---------------------------------------------------------+
+| Ctrl+E | Switch to the micro command prompt to run a command.    |
+|        | (See `>help commands` for a list of commands. )         |
++--------+---------------------------------------------------------+
+| Tab    | In command prompt it will auto complete if possible.    |
++--------+---------------------------------------------------------+
+| Ctrl+B | Run shell commands in micro's current working directory.|
++--------+---------------------------------------------------------+
+
+#Navigation
+|--------+---------------------------------------------------------+
+| Arrows | Move the cursor around your current document.           |
+|        | (Yes this is rebindable to the vim keys if you want.)   |
++--------+---------------------------------------------------------+
+| Shift+ | Move and select text.                                   |
+| Arrows |                                                         |
++--------+---------------------------------------------------------+
+| Home   |                                                         |
+|  or    |                                                         |
+| Ctrl+  | Move to the beginning of the current line. (Naturally.) |
+| Left   |                                                         |
+| Arrow  |                                                         |
++--------+---------------------------------------------------------+
+| End    |                                                         |
+|  or    |                                                         |
+| Ctrl+  | Move to the end of the current line.                    |
+| Right  |                                                         |
+| Arrow  |                                                         |
++--------+---------------------------------------------------------+
+| Alt+   |                                                         |
+| Left   | Move cursor one complete word left.                     |
+| Arrow  |                                                         |
++--------+---------------------------------------------------------+
+| Alt+   |                                                         |
+| Right  | Move cursor one complete word right.                    |
+| Arrow  |                                                         |
++--------+---------------------------------------------------------+
+| PageUp | Move cursor up lines quickly.                           |
++--------+---------------------------------------------------------+
+| PageDn | Move cursor down lines quickly.                         |
++--------+---------------------------------------------------------+
+| Ctrl+  |                                                         |
+| Home   |                                                         |
+|  or    | Move cursor to start of the document                    |
+| Ctrl+  |                                                         |
+| Up     |                                                         |
+| Arrow  |                                                         |
++--------+---------------------------------------------------------+
+| Ctrl+  |                                                         |
+| End    |                                                         |
+|  or    | Move cursor to end of the document                      |
+| Ctrl+  |                                                         |
+| Down   |                                                         |
+| Arrow  |                                                         |
++--------+---------------------------------------------------------+
+| Ctrl+L | Jump to line in current file. ( Prompts for line # )    |
++--------+---------------------------------------------------------+
+| Ctrl+W | Move between splits open in current tab.                |
+|        | (See vsplit and hsplit in `>help commands`)             |
++--------+---------------------------------------------------------+
+
+#Tabs
++--------+---------------------------------------------------------+
+| Ctrl+T | Open a new tab.                                         |
++--------+---------------------------------------------------------+
+| Alt+,  | Move to the previous tab in the tablist.                |
+|        | (This works like moving between file buffers in nano)   |
++--------+---------------------------------------------------------+
+| Alt+.  | Move to the next tab in the tablist.                    |
++--------+---------------------------------------------------------+
+
+#Find Operations
++--------+---------------------------------------------------------+
+| Ctrl+F | Find text in current file. ( Prompts for text to find.) |
++--------+---------------------------------------------------------+
+| Ctrl+N | Find next instance of current search in current file.   |
++--------+---------------------------------------------------------+
+| Ctrl+P | Find prev instance of current search in current file.   |
++--------+---------------------------------------------------------+
+
+#File Operations
++--------+---------------------------------------------------------+
+| Ctrl+Q | Close current file. ( Quits micro if last file open. )  |
++--------+---------------------------------------------------------+
+| Ctrl+O | Open a file. ( Prompts you to input filename. )         |
++--------+---------------------------------------------------------+
+| Ctrl+S | Save current file.                                      |
++--------+---------------------------------------------------------+
+
+#Text operations
++--------+---------------------------------------------------------+
+| Ctrl+A | Select all text in current file.                        |
++--------+---------------------------------------------------------+
+| Alt+   |                                                         |
+| Shift+ | Select complete word right.                             |
+| Right  |                                                         |
+| Arrow  |                                                         |
++--------+---------------------------------------------------------+
+| Alt+   |                                                         |
+| Shift+ | Select complete word left.                              |
+| Left   |                                                         |
+| Arrow  |                                                         |
++--------+---------------------------------------------------------+
+| Shift+ |                                                         |
+| Home   |                                                         |
+|  or    | Select from the current cursor position to the          |
+| Ctrl+  | start of the current line.                              |
+| Shift+ |                                                         |
+| Left   |                                                         |
+| Arrow  |                                                         |
++--------+---------------------------------------------------------+
+| Shift+ |                                                         |
+| End    |                                                         |
+|  or    | Select from the current cursor position to the          |
+| Ctrl+  | end of the current line.                                |
+| Shift+ |                                                         |
+| Right  |                                                         |
+| Arrow  |                                                         |
++--------+---------------------------------------------------------+
+| Ctrl+  |                                                         |
+| Shift+ | Select from the current cursor position to the          |
+| Up     | start of the document.                                  |
+| Arrow  |                                                         |
++--------+---------------------------------------------------------+
+| Ctrl+  |                                                         |
+| Shift+ | Select from the current cursor position to the          |
+| Down   | end of the document.                                    |
+| Arrow  |                                                         |
++--------+---------------------------------------------------------+
+| Ctrl+X | Cut selected text.                                      |
++--------+---------------------------------------------------------+
+| Ctrl+C | Copy selected text.                                     |
++--------+---------------------------------------------------------+
+| Ctrl+V | Paste selected text.                                    |
++--------+---------------------------------------------------------+
+| Ctrl+K | Cut current line. ( Can then be pasted with Ctrl+V)     |
++--------+---------------------------------------------------------+
+| Ctrl+D | Duplicate current line.                                 |
++--------+---------------------------------------------------------+
+| Ctrl+Z | Undo actions.                                           |
++--------+---------------------------------------------------------+
+| Ctrl+Y | Redo actions.                                           |
++--------+---------------------------------------------------------+
+| Alt+   |                                                         |
+| Up     | Move current line or selected lines up.                 |
+| Arrow  |                                                         |
++--------+---------------------------------------------------------+
+| Alt+   |                                                         |
+| Down   | Move current line or selected lines down.               |
+| Arrow  |                                                         |
++--------+---------------------------------------------------------+
+| Alt+   |                                                         |
+| Ctrl+H |                                                         |
+|  or    | Delete complete word left.                              |
+| Alt+   |                                                         |
+| Back-  |                                                         |
+| space  |                                                         |
++--------+---------------------------------------------------------+
+
+#Macros
++--------+---------------------------------------------------------+
+|        | Toggle ON/OFF macro recording.                          |
+| Ctrl+U | Simply press Ctrl+U to begin recording a macro and      |
+|        | press Ctrl+U to stop recording macro.                   |
++--------+---------------------------------------------------------+
+| Ctrl+J | Run your recorded macro.                                |
++--------+---------------------------------------------------------+
+
+#Other
++--------+---------------------------------------------------------+
+| Ctrl+G | Open the help file.                                     |
++--------+---------------------------------------------------------+
+| Ctrl+H | Alternate backspace.                                    |
+|        | (Some old terminals don't support the Backspace key .)  |
++--------+---------------------------------------------------------+
+| Ctrl+R | Toggle the line number ruler. ( On the lefthand side.)  |
++--------+---------------------------------------------------------+
+
+#Emacs style actions
++--------+---------------------------------------------------------+
+| Alt+F  | Move to the end of the next word. (To the next space.)  |
++--------+---------------------------------------------------------+
+| Alt+B  | Move to the beginning of the previous word.             |
++--------+---------------------------------------------------------+
+| Alt+A  | Alternate Home key. ( Move to beginning of line. )      |
++--------+---------------------------------------------------------+
+| Alt+E  | Alternate End key. ( Move to the end of line.)          |
++--------+---------------------------------------------------------+
+| Alt+P  | Move cursor up. ( Same as up key. )                     |
++--------+---------------------------------------------------------+
+| Alt+N  | Move cursor down. ( Same as down key. )                 |
++--------+---------------------------------------------------------+
+
+#Function keys.
+Warning! The function keys may not work in all terminals! 
++--------+---------------------------------------------------------+
+| F1     | Open help.                                              |
++--------+---------------------------------------------------------+
+| F2     | Save current file.                                      |
++--------+---------------------------------------------------------+
+| F3     | Find in current file. ( Same as Ctrl+F )                |
++--------+---------------------------------------------------------+
+| F4     | Close current file. (Quit if only file.)                |
++--------+---------------------------------------------------------+
+| F7     | Find in current file. (Same as Ctrl+F)                  |
++--------+---------------------------------------------------------+
+| F10    | Close current file.                                     |
++--------+---------------------------------------------------------+
+

runtime/help/gimmickcolors.md

@@ -0,0 +1,14 @@
+# Gimmick colors
+
+We have included a few colorschemes that are for fun:
+
+* funky-cactus: I don't know why I made this. (Written by CaptainMcClellan)
+* gameboy-tc: Colorscheme based on the olive green original Gameboy!
+* nes-tc: A colorscheme and syntax highlighting using only colors in the 
+  Nintendo Entertainment System color palette.
+* symbian-tc: Colorscheme based on SymbOS's GUI.
+* matrix: Pretend it's 1981 with a colorscheme based on a monochrome
+  IBM 5151. ( Does not include the ghosting and trailing. )
+
+Check the plugin repo periodically for gimmick-color extension packs
+and genuine additional themes.

runtime/help/help.md

@@ -1,35 +1,51 @@
 # Micro help text
 
+Thank you for downloading and using micro.
 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.
 
+If you want to see all the keybindings press CtrlE and type `help keybindings`.
+
+See the next section for more information about documentation and help.
+
+### Quick-start
+
+Press CtrlQ to quit, and CtrlS to save. Press CtrlE to start typing commands
+and you can see which commands are available by pressing tab, or by
+viewing the help topic `> help commands`. When I write `> ...` I mean press
+CtrlE and then type whatever is there. 
+
+Move the cursor around with the mouse or the arrow keys. Type `>help defaultkeys` to 
+get a quick, easy overview of the default hotkeys and what they do. For more info
+on rebinding keys, see type `>help keybindings`
+
+If the colorscheme doesn't look good, you can change it with `> set colorscheme ...`.
+You can press tab to see the available colorschemes, or see more information with
+`> help colors`.
+
+Press CtrlW to move between splits, and type `> vsplit filename` or `> hsplit filename`
+to open a new split.
+
 ### Accessing more help
 
 Micro has a built-in help system much like Vim's (although less extensive).
 
-To use it, press CtrlE to access command mode and type in help followed by a topic.
-Typing help followed by nothing will open this page.
+To use it, press CtrlE 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:
 
+* tutorial: A brief tutorial which gives an overview of all the other help topics
 * keybindings: Gives a full list of the default keybindings as well as how to rebind them
+* defaultkeys: Gives a more straight-forward list of the hotkey commands and what they do.
 * commands: Gives a list of all the commands and what they do
 * options: Gives a list of all the options you can customize
 * plugins: Explains how micro's plugin system works and how to create your own plugins
 * colors: Explains micro's colorscheme and syntax highlighting engine and how to create your
   own colorschemes or add new languages to the engine
 
-For example to open the help page on plugins you would press CtrlE and type `help plugins`.
+For example, to open the help page on plugins you would press CtrlE and type `help plugins`.
 
-### Usage
-
-Once you have built the editor, simply start it by running 
-`micro path/to/file.txt` or simply `micro` to open an empty buffer.
-
-Micro also supports creating buffers from stdin:
-
-```
-$ ifconfig | micro
-```
-
-You can move the cursor around with the arrow keys and mouse.
+I recommend looking at the `tutorial` help file because it is short for each section and
+gives concrete examples of how to use the various configuration options in micro. However,
+it does not give the in-depth documentation that the other topics provide.

runtime/help/keybindings.md

@@ -1,76 +1,15 @@
 # Keybindings
 
-Here are the default keybindings in json form which is also how
-you can rebind them to your liking.
+Micro has a plethora of hotkeys that make it easy and powerful to use and all
+hotkeys are fully customizable to your liking.
+Custom keybindings are stored internally in micro if changed with the `>bind` command or
+you can also be added in the file `~/.config/micro/bindings.json` as discussed below.
+For a list of the default keybindings in the json format used by micro, please see
+the end of this file. For a more user-friendly list with explanations of what the default
+hotkeys are and what they do, please see `>help defaultkeys`
 
-```json
-{
-	"Up":             "CursorUp",
-	"Down":           "CursorDown",
-	"Right":          "CursorRight",
-	"Left":           "CursorLeft",
-	"ShiftUp":        "SelectUp",
-	"ShiftDown":      "SelectDown",
-	"ShiftLeft":      "SelectLeft",
-	"ShiftRight":     "SelectRight",
-	"AltLeft":        "WordLeft",
-	"AltRight":       "WordRight",
-	"AltShiftRight":  "SelectWordRight",
-	"AltShiftLeft":   "SelectWordLeft",
-	"CtrlLeft":       "StartOfLine",
-	"CtrlRight":      "EndOfLine",
-	"CtrlShiftLeft":  "SelectToStartOfLine",
-	"CtrlShiftRight": "SelectToEndOfLine",
-	"CtrlUp":         "CursorStart",
-	"CtrlDown":       "CursorEnd",
-	"CtrlShiftUp":    "SelectToStart",
-	"CtrlShiftDown":  "SelectToEnd",
-	"Enter":          "InsertEnter",
-	"Space":          "InsertSpace",
-	"Backspace":      "Backspace",
-	"Backspace2":     "Backspace",
-	"Alt-Backspace":  "DeleteWordLeft",
-	"Alt-Backspace2": "DeleteWordLeft",
-	"Tab":            "InsertTab,IndentSelection",
-	"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"
-	"CtrlRightSq":    "PreviousTab",
-	"CtrlBackslash":  "NextTab",
-	"Home":           "Start",
-	"End":            "End",
-	"PageUp":         "CursorPageUp",
-	"PageDown":       "CursorPageDown",
-	"CtrlG":          "ToggleHelp",
-	"CtrlR":          "ToggleRuler",
-	"CtrlL":          "JumpLine",
-	"Delete":         "Delete",
-	"Esc":            "ClearStatus",
-	"CtrlB":          "ShellMode",
-	"CtrlQ":          "Quit",
-	"CtrlE":          "CommandMode",
-	"CtrlW":          "NextSplit",
-	
-	// Emacs-style keybindings
-	"Alt-f": "WordRight",
-	"Alt-b": "WordLeft",
-	"Alt-a": "StartOfLine",
-	"Alt-e": "EndOfLine",
-	"Alt-p": "CursorUp",
-	"Alt-n": "CursorDown"
-}
-```
+If `~/.config/micro/bindings.json` does not exist, you can simply create it.
+Micro will know what to do with it.
 
 You can use the alt keys + arrows to move word by word.
 Ctrl left and right move the cursor to the start and end of the line, and
@@ -93,6 +32,9 @@ following in the `bindings.json` file.
 }
 ```
 
+In addition to editing your `~/.config/micro/bindings.json`, you can run
+`>bind <keycombo> <action>` For a list of bindable actions, see below.
+
 You can also chain commands when rebinding. For example, if you want Alt-s to save
 and quit you can bind it like so:
 
@@ -102,6 +44,11 @@ and quit you can bind it like so:
 }
 ```
 
+# Unbinding keys
+
+It is also possible to disable any of the default key bindings by use of the 
+`UnbindKey` action in the user's `bindings.json` file.
+
 # Bindable actions and bindable keys
 
 The list of default keybindings contains most of the possible actions and keys
@@ -128,6 +75,8 @@ WordRight
 WordLeft
 SelectWordRight
 SelectWordLeft
+MoveLinesUp
+MoveLinesDown
 DeleteWordRight
 DeleteWordLeft
 SelectToStartOfLine
@@ -136,8 +85,11 @@ InsertNewline
 InsertSpace
 Backspace
 Delete
+Center
 InsertTab
 Save
+SaveAll
+SaveAs
 Find
 FindNext
 FindPrevious
@@ -168,11 +120,18 @@ ClearStatus
 ShellMode
 CommandMode
 Quit
+QuitAll
 AddTab
 PreviousTab
 NextTab
 NextSplit
+Unsplit
+VSplit
+HSplit
 PreviousSplit
+ToggleMacro
+PlayMacro
+UnbindKey
 ```
 
 Here is the list of all possible keys you can bind:
@@ -301,9 +260,100 @@ Tab
 Esc
 Escape
 Enter
-Backspace2
 ```
 
+# Default keybinding configuration.
+
+```json
+{
+    "Up":             "CursorUp",
+    "Down":           "CursorDown",
+    "Right":          "CursorRight",
+    "Left":           "CursorLeft",
+    "ShiftUp":        "SelectUp",
+    "ShiftDown":      "SelectDown",
+    "ShiftLeft":      "SelectLeft",
+    "ShiftRight":     "SelectRight",
+    "AltLeft":        "WordLeft",
+    "AltRight":       "WordRight",
+    "AltShiftRight":  "SelectWordRight",
+    "AltShiftLeft":   "SelectWordLeft",
+    "AltUp":          "MoveLinesUp",
+    "AltDown":        "MoveLinesDown",
+    "CtrlLeft":       "StartOfLine",
+    "CtrlRight":      "EndOfLine",
+    "CtrlShiftLeft":  "SelectToStartOfLine",
+    "ShiftHome":      "SelectToStartOfLine",
+    "CtrlShiftRight": "SelectToEndOfLine",
+    "ShiftEnd":       "SelectToEndOfLine",
+    "CtrlUp":         "CursorStart",
+    "CtrlDown":       "CursorEnd",
+    "CtrlShiftUp":    "SelectToStart",
+    "CtrlShiftDown":  "SelectToEnd",
+    "Enter":          "InsertNewline",
+    "Space":          "InsertSpace",
+    "CtrlH":          "Backspace",
+    "Backspace":      "Backspace",
+    "Alt-CtrlH":      "DeleteWordLeft",
+    "Alt-Backspace":  "DeleteWordLeft",
+    "Tab":            "IndentSelection,InsertTab",
+    "Backtab":        "OutdentSelection",
+    "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",
+    "End":            "EndOfLine",
+    "CtrlHome":       "CursorStart",
+    "CtrlEnd":        "CursorEnd",
+    "PageUp":         "CursorPageUp",
+    "PageDown":       "CursorPageDown",
+    "CtrlG":          "ToggleHelp",
+    "CtrlR":          "ToggleRuler",
+    "CtrlL":          "JumpLine",
+    "Delete":         "Delete",
+    "CtrlB":          "ShellMode",
+    "CtrlQ":          "Quit",
+    "CtrlE":          "CommandMode",
+    "CtrlW":          "NextSplit",
+    "CtrlU":          "ToggleMacro",
+    "CtrlJ":          "PlayMacro",
+
+    // Emacs-style keybindings
+    "Alt-f": "WordRight",
+    "Alt-b": "WordLeft",
+    "Alt-a": "StartOfLine",
+    "Alt-e": "EndOfLine",
+    "Alt-p": "CursorUp",
+    "Alt-n": "CursorDown",
+
+    // Integration with file managers
+    "F1":  "ToggleHelp",
+    "F2":  "Save",
+    "F3":  "Find",
+    "F4":  "Quit",
+    "F7":  "Find",
+    "F10": "Quit",
+    "Esc": "Escape",
+}
+```
+
+#Final notes
+Note: On some old terminal emulators and on Windows machines, `CtrlH` should be used
+for backspace.
+
 Additionally, alt keys can be bound by using `Alt-key`. For example `Alt-a`
 or `Alt-Up`. Micro supports an optional `-` between modifiers like `Alt` and `Ctrl`
 so `Alt-a` could be rewritten as `Alta` (case matters for alt bindings). This is

runtime/help/options.md

@@ -14,27 +14,27 @@ Here are the options that you can set:
 
 	default value: `default`
 	Note that the default colorschemes (default, solarized, and solarized-tc)
-	are not located in configDir, because they are embedded in the micro binary
+	are not located in configDir, because they are embedded in the micro binary.
 
 	The colorscheme can be selected from all the files in the 
 	~/.config/micro/colorschemes/ directory. Micro comes by default with three
 	colorschemes:
 
-	* default: this is the default colorscheme.
+    You can read more about micro's colorschemes in the `colors` help topic
+    (`help colors`).
 
-	* solarized: this is the solarized colorscheme (used in the screenshot). 
-	  You should have the solarized color palette in your terminal to use it.
+* `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.
 
-	* solarized-tc: this is the solarized colorscheme for true color, just 
-	  make sure your terminal supports true color before using it and that the 
-	  MICRO_TRUECOLOR environment variable is set to 1 before starting micro.
+	default value: `0`
 
-	* monokai-tc: this is the monokai colorscheme. It requires true color to
-	  look perfect, but the 256 color approximation looks good as well.
+* `eofnewline`: micro will automatically add a newline to the file.
 
-	* atom-dark-tc: this colorscheme is based off of Atom's "dark" colorscheme.
-	  It requires true color to look good.
+	default value: `false`
 
+* `rmtrailingws`: micro will automatically trim trailing whitespaces at eol.
+
+	default value: `false`
 
 * `tabsize`: sets the tab size to `option`
 
@@ -44,6 +44,11 @@ Here are the options that you can set:
 
 	default value: ` `
 
+* `infobar`: enables the line at the bottom of the editor where messages are printed.
+   This option is `global only`.
+
+	default value: `on`
+
 * `filetype`: sets the filetype for the current buffer. This setting is `local only`
 
     default value: this will be automatically set depending on the file you have open
@@ -60,6 +65,11 @@ Here are the options that you can set:
 
 	default value: `off`
 
+* `tabmovement`: navigate spaces at the beginning of lines as if they are tabs (e.g. move over 4 spaces at once).
+   This option only does anything if `tabstospaces` is on.
+
+    default value: `off`
+
 * `autoindent`: when creating a new line use the same indentation as the 
    previous line
 
@@ -68,7 +78,7 @@ Here are the options that you can set:
 * `cursorline`: highlight the line that the cursor is on in a different color
    (the color is defined by the colorscheme you are using)
 
-	default value: `off`
+	default value: `on`
 
 * `ruler`: display line numbers
 
@@ -96,24 +106,70 @@ Here are the options that you can set:
 
 	default value: `2`
 
+* `softwrap`: should micro wrap lines that are too long to fit on the screen
+
+	default value: `off`
+
+* `splitRight`: when a vertical split is created, should it be created to the right of
+   the current split?
+
+	default value: `on`
+
+* `splitBottom`: when a horizontal split is created, should it be created below the
+   current split?
+
+	default value: `on`
+
+* `autosave`: micro will save the buffer every 8 seconds automatically.
+   Micro also will automatically save and quit when you exit without asking.
+   Be careful when using this feature, because you might accidentally save a file,
+   overwriting what was there before.
+
+	default value: `off`
+
+* `pluginchannels`: contains all the channels micro's plugin manager will search
+   for plugins in. A channel is simply a list of 'repository' json files which contain
+   metadata about the given plugin. See the `Plugin Manager` section of the `plugins` help topic
+   for more information.
+
+	default value: `https://github.com/micro-editor/plugin-channel`
+
+* `pluginrepos`: contains all the 'repositories' micro's plugin manager will search for
+   plugins in. A repository consists of a `repo.json` file which contains metadata for a
+   single plugin.
+
+	default value: ` `
+
+* `useprimary` (only useful on Linux): defines whether or not micro will use the primary clipboard to copy selections
+   in the background. This does not affect the normal clipboard using Ctrl-C and Ctrl-V.
+
+	default value: `on`
+
+* `keepautoindent`: when using autoindent, whitespace is added for you. This option determines if
+   when you move to the next line without any insertions the whitespace that was added should be deleted.
+   By default the autoindent whitespace is deleted if the line was left empty.
+
+    default value: `off`
+
+* `termtitle`: defines whether or not your terminal's title will be set by micro when opened.
+
+    default value: `off`
+
 ---
 
 Default plugin options:
 
-* `linter`: lint languages on save (supported languages are C, D, Go, Java,
-   Javascript, Lua). Provided by the `linter` plugin.
+* `autoclose`: Automatically close `{}` `()` `[]` `""` `''`. Provided by the `autoclose` plugin
 
 	default value: `on`
 
-* `autoclose`: Automatically close `{}` `()` `[]` `""` `''`. Provided by the autoclose plugin
+* `linter`: Automatically lint when the file is saved. Provided by the `linter` plugin
 
 	default value: `on`
 
-* `goimports`: Run goimports on save. Provided by the `go` plugin.
-
-	default value: `off`
-
-* `gofmt`: Run gofmt on save. Provided by the `go` plugin.
+* `ftoptions`: by default, micro will set some options based on the filetype. At the moment, micro will
+   use tabs for makefiles and spaces for python files regardless of your settings. If you would like to
+   disable this behavior turn this option off.
 
 	default value: `on`
 
@@ -136,16 +192,16 @@ In the `settings.json` file you can also put set options locally by specifying a
 Here is an example which has `tabstospaces` on for all files except Go files, and
 `tabsize` 4 for all files except Ruby files:
 
-```
+```json
 {
     "*.go": {
         "tabstospaces": false
     },
     "*.rb": {
         "tabsize": 2
-    }
+    },
     "tabstospaces": true,
-    "tabsize": 4,
+    "tabsize": 4
 }
 ```
 

runtime/help/plugins.md

@@ -37,48 +37,79 @@ for example turning off `tabstospaces` only for Go files when they are opened.
 ---
 
 There are a number of functions and variables that are available to you in
-oder to access the inner workings of micro. Here is a list (the type signatures
+order to access the inner workings of micro. Here is a list (the type signatures
 for functions are given using Go's type system):
 
 * `OS`: variable which gives the OS micro is currently running on (this is the same
 as Go's GOOS variable, so `darwin`, `windows`, `linux`, `freebsd`...)
 
+* `configDir`: contains the path to the micro configuration files
+
 * `tabs`: a list of all the tabs currently in use
 
 * `curTab`: the index of the current tabs in the tabs list
 
 * `messenger`: lets you send messages to the user or create prompts
 
+* `NewBuffer(text, path string) *Buffer`: creates a new buffer from a given reader with a given path
+
+* `GetLeadingWhitespace() bool`: returns the leading whitespace of the given string
+
+* `IsWordChar(str string) bool`: returns whether or not the string is a 'word character'
+
+* `RuneStr(r rune) string`: returns a string containing the given rune
+
+* `Loc(x, y int) Loc`: returns a new `Loc` struct
+
+* `JoinPaths(dir... string) string` combines multiple directories to a full path
+
+* `DirectoryName(path string)` returns all but the last element of path ,typically the path's directory
+
 * `GetOption(name string)`: returns the value of the requested option
 
 * `AddOption(name string, value interface{})`: sets the given option with the given
-   value (`interface{}` means any type in Go).
+   value (`interface{}` means any type in Go)
 
 * `SetOption(option, value string)`: sets the given option to the value. This will
    set the option globally, unless it is a local only option.
 
-* `SetLocalOption(option, value string, buffer *Buffer)`: sets the given option to
-   the value locally in the given buffer.
+* `SetLocalOption(option, value string, view *View)`: sets the given option to
+   the value locally in the given buffer
 
-* `BindKey(key, action string)`: binds `key` to `action`.
+* `BindKey(key, action string)`: binds `key` to `action`
 
 * `MakeCommand(name, function string, completions ...Completion)`: 
    creates a command with `name` which will call `function` when executed.
    Use 0 for completions to get NoCompletion.
 
+* `MakeCompletion(function string)`:
+   creates a `Completion` to use with `MakeCommand`
+
 * `CurView()`: returns the current view
 
 * `HandleCommand(cmd string)`: runs the given command
 
-* `HandleShellCommand(shellCmd string, interactive bool)`: runs the given shell
-   command
+* `HandleShellCommand(shellCmd string, interactive bool, waitToClose bool)`: runs the given shell
+   command. The `interactive` bool specifies whether the command should run in the background. The
+   `waitToClose` bool only applies if `interactive` is true and means that it should wait before
+   returning to the editor.
 
-* `JobStart(cmd string, onStdout, onStderr, onExit string, userargs ...string)`:
-   Starts running the given shell command in the background. `onStdout` `onStderr` and `onExit`
+* `ToCharPos(loc Loc, buf *Buffer) int`: returns the character position of a given x, y location
+
+* `Reload`: (Re)load everything
+
+* `ByteOffset(loc Loc, buf *Buffer) int`: exactly like `ToCharPos` except it it counts bytes instead of runes
+
+* `JobSpawn(cmdName string, cmdArgs []string, onStdout, onStderr, onExit string, userargs ...string)`:
+   Starts running the given process in the background. `onStdout` `onStderr` and `onExit`
    are callbacks to lua functions which will be called when the given actions happen
    to the background process.
    `userargs` are the arguments which will get passed to the callback functions
 
+* `JobStart(cmd string, onStdout, onStderr, onExit string, userargs ...string)`:
+   Starts running the given shell command in the background. Note that the command execute
+   is first parsed by a shell when using this command. It is executed with `sh -c`.
+
 * `JobSend(cmd *exec.Cmd, data string)`: send a string into the stdin of the job process
 
 * `JobStop(cmd *exec.Cmd)`: kill a job
@@ -104,7 +135,91 @@ The possible methods which you can call using the `messenger` variable are:
 
 If you want a standard prompt, just use `messenger.Prompt(prompt, "", 0)`
 
+# Adding help files, syntax files, or colorschemes in your plugin
+
+You can use the `AddRuntimeFile(name, type, path string)` function to add various kinds of
+files to your plugin. For example, if you'd like to add a help topic to your plugin
+called `test`, you would create a `test.md` file, and call the function:
+
+```lua
+AddRuntimeFile("test", "help", "test.md")
+```
+
+Use `AddRuntimeFilesFromDirectory(name, type, dir, pattern)` to add a number of files
+to the runtime.
+To read the content of a runtime file use `ReadRuntimeFile(fileType, name string)`
+or `ListRuntimeFiles(fileType string)` for all runtime files.
+
+# Autocomplete command arguments
+
+See this example to learn how to use `MakeCompletion` and `MakeCommand`
+
+```lua
+local function StartsWith(String,Start)
+  String = String:upper()
+  Start = Start:upper() 
+  return string.sub(String,1,string.len(Start))==Start
+end
+
+function complete(input)
+  local allCompletions = {"Hello", "World", "Foo", "Bar"}
+  local result = {}
+   
+  for i,v in pairs(allCompletions) do
+  if StartsWith(v, input) then
+       table.insert(result, v)
+     end
+   end
+   return result
+end
+
+function foo(arg)
+  messenger:Message(arg)
+end
+
+MakeCommand("foo", "example.foo", MakeCompletion("example.complete"))
+```
+
 # Default plugins
 
-For examples of plugins, see the default plugins `linter`, `go`, and `autoclose`.
-They are stored in Micro's github repository [here](https://github.com/zyedidia/micro/tree/master/runtime/plugins).
+For examples of plugins, see the default `autoclose` and `linter` plugins
+(stored in the normal micro core repo under `runtime/plugins`) as well as
+any plugins that are stored in the official channel [here](https://github.com/micro-editor/plugin-channel).
+
+# Plugin Manager
+
+Micro also has a built in plugin manager which you can invoke with the `> plugin ...` command.
+
+For the valid commands you can use, see the `command` help topic.
+
+The manager fetches plugins from the channels (which is simply a list of plugin metadata)
+which it knows about. By default, micro only knows about the official channel which is located
+at github.com/micro-editor/plugin-channel but you can add your own third-party channels using
+the `pluginchannels` option and you can directly link third-party plugins to allow installation
+through the plugin manager with the `pluginrepos` option.
+
+If you'd like to publish a plugin you've made as an official plugin, you should upload your
+plugin online (to Github preferably) and add a `repo.json` file. This file will contain the
+metadata for your plugin. Here is an example:
+
+```json
+[{
+  "Name": "pluginname",
+  "Description": "Here is a nice concise description of my plugin",
+  "Tags": ["python", "linting"],
+  "Versions": [
+    {
+      "Version": "1.0.0",
+      "Url": "https://github.com/user/plugin/archive/v1.0.0.zip",
+      "Require": {
+        "micro": ">=1.0.3"
+      }
+    }
+  ]
+}]
+```
+
+Then open a pull request at github.com/micro-editor/plugin-channel adding a link to the
+raw `repo.json` that is in your plugin repository.
+To make updating the plugin work, the first line of your plugins lua code should contain the version of the plugin. (Like this: `VERSION = "1.0.0"`)
+Please make sure to use [semver](http://semver.org/) for versioning.

runtime/help/tutorial.md

@@ -1,11 +1,22 @@
 # Tutorial
 
-This is a brief intro to micro's configuration system that will will give some
-simple examples showing how to configure settings, rebind keys, 
+This is a brief intro to micro's configuration system that will give some
+simple examples showing how to configure settings, rebind keys,
 and use `init.lua` to configure micro to your liking.
 
 Hopefully you'll find this useful.
 
+### Plugins
+
+Micro has a plugin manager which can automatically download plugins for you.
+To see the plugins 'official' plugins, go to github.com/micro-editor/plugin-channel.
+
+For example, if you'd like to install the snippets plugin (listed in that repo),
+just press `CtrlE` to execute a command, and type `plugin install snippets`.
+
+For more information about the plugin manager, see the end of the `plugins` help
+topic.
+
 ### Settings
 
 In micro, your settings are stored in `~/.config/micro/settings.json`, a file
@@ -68,19 +79,19 @@ what actions are available, see the `keybindings` help topic (`> help keybinding
 
 If you need more power than the json files provide, you can use the `init.lua`
 file. Create it in `~/.config/micro`. This file is a lua file that is run
-when micro starts and is essential a one-file plugin.
+when micro starts and is essentially a one-file plugin.
 
 I'll show you how to use the `init.lua` file by giving an example of how to
 create a binding to `CtrlR` which will execute `go run` on the current file,
 given that the current file is a Go file.
 
-You can do that by puttint the following in `init.lua`:
+You can do that by putting the following in `init.lua`:
 
 ```lua
 function gorun()
     local buf = CurView().Buf -- The current buffer
     if buf:FileType() == "go" then
-        HandleShellCommand("go run " .. buf.Path, true) -- true means don't run it in the background
+        HandleShellCommand("go run " .. buf.Path, true, true) -- the first true means don't run it in the background
     end
 end
 

runtime/plugins/autoclose/utf8/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Stepets
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

runtime/plugins/autoclose/utf8/README.md

@@ -0,0 +1,109 @@
+# utf8.lua
+one-file pure-lua 5.1 regex library
+
+This library _is_ the simple way to add utf8 support into your application.
+
+Some examples from http://www.lua.org/manual/5.1/manual.html#5.4 :
+```Lua
+local utf8 = require "utf8"
+
+local s = "hello world from Lua"
+for w in string.gmatch(s, "%a+") do
+    print(w)
+end
+--[[
+hello
+world
+from
+Lua
+]]--
+
+s = "Привет, мир, от Lua"
+for w in utf8.gmatch(s, "[^%p%d%s%c]+") do
+    print(w)
+end
+--[[
+Привет
+мир
+от
+Lua
+]]--
+
+local t = {}
+s = "from=world, to=Lua"
+for k, v in string.gmatch(s, "(%w+)=(%w+)") do
+    t[k] = v
+end
+for k,v in pairs(t) do
+    print(k,v)
+end
+--[[
+to	Lua
+from	world
+]]--
+
+t = {}
+s = "从=世界, 到=Lua"
+for k, v in utf8.gmatch(s, "([^%p%s%c]+)=([^%p%s%c]+)") do
+    t[k] = v
+end
+for k,v in pairs(t) do
+    print(k,v)
+end
+--[[
+到	Lua
+从	世界
+]]--
+
+local x = string.gsub("hello world", "(%w+)", "%1 %1")
+print(x)
+--hello hello world world
+
+x = utf8.gsub("Ahoj světe", "([^%p%s%c]+)", "%1 %1")
+print(x)
+--Ahoj Ahoj světe světe
+
+x = string.gsub("hello world", "%w+", "%0 %0", 1)
+print(x)
+--hello hello world
+
+x = utf8.gsub("Ahoj světe", "[^%p%s%c]+", "%0 %0", 1)
+print(x)
+--Ahoj Ahoj světe
+
+x = string.gsub("hello world from Lua", "(%w+)%s*(%w+)", "%2 %1")
+print(x)
+--world hello Lua from
+
+x = utf8.gsub("γεια κόσμο από Lua", "([^%p%s%c]+)%s*([^%p%s%c]+)", "%2 %1")
+print(x)
+--κόσμο γεια Lua από
+```
+Notice, there are some classes that can work only with latin(ASCII) symbols,
+for details see: https://github.com/Stepets/utf8.lua/blob/master/utf8.lua#L470
+
+Of course you can do this trick:
+```Lua
+for k,v in pairs(utf8) do
+        string[k] = v
+end
+```
+But this can lead to very strange errors. You were warned.
+
+A little bit more interesting examples:
+```Lua
+local utf8 = require 'utf8'
+for k,v in pairs(utf8) do
+        string[k] = v
+end
+
+local str = "пыщпыщ ололоо я водитель нло"
+print(str:find("(.л.+)н"))
+-- 8	26	ололоо я водитель 
+
+print(str:gsub("ло+", "보라"))
+-- пыщпыщ о보라보라 я водитель н보라	3
+
+print(str:match("^п[лопыщ ]*я"))
+-- пыщпыщ ололоо я
+```

runtime/plugins/ftoptions/ftoptions.lua

@@ -0,0 +1,17 @@
+if GetOption("ftoptions") == nil then
+    AddOption("ftoptions", true)
+end
+
+function onViewOpen(view)
+    if not GetOption("ftoptions") then
+        return
+    end
+
+    local ft = view.Buf.Settings["filetype"]
+
+    if ft == "makefile" or ft == "go" then
+        SetOption("tabstospaces", "off")
+    elseif ft == "python" or ft == "python2" or ft == "python3" then
+        SetOption("tabstospaces", "on")
+    end
+end

runtime/plugins/go/go.lua

@@ -1,52 +0,0 @@
-if GetOption("goimports") == nil then
-    AddOption("goimports", false)
-end
-if GetOption("gofmt") == nil then
-    AddOption("gofmt", true)
-end
-
-MakeCommand("goimports", "go.goimports", 0)
-MakeCommand("gofmt", "go.gofmt", 0)
-
-function onViewOpen(view)
-    if view.Buf:FileType() == "go" then
-        SetLocalOption("tabstospaces", "off", view)
-    end
-end
-
-function onSave(view)
-    if CurView().Buf:FileType() == "go" then
-        if GetOption("goimports") then
-            goimports()
-        elseif GetOption("gofmt") then
-            gofmt()
-        end
-    end
-end
-
-function gofmt()
-    CurView():Save(false)
-    local handle = io.popen("gofmt -w " .. CurView().Buf.Path)
-    local result = handle:read("*a")
-    handle:close()
-
-    CurView():ReOpen()
-end
-
-function goimports()
-    CurView():Save(false)
-    local handle = io.popen("goimports -w " .. CurView().Buf.Path)
-    local result = split(handle:read("*a"), ":")
-    handle:close()
-
-    CurView():ReOpen()
-end
-
-function split(str, sep)
-    local result = {}
-    local regex = ("([^%s]+)"):format(sep)
-    for each in str:gmatch(regex) do
-        table.insert(result, each)
-    end
-    return result
-end

runtime/plugins/linter/linter.lua

@@ -2,31 +2,53 @@ if GetOption("linter") == nil then
     AddOption("linter", true)
 end
 
-MakeCommand("lint", "linter.runLinter", 0)
+MakeCommand("lint", "linter.lintCommand", 0)
+
+function lintCommand()
+    CurView():Save(false)
+    runLinter()
+end
 
 function runLinter()
-    CurView():Save(false)
     local ft = CurView().Buf:FileType()
     local file = CurView().Buf.Path
-    local devnull = "/dev/null"
+    local dir = DirectoryName(file)
     if OS == "windows" then
         devnull = "NUL"
+    else
+    	devnull = "/dev/null"
     end
     if ft == "go" then
-        lint("gobuild", "go build -o " .. devnull, "%f:%l: %m")
-        lint("golint", "golint " .. CurView().Buf.Path, "%f:%l:%d+: %m")
+        lint("gobuild", "go", {"build", "-o", devnull}, "%f:%l: %m")
+        lint("golint", "golint", {file}, "%f:%l:%d+: %m")
     elseif ft == "lua" then
-        lint("luacheck", "luacheck --no-color " .. file, "%f:%l:%d+: %m")
+        lint("luacheck", "luacheck", {"--no-color", file}, "%f:%l:%d+: %m")
     elseif ft == "python" then
-        lint("pyflakes", "pyflakes " .. file, "%f:%l: %m")
+        lint("pyflakes", "pyflakes", {file}, "%f:%l:.-:? %m")
+        lint("mypy", "mypy", {file}, "%f:%l: %m")
+        lint("pylint", "pylint", {"--output-format=parseable", "--reports=no", file}, "%f:%l: %m")
     elseif ft == "c" then
-        lint("gcc", "gcc -fsyntax-only -Wall -Wextra " .. file, "%f:%l:%d+:.+: %m")
+        lint("gcc", "gcc", {"-fsyntax-only", "-Wall", "-Wextra", file}, "%f:%l:%d+:.+: %m")
+	  elseif ft == "c++" then
+       lint("gcc", "gcc", {"-fsyntax-only","-std=c++14", "-Wall", "-Wextra", file}, "%f:%l:%d+:.+: %m")		
+    elseif ft == "swift" and OS == "darwin" then 
+        lint("switfc", "xcrun", {"swiftc", file}, "%f:%l:%d+:.+: %m")
+    elseif ft == "swift" and OS == "linux" then 
+        lint("switfc", "swiftc", {file}, "%f:%l:%d+:.+: %m")
+    elseif ft == "Objective-C" then
+        lint("clang", "xcrun", {"clang", "-fsyntax-only", "-Wall", "-Wextra", file}, "%f:%l:%d+:.+: %m")
     elseif ft == "d" then
-        lint("dmd", "dmd -color=off -o- -w -wi -c " .. file, "%f%(%l%):.+: %m")
+        lint("dmd", "dmd", {"-color=off", "-o-", "-w", "-wi", "-c", file}, "%f%(%l%):.+: %m")
     elseif ft == "java" then
-        lint("javac", "javac " .. file, "%f:%l: error: %m")
+        lint("javac", "javac", {"-d", dir, file}, "%f:%l: error: %m")
     elseif ft == "javascript" then
-        lint("jshint", "jshint " .. file, "%f: line %l,.+, %m")
+        lint("jshint", "jshint", {file}, "%f: line %l,.+, %m")
+    elseif ft == "nim" then
+        lint("nim", "nim", {"check", "--listFullPaths", "--stdout", "--hints:off", file}, "%f.%l, %d+. %m")
+    elseif string.match(ft, "literate") then
+        lint("literate", "lit", {"-c", file}, "%f:%l:%m")
+    elseif ft == "yaml" then
+        lint("yaml", "yamllint", {"--format", "parsable", file}, "%f:%l:%d+:.+ %m")
     end
 end
 
@@ -38,16 +60,16 @@ function onSave(view)
     end
 end
 
-function lint(linter, cmd, errorformat)
+function lint(linter, cmd, args, errorformat)
     CurView():ClearGutterMessages(linter)
 
-    JobStart(cmd, "", "", "linter.onExit", linter, errorformat)
+    JobSpawn(cmd, args, "", "", "linter.onExit", linter, errorformat)
 end
 
 function onExit(output, linter, errorformat)
     local lines = split(output, "\n")
 
-    local regex = errorformat:gsub("%%f", "(.+)"):gsub("%%l", "(%d+)"):gsub("%%m", "(.+)")
+    local regex = errorformat:gsub("%%f", "(..-)"):gsub("%%l", "(%d+)"):gsub("%%m", "(.+)")
     for _,line in ipairs(lines) do
         -- Trim whitespace
         line = line:match("^%s*(.+)%s*$")

runtime/plugins/literate/README.md

@@ -0,0 +1,5 @@
+# Literate Micro
+
+Support for reading `.lit` files from [zyedidia/Literate](https://github.com/zyedidia/Literate).
+
+This plugin will automatically detect the filetype and highlight the correct language inside the code blocks.

runtime/plugins/literate/literate.lua

@@ -0,0 +1,53 @@
+VERSION = "1.0.0"
+
+function startswith(str, start)
+   return string.sub(str,1,string.len(start))==start
+end
+
+function endswith(str, endStr)
+   return endStr=='' or string.sub(str,-string.len(endStr))==endStr
+end
+
+function split(string, sep)
+        local sep, fields = sep or ":", {}
+        local pattern = string.format("([^%s]+)", sep)
+        string:gsub(pattern, function(c) fields[#fields+1] = c end)
+        return fields
+end
+
+function onViewOpen(view)
+    if not endswith(view.Buf.Path, ".lit") then
+        return
+    end
+
+    local codetype = "unknown"
+    for i=1,view.Buf.NumLines do
+        local line = view.Buf:Line(i-1)
+        if startswith(line, "@code_type") then
+            codetype = split(line, " ")[2]
+            break
+        end
+    end
+
+    local syntaxFile = ""
+    syntaxFile = syntaxFile .. "filetype: literate-" .. codetype .. "\n"
+    syntaxFile = syntaxFile .. "detect:\n"
+    syntaxFile = syntaxFile .. "    filename: \"\\\\.lit$\"\n"
+    syntaxFile = syntaxFile .. "rules:\n"
+    syntaxFile = syntaxFile .. "    - include: \"markdown\"\n"
+    syntaxFile = syntaxFile .. "    - special: \"^(@s|@title|@code_type|@comment_type|@include|@change|@change_end)\"\n"
+    syntaxFile = syntaxFile .. "    - special: \"(@add_css|@overwrite_css|@colorscheme|@compiler|@error_format|@book)\"\n"
+    syntaxFile = syntaxFile .. "    - default:\n"
+    syntaxFile = syntaxFile .. "        start: \"---.*$\"\n"
+    syntaxFile = syntaxFile .. "        end: \"---$\"\n"
+    syntaxFile = syntaxFile .. "        limit-group: \"identifier\"\n"
+    syntaxFile = syntaxFile .. "        rules:\n"
+    syntaxFile = syntaxFile .. "            - special:\n"
+    syntaxFile = syntaxFile .. "                start: \"@\\\\{\"\n"
+    syntaxFile = syntaxFile .. "                end: \"\\\\}\"\n"
+    syntaxFile = syntaxFile .. "                rules: []\n"
+    syntaxFile = syntaxFile .. "            - include: " .. codetype .. "\n"
+
+    AddRuntimeFileFromMemory("literate", "syntax", "literate.yaml", syntaxFile)
+    Reload()
+end

runtime/syntax/Dockerfile.micro

@@ -1,26 +0,0 @@
-## Syntax highlighting for Dockerfiles
-syntax "dockerfile" "Dockerfile[^/]*$" "\.dockerfile$"
-
-## Keywords
-red (i) "^(FROM|MAINTAINER|RUN|CMD|LABEL|EXPOSE|ENV|ADD|COPY|ENTRYPOINT|VOLUME|USER|WORKDIR|ONBUILD)[[:space:]]"
-
-## Brackets & parenthesis
-color brightgreen "(\(|\)|\[|\])"
-
-## Double ampersand
-color brightmagenta "&&"
-
-## Comments
-cyan (i) "^[[:space:]]*#.*$"
-
-## Blank space at EOL
-color ,green "[[:space:]]+$"
-
-## Strings, single-quoted
-color brightwhite "'([^']|(\\'))*'" "%[qw]\{[^}]*\}" "%[qw]\([^)]*\)" "%[qw]<[^>]*>" "%[qw]\[[^]]*\]" "%[qw]\$[^$]*\$" "%[qw]\^[^^]*\^" "%[qw]![^!]*!"
-
-## Strings, double-quoted
-color brightwhite ""([^"]|(\\"))*"" "%[QW]?\{[^}]*\}" "%[QW]?\([^)]*\)" "%[QW]?<[^>]*>" "%[QW]?\[[^]]*\]" "%[QW]?\$[^$]*\$" "%[QW]?\^[^^]*\^" "%[QW]?![^!]*!"
-
-## Single and double quotes
-color brightyellow "('|\")"

runtime/syntax/LICENSE

@@ -1,15 +1,22 @@
-    micro syntax files
-    Copyright (C) 2016+ Zachary Yedidia et al.
+Micro's syntax files are licensed under the MIT "Expat" License:
 
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
+Copyright (c) 2016: Zachary Yedidia, Collin Warren, et al.
 
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
 
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

runtime/syntax/Makefile

@@ -1,4 +0,0 @@
-export
-:=
-error
-

runtime/syntax/README.md

@@ -1,3 +1,31 @@
+# Syntax Files
+
+Here are micro's syntax files.
+
+Each yaml file specifies how to detect the filetype based on file extension or headers (first line of the file).
+Then there are patterns and regions linked to highlight groups which tell micro how to highlight that filetype.
+
+Making your own syntax files is very simple. I recommend you check the file after you are finished with the
+[`syntax_checker.go`](./syntax_checker.go) program (located in this directory). Just place your yaml syntax
+file in the current directory and run `go run syntax_checker.go` and it will check every file. If there are no
+errors it will print `No issues!`.
+
+You can read more about how to write syntax files (and colorschemes) in the [colors](../help/colors.md) documentation.
+
+# Legacy '.micro' filetype
+
+Micro used to use the `.micro` filetype for syntax files which is no longer supported. If you have `.micro`
+syntax files that you would like to convert to the new filetype, you can use the [`syntax_converter.go`](./syntax_converter.go) program (also located in this directory):
+
+```
+$ go run syntax_converter.go c.micro > c.yaml
+```
+
+Most the the syntax files here have been converted using that tool.
+
+Note that the tool isn't perfect and though it is unlikely, you may run into some small issues that you will have to fix manually
+(about 4 files from this directory had issues after being converted).
+=======
 # Micro syntax highlighting files
 
 These are the syntax highlighting files for micro. To install them, just
@@ -7,14 +35,11 @@ They are taken from Nano, specifically from [this repository](https://github.com
 Micro syntax files are almost identical to Nano's, except for some key differences:
 
 * Micro does not use `icolor`. Instead, for a case insensitive match, use the case insensitive flag (`i`) in the regular expression
-    * For example, `icolor green ".*"` would become `color green (i) ".*"`
-* Micro does not support `start="..." end="..."`. Instead use the `s` flag to match newlines and put `.*?` in the middle
-    * For example `color green start="hello" end="world"` would become `color green (s) "hello.*?world"`
+    * For example, `icolor green ".*"` would become `color green "(?i).*"`
 
 # Using with colorschemes
 
-Not all of these files have been converted to use micro's colorscheme feature. Most of them just hardcode the colors, which
-can be problematic depending on the colorscheme you use.
+Not all of these files have been converted to use micro's colorscheme feature. Most of them just hardcode the colors, which can be problematic depending on the colorscheme you use.
 
 Here is a list of the files that have been converted to properly use colorschemes:
 
@@ -29,10 +54,13 @@ Here is a list of the files that have been converted to properly use colorscheme
 * rust
 * java
 * javascript
+* pascal
 * python
 * ruby
 * sh
 * git
+* tex
+* solidity
 
 # License
 

runtime/syntax/apacheconf.micro

@@ -1,44 +0,0 @@
-# Apache files
-syntax "apacheconf" "httpd\.conf|mime\.types|vhosts\.d\\*|\.htaccess"
-color yellow ".+"
-color brightcyan "(AcceptMutex|AcceptPathInfo|AccessFileName|Action|AddAlt|AddAltByEncoding|AddAltByType|AddCharset|AddDefaultCharset|AddDescription|AddEncoding)"
-color brightcyan "(AddHandler|AddIcon|AddIconByEncoding|AddIconByType|AddInputFilter|AddLanguage|AddModuleInfo|AddOutputFilter|AddOutputFilterByType|AddType|Alias|AliasMatch)"
-color brightcyan "(Allow|AllowCONNECT|AllowEncodedSlashes|AllowOverride|Anonymous|Anonymous_Authoritative|Anonymous_LogEmail|Anonymous_MustGiveEmail|Anonymous_NoUserID)"
-color brightcyan "(Anonymous_VerifyEmail|AssignUserID|AuthAuthoritative|AuthDBMAuthoritative|AuthDBMGroupFile|AuthDBMType|AuthDBMUserFile|AuthDigestAlgorithm)"
-color brightcyan "(AuthDigestDomain|AuthDigestFile|AuthDigestGroupFile|AuthDigestNcCheck|AuthDigestNonceFormat|AuthDigestNonceLifetime|AuthDigestQop|AuthDigestShmemSize)"
-color brightcyan "(AuthGroupFile|AuthLDAPAuthoritative|AuthLDAPBindDN|AuthLDAPBindPassword|AuthLDAPCharsetConfig|AuthLDAPCompareDNOnServer|AuthLDAPDereferenceAliases)"
-color brightcyan "(AuthLDAPEnabled|AuthLDAPFrontPageHack|AuthLDAPGroupAttribute|AuthLDAPGroupAttributeIsDN|AuthLDAPRemoteUserIsDN|AuthLDAPUrl|AuthName|AuthType|AuthUserFile)"
-color brightcyan "(BrowserMatch|BrowserMatchNoCase|BS2000Account|BufferedLogs|CacheDefaultExpire|CacheDirLength|CacheDirLevels|CacheDisable|CacheEnable|CacheExpiryCheck)"
-color brightcyan "(CacheFile|CacheForceCompletion|CacheGcClean|CacheGcDaily|CacheGcInterval|CacheGcMemUsage|CacheGcUnused|CacheIgnoreCacheControl|CacheIgnoreHeaders)"
-color brightcyan "(CacheIgnoreNoLastMod|CacheLastModifiedFactor|CacheMaxExpire|CacheMaxFileSize|CacheMinFileSize|CacheNegotiatedDocs|CacheRoot|CacheSize|CacheTimeMargin)"
-color brightcyan "(CGIMapExtension|CharsetDefault|CharsetOptions|CharsetSourceEnc|CheckSpelling|ChildPerUserID|ContentDigest|CookieDomain|CookieExpires|CookieLog|CookieName)"
-color brightcyan "(CookieStyle|CookieTracking|CoreDumpDirectory|CustomLog|Dav|DavDepthInfinity|DavLockDB|DavMinTimeout|DefaultIcon|DefaultLanguage|DefaultType)"
-color brightcyan "(DeflateBufferSize|DeflateCompressionLevel|DeflateFilterNote|DeflateMemLevel|DeflateWindowSize|Deny|Directory|DirectoryIndex|DirectoryMatch|DirectorySlash)"
-color brightcyan "(DocumentRoot|DumpIOInput|DumpIOOutput|EnableExceptionHook|EnableMMAP|EnableSendfile|ErrorDocument|ErrorLog|Example|ExpiresActive|ExpiresByType)"
-color brightcyan "(ExpiresDefault|ExtendedStatus|ExtFilterDefine|ExtFilterOptions|FileETag|Files|FilesMatch|ForceLanguagePriority|ForceType|ForensicLog|Group|Header)"
-color brightcyan "(HeaderName|HostnameLookups|IdentityCheck|IfDefine|IfModule|IfVersion|ImapBase|ImapDefault|ImapMenu|Include|IndexIgnore|IndexOptions|IndexOrderDefault)"
-color brightcyan "(ISAPIAppendLogToErrors|ISAPIAppendLogToQuery|ISAPICacheFile|ISAPIFakeAsync|ISAPILogNotSupported|ISAPIReadAheadBuffer|KeepAlive|KeepAliveTimeout)"
-color brightcyan "(LanguagePriority|LDAPCacheEntries|LDAPCacheTTL|LDAPConnectionTimeout|LDAPOpCacheEntries|LDAPOpCacheTTL|LDAPSharedCacheFile|LDAPSharedCacheSize)"
-color brightcyan "(LDAPTrustedCA|LDAPTrustedCAType|Limit|LimitExcept|LimitInternalRecursion|LimitRequestBody|LimitRequestFields|LimitRequestFieldSize|LimitRequestLine)"
-color brightcyan "(LimitXMLRequestBody|Listen|ListenBackLog|LoadFile|LoadModule|Location|LocationMatch|LockFile|LogFormat|LogLevel|MaxClients|MaxKeepAliveRequests)"
-color brightcyan "(MaxMemFree|MaxRequestsPerChild|MaxRequestsPerThread|MaxSpareServers|MaxSpareThreads|MaxThreads|MaxThreadsPerChild|MCacheMaxObjectCount|MCacheMaxObjectSize)"
-color brightcyan "(MCacheMaxStreamingBuffer|MCacheMinObjectSize|MCacheRemovalAlgorithm|MCacheSize|MetaDir|MetaFiles|MetaSuffix|MimeMagicFile|MinSpareServers|MinSpareThreads)"
-color brightcyan "(MMapFile|ModMimeUsePathInfo|MultiviewsMatch|NameVirtualHost|NoProxy|NumServers|NWSSLTrustedCerts|NWSSLUpgradeable|Options|Order|PassEnv|PidFile)"
-color brightcyan "(ProtocolEcho|Proxy|ProxyBadHeader|ProxyBlock|ProxyDomain|ProxyErrorOverride|ProxyIOBufferSize|ProxyMatch|ProxyMaxForwards|ProxyPass|ProxyPassReverse)"
-color brightcyan "(ProxyPreserveHost|ProxyReceiveBufferSize|ProxyRemote|ProxyRemoteMatch|ProxyRequests|ProxyTimeout|ProxyVia|ReadmeName|Redirect|RedirectMatch)"
-color brightcyan "(RedirectPermanent|RedirectTemp|RemoveCharset|RemoveEncoding|RemoveHandler|RemoveInputFilter|RemoveLanguage|RemoveOutputFilter|RemoveType|RequestHeader)"
-color brightcyan "(Require|RewriteBase|RewriteCond|RewriteEngine|RewriteLock|RewriteLog|RewriteLogLevel|RewriteMap|RewriteOptions|RewriteRule|RLimitCPU|RLimitMEM|RLimitNPROC)"
-color brightcyan "(Satisfy|ScoreBoardFile|Script|ScriptAlias|ScriptAliasMatch|ScriptInterpreterSource|ScriptLog|ScriptLogBuffer|ScriptLogLength|ScriptSock|SecureListen)"
-color brightcyan "(SendBufferSize|ServerAdmin|ServerAlias|ServerLimit|ServerName|ServerPath|ServerRoot|ServerSignature|ServerTokens|SetEnv|SetEnvIf|SetEnvIfNoCase|SetHandler)"
-color brightcyan "(SetInputFilter|SetOutputFilter|SSIEndTag|SSIErrorMsg|SSIStartTag|SSITimeFormat|SSIUndefinedEcho|SSLCACertificateFile|SSLCACertificatePath)"
-color brightcyan "(SSLCARevocationFile|SSLCARevocationPath|SSLCertificateChainFile|SSLCertificateFile|SSLCertificateKeyFile|SSLCipherSuite|SSLEngine|SSLMutex|SSLOptions)"
-color brightcyan "(SSLPassPhraseDialog|SSLProtocol|SSLProxyCACertificateFile|SSLProxyCACertificatePath|SSLProxyCARevocationFile|SSLProxyCARevocationPath|SSLProxyCipherSuite)"
-color brightcyan "(SSLProxyEngine|SSLProxyMachineCertificateFile|SSLProxyMachineCertificatePath|SSLProxyProtocol|SSLProxyVerify|SSLProxyVerifyDepth|SSLRandomSeed|SSLRequire)"
-color brightcyan "(SSLRequireSSL|SSLSessionCache|SSLSessionCacheTimeout|SSLUserName|SSLVerifyClient|SSLVerifyDepth|StartServers|StartThreads|SuexecUserGroup|ThreadLimit)"
-color brightcyan "(ThreadsPerChild|ThreadStackSize|TimeOut|TraceEnable|TransferLog|TypesConfig|UnsetEnv|UseCanonicalName|User|UserDir|VirtualDocumentRoot)"
-color brightcyan "(VirtualDocumentRootIP|VirtualHost|VirtualScriptAlias|VirtualScriptAliasIP|Win32DisableAcceptEx|XBitHack)"
-color yellow "<[^>]+>"
-color brightcyan "</?[A-Za-z]+"
-color brightcyan "(<|</|>)"
-color green "\"(\\.|[^\"])*\""
-color white "#.*"

runtime/syntax/apacheconf.yaml

@@ -0,0 +1,59 @@
+filetype: apacheconf
+
+detect:
+    filename: "httpd\\.conf|mime\\.types|vhosts\\.d\\\\*|\\.htaccess"
+
+rules:
+    - identifier: "(AcceptMutex|AcceptPathInfo|AccessFileName|Action|AddAlt|AddAltByEncoding|AddAltByType|AddCharset|AddDefaultCharset|AddDescription|AddEncoding)"
+    - identifier: "(AddHandler|AddIcon|AddIconByEncoding|AddIconByType|AddInputFilter|AddLanguage|AddModuleInfo|AddOutputFilter|AddOutputFilterByType|AddType|Alias|AliasMatch)"
+    - identifier: "(Allow|AllowCONNECT|AllowEncodedSlashes|AllowOverride|Anonymous|Anonymous_Authoritative|Anonymous_LogEmail|Anonymous_MustGiveEmail|Anonymous_NoUserID)"
+    - identifier: "(Anonymous_VerifyEmail|AssignUserID|AuthAuthoritative|AuthDBMAuthoritative|AuthDBMGroupFile|AuthDBMType|AuthDBMUserFile|AuthDigestAlgorithm)"
+    - identifier: "(AuthDigestDomain|AuthDigestFile|AuthDigestGroupFile|AuthDigestNcCheck|AuthDigestNonceFormat|AuthDigestNonceLifetime|AuthDigestQop|AuthDigestShmemSize)"
+    - identifier: "(AuthGroupFile|AuthLDAPAuthoritative|AuthLDAPBindDN|AuthLDAPBindPassword|AuthLDAPCharsetConfig|AuthLDAPCompareDNOnServer|AuthLDAPDereferenceAliases)"
+    - identifier: "(AuthLDAPEnabled|AuthLDAPFrontPageHack|AuthLDAPGroupAttribute|AuthLDAPGroupAttributeIsDN|AuthLDAPRemoteUserIsDN|AuthLDAPUrl|AuthName|AuthType|AuthUserFile)"
+    - identifier: "(BrowserMatch|BrowserMatchNoCase|BS2000Account|BufferedLogs|CacheDefaultExpire|CacheDirLength|CacheDirLevels|CacheDisable|CacheEnable|CacheExpiryCheck)"
+    - identifier: "(CacheFile|CacheForceCompletion|CacheGcClean|CacheGcDaily|CacheGcInterval|CacheGcMemUsage|CacheGcUnused|CacheIgnoreCacheControl|CacheIgnoreHeaders)"
+    - identifier: "(CacheIgnoreNoLastMod|CacheLastModifiedFactor|CacheMaxExpire|CacheMaxFileSize|CacheMinFileSize|CacheNegotiatedDocs|CacheRoot|CacheSize|CacheTimeMargin)"
+    - identifier: "(CGIMapExtension|CharsetDefault|CharsetOptions|CharsetSourceEnc|CheckSpelling|ChildPerUserID|ContentDigest|CookieDomain|CookieExpires|CookieLog|CookieName)"
+    - identifier: "(CookieStyle|CookieTracking|CoreDumpDirectory|CustomLog|Dav|DavDepthInfinity|DavLockDB|DavMinTimeout|DefaultIcon|DefaultLanguage|DefaultType)"
+    - identifier: "(DeflateBufferSize|DeflateCompressionLevel|DeflateFilterNote|DeflateMemLevel|DeflateWindowSize|Deny|Directory|DirectoryIndex|DirectoryMatch|DirectorySlash)"
+    - identifier: "(DocumentRoot|DumpIOInput|DumpIOOutput|EnableExceptionHook|EnableMMAP|EnableSendfile|ErrorDocument|ErrorLog|Example|ExpiresActive|ExpiresByType)"
+    - identifier: "(ExpiresDefault|ExtendedStatus|ExtFilterDefine|ExtFilterOptions|FileETag|Files|FilesMatch|ForceLanguagePriority|ForceType|ForensicLog|Group|Header)"
+    - identifier: "(HeaderName|HostnameLookups|IdentityCheck|IfDefine|IfModule|IfVersion|ImapBase|ImapDefault|ImapMenu|Include|IndexIgnore|IndexOptions|IndexOrderDefault)"
+    - identifier: "(ISAPIAppendLogToErrors|ISAPIAppendLogToQuery|ISAPICacheFile|ISAPIFakeAsync|ISAPILogNotSupported|ISAPIReadAheadBuffer|KeepAlive|KeepAliveTimeout)"
+    - identifier: "(LanguagePriority|LDAPCacheEntries|LDAPCacheTTL|LDAPConnectionTimeout|LDAPOpCacheEntries|LDAPOpCacheTTL|LDAPSharedCacheFile|LDAPSharedCacheSize)"
+    - identifier: "(LDAPTrustedCA|LDAPTrustedCAType|Limit|LimitExcept|LimitInternalRecursion|LimitRequestBody|LimitRequestFields|LimitRequestFieldSize|LimitRequestLine)"
+    - identifier: "(LimitXMLRequestBody|Listen|ListenBackLog|LoadFile|LoadModule|Location|LocationMatch|LockFile|LogFormat|LogLevel|MaxClients|MaxKeepAliveRequests)"
+    - identifier: "(MaxMemFree|MaxRequestsPerChild|MaxRequestsPerThread|MaxSpareServers|MaxSpareThreads|MaxThreads|MaxThreadsPerChild|MCacheMaxObjectCount|MCacheMaxObjectSize)"
+    - identifier: "(MCacheMaxStreamingBuffer|MCacheMinObjectSize|MCacheRemovalAlgorithm|MCacheSize|MetaDir|MetaFiles|MetaSuffix|MimeMagicFile|MinSpareServers|MinSpareThreads)"
+    - identifier: "(MMapFile|ModMimeUsePathInfo|MultiviewsMatch|NameVirtualHost|NoProxy|NumServers|NWSSLTrustedCerts|NWSSLUpgradeable|Options|Order|PassEnv|PidFile)"
+    - identifier: "(ProtocolEcho|Proxy|ProxyBadHeader|ProxyBlock|ProxyDomain|ProxyErrorOverride|ProxyIOBufferSize|ProxyMatch|ProxyMaxForwards|ProxyPass|ProxyPassReverse)"
+    - identifier: "(ProxyPreserveHost|ProxyReceiveBufferSize|ProxyRemote|ProxyRemoteMatch|ProxyRequests|ProxyTimeout|ProxyVia|ReadmeName|Redirect|RedirectMatch)"
+    - identifier: "(RedirectPermanent|RedirectTemp|RemoveCharset|RemoveEncoding|RemoveHandler|RemoveInputFilter|RemoveLanguage|RemoveOutputFilter|RemoveType|RequestHeader)"
+    - identifier: "(Require|RewriteBase|RewriteCond|RewriteEngine|RewriteLock|RewriteLog|RewriteLogLevel|RewriteMap|RewriteOptions|RewriteRule|RLimitCPU|RLimitMEM|RLimitNPROC)"
+    - identifier: "(Satisfy|ScoreBoardFile|Script|ScriptAlias|ScriptAliasMatch|ScriptInterpreterSource|ScriptLog|ScriptLogBuffer|ScriptLogLength|ScriptSock|SecureListen)"
+    - identifier: "(SendBufferSize|ServerAdmin|ServerAlias|ServerLimit|ServerName|ServerPath|ServerRoot|ServerSignature|ServerTokens|SetEnv|SetEnvIf|SetEnvIfNoCase|SetHandler)"
+    - identifier: "(SetInputFilter|SetOutputFilter|SSIEndTag|SSIErrorMsg|SSIStartTag|SSITimeFormat|SSIUndefinedEcho|SSLCACertificateFile|SSLCACertificatePath)"
+    - identifier: "(SSLCARevocationFile|SSLCARevocationPath|SSLCertificateChainFile|SSLCertificateFile|SSLCertificateKeyFile|SSLCipherSuite|SSLEngine|SSLMutex|SSLOptions)"
+    - identifier: "(SSLPassPhraseDialog|SSLProtocol|SSLProxyCACertificateFile|SSLProxyCACertificatePath|SSLProxyCARevocationFile|SSLProxyCARevocationPath|SSLProxyCipherSuite)"
+    - identifier: "(SSLProxyEngine|SSLProxyMachineCertificateFile|SSLProxyMachineCertificatePath|SSLProxyProtocol|SSLProxyVerify|SSLProxyVerifyDepth|SSLRandomSeed|SSLRequire)"
+    - identifier: "(SSLRequireSSL|SSLSessionCache|SSLSessionCacheTimeout|SSLUserName|SSLVerifyClient|SSLVerifyDepth|StartServers|StartThreads|SuexecUserGroup|ThreadLimit)"
+    - identifier: "(ThreadsPerChild|ThreadStackSize|TimeOut|TraceEnable|TransferLog|TypesConfig|UnsetEnv|UseCanonicalName|User|UserDir|VirtualDocumentRoot)"
+    - identifier: "(VirtualDocumentRootIP|VirtualHost|VirtualScriptAlias|VirtualScriptAliasIP|Win32DisableAcceptEx|XBitHack)"
+    - symbol.tag: "<[^>]+>"
+    - identifier: "</?[A-Za-z]+"
+    - identifier: "(<|</|>)"
+
+    - constant.string:
+        start: "\""
+        end: "\""
+        skip: "\\\\."
+        rules:
+            - constant.specialChar: "\\\\."
+
+    - comment:
+        start: "#"
+        end: "$"
+        rules:
+            - todo: "(TODO|XXX|FIXME):?"
+

runtime/syntax/arduino.micro

@@ -1,116 +0,0 @@
-
-## FILENAME:    arduino.nanorc
-##
-## DESCRIPTION: The arduino.nanorc syntax files allows syntax highlighting
-##              for Arduino sketch files in the GNU nano text editor.
-##
-## Maintainer:  Nicholas Wilde
-## Version:     0.1
-## DATE:        06/23/2011
-##
-## HOMEPAGE:    http://code.google.com/p/arduino-nano-editor-syntax/
-##
-## COMMENTS:    -Most of the code was taken from the c.nanorc code found with 
-##               GNU nano 2.2.6.
-##              -Direction was taken from the arduino vim syntax code by johannes
-##               <https://bitbucket.org/johannes/arduino-vim-syntax/>
-##              -Tested on Ubuntu Server 11.04 Natty Narwhal and GNU nano 2.2.6
-##
-## DIRECTIONS:  For Ubuntu Server 11.04 Natty Narwhal:
-##              -Move this file <arduino.nanorc> to the nano directory
-##               /usr/share/nano/
-##              -Add arduino.nanorc reference to the nanorc settings file
-##               /etc/nanorc
-##               ...
-##               ## Arduino
-##               /usr/share/nano/arduino.nanorc
-##               ...
-
-syntax "ino"  "\.?ino$"
-
-## 
-color brightred "\<[A-Z_][0-9A-Z_]+\>" 
-
-## 
-color green "\<((s?size)|((u_?)?int(8|16|32|64|ptr)))_t\>"
-
-## Constants
-green (i) "\<(HIGH|LOW|INPUT|OUTPUT)\>"
-
-## Serial Print
-red (i) "\<(DEC|BIN|HEX|OCT|BYTE)\>"
-
-## PI Constants
-green (i) "\<(PI|HALF_PI|TWO_PI)\>"
-
-## ShiftOut
-green (i) "\<(LSBFIRST|MSBFIRST)\>"
-
-## Attach Interrupt
-green (i) "\<(CHANGE|FALLING|RISING)\>"
-
-## Analog Reference
-green (i) "\<(DEFAULT|EXTERNAL|INTERNAL|INTERNAL1V1|INTERNAL2V56)\>"
-
-## === FUNCTIONS === ##
-
-## Data Types
-color green "\<(boolean|byte|char|float|int|long|word)\>"
-
-## Control Structions
-color brightyellow "\<(case|class|default|do|double|else|false|for|if|new|null|private|protected|public|short|signed|static|String|switch|this|throw|try|true|unsigned|void|while)\>" 
-color magenta "\<(goto|continue|break|return)\>"
-
-## Math
-color brightyellow "\<(abs|acos|asin|atan|atan2|ceil|constrain|cos|degrees|exp|floor|log|map|max|min|radians|random|randomSeed|round|sin|sq|sqrt|tan)\>"
-
-## Bits & Bytes
-color brightyellow "\<(bitRead|bitWrite|bitSet|bitClear|bit|highByte|lowByte)\>"
-
-## Analog I/O
-color brightyellow "\<(analogReference|analogRead|analogWrite)\>"
-
-## External Interrupts
-color brightyellow "\<(attachInterrupt|detachInterrupt)\>"
-
-## Time
-color brightyellow "\<(delay|delayMicroseconds|millis|micros)\>"
-
-## Digital I/O
-color brightyellow "\<(pinMode|digitalWrite|digitalRead)\>"
-
-## Interrupts
-color brightyellow "\<(interrupts|noInterrupts)\>"
-
-## Advanced I/O
-color brightyellow "\<(noTone|pulseIn|shiftIn|shiftOut|tone)\>"
-
-## Serial
-color magenta "\<(Serial|Serial1|Serial2|Serial3|begin|end|peek|read|print|println|available|flush)\>"
-
-## Structure
-color brightyellow "\<(setup|loop)\>"
-
-## 
-color brightcyan "^[[:space:]]*#[[:space:]]*(define|include(_next)?|(un|ifn?)def|endif|el(if|se)|if|warning|error|pragma)"
-
-## 
-color brightmagenta "'([^']|(\\["'abfnrtv\\]))'" "'\\(([0-3]?[0-7]{1,2}))'" "'\\x[0-9A-Fa-f]{1,2}'"
-
-## GCC builtins
-color cyan "__attribute__[[:space:]]*\(\([^)]*\)\)" "__(aligned|asm|builtin|hidden|inline|packed|restrict|section|typeof|weak)__"
-
-## String highlighting.  You will in general want your comments and
-## strings to come last, because syntax highlighting rules will be
-## applied in the order they are read in.
-color brightyellow "<[^=    ]*>" ""(\\.|[^"])*""
-
-## This string is VERY resource intensive!
-color brightyellow start=""(\\.|[^"])*\\[[:space:]]*$" end="^(\\.|[^"])*""
-
-## Comments
-color brightblue "//.*"
-color brightblue start="/\*" end="\*/"
-
-## Trailing whitespace
-color ,green "[[:space:]]+$"