Autocompletion fix for infobuffer

This reverts commit 75f9d7d9122f5b475c4ff323cca7cc068ea4e411.

.editorconfig

@@ -0,0 +1,7 @@
+# See http://editorconfig.org
+
+# In Go files we indent with tabs but still 
+# set indent_size to control the GitHub web viewer.  
+[*.go]
+indent_size=4
+

.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,17 @@
-./micro
+.DS_Store
+
+micro
 !cmd/micro
 binaries/
+tmp.sh
+test/
+.idea/
+packages/
+todo.txt
+test.txt
+log.txt
+*.old
+tools/build-version
+tools/build-date
+tools/info-plist
+tools/bindata

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "tools/go-bindata"]
+	path = tools/go-bindata
+	url = https://github.com/zyedidia/go-bindata

.travis.yml

@@ -1,2 +1,9 @@
 language: go
-script: make test
+go:
+    - "1.11.x"
+os:
+    - linux
+    - osx
+script:
+    - env GO111MODULE=on make build
+    - env GO111MODULE=on make test

LICENSE

@@ -1,6 +1,6 @@
-Micro is licensed under the MIT "Expat" License:
+MIT License
 
-Copyright (c) 2016: Zachary Yedidia.
+Copyright (c) 2016-2017: 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,47 +1,51 @@
 .PHONY: runtime
 
-VERSION = $(shell git describe --tags --abbrev=0)
-HASH = $(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
+GOVARS := -X github.com/zyedidia/micro/internal/util.Version=$(VERSION) -X github.com/zyedidia/micro/internal/util.CommitHash=$(HASH) -X 'github.com/zyedidia/micro/internal/util.CompileDate=$(DATE)' -X github.com/zyedidia/micro/internal/util.Debug=OFF
 
 # Builds micro after checking dependencies but without updating the runtime
-build: deps tcell
-	go build -ldflags "-X main.Version=$(VERSION) -X main.CommitHash=$(HASH) -X 'main.CompileDate=$(shell date -u '+%B %d, %Y')'" -o micro ./cmd/micro
+build:
+	go build -ldflags "-s -w $(GOVARS) $(ADDITIONAL_GO_LINKER_FLAGS)" ./cmd/micro
 
-# Builds micro after building the runtiem and checking dependencies
+build-dbg:
+	go build -ldflags "-s -w $(ADDITIONAL_GO_LINKER_FLAGS)" ./cmd/micro
+
+# Builds micro after building the runtime and checking dependencies
 build-all: runtime build
 
 # Builds micro without checking for dependencies
 build-quick:
-	go build -ldflags "-X main.Version=$(VERSION) -X main.CommitHash=$(HASH) -X 'main.CompileDate=$(shell date -u '+%B %d, %Y')'" -o micro ./cmd/micro
+	go build -ldflags "-s -w $(GOVARS) $(ADDITIONAL_GO_LINKER_FLAGS)" ./cmd/micro
 
-# Same as 'build' but installs to $GOPATH/bin afterward
-install: build
-	mv micro $(GOPATH)/bin
+# Same as 'build' but installs to $GOBIN afterward
+install:
+	go install -ldflags "-s -w $(GOVARS) $(ADDITIONAL_GO_LINKER_FLAGS)" ./cmd/micro
 
-# Same as 'build-all' but installs to $GOPATH/bin afterward
+# Same as 'build-all' but installs to $GOBIN afterward
 install-all: runtime install
 
-# Same as 'build-quick' but installs to $GOPATH/bin afterward
-install-quick: build-quick
-	mv micro $(GOPATH)/bin
-
-# Updates tcell
-tcell:
-	git -C $(GOPATH)/src/github.com/zyedidia/tcell pull
-
-# Checks for dependencies
-deps:
-	go get -d ./cmd/micro
+# Same as 'build-quick' but installs to $GOBIN afterward
+install-quick:
+	go install -ldflags "-s -w $(GOVARS) $(ADDITIONAL_GO_LINKER_FLAGS)"  ./cmd/micro
 
 # Builds the runtime
 runtime:
-	go get -u github.com/jteeuwen/go-bindata/...
-	$(GOPATH)/bin/go-bindata -nometadata -o runtime.go runtime/...
-	mv runtime.go cmd/micro
+	git submodule update --init
+	go build -o tools/bindata ./tools/go-bindata
+	tools/bindata -pkg config -nomemcopy -nometadata -o runtime.go runtime/...
+	mv runtime.go internal/config
+	gofmt -w internal/config/runtime.go
 
 test:
-	go get -d ./cmd/micro
-	go test ./cmd/micro
+	go test ./internal/...
 
 clean:
 	rm -f micro

README.md

@@ -4,6 +4,7 @@
 [![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)
+[![Snap Status](https://build.snapcraft.io/badge/zyedidia/micro.svg)](https://build.snapcraft.io/user/zyedidia/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. It comes as one single, batteries-included, static binary with no dependencies, and you can download and use it right now.
@@ -16,39 +17,63 @@ 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.
+
+# Table of Contents
+- [Features](#features)
+- [Installation](#installation)
+  - [Prebuilt binaries](#prebuilt-binaries)
+  - [Package Managers](#package-managers)
+  - [Building from source](#building-from-source)
+  - [MacOS terminal](#macos-terminal)
+  - [Linux clipboard support](#linux-clipboard-support)
+  - [Colors and syntax highlighting](#colors-and-syntax-highlighting)
+  - [Plan9, Cygwin](#plan9-cygwin)
+- [Usage](#usage)
+- [Documentation and Help](#documentation-and-help)
+- [Contributing](#contributing)
+
+- - -
 
 # Features
 
 * Easy to use and to install
 * No dependencies or external files are needed -- just the binary you can download further down the page
+* Multiple cursors
 * Common keybindings (ctrl-s, ctrl-c, ctrl-v, ctrl-z...)
     * 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
+* Nano-like menu to help you remember the keybindings
 * 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, and multiple cursors in the future.
+Although not yet implemented, I hope to add more features such as autocompletion ([#174](https://github.com/zyedidia/micro/issues/174)) or a tree view ([#249](https://github.com/zyedidia/micro/issues/249)) in the future.
 
 # Installation
 
 To install micro, you can download a [prebuilt binary](https://github.com/zyedidia/micro/releases), or you can build it from source.
 
-If you want more information about ways to install micro, see this [wiki page](https://github.com/zyedidia/micro/wiki/Installing-Micro)
+If you want more information about ways to install micro, see this [wiki page](https://github.com/zyedidia/micro/wiki/Installing-Micro).
 
 ### Prebuilt binaries
 
@@ -61,19 +86,75 @@ and you'll see all the stable releases with the corresponding binaries.
 
 If you'd like to see more information after installing micro, run `micro -version`.
 
+### Installation script
+
+There is a great script which can install micro for you by downloading the latest prebuilt binary. You can find it at https://getmic.ro (the github repo for it is [here](https://github.com/benweissmann/getmic.ro)).
+
+Then you can easily install micro:
+
+    $ curl https://getmic.ro | bash
+
+The script will install the micro binary to the current directory.
+
+See the [Github page](https://github.com/benweissmann/getmic.ro) for more information.
+
+### Package managers
+
+You can install micro using Homebrew on Mac:
+
+```
+brew install micro
+```
+
+On Windows, you can install micro through [Chocolatey](https://chocolatey.org/) or [Scoop](https://github.com/lukesampson/scoop):
+
+```
+choco install micro
+```
+
+or
+
+```
+scoop install micro
+```
+
+On Linux, you can install micro through [snap](https://snapcraft.io/docs/core/install)
+
+```
+snap install micro --classic
+```
+
+On OpenBSD, micro is available in the ports tree. It is also available as a binary package.
+
+```
+pkg_add -v micro
+```
+
 ### Building from source
 
-If your operating system does not have binary, but does run Go, you can build from source.
+If your operating system does not have a binary release, but does run Go, you can build from source.
 
-Make sure that you have Go version 1.5 or greater (Go 1.4 will work if your version supports CGO).
+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 recommend setting it to `~/go` if you don't have one).
 
-```sh
-go get -u github.com/zyedidia/micro/...
 ```
+go get -d github.com/zyedidia/micro/cmd/micro
+cd $GOPATH/src/github.com/zyedidia/micro
+make install
+```
+
+The binary will then be installed to `$GOPATH/bin` (or your `$GOBIN`).
+
+Please make sure that when you are working with micro's code, you are working on your `GOPATH`.
+
+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. For best keybinding behavior, choose `xterm defaults` under `Preferences->Profiles->Keys->Load Preset`. The newest versions also support true color.
 
 ### Linux clipboard support
 
-On Linux, clipboard support requires 'xclip' or 'xsel' command to be installed.
+On Linux, clipboard support requires the 'xclip' or 'xsel' commands to be installed.
 
 For Ubuntu:
 
@@ -83,18 +164,25 @@ 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.
 
-### Windows colors
+### 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 or cmder.
+mintty.
 
-### Plan9, NaCl, Cygwin
+### Plan9, 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).
+Plan9, and Cygwin (although this may change in the future). Micro also doesn't support NaCl (but NaCl is deprecated anyways).
 
 # Usage
 
@@ -114,8 +202,15 @@ 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.
@@ -124,4 +219,7 @@ a brief introduction to the more powerful configuration features micro offers.
 
 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).

assets/logo.svg

@@ -0,0 +1,63 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   id="svg3336"
+   version="1.1"
+   inkscape:version="0.91 r13725"
+   width="128"
+   height="128"
+   viewBox="0 0 128 128"
+   sodipodi:docname="logo.svg">
+  <metadata
+     id="metadata3342">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+        <dc:title></dc:title>
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <defs
+     id="defs3340" />
+  <sodipodi:namedview
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1"
+     objecttolerance="10"
+     gridtolerance="10"
+     guidetolerance="10"
+     inkscape:pageopacity="0"
+     inkscape:pageshadow="2"
+     inkscape:window-width="1355"
+     inkscape:window-height="717"
+     id="namedview3338"
+     showgrid="false"
+     inkscape:zoom="1.6243169"
+     inkscape:cx="111.32302"
+     inkscape:cy="30.538264"
+     inkscape:window-x="0"
+     inkscape:window-y="0"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="svg3336" />
+  <path
+     style="fill:#2e3192;fill-opacity:1"
+     d="m 56.1,127.32358 c -13.68932,-1.70993 -27.156628,-8.3544 -37.112903,-18.31068 -25.0687936,-25.068788 -25.0687936,-65.95701 0,-91.025803 25.068793,-25.0687936 65.957015,-25.0687936 91.025803,0 25.0688,25.068793 25.0688,65.957015 0,91.025803 C 95.87457,123.15123 76.198116,129.83404 56.1,127.32358 Z"
+     id="path3364"
+     inkscape:connector-curvature="0" />
+  <path
+     style="fill:#ffffff"
+     d="m 40.756452,106.01908 c 1.442831,-1.83426 1.55476,-4.09687 0.414499,-8.37899 -0.678184,-2.546844 -0.684604,-4.05591 -0.03829,-9 1.276867,-9.767604 4.483143,-23.040636 5.565559,-23.039766 0.220979,1.74e-4 0.417725,2.092674 0.437213,4.65 0.04167,5.468298 1.558564,9.06891 4.638769,11.010942 2.551646,1.608774 9.15365,1.329324 12.80399,-0.541974 3.245124,-1.663572 7.649064,-6.112434 9.850956,-9.951438 L 76.188736,67.7 l 0.0054,3.922866 c 0.0042,2.867148 0.36894,4.642788 1.355628,6.59796 1.532058,3.035856 3.323226,4.15755 6.659322,4.17033 5.192928,0.01986 9.07014,-3.668676 10.866768,-10.338036 0.98277,-3.64821 1.064448,-11.21265 0.09235,-8.55312 -3.025218,8.276592 -4.468212,9.893562 -9.238056,10.351884 -2.629152,0.25263 -3.177804,0.08883 -4.921776,-1.469412 -1.609044,-1.437678 -2.016072,-2.308416 -2.258508,-4.8315 -0.262884,-2.73585 0.105942,-4.06497 3.32007,-11.964365 C 88.28388,40.315087 89.33625,35.536248 87,33.2 c -1.559352,-1.559353 -3.62787,-1.522741 -5.691792,0.10074 -2.295762,1.805846 -3.105984,4.070756 -5.14293,14.376662 -2.464164,12.46744 -6.525822,20.297092 -12.62193,24.331306 C 59.052142,74.98085 52.704914,73.6403 50.637191,69.282896 49.19967,66.253544 49.857706,62.552972 53.387813,53.814319 56.613526,45.829186 58.8,38.711369 58.8,36.195564 c 0,-4.161283 -4.366993,-5.665719 -7.364438,-2.537061 -2.183558,2.279144 -3.117251,5.256959 -4.280897,13.653016 -0.547956,3.953665 -1.259292,9.010489 -1.580746,11.237387 -0.321454,2.226896 -2.083918,8.706896 -3.916587,14.400002 -4.33165,13.456074 -6.85029,23.184822 -7.273674,28.096022 -0.325586,3.77675 -0.269352,4.00056 1.319044,5.25 2.187498,1.72068 3.541408,1.64679 5.05375,-0.27585 z"
+     id="path3362"
+     inkscape:connector-curvature="0" />
+</svg>

assets/packaging/micro.1

@@ -0,0 +1,73 @@
+.\" micro manual page - micro(1)
+.\" 
+.\" Copyright © 2017 Zachary Yedidia <zyedidia@gmail.com>
+.\" Copyright © 2017 Collin Warren <anatoly@somethinghub.com>
+.\"
+.\" This document is provided under the same licensing as micro.
+.\" See \usr\share\doc\micro\LICENSE for more information.
+.TH micro 1 "2017-03-28"
+.SH NAME
+micro \- A modern and intuitive terminal-based text editor
+.SH SYNOPSIS
+.B micro
+.RB [OPTIONS]
+[FILE]\&...
+
+.SH DESCRIPTION
+
+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.
+
+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).
+
+.SH OPTIONS
+.PP
+\-config-dir dir
+.RS 4
+Specify a custom location for the configuration directory
+.RE
+.PP
+\-startpos LINE,COL
+.RS 4
+Specify a line and column to start the cursor at when opening a buffer
+.RE
+.PP
+\-options
+.RS 4
+Show all option help
+.RE
+.PP
+\-version
+.RS 4
+Show the version number and information
+.RE
+
+.SH CONFIGURATION
+
+Micro uses
+\fI$XDG_CONFIG_HOME/micro\fR
+for configuration by default. If it is not set, micro uses ~/.config/micro.
+Two main configuration files are settings.json, containing the user's
+settings, and bindings.json, containing the user's custom keybindings.
+
+.SH ENVIRONMENT
+Micro's behaviour can be changed by setting environment variables, of which there is currently only one:
+\fIMICRO_TRUECOLOR\fR.
+When MICRO_TRUECOLOR is set to 1, micro will attempt to treat your terminal as a true-color terminal and will be able to make full use of the true-color colorschemes that are included with micro. If MICRO_TRUECOLOR is not set or is set to 0, then micro will only make use of 256 color features and will internally map true-color colorschemes to the nearest colors available. For more information see micro's documentation.
+
+.SH NOTICE
+This manpage is intended only to serve as a quick guide to the invocation of 
+micro and is not intended to replace the full documentation included with micro
+which can be accessed from within micro. Micro tells you what key combination to
+press to get help in the lower right.
+
+.SH BUGS
+A comprehensive list of bugs will not be listed in this manpage. See the Github
+page at \fBhttps://github.com/zyedidia/micro/issues\fP for a list of known bugs
+and to report any newly encountered bugs you may find. We strive to correct
+bugs as swiftly as possible.
+
+.SH COPYRIGHT
+Copyright \(co 2017 Zachary Yedidia, Collin Warren, et al.
+See /usr/share/doc/micro/LICENSE and /usr/share/doc/micro/AUTHORS for more information.

assets/packaging/micro.desktop

@@ -0,0 +1,15 @@
+[Desktop Entry]
+
+Name=Micro
+GenericName=Text Editor
+Comment=Edit text files in a terminal
+
+Icon=micro
+Type=Application
+Categories=terminal;TextEditor;
+Keywords=text;editor;syntax;terminal;
+
+Exec=micro %U
+StartupNotify=false
+Terminal=true
+MimeType=text/plain;text/x-chdr;text/x-csrc;text/x-c++hdr;text/x-c++src;text/x-java;text/x-dsrc;text/x-pascal;text/x-perl;text/x-python;application/x-php;application/x-httpd-php3;application/x-httpd-php4;application/x-httpd-php5;application/xml;text/html;text/css;text/x-sql;text/x-diff;

cmd/micro/autocomplete.go

@@ -1,124 +0,0 @@
-package main
-
-import (
-	"io/ioutil"
-	"os"
-	"strings"
-
-	"github.com/mitchellh/go-homedir"
-)
-
-// 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 files []os.FileInfo
-	var err error
-	if len(dirs) > 1 {
-		home, _ := homedir.Dir()
-
-		directories := strings.Join(dirs[:len(dirs)-1], "/")
-		if strings.HasPrefix(directories, "~") {
-			directories = strings.Replace(directories, "~", home, 1)
-		}
-		files, err = ioutil.ReadDir(directories)
-	} else {
-		files, err = ioutil.ReadDir(".")
-	}
-	var suggestions []string
-	if err != nil {
-		return "", suggestions
-	}
-	for _, f := range files {
-		name := f.Name()
-		if f.IsDir() {
-			name += "/"
-		}
-		if strings.HasPrefix(name, dirs[len(dirs)-1]) {
-			suggestions = append(suggestions, name)
-		}
-	}
-
-	var chosen string
-	if len(suggestions) == 1 {
-		if len(dirs) > 1 {
-			chosen = strings.Join(dirs[:len(dirs)-1], "/") + "/" + suggestions[0]
-		} else {
-			chosen = suggestions[0]
-		}
-	} else {
-		if len(dirs) > 1 {
-			chosen = strings.Join(dirs[:len(dirs)-1], "/") + "/"
-		}
-	}
-
-	return chosen, suggestions
-}
-
-// CommandComplete autocompletes commands
-func CommandComplete(input string) (string, []string) {
-	var suggestions []string
-	for cmd := range commands {
-		if strings.HasPrefix(cmd, input) {
-			suggestions = append(suggestions, cmd)
-		}
-	}
-
-	var chosen string
-	if len(suggestions) == 1 {
-		chosen = suggestions[0]
-	}
-	return chosen, suggestions
-}
-
-// HelpComplete autocompletes help topics
-func HelpComplete(input string) (string, []string) {
-	var suggestions []string
-
-	for _, topic := range helpFiles {
-		if strings.HasPrefix(topic, input) {
-
-			suggestions = append(suggestions, topic)
-		}
-	}
-
-	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
-	localSettings := DefaultLocalSettings()
-	for option := range globalSettings {
-		if strings.HasPrefix(option, input) {
-			suggestions = append(suggestions, option)
-		}
-	}
-	for option := range localSettings {
-		if strings.HasPrefix(option, input) && !contains(suggestions, option) {
-			suggestions = append(suggestions, option)
-		}
-	}
-
-	var chosen string
-	if len(suggestions) == 1 {
-		chosen = suggestions[0]
-	}
-	return chosen, suggestions
-}

cmd/micro/buffer.go

@@ -1,325 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"encoding/gob"
-	"io/ioutil"
-	"os"
-	"os/exec"
-	"os/signal"
-	"path/filepath"
-	"time"
-	"unicode/utf8"
-)
-
-// Buffer stores the text for files that are loaded into the text editor
-// It uses a rope to efficiently store the string and contains some
-// simple functions for saving and wrapper functions for modifying the rope
-type Buffer struct {
-	// The eventhandler for undo/redo
-	*EventHandler
-	// This stores all the text in the buffer as an array of lines
-	*LineArray
-
-	Cursor Cursor
-
-	// Path to the file on disk
-	Path string
-	// Name of the buffer on the status line
-	Name string
-
-	// Whether or not the buffer has been modified since it was opened
-	IsModified bool
-
-	// Stores the last modification time of the file the buffer is pointing to
-	ModTime time.Time
-
-	NumLines int
-
-	// Syntax highlighting rules
-	rules []SyntaxRule
-
-	// Buffer local settings
-	Settings map[string]interface{}
-}
-
-// The SerializedBuffer holds the types that get serialized when a buffer is saved
-// These are used for the savecursor and saveundo options
-type SerializedBuffer struct {
-	EventHandler *EventHandler
-	Cursor       Cursor
-	ModTime      time.Time
-}
-
-// NewBuffer creates a new buffer from `txt` with path and name `path`
-func NewBuffer(txt []byte, path string) *Buffer {
-	b := new(Buffer)
-	b.LineArray = NewLineArray(txt)
-
-	b.Settings = DefaultLocalSettings()
-	for k, v := range globalSettings {
-		if _, ok := b.Settings[k]; ok {
-			b.Settings[k] = v
-		}
-	}
-
-	b.Path = path
-	b.Name = path
-
-	// If the file doesn't have a path to disk then we give it no name
-	if path == "" {
-		b.Name = "No name"
-	}
-
-	// The last time this file was modified
-	b.ModTime, _ = GetModTime(b.Path)
-
-	b.EventHandler = NewEventHandler(b)
-
-	b.Update()
-	b.FindFileType()
-	b.UpdateRules()
-
-	if _, err := os.Stat(configDir + "/buffers/"); os.IsNotExist(err) {
-		os.Mkdir(configDir+"/buffers/", os.ModePerm)
-	}
-
-	// Put the cursor at the first spot
-	b.Cursor = Cursor{
-		Loc: Loc{
-			X: 0,
-			Y: 0,
-		},
-		buf: b,
-	}
-
-	InitLocalSettings(b)
-
-	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))
-		if err == nil {
-			var buffer SerializedBuffer
-			decoder := gob.NewDecoder(file)
-			gob.Register(TextEvent{})
-			err = decoder.Decode(&buffer)
-			if err != nil {
-				TermMessage(err.Error(), "\n", "You may want to remove the files in ~/.config/micro/buffers (these files store the information for the 'saveundo' and 'savecursor' options) if this problem persists.")
-			}
-			if b.Settings["savecursor"].(bool) {
-				b.Cursor = buffer.Cursor
-				b.Cursor.buf = b
-				b.Cursor.Relocate()
-			}
-
-			if b.Settings["saveundo"].(bool) {
-				// We should only use last time's eventhandler if the file wasn't by someone else in the meantime
-				if b.ModTime == buffer.ModTime {
-					b.EventHandler = buffer.EventHandler
-					b.EventHandler.buf = b
-				}
-			}
-		}
-		file.Close()
-	}
-
-	return b
-}
-
-// 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)
-}
-
-// FindFileType identifies this buffer's filetype based on the extension or header
-func (b *Buffer) FindFileType() {
-	b.Settings["filetype"] = FindFileType(b)
-}
-
-// FileType returns the buffer's filetype
-func (b *Buffer) FileType() string {
-	return b.Settings["filetype"].(string)
-}
-
-// 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
-func (b *Buffer) CheckModTime() {
-	modTime, ok := GetModTime(b.Path)
-	if ok {
-		if modTime != b.ModTime {
-			choice, canceled := messenger.YesNoPrompt("The file has changed since it was last read. Reload file? (y,n)")
-			messenger.Reset()
-			messenger.Clear()
-			if !choice || canceled {
-				// Don't load new changes -- do nothing
-				b.ModTime, _ = GetModTime(b.Path)
-			} else {
-				// Load new changes
-				b.ReOpen()
-			}
-		}
-	}
-}
-
-// ReOpen reloads the current buffer from disk
-func (b *Buffer) ReOpen() {
-	data, err := ioutil.ReadFile(b.Path)
-	txt := string(data)
-
-	if err != nil {
-		messenger.Error(err.Error())
-		return
-	}
-	b.EventHandler.ApplyDiff(txt)
-
-	b.ModTime, _ = GetModTime(b.Path)
-	b.IsModified = false
-	b.Update()
-	b.Cursor.Relocate()
-}
-
-// Update fetches the string from the rope and updates the `text` and `lines` in the buffer
-func (b *Buffer) Update() {
-	b.NumLines = len(b.lines)
-}
-
-// Save saves the buffer to its default path
-func (b *Buffer) Save() error {
-	return b.SaveAs(b.Path)
-}
-
-// SaveWithSudo saves the buffer to the default path with sudo
-func (b *Buffer) SaveWithSudo() error {
-	return b.SaveAsWithSudo(b.Path)
-}
-
-// 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))
-		if err == nil {
-			enc := gob.NewEncoder(file)
-			gob.Register(TextEvent{})
-			err = enc.Encode(SerializedBuffer{
-				b.EventHandler,
-				b.Cursor,
-				b.ModTime,
-			})
-		}
-		file.Close()
-		return err
-	}
-	return nil
-}
-
-// 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())
-	err := ioutil.WriteFile(filename, data, 0644)
-	if err == nil {
-		b.IsModified = false
-		b.ModTime, _ = GetModTime(filename)
-		return b.Serialize()
-	}
-	return err
-}
-
-// SaveAsWithSudo is the same as SaveAs except it uses a neat trick
-// 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
-	// It's a bit nicer for them if they don't have to enter the password every time
-	_, err := RunShellCommand("sudo -v")
-	needPassword := err != nil
-
-	// If we need the password, we have to close the screen and ask using the shell
-	if needPassword {
-		// Shut down the screen because we're going to interact directly with the shell
-		screen.Fini()
-		screen = nil
-	}
-
-	// Set up everything for the command
-	cmd := exec.Command("sudo", "tee", filename)
-	cmd.Stdin = bytes.NewBufferString(b.String())
-
-	// This is a trap for Ctrl-C so that it doesn't kill micro
-	// Instead we trap Ctrl-C to kill the program we're running
-	c := make(chan os.Signal, 1)
-	signal.Notify(c, os.Interrupt)
-	go func() {
-		for range c {
-			cmd.Process.Kill()
-		}
-	}()
-
-	// Start the command
-	cmd.Start()
-	err = cmd.Wait()
-
-	// If we needed the password, we closed the screen, so we have to initialize it again
-	if needPassword {
-		// Start the screen back up
-		InitScreen()
-	}
-	if err == nil {
-		b.IsModified = false
-		b.ModTime, _ = GetModTime(filename)
-		b.Serialize()
-	}
-	return err
-}
-
-func (b *Buffer) insert(pos Loc, value []byte) {
-	b.IsModified = true
-	b.LineArray.insert(pos, value)
-	b.Update()
-}
-func (b *Buffer) remove(start, end Loc) string {
-	b.IsModified = true
-	sub := b.LineArray.remove(start, end)
-	b.Update()
-	return sub
-}
-
-// Start returns the location of the first character in the buffer
-func (b *Buffer) Start() Loc {
-	return Loc{0, 0}
-}
-
-// 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}
-}
-
-// Line returns a single line
-func (b *Buffer) Line(n int) string {
-	return string(b.lines[n])
-}
-
-// Lines returns an array of strings containing the lines from start to end
-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))
-	}
-	return slice
-}
-
-// Len gives the length of the buffer
-func (b *Buffer) Len() int {
-	return Count(b.String())
-}

cmd/micro/command.go

@@ -1,425 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"io/ioutil"
-	"os"
-	"os/exec"
-	"os/signal"
-	"regexp"
-	"strings"
-
-	"github.com/mitchellh/go-homedir"
-)
-
-type Command struct {
-	action      func([]string)
-	completions []Completion
-}
-
-type StrCommand struct {
-	action      string
-	completions []Completion
-}
-
-var commands map[string]Command
-
-var 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,
-}
-
-// InitCommands initializes the default commands
-func InitCommands() {
-	commands = make(map[string]Command)
-
-	defaults := DefaultCommands()
-	parseCommands(defaults)
-}
-
-func parseCommands(userCommands map[string]StrCommand) {
-	for k, v := range userCommands {
-		MakeCommand(k, v.action, v.completions...)
-	}
-}
-
-// MakeCommand is a function to easily create new commands
-// This can be called by plugins in Lua so that plugins can define their own commands
-func MakeCommand(name, function string, completions ...Completion) {
-	action := commandActions[function]
-	if _, ok := commandActions[function]; !ok {
-		// If the user seems to be binding a function that doesn't exist
-		// We hope that it's a lua function that exists and bind it to that
-		action = LuaFunctionCommand(function)
-	}
-
-	commands[name] = Command{action, completions}
-}
-
-// DefaultCommands returns a map containing micro's default commands
-func DefaultCommands() map[string]StrCommand {
-	return map[string]StrCommand{
-		"set":      {"Set", []Completion{OptionCompletion, NoCompletion}},
-		"setlocal": {"SetLocal", []Completion{OptionCompletion, NoCompletion}},
-		"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}},
-	}
-}
-
-// Help tries to open the given help page in a horizontal split
-func Help(args []string) {
-	if len(args) < 1 {
-		// Open the default help if the user just typed "> help"
-		CurView().openHelp("help")
-	} else {
-		helpPage := args[0]
-		if _, ok := helpPages[helpPage]; ok {
-			CurView().openHelp(helpPage)
-		} else {
-			messenger.Error("Sorry, no help for ", helpPage)
-		}
-	}
-}
-
-// VSplit opens a vertical split with file given in the first argument
-// 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{}, ""))
-	} else {
-		filename := args[0]
-		home, _ := homedir.Dir()
-		filename = strings.Replace(filename, "~", home, 1)
-		file, err := ioutil.ReadFile(filename)
-
-		var buf *Buffer
-		if err != nil {
-			// File does not exist -- create an empty buffer with that name
-			buf = NewBuffer([]byte{}, filename)
-		} else {
-			buf = NewBuffer(file, filename)
-		}
-		CurView().VSplit(buf)
-	}
-}
-
-// HSplit opens a horizontal split with file given in the first argument
-// 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{}, ""))
-	} else {
-		filename := args[0]
-		home, _ := homedir.Dir()
-		filename = strings.Replace(filename, "~", home, 1)
-		file, err := ioutil.ReadFile(filename)
-
-		var buf *Buffer
-		if err != nil {
-			// File does not exist -- create an empty buffer with that name
-			buf = NewBuffer([]byte{}, filename)
-		} else {
-			buf = NewBuffer(file, filename)
-		}
-		CurView().HSplit(buf)
-	}
-}
-
-// NewTab opens the given file in a new tab
-func NewTab(args []string) {
-	if len(args) == 0 {
-		CurView().AddTab(true)
-	} else {
-		filename := args[0]
-		home, _ := homedir.Dir()
-		filename = strings.Replace(filename, "~", home, 1)
-		file, _ := ioutil.ReadFile(filename)
-
-		tab := NewTabFromView(NewView(NewBuffer(file, filename)))
-		tab.SetNum(len(tabs))
-		tabs = append(tabs, tab)
-		curTab++
-		if len(tabs) == 2 {
-			for _, t := range tabs {
-				for _, v := range t.views {
-					v.ToggleTabbar()
-				}
-			}
-		}
-	}
-}
-
-// 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])
-
-	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])
-
-	err := SetLocalOption(option, value, CurView())
-	if err != nil {
-		messenger.Error(err.Error())
-	}
-}
-
-// 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("Not enough arguments")
-		return
-	}
-	BindKey(args[0], args[1])
-}
-
-// 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)
-}
-
-// Quit closes the main view
-func Quit(args []string) {
-	// Close the main view
-	CurView().Quit(true)
-}
-
-// Save saves the buffer in the main view
-func Save(args []string) {
-	// Save the main view
-	CurView().Save(true)
-}
-
-// 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 {
-		// 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 {
-		// The user included some flags
-		flags = replaceCmd[2]
-	}
-
-	search := string(replaceCmd[0])
-	replace := string(replaceCmd[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)
-	if err != nil {
-		// There was an error with the user's regex
-		messenger.Error(err.Error())
-		return
-	}
-
-	view := CurView()
-
-	found := 0
-	for {
-		match := regex.FindStringIndex(view.Buf.String())
-		if match == nil {
-			break
-		}
-		found++
-		if strings.Contains(flags, "c") {
-			// The 'check' flag was used
-			Search(search, view, true)
-			view.Relocate()
-			if view.Buf.Settings["syntax"].(bool) {
-				view.matches = Match(view)
-			}
-			RedrawAll()
-			choice, canceled := messenger.YesNoPrompt("Perform replacement? (y,n)")
-			if canceled {
-				if view.Cursor.HasSelection() {
-					view.Cursor.Loc = view.Cursor.CurSelection[0]
-					view.Cursor.ResetSelection()
-				}
-				messenger.Reset()
-				return
-			}
-			if choice {
-				view.Cursor.DeleteSelection()
-				view.Buf.Insert(FromCharPos(match[0], view.Buf), replace)
-				view.Cursor.ResetSelection()
-				messenger.Reset()
-			} else {
-				if view.Cursor.HasSelection() {
-					searchStart = ToCharPos(view.Cursor.CurSelection[1], view.Buf)
-				} else {
-					searchStart = ToCharPos(view.Cursor.Loc, view.Buf)
-				}
-				continue
-			}
-		} else {
-			view.Buf.Replace(FromCharPos(match[0], view.Buf), FromCharPos(match[1], view.Buf), replace)
-		}
-	}
-	view.Cursor.Relocate()
-
-	if found > 1 {
-		messenger.Message("Replaced ", found, " occurrences of ", search)
-	} else if found == 1 {
-		messenger.Message("Replaced ", found, " occurrence of ", search)
-	} else {
-		messenger.Message("Nothing matched ", search)
-	}
-}
-
-// 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:]
-
-	cmd := exec.Command(inputCmd, args...)
-	outputBytes := &bytes.Buffer{}
-	cmd.Stdout = outputBytes
-	cmd.Stderr = outputBytes
-	cmd.Start()
-	err := cmd.Wait() // wait for command to finish
-	outstring := outputBytes.String()
-	return outstring, err
-}
-
-// HandleShellCommand runs the shell command
-// The openTerm argument specifies whether a terminal should be opened (for viewing output
-// or interacting with stdin)
-func HandleShellCommand(input string, openTerm bool) {
-	inputCmd := strings.Split(input, " ")[0]
-	if !openTerm {
-		// Simply run the command in the background and notify the user when it's done
-		messenger.Message("Running...")
-		go func() {
-			output, err := RunShellCommand(input)
-			totalLines := strings.Split(output, "\n")
-
-			if len(totalLines) < 3 {
-				if err == nil {
-					messenger.Message(inputCmd, " exited without error")
-				} else {
-					messenger.Message(inputCmd, " exited with error: ", err, ": ", output)
-				}
-			} else {
-				messenger.Message(output)
-			}
-			// We have to make sure to redraw
-			RedrawAll()
-		}()
-	} else {
-		// Shut down the screen because we're going to interact directly with the shell
-		screen.Fini()
-		screen = nil
-
-		args := strings.Split(input, " ")[1:]
-
-		// Set up everything for the command
-		cmd := exec.Command(inputCmd, args...)
-		cmd.Stdin = os.Stdin
-		cmd.Stdout = os.Stdout
-		cmd.Stderr = os.Stderr
-
-		// This is a trap for Ctrl-C so that it doesn't kill micro
-		// Instead we trap Ctrl-C to kill the program we're running
-		c := make(chan os.Signal, 1)
-		signal.Notify(c, os.Interrupt)
-		go func() {
-			for range c {
-				cmd.Process.Kill()
-			}
-		}()
-
-		// Start the command
-		cmd.Start()
-		cmd.Wait()
-
-		// 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()
-	}
-}
-
-// HandleCommand handles input from the user
-func HandleCommand(input string) {
-	inputCmd := strings.Split(input, " ")[0]
-	args := strings.Split(input, " ")[1:]
-
-	if _, ok := commands[inputCmd]; !ok {
-		messenger.Error("Unknown command ", inputCmd)
-	} else {
-		commands[inputCmd].action(args)
-	}
-}

cmd/micro/cursor.go

@@ -1,330 +0,0 @@
-package main
-
-// 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
-// uses a rope to store text, to insert text we must have an index. It
-// is also simpler to use character indicies for other tasks such as
-// selection.
-type Cursor struct {
-	buf *Buffer
-	Loc
-
-	// Last cursor x position
-	LastVisualX int
-
-	// The current selection as a range of character numbers (inclusive)
-	CurSelection [2]Loc
-	// The original selection as a range of character numbers
-	// This is used for line and word selection where it is necessary
-	// to know what the original selection was
-	OrigSelection [2]Loc
-}
-
-// Goto puts the cursor at the given cursor's location and gives the current cursor its selection too
-func (c *Cursor) Goto(b Cursor) {
-	c.X, c.Y, c.LastVisualX = b.X, b.Y, b.LastVisualX
-	c.OrigSelection, c.CurSelection = b.OrigSelection, b.CurSelection
-}
-
-// ResetSelection resets the user's selection
-func (c *Cursor) ResetSelection() {
-	c.CurSelection[0] = c.buf.Start()
-	c.CurSelection[1] = c.buf.Start()
-}
-
-// HasSelection returns whether or not the user has selected anything
-func (c *Cursor) HasSelection() bool {
-	return c.CurSelection[0] != c.CurSelection[1]
-}
-
-// DeleteSelection deletes the currently selected text
-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() == "" {
-		return
-	} else {
-		c.buf.Remove(c.CurSelection[0], c.CurSelection[1])
-		c.Loc = c.CurSelection[0]
-	}
-}
-
-// 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])
-	}
-	return c.buf.Substr(c.CurSelection[0], c.CurSelection[1])
-}
-
-// SelectLine selects the current line
-func (c *Cursor) SelectLine() {
-	c.Start()
-	c.CurSelection[0] = c.Loc
-	c.End()
-	if c.buf.NumLines-1 > c.Y {
-		c.CurSelection[1] = c.Loc.Move(1, c.buf)
-	} else {
-		c.CurSelection[1] = c.Loc
-	}
-
-	c.OrigSelection = c.CurSelection
-}
-
-// AddLineToSelection adds the current line to the selection
-func (c *Cursor) AddLineToSelection() {
-	if c.Loc.LessThan(c.OrigSelection[0]) {
-		c.Start()
-		c.CurSelection[0] = c.Loc
-		c.CurSelection[1] = 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]
-	}
-
-	if c.Loc.LessThan(c.OrigSelection[1]) && c.Loc.GreaterThan(c.OrigSelection[0]) {
-		c.CurSelection = c.OrigSelection
-	}
-}
-
-// SelectWord selects the word the cursor is currently on
-func (c *Cursor) SelectWord() {
-	if len(c.buf.Line(c.Y)) == 0 {
-		return
-	}
-
-	if !IsWordChar(string(c.RuneUnder(c.X))) {
-		c.CurSelection[0] = c.Loc
-		c.CurSelection[1] = c.Loc.Move(1, c.buf)
-		c.OrigSelection = c.CurSelection
-		return
-	}
-
-	forward, backward := c.X, c.X
-
-	for backward > 0 && IsWordChar(string(c.RuneUnder(backward-1))) {
-		backward--
-	}
-
-	c.CurSelection[0] = 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.OrigSelection[1] = c.CurSelection[1]
-	c.Loc = c.CurSelection[1]
-}
-
-// AddWordToSelection adds the word the cursor is currently on to the selection
-func (c *Cursor) AddWordToSelection() {
-	if c.Loc.GreaterThan(c.OrigSelection[0]) && c.Loc.LessThan(c.OrigSelection[1]) {
-		c.CurSelection = c.OrigSelection
-		return
-	}
-
-	if c.Loc.LessThan(c.OrigSelection[0]) {
-		backward := c.X
-
-		for backward > 0 && IsWordChar(string(c.RuneUnder(backward-1))) {
-			backward--
-		}
-
-		c.CurSelection[0] = Loc{backward, c.Y}
-		c.CurSelection[1] = c.OrigSelection[1]
-	}
-
-	if c.Loc.GreaterThan(c.OrigSelection[1]) {
-		forward := c.X
-
-		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.CurSelection[0] = c.OrigSelection[0]
-	}
-
-	c.Loc = c.CurSelection[1]
-}
-
-// 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
-	} else {
-		c.CurSelection[0] = loc
-		c.CurSelection[1] = c.OrigSelection[0]
-	}
-}
-
-// WordRight moves the cursor one word to the right
-func (c *Cursor) WordRight() {
-	for IsWhitespace(c.RuneUnder(c.X)) {
-		if c.X == Count(c.buf.Line(c.Y)) {
-			c.Right()
-			return
-		}
-		c.Right()
-	}
-	c.Right()
-	for IsWordChar(string(c.RuneUnder(c.X))) {
-		if c.X == Count(c.buf.Line(c.Y)) {
-			return
-		}
-		c.Right()
-	}
-}
-
-// WordLeft moves the cursor one word to the left
-func (c *Cursor) WordLeft() {
-	c.Left()
-	for IsWhitespace(c.RuneUnder(c.X)) {
-		if c.X == 0 {
-			return
-		}
-		c.Left()
-	}
-	c.Left()
-	for IsWordChar(string(c.RuneUnder(c.X))) {
-		if c.X == 0 {
-			return
-		}
-		c.Left()
-	}
-	c.Right()
-}
-
-// RuneUnder returns the rune under the given x position
-func (c *Cursor) RuneUnder(x int) rune {
-	line := []rune(c.buf.Line(c.Y))
-	if len(line) == 0 {
-		return '\n'
-	}
-	if x >= len(line) {
-		return '\n'
-	} else if x < 0 {
-		x = 0
-	}
-	return line[x]
-}
-
-// UpN moves the cursor up N lines (if possible)
-func (c *Cursor) UpN(amount int) {
-	proposedY := c.Y - amount
-	if proposedY < 0 {
-		proposedY = 0
-	} else if proposedY >= c.buf.NumLines {
-		proposedY = c.buf.NumLines - 1
-	}
-	if proposedY == c.Y {
-		return
-	}
-
-	c.Y = proposedY
-	runes := []rune(c.buf.Line(c.Y))
-	c.X = c.GetCharPosInLine(c.Y, c.LastVisualX)
-	if c.X > len(runes) {
-		c.X = len(runes)
-	}
-}
-
-// DownN moves the cursor down N lines (if possible)
-func (c *Cursor) DownN(amount int) {
-	c.UpN(-amount)
-}
-
-// Up moves the cursor up one line (if possible)
-func (c *Cursor) Up() {
-	c.UpN(1)
-}
-
-// Down moves the cursor down one line (if possible)
-func (c *Cursor) Down() {
-	c.DownN(1)
-}
-
-// Left moves the cursor left one cell (if possible) or to the last line if it is at the beginning
-func (c *Cursor) Left() {
-	if c.Loc == c.buf.Start() {
-		return
-	}
-	if c.X > 0 {
-		c.X--
-	} else {
-		c.Up()
-		c.End()
-	}
-	c.LastVisualX = c.GetVisualX()
-}
-
-// Right moves the cursor right one cell (if possible) or to the next line if it is at the end
-func (c *Cursor) Right() {
-	if c.Loc == c.buf.End() {
-		return
-	}
-	if c.X < Count(c.buf.Line(c.Y)) {
-		c.X++
-	} else {
-		c.Down()
-		c.Start()
-	}
-	c.LastVisualX = c.GetVisualX()
-}
-
-// End moves the cursor to the end of the line it is on
-func (c *Cursor) End() {
-	c.X = Count(c.buf.Line(c.Y))
-	c.LastVisualX = c.GetVisualX()
-}
-
-// Start moves the cursor to the start of the line it is on
-func (c *Cursor) Start() {
-	c.X = 0
-	c.LastVisualX = c.GetVisualX()
-}
-
-// GetCharPosInLine gets the char position of a visual x y coordinate (this is necessary because tabs are 1 char but 4 visual spaces)
-func (c *Cursor) GetCharPosInLine(lineNum, visualPos int) int {
-	// Get the tab size
-	tabSize := int(c.buf.Settings["tabsize"].(float64))
-	visualLineLen := StringWidth(c.buf.Line(lineNum), tabSize)
-	if visualPos > visualLineLen {
-		visualPos = visualLineLen
-	}
-	width := WidthOfLargeRunes(c.buf.Line(lineNum), tabSize)
-	if visualPos >= width {
-		return visualPos - width
-	}
-	return visualPos / tabSize
-}
-
-// GetVisualX returns the x value of the cursor in visual spaces
-func (c *Cursor) GetVisualX() int {
-	runes := []rune(c.buf.Line(c.Y))
-	tabSize := int(c.buf.Settings["tabsize"].(float64))
-	return StringWidth(string(runes[:c.X]), tabSize)
-}
-
-// Relocate makes sure that the cursor is inside the bounds of the buffer
-// If it isn't, it moves it to be within the buffer's lines
-func (c *Cursor) Relocate() {
-	if c.Y < 0 {
-		c.Y = 0
-	} else if c.Y >= c.buf.NumLines {
-		c.Y = c.buf.NumLines - 1
-	}
-
-	if c.X < 0 {
-		c.X = 0
-	} else if c.X > Count(c.buf.Line(c.Y)) {
-		c.X = Count(c.buf.Line(c.Y))
-	}
-}

cmd/micro/debug.go

@@ -0,0 +1,31 @@
+package main
+
+import (
+	"log"
+	"os"
+
+	"github.com/zyedidia/micro/internal/util"
+)
+
+// NullWriter simply sends writes into the void
+type NullWriter struct{}
+
+// Write is empty
+func (NullWriter) Write(data []byte) (n int, err error) {
+	return 0, nil
+}
+
+// InitLog sets up the debug log system for micro if it has been enabled by compile-time variables
+func InitLog() {
+	if util.Debug == "ON" {
+		f, err := os.OpenFile("log.txt", os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0666)
+		if err != nil {
+			log.Fatalf("error opening file: %v", err)
+		}
+
+		log.SetOutput(f)
+		log.Println("Micro started")
+	} else {
+		log.SetOutput(NullWriter{})
+	}
+}

cmd/micro/eventhandler.go

@@ -1,208 +0,0 @@
-package main
-
-import (
-	"time"
-
-	dmp "github.com/sergi/go-diff/diffmatchpatch"
-)
-
-const (
-	// Opposite and undoing events must have opposite values
-
-	// TextEventInsert repreasents an insertion event
-	TextEventInsert = 1
-	// TextEventRemove represents a deletion event
-	TextEventRemove = -1
-)
-
-// TextEvent holds data for a manipulation on some text that can be undone
-type TextEvent struct {
-	C Cursor
-
-	EventType int
-	Text      string
-	Start     Loc
-	End       Loc
-	Time      time.Time
-}
-
-// ExecuteTextEvent runs a text event
-func ExecuteTextEvent(t *TextEvent, buf *Buffer) {
-	if t.EventType == TextEventInsert {
-		buf.insert(t.Start, []byte(t.Text))
-	} else if t.EventType == TextEventRemove {
-		t.Text = buf.remove(t.Start, t.End)
-	}
-}
-
-// UndoTextEvent undoes a text event
-func UndoTextEvent(t *TextEvent, buf *Buffer) {
-	t.EventType = -t.EventType
-	ExecuteTextEvent(t, buf)
-}
-
-// EventHandler executes text manipulations and allows undoing and redoing
-type EventHandler struct {
-	buf       *Buffer
-	UndoStack *Stack
-	RedoStack *Stack
-}
-
-// NewEventHandler returns a new EventHandler
-func NewEventHandler(buf *Buffer) *EventHandler {
-	eh := new(EventHandler)
-	eh.UndoStack = new(Stack)
-	eh.RedoStack = new(Stack)
-	eh.buf = buf
-	return eh
-}
-
-// ApplyDiff takes a string and runs the necessary insertion and deletion events to make
-// the buffer equal to that string
-// This means that we can transform the buffer into any string and still preserve undo/redo
-// through insert and delete events
-func (eh *EventHandler) ApplyDiff(new string) {
-	differ := dmp.New()
-	diff := differ.DiffMain(eh.buf.String(), new, false)
-	loc := eh.buf.Start()
-	for _, d := range diff {
-		if d.Type == dmp.DiffDelete {
-			eh.Remove(loc, loc.Move(Count(d.Text), eh.buf))
-		} else {
-			if d.Type == dmp.DiffInsert {
-				eh.Insert(loc, d.Text)
-			}
-			loc = loc.Move(Count(d.Text), eh.buf)
-		}
-	}
-}
-
-// Insert creates an insert text event and executes it
-func (eh *EventHandler) Insert(start Loc, text string) {
-	e := &TextEvent{
-		C:         eh.buf.Cursor,
-		EventType: TextEventInsert,
-		Text:      text,
-		Start:     start,
-		Time:      time.Now(),
-	}
-	eh.Execute(e)
-	e.End = start.Move(Count(text), eh.buf)
-}
-
-// Remove creates a remove text event and executes it
-func (eh *EventHandler) Remove(start, end Loc) {
-	e := &TextEvent{
-		C:         eh.buf.Cursor,
-		EventType: TextEventRemove,
-		Start:     start,
-		End:       end,
-		Time:      time.Now(),
-	}
-	eh.Execute(e)
-}
-
-// Replace deletes from start to end and replaces it with the given string
-func (eh *EventHandler) Replace(start, end Loc, replace string) {
-	eh.Remove(start, end)
-	eh.Insert(start, replace)
-}
-
-// Execute a textevent and add it to the undo stack
-func (eh *EventHandler) Execute(t *TextEvent) {
-	if eh.RedoStack.Len() > 0 {
-		eh.RedoStack = new(Stack)
-	}
-	eh.UndoStack.Push(t)
-	ExecuteTextEvent(t, eh.buf)
-}
-
-// Undo the first event in the undo stack
-func (eh *EventHandler) Undo() {
-	t := eh.UndoStack.Peek()
-	if t == nil {
-		return
-	}
-
-	startTime := t.Time.UnixNano() / int64(time.Millisecond)
-
-	eh.UndoOneEvent()
-
-	for {
-		t = eh.UndoStack.Peek()
-		if t == nil {
-			return
-		}
-
-		if startTime-(t.Time.UnixNano()/int64(time.Millisecond)) > undoThreshold {
-			return
-		}
-		startTime = t.Time.UnixNano() / int64(time.Millisecond)
-
-		eh.UndoOneEvent()
-	}
-}
-
-// UndoOneEvent undoes one event
-func (eh *EventHandler) UndoOneEvent() {
-	// This event should be undone
-	// Pop it off the stack
-	t := eh.UndoStack.Pop()
-	if t == nil {
-		return
-	}
-
-	// Undo it
-	// Modifies the text event
-	UndoTextEvent(t, eh.buf)
-
-	// Set the cursor in the right place
-	teCursor := t.C
-	t.C = eh.buf.Cursor
-	eh.buf.Cursor.Goto(teCursor)
-
-	// Push it to the redo stack
-	eh.RedoStack.Push(t)
-}
-
-// Redo the first event in the redo stack
-func (eh *EventHandler) Redo() {
-	t := eh.RedoStack.Peek()
-	if t == nil {
-		return
-	}
-
-	startTime := t.Time.UnixNano() / int64(time.Millisecond)
-
-	eh.RedoOneEvent()
-
-	for {
-		t = eh.RedoStack.Peek()
-		if t == nil {
-			return
-		}
-
-		if (t.Time.UnixNano()/int64(time.Millisecond))-startTime > undoThreshold {
-			return
-		}
-
-		eh.RedoOneEvent()
-	}
-}
-
-// RedoOneEvent redoes one event
-func (eh *EventHandler) RedoOneEvent() {
-	t := eh.RedoStack.Pop()
-	if t == nil {
-		return
-	}
-
-	// Modifies the text event
-	UndoTextEvent(t, eh.buf)
-
-	teCursor := t.C
-	t.C = eh.buf.Cursor
-	eh.buf.Cursor.Goto(teCursor)
-
-	eh.UndoStack.Push(t)
-}

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/highlighter.go

@@ -1,495 +0,0 @@
-package main
-
-import (
-	"github.com/zyedidia/tcell"
-	"io/ioutil"
-	"path/filepath"
-	"regexp"
-	"strings"
-)
-
-// FileTypeRules represents a complete set of syntax rules for a filetype
-type FileTypeRules struct {
-	filetype string
-	filename string
-	text     string
-}
-
-// 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
-						}
-					}
-				}
-			}
-		} 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)
-						for i := start; i < end; i++ {
-							matches[lineN][i] = rule.style
-						}
-					}
-				}
-			}
-		}
-	}
-
-	return matches
-}

cmd/micro/initlua.go

@@ -0,0 +1,129 @@
+package main
+
+import (
+	"log"
+
+	lua "github.com/yuin/gopher-lua"
+	luar "layeh.com/gopher-luar"
+
+	"github.com/zyedidia/micro/internal/action"
+	"github.com/zyedidia/micro/internal/buffer"
+	"github.com/zyedidia/micro/internal/config"
+	"github.com/zyedidia/micro/internal/display"
+	ulua "github.com/zyedidia/micro/internal/lua"
+	"github.com/zyedidia/micro/internal/screen"
+	"github.com/zyedidia/micro/internal/shell"
+	"github.com/zyedidia/micro/internal/util"
+)
+
+func init() {
+	ulua.L = lua.NewState()
+	ulua.L.SetGlobal("import", luar.New(ulua.L, LuaImport))
+}
+
+func LuaImport(pkg string) *lua.LTable {
+	switch pkg {
+	case "micro":
+		return luaImportMicro()
+	case "micro/shell":
+		return luaImportMicroShell()
+	case "micro/buffer":
+		return luaImportMicroBuffer()
+	case "micro/config":
+		return luaImportMicroConfig()
+	case "micro/util":
+		return luaImportMicroUtil()
+	default:
+		return ulua.Import(pkg)
+	}
+}
+
+func luaImportMicro() *lua.LTable {
+	pkg := ulua.L.NewTable()
+
+	ulua.L.SetField(pkg, "TermMessage", luar.New(ulua.L, screen.TermMessage))
+	ulua.L.SetField(pkg, "TermError", luar.New(ulua.L, screen.TermError))
+	ulua.L.SetField(pkg, "InfoBar", luar.New(ulua.L, action.GetInfoBar))
+	ulua.L.SetField(pkg, "Log", luar.New(ulua.L, log.Println))
+	ulua.L.SetField(pkg, "SetStatusInfoFn", luar.New(ulua.L, display.SetStatusInfoFnLua))
+
+	return pkg
+}
+
+func luaImportMicroConfig() *lua.LTable {
+	pkg := ulua.L.NewTable()
+
+	ulua.L.SetField(pkg, "MakeCommand", luar.New(ulua.L, action.LuaMakeCommand))
+	ulua.L.SetField(pkg, "FileComplete", luar.New(ulua.L, buffer.FileComplete))
+	ulua.L.SetField(pkg, "HelpComplete", luar.New(ulua.L, action.HelpComplete))
+	ulua.L.SetField(pkg, "OptionComplete", luar.New(ulua.L, action.OptionComplete))
+	ulua.L.SetField(pkg, "OptionValueComplete", luar.New(ulua.L, action.OptionValueComplete))
+	ulua.L.SetField(pkg, "NoComplete", luar.New(ulua.L, nil))
+	ulua.L.SetField(pkg, "TryBindKey", luar.New(ulua.L, action.TryBindKey))
+	ulua.L.SetField(pkg, "Reload", luar.New(ulua.L, action.ReloadConfig))
+	ulua.L.SetField(pkg, "AddRuntimeFileFromMemory", luar.New(ulua.L, config.PluginAddRuntimeFileFromMemory))
+	ulua.L.SetField(pkg, "AddRuntimeFilesFromDirectory", luar.New(ulua.L, config.PluginAddRuntimeFileFromMemory))
+	ulua.L.SetField(pkg, "AddRuntimeFile", luar.New(ulua.L, config.PluginAddRuntimeFile))
+	ulua.L.SetField(pkg, "ListRuntimeFiles", luar.New(ulua.L, config.PluginListRuntimeFiles))
+	ulua.L.SetField(pkg, "ReadRuntimeFile", luar.New(ulua.L, config.PluginReadRuntimeFile))
+	ulua.L.SetField(pkg, "RTColorscheme", luar.New(ulua.L, config.RTColorscheme))
+	ulua.L.SetField(pkg, "RTSyntax", luar.New(ulua.L, config.RTSyntax))
+	ulua.L.SetField(pkg, "RTHelp", luar.New(ulua.L, config.RTHelp))
+	ulua.L.SetField(pkg, "RTPlugin", luar.New(ulua.L, config.RTPlugin))
+	ulua.L.SetField(pkg, "RegisterCommonOption", luar.New(ulua.L, config.RegisterCommonOption))
+	ulua.L.SetField(pkg, "RegisterGlobalOption", luar.New(ulua.L, config.RegisterGlobalOption))
+
+	return pkg
+}
+
+func luaImportMicroShell() *lua.LTable {
+	pkg := ulua.L.NewTable()
+
+	ulua.L.SetField(pkg, "ExecCommand", luar.New(ulua.L, shell.ExecCommand))
+	ulua.L.SetField(pkg, "RunCommand", luar.New(ulua.L, shell.RunCommand))
+	ulua.L.SetField(pkg, "RunBackgroundShell", luar.New(ulua.L, shell.RunBackgroundShell))
+	ulua.L.SetField(pkg, "RunInteractiveShell", luar.New(ulua.L, shell.RunInteractiveShell))
+	ulua.L.SetField(pkg, "JobStart", luar.New(ulua.L, shell.JobStart))
+	ulua.L.SetField(pkg, "JobSpawn", luar.New(ulua.L, shell.JobSpawn))
+	ulua.L.SetField(pkg, "JobStop", luar.New(ulua.L, shell.JobStop))
+	ulua.L.SetField(pkg, "JobSend", luar.New(ulua.L, shell.JobSend))
+	ulua.L.SetField(pkg, "RunTermEmulator", luar.New(ulua.L, action.RunTermEmulator))
+	ulua.L.SetField(pkg, "TermEmuSupported", luar.New(ulua.L, action.TermEmuSupported))
+
+	return pkg
+}
+
+func luaImportMicroBuffer() *lua.LTable {
+	pkg := ulua.L.NewTable()
+
+	ulua.L.SetField(pkg, "NewMessage", luar.New(ulua.L, buffer.NewMessage))
+	ulua.L.SetField(pkg, "NewMessageAtLine", luar.New(ulua.L, buffer.NewMessageAtLine))
+	ulua.L.SetField(pkg, "MTInfo", luar.New(ulua.L, buffer.MTInfo))
+	ulua.L.SetField(pkg, "MTWarning", luar.New(ulua.L, buffer.MTWarning))
+	ulua.L.SetField(pkg, "MTError", luar.New(ulua.L, buffer.MTError))
+	ulua.L.SetField(pkg, "Loc", luar.New(ulua.L, func(x, y int) buffer.Loc {
+		return buffer.Loc{x, y}
+	}))
+	ulua.L.SetField(pkg, "BTDefault", luar.New(ulua.L, buffer.BTDefault.Kind))
+	ulua.L.SetField(pkg, "BTHelp", luar.New(ulua.L, buffer.BTHelp.Kind))
+	ulua.L.SetField(pkg, "BTLog", luar.New(ulua.L, buffer.BTLog.Kind))
+	ulua.L.SetField(pkg, "BTScratch", luar.New(ulua.L, buffer.BTScratch.Kind))
+	ulua.L.SetField(pkg, "BTRaw", luar.New(ulua.L, buffer.BTRaw.Kind))
+	ulua.L.SetField(pkg, "BTInfo", luar.New(ulua.L, buffer.BTInfo.Kind))
+	ulua.L.SetField(pkg, "NewBufferFromFile", luar.New(ulua.L, func(path string) (*buffer.Buffer, error) {
+		return buffer.NewBufferFromFile(path, buffer.BTDefault)
+	}))
+	ulua.L.SetField(pkg, "ByteOffset", luar.New(ulua.L, buffer.ByteOffset))
+
+	return pkg
+}
+
+func luaImportMicroUtil() *lua.LTable {
+	pkg := ulua.L.NewTable()
+
+	ulua.L.SetField(pkg, "RuneAt", luar.New(ulua.L, util.LuaRuneAt))
+	ulua.L.SetField(pkg, "GetLeadingWhitespace", luar.New(ulua.L, util.LuaGetLeadingWhitespace))
+	ulua.L.SetField(pkg, "IsWordChar", luar.New(ulua.L, util.LuaIsWordChar))
+
+	return pkg
+}

cmd/micro/job.go

@@ -1,87 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"io"
-	"os/exec"
-	"strings"
-)
-
-// Jobs are the way plugins can run processes in the background
-// A job is simply a process that gets executed asynchronously
-// There are callbacks for when the job exits, when the job creates stdout
-// and when the job creates stderr
-
-// These jobs run in a separate goroutine but the lua callbacks need to be
-// executed in the main thread (where the Lua VM is running) so they are
-// put into the jobs channel which gets read by the main loop
-
-// JobFunction is a representation of a job (this data structure is what is loaded
-// into the jobs channel)
-type JobFunction struct {
-	function func(string, ...string)
-	output   string
-	args     []string
-}
-
-// A CallbackFile is the data structure that makes it possible to catch stderr and stdout write events
-type CallbackFile struct {
-	io.Writer
-
-	callback func(string, ...string)
-	args     []string
-}
-
-func (f *CallbackFile) Write(data []byte) (int, error) {
-	// This is either stderr or stdout
-	// In either case we create a new job function callback and put it in the jobs channel
-	jobFunc := JobFunction{f.callback, string(data), f.args}
-	jobs <- jobFunc
-	return f.Writer.Write(data)
-}
-
-// JobStart starts a process 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]
-
-	// Set up everything correctly if the functions have been provided
-	proc := exec.Command(cmdName, args...)
-	var outbuf bytes.Buffer
-	if onStdout != "" {
-		proc.Stdout = &CallbackFile{&outbuf, LuaFunctionJob(onStdout), userargs}
-	} else {
-		proc.Stdout = &outbuf
-	}
-	if onStderr != "" {
-		proc.Stderr = &CallbackFile{&outbuf, LuaFunctionJob(onStderr), userargs}
-	} else {
-		proc.Stderr = &outbuf
-	}
-
-	go func() {
-		// Run the process in the background and create the onExit callback
-		proc.Run()
-		jobFunc := JobFunction{LuaFunctionJob(onExit), string(outbuf.Bytes()), userargs}
-		jobs <- jobFunc
-	}()
-
-	return proc
-}
-
-// JobStop kills a job
-func JobStop(cmd *exec.Cmd) {
-	cmd.Process.Kill()
-}
-
-// JobSend sends the given data into the job's stdin stream
-func JobSend(cmd *exec.Cmd, data string) {
-	stdin, err := cmd.StdinPipe()
-	if err != nil {
-		return
-	}
-
-	stdin.Write([]byte(data))
-}

cmd/micro/lineArray.go

@@ -1,149 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"unicode/utf8"
-)
-
-func runeToByteIndex(n int, txt []byte) int {
-	if n == 0 {
-		return 0
-	}
-
-	count := 0
-	i := 0
-	for len(txt) > 0 {
-		_, size := utf8.DecodeRune(txt)
-
-		txt = txt[size:]
-		count += size
-		i++
-
-		if i == n {
-			break
-		}
-	}
-	return count
-}
-
-// A LineArray simply stores and array of lines and makes it easy to insert
-// and delete in it
-type LineArray struct {
-	lines [][]byte
-}
-
-// NewLineArray returns a new line array from an array of bytes
-func NewLineArray(text []byte) *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])
-	}
-
-	return la
-}
-
-// Returns the String representation of the LineArray
-func (la *LineArray) String() string {
-	return string(bytes.Join(la.lines, []byte("\n")))
-}
-
-// NewlineBelow adds a newline below the given line number
-func (la *LineArray) NewlineBelow(y int) {
-	la.lines = append(la.lines, []byte(" "))
-	copy(la.lines[y+2:], la.lines[y+1:])
-	la.lines[y+1] = []byte("")
-}
-
-// 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 := pos.x, pos.y
-	for i := 0; i < len(value); i++ {
-		if value[i] == '\n' {
-			la.Split(Loc{x, y})
-			x = 0
-			y++
-			continue
-		}
-		la.insertByte(Loc{x, y}, value[i])
-		x++
-	}
-}
-
-// 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
-}
-
-// 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.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.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])
-	if start.Y == end.Y {
-		la.lines[start.Y] = append(la.lines[start.Y][:startX], la.lines[start.Y][endX:]...)
-	} else {
-		for i := start.Y + 1; i <= end.Y-1; i++ {
-			la.DeleteLine(start.Y + 1)
-		}
-		la.DeleteToEnd(Loc{startX, start.Y})
-		la.DeleteFromStart(Loc{endX - 1, start.Y + 1})
-		la.JoinLines(start.Y, start.Y+1)
-	}
-	return sub
-}
-
-// 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]
-}
-
-// 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:]
-}
-
-// DeleteLine deletes the line number
-func (la *LineArray) DeleteLine(y int) {
-	la.lines = la.lines[:y+copy(la.lines[y:], la.lines[y+1:])]
-}
-
-// 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:])]
-}
-
-// 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])
-	if start.Y == end.Y {
-		return string(la.lines[start.Y][startX:endX])
-	}
-	var str string
-	str += string(la.lines[start.Y][startX:]) + "\n"
-	for i := start.Y + 1; i <= end.Y-1; i++ {
-		str += string(la.lines[i]) + "\n"
-	}
-	str += string(la.lines[end.Y][:endX])
-	return str
-}

cmd/micro/messenger.go

@@ -1,376 +0,0 @@
-package main
-
-import (
-	"bufio"
-	"bytes"
-	"fmt"
-	"os"
-	"strconv"
-	"strings"
-
-	"github.com/zyedidia/clipboard"
-	"github.com/zyedidia/tcell"
-)
-
-// TermMessage sends a message to the user in the terminal. This usually occurs before
-// micro has been fully initialized -- ie if there is an error in the syntax highlighting
-// regular expressions
-// The function must be called when the screen is not initialized
-// This will write the message, and wait for the user
-// to press and key to continue
-func TermMessage(msg ...interface{}) {
-	screenWasNil := screen == nil
-	if !screenWasNil {
-		screen.Fini()
-	}
-
-	fmt.Println(msg...)
-	fmt.Print("\nPress enter to continue")
-
-	reader := bufio.NewReader(os.Stdin)
-	reader.ReadString('\n')
-
-	if !screenWasNil {
-		InitScreen()
-	}
-}
-
-// TermError sends an error to the user in the terminal. Like TermMessage except formatted
-// as an error
-func TermError(filename string, lineNum int, err string) {
-	TermMessage(filename + ", " + strconv.Itoa(lineNum) + ": " + err)
-}
-
-// Messenger is an object that makes it easy to send messages to the user
-// and get input from the user
-type Messenger struct {
-	// Are we currently prompting the user?
-	hasPrompt bool
-	// Is there a message to print
-	hasMessage bool
-
-	// Message to print
-	message string
-	// The user's response to a prompt
-	response string
-	// style to use when drawing the message
-	style tcell.Style
-
-	// We have to keep track of the cursor for prompting
-	cursorx int
-
-	// This map stores the history for all the different kinds of uses Prompt has
-	// It's a map of history type -> history array
-	history    map[string][]string
-	historyNum int
-
-	// Is the current message a message from the gutter
-	gutterMessage bool
-}
-
-// 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
-
-	if _, ok := colorscheme["message"]; ok {
-		m.style = colorscheme["message"]
-	}
-	m.hasMessage = true
-}
-
-// 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"]
-	}
-	m.hasMessage = true
-}
-
-// 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)
-
-	_, 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:
-				if e.Rune() == 'y' {
-					return true, false
-				} else if e.Rune() == 'n' {
-					return false, false
-				}
-			case tcell.KeyCtrlC, tcell.KeyCtrlQ, tcell.KeyEscape:
-				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.Message(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.Reset()
-						return r, false
-					}
-				}
-			case tcell.KeyCtrlC, tcell.KeyCtrlQ, tcell.KeyEscape:
-				return ' ', true
-			}
-		}
-	}
-}
-
-type Completion int
-
-const (
-	NoCompletion Completion = iota
-	FileCompletion
-	CommandCompletion
-	HelpCompletion
-	OptionCompletion
-)
-
-// 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) {
-	m.hasPrompt = true
-	m.Message(prompt)
-	if _, ok := m.history[historyType]; !ok {
-		m.history[historyType] = []string{""}
-	} else {
-		m.history[historyType] = append(m.history[historyType], "")
-	}
-	m.historyNum = len(m.history[historyType]) - 1
-
-	response, canceled := "", true
-
-	RedrawAll()
-	for m.hasPrompt {
-		var suggestions []string
-		m.Clear()
-
-		event := <-events
-
-		switch e := event.(type) {
-		case *tcell.EventKey:
-			switch e.Key() {
-			case tcell.KeyCtrlQ, tcell.KeyCtrlC, tcell.KeyEscape:
-				// Cancel
-				m.hasPrompt = false
-			case tcell.KeyEnter:
-				// User is done entering their 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, " ")
-				currentArgNum := len(args) - 1
-				currentArg := args[currentArgNum]
-				var completionType Completion
-
-				if completionTypes[0] == CommandCompletion && currentArgNum > 0 {
-					if command, ok := commands[args[0]]; ok {
-						completionTypes = append([]Completion{CommandCompletion}, command.completions...)
-					}
-				}
-
-				if currentArgNum >= len(completionTypes) {
-					completionType = completionTypes[len(completionTypes)-1]
-				} else {
-					completionType = completionTypes[currentArgNum]
-				}
-
-				var chosen string
-				if completionType == FileCompletion {
-					chosen, suggestions = FileComplete(currentArg)
-				} else if completionType == CommandCompletion {
-					chosen, suggestions = CommandComplete(currentArg)
-				} else if completionType == HelpCompletion {
-					chosen, suggestions = HelpComplete(currentArg)
-				} else if completionType == OptionCompletion {
-					chosen, suggestions = OptionComplete(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.cursorx = Count(m.response)
-				}
-			}
-		}
-
-		m.HandleEvent(event, m.history[historyType])
-
-		messenger.Clear()
-		for _, v := range tabs[curTab].views {
-			v.Display()
-		}
-		DisplayTabs()
-		messenger.Display()
-		if len(suggestions) > 1 {
-			m.DisplaySuggestions(suggestions)
-		}
-		screen.Show()
-	}
-
-	m.Reset()
-	return response, canceled
-}
-
-// HandleEvent handles an event for the prompter
-func (m *Messenger) HandleEvent(event tcell.Event, history []string) {
-	switch e := event.(type) {
-	case *tcell.EventKey:
-		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++
-		}
-		history[m.historyNum] = m.response
-
-	case *tcell.EventPaste:
-		clip := e.Text()
-		m.response = Insert(m.response, m.cursorx, clip)
-		m.cursorx += Count(clip)
-	}
-}
-
-// Reset resets the messenger's cursor, message and response
-func (m *Messenger) Reset() {
-	m.cursorx = 0
-	m.message = ""
-	m.response = ""
-}
-
-// Clear clears the line at the bottom of the editor
-func (m *Messenger) Clear() {
-	w, h := screen.Size()
-	for x := 0; x < w; x++ {
-		screen.SetContent(x, h-1, ' ', nil, defStyle)
-	}
-}
-
-func (m *Messenger) DisplaySuggestions(suggestions []string) {
-	w, screenH := screen.Size()
-
-	y := screenH - 2
-
-	statusLineStyle := defStyle.Reverse(true)
-	if style, ok := colorscheme["statusline"]; ok {
-		statusLineStyle = style
-	}
-
-	for x := 0; x < w; x++ {
-		screen.SetContent(x, y, ' ', nil, statusLineStyle)
-	}
-
-	x := 0
-	for _, suggestion := range suggestions {
-		for _, c := range suggestion {
-			screen.SetContent(x, y, c, nil, statusLineStyle)
-			x++
-		}
-		screen.SetContent(x, y, ' ', nil, statusLineStyle)
-		x++
-	}
-}
-
-// Display displays messages or prompts
-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 {
-		screen.ShowCursor(Count(m.message)+m.cursorx, h-1)
-		screen.Show()
-	}
-}
-
-// A GutterMessage is a message displayed on the side of the editor
-type GutterMessage struct {
-	lineNum int
-	msg     string
-	kind    int
-}
-
-// These are the different types of messages
-const (
-	// GutterInfo represents a simple info message
-	GutterInfo = iota
-	// GutterWarning represents a compiler warning
-	GutterWarning
-	// GutterError represents a compiler error
-	GutterError
-)

cmd/micro/micro.go

@@ -5,70 +5,90 @@ import (
 	"fmt"
 	"io/ioutil"
 	"os"
-	"runtime"
-	"strings"
+	"sort"
 
 	"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"
+	isatty "github.com/mattn/go-isatty"
+	"github.com/zyedidia/micro/internal/action"
+	"github.com/zyedidia/micro/internal/buffer"
+	"github.com/zyedidia/micro/internal/config"
+	"github.com/zyedidia/micro/internal/screen"
+	"github.com/zyedidia/micro/internal/shell"
+	"github.com/zyedidia/micro/internal/util"
 	"github.com/zyedidia/tcell"
-	"github.com/zyedidia/tcell/encoding"
-)
-
-const (
-	synLinesUp           = 75  // How many lines up to look to do syntax highlighting
-	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
 )
 
 var (
-	// The main screen
-	screen tcell.Screen
-
-	// Object to send messages and prompts to the user
-	messenger *Messenger
-
-	// The default highlighting style
-	// This simply defines the default foreground and background colors
-	defStyle tcell.Style
-
-	// Where the user's configuration is
-	// This should be $XDG_CONFIG_HOME/micro
-	// If $XDG_CONFIG_HOME is not set, it is ~/.config/micro
-	configDir string
-
-	// Version is the version number or commit hash
-	// These variables should be set by the linker when compiling
-	Version     = "Unknown"
-	CommitHash  = "Unknown"
-	CompileDate = "Unknown"
-
-	// L is the lua state
-	// This is the VM that runs the plugins
-	L *lua.LState
-
-	// The list of views
-	tabs []*Tab
-	// This is the currently open tab
-	// It's just an index to the tab in the tabs array
-	curTab int
-
-	// Channel of jobs running in the background
-	jobs chan JobFunction
 	// Event channel
-	events chan tcell.Event
+	events   chan tcell.Event
+	autosave chan bool
+
+	// Command line flags
+	flagVersion   = flag.Bool("version", false, "Show the version number and information")
+	flagConfigDir = flag.String("config-dir", "", "Specify a custom location for the configuration directory")
+	flagOptions   = flag.Bool("options", false, "Show all option help")
+	optionFlags   map[string]*string
 )
 
+func InitFlags() {
+	flag.Usage = func() {
+		fmt.Println("Usage: micro [OPTIONS] [FILE]...")
+		fmt.Println("-config-dir dir")
+		fmt.Println("    \tSpecify a custom location for the configuration directory")
+		fmt.Println("[FILE]:LINE:COL")
+		fmt.Println("    \tSpecify a line and column to start the cursor at when opening a buffer")
+		fmt.Println("    \tThis can also be done by opening file:LINE:COL")
+		fmt.Println("-options")
+		fmt.Println("    \tShow all option help")
+		fmt.Println("-version")
+		fmt.Println("    \tShow the version number and information")
+
+		fmt.Print("\nMicro's options can also be set via command line arguments for quick\nadjustments. For real configuration, please use the settings.json\nfile (see 'help options').\n\n")
+		fmt.Println("-option value")
+		fmt.Println("    \tSet `option` to `value` for this session")
+		fmt.Println("    \tFor example: `micro -syntax off file.c`")
+		fmt.Println("\nUse `micro -options` to see the full list of configuration options")
+	}
+
+	optionFlags = make(map[string]*string)
+
+	for k, v := range config.DefaultAllSettings() {
+		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("Version:", util.Version)
+		fmt.Println("Commit hash:", util.CommitHash)
+		fmt.Println("Compiled on", util.CompileDate)
+		os.Exit(0)
+	}
+
+	if *flagOptions {
+		// If -options was passed
+		var keys []string
+		m := config.DefaultAllSettings()
+		for k := range m {
+			keys = append(keys, k)
+		}
+		sort.Strings(keys)
+		for _, k := range keys {
+			v := m[k]
+			fmt.Printf("-%s value\n", k)
+			fmt.Printf("    \tDefault value: '%v'\n", v)
+		}
+		os.Exit(0)
+	}
+}
+
 // LoadInput determines which files should be loaded into buffers
-// based on the input stored in os.Args
-func LoadInput() []*Buffer {
+// based on the input stored in flag.Args()
+func LoadInput() []*buffer.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
@@ -80,25 +100,20 @@ func LoadInput() []*Buffer {
 	var filename string
 	var input []byte
 	var err error
-	var buffers []*Buffer
+	args := flag.Args()
+	buffers := make([]*buffer.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]
-			// Check that the file exists
-			if _, e := os.Stat(filename); e == nil {
-				// If it exists we load it into a buffer
-				input, err = ioutil.ReadFile(filename)
-				if err != nil {
-					TermMessage(err)
-					input = []byte{}
-					filename = ""
-				}
+		for i := 0; i < len(args); i++ {
+			buf, err := buffer.NewBufferFromFile(args[i], buffer.BTDefault)
+			if err != nil {
+				screen.TermMessage(err)
+				continue
 			}
 			// If the file didn't exist, input will be empty, and we'll open an empty buffer
-			buffers = append(buffers, NewBuffer(input, filename))
+			buffers = append(buffers, buf)
 		}
 	} else if !isatty.IsTerminal(os.Stdin.Fd()) {
 		// Option 2
@@ -106,271 +121,141 @@ func LoadInput() []*Buffer {
 		// and we should read from stdin
 		input, err = ioutil.ReadAll(os.Stdin)
 		if err != nil {
-			TermMessage("Error reading from stdin: ", err)
+			screen.TermMessage("Error reading from stdin: ", err)
 			input = []byte{}
 		}
-		buffers = append(buffers, NewBuffer(input, filename))
+		buffers = append(buffers, buffer.NewBufferFromString(string(input), filename, buffer.BTDefault))
 	} else {
 		// Option 3, just open an empty buffer
-		buffers = append(buffers, NewBuffer(input, filename))
+		buffers = append(buffers, buffer.NewBufferFromString(string(input), filename, buffer.BTDefault))
 	}
 
 	return buffers
 }
 
-// InitConfigDir finds the configuration directory for micro according to the XDG spec.
-// If no directory is found, it creates one.
-func InitConfigDir() {
-	xdgHome := os.Getenv("XDG_CONFIG_HOME")
-	if xdgHome == "" {
-		// The user has not set $XDG_CONFIG_HOME so we should act like it was set to ~/.config
-		home, err := homedir.Dir()
-		if err != nil {
-			TermMessage("Error finding your home directory\nCan't load config files")
-			return
-		}
-		xdgHome = home + "/.config"
-	}
-	configDir = xdgHome + "/micro"
-
-	if _, err := os.Stat(xdgHome); os.IsNotExist(err) {
-		// If the xdgHome doesn't exist we should create it
-		err = os.Mkdir(xdgHome, os.ModePerm)
-		if err != nil {
-			TermMessage("Error creating XDG_CONFIG_HOME directory: " + err.Error())
-		}
-	}
-
-	if _, err := os.Stat(configDir); os.IsNotExist(err) {
-		// If the micro specific config directory doesn't exist we should create that too
-		err = os.Mkdir(configDir, os.ModePerm)
-		if err != nil {
-			TermMessage("Error creating configuration directory: " + err.Error())
-		}
-	}
-}
-
-// InitScreen creates and initializes the tcell screen
-func InitScreen() {
-	// Should we enable true color?
-	truecolor := os.Getenv("MICRO_TRUECOLOR") == "1"
-
-	// In order to enable true color, we have to set the TERM to `xterm-truecolor` when
-	// initializing tcell, but after that, we can set the TERM back to whatever it was
-	oldTerm := os.Getenv("TERM")
-	if truecolor {
-		os.Setenv("TERM", "xterm-truecolor")
-	}
-
-	// Initilize tcell
-	var err error
-	screen, err = tcell.NewScreen()
-	if err != nil {
-		fmt.Println(err)
-		os.Exit(1)
-	}
-	if err = screen.Init(); err != nil {
-		fmt.Println(err)
-		os.Exit(1)
-	}
-
-	// Now we can put the TERM back to what it was before
-	if truecolor {
-		os.Setenv("TERM", oldTerm)
-	}
-
-	screen.SetStyle(defStyle)
-	screen.EnableMouse()
-}
-
-// RedrawAll redraws everything -- all the views and the messenger
-func RedrawAll() {
-	messenger.Clear()
-	for _, v := range tabs[curTab].views {
-		v.Display()
-	}
-	DisplayTabs()
-	messenger.Display()
-	screen.Show()
-}
-
-// Passing -version as a flag will have micro print out the version number
-var flagVersion = flag.Bool("version", false, "Show the version number")
-
 func main() {
-	flag.Parse()
-	if *flagVersion {
-		// If -version was passed
-		fmt.Println("Version:", Version)
-		fmt.Println("Commit hash:", CommitHash)
-		fmt.Println("Compiled on", CompileDate)
-		os.Exit(0)
+	defer os.Exit(0)
+
+	// runtime.SetCPUProfileRate(400)
+	// f, _ := os.Create("micro.prof")
+	// pprof.StartCPUProfile(f)
+	// defer pprof.StopCPUProfile()
+
+	var err error
+
+	InitLog()
+
+	InitFlags()
+
+	err = config.InitConfigDir(*flagConfigDir)
+	if err != nil {
+		screen.TermMessage(err)
 	}
 
-	// Start the Lua VM for running plugins
-	L = lua.NewState()
-	defer L.Close()
+	config.InitRuntimeFiles()
+	err = config.ReadSettings()
+	if err != nil {
+		screen.TermMessage(err)
+	}
+	config.InitGlobalSettings()
 
-	// Some encoding stuff in case the user isn't using UTF-8
-	encoding.Register()
-	tcell.SetEncodingFallback(tcell.EncodingFallbackASCII)
+	// flag options
+	for k, v := range optionFlags {
+		if *v != "" {
+			nativeValue, err := config.GetNativeValue(k, config.DefaultAllSettings()[k], *v)
+			if err != nil {
+				screen.TermMessage(err)
+				continue
+			}
+			config.GlobalSettings[k] = nativeValue
+		}
+	}
 
-	// Find the user's configuration directory (probably $XDG_CONFIG_HOME/micro)
-	InitConfigDir()
+	action.InitBindings()
+	action.InitCommands()
 
-	// Load the user's settings
-	InitGlobalSettings()
-	InitCommands()
-	InitBindings()
+	err = config.InitColorscheme()
+	if err != nil {
+		screen.TermMessage(err)
+	}
 
-	// Load the syntax files, including the colorscheme
-	LoadSyntaxFiles()
+	err = config.LoadAllPlugins()
+	if err != nil {
+		screen.TermMessage(err)
+	}
+	err = config.RunPluginFn("init")
+	if err != nil {
+		screen.TermMessage(err)
+	}
 
-	// Load the help files
-	LoadHelp()
+	screen.Init()
 
-	// Start the screen
-	InitScreen()
-
-	// This is just so if we have an error, we can exit cleanly and not completely
+	// If we have an error, we can exit cleanly and not completely
 	// mess up the terminal being worked in
 	// In other words we need to shut down tcell before the program crashes
 	defer func() {
 		if err := recover(); err != nil {
-			screen.Fini()
+			screen.Screen.Fini()
 			fmt.Println("Micro encountered an error:", err)
+			// backup all open buffers
+			for _, b := range buffer.OpenBuffers {
+				b.Backup(false)
+			}
 			// Print the stack trace too
 			fmt.Print(errors.Wrap(err, 2).ErrorStack())
 			os.Exit(1)
 		}
 	}()
 
-	// Create a new messenger
-	// This is used for sending the user messages in the bottom of the editor
-	messenger = new(Messenger)
-	messenger.history = make(map[string][]string)
-
-	// Now we load the input
-	buffers := LoadInput()
-	for _, buf := range buffers {
-		// For each buffer we create a new tab and place the view in that tab
-		tab := NewTabFromView(NewView(buf))
-		tab.SetNum(len(tabs))
-		tabs = append(tabs, tab)
-		for _, t := range tabs {
-			for _, v := range t.views {
-				v.Center(false)
-				if globalSettings["syntax"].(bool) {
-					v.matches = Match(v)
-				}
-			}
-		}
-	}
-
-	// Load all the plugin stuff
-	// We give plugins access to a bunch of variables here which could be useful to them
-	L.SetGlobal("OS", luar.New(L, runtime.GOOS))
-	L.SetGlobal("tabs", luar.New(L, tabs))
-	L.SetGlobal("curTab", luar.New(L, curTab))
-	L.SetGlobal("messenger", luar.New(L, messenger))
-	L.SetGlobal("GetOption", luar.New(L, GetOption))
-	L.SetGlobal("AddOption", luar.New(L, AddOption))
-	L.SetGlobal("SetOption", luar.New(L, SetOption))
-	L.SetGlobal("SetLocalOption", luar.New(L, SetLocalOption))
-	L.SetGlobal("BindKey", luar.New(L, BindKey))
-	L.SetGlobal("MakeCommand", luar.New(L, MakeCommand))
-	L.SetGlobal("CurView", luar.New(L, CurView))
-	L.SetGlobal("IsWordChar", luar.New(L, IsWordChar))
-	L.SetGlobal("HandleCommand", luar.New(L, HandleCommand))
-	L.SetGlobal("HandleShellCommand", luar.New(L, HandleShellCommand))
-	L.SetGlobal("GetLeadingWhitespace", luar.New(L, GetLeadingWhitespace))
-
-	// Used for asynchronous jobs
-	L.SetGlobal("JobStart", luar.New(L, JobStart))
-	L.SetGlobal("JobSend", luar.New(L, JobSend))
-	L.SetGlobal("JobStop", luar.New(L, JobStop))
-
-	LoadPlugins()
-
-	jobs = make(chan JobFunction, 100)
-	events = make(chan tcell.Event)
-
-	for _, t := range tabs {
-		for _, v := range t.views {
-			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)
-			}
-		}
-	}
+	b := LoadInput()
+	action.InitTabs(b)
+	action.InitGlobals()
 
 	// Here is the event loop which runs in a separate thread
 	go func() {
+		events = make(chan tcell.Event)
 		for {
-			events <- screen.PollEvent()
+			screen.Lock()
+			e := screen.Screen.PollEvent()
+			screen.Unlock()
+			if e != nil {
+				events <- e
+			}
 		}
 	}()
 
 	for {
 		// Display everything
-		RedrawAll()
+		screen.Screen.Fill(' ', config.DefStyle)
+		screen.Screen.HideCursor()
+		action.Tabs.Display()
+		for _, ep := range action.MainTab().Panes {
+			ep.Display()
+		}
+		action.MainTab().Display()
+		action.InfoBar.Display()
+		screen.Screen.Show()
 
 		var event tcell.Event
 
 		// Check for new events
 		select {
-		case f := <-jobs:
+		case f := <-shell.Jobs:
 			// If a new job has finished while running in the background we should execute the callback
-			f.function(f.output, f.args...)
-			continue
-		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
-				}
-
-				// 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
-					}
-				}
+			f.Function(f.Output, f.Args...)
+		case <-config.Autosave:
+			for _, b := range buffer.OpenBuffers {
+				b.Save()
 			}
+		case <-shell.CloseTerms:
+		case event = <-events:
+		case <-screen.DrawChan:
 		}
 
-		// 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
-		}
-
-		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())
+		if action.InfoBar.HasPrompt {
+			action.InfoBar.HandleEvent(event)
 		} else {
-			// Send it to the view
-			CurView().HandleEvent(event)
+			action.Tabs.HandleEvent(event)
 		}
 	}
 }

cmd/micro/plugin.go

@@ -1,152 +0,0 @@
-package main
-
-import (
-	"errors"
-	"io/ioutil"
-	"os"
-	"strings"
-
-	"github.com/layeh/gopher-luar"
-	"github.com/yuin/gopher-lua"
-)
-
-var loadedPlugins []string
-
-var preInstalledPlugins = []string{
-	"go",
-	"linter",
-	"autoclose",
-}
-
-// Call calls the lua function 'function'
-// If it does not exist nothing happens, if there is an error,
-// the error is returned
-func Call(function string, args ...interface{}) (lua.LValue, error) {
-	var luaFunc lua.LValue
-	if strings.Contains(function, ".") {
-		plugin := L.GetGlobal(strings.Split(function, ".")[0])
-		if plugin.String() == "nil" {
-			return nil, errors.New("function does not exist: " + function)
-		}
-		luaFunc = L.GetField(plugin, strings.Split(function, ".")[1])
-	} else {
-		luaFunc = L.GetGlobal(function)
-	}
-
-	if luaFunc.String() == "nil" {
-		return nil, errors.New("function does not exist: " + function)
-	}
-	var luaArgs []lua.LValue
-	for _, v := range args {
-		luaArgs = append(luaArgs, luar.New(L, v))
-	}
-	err := L.CallByParam(lua.P{
-		Fn:      luaFunc,
-		NRet:    1,
-		Protect: true,
-	}, luaArgs...)
-	ret := L.Get(-1) // returned value
-	if ret.String() != "nil" {
-		L.Pop(1) // remove received value
-	}
-	return ret, err
-}
-
-// LuaFunctionBinding is a function generator which takes the name of a lua function
-// and creates a function that will call that lua function
-// Specifically it creates a function that can be called as a binding because this is used
-// to bind keys to lua functions
-func LuaFunctionBinding(function string) func(*View, bool) bool {
-	return func(v *View, _ bool) bool {
-		_, err := Call(function, nil)
-		if err != nil {
-			TermMessage(err)
-		}
-		return false
-	}
-}
-
-func unpack(old []string) []interface{} {
-	new := make([]interface{}, len(old))
-	for i, v := range old {
-		new[i] = v
-	}
-	return new
-}
-
-// LuaFunctionCommand is the same as LuaFunctionBinding except it returns a normal function
-// so that a command can be bound to a lua function
-func LuaFunctionCommand(function string) func([]string) {
-	return func(args []string) {
-		_, err := Call(function, unpack(args)...)
-		if err != nil {
-			TermMessage(err)
-		}
-	}
-}
-
-func LuaFunctionJob(function string) func(string, ...string) {
-	return func(output string, args ...string) {
-		_, err := Call(function, unpack(append([]string{output}, args...))...)
-		if err != nil {
-			TermMessage(err)
-		}
-	}
-}
-
-// 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)
-				}
-			}
-		}
-	}
-
-	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
-			}
-
-			loadedPlugins = append(loadedPlugins, pluginName)
-		}
-	}
-
-	if _, err := os.Stat(configDir + "/init.lua"); err == nil {
-		pluginDef := "\nlocal P = {}\n" + "init" + " = P\nsetmetatable(" + "init" + ", {__index = _G})\nsetfenv(1, P)\n"
-		data, _ := ioutil.ReadFile(configDir + "/init.lua")
-		if err := L.DoString(pluginDef + string(data)); err != nil {
-			TermMessage(err)
-		}
-		loadedPlugins = append(loadedPlugins, "init")
-	}
-}

cmd/micro/search.go

@@ -1,135 +0,0 @@
-package main
-
-import (
-	"regexp"
-
-	"github.com/zyedidia/tcell"
-)
-
-var (
-	// What was the last search
-	lastSearch string
-
-	// Where should we start the search down from (or up from)
-	searchStart int
-
-	// Is there currently a search in progress
-	searching bool
-
-	// Stores the history for searching
-	searchHistory []string
-)
-
-// BeginSearch starts a search
-func BeginSearch() {
-	searchHistory = append(searchHistory, "")
-	messenger.historyNum = len(searchHistory) - 1
-	searching = true
-	messenger.hasPrompt = true
-	messenger.Message("Find: ")
-}
-
-// EndSearch stops the current search
-func EndSearch() {
-	searchHistory[len(searchHistory)-1] = messenger.response
-	searching = false
-	messenger.hasPrompt = false
-	messenger.Clear()
-	messenger.Reset()
-	if lastSearch != "" {
-		messenger.Message("^P Previous ^N Next")
-	}
-}
-
-// 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:
-			// Done
-			EndSearch()
-			return
-		}
-	}
-
-	messenger.HandleEvent(event, searchHistory)
-
-	if messenger.cursorx < 0 {
-		// Done
-		EndSearch()
-		return
-	}
-
-	if messenger.response == "" {
-		v.Cursor.ResetSelection()
-		// We don't end the search though
-		return
-	}
-
-	Search(messenger.response, v, true)
-
-	return
-}
-
-// Search searches in the view for the given regex. The down bool
-// specifies whether it should search down from the searchStart position
-// or up from there
-func Search(searchStr string, v *View, down bool) {
-	if searchStr == "" {
-		return
-	}
-	var str string
-	var charPos int
-	text := v.Buf.String()
-	if down {
-		str = string([]rune(text)[searchStart:])
-		charPos = searchStart
-	} else {
-		str = string([]rune(text)[:searchStart])
-	}
-	r, err := regexp.Compile(searchStr)
-	if v.Buf.Settings["ignorecase"].(bool) {
-		r, err = regexp.Compile("(?i)" + searchStr)
-	}
-	if err != nil {
-		return
-	}
-	matches := r.FindAllStringIndex(str, -1)
-	var match []int
-	if matches == nil {
-		// Search the entire buffer now
-		matches = r.FindAllStringIndex(text, -1)
-		charPos = 0
-		if matches == nil {
-			v.Cursor.ResetSelection()
-			return
-		}
-
-		if !down {
-			match = matches[len(matches)-1]
-		} else {
-			match = matches[0]
-		}
-		str = text
-	}
-
-	if !down {
-		match = matches[len(matches)-1]
-	} else {
-		match = matches[0]
-	}
-
-	if match[0] == match[1] {
-		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.Loc = v.Cursor.CurSelection[1]
-	if v.Relocate() {
-		v.matches = Match(v)
-	}
-	lastSearch = searchStr
-}

cmd/micro/settings.go

@@ -1,306 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"errors"
-	"io/ioutil"
-	"os"
-	"reflect"
-	"strconv"
-	"strings"
-
-	"github.com/zyedidia/glob"
-)
-
-// The options that the user can set
-var globalSettings map[string]interface{}
-
-// 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"
-	if _, e := os.Stat(filename); e == nil {
-		input, err := ioutil.ReadFile(filename)
-		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())
-		}
-	}
-
-	globalSettings = make(map[string]interface{})
-	for k, v := range defaults {
-		globalSettings[k] = v
-	}
-	for k, v := range parsed {
-		if !strings.HasPrefix(reflect.TypeOf(v).String(), "map") {
-			globalSettings[k] = v
-		}
-	}
-
-	if _, err := os.Stat(filename); os.IsNotExist(err) {
-		err := WriteSettings(filename)
-		if err != nil {
-			TermMessage("Error writing settings.json file: " + err.Error())
-		}
-	}
-}
-
-// InitLocalSettings scans the json in settings.json and sets the options locally based
-// on whether the buffer matches the glob
-func InitLocalSettings(buf *Buffer) {
-	var parsed map[string]interface{}
-
-	filename := configDir + "/settings.json"
-	if _, e := os.Stat(filename); e == nil {
-		input, err := ioutil.ReadFile(filename)
-		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())
-		}
-	}
-
-	for k, v := range parsed {
-		if strings.HasPrefix(reflect.TypeOf(v).String(), "map") {
-			g, err := glob.Compile(k)
-			if err != nil {
-				TermMessage("Error with glob setting ", k, ": ", err)
-				continue
-			}
-
-			if g.MatchString(buf.Path) {
-				for k1, v1 := range v.(map[string]interface{}) {
-					buf.Settings[k1] = v1
-				}
-			}
-		}
-	}
-}
-
-// WriteSettings writes the settings to the specified filename as JSON
-func WriteSettings(filename string) error {
-	var err error
-	if _, e := os.Stat(configDir); e == nil {
-		var parsed map[string]interface{}
-
-		filename := configDir + "/settings.json"
-		if _, e := os.Stat(filename); e == nil {
-			input, err := ioutil.ReadFile(filename)
-			if err != nil {
-				return err
-			}
-
-			err = json.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]
-				}
-			}
-		}
-
-		txt, _ := json.MarshalIndent(parsed, "", "    ")
-		err = ioutil.WriteFile(filename, txt, 0644)
-	}
-	return err
-}
-
-// AddOption creates a new option. This is meant to be called by plugins to add options.
-func AddOption(name string, value interface{}) {
-	globalSettings[name] = value
-	err := WriteSettings(configDir + "/settings.json")
-	if err != nil {
-		TermMessage("Error writing settings.json file: " + err.Error())
-	}
-}
-
-// GetGlobalOption returns the global value of the given option
-func GetGlobalOption(name string) interface{} {
-	return globalSettings[name]
-}
-
-// GetLocalOption returns the local value of the given option
-func GetLocalOption(name string, buf *Buffer) interface{} {
-	return buf.Settings[name]
-}
-
-// GetOption returns the value of the given option
-// If there is a local version of the option, it returns that
-// otherwise it will return the global version
-func GetOption(name string) interface{} {
-	if GetLocalOption(name, CurView().Buf) != nil {
-		return GetLocalOption(name, CurView().Buf)
-	}
-	return GetGlobalOption(name)
-}
-
-// 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":  "zenburn",
-		"cursorline":   true,
-		"ignorecase":   false,
-		"indentchar":   " ",
-		"ruler":        true,
-		"savecursor":   false,
-		"saveundo":     false,
-		"scrollspeed":  float64(2),
-		"scrollmargin": float64(3),
-		"statusline":   true,
-		"syntax":       true,
-		"tabsize":      float64(4),
-		"tabstospaces": false,
-	}
-}
-
-// DefaultLocalSettings returns the default local settings
-// Note that filetype is a local only option
-func DefaultLocalSettings() map[string]interface{} {
-	return map[string]interface{}{
-		"autoindent":   true,
-		"cursorline":   true,
-		"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,
-	}
-}
-
-// SetOption attempts to set the given option to the value
-// By default it will set the option as global, but if the option
-// is local only it will set the local version
-// Use setlocal to force an option to be set locally
-func SetOption(option, value string) error {
-	if _, ok := globalSettings[option]; !ok {
-		if _, ok := CurView().Buf.Settings[option]; !ok {
-			return errors.New("Invalid option")
-		}
-		SetLocalOption(option, value, CurView())
-		return nil
-	}
-
-	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
-	} else if kind == reflect.String {
-		globalSettings[option] = value
-	} else if kind == reflect.Float64 {
-		i, err := strconv.Atoi(value)
-		if err != nil {
-			return errors.New("Invalid value")
-		}
-		globalSettings[option] = float64(i)
-	}
-
-	if option == "colorscheme" {
-		LoadSyntaxFiles()
-		for _, tab := range tabs {
-			for _, view := range tab.views {
-				view.Buf.UpdateRules()
-				if view.Buf.Settings["syntax"].(bool) {
-					view.matches = Match(view)
-				}
-			}
-		}
-	}
-
-	if _, ok := CurView().Buf.Settings[option]; ok {
-		for _, tab := range tabs {
-			for _, view := range tab.views {
-				SetLocalOption(option, value, view)
-			}
-		}
-	}
-
-	return nil
-}
-
-// SetLocalOption sets the local version of this option
-func SetLocalOption(option, value string, view *View) error {
-	buf := view.Buf
-	if _, ok := buf.Settings[option]; !ok {
-		return errors.New("Invalid option")
-	}
-
-	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
-	} else if kind == reflect.String {
-		buf.Settings[option] = value
-	} else if kind == reflect.Float64 {
-		i, err := strconv.Atoi(value)
-		if err != nil {
-			return errors.New("Invalid value")
-		}
-		buf.Settings[option] = float64(i)
-	}
-
-	if option == "statusline" {
-		view.ToggleStatusLine()
-		if buf.Settings["syntax"].(bool) {
-			view.matches = Match(view)
-		}
-	}
-
-	if option == "filetype" {
-		LoadSyntaxFiles()
-		buf.UpdateRules()
-		if buf.Settings["syntax"].(bool) {
-			view.matches = Match(view)
-		}
-	}
-
-	return nil
-}
-
-// SetOptionAndSettings sets the given option and saves the option setting to the settings config file
-func SetOptionAndSettings(option, value string) {
-	filename := configDir + "/settings.json"
-
-	err := SetOption(option, value)
-
-	if err != nil {
-		messenger.Error(err.Error())
-		return
-	}
-
-	err = WriteSettings(filename)
-	if err != nil {
-		messenger.Error("Error writing to settings.json: " + err.Error())
-		return
-	}
-}

cmd/micro/split_tree.go

@@ -1,207 +0,0 @@
-package main
-
-type SplitType bool
-
-const (
-	VerticalSplit   = false
-	HorizontalSplit = true
-)
-
-type Node interface {
-	VSplit(buf *Buffer)
-	HSplit(buf *Buffer)
-	String() string
-}
-
-type LeafNode struct {
-	view *View
-
-	parent *SplitTree
-}
-
-func NewLeafNode(v *View, parent *SplitTree) *LeafNode {
-	n := new(LeafNode)
-	n.view = v
-	n.view.splitNode = n
-	n.parent = parent
-	return n
-}
-
-type SplitTree struct {
-	kind SplitType
-
-	parent   *SplitTree
-	children []Node
-
-	x int
-	y int
-
-	width  int
-	height int
-
-	tabNum int
-}
-
-func (l *LeafNode) VSplit(buf *Buffer) {
-	tab := tabs[l.parent.tabNum]
-	if l.parent.kind == VerticalSplit {
-		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)
-	} else {
-		s := new(SplitTree)
-		s.kind = VerticalSplit
-		s.parent = l.parent
-		newView := NewView(buf)
-		newView.TabNum = l.parent.tabNum
-		newView.Num = len(tab.views)
-		s.children = []Node{l, NewLeafNode(newView, s)}
-		l.parent.children[search(l.parent.children, l)] = s
-		l.parent = s
-
-		tab.curView++
-		tab.views = append(tab.views, newView)
-	}
-}
-
-func (l *LeafNode) HSplit(buf *Buffer) {
-	tab := tabs[l.parent.tabNum]
-	if l.parent.kind == HorizontalSplit {
-		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)
-	} else {
-		s := new(SplitTree)
-		s.kind = HorizontalSplit
-		s.parent = l.parent
-		newView := NewView(buf)
-		newView.TabNum = l.parent.tabNum
-		newView.Num = len(tab.views)
-		s.children = []Node{l, NewLeafNode(newView, s)}
-		l.parent.children[search(l.parent.children, l)] = s
-		l.parent = s
-
-		tab.curView++
-		tab.views = append(tab.views, newView)
-	}
-}
-
-func (l *LeafNode) Delete() {
-	i := search(l.parent.children, l)
-
-	copy(l.parent.children[i:], l.parent.children[i+1:])
-	l.parent.children[len(l.parent.children)-1] = nil
-	l.parent.children = l.parent.children[:len(l.parent.children)-1]
-
-	tab := tabs[l.parent.tabNum]
-	j := findView(tab.views, l.view)
-	copy(tab.views[j:], tab.views[j+1:])
-	tab.views[len(tab.views)-1] = nil // or the zero value of T
-	tab.views = tab.views[:len(tab.views)-1]
-
-	for i, v := range tab.views {
-		v.Num = i
-	}
-	if tab.curView > 0 {
-		tab.curView--
-	}
-}
-
-func (s *SplitTree) Cleanup() {
-	for i, node := range s.children {
-		if n, ok := node.(*SplitTree); ok {
-			if len(n.children) == 1 {
-				if child, ok := n.children[0].(*LeafNode); ok {
-					s.children[i] = child
-					child.parent = s
-					continue
-				}
-			}
-			n.Cleanup()
-		}
-	}
-}
-
-func (s *SplitTree) ResizeSplits() {
-	for i, 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
-			} 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
-			}
-			// n.view.ToggleStatusLine()
-			_, screenH := screen.Size()
-			if n.view.Buf.Settings["statusline"].(bool) || (n.view.y+n.view.height) != screenH-1 {
-				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)
-				n.height = s.height
-
-				n.x = s.x + n.width*i
-				n.y = s.y
-			} else {
-				n.height = s.height / len(s.children)
-				n.width = s.width
-
-				n.y = s.y + n.height*i
-				n.x = s.x
-			}
-			n.ResizeSplits()
-		}
-	}
-}
-
-func (l *LeafNode) String() string {
-	return l.view.Buf.Name
-}
-
-func search(haystack []Node, needle Node) int {
-	for i, x := range haystack {
-		if x == needle {
-			return i
-		}
-	}
-	return 0
-}
-
-func findView(haystack []*View, needle *View) int {
-	for i, x := range haystack {
-		if x == needle {
-			return i
-		}
-	}
-	return 0
-}
-
-func (s *SplitTree) VSplit(buf *Buffer) {}
-func (s *SplitTree) HSplit(buf *Buffer) {}
-
-func (s *SplitTree) String() string {
-	str := "["
-	for _, child := range s.children {
-		str += child.String() + ", "
-	}
-	return str + "]"
-}

cmd/micro/statusline.go

@@ -1,65 +0,0 @@
-package main
-
-import (
-	"strconv"
-)
-
-// Statusline represents the information line at the bottom
-// of each view
-// It gives information such as filename, whether the file has been
-// modified, filetype, cursor location
-type Statusline struct {
-	view *View
-}
-
-// 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
-
-	file := sline.view.Buf.Name
-
-	// If the buffer is dirty (has been modified) write a little '+'
-	if sline.view.Buf.IsModified {
-		file += " +"
-	}
-
-	// Add one to cursor.x and cursor.y because (0,0) is the top left,
-	// but users will be used to (1,1) (first line,first column)
-	// We use GetVisualX() here because otherwise we get the column number in runes
-	// so a '\t' is only 1, when it should be tabSize
-	columnNum := strconv.Itoa(sline.view.Cursor.GetVisualX() + 1)
-	lineNum := strconv.Itoa(sline.view.Cursor.Y + 1)
-
-	file += " (" + lineNum + "," + columnNum + ")"
-
-	// Add the filetype
-	file += " " + sline.view.Buf.FileType()
-
-	rightText := helpBinding + " for help "
-	if sline.view.Help {
-		rightText = helpBinding + " to close help "
-	}
-
-	statusLineStyle := defStyle.Reverse(true)
-	if style, ok := colorscheme["statusline"]; ok {
-		statusLineStyle = style
-	}
-
-	// Maybe there is a unicode filename?
-	fileRunes := []rune(file)
-	viewX := sline.view.x
-	if viewX != 0 {
-		screen.SetContent(viewX, y, ' ', nil, statusLineStyle)
-		viewX++
-	}
-	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 {
-			screen.SetContent(viewX+x, y, ' ', nil, statusLineStyle)
-		}
-	}
-}

cmd/micro/tab.go

@@ -1,152 +0,0 @@
-package main
-
-import (
-	"sort"
-
-	"github.com/zyedidia/tcell"
-)
-
-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
-
-	tree *SplitTree
-}
-
-// NewTabFromView creates a new tab and puts the given view in the tab
-func NewTabFromView(v *View) *Tab {
-	t := new(Tab)
-	t.views = append(t.views, v)
-	t.views[0].Num = 0
-
-	t.tree = new(SplitTree)
-	t.tree.kind = VerticalSplit
-	t.tree.children = []Node{NewLeafNode(t.views[0], t.tree)}
-
-	w, h := screen.Size()
-	t.tree.width = w
-	t.tree.height = h - 1
-	return t
-}
-
-// SetNum sets all this tab's views to have the correct tab number
-func (t *Tab) SetNum(num int) {
-	for _, v := range t.views {
-		v.TabNum = num
-	}
-}
-
-func (t *Tab) Cleanup() {
-	t.tree.Cleanup()
-}
-
-func (t *Tab) Resize() {
-	w, h := screen.Size()
-	t.tree.width = w
-	t.tree.height = h - 1
-	t.tree.ResizeSplits()
-}
-
-// CurView returns the current view
-func CurView() *View {
-	curTab := tabs[curTab]
-	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 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 := ""
-	indicies := make(map[int]int)
-	for i, t := range tabs {
-		if i == curTab {
-			str += "["
-		} else {
-			str += " "
-		}
-		str += t.views[t.curView].Buf.Name
-		if i == curTab {
-			str += "]"
-		} else {
-			str += " "
-		}
-		indicies[len(str)-1] = i + 1
-		str += " "
-	}
-	return str, indicies
-}
-
-// TabbarHandleMouseEvent checks the given mouse event if it is clicking on the tabbar
-// If it is it changes the current tab accordingly
-// This function returns true if the tab is changed
-func TabbarHandleMouseEvent(event tcell.Event) bool {
-	// There is no tabbar displayed if there are less than 2 tabs
-	if len(tabs) <= 1 {
-		return false
-	}
-
-	switch e := event.(type) {
-	case *tcell.EventMouse:
-		button := e.Buttons()
-		// Must be a left click
-		if button == tcell.Button1 {
-			x, y := e.Position()
-			if y != 0 {
-				return false
-			}
-			str, indicies := TabbarString()
-			if x >= len(str) {
-				return false
-			}
-			var tabnum int
-			var keys []int
-			for k := range indicies {
-				keys = append(keys, k)
-			}
-			sort.Ints(keys)
-			for _, k := range keys {
-				if x <= k {
-					tabnum = indicies[k] - 1
-					break
-				}
-			}
-			curTab = tabnum
-			return true
-		}
-	}
-
-	return false
-}
-
-// DisplayTabs displays the tabbar at the top of the editor if there are multiple tabs
-func DisplayTabs() {
-	if len(tabs) <= 1 {
-		return
-	}
-
-	str, _ := TabbarString()
-
-	tabBarStyle := defStyle.Reverse(true)
-	if style, ok := colorscheme["tabbar"]; ok {
-		tabBarStyle = style
-	}
-
-	// Maybe there is a unicode filename?
-	fileRunes := []rune(str)
-	w, _ := screen.Size()
-	for x := 0; x < w; x++ {
-		if x < len(fileRunes) {
-			screen.SetContent(x, 0, fileRunes[x], nil, tabBarStyle)
-		} else {
-			screen.SetContent(x, 0, ' ', nil, tabBarStyle)
-		}
-	}
-}

cmd/micro/util.go

@@ -1,219 +0,0 @@
-package main
-
-import (
-	"os"
-	"path/filepath"
-	"strconv"
-	"strings"
-	"time"
-	"unicode/utf8"
-
-	"github.com/mattn/go-runewidth"
-)
-
-// Util.go is a collection of utility functions that are used throughout
-// the program
-
-// Count returns the length of a string in runes
-// This is exactly equivalent to utf8.RuneCountInString(), just less characters
-func Count(s string) int {
-	return utf8.RuneCountInString(s)
-}
-
-// NumOccurrences counts the number of occurences 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 {
-			n++
-		}
-	}
-	return n
-}
-
-// Spaces returns a string with n spaces
-func Spaces(n int) string {
-	var str string
-	for i := 0; i < n; i++ {
-		str += " "
-	}
-	return str
-}
-
-// Min takes the min of two ints
-func Min(a, b int) int {
-	if a > b {
-		return b
-	}
-	return a
-}
-
-// Max takes the max of two ints
-func Max(a, b int) int {
-	if a > b {
-		return a
-	}
-	return b
-}
-
-// 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
-	}
-	c := str[0]
-	return (c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c == '_')
-}
-
-// IsWhitespace returns true if the given rune is a space, tab, or newline
-func IsWhitespace(c rune) bool {
-	return c == ' ' || c == '\t' || c == '\n'
-}
-
-// Contains returns whether or not a string array contains a given string
-func Contains(list []string, a string) bool {
-	for _, b := range list {
-		if b == a {
-			return true
-		}
-	}
-	return false
-}
-
-// Insert makes a simple insert into a string at the given position
-func Insert(str string, pos int, value string) string {
-	return string([]rune(str)[:pos]) + value + string([]rune(str)[pos:])
-}
-
-// GetLeadingWhitespace returns the leading whitespace of the given string
-func GetLeadingWhitespace(str string) string {
-	ws := ""
-	for _, c := range str {
-		if c == ' ' || c == '\t' {
-			ws += string(c)
-		} else {
-			break
-		}
-	}
-	return ws
-}
-
-// IsSpaces checks if a given string is only spaces
-func IsSpaces(str string) bool {
-	for _, c := range str {
-		if c != ' ' {
-			return false
-		}
-	}
-
-	return true
-}
-
-// IsSpacesOrTabs checks if a given string contains only spaces and tabs
-func IsSpacesOrTabs(str string) bool {
-	for _, c := range str {
-		if c != ' ' && c != '\t' {
-			return false
-		}
-	}
-
-	return true
-}
-
-// ParseBool is almost exactly like strconv.ParseBool, except it also accepts 'on' and 'off'
-// as 'true' and 'false' respectively
-func ParseBool(str string) (bool, error) {
-	if str == "on" {
-		return true, nil
-	}
-	if str == "off" {
-		return false, nil
-	}
-	return strconv.ParseBool(str)
-}
-
-// EscapePath replaces every path separator in a given path with a %
-func EscapePath(path string) string {
-	path = filepath.ToSlash(path)
-	return strings.Replace(path, "/", "%", -1)
-}
-
-// GetModTime returns the last modification time for a given file
-// It also returns a boolean if there was a problem accessing the file
-func GetModTime(path string) (time.Time, bool) {
-	info, err := os.Stat(path)
-	if err != nil {
-		return time.Now(), false
-	}
-	return info.ModTime(), true
-}
-
-// 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 += NumOccurrences(str, '\t') * (tabsize - 1)
-	return sw
-}
-
-// WidthOfLargeRunes searches all the runes in a string and counts up all the widths of runes
-// that have a width larger than 1 (this also counts tabs as `tabsize` width)
-func WidthOfLargeRunes(str string, tabsize int) int {
-	count := 0
-	for _, ch := range str {
-		var w int
-		if ch == '\t' {
-			w = tabsize
-		} else {
-			w = runewidth.RuneWidth(ch)
-		}
-		if w > 1 {
-			count += (w - 1)
-		}
-	}
-	return count
-}
-
-// 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 {
-	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 {
-		return -n
-	}
-	return n
-}

cmd/micro/util_test.go

@@ -1,65 +0,0 @@
-package main
-
-import "testing"
-
-func TestNumOccurences(t *testing.T) {
-	var tests = []struct {
-		inputStr  string
-		inputChar byte
-		want      int
-	}{
-		{"aaaa", 'a', 4},
-		{"\trfd\ta", '\t', 2},
-		{"∆ƒ\tø ® \t\t", '\t', 3},
-	}
-	for _, test := range tests {
-		if got := NumOccurrences(test.inputStr, test.inputChar); got != test.want {
-			t.Errorf("NumOccurences(%s, %c) = %d", test.inputStr, test.inputChar, got)
-		}
-	}
-}
-
-func TestSpaces(t *testing.T) {
-	var tests = []struct {
-		input int
-		want  string
-	}{
-		{4, "    "},
-		{0, ""},
-	}
-	for _, test := range tests {
-		if got := Spaces(test.input); got != test.want {
-			t.Errorf("Spaces(%d) = \"%s\"", test.input, got)
-		}
-	}
-}
-
-func TestIsWordChar(t *testing.T) {
-	if IsWordChar("t") == false {
-		t.Errorf("IsWordChar(t) = false")
-	}
-	if IsWordChar("T") == false {
-		t.Errorf("IsWordChar(T) = false")
-	}
-	if IsWordChar("5") == false {
-		t.Errorf("IsWordChar(5) = 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")
-	}
-	if IsWordChar("\n") == true {
-		t.Errorf("IsWordChar(\n)) = true")
-	}
-}

cmd/micro/view.go

@@ -1,773 +0,0 @@
-package main
-
-import (
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/mattn/go-runewidth"
-	"github.com/zyedidia/tcell"
-)
-
-// The View struct stores information about a view into a buffer.
-// It stores information about the cursor, and the viewport
-// that the user sees the buffer from.
-type View struct {
-	// A pointer to the buffer's cursor for ease of access
-	Cursor *Cursor
-
-	// The topmost line, used for vertical scrolling
-	Topline int
-	// The leftmost column, used for horizontal scrolling
-	leftCol int
-
-	// Percentage of the terminal window that this view takes up (from 0 to 100)
-	widthPercent  int
-	heightPercent int
-
-	// Specifies whether or not this view holds a help buffer
-	Help bool
-
-	// Actual with and height
-	width  int
-	height int
-
-	// Where this view is located
-	x, y int
-
-	// How much to offset because of line numbers
-	lineNumOffset int
-
-	// Holds the list of gutter messages
-	messages map[string][]GutterMessage
-
-	// This is the index of this view in the views array
-	Num int
-	// What tab is this view stored in
-	TabNum int
-
-	// The buffer
-	Buf *Buffer
-	// The statusline
-	sline Statusline
-
-	// Since tcell doesn't differentiate between a mouse release event
-	// and a mouse move event with no keys pressed, we need to keep
-	// track of whether or not the mouse was pressed (or not released) last event to determine
-	// mouse release events
-	mouseReleased bool
-
-	// This stores when the last click was
-	// This is useful for detecting double and triple clicks
-	lastClickTime time.Time
-
-	// lastCutTime stores when the last ctrl+k was issued.
-	// It is used for clearing the clipboard to replace it with fresh cut lines.
-	lastCutTime time.Time
-
-	// freshClip returns true if the clipboard has never been pasted.
-	freshClip bool
-
-	// Was the last mouse event actually a double click?
-	// Useful for detecting triple clicks -- if a double click is detected
-	// but the last mouse event was actually a double click, it's a triple click
-	doubleClick bool
-	// Same here, just to keep track for mouse move events
-	tripleClick bool
-
-	// Syntax highlighting matches
-	matches SyntaxMatches
-
-	splitNode *LeafNode
-}
-
-// NewView returns a new fullscreen view
-func NewView(buf *Buffer) *View {
-	screenW, screenH := screen.Size()
-	return NewViewWidthHeight(buf, screenW, screenH-1)
-}
-
-// NewViewWidthHeight returns a new view with the specified width and height
-// Note that w and h are raw column and row values
-func NewViewWidthHeight(buf *Buffer, w, h int) *View {
-	v := new(View)
-
-	v.x, v.y = 0, 0
-
-	v.width = w
-	v.height = h
-
-	v.ToggleTabbar()
-
-	v.OpenBuffer(buf)
-
-	v.messages = make(map[string][]GutterMessage)
-
-	v.sline = Statusline{
-		view: v,
-	}
-
-	if v.Buf.Settings["statusline"].(bool) {
-		v.height--
-	}
-
-	for _, pl := range loadedPlugins {
-		_, err := Call(pl+".onViewOpen", v)
-		if err != nil && !strings.HasPrefix(err.Error(), "function does not exist") {
-			TermMessage(err)
-			continue
-		}
-	}
-
-	return v
-}
-
-func (v *View) ToggleStatusLine() {
-	if v.Buf.Settings["statusline"].(bool) {
-		v.height--
-	} else {
-		v.height++
-	}
-}
-
-func (v *View) ToggleTabbar() {
-	if len(tabs) > 1 {
-		if v.y == 0 {
-			// Include one line for the tab bar at the top
-			v.height--
-			v.y = 1
-		}
-	} else {
-		if v.y == 1 {
-			v.y = 0
-			v.height++
-		}
-	}
-}
-
-// ScrollUp scrolls the view up n lines (if possible)
-func (v *View) ScrollUp(n int) {
-	// Try to scroll by n but if it would overflow, scroll by 1
-	if v.Topline-n >= 0 {
-		v.Topline -= n
-	} else if v.Topline > 0 {
-		v.Topline--
-	}
-}
-
-// ScrollDown scrolls the view down n lines (if possible)
-func (v *View) ScrollDown(n int) {
-	// Try to scroll by n but if it would overflow, scroll by 1
-	if v.Topline+n <= v.Buf.NumLines-v.height {
-		v.Topline += n
-	} else if v.Topline < v.Buf.NumLines-v.height {
-		v.Topline++
-	}
-}
-
-// CanClose returns whether or not the view can be closed
-// If there are unsaved changes, the user will be asked if the view can be closed
-// causing them to lose the unsaved changes
-// The message is what to print after saying "You have unsaved changes. "
-func (v *View) CanClose(msg string, responses ...rune) bool {
-	if v.Buf.IsModified {
-		char, canceled := messenger.LetterPrompt("You have unsaved changes. "+msg, responses...)
-		if !canceled {
-			if char == 'y' {
-				return true
-			} else if char == 's' {
-				v.Save(true)
-				return true
-			}
-		}
-	} else {
-		return true
-	}
-	return false
-}
-
-// OpenBuffer opens a new buffer in this view.
-// This resets the topline, event handler and cursor.
-func (v *View) OpenBuffer(buf *Buffer) {
-	screen.Clear()
-	v.CloseBuffer()
-	v.Buf = buf
-	v.Cursor = &buf.Cursor
-	v.Topline = 0
-	v.leftCol = 0
-	v.Cursor.ResetSelection()
-	v.Relocate()
-	v.Center(false)
-	v.messages = make(map[string][]GutterMessage)
-
-	v.matches = Match(v)
-
-	// Set mouseReleased to true because we assume the mouse is not being pressed when
-	// the editor is opened
-	v.mouseReleased = true
-	v.lastClickTime = time.Time{}
-}
-
-// CloseBuffer performs any closing functions on the buffer
-func (v *View) CloseBuffer() {
-	if v.Buf != nil {
-		v.Buf.Serialize()
-	}
-}
-
-// ReOpen reloads the current buffer
-func (v *View) ReOpen() {
-	if v.CanClose("Continue? (y,n,s) ", 'y', 'n', 's') {
-		screen.Clear()
-		v.Buf.ReOpen()
-		v.Relocate()
-		v.matches = Match(v)
-	}
-}
-
-// HSplit opens a horizontal split with the given buffer
-func (v *View) HSplit(buf *Buffer) bool {
-	v.splitNode.HSplit(buf)
-	tabs[v.TabNum].Resize()
-	return false
-}
-
-// VSplit opens a vertical split with the given buffer
-func (v *View) VSplit(buf *Buffer) bool {
-	v.splitNode.VSplit(buf)
-	tabs[v.TabNum].Resize()
-	return false
-}
-
-// Relocate moves the view window so that the cursor is in view
-// This is useful if the user has scrolled far away, and then starts typing
-func (v *View) Relocate() bool {
-	ret := false
-	cy := v.Cursor.Y
-	scrollmargin := int(v.Buf.Settings["scrollmargin"].(float64))
-	if cy < v.Topline+scrollmargin && cy > scrollmargin-1 {
-		v.Topline = cy - scrollmargin
-		ret = true
-	} else if cy < v.Topline {
-		v.Topline = cy
-		ret = true
-	}
-	if cy > v.Topline+v.height-1-scrollmargin && cy < v.Buf.NumLines-scrollmargin {
-		v.Topline = cy - v.height + 1 + scrollmargin
-		ret = true
-	} else if cy >= v.Buf.NumLines-scrollmargin && cy > v.height {
-		v.Topline = v.Buf.NumLines - v.height
-		ret = true
-	}
-
-	cx := v.Cursor.GetVisualX()
-	if cx < v.leftCol {
-		v.leftCol = cx
-		ret = true
-	}
-	if cx+v.lineNumOffset+1 > v.leftCol+v.width {
-		v.leftCol = cx - v.width + v.lineNumOffset + 1
-		ret = true
-	}
-	return ret
-}
-
-// MoveToMouseClick moves the cursor to location x, y assuming x, y were given
-// by a mouse click
-func (v *View) MoveToMouseClick(x, y int) {
-	if y-v.Topline > v.height-1 {
-		v.ScrollDown(1)
-		y = v.height + v.Topline - 1
-	}
-	if y >= v.Buf.NumLines {
-		y = v.Buf.NumLines - 1
-	}
-	if y < 0 {
-		y = 0
-	}
-	if x < 0 {
-		x = 0
-	}
-
-	x = v.Cursor.GetCharPosInLine(y, x)
-	if x > Count(v.Buf.Line(y)) {
-		x = Count(v.Buf.Line(y))
-	}
-	v.Cursor.X = x
-	v.Cursor.Y = y
-	v.Cursor.LastVisualX = v.Cursor.GetVisualX()
-}
-
-// HandleEvent handles an event passed by the main loop
-func (v *View) HandleEvent(event tcell.Event) {
-	// This bool determines whether the view is relocated at the end of the function
-	// By default it's true because most events should cause a relocate
-	relocate := true
-
-	v.Buf.CheckModTime()
-
-	switch e := event.(type) {
-	case *tcell.EventResize:
-		// Window resized
-		tabs[v.TabNum].Resize()
-	case *tcell.EventKey:
-		if e.Key() == tcell.KeyRune && (e.Modifiers() == 0 || e.Modifiers() == tcell.ModShift) {
-			// Insert a character
-			if v.Cursor.HasSelection() {
-				v.Cursor.DeleteSelection()
-				v.Cursor.ResetSelection()
-			}
-			v.Buf.Insert(v.Cursor.Loc, string(e.Rune()))
-			v.Cursor.Right()
-
-			for _, pl := range loadedPlugins {
-				_, err := Call(pl+".onRune", string(e.Rune()), v)
-				if err != nil && !strings.HasPrefix(err.Error(), "function does not exist") {
-					TermMessage(err)
-				}
-			}
-		} else {
-			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 {
-						relocate = false
-						for _, action := range actions {
-							relocate = action(v, true) || relocate
-						}
-					}
-				}
-			}
-		}
-	case *tcell.EventPaste:
-		relocate = v.Paste(true)
-	case *tcell.EventMouse:
-		x, y := e.Position()
-		x -= v.lineNumOffset - v.leftCol + v.x
-		y += v.Topline - v.y
-		// Don't relocate for mouse events
-		relocate = false
-
-		button := e.Buttons()
-
-		switch button {
-		case tcell.Button1:
-			// Left click
-			if v.mouseReleased {
-				v.MoveToMouseClick(x, y)
-				if time.Since(v.lastClickTime)/time.Millisecond < doubleClickThreshold {
-					if v.doubleClick {
-						// Triple click
-						v.lastClickTime = time.Now()
-
-						v.tripleClick = true
-						v.doubleClick = false
-
-						v.Cursor.SelectLine()
-					} else {
-						// Double click
-						v.lastClickTime = time.Now()
-
-						v.doubleClick = true
-						v.tripleClick = false
-
-						v.Cursor.SelectWord()
-					}
-				} else {
-					v.doubleClick = false
-					v.tripleClick = false
-					v.lastClickTime = time.Now()
-
-					v.Cursor.OrigSelection[0] = v.Cursor.Loc
-					v.Cursor.CurSelection[0] = v.Cursor.Loc
-					v.Cursor.CurSelection[1] = v.Cursor.Loc
-				}
-				v.mouseReleased = false
-			} else if !v.mouseReleased {
-				v.MoveToMouseClick(x, y)
-				if v.tripleClick {
-					v.Cursor.AddLineToSelection()
-				} else if v.doubleClick {
-					v.Cursor.AddWordToSelection()
-				} else {
-					v.Cursor.CurSelection[1] = v.Cursor.Loc
-				}
-			}
-		case tcell.ButtonNone:
-			// Mouse event with no click
-			if !v.mouseReleased {
-				// Mouse was just released
-
-				// Relocating here isn't really necessary because the cursor will
-				// be in the right place from the last mouse event
-				// However, if we are running in a terminal that doesn't support mouse motion
-				// events, this still allows the user to make selections, except only after they
-				// release the mouse
-
-				if !v.doubleClick && !v.tripleClick {
-					v.MoveToMouseClick(x, y)
-					v.Cursor.CurSelection[1] = v.Cursor.Loc
-				}
-				v.mouseReleased = true
-			}
-		case tcell.WheelUp:
-			// Scroll up
-			scrollspeed := int(v.Buf.Settings["scrollspeed"].(float64))
-			v.ScrollUp(scrollspeed)
-		case tcell.WheelDown:
-			// Scroll down
-			scrollspeed := int(v.Buf.Settings["scrollspeed"].(float64))
-			v.ScrollDown(scrollspeed)
-		}
-	}
-
-	if relocate {
-		v.Relocate()
-	}
-	if v.Buf.Settings["syntax"].(bool) {
-		v.matches = Match(v)
-	}
-}
-
-// GutterMessage creates a message in this view's gutter
-func (v *View) GutterMessage(section string, lineN int, msg string, kind int) {
-	lineN--
-	gutterMsg := GutterMessage{
-		lineNum: lineN,
-		msg:     msg,
-		kind:    kind,
-	}
-	for _, v := range v.messages {
-		for _, gmsg := range v {
-			if gmsg.lineNum == lineN {
-				return
-			}
-		}
-	}
-	messages := v.messages[section]
-	v.messages[section] = append(messages, gutterMsg)
-}
-
-// ClearGutterMessages clears all gutter messages from a given section
-func (v *View) ClearGutterMessages(section string) {
-	v.messages[section] = []GutterMessage{}
-}
-
-// ClearAllGutterMessages clears all the gutter messages
-func (v *View) ClearAllGutterMessages() {
-	for k := range v.messages {
-		v.messages[k] = []GutterMessage{}
-	}
-}
-
-// Opens the given help page in a new horizontal split
-func (v *View) openHelp(helpPage string) {
-	if v.Help {
-		helpBuffer := NewBuffer([]byte(helpPages[helpPage]), helpPage+".md")
-		helpBuffer.Name = "Help"
-		v.OpenBuffer(helpBuffer)
-	} else {
-		helpBuffer := NewBuffer([]byte(helpPages[helpPage]), helpPage+".md")
-		helpBuffer.Name = "Help"
-		v.HSplit(helpBuffer)
-		CurView().Help = true
-	}
-}
-
-func (v *View) drawCell(x, y int, ch rune, combc []rune, style tcell.Style) {
-	if x >= v.x && x < v.x+v.width && y >= v.y && y < v.y+v.height {
-		screen.SetContent(x, y, ch, combc, style)
-	}
-}
-
-// DisplayView renders the view to the screen
-func (v *View) DisplayView() {
-	// The charNum we are currently displaying
-	// starts at the start of the viewport
-	charNum := Loc{0, v.Topline}
-
-	// Convert the length of buffer to a string, and get the length of the string
-	// We are going to have to offset by that amount
-	maxLineLength := len(strconv.Itoa(v.Buf.NumLines))
-
-	if v.Buf.Settings["ruler"] == true {
-		// + 1 for the little space after the line number
-		v.lineNumOffset = maxLineLength + 1
-	} else {
-		v.lineNumOffset = 0
-	}
-
-	// We need to add to the line offset if there are gutter messages
-	var hasGutterMessages bool
-	for _, v := range v.messages {
-		if len(v) > 0 {
-			hasGutterMessages = true
-		}
-	}
-	if hasGutterMessages {
-		v.lineNumOffset += 2
-	}
-
-	if v.x != 0 {
-		// One space for the extra split divider
-		v.lineNumOffset++
-	}
-
-	// These represent the current screen coordinates
-	screenX, screenY := 0, 0
-
-	highlightStyle := defStyle
-
-	// ViewLine is the current line from the top of the viewport
-	for viewLine := 0; viewLine < v.height; viewLine++ {
-		screenY = v.y + viewLine
-		screenX = v.x
-
-		// This is the current line number of the buffer that we are drawing
-		curLineN := viewLine + v.Topline
-
-		if v.x != 0 {
-			// Draw the split divider
-			v.drawCell(screenX, screenY, '|', nil, defStyle.Reverse(true))
-			screenX++
-		}
-
-		// If the buffer is smaller than the view height we have to clear all this space
-		if curLineN >= v.Buf.NumLines {
-			for i := screenX; i < v.x+v.width; i++ {
-				v.drawCell(i, screenY, ' ', nil, defStyle)
-			}
-
-			continue
-		}
-		line := v.Buf.Line(curLineN)
-
-		// If there are gutter messages we need to display the '>>' symbol here
-		if hasGutterMessages {
-			// msgOnLine stores whether or not there is a gutter message on this line in particular
-			msgOnLine := false
-			for k := range v.messages {
-				for _, msg := range v.messages[k] {
-					if msg.lineNum == curLineN {
-						msgOnLine = true
-						gutterStyle := defStyle
-						switch msg.kind {
-						case GutterInfo:
-							if style, ok := colorscheme["gutter-info"]; ok {
-								gutterStyle = style
-							}
-						case GutterWarning:
-							if style, ok := colorscheme["gutter-warning"]; ok {
-								gutterStyle = style
-							}
-						case GutterError:
-							if style, ok := colorscheme["gutter-error"]; ok {
-								gutterStyle = style
-							}
-						}
-						v.drawCell(screenX, screenY, '>', nil, gutterStyle)
-						screenX++
-						v.drawCell(screenX, screenY, '>', nil, gutterStyle)
-						screenX++
-						if v.Cursor.Y == curLineN && !messenger.hasPrompt {
-							messenger.Message(msg.msg)
-							messenger.gutterMessage = true
-						}
-					}
-				}
-			}
-			// If there is no message on this line we just display an empty offset
-			if !msgOnLine {
-				v.drawCell(screenX, screenY, ' ', nil, defStyle)
-				screenX++
-				v.drawCell(screenX, screenY, ' ', nil, defStyle)
-				screenX++
-				if v.Cursor.Y == curLineN && messenger.gutterMessage {
-					messenger.Reset()
-					messenger.gutterMessage = false
-				}
-			}
-		}
-
-		if v.Buf.Settings["ruler"] == true {
-			// Write the line number
-			lineNumStyle := defStyle
-			if style, ok := colorscheme["line-number"]; ok {
-				lineNumStyle = style
-			}
-			if style, ok := colorscheme["current-line-number"]; ok {
-				if curLineN == v.Cursor.Y && tabs[curTab].curView == v.Num && !v.Cursor.HasSelection() {
-					lineNumStyle = style
-				}
-			}
-
-			lineNum := strconv.Itoa(curLineN + 1)
-
-			// Write the spaces before the line number if necessary
-			for i := 0; i < maxLineLength-len(lineNum); i++ {
-				v.drawCell(screenX, screenY, ' ', nil, lineNumStyle)
-				screenX++
-			}
-			// Write the actual line number
-			for _, ch := range lineNum {
-				v.drawCell(screenX, screenY, ch, nil, lineNumStyle)
-				screenX++
-			}
-
-			// Write the extra space
-			v.drawCell(screenX, screenY, ' ', nil, lineNumStyle)
-			screenX++
-		}
-
-		// Now we actually draw the line
-		colN := 0
-		for _, ch := range line {
-			lineStyle := defStyle
-
-			if v.Buf.Settings["syntax"].(bool) {
-				// Syntax highlighting is enabled
-				highlightStyle = v.matches[viewLine][colN]
-			}
-
-			if v.Cursor.HasSelection() &&
-				(charNum.GreaterEqual(v.Cursor.CurSelection[0]) && charNum.LessThan(v.Cursor.CurSelection[1]) ||
-					charNum.LessThan(v.Cursor.CurSelection[0]) && charNum.GreaterEqual(v.Cursor.CurSelection[1])) {
-				// The current character is selected
-				lineStyle = defStyle.Reverse(true)
-
-				if style, ok := colorscheme["selection"]; ok {
-					lineStyle = style
-				}
-			} else {
-				lineStyle = highlightStyle
-			}
-
-			// We need to display the background of the linestyle with the correct color if cursorline is enabled
-			// and this is the current view and there is no selection on this line and the cursor is on this line
-			if v.Buf.Settings["cursorline"].(bool) && tabs[curTab].curView == v.Num && !v.Cursor.HasSelection() && v.Cursor.Y == curLineN {
-				if style, ok := colorscheme["cursor-line"]; ok {
-					fg, _, _ := style.Decompose()
-					lineStyle = lineStyle.Background(fg)
-				}
-			}
-
-			if ch == '\t' {
-				// If the character we are displaying is a tab, we need to do a bunch of special things
-
-				// First the user may have configured an `indent-char` to be displayed to show that this
-				// is a tab character
-				lineIndentStyle := defStyle
-				if style, ok := colorscheme["indent-char"]; ok {
-					lineIndentStyle = style
-				}
-				if v.Cursor.HasSelection() &&
-					(charNum.GreaterEqual(v.Cursor.CurSelection[0]) && charNum.LessThan(v.Cursor.CurSelection[1]) ||
-						charNum.LessThan(v.Cursor.CurSelection[0]) && charNum.GreaterEqual(v.Cursor.CurSelection[1])) {
-
-					lineIndentStyle = defStyle.Reverse(true)
-
-					if style, ok := colorscheme["selection"]; ok {
-						lineIndentStyle = style
-					}
-				}
-				if v.Buf.Settings["cursorline"].(bool) && tabs[curTab].curView == v.Num && !v.Cursor.HasSelection() && v.Cursor.Y == curLineN {
-					if style, ok := colorscheme["cursor-line"]; ok {
-						fg, _, _ := style.Decompose()
-						lineIndentStyle = lineIndentStyle.Background(fg)
-					}
-				}
-				// Here we get the indent char
-				indentChar := []rune(v.Buf.Settings["indentchar"].(string))
-				if screenX-v.x-v.leftCol >= v.lineNumOffset {
-					v.drawCell(screenX-v.leftCol, screenY, indentChar[0], nil, lineIndentStyle)
-				}
-				// Now the tab has to be displayed as a bunch of spaces
-				tabSize := int(v.Buf.Settings["tabsize"].(float64))
-				for i := 0; i < tabSize-1; i++ {
-					screenX++
-					if screenX-v.x-v.leftCol >= v.lineNumOffset {
-						v.drawCell(screenX-v.leftCol, screenY, ' ', nil, lineStyle)
-					}
-				}
-			} else if runewidth.RuneWidth(ch) > 1 {
-				if screenX-v.x-v.leftCol >= v.lineNumOffset {
-					v.drawCell(screenX, screenY, ch, nil, lineStyle)
-				}
-				for i := 0; i < runewidth.RuneWidth(ch)-1; i++ {
-					screenX++
-					if screenX-v.x-v.leftCol >= v.lineNumOffset {
-						v.drawCell(screenX-v.leftCol, screenY, '<', nil, lineStyle)
-					}
-				}
-			} else {
-				if screenX-v.x-v.leftCol >= v.lineNumOffset {
-					v.drawCell(screenX-v.leftCol, screenY, ch, nil, lineStyle)
-				}
-			}
-			charNum = charNum.Move(1, v.Buf)
-			screenX++
-			colN++
-		}
-		// Here we are at a newline
-
-		// The newline may be selected, in which case we should draw the selection style
-		// with a space to represent it
-		if v.Cursor.HasSelection() &&
-			(charNum.GreaterEqual(v.Cursor.CurSelection[0]) && charNum.LessThan(v.Cursor.CurSelection[1]) ||
-				charNum.LessThan(v.Cursor.CurSelection[0]) && charNum.GreaterEqual(v.Cursor.CurSelection[1])) {
-
-			selectStyle := defStyle.Reverse(true)
-
-			if style, ok := colorscheme["selection"]; ok {
-				selectStyle = style
-			}
-			v.drawCell(screenX, screenY, ' ', nil, selectStyle)
-			screenX++
-		}
-
-		charNum = charNum.Move(1, v.Buf)
-
-		for i := 0; i < v.width; i++ {
-			lineStyle := defStyle
-			if v.Buf.Settings["cursorline"].(bool) && tabs[curTab].curView == v.Num && !v.Cursor.HasSelection() && v.Cursor.Y == curLineN {
-				if style, ok := colorscheme["cursor-line"]; ok {
-					fg, _, _ := style.Decompose()
-					lineStyle = lineStyle.Background(fg)
-				}
-			}
-			if screenX-v.x-v.leftCol+i >= v.lineNumOffset {
-				v.drawCell(screenX-v.leftCol+i, screenY, ' ', nil, lineStyle)
-			}
-		}
-	}
-}
-
-// DisplayCursor draws the current buffer's cursor to the screen
-func (v *View) DisplayCursor() {
-	// Don't draw the cursor if it is out of the viewport or if it has a selection
-	if (v.Cursor.Y-v.Topline < 0 || v.Cursor.Y-v.Topline > v.height-1) || v.Cursor.HasSelection() {
-		screen.HideCursor()
-	} else {
-		screen.ShowCursor(v.x+v.Cursor.GetVisualX()+v.lineNumOffset-v.leftCol, v.Cursor.Y-v.Topline+v.y)
-	}
-}
-
-// Display renders the view, the cursor, and statusline
-func (v *View) Display() {
-	v.DisplayView()
-	if v.Num == tabs[curTab].curView {
-		v.DisplayCursor()
-	}
-	_, screenH := screen.Size()
-	if v.Buf.Settings["statusline"].(bool) {
-		v.sline.Display()
-	} else if (v.y + v.height) != screenH-1 {
-		for x := 0; x < v.width; x++ {
-			screen.SetContent(v.x+x, v.y+v.height, '-', nil, defStyle.Reverse(true))
-		}
-	}
-}

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

@@ -0,0 +1,23 @@
+<?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>
+	<metadata_license>MIT</metadata_license>
+	<categories>
+		<category>Development</category>
+		<category>TextEditor</category>
+	</categories>
+	<provides>
+	​	<binary>micro</binary>
+	​</provides>
+	​<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>
+	<url type="homepage">https://micro-editor.github.io</url>
+	<url type="bugtracker">https://github.com/zyedidia/micro/issues</url>
+​</component>

go.mod

@@ -0,0 +1,38 @@
+module github.com/zyedidia/micro
+
+require (
+	github.com/blang/semver v3.5.1+incompatible
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/dustin/go-humanize v1.0.0
+	github.com/flynn/json5 v0.0.0-20160717195620-7620272ed633
+	github.com/gdamore/encoding v1.0.0 // indirect
+	github.com/go-errors/errors v1.0.1
+	github.com/gopherjs/gopherjs v0.0.0-20181103185306-d547d1d9531e // indirect
+	github.com/jtolds/gls v4.2.1+incompatible // indirect
+	github.com/kr/pretty v0.1.0 // indirect
+	github.com/kylelemons/godebug v0.0.0-20170820004349-d65d576e9348 // indirect
+	github.com/lucasb-eyer/go-colorful v0.0.0-20181028223441-12d3b2882a08 // indirect
+	github.com/mattn/go-isatty v0.0.4
+	github.com/mattn/go-runewidth v0.0.4
+	github.com/mitchellh/go-homedir v1.1.0
+	github.com/npat-efault/poller v2.0.0+incompatible // indirect
+	github.com/robertkrimen/otto v0.0.0-20180617131154-15f95af6e78d // indirect
+	github.com/sergi/go-diff v1.0.0
+	github.com/smartystreets/assertions v0.0.0-20190116191733-b6c0e53d7304 // indirect
+	github.com/smartystreets/goconvey v0.0.0-20181108003508-044398e4856c // indirect
+	github.com/stretchr/testify v1.3.0
+	github.com/yuin/gopher-lua v0.0.0-20190125051437-7b9317363aa9
+	github.com/zyedidia/clipboard v0.0.0-20180718195219-bd31d747117d
+	github.com/zyedidia/glob v0.0.0-20170209203856-dd4023a66dc3
+	github.com/zyedidia/poller v2.0.0+incompatible // indirect
+	github.com/zyedidia/pty v1.1.2-0.20180126010845-30364665a244 // indirect
+	github.com/zyedidia/tcell v0.0.0-20191219170756-59b50b23fa9b
+	github.com/zyedidia/terminal v0.0.0-20180726154117-533c623e2415
+	golang.org/x/sys v0.0.0-20180903190138-2b024373dcd9 // indirect
+	golang.org/x/text v0.3.0
+	gopkg.in/DATA-DOG/go-sqlmock.v1 v1.3.0 // indirect
+	gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect
+	gopkg.in/sourcemap.v1 v1.0.5 // indirect
+	gopkg.in/yaml.v2 v2.2.2
+	layeh.com/gopher-luar v1.0.4
+)

go.sum

@@ -0,0 +1,79 @@
+github.com/blang/semver v3.5.1+incompatible h1:cQNTCjp13qL8KC3Nbxr/y2Bqb63oX6wdnnjpJbkM4JQ=
+github.com/blang/semver v3.5.1+incompatible/go.mod h1:kRBLl5iJ+tD4TcOOxsy/0fnwebNt5EWlYSAyrTnjyyk=
+github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dustin/go-humanize v1.0.0 h1:VSnTsYCnlFHaM2/igO1h6X3HA71jcobQuxemgkq4zYo=
+github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
+github.com/flynn/json5 v0.0.0-20160717195620-7620272ed633 h1:xJMmr4GMYIbALX5edyoDIOQpc2bOQTeJiWMeCl9lX/8=
+github.com/flynn/json5 v0.0.0-20160717195620-7620272ed633/go.mod h1:NJDK3/o7abx6PP54EOe0G0n0RLmhCo9xv61gUYpI0EY=
+github.com/gdamore/encoding v1.0.0 h1:+7OoQ1Bc6eTm5niUzBa0Ctsh6JbMW6Ra+YNuAtDBdko=
+github.com/gdamore/encoding v1.0.0/go.mod h1:alR0ol34c49FCSBLjhosxzcPHQbf2trDkoo5dl+VrEg=
+github.com/go-errors/errors v1.0.1 h1:LUHzmkK3GUKUrL/1gfBUxAHzcev3apQlezX/+O7ma6w=
+github.com/go-errors/errors v1.0.1/go.mod h1:f4zRHt4oKfwPJE5k8C9vpYG+aDHdBFUsgrm6/TyX73Q=
+github.com/gopherjs/gopherjs v0.0.0-20181103185306-d547d1d9531e h1:JKmoR8x90Iww1ks85zJ1lfDGgIiMDuIptTOhJq+zKyg=
+github.com/gopherjs/gopherjs v0.0.0-20181103185306-d547d1d9531e/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
+github.com/jtolds/gls v4.2.1+incompatible h1:fSuqC+Gmlu6l/ZYAoZzx2pyucC8Xza35fpRVWLVmUEE=
+github.com/jtolds/gls v4.2.1+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
+github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/kylelemons/godebug v0.0.0-20170820004349-d65d576e9348 h1:MtvEpTB6LX3vkb4ax0b5D2DHbNAUsen0Gx5wZoq3lV4=
+github.com/kylelemons/godebug v0.0.0-20170820004349-d65d576e9348/go.mod h1:B69LEHPfb2qLo0BaaOLcbitczOKLWTsrBG9LczfCD4k=
+github.com/lucasb-eyer/go-colorful v0.0.0-20181028223441-12d3b2882a08 h1:5MnxBC15uMxFv5FY/J/8vzyaBiArCOkMdFT9Jsw78iY=
+github.com/lucasb-eyer/go-colorful v0.0.0-20181028223441-12d3b2882a08/go.mod h1:NXg0ArsFk0Y01623LgUqoqcouGDB+PwCCQlrwrG6xJ4=
+github.com/mattn/go-isatty v0.0.4 h1:bnP0vzxcAdeI1zdubAl5PjU6zsERjGZb7raWodagDYs=
+github.com/mattn/go-isatty v0.0.4/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
+github.com/mattn/go-runewidth v0.0.4 h1:2BvfKmzob6Bmd4YsL0zygOqfdFnK7GR4QL06Do4/p7Y=
+github.com/mattn/go-runewidth v0.0.4/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU=
+github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y=
+github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
+github.com/npat-efault/poller v2.0.0+incompatible h1:jtTdXWKgN5kDK41ts8hoY1rvTEi0K08MTB8/bRO9MqE=
+github.com/npat-efault/poller v2.0.0+incompatible/go.mod h1:lni01B89P8PtVpwlAhdhK1niN5rPkDGGpGGgBJzpSgo=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/robertkrimen/otto v0.0.0-20180617131154-15f95af6e78d h1:1VUlQbCfkoSGv7qP7Y+ro3ap1P1pPZxgdGVqiTVy5C4=
+github.com/robertkrimen/otto v0.0.0-20180617131154-15f95af6e78d/go.mod h1:xvqspoSXJTIpemEonrMDFq6XzwHYYgToXWj5eRX1OtY=
+github.com/sergi/go-diff v1.0.0 h1:Kpca3qRNrduNnOQeazBd0ysaKrUJiIuISHxogkT9RPQ=
+github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
+github.com/smartystreets/assertions v0.0.0-20190116191733-b6c0e53d7304 h1:Jpy1PXuP99tXNrhbq2BaPz9B+jNAvH1JPQQpG/9GCXY=
+github.com/smartystreets/assertions v0.0.0-20190116191733-b6c0e53d7304/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
+github.com/smartystreets/goconvey v0.0.0-20181108003508-044398e4856c h1:Ho+uVpkel/udgjbwB5Lktg9BtvJSh2DT0Hi6LPSyI2w=
+github.com/smartystreets/goconvey v0.0.0-20181108003508-044398e4856c/go.mod h1:XDJAKZRPZ1CvBcN2aX5YOUTYGHki24fSF0Iv48Ibg0s=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/yuin/gopher-lua v0.0.0-20190125051437-7b9317363aa9 h1:Wy3fAQLBPP0JSWdq3kBnmbFgXDHcyhtPpd+8kENV7mU=
+github.com/yuin/gopher-lua v0.0.0-20190125051437-7b9317363aa9/go.mod h1:fFiAh+CowNFr0NK5VASokuwKwkbacRmHsVA7Yb1Tqac=
+github.com/zyedidia/clipboard v0.0.0-20180718195219-bd31d747117d h1:Lhqt2eo+rgM8aswvM7nTtAMVm8ARPWzkE9n6eZDOccY=
+github.com/zyedidia/clipboard v0.0.0-20180718195219-bd31d747117d/go.mod h1:WDk3p8GiZV9+xFWlSo8qreeoLhW6Ik692rqXk+cNeRY=
+github.com/zyedidia/glob v0.0.0-20170209203856-dd4023a66dc3 h1:oMHjjTLfGXVuyOQBYj5/td9WC0mw4g1xDBPovIqmHew=
+github.com/zyedidia/glob v0.0.0-20170209203856-dd4023a66dc3/go.mod h1:YKbIYP//Eln8eDgAJGI3IDvR3s4Tv9Z9TGIOumiyQ5c=
+github.com/zyedidia/poller v2.0.0+incompatible h1:DMOvB0EXz2JTokqOKfxPWN/8xXFJbO+m4vNhMkOY7Lo=
+github.com/zyedidia/poller v2.0.0+incompatible/go.mod h1:vZXJOHGDcuK08GXhF6IAY0ZFd2WcgOR5DOTp84Uk5eE=
+github.com/zyedidia/pty v1.1.2-0.20180126010845-30364665a244 h1:DZ7mZvUV5+oXeXV1E1t6ZIXRihHYyqYVIOSA+RGo88A=
+github.com/zyedidia/pty v1.1.2-0.20180126010845-30364665a244/go.mod h1:4y9l9yJZNxRa7GB/fB+mmDmGkG3CqmzLf4vUxGGotEA=
+github.com/zyedidia/tcell v0.0.0-20190204041104-518c15c24302 h1:ruNSURcO81y+J+XnqrLLt+zxcdFtq8QNoZfWXSsybYQ=
+github.com/zyedidia/tcell v0.0.0-20190204041104-518c15c24302/go.mod h1:yXgdp23+aW8OMENYVBvpKoeiBtjaVWJ9HhpPDu6LBfM=
+github.com/zyedidia/tcell v0.0.0-20191219170756-59b50b23fa9b h1:cryFENlMxJJrkimVx/CUMFDCxC4vpmey2x3A3tAgTNM=
+github.com/zyedidia/tcell v0.0.0-20191219170756-59b50b23fa9b/go.mod h1:yXgdp23+aW8OMENYVBvpKoeiBtjaVWJ9HhpPDu6LBfM=
+github.com/zyedidia/terminal v0.0.0-20180726154117-533c623e2415 h1:752dTQ5OatJ9M5ULK2+9lor+nzyZz+LYDo3WGngg3Rc=
+github.com/zyedidia/terminal v0.0.0-20180726154117-533c623e2415/go.mod h1:8leT8G0Cm8NoJHdrrKHyR9MirWoF4YW7pZh06B6H+1E=
+golang.org/x/sys v0.0.0-20180903190138-2b024373dcd9 h1:lkiLiLBHGoH3XnqSLUIaBsilGMUjI+Uy2Xu2JLUtTas=
+golang.org/x/sys v0.0.0-20180903190138-2b024373dcd9/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+gopkg.in/DATA-DOG/go-sqlmock.v1 v1.3.0 h1:FVCohIoYO7IJoDDVpV2pdq7SgrMH6wHnuTyrdrxJNoY=
+gopkg.in/DATA-DOG/go-sqlmock.v1 v1.3.0/go.mod h1:OdE7CF6DbADk7lN8LIKRzRJTTZXIjtWgA5THM5lhBAw=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/sourcemap.v1 v1.0.5 h1:inv58fC9f9J3TK2Y2R1NPntXEn3/wjWHkonhIUODNTI=
+gopkg.in/sourcemap.v1 v1.0.5/go.mod h1:2RlvNNSMglmRrcvhfuzp4hQHwOtjxlbjX7UPY/GXb78=
+gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+layeh.com/gopher-luar v1.0.4 h1:BFgt94J/CXh4HkDcE2b7A7pBaVeQKEVfHEBRKL/K/Tc=
+layeh.com/gopher-luar v1.0.4/go.mod h1:N3rev/ttQd8yVluXaYsa0M/eknzRYWe+pxZ35ZFmaaI=

internal/action/actions_other.go

@@ -0,0 +1,8 @@
+// +build plan9 nacl windows
+
+package action
+
+func (*BufPane) Suspend() bool {
+	InfoBar.Error("Suspend is only supported on BSD/Linux")
+	return false
+}

internal/action/actions_posix.go

@@ -0,0 +1,27 @@
+// +build linux darwin dragonfly solaris openbsd netbsd freebsd
+
+package action
+
+import (
+	"syscall"
+
+	"github.com/zyedidia/micro/internal/screen"
+)
+
+// 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 (*BufPane) Suspend() bool {
+	screenb := screen.TempFini()
+
+	// suspend the process
+	pid := syscall.Getpid()
+	err := syscall.Kill(pid, syscall.SIGSTOP)
+	if err != nil {
+		screen.TermMessage(err)
+	}
+
+	screen.TempStart(screenb)
+
+	return false
+}

internal/action/bindings.go

@@ -1,88 +1,261 @@
-package main
+package action
 
 import (
 	"encoding/json"
+	"errors"
 	"io/ioutil"
 	"os"
 	"strings"
+	"unicode"
 
+	"github.com/flynn/json5"
+	"github.com/zyedidia/micro/internal/config"
+	"github.com/zyedidia/micro/internal/screen"
 	"github.com/zyedidia/tcell"
 )
 
-var bindings map[Key][]func(*View, bool) bool
-var helpBinding string
+func InitBindings() {
+	config.Bindings = DefaultBindings()
 
-var bindingActions = map[string]func(*View, bool) bool{
-	"CursorUp":            (*View).CursorUp,
-	"CursorDown":          (*View).CursorDown,
-	"CursorPageUp":        (*View).CursorPageUp,
-	"CursorPageDown":      (*View).CursorPageDown,
-	"CursorLeft":          (*View).CursorLeft,
-	"CursorRight":         (*View).CursorRight,
-	"CursorStart":         (*View).CursorStart,
-	"CursorEnd":           (*View).CursorEnd,
-	"SelectToStart":       (*View).SelectToStart,
-	"SelectToEnd":         (*View).SelectToEnd,
-	"SelectUp":            (*View).SelectUp,
-	"SelectDown":          (*View).SelectDown,
-	"SelectLeft":          (*View).SelectLeft,
-	"SelectRight":         (*View).SelectRight,
-	"WordRight":           (*View).WordRight,
-	"WordLeft":            (*View).WordLeft,
-	"SelectWordRight":     (*View).SelectWordRight,
-	"SelectWordLeft":      (*View).SelectWordLeft,
-	"DeleteWordRight":     (*View).DeleteWordRight,
-	"DeleteWordLeft":      (*View).DeleteWordLeft,
-	"SelectToStartOfLine": (*View).SelectToStartOfLine,
-	"SelectToEndOfLine":   (*View).SelectToEndOfLine,
-	"InsertNewline":       (*View).InsertNewline,
-	"InsertSpace":         (*View).InsertSpace,
-	"Backspace":           (*View).Backspace,
-	"Delete":              (*View).Delete,
-	"InsertTab":           (*View).InsertTab,
-	"Save":                (*View).Save,
-	"Find":                (*View).Find,
-	"FindNext":            (*View).FindNext,
-	"FindPrevious":        (*View).FindPrevious,
-	"Center":              (*View).Center,
-	"Undo":                (*View).Undo,
-	"Redo":                (*View).Redo,
-	"Copy":                (*View).Copy,
-	"Cut":                 (*View).Cut,
-	"CutLine":             (*View).CutLine,
-	"DuplicateLine":       (*View).DuplicateLine,
-	"DeleteLine":          (*View).DeleteLine,
-	"IndentSelection":     (*View).IndentSelection,
-	"OutdentSelection":    (*View).OutdentSelection,
-	"Paste":               (*View).Paste,
-	"SelectAll":           (*View).SelectAll,
-	"OpenFile":            (*View).OpenFile,
-	"Start":               (*View).Start,
-	"End":                 (*View).End,
-	"PageUp":              (*View).PageUp,
-	"PageDown":            (*View).PageDown,
-	"HalfPageUp":          (*View).HalfPageUp,
-	"HalfPageDown":        (*View).HalfPageDown,
-	"StartOfLine":         (*View).StartOfLine,
-	"EndOfLine":           (*View).EndOfLine,
-	"ToggleHelp":          (*View).ToggleHelp,
-	"ToggleRuler":         (*View).ToggleRuler,
-	"JumpLine":            (*View).JumpLine,
-	"ClearStatus":         (*View).ClearStatus,
-	"ShellMode":           (*View).ShellMode,
-	"CommandMode":         (*View).CommandMode,
-	"Quit":                (*View).Quit,
-	"AddTab":              (*View).AddTab,
-	"PreviousTab":         (*View).PreviousTab,
-	"NextTab":             (*View).NextTab,
-	"NextSplit":           (*View).NextSplit,
-	"PreviousSplit":       (*View).PreviousSplit,
+	var parsed map[string]string
+	defaults := DefaultBindings()
 
-	// This was changed to InsertNewline but I don't want to break backwards compatibility
-	"InsertEnter": (*View).InsertNewline,
+	filename := config.ConfigDir + "/bindings.json"
+	if _, e := os.Stat(filename); e == nil {
+		input, err := ioutil.ReadFile(filename)
+		if err != nil {
+			screen.TermMessage("Error reading bindings.json file: " + err.Error())
+			return
+		}
+
+		err = json5.Unmarshal(input, &parsed)
+		if err != nil {
+			screen.TermMessage("Error reading bindings.json:", err.Error())
+		}
+	}
+
+	for k, v := range defaults {
+		BindKey(k, v)
+	}
+	for k, v := range parsed {
+		BindKey(k, v)
+	}
 }
 
-var bindingKeys = map[string]tcell.Key{
+func BindKey(k, v string) {
+	event, ok := findEvent(k)
+	if !ok {
+		screen.TermMessage(k, "is not a bindable event")
+	}
+
+	switch e := event.(type) {
+	case KeyEvent:
+		BufMapKey(e, v)
+	case MouseEvent:
+		BufMapMouse(e, v)
+	case RawEvent:
+		BufMapKey(e, v)
+	}
+
+	config.Bindings[k] = v
+}
+
+// findEvent will find binding Key 'b' using string 'k'
+func findEvent(k string) (b Event, ok bool) {
+	modifiers := tcell.ModNone
+
+	// First, we'll strip off all the modifiers in the name and add them to the
+	// ModMask
+modSearch:
+	for {
+		switch {
+		case strings.HasPrefix(k, "-"):
+			// We optionally support dashes between modifiers
+			k = k[1:]
+		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"):
+			k = k[3:]
+			modifiers |= tcell.ModAlt
+		case strings.HasPrefix(k, "Shift"):
+			k = k[5:]
+			modifiers |= tcell.ModShift
+		case strings.HasPrefix(k, "\x1b"):
+			return RawEvent{
+				esc: k,
+			}, true
+		default:
+			break modSearch
+		}
+	}
+
+	if len(k) == 0 {
+		return KeyEvent{}, false
+	}
+
+	// Control is handled in a special way, since the terminal sends explicitly
+	// marked escape sequences for control keys
+	// We should check for Control keys first
+	if modifiers&tcell.ModCtrl != 0 {
+		// see if the key is in bindingKeys with the Ctrl prefix.
+		k = string(unicode.ToUpper(rune(k[0]))) + k[1:]
+		if code, ok := keyEvents["Ctrl"+k]; ok {
+			var r tcell.Key
+			// Special case for escape, for some reason tcell doesn't send it with the esc character
+			if code < 256 && code != 27 {
+				r = code
+			}
+			// It is, we're done.
+			return KeyEvent{
+				code: code,
+				mod:  modifiers,
+				r:    rune(r),
+			}, true
+		}
+	}
+
+	// See if we can find the key in bindingKeys
+	if code, ok := keyEvents[k]; ok {
+		var r tcell.Key
+		// Special case for escape, for some reason tcell doesn't send it with the esc character
+		if code < 256 && code != 27 {
+			r = code
+		}
+		return KeyEvent{
+			code: code,
+			mod:  modifiers,
+			r:    rune(r),
+		}, true
+	}
+
+	// See if we can find the key in bindingMouse
+	if code, ok := mouseEvents[k]; ok {
+		return MouseEvent{
+			btn: code,
+			mod: modifiers,
+		}, true
+	}
+
+	// If we were given one character, then we've got a rune.
+	if len(k) == 1 {
+		return KeyEvent{
+			code: tcell.KeyRune,
+			mod:  modifiers,
+			r:    rune(k[0]),
+		}, true
+	}
+
+	// We don't know what happened.
+	return KeyEvent{}, false
+}
+
+// TryBindKey tries to bind a key by writing to config.ConfigDir/bindings.json
+// Returns true if the keybinding already existed and a possible error
+func TryBindKey(k, v string, overwrite bool) (bool, error) {
+	var e error
+	var parsed map[string]string
+
+	filename := config.ConfigDir + "/bindings.json"
+	if _, e = os.Stat(filename); e == nil {
+		input, err := ioutil.ReadFile(filename)
+		if err != nil {
+			return false, errors.New("Error reading bindings.json file: " + err.Error())
+		}
+
+		err = json5.Unmarshal(input, &parsed)
+		if err != nil {
+			return false, errors.New("Error reading bindings.json: " + err.Error())
+		}
+
+		key, ok := findEvent(k)
+		if !ok {
+			return false, errors.New("Invalid event " + k)
+		}
+
+		found := false
+		for ev := range parsed {
+			if e, ok := findEvent(ev); ok {
+				if e == key {
+					if overwrite {
+						parsed[ev] = v
+					}
+					found = true
+					break
+				}
+			}
+		}
+
+		if found && !overwrite {
+			return true, nil
+		} else if !found {
+			parsed[k] = v
+		}
+
+		BindKey(k, v)
+
+		txt, _ := json.MarshalIndent(parsed, "", "    ")
+		return true, ioutil.WriteFile(filename, append(txt, '\n'), 0644)
+	}
+	return false, e
+}
+
+// UnbindKey removes the binding for a key from the bindings.json file
+func UnbindKey(k string) error {
+	var e error
+	var parsed map[string]string
+
+	filename := config.ConfigDir + "/bindings.json"
+	if _, e = os.Stat(filename); e == nil {
+		input, err := ioutil.ReadFile(filename)
+		if err != nil {
+			return errors.New("Error reading bindings.json file: " + err.Error())
+		}
+
+		err = json5.Unmarshal(input, &parsed)
+		if err != nil {
+			return errors.New("Error reading bindings.json: " + err.Error())
+		}
+
+		key, ok := findEvent(k)
+		if !ok {
+			return errors.New("Invalid event " + k)
+		}
+
+		for ev := range parsed {
+			if e, ok := findEvent(ev); ok {
+				if e == key {
+					delete(parsed, ev)
+					break
+				}
+			}
+		}
+
+		defaults := DefaultBindings()
+		if a, ok := defaults[k]; ok {
+			BindKey(k, a)
+		} else if _, ok := config.Bindings[k]; ok {
+			delete(config.Bindings, k)
+		}
+
+		txt, _ := json.MarshalIndent(parsed, "", "    ")
+		return ioutil.WriteFile(filename, append(txt, '\n'), 0644)
+	}
+	return e
+}
+
+var mouseEvents = map[string]tcell.ButtonMask{
+	"MouseLeft":       tcell.Button1,
+	"MouseMiddle":     tcell.Button2,
+	"MouseRight":      tcell.Button3,
+	"MouseWheelUp":    tcell.WheelUp,
+	"MouseWheelDown":  tcell.WheelDown,
+	"MouseWheelLeft":  tcell.WheelLeft,
+	"MouseWheelRight": tcell.WheelRight,
+}
+
+var keyEvents = map[string]tcell.Key{
 	"Up":             tcell.KeyUp,
 	"Down":           tcell.KeyDown,
 	"Right":          tcell.KeyRight,
@@ -201,149 +374,20 @@ var bindingKeys = map[string]tcell.Key{
 	"CtrlRightSq":    tcell.KeyCtrlRightSq,
 	"CtrlCarat":      tcell.KeyCtrlCarat,
 	"CtrlUnderscore": tcell.KeyCtrlUnderscore,
-	"Backspace":      tcell.KeyBackspace,
+	"CtrlPageUp":     tcell.KeyCtrlPgUp,
+	"CtrlPageDown":   tcell.KeyCtrlPgDn,
 	"Tab":            tcell.KeyTab,
 	"Esc":            tcell.KeyEsc,
 	"Escape":         tcell.KeyEscape,
 	"Enter":          tcell.KeyEnter,
-	"Backspace2":     tcell.KeyBackspace2,
+	"Backspace":      tcell.KeyBackspace2,
+	"OldBackspace":   tcell.KeyBackspace,
 
 	// I renamed these keys to PageUp and PageDown but I don't want to break someone's keybindings
 	"PgUp":   tcell.KeyPgUp,
 	"PgDown": tcell.KeyPgDn,
 }
 
-// The Key struct holds the data for a keypress (keycode + modifiers)
-type Key struct {
-	keyCode   tcell.Key
-	modifiers tcell.ModMask
-	r         rune
-}
-
-// InitBindings initializes the keybindings for micro
-func InitBindings() {
-	bindings = make(map[Key][]func(*View, bool) bool)
-
-	var parsed map[string]string
-	defaults := DefaultBindings()
-
-	filename := configDir + "/bindings.json"
-	if _, e := os.Stat(filename); e == nil {
-		input, err := ioutil.ReadFile(filename)
-		if err != nil {
-			TermMessage("Error reading bindings.json file: " + err.Error())
-			return
-		}
-
-		err = json.Unmarshal(input, &parsed)
-		if err != nil {
-			TermMessage("Error reading bindings.json:", err.Error())
-		}
-	}
-
-	parseBindings(defaults)
-	parseBindings(parsed)
-}
-
-func parseBindings(userBindings map[string]string) {
-	for k, v := range userBindings {
-		BindKey(k, v)
-	}
-}
-
-// findKey will find binding Key 'b' using string 'k'
-func findKey(k string) (b Key, ok bool) {
-	modifiers := tcell.ModNone
-
-	// First, we'll strip off all the modifiers in the name and add them to the
-	// ModMask
-modSearch:
-	for {
-		switch {
-		case strings.HasPrefix(k, "-"):
-			// We optionally support dashes between modifiers
-			k = k[1:]
-		case strings.HasPrefix(k, "Ctrl"):
-			k = k[4:]
-			modifiers |= tcell.ModCtrl
-		case strings.HasPrefix(k, "Alt"):
-			k = k[3:]
-			modifiers |= tcell.ModAlt
-		case strings.HasPrefix(k, "Shift"):
-			k = k[5:]
-			modifiers |= tcell.ModShift
-		default:
-			break modSearch
-		}
-	}
-
-	// Control is handled specially, since some character codes in bindingKeys
-	// are different when Control is depressed. We should check for Control keys
-	// first.
-	if modifiers&tcell.ModCtrl != 0 {
-		// see if the key is in bindingKeys with the Ctrl prefix.
-		if code, ok := bindingKeys["Ctrl"+k]; ok {
-			// It is, we're done.
-			return Key{
-				keyCode:   code,
-				modifiers: modifiers,
-				r:         0,
-			}, true
-		}
-	}
-
-	// See if we can find the key in bindingKeys
-	if code, ok := bindingKeys[k]; ok {
-		return Key{
-			keyCode:   code,
-			modifiers: modifiers,
-			r:         0,
-		}, true
-	}
-
-	// If we were given one character, then we've got a rune.
-	if len(k) == 1 {
-		return Key{
-			keyCode:   tcell.KeyRune,
-			modifiers: modifiers,
-			r:         rune(k[0]),
-		}, true
-	}
-
-	// We don't know what happened.
-	return Key{}, false
-}
-
-// findAction will find 'action' using string 'v'
-func findAction(v string) (action func(*View, bool) bool) {
-	action, ok := bindingActions[v]
-	if !ok {
-		// If the user seems to be binding a function that doesn't exist
-		// We hope that it's a lua function that exists and bind it to that
-		action = LuaFunctionBinding(v)
-	}
-	return action
-}
-
-// BindKey takes a key and an action and binds the two together
-func BindKey(k, v string) {
-	key, ok := findKey(k)
-	if !ok {
-		return
-	}
-	if v == "ToggleHelp" {
-		helpBinding = k
-	}
-
-	actionNames := strings.Split(v, ",")
-	actions := make([]func(*View, bool) bool, 0, len(actionNames))
-	for _, actionName := range actionNames {
-		actions = append(actions, findAction(actionName))
-	}
-
-	bindings[key] = actions
-}
-
 // DefaultBindings returns a map containing micro's default keybindings
 func DefaultBindings() map[string]string {
 	return map[string]string{
@@ -357,24 +401,29 @@ 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",
+		"Alt-{":          "ParagraphPrevious",
+		"Alt-}":          "ParagraphNext",
 		"Enter":          "InsertNewline",
-		"Space":          "InsertSpace",
+		"CtrlH":          "Backspace",
 		"Backspace":      "Backspace",
-		"Backspace2":     "Backspace",
+		"Alt-CtrlH":      "DeleteWordLeft",
 		"Alt-Backspace":  "DeleteWordLeft",
-		"Alt-Backspace2": "DeleteWordLeft",
-		"Tab":            "IndentSelection,InsertTab",
-		"Backtab":        "OutdentSelection",
+		"Tab":            "Autocomplete|IndentSelection|InsertTab",
+		"Backtab":        "OutdentSelection|OutdentLine",
 		"CtrlO":          "OpenFile",
 		"CtrlS":          "Save",
 		"CtrlF":          "Find",
@@ -389,28 +438,56 @@ 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",
+		"CtrlPageUp":     "PreviousTab",
+		"CtrlPageDown":   "NextTab",
 		"CtrlG":          "ToggleHelp",
+		"Alt-g":          "ToggleKeyMenu",
 		"CtrlR":          "ToggleRuler",
-		"CtrlL":          "JumpLine",
+		"CtrlL":          "command-edit:goto ",
 		"Delete":         "Delete",
-		"Esc":            "ClearStatus",
 		"CtrlB":          "ShellMode",
 		"CtrlQ":          "Quit",
 		"CtrlE":          "CommandMode",
 		"CtrlW":          "NextSplit",
+		"CtrlU":          "ToggleMacro",
+		"CtrlJ":          "PlayMacro",
+		"Insert":         "ToggleOverwriteMode",
 
 		// Emacs-style keybindings
 		"Alt-f": "WordRight",
 		"Alt-b": "WordLeft",
 		"Alt-a": "StartOfLine",
 		"Alt-e": "EndOfLine",
-		"Alt-p": "CursorUp",
-		"Alt-n": "CursorDown",
+		// "Alt-p": "CursorUp",
+		// "Alt-n": "CursorDown",
+
+		// Integration with file managers
+		"F2":  "Save",
+		"F3":  "Find",
+		"F4":  "Quit",
+		"F7":  "Find",
+		"F10": "Quit",
+		"Esc": "Escape",
+
+		// Mouse bindings
+		"MouseWheelUp":   "ScrollUp",
+		"MouseWheelDown": "ScrollDown",
+		"MouseLeft":      "MousePress",
+		"MouseMiddle":    "PastePrimary",
+		"Ctrl-MouseLeft": "MouseMultiCursor",
+
+		"Alt-n": "SpawnMultiCursor",
+		"Alt-m": "SpawnMultiCursorSelect",
+		"Alt-p": "RemoveMultiCursor",
+		"Alt-c": "RemoveAllMultiCursors",
+		"Alt-x": "SkipMultiCursor",
 	}
 }

internal/action/bufpane.go

@@ -0,0 +1,601 @@
+package action
+
+import (
+	"strings"
+	"time"
+
+	luar "layeh.com/gopher-luar"
+
+	lua "github.com/yuin/gopher-lua"
+	"github.com/zyedidia/micro/internal/buffer"
+	"github.com/zyedidia/micro/internal/config"
+	"github.com/zyedidia/micro/internal/display"
+	ulua "github.com/zyedidia/micro/internal/lua"
+	"github.com/zyedidia/micro/internal/screen"
+	"github.com/zyedidia/tcell"
+)
+
+type BufKeyAction func(*BufPane) bool
+type BufMouseAction func(*BufPane, *tcell.EventMouse) bool
+
+var BufKeyBindings map[Event]BufKeyAction
+var BufKeyStrings map[Event]string
+var BufMouseBindings map[MouseEvent]BufMouseAction
+
+func init() {
+	BufKeyBindings = make(map[Event]BufKeyAction)
+	BufKeyStrings = make(map[Event]string)
+	BufMouseBindings = make(map[MouseEvent]BufMouseAction)
+}
+
+func LuaAction(fn string) func(*BufPane) bool {
+	luaFn := strings.Split(fn, ".")
+	if len(luaFn) <= 1 {
+		return nil
+	}
+	plName, plFn := luaFn[0], luaFn[1]
+	pl := config.FindPlugin(plName)
+	if pl == nil {
+		return nil
+	}
+	return func(h *BufPane) bool {
+		val, err := pl.Call(plFn, luar.New(ulua.L, h))
+		if err != nil {
+			screen.TermMessage(err)
+		}
+		if v, ok := val.(lua.LBool); !ok {
+			return false
+		} else {
+			return bool(v)
+		}
+	}
+}
+
+// BufMapKey maps a key event to an action
+func BufMapKey(k Event, action string) {
+	BufKeyStrings[k] = action
+	var actionfns []func(*BufPane) bool
+	var names []string
+	var types []byte
+	for i := 0; ; i++ {
+		if action == "" {
+			break
+		}
+
+		idx := strings.IndexAny(action, "&|,")
+		a := action
+		if idx >= 0 {
+			a = action[:idx]
+			types = append(types, action[idx])
+			action = action[idx+1:]
+		} else {
+			types = append(types, ' ')
+			action = ""
+		}
+
+		var afn func(*BufPane) bool
+		if strings.HasPrefix(action, "command:") {
+			a = strings.SplitN(a, ":", 2)[1]
+			afn = CommandAction(a)
+			names = append(names, "")
+		} else if strings.HasPrefix(a, "command-edit:") {
+			a = strings.SplitN(a, ":", 2)[1]
+			afn = CommandEditAction(a)
+			names = append(names, "")
+		} else if strings.HasPrefix(a, "lua:") {
+			a = strings.SplitN(a, ":", 2)[1]
+			afn = LuaAction(a)
+			if afn == nil {
+				screen.TermMessage("Lua Error:", action, "does not exist")
+				continue
+			}
+			names = append(names, "")
+		} else if f, ok := BufKeyActions[a]; ok {
+			afn = f
+			names = append(names, a)
+		} else {
+			screen.TermMessage("Error:", action, "does not exist")
+			continue
+		}
+		actionfns = append(actionfns, afn)
+	}
+	BufKeyBindings[k] = func(h *BufPane) bool {
+		cursors := h.Buf.GetCursors()
+		success := true
+		for i, a := range actionfns {
+			for j, c := range cursors {
+				h.Buf.SetCurCursor(c.Num)
+				h.Cursor = c
+				if i == 0 || (success && types[i-1] == '&') || (!success && types[i-1] == '|') || (types[i-1] == ',') {
+					success = h.execAction(a, names[i], j)
+				} else {
+					break
+				}
+			}
+		}
+		return true
+	}
+}
+
+// BufMapMouse maps a mouse event to an action
+func BufMapMouse(k MouseEvent, action string) {
+	if f, ok := BufMouseActions[action]; ok {
+		BufMouseBindings[k] = f
+	} else {
+		delete(BufMouseBindings, k)
+		BufMapKey(k, action)
+	}
+}
+
+// The BufPane connects the buffer and the window
+// It provides a cursor (or multiple) and defines a set of actions
+// that can be taken on the buffer
+// The ActionHandler can access the window for necessary info about
+// visual positions for mouse clicks and scrolling
+type BufPane struct {
+	display.BWindow
+
+	Buf *buffer.Buffer
+
+	Cursor *buffer.Cursor // the active cursor
+
+	// Since tcell doesn't differentiate between a mouse release event
+	// and a mouse move event with no keys pressed, we need to keep
+	// track of whether or not the mouse was pressed (or not released) last event to determine
+	// mouse release events
+	mouseReleased bool
+
+	// We need to keep track of insert key press toggle
+	isOverwriteMode bool
+	// This stores when the last click was
+	// This is useful for detecting double and triple clicks
+	lastClickTime time.Time
+	lastLoc       buffer.Loc
+
+	// lastCutTime stores when the last ctrl+k was issued.
+	// It is used for clearing the clipboard to replace it with fresh cut lines.
+	lastCutTime time.Time
+
+	// freshClip returns true if the clipboard has never been pasted.
+	freshClip bool
+
+	// Was the last mouse event actually a double click?
+	// Useful for detecting triple clicks -- if a double click is detected
+	// but the last mouse event was actually a double click, it's a triple click
+	doubleClick bool
+	// Same here, just to keep track for mouse move events
+	tripleClick bool
+
+	// Last search stores the last successful search for FindNext and FindPrev
+	lastSearch string
+	// Should the current multiple cursor selection search based on word or
+	// based on selection (false for selection, true for word)
+	multiWord bool
+
+	splitID uint64
+
+	// remember original location of a search in case the search is canceled
+	searchOrig buffer.Loc
+}
+
+func NewBufPane(buf *buffer.Buffer, win display.BWindow) *BufPane {
+	h := new(BufPane)
+	h.Buf = buf
+	h.BWindow = win
+
+	h.Cursor = h.Buf.GetActiveCursor()
+	h.mouseReleased = true
+
+	config.RunPluginFn("onBufPaneOpen", luar.New(ulua.L, h))
+
+	return h
+}
+
+func NewBufPaneFromBuf(buf *buffer.Buffer) *BufPane {
+	w := display.NewBufWindow(0, 0, 0, 0, buf)
+	return NewBufPane(buf, w)
+}
+
+// PluginCB calls all plugin callbacks with a certain name and
+// displays an error if there is one and returns the aggregrate
+// boolean response
+func (h *BufPane) PluginCB(cb string) bool {
+	b, err := config.RunPluginFnBool(cb, luar.New(ulua.L, h))
+	if err != nil {
+		screen.TermMessage(err)
+	}
+	return b
+}
+
+// PluginCBRune is the same as PluginCB but also passes a rune to
+// the plugins
+func (h *BufPane) PluginCBRune(cb string, r rune) bool {
+	b, err := config.RunPluginFnBool(cb, luar.New(ulua.L, h), luar.New(ulua.L, string(r)))
+	if err != nil {
+		screen.TermMessage(err)
+	}
+	return b
+}
+
+func (h *BufPane) OpenBuffer(b *buffer.Buffer) {
+	h.Buf.Close()
+	h.Buf = b
+	h.BWindow.SetBuffer(b)
+	h.Cursor = b.GetActiveCursor()
+	h.Resize(h.GetView().Width, h.GetView().Height)
+	v := new(display.View)
+	h.SetView(v)
+	h.Relocate()
+	// Set mouseReleased to true because we assume the mouse is not being pressed when
+	// the editor is opened
+	h.mouseReleased = true
+	// Set isOverwriteMode to false, because we assume we are in the default mode when editor
+	// is opened
+	h.isOverwriteMode = false
+	h.lastClickTime = time.Time{}
+}
+
+func (h *BufPane) ID() uint64 {
+	return h.splitID
+}
+
+func (h *BufPane) SetID(i uint64) {
+	h.splitID = i
+}
+
+func (h *BufPane) Name() string {
+	return h.Buf.GetName()
+}
+
+// HandleEvent executes the tcell event properly
+func (h *BufPane) HandleEvent(event tcell.Event) {
+	switch e := event.(type) {
+	case *tcell.EventRaw:
+		re := RawEvent{
+			esc: e.EscSeq(),
+		}
+		h.DoKeyEvent(re)
+	case *tcell.EventKey:
+		ke := KeyEvent{
+			code: e.Key(),
+			mod:  e.Modifiers(),
+			r:    e.Rune(),
+		}
+
+		done := h.DoKeyEvent(ke)
+		if !done && e.Key() == tcell.KeyRune {
+			h.DoRuneInsert(e.Rune())
+		}
+	case *tcell.EventMouse:
+		switch e.Buttons() {
+		case tcell.ButtonNone:
+			// Mouse event with no click
+			if !h.mouseReleased {
+				// Mouse was just released
+
+				mx, my := e.Position()
+				mouseLoc := h.LocFromVisual(buffer.Loc{X: mx, Y: my})
+
+				// Relocating here isn't really necessary because the cursor will
+				// be in the right place from the last mouse event
+				// However, if we are running in a terminal that doesn't support mouse motion
+				// events, this still allows the user to make selections, except only after they
+				// release the mouse
+
+				if !h.doubleClick && !h.tripleClick {
+					h.Cursor.Loc = mouseLoc
+					h.Cursor.SetSelectionEnd(h.Cursor.Loc)
+					h.Cursor.CopySelection("primary")
+				}
+				h.mouseReleased = true
+			}
+		}
+
+		me := MouseEvent{
+			btn: e.Buttons(),
+			mod: e.Modifiers(),
+		}
+		h.DoMouseEvent(me, e)
+	}
+	h.Buf.MergeCursors()
+
+	if h.IsActive() {
+		// Display any gutter messages for this line
+		c := h.Buf.GetActiveCursor()
+		none := true
+		for _, m := range h.Buf.Messages {
+			if c.Y == m.Start.Y || c.Y == m.End.Y {
+				InfoBar.GutterMessage(m.Msg)
+				none = false
+				break
+			}
+		}
+		if none && InfoBar.HasGutter {
+			InfoBar.ClearGutter()
+		}
+	}
+}
+
+// DoKeyEvent executes a key event by finding the action it is bound
+// to and executing it (possibly multiple times for multiple cursors)
+func (h *BufPane) DoKeyEvent(e Event) bool {
+	if action, ok := BufKeyBindings[e]; ok {
+		return action(h)
+	}
+	return false
+}
+
+func (h *BufPane) execAction(action func(*BufPane) bool, name string, cursor int) bool {
+	if name != "Autocomplete" {
+		h.Buf.HasSuggestions = false
+	}
+
+	_, isMulti := MultiActions[name]
+	if (!isMulti && cursor == 0) || isMulti {
+		if h.PluginCB("pre" + name) {
+			asuccess := action(h)
+			psuccess := h.PluginCB("on" + name)
+
+			if isMulti {
+				if recording_macro {
+					if name != "ToggleMacro" && name != "PlayMacro" {
+						curmacro = append(curmacro, action)
+					}
+				}
+			}
+
+			return asuccess && psuccess
+		}
+	}
+
+	return false
+}
+
+func (h *BufPane) HasKeyEvent(e Event) bool {
+	_, ok := BufKeyBindings[e]
+	return ok
+}
+
+// DoMouseEvent executes a mouse event by finding the action it is bound
+// to and executing it
+func (h *BufPane) DoMouseEvent(e MouseEvent, te *tcell.EventMouse) bool {
+	if action, ok := BufMouseBindings[e]; ok {
+		if action(h, te) {
+			h.Relocate()
+		}
+		return true
+	} else if h.HasKeyEvent(e) {
+		return h.DoKeyEvent(e)
+	}
+	return false
+}
+
+// DoRuneInsert inserts a given rune into the current buffer
+// (possibly multiple times for multiple cursors)
+func (h *BufPane) DoRuneInsert(r rune) {
+	cursors := h.Buf.GetCursors()
+	for _, c := range cursors {
+		// Insert a character
+		h.Buf.SetCurCursor(c.Num)
+		h.Cursor = c
+		if !h.PluginCBRune("preRune", r) {
+			continue
+		}
+		if c.HasSelection() {
+			c.DeleteSelection()
+			c.ResetSelection()
+		}
+
+		if h.isOverwriteMode {
+			next := c.Loc
+			next.X++
+			h.Buf.Replace(c.Loc, next, string(r))
+		} else {
+			h.Buf.Insert(c.Loc, string(r))
+		}
+		if recording_macro {
+			curmacro = append(curmacro, r)
+		}
+		h.PluginCBRune("onRune", r)
+	}
+}
+
+func (h *BufPane) VSplitBuf(buf *buffer.Buffer) *BufPane {
+	e := NewBufPaneFromBuf(buf)
+	e.splitID = MainTab().GetNode(h.splitID).VSplit(h.Buf.Settings["splitright"].(bool))
+	MainTab().Panes = append(MainTab().Panes, e)
+	MainTab().Resize()
+	MainTab().SetActive(len(MainTab().Panes) - 1)
+	return e
+}
+func (h *BufPane) HSplitBuf(buf *buffer.Buffer) *BufPane {
+	e := NewBufPaneFromBuf(buf)
+	e.splitID = MainTab().GetNode(h.splitID).HSplit(h.Buf.Settings["splitbottom"].(bool))
+	MainTab().Panes = append(MainTab().Panes, e)
+	MainTab().Resize()
+	MainTab().SetActive(len(MainTab().Panes) - 1)
+	return e
+}
+func (h *BufPane) Close() {
+	h.Buf.Close()
+}
+
+func (h *BufPane) SetActive(b bool) {
+	h.BWindow.SetActive(b)
+	if b {
+		// Display any gutter messages for this line
+		c := h.Buf.GetActiveCursor()
+		none := true
+		for _, m := range h.Buf.Messages {
+			if c.Y == m.Start.Y || c.Y == m.End.Y {
+				InfoBar.GutterMessage(m.Msg)
+				none = false
+				break
+			}
+		}
+		if none && InfoBar.HasGutter {
+			InfoBar.ClearGutter()
+		}
+	}
+
+}
+
+// BufKeyActions contains the list of all possible key actions the bufhandler could execute
+var BufKeyActions = map[string]BufKeyAction{
+	"CursorUp":               (*BufPane).CursorUp,
+	"CursorDown":             (*BufPane).CursorDown,
+	"CursorPageUp":           (*BufPane).CursorPageUp,
+	"CursorPageDown":         (*BufPane).CursorPageDown,
+	"CursorLeft":             (*BufPane).CursorLeft,
+	"CursorRight":            (*BufPane).CursorRight,
+	"CursorStart":            (*BufPane).CursorStart,
+	"CursorEnd":              (*BufPane).CursorEnd,
+	"SelectToStart":          (*BufPane).SelectToStart,
+	"SelectToEnd":            (*BufPane).SelectToEnd,
+	"SelectUp":               (*BufPane).SelectUp,
+	"SelectDown":             (*BufPane).SelectDown,
+	"SelectLeft":             (*BufPane).SelectLeft,
+	"SelectRight":            (*BufPane).SelectRight,
+	"WordRight":              (*BufPane).WordRight,
+	"WordLeft":               (*BufPane).WordLeft,
+	"SelectWordRight":        (*BufPane).SelectWordRight,
+	"SelectWordLeft":         (*BufPane).SelectWordLeft,
+	"DeleteWordRight":        (*BufPane).DeleteWordRight,
+	"DeleteWordLeft":         (*BufPane).DeleteWordLeft,
+	"SelectLine":             (*BufPane).SelectLine,
+	"SelectToStartOfLine":    (*BufPane).SelectToStartOfLine,
+	"SelectToEndOfLine":      (*BufPane).SelectToEndOfLine,
+	"ParagraphPrevious":      (*BufPane).ParagraphPrevious,
+	"ParagraphNext":          (*BufPane).ParagraphNext,
+	"InsertNewline":          (*BufPane).InsertNewline,
+	"Backspace":              (*BufPane).Backspace,
+	"Delete":                 (*BufPane).Delete,
+	"InsertTab":              (*BufPane).InsertTab,
+	"Save":                   (*BufPane).Save,
+	"SaveAll":                (*BufPane).SaveAll,
+	"SaveAs":                 (*BufPane).SaveAs,
+	"Find":                   (*BufPane).Find,
+	"FindNext":               (*BufPane).FindNext,
+	"FindPrevious":           (*BufPane).FindPrevious,
+	"Center":                 (*BufPane).Center,
+	"Undo":                   (*BufPane).Undo,
+	"Redo":                   (*BufPane).Redo,
+	"Copy":                   (*BufPane).Copy,
+	"Cut":                    (*BufPane).Cut,
+	"CutLine":                (*BufPane).CutLine,
+	"DuplicateLine":          (*BufPane).DuplicateLine,
+	"DeleteLine":             (*BufPane).DeleteLine,
+	"MoveLinesUp":            (*BufPane).MoveLinesUp,
+	"MoveLinesDown":          (*BufPane).MoveLinesDown,
+	"IndentSelection":        (*BufPane).IndentSelection,
+	"OutdentSelection":       (*BufPane).OutdentSelection,
+	"Autocomplete":           (*BufPane).Autocomplete,
+	"OutdentLine":            (*BufPane).OutdentLine,
+	"Paste":                  (*BufPane).Paste,
+	"PastePrimary":           (*BufPane).PastePrimary,
+	"SelectAll":              (*BufPane).SelectAll,
+	"OpenFile":               (*BufPane).OpenFile,
+	"Start":                  (*BufPane).Start,
+	"End":                    (*BufPane).End,
+	"PageUp":                 (*BufPane).PageUp,
+	"PageDown":               (*BufPane).PageDown,
+	"SelectPageUp":           (*BufPane).SelectPageUp,
+	"SelectPageDown":         (*BufPane).SelectPageDown,
+	"HalfPageUp":             (*BufPane).HalfPageUp,
+	"HalfPageDown":           (*BufPane).HalfPageDown,
+	"StartOfLine":            (*BufPane).StartOfLine,
+	"EndOfLine":              (*BufPane).EndOfLine,
+	"ToggleHelp":             (*BufPane).ToggleHelp,
+	"ToggleKeyMenu":          (*BufPane).ToggleKeyMenu,
+	"ToggleRuler":            (*BufPane).ToggleRuler,
+	"ClearStatus":            (*BufPane).ClearStatus,
+	"ShellMode":              (*BufPane).ShellMode,
+	"CommandMode":            (*BufPane).CommandMode,
+	"ToggleOverwriteMode":    (*BufPane).ToggleOverwriteMode,
+	"Escape":                 (*BufPane).Escape,
+	"Quit":                   (*BufPane).Quit,
+	"QuitAll":                (*BufPane).QuitAll,
+	"AddTab":                 (*BufPane).AddTab,
+	"PreviousTab":            (*BufPane).PreviousTab,
+	"NextTab":                (*BufPane).NextTab,
+	"NextSplit":              (*BufPane).NextSplit,
+	"PreviousSplit":          (*BufPane).PreviousSplit,
+	"Unsplit":                (*BufPane).Unsplit,
+	"VSplit":                 (*BufPane).VSplitAction,
+	"HSplit":                 (*BufPane).HSplitAction,
+	"ToggleMacro":            (*BufPane).ToggleMacro,
+	"PlayMacro":              (*BufPane).PlayMacro,
+	"Suspend":                (*BufPane).Suspend,
+	"ScrollUp":               (*BufPane).ScrollUpAction,
+	"ScrollDown":             (*BufPane).ScrollDownAction,
+	"SpawnMultiCursor":       (*BufPane).SpawnMultiCursor,
+	"SpawnMultiCursorSelect": (*BufPane).SpawnMultiCursorSelect,
+	"RemoveMultiCursor":      (*BufPane).RemoveMultiCursor,
+	"RemoveAllMultiCursors":  (*BufPane).RemoveAllMultiCursors,
+	"SkipMultiCursor":        (*BufPane).SkipMultiCursor,
+	"JumpToMatchingBrace":    (*BufPane).JumpToMatchingBrace,
+	"None":                   (*BufPane).None,
+
+	// This was changed to InsertNewline but I don't want to break backwards compatibility
+	"InsertEnter": (*BufPane).InsertNewline,
+}
+
+// BufMouseActions contains the list of all possible mouse actions the bufhandler could execute
+var BufMouseActions = map[string]BufMouseAction{
+	"MousePress":       (*BufPane).MousePress,
+	"MouseMultiCursor": (*BufPane).MouseMultiCursor,
+}
+
+// MultiActions is a list of actions that should be executed multiple
+// times if there are multiple cursors (one per cursor)
+// Generally actions that modify global editor state like quitting or
+// saving should not be included in this list
+var MultiActions = map[string]bool{
+	"CursorUp":            true,
+	"CursorDown":          true,
+	"CursorPageUp":        true,
+	"CursorPageDown":      true,
+	"CursorLeft":          true,
+	"CursorRight":         true,
+	"CursorStart":         true,
+	"CursorEnd":           true,
+	"SelectToStart":       true,
+	"SelectToEnd":         true,
+	"SelectUp":            true,
+	"SelectDown":          true,
+	"SelectLeft":          true,
+	"SelectRight":         true,
+	"WordRight":           true,
+	"WordLeft":            true,
+	"SelectWordRight":     true,
+	"SelectWordLeft":      true,
+	"DeleteWordRight":     true,
+	"DeleteWordLeft":      true,
+	"SelectLine":          true,
+	"SelectToStartOfLine": true,
+	"SelectToEndOfLine":   true,
+	"ParagraphPrevious":   true,
+	"ParagraphNext":       true,
+	"InsertNewline":       true,
+	"Backspace":           true,
+	"Delete":              true,
+	"InsertTab":           true,
+	"FindNext":            true,
+	"FindPrevious":        true,
+	"Cut":                 true,
+	"CutLine":             true,
+	"DuplicateLine":       true,
+	"DeleteLine":          true,
+	"MoveLinesUp":         true,
+	"MoveLinesDown":       true,
+	"IndentSelection":     true,
+	"OutdentSelection":    true,
+	"OutdentLine":         true,
+	"Paste":               true,
+	"PastePrimary":        true,
+	"SelectPageUp":        true,
+	"SelectPageDown":      true,
+	"StartOfLine":         true,
+	"EndOfLine":           true,
+	"JumpToMatchingBrace": true,
+}

internal/action/command.go

@@ -0,0 +1,967 @@
+package action
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"unicode/utf8"
+
+	luar "layeh.com/gopher-luar"
+
+	lua "github.com/yuin/gopher-lua"
+	"github.com/zyedidia/micro/internal/buffer"
+	"github.com/zyedidia/micro/internal/config"
+	ulua "github.com/zyedidia/micro/internal/lua"
+	"github.com/zyedidia/micro/internal/screen"
+	"github.com/zyedidia/micro/internal/shell"
+	"github.com/zyedidia/micro/internal/util"
+	"github.com/zyedidia/micro/pkg/shellwords"
+)
+
+// A Command contains information about how to execute a command
+// It has the action for that command as well as a completer function
+type Command struct {
+	action    func(*BufPane, []string)
+	completer buffer.Completer
+}
+
+var commands map[string]Command
+
+func InitCommands() {
+	commands = map[string]Command{
+		"set":        Command{(*BufPane).SetCmd, OptionValueComplete},
+		"reset":      Command{(*BufPane).ResetCmd, OptionValueComplete},
+		"setlocal":   Command{(*BufPane).SetLocalCmd, OptionValueComplete},
+		"show":       Command{(*BufPane).ShowCmd, OptionComplete},
+		"showkey":    Command{(*BufPane).ShowKeyCmd, nil},
+		"run":        Command{(*BufPane).RunCmd, nil},
+		"bind":       Command{(*BufPane).BindCmd, nil},
+		"unbind":     Command{(*BufPane).UnbindCmd, nil},
+		"quit":       Command{(*BufPane).QuitCmd, nil},
+		"goto":       Command{(*BufPane).GotoCmd, nil},
+		"save":       Command{(*BufPane).SaveCmd, nil},
+		"replace":    Command{(*BufPane).ReplaceCmd, nil},
+		"replaceall": Command{(*BufPane).ReplaceAllCmd, nil},
+		"vsplit":     Command{(*BufPane).VSplitCmd, buffer.FileComplete},
+		"hsplit":     Command{(*BufPane).HSplitCmd, buffer.FileComplete},
+		"tab":        Command{(*BufPane).NewTabCmd, buffer.FileComplete},
+		"help":       Command{(*BufPane).HelpCmd, HelpComplete},
+		"eval":       Command{(*BufPane).EvalCmd, nil},
+		"log":        Command{(*BufPane).ToggleLogCmd, nil},
+		"plugin":     Command{(*BufPane).PluginCmd, PluginComplete},
+		"reload":     Command{(*BufPane).ReloadCmd, nil},
+		"reopen":     Command{(*BufPane).ReopenCmd, nil},
+		"cd":         Command{(*BufPane).CdCmd, buffer.FileComplete},
+		"pwd":        Command{(*BufPane).PwdCmd, nil},
+		"open":       Command{(*BufPane).OpenCmd, buffer.FileComplete},
+		"tabswitch":  Command{(*BufPane).TabSwitchCmd, nil},
+		"term":       Command{(*BufPane).TermCmd, nil},
+		"memusage":   Command{(*BufPane).MemUsageCmd, nil},
+		"retab":      Command{(*BufPane).RetabCmd, nil},
+		"raw":        Command{(*BufPane).RawCmd, nil},
+		"textfilter": Command{(*BufPane).TextFilterCmd, nil},
+	}
+}
+
+// MakeCommand is a function to easily create new commands
+// This can be called by plugins in Lua so that plugins can define their own commands
+func LuaMakeCommand(name, function string, completer buffer.Completer) {
+	action := LuaFunctionCommand(function)
+	commands[name] = Command{action, completer}
+}
+
+// LuaFunctionCommand returns a normal function
+// so that a command can be bound to a lua function
+func LuaFunctionCommand(fn string) func(*BufPane, []string) {
+	luaFn := strings.Split(fn, ".")
+	if len(luaFn) <= 1 {
+		return nil
+	}
+	plName, plFn := luaFn[0], luaFn[1]
+	pl := config.FindPlugin(plName)
+	if pl == nil {
+		return nil
+	}
+	return func(bp *BufPane, args []string) {
+		luaArgs := []lua.LValue{luar.New(ulua.L, bp), luar.New(ulua.L, args)}
+		_, err := pl.Call(plFn, luaArgs...)
+		if err != nil {
+			screen.TermMessage(err)
+		}
+	}
+}
+
+// CommandEditAction returns a bindable function that opens a prompt with
+// the given string and executes the command when the user presses
+// enter
+func CommandEditAction(prompt string) BufKeyAction {
+	return func(h *BufPane) bool {
+		InfoBar.Prompt("> ", prompt, "Command", nil, func(resp string, canceled bool) {
+			if !canceled {
+				MainTab().CurPane().HandleCommand(resp)
+			}
+		})
+		return false
+	}
+}
+
+// CommandAction returns a bindable function which executes the
+// given command
+func CommandAction(cmd string) BufKeyAction {
+	return func(h *BufPane) bool {
+		MainTab().CurPane().HandleCommand(cmd)
+		return false
+	}
+}
+
+var PluginCmds = []string{"list", "info", "version"}
+
+// PluginCmd installs, removes, updates, lists, or searches for given plugins
+func (h *BufPane) PluginCmd(args []string) {
+	if len(args) <= 0 {
+		InfoBar.Error("Not enough arguments, see 'help commands'")
+		return
+	}
+
+	valid := true
+	switch args[0] {
+	case "list":
+		for _, pl := range config.Plugins {
+			var en string
+			if pl.IsEnabled() {
+				en = "enabled"
+			} else {
+				en = "disabled"
+			}
+			WriteLog(fmt.Sprintf("%s: %s", pl.Name, en))
+			if pl.Default {
+				WriteLog(" (default)\n")
+			} else {
+				WriteLog("\n")
+			}
+		}
+		WriteLog("Default plugins come pre-installed with micro.")
+	case "version":
+		if len(args) <= 1 {
+			InfoBar.Error("No plugin provided to give info for")
+			return
+		}
+		found := false
+		for _, pl := range config.Plugins {
+			if pl.Name == args[1] {
+				found = true
+				if pl.Info == nil {
+					InfoBar.Message("Sorry no version for", pl.Name)
+					return
+				}
+
+				WriteLog("Version: " + pl.Info.Vstr + "\n")
+			}
+		}
+		if !found {
+			InfoBar.Message(args[1], "is not installed")
+		}
+	case "info":
+		if len(args) <= 1 {
+			InfoBar.Error("No plugin provided to give info for")
+			return
+		}
+		found := false
+		for _, pl := range config.Plugins {
+			if pl.Name == args[1] {
+				found = true
+				if pl.Info == nil {
+					InfoBar.Message("Sorry no info for ", pl.Name)
+					return
+				}
+
+				var buffer bytes.Buffer
+				buffer.WriteString("Name: ")
+				buffer.WriteString(pl.Info.Name)
+				buffer.WriteString("\n")
+				buffer.WriteString("Description: ")
+				buffer.WriteString(pl.Info.Desc)
+				buffer.WriteString("\n")
+				buffer.WriteString("Website: ")
+				buffer.WriteString(pl.Info.Site)
+				buffer.WriteString("\n")
+				buffer.WriteString("Installation link: ")
+				buffer.WriteString(pl.Info.Install)
+				buffer.WriteString("\n")
+				buffer.WriteString("Version: ")
+				buffer.WriteString(pl.Info.Vstr)
+				buffer.WriteString("\n")
+				buffer.WriteString("Requirements:")
+				buffer.WriteString("\n")
+				for _, r := range pl.Info.Require {
+					buffer.WriteString("    - ")
+					buffer.WriteString(r)
+					buffer.WriteString("\n")
+				}
+
+				WriteLog(buffer.String())
+			}
+		}
+		if !found {
+			InfoBar.Message(args[1], "is not installed")
+			return
+		}
+	default:
+		InfoBar.Error("Not a valid plugin command")
+		return
+	}
+
+	if valid && h.Buf.Type != buffer.BTLog {
+		OpenLogBuf(h)
+	}
+}
+
+// RetabCmd changes all spaces to tabs or all tabs to spaces
+// depending on the user's settings
+func (h *BufPane) RetabCmd(args []string) {
+	h.Buf.Retab()
+}
+
+// RawCmd opens a new raw view which displays the escape sequences micro
+// is receiving in real-time
+func (h *BufPane) RawCmd(args []string) {
+	width, height := screen.Screen.Size()
+	iOffset := config.GetInfoBarOffset()
+	tp := NewTabFromPane(0, 0, width, height-iOffset, NewRawPane())
+	Tabs.AddTab(tp)
+	Tabs.SetActive(len(Tabs.List) - 1)
+}
+
+// TextFilterCmd filters the selection through the command.
+// Selection goes to the command input.
+// On successfull run command output replaces the current selection.
+func (h *BufPane) TextFilterCmd(args []string) {
+	if len(args) == 0 {
+		InfoBar.Error("usage: textfilter arguments")
+		return
+	}
+	sel := h.Cursor.GetSelection()
+	if len(sel) == 0 {
+		h.Cursor.SelectWord()
+		sel = h.Cursor.GetSelection()
+	}
+	var bout, berr bytes.Buffer
+	cmd := exec.Command(args[0], args[1:]...)
+	cmd.Stdin = strings.NewReader(string(sel))
+	cmd.Stderr = &berr
+	cmd.Stdout = &bout
+	err := cmd.Run()
+	if err != nil {
+		InfoBar.Error(err.Error() + " " + berr.String())
+		return
+	}
+	h.Cursor.DeleteSelection()
+	h.Buf.Insert(h.Cursor.Loc, bout.String())
+}
+
+// TabSwitchCmd switches to a given tab either by name or by number
+func (h *BufPane) TabSwitchCmd(args []string) {
+	if len(args) > 0 {
+		num, err := strconv.Atoi(args[0])
+		if err != nil {
+			// Check for tab with this name
+
+			found := false
+			for i, t := range Tabs.List {
+				if t.Panes[t.active].Name() == args[0] {
+					Tabs.SetActive(i)
+					found = true
+				}
+			}
+			if !found {
+				InfoBar.Error("Could not find tab: ", err)
+			}
+		} else {
+			num--
+			if num >= 0 && num < len(Tabs.List) {
+				Tabs.SetActive(num)
+			} else {
+				InfoBar.Error("Invalid tab index")
+			}
+		}
+	}
+}
+
+// CdCmd changes the current working directory
+func (h *BufPane) CdCmd(args []string) {
+	if len(args) > 0 {
+		path, err := util.ReplaceHome(args[0])
+		if err != nil {
+			InfoBar.Error(err)
+			return
+		}
+		err = os.Chdir(path)
+		if err != nil {
+			InfoBar.Error(err)
+			return
+		}
+		wd, _ := os.Getwd()
+		for _, b := range buffer.OpenBuffers {
+			if len(b.Path) > 0 {
+				b.Path, _ = util.MakeRelative(b.AbsPath, wd)
+				if p, _ := filepath.Abs(b.Path); !strings.Contains(p, wd) {
+					b.Path = b.AbsPath
+				}
+			}
+		}
+	}
+}
+
+// MemUsageCmd 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 (h *BufPane) MemUsageCmd(args []string) {
+	InfoBar.Message(util.GetMemStats())
+}
+
+// PwdCmd prints the current working directory
+func (h *BufPane) PwdCmd(args []string) {
+	wd, err := os.Getwd()
+	if err != nil {
+		InfoBar.Message(err.Error())
+	} else {
+		InfoBar.Message(wd)
+	}
+}
+
+// OpenCmd opens a new buffer with a given filename
+func (h *BufPane) OpenCmd(args []string) {
+	if len(args) > 0 {
+		filename := args[0]
+		// the filename might or might not be quoted, so unquote first then join the strings.
+		args, err := shellwords.Split(filename)
+		if err != nil {
+			InfoBar.Error("Error parsing args ", err)
+			return
+		}
+		filename = strings.Join(args, " ")
+
+		open := func() {
+			b, err := buffer.NewBufferFromFile(filename, buffer.BTDefault)
+			if err != nil {
+				InfoBar.Error(err)
+				return
+			}
+			h.OpenBuffer(b)
+		}
+		if h.Buf.Modified() {
+			InfoBar.YNPrompt("Save changes to "+h.Buf.GetName()+" before closing? (y,n,esc)", func(yes, canceled bool) {
+				if !canceled && !yes {
+					open()
+				} else if !canceled && yes {
+					h.Save()
+					open()
+				}
+			})
+		} else {
+			open()
+		}
+	} else {
+		InfoBar.Error("No filename")
+	}
+}
+
+// ToggleLogCmd toggles the log view
+func (h *BufPane) ToggleLogCmd(args []string) {
+	if h.Buf.Type != buffer.BTLog {
+		OpenLogBuf(h)
+	} else {
+		h.Quit()
+	}
+}
+
+// ReloadCmd reloads all files (syntax files, colorschemes...)
+func (h *BufPane) ReloadCmd(args []string) {
+	ReloadConfig()
+}
+
+func ReloadConfig() {
+	config.InitRuntimeFiles()
+	err := config.ReadSettings()
+	if err != nil {
+		screen.TermMessage(err)
+	}
+	config.InitGlobalSettings()
+	InitBindings()
+	InitCommands()
+
+	err = config.InitColorscheme()
+	if err != nil {
+		screen.TermMessage(err)
+	}
+
+	for _, b := range buffer.OpenBuffers {
+		b.UpdateRules()
+	}
+}
+
+// ReopenCmd reopens the buffer (reload from disk)
+func (h *BufPane) ReopenCmd(args []string) {
+	if h.Buf.Modified() {
+		InfoBar.YNPrompt("Save file before reopen?", func(yes, canceled bool) {
+			if !canceled && yes {
+				h.Save()
+				h.Buf.ReOpen()
+			} else if !canceled {
+				h.Buf.ReOpen()
+			}
+		})
+	} else {
+		h.Buf.ReOpen()
+	}
+}
+
+func (h *BufPane) openHelp(page string) error {
+	if data, err := config.FindRuntimeFile(config.RTHelp, page).Data(); err != nil {
+		return errors.New(fmt.Sprint("Unable to load help text", page, "\n", err))
+	} else {
+		helpBuffer := buffer.NewBufferFromString(string(data), page+".md", buffer.BTHelp)
+		helpBuffer.SetName("Help " + page)
+
+		if h.Buf.Type == buffer.BTHelp {
+			h.OpenBuffer(helpBuffer)
+		} else {
+			h.HSplitBuf(helpBuffer)
+		}
+	}
+	return nil
+}
+
+// HelpCmd tries to open the given help page in a horizontal split
+func (h *BufPane) HelpCmd(args []string) {
+	if len(args) < 1 {
+		// Open the default help if the user just typed "> help"
+		h.openHelp("help")
+	} else {
+		if config.FindRuntimeFile(config.RTHelp, args[0]) != nil {
+			err := h.openHelp(args[0])
+			if err != nil {
+				InfoBar.Error(err)
+			}
+		} else {
+			InfoBar.Error("Sorry, no help for ", args[0])
+		}
+	}
+}
+
+// VSplitCmd opens a vertical split with file given in the first argument
+// If no file is given, it opens an empty buffer in a new split
+func (h *BufPane) VSplitCmd(args []string) {
+	if len(args) == 0 {
+		// Open an empty vertical split
+		h.VSplitAction()
+		return
+	}
+
+	buf, err := buffer.NewBufferFromFile(args[0], buffer.BTDefault)
+	if err != nil {
+		InfoBar.Error(err)
+		return
+	}
+
+	h.VSplitBuf(buf)
+}
+
+// HSplitCmd opens a horizontal split with file given in the first argument
+// If no file is given, it opens an empty buffer in a new split
+func (h *BufPane) HSplitCmd(args []string) {
+	if len(args) == 0 {
+		// Open an empty horizontal split
+		h.HSplitAction()
+		return
+	}
+
+	buf, err := buffer.NewBufferFromFile(args[0], buffer.BTDefault)
+	if err != nil {
+		InfoBar.Error(err)
+		return
+	}
+
+	h.HSplitBuf(buf)
+}
+
+// EvalCmd evaluates a lua expression
+func (h *BufPane) EvalCmd(args []string) {
+}
+
+// NewTabCmd opens the given file in a new tab
+func (h *BufPane) NewTabCmd(args []string) {
+	width, height := screen.Screen.Size()
+	iOffset := config.GetInfoBarOffset()
+	if len(args) > 0 {
+		for _, a := range args {
+			b, err := buffer.NewBufferFromFile(a, buffer.BTDefault)
+			if err != nil {
+				InfoBar.Error(err)
+				return
+			}
+			tp := NewTabFromBuffer(0, 0, width, height-1-iOffset, b)
+			Tabs.AddTab(tp)
+			Tabs.SetActive(len(Tabs.List) - 1)
+		}
+	} else {
+		b := buffer.NewBufferFromString("", "", buffer.BTDefault)
+		tp := NewTabFromBuffer(0, 0, width, height-iOffset, b)
+		Tabs.AddTab(tp)
+		Tabs.SetActive(len(Tabs.List) - 1)
+	}
+}
+
+func SetGlobalOptionNative(option string, nativeValue interface{}) error {
+	config.GlobalSettings[option] = nativeValue
+
+	if option == "colorscheme" {
+		// LoadSyntaxFiles()
+		config.InitColorscheme()
+		for _, b := range buffer.OpenBuffers {
+			b.UpdateRules()
+		}
+	} else if option == "infobar" || option == "keymenu" {
+		Tabs.Resize()
+	} else if option == "mouse" {
+		if !nativeValue.(bool) {
+			screen.Screen.DisableMouse()
+		} else {
+			screen.Screen.EnableMouse()
+		}
+	} else if option == "autosave" {
+		if nativeValue.(float64) > 0 {
+			config.SetAutoTime(int(nativeValue.(float64)))
+			config.StartAutoSave()
+		} else {
+			config.SetAutoTime(0)
+		}
+	} else {
+		for _, pl := range config.Plugins {
+			if option == pl.Name {
+				if nativeValue.(bool) && !pl.Loaded {
+					pl.Load()
+					pl.Call("init")
+				} else if !nativeValue.(bool) && pl.Loaded {
+					pl.Call("deinit")
+				}
+			}
+		}
+	}
+
+	for _, b := range buffer.OpenBuffers {
+		b.SetOptionNative(option, nativeValue)
+	}
+
+	return config.WriteSettings(config.ConfigDir + "/settings.json")
+}
+
+func SetGlobalOption(option, value string) error {
+	if _, ok := config.GlobalSettings[option]; !ok {
+		return config.ErrInvalidOption
+	}
+
+	nativeValue, err := config.GetNativeValue(option, config.GlobalSettings[option], value)
+	if err != nil {
+		return err
+	}
+
+	return SetGlobalOptionNative(option, nativeValue)
+}
+
+// ResetCmd resets a setting to its default value
+func (h *BufPane) ResetCmd(args []string) {
+	if len(args) < 1 {
+		InfoBar.Error("Not enough arguments")
+		return
+	}
+
+	option := args[0]
+
+	defaultGlobals := config.DefaultGlobalSettings()
+	defaultLocals := config.DefaultCommonSettings()
+
+	if _, ok := defaultGlobals[option]; ok {
+		SetGlobalOptionNative(option, defaultGlobals[option])
+		return
+	}
+	if _, ok := defaultLocals[option]; ok {
+		h.Buf.SetOptionNative(option, defaultLocals[option])
+		return
+	}
+	InfoBar.Error(config.ErrInvalidOption)
+}
+
+// SetCmd sets an option
+func (h *BufPane) SetCmd(args []string) {
+	if len(args) < 2 {
+		InfoBar.Error("Not enough arguments")
+		return
+	}
+
+	option := args[0]
+	value := args[1]
+
+	err := SetGlobalOption(option, value)
+	if err == config.ErrInvalidOption {
+		err := h.Buf.SetOption(option, value)
+		if err != nil {
+			InfoBar.Error(err)
+		}
+	} else if err != nil {
+		InfoBar.Error(err)
+	}
+}
+
+// SetLocalCmd sets an option local to the buffer
+func (h *BufPane) SetLocalCmd(args []string) {
+	if len(args) < 2 {
+		InfoBar.Error("Not enough arguments")
+		return
+	}
+
+	option := args[0]
+	value := args[1]
+
+	err := h.Buf.SetOption(option, value)
+	if err != nil {
+		InfoBar.Error(err)
+	}
+}
+
+// ShowCmd shows the value of the given option
+func (h *BufPane) ShowCmd(args []string) {
+	if len(args) < 1 {
+		InfoBar.Error("Please provide an option to show")
+		return
+	}
+
+	var option interface{}
+	if opt, ok := h.Buf.Settings[args[0]]; ok {
+		option = opt
+	} else if opt, ok := config.GlobalSettings[args[0]]; ok {
+		option = opt
+	}
+
+	if option == nil {
+		InfoBar.Error(args[0], " is not a valid option")
+		return
+	}
+
+	InfoBar.Message(option)
+}
+
+// ShowKeyCmd displays the action that a key is bound to
+func (h *BufPane) ShowKeyCmd(args []string) {
+	if len(args) < 1 {
+		InfoBar.Error("Please provide a key to show")
+		return
+	}
+
+	if action, ok := config.Bindings[args[0]]; ok {
+		InfoBar.Message(action)
+	} else {
+		InfoBar.Message(args[0], " has no binding")
+	}
+}
+
+// BindCmd creates a new keybinding
+func (h *BufPane) BindCmd(args []string) {
+	if len(args) < 2 {
+		InfoBar.Error("Not enough arguments")
+		return
+	}
+
+	_, err := TryBindKey(args[0], args[1], true)
+	if err != nil {
+		InfoBar.Error(err)
+	}
+}
+
+// UnbindCmd binds a key to its default action
+func (h *BufPane) UnbindCmd(args []string) {
+	if len(args) < 1 {
+		InfoBar.Error("Not enough arguements")
+		return
+	}
+
+	err := UnbindKey(args[0])
+	if err != nil {
+		InfoBar.Error(err)
+	}
+}
+
+// RunCmd runs a shell command in the background
+func (h *BufPane) RunCmd(args []string) {
+	runf, err := shell.RunBackgroundShell(shellwords.Join(args...))
+	if err != nil {
+		InfoBar.Error(err)
+	} else {
+		go func() {
+			InfoBar.Message(runf())
+			screen.Redraw()
+		}()
+	}
+}
+
+// QuitCmd closes the main view
+func (h *BufPane) QuitCmd(args []string) {
+	h.Quit()
+}
+
+// GotoCmd is a command that will send the cursor to a certain
+// position in the buffer
+// For example: `goto line`, or `goto line:col`
+func (h *BufPane) GotoCmd(args []string) {
+	if len(args) <= 0 {
+		InfoBar.Error("Not enough arguments")
+	} else {
+		h.RemoveAllMultiCursors()
+		if strings.Contains(args[0], ":") {
+			parts := strings.SplitN(args[0], ":", 2)
+			line, err := strconv.Atoi(parts[0])
+			if err != nil {
+				InfoBar.Error(err)
+				return
+			}
+			col, err := strconv.Atoi(parts[1])
+			if err != nil {
+				InfoBar.Error(err)
+				return
+			}
+			line = util.Clamp(line-1, 0, h.Buf.LinesNum()-1)
+			col = util.Clamp(col-1, 0, utf8.RuneCount(h.Buf.LineBytes(line)))
+			h.Cursor.GotoLoc(buffer.Loc{col, line})
+		} else {
+			line, err := strconv.Atoi(args[0])
+			if err != nil {
+				InfoBar.Error(err)
+				return
+			}
+			line = util.Clamp(line-1, 0, h.Buf.LinesNum()-1)
+			h.Cursor.GotoLoc(buffer.Loc{0, line})
+		}
+		h.Relocate()
+	}
+}
+
+// SaveCmd saves the buffer optionally with an argument file name
+func (h *BufPane) SaveCmd(args []string) {
+	if len(args) == 0 {
+		h.Save()
+	} else {
+		h.Buf.SaveAs(args[0])
+	}
+}
+
+// ReplaceCmd runs search and replace
+func (h *BufPane) ReplaceCmd(args []string) {
+	if len(args) < 2 || len(args) > 4 {
+		// We need to find both a search and replace expression
+		InfoBar.Error("Invalid replace statement: " + strings.Join(args, " "))
+		return
+	}
+
+	all := false
+	noRegex := false
+
+	foundSearch := false
+	foundReplace := false
+	var search string
+	var replaceStr string
+	for _, arg := range args {
+		switch arg {
+		case "-a":
+			all = true
+		case "-l":
+			noRegex = true
+		default:
+			if !foundSearch {
+				foundSearch = true
+				search = arg
+			} else if !foundReplace {
+				foundReplace = true
+				replaceStr = arg
+			} else {
+				InfoBar.Error("Invalid flag: " + arg)
+				return
+			}
+		}
+	}
+
+	if noRegex {
+		search = regexp.QuoteMeta(search)
+	}
+
+	replace := []byte(replaceStr)
+
+	var regex *regexp.Regexp
+	var err error
+	if h.Buf.Settings["ignorecase"].(bool) {
+		regex, err = regexp.Compile("(?im)" + search)
+	} else {
+		regex, err = regexp.Compile("(?m)" + search)
+	}
+	if err != nil {
+		// There was an error with the user's regex
+		InfoBar.Error(err)
+		return
+	}
+
+	nreplaced := 0
+	start := h.Buf.Start()
+	end := h.Buf.End()
+	if h.Cursor.HasSelection() {
+		start = h.Cursor.CurSelection[0]
+		end = h.Cursor.CurSelection[1]
+	}
+	if all {
+		nreplaced = h.Buf.ReplaceRegex(start, end, regex, replace)
+	} else {
+		inRange := func(l buffer.Loc) bool {
+			return l.GreaterEqual(start) && l.LessThan(end)
+		}
+
+		searchLoc := start
+		searching := true
+		var doReplacement func()
+		doReplacement = func() {
+			locs, found, err := h.Buf.FindNext(search, start, end, searchLoc, true, !noRegex)
+			if err != nil {
+				InfoBar.Error(err)
+				return
+			}
+			if !found || !inRange(locs[0]) || !inRange(locs[1]) {
+				h.Cursor.ResetSelection()
+				h.Buf.RelocateCursors()
+				return
+			}
+
+			h.Cursor.SetSelectionStart(locs[0])
+			h.Cursor.SetSelectionEnd(locs[1])
+
+			InfoBar.YNPrompt("Perform replacement (y,n,esc)", func(yes, canceled bool) {
+				if !canceled && yes {
+					h.Buf.Replace(locs[0], locs[1], replaceStr)
+					searchLoc = locs[0]
+					searchLoc.X += utf8.RuneCount(replace)
+					h.Cursor.Loc = searchLoc
+					nreplaced++
+				} else if !canceled && !yes {
+					searchLoc = locs[0]
+					searchLoc.X += utf8.RuneCount(replace)
+				} else if canceled {
+					h.Cursor.ResetSelection()
+					h.Buf.RelocateCursors()
+					return
+				}
+				if searching {
+					doReplacement()
+				}
+			})
+		}
+		doReplacement()
+	}
+
+	h.Buf.RelocateCursors()
+
+	if nreplaced > 1 {
+		InfoBar.Message("Replaced ", nreplaced, " occurrences of ", search)
+	} else if nreplaced == 1 {
+		InfoBar.Message("Replaced ", nreplaced, " occurrence of ", search)
+	} else {
+		InfoBar.Message("Nothing matched ", search)
+	}
+}
+
+// ReplaceAllCmd replaces search term all at once
+func (h *BufPane) ReplaceAllCmd(args []string) {
+	// aliased to Replace command
+	h.ReplaceCmd(append(args, "-a"))
+}
+
+// TermCmd opens a terminal in the current view
+func (h *BufPane) TermCmd(args []string) {
+	ps := MainTab().Panes
+
+	if len(args) == 0 {
+		sh := os.Getenv("SHELL")
+		if sh == "" {
+			InfoBar.Error("Shell environment not found")
+			return
+		}
+		args = []string{sh}
+	}
+
+	term := func(i int, newtab bool) {
+		t := new(shell.Terminal)
+		t.Start(args, false, true, "", nil)
+
+		id := h.ID()
+		if newtab {
+			h.AddTab()
+			i = 0
+			id = MainTab().Panes[0].ID()
+		} else {
+			MainTab().Panes[i].Close()
+		}
+
+		v := h.GetView()
+		MainTab().Panes[i] = NewTermPane(v.X, v.Y, v.Width, v.Height, t, id)
+		MainTab().SetActive(i)
+	}
+
+	// If there is only one open file we make a new tab instead of overwriting it
+	newtab := len(MainTab().Panes) == 1 && len(Tabs.List) == 1
+
+	if newtab {
+		term(0, true)
+		return
+	}
+
+	for i, p := range ps {
+		if p.ID() == h.ID() {
+			if h.Buf.Modified() {
+				InfoBar.YNPrompt("Save changes to "+h.Buf.GetName()+" before closing? (y,n,esc)", func(yes, canceled bool) {
+					if !canceled && !yes {
+						term(i, false)
+					} else if !canceled && yes {
+						h.Save()
+						term(i, false)
+					}
+				})
+			} else {
+				term(i, false)
+			}
+		}
+	}
+}
+
+// HandleCommand handles input from the user
+func (h *BufPane) HandleCommand(input string) {
+	args, err := shellwords.Split(input)
+	if err != nil {
+		InfoBar.Error("Error parsing args ", err)
+		return
+	}
+
+	inputCmd := args[0]
+
+	if _, ok := commands[inputCmd]; !ok {
+		InfoBar.Error("Unknown command ", inputCmd)
+	} else {
+		WriteLog("> " + input + "\n")
+		commands[inputCmd].action(h, args[1:])
+		WriteLog("\n")
+	}
+}

internal/action/events.go

@@ -0,0 +1,42 @@
+package action
+
+import (
+	"github.com/zyedidia/tcell"
+)
+
+type Event interface{}
+
+// RawEvent is simply an escape code
+// We allow users to directly bind escape codes
+// to get around some of a limitations of terminals
+type RawEvent struct {
+	esc string
+}
+
+// KeyEvent is a key event containing a key code,
+// some possible modifiers (alt, ctrl, etc...) and
+// a rune if it was simply a character press
+// Note: to be compatible with tcell events,
+// for ctrl keys r=code
+type KeyEvent struct {
+	code tcell.Key
+	mod  tcell.ModMask
+	r    rune
+}
+
+// MouseEvent is a mouse event with a mouse button and
+// any possible key modifiers
+type MouseEvent struct {
+	btn tcell.ButtonMask
+	mod tcell.ModMask
+}
+
+type KeyAction func(Handler) bool
+type MouseAction func(Handler, tcell.EventMouse) bool
+
+// A Handler will take a tcell event and execute it
+// appropriately
+type Handler interface {
+	HandleEvent(tcell.Event)
+	HandleCommand(string)
+}

internal/action/globals.go

@@ -0,0 +1,42 @@
+package action
+
+import "github.com/zyedidia/micro/internal/buffer"
+
+var InfoBar *InfoPane
+var LogBufPane *BufPane
+
+func InitGlobals() {
+	InfoBar = NewInfoBar()
+	buffer.LogBuf = buffer.NewBufferFromString("", "Log", buffer.BTLog)
+}
+
+func GetInfoBar() *InfoPane {
+	return InfoBar
+}
+
+func WriteLog(s string) {
+	buffer.WriteLog(s)
+	if LogBufPane != nil {
+		LogBufPane.CursorEnd()
+		v := LogBufPane.GetView()
+		endY := buffer.LogBuf.End().Y
+
+		if endY > v.StartLine+v.Height {
+			v.StartLine = buffer.LogBuf.End().Y - v.Height + 2
+			LogBufPane.SetView(v)
+		}
+	}
+}
+
+func OpenLogBuf(h *BufPane) {
+	LogBufPane = h.HSplitBuf(buffer.LogBuf)
+	LogBufPane.CursorEnd()
+
+	v := LogBufPane.GetView()
+	endY := buffer.LogBuf.End().Y
+
+	if endY > v.StartLine+v.Height {
+		v.StartLine = buffer.LogBuf.End().Y - v.Height + 2
+		LogBufPane.SetView(v)
+	}
+}

internal/action/infocomplete.go

@@ -0,0 +1,303 @@
+package action
+
+import (
+	"bytes"
+	"sort"
+	"strings"
+
+	"github.com/zyedidia/micro/internal/buffer"
+	"github.com/zyedidia/micro/internal/config"
+	"github.com/zyedidia/micro/internal/util"
+)
+
+// 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`.
+
+// CommandComplete autocompletes commands
+func CommandComplete(b *buffer.Buffer) ([]string, []string) {
+	c := b.GetActiveCursor()
+	input, argstart := buffer.GetArg(b)
+
+	var suggestions []string
+	for cmd := range commands {
+		if strings.HasPrefix(cmd, input) {
+			suggestions = append(suggestions, cmd)
+		}
+	}
+
+	sort.Strings(suggestions)
+	completions := make([]string, len(suggestions))
+	for i := range suggestions {
+		completions[i] = util.SliceEndStr(suggestions[i], c.X-argstart)
+	}
+
+	return completions, suggestions
+}
+
+// HelpComplete autocompletes help topics
+func HelpComplete(b *buffer.Buffer) ([]string, []string) {
+	c := b.GetActiveCursor()
+	input, argstart := buffer.GetArg(b)
+
+	var suggestions []string
+
+	for _, file := range config.ListRuntimeFiles(config.RTHelp) {
+		topic := file.Name()
+		if strings.HasPrefix(topic, input) {
+			suggestions = append(suggestions, topic)
+		}
+	}
+
+	sort.Strings(suggestions)
+	completions := make([]string, len(suggestions))
+	for i := range suggestions {
+		completions[i] = util.SliceEndStr(suggestions[i], c.X-argstart)
+	}
+	return completions, suggestions
+}
+
+// colorschemeComplete tab-completes names of colorschemes.
+// This is just a heper value for OptionValueComplete
+func colorschemeComplete(input string) (string, []string) {
+	var suggestions []string
+	files := config.ListRuntimeFiles(config.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(b *buffer.Buffer) ([]string, []string) {
+	c := b.GetActiveCursor()
+	input, argstart := buffer.GetArg(b)
+
+	var suggestions []string
+	for option := range config.GlobalSettings {
+		if strings.HasPrefix(option, input) {
+			suggestions = append(suggestions, option)
+		}
+	}
+	// for option := range localSettings {
+	// 	if strings.HasPrefix(option, input) && !contains(suggestions, option) {
+	// 		suggestions = append(suggestions, option)
+	// 	}
+	// }
+
+	sort.Strings(suggestions)
+	completions := make([]string, len(suggestions))
+	for i := range suggestions {
+		completions[i] = util.SliceEndStr(suggestions[i], c.X-argstart)
+	}
+	return completions, suggestions
+}
+
+// OptionValueComplete completes values for various options
+func OptionValueComplete(b *buffer.Buffer) ([]string, []string) {
+	c := b.GetActiveCursor()
+	l := b.LineBytes(c.Y)
+	l = util.SliceStart(l, c.X)
+	input, argstart := buffer.GetArg(b)
+
+	completeValue := false
+	args := bytes.Split(l, []byte{' '})
+	if len(args) >= 2 {
+		// localSettings := config.DefaultLocalSettings()
+		for option := range config.GlobalSettings {
+			if option == string(args[len(args)-2]) {
+				completeValue = true
+				break
+			}
+		}
+		// for option := range localSettings {
+		// 	if option == string(args[len(args)-2]) {
+		// 		completeValue = true
+		// 		break
+		// 	}
+		// }
+	}
+	if !completeValue {
+		return OptionComplete(b)
+	}
+
+	inputOpt := string(args[len(args)-2])
+
+	inputOpt = strings.TrimSpace(inputOpt)
+	var suggestions []string
+	// localSettings := config.DefaultLocalSettings()
+	var optionVal interface{}
+	for k, option := range config.GlobalSettings {
+		if k == inputOpt {
+			optionVal = option
+		}
+	}
+	// for k, option := range localSettings {
+	// 	if k == inputOpt {
+	// 		optionVal = option
+	// 	}
+	// }
+
+	switch optionVal.(type) {
+	case bool:
+		if strings.HasPrefix("on", input) {
+			suggestions = append(suggestions, "on")
+		} else if strings.HasPrefix("true", input) {
+			suggestions = append(suggestions, "true")
+		}
+		if strings.HasPrefix("off", input) {
+			suggestions = append(suggestions, "off")
+		} else if strings.HasPrefix("false", input) {
+			suggestions = append(suggestions, "false")
+		}
+	case string:
+		switch inputOpt {
+		case "colorscheme":
+			_, suggestions = colorschemeComplete(input)
+		case "fileformat":
+			if strings.HasPrefix("unix", input) {
+				suggestions = append(suggestions, "unix")
+			}
+			if strings.HasPrefix("dos", input) {
+				suggestions = append(suggestions, "dos")
+			}
+		case "sucmd":
+			if strings.HasPrefix("sudo", input) {
+				suggestions = append(suggestions, "sudo")
+			}
+			if strings.HasPrefix("doas", input) {
+				suggestions = append(suggestions, "doas")
+			}
+		}
+	}
+	sort.Strings(suggestions)
+
+	completions := make([]string, len(suggestions))
+	for i := range suggestions {
+		completions[i] = util.SliceEndStr(suggestions[i], c.X-argstart)
+	}
+	return completions, suggestions
+}
+
+// OptionComplete autocompletes options
+func PluginCmdComplete(b *buffer.Buffer) ([]string, []string) {
+	c := b.GetActiveCursor()
+	input, argstart := buffer.GetArg(b)
+
+	var suggestions []string
+	for _, cmd := range PluginCmds {
+		if strings.HasPrefix(cmd, input) {
+			suggestions = append(suggestions, cmd)
+		}
+	}
+
+	sort.Strings(suggestions)
+	completions := make([]string, len(suggestions))
+	for i := range suggestions {
+		completions[i] = util.SliceEndStr(suggestions[i], c.X-argstart)
+	}
+	return completions, suggestions
+}
+
+// PluginComplete completes values for the plugin command
+func PluginComplete(b *buffer.Buffer) ([]string, []string) {
+	c := b.GetActiveCursor()
+	l := b.LineBytes(c.Y)
+	l = util.SliceStart(l, c.X)
+	input, argstart := buffer.GetArg(b)
+
+	completeValue := false
+	args := bytes.Split(l, []byte{' '})
+	if len(args) >= 2 {
+		for _, cmd := range PluginCmds {
+			if cmd == string(args[len(args)-2]) {
+				completeValue = true
+				break
+			}
+		}
+	}
+	if !completeValue {
+		return PluginCmdComplete(b)
+	}
+
+	var suggestions []string
+	for _, pl := range config.Plugins {
+		if strings.HasPrefix(pl.Name, input) {
+			suggestions = append(suggestions, pl.Name)
+		}
+	}
+	sort.Strings(suggestions)
+
+	completions := make([]string, len(suggestions))
+	for i := range suggestions {
+		completions[i] = util.SliceEndStr(suggestions[i], c.X-argstart)
+	}
+	return completions, 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
+// }
+//
+// // PluginCmdComplete completes with possible choices for the `> plugin` command
+// 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
+// }
+//
+// // PluginnameComplete completes with the names of loaded plugins
+// 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
+// }

internal/action/infopane.go

@@ -0,0 +1,226 @@
+package action
+
+import (
+	"bytes"
+	"strings"
+
+	"github.com/zyedidia/micro/internal/display"
+	"github.com/zyedidia/micro/internal/info"
+	"github.com/zyedidia/micro/internal/util"
+	"github.com/zyedidia/tcell"
+)
+
+type InfoKeyAction func(*InfoPane)
+
+type InfoPane struct {
+	*BufPane
+	*info.InfoBuf
+}
+
+func NewInfoPane(ib *info.InfoBuf, w display.BWindow) *InfoPane {
+	ip := new(InfoPane)
+	ip.InfoBuf = ib
+	ip.BufPane = NewBufPane(ib.Buffer, w)
+
+	return ip
+}
+
+func NewInfoBar() *InfoPane {
+	ib := info.NewBuffer()
+	w := display.NewInfoWindow(ib)
+	return NewInfoPane(ib, w)
+}
+
+func (h *InfoPane) Close() {
+	h.InfoBuf.Close()
+	h.BufPane.Close()
+}
+
+func (h *InfoPane) HandleEvent(event tcell.Event) {
+	switch e := event.(type) {
+	case *tcell.EventKey:
+		ke := KeyEvent{
+			code: e.Key(),
+			mod:  e.Modifiers(),
+			r:    e.Rune(),
+		}
+
+		done := h.DoKeyEvent(ke)
+		hasYN := h.HasYN
+		if e.Key() == tcell.KeyRune && hasYN {
+			if e.Rune() == 'y' && hasYN {
+				h.YNResp = true
+				h.DonePrompt(false)
+			} else if e.Rune() == 'n' && hasYN {
+				h.YNResp = false
+				h.DonePrompt(false)
+			}
+		}
+		if e.Key() == tcell.KeyRune && !done && !hasYN {
+			h.DoRuneInsert(e.Rune())
+			done = true
+		}
+		if done && h.HasPrompt && !hasYN {
+			resp := string(h.LineBytes(0))
+			hist := h.History[h.PromptType]
+			hist[h.HistoryNum] = resp
+			if h.EventCallback != nil {
+				h.EventCallback(resp)
+			}
+		}
+	case *tcell.EventMouse:
+		h.BufPane.HandleEvent(event)
+	}
+}
+
+func (h *InfoPane) DoKeyEvent(e KeyEvent) bool {
+	done := false
+	if action, ok := BufKeyBindings[e]; ok {
+		estr := BufKeyStrings[e]
+		for _, s := range InfoNones {
+			if s == estr {
+				return false
+			}
+		}
+		for s, a := range InfoOverrides {
+			// TODO this is a hack and really we should have support
+			// for having binding overrides for different buffers
+			if strings.Contains(estr, s) {
+				done = true
+				a(h)
+				break
+			}
+		}
+		if !done {
+			done = action(h.BufPane)
+		}
+	}
+	return done
+}
+
+// InfoNones is a list of actions that should have no effect when executed
+// by an infohandler
+var InfoNones = []string{
+	"Save",
+	"SaveAll",
+	"SaveAs",
+	"Find",
+	"FindNext",
+	"FindPrevious",
+	"Center",
+	"DuplicateLine",
+	"MoveLinesUp",
+	"MoveLinesDown",
+	"OpenFile",
+	"Start",
+	"End",
+	"PageUp",
+	"PageDown",
+	"SelectPageUp",
+	"SelectPageDown",
+	"HalfPageUp",
+	"HalfPageDown",
+	"ToggleHelp",
+	"ToggleKeyMenu",
+	"ToggleRuler",
+	"JumpLine",
+	"ClearStatus",
+	"ShellMode",
+	"CommandMode",
+	"AddTab",
+	"PreviousTab",
+	"NextTab",
+	"NextSplit",
+	"PreviousSplit",
+	"Unsplit",
+	"VSplit",
+	"HSplit",
+	"ToggleMacro",
+	"PlayMacro",
+	"Suspend",
+	"ScrollUp",
+	"ScrollDown",
+	"SpawnMultiCursor",
+	"SpawnMultiCursorSelect",
+	"RemoveMultiCursor",
+	"RemoveAllMultiCursors",
+	"SkipMultiCursor",
+}
+
+// InfoOverrides is the list of actions which have been overriden
+// by the infohandler
+var InfoOverrides = map[string]InfoKeyAction{
+	"CursorUp":      (*InfoPane).CursorUp,
+	"CursorDown":    (*InfoPane).CursorDown,
+	"InsertNewline": (*InfoPane).InsertNewline,
+	"Autocomplete":  (*InfoPane).Autocomplete,
+	"OutdentLine":   (*InfoPane).CycleBack,
+	"Escape":        (*InfoPane).Escape,
+	"Quit":          (*InfoPane).Quit,
+	"QuitAll":       (*InfoPane).QuitAll,
+}
+
+// CursorUp cycles history up
+func (h *InfoPane) CursorUp() {
+	h.UpHistory(h.History[h.PromptType])
+}
+
+// CursorDown cycles history down
+func (h *InfoPane) CursorDown() {
+	h.DownHistory(h.History[h.PromptType])
+}
+
+// Autocomplete begins autocompletion
+func (h *InfoPane) Autocomplete() {
+	b := h.Buf
+	if b.HasSuggestions {
+		b.CycleAutocomplete(true)
+		return
+	}
+
+	c := b.GetActiveCursor()
+	l := b.LineBytes(0)
+	l = util.SliceStart(l, c.X)
+
+	args := bytes.Split(l, []byte{' '})
+	cmd := string(args[0])
+
+	if len(args) == 1 {
+		b.Autocomplete(CommandComplete)
+	} else {
+		if action, ok := commands[cmd]; ok {
+			if action.completer != nil {
+				b.Autocomplete(action.completer)
+			}
+		}
+	}
+}
+
+// CycleBack cycles back in the autocomplete suggestion list
+func (h *InfoPane) CycleBack() {
+	if h.Buf.HasSuggestions {
+		h.Buf.CycleAutocomplete(false)
+	}
+}
+
+// InsertNewline completes the prompt
+func (h *InfoPane) InsertNewline() {
+	if !h.HasYN {
+		h.DonePrompt(false)
+	}
+}
+
+// Quit cancels the prompt
+func (h *InfoPane) Quit() {
+	h.DonePrompt(true)
+}
+
+// QuitAll cancels the prompt
+func (h *InfoPane) QuitAll() {
+	h.DonePrompt(true)
+}
+
+// Escape cancels the prompt
+func (h *InfoPane) Escape() {
+	h.DonePrompt(true)
+}

internal/action/pane.go

@@ -0,0 +1,14 @@
+package action
+
+import (
+	"github.com/zyedidia/micro/internal/display"
+)
+
+type Pane interface {
+	Handler
+	display.Window
+	ID() uint64
+	SetID(i uint64)
+	Name() string
+	Close()
+}

internal/action/rawpane.go

@@ -0,0 +1,40 @@
+package action
+
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/zyedidia/micro/internal/buffer"
+	"github.com/zyedidia/micro/internal/display"
+	"github.com/zyedidia/tcell"
+)
+
+type RawPane struct {
+	*BufPane
+}
+
+func NewRawPaneFromWin(b *buffer.Buffer, win display.BWindow) *RawPane {
+	rh := new(RawPane)
+	rh.BufPane = NewBufPane(b, win)
+
+	return rh
+}
+
+func NewRawPane() *RawPane {
+	b := buffer.NewBufferFromString("", "", buffer.BTRaw)
+	w := display.NewBufWindow(0, 0, 0, 0, b)
+	return NewRawPaneFromWin(b, w)
+}
+
+func (h *RawPane) HandleEvent(event tcell.Event) {
+	switch e := event.(type) {
+	case *tcell.EventKey:
+		if e.Key() == tcell.KeyCtrlQ {
+			h.Quit()
+		}
+	}
+
+	h.Buf.Insert(h.Cursor.Loc, reflect.TypeOf(event).String()[7:])
+	h.Buf.Insert(h.Cursor.Loc, fmt.Sprintf(": %q\n", event.EscSeq()))
+	h.Relocate()
+}

internal/action/tab.go

@@ -0,0 +1,282 @@
+package action
+
+import (
+	"github.com/zyedidia/micro/internal/buffer"
+	"github.com/zyedidia/micro/internal/config"
+	"github.com/zyedidia/micro/internal/display"
+	"github.com/zyedidia/micro/internal/screen"
+	"github.com/zyedidia/micro/internal/views"
+	"github.com/zyedidia/tcell"
+)
+
+// The TabList is a list of tabs and a window to display the tab bar
+// at the top of the screen
+type TabList struct {
+	*display.TabWindow
+	List []*Tab
+}
+
+// NewTabList creates a TabList from a list of buffers by creating a Tab
+// for each buffer
+func NewTabList(bufs []*buffer.Buffer) *TabList {
+	w, h := screen.Screen.Size()
+	iOffset := config.GetInfoBarOffset()
+	tl := new(TabList)
+	tl.List = make([]*Tab, len(bufs))
+	if len(bufs) > 1 {
+		for i, b := range bufs {
+			tl.List[i] = NewTabFromBuffer(0, 1, w, h-1-iOffset, b)
+		}
+	} else {
+		tl.List[0] = NewTabFromBuffer(0, 0, w, h-iOffset, bufs[0])
+	}
+	tl.TabWindow = display.NewTabWindow(w, 0)
+	tl.Names = make([]string, len(bufs))
+
+	return tl
+}
+
+// UpdateNames makes sure that the list of names the tab window has access to is
+// correct
+func (t *TabList) UpdateNames() {
+	t.Names = t.Names[:0]
+	for _, p := range t.List {
+		t.Names = append(t.Names, p.Panes[p.active].Name())
+	}
+}
+
+// AddTab adds a new tab to this TabList
+func (t *TabList) AddTab(p *Tab) {
+	t.List = append(t.List, p)
+	t.Resize()
+	t.UpdateNames()
+}
+
+// RemoveTab removes a tab with the given id from the TabList
+func (t *TabList) RemoveTab(id uint64) {
+	for i, p := range t.List {
+		if len(p.Panes) == 0 {
+			continue
+		}
+		if p.Panes[0].ID() == id {
+			copy(t.List[i:], t.List[i+1:])
+			t.List[len(t.List)-1] = nil
+			t.List = t.List[:len(t.List)-1]
+			if t.Active() >= len(t.List) {
+				t.SetActive(len(t.List) - 1)
+			}
+			t.Resize()
+			t.UpdateNames()
+			return
+		}
+	}
+}
+
+// Resize resizes all elements within the tab list
+// One thing to note is that when there is only 1 tab
+// the tab bar should not be drawn so resizing must take
+// that into account
+func (t *TabList) Resize() {
+	w, h := screen.Screen.Size()
+	iOffset := config.GetInfoBarOffset()
+	InfoBar.Resize(w, h-1)
+	if len(t.List) > 1 {
+		for _, p := range t.List {
+			p.Y = 1
+			p.Node.Resize(w, h-1-iOffset)
+			p.Resize()
+		}
+	} else if len(t.List) == 1 {
+		t.List[0].Y = 0
+		t.List[0].Node.Resize(w, h-iOffset)
+		t.List[0].Resize()
+	}
+}
+
+// HandleEvent checks for a resize event or a mouse event on the tab bar
+// otherwise it will forward the event to the currently active tab
+func (t *TabList) HandleEvent(event tcell.Event) {
+	switch e := event.(type) {
+	case *tcell.EventResize:
+		t.Resize()
+	case *tcell.EventMouse:
+		mx, my := e.Position()
+		switch e.Buttons() {
+		case tcell.Button1:
+			ind := t.LocFromVisual(buffer.Loc{mx, my})
+			if ind != -1 {
+				t.SetActive(ind)
+			}
+		case tcell.WheelUp:
+			if my == t.Y {
+				t.Scroll(4)
+				return
+			}
+		case tcell.WheelDown:
+			if my == t.Y {
+				t.Scroll(-4)
+				return
+			}
+		}
+	}
+	t.List[t.Active()].HandleEvent(event)
+}
+
+// Display updates the names and then displays the tab bar
+func (t *TabList) Display() {
+	t.UpdateNames()
+	if len(t.List) > 1 {
+		t.TabWindow.Display()
+	}
+}
+
+// Tabs is the global tab list
+var Tabs *TabList
+
+func InitTabs(bufs []*buffer.Buffer) {
+	Tabs = NewTabList(bufs)
+}
+
+func MainTab() *Tab {
+	return Tabs.List[Tabs.Active()]
+}
+
+// A Tab represents a single tab
+// It consists of a list of edit panes (the open buffers),
+// a split tree (stored as just the root node), and a uiwindow
+// to display the UI elements like the borders between splits
+type Tab struct {
+	*views.Node
+	*display.UIWindow
+	Panes  []Pane
+	active int
+
+	resizing *views.Node // node currently being resized
+}
+
+// NewTabFromBuffer creates a new tab from the given buffer
+func NewTabFromBuffer(x, y, width, height int, b *buffer.Buffer) *Tab {
+	t := new(Tab)
+	t.Node = views.NewRoot(x, y, width, height)
+	t.UIWindow = display.NewUIWindow(t.Node)
+
+	e := NewBufPaneFromBuf(b)
+	e.SetID(t.ID())
+
+	t.Panes = append(t.Panes, e)
+	return t
+}
+
+func NewTabFromPane(x, y, width, height int, pane Pane) *Tab {
+	t := new(Tab)
+	t.Node = views.NewRoot(x, y, width, height)
+	t.UIWindow = display.NewUIWindow(t.Node)
+
+	pane.SetID(t.ID())
+
+	t.Panes = append(t.Panes, pane)
+	return t
+}
+
+// HandleEvent takes a tcell event and usually dispatches it to the current
+// active pane. However if the event is a resize or a mouse event where the user
+// is interacting with the UI (resizing splits) then the event is consumed here
+// If the event is a mouse event in a pane, that pane will become active and get
+// the event
+func (t *Tab) HandleEvent(event tcell.Event) {
+	switch e := event.(type) {
+	case *tcell.EventMouse:
+		mx, my := e.Position()
+		switch e.Buttons() {
+		case tcell.Button1:
+			resizeID := t.GetMouseSplitID(buffer.Loc{mx, my})
+			if t.resizing != nil {
+				var size int
+				if t.resizing.Kind == views.STVert {
+					size = mx - t.resizing.X
+				} else {
+					size = my - t.resizing.Y + 1
+				}
+				t.resizing.ResizeSplit(size)
+				t.Resize()
+				return
+			}
+
+			if resizeID != 0 {
+				t.resizing = t.GetNode(uint64(resizeID))
+				return
+			}
+
+			for i, p := range t.Panes {
+				v := p.GetView()
+				inpane := mx >= v.X && mx < v.X+v.Width && my >= v.Y && my < v.Y+v.Height
+				if inpane {
+					t.SetActive(i)
+					break
+				}
+			}
+		case tcell.ButtonNone:
+			t.resizing = nil
+		default:
+			for _, p := range t.Panes {
+				v := p.GetView()
+				inpane := mx >= v.X && mx < v.X+v.Width && my >= v.Y && my < v.Y+v.Height
+				if inpane {
+					p.HandleEvent(event)
+					return
+				}
+			}
+		}
+
+	}
+	t.Panes[t.active].HandleEvent(event)
+}
+
+// SetActive changes the currently active pane to the specified index
+func (t *Tab) SetActive(i int) {
+	t.active = i
+	for j, p := range t.Panes {
+		if j == i {
+			p.SetActive(true)
+		} else {
+			p.SetActive(false)
+		}
+	}
+}
+
+// GetPane returns the pane with the given split index
+func (t *Tab) GetPane(splitid uint64) int {
+	for i, p := range t.Panes {
+		if p.ID() == splitid {
+			return i
+		}
+	}
+	return 0
+}
+
+// Remove pane removes the pane with the given index
+func (t *Tab) RemovePane(i int) {
+	copy(t.Panes[i:], t.Panes[i+1:])
+	t.Panes[len(t.Panes)-1] = nil
+	t.Panes = t.Panes[:len(t.Panes)-1]
+}
+
+// Resize resizes all panes according to their corresponding split nodes
+func (t *Tab) Resize() {
+	for _, p := range t.Panes {
+		n := t.GetNode(p.ID())
+		pv := p.GetView()
+		offset := 0
+		if n.X != 0 {
+			offset = 1
+		}
+		pv.X, pv.Y = n.X+offset, n.Y
+		p.SetView(pv)
+		p.Resize(n.W-offset, n.H)
+	}
+}
+
+// CurPane returns the currently active pane
+func (t *Tab) CurPane() Pane {
+	return t.Panes[t.active]
+}

internal/action/terminal_supported.go

@@ -0,0 +1,30 @@
+// +build linux darwin dragonfly openbsd_amd64 freebsd
+
+package action
+
+import (
+	"github.com/zyedidia/micro/internal/shell"
+	"github.com/zyedidia/micro/pkg/shellwords"
+)
+
+const TermEmuSupported = true
+
+func RunTermEmulator(h *BufPane, input string, wait bool, getOutput bool, callback string, userargs []interface{}) error {
+	args, err := shellwords.Split(input)
+	if err != nil {
+		return err
+	}
+
+	t := new(shell.Terminal)
+	t.Start(args, getOutput, wait, callback, userargs)
+
+	id := h.ID()
+	h.AddTab()
+	id = MainTab().Panes[0].ID()
+
+	v := h.GetView()
+	MainTab().Panes[0] = NewTermPane(v.X, v.Y, v.Width, v.Height, t, id)
+	MainTab().SetActive(0)
+
+	return nil
+}

internal/action/terminal_unsupported.go

@@ -0,0 +1,11 @@
+// +build !linux,!darwin,!freebsd,!dragonfly,!openbsd_amd64
+
+package action
+
+import "errors"
+
+const TermEmuSupported = false
+
+func RunTermEmulator(input string, wait bool, getOutput bool, callback string, userargs []interface{}) error {
+	return errors.New("Unsupported operating system")
+}

internal/action/termpane.go

@@ -0,0 +1,120 @@
+package action
+
+import (
+	"runtime"
+
+	"github.com/zyedidia/clipboard"
+	"github.com/zyedidia/micro/internal/display"
+	"github.com/zyedidia/micro/internal/screen"
+	"github.com/zyedidia/micro/internal/shell"
+	"github.com/zyedidia/tcell"
+	"github.com/zyedidia/terminal"
+)
+
+type TermPane struct {
+	*shell.Terminal
+	display.Window
+
+	mouseReleased bool
+	id            uint64
+}
+
+func NewTermPane(x, y, w, h int, t *shell.Terminal, id uint64) *TermPane {
+	th := new(TermPane)
+	th.Terminal = t
+	th.id = id
+	th.mouseReleased = true
+	th.Window = display.NewTermWindow(x, y, w, h, t)
+	return th
+}
+
+func (t *TermPane) ID() uint64 {
+	return t.id
+}
+
+func (t *TermPane) SetID(i uint64) {
+	t.id = i
+}
+
+func (t *TermPane) Close() {}
+
+func (t *TermPane) Quit() {
+	t.Close()
+	if len(MainTab().Panes) > 1 {
+		t.Unsplit()
+	} else if len(Tabs.List) > 1 {
+		Tabs.RemoveTab(t.id)
+	} else {
+		screen.Screen.Fini()
+		InfoBar.Close()
+		runtime.Goexit()
+	}
+}
+
+func (t *TermPane) Unsplit() {
+	n := MainTab().GetNode(t.id)
+	n.Unsplit()
+
+	MainTab().RemovePane(MainTab().GetPane(t.id))
+	MainTab().Resize()
+	MainTab().SetActive(len(MainTab().Panes) - 1)
+}
+
+// HandleEvent handles a tcell event by forwarding it to the terminal emulator
+// If the event is a mouse event and the program running in the emulator
+// does not have mouse support, the emulator will support selections and
+// copy-paste
+func (t *TermPane) HandleEvent(event tcell.Event) {
+	if e, ok := event.(*tcell.EventKey); ok {
+		if t.Status == shell.TTDone {
+			switch e.Key() {
+			case tcell.KeyEscape, tcell.KeyCtrlQ, tcell.KeyEnter:
+				t.Close()
+				t.Quit()
+			default:
+			}
+		}
+		if e.Key() == tcell.KeyCtrlC && t.HasSelection() {
+			clipboard.WriteAll(t.GetSelection(t.GetView().Width), "clipboard")
+			InfoBar.Message("Copied selection to clipboard")
+		} else if t.Status != shell.TTDone {
+			t.WriteString(event.EscSeq())
+		}
+	} else if e, ok := event.(*tcell.EventMouse); e != nil && (!ok || t.State.Mode(terminal.ModeMouseMask)) {
+		t.WriteString(event.EscSeq())
+	} else if e != nil {
+		x, y := e.Position()
+		v := t.GetView()
+		x -= v.X
+		y -= v.Y
+
+		if e.Buttons() == tcell.Button1 {
+			if !t.mouseReleased {
+				// drag
+				t.Selection[1].X = x
+				t.Selection[1].Y = y
+			} else {
+				t.Selection[0].X = x
+				t.Selection[0].Y = y
+				t.Selection[1].X = x
+				t.Selection[1].Y = y
+			}
+
+			t.mouseReleased = false
+		} else if e.Buttons() == tcell.ButtonNone {
+			if !t.mouseReleased {
+				t.Selection[1].X = x
+				t.Selection[1].Y = y
+			}
+			t.mouseReleased = true
+		}
+	}
+
+	if t.Status == shell.TTClose {
+		t.Quit()
+	}
+}
+
+func (t *TermPane) HandleCommand(input string) {
+	InfoBar.Error("Commands are unsupported in term for now")
+}

internal/buffer/autocomplete.go

@@ -0,0 +1,206 @@
+package buffer
+
+import (
+	"bytes"
+	"io/ioutil"
+	"os"
+	"sort"
+	"strings"
+	"unicode/utf8"
+
+	"github.com/zyedidia/micro/internal/util"
+)
+
+// A Completer is a function that takes a buffer and returns info
+// describing what autocompletions should be inserted at the current
+// cursor location
+// It returns a list of string suggestions which will be inserted at
+// the current cursor location if selected as well as a list of
+// suggestion names which can be displayed in an autocomplete box or
+// other UI element
+type Completer func(*Buffer) ([]string, []string)
+
+func (b *Buffer) GetSuggestions() {
+
+}
+
+// Autocomplete starts the autocomplete process
+func (b *Buffer) Autocomplete(c Completer) bool {
+	b.Completions, b.Suggestions = c(b)
+	if len(b.Completions) != len(b.Suggestions) || len(b.Completions) == 0 {
+		return false
+	}
+	b.CurSuggestion = -1
+	b.CycleAutocomplete(true)
+	return true
+}
+
+// CycleAutocomplete moves to the next suggestion
+func (b *Buffer) CycleAutocomplete(forward bool) {
+	prevSuggestion := b.CurSuggestion
+
+	if forward {
+		b.CurSuggestion++
+	} else {
+		b.CurSuggestion--
+	}
+	if b.CurSuggestion >= len(b.Suggestions) {
+		b.CurSuggestion = 0
+	} else if b.CurSuggestion < 0 {
+		b.CurSuggestion = len(b.Suggestions) - 1
+	}
+
+	c := b.GetActiveCursor()
+	start := c.Loc
+	end := c.Loc
+	if prevSuggestion < len(b.Suggestions) && prevSuggestion >= 0 {
+		start = end.Move(-utf8.RuneCountInString(b.Completions[prevSuggestion]), b)
+	} else {
+		// end = start.Move(1, b)
+	}
+
+	b.Replace(start, end, b.Completions[b.CurSuggestion])
+	if len(b.Suggestions) > 1 {
+		b.HasSuggestions = true
+	}
+}
+
+// GetWord gets the most recent word separated by any separator
+// (whitespace, punctuation, any non alphanumeric character)
+func GetWord(b *Buffer) ([]byte, int) {
+	c := b.GetActiveCursor()
+	l := b.LineBytes(c.Y)
+	l = util.SliceStart(l, c.X)
+
+	if c.X == 0 || util.IsWhitespace(b.RuneAt(c.Loc)) {
+		return []byte{}, -1
+	}
+
+	if util.IsNonAlphaNumeric(b.RuneAt(c.Loc)) {
+		return []byte{}, c.X
+	}
+
+	args := bytes.FieldsFunc(l, util.IsNonAlphaNumeric)
+	input := args[len(args)-1]
+	return input, c.X - utf8.RuneCount(input)
+}
+
+// GetArg gets the most recent word (separated by ' ' only)
+func GetArg(b *Buffer) (string, int) {
+	c := b.GetActiveCursor()
+	l := b.LineBytes(c.Y)
+	l = util.SliceStart(l, c.X)
+
+	args := bytes.Split(l, []byte{' '})
+	input := string(args[len(args)-1])
+	argstart := 0
+	for i, a := range args {
+		if i == len(args)-1 {
+			break
+		}
+		argstart += utf8.RuneCount(a) + 1
+	}
+
+	return input, argstart
+}
+
+// FileComplete autocompletes filenames
+func FileComplete(b *Buffer) ([]string, []string) {
+	c := b.GetActiveCursor()
+	input, argstart := GetArg(b)
+
+	sep := string(os.PathSeparator)
+	dirs := strings.Split(input, sep)
+
+	var files []os.FileInfo
+	var err error
+	if len(dirs) > 1 {
+		directories := strings.Join(dirs[:len(dirs)-1], sep) + sep
+
+		directories, _ = util.ReplaceHome(directories)
+		files, err = ioutil.ReadDir(directories)
+	} else {
+		files, err = ioutil.ReadDir(".")
+	}
+
+	if err != nil {
+		return nil, nil
+	}
+
+	var suggestions []string
+	for _, f := range files {
+		name := f.Name()
+		if f.IsDir() {
+			name += sep
+		}
+		if strings.HasPrefix(name, dirs[len(dirs)-1]) {
+			suggestions = append(suggestions, name)
+		}
+	}
+
+	sort.Strings(suggestions)
+	completions := make([]string, len(suggestions))
+	for i := range suggestions {
+		var complete string
+		if len(dirs) > 1 {
+			complete = strings.Join(dirs[:len(dirs)-1], sep) + sep + suggestions[i]
+		} else {
+			complete = suggestions[i]
+		}
+		completions[i] = util.SliceEndStr(complete, c.X-argstart)
+	}
+
+	return completions, suggestions
+}
+
+// BufferComplete autocompletes based on previous words in the buffer
+func BufferComplete(b *Buffer) ([]string, []string) {
+	c := b.GetActiveCursor()
+	input, argstart := GetWord(b)
+
+	if argstart == -1 {
+		return []string{}, []string{}
+	}
+
+	inputLen := utf8.RuneCount(input)
+
+	suggestionsSet := make(map[string]struct{})
+
+	var suggestions []string
+	for i := c.Y; i >= 0; i-- {
+		l := b.LineBytes(i)
+		words := bytes.FieldsFunc(l, util.IsNonAlphaNumeric)
+		for _, w := range words {
+			if bytes.HasPrefix(w, input) && utf8.RuneCount(w) > inputLen {
+				strw := string(w)
+				if _, ok := suggestionsSet[strw]; !ok {
+					suggestionsSet[strw] = struct{}{}
+					suggestions = append(suggestions, strw)
+				}
+			}
+		}
+	}
+	for i := c.Y + 1; i < b.LinesNum(); i++ {
+		l := b.LineBytes(i)
+		words := bytes.FieldsFunc(l, util.IsNonAlphaNumeric)
+		for _, w := range words {
+			if bytes.HasPrefix(w, input) && utf8.RuneCount(w) > inputLen {
+				strw := string(w)
+				if _, ok := suggestionsSet[strw]; !ok {
+					suggestionsSet[strw] = struct{}{}
+					suggestions = append(suggestions, strw)
+				}
+			}
+		}
+	}
+	if len(suggestions) > 1 {
+		suggestions = append(suggestions, string(input))
+	}
+
+	completions := make([]string, len(suggestions))
+	for i := range suggestions {
+		completions[i] = util.SliceEndStr(suggestions[i], c.X-argstart)
+	}
+
+	return completions, suggestions
+}

internal/buffer/backup.go

@@ -0,0 +1,118 @@
+package buffer
+
+import (
+	"fmt"
+	"io"
+	"log"
+	"os"
+	"time"
+
+	"github.com/zyedidia/micro/internal/config"
+	"github.com/zyedidia/micro/internal/screen"
+	"github.com/zyedidia/micro/internal/util"
+	"golang.org/x/text/encoding"
+)
+
+const backupMsg = `A backup was detected for this file. This likely means that micro
+crashed while editing this file, or another instance of micro is currently
+editing this file.
+
+The backup was created on %s.
+
+* 'recover' will apply the backup as unsaved changes to the current buffer.
+  When the buffer is closed, the backup will be removed.
+* 'ignore' will ignore the backup, discarding its changes. The backup file
+  will be removed.
+
+Options: [r]ecover, [i]gnore: `
+
+// Backup saves the current buffer to ConfigDir/backups
+func (b *Buffer) Backup(checkTime bool) error {
+	if !b.Settings["backup"].(bool) || b.Path == "" {
+		return nil
+	}
+
+	if checkTime {
+		sub := time.Now().Sub(b.lastbackup)
+		if sub < time.Duration(backup_time)*time.Millisecond {
+			log.Println("Backup event but not enough time has passed", sub)
+			return nil
+		}
+	}
+
+	b.lastbackup = time.Now()
+
+	backupdir := config.ConfigDir + "/backups/"
+	if _, err := os.Stat(backupdir); os.IsNotExist(err) {
+		os.Mkdir(backupdir, os.ModePerm)
+		log.Println("Creating backup dir")
+	}
+
+	name := backupdir + util.EscapePath(b.AbsPath)
+
+	log.Println("Backing up to", name)
+
+	err := overwriteFile(name, encoding.Nop, func(file io.Writer) (e error) {
+		if len(b.lines) == 0 {
+			return
+		}
+
+		// end of line
+		eol := []byte{'\n'}
+
+		// write lines
+		if _, e = file.Write(b.lines[0].data); e != nil {
+			return
+		}
+
+		for _, l := range b.lines[1:] {
+			if _, e = file.Write(eol); e != nil {
+				return
+			}
+			if _, e = file.Write(l.data); e != nil {
+				return
+			}
+		}
+		return
+	})
+
+	return err
+}
+
+// RemoveBackup removes any backup file associated with this buffer
+func (b *Buffer) RemoveBackup() {
+	if !b.Settings["backup"].(bool) || b.Path == "" {
+		return
+	}
+	f := config.ConfigDir + "/backups/" + util.EscapePath(b.AbsPath)
+	os.Remove(f)
+}
+
+// ApplyBackup applies the corresponding backup file to this buffer (if one exists)
+// Returns true if a backup was applied
+func (b *Buffer) ApplyBackup(fsize int64) bool {
+	if b.Settings["backup"].(bool) && len(b.Path) > 0 {
+		backupfile := config.ConfigDir + "/backups/" + util.EscapePath(b.AbsPath)
+		if info, err := os.Stat(backupfile); err == nil {
+			backup, err := os.Open(backupfile)
+			if err == nil {
+				defer backup.Close()
+				t := info.ModTime()
+				msg := fmt.Sprintf(backupMsg, t.Format("Mon Jan _2 at 15:04, 2006"))
+				choice := screen.TermPrompt(msg, []string{"r", "i", "recover", "ignore"}, true)
+
+				if choice%2 == 0 {
+					// recover
+					b.LineArray = NewLineArray(uint64(fsize), FFAuto, backup)
+					b.isModified = true
+					return true
+				} else if choice%2 == 1 {
+					// delete
+					os.Remove(backupfile)
+				}
+			}
+		}
+	}
+
+	return false
+}

internal/buffer/buffer.go

@@ -0,0 +1,798 @@
+package buffer
+
+import (
+	"bytes"
+	"crypto/md5"
+	"errors"
+	"io"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"time"
+	"unicode/utf8"
+
+	luar "layeh.com/gopher-luar"
+
+	"github.com/zyedidia/micro/internal/config"
+	ulua "github.com/zyedidia/micro/internal/lua"
+	"github.com/zyedidia/micro/internal/screen"
+	. "github.com/zyedidia/micro/internal/util"
+	"github.com/zyedidia/micro/pkg/highlight"
+	"golang.org/x/text/encoding/htmlindex"
+	"golang.org/x/text/encoding/unicode"
+	"golang.org/x/text/transform"
+)
+
+const backup_time = 8000
+
+var (
+	OpenBuffers []*Buffer
+	LogBuf      *Buffer
+)
+
+// The BufType defines what kind of buffer this is
+type BufType struct {
+	Kind     int
+	Readonly bool // The buffer cannot be edited
+	Scratch  bool // The buffer cannot be saved
+	Syntax   bool // Syntax highlighting is enabled
+}
+
+var (
+	BTDefault = BufType{0, false, false, true}
+	BTHelp    = BufType{1, true, true, true}
+	BTLog     = BufType{2, true, true, false}
+	BTScratch = BufType{3, false, true, false}
+	BTRaw     = BufType{4, false, true, false}
+	BTInfo    = BufType{5, false, true, false}
+
+	ErrFileTooLarge = errors.New("File is too large to hash")
+)
+
+type SharedBuffer struct {
+	*LineArray
+	// Stores the last modification time of the file the buffer is pointing to
+	ModTime time.Time
+	// Type of the buffer (e.g. help, raw, scratch etc..)
+	Type BufType
+
+	isModified bool
+	// Whether or not suggestions can be autocompleted must be shared because
+	// it changes based on how the buffer has changed
+	HasSuggestions bool
+}
+
+func (b *SharedBuffer) insert(pos Loc, value []byte) {
+	b.isModified = true
+	b.HasSuggestions = false
+	b.LineArray.insert(pos, value)
+}
+func (b *SharedBuffer) remove(start, end Loc) []byte {
+	b.isModified = true
+	b.HasSuggestions = false
+	return b.LineArray.remove(start, end)
+}
+
+// Buffer stores the main information about a currently open file including
+// the actual text (in a LineArray), the undo/redo stack (in an EventHandler)
+// all the cursors, the syntax highlighting info, the settings for the buffer
+// and some misc info about modification time and path location.
+// The syntax highlighting info must be stored with the buffer because the syntax
+// highlighter attaches information to each line of the buffer for optimization
+// purposes so it doesn't have to rehighlight everything on every update.
+type Buffer struct {
+	*EventHandler
+	*SharedBuffer
+
+	cursors     []*Cursor
+	curCursor   int
+	StartCursor Loc
+
+	// Path to the file on disk
+	Path string
+	// Absolute path to the file on disk
+	AbsPath string
+	// Name of the buffer on the status line
+	name string
+
+	SyntaxDef   *highlight.Def
+	Highlighter *highlight.Highlighter
+
+	// Hash of the original buffer -- empty if fastdirty is on
+	origHash [md5.Size]byte
+
+	// Settings customized by the user
+	Settings map[string]interface{}
+
+	Suggestions   []string
+	Completions   []string
+	CurSuggestion int
+
+	Messages []*Message
+
+	// counts the number of edits
+	// resets every backup_time edits
+	lastbackup time.Time
+}
+
+// NewBufferFromFile opens a new buffer using the given path
+// It will also automatically handle `~`, and line/column with filename:l:c
+// It will return an empty buffer if the path does not exist
+// and an error if the file is a directory
+func NewBufferFromFile(path string, btype BufType) (*Buffer, error) {
+	var err error
+	filename, cursorPos := GetPathAndCursorPosition(path)
+	filename, err = ReplaceHome(filename)
+	if err != nil {
+		return nil, err
+	}
+
+	file, err := os.Open(filename)
+	fileInfo, _ := os.Stat(filename)
+
+	if err == nil && fileInfo.IsDir() {
+		return nil, errors.New(filename + " is a directory")
+	}
+
+	defer file.Close()
+
+	cursorLoc, cursorerr := ParseCursorLocation(cursorPos)
+	if cursorerr != nil {
+		cursorLoc = Loc{-1, -1}
+	}
+
+	var buf *Buffer
+	if err != nil {
+		// File does not exist -- create an empty buffer with that name
+		buf = NewBufferFromString("", filename, btype)
+	} else {
+		buf = NewBuffer(file, FSize(file), filename, cursorLoc, btype)
+	}
+
+	return buf, nil
+}
+
+// NewBufferFromString creates a new buffer containing the given string
+func NewBufferFromString(text, path string, btype BufType) *Buffer {
+	return NewBuffer(strings.NewReader(text), int64(len(text)), path, Loc{-1, -1}, btype)
+}
+
+// NewBuffer creates a new buffer from a given reader with a given path
+// Ensure that ReadSettings and InitGlobalSettings have been called before creating
+// a new buffer
+// Places the cursor at startcursor. If startcursor is -1, -1 places the
+// cursor at an autodetected location (based on savecursor or :LINE:COL)
+func NewBuffer(r io.Reader, size int64, path string, startcursor Loc, btype BufType) *Buffer {
+	absPath, _ := filepath.Abs(path)
+
+	b := new(Buffer)
+
+	b.Settings = config.DefaultCommonSettings()
+	for k, v := range config.GlobalSettings {
+		if _, ok := b.Settings[k]; ok {
+			b.Settings[k] = v
+		}
+	}
+	config.InitLocalSettings(b.Settings, path)
+
+	enc, err := htmlindex.Get(b.Settings["encoding"].(string))
+	if err != nil {
+		enc = unicode.UTF8
+		b.Settings["encoding"] = "utf-8"
+	}
+
+	reader := transform.NewReader(r, enc.NewDecoder())
+
+	found := false
+	if len(path) > 0 {
+		for _, buf := range OpenBuffers {
+			if buf.AbsPath == absPath && buf.Type != BTInfo {
+				found = true
+				b.SharedBuffer = buf.SharedBuffer
+				b.EventHandler = buf.EventHandler
+			}
+		}
+	}
+
+	b.Path = path
+	b.AbsPath = absPath
+
+	if !found {
+		b.SharedBuffer = new(SharedBuffer)
+		b.Type = btype
+
+		hasBackup := b.ApplyBackup(size)
+
+		if !hasBackup {
+			b.LineArray = NewLineArray(uint64(size), FFAuto, reader)
+		}
+		b.EventHandler = NewEventHandler(b.SharedBuffer, b.cursors)
+	}
+
+	if b.Settings["readonly"].(bool) {
+		b.Type.Readonly = true
+	}
+
+	// The last time this file was modified
+	b.ModTime, _ = GetModTime(b.Path)
+
+	switch b.Endings {
+	case FFUnix:
+		b.Settings["fileformat"] = "unix"
+	case FFDos:
+		b.Settings["fileformat"] = "dos"
+	}
+
+	b.UpdateRules()
+	config.InitLocalSettings(b.Settings, b.Path)
+
+	if _, err := os.Stat(config.ConfigDir + "/buffers/"); os.IsNotExist(err) {
+		os.Mkdir(config.ConfigDir+"/buffers/", os.ModePerm)
+	}
+
+	if startcursor.X != -1 && startcursor.Y != -1 {
+		b.StartCursor = startcursor
+	} else {
+		if b.Settings["savecursor"].(bool) || b.Settings["saveundo"].(bool) {
+			err := b.Unserialize()
+			if err != nil {
+				screen.TermMessage(err)
+			}
+		}
+	}
+
+	b.AddCursor(NewCursor(b, b.StartCursor))
+	b.GetActiveCursor().Relocate()
+
+	if !b.Settings["fastdirty"].(bool) {
+		if size > LargeFileThreshold {
+			// If the file is larger than LargeFileThreshold fastdirty needs to be on
+			b.Settings["fastdirty"] = true
+		} else {
+			calcHash(b, &b.origHash)
+		}
+	}
+
+	err = config.RunPluginFn("onBufferOpen", luar.New(ulua.L, b))
+	if err != nil {
+		screen.TermMessage(err)
+	}
+
+	OpenBuffers = append(OpenBuffers, b)
+
+	return b
+}
+
+// Close removes this buffer from the list of open buffers
+func (b *Buffer) Close() {
+	for i, buf := range OpenBuffers {
+		if b == buf {
+			b.Fini()
+			copy(OpenBuffers[i:], OpenBuffers[i+1:])
+			OpenBuffers[len(OpenBuffers)-1] = nil
+			OpenBuffers = OpenBuffers[:len(OpenBuffers)-1]
+			return
+		}
+	}
+}
+
+// Fini should be called when a buffer is closed and performs
+// some cleanup
+func (b *Buffer) Fini() {
+	if !b.Modified() {
+		b.Serialize()
+	}
+	b.RemoveBackup()
+}
+
+// GetName returns the name that should be displayed in the statusline
+// for this buffer
+func (b *Buffer) GetName() string {
+	if b.name == "" {
+		if b.Path == "" {
+			return "No name"
+		}
+		return b.Path
+	}
+	return b.name
+}
+
+//SetName changes the name for this buffer
+func (b *Buffer) SetName(s string) {
+	b.name = s
+}
+
+func (b *Buffer) Insert(start Loc, text string) {
+	if !b.Type.Readonly {
+		b.EventHandler.cursors = b.cursors
+		b.EventHandler.active = b.curCursor
+		b.EventHandler.Insert(start, text)
+
+		go b.Backup(true)
+	}
+}
+
+func (b *Buffer) Remove(start, end Loc) {
+	if !b.Type.Readonly {
+		b.EventHandler.cursors = b.cursors
+		b.EventHandler.active = b.curCursor
+		b.EventHandler.Remove(start, end)
+
+		go b.Backup(true)
+	}
+}
+
+// FileType returns the buffer's filetype
+func (b *Buffer) FileType() string {
+	return b.Settings["filetype"].(string)
+}
+
+// ReOpen reloads the current buffer from disk
+func (b *Buffer) ReOpen() error {
+	file, err := os.Open(b.Path)
+	if err != nil {
+		return err
+	}
+
+	enc, err := htmlindex.Get(b.Settings["encoding"].(string))
+	if err != nil {
+		return err
+	}
+
+	reader := transform.NewReader(file, enc.NewDecoder())
+	data, err := ioutil.ReadAll(reader)
+	txt := string(data)
+
+	if err != nil {
+		return err
+	}
+	b.EventHandler.ApplyDiff(txt)
+
+	b.ModTime, err = GetModTime(b.Path)
+	b.isModified = false
+	b.RelocateCursors()
+	return err
+}
+
+func (b *Buffer) RelocateCursors() {
+	for _, c := range b.cursors {
+		c.Relocate()
+	}
+}
+
+// RuneAt returns the rune at a given location in the buffer
+func (b *Buffer) RuneAt(loc Loc) rune {
+	line := b.LineBytes(loc.Y)
+	if len(line) > 0 {
+		i := 0
+		for len(line) > 0 {
+			r, size := utf8.DecodeRune(line)
+			line = line[size:]
+			i++
+
+			if i == loc.X {
+				return r
+			}
+		}
+	}
+	return '\n'
+}
+
+// Modified returns if this buffer has been modified since
+// being opened
+func (b *Buffer) Modified() bool {
+	if b.Type.Scratch {
+		return false
+	}
+
+	if b.Settings["fastdirty"].(bool) {
+		return b.isModified
+	}
+
+	var buff [md5.Size]byte
+
+	calcHash(b, &buff)
+	return buff != b.origHash
+}
+
+// calcHash calculates md5 hash of all lines in the buffer
+func calcHash(b *Buffer, out *[md5.Size]byte) error {
+	h := md5.New()
+
+	size := 0
+	if len(b.lines) > 0 {
+		n, e := h.Write(b.lines[0].data)
+		if e != nil {
+			return e
+		}
+		size += n
+
+		for _, l := range b.lines[1:] {
+			n, e = h.Write([]byte{'\n'})
+			if e != nil {
+				return e
+			}
+			size += n
+			n, e = h.Write(l.data)
+			if e != nil {
+				return e
+			}
+			size += n
+		}
+	}
+
+	if size > LargeFileThreshold {
+		return ErrFileTooLarge
+	}
+
+	h.Sum((*out)[:0])
+	return nil
+}
+
+// UpdateRules updates the syntax rules and filetype for this buffer
+// This is called when the colorscheme changes
+func (b *Buffer) UpdateRules() {
+	if !b.Type.Syntax {
+		return
+	}
+	rehighlight := false
+	var files []*highlight.File
+	for _, f := range config.ListRuntimeFiles(config.RTSyntax) {
+		data, err := f.Data()
+		if err != nil {
+			screen.TermMessage("Error loading syntax file " + f.Name() + ": " + err.Error())
+		} else {
+			file, err := highlight.ParseFile(data)
+			if err != nil {
+				screen.TermMessage("Error loading syntax file " + f.Name() + ": " + err.Error())
+				continue
+			}
+			ftdetect, err := highlight.ParseFtDetect(file)
+			if err != nil {
+				screen.TermMessage("Error loading syntax file " + f.Name() + ": " + err.Error())
+				continue
+			}
+
+			ft := b.Settings["filetype"].(string)
+			if (ft == "unknown" || ft == "") && !rehighlight {
+				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 {
+						screen.TermMessage("Error loading syntax file " + f.Name() + ": " + err.Error())
+						continue
+					}
+					rehighlight = true
+				}
+			} else {
+				if file.FileType == ft && !rehighlight {
+					header := new(highlight.Header)
+					header.FileType = file.FileType
+					header.FtDetect = ftdetect
+					b.SyntaxDef, err = highlight.ParseDef(file, header)
+					if err != nil {
+						screen.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)
+	}
+
+	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)
+			}
+		}
+	}
+}
+
+// ClearMatches clears all of the syntax highlighting for the buffer
+func (b *Buffer) ClearMatches() {
+	for i := range b.lines {
+		b.SetMatch(i, nil)
+		b.SetState(i, nil)
+	}
+}
+
+// IndentString returns this buffer's indent method (a tabstop or n spaces
+// depending on the settings)
+func (b *Buffer) IndentString(tabsize int) string {
+	if b.Settings["tabstospaces"].(bool) {
+		return Spaces(tabsize)
+	}
+	return "\t"
+}
+
+// SetCursors resets this buffer's cursors to a new list
+func (b *Buffer) SetCursors(c []*Cursor) {
+	b.cursors = c
+	b.EventHandler.cursors = b.cursors
+	b.EventHandler.active = b.curCursor
+}
+
+// AddCursor adds a new cursor to the list
+func (b *Buffer) AddCursor(c *Cursor) {
+	b.cursors = append(b.cursors, c)
+	b.EventHandler.cursors = b.cursors
+	b.EventHandler.active = b.curCursor
+	b.UpdateCursors()
+}
+
+// SetCurCursor sets the current cursor
+func (b *Buffer) SetCurCursor(n int) {
+	b.curCursor = n
+}
+
+// GetActiveCursor returns the main cursor in this buffer
+func (b *Buffer) GetActiveCursor() *Cursor {
+	return b.cursors[b.curCursor]
+}
+
+// GetCursor returns the nth cursor
+func (b *Buffer) GetCursor(n int) *Cursor {
+	return b.cursors[n]
+}
+
+// GetCursors returns the list of cursors in this buffer
+func (b *Buffer) GetCursors() []*Cursor {
+	return b.cursors
+}
+
+// NumCursors returns the number of cursors
+func (b *Buffer) NumCursors() int {
+	return len(b.cursors)
+}
+
+// MergeCursors merges any cursors that are at the same position
+// into one cursor
+func (b *Buffer) MergeCursors() {
+	var cursors []*Cursor
+	for i := 0; i < len(b.cursors); i++ {
+		c1 := b.cursors[i]
+		if c1 != nil {
+			for j := 0; j < len(b.cursors); j++ {
+				c2 := b.cursors[j]
+				if c2 != nil && i != j && c1.Loc == c2.Loc {
+					b.cursors[j] = nil
+				}
+			}
+			cursors = append(cursors, c1)
+		}
+	}
+
+	b.cursors = cursors
+
+	for i := range b.cursors {
+		b.cursors[i].Num = i
+	}
+
+	if b.curCursor >= len(b.cursors) {
+		b.curCursor = len(b.cursors) - 1
+	}
+	b.EventHandler.cursors = b.cursors
+	b.EventHandler.active = b.curCursor
+}
+
+// UpdateCursors updates all the cursors indicies
+func (b *Buffer) UpdateCursors() {
+	b.EventHandler.cursors = b.cursors
+	b.EventHandler.active = b.curCursor
+	for i, c := range b.cursors {
+		c.Num = i
+	}
+}
+
+func (b *Buffer) RemoveCursor(i int) {
+	copy(b.cursors[i:], b.cursors[i+1:])
+	b.cursors[len(b.cursors)-1] = nil
+	b.cursors = b.cursors[:len(b.cursors)-1]
+	b.curCursor = Clamp(b.curCursor, 0, len(b.cursors)-1)
+	b.UpdateCursors()
+}
+
+// ClearCursors removes all extra cursors
+func (b *Buffer) ClearCursors() {
+	for i := 1; i < len(b.cursors); i++ {
+		b.cursors[i] = nil
+	}
+	b.cursors = b.cursors[:1]
+	b.UpdateCursors()
+	b.curCursor = 0
+	b.GetActiveCursor().ResetSelection()
+}
+
+// MoveLinesUp moves the range of lines up one row
+func (b *Buffer) MoveLinesUp(start int, end int) {
+	if start < 1 || start >= end || end > len(b.lines) {
+		return
+	}
+	l := string(b.LineBytes(start - 1))
+	if end == len(b.lines) {
+		b.Insert(
+			Loc{
+				utf8.RuneCount(b.lines[end-1].data),
+				end - 1,
+			},
+			"\n"+l,
+		)
+	} else {
+		b.Insert(
+			Loc{0, end},
+			l+"\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) {
+	if start < 0 || start >= end || end >= len(b.lines)-1 {
+		return
+	}
+	l := string(b.LineBytes(end))
+	b.Insert(
+		Loc{0, start},
+		l+"\n",
+	)
+	end++
+	b.Remove(
+		Loc{0, end},
+		Loc{0, end + 1},
+	)
+}
+
+var BracePairs = [][2]rune{
+	{'(', ')'},
+	{'{', '}'},
+	{'[', ']'},
+}
+
+// FindMatchingBrace returns the location in the buffer of the matching bracket
+// It is given a brace type containing the open and closing character, (for example
+// '{' and '}') as well as the location to match from
+// TODO: maybe can be more efficient with utf8 package
+// returns the location of the matching brace
+// if the boolean returned is true then the original matching brace is one character left
+// of the starting location
+func (b *Buffer) FindMatchingBrace(braceType [2]rune, start Loc) (Loc, bool) {
+	curLine := []rune(string(b.LineBytes(start.Y)))
+	startChar := ' '
+	if start.X >= 0 && start.X < len(curLine) {
+		startChar = curLine[start.X]
+	}
+	leftChar := ' '
+	if start.X-1 >= 0 && start.X-1 < len(curLine) {
+		leftChar = curLine[start.X-1]
+	}
+	var i int
+	if startChar == braceType[0] || leftChar == braceType[0] {
+		for y := start.Y; y < b.LinesNum(); y++ {
+			l := []rune(string(b.LineBytes(y)))
+			xInit := 0
+			if y == start.Y {
+				if startChar == braceType[0] {
+					xInit = start.X
+				} else {
+					xInit = start.X - 1
+				}
+			}
+			for x := xInit; x < len(l); x++ {
+				r := l[x]
+				if r == braceType[0] {
+					i++
+				} else if r == braceType[1] {
+					i--
+					if i == 0 {
+						if startChar == braceType[0] {
+							return Loc{x, y}, false
+						}
+						return Loc{x, y}, true
+					}
+				}
+			}
+		}
+	} else if startChar == braceType[1] || leftChar == braceType[1] {
+		for y := start.Y; y >= 0; y-- {
+			l := []rune(string(b.lines[y].data))
+			xInit := len(l) - 1
+			if y == start.Y {
+				if leftChar == braceType[1] {
+					xInit = start.X - 1
+				} else {
+					xInit = start.X
+				}
+			}
+			for x := xInit; x >= 0; x-- {
+				r := l[x]
+				if r == braceType[0] {
+					i--
+					if i == 0 {
+						if leftChar == braceType[1] {
+							return Loc{x, y}, true
+						}
+						return Loc{x, y}, false
+					}
+				} else if r == braceType[1] {
+					i++
+				}
+			}
+		}
+	}
+	return start, true
+}
+
+// Retab changes all tabs to spaces or vice versa
+func (b *Buffer) Retab() {
+	toSpaces := b.Settings["tabstospaces"].(bool)
+	tabsize := IntOpt(b.Settings["tabsize"])
+	dirty := false
+
+	for i := 0; i < b.LinesNum(); i++ {
+		l := b.LineBytes(i)
+
+		ws := GetLeadingWhitespace(l)
+		if len(ws) != 0 {
+			if toSpaces {
+				ws = bytes.Replace(ws, []byte{'\t'}, bytes.Repeat([]byte{' '}, tabsize), -1)
+			} else {
+				ws = bytes.Replace(ws, bytes.Repeat([]byte{' '}, tabsize), []byte{'\t'}, -1)
+			}
+		}
+
+		l = bytes.TrimLeft(l, " \t")
+		b.lines[i].data = append(ws, l...)
+		dirty = true
+	}
+
+	b.isModified = dirty
+}
+
+// ParseCursorLocation turns a cursor location like 10:5 (LINE:COL)
+// into a loc
+func ParseCursorLocation(cursorPositions []string) (Loc, error) {
+	startpos := Loc{0, 0}
+	var err error
+
+	// if no positions are available exit early
+	if cursorPositions == nil {
+		return startpos, errors.New("No cursor positions were provided.")
+	}
+
+	startpos.Y, err = strconv.Atoi(cursorPositions[0])
+	startpos.Y -= 1
+	if err == nil {
+		if len(cursorPositions) > 1 {
+			startpos.X, err = strconv.Atoi(cursorPositions[1])
+			if startpos.X > 0 {
+				startpos.X -= 1
+			}
+		}
+	}
+
+	return startpos, err
+}
+
+func (b *Buffer) Line(i int) string {
+	return string(b.LineBytes(i))
+}
+
+func WriteLog(s string) {
+	LogBuf.EventHandler.Insert(LogBuf.End(), s)
+}

internal/buffer/cursor.go

@@ -0,0 +1,440 @@
+package buffer
+
+import (
+	"unicode/utf8"
+
+	"github.com/zyedidia/clipboard"
+	"github.com/zyedidia/micro/internal/util"
+)
+
+// InBounds returns whether the given location is a valid character position in the given buffer
+func InBounds(pos Loc, buf *Buffer) bool {
+	if pos.Y < 0 || pos.Y >= len(buf.lines) || pos.X < 0 || pos.X > utf8.RuneCount(buf.LineBytes(pos.Y)) {
+		return false
+	}
+
+	return true
+}
+
+// The Cursor struct stores the location of the cursor in the buffer
+// as well as the selection
+type Cursor struct {
+	buf *Buffer
+	Loc
+
+	// Last cursor x position
+	LastVisualX int
+
+	// The current selection as a range of character numbers (inclusive)
+	CurSelection [2]Loc
+	// The original selection as a range of character numbers
+	// This is used for line and word selection where it is necessary
+	// to know what the original selection was
+	OrigSelection [2]Loc
+
+	// Which cursor index is this (for multiple cursors)
+	Num int
+}
+
+func NewCursor(b *Buffer, l Loc) *Cursor {
+	c := &Cursor{
+		buf: b,
+		Loc: l,
+	}
+	c.StoreVisualX()
+	return c
+}
+
+func (c *Cursor) SetBuf(b *Buffer) {
+	c.buf = b
+}
+
+func (c *Cursor) Buf() *Buffer {
+	return c.buf
+}
+
+// Goto puts the cursor at the given cursor's location and gives
+// the current cursor its selection too
+func (c *Cursor) Goto(b Cursor) {
+	c.X, c.Y, c.LastVisualX = b.X, b.Y, b.LastVisualX
+	c.OrigSelection, c.CurSelection = b.OrigSelection, b.CurSelection
+}
+
+// GotoLoc puts the cursor at the given cursor's location and gives
+// the current cursor its selection too
+func (c *Cursor) GotoLoc(l Loc) {
+	c.X, c.Y = l.X, l.Y
+	c.StoreVisualX()
+}
+
+// GetVisualX returns the x value of the cursor in visual spaces
+func (c *Cursor) GetVisualX() int {
+	if c.X <= 0 {
+		c.X = 0
+		return 0
+	}
+
+	bytes := c.buf.LineBytes(c.Y)
+	tabsize := int(c.buf.Settings["tabsize"].(float64))
+	if c.X > utf8.RuneCount(bytes) {
+		c.X = utf8.RuneCount(bytes) - 1
+	}
+
+	return util.StringWidth(bytes, c.X, tabsize)
+}
+
+// GetCharPosInLine gets the char position of a visual x y
+// coordinate (this is necessary because tabs are 1 char but
+// 4 visual spaces)
+func (c *Cursor) GetCharPosInLine(b []byte, visualPos int) int {
+	tabsize := int(c.buf.Settings["tabsize"].(float64))
+	return util.GetCharPosInLine(b, visualPos, tabsize)
+}
+
+// Start moves the cursor to the start of the line it is on
+func (c *Cursor) Start() {
+	c.X = 0
+	c.LastVisualX = c.GetVisualX()
+}
+
+// StartOfText moves the cursor to the first non-whitespace rune of
+// the line it is on
+func (c *Cursor) StartOfText() {
+	c.Start()
+	for util.IsWhitespace(c.RuneUnder(c.X)) {
+		if c.X == utf8.RuneCount(c.buf.LineBytes(c.Y)) {
+			break
+		}
+		c.Right()
+	}
+}
+
+// End moves the cursor to the end of the line it is on
+func (c *Cursor) End() {
+	c.X = utf8.RuneCount(c.buf.LineBytes(c.Y))
+	c.LastVisualX = c.GetVisualX()
+}
+
+// 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(string(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]
+}
+
+// DeleteSelection deletes the currently selected text
+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.HasSelection() {
+		return
+	} else {
+		c.buf.Remove(c.CurSelection[0], c.CurSelection[1])
+		c.Loc = c.CurSelection[0]
+	}
+}
+
+// Deselect closes the cursor's current selection
+// Start indicates whether the cursor should be placed
+// at the start or end of the selection
+func (c *Cursor) Deselect(start bool) {
+	if c.HasSelection() {
+		if start {
+			c.Loc = c.CurSelection[0]
+		} else {
+			c.Loc = c.CurSelection[1].Move(-1, c.buf)
+		}
+		c.ResetSelection()
+		c.StoreVisualX()
+	}
+}
+
+// GetSelection returns the cursor's selection
+func (c *Cursor) GetSelection() []byte {
+	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 []byte{}
+}
+
+// SelectLine selects the current line
+func (c *Cursor) SelectLine() {
+	c.Start()
+	c.SetSelectionStart(c.Loc)
+	c.End()
+	if len(c.buf.lines)-1 > c.Y {
+		c.SetSelectionEnd(c.Loc.Move(1, c.buf))
+	} else {
+		c.SetSelectionEnd(c.Loc)
+	}
+
+	c.OrigSelection = c.CurSelection
+}
+
+// AddLineToSelection adds the current line to the selection
+func (c *Cursor) AddLineToSelection() {
+	if c.Loc.LessThan(c.OrigSelection[0]) {
+		c.Start()
+		c.SetSelectionStart(c.Loc)
+		c.SetSelectionEnd(c.OrigSelection[1])
+	}
+	if c.Loc.GreaterThan(c.OrigSelection[1]) {
+		c.End()
+		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]) {
+		c.CurSelection = c.OrigSelection
+	}
+}
+
+// UpN moves the cursor up N lines (if possible)
+func (c *Cursor) UpN(amount int) {
+	proposedY := c.Y - amount
+	if proposedY < 0 {
+		proposedY = 0
+	} else if proposedY >= len(c.buf.lines) {
+		proposedY = len(c.buf.lines) - 1
+	}
+
+	bytes := c.buf.LineBytes(proposedY)
+	c.X = c.GetCharPosInLine(bytes, c.LastVisualX)
+
+	if c.X > utf8.RuneCount(bytes) || (amount < 0 && proposedY == c.Y) {
+		c.X = utf8.RuneCount(bytes)
+	}
+
+	c.Y = proposedY
+}
+
+// DownN moves the cursor down N lines (if possible)
+func (c *Cursor) DownN(amount int) {
+	c.UpN(-amount)
+}
+
+// Up moves the cursor up one line (if possible)
+func (c *Cursor) Up() {
+	c.UpN(1)
+}
+
+// Down moves the cursor down one line (if possible)
+func (c *Cursor) Down() {
+	c.DownN(1)
+}
+
+// Left moves the cursor left one cell (if possible) or to
+// the previous line if it is at the beginning
+func (c *Cursor) Left() {
+	if c.Loc == c.buf.Start() {
+		return
+	}
+	if c.X > 0 {
+		c.X--
+	} else {
+		c.Up()
+		c.End()
+	}
+	c.StoreVisualX()
+}
+
+// Right moves the cursor right one cell (if possible) or
+// to the next line if it is at the end
+func (c *Cursor) Right() {
+	if c.Loc == c.buf.End() {
+		return
+	}
+	if c.X < utf8.RuneCount(c.buf.LineBytes(c.Y)) {
+		c.X++
+	} else {
+		c.Down()
+		c.Start()
+	}
+	c.StoreVisualX()
+}
+
+// Relocate makes sure that the cursor is inside the bounds
+// of the buffer If it isn't, it moves it to be within the
+// buffer's lines
+func (c *Cursor) Relocate() {
+	if c.Y < 0 {
+		c.Y = 0
+	} else if c.Y >= len(c.buf.lines) {
+		c.Y = len(c.buf.lines) - 1
+	}
+
+	if c.X < 0 {
+		c.X = 0
+	} else if c.X > utf8.RuneCount(c.buf.LineBytes(c.Y)) {
+		c.X = utf8.RuneCount(c.buf.LineBytes(c.Y))
+	}
+}
+
+// SelectWord selects the word the cursor is currently on
+func (c *Cursor) SelectWord() {
+	if len(c.buf.LineBytes(c.Y)) == 0 {
+		return
+	}
+
+	if !util.IsWordChar(c.RuneUnder(c.X)) {
+		c.SetSelectionStart(c.Loc)
+		c.SetSelectionEnd(c.Loc.Move(1, c.buf))
+		c.OrigSelection = c.CurSelection
+		return
+	}
+
+	forward, backward := c.X, c.X
+
+	for backward > 0 && util.IsWordChar(c.RuneUnder(backward-1)) {
+		backward--
+	}
+
+	c.SetSelectionStart(Loc{backward, c.Y})
+	c.OrigSelection[0] = c.CurSelection[0]
+
+	lineLen := utf8.RuneCount(c.buf.LineBytes(c.Y)) - 1
+	for forward < lineLen && util.IsWordChar(c.RuneUnder(forward+1)) {
+		forward++
+	}
+
+	c.SetSelectionEnd(Loc{forward, c.Y}.Move(1, c.buf))
+	c.OrigSelection[1] = c.CurSelection[1]
+	c.Loc = c.CurSelection[1]
+}
+
+// AddWordToSelection adds the word the cursor is currently on
+// to the selection
+func (c *Cursor) AddWordToSelection() {
+	if c.Loc.GreaterThan(c.OrigSelection[0]) && c.Loc.LessThan(c.OrigSelection[1]) {
+		c.CurSelection = c.OrigSelection
+		return
+	}
+
+	if c.Loc.LessThan(c.OrigSelection[0]) {
+		backward := c.X
+
+		for backward > 0 && util.IsWordChar(c.RuneUnder(backward-1)) {
+			backward--
+		}
+
+		c.SetSelectionStart(Loc{backward, c.Y})
+		c.SetSelectionEnd(c.OrigSelection[1])
+	}
+
+	if c.Loc.GreaterThan(c.OrigSelection[1]) {
+		forward := c.X
+
+		lineLen := utf8.RuneCount(c.buf.LineBytes(c.Y)) - 1
+		for forward < lineLen && util.IsWordChar(c.RuneUnder(forward+1)) {
+			forward++
+		}
+
+		c.SetSelectionEnd(Loc{forward, c.Y}.Move(1, c.buf))
+		c.SetSelectionStart(c.OrigSelection[0])
+	}
+
+	c.Loc = c.CurSelection[1]
+}
+
+// SelectTo selects from the current cursor location to the given
+// location
+func (c *Cursor) SelectTo(loc Loc) {
+	if loc.GreaterThan(c.OrigSelection[0]) {
+		c.SetSelectionStart(c.OrigSelection[0])
+		c.SetSelectionEnd(loc)
+	} else {
+		c.SetSelectionStart(loc)
+		c.SetSelectionEnd(c.OrigSelection[0])
+	}
+}
+
+// WordRight moves the cursor one word to the right
+func (c *Cursor) WordRight() {
+	for util.IsWhitespace(c.RuneUnder(c.X)) {
+		if c.X == utf8.RuneCount(c.buf.LineBytes(c.Y)) {
+			c.Right()
+			return
+		}
+		c.Right()
+	}
+	c.Right()
+	for util.IsWordChar(c.RuneUnder(c.X)) {
+		if c.X == utf8.RuneCount(c.buf.LineBytes(c.Y)) {
+			return
+		}
+		c.Right()
+	}
+}
+
+// WordLeft moves the cursor one word to the left
+func (c *Cursor) WordLeft() {
+	c.Left()
+	for util.IsWhitespace(c.RuneUnder(c.X)) {
+		if c.X == 0 {
+			return
+		}
+		c.Left()
+	}
+	c.Left()
+	for util.IsWordChar(c.RuneUnder(c.X)) {
+		if c.X == 0 {
+			return
+		}
+		c.Left()
+	}
+	c.Right()
+}
+
+// RuneUnder returns the rune under the given x position
+func (c *Cursor) RuneUnder(x int) rune {
+	line := c.buf.LineBytes(c.Y)
+	if len(line) == 0 || x >= utf8.RuneCount(line) {
+		return '\n'
+	} else if x < 0 {
+		x = 0
+	}
+	i := 0
+	for len(line) > 0 {
+		r, size := utf8.DecodeRune(line)
+		line = line[size:]
+
+		if i == x {
+			return r
+		}
+
+		i++
+	}
+	return '\n'
+}
+
+func (c *Cursor) StoreVisualX() {
+	c.LastVisualX = c.GetVisualX()
+}

internal/buffer/eventhandler.go

@@ -0,0 +1,300 @@
+package buffer
+
+import (
+	"time"
+	"unicode/utf8"
+
+	dmp "github.com/sergi/go-diff/diffmatchpatch"
+)
+
+const (
+	// Opposite and undoing events must have opposite values
+
+	// TextEventInsert represents an insertion event
+	TextEventInsert = 1
+	// TextEventRemove represents a deletion event
+	TextEventRemove = -1
+	// TextEventReplace represents a replace event
+	TextEventReplace = 0
+
+	undoThreshold = 500 // If two events are less than n milliseconds apart, undo both of them
+)
+
+// TextEvent holds data for a manipulation on some text that can be undone
+type TextEvent struct {
+	C Cursor
+
+	EventType int
+	Deltas    []Delta
+	Time      time.Time
+}
+
+// A Delta is a change to the buffer
+type Delta struct {
+	Text  []byte
+	Start Loc
+	End   Loc
+}
+
+// ExecuteTextEvent runs a text event
+func ExecuteTextEvent(t *TextEvent, buf *SharedBuffer) {
+	if t.EventType == TextEventInsert {
+		for _, d := range t.Deltas {
+			buf.insert(d.Start, d.Text)
+		}
+	} else if t.EventType == TextEventRemove {
+		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, d.Text)
+			t.Deltas[i].Start = d.Start
+			t.Deltas[i].End = Loc{d.Start.X + utf8.RuneCount(d.Text), d.Start.Y}
+		}
+		for i, j := 0, len(t.Deltas)-1; i < j; i, j = i+1, j-1 {
+			t.Deltas[i], t.Deltas[j] = t.Deltas[j], t.Deltas[i]
+		}
+	}
+}
+
+// UndoTextEvent undoes a text event
+func UndoTextEvent(t *TextEvent, buf *SharedBuffer) {
+	t.EventType = -t.EventType
+	ExecuteTextEvent(t, buf)
+}
+
+// EventHandler executes text manipulations and allows undoing and redoing
+type EventHandler struct {
+	buf       *SharedBuffer
+	cursors   []*Cursor
+	active    int
+	UndoStack *TEStack
+	RedoStack *TEStack
+}
+
+// NewEventHandler returns a new EventHandler
+func NewEventHandler(buf *SharedBuffer, cursors []*Cursor) *EventHandler {
+	eh := new(EventHandler)
+	eh.UndoStack = new(TEStack)
+	eh.RedoStack = new(TEStack)
+	eh.buf = buf
+	eh.cursors = cursors
+	return eh
+}
+
+// ApplyDiff takes a string and runs the necessary insertion and deletion events to make
+// the buffer equal to that string
+// This means that we can transform the buffer into any string and still preserve undo/redo
+// through insert and delete events
+func (eh *EventHandler) ApplyDiff(new string) {
+	differ := dmp.New()
+	diff := differ.DiffMain(string(eh.buf.Bytes()), new, false)
+	loc := eh.buf.Start()
+	for _, d := range diff {
+		if d.Type == dmp.DiffDelete {
+			eh.Remove(loc, loc.MoveLA(utf8.RuneCountInString(d.Text), eh.buf.LineArray))
+		} else {
+			if d.Type == dmp.DiffInsert {
+				eh.Insert(loc, d.Text)
+			}
+			loc = loc.MoveLA(utf8.RuneCountInString(d.Text), eh.buf.LineArray)
+		}
+	}
+}
+
+// Insert creates an insert text event and executes it
+func (eh *EventHandler) Insert(start Loc, textStr string) {
+	text := []byte(textStr)
+	e := &TextEvent{
+		C:         *eh.cursors[eh.active],
+		EventType: TextEventInsert,
+		Deltas:    []Delta{{text, start, Loc{0, 0}}},
+		Time:      time.Now(),
+	}
+	eh.Execute(e)
+	e.Deltas[0].End = start.MoveLA(utf8.RuneCount(text), eh.buf.LineArray)
+	end := e.Deltas[0].End
+
+	for _, c := range eh.cursors {
+		move := func(loc Loc) Loc {
+			if start.Y != end.Y && loc.GreaterThan(start) {
+				loc.Y += end.Y - start.Y
+			} else if loc.Y == start.Y && loc.GreaterEqual(start) {
+				loc = loc.MoveLA(utf8.RuneCount(text), eh.buf.LineArray)
+			}
+			return loc
+		}
+		c.Loc = move(c.Loc)
+		c.CurSelection[0] = move(c.CurSelection[0])
+		c.CurSelection[1] = move(c.CurSelection[1])
+		c.OrigSelection[0] = move(c.OrigSelection[0])
+		c.OrigSelection[1] = move(c.OrigSelection[1])
+		c.LastVisualX = c.GetVisualX()
+	}
+}
+
+// Remove creates a remove text event and executes it
+func (eh *EventHandler) Remove(start, end Loc) {
+	e := &TextEvent{
+		C:         *eh.cursors[eh.active],
+		EventType: TextEventRemove,
+		Deltas:    []Delta{{[]byte{}, start, end}},
+		Time:      time.Now(),
+	}
+	eh.Execute(e)
+
+	for _, c := range eh.cursors {
+		move := func(loc Loc) Loc {
+			if start.Y != end.Y && loc.GreaterThan(end) {
+				loc.Y -= end.Y - start.Y
+			} else if loc.Y == end.Y && loc.GreaterEqual(end) {
+				loc = loc.MoveLA(-DiffLA(start, end, eh.buf.LineArray), eh.buf.LineArray)
+			}
+			return loc
+		}
+		c.Loc = move(c.Loc)
+		c.CurSelection[0] = move(c.CurSelection[0])
+		c.CurSelection[1] = move(c.CurSelection[1])
+		c.OrigSelection[0] = move(c.OrigSelection[0])
+		c.OrigSelection[1] = move(c.OrigSelection[1])
+		c.LastVisualX = c.GetVisualX()
+	}
+}
+
+// MultipleReplace creates an multiple insertions executes them
+func (eh *EventHandler) MultipleReplace(deltas []Delta) {
+	e := &TextEvent{
+		C:         *eh.cursors[eh.active],
+		EventType: TextEventReplace,
+		Deltas:    deltas,
+		Time:      time.Now(),
+	}
+	eh.Execute(e)
+}
+
+// Replace deletes from start to end and replaces it with the given string
+func (eh *EventHandler) Replace(start, end Loc, replace string) {
+	eh.Remove(start, end)
+	eh.Insert(start, replace)
+}
+
+// Execute a textevent and add it to the undo stack
+func (eh *EventHandler) Execute(t *TextEvent) {
+	if eh.RedoStack.Len() > 0 {
+		eh.RedoStack = new(TEStack)
+	}
+	eh.UndoStack.Push(t)
+
+	// TODO: Call plugins on text events
+	// for pl := range loadedPlugins {
+	// 	ret, err := Call(pl+".onBeforeTextEvent", t)
+	// 	if err != nil && !strings.HasPrefix(err.Error(), "function does not exist") {
+	// 		screen.TermMessage(err)
+	// 	}
+	// 	if val, ok := ret.(lua.LBool); ok && val == lua.LFalse {
+	// 		return
+	// 	}
+	// }
+
+	ExecuteTextEvent(t, eh.buf)
+}
+
+// Undo the first event in the undo stack
+func (eh *EventHandler) Undo() {
+	t := eh.UndoStack.Peek()
+	if t == nil {
+		return
+	}
+
+	startTime := t.Time.UnixNano() / int64(time.Millisecond)
+
+	eh.UndoOneEvent()
+
+	for {
+		t = eh.UndoStack.Peek()
+		if t == nil {
+			return
+		}
+
+		if startTime-(t.Time.UnixNano()/int64(time.Millisecond)) > undoThreshold {
+			return
+		}
+		startTime = t.Time.UnixNano() / int64(time.Millisecond)
+
+		eh.UndoOneEvent()
+	}
+}
+
+// UndoOneEvent undoes one event
+func (eh *EventHandler) UndoOneEvent() {
+	// This event should be undone
+	// Pop it off the stack
+	t := eh.UndoStack.Pop()
+	if t == nil {
+		return
+	}
+
+	// Undo it
+	// Modifies the text event
+	UndoTextEvent(t, eh.buf)
+
+	// Set the cursor in the right place
+	teCursor := t.C
+	if teCursor.Num >= 0 && teCursor.Num < len(eh.cursors) {
+		t.C = *eh.cursors[teCursor.Num]
+		eh.cursors[teCursor.Num].Goto(teCursor)
+	} else {
+		teCursor.Num = -1
+	}
+
+	// Push it to the redo stack
+	eh.RedoStack.Push(t)
+}
+
+// Redo the first event in the redo stack
+func (eh *EventHandler) Redo() {
+	t := eh.RedoStack.Peek()
+	if t == nil {
+		return
+	}
+
+	startTime := t.Time.UnixNano() / int64(time.Millisecond)
+
+	eh.RedoOneEvent()
+
+	for {
+		t = eh.RedoStack.Peek()
+		if t == nil {
+			return
+		}
+
+		if (t.Time.UnixNano()/int64(time.Millisecond))-startTime > undoThreshold {
+			return
+		}
+
+		eh.RedoOneEvent()
+	}
+}
+
+// RedoOneEvent redoes one event
+func (eh *EventHandler) RedoOneEvent() {
+	t := eh.RedoStack.Pop()
+	if t == nil {
+		return
+	}
+
+	// Modifies the text event
+	UndoTextEvent(t, eh.buf)
+
+	teCursor := t.C
+	if teCursor.Num >= 0 && teCursor.Num < len(eh.cursors) {
+		t.C = *eh.cursors[teCursor.Num]
+		eh.cursors[teCursor.Num].Goto(teCursor)
+	} else {
+		teCursor.Num = -1
+	}
+
+	eh.UndoStack.Push(t)
+}

internal/buffer/line_array.go

@@ -0,0 +1,312 @@
+package buffer
+
+import (
+	"bufio"
+	"io"
+	"unicode/utf8"
+
+	"github.com/zyedidia/micro/pkg/highlight"
+)
+
+// Finds the byte index of the nth rune in a byte slice
+func runeToByteIndex(n int, txt []byte) int {
+	if n == 0 {
+		return 0
+	}
+
+	count := 0
+	i := 0
+	for len(txt) > 0 {
+		_, size := utf8.DecodeRune(txt)
+
+		txt = txt[size:]
+		count += size
+		i++
+
+		if i == n {
+			break
+		}
+	}
+	return count
+}
+
+// A Line contains the data in bytes as well as a highlight state, match
+// and a flag for whether the highlighting needs to be updated
+type Line struct {
+	data []byte
+
+	state       highlight.State
+	match       highlight.LineMatch
+	rehighlight bool
+}
+
+const (
+	// Line ending file formats
+	FFAuto = 0 // Autodetect format
+	FFUnix = 1 // LF line endings (unix style '\n')
+	FFDos  = 2 // CRLF line endings (dos style '\r\n')
+)
+
+type FileFormat byte
+
+// A LineArray simply stores and array of lines and makes it easy to insert
+// and delete in it
+type LineArray struct {
+	lines    []Line
+	Endings  FileFormat
+	initsize uint64
+}
+
+// Append efficiently appends lines together
+// It allocates an additional 10000 lines if the original estimate
+// is incorrect
+func Append(slice []Line, data ...Line) []Line {
+	l := len(slice)
+	if l+len(data) > cap(slice) { // reallocate
+		newSlice := make([]Line, (l+len(data))+10000)
+		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(size uint64, endings FileFormat, reader io.Reader) *LineArray {
+	la := new(LineArray)
+
+	la.lines = make([]Line, 0, 1000)
+	la.initsize = size
+
+	br := bufio.NewReader(reader)
+	var loaded int
+
+	n := 0
+	for {
+		data, err := br.ReadBytes('\n')
+		// Detect the line ending by checking to see if there is a '\r' char
+		// before the '\n'
+		// Even if the file format is set to DOS, the '\r' is removed so
+		// that all lines end with '\n'
+		dlen := len(data)
+		if dlen > 1 && data[dlen-2] == '\r' {
+			data = append(data[:dlen-2], '\n')
+			if endings == FFAuto {
+				la.Endings = FFDos
+			}
+			dlen = len(data)
+		} else if dlen > 0 {
+			if endings == FFAuto {
+				la.Endings = FFUnix
+			}
+		}
+
+		// If we are loading a large file (greater than 1000) we use the file
+		// size and the length of the first 1000 lines to try to estimate
+		// how many lines will need to be allocated for the rest of the file
+		// We add an extra 10000 to the original estimate to be safe and give
+		// plenty of room for expansion
+		if n >= 1000 && loaded >= 0 {
+			totalLinesNum := int(float64(size) * (float64(n) / float64(loaded)))
+			newSlice := make([]Line, len(la.lines), totalLinesNum+10000)
+			copy(newSlice, la.lines)
+			la.lines = newSlice
+			loaded = -1
+		}
+
+		// Counter for the number of bytes in the first 1000 lines
+		if loaded >= 0 {
+			loaded += dlen
+		}
+
+		if err != nil {
+			if err == io.EOF {
+				la.lines = Append(la.lines, Line{data[:], nil, nil, false})
+			}
+			// Last line was read
+			break
+		} else {
+			la.lines = Append(la.lines, Line{data[:dlen-1], nil, nil, false})
+		}
+		n++
+	}
+
+	return la
+}
+
+// Bytes returns the string that should be written to disk when
+// the line array is saved
+func (la *LineArray) Bytes() []byte {
+	str := make([]byte, 0, la.initsize+1000) // initsize should provide a good estimate
+	for i, l := range la.lines {
+		str = append(str, l.data...)
+		if i != len(la.lines)-1 {
+			if la.Endings == FFDos {
+				str = append(str, '\r')
+			}
+			str = append(str, '\n')
+		}
+	}
+	return str
+}
+
+// newlineBelow adds a newline below the given line number
+func (la *LineArray) newlineBelow(y int) {
+	la.lines = append(la.lines, Line{[]byte{' '}, nil, nil, false})
+	copy(la.lines[y+2:], la.lines[y+1:])
+	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].data), pos.Y
+	for i := 0; i < len(value); i++ {
+		if value[i] == '\n' {
+			la.split(Loc{x, y})
+			x = 0
+			y++
+			continue
+		}
+		la.insertByte(Loc{x, y}, value[i])
+		x++
+	}
+}
+
+// InsertByte inserts a byte at a given location
+func (la *LineArray) insertByte(pos Loc, value byte) {
+	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].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].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) []byte {
+	sub := la.Substr(start, end)
+	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].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)
+		}
+		la.deleteToEnd(Loc{startX, start.Y})
+		la.deleteFromStart(Loc{endX - 1, start.Y + 1})
+		la.joinLines(start.Y, start.Y+1)
+	}
+	return sub
+}
+
+// deleteToEnd deletes from the end of a line to the position
+func (la *LineArray) deleteToEnd(pos Loc) {
+	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].data = la.lines[pos.Y].data[pos.X+1:]
+}
+
+// deleteLine deletes the line number
+func (la *LineArray) deleteLine(y int) {
+	la.lines = la.lines[:y+copy(la.lines[y:], la.lines[y+1:])]
+}
+
+// DeleteByte deletes the byte at a position
+func (la *LineArray) deleteByte(pos Loc) {
+	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) []byte {
+	startX := runeToByteIndex(start.X, la.lines[start.Y].data)
+	endX := runeToByteIndex(end.X, la.lines[end.Y].data)
+	if start.Y == end.Y {
+		src := la.lines[start.Y].data[startX:endX]
+		dest := make([]byte, len(src))
+		copy(dest, src)
+		return dest
+	}
+	str := make([]byte, 0, len(la.lines[start.Y+1].data)*(end.Y-start.Y))
+	str = append(str, la.lines[start.Y].data[startX:]...)
+	str = append(str, '\n')
+	for i := start.Y + 1; i <= end.Y-1; i++ {
+		str = append(str, la.lines[i].data...)
+		str = append(str, '\n')
+	}
+	str = append(str, la.lines[end.Y].data[:endX]...)
+	return str
+}
+
+// LinesNum returns the number of lines in the buffer
+func (la *LineArray) LinesNum() int {
+	return len(la.lines)
+}
+
+// Start returns the start of the buffer
+func (la *LineArray) Start() Loc {
+	return Loc{0, 0}
+}
+
+// End returns the location of the last character in the buffer
+func (la *LineArray) End() Loc {
+	numlines := len(la.lines)
+	return Loc{utf8.RuneCount(la.lines[numlines-1].data), numlines - 1}
+}
+
+// LineBytes returns line n as an array of bytes
+func (la *LineArray) LineBytes(n int) []byte {
+	if n >= len(la.lines) || n < 0 {
+		return []byte{}
+	}
+	return la.lines[n].data
+}
+
+// State gets the highlight state for the given line number
+func (la *LineArray) State(lineN int) highlight.State {
+	return la.lines[lineN].state
+}
+
+// SetState sets the highlight state at the given line number
+func (la *LineArray) SetState(lineN int, s highlight.State) {
+	la.lines[lineN].state = s
+}
+
+// SetMatch sets the match at the given line number
+func (la *LineArray) SetMatch(lineN int, m highlight.LineMatch) {
+	la.lines[lineN].match = m
+}
+
+// Match retrieves the match for the given line number
+func (la *LineArray) Match(lineN int) highlight.LineMatch {
+	return la.lines[lineN].match
+}
+
+func (la *LineArray) Rehighlight(lineN int) bool {
+	return la.lines[lineN].rehighlight
+}
+
+func (la *LineArray) SetRehighlight(lineN int, on bool) {
+	la.lines[lineN].rehighlight = on
+}

internal/buffer/line_array_test.go

@@ -0,0 +1,60 @@
+package buffer
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+var unicode_txt = `An preost wes on leoden, Laȝamon was ihoten
+He wes Leovenaðes sone -- liðe him be Drihten.
+He wonede at Ernleȝe at æðelen are chirechen,
+Uppen Sevarne staþe, sel þar him þuhte,
+Onfest Radestone, þer he bock radde.`
+
+var la *LineArray
+
+func init() {
+	reader := strings.NewReader(unicode_txt)
+	la = NewLineArray(uint64(len(unicode_txt)), FFAuto, reader)
+}
+
+func TestSplit(t *testing.T) {
+	la.insert(Loc{17, 1}, []byte{'\n'})
+	assert.Equal(t, len(la.lines), 6)
+	sub1 := la.Substr(Loc{0, 1}, Loc{17, 1})
+	sub2 := la.Substr(Loc{0, 2}, Loc{30, 2})
+
+	assert.Equal(t, []byte("He wes Leovenaðes"), sub1)
+	assert.Equal(t, []byte(" sone -- liðe him be Drihten."), sub2)
+}
+
+func TestJoin(t *testing.T) {
+	la.remove(Loc{47, 1}, Loc{0, 2})
+	assert.Equal(t, len(la.lines), 5)
+	sub := la.Substr(Loc{0, 1}, Loc{47, 1})
+	bytes := la.Bytes()
+
+	assert.Equal(t, []byte("He wes Leovenaðes sone -- liðe him be Drihten."), sub)
+	assert.Equal(t, unicode_txt, string(bytes))
+}
+
+func TestInsert(t *testing.T) {
+	la.insert(Loc{20, 3}, []byte(" foobar"))
+	sub1 := la.Substr(Loc{0, 3}, Loc{50, 3})
+
+	assert.Equal(t, []byte("Uppen Sevarne staþe, foobar sel þar him þuhte,"), sub1)
+
+	la.insert(Loc{25, 2}, []byte("ಮಣ್ಣಾಗಿ"))
+	sub2 := la.Substr(Loc{0, 2}, Loc{60, 2})
+	assert.Equal(t, []byte("He wonede at Ernleȝe at æಮಣ್ಣಾಗಿðelen are chirechen,"), sub2)
+}
+
+func TestRemove(t *testing.T) {
+	la.remove(Loc{20, 3}, Loc{27, 3})
+	la.remove(Loc{25, 2}, Loc{32, 2})
+
+	bytes := la.Bytes()
+	assert.Equal(t, unicode_txt, string(bytes))
+}

internal/buffer/loc.go

@@ -1,32 +1,10 @@
-package main
+package buffer
 
-// FromCharPos converts from a character position to an x, y position
-func FromCharPos(loc int, buf *Buffer) Loc {
-	charNum := 0
-	x, y := 0, 0
+import (
+	"unicode/utf8"
 
-	lineLen := Count(buf.Line(y)) + 1
-	for charNum+lineLen <= loc {
-		charNum += lineLen
-		y++
-		lineLen = Count(buf.Line(y)) + 1
-	}
-	x = loc - charNum
-
-	return Loc{x, y}
-}
-
-// ToCharPos converts from an x, y position to a character position
-func ToCharPos(start Loc, buf *Buffer) int {
-	x, y := start.X, start.Y
-	loc := 0
-	for i := 0; i < y; i++ {
-		// + 1 for the newline
-		loc += Count(buf.Line(i)) + 1
-	}
-	loc += x
-	return loc
-}
+	"github.com/zyedidia/micro/internal/util"
+)
 
 // Loc stores a location
 type Loc struct {
@@ -38,10 +16,7 @@ func (l Loc) LessThan(b Loc) bool {
 	if l.Y < b.Y {
 		return true
 	}
-	if l.Y == b.Y && l.X < b.X {
-		return true
-	}
-	return false
+	return l.Y == b.Y && l.X < b.X
 }
 
 // GreaterThan returns true if b is bigger
@@ -49,10 +24,7 @@ func (l Loc) GreaterThan(b Loc) bool {
 	if l.Y > b.Y {
 		return true
 	}
-	if l.Y == b.Y && l.X > b.X {
-		return true
-	}
-	return false
+	return l.Y == b.Y && l.X > b.X
 }
 
 // GreaterEqual returns true if b is greater than or equal to b
@@ -63,10 +35,7 @@ func (l Loc) GreaterEqual(b Loc) bool {
 	if l.Y == b.Y && l.X > b.X {
 		return true
 	}
-	if l == b {
-		return true
-	}
-	return false
+	return l == b
 }
 
 // LessEqual returns true if b is less than or equal to b
@@ -77,19 +46,41 @@ func (l Loc) LessEqual(b Loc) bool {
 	if l.Y == b.Y && l.X < b.X {
 		return true
 	}
-	if l == b {
-		return true
+	return l == b
+}
+
+// The following functions require a buffer to know where newlines are
+
+// Diff returns the distance between two locations
+func DiffLA(a, b Loc, buf *LineArray) int {
+	if a.Y == b.Y {
+		if a.X > b.X {
+			return a.X - b.X
+		}
+		return b.X - a.X
 	}
-	return false
+
+	// Make sure a is guaranteed to be less than b
+	if b.LessThan(a) {
+		a, b = b, a
+	}
+
+	loc := 0
+	for i := a.Y + 1; i < b.Y; i++ {
+		// + 1 for the newline
+		loc += utf8.RuneCount(buf.LineBytes(i)) + 1
+	}
+	loc += utf8.RuneCount(buf.LineBytes(a.Y)) - a.X + b.X + 1
+	return loc
 }
 
 // This moves the location one character to the right
-func (l Loc) right(buf *Buffer) Loc {
+func (l Loc) right(buf *LineArray) Loc {
 	if l == buf.End() {
 		return Loc{l.X + 1, l.Y}
 	}
 	var res Loc
-	if l.X < Count(buf.Line(l.Y)) {
+	if l.X < utf8.RuneCount(buf.LineBytes(l.Y)) {
 		res = Loc{l.X + 1, l.Y}
 	} else {
 		res = Loc{0, l.Y + 1}
@@ -98,7 +89,7 @@ func (l Loc) right(buf *Buffer) Loc {
 }
 
 // This moves the given location one character to the left
-func (l Loc) left(buf *Buffer) Loc {
+func (l Loc) left(buf *LineArray) Loc {
 	if l == buf.Start() {
 		return Loc{l.X - 1, l.Y}
 	}
@@ -106,22 +97,41 @@ func (l Loc) left(buf *Buffer) Loc {
 	if l.X > 0 {
 		res = Loc{l.X - 1, l.Y}
 	} else {
-		res = Loc{Count(buf.Line(l.Y - 1)), l.Y - 1}
+		res = Loc{utf8.RuneCount(buf.LineBytes(l.Y - 1)), l.Y - 1}
 	}
 	return res
 }
 
 // Move moves the cursor n characters to the left or right
 // It moves the cursor left if n is negative
-func (l Loc) Move(n int, buf *Buffer) Loc {
+func (l Loc) MoveLA(n int, buf *LineArray) Loc {
 	if n > 0 {
 		for i := 0; i < n; i++ {
 			l = l.right(buf)
 		}
 		return l
 	}
-	for i := 0; i < Abs(n); i++ {
+	for i := 0; i < util.Abs(n); i++ {
 		l = l.left(buf)
 	}
 	return l
 }
+
+func (l Loc) Diff(a, b Loc, buf *Buffer) int {
+	return DiffLA(a, b, buf.LineArray)
+}
+func (l Loc) Move(n int, buf *Buffer) Loc {
+	return l.MoveLA(n, buf.LineArray)
+}
+
+// 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
+}

internal/buffer/message.go

@@ -0,0 +1,77 @@
+package buffer
+
+import (
+	"github.com/zyedidia/micro/internal/config"
+	"github.com/zyedidia/tcell"
+)
+
+type MsgType int
+
+const (
+	MTInfo = iota
+	MTWarning
+	MTError
+)
+
+type Message struct {
+	Msg        string
+	Start, End Loc
+	Kind       MsgType
+	Owner      string
+}
+
+func NewMessage(owner string, msg string, start, end Loc, kind MsgType) *Message {
+	return &Message{
+		Msg:   msg,
+		Start: start,
+		End:   end,
+		Kind:  kind,
+		Owner: owner,
+	}
+}
+
+func NewMessageAtLine(owner string, msg string, line int, kind MsgType) *Message {
+	start := Loc{-1, line - 1}
+	end := start
+	return NewMessage(owner, msg, start, end, kind)
+}
+
+func (m *Message) Style() tcell.Style {
+	switch m.Kind {
+	case MTInfo:
+		if style, ok := config.Colorscheme["gutter-info"]; ok {
+			return style
+		}
+	case MTWarning:
+		if style, ok := config.Colorscheme["gutter-warning"]; ok {
+			return style
+		}
+	case MTError:
+		if style, ok := config.Colorscheme["gutter-error"]; ok {
+			return style
+		}
+	}
+	return config.DefStyle
+}
+
+func (b *Buffer) AddMessage(m *Message) {
+	b.Messages = append(b.Messages, m)
+}
+
+func (b *Buffer) removeMsg(i int) {
+	copy(b.Messages[i:], b.Messages[i+1:])
+	b.Messages[len(b.Messages)-1] = nil
+	b.Messages = b.Messages[:len(b.Messages)-1]
+}
+
+func (b *Buffer) ClearMessages(owner string) {
+	for i := len(b.Messages) - 1; i >= 0; i-- {
+		if b.Messages[i].Owner == owner {
+			b.removeMsg(i)
+		}
+	}
+}
+
+func (b *Buffer) ClearAllMessages() {
+	b.Messages = make([]*Message, 0)
+}

internal/buffer/save.go

@@ -0,0 +1,228 @@
+package buffer
+
+import (
+	"bytes"
+	"errors"
+	"io"
+	"os"
+	"os/exec"
+	"os/signal"
+	"path/filepath"
+	"unicode"
+	"unicode/utf8"
+
+	"github.com/zyedidia/micro/internal/config"
+	"github.com/zyedidia/micro/internal/screen"
+	. "github.com/zyedidia/micro/internal/util"
+	"golang.org/x/text/encoding"
+	"golang.org/x/text/encoding/htmlindex"
+	"golang.org/x/text/transform"
+)
+
+// LargeFileThreshold is the number of bytes when fastdirty is forced
+// because hashing is too slow
+const LargeFileThreshold = 50000
+
+// overwriteFile opens the given file for writing, truncating if one exists, and then calls
+// the supplied function with the file as io.Writer object, also making sure the file is
+// closed afterwards.
+func overwriteFile(name string, enc encoding.Encoding, fn func(io.Writer) error) (err error) {
+	var file *os.File
+
+	if file, err = os.OpenFile(name, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644); err != nil {
+		return
+	}
+
+	defer func() {
+		if e := file.Close(); e != nil && err == nil {
+			err = e
+		}
+	}()
+
+	w := transform.NewWriter(file, enc.NewEncoder())
+	// w := bufio.NewWriter(file)
+
+	if err = fn(w); err != nil {
+		return
+	}
+
+	// err = w.Flush()
+	return
+}
+
+// overwriteFileAsRoot executes dd as root and then calls the supplied function
+// with dd's standard input as an io.Writer object. Dd opens the given file for writing,
+// truncating it if it exists, and writes what it receives on its standard input to the file.
+func overwriteFileAsRoot(name string, enc encoding.Encoding, fn func(io.Writer) error) (err error) {
+	cmd := exec.Command(config.GlobalSettings["sucmd"].(string), "dd", "status=none", "bs=4K", "of="+name)
+	var stdin io.WriteCloser
+
+	screenb := screen.TempFini()
+
+	// This is a trap for Ctrl-C so that it doesn't kill micro
+	// Instead we trap Ctrl-C to kill the program we're running
+	c := make(chan os.Signal, 1)
+	signal.Notify(c, os.Interrupt)
+	go func() {
+		for range c {
+			cmd.Process.Kill()
+		}
+	}()
+
+	if stdin, err = cmd.StdinPipe(); err != nil {
+		return
+	}
+
+	if err = cmd.Start(); err != nil {
+		return
+	}
+
+	e := fn(stdin)
+
+	if err = stdin.Close(); err != nil {
+		return
+	}
+
+	if err = cmd.Wait(); err != nil {
+		return
+	}
+
+	screen.TempStart(screenb)
+
+	return e
+}
+
+// Save saves the buffer to its default path
+func (b *Buffer) Save() error {
+	return b.SaveAs(b.Path)
+}
+
+// SaveAs saves the buffer to a specified path (filename), creating the file if it does not exist
+func (b *Buffer) SaveAs(filename string) error {
+	return b.saveToFile(filename, false)
+}
+
+func (b *Buffer) SaveWithSudo() error {
+	return b.SaveAsWithSudo(b.Path)
+}
+
+func (b *Buffer) SaveAsWithSudo(filename string) error {
+	return b.saveToFile(filename, true)
+}
+
+func (b *Buffer) saveToFile(filename string, withSudo bool) error {
+	var err error
+	if b.Type.Readonly {
+		return errors.New("Cannot save readonly buffer")
+	}
+	if b.Type.Scratch {
+		return errors.New("Cannot save scratch buffer")
+	}
+
+	b.UpdateRules()
+	if b.Settings["rmtrailingws"].(bool) {
+		for i, l := range b.lines {
+			leftover := utf8.RuneCount(bytes.TrimRightFunc(l.data, unicode.IsSpace))
+
+			linelen := utf8.RuneCount(l.data)
+			b.Remove(Loc{leftover, i}, Loc{linelen, i})
+		}
+
+		b.RelocateCursors()
+	}
+
+	if b.Settings["eofnewline"].(bool) {
+		end := b.End()
+		if b.RuneAt(Loc{end.X - 1, end.Y}) != '\n' {
+			b.Insert(end, "\n")
+		}
+	}
+
+	// Update the last time this file was updated after saving
+	defer func() {
+		b.ModTime, _ = GetModTime(filename)
+		err = b.Serialize()
+	}()
+
+	// Removes any tilde and replaces with the absolute path to home
+	absFilename, _ := ReplaceHome(filename)
+
+	// Get the leading path to the file | "." is returned if there's no leading path provided
+	if dirname := filepath.Dir(absFilename); dirname != "." {
+		// Check if the parent dirs don't exist
+		if _, statErr := os.Stat(dirname); os.IsNotExist(statErr) {
+			// Prompt to make sure they want to create the dirs that are missing
+			if b.Settings["mkparents"].(bool) {
+				// Create all leading dir(s) since they don't exist
+				if mkdirallErr := os.MkdirAll(dirname, os.ModePerm); mkdirallErr != nil {
+					// If there was an error creating the dirs
+					return mkdirallErr
+				}
+			} else {
+				return errors.New("Parent dirs don't exist, enable 'mkparents' for auto creation")
+			}
+		}
+	}
+
+	var fileSize int
+
+	enc, err := htmlindex.Get(b.Settings["encoding"].(string))
+	if err != nil {
+		return err
+	}
+
+	fwriter := func(file io.Writer) (e error) {
+		if len(b.lines) == 0 {
+			return
+		}
+
+		// end of line
+		var eol []byte
+		if b.Endings == FFDos {
+			eol = []byte{'\r', '\n'}
+		} else {
+			eol = []byte{'\n'}
+		}
+
+		// write lines
+		if fileSize, e = file.Write(b.lines[0].data); e != nil {
+			return
+		}
+
+		for _, l := range b.lines[1:] {
+			if _, e = file.Write(eol); e != nil {
+				return
+			}
+			if _, e = file.Write(l.data); e != nil {
+				return
+			}
+			fileSize += len(eol) + len(l.data)
+		}
+		return
+	}
+
+	if withSudo {
+		err = overwriteFileAsRoot(absFilename, enc, fwriter)
+	} else {
+		err = overwriteFile(absFilename, enc, fwriter)
+	}
+
+	if err != nil {
+		return err
+	}
+
+	if !b.Settings["fastdirty"].(bool) {
+		if fileSize > LargeFileThreshold {
+			// For large files 'fastdirty' needs to be on
+			b.Settings["fastdirty"] = true
+		} else {
+			calcHash(b, &b.origHash)
+		}
+	}
+
+	b.Path = filename
+	absPath, _ := filepath.Abs(filename)
+	b.AbsPath = absPath
+	b.isModified = false
+	return err
+}

internal/buffer/search.go

@@ -0,0 +1,170 @@
+package buffer
+
+import (
+	"regexp"
+	"unicode/utf8"
+
+	"github.com/zyedidia/micro/internal/util"
+)
+
+func (b *Buffer) findDown(r *regexp.Regexp, start, end Loc) ([2]Loc, bool) {
+	start.Y = util.Clamp(start.Y, 0, b.LinesNum()-1)
+	end.Y = util.Clamp(end.Y, 0, b.LinesNum()-1)
+
+	if start.GreaterThan(end) {
+		start, end = end, start
+	}
+
+	for i := start.Y; i <= end.Y; i++ {
+		l := b.LineBytes(i)
+		charpos := 0
+
+		if i == start.Y && start.Y == end.Y {
+			nchars := utf8.RuneCount(l)
+			start.X = util.Clamp(start.X, 0, nchars)
+			end.X = util.Clamp(end.X, 0, nchars)
+			l = util.SliceStart(l, end.X)
+			l = util.SliceEnd(l, start.X)
+			charpos = start.X
+		} else if i == start.Y {
+			nchars := utf8.RuneCount(l)
+			start.X = util.Clamp(start.X, 0, nchars)
+			l = util.SliceEnd(l, start.X)
+			charpos = start.X
+		} else if i == end.Y {
+			nchars := utf8.RuneCount(l)
+			end.X = util.Clamp(end.X, 0, nchars)
+			l = util.SliceStart(l, end.X)
+		}
+
+		match := r.FindIndex(l)
+
+		if match != nil {
+			start := Loc{charpos + util.RunePos(l, match[0]), i}
+			end := Loc{charpos + util.RunePos(l, match[1]), i}
+			return [2]Loc{start, end}, true
+		}
+	}
+	return [2]Loc{}, false
+}
+
+func (b *Buffer) findUp(r *regexp.Regexp, start, end Loc) ([2]Loc, bool) {
+	start.Y = util.Clamp(start.Y, 0, b.LinesNum()-1)
+	end.Y = util.Clamp(end.Y, 0, b.LinesNum()-1)
+
+	if start.GreaterThan(end) {
+		start, end = end, start
+	}
+
+	for i := end.Y; i >= start.Y; i-- {
+		l := b.LineBytes(i)
+		charpos := 0
+
+		if i == start.Y && start.Y == end.Y {
+			nchars := utf8.RuneCount(l)
+			start.X = util.Clamp(start.X, 0, nchars)
+			end.X = util.Clamp(end.X, 0, nchars)
+			l = util.SliceStart(l, end.X)
+			l = util.SliceEnd(l, start.X)
+			charpos = start.X
+		} else if i == start.Y {
+			nchars := utf8.RuneCount(l)
+			start.X = util.Clamp(start.X, 0, nchars)
+			l = util.SliceEnd(l, start.X)
+			charpos = start.X
+		} else if i == end.Y {
+			nchars := utf8.RuneCount(l)
+			end.X = util.Clamp(end.X, 0, nchars)
+			l = util.SliceStart(l, end.X)
+		}
+
+		match := r.FindIndex(l)
+
+		if match != nil {
+			start := Loc{charpos + util.RunePos(l, match[0]), i}
+			end := Loc{charpos + util.RunePos(l, match[1]), i}
+			return [2]Loc{start, end}, true
+		}
+	}
+	return [2]Loc{}, false
+}
+
+// FindNext finds the next occurrence of a given string in the buffer
+// It returns the start and end location of the match (if found) and
+// a boolean indicating if it was found
+// May also return an error if the search regex is invalid
+func (b *Buffer) FindNext(s string, start, end, from Loc, down bool, useRegex bool) ([2]Loc, bool, error) {
+	if s == "" {
+		return [2]Loc{}, false, nil
+	}
+
+	var r *regexp.Regexp
+	var err error
+
+	if !useRegex {
+		s = regexp.QuoteMeta(s)
+	}
+
+	if b.Settings["ignorecase"].(bool) {
+		r, err = regexp.Compile("(?i)" + s)
+	} else {
+		r, err = regexp.Compile(s)
+	}
+
+	if err != nil {
+		return [2]Loc{}, false, err
+	}
+
+	found := false
+	var l [2]Loc
+	if down {
+		l, found = b.findDown(r, from, end)
+		if !found {
+			l, found = b.findDown(r, start, from)
+		}
+	} else {
+		l, found = b.findUp(r, from, start)
+		if !found {
+			l, found = b.findUp(r, end, from)
+		}
+	}
+	return l, found, nil
+}
+
+// ReplaceRegex replaces all occurrences of 'search' with 'replace' in the given area
+// and returns the number of replacements made
+func (b *Buffer) ReplaceRegex(start, end Loc, search *regexp.Regexp, replace []byte) int {
+	if start.GreaterThan(end) {
+		start, end = end, start
+	}
+
+	found := 0
+	var deltas []Delta
+	for i := start.Y; i <= end.Y; i++ {
+		l := b.lines[i].data
+		charpos := 0
+
+		if start.Y == end.Y && i == start.Y {
+			l = util.SliceStart(l, end.X)
+			l = util.SliceEnd(l, start.X)
+			charpos = start.X
+		} else if i == start.Y {
+			l = util.SliceEnd(l, start.X)
+			charpos = start.X
+		} else if i == end.Y {
+			l = util.SliceStart(l, end.X)
+		}
+		newText := search.ReplaceAllFunc(l, func(in []byte) []byte {
+			found++
+			return replace
+		})
+
+		from := Loc{charpos, i}
+		to := Loc{charpos + utf8.RuneCount(l), i}
+
+		deltas = append(deltas, Delta{newText, from, to})
+	}
+	b.MultipleReplace(deltas)
+
+	return found
+}

internal/buffer/serialize.go

@@ -0,0 +1,74 @@
+package buffer
+
+import (
+	"encoding/gob"
+	"errors"
+	"io"
+	"os"
+	"time"
+
+	"golang.org/x/text/encoding"
+
+	"github.com/zyedidia/micro/internal/config"
+	. "github.com/zyedidia/micro/internal/util"
+)
+
+// The SerializedBuffer holds the types that get serialized when a buffer is saved
+// These are used for the savecursor and saveundo options
+type SerializedBuffer struct {
+	EventHandler *EventHandler
+	Cursor       Loc
+	ModTime      time.Time
+}
+
+// Serialize serializes the buffer to config.ConfigDir/buffers
+func (b *Buffer) Serialize() error {
+	if !b.Settings["savecursor"].(bool) && !b.Settings["saveundo"].(bool) {
+		return nil
+	}
+	if b.Path == "" {
+		return nil
+	}
+
+	name := config.ConfigDir + "/buffers/" + EscapePath(b.AbsPath)
+
+	return overwriteFile(name, encoding.Nop, func(file io.Writer) error {
+		err := gob.NewEncoder(file).Encode(SerializedBuffer{
+			b.EventHandler,
+			b.GetActiveCursor().Loc,
+			b.ModTime,
+		})
+		return err
+	})
+}
+
+func (b *Buffer) Unserialize() error {
+	// If either savecursor or saveundo is turned on, we need to load the serialized information
+	// from ~/.config/micro/buffers
+	if b.Path == "" {
+		return nil
+	}
+	file, err := os.Open(config.ConfigDir + "/buffers/" + EscapePath(b.AbsPath))
+	defer file.Close()
+	if err == nil {
+		var buffer SerializedBuffer
+		decoder := gob.NewDecoder(file)
+		err = decoder.Decode(&buffer)
+		if err != nil {
+			return errors.New(err.Error() + "\nYou may want to remove the files in ~/.config/micro/buffers (these files store the information for the 'saveundo' and 'savecursor' options) if this problem persists.")
+		}
+		if b.Settings["savecursor"].(bool) {
+			b.StartCursor = buffer.Cursor
+		}
+
+		if b.Settings["saveundo"].(bool) {
+			// We should only use last time's eventhandler if the file wasn't modified by someone else in the meantime
+			if b.ModTime == buffer.ModTime {
+				b.EventHandler = buffer.EventHandler
+				b.EventHandler.cursors = b.cursors
+				b.EventHandler.buf = b.SharedBuffer
+			}
+		}
+	}
+	return nil
+}

internal/buffer/settings.go

@@ -0,0 +1,57 @@
+package buffer
+
+import (
+	"github.com/zyedidia/micro/internal/config"
+	"github.com/zyedidia/micro/internal/screen"
+)
+
+func (b *Buffer) SetOptionNative(option string, nativeValue interface{}) error {
+	b.Settings[option] = nativeValue
+
+	if option == "fastdirty" {
+		if !nativeValue.(bool) {
+			e := calcHash(b, &b.origHash)
+			if e == ErrFileTooLarge {
+				b.Settings["fastdirty"] = false
+			}
+		}
+	} else if option == "statusline" {
+		screen.Redraw()
+	} else if option == "filetype" {
+		b.UpdateRules()
+	} else if option == "fileformat" {
+		switch b.Settings["fileformat"].(string) {
+		case "unix":
+			b.Endings = FFUnix
+		case "dos":
+			b.Endings = FFDos
+		}
+		b.isModified = true
+	} else if option == "syntax" {
+		if !nativeValue.(bool) {
+			b.ClearMatches()
+		} else {
+			b.UpdateRules()
+		}
+	} else if option == "encoding" {
+		b.isModified = true
+	} else if option == "readonly" {
+		b.Type.Readonly = nativeValue.(bool)
+	}
+
+	return nil
+}
+
+// SetOption sets a given option to a value just for this buffer
+func (b *Buffer) SetOption(option, value string) error {
+	if _, ok := b.Settings[option]; !ok {
+		return config.ErrInvalidOption
+	}
+
+	nativeValue, err := config.GetNativeValue(option, b.Settings[option], value)
+	if err != nil {
+		return err
+	}
+
+	return b.SetOptionNative(option, nativeValue)
+}

internal/buffer/stack.go

@@ -1,7 +1,7 @@
-package main
+package buffer
 
-// Stack is a simple implementation of a LIFO stack for text events
-type Stack struct {
+// TEStack is a simple implementation of a LIFO stack for text events
+type TEStack struct {
 	Top  *Element
 	Size int
 }
@@ -13,19 +13,19 @@ type Element struct {
 }
 
 // Len returns the stack's length
-func (s *Stack) Len() int {
+func (s *TEStack) Len() int {
 	return s.Size
 }
 
 // Push a new element onto the stack
-func (s *Stack) Push(value *TextEvent) {
+func (s *TEStack) Push(value *TextEvent) {
 	s.Top = &Element{value, s.Top}
 	s.Size++
 }
 
 // Pop removes the top element from the stack and returns its value
 // If the stack is empty, return nil
-func (s *Stack) Pop() (value *TextEvent) {
+func (s *TEStack) Pop() (value *TextEvent) {
 	if s.Size > 0 {
 		value, s.Top = s.Top.Value, s.Top.Next
 		s.Size--
@@ -35,7 +35,7 @@ func (s *Stack) Pop() (value *TextEvent) {
 }
 
 // Peek returns the top element of the stack without removing it
-func (s *Stack) Peek() *TextEvent {
+func (s *TEStack) Peek() *TextEvent {
 	if s.Size > 0 {
 		return s.Top.Value
 	}

internal/buffer/stack_test.go

@@ -0,0 +1,35 @@
+package buffer
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestStack(t *testing.T) {
+	s := new(TEStack)
+	e1 := &TextEvent{
+		EventType: TextEventReplace,
+		Time:      time.Now(),
+	}
+	e2 := &TextEvent{
+		EventType: TextEventInsert,
+		Time:      time.Now(),
+	}
+	s.Push(e1)
+	s.Push(e2)
+
+	p := s.Peek()
+	assert.Equal(t, p.EventType, TextEventInsert)
+	p = s.Pop()
+	assert.Equal(t, p.EventType, TextEventInsert)
+	p = s.Peek()
+	assert.Equal(t, p.EventType, TextEventReplace)
+	p = s.Pop()
+	assert.Equal(t, p.EventType, TextEventReplace)
+	p = s.Pop()
+	assert.Nil(t, p)
+	p = s.Peek()
+	assert.Nil(t, p)
+}

internal/config/autosave.go

@@ -0,0 +1,45 @@
+package config
+
+import (
+	"sync"
+	"time"
+)
+
+var Autosave chan bool
+var autotime int
+
+// lock for autosave
+var autolock sync.Mutex
+
+func init() {
+	Autosave = make(chan bool)
+}
+
+func SetAutoTime(a int) {
+	autolock.Lock()
+	autotime = a
+	autolock.Unlock()
+}
+
+func GetAutoTime() int {
+	autolock.Lock()
+	a := autotime
+	autolock.Unlock()
+	return a
+}
+
+func StartAutoSave() {
+	go func() {
+		for {
+			if autotime < 1 {
+				break
+			}
+			time.Sleep(time.Duration(autotime) * time.Second)
+			// it's possible autotime was changed while sleeping
+			if autotime < 1 {
+				break
+			}
+			Autosave <- true
+		}
+	}()
+}

internal/config/colorscheme.go

@@ -1,8 +1,7 @@
-package main
+package config
 
 import (
-	"fmt"
-	"io/ioutil"
+	"errors"
 	"regexp"
 	"strconv"
 	"strings"
@@ -10,60 +9,85 @@ import (
 	"github.com/zyedidia/tcell"
 )
 
-// Colorscheme is a map from string to style -- it represents a colorscheme
-type Colorscheme map[string]tcell.Style
+// Micro's default style
+var DefStyle tcell.Style = tcell.StyleDefault
 
 // The current colorscheme
-var colorscheme Colorscheme
+var Colorscheme map[string]tcell.Style
 
-var preInstalledColors = []string{"default", "simple", "solarized", "solarized-tc", "atom-dark-tc", "monokai", "gruvbox", "zenburn"}
+// GetColor 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)
+	}
 
-// InitColorscheme picks and initializes the colorscheme when micro starts
-func InitColorscheme() {
-	LoadDefaultColorscheme()
+	return st
 }
 
-// LoadDefaultColorscheme loads the default colorscheme from $(configDir)/colorschemes
-func LoadDefaultColorscheme() {
-	LoadColorscheme(globalSettings["colorscheme"].(string), configDir+"/colorschemes")
+// 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() error {
+	Colorscheme = make(map[string]tcell.Style)
+	DefStyle = tcell.StyleDefault
+
+	return LoadDefaultColorscheme()
+}
+
+// LoadDefaultColorscheme loads the default colorscheme from $(ConfigDir)/colorschemes
+func LoadDefaultColorscheme() error {
+	return 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
-			}
-			colorscheme = ParseColorscheme(string(data))
+func LoadColorscheme(colorschemeName string) error {
+	file := FindRuntimeFile(RTColorscheme, colorschemeName)
+	if file == nil {
+		return errors.New(colorschemeName + " is not a valid colorscheme")
+	}
+	if data, err := file.Data(); err != nil {
+		return errors.New("Error loading colorscheme: " + err.Error())
+	} else {
+		Colorscheme, err = ParseColorscheme(string(data))
+		if err != nil {
+			return err
 		}
 	}
+	return nil
 }
 
 // ParseColorscheme parses the text definition for a colorscheme and returns the corresponding object
 // Colorschemes are made up of color-link statements linking a color group to a list of colors
 // For example, color-link keyword (blue,red) makes all keywords have a blue foreground and
 // red background
-func ParseColorscheme(text string) Colorscheme {
+func ParseColorscheme(text string) (map[string]tcell.Style, error) {
+	var err error
 	parser := regexp.MustCompile(`color-link\s+(\S*)\s+"(.*)"`)
 
 	lines := strings.Split(text, "\n")
 
-	c := make(Colorscheme)
+	c := make(map[string]tcell.Style)
 
 	for _, line := range lines {
 		if strings.TrimSpace(line) == "" ||
@@ -77,22 +101,32 @@ 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
+			}
 		} else {
-			fmt.Println("Color-link statement is not valid:", line)
+			err = errors.New("Color-link statement is not valid: " + line)
 		}
 	}
 
-	return c
+	return c, err
 }
 
 // StringToStyle returns a style from a string
 // 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 {
@@ -101,7 +135,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)
 	}
@@ -202,5 +248,9 @@ func GetColor256(color int) tcell.Color {
 		tcell.Color253, tcell.Color254, tcell.Color255,
 	}
 
-	return colors[color]
+	if color >= 0 && color < len(colors) {
+		return colors[color]
+	}
+
+	return tcell.ColorDefault
 }

internal/config/colorscheme_test.go

@@ -0,0 +1,62 @@
+package config
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/zyedidia/tcell"
+)
+
+func TestSimpleStringToStyle(t *testing.T) {
+	s := StringToStyle("lightblue,magenta")
+
+	fg, bg, _ := s.Decompose()
+
+	assert.Equal(t, tcell.ColorBlue, fg)
+	assert.Equal(t, tcell.ColorPurple, bg)
+}
+
+func TestAttributeStringToStyle(t *testing.T) {
+	s := StringToStyle("bold cyan,brightcyan")
+
+	fg, bg, attr := s.Decompose()
+
+	assert.Equal(t, tcell.ColorTeal, fg)
+	assert.Equal(t, tcell.ColorAqua, bg)
+	assert.NotEqual(t, 0, attr&tcell.AttrBold)
+}
+
+func TestColor256StringToStyle(t *testing.T) {
+	s := StringToStyle("128,60")
+
+	fg, bg, _ := s.Decompose()
+
+	assert.Equal(t, tcell.Color128, fg)
+	assert.Equal(t, tcell.Color60, bg)
+}
+
+func TestColorHexStringToStyle(t *testing.T) {
+	s := StringToStyle("#deadbe,#ef1234")
+
+	fg, bg, _ := s.Decompose()
+
+	assert.Equal(t, tcell.NewRGBColor(222, 173, 190), fg)
+	assert.Equal(t, tcell.NewRGBColor(239, 18, 52), bg)
+}
+
+func TestColorschemeParser(t *testing.T) {
+	testColorscheme := `color-link default "#F8F8F2,#282828"
+color-link comment "#75715E,#282828"
+# comment
+color-link identifier "#66D9EF,#282828" #comment
+color-link constant "#AE81FF,#282828"
+color-link constant.string "#E6DB74,#282828"
+color-link constant.string.char "#BDE6AD,#282828"`
+
+	c, err := ParseColorscheme(testColorscheme)
+	assert.Nil(t, err)
+
+	fg, bg, _ := c["comment"].Decompose()
+	assert.Equal(t, tcell.NewRGBColor(117, 113, 94), fg)
+	assert.Equal(t, tcell.NewRGBColor(40, 40, 40), bg)
+}

internal/config/config.go

@@ -0,0 +1,54 @@
+package config
+
+import (
+	"errors"
+	"os"
+
+	homedir "github.com/mitchellh/go-homedir"
+)
+
+var ConfigDir string
+
+// InitConfigDir finds the configuration directory for micro according to the XDG spec.
+// If no directory is found, it creates one.
+func InitConfigDir(flagConfigDir string) error {
+	var e error
+
+	xdgHome := os.Getenv("XDG_CONFIG_HOME")
+	if xdgHome == "" {
+		// The user has not set $XDG_CONFIG_HOME so we should act like it was set to ~/.config
+		home, err := homedir.Dir()
+		if err != nil {
+			return errors.New("Error finding your home directory\nCan't load config files")
+		}
+		xdgHome = home + "/.config"
+	}
+	ConfigDir = xdgHome + "/micro"
+
+	if len(flagConfigDir) > 0 {
+		if _, err := os.Stat(flagConfigDir); os.IsNotExist(err) {
+			e = errors.New("Error: " + flagConfigDir + " does not exist. Defaulting to " + ConfigDir + ".")
+		} else {
+			ConfigDir = flagConfigDir
+			return nil
+		}
+	}
+
+	if _, err := os.Stat(xdgHome); os.IsNotExist(err) {
+		// If the xdgHome doesn't exist we should create it
+		err = os.Mkdir(xdgHome, os.ModePerm)
+		if err != nil {
+			return errors.New("Error creating XDG_CONFIG_HOME directory: " + err.Error())
+		}
+	}
+
+	if _, err := os.Stat(ConfigDir); os.IsNotExist(err) {
+		// If the micro specific config directory doesn't exist we should create that too
+		err = os.Mkdir(ConfigDir, os.ModePerm)
+		if err != nil {
+			return errors.New("Error creating configuration directory: " + err.Error())
+		}
+	}
+
+	return e
+}

internal/config/globals.go

@@ -0,0 +1,7 @@
+package config
+
+const (
+	DoubleClickThreshold = 400 // How many milliseconds to wait before a second click is not a double click
+)
+
+var Bindings map[string]string

internal/config/plugin.go

@@ -0,0 +1,131 @@
+package config
+
+import (
+	"errors"
+
+	lua "github.com/yuin/gopher-lua"
+	ulua "github.com/zyedidia/micro/internal/lua"
+)
+
+var ErrNoSuchFunction = errors.New("No such function exists")
+
+// LoadAllPlugins loads all detected plugins (in runtime/plugins and ConfigDir/plugins)
+func LoadAllPlugins() error {
+	var reterr error
+	for _, p := range Plugins {
+		err := p.Load()
+		if err != nil {
+			reterr = err
+		}
+	}
+	return reterr
+}
+
+// RunPluginFn runs a given function in all plugins
+// returns an error if any of the plugins had an error
+func RunPluginFn(fn string, args ...lua.LValue) error {
+	var reterr error
+	for _, p := range Plugins {
+		if !p.IsEnabled() {
+			continue
+		}
+		_, err := p.Call(fn, args...)
+		if err != nil && err != ErrNoSuchFunction {
+			reterr = errors.New("Plugin " + p.Name + ": " + err.Error())
+		}
+	}
+	return reterr
+}
+
+// RunPluginFnBool runs a function in all plugins and returns
+// false if any one of them returned false
+// also returns an error if any of the plugins had an error
+func RunPluginFnBool(fn string, args ...lua.LValue) (bool, error) {
+	var reterr error
+	retbool := true
+	for _, p := range Plugins {
+		if !p.IsEnabled() {
+			continue
+		}
+		val, err := p.Call(fn, args...)
+		if err == ErrNoSuchFunction {
+			continue
+		}
+		if err != nil {
+			reterr = errors.New("Plugin " + p.Name + ": " + err.Error())
+			continue
+		}
+		if v, ok := val.(lua.LBool); !ok {
+			reterr = errors.New(p.Name + "." + fn + " should return a boolean")
+		} else {
+			retbool = retbool && bool(v)
+		}
+	}
+	return retbool, reterr
+}
+
+type Plugin struct {
+	Name    string        // name of plugin
+	Info    *PluginInfo   // json file containing info
+	Srcs    []RuntimeFile // lua files
+	Loaded  bool
+	Default bool // pre-installed plugin
+}
+
+func (p *Plugin) IsEnabled() bool {
+	if v, ok := GlobalSettings[p.Name]; ok {
+		return v.(bool) && p.Loaded
+	}
+	return true
+}
+
+var Plugins []*Plugin
+
+func (p *Plugin) Load() error {
+	for _, f := range p.Srcs {
+		if v, ok := GlobalSettings[p.Name]; ok && !v.(bool) {
+			return nil
+		}
+		dat, err := f.Data()
+		if err != nil {
+			return err
+		}
+		err = ulua.LoadFile(p.Name, f.Name(), dat)
+		if err != nil {
+			return err
+		}
+		p.Loaded = true
+		RegisterGlobalOption(p.Name, true)
+	}
+	return nil
+}
+
+func (p *Plugin) Call(fn string, args ...lua.LValue) (lua.LValue, error) {
+	plug := ulua.L.GetGlobal(p.Name)
+	luafn := ulua.L.GetField(plug, fn)
+	if luafn == lua.LNil {
+		return nil, ErrNoSuchFunction
+	}
+	err := ulua.L.CallByParam(lua.P{
+		Fn:      luafn,
+		NRet:    1,
+		Protect: true,
+	}, args...)
+	if err != nil {
+		return nil, err
+	}
+	ret := ulua.L.Get(-1)
+	ulua.L.Pop(1)
+	return ret, nil
+}
+
+func FindPlugin(name string) *Plugin {
+	var pl *Plugin
+	for _, p := range Plugins {
+		if p.Name == name {
+			pl = p
+			break
+		}
+	}
+	return pl
+}

internal/config/plugin_manager.go

@@ -0,0 +1,66 @@
+package config
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+)
+
+var (
+	ErrMissingName    = errors.New("Missing or empty name field")
+	ErrMissingDesc    = errors.New("Missing or empty description field")
+	ErrMissingSite    = errors.New("Missing or empty website field")
+	ErrMissingInstall = errors.New("Missing or empty install field")
+	ErrMissingVstr    = errors.New("Missing or empty versions field")
+	ErrMissingRequire = errors.New("Missing or empty require field")
+)
+
+// PluginInfo contains all the needed info about a plugin
+// The info is just strings and are not used beyond that (except
+// the Site and Install fields should be valid URLs). This means
+// that the requirements for example can be formatted however the
+// plugin maker decides, the fields will only be parsed by humans
+// Name: name of plugin
+// Desc: description of plugin
+// Site: home website of plugin
+// Install: install link for plugin (can be link to repo or zip file)
+// Vstr: version
+// Require: list of dependencies and requirements
+type PluginInfo struct {
+	Name    string   `json:"name"`
+	Desc    string   `json:"description"`
+	Site    string   `json:"website"`
+	Install string   `json:"install"`
+	Vstr    string   `json:"version"`
+	Require []string `json:"require"`
+}
+
+// NewPluginInfo parses a JSON input into a valid PluginInfo struct
+// Returns an error if there are any missing fields or any invalid fields
+// There are no optional fields in a plugin info json file
+func NewPluginInfo(data []byte) (*PluginInfo, error) {
+	var info PluginInfo
+
+	dec := json.NewDecoder(bytes.NewReader(data))
+	// dec.DisallowUnknownFields() // Force errors
+
+	if err := dec.Decode(&info); err != nil {
+		return nil, err
+	}
+
+	// if len(info.Name) == 0 {
+	// 	return nil, ErrMissingName
+	// } else if len(info.Desc) == 0 {
+	// 	return nil, ErrMissingDesc
+	// } else if len(info.Site) == 0 {
+	// 	return nil, ErrMissingSite
+	// } else if len(info.Install) == 0 {
+	// 	return nil, ErrMissingInstall
+	// } else if len(info.Vstr) == 0 {
+	// 	return nil, ErrMissingVstr
+	// } else if len(info.Require) == 0 {
+	// 	return nil, ErrMissingRequire
+	// }
+
+	return &info, nil
+}

internal/config/rtfiles.go

@@ -0,0 +1,253 @@
+package config
+
+import (
+	"io/ioutil"
+	"log"
+	"os"
+	"path"
+	"path/filepath"
+	"regexp"
+	"strings"
+)
+
+const (
+	RTColorscheme = 0
+	RTSyntax      = 1
+	RTHelp        = 2
+	RTPlugin      = 3
+	NumTypes      = 4 // How many filetypes are there
+)
+
+type RTFiletype byte
+
+// 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 [NumTypes][]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 RTFiletype, file 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 RTFiletype, 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 RTFiletype, 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 RTFiletype, 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 RTFiletype) []RuntimeFile {
+	return allFiles[fileType]
+}
+
+// InitRuntimeFiles initializes all assets file and the config directory
+func InitRuntimeFiles() {
+	add := func(fileType RTFiletype, 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")
+
+	initlua := filepath.Join(ConfigDir, "init.lua")
+	if _, err := os.Stat(initlua); !os.IsNotExist(err) {
+		p := new(Plugin)
+		p.Name = "initlua"
+		p.Srcs = append(p.Srcs, realFile(initlua))
+		Plugins = append(Plugins, p)
+	}
+
+	// Search ConfigDir for plugin-scripts
+	plugdir := filepath.Join(ConfigDir, "plug")
+	files, _ := ioutil.ReadDir(plugdir)
+
+	isID := regexp.MustCompile(`^[_A-Za-z0-9]+$`).MatchString
+
+	for _, d := range files {
+		if d.IsDir() {
+			srcs, _ := ioutil.ReadDir(filepath.Join(plugdir, d.Name()))
+			p := new(Plugin)
+			p.Name = d.Name()
+			for _, f := range srcs {
+				if strings.HasSuffix(f.Name(), ".lua") {
+					p.Srcs = append(p.Srcs, realFile(filepath.Join(plugdir, d.Name(), f.Name())))
+				} else if f.Name() == "info.json" {
+					data, err := ioutil.ReadFile(filepath.Join(plugdir, d.Name(), "info.json"))
+					if err != nil {
+						continue
+					}
+					p.Info, _ = NewPluginInfo(data)
+					p.Name = p.Info.Name
+				}
+			}
+
+			if !isID(p.Name) {
+				log.Println("Invalid plugin name", p.Name)
+				continue
+			}
+			Plugins = append(Plugins, p)
+		}
+	}
+
+	plugdir = filepath.Join("runtime", "plugins")
+	if files, err := AssetDir(plugdir); err == nil {
+		for _, d := range files {
+			if srcs, err := AssetDir(filepath.Join(plugdir, d)); err == nil {
+				p := new(Plugin)
+				p.Name = d
+				p.Default = true
+				for _, f := range srcs {
+					if strings.HasSuffix(f, ".lua") {
+						p.Srcs = append(p.Srcs, assetFile(filepath.Join(plugdir, d, f)))
+					} else if f == "info.json" {
+						data, err := Asset(filepath.Join(plugdir, d, "info.json"))
+						if err != nil {
+							continue
+						}
+						p.Info, _ = NewPluginInfo(data)
+						p.Name = p.Info.Name
+					}
+				}
+				if !isID(p.Name) {
+					log.Println("Invalid plugin name", p.Name)
+					continue
+				}
+				Plugins = append(Plugins, p)
+			}
+		}
+	}
+}
+
+// PluginReadRuntimeFile allows plugin scripts to read the content of a runtime file
+func PluginReadRuntimeFile(fileType RTFiletype, 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 RTFiletype) []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 string, filetype RTFiletype, filePath string) {
+	fullpath := filepath.Join(ConfigDir, "plug", 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 string, filetype RTFiletype, directory, pattern string) {
+	fullpath := filepath.Join(ConfigDir, "plug", 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 string, filetype RTFiletype, filename, data string) {
+	AddRuntimeFile(filetype, memoryFile{filename, []byte(data)})
+}

internal/config/rtfiles_test.go

@@ -0,0 +1,42 @@
+package config
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func init() {
+	InitRuntimeFiles()
+}
+
+func TestAddFile(t *testing.T) {
+	AddRuntimeFile(RTPlugin, memoryFile{"foo.lua", []byte("hello world\n")})
+	AddRuntimeFile(RTSyntax, memoryFile{"bar", []byte("some syntax file\n")})
+
+	f1 := FindRuntimeFile(RTPlugin, "foo.lua")
+	assert.NotNil(t, f1)
+	assert.Equal(t, "foo.lua", f1.Name())
+	data, err := f1.Data()
+	assert.Nil(t, err)
+	assert.Equal(t, []byte("hello world\n"), data)
+
+	f2 := FindRuntimeFile(RTSyntax, "bar")
+	assert.NotNil(t, f2)
+	assert.Equal(t, "bar", f2.Name())
+	data, err = f2.Data()
+	assert.Nil(t, err)
+	assert.Equal(t, []byte("some syntax file\n"), data)
+}
+
+func TestFindFile(t *testing.T) {
+	f := FindRuntimeFile(RTSyntax, "go")
+	assert.NotNil(t, f)
+	assert.Equal(t, "go", f.Name())
+	data, err := f.Data()
+	assert.Nil(t, err)
+	assert.Equal(t, []byte("filetype: go"), data[:12])
+
+	e := FindRuntimeFile(RTSyntax, "foobar")
+	assert.Nil(t, e)
+}

internal/config/settings.go

@@ -0,0 +1,349 @@
+package config
+
+import (
+	"encoding/json"
+	"errors"
+	"io/ioutil"
+	"os"
+	"reflect"
+	"strconv"
+	"strings"
+
+	"github.com/flynn/json5"
+	"github.com/zyedidia/glob"
+	"github.com/zyedidia/micro/internal/util"
+	"golang.org/x/text/encoding/htmlindex"
+)
+
+type optionValidator func(string, interface{}) error
+
+var (
+	ErrInvalidOption = errors.New("Invalid option")
+	ErrInvalidValue  = errors.New("Invalid value")
+
+	// The options that the user can set
+	GlobalSettings map[string]interface{}
+
+	// This is the raw parsed json
+	parsedSettings map[string]interface{}
+)
+
+func init() {
+	parsedSettings = make(map[string]interface{})
+}
+
+// Options with validators
+var optionValidators = map[string]optionValidator{
+	"autosave":     validateNonNegativeValue,
+	"tabsize":      validatePositiveValue,
+	"scrollmargin": validateNonNegativeValue,
+	"scrollspeed":  validateNonNegativeValue,
+	"colorscheme":  validateColorscheme,
+	"colorcolumn":  validateNonNegativeValue,
+	"fileformat":   validateLineEnding,
+	"encoding":     validateEncoding,
+}
+
+func ReadSettings() error {
+	filename := ConfigDir + "/settings.json"
+	if _, e := os.Stat(filename); e == nil {
+		input, err := ioutil.ReadFile(filename)
+		if err != nil {
+			return errors.New("Error reading settings.json file: " + err.Error())
+		}
+		if !strings.HasPrefix(string(input), "null") {
+			// Unmarshal the input into the parsed map
+			err = json5.Unmarshal(input, &parsedSettings)
+			if err != nil {
+				return errors.New("Error reading settings.json: " + err.Error())
+			}
+		}
+	}
+	return nil
+}
+
+// InitGlobalSettings initializes the options map and sets all options to their default values
+// Must be called after ReadSettings
+func InitGlobalSettings() {
+	GlobalSettings = DefaultGlobalSettings()
+
+	for k, v := range parsedSettings {
+		if !strings.HasPrefix(reflect.TypeOf(v).String(), "map") {
+			GlobalSettings[k] = v
+		}
+	}
+}
+
+// InitLocalSettings scans the json in settings.json and sets the options locally based
+// on whether the filetype or path matches ft or glob local settings
+// Must be called after ReadSettings
+func InitLocalSettings(settings map[string]interface{}, path string) error {
+	var parseError error
+	for k, v := range parsedSettings {
+		if strings.HasPrefix(reflect.TypeOf(v).String(), "map") {
+			if strings.HasPrefix(k, "ft:") {
+				if settings["filetype"].(string) == k[3:] {
+					for k1, v1 := range v.(map[string]interface{}) {
+						settings[k1] = v1
+					}
+				}
+			} else {
+				g, err := glob.Compile(k)
+				if err != nil {
+					parseError = errors.New("Error with glob setting " + k + ": " + err.Error())
+					continue
+				}
+
+				if g.MatchString(path) {
+					for k1, v1 := range v.(map[string]interface{}) {
+						settings[k1] = v1
+					}
+				}
+			}
+		}
+	}
+	return parseError
+}
+
+// WriteSettings writes the settings to the specified filename as JSON
+func WriteSettings(filename string) error {
+	var err error
+	if _, e := os.Stat(ConfigDir); e == nil {
+		for k, v := range GlobalSettings {
+			parsedSettings[k] = v
+		}
+
+		txt, _ := json.MarshalIndent(parsedSettings, "", "    ")
+		err = ioutil.WriteFile(filename, append(txt, '\n'), 0644)
+	}
+	return err
+}
+
+// RegisterCommonOption creates a new option. This is meant to be called by plugins to add options.
+func RegisterCommonOption(name string, defaultvalue interface{}) error {
+	if v, ok := GlobalSettings[name]; !ok {
+		defaultCommonSettings[name] = defaultvalue
+		GlobalSettings[name] = defaultvalue
+		err := WriteSettings(ConfigDir + "/settings.json")
+		if err != nil {
+			return errors.New("Error writing settings.json file: " + err.Error())
+		}
+	} else {
+		defaultCommonSettings[name] = v
+	}
+	return nil
+}
+
+func RegisterGlobalOption(name string, defaultvalue interface{}) error {
+	if v, ok := GlobalSettings[name]; !ok {
+		defaultGlobalSettings[name] = defaultvalue
+		GlobalSettings[name] = defaultvalue
+		err := WriteSettings(ConfigDir + "/settings.json")
+		if err != nil {
+			return errors.New("Error writing settings.json file: " + err.Error())
+		}
+	} else {
+		defaultGlobalSettings[name] = v
+	}
+	return nil
+}
+
+// GetGlobalOption returns the global value of the given option
+func GetGlobalOption(name string) interface{} {
+	return GlobalSettings[name]
+}
+
+var defaultCommonSettings = map[string]interface{}{
+	"autoindent":     true,
+	"backup":         true,
+	"basename":       false,
+	"colorcolumn":    float64(0),
+	"cursorline":     true,
+	"encoding":       "utf-8",
+	"eofnewline":     false,
+	"fastdirty":      true,
+	"fileformat":     "unix",
+	"filetype":       "unknown",
+	"ignorecase":     false,
+	"indentchar":     " ",
+	"keepautoindent": false,
+	"matchbrace":     true,
+	"mkparents":      false,
+	"readonly":       false,
+	"rmtrailingws":   false,
+	"ruler":          true,
+	"savecursor":     false,
+	"saveundo":       false,
+	"scrollbar":      false,
+	"scrollmargin":   float64(3),
+	"scrollspeed":    float64(2),
+	"smartpaste":     true,
+	"softwrap":       false,
+	"splitbottom":    true,
+	"splitright":     true,
+	"statusformatl":  "$(filename) $(modified)($(line),$(col)) | ft:$(opt:filetype) | $(opt:fileformat) | $(opt:encoding)",
+	"statusformatr":  "$(bind:ToggleKeyMenu): show bindings, $(bind:ToggleHelp): toggle help",
+	"statusline":     true,
+	"syntax":         true,
+	"tabmovement":    false,
+	"tabsize":        float64(4),
+	"tabstospaces":   false,
+	"useprimary":     true,
+}
+
+func GetInfoBarOffset() int {
+	offset := 0
+	if GetGlobalOption("infobar").(bool) {
+		offset++
+	}
+	if GetGlobalOption("keymenu").(bool) {
+		offset += 2
+	}
+	return offset
+}
+
+// DefaultCommonSettings returns the default global settings for micro
+// Note that colorscheme is a global only option
+func DefaultCommonSettings() map[string]interface{} {
+	commonsettings := make(map[string]interface{})
+	for k, v := range defaultCommonSettings {
+		commonsettings[k] = v
+	}
+	return commonsettings
+}
+
+var defaultGlobalSettings = map[string]interface{}{
+	"autosave":    float64(0),
+	"colorscheme": "default",
+	"infobar":     true,
+	"keymenu":     false,
+	"mouse":       true,
+	"savehistory": true,
+	"sucmd":       "sudo",
+	"termtitle":   false,
+}
+
+// DefaultGlobalSettings returns the default global settings for micro
+// Note that colorscheme is a global only option
+func DefaultGlobalSettings() map[string]interface{} {
+	globalsettings := make(map[string]interface{})
+	for k, v := range defaultCommonSettings {
+		globalsettings[k] = v
+	}
+	for k, v := range defaultGlobalSettings {
+		globalsettings[k] = v
+	}
+	return globalsettings
+}
+
+// DefaultAllSettings returns a map of all settings and their
+// default values (both common and global settings)
+func DefaultAllSettings() map[string]interface{} {
+	allsettings := make(map[string]interface{})
+	for k, v := range defaultCommonSettings {
+		allsettings[k] = v
+	}
+	for k, v := range defaultGlobalSettings {
+		allsettings[k] = v
+	}
+	return allsettings
+}
+
+func GetNativeValue(option string, realValue interface{}, value string) (interface{}, error) {
+	var native interface{}
+	kind := reflect.TypeOf(realValue).Kind()
+	if kind == reflect.Bool {
+		b, err := util.ParseBool(value)
+		if err != nil {
+			return nil, ErrInvalidValue
+		}
+		native = b
+	} else if kind == reflect.String {
+		native = value
+	} else if kind == reflect.Float64 {
+		i, err := strconv.Atoi(value)
+		if err != nil {
+			return nil, ErrInvalidValue
+		}
+		native = float64(i)
+	} else {
+		return nil, ErrInvalidValue
+	}
+
+	if err := OptionIsValid(option, native); err != nil {
+		return nil, err
+	}
+	return native, nil
+}
+
+// OptionIsValid checks if a value is valid for a certain option
+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
+}
+
+func validateLineEnding(option string, value interface{}) error {
+	endingType, ok := value.(string)
+
+	if !ok {
+		return errors.New("Expected string type for file format")
+	}
+
+	if endingType != "unix" && endingType != "dos" {
+		return errors.New("File format must be either 'unix' or 'dos'")
+	}
+
+	return nil
+}
+
+func validateEncoding(option string, value interface{}) error {
+	_, err := htmlindex.Get(value.(string))
+	return err
+}

internal/display/bufwindow.go

@@ -0,0 +1,660 @@
+package display
+
+import (
+	"log"
+	"strconv"
+	"unicode/utf8"
+
+	runewidth "github.com/mattn/go-runewidth"
+	"github.com/zyedidia/micro/internal/buffer"
+	"github.com/zyedidia/micro/internal/config"
+	"github.com/zyedidia/micro/internal/screen"
+	"github.com/zyedidia/micro/internal/util"
+	"github.com/zyedidia/tcell"
+)
+
+// The BufWindow provides a way of displaying a certain section
+// of a buffer
+type BufWindow struct {
+	*View
+
+	// Buffer being shown in this window
+	Buf *buffer.Buffer
+
+	active bool
+
+	sline *StatusLine
+
+	gutterOffset int
+	drawStatus   bool
+}
+
+// NewBufWindow creates a new window at a location in the screen with a width and height
+func NewBufWindow(x, y, width, height int, buf *buffer.Buffer) *BufWindow {
+	w := new(BufWindow)
+	w.View = new(View)
+	w.X, w.Y, w.Width, w.Height, w.Buf = x, y, width, height, buf
+	w.active = true
+
+	w.sline = NewStatusLine(w)
+
+	return w
+}
+
+func (w *BufWindow) SetBuffer(b *buffer.Buffer) {
+	w.Buf = b
+}
+
+func (v *View) GetView() *View {
+	return v
+}
+
+func (v *View) SetView(view *View) {
+	v = view
+}
+
+func (w *BufWindow) Resize(width, height int) {
+	w.Width, w.Height = width, height
+	w.Relocate()
+}
+
+func (w *BufWindow) SetActive(b bool) {
+	w.active = b
+}
+
+func (w *BufWindow) IsActive() bool {
+	return w.active
+}
+
+func (w *BufWindow) getStartInfo(n, lineN int) ([]byte, int, int, *tcell.Style) {
+	tabsize := util.IntOpt(w.Buf.Settings["tabsize"])
+	width := 0
+	bloc := buffer.Loc{0, lineN}
+	b := w.Buf.LineBytes(lineN)
+	curStyle := config.DefStyle
+	var s *tcell.Style
+	for len(b) > 0 {
+		r, size := utf8.DecodeRune(b)
+
+		curStyle, found := w.getStyle(curStyle, bloc, r)
+		if found {
+			s = &curStyle
+		}
+
+		w := 0
+		switch r {
+		case '\t':
+			ts := tabsize - (width % tabsize)
+			w = ts
+		default:
+			w = runewidth.RuneWidth(r)
+		}
+		if width+w > n {
+			return b, n - width, bloc.X, s
+		}
+		width += w
+		b = b[size:]
+		bloc.X++
+	}
+	return b, n - width, bloc.X, s
+}
+
+// Clear resets all cells in this window to the default style
+func (w *BufWindow) Clear() {
+	for y := 0; y < w.Height; y++ {
+		for x := 0; x < w.Width; x++ {
+			screen.Screen.SetContent(w.X+x, w.Y+y, ' ', nil, config.DefStyle)
+		}
+	}
+}
+
+// Bottomline returns the line number of the lowest line in the view
+// You might think that this is obviously just v.StartLine + v.Height
+// but if softwrap is enabled things get complicated since one buffer
+// line can take up multiple lines in the view
+func (w *BufWindow) Bottomline() int {
+	if !w.Buf.Settings["softwrap"].(bool) {
+		h := w.StartLine + w.Height - 1
+		if w.drawStatus {
+			h--
+		}
+		return h
+	}
+
+	l := w.LocFromVisual(buffer.Loc{0, w.Height})
+
+	log.Println("Bottom line:", l.Y)
+	return l.Y
+}
+
+// Relocate moves the view window so that the cursor is in view
+// This is useful if the user has scrolled far away, and then starts typing
+// Returns true if the window location is moved
+func (w *BufWindow) Relocate() bool {
+	b := w.Buf
+	// how many buffer lines are in the view
+	height := w.Bottomline() + 1 - w.StartLine
+	log.Printf("Height: %d, w.Height: %d\n", height, w.Height)
+	h := w.Height
+	if w.drawStatus {
+		h--
+	}
+	if b.LinesNum() <= h {
+		height = w.Height
+	}
+	ret := false
+	activeC := w.Buf.GetActiveCursor()
+	cy := activeC.Y
+	scrollmargin := int(b.Settings["scrollmargin"].(float64))
+	if cy < w.StartLine+scrollmargin && cy > scrollmargin-1 {
+		w.StartLine = cy - scrollmargin
+		ret = true
+	} else if cy < w.StartLine {
+		w.StartLine = cy
+		ret = true
+	}
+	if cy > w.StartLine+height-1-scrollmargin && cy < b.LinesNum()-scrollmargin {
+		w.StartLine = cy - height + 1 + scrollmargin
+		ret = true
+	} else if cy >= b.LinesNum()-scrollmargin && cy >= height {
+		w.StartLine = b.LinesNum() - height
+		ret = true
+	}
+
+	// horizontal relocation (scrolling)
+	if !b.Settings["softwrap"].(bool) {
+		cx := activeC.GetVisualX()
+		if cx < w.StartCol {
+			w.StartCol = cx
+			ret = true
+		}
+		if cx+w.gutterOffset+1 > w.StartCol+w.Width {
+			w.StartCol = cx - w.Width + w.gutterOffset + 1
+			ret = true
+		}
+	}
+	return ret
+}
+
+// LocFromVisual takes a visual location (x and y position) and returns the
+// position in the buffer corresponding to the visual location
+// Computing the buffer location requires essentially drawing the entire screen
+// to account for complications like softwrap, wide characters, and horizontal scrolling
+// If the requested position does not correspond to a buffer location it returns
+// the nearest position
+func (w *BufWindow) LocFromVisual(svloc buffer.Loc) buffer.Loc {
+	b := w.Buf
+
+	hasMessage := len(b.Messages) > 0
+	bufHeight := w.Height
+	if w.drawStatus {
+		bufHeight--
+	}
+
+	// We need to know the string length of the largest line number
+	// so we can pad appropriately when displaying line numbers
+	maxLineNumLength := len(strconv.Itoa(b.LinesNum()))
+
+	tabsize := int(b.Settings["tabsize"].(float64))
+	softwrap := b.Settings["softwrap"].(bool)
+
+	// this represents the current draw position
+	// within the current window
+	vloc := buffer.Loc{X: 0, Y: 0}
+
+	// this represents the current draw position in the buffer (char positions)
+	bloc := buffer.Loc{X: -1, Y: w.StartLine}
+
+	for vloc.Y = 0; vloc.Y < bufHeight; vloc.Y++ {
+		vloc.X = 0
+		if hasMessage {
+			vloc.X += 2
+		}
+		if b.Settings["ruler"].(bool) {
+			vloc.X += maxLineNumLength + 1
+		}
+
+		line := b.LineBytes(bloc.Y)
+		line, nColsBeforeStart, bslice := util.SliceVisualEnd(line, w.StartCol, tabsize)
+		bloc.X = bslice
+
+		draw := func() {
+			if nColsBeforeStart <= 0 {
+				vloc.X++
+			}
+			nColsBeforeStart--
+		}
+
+		totalwidth := w.StartCol - nColsBeforeStart
+
+		if svloc.X <= vloc.X+w.X && vloc.Y+w.Y == svloc.Y {
+			return bloc
+		}
+		for len(line) > 0 {
+			if vloc.X+w.X == svloc.X && vloc.Y+w.Y == svloc.Y {
+				return bloc
+			}
+
+			r, size := utf8.DecodeRune(line)
+			draw()
+			width := 0
+
+			switch r {
+			case '\t':
+				ts := tabsize - (totalwidth % tabsize)
+				width = ts
+			default:
+				width = runewidth.RuneWidth(r)
+			}
+
+			// Draw any extra characters either spaces for tabs or @ for incomplete wide runes
+			if width > 1 {
+				for i := 1; i < width; i++ {
+					if vloc.X+w.X == svloc.X && vloc.Y+w.Y == svloc.Y {
+						return bloc
+					}
+					draw()
+				}
+			}
+			bloc.X++
+			line = line[size:]
+
+			totalwidth += width
+
+			// If we reach the end of the window then we either stop or we wrap for softwrap
+			if vloc.X >= w.Width {
+				if !softwrap {
+					break
+				} else {
+					vloc.Y++
+					if vloc.Y >= bufHeight {
+						break
+					}
+					vloc.X = 0
+					// This will draw an empty line number because the current line is wrapped
+					vloc.X += maxLineNumLength + 1
+				}
+			}
+		}
+		if vloc.Y+w.Y == svloc.Y {
+			return bloc
+		}
+
+		if bloc.Y+1 >= b.LinesNum() || vloc.Y+1 >= bufHeight {
+			return bloc
+		}
+
+		bloc.X = w.StartCol
+		bloc.Y++
+	}
+
+	return buffer.Loc{}
+}
+
+func (w *BufWindow) drawGutter(vloc *buffer.Loc, bloc *buffer.Loc) {
+	char := ' '
+	s := config.DefStyle
+	for _, m := range w.Buf.Messages {
+		if m.Start.Y == bloc.Y || m.End.Y == bloc.Y {
+			s = m.Style()
+			char = '>'
+			break
+		}
+	}
+	screen.Screen.SetContent(w.X+vloc.X, w.Y+vloc.Y, char, nil, s)
+	vloc.X++
+	screen.Screen.SetContent(w.X+vloc.X, w.Y+vloc.Y, char, nil, s)
+	vloc.X++
+}
+
+func (w *BufWindow) drawLineNum(lineNumStyle tcell.Style, softwrapped bool, maxLineNumLength int, vloc *buffer.Loc, bloc *buffer.Loc) {
+	lineNum := strconv.Itoa(bloc.Y + 1)
+
+	// Write the spaces before the line number if necessary
+	for i := 0; i < maxLineNumLength-len(lineNum); i++ {
+		screen.Screen.SetContent(w.X+vloc.X, w.Y+vloc.Y, ' ', nil, lineNumStyle)
+		vloc.X++
+	}
+	// Write the actual line number
+	for _, ch := range lineNum {
+		if softwrapped {
+			screen.Screen.SetContent(w.X+vloc.X, w.Y+vloc.Y, ' ', nil, lineNumStyle)
+		} else {
+			screen.Screen.SetContent(w.X+vloc.X, w.Y+vloc.Y, ch, nil, lineNumStyle)
+		}
+		vloc.X++
+	}
+
+	// Write the extra space
+	screen.Screen.SetContent(w.X+vloc.X, w.Y+vloc.Y, ' ', nil, lineNumStyle)
+	vloc.X++
+}
+
+// getStyle returns the highlight style for the given character position
+// If there is no change to the current highlight style it just returns that
+func (w *BufWindow) getStyle(style tcell.Style, bloc buffer.Loc, r rune) (tcell.Style, bool) {
+	if group, ok := w.Buf.Match(bloc.Y)[bloc.X]; ok {
+		s := config.GetColor(group.String())
+		return s, true
+	}
+	return style, false
+}
+
+func (w *BufWindow) showCursor(x, y int, main bool) {
+	if w.active {
+		if main {
+			screen.Screen.ShowCursor(x, y)
+		} else {
+			r, _, _, _ := screen.Screen.GetContent(x, y)
+			screen.Screen.SetContent(x, y, r, nil, config.DefStyle.Reverse(true))
+		}
+	}
+}
+
+// displayBuffer draws the buffer being shown in this window on the screen.Screen
+func (w *BufWindow) displayBuffer() {
+	b := w.Buf
+
+	hasMessage := len(b.Messages) > 0
+	bufHeight := w.Height
+	if w.drawStatus {
+		bufHeight--
+	}
+
+	bufWidth := w.Width
+	if w.Buf.Settings["scrollbar"].(bool) && w.Buf.LinesNum() > w.Height {
+		bufWidth--
+	}
+
+	if b.Settings["syntax"].(bool) && b.SyntaxDef != nil {
+		for _, c := range b.GetCursors() {
+			// rehighlight starting from where the cursor is
+			start := c.Y
+			if start > 0 && b.Rehighlight(start-1) {
+				b.Highlighter.ReHighlightLine(b, start-1)
+				b.SetRehighlight(start-1, false)
+			}
+
+			b.Highlighter.ReHighlightStates(b, start)
+			b.Highlighter.HighlightMatches(b, w.StartLine, w.StartLine+bufHeight)
+		}
+	}
+
+	var matchingBraces []buffer.Loc
+	// bracePairs is defined in buffer.go
+	if b.Settings["matchbrace"].(bool) {
+		for _, bp := range buffer.BracePairs {
+			for _, c := range b.GetCursors() {
+				if c.HasSelection() {
+					continue
+				}
+				curX := c.X
+				curLoc := c.Loc
+
+				r := c.RuneUnder(curX)
+				rl := c.RuneUnder(curX - 1)
+				if r == bp[0] || r == bp[1] || rl == bp[0] || rl == bp[1] {
+					mb, left := b.FindMatchingBrace(bp, curLoc)
+					matchingBraces = append(matchingBraces, mb)
+					if !left {
+						matchingBraces = append(matchingBraces, curLoc)
+					} else {
+						matchingBraces = append(matchingBraces, curLoc.Move(-1, b))
+					}
+				}
+			}
+		}
+	}
+
+	lineNumStyle := config.DefStyle
+	if style, ok := config.Colorscheme["line-number"]; ok {
+		lineNumStyle = style
+	}
+	curNumStyle := config.DefStyle
+	if style, ok := config.Colorscheme["current-line-number"]; ok {
+		curNumStyle = style
+	}
+
+	// We need to know the string length of the largest line number
+	// so we can pad appropriately when displaying line numbers
+	maxLineNumLength := len(strconv.Itoa(b.LinesNum()))
+
+	softwrap := b.Settings["softwrap"].(bool)
+	tabsize := util.IntOpt(b.Settings["tabsize"])
+	colorcolumn := util.IntOpt(b.Settings["colorcolumn"])
+
+	// this represents the current draw position
+	// within the current window
+	vloc := buffer.Loc{X: 0, Y: 0}
+
+	// this represents the current draw position in the buffer (char positions)
+	bloc := buffer.Loc{X: -1, Y: w.StartLine}
+
+	cursors := b.GetCursors()
+
+	curStyle := config.DefStyle
+	for vloc.Y = 0; vloc.Y < bufHeight; vloc.Y++ {
+		vloc.X = 0
+
+		if hasMessage {
+			w.drawGutter(&vloc, &bloc)
+		}
+
+		if b.Settings["ruler"].(bool) {
+			s := lineNumStyle
+			for _, c := range cursors {
+				if bloc.Y == c.Y && w.active {
+					s = curNumStyle
+					break
+				}
+			}
+			w.drawLineNum(s, false, maxLineNumLength, &vloc, &bloc)
+		}
+
+		w.gutterOffset = vloc.X
+
+		line, nColsBeforeStart, bslice, startStyle := w.getStartInfo(w.StartCol, bloc.Y)
+		if startStyle != nil {
+			curStyle = *startStyle
+		}
+		bloc.X = bslice
+
+		draw := func(r rune, style tcell.Style, showcursor bool) {
+			if nColsBeforeStart <= 0 {
+				for _, c := range cursors {
+					if c.HasSelection() &&
+						(bloc.GreaterEqual(c.CurSelection[0]) && bloc.LessThan(c.CurSelection[1]) ||
+							bloc.LessThan(c.CurSelection[0]) && bloc.GreaterEqual(c.CurSelection[1])) {
+						// The current character is selected
+						style = config.DefStyle.Reverse(true)
+
+						if s, ok := config.Colorscheme["selection"]; ok {
+							style = s
+						}
+					}
+
+					if b.Settings["cursorline"].(bool) && w.active &&
+						!c.HasSelection() && c.Y == bloc.Y {
+						if s, ok := config.Colorscheme["cursor-line"]; ok {
+							fg, _, _ := s.Decompose()
+							style = style.Background(fg)
+						}
+					}
+				}
+
+				for _, m := range b.Messages {
+					if bloc.GreaterEqual(m.Start) && bloc.LessThan(m.End) ||
+						bloc.LessThan(m.End) && bloc.GreaterEqual(m.Start) {
+						style = style.Underline(true)
+						break
+					}
+				}
+
+				if r == '\t' {
+					indentrunes := []rune(b.Settings["indentchar"].(string))
+					// if empty indentchar settings, use space
+					if indentrunes == nil || len(indentrunes) == 0 {
+						indentrunes = []rune{' '}
+					}
+
+					r = indentrunes[0]
+					if s, ok := config.Colorscheme["indent-char"]; ok && r != ' ' {
+						fg, _, _ := s.Decompose()
+						style = style.Foreground(fg)
+					}
+				}
+
+				if s, ok := config.Colorscheme["color-column"]; ok {
+					if colorcolumn != 0 && vloc.X-w.gutterOffset == colorcolumn {
+						fg, _, _ := s.Decompose()
+						style = style.Background(fg)
+					}
+				}
+
+				for _, mb := range matchingBraces {
+					if mb.X == bloc.X && mb.Y == bloc.Y {
+						style = style.Underline(true)
+					}
+				}
+
+				screen.Screen.SetContent(w.X+vloc.X, w.Y+vloc.Y, r, nil, style)
+
+				if showcursor {
+					for _, c := range cursors {
+						if c.X == bloc.X && c.Y == bloc.Y && !c.HasSelection() {
+							w.showCursor(w.X+vloc.X, w.Y+vloc.Y, c.Num == 0)
+						}
+					}
+				}
+				vloc.X++
+			}
+			nColsBeforeStart--
+		}
+
+		totalwidth := w.StartCol - nColsBeforeStart
+		for len(line) > 0 {
+			r, size := utf8.DecodeRune(line)
+			curStyle, _ = w.getStyle(curStyle, bloc, r)
+
+			draw(r, curStyle, true)
+
+			width := 0
+
+			char := ' '
+			switch r {
+			case '\t':
+				ts := tabsize - (totalwidth % tabsize)
+				width = ts
+			default:
+				width = runewidth.RuneWidth(r)
+				char = '@'
+			}
+
+			// Draw any extra characters either spaces for tabs or @ for incomplete wide runes
+			if width > 1 {
+				for i := 1; i < width; i++ {
+					draw(char, curStyle, false)
+				}
+			}
+			bloc.X++
+			line = line[size:]
+
+			totalwidth += width
+
+			// If we reach the end of the window then we either stop or we wrap for softwrap
+			if vloc.X >= bufWidth {
+				if !softwrap {
+					break
+				} else {
+					vloc.Y++
+					if vloc.Y >= bufHeight {
+						break
+					}
+					vloc.X = 0
+					// This will draw an empty line number because the current line is wrapped
+					w.drawLineNum(lineNumStyle, true, maxLineNumLength, &vloc, &bloc)
+				}
+			}
+		}
+
+		style := config.DefStyle
+		for _, c := range cursors {
+			if b.Settings["cursorline"].(bool) && w.active &&
+				!c.HasSelection() && c.Y == bloc.Y {
+				if s, ok := config.Colorscheme["cursor-line"]; ok {
+					fg, _, _ := s.Decompose()
+					style = style.Background(fg)
+				}
+			}
+		}
+		for i := vloc.X; i < bufWidth; i++ {
+			curStyle := style
+			if s, ok := config.Colorscheme["color-column"]; ok {
+				if colorcolumn != 0 && i-w.gutterOffset == colorcolumn {
+					fg, _, _ := s.Decompose()
+					curStyle = style.Background(fg)
+				}
+			}
+			screen.Screen.SetContent(i+w.X, vloc.Y+w.Y, ' ', nil, curStyle)
+		}
+
+		for _, c := range cursors {
+			if c.X == bloc.X && c.Y == bloc.Y && !c.HasSelection() {
+				w.showCursor(w.X+vloc.X, w.Y+vloc.Y, c.Num == 0)
+			}
+		}
+
+		draw(' ', curStyle, false)
+
+		bloc.X = w.StartCol
+		bloc.Y++
+		if bloc.Y >= b.LinesNum() {
+			break
+		}
+	}
+}
+
+func (w *BufWindow) displayStatusLine() {
+	_, h := screen.Screen.Size()
+	infoY := h
+	if config.GetGlobalOption("infobar").(bool) {
+		infoY--
+	}
+
+	if w.Buf.Settings["statusline"].(bool) {
+		w.drawStatus = true
+		w.sline.Display()
+	} else if w.Y+w.Height != infoY {
+		w.drawStatus = true
+		for x := w.X; x < w.X+w.Width; x++ {
+			screen.Screen.SetContent(x, w.Y+w.Height-1, '-', nil, config.DefStyle.Reverse(true))
+		}
+	} else {
+		w.drawStatus = false
+	}
+}
+
+func (w *BufWindow) displayScrollBar() {
+	if w.Buf.Settings["scrollbar"].(bool) && w.Buf.LinesNum() > w.Height {
+		scrollX := w.X + w.Width - 1
+		bufHeight := w.Height
+		if w.drawStatus {
+			bufHeight--
+		}
+		barsize := int(float64(w.Height) / float64(w.Buf.LinesNum()) * float64(w.Height))
+		if barsize < 1 {
+			barsize = 1
+		}
+		barstart := w.Y + int(float64(w.StartLine)/float64(w.Buf.LinesNum())*float64(w.Height))
+		for y := barstart; y < util.Min(barstart+barsize, w.Y+bufHeight); y++ {
+			screen.Screen.SetContent(scrollX, y, '|', nil, config.DefStyle.Reverse(true))
+		}
+	}
+}
+
+// Display displays the buffer and the statusline
+func (w *BufWindow) Display() {
+	w.displayStatusLine()
+	w.displayScrollBar()
+	w.displayBuffer()
+}

internal/display/infowindow.go

@@ -0,0 +1,240 @@
+package display
+
+import (
+	"unicode/utf8"
+
+	runewidth "github.com/mattn/go-runewidth"
+	"github.com/zyedidia/micro/internal/buffer"
+	"github.com/zyedidia/micro/internal/config"
+	"github.com/zyedidia/micro/internal/info"
+	"github.com/zyedidia/micro/internal/screen"
+	"github.com/zyedidia/micro/internal/util"
+	"github.com/zyedidia/tcell"
+)
+
+type InfoWindow struct {
+	*info.InfoBuf
+	*View
+}
+
+func (i *InfoWindow) errStyle() tcell.Style {
+	errStyle := config.DefStyle.
+		Foreground(tcell.ColorBlack).
+		Background(tcell.ColorMaroon)
+
+	if _, ok := config.Colorscheme["error-message"]; ok {
+		errStyle = config.Colorscheme["error-message"]
+	}
+
+	return errStyle
+}
+
+func (i *InfoWindow) defStyle() tcell.Style {
+	defStyle := config.DefStyle
+
+	if _, ok := config.Colorscheme["message"]; ok {
+		defStyle = config.Colorscheme["message"]
+	}
+
+	return defStyle
+}
+
+func NewInfoWindow(b *info.InfoBuf) *InfoWindow {
+	iw := new(InfoWindow)
+	iw.InfoBuf = b
+	iw.View = new(View)
+
+	iw.Width, iw.Y = screen.Screen.Size()
+	iw.Y--
+
+	return iw
+}
+
+func (i *InfoWindow) Resize(w, h int) {
+	i.Width = w
+	i.Y = h
+}
+
+func (i *InfoWindow) SetBuffer(b *buffer.Buffer) {
+	i.InfoBuf.Buffer = b
+}
+
+func (i *InfoWindow) Relocate() bool   { return false }
+func (i *InfoWindow) GetView() *View   { return i.View }
+func (i *InfoWindow) SetView(v *View)  {}
+func (i *InfoWindow) SetActive(b bool) {}
+func (i *InfoWindow) IsActive() bool   { return true }
+
+func (i *InfoWindow) LocFromVisual(vloc buffer.Loc) buffer.Loc {
+	c := i.Buffer.GetActiveCursor()
+	l := i.Buffer.LineBytes(0)
+	n := utf8.RuneCountInString(i.Msg)
+	return buffer.Loc{c.GetCharPosInLine(l, vloc.X-n), 0}
+}
+
+func (i *InfoWindow) Clear() {
+	for x := 0; x < i.Width; x++ {
+		screen.Screen.SetContent(x, i.Y, ' ', nil, i.defStyle())
+	}
+}
+
+func (i *InfoWindow) displayBuffer() {
+	b := i.Buffer
+	line := b.LineBytes(0)
+	activeC := b.GetActiveCursor()
+
+	blocX := 0
+	vlocX := utf8.RuneCountInString(i.Msg)
+
+	tabsize := 4
+	line, nColsBeforeStart, bslice := util.SliceVisualEnd(line, blocX, tabsize)
+	blocX = bslice
+
+	draw := func(r rune, style tcell.Style) {
+		if nColsBeforeStart <= 0 {
+			bloc := buffer.Loc{X: blocX, Y: 0}
+			if activeC.HasSelection() &&
+				(bloc.GreaterEqual(activeC.CurSelection[0]) && bloc.LessThan(activeC.CurSelection[1]) ||
+					bloc.LessThan(activeC.CurSelection[0]) && bloc.GreaterEqual(activeC.CurSelection[1])) {
+				// The current character is selected
+				style = i.defStyle().Reverse(true)
+
+				if s, ok := config.Colorscheme["selection"]; ok {
+					style = s
+				}
+
+			}
+
+			rw := runewidth.RuneWidth(r)
+			for j := 0; j < rw; j++ {
+				c := r
+				if j > 0 {
+					c = ' '
+				}
+				screen.Screen.SetContent(vlocX, i.Y, c, nil, style)
+			}
+			vlocX++
+		}
+		nColsBeforeStart--
+	}
+
+	totalwidth := blocX - nColsBeforeStart
+	for len(line) > 0 {
+		if activeC.X == blocX {
+			screen.Screen.ShowCursor(vlocX, i.Y)
+		}
+
+		r, size := utf8.DecodeRune(line)
+
+		draw(r, i.defStyle())
+
+		width := 0
+
+		char := ' '
+		switch r {
+		case '\t':
+			ts := tabsize - (totalwidth % tabsize)
+			width = ts
+		default:
+			width = runewidth.RuneWidth(r)
+			char = '@'
+		}
+
+		blocX++
+		line = line[size:]
+
+		// Draw any extra characters either spaces for tabs or @ for incomplete wide runes
+		if width > 1 {
+			for j := 1; j < width; j++ {
+				draw(char, i.defStyle())
+			}
+		}
+		totalwidth += width
+		if vlocX >= i.Width {
+			break
+		}
+	}
+	if activeC.X == blocX {
+		screen.Screen.ShowCursor(vlocX, i.Y)
+	}
+}
+
+var keydisplay = []string{"^Q Quit, ^S Save, ^O Open, ^G Help, ^E Command Bar, ^K Cut Line", "^F Find, ^Z Undo, ^Y Redo, ^A Select All, ^D Duplicate Line, ^T New Tab"}
+
+func (i *InfoWindow) displayKeyMenu() {
+	// TODO: maybe make this based on the actual keybindings
+
+	for y := 0; y < len(keydisplay); y++ {
+		for x := 0; x < i.Width; x++ {
+			if x < len(keydisplay[y]) {
+				screen.Screen.SetContent(x, i.Y-len(keydisplay)+y, rune(keydisplay[y][x]), nil, i.defStyle())
+			} else {
+				screen.Screen.SetContent(x, i.Y-len(keydisplay)+y, ' ', nil, i.defStyle())
+			}
+		}
+	}
+}
+
+func (i *InfoWindow) Display() {
+	x := 0
+	if config.GetGlobalOption("keymenu").(bool) {
+		i.displayKeyMenu()
+	}
+
+	if i.HasPrompt || config.GlobalSettings["infobar"].(bool) {
+		if !i.HasPrompt && !i.HasMessage && !i.HasError {
+			return
+		}
+		i.Clear()
+		style := i.defStyle()
+
+		if i.HasError {
+			style = i.errStyle()
+		}
+
+		display := i.Msg
+		for _, c := range display {
+			screen.Screen.SetContent(x, i.Y, c, nil, style)
+			x += runewidth.RuneWidth(c)
+		}
+
+		if i.HasPrompt {
+			i.displayBuffer()
+		}
+	}
+
+	if i.HasSuggestions && len(i.Suggestions) > 1 {
+		statusLineStyle := config.DefStyle.Reverse(true)
+		if style, ok := config.Colorscheme["statusline"]; ok {
+			statusLineStyle = style
+		}
+		keymenuOffset := 0
+		if config.GetGlobalOption("keymenu").(bool) {
+			keymenuOffset = len(keydisplay)
+		}
+		x := 0
+		for j, s := range i.Suggestions {
+			style := statusLineStyle
+			if i.CurSuggestion == j {
+				style = style.Reverse(true)
+			}
+			for _, r := range s {
+				screen.Screen.SetContent(x, i.Y-keymenuOffset-1, r, nil, style)
+				x++
+				if x >= i.Width {
+					return
+				}
+			}
+			screen.Screen.SetContent(x, i.Y-keymenuOffset-1, ' ', nil, statusLineStyle)
+			x++
+			if x >= i.Width {
+				return
+			}
+		}
+
+		for x < i.Width {
+			screen.Screen.SetContent(x, i.Y-keymenuOffset-1, ' ', nil, statusLineStyle)
+			x++
+		}
+	}
+}

internal/display/statusline.go

@@ -0,0 +1,205 @@
+package display
+
+import (
+	"bytes"
+	"fmt"
+	"path"
+	"regexp"
+	"strconv"
+	"strings"
+	"unicode/utf8"
+
+	luar "layeh.com/gopher-luar"
+
+	runewidth "github.com/mattn/go-runewidth"
+	lua "github.com/yuin/gopher-lua"
+	"github.com/zyedidia/micro/internal/buffer"
+	"github.com/zyedidia/micro/internal/config"
+	ulua "github.com/zyedidia/micro/internal/lua"
+	"github.com/zyedidia/micro/internal/screen"
+	"github.com/zyedidia/micro/internal/util"
+)
+
+// StatusLine represents the information line at the bottom
+// of each window
+// It gives information such as filename, whether the file has been
+// modified, filetype, cursor location
+type StatusLine struct {
+	Info map[string]func(*buffer.Buffer) string
+
+	win *BufWindow
+}
+
+var statusInfo = map[string]func(*buffer.Buffer) string{
+	"filename": func(b *buffer.Buffer) string {
+		if b.Settings["basename"].(bool) {
+			return path.Base(b.GetName())
+		}
+		return b.GetName()
+	},
+	"line": func(b *buffer.Buffer) string {
+		return strconv.Itoa(b.GetActiveCursor().Y + 1)
+	},
+	"col": func(b *buffer.Buffer) string {
+		return strconv.Itoa(b.GetActiveCursor().X + 1)
+	},
+	"modified": func(b *buffer.Buffer) string {
+		if b.Modified() {
+			return "+ "
+		}
+		return ""
+	},
+}
+
+func SetStatusInfoFnLua(s string, fn string) {
+	luaFn := strings.Split(fn, ".")
+	if len(luaFn) <= 1 {
+		return
+	}
+	plName, plFn := luaFn[0], luaFn[1]
+	pl := config.FindPlugin(plName)
+	if pl == nil {
+		return
+	}
+	statusInfo[s] = func(b *buffer.Buffer) string {
+		if pl == nil || !pl.IsEnabled() {
+			return ""
+		}
+		val, err := pl.Call(plFn, luar.New(ulua.L, b))
+		if err == nil {
+			if v, ok := val.(lua.LString); !ok {
+				screen.TermMessage(plFn, "should return a string")
+				return ""
+			} else {
+				return string(v)
+			}
+		}
+		return ""
+	}
+}
+
+// NewStatusLine returns a statusline bound to a window
+func NewStatusLine(win *BufWindow) *StatusLine {
+	s := new(StatusLine)
+	s.win = win
+	return s
+}
+
+// FindOpt finds a given option in the current buffer's settings
+func (s *StatusLine) FindOpt(opt string) interface{} {
+	if val, ok := s.win.Buf.Settings[opt]; ok {
+		return val
+	}
+	return "null"
+}
+
+var formatParser = regexp.MustCompile(`\$\(.+?\)`)
+
+// Display draws the statusline to the screen
+func (s *StatusLine) Display() {
+	// We'll draw the line at the lowest line in the window
+	y := s.win.Height + s.win.Y - 1
+
+	b := s.win.Buf
+	// autocomplete suggestions (for the buffer, not for the infowindow)
+	if b.HasSuggestions && len(b.Suggestions) > 1 {
+		statusLineStyle := config.DefStyle.Reverse(true)
+		if style, ok := config.Colorscheme["statusline"]; ok {
+			statusLineStyle = style
+		}
+		keymenuOffset := 0
+		if config.GetGlobalOption("keymenu").(bool) {
+			keymenuOffset = len(keydisplay)
+		}
+		x := 0
+		for j, sug := range b.Suggestions {
+			style := statusLineStyle
+			if b.CurSuggestion == j {
+				style = style.Reverse(true)
+			}
+			for _, r := range sug {
+				screen.Screen.SetContent(x, y-keymenuOffset, r, nil, style)
+				x++
+				if x >= s.win.Width {
+					return
+				}
+			}
+			screen.Screen.SetContent(x, y-keymenuOffset, ' ', nil, statusLineStyle)
+			x++
+			if x >= s.win.Width {
+				return
+			}
+		}
+
+		for x < s.win.Width {
+			screen.Screen.SetContent(x, y-keymenuOffset, ' ', nil, statusLineStyle)
+			x++
+		}
+		return
+	}
+
+	formatter := func(match []byte) []byte {
+		name := match[2 : len(match)-1]
+		if bytes.HasPrefix(name, []byte("opt")) {
+			option := name[4:]
+			return []byte(fmt.Sprint(s.FindOpt(string(option))))
+		} else if bytes.HasPrefix(name, []byte("bind")) {
+			binding := string(name[5:])
+			for k, v := range config.Bindings {
+				if v == binding {
+					return []byte(k)
+				}
+			}
+			return []byte("null")
+		} else {
+			if fn, ok := statusInfo[string(name)]; ok {
+				return []byte(fn(s.win.Buf))
+			}
+			return []byte{}
+		}
+	}
+
+	leftText := []byte(s.win.Buf.Settings["statusformatl"].(string))
+	leftText = formatParser.ReplaceAllFunc(leftText, formatter)
+	rightText := []byte(s.win.Buf.Settings["statusformatr"].(string))
+	rightText = formatParser.ReplaceAllFunc(rightText, formatter)
+
+	statusLineStyle := config.DefStyle.Reverse(true)
+	if style, ok := config.Colorscheme["statusline"]; ok {
+		statusLineStyle = style
+	}
+
+	leftLen := util.StringWidth(leftText, utf8.RuneCount(leftText), 1)
+	rightLen := util.StringWidth(rightText, utf8.RuneCount(rightText), 1)
+
+	winX := s.win.X
+	for x := 0; x < s.win.Width; x++ {
+		if x < leftLen {
+			r, size := utf8.DecodeRune(leftText)
+			leftText = leftText[size:]
+			rw := runewidth.RuneWidth(r)
+			for j := 0; j < rw; j++ {
+				c := r
+				if j > 0 {
+					c = ' '
+					x++
+				}
+				screen.Screen.SetContent(winX+x, y, c, nil, statusLineStyle)
+			}
+		} else if x >= s.win.Width-rightLen && x < rightLen+s.win.Width-rightLen {
+			r, size := utf8.DecodeRune(rightText)
+			rightText = rightText[size:]
+			rw := runewidth.RuneWidth(r)
+			for j := 0; j < rw; j++ {
+				c := r
+				if j > 0 {
+					c = ' '
+					x++
+				}
+				screen.Screen.SetContent(winX+x, y, c, nil, statusLineStyle)
+			}
+		} else {
+			screen.Screen.SetContent(winX+x, y, ' ', nil, statusLineStyle)
+		}
+	}
+}

internal/display/tabwindow.go

@@ -0,0 +1,133 @@
+package display
+
+import (
+	"unicode/utf8"
+
+	runewidth "github.com/mattn/go-runewidth"
+	"github.com/zyedidia/micro/internal/buffer"
+	"github.com/zyedidia/micro/internal/config"
+	"github.com/zyedidia/micro/internal/screen"
+	"github.com/zyedidia/micro/internal/util"
+)
+
+type TabWindow struct {
+	Names   []string
+	active  int
+	Y       int
+	width   int
+	hscroll int
+}
+
+func NewTabWindow(w int, y int) *TabWindow {
+	tw := new(TabWindow)
+	tw.width = w
+	tw.Y = y
+	return tw
+}
+
+func (w *TabWindow) LocFromVisual(vloc buffer.Loc) int {
+	x := -w.hscroll
+
+	for i, n := range w.Names {
+		x++
+		s := utf8.RuneCountInString(n)
+		if vloc.Y == w.Y && vloc.X < x+s {
+			return i
+		}
+		x += s
+		x += 3
+		if x >= w.width {
+			break
+		}
+	}
+	return -1
+}
+
+func (w *TabWindow) Scroll(amt int) {
+	w.hscroll += amt
+	w.hscroll = util.Clamp(w.hscroll, 0, w.TotalSize()-w.width)
+}
+
+func (w *TabWindow) TotalSize() int {
+	sum := 2
+	for _, n := range w.Names {
+		sum += utf8.RuneCountInString(n) + 4
+	}
+	return sum - 4
+}
+
+func (w *TabWindow) Active() int {
+	return w.active
+}
+
+func (w *TabWindow) SetActive(a int) {
+	w.active = a
+	x := 2
+	s := w.TotalSize()
+	for i, n := range w.Names {
+		c := utf8.RuneCountInString(n)
+		if i == a {
+			if x+c >= w.hscroll+w.width {
+				w.hscroll = util.Clamp(x+c+1-w.width, 0, s-w.width)
+			} else if x < w.hscroll {
+				w.hscroll = util.Clamp(x-4, 0, s-w.width)
+			}
+			break
+		}
+		x += c + 4
+	}
+}
+
+func (w *TabWindow) Display() {
+	x := -w.hscroll
+	done := false
+
+	draw := func(r rune, n int) {
+		for i := 0; i < n; i++ {
+			rw := runewidth.RuneWidth(r)
+			for j := 0; j < rw; j++ {
+				c := r
+				if j > 0 {
+					c = ' '
+				}
+				if x == w.width-1 && !done {
+					screen.Screen.SetContent(w.width-1, w.Y, '>', nil, config.DefStyle.Reverse(true))
+					x++
+					break
+				} else if x == 0 && w.hscroll > 0 {
+					screen.Screen.SetContent(0, w.Y, '<', nil, config.DefStyle.Reverse(true))
+				} else if x >= 0 && x < w.width {
+					screen.Screen.SetContent(x, w.Y, c, nil, config.DefStyle.Reverse(true))
+				}
+				x++
+			}
+		}
+	}
+
+	for i, n := range w.Names {
+		if i == w.active {
+			draw('[', 1)
+		} else {
+			draw(' ', 1)
+		}
+		for _, c := range n {
+			draw(c, 1)
+		}
+		if i == len(w.Names)-1 {
+			done = true
+		}
+		if i == w.active {
+			draw(']', 1)
+			draw(' ', 2)
+		} else {
+			draw(' ', 3)
+		}
+		if x >= w.width {
+			break
+		}
+	}
+
+	if x < w.width {
+		draw(' ', w.width-x)
+	}
+}

internal/display/termwindow.go

@@ -0,0 +1,116 @@
+package display
+
+import (
+	"unicode/utf8"
+
+	"github.com/zyedidia/micro/internal/buffer"
+	"github.com/zyedidia/micro/internal/config"
+	"github.com/zyedidia/micro/internal/screen"
+	"github.com/zyedidia/micro/internal/shell"
+	"github.com/zyedidia/tcell"
+	"github.com/zyedidia/terminal"
+)
+
+type TermWindow struct {
+	*View
+	*shell.Terminal
+
+	active bool
+}
+
+func NewTermWindow(x, y, w, h int, term *shell.Terminal) *TermWindow {
+	tw := new(TermWindow)
+	tw.View = new(View)
+	tw.Terminal = term
+	tw.X, tw.Y = x, y
+	tw.Resize(w, h)
+	return tw
+}
+
+// Resize informs the terminal of a resize event
+func (w *TermWindow) Resize(width, height int) {
+	if config.GetGlobalOption("statusline").(bool) {
+		height--
+	}
+	w.Term.Resize(width, height)
+	w.Width, w.Height = width, height
+}
+
+func (w *TermWindow) SetActive(b bool) {
+	w.active = b
+}
+
+func (w *TermWindow) IsActive() bool {
+	return w.active
+}
+
+func (w *TermWindow) LocFromVisual(vloc buffer.Loc) buffer.Loc {
+	return vloc
+}
+
+func (w *TermWindow) Clear() {
+	for y := 0; y < w.Height; y++ {
+		for x := 0; x < w.Width; x++ {
+			screen.Screen.SetContent(w.X+x, w.Y+y, ' ', nil, config.DefStyle)
+		}
+	}
+}
+
+func (w *TermWindow) Relocate() bool { return true }
+func (w *TermWindow) GetView() *View {
+	return w.View
+}
+func (w *TermWindow) SetView(v *View) {
+	w.View = v
+}
+
+// Display displays this terminal in a view
+func (w *TermWindow) Display() {
+	w.State.Lock()
+	defer w.State.Unlock()
+
+	var l buffer.Loc
+	for y := 0; y < w.Height; y++ {
+		for x := 0; x < w.Width; x++ {
+			l.X, l.Y = x, y
+			c, f, b := w.State.Cell(x, y)
+
+			fg, bg := int(f), int(b)
+			if f == terminal.DefaultFG {
+				fg = int(tcell.ColorDefault)
+			}
+			if b == terminal.DefaultBG {
+				bg = int(tcell.ColorDefault)
+			}
+			st := tcell.StyleDefault.Foreground(config.GetColor256(int(fg))).Background(config.GetColor256(int(bg)))
+
+			if l.LessThan(w.Selection[1]) && l.GreaterEqual(w.Selection[0]) || l.LessThan(w.Selection[0]) && l.GreaterEqual(w.Selection[1]) {
+				st = st.Reverse(true)
+			}
+
+			screen.Screen.SetContent(w.X+x, w.Y+y, c, nil, st)
+		}
+	}
+	if config.GetGlobalOption("statusline").(bool) {
+		statusLineStyle := config.DefStyle.Reverse(true)
+		if style, ok := config.Colorscheme["statusline"]; ok {
+			statusLineStyle = style
+		}
+
+		text := []byte(w.Name())
+		textLen := utf8.RuneCount(text)
+		for x := 0; x < w.Width; x++ {
+			if x < textLen {
+				r, size := utf8.DecodeRune(text)
+				text = text[size:]
+				screen.Screen.SetContent(w.X+x, w.Y+w.Height, r, nil, statusLineStyle)
+			} else {
+				screen.Screen.SetContent(w.X+x, w.Y+w.Height, ' ', nil, statusLineStyle)
+			}
+		}
+	}
+	if w.State.CursorVisible() && w.active {
+		curx, cury := w.State.Cursor()
+		screen.Screen.ShowCursor(curx+w.X, cury+w.Y)
+	}
+}

internal/display/uiwindow.go

@@ -0,0 +1,74 @@
+package display
+
+import (
+	"github.com/zyedidia/micro/internal/buffer"
+	"github.com/zyedidia/micro/internal/config"
+	"github.com/zyedidia/micro/internal/screen"
+	"github.com/zyedidia/micro/internal/views"
+)
+
+type UIWindow struct {
+	root *views.Node
+}
+
+func NewUIWindow(n *views.Node) *UIWindow {
+	uw := new(UIWindow)
+	uw.root = n
+	return uw
+}
+
+func (w *UIWindow) drawNode(n *views.Node) {
+	cs := n.Children()
+	dividerStyle := config.DefStyle
+	if style, ok := config.Colorscheme["divider"]; ok {
+		dividerStyle = style
+	}
+
+	for i, c := range cs {
+		if c.IsLeaf() && c.Kind == views.STVert {
+			if i != len(cs)-1 {
+				for h := 0; h < c.H; h++ {
+					screen.Screen.SetContent(c.X+c.W, c.Y+h, '|', nil, dividerStyle.Reverse(true))
+				}
+			}
+		} else {
+			w.drawNode(c)
+		}
+	}
+}
+
+func (w *UIWindow) Display() {
+	w.drawNode(w.root)
+}
+
+func (w *UIWindow) GetMouseSplitID(vloc buffer.Loc) uint64 {
+	var mouseLoc func(*views.Node) uint64
+	mouseLoc = func(n *views.Node) uint64 {
+		cs := n.Children()
+		for i, c := range cs {
+			if c.Kind == views.STVert {
+				if i != len(cs)-1 {
+					if vloc.X == c.X+c.W && vloc.Y >= c.Y && vloc.Y < c.Y+c.H {
+						return c.ID()
+					}
+				}
+			} else if c.Kind == views.STHoriz {
+				if i != len(cs)-1 {
+					if vloc.Y == c.Y+c.H-1 && vloc.X >= c.X && vloc.X < c.X+c.W {
+						return c.ID()
+					}
+				}
+			}
+		}
+		for _, c := range cs {
+			m := mouseLoc(c)
+			if m != 0 {
+				return m
+			}
+		}
+		return 0
+	}
+	return mouseLoc(w.root)
+}
+func (w *UIWindow) Resize(width, height int) {}
+func (w *UIWindow) SetActive(b bool)         {}

internal/display/window.go

@@ -0,0 +1,32 @@
+package display
+
+import (
+	"github.com/zyedidia/micro/internal/buffer"
+)
+
+type View struct {
+	X, Y          int // X,Y location of the view
+	Width, Height int // Width and height of the view
+
+	// Start line and start column of the view (vertical/horizontal scroll)
+	// note that since the starting column of every line is different if the view
+	// is scrolled, StartCol is a visual index (will be the same for every line)
+	StartLine, StartCol int
+}
+
+type Window interface {
+	Display()
+	Clear()
+	Relocate() bool
+	GetView() *View
+	SetView(v *View)
+	LocFromVisual(vloc buffer.Loc) buffer.Loc
+	Resize(w, h int)
+	SetActive(b bool)
+	IsActive() bool
+}
+
+type BWindow interface {
+	Window
+	SetBuffer(b *buffer.Buffer)
+}

internal/info/gutter.go

@@ -0,0 +1,18 @@
+package info
+
+// A GutterMessage is a message displayed on the side of the editor
+type GutterMessage struct {
+	lineNum int
+	msg     string
+	kind    int
+}
+
+// These are the different types of messages
+const (
+	// GutterInfo represents a simple info message
+	GutterInfo = iota
+	// GutterWarning represents a compiler warning
+	GutterWarning
+	// GutterError represents a compiler error
+	GutterError
+)

internal/info/history.go

@@ -0,0 +1,79 @@
+package info
+
+import (
+	"encoding/gob"
+	"os"
+
+	"github.com/zyedidia/micro/internal/config"
+)
+
+// LoadHistory attempts to load user history from configDir/buffers/history
+// into the history map
+// The savehistory option must be on
+func (i *InfoBuf) LoadHistory() {
+	if config.GetGlobalOption("savehistory").(bool) {
+		file, err := os.Open(config.ConfigDir + "/buffers/history")
+		defer file.Close()
+		var decodedMap map[string][]string
+		if err == nil {
+			decoder := gob.NewDecoder(file)
+			err = decoder.Decode(&decodedMap)
+
+			if err != nil {
+				i.Error("Error loading history:", err)
+				return
+			}
+		}
+
+		if decodedMap != nil {
+			i.History = decodedMap
+		} else {
+			i.History = make(map[string][]string)
+		}
+	} else {
+		i.History = make(map[string][]string)
+	}
+}
+
+// SaveHistory saves the user's command history to configDir/buffers/history
+// only if the savehistory option is on
+func (i *InfoBuf) SaveHistory() {
+	if config.GetGlobalOption("savehistory").(bool) {
+		// Don't save history past 100
+		for k, v := range i.History {
+			if len(v) > 100 {
+				i.History[k] = v[len(i.History[k])-100:]
+			}
+		}
+
+		file, err := os.Create(config.ConfigDir + "/buffers/history")
+		defer file.Close()
+		if err == nil {
+			encoder := gob.NewEncoder(file)
+
+			err = encoder.Encode(i.History)
+			if err != nil {
+				i.Error("Error saving history:", err)
+				return
+			}
+		}
+	}
+}
+
+// UpHistory fetches the previous item in the history
+func (i *InfoBuf) UpHistory(history []string) {
+	if i.HistoryNum > 0 && i.HasPrompt && !i.HasYN {
+		i.HistoryNum--
+		i.Replace(i.Start(), i.End(), history[i.HistoryNum])
+		i.Buffer.GetActiveCursor().GotoLoc(i.End())
+	}
+}
+
+// DownHistory fetches the next item in the history
+func (i *InfoBuf) DownHistory(history []string) {
+	if i.HistoryNum < len(history)-1 && i.HasPrompt && !i.HasYN {
+		i.HistoryNum++
+		i.Replace(i.Start(), i.End(), history[i.HistoryNum])
+		i.Buffer.GetActiveCursor().GotoLoc(i.End())
+	}
+}

internal/info/infobuffer.go

@@ -0,0 +1,226 @@
+package info
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/zyedidia/micro/internal/buffer"
+	luar "layeh.com/gopher-luar"
+
+	"github.com/zyedidia/micro/internal/config"
+	ulua "github.com/zyedidia/micro/internal/lua"
+	"github.com/zyedidia/micro/internal/screen"
+)
+
+// The InfoBuf displays messages and other info at the bottom of the screen.
+// It is respresented as a buffer and a message with a style.
+type InfoBuf struct {
+	*buffer.Buffer
+
+	HasPrompt  bool
+	HasMessage bool
+	HasError   bool
+	HasYN      bool
+
+	PromptType string
+
+	Msg    string
+	YNResp bool
+
+	// This map stores the history for all the different kinds of uses Prompt has
+	// It's a map of history type -> history array
+	History    map[string][]string
+	HistoryNum int
+
+	// Is the current message a message from the gutter
+	HasGutter bool
+
+	PromptCallback func(resp string, canceled bool)
+	EventCallback  func(resp string)
+	YNCallback     func(yes bool, canceled bool)
+}
+
+// NewBuffer returns a new infobuffer
+func NewBuffer() *InfoBuf {
+	ib := new(InfoBuf)
+	ib.History = make(map[string][]string)
+
+	ib.Buffer = buffer.NewBufferFromString("", "", buffer.BTInfo)
+	ib.LoadHistory()
+
+	return ib
+}
+
+// Close performs any cleanup necessary when shutting down the infobuffer
+func (i *InfoBuf) Close() {
+	i.SaveHistory()
+}
+
+// Message sends a message to the user
+func (i *InfoBuf) Message(msg ...interface{}) {
+	// only display a new message if there isn't an active prompt
+	// this is to prevent overwriting an existing prompt to the user
+	if i.HasPrompt == false {
+		displayMessage := fmt.Sprint(msg...)
+		// if there is no active prompt then style and display the message as normal
+		i.Msg = displayMessage
+		i.HasMessage, i.HasError = true, false
+	}
+}
+
+// GutterMessage displays a message and marks it as a gutter message
+func (i *InfoBuf) GutterMessage(msg ...interface{}) {
+	i.Message(msg...)
+	i.HasGutter = true
+}
+
+// ClearGutter clears the info bar and unmarks the message
+func (i *InfoBuf) ClearGutter() {
+	i.HasGutter = false
+	i.Message("")
+}
+
+// Error sends an error message to the user
+func (i *InfoBuf) Error(msg ...interface{}) {
+	// only display a new message if there isn't an active prompt
+	// this is to prevent overwriting an existing prompt to the user
+	if i.HasPrompt == false {
+		// if there is no active prompt then style and display the message as normal
+		i.Msg = fmt.Sprint(msg...)
+		i.HasMessage, i.HasError = false, true
+	}
+	// TODO: add to log?
+}
+
+// Prompt starts a prompt for the user, it takes a prompt, a possibly partially filled in msg
+// and callbacks executed when the user executes an event and when the user finishes the prompt
+// The eventcb passes the current user response as the argument and donecb passes the user's message
+// and a boolean indicating if the prompt was canceled
+func (i *InfoBuf) Prompt(prompt string, msg string, ptype string, eventcb func(string), donecb func(string, bool)) {
+	// If we get another prompt mid-prompt we cancel the one getting overwritten
+	if i.HasPrompt {
+		i.DonePrompt(true)
+	}
+
+	if _, ok := i.History[ptype]; !ok {
+		i.History[ptype] = []string{""}
+	} else {
+		i.History[ptype] = append(i.History[ptype], "")
+	}
+	i.HistoryNum = len(i.History[ptype]) - 1
+
+	i.PromptType = ptype
+	i.Msg = prompt
+	i.HasPrompt = true
+	i.HasMessage, i.HasError, i.HasYN = false, false, false
+	i.HasGutter = false
+	i.PromptCallback = donecb
+	i.EventCallback = eventcb
+	i.Buffer.Insert(i.Buffer.Start(), msg)
+}
+
+// YNPrompt creates a yes or no prompt, and the callback returns the yes/no result and whether
+// the prompt was canceled
+func (i *InfoBuf) YNPrompt(prompt string, donecb func(bool, bool)) {
+	if i.HasPrompt {
+		i.DonePrompt(true)
+	}
+
+	i.Msg = prompt
+	i.HasPrompt = true
+	i.HasYN = true
+	i.HasMessage, i.HasError = false, false
+	i.HasGutter = false
+	i.YNCallback = donecb
+}
+
+// PlugPrompt provides a plugin interface for calling "Prompt" with the appropriate Lua callbacks
+func (i *InfoBuf) PlugPrompt(prompt string, msg string, ptype string, eventcb string, donecb string) {
+	eventLuaFn := strings.Split(eventcb, ".")
+	doneLuaFn := strings.Split(donecb, ".")
+	var luaEventcb func(string)
+	var luaDonecb func(string, bool)
+
+	if len(eventLuaFn) == 2 {
+		plName, plFn := doneLuaFn[0], doneLuaFn[1]
+		pl := config.FindPlugin(plName)
+		if pl != nil {
+			luaEventcb = func(resp string) {
+				_, err := pl.Call(plFn, luar.New(ulua.L, resp))
+				if err != nil && err != config.ErrNoSuchFunction {
+					screen.TermMessage(err)
+				}
+			}
+		}
+	}
+
+	if len(doneLuaFn) == 2 {
+		plName, plFn := doneLuaFn[0], doneLuaFn[1]
+		pl := config.FindPlugin(plName)
+		if pl != nil {
+			luaDonecb = func(resp string, canceled bool) {
+				_, err := pl.Call(plFn, luar.New(ulua.L, resp), luar.New(ulua.L, canceled))
+				if err != nil && err != config.ErrNoSuchFunction {
+					screen.TermMessage(err)
+				}
+			}
+		}
+	}
+
+	i.Prompt(prompt, msg, ptype, luaEventcb, luaDonecb)
+}
+
+// PlugYNPrompt provides a plugin interface for calling "YNPrompt" with the appropriate Lua callbacks
+func (i *InfoBuf) PlugYNPrompt(prompt string, donecb string) {
+	doneLuaFn := strings.Split(donecb, ".")
+	var luaDonecb func(bool, bool)
+
+	if len(doneLuaFn) == 2 {
+		plName, plFn := doneLuaFn[0], doneLuaFn[1]
+		pl := config.FindPlugin(plName)
+		if pl != nil {
+			luaDonecb = func(resp bool, canceled bool) {
+				_, err := pl.Call(plFn, luar.New(ulua.L, resp), luar.New(ulua.L, canceled))
+				if err != nil && err != config.ErrNoSuchFunction {
+					screen.TermMessage(err)
+				}
+			}
+		}
+	}
+
+	i.YNPrompt(prompt, luaDonecb)
+}
+
+// DonePrompt finishes the current prompt and indicates whether or not it was canceled
+func (i *InfoBuf) DonePrompt(canceled bool) {
+	hadYN := i.HasYN
+	i.HasPrompt = false
+	i.HasYN = false
+	i.HasGutter = false
+	if !hadYN {
+		if i.PromptCallback != nil {
+			if canceled {
+				i.PromptCallback("", true)
+				h := i.History[i.PromptType]
+				i.History[i.PromptType] = h[:len(h)-1]
+			} else {
+				resp := string(i.LineBytes(0))
+				i.PromptCallback(resp, false)
+				h := i.History[i.PromptType]
+				h[len(h)-1] = resp
+			}
+			i.PromptCallback = nil
+		}
+		i.Replace(i.Start(), i.End(), "")
+	}
+	if i.YNCallback != nil && hadYN {
+		i.YNCallback(i.YNResp, canceled)
+	}
+}
+
+// Reset resets the infobuffer's msg and info
+func (i *InfoBuf) Reset() {
+	i.Msg = ""
+	i.HasPrompt, i.HasMessage, i.HasError = false, false, false
+	i.HasGutter = false
+}

internal/lua/lua.go

@@ -0,0 +1,558 @@
+package lua
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"math"
+	"math/rand"
+	"net"
+	"os"
+	"path"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"time"
+	"unicode/utf8"
+
+	lua "github.com/yuin/gopher-lua"
+	luar "layeh.com/gopher-luar"
+)
+
+var L *lua.LState
+
+// LoadFile loads a lua file
+func LoadFile(module string, file string, data []byte) error {
+	pluginDef := []byte("module(\"" + module + "\", package.seeall)")
+
+	if fn, err := L.Load(bytes.NewReader(append(pluginDef, data...)), file); err != nil {
+		return err
+	} else {
+		L.Push(fn)
+		return L.PCall(0, lua.MultRet, nil)
+	}
+}
+
+// Import allows a lua plugin to import a package
+func Import(pkg string) *lua.LTable {
+	switch pkg {
+	case "fmt":
+		return importFmt()
+	case "io":
+		return importIo()
+	case "io/ioutil", "ioutil":
+		return importIoUtil()
+	case "net":
+		return importNet()
+	case "math":
+		return importMath()
+	case "math/rand":
+		return importMathRand()
+	case "os":
+		return importOs()
+	case "runtime":
+		return importRuntime()
+	case "path":
+		return importPath()
+	case "path/filepath", "filepath":
+		return importFilePath()
+	case "strings":
+		return importStrings()
+	case "regexp":
+		return importRegexp()
+	case "errors":
+		return importErrors()
+	case "time":
+		return importTime()
+	case "unicode/utf8", "utf8":
+		return importUtf8()
+	default:
+		return nil
+	}
+}
+
+func importFmt() *lua.LTable {
+	pkg := L.NewTable()
+
+	L.SetField(pkg, "Errorf", luar.New(L, fmt.Errorf))
+	L.SetField(pkg, "Fprint", luar.New(L, fmt.Fprint))
+	L.SetField(pkg, "Fprintf", luar.New(L, fmt.Fprintf))
+	L.SetField(pkg, "Fprintln", luar.New(L, fmt.Fprintln))
+	L.SetField(pkg, "Fscan", luar.New(L, fmt.Fscan))
+	L.SetField(pkg, "Fscanf", luar.New(L, fmt.Fscanf))
+	L.SetField(pkg, "Fscanln", luar.New(L, fmt.Fscanln))
+	L.SetField(pkg, "Print", luar.New(L, fmt.Print))
+	L.SetField(pkg, "Printf", luar.New(L, fmt.Printf))
+	L.SetField(pkg, "Println", luar.New(L, fmt.Println))
+	L.SetField(pkg, "Scan", luar.New(L, fmt.Scan))
+	L.SetField(pkg, "Scanf", luar.New(L, fmt.Scanf))
+	L.SetField(pkg, "Scanln", luar.New(L, fmt.Scanln))
+	L.SetField(pkg, "Sprint", luar.New(L, fmt.Sprint))
+	L.SetField(pkg, "Sprintf", luar.New(L, fmt.Sprintf))
+	L.SetField(pkg, "Sprintln", luar.New(L, fmt.Sprintln))
+	L.SetField(pkg, "Sscan", luar.New(L, fmt.Sscan))
+	L.SetField(pkg, "Sscanf", luar.New(L, fmt.Sscanf))
+	L.SetField(pkg, "Sscanln", luar.New(L, fmt.Sscanln))
+
+	return pkg
+}
+
+func importIo() *lua.LTable {
+	pkg := L.NewTable()
+
+	L.SetField(pkg, "Copy", luar.New(L, io.Copy))
+	L.SetField(pkg, "CopyN", luar.New(L, io.CopyN))
+	L.SetField(pkg, "EOF", luar.New(L, io.EOF))
+	L.SetField(pkg, "ErrClosedPipe", luar.New(L, io.ErrClosedPipe))
+	L.SetField(pkg, "ErrNoProgress", luar.New(L, io.ErrNoProgress))
+	L.SetField(pkg, "ErrShortBuffer", luar.New(L, io.ErrShortBuffer))
+	L.SetField(pkg, "ErrShortWrite", luar.New(L, io.ErrShortWrite))
+	L.SetField(pkg, "ErrUnexpectedEOF", luar.New(L, io.ErrUnexpectedEOF))
+	L.SetField(pkg, "LimitReader", luar.New(L, io.LimitReader))
+	L.SetField(pkg, "MultiReader", luar.New(L, io.MultiReader))
+	L.SetField(pkg, "MultiWriter", luar.New(L, io.MultiWriter))
+	L.SetField(pkg, "NewSectionReader", luar.New(L, io.NewSectionReader))
+	L.SetField(pkg, "Pipe", luar.New(L, io.Pipe))
+	L.SetField(pkg, "ReadAtLeast", luar.New(L, io.ReadAtLeast))
+	L.SetField(pkg, "ReadFull", luar.New(L, io.ReadFull))
+	L.SetField(pkg, "TeeReader", luar.New(L, io.TeeReader))
+	L.SetField(pkg, "WriteString", luar.New(L, io.WriteString))
+
+	return pkg
+}
+
+func importIoUtil() *lua.LTable {
+	pkg := L.NewTable()
+
+	L.SetField(pkg, "ReadAll", luar.New(L, ioutil.ReadAll))
+	L.SetField(pkg, "ReadDir", luar.New(L, ioutil.ReadDir))
+	L.SetField(pkg, "ReadFile", luar.New(L, ioutil.ReadFile))
+	L.SetField(pkg, "WriteFile", luar.New(L, ioutil.WriteFile))
+
+	return pkg
+}
+
+func importNet() *lua.LTable {
+	pkg := L.NewTable()
+
+	L.SetField(pkg, "CIDRMask", luar.New(L, net.CIDRMask))
+	L.SetField(pkg, "Dial", luar.New(L, net.Dial))
+	L.SetField(pkg, "DialIP", luar.New(L, net.DialIP))
+	L.SetField(pkg, "DialTCP", luar.New(L, net.DialTCP))
+	L.SetField(pkg, "DialTimeout", luar.New(L, net.DialTimeout))
+	L.SetField(pkg, "DialUDP", luar.New(L, net.DialUDP))
+	L.SetField(pkg, "DialUnix", luar.New(L, net.DialUnix))
+	L.SetField(pkg, "ErrWriteToConnected", luar.New(L, net.ErrWriteToConnected))
+	L.SetField(pkg, "FileConn", luar.New(L, net.FileConn))
+	L.SetField(pkg, "FileListener", luar.New(L, net.FileListener))
+	L.SetField(pkg, "FilePacketConn", luar.New(L, net.FilePacketConn))
+	L.SetField(pkg, "FlagBroadcast", luar.New(L, net.FlagBroadcast))
+	L.SetField(pkg, "FlagLoopback", luar.New(L, net.FlagLoopback))
+	L.SetField(pkg, "FlagMulticast", luar.New(L, net.FlagMulticast))
+	L.SetField(pkg, "FlagPointToPoint", luar.New(L, net.FlagPointToPoint))
+	L.SetField(pkg, "FlagUp", luar.New(L, net.FlagUp))
+	L.SetField(pkg, "IPv4", luar.New(L, net.IPv4))
+	L.SetField(pkg, "IPv4Mask", luar.New(L, net.IPv4Mask))
+	L.SetField(pkg, "IPv4allrouter", luar.New(L, net.IPv4allrouter))
+	L.SetField(pkg, "IPv4allsys", luar.New(L, net.IPv4allsys))
+	L.SetField(pkg, "IPv4bcast", luar.New(L, net.IPv4bcast))
+	L.SetField(pkg, "IPv4len", luar.New(L, net.IPv4len))
+	L.SetField(pkg, "IPv4zero", luar.New(L, net.IPv4zero))
+	L.SetField(pkg, "IPv6interfacelocalallnodes", luar.New(L, net.IPv6interfacelocalallnodes))
+	L.SetField(pkg, "IPv6len", luar.New(L, net.IPv6len))
+	L.SetField(pkg, "IPv6linklocalallnodes", luar.New(L, net.IPv6linklocalallnodes))
+	L.SetField(pkg, "IPv6linklocalallrouters", luar.New(L, net.IPv6linklocalallrouters))
+	L.SetField(pkg, "IPv6loopback", luar.New(L, net.IPv6loopback))
+	L.SetField(pkg, "IPv6unspecified", luar.New(L, net.IPv6unspecified))
+	L.SetField(pkg, "IPv6zero", luar.New(L, net.IPv6zero))
+	L.SetField(pkg, "InterfaceAddrs", luar.New(L, net.InterfaceAddrs))
+	L.SetField(pkg, "InterfaceByIndex", luar.New(L, net.InterfaceByIndex))
+	L.SetField(pkg, "InterfaceByName", luar.New(L, net.InterfaceByName))
+	L.SetField(pkg, "Interfaces", luar.New(L, net.Interfaces))
+	L.SetField(pkg, "JoinHostPort", luar.New(L, net.JoinHostPort))
+	L.SetField(pkg, "Listen", luar.New(L, net.Listen))
+	L.SetField(pkg, "ListenIP", luar.New(L, net.ListenIP))
+	L.SetField(pkg, "ListenMulticastUDP", luar.New(L, net.ListenMulticastUDP))
+	L.SetField(pkg, "ListenPacket", luar.New(L, net.ListenPacket))
+	L.SetField(pkg, "ListenTCP", luar.New(L, net.ListenTCP))
+	L.SetField(pkg, "ListenUDP", luar.New(L, net.ListenUDP))
+	L.SetField(pkg, "ListenUnix", luar.New(L, net.ListenUnix))
+	L.SetField(pkg, "ListenUnixgram", luar.New(L, net.ListenUnixgram))
+	L.SetField(pkg, "LookupAddr", luar.New(L, net.LookupAddr))
+	L.SetField(pkg, "LookupCNAME", luar.New(L, net.LookupCNAME))
+	L.SetField(pkg, "LookupHost", luar.New(L, net.LookupHost))
+	L.SetField(pkg, "LookupIP", luar.New(L, net.LookupIP))
+	L.SetField(pkg, "LookupMX", luar.New(L, net.LookupMX))
+	L.SetField(pkg, "LookupNS", luar.New(L, net.LookupNS))
+	L.SetField(pkg, "LookupPort", luar.New(L, net.LookupPort))
+	L.SetField(pkg, "LookupSRV", luar.New(L, net.LookupSRV))
+	L.SetField(pkg, "LookupTXT", luar.New(L, net.LookupTXT))
+	L.SetField(pkg, "ParseCIDR", luar.New(L, net.ParseCIDR))
+	L.SetField(pkg, "ParseIP", luar.New(L, net.ParseIP))
+	L.SetField(pkg, "ParseMAC", luar.New(L, net.ParseMAC))
+	L.SetField(pkg, "Pipe", luar.New(L, net.Pipe))
+	L.SetField(pkg, "ResolveIPAddr", luar.New(L, net.ResolveIPAddr))
+	L.SetField(pkg, "ResolveTCPAddr", luar.New(L, net.ResolveTCPAddr))
+	L.SetField(pkg, "ResolveUDPAddr", luar.New(L, net.ResolveUDPAddr))
+	L.SetField(pkg, "ResolveUnixAddr", luar.New(L, net.ResolveUnixAddr))
+	L.SetField(pkg, "SplitHostPort", luar.New(L, net.SplitHostPort))
+
+	return pkg
+}
+
+func importMath() *lua.LTable {
+	pkg := L.NewTable()
+
+	L.SetField(pkg, "Abs", luar.New(L, math.Abs))
+	L.SetField(pkg, "Acos", luar.New(L, math.Acos))
+	L.SetField(pkg, "Acosh", luar.New(L, math.Acosh))
+	L.SetField(pkg, "Asin", luar.New(L, math.Asin))
+	L.SetField(pkg, "Asinh", luar.New(L, math.Asinh))
+	L.SetField(pkg, "Atan", luar.New(L, math.Atan))
+	L.SetField(pkg, "Atan2", luar.New(L, math.Atan2))
+	L.SetField(pkg, "Atanh", luar.New(L, math.Atanh))
+	L.SetField(pkg, "Cbrt", luar.New(L, math.Cbrt))
+	L.SetField(pkg, "Ceil", luar.New(L, math.Ceil))
+	L.SetField(pkg, "Copysign", luar.New(L, math.Copysign))
+	L.SetField(pkg, "Cos", luar.New(L, math.Cos))
+	L.SetField(pkg, "Cosh", luar.New(L, math.Cosh))
+	L.SetField(pkg, "Dim", luar.New(L, math.Dim))
+	L.SetField(pkg, "Erf", luar.New(L, math.Erf))
+	L.SetField(pkg, "Erfc", luar.New(L, math.Erfc))
+	L.SetField(pkg, "Exp", luar.New(L, math.Exp))
+	L.SetField(pkg, "Exp2", luar.New(L, math.Exp2))
+	L.SetField(pkg, "Expm1", luar.New(L, math.Expm1))
+	L.SetField(pkg, "Float32bits", luar.New(L, math.Float32bits))
+	L.SetField(pkg, "Float32frombits", luar.New(L, math.Float32frombits))
+	L.SetField(pkg, "Float64bits", luar.New(L, math.Float64bits))
+	L.SetField(pkg, "Float64frombits", luar.New(L, math.Float64frombits))
+	L.SetField(pkg, "Floor", luar.New(L, math.Floor))
+	L.SetField(pkg, "Frexp", luar.New(L, math.Frexp))
+	L.SetField(pkg, "Gamma", luar.New(L, math.Gamma))
+	L.SetField(pkg, "Hypot", luar.New(L, math.Hypot))
+	L.SetField(pkg, "Ilogb", luar.New(L, math.Ilogb))
+	L.SetField(pkg, "Inf", luar.New(L, math.Inf))
+	L.SetField(pkg, "IsInf", luar.New(L, math.IsInf))
+	L.SetField(pkg, "IsNaN", luar.New(L, math.IsNaN))
+	L.SetField(pkg, "J0", luar.New(L, math.J0))
+	L.SetField(pkg, "J1", luar.New(L, math.J1))
+	L.SetField(pkg, "Jn", luar.New(L, math.Jn))
+	L.SetField(pkg, "Ldexp", luar.New(L, math.Ldexp))
+	L.SetField(pkg, "Lgamma", luar.New(L, math.Lgamma))
+	L.SetField(pkg, "Log", luar.New(L, math.Log))
+	L.SetField(pkg, "Log10", luar.New(L, math.Log10))
+	L.SetField(pkg, "Log1p", luar.New(L, math.Log1p))
+	L.SetField(pkg, "Log2", luar.New(L, math.Log2))
+	L.SetField(pkg, "Logb", luar.New(L, math.Logb))
+	L.SetField(pkg, "Max", luar.New(L, math.Max))
+	L.SetField(pkg, "Min", luar.New(L, math.Min))
+	L.SetField(pkg, "Mod", luar.New(L, math.Mod))
+	L.SetField(pkg, "Modf", luar.New(L, math.Modf))
+	L.SetField(pkg, "NaN", luar.New(L, math.NaN))
+	L.SetField(pkg, "Nextafter", luar.New(L, math.Nextafter))
+	L.SetField(pkg, "Pow", luar.New(L, math.Pow))
+	L.SetField(pkg, "Pow10", luar.New(L, math.Pow10))
+	L.SetField(pkg, "Remainder", luar.New(L, math.Remainder))
+	L.SetField(pkg, "Signbit", luar.New(L, math.Signbit))
+	L.SetField(pkg, "Sin", luar.New(L, math.Sin))
+	L.SetField(pkg, "Sincos", luar.New(L, math.Sincos))
+	L.SetField(pkg, "Sinh", luar.New(L, math.Sinh))
+	L.SetField(pkg, "Sqrt", luar.New(L, math.Sqrt))
+	L.SetField(pkg, "Tan", luar.New(L, math.Tan))
+	L.SetField(pkg, "Tanh", luar.New(L, math.Tanh))
+	L.SetField(pkg, "Trunc", luar.New(L, math.Trunc))
+	L.SetField(pkg, "Y0", luar.New(L, math.Y0))
+	L.SetField(pkg, "Y1", luar.New(L, math.Y1))
+	L.SetField(pkg, "Yn", luar.New(L, math.Yn))
+
+	return pkg
+}
+
+func importMathRand() *lua.LTable {
+	pkg := L.NewTable()
+
+	L.SetField(pkg, "ExpFloat64", luar.New(L, rand.ExpFloat64))
+	L.SetField(pkg, "Float32", luar.New(L, rand.Float32))
+	L.SetField(pkg, "Float64", luar.New(L, rand.Float64))
+	L.SetField(pkg, "Int", luar.New(L, rand.Int))
+	L.SetField(pkg, "Int31", luar.New(L, rand.Int31))
+	L.SetField(pkg, "Int31n", luar.New(L, rand.Int31n))
+	L.SetField(pkg, "Int63", luar.New(L, rand.Int63))
+	L.SetField(pkg, "Int63n", luar.New(L, rand.Int63n))
+	L.SetField(pkg, "Intn", luar.New(L, rand.Intn))
+	L.SetField(pkg, "NormFloat64", luar.New(L, rand.NormFloat64))
+	L.SetField(pkg, "Perm", luar.New(L, rand.Perm))
+	L.SetField(pkg, "Seed", luar.New(L, rand.Seed))
+	L.SetField(pkg, "Uint32", luar.New(L, rand.Uint32))
+
+	return pkg
+}
+
+func importOs() *lua.LTable {
+	pkg := L.NewTable()
+
+	L.SetField(pkg, "Args", luar.New(L, os.Args))
+	L.SetField(pkg, "Chdir", luar.New(L, os.Chdir))
+	L.SetField(pkg, "Chmod", luar.New(L, os.Chmod))
+	L.SetField(pkg, "Chown", luar.New(L, os.Chown))
+	L.SetField(pkg, "Chtimes", luar.New(L, os.Chtimes))
+	L.SetField(pkg, "Clearenv", luar.New(L, os.Clearenv))
+	L.SetField(pkg, "Create", luar.New(L, os.Create))
+	L.SetField(pkg, "DevNull", luar.New(L, os.DevNull))
+	L.SetField(pkg, "Environ", luar.New(L, os.Environ))
+	L.SetField(pkg, "ErrExist", luar.New(L, os.ErrExist))
+	L.SetField(pkg, "ErrInvalid", luar.New(L, os.ErrInvalid))
+	L.SetField(pkg, "ErrNotExist", luar.New(L, os.ErrNotExist))
+	L.SetField(pkg, "ErrPermission", luar.New(L, os.ErrPermission))
+	L.SetField(pkg, "Exit", luar.New(L, os.Exit))
+	L.SetField(pkg, "Expand", luar.New(L, os.Expand))
+	L.SetField(pkg, "ExpandEnv", luar.New(L, os.ExpandEnv))
+	L.SetField(pkg, "FindProcess", luar.New(L, os.FindProcess))
+	L.SetField(pkg, "Getegid", luar.New(L, os.Getegid))
+	L.SetField(pkg, "Getenv", luar.New(L, os.Getenv))
+	L.SetField(pkg, "Geteuid", luar.New(L, os.Geteuid))
+	L.SetField(pkg, "Getgid", luar.New(L, os.Getgid))
+	L.SetField(pkg, "Getgroups", luar.New(L, os.Getgroups))
+	L.SetField(pkg, "Getpagesize", luar.New(L, os.Getpagesize))
+	L.SetField(pkg, "Getpid", luar.New(L, os.Getpid))
+	L.SetField(pkg, "Getuid", luar.New(L, os.Getuid))
+	L.SetField(pkg, "Getwd", luar.New(L, os.Getwd))
+	L.SetField(pkg, "Hostname", luar.New(L, os.Hostname))
+	L.SetField(pkg, "Interrupt", luar.New(L, os.Interrupt))
+	L.SetField(pkg, "IsExist", luar.New(L, os.IsExist))
+	L.SetField(pkg, "IsNotExist", luar.New(L, os.IsNotExist))
+	L.SetField(pkg, "IsPathSeparator", luar.New(L, os.IsPathSeparator))
+	L.SetField(pkg, "IsPermission", luar.New(L, os.IsPermission))
+	L.SetField(pkg, "Kill", luar.New(L, os.Kill))
+	L.SetField(pkg, "Lchown", luar.New(L, os.Lchown))
+	L.SetField(pkg, "Link", luar.New(L, os.Link))
+	L.SetField(pkg, "Lstat", luar.New(L, os.Lstat))
+	L.SetField(pkg, "Mkdir", luar.New(L, os.Mkdir))
+	L.SetField(pkg, "MkdirAll", luar.New(L, os.MkdirAll))
+	L.SetField(pkg, "ModeAppend", luar.New(L, os.ModeAppend))
+	L.SetField(pkg, "ModeCharDevice", luar.New(L, os.ModeCharDevice))
+	L.SetField(pkg, "ModeDevice", luar.New(L, os.ModeDevice))
+	L.SetField(pkg, "ModeDir", luar.New(L, os.ModeDir))
+	L.SetField(pkg, "ModeExclusive", luar.New(L, os.ModeExclusive))
+	L.SetField(pkg, "ModeNamedPipe", luar.New(L, os.ModeNamedPipe))
+	L.SetField(pkg, "ModePerm", luar.New(L, os.ModePerm))
+	L.SetField(pkg, "ModeSetgid", luar.New(L, os.ModeSetgid))
+	L.SetField(pkg, "ModeSetuid", luar.New(L, os.ModeSetuid))
+	L.SetField(pkg, "ModeSocket", luar.New(L, os.ModeSocket))
+	L.SetField(pkg, "ModeSticky", luar.New(L, os.ModeSticky))
+	L.SetField(pkg, "ModeSymlink", luar.New(L, os.ModeSymlink))
+	L.SetField(pkg, "ModeTemporary", luar.New(L, os.ModeTemporary))
+	L.SetField(pkg, "ModeType", luar.New(L, os.ModeType))
+	L.SetField(pkg, "NewFile", luar.New(L, os.NewFile))
+	L.SetField(pkg, "NewSyscallError", luar.New(L, os.NewSyscallError))
+	L.SetField(pkg, "O_APPEND", luar.New(L, os.O_APPEND))
+	L.SetField(pkg, "O_CREATE", luar.New(L, os.O_CREATE))
+	L.SetField(pkg, "O_EXCL", luar.New(L, os.O_EXCL))
+	L.SetField(pkg, "O_RDONLY", luar.New(L, os.O_RDONLY))
+	L.SetField(pkg, "O_RDWR", luar.New(L, os.O_RDWR))
+	L.SetField(pkg, "O_SYNC", luar.New(L, os.O_SYNC))
+	L.SetField(pkg, "O_TRUNC", luar.New(L, os.O_TRUNC))
+	L.SetField(pkg, "O_WRONLY", luar.New(L, os.O_WRONLY))
+	L.SetField(pkg, "Open", luar.New(L, os.Open))
+	L.SetField(pkg, "OpenFile", luar.New(L, os.OpenFile))
+	L.SetField(pkg, "PathListSeparator", luar.New(L, os.PathListSeparator))
+	L.SetField(pkg, "PathSeparator", luar.New(L, os.PathSeparator))
+	L.SetField(pkg, "Pipe", luar.New(L, os.Pipe))
+	L.SetField(pkg, "Readlink", luar.New(L, os.Readlink))
+	L.SetField(pkg, "Remove", luar.New(L, os.Remove))
+	L.SetField(pkg, "RemoveAll", luar.New(L, os.RemoveAll))
+	L.SetField(pkg, "Rename", luar.New(L, os.Rename))
+	L.SetField(pkg, "SEEK_CUR", luar.New(L, os.SEEK_CUR))
+	L.SetField(pkg, "SEEK_END", luar.New(L, os.SEEK_END))
+	L.SetField(pkg, "SEEK_SET", luar.New(L, os.SEEK_SET))
+	L.SetField(pkg, "SameFile", luar.New(L, os.SameFile))
+	L.SetField(pkg, "Setenv", luar.New(L, os.Setenv))
+	L.SetField(pkg, "StartProcess", luar.New(L, os.StartProcess))
+	L.SetField(pkg, "Stat", luar.New(L, os.Stat))
+	L.SetField(pkg, "Stderr", luar.New(L, os.Stderr))
+	L.SetField(pkg, "Stdin", luar.New(L, os.Stdin))
+	L.SetField(pkg, "Stdout", luar.New(L, os.Stdout))
+	L.SetField(pkg, "Symlink", luar.New(L, os.Symlink))
+	L.SetField(pkg, "TempDir", luar.New(L, os.TempDir))
+	L.SetField(pkg, "Truncate", luar.New(L, os.Truncate))
+
+	return pkg
+}
+
+func importRuntime() *lua.LTable {
+	pkg := L.NewTable()
+
+	L.SetField(pkg, "GC", luar.New(L, runtime.GC))
+	L.SetField(pkg, "GOARCH", luar.New(L, runtime.GOARCH))
+	L.SetField(pkg, "GOMAXPROCS", luar.New(L, runtime.GOMAXPROCS))
+	L.SetField(pkg, "GOOS", luar.New(L, runtime.GOOS))
+	L.SetField(pkg, "GOROOT", luar.New(L, runtime.GOROOT))
+
+	return pkg
+}
+
+func importPath() *lua.LTable {
+	pkg := L.NewTable()
+
+	L.SetField(pkg, "Base", luar.New(L, path.Base))
+	L.SetField(pkg, "Clean", luar.New(L, path.Clean))
+	L.SetField(pkg, "Dir", luar.New(L, path.Dir))
+	L.SetField(pkg, "ErrBadPattern", luar.New(L, path.ErrBadPattern))
+	L.SetField(pkg, "Ext", luar.New(L, path.Ext))
+	L.SetField(pkg, "IsAbs", luar.New(L, path.IsAbs))
+	L.SetField(pkg, "Join", luar.New(L, path.Join))
+	L.SetField(pkg, "Match", luar.New(L, path.Match))
+	L.SetField(pkg, "Split", luar.New(L, path.Split))
+
+	return pkg
+}
+
+func importFilePath() *lua.LTable {
+	pkg := L.NewTable()
+
+	L.SetField(pkg, "Join", luar.New(L, filepath.Join))
+	L.SetField(pkg, "Abs", luar.New(L, filepath.Abs))
+	L.SetField(pkg, "Base", luar.New(L, filepath.Base))
+	L.SetField(pkg, "Clean", luar.New(L, filepath.Clean))
+	L.SetField(pkg, "Dir", luar.New(L, filepath.Dir))
+	L.SetField(pkg, "EvalSymlinks", luar.New(L, filepath.EvalSymlinks))
+	L.SetField(pkg, "Ext", luar.New(L, filepath.Ext))
+	L.SetField(pkg, "FromSlash", luar.New(L, filepath.FromSlash))
+	L.SetField(pkg, "Glob", luar.New(L, filepath.Glob))
+	L.SetField(pkg, "HasPrefix", luar.New(L, filepath.HasPrefix))
+	L.SetField(pkg, "IsAbs", luar.New(L, filepath.IsAbs))
+	L.SetField(pkg, "Join", luar.New(L, filepath.Join))
+	L.SetField(pkg, "Match", luar.New(L, filepath.Match))
+	L.SetField(pkg, "Rel", luar.New(L, filepath.Rel))
+	L.SetField(pkg, "Split", luar.New(L, filepath.Split))
+	L.SetField(pkg, "SplitList", luar.New(L, filepath.SplitList))
+	L.SetField(pkg, "ToSlash", luar.New(L, filepath.ToSlash))
+	L.SetField(pkg, "VolumeName", luar.New(L, filepath.VolumeName))
+
+	return pkg
+}
+
+func importStrings() *lua.LTable {
+	pkg := L.NewTable()
+
+	L.SetField(pkg, "Contains", luar.New(L, strings.Contains))
+	L.SetField(pkg, "ContainsAny", luar.New(L, strings.ContainsAny))
+	L.SetField(pkg, "ContainsRune", luar.New(L, strings.ContainsRune))
+	L.SetField(pkg, "Count", luar.New(L, strings.Count))
+	L.SetField(pkg, "EqualFold", luar.New(L, strings.EqualFold))
+	L.SetField(pkg, "Fields", luar.New(L, strings.Fields))
+	L.SetField(pkg, "FieldsFunc", luar.New(L, strings.FieldsFunc))
+	L.SetField(pkg, "HasPrefix", luar.New(L, strings.HasPrefix))
+	L.SetField(pkg, "HasSuffix", luar.New(L, strings.HasSuffix))
+	L.SetField(pkg, "Index", luar.New(L, strings.Index))
+	L.SetField(pkg, "IndexAny", luar.New(L, strings.IndexAny))
+	L.SetField(pkg, "IndexByte", luar.New(L, strings.IndexByte))
+	L.SetField(pkg, "IndexFunc", luar.New(L, strings.IndexFunc))
+	L.SetField(pkg, "IndexRune", luar.New(L, strings.IndexRune))
+	L.SetField(pkg, "Join", luar.New(L, strings.Join))
+	L.SetField(pkg, "LastIndex", luar.New(L, strings.LastIndex))
+	L.SetField(pkg, "LastIndexAny", luar.New(L, strings.LastIndexAny))
+	L.SetField(pkg, "LastIndexFunc", luar.New(L, strings.LastIndexFunc))
+	L.SetField(pkg, "Map", luar.New(L, strings.Map))
+	L.SetField(pkg, "NewReader", luar.New(L, strings.NewReader))
+	L.SetField(pkg, "NewReplacer", luar.New(L, strings.NewReplacer))
+	L.SetField(pkg, "Repeat", luar.New(L, strings.Repeat))
+	L.SetField(pkg, "Replace", luar.New(L, strings.Replace))
+	L.SetField(pkg, "Split", luar.New(L, strings.Split))
+	L.SetField(pkg, "SplitAfter", luar.New(L, strings.SplitAfter))
+	L.SetField(pkg, "SplitAfterN", luar.New(L, strings.SplitAfterN))
+	L.SetField(pkg, "SplitN", luar.New(L, strings.SplitN))
+	L.SetField(pkg, "Title", luar.New(L, strings.Title))
+	L.SetField(pkg, "ToLower", luar.New(L, strings.ToLower))
+	L.SetField(pkg, "ToLowerSpecial", luar.New(L, strings.ToLowerSpecial))
+	L.SetField(pkg, "ToTitle", luar.New(L, strings.ToTitle))
+	L.SetField(pkg, "ToTitleSpecial", luar.New(L, strings.ToTitleSpecial))
+	L.SetField(pkg, "ToUpper", luar.New(L, strings.ToUpper))
+	L.SetField(pkg, "ToUpperSpecial", luar.New(L, strings.ToUpperSpecial))
+	L.SetField(pkg, "Trim", luar.New(L, strings.Trim))
+	L.SetField(pkg, "TrimFunc", luar.New(L, strings.TrimFunc))
+	L.SetField(pkg, "TrimLeft", luar.New(L, strings.TrimLeft))
+	L.SetField(pkg, "TrimLeftFunc", luar.New(L, strings.TrimLeftFunc))
+	L.SetField(pkg, "TrimPrefix", luar.New(L, strings.TrimPrefix))
+	L.SetField(pkg, "TrimRight", luar.New(L, strings.TrimRight))
+	L.SetField(pkg, "TrimRightFunc", luar.New(L, strings.TrimRightFunc))
+	L.SetField(pkg, "TrimSpace", luar.New(L, strings.TrimSpace))
+	L.SetField(pkg, "TrimSuffix", luar.New(L, strings.TrimSuffix))
+
+	return pkg
+}
+
+func importRegexp() *lua.LTable {
+	pkg := L.NewTable()
+
+	L.SetField(pkg, "Match", luar.New(L, regexp.Match))
+	L.SetField(pkg, "MatchReader", luar.New(L, regexp.MatchReader))
+	L.SetField(pkg, "MatchString", luar.New(L, regexp.MatchString))
+	L.SetField(pkg, "QuoteMeta", luar.New(L, regexp.QuoteMeta))
+	L.SetField(pkg, "Compile", luar.New(L, regexp.Compile))
+	L.SetField(pkg, "CompilePOSIX", luar.New(L, regexp.CompilePOSIX))
+	L.SetField(pkg, "MustCompile", luar.New(L, regexp.MustCompile))
+	L.SetField(pkg, "MustCompilePOSIX", luar.New(L, regexp.MustCompilePOSIX))
+
+	return pkg
+}
+
+func importErrors() *lua.LTable {
+	pkg := L.NewTable()
+
+	L.SetField(pkg, "New", luar.New(L, errors.New))
+
+	return pkg
+}
+
+func importTime() *lua.LTable {
+	pkg := L.NewTable()
+
+	L.SetField(pkg, "After", luar.New(L, time.After))
+	L.SetField(pkg, "Sleep", luar.New(L, time.Sleep))
+	L.SetField(pkg, "Tick", luar.New(L, time.Tick))
+	L.SetField(pkg, "Since", luar.New(L, time.Since))
+	L.SetField(pkg, "FixedZone", luar.New(L, time.FixedZone))
+	L.SetField(pkg, "LoadLocation", luar.New(L, time.LoadLocation))
+	L.SetField(pkg, "NewTicker", luar.New(L, time.NewTicker))
+	L.SetField(pkg, "Date", luar.New(L, time.Date))
+	L.SetField(pkg, "Now", luar.New(L, time.Now))
+	L.SetField(pkg, "Parse", luar.New(L, time.Parse))
+	L.SetField(pkg, "ParseDuration", luar.New(L, time.ParseDuration))
+	L.SetField(pkg, "ParseInLocation", luar.New(L, time.ParseInLocation))
+	L.SetField(pkg, "Unix", luar.New(L, time.Unix))
+	L.SetField(pkg, "AfterFunc", luar.New(L, time.AfterFunc))
+	L.SetField(pkg, "NewTimer", luar.New(L, time.NewTimer))
+	L.SetField(pkg, "Nanosecond", luar.New(L, time.Nanosecond))
+	L.SetField(pkg, "Microsecond", luar.New(L, time.Microsecond))
+	L.SetField(pkg, "Millisecond", luar.New(L, time.Millisecond))
+	L.SetField(pkg, "Second", luar.New(L, time.Second))
+	L.SetField(pkg, "Minute", luar.New(L, time.Minute))
+	L.SetField(pkg, "Hour", luar.New(L, time.Hour))
+
+	return pkg
+}
+
+func importUtf8() *lua.LTable {
+	pkg := L.NewTable()
+
+	L.SetField(pkg, "DecodeLastRune", luar.New(L, utf8.DecodeLastRune))
+	L.SetField(pkg, "DecodeLastRuneInString", luar.New(L, utf8.DecodeLastRuneInString))
+	L.SetField(pkg, "DecodeRune", luar.New(L, utf8.DecodeRune))
+	L.SetField(pkg, "DecodeRuneInString", luar.New(L, utf8.DecodeRuneInString))
+	L.SetField(pkg, "EncodeRune", luar.New(L, utf8.EncodeRune))
+	L.SetField(pkg, "FullRune", luar.New(L, utf8.FullRune))
+	L.SetField(pkg, "FullRuneInString", luar.New(L, utf8.FullRuneInString))
+	L.SetField(pkg, "RuneCount", luar.New(L, utf8.RuneCount))
+	L.SetField(pkg, "RuneCountInString", luar.New(L, utf8.RuneCountInString))
+	L.SetField(pkg, "RuneLen", luar.New(L, utf8.RuneLen))
+	L.SetField(pkg, "RuneStart", luar.New(L, utf8.RuneStart))
+	L.SetField(pkg, "Valid", luar.New(L, utf8.Valid))
+	L.SetField(pkg, "ValidRune", luar.New(L, utf8.ValidRune))
+	L.SetField(pkg, "ValidString", luar.New(L, utf8.ValidString))
+
+	return pkg
+}

internal/screen/message.go

@@ -0,0 +1,65 @@
+package screen
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+)
+
+// TermMessage sends a message to the user in the terminal. This usually occurs before
+// micro has been fully initialized -- ie if there is an error in the syntax highlighting
+// regular expressions
+// The function must be called when the Screen is not initialized
+// This will write the message, and wait for the user
+// to press and key to continue
+func TermMessage(msg ...interface{}) {
+	screenb := TempFini()
+
+	fmt.Println(msg...)
+	fmt.Print("\nPress enter to continue")
+
+	reader := bufio.NewReader(os.Stdin)
+	reader.ReadString('\n')
+
+	TempStart(screenb)
+}
+
+// TermPrompt prints a prompt and requests the user for a response
+// The result is matched against a list of options and the index of
+// the match is returned
+// If wait is true, the prompt re-prompts until a valid option is
+// chosen, otherwise if wait is false, -1 is returned for no match
+func TermPrompt(prompt string, options []string, wait bool) int {
+	screenb := TempFini()
+
+	idx := -1
+	// same behavior as do { ... } while (wait && idx == -1)
+	for ok := true; ok; ok = wait && idx == -1 {
+		reader := bufio.NewReader(os.Stdin)
+		fmt.Print(prompt)
+		resp, _ := reader.ReadString('\n')
+		resp = strings.TrimSpace(resp)
+
+		for i, opt := range options {
+			if resp == opt {
+				idx = i
+			}
+		}
+
+		if wait && idx == -1 {
+			fmt.Println("\nInvalid choice.")
+		}
+	}
+
+	TempStart(screenb)
+
+	return idx
+}
+
+// TermError sends an error to the user in the terminal. Like TermMessage except formatted
+// as an error
+func TermError(filename string, lineNum int, err string) {
+	TermMessage(filename + ", " + strconv.Itoa(lineNum) + ": " + err)
+}

internal/screen/screen.go

@@ -0,0 +1,110 @@
+package screen
+
+import (
+	"fmt"
+	"os"
+	"sync"
+
+	"github.com/zyedidia/micro/internal/config"
+	"github.com/zyedidia/micro/pkg/terminfo"
+	"github.com/zyedidia/tcell"
+)
+
+// Screen is the tcell screen we use to draw to the terminal
+// Synchronization is used because we poll the screen on a separate
+// thread and sometimes the screen is shut down by the main thread
+// (for example on TermMessage) so we don't want to poll a nil/shutdown
+// screen. TODO: maybe we should worry about polling and drawing at the
+// same time too.
+var Screen tcell.Screen
+var lock sync.Mutex
+var DrawChan chan bool
+
+func Lock() {
+	lock.Lock()
+}
+
+func Unlock() {
+	lock.Unlock()
+}
+
+func Redraw() {
+	DrawChan <- true
+}
+
+// TempFini shuts the screen down temporarily
+func TempFini() bool {
+	screenWasNil := Screen == nil
+
+	if !screenWasNil {
+		Screen.Fini()
+		Lock()
+		Screen = nil
+	}
+	return screenWasNil
+}
+
+// TempStart restarts the screen after it was temporarily disabled
+func TempStart(screenWasNil bool) {
+	if !screenWasNil {
+		Init()
+		Unlock()
+	}
+}
+
+// Init creates and initializes the tcell screen
+func Init() {
+	DrawChan = make(chan bool, 8)
+
+	// Should we enable true color?
+	truecolor := os.Getenv("MICRO_TRUECOLOR") == "1"
+
+	tcelldb := os.Getenv("TCELLDB")
+	os.Setenv("TCELLDB", config.ConfigDir+"/.tcelldb")
+
+	// In order to enable true color, we have to set the TERM to `xterm-truecolor` when
+	// initializing tcell, but after that, we can set the TERM back to whatever it was
+	oldTerm := os.Getenv("TERM")
+	if truecolor {
+		os.Setenv("TERM", "xterm-truecolor")
+	}
+
+	// Initilize tcell
+	var err error
+	Screen, err = tcell.NewScreen()
+	if err != nil {
+		if err == tcell.ErrTermNotFound {
+			err = terminfo.WriteDB(config.ConfigDir + "/.tcelldb")
+			if err != nil {
+				fmt.Println(err)
+				fmt.Println("Fatal: Micro could not create terminal database file", config.ConfigDir+"/.tcelldb")
+				os.Exit(1)
+			}
+			Screen, err = tcell.NewScreen()
+			if err != nil {
+				fmt.Println(err)
+				fmt.Println("Fatal: Micro could not initialize a Screen.")
+				os.Exit(1)
+			}
+		} else {
+			fmt.Println(err)
+			fmt.Println("Fatal: Micro could not initialize a Screen.")
+			os.Exit(1)
+		}
+	}
+	if err = Screen.Init(); err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+
+	// Now we can put the TERM back to what it was before
+	if truecolor {
+		os.Setenv("TERM", oldTerm)
+	}
+
+	if config.GetGlobalOption("mouse").(bool) {
+		Screen.EnableMouse()
+	}
+
+	os.Setenv("TCELLDB", tcelldb)
+}

internal/shell/job.go

@@ -0,0 +1,124 @@
+package shell
+
+import (
+	"bytes"
+	"io"
+	"os/exec"
+	"strings"
+
+	luar "layeh.com/gopher-luar"
+
+	lua "github.com/yuin/gopher-lua"
+	"github.com/zyedidia/micro/internal/config"
+	ulua "github.com/zyedidia/micro/internal/lua"
+	"github.com/zyedidia/micro/internal/screen"
+)
+
+var Jobs chan JobFunction
+
+func init() {
+	Jobs = make(chan JobFunction, 100)
+}
+
+// Jobs are the way plugins can run processes in the background
+// A job is simply a process that gets executed asynchronously
+// There are callbacks for when the job exits, when the job creates stdout
+// and when the job creates stderr
+
+// These jobs run in a separate goroutine but the lua callbacks need to be
+// executed in the main thread (where the Lua VM is running) so they are
+// put into the jobs channel which gets read by the main loop
+
+// JobFunction is a representation of a job (this data structure is what is loaded
+// into the jobs channel)
+type JobFunction struct {
+	Function func(string, ...interface{})
+	Output   string
+	Args     []interface{}
+}
+
+// A CallbackFile is the data structure that makes it possible to catch stderr and stdout write events
+type CallbackFile struct {
+	io.Writer
+
+	callback func(string, ...interface{})
+	args     []interface{}
+}
+
+func (f *CallbackFile) Write(data []byte) (int, error) {
+	// This is either stderr or stdout
+	// In either case we create a new job function callback and put it in the jobs channel
+	jobFunc := JobFunction{f.callback, string(data), f.args}
+	Jobs <- jobFunc
+	return f.Writer.Write(data)
+}
+
+// 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 ...interface{}) *exec.Cmd {
+	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 ...interface{}) *exec.Cmd {
+	// Set up everything correctly if the functions have been provided
+	proc := exec.Command(cmdName, cmdArgs...)
+	var outbuf bytes.Buffer
+	if onStdout != "" {
+		proc.Stdout = &CallbackFile{&outbuf, luaFunctionJob(onStdout), userargs}
+	} else {
+		proc.Stdout = &outbuf
+	}
+	if onStderr != "" {
+		proc.Stderr = &CallbackFile{&outbuf, luaFunctionJob(onStderr), userargs}
+	} else {
+		proc.Stderr = &outbuf
+	}
+
+	go func() {
+		// Run the process in the background and create the onExit callback
+		proc.Run()
+		jobFunc := JobFunction{luaFunctionJob(onExit), string(outbuf.Bytes()), userargs}
+		Jobs <- jobFunc
+	}()
+
+	return proc
+}
+
+// JobStop kills a job
+func JobStop(cmd *exec.Cmd) {
+	cmd.Process.Kill()
+}
+
+// JobSend sends the given data into the job's stdin stream
+func JobSend(cmd *exec.Cmd, data string) {
+	stdin, err := cmd.StdinPipe()
+	if err != nil {
+		return
+	}
+
+	stdin.Write([]byte(data))
+}
+
+// luaFunctionJob returns a function that will call the given lua function
+// structured as a job call i.e. the job output and arguments are provided
+// to the lua function
+func luaFunctionJob(fn string) func(string, ...interface{}) {
+	luaFn := strings.Split(fn, ".")
+	if len(luaFn) <= 1 {
+		return nil
+	}
+	plName, plFn := luaFn[0], luaFn[1]
+	pl := config.FindPlugin(plName)
+	if pl == nil {
+		return nil
+	}
+	return func(output string, args ...interface{}) {
+		luaArgs := []lua.LValue{luar.New(ulua.L, output), luar.New(ulua.L, args)}
+		_, err := pl.Call(plFn, luaArgs...)
+		if err != nil && err != config.ErrNoSuchFunction {
+			screen.TermMessage(err)
+		}
+	}
+}

internal/shell/shell.go

@@ -0,0 +1,130 @@
+package shell
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"os/signal"
+	"strings"
+
+	"github.com/zyedidia/micro/internal/screen"
+	"github.com/zyedidia/micro/pkg/shellwords"
+)
+
+// ExecCommand executes a command using exec
+// It returns any output/errors
+func ExecCommand(name string, arg ...string) (string, error) {
+	var err error
+	cmd := exec.Command(name, arg...)
+	outputBytes := &bytes.Buffer{}
+	cmd.Stdout = outputBytes
+	cmd.Stderr = outputBytes
+	err = cmd.Start()
+	if err != nil {
+		return "", err
+	}
+	err = cmd.Wait() // wait for command to finish
+	outstring := outputBytes.String()
+	return outstring, err
+}
+
+// RunCommand executes a shell command and returns the output/error
+func RunCommand(input string) (string, error) {
+	args, err := shellwords.Split(input)
+	if err != nil {
+		return "", err
+	}
+	inputCmd := args[0]
+
+	return ExecCommand(inputCmd, args[1:]...)
+}
+
+// RunBackgroundShell runs a shell command in the background
+// It returns a function which will run the command and returns a string
+// message result
+func RunBackgroundShell(input string) (func() string, error) {
+	args, err := shellwords.Split(input)
+	if err != nil {
+		return nil, err
+	}
+	inputCmd := args[0]
+	return func() string {
+		output, err := RunCommand(input)
+		totalLines := strings.Split(output, "\n")
+
+		str := output
+		if len(totalLines) < 3 {
+			if err == nil {
+				str = fmt.Sprint(inputCmd, " exited without error")
+			} else {
+				str = fmt.Sprint(inputCmd, " exited with error: ", err, ": ", output)
+			}
+		}
+		return str
+	}, nil
+}
+
+// RunInteractiveShell runs a shellcommand interactively
+func RunInteractiveShell(input string, wait bool, getOutput bool) (string, error) {
+	args, err := shellwords.Split(input)
+	if err != nil {
+		return "", err
+	}
+	inputCmd := args[0]
+
+	// Shut down the screen because we're going to interact directly with the shell
+	screenb := screen.TempFini()
+
+	args = args[1:]
+
+	// Set up everything for the command
+	outputBytes := &bytes.Buffer{}
+	cmd := exec.Command(inputCmd, args...)
+	cmd.Stdin = os.Stdin
+	if getOutput {
+		cmd.Stdout = io.MultiWriter(os.Stdout, outputBytes)
+	} else {
+		cmd.Stdout = os.Stdout
+	}
+	cmd.Stderr = os.Stderr
+
+	// This is a trap for Ctrl-C so that it doesn't kill micro
+	// Instead we trap Ctrl-C to kill the program we're running
+	c := make(chan os.Signal, 1)
+	signal.Notify(c, os.Interrupt)
+	go func() {
+		for range c {
+			cmd.Process.Kill()
+		}
+	}()
+
+	cmd.Start()
+	err = cmd.Wait()
+
+	output := outputBytes.String()
+
+	if wait {
+		// This is just so we don't return right away and let the user press enter to return
+		screen.TermMessage("")
+	}
+
+	// Start the screen back up
+	screen.TempStart(screenb)
+
+	return output, err
+}
+
+// UserCommand runs the shell command
+// The openTerm argument specifies whether a terminal should be opened (for viewing output
+// or interacting with stdin)
+// func UserCommand(input string, openTerm bool, waitToFinish bool) string {
+// 	if !openTerm {
+// 		RunBackgroundShell(input)
+// 		return ""
+// 	} else {
+// 		output, _ := RunInteractiveShell(input, waitToFinish, false)
+// 		return output
+// 	}
+// }

internal/shell/terminal.go

@@ -0,0 +1,157 @@
+package shell
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"os/exec"
+	"strconv"
+	"strings"
+
+	lua "github.com/yuin/gopher-lua"
+	"github.com/zyedidia/micro/internal/buffer"
+	"github.com/zyedidia/micro/internal/config"
+	ulua "github.com/zyedidia/micro/internal/lua"
+	"github.com/zyedidia/micro/internal/screen"
+	"github.com/zyedidia/terminal"
+	luar "layeh.com/gopher-luar"
+)
+
+type TermType int
+type CallbackFunc func(string)
+
+const (
+	TTClose   = iota // Should be closed
+	TTRunning        // Currently running a command
+	TTDone           // Finished running a command
+)
+
+var CloseTerms chan bool
+
+func init() {
+	CloseTerms = make(chan bool)
+}
+
+// A Terminal holds information for the terminal emulator
+type Terminal struct {
+	State     terminal.State
+	Term      *terminal.VT
+	title     string
+	Status    TermType
+	Selection [2]buffer.Loc
+	wait      bool
+	getOutput bool
+	output    *bytes.Buffer
+	callback  CallbackFunc
+}
+
+// HasSelection returns whether this terminal has a valid selection
+func (t *Terminal) HasSelection() bool {
+	return t.Selection[0] != t.Selection[1]
+}
+
+func (t *Terminal) Name() string {
+	return t.title
+}
+
+// GetSelection returns the selected text
+func (t *Terminal) GetSelection(width int) string {
+	start := t.Selection[0]
+	end := t.Selection[1]
+	if start.GreaterThan(end) {
+		start, end = end, start
+	}
+	var ret string
+	var l buffer.Loc
+	for y := start.Y; y <= end.Y; y++ {
+		for x := 0; x < width; x++ {
+			l.X, l.Y = x, y
+			if l.GreaterEqual(start) && l.LessThan(end) {
+				c, _, _ := t.State.Cell(x, y)
+				ret += string(c)
+			}
+		}
+	}
+	return ret
+}
+
+// Start begins a new command in this terminal with a given view
+func (t *Terminal) Start(execCmd []string, getOutput bool, wait bool, callback string, userargs []interface{}) error {
+	if len(execCmd) <= 0 {
+		return nil
+	}
+
+	cmd := exec.Command(execCmd[0], execCmd[1:]...)
+	t.output = nil
+	if getOutput {
+		t.output = bytes.NewBuffer([]byte{})
+	}
+	Term, _, err := terminal.Start(&t.State, cmd, t.output)
+	if err != nil {
+		return err
+	}
+	t.Term = Term
+	t.getOutput = getOutput
+	t.Status = TTRunning
+	t.title = execCmd[0] + ":" + strconv.Itoa(cmd.Process.Pid)
+	t.wait = wait
+
+	luaFn := strings.Split(callback, ".")
+	if len(luaFn) >= 2 {
+		plName, plFn := luaFn[0], luaFn[1]
+		pl := config.FindPlugin(plName)
+		if pl != nil {
+			t.callback = func(out string) {
+				luaArgs := []lua.LValue{luar.New(ulua.L, out), luar.New(ulua.L, userargs)}
+				_, err := pl.Call(plFn, luaArgs...)
+				if err != nil {
+					screen.TermMessage(err)
+				}
+			}
+		}
+	}
+
+	go func() {
+		for {
+			err := Term.Parse()
+			if err != nil {
+				fmt.Fprintln(os.Stderr, "[Press enter to close]")
+				break
+			}
+			screen.Redraw()
+		}
+		t.Stop()
+	}()
+
+	return nil
+}
+
+// Stop stops execution of the terminal and sets the Status
+// to TTDone
+func (t *Terminal) Stop() {
+	t.Term.File().Close()
+	t.Term.Close()
+	if t.wait {
+		t.Status = TTDone
+	} else {
+		t.Close()
+		CloseTerms <- true
+	}
+}
+
+// Close sets the Status to TTClose indicating that the terminal
+// is done and should be closed
+func (t *Terminal) Close() {
+	t.Status = TTClose
+	// call the lua function that the user has given as a callback
+	if t.getOutput {
+		if t.callback != nil {
+			t.callback(t.output.String())
+		}
+	}
+}
+
+// WriteString writes a given string to this terminal's pty
+func (t *Terminal) WriteString(str string) {
+	t.Term.File().WriteString(str)
+}

internal/util/lua.go

@@ -0,0 +1,41 @@
+package util
+
+import (
+	"unicode/utf8"
+)
+
+func LuaRuneAt(str string, runeidx int) string {
+	i := 0
+	for len(str) > 0 {
+		r, size := utf8.DecodeRuneInString(str)
+
+		str = str[size:]
+
+		if i == runeidx {
+			return string(r)
+		}
+
+		i++
+	}
+	return ""
+}
+
+func LuaGetLeadingWhitespace(s string) string {
+	ws := []byte{}
+	for len(s) > 0 {
+		r, size := utf8.DecodeRuneInString(s)
+		if r == ' ' || r == '\t' {
+			ws = append(ws, byte(r))
+		} else {
+			break
+		}
+
+		s = s[size:]
+	}
+	return string(ws)
+}
+
+func LuaIsWordChar(s string) bool {
+	r, _ := utf8.DecodeRuneInString(s)
+	return IsWordChar(r)
+}