Fix tcell import

.editorconfig

@@ -1,7 +0,0 @@
-# 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
-

.gitignore

@@ -1,9 +1,5 @@
-.DS_Store
-
-micro
+./micro
 !cmd/micro
 binaries/
 tmp.sh
 test/
-.idea/
-packages/

.gitmodules

@@ -1,72 +0,0 @@
-[submodule "cmd/micro/vendor/github.com/blang/semver"]
-	path = cmd/micro/vendor/github.com/blang/semver
-	url = https://github.com/blang/semver
-[submodule "cmd/micro/vendor/github.com/dustin/go-humanize"]
-	path = cmd/micro/vendor/github.com/dustin/go-humanize
-	url = https://github.com/dustin/go-humanize
-[submodule "cmd/micro/vendor/github.com/go-errors/errors"]
-	path = cmd/micro/vendor/github.com/go-errors/errors
-	url = https://github.com/go-errors/errors
-[submodule "cmd/micro/vendor/github.com/mattn/go-isatty"]
-	path = cmd/micro/vendor/github.com/mattn/go-isatty
-	url = https://github.com/mattn/go-isatty
-[submodule "cmd/micro/vendor/github.com/mattn/go-runewidth"]
-	path = cmd/micro/vendor/github.com/mattn/go-runewidth
-	url = https://github.com/mattn/go-runewidth
-[submodule "cmd/micro/vendor/github.com/mitchellh/go-homedir"]
-	path = cmd/micro/vendor/github.com/mitchellh/go-homedir
-	url = https://github.com/mitchellh/go-homedir
-[submodule "cmd/micro/vendor/github.com/sergi/go-diff"]
-	path = cmd/micro/vendor/github.com/sergi/go-diff
-	url = https://github.com/sergi/go-diff
-[submodule "cmd/micro/vendor/github.com/yuin/gopher-lua"]
-	path = cmd/micro/vendor/github.com/yuin/gopher-lua
-	url = https://github.com/yuin/gopher-lua
-[submodule "cmd/micro/vendor/golang.org/x/net"]
-	path = cmd/micro/vendor/golang.org/x/net
-	url = https://go.googlesource.com/net
-[submodule "cmd/micro/vendor/github.com/zyedidia/clipboard"]
-	path = cmd/micro/vendor/github.com/zyedidia/clipboard
-	url = https://github.com/zyedidia/clipboard
-[submodule "cmd/micro/vendor/github.com/zyedidia/glob"]
-	path = cmd/micro/vendor/github.com/zyedidia/glob
-	url = https://github.com/zyedidia/glob
-[submodule "cmd/micro/vendor/github.com/zyedidia/tcell"]
-	path = cmd/micro/vendor/github.com/zyedidia/tcell
-	url = https://github.com/zyedidia/tcell
-[submodule "cmd/micro/vendor/github.com/gdamore/encoding"]
-	path = cmd/micro/vendor/github.com/gdamore/encoding
-	url = https://github.com/gdamore/encoding
-[submodule "cmd/micro/vendor/golang.org/x/text"]
-	path = cmd/micro/vendor/golang.org/x/text
-	url = https://go.googlesource.com/text
-[submodule "cmd/micro/vendor/github.com/lucasb-eyer/go-colorful"]
-	path = cmd/micro/vendor/github.com/lucasb-eyer/go-colorful
-	url = https://github.com/lucasb-eyer/go-colorful
-[submodule "cmd/micro/vendor/layeh.com/gopher-luar"]
-	path = cmd/micro/vendor/layeh.com/gopher-luar
-	url = https://github.com/layeh/gopher-luar
-[submodule "cmd/micro/vendor/gopkg.in/yaml.v2"]
-	path = cmd/micro/vendor/gopkg.in/yaml.v2
-	url = https://gopkg.in/yaml.v2
-[submodule "cmd/micro/vendor/github.com/zyedidia/poller"]
-	path = cmd/micro/vendor/github.com/zyedidia/poller
-	url = https://github.com/zyedidia/poller
-[submodule "cmd/micro/vendor/github.com/flynn/json5"]
-	path = cmd/micro/vendor/github.com/flynn/json5
-	url = https://github.com/flynn/json5
-[submodule "cmd/micro/vendor/github.com/zyedidia/terminal"]
-	path = cmd/micro/vendor/github.com/zyedidia/terminal
-	url = https://github.com/zyedidia/terminal
-[submodule "cmd/micro/vendor/github.com/zyedidia/pty"]
-	path = cmd/micro/vendor/github.com/zyedidia/pty
-	url = https://github.com/zyedidia/pty
-[submodule "cmd/micro/vendor/github.com/smartystreets/goconvey"]
-	path = cmd/micro/vendor/github.com/smartystreets/goconvey
-	url = https://github.com/smartystreets/goconvey
-[submodule "cmd/micro/vendor/github.com/jtolds/gls"]
-	path = cmd/micro/vendor/github.com/jtolds/gls
-	url = https://github.com/jtolds/gls
-[submodule "cmd/micro/vendor/github.com/smartystreets/assertions"]
-	path = cmd/micro/vendor/github.com/smartystreets/assertions
-	url = https://github.com/smartystreets/assertions

LICENSE

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

Makefile

@@ -1,48 +1,47 @@
 .PHONY: runtime
 
-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
+VERSION = $(shell git describe --tags --abbrev=0)
+HASH = $(shell git rev-parse --short HEAD)
+DATE = $(shell go run tools/build-date.go)
 
 # Builds micro after checking dependencies but without updating the runtime
-build: update
-	go build -ldflags "-s -w -X main.Version=$(VERSION) -X main.CommitHash=$(HASH) -X 'main.CompileDate=$(DATE)' $(ADDITIONAL_GO_LINKER_FLAGS)" ./cmd/micro
+build: deps tcell
+	go build -ldflags "-X main.Version=$(VERSION) -X main.CommitHash=$(HASH) -X 'main.CompileDate=$(DATE)'" ./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 "-s -w -X main.Version=$(VERSION) -X main.CommitHash=$(HASH) -X 'main.CompileDate=$(DATE)' $(ADDITIONAL_GO_LINKER_FLAGS)" ./cmd/micro
+	go build -ldflags "-X main.Version=$(VERSION) -X main.CommitHash=$(HASH) -X 'main.CompileDate=$(DATE)'" ./cmd/micro
 
-# Same as 'build' but installs to $GOBIN afterward
-install: update
-	go install -ldflags "-s -w -X main.Version=$(VERSION) -X main.CommitHash=$(HASH) -X 'main.CompileDate=$(DATE)' $(ADDITIONAL_GO_LINKER_FLAGS)" ./cmd/micro
+# Same as 'build' but installs to $GOPATH/bin afterward
+install: build
+	mv micro $(GOPATH)/bin
 
-# Same as 'build-all' but installs to $GOBIN afterward
+# Same as 'build-all' but installs to $GOPATH/bin afterward
 install-all: runtime install
 
-# Same as 'build-quick' but installs to $GOBIN afterward
-install-quick:
-	go install -ldflags "-s -w -X main.Version=$(VERSION) -X main.CommitHash=$(HASH) -X 'main.CompileDate=$(DATE)' $(ADDITIONAL_GO_LINKER_FLAGS)"  ./cmd/micro
+# Same as 'build-quick' but installs to $GOPATH/bin afterward
+install-quick: build-quick
+	mv micro $(GOPATH)/bin
 
-update:
-	git pull
-	git submodule update --init
+# Updates tcell
+tcell:
+	git -C $(GOPATH)/src/github.com/zyedidia/tcell pull
+
+# Checks for dependencies
+deps:
+	go get -d ./cmd/micro
 
 # Builds the runtime
 runtime:
 	go get -u github.com/jteeuwen/go-bindata/...
-	$(GOBIN)/go-bindata -nometadata -o runtime.go runtime/...
+	$(GOPATH)/bin/go-bindata -nometadata -o runtime.go runtime/...
 	mv runtime.go cmd/micro
 
 test:
+	go get -d ./cmd/micro
 	go test ./cmd/micro
 
 clean:

README.md

@@ -4,7 +4,6 @@
 [![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.
@@ -18,62 +17,39 @@ Here is a picture of micro editing its source code.
 
 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 [90 languages](runtime/syntax)!)
+* Syntax highlighting (for over [75 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
 * Macros
-* Common editor things such as undo/redo, line numbers, Unicode support, softwrap...
+* Common editor things such as undo/redo, line numbers, unicode support...
 
-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.
+Although not yet implemented, I hope to add more features such as autocompletion ([#174](https://github.com/zyedidia/micro/issues/174)), and multiple cursors ([#5](https://github.com/zyedidia/micro/issues/5)) in the future.
 
 # Installation
 
 To install micro, you can download a [prebuilt binary](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
 
@@ -86,75 +62,19 @@ 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 a binary release, but does run Go, you can build from source.
+If your operating system does not have binary, 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) and that your `GOPATH` env variable is set (I recommend setting it to `~/go` if you don't have one).
+Make sure that you have Go version 1.5 or greater (Go 1.4 will work if your version supports CGO).
 
+```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 the 'xclip' or 'xsel' commands to be installed.
+On Linux, clipboard support requires 'xclip' or 'xsel' command to be installed.
 
 For Ubuntu:
 
@@ -168,9 +88,9 @@ If you don't have xclip or xsel, micro will use an internal clipboard for copy a
 
 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`.
+by running `> set colorscheme simple`.
 
-If you are using the default Ubuntu terminal, to enable 256 make sure your `TERM` variable is set
+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
@@ -178,11 +98,11 @@ that micro's default colorscheme won't look very good. You can either set
 the colorscheme to `simple`, or download a better terminal emulator, like
 mintty.
 
-### Plan9, Cygwin
+### Plan9, NaCl, Cygwin
 
 Please note that micro uses the amazing [tcell library](https://github.com/gdamore/tcell), but this
 means that micro is restricted to the platforms tcell supports. As a result, micro does not support
-Plan9, and Cygwin (although this may change in the future). Micro also doesn't support NaCl (but NaCl is deprecated anyways).
+Plan9, NaCl, and Cygwin (although this may change in the future).
 
 # Usage
 
@@ -202,7 +122,7 @@ click to enable line selection.
 
 # Documentation and Help
 
-Micro has a built-in help system which you can access by pressing `Ctrl-E` and typing `help`. Additionally, you can
+Micro has a built-in help system which you can access by pressing `CtrlE` and typing `help`. Additionally, you can
 view the help files here:
 
 * [main help](https://github.com/zyedidia/micro/tree/master/runtime/help/help.md)
@@ -219,7 +139,6 @@ 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](https://github.com/zyedidia/micro/issues)
-to report bugs, ask questions, or suggest new features.
+You can use the Github issue tracker 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

@@ -1,63 +0,0 @@
-<?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

@@ -1,73 +0,0 @@
-.\" 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

@@ -1,15 +0,0 @@
-[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/actions_other.go

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

cmd/micro/actions_posix.go

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

cmd/micro/autocomplete.go

@@ -4,6 +4,8 @@ import (
 	"io/ioutil"
 	"os"
 	"strings"
+
+	"github.com/mitchellh/go-homedir"
 )
 
 var pluginCompletions []func(string) []string
@@ -16,18 +18,19 @@ var pluginCompletions []func(string) []string
 func FileComplete(input string) (string, []string) {
 	var sep string = 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
+		home, _ := homedir.Dir()
 
-		directories = ReplaceHome(directories)
+		directories := strings.Join(dirs[:len(dirs)-1], sep)
+		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
@@ -78,9 +81,9 @@ func CommandComplete(input string) (string, []string) {
 func HelpComplete(input string) (string, []string) {
 	var suggestions []string
 
-	for _, file := range ListRuntimeFiles(RTHelp) {
-		topic := file.Name()
+	for _, topic := range helpFiles {
 		if strings.HasPrefix(topic, input) {
+
 			suggestions = append(suggestions, topic)
 		}
 	}
@@ -92,25 +95,6 @@ func HelpComplete(input string) (string, []string) {
 	return chosen, suggestions
 }
 
-// ColorschemeComplete tab-completes names of colorschemes.
-func ColorschemeComplete(input string) (string, []string) {
-	var suggestions []string
-	files := ListRuntimeFiles(RTColorscheme)
-
-	for _, f := range files {
-		if strings.HasPrefix(f.Name(), input) {
-			suggestions = append(suggestions, f.Name())
-		}
-	}
-
-	var chosen string
-	if len(suggestions) == 1 {
-		chosen = suggestions[0]
-	}
-
-	return chosen, suggestions
-}
-
 func contains(s []string, e string) bool {
 	for _, a := range s {
 		if a == e {
@@ -142,64 +126,7 @@ func OptionComplete(input string) (string, []string) {
 	return chosen, suggestions
 }
 
-// OptionValueComplete completes values for various options
-func OptionValueComplete(inputOpt, input string) (string, []string) {
-	inputOpt = strings.TrimSpace(inputOpt)
-	var suggestions []string
-	localSettings := DefaultLocalSettings()
-	var optionVal interface{}
-	for k, option := range 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")
-			}
-		}
-	}
-
-	var chosen string
-	if len(suggestions) == 1 {
-		chosen = suggestions[0]
-	}
-	return chosen, suggestions
-}
-
-// MakeCompletion registers a function from a plugin for autocomplete commands
+// MakeCompletion registeres a function from a plugin for autocomplete commands
 func MakeCompletion(function string) Completion {
 	pluginCompletions = append(pluginCompletions, LuaFunctionComplete(function))
 	return Completion(-len(pluginCompletions))
@@ -219,31 +146,3 @@ func PluginComplete(complete Completion, input string) (chosen string, suggestio
 	}
 	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
-}

cmd/micro/bindings.go

@@ -1,134 +1,91 @@
 package main
 
 import (
-	"fmt"
 	"io/ioutil"
 	"os"
 	"strings"
-	"unicode"
 
-	"github.com/flynn/json5"
+	"github.com/yosuke-furukawa/json5/encoding/json5"
 	"github.com/zyedidia/tcell"
 )
 
-var bindingsStr map[string]string
 var bindings map[Key][]func(*View, bool) bool
-var mouseBindings map[Key][]func(*View, bool, *tcell.EventMouse) bool
 var helpBinding string
-var kmenuBinding string
-
-var mouseBindingActions = map[string]func(*View, bool, *tcell.EventMouse) bool{
-	"MousePress":       (*View).MousePress,
-	"MouseMultiCursor": (*View).MouseMultiCursor,
-}
 
 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,
-	"SelectLine":             (*View).SelectLine,
-	"SelectToStartOfLine":    (*View).SelectToStartOfLine,
-	"SelectToEndOfLine":      (*View).SelectToEndOfLine,
-	"ParagraphPrevious":      (*View).ParagraphPrevious,
-	"ParagraphNext":          (*View).ParagraphNext,
-	"InsertNewline":          (*View).InsertNewline,
-	"InsertSpace":            (*View).InsertSpace,
-	"Backspace":              (*View).Backspace,
-	"Delete":                 (*View).Delete,
-	"InsertTab":              (*View).InsertTab,
-	"Save":                   (*View).Save,
-	"SaveAll":                (*View).SaveAll,
-	"SaveAs":                 (*View).SaveAs,
-	"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,
-	"MoveLinesUp":            (*View).MoveLinesUp,
-	"MoveLinesDown":          (*View).MoveLinesDown,
-	"IndentSelection":        (*View).IndentSelection,
-	"OutdentSelection":       (*View).OutdentSelection,
-	"OutdentLine":            (*View).OutdentLine,
-	"Paste":                  (*View).Paste,
-	"PastePrimary":           (*View).PastePrimary,
-	"SelectAll":              (*View).SelectAll,
-	"OpenFile":               (*View).OpenFile,
-	"Start":                  (*View).Start,
-	"End":                    (*View).End,
-	"PageUp":                 (*View).PageUp,
-	"PageDown":               (*View).PageDown,
-	"HalfPageUp":             (*View).HalfPageUp,
-	"HalfPageDown":           (*View).HalfPageDown,
-	"StartOfLine":            (*View).StartOfLine,
-	"EndOfLine":              (*View).EndOfLine,
-	"ToggleHelp":             (*View).ToggleHelp,
-	"ToggleKeyMenu":          (*View).ToggleKeyMenu,
-	"ToggleRuler":            (*View).ToggleRuler,
-	"JumpLine":               (*View).JumpLine,
-	"ClearStatus":            (*View).ClearStatus,
-	"ShellMode":              (*View).ShellMode,
-	"CommandMode":            (*View).CommandMode,
-	"ToggleOverwriteMode":    (*View).ToggleOverwriteMode,
-	"Escape":                 (*View).Escape,
-	"Quit":                   (*View).Quit,
-	"QuitAll":                (*View).QuitAll,
-	"AddTab":                 (*View).AddTab,
-	"PreviousTab":            (*View).PreviousTab,
-	"NextTab":                (*View).NextTab,
-	"NextSplit":              (*View).NextSplit,
-	"PreviousSplit":          (*View).PreviousSplit,
-	"Unsplit":                (*View).Unsplit,
-	"VSplit":                 (*View).VSplitBinding,
-	"HSplit":                 (*View).HSplitBinding,
-	"ToggleMacro":            (*View).ToggleMacro,
-	"PlayMacro":              (*View).PlayMacro,
-	"Suspend":                (*View).Suspend,
-	"ScrollUp":               (*View).ScrollUpAction,
-	"ScrollDown":             (*View).ScrollDownAction,
-	"SpawnMultiCursor":       (*View).SpawnMultiCursor,
-	"SpawnMultiCursorSelect": (*View).SpawnMultiCursorSelect,
-	"RemoveMultiCursor":      (*View).RemoveMultiCursor,
-	"RemoveAllMultiCursors":  (*View).RemoveAllMultiCursors,
-	"SkipMultiCursor":        (*View).SkipMultiCursor,
-	"JumpToMatchingBrace":    (*View).JumpToMatchingBrace,
+	"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,
+	"PastePrimary":        (*View).PastePrimary,
+	"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,
+	"QuitAll":             (*View).QuitAll,
+	"AddTab":              (*View).AddTab,
+	"PreviousTab":         (*View).PreviousTab,
+	"NextTab":             (*View).NextTab,
+	"NextSplit":           (*View).NextSplit,
+	"PreviousSplit":       (*View).PreviousSplit,
+	"ToggleMacro":         (*View).ToggleMacro,
+	"PlayMacro":           (*View).PlayMacro,
 
 	// This was changed to InsertNewline but I don't want to break backwards compatibility
 	"InsertEnter": (*View).InsertNewline,
 }
 
-var bindingMouse = 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 bindingKeys = map[string]tcell.Key{
 	"Up":             tcell.KeyUp,
 	"Down":           tcell.KeyDown,
@@ -248,13 +205,12 @@ var bindingKeys = map[string]tcell.Key{
 	"CtrlRightSq":    tcell.KeyCtrlRightSq,
 	"CtrlCarat":      tcell.KeyCtrlCarat,
 	"CtrlUnderscore": tcell.KeyCtrlUnderscore,
-	"CtrlPageUp":     tcell.KeyCtrlPgUp,
-	"CtrlPageDown":   tcell.KeyCtrlPgDn,
+	"Backspace":      tcell.KeyBackspace,
 	"Tab":            tcell.KeyTab,
 	"Esc":            tcell.KeyEsc,
 	"Escape":         tcell.KeyEscape,
 	"Enter":          tcell.KeyEnter,
-	"Backspace":      tcell.KeyBackspace2,
+	"Backspace2":     tcell.KeyBackspace2,
 
 	// I renamed these keys to PageUp and PageDown but I don't want to break someone's keybindings
 	"PgUp":   tcell.KeyPgUp,
@@ -265,16 +221,12 @@ var bindingKeys = map[string]tcell.Key{
 type Key struct {
 	keyCode   tcell.Key
 	modifiers tcell.ModMask
-	buttons   tcell.ButtonMask
 	r         rune
-	escape    string
 }
 
 // InitBindings initializes the keybindings for micro
 func InitBindings() {
 	bindings = make(map[Key][]func(*View, bool) bool)
-	bindingsStr = make(map[string]string)
-	mouseBindings = make(map[Key][]func(*View, bool, *tcell.EventMouse) bool)
 
 	var parsed map[string]string
 	defaults := DefaultBindings()
@@ -315,8 +267,7 @@ modSearch:
 		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
+		case strings.HasPrefix(k, "Ctrl"):
 			k = k[4:]
 			modifiers |= tcell.ModCtrl
 		case strings.HasPrefix(k, "Alt"):
@@ -325,35 +276,21 @@ modSearch:
 		case strings.HasPrefix(k, "Shift"):
 			k = k[5:]
 			modifiers |= tcell.ModShift
-		case strings.HasPrefix(k, "\x1b"):
-			return Key{
-				keyCode:   -1,
-				modifiers: modifiers,
-				buttons:   -1,
-				r:         0,
-				escape:    k,
-			}, true
 		default:
 			break modSearch
 		}
 	}
 
-	if len(k) == 0 {
-		return Key{buttons: -1}, false
-	}
-
 	// 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.
-		k = string(unicode.ToUpper(rune(k[0]))) + k[1:]
 		if code, ok := bindingKeys["Ctrl"+k]; ok {
 			// It is, we're done.
 			return Key{
 				keyCode:   code,
 				modifiers: modifiers,
-				buttons:   -1,
 				r:         0,
 			}, true
 		}
@@ -364,16 +301,6 @@ modSearch:
 		return Key{
 			keyCode:   code,
 			modifiers: modifiers,
-			buttons:   -1,
-			r:         0,
-		}, true
-	}
-
-	// See if we can find the key in bindingMouse
-	if code, ok := bindingMouse[k]; ok {
-		return Key{
-			modifiers: modifiers,
-			buttons:   code,
 			r:         0,
 		}, true
 	}
@@ -383,13 +310,12 @@ modSearch:
 		return Key{
 			keyCode:   tcell.KeyRune,
 			modifiers: modifiers,
-			buttons:   -1,
 			r:         rune(k[0]),
 		}, true
 	}
 
 	// We don't know what happened.
-	return Key{buttons: -1}, false
+	return Key{}, false
 }
 
 // findAction will find 'action' using string 'v'
@@ -403,109 +329,23 @@ func findAction(v string) (action func(*View, bool) bool) {
 	return action
 }
 
-func findMouseAction(v string) func(*View, bool, *tcell.EventMouse) bool {
-	action, ok := mouseBindingActions[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 = LuaFunctionMouseBinding(v)
-	}
-	return action
-}
-
-// TryBindKey tries to bind a key by writing to configDir/bindings.json
-// This function is unused for now
-func TryBindKey(k, v string) {
-	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
-		}
-
-		conflict := -1
-		lines := strings.Split(string(input), "\n")
-		for i, l := range lines {
-			parts := strings.Split(l, ":")
-			if len(parts) >= 2 {
-				if strings.Contains(parts[0], k) {
-					conflict = i
-					TermMessage("Warning: Keybinding conflict:", k, " has been overwritten")
-				}
-			}
-		}
-
-		binding := fmt.Sprintf("    \"%s\": \"%s\",", k, v)
-		if conflict == -1 {
-			lines = append([]string{lines[0], binding}, lines[conflict:]...)
-		} else {
-			lines = append(append(lines[:conflict], binding), lines[conflict+1:]...)
-		}
-		txt := strings.Join(lines, "\n")
-		err = ioutil.WriteFile(filename, []byte(txt), 0644)
-		if err != nil {
-			TermMessage("Error")
-		}
-	}
-}
-
 // BindKey takes a key and an action and binds the two together
 func BindKey(k, v string) {
 	key, ok := findKey(k)
 	if !ok {
-		TermMessage("Unknown keybinding: " + k)
 		return
 	}
 	if v == "ToggleHelp" {
 		helpBinding = k
 	}
-	if v == "ToggleKeyMenu" {
-		kmenuBinding = k
-	}
-	if helpBinding == k && v != "ToggleHelp" {
-		helpBinding = ""
-	}
-	if kmenuBinding == k && v != "ToggleKeyMenu" {
-		kmenuBinding = ""
-	}
 
 	actionNames := strings.Split(v, ",")
-	if actionNames[0] == "UnbindKey" {
-		delete(bindings, key)
-		delete(mouseBindings, key)
-		delete(bindingsStr, k)
-		if len(actionNames) == 1 {
-			return
-		}
-		actionNames = append(actionNames[:0], actionNames[1:]...)
-	}
 	actions := make([]func(*View, bool) bool, 0, len(actionNames))
-	mouseActions := make([]func(*View, bool, *tcell.EventMouse) bool, 0, len(actionNames))
 	for _, actionName := range actionNames {
-		if strings.HasPrefix(actionName, "Mouse") {
-			mouseActions = append(mouseActions, findMouseAction(actionName))
-		} else if strings.HasPrefix(actionName, "command:") {
-			cmd := strings.SplitN(actionName, ":", 2)[1]
-			actions = append(actions, CommandAction(cmd))
-		} else if strings.HasPrefix(actionName, "command-edit:") {
-			cmd := strings.SplitN(actionName, ":", 2)[1]
-			actions = append(actions, CommandEditAction(cmd))
-		} else {
-			actions = append(actions, findAction(actionName))
-		}
+		actions = append(actions, findAction(actionName))
 	}
 
-	if len(actions) > 0 {
-		// Can't have a binding be both mouse and normal
-		delete(mouseBindings, key)
-		bindings[key] = actions
-		bindingsStr[k] = v
-	} else if len(mouseActions) > 0 {
-		// Can't have a binding be both mouse and normal
-		delete(bindings, key)
-		mouseBindings[key] = mouseActions
-	}
+	bindings[key] = actions
 }
 
 // DefaultBindings returns a map containing micro's default keybindings
@@ -521,29 +361,24 @@ 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",
-		"CtrlH":          "Backspace",
+		"Space":          "InsertSpace",
 		"Backspace":      "Backspace",
-		"Alt-CtrlH":      "DeleteWordLeft",
+		"Backspace2":     "Backspace",
 		"Alt-Backspace":  "DeleteWordLeft",
+		"Alt-Backspace2": "DeleteWordLeft",
 		"Tab":            "IndentSelection,InsertTab",
-		"Backtab":        "OutdentSelection,OutdentLine",
+		"Backtab":        "OutdentSelection",
 		"CtrlO":          "OpenFile",
 		"CtrlS":          "Save",
 		"CtrlF":          "Find",
@@ -558,56 +393,32 @@ func DefaultBindings() map[string]string {
 		"CtrlV":          "Paste",
 		"CtrlA":          "SelectAll",
 		"CtrlT":          "AddTab",
-		"Alt,":           "PreviousTab",
-		"Alt.":           "NextTab",
+		"CtrlRightSq":    "PreviousTab",
+		"CtrlBackslash":  "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",
 		"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",
-
-		// 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",
+		"Alt-p": "CursorUp",
+		"Alt-n": "CursorDown",
 	}
 }

cmd/micro/buffer.go

@@ -2,29 +2,16 @@ package main
 
 import (
 	"bytes"
-	"crypto/md5"
 	"encoding/gob"
-	"errors"
-	"io"
 	"io/ioutil"
 	"os"
 	"os/exec"
 	"os/signal"
 	"path/filepath"
-	"regexp"
 	"strconv"
 	"strings"
 	"time"
 	"unicode/utf8"
-
-	"github.com/zyedidia/micro/cmd/micro/highlight"
-)
-
-var (
-	// 0 - no line type detected
-	// 1 - lf detected
-	// 2 - crlf detected
-	fileformat = 0
 )
 
 // Buffer stores the text for files that are loaded into the text editor
@@ -36,16 +23,12 @@ type Buffer struct {
 	// This stores all the text in the buffer as an array of lines
 	*LineArray
 
-	Cursor    Cursor
-	cursors   []*Cursor // for multiple cursors
-	curCursor int       // the current cursor
+	Cursor Cursor
 
 	// Path to the file on disk
 	Path string
-	// Absolute path to the file on disk
-	AbsPath string
 	// Name of the buffer on the status line
-	name string
+	Name string
 
 	// Whether or not the buffer has been modified since it was opened
 	IsModified bool
@@ -53,14 +36,10 @@ type Buffer struct {
 	// Stores the last modification time of the file the buffer is pointing to
 	ModTime time.Time
 
-	// NumLines is the number of lines in the buffer
 	NumLines int
 
-	syntaxDef   *highlight.Def
-	highlighter *highlight.Highlighter
-
-	// Hash of the original buffer -- empty if fastdirty is on
-	origHash [16]byte
+	// Syntax highlighting rules
+	rules []SyntaxRule
 
 	// Buffer local settings
 	Settings map[string]interface{}
@@ -74,73 +53,10 @@ type SerializedBuffer struct {
 	ModTime      time.Time
 }
 
-// NewBufferFromFile opens a new buffer using the given filepath
-// It will also automatically handle `~`, and line/column with filename:l:c
-// It will return an empty buffer if the filepath does not exist
-// and an error if the file is a directory
-func NewBufferFromFile(path string) (*Buffer, error) {
-	filename := GetPath(path)
-	filename = ReplaceHome(filename)
-	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()
-
-	var buf *Buffer
-	if err != nil {
-		// File does not exist -- create an empty buffer with that name
-		buf = NewBufferFromString("", path)
-	} else {
-		buf = NewBuffer(file, FSize(file), path)
-	}
-
-	return buf, nil
-}
-
-// NewBufferFromString creates a new buffer containing the given
-// string
-func NewBufferFromString(text, path string) *Buffer {
-	return NewBuffer(strings.NewReader(text), int64(len(text)), path)
-}
-
-// NewBuffer creates a new buffer from a given reader with a given path
-func NewBuffer(reader io.Reader, size int64, path string) *Buffer {
-	startpos := Loc{0, 0}
-	startposErr := true
-	if strings.Contains(path, ":") {
-		var err error
-		split := strings.Split(path, ":")
-		path = split[0]
-		startpos.Y, err = strconv.Atoi(split[1])
-		if err != nil {
-			messenger.Error("Error opening file: ", err)
-		} else {
-			startposErr = false
-			if len(split) > 2 {
-				startpos.X, err = strconv.Atoi(split[2])
-				if err != nil {
-					messenger.Error("Error opening file: ", err)
-				}
-			}
-		}
-	}
-
-	if path != "" {
-		for _, tab := range tabs {
-			for _, view := range tab.Views {
-				if view.Buf.Path == path {
-					return view.Buf
-				}
-			}
-		}
-	}
-
+// 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(size, reader)
+	b.LineArray = NewLineArray(txt)
 
 	b.Settings = DefaultLocalSettings()
 	for k, v := range globalSettings {
@@ -149,16 +65,13 @@ func NewBuffer(reader io.Reader, size int64, path string) *Buffer {
 		}
 	}
 
-	if fileformat == 1 {
-		b.Settings["fileformat"] = "unix"
-	} else if fileformat == 2 {
-		b.Settings["fileformat"] = "dos"
-	}
-
-	absPath, _ := filepath.Abs(path)
-
 	b.Path = path
-	b.AbsPath = absPath
+	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)
@@ -166,6 +79,7 @@ func NewBuffer(reader io.Reader, size int64, path string) *Buffer {
 	b.EventHandler = NewEventHandler(b)
 
 	b.Update()
+	b.FindFileType()
 	b.UpdateRules()
 
 	if _, err := os.Stat(configDir + "/buffers/"); os.IsNotExist(err) {
@@ -176,18 +90,11 @@ func NewBuffer(reader io.Reader, size int64, path string) *Buffer {
 	cursorStartX := 0
 	cursorStartY := 0
 	// If -startpos LINE,COL was passed, use start position LINE,COL
-	if len(*flagStartPos) > 0 || !startposErr {
+	if len(*flagStartPos) > 0 {
 		positions := strings.Split(*flagStartPos, ",")
-		if len(positions) == 2 || !startposErr {
-			var lineNum, colNum int
-			var errPos1, errPos2 error
-			if !startposErr {
-				lineNum = startpos.Y
-				colNum = startpos.X
-			} else {
-				lineNum, errPos1 = strconv.Atoi(positions[0])
-				colNum, errPos2 = strconv.Atoi(positions[1])
-			}
+		if len(positions) == 2 {
+			lineNum, errPos1 := strconv.Atoi(positions[0])
+			colNum, errPos2 := strconv.Atoi(positions[1])
 			if errPos1 == nil && errPos2 == nil {
 				cursorStartX = colNum
 				cursorStartY = lineNum - 1
@@ -216,11 +123,11 @@ func NewBuffer(reader io.Reader, size int64, path string) *Buffer {
 
 	InitLocalSettings(b)
 
-	if startposErr && len(*flagStartPos) == 0 && (b.Settings["savecursor"].(bool) || b.Settings["saveundo"].(bool)) {
+	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
-		file, err := os.Open(configDir + "/buffers/" + EscapePath(b.AbsPath))
-		defer file.Close()
+		absPath, _ := filepath.Abs(b.Path)
+		file, err := os.Open(configDir + "/buffers/" + EscapePath(absPath))
 		if err == nil {
 			var buffer SerializedBuffer
 			decoder := gob.NewDecoder(file)
@@ -236,105 +143,28 @@ func NewBuffer(reader io.Reader, size int64, path string) *Buffer {
 			}
 
 			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
+				// 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()
 	}
 
-	if !b.Settings["fastdirty"].(bool) {
-		if size > 50000 {
-			// If the file is larger than a megabyte fastdirty needs to be on
-			b.Settings["fastdirty"] = true
-		} else {
-			b.origHash = md5.Sum([]byte(b.String()))
-		}
-	}
-
-	b.cursors = []*Cursor{&b.Cursor}
-
 	return b
 }
 
-// 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
-}
-
 // UpdateRules updates the syntax rules and filetype for this buffer
 // This is called when the colorscheme changes
 func (b *Buffer) UpdateRules() {
-	rehighlight := false
-	var files []*highlight.File
-	for _, f := range ListRuntimeFiles(RTSyntax) {
-		data, err := f.Data()
-		if err != nil {
-			TermMessage("Error loading syntax file " + f.Name() + ": " + err.Error())
-		} else {
-			file, err := highlight.ParseFile(data)
-			if err != nil {
-				TermMessage("Error loading syntax file " + f.Name() + ": " + err.Error())
-				continue
-			}
-			ftdetect, err := highlight.ParseFtDetect(file)
-			if err != nil {
-				TermMessage("Error loading syntax file " + f.Name() + ": " + err.Error())
-				continue
-			}
+	b.rules = GetRules(b)
+}
 
-			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 {
-						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 {
-						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)
-			}
-		}
-	}
+// 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
@@ -342,14 +172,6 @@ func (b *Buffer) FileType() string {
 	return b.Settings["filetype"].(string)
 }
 
-// IndentString returns a string representing one level of indentation
-func (b *Buffer) IndentString() string {
-	if b.Settings["tabstospaces"].(bool) {
-		return Spaces(int(b.Settings["tabsize"].(float64)))
-	}
-	return "\t"
-}
-
 // CheckModTime makes sure that the file this buffer points to hasn't been updated
 // by an external program since it was last read
 // If it has, we ask the user if they would like to reload the file
@@ -393,41 +215,6 @@ func (b *Buffer) Update() {
 	b.NumLines = len(b.lines)
 }
 
-// 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
-	}
-}
-
-// UpdateCursors updates all the cursors indicies
-func (b *Buffer) UpdateCursors() {
-	for i, c := range b.cursors {
-		c.Num = i
-	}
-}
-
 // Save saves the buffer to its default path
 func (b *Buffer) Save() error {
 	return b.SaveAs(b.Path)
@@ -441,7 +228,8 @@ func (b *Buffer) SaveWithSudo() error {
 // Serialize serializes the buffer to configDir/buffers
 func (b *Buffer) Serialize() error {
 	if b.Settings["savecursor"].(bool) || b.Settings["saveundo"].(bool) {
-		file, err := os.Create(configDir + "/buffers/" + EscapePath(b.AbsPath))
+		absPath, _ := filepath.Abs(b.Path)
+		file, err := os.Create(configDir + "/buffers/" + EscapePath(absPath))
 		if err == nil {
 			enc := gob.NewEncoder(file)
 			gob.Register(TextEvent{})
@@ -451,7 +239,7 @@ func (b *Buffer) Serialize() error {
 				b.ModTime,
 			})
 		}
-		err = file.Close()
+		file.Close()
 		return err
 	}
 	return nil
@@ -459,108 +247,43 @@ func (b *Buffer) Serialize() error {
 
 // SaveAs saves the buffer to a specified path (filename), creating the file if it does not exist
 func (b *Buffer) SaveAs(filename string) error {
+	b.FindFileType()
 	b.UpdateRules()
-	if b.Settings["rmtrailingws"].(bool) {
-		r, _ := regexp.Compile(`[ \t]+$`)
-		for lineNum, line := range b.Lines(0, b.NumLines) {
-			indices := r.FindStringIndex(line)
-			if indices == nil {
-				continue
-			}
-			startLoc := Loc{indices[0], lineNum}
-			b.deleteToEnd(startLoc)
-		}
-		b.Cursor.Relocate()
-	}
-	if b.Settings["eofnewline"].(bool) {
-		end := b.End()
-		if b.RuneAt(Loc{end.X - 1, end.Y}) != '\n' {
-			b.Insert(end, "\n")
-		}
-	}
-
-	defer func() {
-		b.ModTime, _ = GetModTime(filename)
-	}()
-
-	// Removes any tilde and replaces with the absolute path to home
-	var absFilename string = 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 yes, canceled := messenger.YesNoPrompt("Parent folders \"" + dirname + "\" do not exist. Create them? (y,n)"); yes && !canceled {
-				// 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 {
-				// If they canceled the creation of leading dirs
-				return errors.New("Save aborted")
-			}
-		}
-	}
-
-	f, err := os.OpenFile(absFilename, os.O_WRONLY|os.O_CREATE, 0644)
-	defer f.Close()
-	if err != nil {
-		return err
-	}
-	if err := f.Truncate(0); err != nil {
-		return err
-	}
-	useCrlf := b.Settings["fileformat"] == "dos"
-	size := 0
-	for i, l := range b.lines {
-		size += len(l.data)
-		if _, err := f.Write(l.data); err != nil {
-			return err
-		}
-		if i != len(b.lines)-1 {
-			if useCrlf {
-				size += 2
-				if _, err := f.Write([]byte{'\r', '\n'}); err != nil {
-					return err
-				}
-			} else {
-				size++
-				if _, err := f.Write([]byte{'\n'}); err != nil {
-					return err
-				}
-			}
-		}
-	}
-
-	if !b.Settings["fastdirty"].(bool) {
-		if size > 50000 {
-			// If the file is larger than a megabyte fastdirty needs to be on
-			b.Settings["fastdirty"] = true
-		} else {
-			b.origHash = md5.Sum([]byte(b.String()))
-		}
-	}
-
+	b.Name = filename
 	b.Path = filename
-	b.IsModified = false
-	return b.Serialize()
+	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.FindFileType()
 	b.UpdateRules()
+	b.Name = filename
 	b.Path = filename
 
-	// Shut down the screen because we're going to interact directly with the shell
-	screen.Fini()
-	screen = nil
+	// 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(globalSettings["sucmd"].(string), "tee", filename)
-	cmd.Stdin = bytes.NewBufferString(b.SaveString(b.Settings["fileformat"] == "dos"))
+	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
@@ -574,10 +297,13 @@ func (b *Buffer) SaveAsWithSudo(filename string) error {
 
 	// Start the command
 	cmd.Start()
-	err := cmd.Wait()
+	err = cmd.Wait()
 
-	// Start the screen back up
-	InitScreen()
+	// 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)
@@ -586,15 +312,6 @@ func (b *Buffer) SaveAsWithSudo(filename string) error {
 	return err
 }
 
-// Modified returns if this buffer has been modified since
-// being opened
-func (b *Buffer) Modified() bool {
-	if b.Settings["fastdirty"].(bool) {
-		return b.IsModified
-	}
-	return b.origHash != md5.Sum([]byte(b.String()))
-}
-
 func (b *Buffer) insert(pos Loc, value []byte) {
 	b.IsModified = true
 	b.LineArray.insert(pos, value)
@@ -606,11 +323,6 @@ func (b *Buffer) remove(start, end Loc) string {
 	b.Update()
 	return sub
 }
-func (b *Buffer) deleteToEnd(start Loc) {
-	b.IsModified = true
-	b.LineArray.DeleteToEnd(start)
-	b.Update()
-}
 
 // Start returns the location of the first character in the buffer
 func (b *Buffer) Start() Loc {
@@ -619,45 +331,12 @@ func (b *Buffer) Start() Loc {
 
 // End returns the location of the last character in the buffer
 func (b *Buffer) End() Loc {
-	return Loc{utf8.RuneCount(b.lines[b.NumLines-1].data), b.NumLines - 1}
-}
-
-// RuneAt returns the rune at a given location in the buffer
-func (b *Buffer) RuneAt(loc Loc) rune {
-	line := b.LineRunes(loc.Y)
-	if len(line) > 0 {
-		return line[loc.X]
-	}
-	return '\n'
-}
-
-// Line returns a single line as an array of runes
-func (b *Buffer) LineBytes(n int) []byte {
-	if n >= len(b.lines) {
-		return []byte{}
-	}
-	return b.lines[n].data
-}
-
-// Line returns a single line as an array of runes
-func (b *Buffer) LineRunes(n int) []rune {
-	if n >= len(b.lines) {
-		return []rune{}
-	}
-	return toRunes(b.lines[n].data)
+	return Loc{utf8.RuneCount(b.lines[b.NumLines-1]), b.NumLines - 1}
 }
 
 // Line returns a single line
 func (b *Buffer) Line(n int) string {
-	if n >= len(b.lines) {
-		return ""
-	}
-	return string(b.lines[n].data)
-}
-
-// LinesNum returns the number of lines in the buffer
-func (b *Buffer) LinesNum() int {
-	return len(b.lines)
+	return string(b.lines[n])
 }
 
 // Lines returns an array of strings containing the lines from start to end
@@ -665,7 +344,7 @@ func (b *Buffer) Lines(start, end int) []string {
 	lines := b.lines[start:end]
 	var slice []string
 	for _, line := range lines {
-		slice = append(slice, string(line.data))
+		slice = append(slice, string(line))
 	}
 	return slice
 }
@@ -674,120 +353,3 @@ func (b *Buffer) Lines(start, end int) []string {
 func (b *Buffer) Len() int {
 	return Count(b.String())
 }
-
-// MoveLinesUp moves the range of lines up one row
-func (b *Buffer) MoveLinesUp(start int, end int) {
-	// 0 < start < end <= len(b.lines)
-	if start < 1 || start >= end || end > len(b.lines) {
-		return // what to do? FIXME
-	}
-	if end == len(b.lines) {
-		b.Insert(
-			Loc{
-				utf8.RuneCount(b.lines[end-1].data),
-				end - 1,
-			},
-			"\n"+b.Line(start-1),
-		)
-	} else {
-		b.Insert(
-			Loc{0, end},
-			b.Line(start-1)+"\n",
-		)
-	}
-	b.Remove(
-		Loc{0, start - 1},
-		Loc{0, start},
-	)
-}
-
-// MoveLinesDown moves the range of lines down one row
-func (b *Buffer) MoveLinesDown(start int, end int) {
-	// 0 <= start < end < len(b.lines)
-	// if end == len(b.lines), we can't do anything here because the
-	// last line is unaccessible, FIXME
-	if start < 0 || start >= end || end >= len(b.lines)-1 {
-		return // what to do? FIXME
-	}
-	b.Insert(
-		Loc{0, start},
-		b.Line(end)+"\n",
-	)
-	end++
-	b.Remove(
-		Loc{0, end},
-		Loc{0, end + 1},
-	)
-}
-
-// ClearMatches clears all of the syntax highlighting for this buffer
-func (b *Buffer) ClearMatches() {
-	for i := range b.lines {
-		b.SetMatch(i, nil)
-		b.SetState(i, nil)
-	}
-}
-
-func (b *Buffer) clearCursors() {
-	for i := 1; i < len(b.cursors); i++ {
-		b.cursors[i] = nil
-	}
-	b.cursors = b.cursors[:1]
-	b.UpdateCursors()
-	b.Cursor.ResetSelection()
-}
-
-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
-func (b *Buffer) FindMatchingBrace(braceType [2]rune, start Loc) Loc {
-	curLine := b.LineRunes(start.Y)
-	startChar := curLine[start.X]
-	var i int
-	if startChar == braceType[0] {
-		for y := start.Y; y < b.NumLines; y++ {
-			l := b.LineRunes(y)
-			xInit := 0
-			if y == start.Y {
-				xInit = start.X
-			}
-			for x := xInit; x < len(l); x++ {
-				r := l[x]
-				if r == braceType[0] {
-					i++
-				} else if r == braceType[1] {
-					i--
-					if i == 0 {
-						return Loc{x, y}
-					}
-				}
-			}
-		}
-	} else if startChar == braceType[1] {
-		for y := start.Y; y >= 0; y-- {
-			l := []rune(string(b.lines[y].data))
-			xInit := len(l) - 1
-			if y == start.Y {
-				xInit = start.X
-			}
-			for x := xInit; x >= 0; x-- {
-				r := l[x]
-				if r == braceType[0] {
-					i--
-					if i == 0 {
-						return Loc{x, y}
-					}
-				} else if r == braceType[1] {
-					i++
-				}
-			}
-		}
-	}
-	return start
-}

cmd/micro/cellview.go

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

cmd/micro/colorscheme.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"fmt"
+	"io/ioutil"
 	"regexp"
 	"strconv"
 	"strings"
@@ -15,68 +16,67 @@ type Colorscheme map[string]tcell.Style
 // The current colorscheme
 var colorscheme Colorscheme
 
-// 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)
-	}
-
-	return st
-}
+var preInstalledColors = []string{"default", "simple", "solarized", "solarized-tc", "atom-dark-tc", "monokai", "gruvbox", "zenburn", "bubblegum"}
 
 // ColorschemeExists checks if a given colorscheme exists
 func ColorschemeExists(colorschemeName string) bool {
-	return FindRuntimeFile(RTColorscheme, colorschemeName) != nil
+	files, _ := ioutil.ReadDir(configDir)
+	for _, f := range files {
+		if f.Name() == colorschemeName+".micro" {
+			return true
+		}
+	}
+
+	for _, name := range preInstalledColors {
+		if name == colorschemeName {
+			return true
+		}
+	}
+
+	return false
 }
 
 // InitColorscheme picks and initializes the colorscheme when micro starts
 func InitColorscheme() {
-	colorscheme = make(Colorscheme)
-	defStyle = tcell.StyleDefault.
-		Foreground(tcell.ColorDefault).
-		Background(tcell.ColorDefault)
-	if screen != nil {
-		// screen.SetStyle(defStyle)
-	}
-
 	LoadDefaultColorscheme()
 }
 
 // LoadDefaultColorscheme loads the default colorscheme from $(configDir)/colorschemes
 func LoadDefaultColorscheme() {
-	LoadColorscheme(globalSettings["colorscheme"].(string))
+	LoadColorscheme(globalSettings["colorscheme"].(string), configDir+"/colorschemes")
 }
 
 // LoadColorscheme loads the given colorscheme from a directory
-func LoadColorscheme(colorschemeName string) {
-	file := FindRuntimeFile(RTColorscheme, colorschemeName)
-	if file == nil {
-		TermMessage(colorschemeName, "is not a valid colorscheme")
-	} else {
-		if data, err := file.Data(); err != nil {
-			TermMessage("Error loading colorscheme:", err)
-		} else {
-			colorscheme = ParseColorscheme(string(data))
+func LoadColorscheme(colorschemeName, dir string) {
+	files, _ := ioutil.ReadDir(dir)
+	found := false
+	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))
+			found = true
 		}
 	}
+
+	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))
+			found = true
+		}
+	}
+
+	if !found {
+		TermMessage(colorschemeName, "is not a valid colorscheme")
+	}
 }
 
 // ParseColorscheme parses the text definition for a colorscheme and returns the corresponding object
@@ -102,15 +102,7 @@ func ParseColorscheme(text string) Colorscheme {
 			link := string(matches[1])
 			colors := string(matches[2])
 
-			style := StringToStyle(colors)
-			c[link] = style
-
-			if link == "default" {
-				defStyle = style
-			}
-			if screen != nil {
-				// screen.SetStyle(defStyle)
-			}
+			c[link] = StringToStyle(colors)
 		} else {
 			fmt.Println("Color-link statement is not valid:", line)
 		}
@@ -123,14 +115,9 @@ func ParseColorscheme(text string) Colorscheme {
 // The strings must be in the format "extra foregroundcolor,backgroundcolor"
 // The 'extra' can be bold, reverse, or underline
 func StringToStyle(str string) tcell.Style {
-	var fg, bg string
-	spaceSplit := strings.Split(str, " ")
-	var split []string
-	if len(spaceSplit) > 1 {
-		split = strings.Split(spaceSplit[1], ",")
-	} else {
-		split = strings.Split(str, ",")
-	}
+	var fg string
+	bg := "default"
+	split := strings.Split(str, ",")
 	if len(split) > 1 {
 		fg, bg = split[0], split[1]
 	} else {
@@ -139,19 +126,7 @@ func StringToStyle(str string) tcell.Style {
 	fg = strings.TrimSpace(fg)
 	bg = strings.TrimSpace(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)
+	style := defStyle.Foreground(StringToColor(fg)).Background(StringToColor(bg))
 	if strings.Contains(str, "bold") {
 		style = style.Bold(true)
 	}
@@ -252,9 +227,5 @@ func GetColor256(color int) tcell.Color {
 		tcell.Color253, tcell.Color254, tcell.Color255,
 	}
 
-	if color >= 0 && color < len(colors) {
-		return colors[color]
-	}
-
-	return tcell.ColorDefault
+	return colors[color]
 }

cmd/micro/command.go

@@ -1,26 +1,22 @@
 package main
 
 import (
-	"fmt"
+	"bytes"
+	"io/ioutil"
 	"os"
-	"path/filepath"
+	"os/exec"
+	"os/signal"
 	"regexp"
-	"runtime"
-	"strconv"
 	"strings"
-	"unicode/utf8"
 
-	humanize "github.com/dustin/go-humanize"
-	"github.com/zyedidia/micro/cmd/micro/shellwords"
+	"github.com/mitchellh/go-homedir"
 )
 
-// A Command contains a action (a function to call) as well as information about how to autocomplete the command
 type Command struct {
 	action      func([]string)
 	completions []Completion
 }
 
-// A StrCommand is similar to a command but keeps the name of the action
 type StrCommand struct {
 	action      string
 	completions []Completion
@@ -28,37 +24,19 @@ type StrCommand struct {
 
 var commands map[string]Command
 
-var commandActions map[string]func([]string)
-
-func init() {
-	commandActions = map[string]func([]string){
-		"Set":        Set,
-		"SetLocal":   SetLocal,
-		"Show":       Show,
-		"ShowKey":    ShowKey,
-		"Run":        Run,
-		"Bind":       Bind,
-		"Quit":       Quit,
-		"Save":       Save,
-		"Replace":    Replace,
-		"ReplaceAll": ReplaceAll,
-		"VSplit":     VSplit,
-		"HSplit":     HSplit,
-		"Tab":        NewTab,
-		"Help":       Help,
-		"Eval":       Eval,
-		"ToggleLog":  ToggleLog,
-		"Plugin":     PluginCmd,
-		"Reload":     Reload,
-		"Cd":         Cd,
-		"Pwd":        Pwd,
-		"Open":       Open,
-		"TabSwitch":  TabSwitch,
-		"Term":       Term,
-		"MemUsage":   MemUsage,
-		"Retab":      Retab,
-		"Raw":        Raw,
-	}
+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
@@ -91,285 +69,21 @@ func MakeCommand(name, function string, completions ...Completion) {
 // DefaultCommands returns a map containing micro's default commands
 func DefaultCommands() map[string]StrCommand {
 	return map[string]StrCommand{
-		"set":        {"Set", []Completion{OptionCompletion, OptionValueCompletion}},
-		"setlocal":   {"SetLocal", []Completion{OptionCompletion, OptionValueCompletion}},
-		"show":       {"Show", []Completion{OptionCompletion, NoCompletion}},
-		"showkey":    {"ShowKey", []Completion{NoCompletion}},
-		"bind":       {"Bind", []Completion{NoCompletion}},
-		"run":        {"Run", []Completion{NoCompletion}},
-		"quit":       {"Quit", []Completion{NoCompletion}},
-		"save":       {"Save", []Completion{NoCompletion}},
-		"replace":    {"Replace", []Completion{NoCompletion}},
-		"replaceall": {"ReplaceAll", []Completion{NoCompletion}},
-		"vsplit":     {"VSplit", []Completion{FileCompletion, NoCompletion}},
-		"hsplit":     {"HSplit", []Completion{FileCompletion, NoCompletion}},
-		"tab":        {"Tab", []Completion{FileCompletion, NoCompletion}},
-		"help":       {"Help", []Completion{HelpCompletion, NoCompletion}},
-		"eval":       {"Eval", []Completion{NoCompletion}},
-		"log":        {"ToggleLog", []Completion{NoCompletion}},
-		"plugin":     {"Plugin", []Completion{PluginCmdCompletion, PluginNameCompletion}},
-		"reload":     {"Reload", []Completion{NoCompletion}},
-		"cd":         {"Cd", []Completion{FileCompletion}},
-		"pwd":        {"Pwd", []Completion{NoCompletion}},
-		"open":       {"Open", []Completion{FileCompletion}},
-		"tabswitch":  {"TabSwitch", []Completion{NoCompletion}},
-		"term":       {"Term", []Completion{NoCompletion}},
-		"memusage":   {"MemUsage", []Completion{NoCompletion}},
-		"retab":      {"Retab", []Completion{NoCompletion}},
-		"raw":        {"Raw", []Completion{NoCompletion}},
+		"set":      {"Set", []Completion{OptionCompletion, NoCompletion}},
+		"setlocal": {"SetLocal", []Completion{OptionCompletion, NoCompletion}},
+		"show":     {"Show", []Completion{OptionCompletion, NoCompletion}},
+		"bind":     {"Bind", []Completion{NoCompletion}},
+		"run":      {"Run", []Completion{NoCompletion}},
+		"quit":     {"Quit", []Completion{NoCompletion}},
+		"save":     {"Save", []Completion{NoCompletion}},
+		"replace":  {"Replace", []Completion{NoCompletion}},
+		"vsplit":   {"VSplit", []Completion{FileCompletion, NoCompletion}},
+		"hsplit":   {"HSplit", []Completion{FileCompletion, NoCompletion}},
+		"tab":      {"Tab", []Completion{FileCompletion, NoCompletion}},
+		"help":     {"Help", []Completion{HelpCompletion, NoCompletion}},
 	}
 }
 
-// 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) func(*View, bool) bool {
-	return func(v *View, usePlugin bool) bool {
-		input, canceled := messenger.Prompt("> ", prompt, "Command", CommandCompletion)
-		if !canceled {
-			HandleCommand(input)
-		}
-		return false
-	}
-}
-
-// CommandAction returns a bindable function which executes the
-// given command
-func CommandAction(cmd string) func(*View, bool) bool {
-	return func(v *View, usePlugin bool) bool {
-		HandleCommand(cmd)
-		return false
-	}
-}
-
-// PluginCmd installs, removes, updates, lists, or searches for given plugins
-func PluginCmd(args []string) {
-	if len(args) >= 1 {
-		switch args[0] {
-		case "install":
-			installedVersions := GetInstalledVersions(false)
-			for _, plugin := range args[1:] {
-				pp := GetAllPluginPackages().Get(plugin)
-				if pp == nil {
-					messenger.Error("Unknown plugin \"" + plugin + "\"")
-				} else if err := pp.IsInstallable(); err != nil {
-					messenger.Error("Error installing ", plugin, ": ", err)
-				} else {
-					for _, installed := range installedVersions {
-						if pp.Name == installed.pack.Name {
-							if pp.Versions[0].Version.Compare(installed.Version) == 1 {
-								messenger.Error(pp.Name, " is already installed but out-of-date: use 'plugin update ", pp.Name, "' to update")
-							} else {
-								messenger.Error(pp.Name, " is already installed")
-							}
-						}
-					}
-					pp.Install()
-				}
-			}
-		case "remove":
-			removed := ""
-			for _, plugin := range args[1:] {
-				// check if the plugin exists.
-				if _, ok := loadedPlugins[plugin]; ok {
-					UninstallPlugin(plugin)
-					removed += plugin + " "
-					continue
-				}
-			}
-			if !IsSpaces([]byte(removed)) {
-				messenger.Message("Removed ", removed)
-			} else {
-				messenger.Error("The requested plugins do not exist")
-			}
-		case "update":
-			UpdatePlugins(args[1:])
-		case "list":
-			plugins := GetInstalledVersions(false)
-			messenger.AddLog("----------------")
-			messenger.AddLog("The following plugins are currently installed:\n")
-			for _, p := range plugins {
-				messenger.AddLog(fmt.Sprintf("%s (%s)", p.pack.Name, p.Version))
-			}
-			messenger.AddLog("----------------")
-			if len(plugins) > 0 {
-				if CurView().Type != vtLog {
-					ToggleLog([]string{})
-				}
-			}
-		case "search":
-			plugins := SearchPlugin(args[1:])
-			messenger.Message(len(plugins), " plugins found")
-			for _, p := range plugins {
-				messenger.AddLog("----------------")
-				messenger.AddLog(p.String())
-			}
-			messenger.AddLog("----------------")
-			if len(plugins) > 0 {
-				if CurView().Type != vtLog {
-					ToggleLog([]string{})
-				}
-			}
-		case "available":
-			packages := GetAllPluginPackages()
-			messenger.AddLog("Available Plugins:")
-			for _, pkg := range packages {
-				messenger.AddLog(pkg.Name)
-			}
-			if CurView().Type != vtLog {
-				ToggleLog([]string{})
-			}
-		}
-	} else {
-		messenger.Error("Not enough arguments")
-	}
-}
-
-// Retab changes all spaces to tabs or all tabs to spaces
-// depending on the user's settings
-func Retab(args []string) {
-	CurView().Retab(true)
-}
-
-// Raw opens a new raw view which displays the escape sequences micro
-// is receiving in real-time
-func Raw(args []string) {
-	buf := NewBufferFromString("", "Raw events")
-
-	view := NewView(buf)
-	view.Buf.Insert(view.Cursor.Loc, "Warning: Showing raw event escape codes\n")
-	view.Buf.Insert(view.Cursor.Loc, "Use CtrlQ to exit\n")
-	view.Type = vtRaw
-	tab := NewTabFromView(view)
-	tab.SetNum(len(tabs))
-	tabs = append(tabs, tab)
-	curTab = len(tabs) - 1
-	if len(tabs) == 2 {
-		for _, t := range tabs {
-			for _, v := range t.Views {
-				v.ToggleTabbar()
-			}
-		}
-	}
-}
-
-// TabSwitch switches to a given tab either by name or by number
-func TabSwitch(args []string) {
-	if len(args) > 0 {
-		num, err := strconv.Atoi(args[0])
-		if err != nil {
-			// Check for tab with this name
-
-			found := false
-			for _, t := range tabs {
-				v := t.Views[t.CurView]
-				if v.Buf.GetName() == args[0] {
-					curTab = v.TabNum
-					found = true
-				}
-			}
-			if !found {
-				messenger.Error("Could not find tab: ", err)
-			}
-		} else {
-			num--
-			if num >= 0 && num < len(tabs) {
-				curTab = num
-			} else {
-				messenger.Error("Invalid tab index")
-			}
-		}
-	}
-}
-
-// Cd changes the current working directory
-func Cd(args []string) {
-	if len(args) > 0 {
-		path := ReplaceHome(args[0])
-		err := os.Chdir(path)
-		if err != nil {
-			messenger.Error("Error with cd: ", err)
-			return
-		}
-		wd, _ := os.Getwd()
-		for _, tab := range tabs {
-			for _, view := range tab.Views {
-				if len(view.Buf.name) == 0 {
-					continue
-				}
-
-				view.Buf.Path, _ = MakeRelative(view.Buf.AbsPath, wd)
-				if p, _ := filepath.Abs(view.Buf.Path); !strings.Contains(p, wd) {
-					view.Buf.Path = view.Buf.AbsPath
-				}
-			}
-		}
-	}
-}
-
-// MemUsage prints micro's memory usage
-// Alloc shows how many bytes are currently in use
-// Sys shows how many bytes have been requested from the operating system
-// NumGC shows how many times the GC has been run
-// Note that Go commonly reserves more memory from the OS than is currently in-use/required
-// Additionally, even if Go returns memory to the OS, the OS does not always claim it because
-// there may be plenty of memory to spare
-func MemUsage(args []string) {
-	var mem runtime.MemStats
-	runtime.ReadMemStats(&mem)
-
-	messenger.Message(fmt.Sprintf("Alloc: %v, Sys: %v, NumGC: %v", humanize.Bytes(mem.Alloc), humanize.Bytes(mem.Sys), mem.NumGC))
-}
-
-// Pwd prints the current working directory
-func Pwd(args []string) {
-	wd, err := os.Getwd()
-	if err != nil {
-		messenger.Message(err.Error())
-	} else {
-		messenger.Message(wd)
-	}
-}
-
-// Open opens a new buffer with a given filename
-func Open(args []string) {
-	if len(args) > 0 {
-		filename := args[0]
-		// the filename might or might not be quoted, so unquote first then join the strings.
-		args, err := shellwords.Split(filename)
-		if err != nil {
-			messenger.Error("Error parsing args ", err)
-			return
-		}
-		filename = strings.Join(args, " ")
-
-		CurView().Open(filename)
-	} else {
-		messenger.Error("No filename")
-	}
-}
-
-// ToggleLog toggles the log view
-func ToggleLog(args []string) {
-	buffer := messenger.getBuffer()
-	if CurView().Type != vtLog {
-		CurView().HSplit(buffer)
-		CurView().Type = vtLog
-		RedrawAll()
-		buffer.Cursor.Loc = buffer.Start()
-		CurView().Relocate()
-		buffer.Cursor.Loc = buffer.End()
-		CurView().Relocate()
-	} else {
-		CurView().Quit(true)
-	}
-}
-
-// Reload reloads all files (syntax files, colorschemes...)
-func Reload(args []string) {
-	LoadAll()
-}
-
 // Help tries to open the given help page in a horizontal split
 func Help(args []string) {
 	if len(args) < 1 {
@@ -377,7 +91,7 @@ func Help(args []string) {
 		CurView().openHelp("help")
 	} else {
 		helpPage := args[0]
-		if FindRuntimeFile(RTHelp, helpPage) != nil {
+		if _, ok := helpPages[helpPage]; ok {
 			CurView().openHelp(helpPage)
 		} else {
 			messenger.Error("Sorry, no help for ", helpPage)
@@ -389,12 +103,19 @@ func Help(args []string) {
 // If no file is given, it opens an empty buffer in a new split
 func VSplit(args []string) {
 	if len(args) == 0 {
-		CurView().VSplit(NewBufferFromString("", ""))
+		CurView().VSplit(NewBuffer([]byte{}, ""))
 	} else {
-		buf, err := NewBufferFromFile(args[0])
+		filename := args[0]
+		home, _ := homedir.Dir()
+		filename = strings.Replace(filename, "~", home, 1)
+		file, err := ioutil.ReadFile(filename)
+
+		var buf *Buffer
 		if err != nil {
-			messenger.Error(err)
-			return
+			// File does not exist -- create an empty buffer with that name
+			buf = NewBuffer([]byte{}, filename)
+		} else {
+			buf = NewBuffer(file, filename)
 		}
 		CurView().VSplit(buf)
 	}
@@ -404,47 +125,41 @@ func VSplit(args []string) {
 // If no file is given, it opens an empty buffer in a new split
 func HSplit(args []string) {
 	if len(args) == 0 {
-		CurView().HSplit(NewBufferFromString("", ""))
+		CurView().HSplit(NewBuffer([]byte{}, ""))
 	} else {
-		buf, err := NewBufferFromFile(args[0])
+		filename := args[0]
+		home, _ := homedir.Dir()
+		filename = strings.Replace(filename, "~", home, 1)
+		file, err := ioutil.ReadFile(filename)
+
+		var buf *Buffer
 		if err != nil {
-			messenger.Error(err)
-			return
+			// File does not exist -- create an empty buffer with that name
+			buf = NewBuffer([]byte{}, filename)
+		} else {
+			buf = NewBuffer(file, filename)
 		}
 		CurView().HSplit(buf)
 	}
 }
 
-// Eval evaluates a lua expression
-func Eval(args []string) {
-	if len(args) >= 1 {
-		err := L.DoString(args[0])
-		if err != nil {
-			messenger.Error(err)
-		}
-	} else {
-		messenger.Error("Not enough arguments")
-	}
-}
-
 // NewTab opens the given file in a new tab
 func NewTab(args []string) {
 	if len(args) == 0 {
 		CurView().AddTab(true)
 	} else {
-		buf, err := NewBufferFromFile(args[0])
-		if err != nil {
-			messenger.Error(err)
-			return
-		}
+		filename := args[0]
+		home, _ := homedir.Dir()
+		filename = strings.Replace(filename, "~", home, 1)
+		file, _ := ioutil.ReadFile(filename)
 
-		tab := NewTabFromView(NewView(buf))
+		tab := NewTabFromView(NewView(NewBuffer(file, filename)))
 		tab.SetNum(len(tabs))
 		tabs = append(tabs, tab)
-		curTab = len(tabs) - 1
+		curTab++
 		if len(tabs) == 2 {
 			for _, t := range tabs {
-				for _, v := range t.Views {
+				for _, v := range t.views {
 					v.ToggleTabbar()
 				}
 			}
@@ -459,8 +174,8 @@ func Set(args []string) {
 		return
 	}
 
-	option := args[0]
-	value := args[1]
+	option := strings.TrimSpace(args[0])
+	value := strings.TrimSpace(args[1])
 
 	SetOptionAndSettings(option, value)
 }
@@ -472,8 +187,8 @@ func SetLocal(args []string) {
 		return
 	}
 
-	option := args[0]
-	value := args[1]
+	option := strings.TrimSpace(args[0])
+	value := strings.TrimSpace(args[1])
 
 	err := SetLocalOption(option, value, CurView())
 	if err != nil {
@@ -498,20 +213,6 @@ func Show(args []string) {
 	messenger.Message(option)
 }
 
-// ShowKey displays the action that a key is bound to
-func ShowKey(args []string) {
-	if len(args) < 1 {
-		messenger.Error("Please provide a key to show")
-		return
-	}
-
-	if action, ok := bindingsStr[args[0]]; ok {
-		messenger.Message(action)
-	} else {
-		messenger.Message(args[0], " has no binding")
-	}
-}
-
 // Bind creates a new keybinding
 func Bind(args []string) {
 	if len(args) < 2 {
@@ -524,7 +225,7 @@ func Bind(args []string) {
 // Run runs a shell command in the background
 func Run(args []string) {
 	// Run a shell command in the background (openTerm is false)
-	HandleShellCommand(shellwords.Join(args...), false, true)
+	HandleShellCommand(JoinCommandArgs(args...), false)
 }
 
 // Quit closes the main view
@@ -535,49 +236,28 @@ func Quit(args []string) {
 
 // Save saves the buffer in the main view
 func Save(args []string) {
-	if len(args) == 0 {
-		// Save the main view
-		CurView().Save(true)
-	} else {
-		CurView().Buf.SaveAs(args[0])
-	}
+	// Save the main view
+	CurView().Save(true)
 }
 
 // Replace runs search and replace
 func Replace(args []string) {
-	if len(args) < 2 || len(args) > 4 {
+	if len(args) < 2 {
 		// We need to find both a search and replace expression
 		messenger.Error("Invalid replace statement: " + strings.Join(args, " "))
 		return
 	}
 
-	all := false
-	noRegex := false
-
-	if len(args) > 2 {
-		for _, arg := range args[2:] {
-			switch arg {
-			case "-a":
-				all = true
-			case "-l":
-				noRegex = true
-			default:
-				messenger.Error("Invalid flag: " + arg)
-				return
-			}
-		}
+	var flags string
+	if len(args) == 3 {
+		// The user included some flags
+		flags = args[2]
 	}
 
 	search := string(args[0])
-
-	if noRegex {
-		search = regexp.QuoteMeta(search)
-	}
-
 	replace := string(args[1])
-	replaceBytes := []byte(replace)
 
-	regex, err := regexp.Compile("(?m)" + search)
+	regex, err := regexp.Compile(search)
 	if err != nil {
 		// There was an error with the user's regex
 		messenger.Error(err.Error())
@@ -587,25 +267,7 @@ func Replace(args []string) {
 	view := CurView()
 
 	found := 0
-	replaceAll := func() {
-		var deltas []Delta
-		for i := 0; i < view.Buf.LinesNum(); i++ {
-			newText := regex.ReplaceAllFunc(view.Buf.lines[i].data, func(in []byte) []byte {
-				found++
-				return replaceBytes
-			})
-
-			from := Loc{0, i}
-			to := Loc{utf8.RuneCount(view.Buf.lines[i].data), i}
-
-			deltas = append(deltas, Delta{string(newText), from, to})
-		}
-		view.Buf.MultipleReplace(deltas)
-	}
-
-	if all {
-		replaceAll()
-	} else {
+	if strings.Contains(flags, "c") {
 		for {
 			// The 'check' flag was used
 			Search(search, view, true)
@@ -613,8 +275,11 @@ func Replace(args []string) {
 				break
 			}
 			view.Relocate()
+			if view.Buf.Settings["syntax"].(bool) {
+				view.matches = Match(view)
+			}
 			RedrawAll()
-			choice, canceled := messenger.LetterPrompt("Perform replacement? (y,n,a)", 'y', 'n', 'a')
+			choice, canceled := messenger.YesNoPrompt("Perform replacement? (y,n)")
 			if canceled {
 				if view.Cursor.HasSelection() {
 					view.Cursor.Loc = view.Cursor.CurSelection[0]
@@ -622,27 +287,31 @@ func Replace(args []string) {
 				}
 				messenger.Reset()
 				break
-			} else if choice == 'a' {
-				if view.Cursor.HasSelection() {
-					view.Cursor.Loc = view.Cursor.CurSelection[0]
-					view.Cursor.ResetSelection()
-				}
-				messenger.Reset()
-				replaceAll()
-				break
-			} else if choice == 'y' {
+			}
+			if choice {
 				view.Cursor.DeleteSelection()
 				view.Buf.Insert(view.Cursor.Loc, replace)
 				view.Cursor.ResetSelection()
 				messenger.Reset()
 				found++
-			}
-			if view.Cursor.HasSelection() {
-				searchStart = view.Cursor.CurSelection[1]
 			} else {
-				searchStart = view.Cursor.Loc
+				if view.Cursor.HasSelection() {
+					searchStart = ToCharPos(view.Cursor.CurSelection[1], view.Buf)
+				} else {
+					searchStart = ToCharPos(view.Cursor.Loc, view.Buf)
+				}
+				continue
 			}
 		}
+	} else {
+		for {
+			match := regex.FindStringIndex(view.Buf.String())
+			if match == nil {
+				break
+			}
+			found++
+			view.Buf.Replace(FromCharPos(match[0], view.Buf), FromCharPos(match[1], view.Buf), replace)
+		}
 	}
 	view.Cursor.Relocate()
 
@@ -655,33 +324,83 @@ func Replace(args []string) {
 	}
 }
 
-// ReplaceAll replaces search term all at once
-func ReplaceAll(args []string) {
-	// aliased to Replace command
-	Replace(append(args, "-a"))
+// RunShellCommand executes a shell command and returns the output/error
+func RunShellCommand(input string) (string, error) {
+	inputCmd := SplitCommandArgs(input)[0]
+	args := SplitCommandArgs(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
 }
 
-// Term opens a terminal in the current view
-func Term(args []string) {
-	var err error
-	if len(args) == 0 {
-		err = CurView().StartTerminal([]string{os.Getenv("SHELL"), "-i"}, true, false, "")
+// 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 := SplitCommandArgs(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 {
-		err = CurView().StartTerminal(args, true, false, "")
-	}
-	if err != nil {
-		messenger.Error(err)
+		// Shut down the screen because we're going to interact directly with the shell
+		screen.Fini()
+		screen = nil
+
+		args := SplitCommandArgs(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) {
-	args, err := shellwords.Split(input)
-	if err != nil {
-		messenger.Error("Error parsing args ", err)
-		return
-	}
-
+	args := SplitCommandArgs(input)
 	inputCmd := args[0]
 
 	if _, ok := commands[inputCmd]; !ok {

cmd/micro/cursor.go

@@ -1,8 +1,6 @@
 package main
 
-import (
-	"github.com/zyedidia/clipboard"
-)
+import "github.com/zyedidia/clipboard"
 
 // The Cursor struct stores the location of the cursor in the view
 // The complicated part about the cursor is storing its location.
@@ -23,35 +21,14 @@ type Cursor struct {
 	// 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
 }
 
-// Goto puts the cursor at the given cursor's location and gives
-// the current cursor its selection too
+// 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.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(c.GetSelection(), target)
-		}
-	}
-}
-
 // ResetSelection resets the user's selection
 func (c *Cursor) ResetSelection() {
 	c.CurSelection[0] = c.buf.Start()
@@ -61,11 +38,19 @@ func (c *Cursor) ResetSelection() {
 // SetSelectionStart sets the start of the selection
 func (c *Cursor) SetSelectionStart(pos Loc) {
 	c.CurSelection[0] = pos
+	// Copy to primary clipboard for linux
+	if c.HasSelection() {
+		clipboard.WriteAll(c.GetSelection(), "primary")
+	}
 }
 
 // SetSelectionEnd sets the end of the selection
 func (c *Cursor) SetSelectionEnd(pos Loc) {
 	c.CurSelection[1] = pos
+	// Copy to primary clipboard for linux
+	if c.HasSelection() {
+		clipboard.WriteAll(c.GetSelection(), "primary")
+	}
 }
 
 // HasSelection returns whether or not the user has selected anything
@@ -88,13 +73,10 @@ func (c *Cursor) DeleteSelection() {
 
 // GetSelection returns the cursor's selection
 func (c *Cursor) GetSelection() string {
-	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])
+	if c.CurSelection[0].GreaterThan(c.CurSelection[1]) {
+		return c.buf.Substr(c.CurSelection[1], c.CurSelection[0])
 	}
-	return ""
+	return c.buf.Substr(c.CurSelection[0], c.CurSelection[1])
 }
 
 // SelectLine selects the current line
@@ -160,8 +142,7 @@ func (c *Cursor) SelectWord() {
 	c.Loc = c.CurSelection[1]
 }
 
-// AddWordToSelection adds the word the cursor is currently on
-// to the selection
+// 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
@@ -193,8 +174,7 @@ func (c *Cursor) AddWordToSelection() {
 	c.Loc = c.CurSelection[1]
 }
 
-// SelectTo selects from the current cursor location to the given
-// location
+// 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])
@@ -261,19 +241,19 @@ func (c *Cursor) UpN(amount int) {
 	proposedY := c.Y - amount
 	if proposedY < 0 {
 		proposedY = 0
-		c.LastVisualX = 0
 	} else if proposedY >= c.buf.NumLines {
 		proposedY = c.buf.NumLines - 1
 	}
-
-	runes := []rune(c.buf.Line(c.Y))
-	c.X = c.GetCharPosInLine(proposedY, c.LastVisualX)
-
-	if c.X > len(runes) || (amount < 0 && proposedY == c.Y) {
-		c.X = len(runes)
+	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)
@@ -291,8 +271,7 @@ 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
+// 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
@@ -306,8 +285,7 @@ func (c *Cursor) Left() {
 	c.LastVisualX = c.GetVisualX()
 }
 
-// Right moves the cursor right one cell (if possible) or
-// to the next line if it is at the end
+// 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
@@ -333,21 +311,7 @@ func (c *Cursor) Start() {
 	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 IsWhitespace(c.RuneUnder(c.X)) {
-		if c.X == Count(c.buf.Line(c.Y)) {
-			break
-		}
-		c.Right()
-	}
-}
-
-// GetCharPosInLine gets the char position of a visual x y
-// coordinate (this is necessary because tabs are 1 char but
-// 4 visual spaces)
+// 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))
@@ -366,25 +330,11 @@ func (c *Cursor) GetCharPosInLine(lineNum, visualPos int) int {
 func (c *Cursor) GetVisualX() int {
 	runes := []rune(c.buf.Line(c.Y))
 	tabSize := int(c.buf.Settings["tabsize"].(float64))
-	if c.X > len(runes) {
-		c.X = len(runes) - 1
-	}
-
-	if c.X < 0 {
-		c.X = 0
-	}
-
 	return StringWidth(string(runes[:c.X]), tabSize)
 }
 
-// StoreVisualX stores the current visual x value in the cursor
-func (c *Cursor) StoreVisualX() {
-	c.LastVisualX = c.GetVisualX()
-}
-
-// 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
+// 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

cmd/micro/eventhandler.go

@@ -1,22 +1,18 @@
 package main
 
 import (
-	"strings"
 	"time"
 
 	dmp "github.com/sergi/go-diff/diffmatchpatch"
-	"github.com/yuin/gopher-lua"
 )
 
 const (
 	// Opposite and undoing events must have opposite values
 
-	// TextEventInsert represents an insertion event
+	// TextEventInsert repreasents an insertion event
 	TextEventInsert = 1
 	// TextEventRemove represents a deletion event
 	TextEventRemove = -1
-	// TextEventReplace represents a replace event
-	TextEventReplace = 0
 )
 
 // TextEvent holds data for a manipulation on some text that can be undone
@@ -24,37 +20,18 @@ type TextEvent struct {
 	C Cursor
 
 	EventType int
-	Deltas    []Delta
+	Text      string
+	Start     Loc
+	End       Loc
 	Time      time.Time
 }
 
-// A Delta is a change to the buffer
-type Delta struct {
-	Text  string
-	Start Loc
-	End   Loc
-}
-
 // ExecuteTextEvent runs a text event
 func ExecuteTextEvent(t *TextEvent, buf *Buffer) {
 	if t.EventType == TextEventInsert {
-		for _, d := range t.Deltas {
-			buf.insert(d.Start, []byte(d.Text))
-		}
+		buf.insert(t.Start, []byte(t.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, []byte(d.Text))
-			t.Deltas[i].Start = d.Start
-			t.Deltas[i].End = Loc{d.Start.X + Count(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]
-		}
+		t.Text = buf.remove(t.Start, t.End)
 	}
 }
 
@@ -103,67 +80,23 @@ func (eh *EventHandler) ApplyDiff(new string) {
 // Insert creates an insert text event and executes it
 func (eh *EventHandler) Insert(start Loc, text string) {
 	e := &TextEvent{
-		C:         *eh.buf.cursors[eh.buf.curCursor],
+		C:         eh.buf.Cursor,
 		EventType: TextEventInsert,
-		Deltas:    []Delta{{text, start, Loc{0, 0}}},
+		Text:      text,
+		Start:     start,
 		Time:      time.Now(),
 	}
 	eh.Execute(e)
-	e.Deltas[0].End = start.Move(Count(text), eh.buf)
-	end := e.Deltas[0].End
-
-	for _, c := range eh.buf.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.Move(Count(text), eh.buf)
-			}
-			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()
-	}
+	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.cursors[eh.buf.curCursor],
+		C:         eh.buf.Cursor,
 		EventType: TextEventRemove,
-		Deltas:    []Delta{{"", start, end}},
-		Time:      time.Now(),
-	}
-	eh.Execute(e)
-
-	for _, c := range eh.buf.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.Move(-Diff(start, end, eh.buf), eh.buf)
-			}
-			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.buf.cursors[eh.buf.curCursor],
-		EventType: TextEventReplace,
-		Deltas:    deltas,
+		Start:     start,
+		End:       end,
 		Time:      time.Now(),
 	}
 	eh.Execute(e)
@@ -181,17 +114,6 @@ func (eh *EventHandler) Execute(t *TextEvent) {
 		eh.RedoStack = new(Stack)
 	}
 	eh.UndoStack.Push(t)
-
-	for pl := range loadedPlugins {
-		ret, err := Call(pl+".onBeforeTextEvent", t)
-		if err != nil && !strings.HasPrefix(err.Error(), "function does not exist") {
-			TermMessage(err)
-		}
-		if val, ok := ret.(lua.LBool); ok && val == lua.LFalse {
-			return
-		}
-	}
-
 	ExecuteTextEvent(t, eh.buf)
 }
 
@@ -236,12 +158,8 @@ func (eh *EventHandler) UndoOneEvent() {
 
 	// Set the cursor in the right place
 	teCursor := t.C
-	if teCursor.Num >= 0 && teCursor.Num < len(eh.buf.cursors) {
-		t.C = *eh.buf.cursors[teCursor.Num]
-		eh.buf.cursors[teCursor.Num].Goto(teCursor)
-	} else {
-		teCursor.Num = -1
-	}
+	t.C = eh.buf.Cursor
+	eh.buf.Cursor.Goto(teCursor)
 
 	// Push it to the redo stack
 	eh.RedoStack.Push(t)
@@ -283,12 +201,8 @@ func (eh *EventHandler) RedoOneEvent() {
 	UndoTextEvent(t, eh.buf)
 
 	teCursor := t.C
-	if teCursor.Num >= 0 && teCursor.Num < len(eh.buf.cursors) {
-		t.C = *eh.buf.cursors[teCursor.Num]
-		eh.buf.cursors[teCursor.Num].Goto(teCursor)
-	} else {
-		teCursor.Num = -1
-	}
+	t.C = eh.buf.Cursor
+	eh.buf.Cursor.Goto(teCursor)
 
 	eh.UndoStack.Push(t)
 }

cmd/micro/help.go

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

cmd/micro/highlight/ftdetect.go

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

cmd/micro/highlight/highlighter.go

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

cmd/micro/highlight/parser.go

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

cmd/micro/highlighter.go

@@ -1,28 +1,499 @@
 package main
 
-import "github.com/zyedidia/micro/cmd/micro/highlight"
+import (
+	"github.com/zyedidia/tcell"
+	"io/ioutil"
+	"path/filepath"
+	"regexp"
+	"strings"
+)
 
-var syntaxFiles []*highlight.File
+// 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",
+	"caddyfile",
+	"cmake",
+	"coffeescript",
+	"colortest",
+	"conf",
+	"conky",
+	"csharp",
+	"css",
+	"cython",
+	"d",
+	"dart",
+	"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",
+	"micro",
+	"nanorc",
+	"nginx",
+	"ocaml",
+	"pascal",
+	"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() {
-	InitColorscheme()
-	for _, f := range ListRuntimeFiles(RTSyntax) {
-		data, err := f.Data()
+	// 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("Error loading syntax file " + f.Name() + ": " + err.Error())
-		} else {
-			LoadSyntaxFile(data, f.Name())
+			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)
 		}
 	}
 }
 
-func LoadSyntaxFile(text []byte, filename string) {
-	f, err := highlight.ParseFile(text)
+// 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
+}
 
-	if err != nil {
-		TermMessage("Syntax file error: " + filename + ": " + err.Error())
-		return
+// 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
 	}
 
-	syntaxFiles = append(syntaxFiles, f)
+	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/job.go

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

cmd/micro/keymenu.go

@@ -1,20 +0,0 @@
-package main
-
-// DisplayKeyMenu displays the nano-style key menu at the bottom of the screen
-func DisplayKeyMenu() {
-	w, h := screen.Size()
-
-	bot := h - 3
-
-	display := []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"}
-
-	for y := 0; y < len(display); y++ {
-		for x := 0; x < w; x++ {
-			if x < len(display[y]) {
-				screen.SetContent(x, bot+y, rune(display[y][x]), nil, defStyle)
-			} else {
-				screen.SetContent(x, bot+y, ' ', nil, defStyle)
-			}
-		}
-	}
-}

cmd/micro/lineArray.go

@@ -1,11 +1,8 @@
 package main
 
 import (
-	"bufio"
-	"io"
+	"bytes"
 	"unicode/utf8"
-
-	"github.com/zyedidia/micro/cmd/micro/highlight"
 )
 
 func runeToByteIndex(n int, txt []byte) int {
@@ -29,87 +26,21 @@ func runeToByteIndex(n int, txt []byte) int {
 	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
-}
-
 // A LineArray simply stores and array of lines and makes it easy to insert
 // and delete in it
 type LineArray struct {
-	lines []Line
-}
-
-// 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)
-		// The copy function is predeclared and works for any slice type.
-		copy(newSlice, slice)
-		slice = newSlice
-	}
-	slice = slice[0 : l+len(data)]
-	for i, c := range data {
-		slice[l+i] = c
-	}
-	return slice
+	lines [][]byte
 }
 
 // NewLineArray returns a new line array from an array of bytes
-func NewLineArray(size int64, reader io.Reader) *LineArray {
+func NewLineArray(text []byte) *LineArray {
 	la := new(LineArray)
-
-	la.lines = make([]Line, 0, 1000)
-
-	br := bufio.NewReader(reader)
-	var loaded int
-
-	n := 0
-	for {
-		data, err := br.ReadBytes('\n')
-		if len(data) > 1 && data[len(data)-2] == '\r' {
-			data = append(data[:len(data)-2], '\n')
-			if fileformat == 0 {
-				fileformat = 2
-			}
-		} else if len(data) > 0 {
-			if fileformat == 0 {
-				fileformat = 1
-			}
-		}
-
-		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
-		}
-
-		if loaded >= 0 {
-			loaded += len(data)
-		}
-
-		if err != nil {
-			if err == io.EOF {
-				la.lines = Append(la.lines, Line{data[:], nil, nil, false})
-				// la.lines = Append(la.lines, Line{data[:len(data)]})
-			}
-			// Last line was read
-			break
-		} else {
-			// la.lines = Append(la.lines, Line{data[:len(data)-1]})
-			la.lines = Append(la.lines, Line{data[:len(data)-1], nil, nil, false})
-		}
-		n++
+	// 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
@@ -117,43 +48,19 @@ func NewLineArray(size int64, reader io.Reader) *LineArray {
 
 // Returns the String representation of the LineArray
 func (la *LineArray) String() string {
-	str := ""
-	for i, l := range la.lines {
-		str += string(l.data)
-		if i != len(la.lines)-1 {
-			str += "\n"
-		}
-	}
-	return str
-}
-
-// SaveString returns the string that should be written to disk when
-// the line array is saved
-// It is the same as string but uses crlf or lf line endings depending
-func (la *LineArray) SaveString(useCrlf bool) string {
-	str := ""
-	for i, l := range la.lines {
-		str += string(l.data)
-		if i != len(la.lines)-1 {
-			if useCrlf {
-				str += "\r"
-			}
-			str += "\n"
-		}
-	}
-	return str
+	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, Line{[]byte{' '}, nil, nil, false})
+	la.lines = append(la.lines, []byte(" "))
 	copy(la.lines[y+2:], la.lines[y+1:])
-	la.lines[y+1] = Line{[]byte{}, la.lines[y].state, nil, false}
+	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].data), pos.Y
+	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' {
@@ -169,36 +76,31 @@ func (la *LineArray) insert(pos Loc, value []byte) {
 
 // inserts a byte at a given location
 func (la *LineArray) insertByte(pos Loc, value byte) {
-	la.lines[pos.Y].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
+	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].data), a}, la.lines[b].data)
+	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].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.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].data)
-	endX := runeToByteIndex(end.X, la.lines[end.Y].data)
+	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].data = append(la.lines[start.Y].data[:startX], la.lines[start.Y].data[endX:]...)
+		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)
@@ -212,12 +114,12 @@ func (la *LineArray) remove(start, end Loc) string {
 
 // DeleteToEnd deletes from the end of a line to the position
 func (la *LineArray) DeleteToEnd(pos Loc) {
-	la.lines[pos.Y].data = la.lines[pos.Y].data[:pos.X]
+	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].data = la.lines[pos.Y].data[pos.X+1:]
+	la.lines[pos.Y] = la.lines[pos.Y][pos.X+1:]
 }
 
 // DeleteLine deletes the line number
@@ -227,41 +129,21 @@ func (la *LineArray) DeleteLine(y int) {
 
 // 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:])]
+	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].data)
-	endX := runeToByteIndex(end.X, la.lines[end.Y].data)
+	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].data[startX:endX])
+		return string(la.lines[start.Y][startX:endX])
 	}
 	var str string
-	str += string(la.lines[start.Y].data[startX:]) + "\n"
+	str += string(la.lines[start.Y][startX:]) + "\n"
 	for i := start.Y + 1; i <= end.Y-1; i++ {
-		str += string(la.lines[i].data) + "\n"
+		str += string(la.lines[i]) + "\n"
 	}
-	str += string(la.lines[end.Y].data[:endX])
+	str += string(la.lines[end.Y][:endX])
 	return str
 }
-
-// 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
-}

cmd/micro/loc.go

@@ -28,55 +28,11 @@ func ToCharPos(start Loc, buf *Buffer) int {
 	return loc
 }
 
-// InBounds returns whether the given location is a valid character position in the given buffer
-func InBounds(pos Loc, buf *Buffer) bool {
-	if pos.Y < 0 || pos.Y >= buf.NumLines || pos.X < 0 || pos.X > Count(buf.Line(pos.Y)) {
-		return false
-	}
-
-	return true
-}
-
-// ByteOffset is just like ToCharPos except it counts bytes instead of runes
-func ByteOffset(pos Loc, buf *Buffer) int {
-	x, y := pos.X, pos.Y
-	loc := 0
-	for i := 0; i < y; i++ {
-		// + 1 for the newline
-		loc += len(buf.Line(i)) + 1
-	}
-	loc += len(buf.Line(y)[:x])
-	return loc
-}
-
 // Loc stores a location
 type Loc struct {
 	X, Y int
 }
 
-// Diff returns the distance between two locations
-func Diff(a, b Loc, buf *Buffer) int {
-	if a.Y == b.Y {
-		if a.X > b.X {
-			return a.X - b.X
-		}
-		return b.X - a.X
-	}
-
-	// 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 += Count(buf.Line(i)) + 1
-	}
-	loc += Count(buf.Line(a.Y)) - a.X + b.X + 1
-	return loc
-}
-
 // LessThan returns true if b is smaller
 func (l Loc) LessThan(b Loc) bool {
 	if l.Y < b.Y {

cmd/micro/lua.go

@@ -1,539 +0,0 @@
-package main
-
-import (
-	"errors"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"math"
-	"math/rand"
-	"net"
-	"os"
-	"path"
-	"path/filepath"
-	"regexp"
-	"runtime"
-	"strings"
-	"time"
-
-	luar "layeh.com/gopher-luar"
-
-	lua "github.com/yuin/gopher-lua"
-)
-
-var L *lua.LState
-
-func init() {
-	L = lua.NewState()
-	L.SetGlobal("import", luar.New(L, Import))
-}
-
-// LoadFile loads a lua file
-func LoadFile(module string, file string, data string) error {
-	pluginDef := "local P = {};" + module + " = P;setmetatable(" + module + ", {__index = _G});setfenv(1, P);"
-
-	if fn, err := L.Load(strings.NewReader(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 "filepath":
-		return importFilePath()
-	case "strings":
-		return importStrings()
-	case "regexp":
-		return importRegexp()
-	case "errors":
-		return importErrors()
-	case "time":
-		return importTime()
-	default:
-		return nil
-	}
-}
-
-func importFmt() *lua.LTable {
-	pkg := L.NewTable()
-
-	L.SetField(pkg, "tErrorf", 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
-}

cmd/micro/messenger.go

@@ -3,14 +3,11 @@ package main
 import (
 	"bufio"
 	"bytes"
-	"encoding/gob"
 	"fmt"
 	"os"
 	"strconv"
 
-	"github.com/mattn/go-runewidth"
 	"github.com/zyedidia/clipboard"
-	"github.com/zyedidia/micro/cmd/micro/shellwords"
 	"github.com/zyedidia/tcell"
 )
 
@@ -24,7 +21,6 @@ func TermMessage(msg ...interface{}) {
 	screenWasNil := screen == nil
 	if !screenWasNil {
 		screen.Fini()
-		screen = nil
 	}
 
 	fmt.Println(msg...)
@@ -47,7 +43,6 @@ func TermError(filename string, lineNum int, err string) {
 // Messenger is an object that makes it easy to send messages to the user
 // and get input from the user
 type Messenger struct {
-	log *Buffer
 	// Are we currently prompting the user?
 	hasPrompt bool
 	// Is there a message to print
@@ -72,87 +67,38 @@ type Messenger struct {
 	gutterMessage bool
 }
 
-// AddLog sends a message to the log view
-func (m *Messenger) AddLog(msg ...interface{}) {
-	logMessage := fmt.Sprint(msg...)
-	buffer := m.getBuffer()
-	buffer.insert(buffer.End(), []byte(logMessage+"\n"))
-	buffer.Cursor.Loc = buffer.End()
-	buffer.Cursor.Relocate()
-}
-
-func (m *Messenger) getBuffer() *Buffer {
-	if m.log == nil {
-		m.log = NewBufferFromString("", "")
-		m.log.name = "Log"
-	}
-	return m.log
-}
-
 // Message sends a message to the user
 func (m *Messenger) Message(msg ...interface{}) {
-	displayMessage := fmt.Sprint(msg...)
-	// only display a new message if there isn't an active prompt
-	// this is to prevent overwriting an existing prompt to the user
-	if m.hasPrompt == false {
-		// if there is no active prompt then style and display the message as normal
-		m.message = displayMessage
+	buf := new(bytes.Buffer)
+	fmt.Fprint(buf, msg...)
+	m.message = buf.String()
+	m.style = defStyle
 
-		m.style = defStyle
-
-		if _, ok := colorscheme["message"]; ok {
-			m.style = colorscheme["message"]
-		}
-
-		m.hasMessage = true
+	if _, ok := colorscheme["message"]; ok {
+		m.style = colorscheme["message"]
 	}
-	// add the message to the log regardless of active prompts
-	m.AddLog(displayMessage)
+	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)
 
-	// only display a new message if there isn't an active prompt
-	// this is to prevent overwriting an existing prompt to the user
-	if m.hasPrompt == false {
-		// if there is no active prompt then style and display the message as normal
-		m.message = buf.String()
-		m.style = defStyle.
-			Foreground(tcell.ColorBlack).
-			Background(tcell.ColorMaroon)
-
-		if _, ok := colorscheme["error-message"]; ok {
-			m.style = colorscheme["error-message"]
-		}
-		m.hasMessage = true
+	if _, ok := colorscheme["error-message"]; ok {
+		m.style = colorscheme["error-message"]
 	}
-	// add the message to the log regardless of active prompts
-	m.AddLog(buf.String())
-}
-
-func (m *Messenger) PromptText(msg ...interface{}) {
-	displayMessage := fmt.Sprint(msg...)
-	// if there is no active prompt then style and display the message as normal
-	m.message = displayMessage
-
-	m.style = defStyle
-
-	if _, ok := colorscheme["message"]; ok {
-		m.style = colorscheme["message"]
-	}
-
 	m.hasMessage = true
-	// add the message to the log regardless of active prompts
-	m.AddLog(displayMessage)
 }
 
 // YesNoPrompt asks the user a yes or no question (waits for y or n) and returns the result
 func (m *Messenger) YesNoPrompt(prompt string) (bool, bool) {
 	m.hasPrompt = true
-	m.PromptText(prompt)
+	m.Message(prompt)
 
 	_, h := screen.Size()
 	for {
@@ -166,19 +112,14 @@ func (m *Messenger) YesNoPrompt(prompt string) (bool, bool) {
 		case *tcell.EventKey:
 			switch e.Key() {
 			case tcell.KeyRune:
-				if e.Rune() == 'y' || e.Rune() == 'Y' {
-					m.AddLog("\t--> y")
+				if e.Rune() == 'y' {
 					m.hasPrompt = false
 					return true, false
-				} else if e.Rune() == 'n' || e.Rune() == 'N' {
-					m.AddLog("\t--> n")
+				} else if e.Rune() == 'n' {
 					m.hasPrompt = false
 					return false, false
 				}
 			case tcell.KeyCtrlC, tcell.KeyCtrlQ, tcell.KeyEscape:
-				m.AddLog("\t--> (cancel)")
-				m.Clear()
-				m.Reset()
 				m.hasPrompt = false
 				return false, true
 			}
@@ -189,7 +130,7 @@ func (m *Messenger) YesNoPrompt(prompt string) (bool, bool) {
 // LetterPrompt gives the user a prompt and waits for a one letter response
 func (m *Messenger) LetterPrompt(prompt string, responses ...rune) (rune, bool) {
 	m.hasPrompt = true
-	m.PromptText(prompt)
+	m.Message(prompt)
 
 	_, h := screen.Size()
 	for {
@@ -205,7 +146,6 @@ func (m *Messenger) LetterPrompt(prompt string, responses ...rune) (rune, bool)
 			case tcell.KeyRune:
 				for _, r := range responses {
 					if e.Rune() == r {
-						m.AddLog("\t--> " + string(r))
 						m.Clear()
 						m.Reset()
 						m.hasPrompt = false
@@ -213,7 +153,6 @@ func (m *Messenger) LetterPrompt(prompt string, responses ...rune) (rune, bool)
 					}
 				}
 			case tcell.KeyCtrlC, tcell.KeyCtrlQ, tcell.KeyEscape:
-				m.AddLog("\t--> (cancel)")
 				m.Clear()
 				m.Reset()
 				m.hasPrompt = false
@@ -223,7 +162,6 @@ func (m *Messenger) LetterPrompt(prompt string, responses ...rune) (rune, bool)
 	}
 }
 
-// Completion represents a type of completion
 type Completion int
 
 const (
@@ -232,16 +170,13 @@ const (
 	CommandCompletion
 	HelpCompletion
 	OptionCompletion
-	PluginCmdCompletion
-	PluginNameCompletion
-	OptionValueCompletion
 )
 
 // 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, placeholder, historyType string, completionTypes ...Completion) (string, bool) {
+func (m *Messenger) Prompt(prompt, historyType string, completionTypes ...Completion) (string, bool) {
 	m.hasPrompt = true
-	m.PromptText(prompt)
+	m.Message(prompt)
 	if _, ok := m.history[historyType]; !ok {
 		m.history[historyType] = []string{""}
 	} else {
@@ -249,9 +184,7 @@ func (m *Messenger) Prompt(prompt, placeholder, historyType string, completionTy
 	}
 	m.historyNum = len(m.history[historyType]) - 1
 
-	response, canceled := placeholder, true
-	m.response = response
-	m.cursorx = Count(placeholder)
+	response, canceled := "", true
 
 	RedrawAll()
 	for m.hasPrompt {
@@ -261,34 +194,20 @@ func (m *Messenger) Prompt(prompt, placeholder, historyType string, completionTy
 		event := <-events
 
 		switch e := event.(type) {
-		case *tcell.EventResize:
-			for _, t := range tabs {
-				t.Resize()
-			}
-			RedrawAll()
 		case *tcell.EventKey:
 			switch e.Key() {
 			case tcell.KeyCtrlQ, tcell.KeyCtrlC, tcell.KeyEscape:
 				// Cancel
-				m.AddLog("\t--> (cancel)")
 				m.hasPrompt = false
 			case tcell.KeyEnter:
 				// User is done entering their response
-				m.AddLog("\t--> " + m.response)
 				m.hasPrompt = false
 				response, canceled = m.response, false
 				m.history[historyType][len(m.history[historyType])-1] = response
 			case tcell.KeyTab:
-				args, err := shellwords.Split(m.response)
-				if err != nil {
-					break
-				}
-				currentArg := ""
-				currentArgNum := 0
-				if len(args) > 0 {
-					currentArgNum = len(args) - 1
-					currentArg = args[currentArgNum]
-				}
+				args := SplitCommandArgs(m.response)
+				currentArgNum := len(args) - 1
+				currentArg := args[currentArgNum]
 				var completionType Completion
 
 				if completionTypes[0] == CommandCompletion && currentArgNum > 0 {
@@ -312,14 +231,6 @@ func (m *Messenger) Prompt(prompt, placeholder, historyType string, completionTy
 					chosen, suggestions = HelpComplete(currentArg)
 				} else if completionType == OptionCompletion {
 					chosen, suggestions = OptionComplete(currentArg)
-				} else if completionType == OptionValueCompletion {
-					if currentArgNum-1 > 0 {
-						chosen, suggestions = OptionValueComplete(args[currentArgNum-1], currentArg)
-					}
-				} else if completionType == PluginCmdCompletion {
-					chosen, suggestions = PluginCmdComplete(currentArg)
-				} else if completionType == PluginNameCompletion {
-					chosen, suggestions = PluginNameComplete(currentArg)
 				} else if completionType < NoCompletion {
 					chosen, suggestions = PluginComplete(completionType, currentArg)
 				}
@@ -328,8 +239,8 @@ func (m *Messenger) Prompt(prompt, placeholder, historyType string, completionTy
 					chosen = chosen + CommonSubstring(suggestions...)
 				}
 
-				if len(suggestions) != 0 && chosen != "" {
-					m.response = shellwords.Join(append(args[:len(args)-1], chosen)...)
+				if chosen != "" {
+					m.response = JoinCommandArgs(append(args[:len(args)-1], chosen)...)
 					m.cursorx = Count(m.response)
 				}
 			}
@@ -338,7 +249,7 @@ func (m *Messenger) Prompt(prompt, placeholder, historyType string, completionTy
 		m.HandleEvent(event, m.history[historyType])
 
 		m.Clear()
-		for _, v := range tabs[curTab].Views {
+		for _, v := range tabs[curTab].views {
 			v.Display()
 		}
 		DisplayTabs()
@@ -354,160 +265,40 @@ func (m *Messenger) Prompt(prompt, placeholder, historyType string, completionTy
 	return response, canceled
 }
 
-// UpHistory fetches the previous item in the history
-func (m *Messenger) UpHistory(history []string) {
-	if m.historyNum > 0 {
-		m.historyNum--
-		m.response = history[m.historyNum]
-		m.cursorx = Count(m.response)
-	}
-}
-
-// DownHistory fetches the next item in the history
-func (m *Messenger) DownHistory(history []string) {
-	if m.historyNum < len(history)-1 {
-		m.historyNum++
-		m.response = history[m.historyNum]
-		m.cursorx = Count(m.response)
-	}
-}
-
-// CursorLeft moves the cursor one character left
-func (m *Messenger) CursorLeft() {
-	if m.cursorx > 0 {
-		m.cursorx--
-	}
-}
-
-// CursorRight moves the cursor one character right
-func (m *Messenger) CursorRight() {
-	if m.cursorx < Count(m.response) {
-		m.cursorx++
-	}
-}
-
-// Start moves the cursor to the start of the line
-func (m *Messenger) Start() {
-	m.cursorx = 0
-}
-
-// End moves the cursor to the end of the line
-func (m *Messenger) End() {
-	m.cursorx = Count(m.response)
-}
-
-// Backspace deletes one character
-func (m *Messenger) Backspace() {
-	if m.cursorx > 0 {
-		m.response = string([]rune(m.response)[:m.cursorx-1]) + string([]rune(m.response)[m.cursorx:])
-		m.cursorx--
-	}
-}
-
-// Paste pastes the clipboard
-func (m *Messenger) Paste() {
-	clip, _ := clipboard.ReadAll("clipboard")
-	m.response = Insert(m.response, m.cursorx, clip)
-	m.cursorx += Count(clip)
-}
-
-// WordLeft moves the cursor one word to the left
-func (m *Messenger) WordLeft() {
-	response := []rune(m.response)
-	m.CursorLeft()
-	if m.cursorx <= 0 {
-		return
-	}
-	for IsWhitespace(response[m.cursorx]) {
-		if m.cursorx <= 0 {
-			return
-		}
-		m.CursorLeft()
-	}
-	m.CursorLeft()
-	for IsWordChar(string(response[m.cursorx])) {
-		if m.cursorx <= 0 {
-			return
-		}
-		m.CursorLeft()
-	}
-	m.CursorRight()
-}
-
-// WordRight moves the cursor one word to the right
-func (m *Messenger) WordRight() {
-	response := []rune(m.response)
-	if m.cursorx >= len(response) {
-		return
-	}
-	for IsWhitespace(response[m.cursorx]) {
-		m.CursorRight()
-		if m.cursorx >= len(response) {
-			m.CursorRight()
-			return
-		}
-	}
-	m.CursorRight()
-	if m.cursorx >= len(response) {
-		return
-	}
-	for IsWordChar(string(response[m.cursorx])) {
-		m.CursorRight()
-		if m.cursorx >= len(response) {
-			return
-		}
-	}
-}
-
-// DeleteWordLeft deletes one word to the left
-func (m *Messenger) DeleteWordLeft() {
-	m.WordLeft()
-	m.response = string([]rune(m.response)[:m.cursorx])
-}
-
 // 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.KeyCtrlA:
-			m.Start()
-		case tcell.KeyCtrlE:
-			m.End()
 		case tcell.KeyUp:
-			m.UpHistory(history)
+			if m.historyNum > 0 {
+				m.historyNum--
+				m.response = history[m.historyNum]
+				m.cursorx = Count(m.response)
+			}
 		case tcell.KeyDown:
-			m.DownHistory(history)
+			if m.historyNum < len(history)-1 {
+				m.historyNum++
+				m.response = history[m.historyNum]
+				m.cursorx = Count(m.response)
+			}
 		case tcell.KeyLeft:
-			if e.Modifiers() == tcell.ModCtrl {
-				m.Start()
-			} else if e.Modifiers() == tcell.ModAlt || e.Modifiers() == tcell.ModMeta {
-				m.WordLeft()
-			} else {
-				m.CursorLeft()
+			if m.cursorx > 0 {
+				m.cursorx--
 			}
 		case tcell.KeyRight:
-			if e.Modifiers() == tcell.ModCtrl {
-				m.End()
-			} else if e.Modifiers() == tcell.ModAlt || e.Modifiers() == tcell.ModMeta {
-				m.WordRight()
-			} else {
-				m.CursorRight()
+			if m.cursorx < Count(m.response) {
+				m.cursorx++
 			}
 		case tcell.KeyBackspace2, tcell.KeyBackspace:
-			if e.Modifiers() == tcell.ModCtrl || e.Modifiers() == tcell.ModAlt || e.Modifiers() == tcell.ModMeta {
-				m.DeleteWordLeft()
-			} else {
-				m.Backspace()
+			if m.cursorx > 0 {
+				m.response = string([]rune(m.response)[:m.cursorx-1]) + string([]rune(m.response)[m.cursorx:])
+				m.cursorx--
 			}
-		case tcell.KeyCtrlW:
-			m.DeleteWordLeft()
 		case tcell.KeyCtrlV:
-			m.Paste()
-		case tcell.KeyCtrlF:
-			m.WordRight()
-		case tcell.KeyCtrlB:
-			m.WordLeft()
+			clip, _ := clipboard.ReadAll("clipboard")
+			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++
@@ -518,23 +309,6 @@ func (m *Messenger) HandleEvent(event tcell.Event, history []string) {
 		clip := e.Text()
 		m.response = Insert(m.response, m.cursorx, clip)
 		m.cursorx += Count(clip)
-	case *tcell.EventMouse:
-		x, y := e.Position()
-		x -= Count(m.message)
-		button := e.Buttons()
-		_, screenH := screen.Size()
-
-		if y == screenH-1 {
-			switch button {
-			case tcell.Button1:
-				m.cursorx = x
-				if m.cursorx < 0 {
-					m.cursorx = 0
-				} else if m.cursorx > Count(m.response) {
-					m.cursorx = Count(m.response)
-				}
-			}
-		}
 	}
 }
 
@@ -584,10 +358,8 @@ func (m *Messenger) Display() {
 	if m.hasMessage {
 		if m.hasPrompt || globalSettings["infobar"].(bool) {
 			runes := []rune(m.message + m.response)
-			posx := 0
 			for x := 0; x < len(runes); x++ {
-				screen.SetContent(posx, h-1, runes[x], nil, m.style)
-				posx += runewidth.RuneWidth(runes[x])
+				screen.SetContent(x, h-1, runes[x], nil, m.style)
 			}
 		}
 	}
@@ -598,59 +370,6 @@ func (m *Messenger) Display() {
 	}
 }
 
-// LoadHistory attempts to load user history from configDir/buffers/history
-// into the history map
-// The savehistory option must be on
-func (m *Messenger) LoadHistory() {
-	if GetGlobalOption("savehistory").(bool) {
-		file, err := os.Open(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 {
-				m.Error("Error loading history:", err)
-				return
-			}
-		}
-
-		if decodedMap != nil {
-			m.history = decodedMap
-		} else {
-			m.history = make(map[string][]string)
-		}
-	} else {
-		m.history = make(map[string][]string)
-	}
-}
-
-// SaveHistory saves the user's command history to configDir/buffers/history
-// only if the savehistory option is on
-func (m *Messenger) SaveHistory() {
-	if GetGlobalOption("savehistory").(bool) {
-		// Don't save history past 100
-		for k, v := range m.history {
-			if len(v) > 100 {
-				m.history[k] = v[len(m.history[k])-100:]
-			}
-		}
-
-		file, err := os.Create(configDir + "/buffers/history")
-		defer file.Close()
-		if err == nil {
-			encoder := gob.NewEncoder(file)
-
-			err = encoder.Encode(m.history)
-			if err != nil {
-				m.Error("Error saving history:", err)
-				return
-			}
-		}
-	}
-}
-
 // A GutterMessage is a message displayed on the side of the editor
 type GutterMessage struct {
 	lineNum int

cmd/micro/micro.go

@@ -5,26 +5,24 @@ import (
 	"fmt"
 	"io/ioutil"
 	"os"
-	"path/filepath"
 	"runtime"
 	"strings"
-	"time"
 
 	"github.com/go-errors/errors"
+	"github.com/layeh/gopher-luar"
 	"github.com/mattn/go-isatty"
 	"github.com/mitchellh/go-homedir"
 	"github.com/yuin/gopher-lua"
 	"github.com/zyedidia/clipboard"
-	"github.com/zyedidia/micro/cmd/micro/terminfo"
 	"github.com/zyedidia/tcell"
 	"github.com/zyedidia/tcell/encoding"
-	"layeh.com/gopher-luar"
 )
 
 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
-	autosaveTime         = 8   // Number of seconds to wait before autosaving
 )
 
 var (
@@ -45,12 +43,14 @@ var (
 
 	// Version is the version number or commit hash
 	// These variables should be set by the linker when compiling
-	Version = "0.0.0-unknown"
-	// CommitHash is the commit this version was built on
-	CommitHash = "Unknown"
-	// CompileDate is the date this binary was compiled on
+	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
@@ -59,17 +59,8 @@ var (
 
 	// Channel of jobs running in the background
 	jobs chan JobFunction
-
 	// Event channel
-	events   chan tcell.Event
-	autosave chan bool
-
-	// Channels for the terminal emulator
-	updateterm chan bool
-	closeterm  chan int
-
-	// How many redraws have happened
-	numRedraw uint
+	events chan tcell.Event
 )
 
 // LoadInput determines which files should be loaded into buffers
@@ -89,30 +80,26 @@ func LoadInput() []*Buffer {
 	var filename string
 	var input []byte
 	var err error
-	args := flag.Args()
-	buffers := make([]*Buffer, 0, len(args))
+	var buffers []*Buffer
 
-	if len(args) > 0 {
+	if len(flag.Args()) > 0 {
 		// Option 1
 		// We go through each file and load it
-		for i := 0; i < len(args); i++ {
-			if strings.HasPrefix(args[i], "+") {
-				if strings.Contains(args[i], ":") {
-					split := strings.Split(args[i], ":")
-					*flagStartPos = split[0][1:] + "," + split[1]
-				} else {
-					*flagStartPos = args[i][1:] + ",0"
-				}
-				continue
-			}
+		for i := 0; i < len(flag.Args()); i++ {
+			filename = flag.Args()[i]
 
-			buf, err := NewBufferFromFile(args[i])
-			if err != nil {
-				TermMessage(err)
-				continue
+			// 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 = ""
+				}
 			}
 			// If the file didn't exist, input will be empty, and we'll open an empty buffer
-			buffers = append(buffers, buf)
+			buffers = append(buffers, NewBuffer(input, filename))
 		}
 	} else if !isatty.IsTerminal(os.Stdin.Fd()) {
 		// Option 2
@@ -123,10 +110,10 @@ func LoadInput() []*Buffer {
 			TermMessage("Error reading from stdin: ", err)
 			input = []byte{}
 		}
-		buffers = append(buffers, NewBufferFromString(string(input), filename))
+		buffers = append(buffers, NewBuffer(input, filename))
 	} else {
 		// Option 3, just open an empty buffer
-		buffers = append(buffers, NewBufferFromString(string(input), filename))
+		buffers = append(buffers, NewBuffer(input, filename))
 	}
 
 	return buffers
@@ -147,15 +134,6 @@ func InitConfigDir() {
 	}
 	configDir = xdgHome + "/micro"
 
-	if len(*flagConfigDir) > 0 {
-		if _, err := os.Stat(*flagConfigDir); os.IsNotExist(err) {
-			TermMessage("Error: " + *flagConfigDir + " does not exist. Defaulting to " + configDir + ".")
-		} else {
-			configDir = *flagConfigDir
-			return
-		}
-	}
-
 	if _, err := os.Stat(xdgHome); os.IsNotExist(err) {
 		// If the xdgHome doesn't exist we should create it
 		err = os.Mkdir(xdgHome, os.ModePerm)
@@ -176,20 +154,7 @@ func InitConfigDir() {
 // InitScreen creates and initializes the tcell screen
 func InitScreen() {
 	// Should we enable true color?
-	truecolor := false
-	colorterm := os.Getenv("COLORTERM")
-	if colorterm == "24bit" || colorterm == "truecolor" {
-		truecolor = true
-	}
-	microtc := os.Getenv("MICRO_TRUECOLOR")
-	if microtc == "1" {
-		truecolor = true
-	} else if microtc == "0" {
-		truecolor = false
-	}
-
-	tcelldb := os.Getenv("TCELLDB")
-	os.Setenv("TCELLDB", configDir+"/.tcelldb")
+	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
@@ -198,23 +163,32 @@ func InitScreen() {
 		os.Setenv("TERM", "xterm-truecolor")
 	}
 
+	os.Setenv("TCELLDB", configDir+"/.tcelldb")
+
 	// Initilize tcell
 	var err error
 	screen, err = tcell.NewScreen()
-	if err != nil {
-		if err == tcell.ErrTermNotFound {
-			terminfo.WriteDB(configDir + "/.tcelldb")
-			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.")
+
+	if err != nil && err.Error() == "terminal entry not found" {
+		var termDB []byte
+		termDB, err = MkInfo()
+
+		if err != nil {
+			fmt.Println("Terminal entry not found")
+			fmt.Println("Error when trying to read terminfo: ", err)
 			os.Exit(1)
 		}
+
+		if _, e := os.Stat(configDir); e == nil {
+			ioutil.WriteFile(configDir+"/.tcelldb", termDB, 0644)
+		}
+
+		screen, err = tcell.NewScreen()
+	}
+
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
 	}
 	if err = screen.Init(); err != nil {
 		fmt.Println(err)
@@ -226,89 +200,30 @@ func InitScreen() {
 		os.Setenv("TERM", oldTerm)
 	}
 
-	if GetGlobalOption("mouse").(bool) {
-		screen.EnableMouse()
-	}
-
-	os.Setenv("TCELLDB", tcelldb)
-
-	// screen.SetStyle(defStyle)
+	screen.SetStyle(defStyle)
+	screen.EnableMouse()
 }
 
 // RedrawAll redraws everything -- all the views and the messenger
 func RedrawAll() {
 	messenger.Clear()
-
-	w, h := screen.Size()
-	for x := 0; x < w; x++ {
-		for y := 0; y < h; y++ {
-			screen.SetContent(x, y, ' ', nil, defStyle)
-		}
-	}
-
-	for _, v := range tabs[curTab].Views {
+	for _, v := range tabs[curTab].views {
 		v.Display()
 	}
 	DisplayTabs()
 	messenger.Display()
-	if globalSettings["keymenu"].(bool) {
-		DisplayKeyMenu()
-	}
 	screen.Show()
-
-	if numRedraw%50 == 0 {
-		runtime.GC()
-	}
-	numRedraw++
 }
 
-func LoadAll() {
-	// Find the user's configuration directory (probably $XDG_CONFIG_HOME/micro)
-	InitConfigDir()
-
-	// Build a list of available Extensions (Syntax, Colorscheme etc.)
-	InitRuntimeFiles()
-
-	// Load the user's settings
-	InitGlobalSettings()
-
-	InitCommands()
-	InitBindings()
-
-	InitColorscheme()
-
-	for _, tab := range tabs {
-		for _, v := range tab.Views {
-			v.Buf.UpdateRules()
-		}
-	}
-}
-
-// Command line flags
+// Passing -version as a flag will have micro print out the version number
 var flagVersion = flag.Bool("version", false, "Show the version number and information")
 var flagStartPos = flag.String("startpos", "", "LINE,COL to start the cursor at when opening a buffer.")
-var flagConfigDir = flag.String("config-dir", "", "Specify a custom location for the configuration directory")
-var flagOptions = flag.Bool("options", false, "Show all option help")
 
 func main() {
 	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("-startpos LINE,COL")
-		fmt.Println("+LINE:COL")
-		fmt.Println("    \tSpecify a line and column to start the cursor at when opening a buffer")
-		fmt.Println("    \tThis can also be done by opening file:LINE:COL")
-		fmt.Println("-options")
-		fmt.Println("    \tShow all option help")
-		fmt.Println("-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")
+		fmt.Println("Micro's options can be set via command line arguments for quick adjustments. For real configuration, please use the bindings.json file (see 'help options').\n")
+		flag.PrintDefaults()
 	}
 
 	optionFlags := make(map[string]*string)
@@ -327,15 +242,6 @@ func main() {
 		os.Exit(0)
 	}
 
-	if *flagOptions {
-		// If -options was passed
-		for k, v := range DefaultGlobalSettings() {
-			fmt.Printf("-%s value\n", k)
-			fmt.Printf("    \tThe %s option. Default value: '%v'\n", k, v)
-		}
-		os.Exit(0)
-	}
-
 	// Start the Lua VM for running plugins
 	L = lua.NewState()
 	defer L.Close()
@@ -347,15 +253,18 @@ func main() {
 	// Find the user's configuration directory (probably $XDG_CONFIG_HOME/micro)
 	InitConfigDir()
 
-	// Build a list of available Extensions (Syntax, Colorscheme etc.)
-	InitRuntimeFiles()
-
 	// Load the user's settings
 	InitGlobalSettings()
 
 	InitCommands()
 	InitBindings()
 
+	// Load the syntax files, including the colorscheme
+	LoadSyntaxFiles()
+
+	// Load the help files
+	LoadHelp()
+
 	// Start the screen
 	InitScreen()
 
@@ -375,26 +284,22 @@ func main() {
 	// Create a new messenger
 	// This is used for sending the user messages in the bottom of the editor
 	messenger = new(Messenger)
-	messenger.LoadHistory()
+	messenger.history = make(map[string][]string)
 
 	// Now we load the input
 	buffers := LoadInput()
-	if len(buffers) == 0 {
-		screen.Fini()
-		os.Exit(1)
-	}
-
 	for _, buf := range buffers {
 		// For each buffer we create a new tab and place the view in that tab
 		tab := NewTabFromView(NewView(buf))
 		tab.SetNum(len(tabs))
 		tabs = append(tabs, tab)
 		for _, t := range tabs {
-			for _, v := range t.Views {
+			for _, v := range t.views {
 				v.Center(false)
+				if globalSettings["syntax"].(bool) {
+					v.matches = Match(v)
+				}
 			}
-
-			t.Resize()
 		}
 	}
 
@@ -420,79 +325,38 @@ func main() {
 	L.SetGlobal("IsWordChar", luar.New(L, IsWordChar))
 	L.SetGlobal("HandleCommand", luar.New(L, HandleCommand))
 	L.SetGlobal("HandleShellCommand", luar.New(L, HandleShellCommand))
-	L.SetGlobal("ExecCommand", luar.New(L, ExecCommand))
-	L.SetGlobal("RunShellCommand", luar.New(L, RunShellCommand))
-	L.SetGlobal("RunBackgroundShell", luar.New(L, RunBackgroundShell))
-	L.SetGlobal("RunInteractiveShell", luar.New(L, RunInteractiveShell))
-	L.SetGlobal("TermEmuSupported", luar.New(L, TermEmuSupported))
-	L.SetGlobal("RunTermEmulator", luar.New(L, RunTermEmulator))
 	L.SetGlobal("GetLeadingWhitespace", luar.New(L, GetLeadingWhitespace))
 	L.SetGlobal("MakeCompletion", luar.New(L, MakeCompletion))
-	L.SetGlobal("NewBuffer", luar.New(L, NewBufferFromString))
-	L.SetGlobal("NewBufferFromFile", luar.New(L, NewBufferFromFile))
-	L.SetGlobal("RuneStr", luar.New(L, func(r rune) string {
-		return string(r)
-	}))
-	L.SetGlobal("Loc", luar.New(L, func(x, y int) Loc {
-		return Loc{x, y}
-	}))
-	L.SetGlobal("WorkingDirectory", luar.New(L, os.Getwd))
-	L.SetGlobal("JoinPaths", luar.New(L, filepath.Join))
-	L.SetGlobal("DirectoryName", luar.New(L, filepath.Dir))
-	L.SetGlobal("configDir", luar.New(L, configDir))
-	L.SetGlobal("Reload", luar.New(L, LoadAll))
-	L.SetGlobal("ByteOffset", luar.New(L, ByteOffset))
-	L.SetGlobal("ToCharPos", luar.New(L, ToCharPos))
 
 	// Used for asynchronous jobs
 	L.SetGlobal("JobStart", luar.New(L, JobStart))
-	L.SetGlobal("JobSpawn", luar.New(L, JobSpawn))
 	L.SetGlobal("JobSend", luar.New(L, JobSend))
 	L.SetGlobal("JobStop", luar.New(L, JobStop))
 
-	// Extension Files
-	L.SetGlobal("ReadRuntimeFile", luar.New(L, PluginReadRuntimeFile))
-	L.SetGlobal("ListRuntimeFiles", luar.New(L, PluginListRuntimeFiles))
-	L.SetGlobal("AddRuntimeFile", luar.New(L, PluginAddRuntimeFile))
-	L.SetGlobal("AddRuntimeFilesFromDirectory", luar.New(L, PluginAddRuntimeFilesFromDirectory))
-	L.SetGlobal("AddRuntimeFileFromMemory", luar.New(L, PluginAddRuntimeFileFromMemory))
-
-	// Access to Go stdlib
-	L.SetGlobal("import", luar.New(L, Import))
-
-	jobs = make(chan JobFunction, 100)
-	events = make(chan tcell.Event, 100)
-	autosave = make(chan bool)
-	updateterm = make(chan bool)
-	closeterm = make(chan int)
-
 	LoadPlugins()
 
+	jobs = make(chan JobFunction, 100)
+	events = make(chan tcell.Event)
+
 	for _, t := range tabs {
-		for _, v := range t.Views {
-			GlobalPluginCall("onViewOpen", v)
-			GlobalPluginCall("onBufferOpen", v.Buf)
+		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)
+			}
 		}
 	}
 
-	InitColorscheme()
-	messenger.style = defStyle
-
 	// Here is the event loop which runs in a separate thread
 	go func() {
 		for {
-			if screen != nil {
-				events <- screen.PollEvent()
-			}
-		}
-	}()
-
-	go func() {
-		for {
-			time.Sleep(autosaveTime * time.Second)
-			if globalSettings["autosave"].(bool) {
-				autosave <- true
-			}
+			events <- screen.PollEvent()
 		}
 	}()
 
@@ -508,88 +372,50 @@ func main() {
 			// If a new job has finished while running in the background we should execute the callback
 			f.function(f.output, f.args...)
 			continue
-		case <-autosave:
-			if CurView().Buf.Path != "" {
-				CurView().Save(true)
-			}
-		case <-updateterm:
-			continue
-		case vnum := <-closeterm:
-			tabs[curTab].Views[vnum].CloseTerminal()
 		case event = <-events:
 		}
 
-		for event != nil {
-			didAction := false
-
-			switch e := event.(type) {
-			case *tcell.EventResize:
-				for _, t := range tabs {
-					t.Resize()
+		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 != "" && globalSettings["infobar"].(bool) {
+					// If the user clicked in the bottom bar, and there is a message down there
+					// we copy it to the clipboard.
+					// Often error messages are displayed down there so it can be useful to easily
+					// copy the message
+					clipboard.WriteAll(messenger.message, "primary")
+					continue
 				}
-			case *tcell.EventMouse:
-				if !searching {
-					if e.Buttons() == tcell.Button1 {
-						// If the user left clicked we check a couple things
-						_, h := screen.Size()
-						x, y := e.Position()
-						if y == h-1 && messenger.message != "" && globalSettings["infobar"].(bool) {
-							// If the user clicked in the bottom bar, and there is a message down there
-							// we copy it to the clipboard.
-							// Often error messages are displayed down there so it can be useful to easily
-							// copy the message
-							clipboard.WriteAll(messenger.message, "primary")
-							break
-						}
 
-						if CurView().mouseReleased {
-							// We loop through each view in the current tab and make sure the current view
-							// is the one being clicked in
-							for _, v := range tabs[curTab].Views {
-								if x >= v.x && x < v.x+v.Width && y >= v.y && y < v.y+v.Height {
-									tabs[curTab].CurView = v.Num
-								}
-							}
-						}
-					} else if e.Buttons() == tcell.WheelUp || e.Buttons() == tcell.WheelDown {
-						var view *View
-						x, y := e.Position()
-						for _, v := range tabs[curTab].Views {
-							if x >= v.x && x < v.x+v.Width && y >= v.y && y < v.y+v.Height {
-								view = tabs[curTab].Views[v.Num]
-							}
-						}
-						if view != nil {
-							view.HandleEvent(e)
-							didAction = true
+				if CurView().mouseReleased {
+					// We loop through each view in the current tab and make sure the current view
+					// is the one being clicked in
+					for _, v := range tabs[curTab].views {
+						if x >= v.x && x < v.x+v.width && y >= v.y && y < v.y+v.height {
+							tabs[curTab].curView = v.Num
 						}
 					}
 				}
 			}
+		}
 
-			if !didAction {
-				// This function checks the mouse event for the possibility of changing the current tab
-				// If the tab was changed it returns true
-				if TabbarHandleMouseEvent(event) {
-					break
-				}
+		// 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())
-				} else {
-					// Send it to the view
-					CurView().HandleEvent(event)
-				}
-			}
-
-			select {
-			case event = <-events:
-			default:
-				event = nil
-			}
+		if searching {
+			// Since searching is done in real time, we need to redraw every time
+			// there is a new event in the search bar so we need a special function
+			// to run instead of the standard HandleEvent.
+			HandleSearchEvent(event, CurView())
+		} else {
+			// Send it to the view
+			CurView().HandleEvent(event)
 		}
 	}
 }

cmd/micro/mkinfo.go

@@ -0,0 +1,669 @@
+// Copyright 2016 The TCell Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use file except in compliance with the License.
+// You may obtain a copy of the license at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This command is used to generate suitable configuration files in either
+// go syntax or in JSON.  It defaults to JSON output on stdout.  If no
+// term values are specified on the command line, then $TERM is used.
+//
+// Usage is like this:
+//
+// mkinfo [-go file.go] [-json file.json] [-quiet] [-nofatal] [<term>...]
+//
+// -go       specifiles Go output into the named file.  Use - for stdout.
+// -json     specifies JSON output in the named file.  Use - for stdout
+// -nofatal  indicates that errors loading definitions should not be fatal
+//
+
+package main
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"regexp"
+	"runtime"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/zyedidia/tcell"
+)
+
+// #include <curses.h>
+// #include <term.h>
+// #cgo LDFLAGS: -lcurses
+//
+// void noenv() {
+//	use_env(FALSE);
+// }
+//
+// char *tigetstr_good(char *name) {
+//	char *r;
+//	r = tigetstr(name);
+//	if (r == (char *)-1) {
+//		r = NULL;
+//	}
+//	return (r);
+// }
+import "C"
+
+func tigetnum(s string) int {
+	n := C.tigetnum(C.CString(s))
+	return int(n)
+}
+
+func tigetflag(s string) bool {
+	n := C.tigetflag(C.CString(s))
+	return n != 0
+}
+
+func tigetstr(s string) string {
+	// NB: If the string is invalid, we'll get back -1, which causes
+	// no end of grief.  So make sure your capability strings are correct!
+	cs := C.tigetstr_good(C.CString(s))
+	if cs == nil {
+		return ""
+	}
+	return C.GoString(cs)
+}
+
+// This program is used to collect data from the system's terminfo library,
+// and write it into Go source code.  That is, we maintain our terminfo
+// capabilities encoded in the program.  It should never need to be run by
+// an end user, but developers can use this to add codes for additional
+// terminal types.
+//
+// If a terminal name ending with -truecolor is given, and we cannot find
+// one, we will try to fabricte one from either the -256color (if present)
+// or the unadorned base name, adding the XTerm specific 24-bit color
+// escapes.  We believe that all 24-bit capable terminals use the same
+// escape sequences, and terminfo has yet to evolve to support this.
+func getinfo(name string) (*tcell.Terminfo, error) {
+	addTrueColor := false
+	rsn := C.int(0)
+	C.noenv()
+	rv, _ := C.setupterm(C.CString(name), 1, &rsn)
+	if rv == C.ERR {
+		if strings.HasSuffix(name, "-truecolor") {
+			base := name[:len(name)-len("-truecolor")]
+			// Probably -256color is closest to what we want
+			rv, _ = C.setupterm(C.CString(base+"-256color"), 1,
+				&rsn)
+			// Otherwise try the base
+			if rv == C.ERR {
+				rv, _ = C.setupterm(C.CString(base), 1, &rsn)
+			}
+			if rv != C.ERR {
+				addTrueColor = true
+			}
+		}
+	}
+	if rv == C.ERR {
+		switch rsn {
+		case 1:
+			return nil, errors.New("hardcopy terminal")
+		case 0:
+			return nil, errors.New("terminal definition not found")
+		case -1:
+			return nil, errors.New("terminfo database missing")
+		default:
+			return nil, errors.New("setupterm failed (other)")
+		}
+	}
+	t := &tcell.Terminfo{}
+	t.Name = name
+	t.Colors = tigetnum("colors")
+	t.Columns = tigetnum("cols")
+	t.Lines = tigetnum("lines")
+	t.Bell = tigetstr("bel")
+	t.Clear = tigetstr("clear")
+	t.EnterCA = tigetstr("smcup")
+	t.ExitCA = tigetstr("rmcup")
+	t.ShowCursor = tigetstr("cnorm")
+	t.HideCursor = tigetstr("civis")
+	t.AttrOff = tigetstr("sgr0")
+	t.Underline = tigetstr("smul")
+	t.Bold = tigetstr("bold")
+	t.Blink = tigetstr("blink")
+	t.Dim = tigetstr("dim")
+	t.Reverse = tigetstr("rev")
+	t.EnterKeypad = tigetstr("smkx")
+	t.ExitKeypad = tigetstr("rmkx")
+	t.SetFg = tigetstr("setaf")
+	t.SetBg = tigetstr("setab")
+	t.SetCursor = tigetstr("cup")
+	t.CursorBack1 = tigetstr("cub1")
+	t.CursorUp1 = tigetstr("cuu1")
+	t.KeyF1 = tigetstr("kf1")
+	t.KeyF2 = tigetstr("kf2")
+	t.KeyF3 = tigetstr("kf3")
+	t.KeyF4 = tigetstr("kf4")
+	t.KeyF5 = tigetstr("kf5")
+	t.KeyF6 = tigetstr("kf6")
+	t.KeyF7 = tigetstr("kf7")
+	t.KeyF8 = tigetstr("kf8")
+	t.KeyF9 = tigetstr("kf9")
+	t.KeyF10 = tigetstr("kf10")
+	t.KeyF11 = tigetstr("kf11")
+	t.KeyF12 = tigetstr("kf12")
+	t.KeyF13 = tigetstr("kf13")
+	t.KeyF14 = tigetstr("kf14")
+	t.KeyF15 = tigetstr("kf15")
+	t.KeyF16 = tigetstr("kf16")
+	t.KeyF17 = tigetstr("kf17")
+	t.KeyF18 = tigetstr("kf18")
+	t.KeyF19 = tigetstr("kf19")
+	t.KeyF20 = tigetstr("kf20")
+	t.KeyF21 = tigetstr("kf21")
+	t.KeyF22 = tigetstr("kf22")
+	t.KeyF23 = tigetstr("kf23")
+	t.KeyF24 = tigetstr("kf24")
+	t.KeyF25 = tigetstr("kf25")
+	t.KeyF26 = tigetstr("kf26")
+	t.KeyF27 = tigetstr("kf27")
+	t.KeyF28 = tigetstr("kf28")
+	t.KeyF29 = tigetstr("kf29")
+	t.KeyF30 = tigetstr("kf30")
+	t.KeyF31 = tigetstr("kf31")
+	t.KeyF32 = tigetstr("kf32")
+	t.KeyF33 = tigetstr("kf33")
+	t.KeyF34 = tigetstr("kf34")
+	t.KeyF35 = tigetstr("kf35")
+	t.KeyF36 = tigetstr("kf36")
+	t.KeyF37 = tigetstr("kf37")
+	t.KeyF38 = tigetstr("kf38")
+	t.KeyF39 = tigetstr("kf39")
+	t.KeyF40 = tigetstr("kf40")
+	t.KeyF41 = tigetstr("kf41")
+	t.KeyF42 = tigetstr("kf42")
+	t.KeyF43 = tigetstr("kf43")
+	t.KeyF44 = tigetstr("kf44")
+	t.KeyF45 = tigetstr("kf45")
+	t.KeyF46 = tigetstr("kf46")
+	t.KeyF47 = tigetstr("kf47")
+	t.KeyF48 = tigetstr("kf48")
+	t.KeyF49 = tigetstr("kf49")
+	t.KeyF50 = tigetstr("kf50")
+	t.KeyF51 = tigetstr("kf51")
+	t.KeyF52 = tigetstr("kf52")
+	t.KeyF53 = tigetstr("kf53")
+	t.KeyF54 = tigetstr("kf54")
+	t.KeyF55 = tigetstr("kf55")
+	t.KeyF56 = tigetstr("kf56")
+	t.KeyF57 = tigetstr("kf57")
+	t.KeyF58 = tigetstr("kf58")
+	t.KeyF59 = tigetstr("kf59")
+	t.KeyF60 = tigetstr("kf60")
+	t.KeyF61 = tigetstr("kf61")
+	t.KeyF62 = tigetstr("kf62")
+	t.KeyF63 = tigetstr("kf63")
+	t.KeyF64 = tigetstr("kf64")
+	t.KeyInsert = tigetstr("kich1")
+	t.KeyDelete = tigetstr("kdch1")
+	t.KeyBackspace = tigetstr("kbs")
+	t.KeyHome = tigetstr("khome")
+	t.KeyEnd = tigetstr("kend")
+	t.KeyUp = tigetstr("kcuu1")
+	t.KeyDown = tigetstr("kcud1")
+	t.KeyRight = tigetstr("kcuf1")
+	t.KeyLeft = tigetstr("kcub1")
+	t.KeyPgDn = tigetstr("knp")
+	t.KeyPgUp = tigetstr("kpp")
+	t.KeyBacktab = tigetstr("kcbt")
+	t.KeyExit = tigetstr("kext")
+	t.KeyCancel = tigetstr("kcan")
+	t.KeyPrint = tigetstr("kprt")
+	t.KeyHelp = tigetstr("khlp")
+	t.KeyClear = tigetstr("kclr")
+	t.AltChars = tigetstr("acsc")
+	t.EnterAcs = tigetstr("smacs")
+	t.ExitAcs = tigetstr("rmacs")
+	t.EnableAcs = tigetstr("enacs")
+	t.Mouse = tigetstr("kmous")
+	t.KeyShfRight = tigetstr("kRIT")
+	t.KeyShfLeft = tigetstr("kLFT")
+	t.KeyShfHome = tigetstr("kHOM")
+	t.KeyShfEnd = tigetstr("kEND")
+
+	// Terminfo lacks descriptions for a bunch of modified keys,
+	// but modern XTerm and emulators often have them.  Let's add them,
+	// if the shifted right and left arrows are defined.
+	if t.KeyShfRight == "\x1b[1;2C" && t.KeyShfLeft == "\x1b[1;2D" {
+		t.KeyShfUp = "\x1b[1;2A"
+		t.KeyShfDown = "\x1b[1;2B"
+		t.KeyMetaUp = "\x1b[1;9A"
+		t.KeyMetaDown = "\x1b[1;9B"
+		t.KeyMetaRight = "\x1b[1;9C"
+		t.KeyMetaLeft = "\x1b[1;9D"
+		t.KeyAltUp = "\x1b[1;3A"
+		t.KeyAltDown = "\x1b[1;3B"
+		t.KeyAltRight = "\x1b[1;3C"
+		t.KeyAltLeft = "\x1b[1;3D"
+		t.KeyCtrlUp = "\x1b[1;5A"
+		t.KeyCtrlDown = "\x1b[1;5B"
+		t.KeyCtrlRight = "\x1b[1;5C"
+		t.KeyCtrlLeft = "\x1b[1;5D"
+		t.KeyAltShfUp = "\x1b[1;4A"
+		t.KeyAltShfDown = "\x1b[1;4B"
+		t.KeyAltShfRight = "\x1b[1;4C"
+		t.KeyAltShfLeft = "\x1b[1;4D"
+
+		t.KeyMetaShfUp = "\x1b[1;10A"
+		t.KeyMetaShfDown = "\x1b[1;10B"
+		t.KeyMetaShfRight = "\x1b[1;10C"
+		t.KeyMetaShfLeft = "\x1b[1;10D"
+
+		t.KeyCtrlShfUp = "\x1b[1;6A"
+		t.KeyCtrlShfDown = "\x1b[1;6B"
+		t.KeyCtrlShfRight = "\x1b[1;6C"
+		t.KeyCtrlShfLeft = "\x1b[1;6D"
+	}
+	// And also for Home and End
+	if t.KeyShfHome == "\x1b[1;2H" && t.KeyShfEnd == "\x1b[1;2F" {
+		t.KeyCtrlHome = "\x1b[1;5H"
+		t.KeyCtrlEnd = "\x1b[1;5F"
+		t.KeyAltHome = "\x1b[1;9H"
+		t.KeyAltEnd = "\x1b[1;9F"
+		t.KeyCtrlShfHome = "\x1b[1;6H"
+		t.KeyCtrlShfEnd = "\x1b[1;6F"
+		t.KeyAltShfHome = "\x1b[1;4H"
+		t.KeyAltShfEnd = "\x1b[1;4F"
+		t.KeyMetaShfHome = "\x1b[1;10H"
+		t.KeyMetaShfEnd = "\x1b[1;10F"
+	}
+
+	// And the same thing for rxvt and workalikes (Eterm, aterm, etc.)
+	// It seems that urxvt at least send ESC as ALT prefix for these,
+	// although some places seem to indicate a separate ALT key sesquence.
+	if t.KeyShfRight == "\x1b[c" && t.KeyShfLeft == "\x1b[d" {
+		t.KeyShfUp = "\x1b[a"
+		t.KeyShfDown = "\x1b[b"
+		t.KeyCtrlUp = "\x1b[Oa"
+		t.KeyCtrlDown = "\x1b[Ob"
+		t.KeyCtrlRight = "\x1b[Oc"
+		t.KeyCtrlLeft = "\x1b[Od"
+	}
+	if t.KeyShfHome == "\x1b[7$" && t.KeyShfEnd == "\x1b[8$" {
+		t.KeyCtrlHome = "\x1b[7^"
+		t.KeyCtrlEnd = "\x1b[8^"
+	}
+
+	// If the kmous entry is present, then we need to record the
+	// the codes to enter and exit mouse mode.  Sadly, this is not
+	// part of the terminfo databases anywhere that I've found, but
+	// is an extension.  The escape codes are documented in the XTerm
+	// manual, and all terminals that have kmous are expected to
+	// use these same codes, unless explicitly configured otherwise
+	// vi XM.  Note that in any event, we only known how to parse either
+	// x11 or SGR mouse events -- if your terminal doesn't support one
+	// of these two forms, you maybe out of luck.
+	t.MouseMode = tigetstr("XM")
+	if t.Mouse != "" && t.MouseMode == "" {
+		// we anticipate that all xterm mouse tracking compatible
+		// terminals understand mouse tracking (1000), but we hope
+		// that those that don't understand any-event tracking (1003)
+		// will at least ignore it.  Likewise we hope that terminals
+		// that don't understand SGR reporting (1006) just ignore it.
+		t.MouseMode = "%?%p1%{1}%=%t%'h'%Pa%e%'l'%Pa%;" +
+			"\x1b[?1000%ga%c\x1b[?1003%ga%c\x1b[?1006%ga%c"
+	}
+
+	// We only support colors in ANSI 8 or 256 color mode.
+	if t.Colors < 8 || t.SetFg == "" {
+		t.Colors = 0
+	}
+	if t.SetCursor == "" {
+		return nil, errors.New("terminal not cursor addressable")
+	}
+
+	// For padding, we lookup the pad char.  If that isn't present,
+	// and npc is *not* set, then we assume a null byte.
+	t.PadChar = tigetstr("pad")
+	if t.PadChar == "" {
+		if !tigetflag("npc") {
+			t.PadChar = "\u0000"
+		}
+	}
+
+	// For some terminals we fabricate a -truecolor entry, that may
+	// not exist in terminfo.
+	if addTrueColor {
+		t.SetFgRGB = "\x1b[38;2;%p1%d;%p2%d;%p3%dm"
+		t.SetBgRGB = "\x1b[48;2;%p1%d;%p2%d;%p3%dm"
+		t.SetFgBgRGB = "\x1b[38;2;%p1%d;%p2%d;%p3%d;" +
+			"48;2;%p4%d;%p5%d;%p6%dm"
+	}
+
+	// For terminals that use "standard" SGR sequences, lets combine the
+	// foreground and background together.
+	if strings.HasPrefix(t.SetFg, "\x1b[") &&
+		strings.HasPrefix(t.SetBg, "\x1b[") &&
+		strings.HasSuffix(t.SetFg, "m") &&
+		strings.HasSuffix(t.SetBg, "m") {
+		fg := t.SetFg[:len(t.SetFg)-1]
+		r := regexp.MustCompile("%p1")
+		bg := r.ReplaceAllString(t.SetBg[2:], "%p2")
+		t.SetFgBg = fg + ";" + bg
+	}
+
+	return t, nil
+}
+
+func dotGoAddInt(w io.Writer, n string, i int) {
+	if i == 0 {
+		// initialized to 0, ignore
+		return
+	}
+	fmt.Fprintf(w, "		%-13s %d,\n", n+":", i)
+}
+func dotGoAddStr(w io.Writer, n string, s string) {
+	if s == "" {
+		return
+	}
+	fmt.Fprintf(w, "		%-13s %q,\n", n+":", s)
+}
+
+func dotGoAddArr(w io.Writer, n string, a []string) {
+	if len(a) == 0 {
+		return
+	}
+	fmt.Fprintf(w, "		%-13s []string{", n+":")
+	did := false
+	for _, b := range a {
+		if did {
+			fmt.Fprint(w, ", ")
+		}
+		did = true
+		fmt.Fprintf(w, "%q", b)
+	}
+	fmt.Fprintln(w, "},")
+}
+
+func dotGoHeader(w io.Writer) {
+	fmt.Fprintf(w, "// Generated by %s (%s/%s) on %s.\n",
+		os.Args[0],
+		runtime.GOOS, runtime.GOARCH,
+		time.Now().Format(time.UnixDate))
+	fmt.Fprintln(w, "// DO NOT HAND-EDIT")
+	fmt.Fprintln(w, "")
+	fmt.Fprintln(w, "package tcell")
+	fmt.Fprintln(w, "")
+	fmt.Fprintln(w, "func init() {")
+}
+
+func dotGoTrailer(w io.Writer) {
+	fmt.Fprintln(w, "}")
+}
+
+func dotGoInfo(w io.Writer, t *tcell.Terminfo) {
+	fmt.Fprintln(w, "	AddTerminfo(&Terminfo{")
+	dotGoAddStr(w, "Name", t.Name)
+	dotGoAddArr(w, "Aliases", t.Aliases)
+	dotGoAddInt(w, "Columns", t.Columns)
+	dotGoAddInt(w, "Lines", t.Lines)
+	dotGoAddInt(w, "Colors", t.Colors)
+	dotGoAddStr(w, "Bell", t.Bell)
+	dotGoAddStr(w, "Clear", t.Clear)
+	dotGoAddStr(w, "EnterCA", t.EnterCA)
+	dotGoAddStr(w, "ExitCA", t.ExitCA)
+	dotGoAddStr(w, "ShowCursor", t.ShowCursor)
+	dotGoAddStr(w, "HideCursor", t.HideCursor)
+	dotGoAddStr(w, "AttrOff", t.AttrOff)
+	dotGoAddStr(w, "Underline", t.Underline)
+	dotGoAddStr(w, "Bold", t.Bold)
+	dotGoAddStr(w, "Dim", t.Dim)
+	dotGoAddStr(w, "Blink", t.Blink)
+	dotGoAddStr(w, "Reverse", t.Reverse)
+	dotGoAddStr(w, "EnterKeypad", t.EnterKeypad)
+	dotGoAddStr(w, "ExitKeypad", t.ExitKeypad)
+	dotGoAddStr(w, "SetFg", t.SetFg)
+	dotGoAddStr(w, "SetBg", t.SetBg)
+	dotGoAddStr(w, "SetFgBg", t.SetFgBg)
+	dotGoAddStr(w, "PadChar", t.PadChar)
+	dotGoAddStr(w, "AltChars", t.AltChars)
+	dotGoAddStr(w, "EnterAcs", t.EnterAcs)
+	dotGoAddStr(w, "ExitAcs", t.ExitAcs)
+	dotGoAddStr(w, "EnableAcs", t.EnableAcs)
+	dotGoAddStr(w, "SetFgRGB", t.SetFgRGB)
+	dotGoAddStr(w, "SetBgRGB", t.SetBgRGB)
+	dotGoAddStr(w, "SetFgBgRGB", t.SetFgBgRGB)
+	dotGoAddStr(w, "Mouse", t.Mouse)
+	dotGoAddStr(w, "MouseMode", t.MouseMode)
+	dotGoAddStr(w, "SetCursor", t.SetCursor)
+	dotGoAddStr(w, "CursorBack1", t.CursorBack1)
+	dotGoAddStr(w, "CursorUp1", t.CursorUp1)
+	dotGoAddStr(w, "KeyUp", t.KeyUp)
+	dotGoAddStr(w, "KeyDown", t.KeyDown)
+	dotGoAddStr(w, "KeyRight", t.KeyRight)
+	dotGoAddStr(w, "KeyLeft", t.KeyLeft)
+	dotGoAddStr(w, "KeyInsert", t.KeyInsert)
+	dotGoAddStr(w, "KeyDelete", t.KeyDelete)
+	dotGoAddStr(w, "KeyBackspace", t.KeyBackspace)
+	dotGoAddStr(w, "KeyHome", t.KeyHome)
+	dotGoAddStr(w, "KeyEnd", t.KeyEnd)
+	dotGoAddStr(w, "KeyPgUp", t.KeyPgUp)
+	dotGoAddStr(w, "KeyPgDn", t.KeyPgDn)
+	dotGoAddStr(w, "KeyF1", t.KeyF1)
+	dotGoAddStr(w, "KeyF2", t.KeyF2)
+	dotGoAddStr(w, "KeyF3", t.KeyF3)
+	dotGoAddStr(w, "KeyF4", t.KeyF4)
+	dotGoAddStr(w, "KeyF5", t.KeyF5)
+	dotGoAddStr(w, "KeyF6", t.KeyF6)
+	dotGoAddStr(w, "KeyF7", t.KeyF7)
+	dotGoAddStr(w, "KeyF8", t.KeyF8)
+	dotGoAddStr(w, "KeyF9", t.KeyF9)
+	dotGoAddStr(w, "KeyF10", t.KeyF10)
+	dotGoAddStr(w, "KeyF11", t.KeyF11)
+	dotGoAddStr(w, "KeyF12", t.KeyF12)
+	dotGoAddStr(w, "KeyF13", t.KeyF13)
+	dotGoAddStr(w, "KeyF14", t.KeyF14)
+	dotGoAddStr(w, "KeyF15", t.KeyF15)
+	dotGoAddStr(w, "KeyF16", t.KeyF16)
+	dotGoAddStr(w, "KeyF17", t.KeyF17)
+	dotGoAddStr(w, "KeyF18", t.KeyF18)
+	dotGoAddStr(w, "KeyF19", t.KeyF19)
+	dotGoAddStr(w, "KeyF20", t.KeyF20)
+	dotGoAddStr(w, "KeyF21", t.KeyF21)
+	dotGoAddStr(w, "KeyF22", t.KeyF22)
+	dotGoAddStr(w, "KeyF23", t.KeyF23)
+	dotGoAddStr(w, "KeyF24", t.KeyF24)
+	dotGoAddStr(w, "KeyF25", t.KeyF25)
+	dotGoAddStr(w, "KeyF26", t.KeyF26)
+	dotGoAddStr(w, "KeyF27", t.KeyF27)
+	dotGoAddStr(w, "KeyF28", t.KeyF28)
+	dotGoAddStr(w, "KeyF29", t.KeyF29)
+	dotGoAddStr(w, "KeyF30", t.KeyF30)
+	dotGoAddStr(w, "KeyF31", t.KeyF31)
+	dotGoAddStr(w, "KeyF32", t.KeyF32)
+	dotGoAddStr(w, "KeyF33", t.KeyF33)
+	dotGoAddStr(w, "KeyF34", t.KeyF34)
+	dotGoAddStr(w, "KeyF35", t.KeyF35)
+	dotGoAddStr(w, "KeyF36", t.KeyF36)
+	dotGoAddStr(w, "KeyF37", t.KeyF37)
+	dotGoAddStr(w, "KeyF38", t.KeyF38)
+	dotGoAddStr(w, "KeyF39", t.KeyF39)
+	dotGoAddStr(w, "KeyF40", t.KeyF40)
+	dotGoAddStr(w, "KeyF41", t.KeyF41)
+	dotGoAddStr(w, "KeyF42", t.KeyF42)
+	dotGoAddStr(w, "KeyF43", t.KeyF43)
+	dotGoAddStr(w, "KeyF44", t.KeyF44)
+	dotGoAddStr(w, "KeyF45", t.KeyF45)
+	dotGoAddStr(w, "KeyF46", t.KeyF46)
+	dotGoAddStr(w, "KeyF47", t.KeyF47)
+	dotGoAddStr(w, "KeyF48", t.KeyF48)
+	dotGoAddStr(w, "KeyF49", t.KeyF49)
+	dotGoAddStr(w, "KeyF50", t.KeyF50)
+	dotGoAddStr(w, "KeyF51", t.KeyF51)
+	dotGoAddStr(w, "KeyF52", t.KeyF52)
+	dotGoAddStr(w, "KeyF53", t.KeyF53)
+	dotGoAddStr(w, "KeyF54", t.KeyF54)
+	dotGoAddStr(w, "KeyF55", t.KeyF55)
+	dotGoAddStr(w, "KeyF56", t.KeyF56)
+	dotGoAddStr(w, "KeyF57", t.KeyF57)
+	dotGoAddStr(w, "KeyF58", t.KeyF58)
+	dotGoAddStr(w, "KeyF59", t.KeyF59)
+	dotGoAddStr(w, "KeyF60", t.KeyF60)
+	dotGoAddStr(w, "KeyF61", t.KeyF61)
+	dotGoAddStr(w, "KeyF62", t.KeyF62)
+	dotGoAddStr(w, "KeyF63", t.KeyF63)
+	dotGoAddStr(w, "KeyF64", t.KeyF64)
+	dotGoAddStr(w, "KeyCancel", t.KeyCancel)
+	dotGoAddStr(w, "KeyPrint", t.KeyPrint)
+	dotGoAddStr(w, "KeyExit", t.KeyExit)
+	dotGoAddStr(w, "KeyHelp", t.KeyHelp)
+	dotGoAddStr(w, "KeyClear", t.KeyClear)
+	dotGoAddStr(w, "KeyBacktab", t.KeyBacktab)
+	dotGoAddStr(w, "KeyShfLeft", t.KeyShfLeft)
+	dotGoAddStr(w, "KeyShfRight", t.KeyShfRight)
+	dotGoAddStr(w, "KeyShfUp", t.KeyShfUp)
+	dotGoAddStr(w, "KeyShfDown", t.KeyShfDown)
+	dotGoAddStr(w, "KeyCtrlLeft", t.KeyCtrlLeft)
+	dotGoAddStr(w, "KeyCtrlRight", t.KeyCtrlRight)
+	dotGoAddStr(w, "KeyCtrlUp", t.KeyCtrlUp)
+	dotGoAddStr(w, "KeyCtrlDown", t.KeyCtrlDown)
+	dotGoAddStr(w, "KeyMetaLeft", t.KeyMetaLeft)
+	dotGoAddStr(w, "KeyMetaRight", t.KeyMetaRight)
+	dotGoAddStr(w, "KeyMetaUp", t.KeyMetaUp)
+	dotGoAddStr(w, "KeyMetaDown", t.KeyMetaDown)
+	dotGoAddStr(w, "KeyAltLeft", t.KeyAltLeft)
+	dotGoAddStr(w, "KeyAltRight", t.KeyAltRight)
+	dotGoAddStr(w, "KeyAltUp", t.KeyAltUp)
+	dotGoAddStr(w, "KeyAltDown", t.KeyAltDown)
+	dotGoAddStr(w, "KeyAltShfLeft", t.KeyAltShfLeft)
+	dotGoAddStr(w, "KeyAltShfRight", t.KeyAltShfRight)
+	dotGoAddStr(w, "KeyAltShfUp", t.KeyAltShfUp)
+	dotGoAddStr(w, "KeyAltShfDown", t.KeyAltShfDown)
+	dotGoAddStr(w, "KeyMetaShfLeft", t.KeyMetaShfLeft)
+	dotGoAddStr(w, "KeyMetaShfRight", t.KeyMetaShfRight)
+	dotGoAddStr(w, "KeyMetaShfUp", t.KeyMetaShfUp)
+	dotGoAddStr(w, "KeyMetaShfDown", t.KeyMetaShfDown)
+	dotGoAddStr(w, "KeyCtrlShfLeft", t.KeyCtrlShfLeft)
+	dotGoAddStr(w, "KeyCtrlShfRight", t.KeyCtrlShfRight)
+	dotGoAddStr(w, "KeyCtrlShfUp", t.KeyCtrlShfUp)
+	dotGoAddStr(w, "KeyCtrlShfDown", t.KeyCtrlShfDown)
+	dotGoAddStr(w, "KeyShfHome", t.KeyShfHome)
+	dotGoAddStr(w, "KeyShfEnd", t.KeyShfEnd)
+	dotGoAddStr(w, "KeyCtrlHome", t.KeyCtrlHome)
+	dotGoAddStr(w, "KeyCtrlEnd", t.KeyCtrlEnd)
+	dotGoAddStr(w, "KeyMetaHome", t.KeyMetaHome)
+	dotGoAddStr(w, "KeyMetaEnd", t.KeyMetaEnd)
+	dotGoAddStr(w, "KeyAltHome", t.KeyAltHome)
+	dotGoAddStr(w, "KeyAltEnd", t.KeyAltEnd)
+	dotGoAddStr(w, "KeyCtrlShfHome", t.KeyCtrlShfHome)
+	dotGoAddStr(w, "KeyCtrlShfEnd", t.KeyCtrlShfEnd)
+	dotGoAddStr(w, "KeyMetaShfHome", t.KeyMetaShfHome)
+	dotGoAddStr(w, "KeyMetaShfEnd", t.KeyMetaShfEnd)
+	dotGoAddStr(w, "KeyAltShfHome", t.KeyAltShfHome)
+	dotGoAddStr(w, "KeyAltShfEnd", t.KeyAltShfEnd)
+	fmt.Fprintln(w, "	})")
+}
+
+func MkInfo() ([]byte, error) {
+	jsonfile := ""
+	gofile := ""
+	nofatal := true
+	quiet := true
+
+	var e error
+	js := []byte{}
+
+	args := []string{os.Getenv("TERM")}
+
+	tdata := make(map[string]*tcell.Terminfo)
+	adata := make(map[string]string)
+	for _, term := range args {
+		if arr := strings.SplitN(term, "=", 2); len(arr) == 2 {
+			adata[arr[0]] = arr[1]
+		} else if t, e := getinfo(term); e != nil {
+			if !quiet {
+				fmt.Fprintf(os.Stderr,
+					"Failed loading %s: %v\n", term, e)
+			}
+			if !nofatal {
+				os.Exit(1)
+			}
+		} else {
+			tdata[t.Name] = t
+		}
+	}
+	for alias, canon := range adata {
+		if t, ok := tdata[canon]; ok {
+			t.Aliases = append(t.Aliases, alias)
+			// sort aliases to avoid extra diffs
+			sort.Strings(t.Aliases)
+		} else {
+			if !quiet {
+				fmt.Fprintf(os.Stderr,
+					"Alias %s missing canonical %s\n",
+					alias, canon)
+			}
+			if !nofatal {
+				os.Exit(1)
+			}
+		}
+	}
+
+	if gofile != "" {
+		w := os.Stdout
+		if gofile != "-" {
+			if w, e = os.Create(gofile); e != nil {
+				return []byte{}, fmt.Errorf("Failed: %v", e)
+			}
+		}
+		dotGoHeader(w)
+		for _, term := range args {
+			if t := tdata[term]; t != nil {
+				dotGoInfo(w, t)
+			}
+		}
+		dotGoTrailer(w)
+		if w != os.Stdout {
+			w.Close()
+		}
+	} else if jsonfile != "" {
+		w := os.Stdout
+		if jsonfile != "-" {
+			if w, e = os.Create(jsonfile); e != nil {
+				fmt.Fprintf(os.Stderr, "Failed: %v", e)
+			}
+		}
+		for _, term := range args {
+			if t := tdata[term]; t != nil {
+				js, e = json.Marshal(t)
+				fmt.Fprintln(w, string(js))
+			}
+			// arguably if there is more than one term, this
+			// should be a javascript array, but that's not how
+			// we load it.  We marshal objects one at a time from
+			// the file.
+		}
+		if e != nil {
+			return []byte{}, fmt.Errorf("Failed: %v", e)
+		}
+	} else {
+		for _, term := range args {
+			if t := tdata[term]; t != nil {
+				js, e := json.Marshal(tdata[term])
+				if e != nil {
+					return []byte{}, fmt.Errorf("Failed ", e)
+				}
+				return js, nil
+			}
+		}
+	}
+
+	return []byte{}, nil
+}

cmd/micro/plugin.go

@@ -6,12 +6,17 @@ import (
 	"os"
 	"strings"
 
+	"github.com/layeh/gopher-luar"
 	"github.com/yuin/gopher-lua"
-	"github.com/zyedidia/tcell"
-	"layeh.com/gopher-luar"
 )
 
-var loadedPlugins map[string]string
+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,
@@ -61,20 +66,6 @@ func LuaFunctionBinding(function string) func(*View, bool) bool {
 	}
 }
 
-// LuaFunctionMouseBinding 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 mouse binding because this is used
-// to bind mouse actions to lua functions
-func LuaFunctionMouseBinding(function string) func(*View, bool, *tcell.EventMouse) bool {
-	return func(v *View, _ bool, e *tcell.EventMouse) bool {
-		_, err := Call(function, e)
-		if err != nil {
-			TermMessage(err)
-		}
-		return false
-	}
-}
-
 func unpack(old []string) []interface{} {
 	new := make([]interface{}, len(old))
 	for i, v := range old {
@@ -118,67 +109,68 @@ func LuaFunctionComplete(function string) func(string) []string {
 	}
 }
 
-// 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(function string) func(string, ...string) {
 	return func(output string, args ...string) {
 		_, err := Call(function, unpack(append([]string{output}, args...))...)
-		if err != nil && !strings.HasPrefix(err.Error(), "function does not exist") {
+		if err != nil {
 			TermMessage(err)
 		}
 	}
 }
 
-// luaPluginName convert a human-friendly plugin name into a valid lua variable name.
-func luaPluginName(name string) string {
-	return strings.Replace(name, "-", "_", -1)
-}
-
 // LoadPlugins loads the pre-installed plugins and the plugins located in ~/.config/micro/plugins
 func LoadPlugins() {
-	loadedPlugins = make(map[string]string)
+	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"
 
-	for _, plugin := range ListRuntimeFiles(RTPlugin) {
-		pluginName := plugin.Name()
-		if _, ok := loadedPlugins[pluginName]; ok {
-			continue
+					if err := L.DoString(pluginDef + string(data)); err != nil {
+						TermMessage(err)
+						continue
+					}
+					loadedPlugins = append(loadedPlugins, pluginName)
+				}
+			}
 		}
+	}
 
-		data, err := plugin.Data()
-		if err != nil {
-			TermMessage("Error loading plugin: " + pluginName)
-			continue
+	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
+			}
 
-		pluginLuaName := luaPluginName(pluginName)
-
-		if err := LoadFile(pluginLuaName, pluginLuaName, string(data)); err != nil {
-			TermMessage(err)
-			continue
+			loadedPlugins = append(loadedPlugins, pluginName)
 		}
-
-		loadedPlugins[pluginName] = pluginLuaName
-
 	}
 
 	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 := LoadFile("init", configDir+"init.lua", string(data)); err != nil {
+		if err := L.DoString(pluginDef + string(data)); err != nil {
 			TermMessage(err)
 		}
-		loadedPlugins["init"] = "init"
-	}
-}
-
-// GlobalCall makes a call to a function in every plugin that is currently
-// loaded
-func GlobalPluginCall(function string, args ...interface{}) {
-	for pl := range loadedPlugins {
-		_, err := Call(pl+"."+function, args...)
-		if err != nil && !strings.HasPrefix(err.Error(), "function does not exist") {
-			TermMessage(err)
-			continue
-		}
+		loadedPlugins = append(loadedPlugins, "init")
 	}
 }

cmd/micro/pluginmanager.go

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

cmd/micro/pluginmanager_test.go

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

cmd/micro/rtfiles.go

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

cmd/micro/scrollbar.go

@@ -1,20 +0,0 @@
-package main
-
-// ScrollBar represents an optional scrollbar that can be used
-type ScrollBar struct {
-	view *View
-}
-
-// Display shows the scrollbar
-func (sb *ScrollBar) Display() {
-	style := defStyle.Reverse(true)
-	screen.SetContent(sb.view.x+sb.view.Width-1, sb.view.y+sb.pos(), ' ', nil, style)
-}
-
-func (sb *ScrollBar) pos() int {
-	numlines := sb.view.Buf.NumLines
-	h := sb.view.Height
-	filepercent := float32(sb.view.Topline) / float32(numlines)
-
-	return int(filepercent * float32(h))
-}

cmd/micro/search.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"regexp"
-	"strings"
 
 	"github.com/zyedidia/tcell"
 )
@@ -12,7 +11,7 @@ var (
 	lastSearch string
 
 	// Where should we start the search down from (or up from)
-	searchStart Loc
+	searchStart int
 
 	// Is there currently a search in progress
 	searching bool
@@ -22,14 +21,12 @@ var (
 )
 
 // BeginSearch starts a search
-func BeginSearch(searchStr string) {
+func BeginSearch() {
 	searchHistory = append(searchHistory, "")
 	messenger.historyNum = len(searchHistory) - 1
 	searching = true
-	messenger.response = searchStr
-	messenger.cursorx = Count(searchStr)
-	messenger.Message("Find: ")
 	messenger.hasPrompt = true
+	messenger.Message("Find: ")
 }
 
 // EndSearch stops the current search
@@ -44,32 +41,13 @@ func EndSearch() {
 	}
 }
 
-// ExitSearch exits the search mode, reset active search phrase, and clear status bar
-func ExitSearch(v *View) {
-	lastSearch = ""
-	searching = false
-	messenger.hasPrompt = false
-	messenger.Clear()
-	messenger.Reset()
-	v.Cursor.ResetSelection()
-}
-
 // HandleSearchEvent takes an event and a view and will do a real time match from the messenger's output
 // to the current buffer. It searches down the buffer.
 func HandleSearchEvent(event tcell.Event, v *View) {
 	switch e := event.(type) {
 	case *tcell.EventKey:
 		switch e.Key() {
-		case tcell.KeyEscape:
-			// Exit the search mode
-			ExitSearch(v)
-			return
-		case tcell.KeyEnter:
-			// If the user has pressed Enter, they want this to be the lastSearch
-			lastSearch = messenger.response
-			EndSearch()
-			return
-		case tcell.KeyCtrlQ, tcell.KeyCtrlC:
+		case tcell.KeyCtrlQ, tcell.KeyCtrlC, tcell.KeyEscape, tcell.KeyEnter:
 			// Done
 			EndSearch()
 			return
@@ -92,71 +70,9 @@ func HandleSearchEvent(event tcell.Event, v *View) {
 
 	Search(messenger.response, v, true)
 
-	v.Relocate()
-
 	return
 }
 
-func searchDown(r *regexp.Regexp, v *View, start, end Loc) bool {
-	for i := start.Y; i <= end.Y; i++ {
-		var l []byte
-		var charPos int
-		if i == start.Y {
-			runes := []rune(string(v.Buf.lines[i].data))
-			l = []byte(string(runes[start.X:]))
-			charPos = start.X
-
-			if strings.Contains(r.String(), "^") && start.X != 0 {
-				continue
-			}
-		} else {
-			l = v.Buf.lines[i].data
-		}
-
-		match := r.FindIndex(l)
-
-		if match != nil {
-			v.Cursor.SetSelectionStart(Loc{charPos + runePos(match[0], string(l)), i})
-			v.Cursor.SetSelectionEnd(Loc{charPos + runePos(match[1], string(l)), i})
-			v.Cursor.OrigSelection[0] = v.Cursor.CurSelection[0]
-			v.Cursor.OrigSelection[1] = v.Cursor.CurSelection[1]
-			v.Cursor.Loc = v.Cursor.CurSelection[1]
-
-			return true
-		}
-	}
-	return false
-}
-
-func searchUp(r *regexp.Regexp, v *View, start, end Loc) bool {
-	for i := start.Y; i >= end.Y; i-- {
-		var l []byte
-		if i == start.Y {
-			runes := []rune(string(v.Buf.lines[i].data))
-			l = []byte(string(runes[:start.X]))
-
-			if strings.Contains(r.String(), "$") && start.X != Count(string(l)) {
-				continue
-			}
-		} else {
-			l = v.Buf.lines[i].data
-		}
-
-		match := r.FindIndex(l)
-
-		if match != nil {
-			v.Cursor.SetSelectionStart(Loc{runePos(match[0], string(l)), i})
-			v.Cursor.SetSelectionEnd(Loc{runePos(match[1], string(l)), i})
-			v.Cursor.OrigSelection[0] = v.Cursor.CurSelection[0]
-			v.Cursor.OrigSelection[1] = v.Cursor.CurSelection[1]
-			v.Cursor.Loc = v.Cursor.CurSelection[1]
-
-			return true
-		}
-	}
-	return false
-}
-
 // 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
@@ -164,6 +80,15 @@ 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)
@@ -171,20 +96,40 @@ func Search(searchStr string, v *View, down bool) {
 	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
+		}
 
-	var found bool
-	if down {
-		found = searchDown(r, v, searchStart, v.Buf.End())
-		if !found {
-			found = searchDown(r, v, v.Buf.Start(), searchStart)
+		if !down {
+			match = matches[len(matches)-1]
+		} else {
+			match = matches[0]
 		}
+		str = text
+	}
+
+	if !down {
+		match = matches[len(matches)-1]
 	} else {
-		found = searchUp(r, v, searchStart, v.Buf.Start())
-		if !found {
-			found = searchUp(r, v, v.Buf.End(), searchStart)
-		}
+		match = matches[0]
 	}
-	if !found {
-		v.Cursor.ResetSelection()
+
+	if match[0] == match[1] {
+		return
 	}
+
+	v.Cursor.SetSelectionStart(FromCharPos(charPos+runePos(match[0], str), v.Buf))
+	v.Cursor.SetSelectionEnd(FromCharPos(charPos+runePos(match[1], str), v.Buf))
+	v.Cursor.Loc = v.Cursor.CurSelection[1]
+	if v.Relocate() {
+		v.matches = Match(v)
+	}
+	lastSearch = searchStr
 }

cmd/micro/settings.go

@@ -1,8 +1,6 @@
 package main
 
 import (
-	"crypto/md5"
-	"encoding/json"
 	"errors"
 	"io/ioutil"
 	"os"
@@ -10,30 +8,15 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/flynn/json5"
+	"github.com/yosuke-furukawa/json5/encoding/json5"
 	"github.com/zyedidia/glob"
 )
 
-type optionValidator func(string, interface{}) error
-
 // The options that the user can set
 var globalSettings map[string]interface{}
 
-var invalidSettings bool
-
-// Options with validators
-var optionValidators = map[string]optionValidator{
-	"tabsize":      validatePositiveValue,
-	"scrollmargin": validateNonNegativeValue,
-	"scrollspeed":  validateNonNegativeValue,
-	"colorscheme":  validateColorscheme,
-	"colorcolumn":  validateNonNegativeValue,
-	"fileformat":   validateLineEnding,
-}
-
 // InitGlobalSettings initializes the options map and sets all options to their default values
 func InitGlobalSettings() {
-	invalidSettings = false
 	defaults := DefaultGlobalSettings()
 	var parsed map[string]interface{}
 
@@ -44,14 +27,12 @@ func InitGlobalSettings() {
 		if !strings.HasPrefix(string(input), "null") {
 			if err != nil {
 				TermMessage("Error reading settings.json file: " + err.Error())
-				invalidSettings = true
 				return
 			}
 
 			err = json5.Unmarshal(input, &parsed)
 			if err != nil {
 				TermMessage("Error reading settings.json:", err.Error())
-				invalidSettings = true
 			}
 		} else {
 			writeSettings = true
@@ -79,7 +60,6 @@ func InitGlobalSettings() {
 // InitLocalSettings scans the json in settings.json and sets the options locally based
 // on whether the buffer matches the glob
 func InitLocalSettings(buf *Buffer) {
-	invalidSettings = false
 	var parsed map[string]interface{}
 
 	filename := configDir + "/settings.json"
@@ -87,36 +67,26 @@ func InitLocalSettings(buf *Buffer) {
 		input, err := ioutil.ReadFile(filename)
 		if err != nil {
 			TermMessage("Error reading settings.json file: " + err.Error())
-			invalidSettings = true
 			return
 		}
 
 		err = json5.Unmarshal(input, &parsed)
 		if err != nil {
 			TermMessage("Error reading settings.json:", err.Error())
-			invalidSettings = true
 		}
 	}
 
 	for k, v := range parsed {
 		if strings.HasPrefix(reflect.TypeOf(v).String(), "map") {
-			if strings.HasPrefix(k, "ft:") {
-				if buf.Settings["filetype"].(string) == k[3:] {
-					for k1, v1 := range v.(map[string]interface{}) {
-						buf.Settings[k1] = v1
-					}
-				}
-			} else {
-				g, err := glob.Compile(k)
-				if err != nil {
-					TermMessage("Error with glob setting ", k, ": ", err)
-					continue
-				}
+			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
-					}
+			if g.MatchString(buf.Path) {
+				for k1, v1 := range v.(map[string]interface{}) {
+					buf.Settings[k1] = v1
 				}
 			}
 		}
@@ -125,11 +95,6 @@ func InitLocalSettings(buf *Buffer) {
 
 // WriteSettings writes the settings to the specified filename as JSON
 func WriteSettings(filename string) error {
-	if invalidSettings {
-		// Do not write the settings if there was an error when reading them
-		return nil
-	}
-
 	var err error
 	if _, e := os.Stat(configDir); e == nil {
 		parsed := make(map[string]interface{})
@@ -148,7 +113,6 @@ func WriteSettings(filename string) error {
 				err = json5.Unmarshal(input, &parsed)
 				if err != nil {
 					TermMessage("Error reading settings.json:", err.Error())
-					invalidSettings = true
 				}
 
 				for k, v := range parsed {
@@ -161,7 +125,7 @@ func WriteSettings(filename string) error {
 			}
 		}
 
-		txt, _ := json.MarshalIndent(parsed, "", "    ")
+		txt, _ := json5.MarshalIndent(parsed, "", "    ")
 		err = ioutil.WriteFile(filename, append(txt, '\n'), 0644)
 	}
 	return err
@@ -200,45 +164,21 @@ func GetOption(name string) interface{} {
 // Note that colorscheme is a global only option
 func DefaultGlobalSettings() map[string]interface{} {
 	return map[string]interface{}{
-		"autoindent":     true,
-		"autosave":       false,
-		"basename":       false,
-		"colorcolumn":    float64(0),
-		"colorscheme":    "default",
-		"cursorline":     true,
-		"eofnewline":     false,
-		"fastdirty":      true,
-		"fileformat":     "unix",
-		"hidehelp":       false,
-		"ignorecase":     false,
-		"indentchar":     " ",
-		"infobar":        true,
-		"keepautoindent": false,
-		"keymenu":        false,
-		"matchbrace":     false,
-		"matchbraceleft": false,
-		"mouse":          true,
-		"pluginchannels": []string{"https://raw.githubusercontent.com/micro-editor/plugin-channel/master/channel.json"},
-		"pluginrepos":    []string{},
-		"rmtrailingws":   false,
-		"ruler":          true,
-		"savecursor":     false,
-		"savehistory":    true,
-		"saveundo":       false,
-		"scrollbar":      false,
-		"scrollmargin":   float64(3),
-		"scrollspeed":    float64(2),
-		"softwrap":       false,
-		"splitbottom":    true,
-		"splitright":     true,
-		"statusline":     true,
-		"sucmd":          "sudo",
-		"syntax":         true,
-		"tabmovement":    false,
-		"tabsize":        float64(4),
-		"tabstospaces":   false,
-		"termtitle":      false,
-		"useprimary":     true,
+		"autoindent":   true,
+		"colorscheme":  "zenburn",
+		"cursorline":   true,
+		"ignorecase":   false,
+		"indentchar":   " ",
+		"infobar":      true,
+		"ruler":        true,
+		"savecursor":   false,
+		"saveundo":     false,
+		"scrollspeed":  float64(2),
+		"scrollmargin": float64(3),
+		"statusline":   true,
+		"syntax":       true,
+		"tabsize":      float64(4),
+		"tabstospaces": false,
 	}
 }
 
@@ -246,37 +186,20 @@ func DefaultGlobalSettings() map[string]interface{} {
 // Note that filetype is a local only option
 func DefaultLocalSettings() map[string]interface{} {
 	return map[string]interface{}{
-		"autoindent":     true,
-		"autosave":       false,
-		"basename":       false,
-		"colorcolumn":    float64(0),
-		"cursorline":     true,
-		"eofnewline":     false,
-		"fastdirty":      true,
-		"fileformat":     "unix",
-		"filetype":       "Unknown",
-		"hidehelp":       false,
-		"ignorecase":     false,
-		"indentchar":     " ",
-		"keepautoindent": false,
-		"matchbrace":     false,
-		"matchbraceleft": false,
-		"rmtrailingws":   false,
-		"ruler":          true,
-		"savecursor":     false,
-		"saveundo":       false,
-		"scrollbar":      false,
-		"scrollmargin":   float64(3),
-		"scrollspeed":    float64(2),
-		"softwrap":       false,
-		"splitbottom":    true,
-		"splitright":     true,
-		"statusline":     true,
-		"syntax":         true,
-		"tabmovement":    false,
-		"tabsize":        float64(4),
-		"tabstospaces":   false,
-		"useprimary":     true,
+		"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,
 	}
 }
 
@@ -285,6 +208,12 @@ func DefaultLocalSettings() map[string]interface{} {
 // 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 option == "colorscheme" {
+		if !ColorschemeExists(value) {
+			return errors.New(value + " is not a valid colorscheme")
+		}
+	}
+
 	if _, ok := globalSettings[option]; !ok {
 		if _, ok := CurView().Buf.Settings[option]; !ok {
 			return errors.New("Invalid option")
@@ -293,63 +222,45 @@ func SetOption(option, value string) error {
 		return nil
 	}
 
-	var nativeValue interface{}
-
 	kind := reflect.TypeOf(globalSettings[option]).Kind()
 	if kind == reflect.Bool {
 		b, err := ParseBool(value)
 		if err != nil {
 			return errors.New("Invalid value")
 		}
-		nativeValue = b
+		globalSettings[option] = b
 	} else if kind == reflect.String {
-		nativeValue = value
+		globalSettings[option] = value
 	} else if kind == reflect.Float64 {
 		i, err := strconv.Atoi(value)
 		if err != nil {
 			return errors.New("Invalid value")
 		}
-		nativeValue = float64(i)
-	} else {
-		return errors.New("Option has unsupported value type")
+		globalSettings[option] = float64(i)
 	}
 
-	if err := optionIsValid(option, nativeValue); err != nil {
-		return err
-	}
-
-	globalSettings[option] = nativeValue
-
 	if option == "colorscheme" {
-		// LoadSyntaxFiles()
-		InitColorscheme()
+		LoadSyntaxFiles()
 		for _, tab := range tabs {
-			for _, view := range tab.Views {
+			for _, view := range tab.views {
 				view.Buf.UpdateRules()
+				if view.Buf.Settings["syntax"].(bool) {
+					view.matches = Match(view)
+				}
 			}
 		}
 	}
 
-	if option == "infobar" || option == "keymenu" {
+	if option == "infobar" {
 		for _, tab := range tabs {
 			tab.Resize()
 		}
 	}
 
-	if option == "mouse" {
-		if !nativeValue.(bool) {
-			screen.DisableMouse()
-		} else {
-			screen.EnableMouse()
-		}
-	}
-
-	if len(tabs) != 0 {
-		if _, ok := CurView().Buf.Settings[option]; ok {
-			for _, tab := range tabs {
-				for _, view := range tab.Views {
-					SetLocalOption(option, value, view)
-				}
+	if _, ok := CurView().Buf.Settings[option]; ok {
+		for _, tab := range tabs {
+			for _, view := range tab.views {
+				SetLocalOption(option, value, view)
 			}
 		}
 	}
@@ -364,74 +275,35 @@ func SetLocalOption(option, value string, view *View) error {
 		return errors.New("Invalid option")
 	}
 
-	var nativeValue interface{}
-
 	kind := reflect.TypeOf(buf.Settings[option]).Kind()
 	if kind == reflect.Bool {
 		b, err := ParseBool(value)
 		if err != nil {
 			return errors.New("Invalid value")
 		}
-		nativeValue = b
+		buf.Settings[option] = b
 	} else if kind == reflect.String {
-		nativeValue = value
+		buf.Settings[option] = value
 	} else if kind == reflect.Float64 {
 		i, err := strconv.Atoi(value)
 		if err != nil {
 			return errors.New("Invalid value")
 		}
-		nativeValue = float64(i)
-	} else {
-		return errors.New("Option has unsupported value type")
+		buf.Settings[option] = float64(i)
 	}
 
-	if err := optionIsValid(option, nativeValue); err != nil {
-		return err
-	}
-
-	if option == "fastdirty" {
-		// If it is being turned off, we have to hash every open buffer
-		var empty [16]byte
-		for _, tab := range tabs {
-			for _, v := range tab.Views {
-				if !nativeValue.(bool) {
-					if v.Buf.origHash == empty {
-						data, err := ioutil.ReadFile(v.Buf.AbsPath)
-						if err != nil {
-							data = []byte{}
-						}
-						v.Buf.origHash = md5.Sum(data)
-					}
-				} else {
-					v.Buf.IsModified = v.Buf.Modified()
-				}
-			}
-		}
-	}
-
-	buf.Settings[option] = nativeValue
-
 	if option == "statusline" {
 		view.ToggleStatusLine()
+		if buf.Settings["syntax"].(bool) {
+			view.matches = Match(view)
+		}
 	}
 
 	if option == "filetype" {
-		// LoadSyntaxFiles()
-		InitColorscheme()
+		LoadSyntaxFiles()
 		buf.UpdateRules()
-	}
-
-	if option == "fileformat" {
-		buf.IsModified = true
-	}
-
-	if option == "syntax" {
-		if !nativeValue.(bool) {
-			buf.ClearMatches()
-		} else {
-			if buf.highlighter != nil {
-				buf.highlighter.HighlightStates(buf)
-			}
+		if buf.Settings["syntax"].(bool) {
+			view.matches = Match(view)
 		}
 	}
 
@@ -455,69 +327,3 @@ func SetOptionAndSettings(option, value string) {
 		return
 	}
 }
-
-func optionIsValid(option string, value interface{}) error {
-	if validator, ok := optionValidators[option]; ok {
-		return validator(option, value)
-	}
-
-	return nil
-}
-
-// Option validators
-
-func validatePositiveValue(option string, value interface{}) error {
-	tabsize, ok := value.(float64)
-
-	if !ok {
-		return errors.New("Expected numeric type for " + option)
-	}
-
-	if tabsize < 1 {
-		return errors.New(option + " must be greater than 0")
-	}
-
-	return nil
-}
-
-func validateNonNegativeValue(option string, value interface{}) error {
-	nativeValue, ok := value.(float64)
-
-	if !ok {
-		return errors.New("Expected numeric type for " + option)
-	}
-
-	if nativeValue < 0 {
-		return errors.New(option + " must be non-negative")
-	}
-
-	return nil
-}
-
-func validateColorscheme(option string, value interface{}) error {
-	colorscheme, ok := value.(string)
-
-	if !ok {
-		return errors.New("Expected string type for colorscheme")
-	}
-
-	if !ColorschemeExists(colorscheme) {
-		return errors.New(colorscheme + " is not a valid colorscheme")
-	}
-
-	return nil
-}
-
-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
-}

cmd/micro/shell.go

@@ -1,129 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"io"
-	"os"
-	"os/exec"
-	"os/signal"
-	"strings"
-
-	"github.com/zyedidia/micro/cmd/micro/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
-}
-
-// RunShellCommand executes a shell command and returns the output/error
-func RunShellCommand(input string) (string, error) {
-	args, err := shellwords.Split(input)
-	if err != nil {
-		return "", err
-	}
-	inputCmd := args[0]
-
-	return ExecCommand(inputCmd, args[1:]...)
-}
-
-func RunBackgroundShell(input string) {
-	args, err := shellwords.Split(input)
-	if err != nil {
-		messenger.Error(err)
-		return
-	}
-	inputCmd := args[0]
-	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()
-	}()
-}
-
-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
-	screen.Fini()
-	screen = nil
-
-	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
-		TermMessage("")
-	}
-
-	// Start the screen back up
-	InitScreen()
-
-	return output, 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, waitToFinish bool) string {
-	if !openTerm {
-		RunBackgroundShell(input)
-		return ""
-	} else {
-		output, _ := RunInteractiveShell(input, waitToFinish, false)
-		return output
-	}
-}

cmd/micro/shell_supported.go

@@ -1,18 +0,0 @@
-// +build linux darwin dragonfly openbsd_amd64 freebsd
-
-package main
-
-import (
-	"github.com/zyedidia/micro/cmd/micro/shellwords"
-)
-
-const TermEmuSupported = true
-
-func RunTermEmulator(input string, wait bool, getOutput bool, callback string) error {
-	args, err := shellwords.Split(input)
-	if err != nil {
-		return err
-	}
-	err = CurView().StartTerminal(args, wait, getOutput, callback)
-	return err
-}

cmd/micro/shell_unsupported.go

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

cmd/micro/shellwords/LICENSE

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

cmd/micro/shellwords/README.md

@@ -1,49 +0,0 @@
-This is a modified version of `go-shellwords` for the micro editor.
-
-# go-shellwords
-
-[![Coverage Status](https://coveralls.io/repos/mattn/go-shellwords/badge.png?branch=master)](https://coveralls.io/r/mattn/go-shellwords?branch=master)
-[![Build Status](https://travis-ci.org/mattn/go-shellwords.svg?branch=master)](https://travis-ci.org/mattn/go-shellwords)
-
-Parse line as shell words.
-
-## Usage
-
-```go
-args, err := shellwords.Parse("./foo --bar=baz")
-// args should be ["./foo", "--bar=baz"]
-```
-
-```go
-os.Setenv("FOO", "bar")
-p := shellwords.NewParser()
-p.ParseEnv = true
-args, err := p.Parse("./foo $FOO")
-// args should be ["./foo", "bar"]
-```
-
-```go
-p := shellwords.NewParser()
-p.ParseBacktick = true
-args, err := p.Parse("./foo `echo $SHELL`")
-// args should be ["./foo", "/bin/bash"]
-```
-
-```go
-shellwords.ParseBacktick = true
-p := shellwords.NewParser()
-args, err := p.Parse("./foo `echo $SHELL`")
-// args should be ["./foo", "/bin/bash"]
-```
-
-# Thanks
-
-This is based on cpan module [Parse::CommandLine](https://metacpan.org/pod/Parse::CommandLine).
-
-# License
-
-under the MIT License: http://mattn.mit-license.org/2017
-
-# Author
-
-Yasuhiro Matsumoto (a.k.a mattn)

cmd/micro/shellwords/shellwords.go

@@ -1,180 +0,0 @@
-package shellwords
-
-import (
-	"bytes"
-	"errors"
-	"os"
-	"regexp"
-)
-
-var envRe = regexp.MustCompile(`\$({[a-zA-Z0-9_]+}|[a-zA-Z0-9_]+)`)
-
-func isSpace(r rune) bool {
-	switch r {
-	case ' ', '\t', '\r', '\n':
-		return true
-	}
-	return false
-}
-
-func replaceEnv(s string) string {
-	return envRe.ReplaceAllStringFunc(s, func(s string) string {
-		s = s[1:]
-		if s[0] == '{' {
-			s = s[1 : len(s)-1]
-		}
-		return os.Getenv(s)
-	})
-}
-
-type Parser struct {
-	Position int
-}
-
-func NewParser() *Parser {
-	return &Parser{0}
-}
-
-func (p *Parser) Parse(line string) ([]string, error) {
-	args := []string{}
-	buf := ""
-	var escaped, doubleQuoted, singleQuoted, backQuote, dollarQuote bool
-	backtick := ""
-
-	pos := -1
-	got := false
-
-loop:
-	for i, r := range line {
-		if escaped {
-			buf += string(r)
-			escaped = false
-			continue
-		}
-
-		if r == '\\' {
-			if singleQuoted {
-				buf += string(r)
-			} else {
-				escaped = true
-			}
-			continue
-		}
-
-		if isSpace(r) {
-			if singleQuoted || doubleQuoted || backQuote || dollarQuote {
-				buf += string(r)
-				backtick += string(r)
-			} else if got {
-				buf = replaceEnv(buf)
-				args = append(args, buf)
-				buf = ""
-				got = false
-			}
-			continue
-		}
-
-		switch r {
-		case '`':
-			if !singleQuoted && !doubleQuoted && !dollarQuote {
-				if backQuote {
-					out, err := shellRun(backtick)
-					if err != nil {
-						return nil, err
-					}
-					buf = out
-				}
-				backtick = ""
-				backQuote = !backQuote
-				continue
-				backtick = ""
-				backQuote = !backQuote
-			}
-		case ')':
-			if !singleQuoted && !doubleQuoted && !backQuote {
-				if dollarQuote {
-					out, err := shellRun(backtick)
-					if err != nil {
-						return nil, err
-					}
-					buf = out
-				}
-				backtick = ""
-				dollarQuote = !dollarQuote
-				continue
-				backtick = ""
-				dollarQuote = !dollarQuote
-			}
-		case '(':
-			if !singleQuoted && !doubleQuoted && !backQuote {
-				if !dollarQuote && len(buf) > 0 && buf == "$" {
-					dollarQuote = true
-					buf += "("
-					continue
-				} else {
-					return nil, errors.New("invalid command line string")
-				}
-			}
-		case '"':
-			if !singleQuoted && !dollarQuote {
-				doubleQuoted = !doubleQuoted
-				continue
-			}
-		case '\'':
-			if !doubleQuoted && !dollarQuote {
-				singleQuoted = !singleQuoted
-				continue
-			}
-		case ';', '&', '|', '<', '>':
-			if !(escaped || singleQuoted || doubleQuoted || backQuote) {
-				pos = i
-				break loop
-			}
-		}
-
-		got = true
-		buf += string(r)
-		if backQuote || dollarQuote {
-			backtick += string(r)
-		}
-	}
-
-	buf = replaceEnv(buf)
-	args = append(args, buf)
-
-	if escaped || singleQuoted || doubleQuoted || backQuote || dollarQuote {
-		return nil, errors.New("invalid command line string")
-	}
-
-	p.Position = pos
-
-	return args, nil
-}
-
-func Split(line string) ([]string, error) {
-	return NewParser().Parse(line)
-}
-
-func Join(args ...string) string {
-	var buf bytes.Buffer
-	for i, w := range args {
-		if i != 0 {
-			buf.WriteByte(' ')
-		}
-		if w == "" {
-			buf.WriteString("''")
-			continue
-		}
-
-		for _, b := range w {
-			switch b {
-			case ' ', '\t', '\r', '\n':
-				buf.WriteByte('\\')
-				buf.WriteString(string(b))
-			default:
-				buf.WriteString(string(b))
-			}
-		}
-	}
-	return buf.String()
-}

cmd/micro/shellwords/shellwords_test.go

@@ -1,229 +0,0 @@
-package shellwords
-
-import (
-	"os"
-	"reflect"
-	"testing"
-)
-
-var testcases = []struct {
-	line     string
-	expected []string
-}{
-	{`var --bar=baz`, []string{`var`, `--bar=baz`}},
-	{`var --bar="baz"`, []string{`var`, `--bar=baz`}},
-	{`var "--bar=baz"`, []string{`var`, `--bar=baz`}},
-	{`var "--bar='baz'"`, []string{`var`, `--bar='baz'`}},
-	{"var --bar=`baz`", []string{`var`, "--bar=`baz`"}},
-	{`var "--bar=\"baz'"`, []string{`var`, `--bar="baz'`}},
-	{`var "--bar=\'baz\'"`, []string{`var`, `--bar='baz'`}},
-	{`var --bar='\'`, []string{`var`, `--bar=\`}},
-	{`var "--bar baz"`, []string{`var`, `--bar baz`}},
-	{`var --"bar baz"`, []string{`var`, `--bar baz`}},
-	{`var  --"bar baz"`, []string{`var`, `--bar baz`}},
-}
-
-func TestSimple(t *testing.T) {
-	for _, testcase := range testcases {
-		args, err := Parse(testcase.line)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if !reflect.DeepEqual(args, testcase.expected) {
-			t.Fatalf("Expected %#v, but %#v:", testcase.expected, args)
-		}
-	}
-}
-
-func TestError(t *testing.T) {
-	_, err := Parse("foo '")
-	if err == nil {
-		t.Fatal("Should be an error")
-	}
-	_, err = Parse(`foo "`)
-	if err == nil {
-		t.Fatal("Should be an error")
-	}
-
-	_, err = Parse("foo `")
-	if err == nil {
-		t.Fatal("Should be an error")
-	}
-}
-
-func TestLastSpace(t *testing.T) {
-	args, err := Parse("foo bar\\  ")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(args) != 2 {
-		t.Fatal("Should have two elements")
-	}
-	if args[0] != "foo" {
-		t.Fatal("1st element should be `foo`")
-	}
-	if args[1] != "bar " {
-		t.Fatal("1st element should be `bar `")
-	}
-}
-
-func TestBacktick(t *testing.T) {
-	goversion, err := shellRun("go version")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	parser := NewParser()
-	parser.ParseBacktick = true
-	args, err := parser.Parse("echo `go version`")
-	if err != nil {
-		t.Fatal(err)
-	}
-	expected := []string{"echo", goversion}
-	if !reflect.DeepEqual(args, expected) {
-		t.Fatalf("Expected %#v, but %#v:", expected, args)
-	}
-
-	args, err = parser.Parse(`echo $(echo foo)`)
-	if err != nil {
-		t.Fatal(err)
-	}
-	expected = []string{"echo", "foo"}
-	if !reflect.DeepEqual(args, expected) {
-		t.Fatalf("Expected %#v, but %#v:", expected, args)
-	}
-
-	parser.ParseBacktick = false
-	args, err = parser.Parse(`echo $(echo "foo")`)
-	expected = []string{"echo", `$(echo "foo")`}
-	if !reflect.DeepEqual(args, expected) {
-		t.Fatalf("Expected %#v, but %#v:", expected, args)
-	}
-	args, err = parser.Parse("echo $(`echo1)")
-	if err != nil {
-		t.Fatal(err)
-	}
-	expected = []string{"echo", "$(`echo1)"}
-	if !reflect.DeepEqual(args, expected) {
-		t.Fatalf("Expected %#v, but %#v:", expected, args)
-	}
-}
-
-func TestBacktickError(t *testing.T) {
-	parser := NewParser()
-	parser.ParseBacktick = true
-	_, err := parser.Parse("echo `go Version`")
-	if err == nil {
-		t.Fatal("Should be an error")
-	}
-	expected := "exit status 2:go: unknown subcommand \"Version\"\nRun 'go help' for usage.\n"
-	if expected != err.Error() {
-		t.Fatalf("Expected %q, but %q", expected, err.Error())
-	}
-	_, err = parser.Parse(`echo $(echo1)`)
-	if err == nil {
-		t.Fatal("Should be an error")
-	}
-	_, err = parser.Parse(`echo $(echo1`)
-	if err == nil {
-		t.Fatal("Should be an error")
-	}
-	_, err = parser.Parse(`echo $ (echo1`)
-	if err == nil {
-		t.Fatal("Should be an error")
-	}
-	_, err = parser.Parse(`echo (echo1`)
-	if err == nil {
-		t.Fatal("Should be an error")
-	}
-	_, err = parser.Parse(`echo )echo1`)
-	if err == nil {
-		t.Fatal("Should be an error")
-	}
-}
-
-func TestEnv(t *testing.T) {
-	os.Setenv("FOO", "bar")
-
-	parser := NewParser()
-	parser.ParseEnv = true
-	args, err := parser.Parse("echo $FOO")
-	if err != nil {
-		t.Fatal(err)
-	}
-	expected := []string{"echo", "bar"}
-	if !reflect.DeepEqual(args, expected) {
-		t.Fatalf("Expected %#v, but %#v:", expected, args)
-	}
-}
-
-func TestNoEnv(t *testing.T) {
-	parser := NewParser()
-	parser.ParseEnv = true
-	args, err := parser.Parse("echo $BAR")
-	if err != nil {
-		t.Fatal(err)
-	}
-	expected := []string{"echo", ""}
-	if !reflect.DeepEqual(args, expected) {
-		t.Fatalf("Expected %#v, but %#v:", expected, args)
-	}
-}
-
-func TestDupEnv(t *testing.T) {
-	os.Setenv("FOO", "bar")
-	os.Setenv("FOO_BAR", "baz")
-
-	parser := NewParser()
-	parser.ParseEnv = true
-	args, err := parser.Parse("echo $$FOO$")
-	if err != nil {
-		t.Fatal(err)
-	}
-	expected := []string{"echo", "$bar$"}
-	if !reflect.DeepEqual(args, expected) {
-		t.Fatalf("Expected %#v, but %#v:", expected, args)
-	}
-
-	args, err = parser.Parse("echo $${FOO_BAR}$")
-	if err != nil {
-		t.Fatal(err)
-	}
-	expected = []string{"echo", "$baz$"}
-	if !reflect.DeepEqual(args, expected) {
-		t.Fatalf("Expected %#v, but %#v:", expected, args)
-	}
-}
-
-func TestHaveMore(t *testing.T) {
-	parser := NewParser()
-	parser.ParseEnv = true
-
-	line := "echo foo; seq 1 10"
-	args, err := parser.Parse(line)
-	if err != nil {
-		t.Fatalf(err.Error())
-	}
-	expected := []string{"echo", "foo"}
-	if !reflect.DeepEqual(args, expected) {
-		t.Fatalf("Expected %#v, but %#v:", expected, args)
-	}
-
-	if parser.Position == 0 {
-		t.Fatalf("Commands should be remaining")
-	}
-
-	line = string([]rune(line)[parser.Position+1:])
-	args, err = parser.Parse(line)
-	if err != nil {
-		t.Fatalf(err.Error())
-	}
-	expected = []string{"seq", "1", "10"}
-	if !reflect.DeepEqual(args, expected) {
-		t.Fatalf("Expected %#v, but %#v:", expected, args)
-	}
-
-	if parser.Position > 0 {
-		t.Fatalf("Commands should not be remaining")
-	}
-}

cmd/micro/shellwords/util_posix.go

@@ -1,22 +0,0 @@
-// +build !windows
-
-package shellwords
-
-import (
-	"errors"
-	"os"
-	"os/exec"
-	"strings"
-)
-
-func shellRun(line string) (string, error) {
-	shell := os.Getenv("SHELL")
-	b, err := exec.Command(shell, "-c", line).Output()
-	if err != nil {
-		if eerr, ok := err.(*exec.ExitError); ok {
-			b = eerr.Stderr
-		}
-		return "", errors.New(err.Error() + ":" + string(b))
-	}
-	return strings.TrimSpace(string(b)), nil
-}

cmd/micro/shellwords/util_windows.go

@@ -1,20 +0,0 @@
-package shellwords
-
-import (
-	"errors"
-	"os"
-	"os/exec"
-	"strings"
-)
-
-func shellRun(line string) (string, error) {
-	shell := os.Getenv("COMSPEC")
-	b, err := exec.Command(shell, "/c", line).Output()
-	if err != nil {
-		if eerr, ok := err.(*exec.ExitError); ok {
-			b = eerr.Stderr
-		}
-		return "", errors.New(err.Error() + ":" + string(b))
-	}
-	return strings.TrimSpace(string(b)), nil
-}

cmd/micro/split_tree.go

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

cmd/micro/statusline.go

@@ -1,7 +1,6 @@
 package main
 
 import (
-	"path"
 	"strconv"
 )
 
@@ -15,20 +14,13 @@ type Statusline struct {
 
 // Display draws the statusline to the screen
 func (sline *Statusline) Display() {
-	if messenger.hasPrompt && !GetGlobalOption("infobar").(bool) {
-		return
-	}
-
 	// We'll draw the line at the lowest line in the view
-	y := sline.view.Height + sline.view.y
+	y := sline.view.height + sline.view.y
 
-	file := sline.view.Buf.GetName()
-	if sline.view.Buf.Settings["basename"].(bool) {
-		file = path.Base(file)
-	}
+	file := sline.view.Buf.Name
 
 	// If the buffer is dirty (has been modified) write a little '+'
-	if sline.view.Buf.Modified() {
+	if sline.view.Buf.IsModified {
 		file += " +"
 	}
 
@@ -44,28 +36,9 @@ func (sline *Statusline) Display() {
 	// Add the filetype
 	file += " " + sline.view.Buf.FileType()
 
-	file += " " + sline.view.Buf.Settings["fileformat"].(string)
-
-	rightText := ""
-	if !sline.view.Buf.Settings["hidehelp"].(bool) {
-		if len(kmenuBinding) > 0 {
-			if globalSettings["keymenu"].(bool) {
-				rightText += kmenuBinding + ": hide bindings"
-			} else {
-				rightText += kmenuBinding + ": show bindings"
-			}
-		}
-		if len(helpBinding) > 0 {
-			if len(kmenuBinding) > 0 {
-				rightText += ", "
-			}
-			if sline.view.Type == vtHelp {
-				rightText += helpBinding + ": close help"
-			} else {
-				rightText += helpBinding + ": open help"
-			}
-		}
-		rightText += " "
+	rightText := helpBinding + " for help "
+	if sline.view.Help {
+		rightText = helpBinding + " to close help "
 	}
 
 	statusLineStyle := defStyle.Reverse(true)
@@ -75,22 +48,16 @@ func (sline *Statusline) Display() {
 
 	// Maybe there is a unicode filename?
 	fileRunes := []rune(file)
-
-	if sline.view.Type == vtTerm {
-		fileRunes = []rune(sline.view.term.title)
-		rightText = ""
-	}
-
 	viewX := sline.view.x
 	if viewX != 0 {
 		screen.SetContent(viewX, y, ' ', nil, statusLineStyle)
 		viewX++
 	}
-	for x := 0; x < sline.view.Width; x++ {
+	for x := 0; x < sline.view.width; x++ {
 		if x < len(fileRunes) {
 			screen.SetContent(viewX+x, y, fileRunes[x], nil, statusLineStyle)
-		} else if x >= sline.view.Width-len(rightText) && x < len(rightText)+sline.view.Width-len(rightText) {
-			screen.SetContent(viewX+x, y, []rune(rightText)[x-sline.view.Width+len(rightText)], nil, statusLineStyle)
+		} else if x >= sline.view.width-len(rightText) && x < len(rightText)+sline.view.width-len(rightText) {
+			screen.SetContent(viewX+x, y, []rune(rightText)[x-sline.view.width+len(rightText)], nil, statusLineStyle)
 		} else {
 			screen.SetContent(viewX+x, y, ' ', nil, statusLineStyle)
 		}

cmd/micro/tab.go

@@ -6,17 +6,15 @@ import (
 	"github.com/zyedidia/tcell"
 )
 
-var tabBarOffset int
-
-// A Tab holds an array of views and a splitTree to determine how the
-// views should be arranged
 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
+	views []*View
 	// This is the current view for this tab
-	CurView int
+	curView int
+	// Generally this is the name of the current view's buffer
+	name string
 
 	tree *SplitTree
 }
@@ -24,12 +22,12 @@ type Tab struct {
 // 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.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)}
+	t.tree.children = []Node{NewLeafNode(t.views[0], t.tree)}
 
 	w, h := screen.Size()
 	t.tree.width = w
@@ -38,30 +36,21 @@ func NewTabFromView(v *View) *Tab {
 	if globalSettings["infobar"].(bool) {
 		t.tree.height--
 	}
-	if globalSettings["keymenu"].(bool) {
-		t.tree.height -= 2
-	}
-
-	t.Resize()
 
 	return t
 }
 
 // SetNum sets all this tab's views to have the correct tab number
 func (t *Tab) SetNum(num int) {
-	t.tree.tabNum = num
-	for _, v := range t.Views {
+	for _, v := range t.views {
 		v.TabNum = num
 	}
 }
 
-// Cleanup cleans up the tree (for example if views have closed)
 func (t *Tab) Cleanup() {
 	t.tree.Cleanup()
 }
 
-// Resize handles a resize event from the terminal and resizes
-// all child views correctly
 func (t *Tab) Resize() {
 	w, h := screen.Size()
 	t.tree.width = w
@@ -70,24 +59,14 @@ func (t *Tab) Resize() {
 	if globalSettings["infobar"].(bool) {
 		t.tree.height--
 	}
-	if globalSettings["keymenu"].(bool) {
-		t.tree.height -= 2
-	}
 
 	t.tree.ResizeSplits()
-
-	for i, v := range t.Views {
-		v.Num = i
-		if v.Type == vtTerm {
-			v.term.Resize(v.Width, v.Height)
-		}
-	}
 }
 
 // CurView returns the current view
 func CurView() *View {
 	curTab := tabs[curTab]
-	return curTab.Views[curTab.CurView]
+	return curTab.views[curTab.curView]
 }
 
 // TabbarString returns the string that should be displayed in the tabbar
@@ -103,17 +82,13 @@ func TabbarString() (string, map[int]int) {
 		} else {
 			str += " "
 		}
-		buf := t.Views[t.CurView].Buf
-		str += buf.GetName()
-		if buf.Modified() {
-			str += " +"
-		}
+		str += t.views[t.curView].Buf.Name
 		if i == curTab {
 			str += "]"
 		} else {
 			str += " "
 		}
-		indicies[Count(str)-1] = i + 1
+		indicies[len(str)-1] = i + 1
 		str += " "
 	}
 	return str, indicies
@@ -138,7 +113,7 @@ func TabbarHandleMouseEvent(event tcell.Event) bool {
 				return false
 			}
 			str, indicies := TabbarString()
-			if x+tabBarOffset >= len(str) {
+			if x >= len(str) {
 				return false
 			}
 			var tabnum int
@@ -148,7 +123,7 @@ func TabbarHandleMouseEvent(event tcell.Event) bool {
 			}
 			sort.Ints(keys)
 			for _, k := range keys {
-				if x+tabBarOffset <= k {
+				if x <= k {
 					tabnum = indicies[k] - 1
 					break
 				}
@@ -167,7 +142,7 @@ func DisplayTabs() {
 		return
 	}
 
-	str, indicies := TabbarString()
+	str, _ := TabbarString()
 
 	tabBarStyle := defStyle.Reverse(true)
 	if style, ok := colorscheme["tabbar"]; ok {
@@ -177,98 +152,6 @@ func DisplayTabs() {
 	// Maybe there is a unicode filename?
 	fileRunes := []rune(str)
 	w, _ := screen.Size()
-	tooWide := (w < len(fileRunes))
-
-	// if the entire tab-bar is longer than the screen is wide,
-	// then it should be truncated appropriately to keep the
-	// active tab visible on the UI.
-	if tooWide == true {
-		// first we have to work out where the selected tab is
-		// out of the total length of the tab bar. this is done
-		// by extracting the hit-areas from the indicies map
-		// that was constructed by `TabbarString()`
-		var keys []int
-		for offset := range indicies {
-			keys = append(keys, offset)
-		}
-		// sort them to be in ascending order so that values will
-		// correctly reflect the displayed ordering of the tabs
-		sort.Ints(keys)
-		// record the offset of each tab and the previous tab so
-		// we can find the position of the tab's hit-box.
-		previousTabOffset := 0
-		currentTabOffset := 0
-		for _, k := range keys {
-			tabIndex := indicies[k] - 1
-			if tabIndex == curTab {
-				currentTabOffset = k
-				break
-			}
-			// this is +2 because there are two padding spaces that aren't accounted
-			// for in the display. please note that this is for cosmetic purposes only.
-			previousTabOffset = k + 2
-		}
-		// get the width of the hitbox of the active tab, from there calculate the offsets
-		// to the left and right of it to approximately center it on the tab bar display.
-		centeringOffset := (w - (currentTabOffset - previousTabOffset))
-		leftBuffer := previousTabOffset - (centeringOffset / 2)
-		rightBuffer := currentTabOffset + (centeringOffset / 2)
-
-		// check to make sure we haven't overshot the bounds of the string,
-		// if we have, then take that remainder and put it on the left side
-		overshotRight := rightBuffer - len(fileRunes)
-		if overshotRight > 0 {
-			leftBuffer = leftBuffer + overshotRight
-		}
-
-		overshotLeft := leftBuffer - 0
-		if overshotLeft < 0 {
-			leftBuffer = 0
-			rightBuffer = leftBuffer + (w - 1)
-		} else {
-			rightBuffer = leftBuffer + (w - 2)
-		}
-
-		if rightBuffer > len(fileRunes)-1 {
-			rightBuffer = len(fileRunes) - 1
-		}
-
-		// construct a new buffer of text to put the
-		// newly formatted tab bar text into.
-		var displayText []rune
-
-		// if the left-side of the tab bar isn't at the start
-		// of the constructed tab bar text, then show that are
-		// more tabs to the left by displaying a "+"
-		if leftBuffer != 0 {
-			displayText = append(displayText, '+')
-		}
-		// copy the runes in from the original tab bar text string
-		// into the new display buffer
-		for x := leftBuffer; x < rightBuffer; x++ {
-			displayText = append(displayText, fileRunes[x])
-		}
-		// if there is more text to the right of the right-most
-		// column in the tab bar text, then indicate there are more
-		// tabs to the right by displaying a "+"
-		if rightBuffer < len(fileRunes)-1 {
-			displayText = append(displayText, '+')
-		}
-
-		// now store the offset from zero of the left-most text
-		// that is being displayed. This is to ensure that when
-		// clicking on the tab bar, the correct tab gets selected.
-		tabBarOffset = leftBuffer
-
-		// use the constructed buffer as the display buffer to print
-		// onscreen.
-		fileRunes = displayText
-	} else {
-		tabBarOffset = 0
-	}
-
-	// iterate over the width of the terminal display and for each column,
-	// write a character into the tab display area with the appropriate style.
 	for x := 0; x < w; x++ {
 		if x < len(fileRunes) {
 			screen.SetContent(x, 0, fileRunes[x], nil, tabBarStyle)

cmd/micro/terminal.go

@@ -1,228 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"fmt"
-	"os"
-	"os/exec"
-	"strconv"
-	"strings"
-
-	"github.com/zyedidia/clipboard"
-	"github.com/zyedidia/tcell"
-	"github.com/zyedidia/terminal"
-)
-
-const (
-	VTIdle    = iota // Waiting for a new command
-	VTRunning        // Currently running a command
-	VTDone           // Finished running a command
-)
-
-// A Terminal holds information for the terminal emulator
-type Terminal struct {
-	state     terminal.State
-	view      *View
-	vtOld     ViewType
-	term      *terminal.VT
-	title     string
-	status    int
-	selection [2]Loc
-	wait      bool
-	getOutput bool
-	output    *bytes.Buffer
-	callback  string
-}
-
-// HasSelection returns whether this terminal has a valid selection
-func (t *Terminal) HasSelection() bool {
-	return t.selection[0] != t.selection[1]
-}
-
-// 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 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, view *View, getOutput bool) 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.view = view
-	t.getOutput = getOutput
-	t.vtOld = view.Type
-	t.status = VTRunning
-	t.title = execCmd[0] + ":" + strconv.Itoa(cmd.Process.Pid)
-
-	go func() {
-		for {
-			err := term.Parse()
-			if err != nil {
-				fmt.Fprintln(os.Stderr, "[Press enter to close]")
-				break
-			}
-			updateterm <- true
-		}
-		closeterm <- view.Num
-	}()
-
-	return nil
-}
-
-// Resize informs the terminal of a resize event
-func (t *Terminal) Resize(width, height int) {
-	t.term.Resize(width, height)
-}
-
-// 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 *Terminal) HandleEvent(event tcell.Event) {
-	if e, ok := event.(*tcell.EventKey); ok {
-		if t.status == VTDone {
-			switch e.Key() {
-			case tcell.KeyEscape, tcell.KeyCtrlQ, tcell.KeyEnter:
-				t.Close()
-				t.view.Type = vtDefault
-			default:
-			}
-		}
-		if e.Key() == tcell.KeyCtrlC && t.HasSelection() {
-			clipboard.WriteAll(t.GetSelection(t.view.Width), "clipboard")
-			messenger.Message("Copied selection to clipboard")
-		} else if t.status != VTDone {
-			t.WriteString(event.EscSeq())
-		}
-	} else if e, ok := event.(*tcell.EventMouse); !ok || t.state.Mode(terminal.ModeMouseMask) {
-		t.WriteString(event.EscSeq())
-	} else {
-		x, y := e.Position()
-		x -= t.view.x
-		y += t.view.y
-
-		if e.Buttons() == tcell.Button1 {
-			if !t.view.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.view.mouseReleased = false
-		} else if e.Buttons() == tcell.ButtonNone {
-			if !t.view.mouseReleased {
-				t.selection[1].X = x
-				t.selection[1].Y = y
-			}
-			t.view.mouseReleased = true
-		}
-	}
-}
-
-// Stop stops execution of the terminal and sets the status
-// to VTDone
-func (t *Terminal) Stop() {
-	t.term.File().Close()
-	t.term.Close()
-	if t.wait {
-		t.status = VTDone
-	} else {
-		t.Close()
-		t.view.Type = t.vtOld
-	}
-}
-
-// Close sets the status to VTIdle indicating that the terminal
-// is ready for a new command to execute
-func (t *Terminal) Close() {
-	t.status = VTIdle
-	// call the lua function that the user has given as a callback
-	if t.getOutput {
-		_, err := Call(t.callback, t.output.String())
-		if err != nil && !strings.HasPrefix(err.Error(), "function does not exist") {
-			TermMessage(err)
-		}
-	}
-}
-
-// WriteString writes a given string to this terminal's pty
-func (t *Terminal) WriteString(str string) {
-	t.term.File().WriteString(str)
-}
-
-// Display displays this terminal in a view
-func (t *Terminal) Display() {
-	divider := 0
-	if t.view.x != 0 {
-		divider = 1
-		dividerStyle := defStyle
-		if style, ok := colorscheme["divider"]; ok {
-			dividerStyle = style
-		}
-		for i := 0; i < t.view.Height; i++ {
-			screen.SetContent(t.view.x, t.view.y+i, '|', nil, dividerStyle.Reverse(true))
-		}
-	}
-	t.state.Lock()
-	defer t.state.Unlock()
-
-	var l Loc
-	for y := 0; y < t.view.Height; y++ {
-		for x := 0; x < t.view.Width; x++ {
-			l.X, l.Y = x, y
-			c, f, b := t.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(GetColor256(int(fg))).Background(GetColor256(int(bg)))
-
-			if l.LessThan(t.selection[1]) && l.GreaterEqual(t.selection[0]) || l.LessThan(t.selection[0]) && l.GreaterEqual(t.selection[1]) {
-				st = st.Reverse(true)
-			}
-
-			screen.SetContent(t.view.x+x+divider, t.view.y+y, c, nil, st)
-		}
-	}
-	if t.state.CursorVisible() && tabs[curTab].CurView == t.view.Num {
-		curx, cury := t.state.Cursor()
-		screen.ShowCursor(curx+t.view.x+divider, cury+t.view.y)
-	}
-}

cmd/micro/terminfo/LICENSE.md

@@ -1,203 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-

cmd/micro/terminfo/README.md

@@ -1,6 +0,0 @@
-# Terminfo parser
-
-This terminfo parser was written by the authors of [tcell](https://github.com/gdamore/tcell). We are using it here
-to compile the terminal database if the terminal entry is not found in set of precompiled terminals.
-
-The source for `mkinfo.go` is adapted from tcell's `mkinfo` tool to be more of a library.

cmd/micro/terminfo/mkinfo.go

@@ -1,512 +0,0 @@
-// Copyright 2017 The TCell Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use file except in compliance with the License.
-// You may obtain a copy of the license at
-//
-//    http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// This command is used to generate suitable configuration files in either
-// go syntax or in JSON.  It defaults to JSON output on stdout.  If no
-// term values are specified on the command line, then $TERM is used.
-//
-// Usage is like this:
-//
-// mkinfo [-init] [-go file.go] [-json file.json] [-quiet] [-nofatal] [<term>...]
-//
-// -gzip     specifies output should be compressed (json only)
-// -go       specifies Go output into the named file.  Use - for stdout.
-// -json     specifies JSON output in the named file.  Use - for stdout
-// -nofatal  indicates that errors loading definitions should not be fatal
-//
-
-package terminfo
-
-import (
-	"bytes"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"os"
-	"os/exec"
-	"regexp"
-	"strconv"
-	"strings"
-)
-
-type termcap struct {
-	name    string
-	desc    string
-	aliases []string
-	bools   map[string]bool
-	nums    map[string]int
-	strs    map[string]string
-}
-
-func (tc *termcap) getnum(s string) int {
-	return (tc.nums[s])
-}
-
-func (tc *termcap) getflag(s string) bool {
-	return (tc.bools[s])
-}
-
-func (tc *termcap) getstr(s string) string {
-	return (tc.strs[s])
-}
-
-const (
-	NONE = iota
-	CTRL
-	ESC
-)
-
-func unescape(s string) string {
-	// Various escapes are in \x format.  Control codes are
-	// encoded as ^M (carat followed by ASCII equivalent).
-	// Escapes are: \e, \E - escape
-	//  \0 NULL, \n \l \r \t \b \f \s for equivalent C escape.
-	buf := &bytes.Buffer{}
-	esc := NONE
-
-	for i := 0; i < len(s); i++ {
-		c := s[i]
-		switch esc {
-		case NONE:
-			switch c {
-			case '\\':
-				esc = ESC
-			case '^':
-				esc = CTRL
-			default:
-				buf.WriteByte(c)
-			}
-		case CTRL:
-			buf.WriteByte(c - 0x40)
-			esc = NONE
-		case ESC:
-			switch c {
-			case 'E', 'e':
-				buf.WriteByte(0x1b)
-			case '0', '1', '2', '3', '4', '5', '6', '7':
-				if i+2 < len(s) && s[i+1] >= '0' && s[i+1] <= '7' && s[i+2] >= '0' && s[i+2] <= '7' {
-					buf.WriteByte(((c - '0') * 64) + ((s[i+1] - '0') * 8) + (s[i+2] - '0'))
-					i = i + 2
-				} else if c == '0' {
-					buf.WriteByte(0)
-				}
-			case 'n':
-				buf.WriteByte('\n')
-			case 'r':
-				buf.WriteByte('\r')
-			case 't':
-				buf.WriteByte('\t')
-			case 'b':
-				buf.WriteByte('\b')
-			case 'f':
-				buf.WriteByte('\f')
-			case 's':
-				buf.WriteByte(' ')
-			case 'l':
-				panic("WTF: weird format: " + s)
-			default:
-				buf.WriteByte(c)
-			}
-			esc = NONE
-		}
-	}
-	return (buf.String())
-}
-
-func (tc *termcap) setupterm(name string) error {
-	cmd := exec.Command("infocmp", "-1", name)
-	output := &bytes.Buffer{}
-	cmd.Stdout = output
-
-	tc.strs = make(map[string]string)
-	tc.bools = make(map[string]bool)
-	tc.nums = make(map[string]int)
-
-	err := cmd.Run()
-	if err != nil {
-		return err
-	}
-
-	// Now parse the output.
-	// We get comment lines (starting with "#"), followed by
-	// a header line that looks like "<name>|<alias>|...|<desc>"
-	// then capabilities, one per line, starting with a tab and ending
-	// with a comma and newline.
-	lines := strings.Split(output.String(), "\n")
-	for len(lines) > 0 && strings.HasPrefix(lines[0], "#") {
-		lines = lines[1:]
-	}
-
-	// Ditch trailing empty last line
-	if lines[len(lines)-1] == "" {
-		lines = lines[:len(lines)-1]
-	}
-	header := lines[0]
-	if strings.HasSuffix(header, ",") {
-		header = header[:len(header)-1]
-	}
-	names := strings.Split(header, "|")
-	tc.name = names[0]
-	names = names[1:]
-	if len(names) > 0 {
-		tc.desc = names[len(names)-1]
-		names = names[:len(names)-1]
-	}
-	tc.aliases = names
-	for _, val := range lines[1:] {
-		if (!strings.HasPrefix(val, "\t")) ||
-			(!strings.HasSuffix(val, ",")) {
-			return (errors.New("malformed infocmp: " + val))
-		}
-
-		val = val[1:]
-		val = val[:len(val)-1]
-
-		if k := strings.SplitN(val, "=", 2); len(k) == 2 {
-			tc.strs[k[0]] = unescape(k[1])
-		} else if k := strings.SplitN(val, "#", 2); len(k) == 2 {
-			if u, err := strconv.ParseUint(k[1], 10, 0); err != nil {
-				return (err)
-			} else {
-				tc.nums[k[0]] = int(u)
-			}
-		} else {
-			tc.bools[val] = true
-		}
-	}
-	return nil
-}
-
-// This program is used to collect data from the system's terminfo library,
-// and write it into Go source code.  That is, we maintain our terminfo
-// capabilities encoded in the program.  It should never need to be run by
-// an end user, but developers can use this to add codes for additional
-// terminal types.
-//
-// If a terminal name ending with -truecolor is given, and we cannot find
-// one, we will try to fabricate one from either the -256color (if present)
-// or the unadorned base name, adding the XTerm specific 24-bit color
-// escapes.  We believe that all 24-bit capable terminals use the same
-// escape sequences, and terminfo has yet to evolve to support this.
-func getinfo(name string) (*Terminfo, string, error) {
-	var tc termcap
-	addTrueColor := false
-	if err := tc.setupterm(name); err != nil {
-		if strings.HasSuffix(name, "-truecolor") {
-			base := name[:len(name)-len("-truecolor")]
-			// Probably -256color is closest to what we want
-			if err = tc.setupterm(base + "-256color"); err != nil {
-				err = tc.setupterm(base)
-			}
-			if err == nil {
-				addTrueColor = true
-			}
-			tc.name = name
-		}
-		if err != nil {
-			return nil, "", err
-		}
-	}
-	t := &Terminfo{}
-	// If this is an alias record, then just emit the alias
-	t.Name = tc.name
-	if t.Name != name {
-		return t, "", nil
-	}
-	t.Aliases = tc.aliases
-	t.Colors = tc.getnum("colors")
-	t.Columns = tc.getnum("cols")
-	t.Lines = tc.getnum("lines")
-	t.Bell = tc.getstr("bel")
-	t.Clear = tc.getstr("clear")
-	t.EnterCA = tc.getstr("smcup")
-	t.ExitCA = tc.getstr("rmcup")
-	t.ShowCursor = tc.getstr("cnorm")
-	t.HideCursor = tc.getstr("civis")
-	t.AttrOff = tc.getstr("sgr0")
-	t.Underline = tc.getstr("smul")
-	t.Bold = tc.getstr("bold")
-	t.Blink = tc.getstr("blink")
-	t.Dim = tc.getstr("dim")
-	t.Reverse = tc.getstr("rev")
-	t.EnterKeypad = tc.getstr("smkx")
-	t.ExitKeypad = tc.getstr("rmkx")
-	t.SetFg = tc.getstr("setaf")
-	t.SetBg = tc.getstr("setab")
-	t.SetCursor = tc.getstr("cup")
-	t.CursorBack1 = tc.getstr("cub1")
-	t.CursorUp1 = tc.getstr("cuu1")
-	t.KeyF1 = tc.getstr("kf1")
-	t.KeyF2 = tc.getstr("kf2")
-	t.KeyF3 = tc.getstr("kf3")
-	t.KeyF4 = tc.getstr("kf4")
-	t.KeyF5 = tc.getstr("kf5")
-	t.KeyF6 = tc.getstr("kf6")
-	t.KeyF7 = tc.getstr("kf7")
-	t.KeyF8 = tc.getstr("kf8")
-	t.KeyF9 = tc.getstr("kf9")
-	t.KeyF10 = tc.getstr("kf10")
-	t.KeyF11 = tc.getstr("kf11")
-	t.KeyF12 = tc.getstr("kf12")
-	t.KeyF13 = tc.getstr("kf13")
-	t.KeyF14 = tc.getstr("kf14")
-	t.KeyF15 = tc.getstr("kf15")
-	t.KeyF16 = tc.getstr("kf16")
-	t.KeyF17 = tc.getstr("kf17")
-	t.KeyF18 = tc.getstr("kf18")
-	t.KeyF19 = tc.getstr("kf19")
-	t.KeyF20 = tc.getstr("kf20")
-	t.KeyF21 = tc.getstr("kf21")
-	t.KeyF22 = tc.getstr("kf22")
-	t.KeyF23 = tc.getstr("kf23")
-	t.KeyF24 = tc.getstr("kf24")
-	t.KeyF25 = tc.getstr("kf25")
-	t.KeyF26 = tc.getstr("kf26")
-	t.KeyF27 = tc.getstr("kf27")
-	t.KeyF28 = tc.getstr("kf28")
-	t.KeyF29 = tc.getstr("kf29")
-	t.KeyF30 = tc.getstr("kf30")
-	t.KeyF31 = tc.getstr("kf31")
-	t.KeyF32 = tc.getstr("kf32")
-	t.KeyF33 = tc.getstr("kf33")
-	t.KeyF34 = tc.getstr("kf34")
-	t.KeyF35 = tc.getstr("kf35")
-	t.KeyF36 = tc.getstr("kf36")
-	t.KeyF37 = tc.getstr("kf37")
-	t.KeyF38 = tc.getstr("kf38")
-	t.KeyF39 = tc.getstr("kf39")
-	t.KeyF40 = tc.getstr("kf40")
-	t.KeyF41 = tc.getstr("kf41")
-	t.KeyF42 = tc.getstr("kf42")
-	t.KeyF43 = tc.getstr("kf43")
-	t.KeyF44 = tc.getstr("kf44")
-	t.KeyF45 = tc.getstr("kf45")
-	t.KeyF46 = tc.getstr("kf46")
-	t.KeyF47 = tc.getstr("kf47")
-	t.KeyF48 = tc.getstr("kf48")
-	t.KeyF49 = tc.getstr("kf49")
-	t.KeyF50 = tc.getstr("kf50")
-	t.KeyF51 = tc.getstr("kf51")
-	t.KeyF52 = tc.getstr("kf52")
-	t.KeyF53 = tc.getstr("kf53")
-	t.KeyF54 = tc.getstr("kf54")
-	t.KeyF55 = tc.getstr("kf55")
-	t.KeyF56 = tc.getstr("kf56")
-	t.KeyF57 = tc.getstr("kf57")
-	t.KeyF58 = tc.getstr("kf58")
-	t.KeyF59 = tc.getstr("kf59")
-	t.KeyF60 = tc.getstr("kf60")
-	t.KeyF61 = tc.getstr("kf61")
-	t.KeyF62 = tc.getstr("kf62")
-	t.KeyF63 = tc.getstr("kf63")
-	t.KeyF64 = tc.getstr("kf64")
-	t.KeyInsert = tc.getstr("kich1")
-	t.KeyDelete = tc.getstr("kdch1")
-	t.KeyBackspace = tc.getstr("kbs")
-	t.KeyHome = tc.getstr("khome")
-	t.KeyEnd = tc.getstr("kend")
-	t.KeyUp = tc.getstr("kcuu1")
-	t.KeyDown = tc.getstr("kcud1")
-	t.KeyRight = tc.getstr("kcuf1")
-	t.KeyLeft = tc.getstr("kcub1")
-	t.KeyPgDn = tc.getstr("knp")
-	t.KeyPgUp = tc.getstr("kpp")
-	t.KeyBacktab = tc.getstr("kcbt")
-	t.KeyExit = tc.getstr("kext")
-	t.KeyCancel = tc.getstr("kcan")
-	t.KeyPrint = tc.getstr("kprt")
-	t.KeyHelp = tc.getstr("khlp")
-	t.KeyClear = tc.getstr("kclr")
-	t.AltChars = tc.getstr("acsc")
-	t.EnterAcs = tc.getstr("smacs")
-	t.ExitAcs = tc.getstr("rmacs")
-	t.EnableAcs = tc.getstr("enacs")
-	t.Mouse = tc.getstr("kmous")
-	t.KeyShfRight = tc.getstr("kRIT")
-	t.KeyShfLeft = tc.getstr("kLFT")
-	t.KeyShfHome = tc.getstr("kHOM")
-	t.KeyShfEnd = tc.getstr("kEND")
-
-	// Terminfo lacks descriptions for a bunch of modified keys,
-	// but modern XTerm and emulators often have them.  Let's add them,
-	// if the shifted right and left arrows are defined.
-	if t.KeyShfRight == "\x1b[1;2C" && t.KeyShfLeft == "\x1b[1;2D" {
-		t.KeyShfUp = "\x1b[1;2A"
-		t.KeyShfDown = "\x1b[1;2B"
-		t.KeyMetaUp = "\x1b[1;9A"
-		t.KeyMetaDown = "\x1b[1;9B"
-		t.KeyMetaRight = "\x1b[1;9C"
-		t.KeyMetaLeft = "\x1b[1;9D"
-		t.KeyAltUp = "\x1b[1;3A"
-		t.KeyAltDown = "\x1b[1;3B"
-		t.KeyAltRight = "\x1b[1;3C"
-		t.KeyAltLeft = "\x1b[1;3D"
-		t.KeyCtrlUp = "\x1b[1;5A"
-		t.KeyCtrlDown = "\x1b[1;5B"
-		t.KeyCtrlRight = "\x1b[1;5C"
-		t.KeyCtrlLeft = "\x1b[1;5D"
-		t.KeyAltShfUp = "\x1b[1;4A"
-		t.KeyAltShfDown = "\x1b[1;4B"
-		t.KeyAltShfRight = "\x1b[1;4C"
-		t.KeyAltShfLeft = "\x1b[1;4D"
-
-		t.KeyMetaShfUp = "\x1b[1;10A"
-		t.KeyMetaShfDown = "\x1b[1;10B"
-		t.KeyMetaShfRight = "\x1b[1;10C"
-		t.KeyMetaShfLeft = "\x1b[1;10D"
-
-		t.KeyCtrlShfUp = "\x1b[1;6A"
-		t.KeyCtrlShfDown = "\x1b[1;6B"
-		t.KeyCtrlShfRight = "\x1b[1;6C"
-		t.KeyCtrlShfLeft = "\x1b[1;6D"
-	}
-	// And also for Home and End
-	if t.KeyShfHome == "\x1b[1;2H" && t.KeyShfEnd == "\x1b[1;2F" {
-		t.KeyCtrlHome = "\x1b[1;5H"
-		t.KeyCtrlEnd = "\x1b[1;5F"
-		t.KeyAltHome = "\x1b[1;9H"
-		t.KeyAltEnd = "\x1b[1;9F"
-		t.KeyCtrlShfHome = "\x1b[1;6H"
-		t.KeyCtrlShfEnd = "\x1b[1;6F"
-		t.KeyAltShfHome = "\x1b[1;4H"
-		t.KeyAltShfEnd = "\x1b[1;4F"
-		t.KeyMetaShfHome = "\x1b[1;10H"
-		t.KeyMetaShfEnd = "\x1b[1;10F"
-	}
-
-	// And the same thing for rxvt and workalikes (Eterm, aterm, etc.)
-	// It seems that urxvt at least send ESC as ALT prefix for these,
-	// although some places seem to indicate a separate ALT key sesquence.
-	if t.KeyShfRight == "\x1b[c" && t.KeyShfLeft == "\x1b[d" {
-		t.KeyShfUp = "\x1b[a"
-		t.KeyShfDown = "\x1b[b"
-		t.KeyCtrlUp = "\x1b[Oa"
-		t.KeyCtrlDown = "\x1b[Ob"
-		t.KeyCtrlRight = "\x1b[Oc"
-		t.KeyCtrlLeft = "\x1b[Od"
-	}
-	if t.KeyShfHome == "\x1b[7$" && t.KeyShfEnd == "\x1b[8$" {
-		t.KeyCtrlHome = "\x1b[7^"
-		t.KeyCtrlEnd = "\x1b[8^"
-	}
-
-	// If the kmous entry is present, then we need to record the
-	// the codes to enter and exit mouse mode.  Sadly, this is not
-	// part of the terminfo databases anywhere that I've found, but
-	// is an extension.  The escape codes are documented in the XTerm
-	// manual, and all terminals that have kmous are expected to
-	// use these same codes, unless explicitly configured otherwise
-	// vi XM.  Note that in any event, we only known how to parse either
-	// x11 or SGR mouse events -- if your terminal doesn't support one
-	// of these two forms, you maybe out of luck.
-	t.MouseMode = tc.getstr("XM")
-	if t.Mouse != "" && t.MouseMode == "" {
-		// we anticipate that all xterm mouse tracking compatible
-		// terminals understand mouse tracking (1000), but we hope
-		// that those that don't understand any-event tracking (1003)
-		// will at least ignore it.  Likewise we hope that terminals
-		// that don't understand SGR reporting (1006) just ignore it.
-		t.MouseMode = "%?%p1%{1}%=%t%'h'%Pa%e%'l'%Pa%;" +
-			"\x1b[?1000%ga%c\x1b[?1002%ga%c\x1b[?1003%ga%c\x1b[?1006%ga%c"
-	}
-
-	// We only support colors in ANSI 8 or 256 color mode.
-	if t.Colors < 8 || t.SetFg == "" {
-		t.Colors = 0
-	}
-	if t.SetCursor == "" {
-		return nil, "", errors.New("terminal not cursor addressable")
-	}
-
-	// For padding, we lookup the pad char.  If that isn't present,
-	// and npc is *not* set, then we assume a null byte.
-	t.PadChar = tc.getstr("pad")
-	if t.PadChar == "" {
-		if !tc.getflag("npc") {
-			t.PadChar = "\u0000"
-		}
-	}
-
-	// For some terminals we fabricate a -truecolor entry, that may
-	// not exist in terminfo.
-	if addTrueColor {
-		t.SetFgRGB = "\x1b[38;2;%p1%d;%p2%d;%p3%dm"
-		t.SetBgRGB = "\x1b[48;2;%p1%d;%p2%d;%p3%dm"
-		t.SetFgBgRGB = "\x1b[38;2;%p1%d;%p2%d;%p3%d;" +
-			"48;2;%p4%d;%p5%d;%p6%dm"
-	}
-
-	// For terminals that use "standard" SGR sequences, lets combine the
-	// foreground and background together.
-	if strings.HasPrefix(t.SetFg, "\x1b[") &&
-		strings.HasPrefix(t.SetBg, "\x1b[") &&
-		strings.HasSuffix(t.SetFg, "m") &&
-		strings.HasSuffix(t.SetBg, "m") {
-		fg := t.SetFg[:len(t.SetFg)-1]
-		r := regexp.MustCompile("%p1")
-		bg := r.ReplaceAllString(t.SetBg[2:], "%p2")
-		t.SetFgBg = fg + ";" + bg
-	}
-
-	return t, tc.desc, nil
-}
-
-func WriteDB(filename string) error {
-	var e error
-	js := []byte{}
-	args := []string{os.Getenv("TERM")}
-
-	tdata := make(map[string]*Terminfo)
-	descs := make(map[string]string)
-
-	for _, term := range args {
-		if t, desc, e := getinfo(term); e != nil {
-			return e
-		} else {
-			tdata[term] = t
-			descs[term] = desc
-		}
-	}
-
-	if len(tdata) == 0 {
-		// No data.
-		return errors.New("No data")
-	}
-	o := os.Stdout
-	if o, e = os.Create(filename); e != nil {
-		return e
-	}
-	var w io.WriteCloser
-	w = o
-	for _, term := range args {
-		if t := tdata[term]; t != nil {
-			js, e = json.Marshal(t)
-			fmt.Fprintln(w, string(js))
-		}
-		// arguably if there is more than one term, this
-		// should be a javascript array, but that's not how
-		// we load it.  We marshal objects one at a time from
-		// the file.
-	}
-	if e != nil {
-		return e
-	}
-	w.Close()
-	if w != o {
-		o.Close()
-	}
-
-	return nil
-}

cmd/micro/terminfo/terminfo.go

@@ -1,837 +0,0 @@
-// Copyright 2017 The TCell Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use file except in compliance with the License.
-// You may obtain a copy of the license at
-//
-//    http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package terminfo
-
-import (
-	"bytes"
-	"compress/gzip"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"os"
-	"path"
-	"strconv"
-	"strings"
-	"sync"
-)
-
-var (
-	// ErrTermNotFound indicates that a suitable terminal entry could
-	// not be found.  This can result from either not having TERM set,
-	// or from the TERM failing to support certain minimal functionality,
-	// in particular absolute cursor addressability (the cup capability)
-	// is required.  For example, legacy "adm3" lacks this capability,
-	// whereas the slightly newer "adm3a" supports it.  This failure
-	// occurs most often with "dumb".
-	ErrTermNotFound = errors.New("terminal entry not found")
-)
-
-// Terminfo represents a terminfo entry.  Note that we use friendly names
-// in Go, but when we write out JSON, we use the same names as terminfo.
-// The name, aliases and smous, rmous fields do not come from terminfo directly.
-type Terminfo struct {
-	Name         string   `json:"name"`
-	Aliases      []string `json:"aliases,omitempty"`
-	Columns      int      `json:"cols,omitempty"`   // cols
-	Lines        int      `json:"lines,omitempty"`  // lines
-	Colors       int      `json:"colors,omitempty"` // colors
-	Bell         string   `json:"bell,omitempty"`   // bell
-	Clear        string   `json:"clear,omitempty"`  // clear
-	EnterCA      string   `json:"smcup,omitempty"`  // smcup
-	ExitCA       string   `json:"rmcup,omitempty"`  // rmcup
-	ShowCursor   string   `json:"cnorm,omitempty"`  // cnorm
-	HideCursor   string   `json:"civis,omitempty"`  // civis
-	AttrOff      string   `json:"sgr0,omitempty"`   // sgr0
-	Underline    string   `json:"smul,omitempty"`   // smul
-	Bold         string   `json:"bold,omitempty"`   // bold
-	Blink        string   `json:"blink,omitempty"`  // blink
-	Reverse      string   `json:"rev,omitempty"`    // rev
-	Dim          string   `json:"dim,omitempty"`    // dim
-	EnterKeypad  string   `json:"smkx,omitempty"`   // smkx
-	ExitKeypad   string   `json:"rmkx,omitempty"`   // rmkx
-	SetFg        string   `json:"setaf,omitempty"`  // setaf
-	SetBg        string   `json:"setbg,omitempty"`  // setab
-	SetCursor    string   `json:"cup,omitempty"`    // cup
-	CursorBack1  string   `json:"cub1,omitempty"`   // cub1
-	CursorUp1    string   `json:"cuu1,omitempty"`   // cuu1
-	PadChar      string   `json:"pad,omitempty"`    // pad
-	KeyBackspace string   `json:"kbs,omitempty"`    // kbs
-	KeyF1        string   `json:"kf1,omitempty"`    // kf1
-	KeyF2        string   `json:"kf2,omitempty"`    // kf2
-	KeyF3        string   `json:"kf3,omitempty"`    // kf3
-	KeyF4        string   `json:"kf4,omitempty"`    // kf4
-	KeyF5        string   `json:"kf5,omitempty"`    // kf5
-	KeyF6        string   `json:"kf6,omitempty"`    // kf6
-	KeyF7        string   `json:"kf7,omitempty"`    // kf7
-	KeyF8        string   `json:"kf8,omitempty"`    // kf8
-	KeyF9        string   `json:"kf9,omitempty"`    // kf9
-	KeyF10       string   `json:"kf10,omitempty"`   // kf10
-	KeyF11       string   `json:"kf11,omitempty"`   // kf11
-	KeyF12       string   `json:"kf12,omitempty"`   // kf12
-	KeyF13       string   `json:"kf13,omitempty"`   // kf13
-	KeyF14       string   `json:"kf14,omitempty"`   // kf14
-	KeyF15       string   `json:"kf15,omitempty"`   // kf15
-	KeyF16       string   `json:"kf16,omitempty"`   // kf16
-	KeyF17       string   `json:"kf17,omitempty"`   // kf17
-	KeyF18       string   `json:"kf18,omitempty"`   // kf18
-	KeyF19       string   `json:"kf19,omitempty"`   // kf19
-	KeyF20       string   `json:"kf20,omitempty"`   // kf20
-	KeyF21       string   `json:"kf21,omitempty"`   // kf21
-	KeyF22       string   `json:"kf22,omitempty"`   // kf22
-	KeyF23       string   `json:"kf23,omitempty"`   // kf23
-	KeyF24       string   `json:"kf24,omitempty"`   // kf24
-	KeyF25       string   `json:"kf25,omitempty"`   // kf25
-	KeyF26       string   `json:"kf26,omitempty"`   // kf26
-	KeyF27       string   `json:"kf27,omitempty"`   // kf27
-	KeyF28       string   `json:"kf28,omitempty"`   // kf28
-	KeyF29       string   `json:"kf29,omitempty"`   // kf29
-	KeyF30       string   `json:"kf30,omitempty"`   // kf30
-	KeyF31       string   `json:"kf31,omitempty"`   // kf31
-	KeyF32       string   `json:"kf32,omitempty"`   // kf32
-	KeyF33       string   `json:"kf33,omitempty"`   // kf33
-	KeyF34       string   `json:"kf34,omitempty"`   // kf34
-	KeyF35       string   `json:"kf35,omitempty"`   // kf35
-	KeyF36       string   `json:"kf36,omitempty"`   // kf36
-	KeyF37       string   `json:"kf37,omitempty"`   // kf37
-	KeyF38       string   `json:"kf38,omitempty"`   // kf38
-	KeyF39       string   `json:"kf39,omitempty"`   // kf39
-	KeyF40       string   `json:"kf40,omitempty"`   // kf40
-	KeyF41       string   `json:"kf41,omitempty"`   // kf41
-	KeyF42       string   `json:"kf42,omitempty"`   // kf42
-	KeyF43       string   `json:"kf43,omitempty"`   // kf43
-	KeyF44       string   `json:"kf44,omitempty"`   // kf44
-	KeyF45       string   `json:"kf45,omitempty"`   // kf45
-	KeyF46       string   `json:"kf46,omitempty"`   // kf46
-	KeyF47       string   `json:"kf47,omitempty"`   // kf47
-	KeyF48       string   `json:"kf48,omitempty"`   // kf48
-	KeyF49       string   `json:"kf49,omitempty"`   // kf49
-	KeyF50       string   `json:"kf50,omitempty"`   // kf50
-	KeyF51       string   `json:"kf51,omitempty"`   // kf51
-	KeyF52       string   `json:"kf52,omitempty"`   // kf52
-	KeyF53       string   `json:"kf53,omitempty"`   // kf53
-	KeyF54       string   `json:"kf54,omitempty"`   // kf54
-	KeyF55       string   `json:"kf55,omitempty"`   // kf55
-	KeyF56       string   `json:"kf56,omitempty"`   // kf56
-	KeyF57       string   `json:"kf57,omitempty"`   // kf57
-	KeyF58       string   `json:"kf58,omitempty"`   // kf58
-	KeyF59       string   `json:"kf59,omitempty"`   // kf59
-	KeyF60       string   `json:"kf60,omitempty"`   // kf60
-	KeyF61       string   `json:"kf61,omitempty"`   // kf61
-	KeyF62       string   `json:"kf62,omitempty"`   // kf62
-	KeyF63       string   `json:"kf63,omitempty"`   // kf63
-	KeyF64       string   `json:"kf64,omitempty"`   // kf64
-	KeyInsert    string   `json:"kich,omitempty"`   // kich1
-	KeyDelete    string   `json:"kdch,omitempty"`   // kdch1
-	KeyHome      string   `json:"khome,omitempty"`  // khome
-	KeyEnd       string   `json:"kend,omitempty"`   // kend
-	KeyHelp      string   `json:"khlp,omitempty"`   // khlp
-	KeyPgUp      string   `json:"kpp,omitempty"`    // kpp
-	KeyPgDn      string   `json:"knp,omitempty"`    // knp
-	KeyUp        string   `json:"kcuu1,omitempty"`  // kcuu1
-	KeyDown      string   `json:"kcud1,omitempty"`  // kcud1
-	KeyLeft      string   `json:"kcub1,omitempty"`  // kcub1
-	KeyRight     string   `json:"kcuf1,omitempty"`  // kcuf1
-	KeyBacktab   string   `json:"kcbt,omitempty"`   // kcbt
-	KeyExit      string   `json:"kext,omitempty"`   // kext
-	KeyClear     string   `json:"kclr,omitempty"`   // kclr
-	KeyPrint     string   `json:"kprt,omitempty"`   // kprt
-	KeyCancel    string   `json:"kcan,omitempty"`   // kcan
-	Mouse        string   `json:"kmous,omitempty"`  // kmous
-	MouseMode    string   `json:"XM,omitempty"`     // XM
-	AltChars     string   `json:"acsc,omitempty"`   // acsc
-	EnterAcs     string   `json:"smacs,omitempty"`  // smacs
-	ExitAcs      string   `json:"rmacs,omitempty"`  // rmacs
-	EnableAcs    string   `json:"enacs,omitempty"`  // enacs
-	KeyShfRight  string   `json:"kRIT,omitempty"`   // kRIT
-	KeyShfLeft   string   `json:"kLFT,omitempty"`   // kLFT
-	KeyShfHome   string   `json:"kHOM,omitempty"`   // kHOM
-	KeyShfEnd    string   `json:"kEND,omitempty"`   // kEND
-
-	// These are non-standard extensions to terminfo.  This includes
-	// true color support, and some additional keys.  Its kind of bizarre
-	// that shifted variants of left and right exist, but not up and down.
-	// Terminal support for these are going to vary amongst XTerm
-	// emulations, so don't depend too much on them in your application.
-
-	SetFgBg         string `json:"_setfgbg,omitempty"`    // setfgbg
-	SetFgBgRGB      string `json:"_setfgbgrgb,omitempty"` // setfgbgrgb
-	SetFgRGB        string `json:"_setfrgb,omitempty"`    // setfrgb
-	SetBgRGB        string `json:"_setbrgb,omitempty"`    // setbrgb
-	KeyShfUp        string `json:"_kscu1,omitempty"`      // shift-up
-	KeyShfDown      string `json:"_kscud1,omitempty"`     // shift-down
-	KeyCtrlUp       string `json:"_kccu1,omitempty"`      // ctrl-up
-	KeyCtrlDown     string `json:"_kccud1,omitempty"`     // ctrl-left
-	KeyCtrlRight    string `json:"_kccuf1,omitempty"`     // ctrl-right
-	KeyCtrlLeft     string `json:"_kccub1,omitempty"`     // ctrl-left
-	KeyMetaUp       string `json:"_kmcu1,omitempty"`      // meta-up
-	KeyMetaDown     string `json:"_kmcud1,omitempty"`     // meta-left
-	KeyMetaRight    string `json:"_kmcuf1,omitempty"`     // meta-right
-	KeyMetaLeft     string `json:"_kmcub1,omitempty"`     // meta-left
-	KeyAltUp        string `json:"_kacu1,omitempty"`      // alt-up
-	KeyAltDown      string `json:"_kacud1,omitempty"`     // alt-left
-	KeyAltRight     string `json:"_kacuf1,omitempty"`     // alt-right
-	KeyAltLeft      string `json:"_kacub1,omitempty"`     // alt-left
-	KeyCtrlHome     string `json:"_kchome,omitempty"`
-	KeyCtrlEnd      string `json:"_kcend,omitempty"`
-	KeyMetaHome     string `json:"_kmhome,omitempty"`
-	KeyMetaEnd      string `json:"_kmend,omitempty"`
-	KeyAltHome      string `json:"_kahome,omitempty"`
-	KeyAltEnd       string `json:"_kaend,omitempty"`
-	KeyAltShfUp     string `json:"_kascu1,omitempty"`
-	KeyAltShfDown   string `json:"_kascud1,omitempty"`
-	KeyAltShfLeft   string `json:"_kascub1,omitempty"`
-	KeyAltShfRight  string `json:"_kascuf1,omitempty"`
-	KeyMetaShfUp    string `json:"_kmscu1,omitempty"`
-	KeyMetaShfDown  string `json:"_kmscud1,omitempty"`
-	KeyMetaShfLeft  string `json:"_kmscub1,omitempty"`
-	KeyMetaShfRight string `json:"_kmscuf1,omitempty"`
-	KeyCtrlShfUp    string `json:"_kcscu1,omitempty"`
-	KeyCtrlShfDown  string `json:"_kcscud1,omitempty"`
-	KeyCtrlShfLeft  string `json:"_kcscub1,omitempty"`
-	KeyCtrlShfRight string `json:"_kcscuf1,omitempty"`
-	KeyCtrlShfHome  string `json:"_kcHOME,omitempty"`
-	KeyCtrlShfEnd   string `json:"_kcEND,omitempty"`
-	KeyAltShfHome   string `json:"_kaHOME,omitempty"`
-	KeyAltShfEnd    string `json:"_kaEND,omitempty"`
-	KeyMetaShfHome  string `json:"_kmHOME,omitempty"`
-	KeyMetaShfEnd   string `json:"_kmEND,omitempty"`
-}
-
-type stackElem struct {
-	s     string
-	i     int
-	isStr bool
-	isInt bool
-}
-
-type stack []stackElem
-
-func (st stack) Push(v string) stack {
-	e := stackElem{
-		s:     v,
-		isStr: true,
-	}
-	return append(st, e)
-}
-
-func (st stack) Pop() (string, stack) {
-	v := ""
-	if len(st) > 0 {
-		e := st[len(st)-1]
-		st = st[:len(st)-1]
-		if e.isStr {
-			v = e.s
-		} else {
-			v = strconv.Itoa(e.i)
-		}
-	}
-	return v, st
-}
-
-func (st stack) PopInt() (int, stack) {
-	if len(st) > 0 {
-		e := st[len(st)-1]
-		st = st[:len(st)-1]
-		if e.isInt {
-			return e.i, st
-		} else if e.isStr {
-			i, _ := strconv.Atoi(e.s)
-			return i, st
-		}
-	}
-	return 0, st
-}
-
-func (st stack) PopBool() (bool, stack) {
-	if len(st) > 0 {
-		e := st[len(st)-1]
-		st = st[:len(st)-1]
-		if e.isStr {
-			if e.s == "1" {
-				return true, st
-			}
-			return false, st
-		} else if e.i == 1 {
-			return true, st
-		} else {
-			return false, st
-		}
-	}
-	return false, st
-}
-
-func (st stack) PushInt(i int) stack {
-	e := stackElem{
-		i:     i,
-		isInt: true,
-	}
-	return append(st, e)
-}
-
-func (st stack) PushBool(i bool) stack {
-	if i {
-		return st.PushInt(1)
-	}
-	return st.PushInt(0)
-}
-
-func nextch(s string, index int) (byte, int) {
-	if index < len(s) {
-		return s[index], index + 1
-	}
-	return 0, index
-}
-
-// static vars
-var svars [26]string
-
-// paramsBuffer handles some persistent state for TParam.  Technically we
-// could probably dispense with this, but caching buffer arrays gives us
-// a nice little performance boost.  Furthermore, we know that TParam is
-// rarely (never?) called re-entrantly, so we can just reuse the same
-// buffers, making it thread-safe by stashing a lock.
-type paramsBuffer struct {
-	out bytes.Buffer
-	buf bytes.Buffer
-	lk  sync.Mutex
-}
-
-// Start initializes the params buffer with the initial string data.
-// It also locks the paramsBuffer.  The caller must call End() when
-// finished.
-func (pb *paramsBuffer) Start(s string) {
-	pb.lk.Lock()
-	pb.out.Reset()
-	pb.buf.Reset()
-	pb.buf.WriteString(s)
-}
-
-// End returns the final output from TParam, but it also releases the lock.
-func (pb *paramsBuffer) End() string {
-	s := pb.out.String()
-	pb.lk.Unlock()
-	return s
-}
-
-// NextCh returns the next input character to the expander.
-func (pb *paramsBuffer) NextCh() (byte, error) {
-	return pb.buf.ReadByte()
-}
-
-// PutCh "emits" (rather schedules for output) a single byte character.
-func (pb *paramsBuffer) PutCh(ch byte) {
-	pb.out.WriteByte(ch)
-}
-
-// PutString schedules a string for output.
-func (pb *paramsBuffer) PutString(s string) {
-	pb.out.WriteString(s)
-}
-
-var pb = &paramsBuffer{}
-
-// TParm takes a terminfo parameterized string, such as setaf or cup, and
-// evaluates the string, and returns the result with the parameter
-// applied.
-func (t *Terminfo) TParm(s string, p ...int) string {
-	var stk stack
-	var a, b string
-	var ai, bi int
-	var ab bool
-	var dvars [26]string
-	var params [9]int
-
-	pb.Start(s)
-
-	// make sure we always have 9 parameters -- makes it easier
-	// later to skip checks
-	for i := 0; i < len(params) && i < len(p); i++ {
-		params[i] = p[i]
-	}
-
-	nest := 0
-
-	for {
-
-		ch, err := pb.NextCh()
-		if err != nil {
-			break
-		}
-
-		if ch != '%' {
-			pb.PutCh(ch)
-			continue
-		}
-
-		ch, err = pb.NextCh()
-		if err != nil {
-			// XXX Error
-			break
-		}
-
-		switch ch {
-		case '%': // quoted %
-			pb.PutCh(ch)
-
-		case 'i': // increment both parameters (ANSI cup support)
-			params[0]++
-			params[1]++
-
-		case 'c', 's':
-			// NB: these, and 'd' below are special cased for
-			// efficiency.  They could be handled by the richer
-			// format support below, less efficiently.
-			a, stk = stk.Pop()
-			pb.PutString(a)
-
-		case 'd':
-			ai, stk = stk.PopInt()
-			pb.PutString(strconv.Itoa(ai))
-
-		case '0', '1', '2', '3', '4', 'x', 'X', 'o', ':':
-			// This is pretty suboptimal, but this is rarely used.
-			// None of the mainstream terminals use any of this,
-			// and it would surprise me if this code is ever
-			// executed outside of test cases.
-			f := "%"
-			if ch == ':' {
-				ch, _ = pb.NextCh()
-			}
-			f += string(ch)
-			for ch == '+' || ch == '-' || ch == '#' || ch == ' ' {
-				ch, _ = pb.NextCh()
-				f += string(ch)
-			}
-			for (ch >= '0' && ch <= '9') || ch == '.' {
-				ch, _ = pb.NextCh()
-				f += string(ch)
-			}
-			switch ch {
-			case 'd', 'x', 'X', 'o':
-				ai, stk = stk.PopInt()
-				pb.PutString(fmt.Sprintf(f, ai))
-			case 'c', 's':
-				a, stk = stk.Pop()
-				pb.PutString(fmt.Sprintf(f, a))
-			}
-
-		case 'p': // push parameter
-			ch, _ = pb.NextCh()
-			ai = int(ch - '1')
-			if ai >= 0 && ai < len(params) {
-				stk = stk.PushInt(params[ai])
-			} else {
-				stk = stk.PushInt(0)
-			}
-
-		case 'P': // pop & store variable
-			ch, _ = pb.NextCh()
-			if ch >= 'A' && ch <= 'Z' {
-				svars[int(ch-'A')], stk = stk.Pop()
-			} else if ch >= 'a' && ch <= 'z' {
-				dvars[int(ch-'a')], stk = stk.Pop()
-			}
-
-		case 'g': // recall & push variable
-			ch, _ = pb.NextCh()
-			if ch >= 'A' && ch <= 'Z' {
-				stk = stk.Push(svars[int(ch-'A')])
-			} else if ch >= 'a' && ch <= 'z' {
-				stk = stk.Push(dvars[int(ch-'a')])
-			}
-
-		case '\'': // push(char)
-			ch, _ = pb.NextCh()
-			pb.NextCh() // must be ' but we don't check
-			stk = stk.Push(string(ch))
-
-		case '{': // push(int)
-			ai = 0
-			ch, _ = pb.NextCh()
-			for ch >= '0' && ch <= '9' {
-				ai *= 10
-				ai += int(ch - '0')
-				ch, _ = pb.NextCh()
-			}
-			// ch must be '}' but no verification
-			stk = stk.PushInt(ai)
-
-		case 'l': // push(strlen(pop))
-			a, stk = stk.Pop()
-			stk = stk.PushInt(len(a))
-
-		case '+':
-			bi, stk = stk.PopInt()
-			ai, stk = stk.PopInt()
-			stk = stk.PushInt(ai + bi)
-
-		case '-':
-			bi, stk = stk.PopInt()
-			ai, stk = stk.PopInt()
-			stk = stk.PushInt(ai - bi)
-
-		case '*':
-			bi, stk = stk.PopInt()
-			ai, stk = stk.PopInt()
-			stk = stk.PushInt(ai * bi)
-
-		case '/':
-			bi, stk = stk.PopInt()
-			ai, stk = stk.PopInt()
-			if bi != 0 {
-				stk = stk.PushInt(ai / bi)
-			} else {
-				stk = stk.PushInt(0)
-			}
-
-		case 'm': // push(pop mod pop)
-			bi, stk = stk.PopInt()
-			ai, stk = stk.PopInt()
-			if bi != 0 {
-				stk = stk.PushInt(ai % bi)
-			} else {
-				stk = stk.PushInt(0)
-			}
-
-		case '&': // AND
-			bi, stk = stk.PopInt()
-			ai, stk = stk.PopInt()
-			stk = stk.PushInt(ai & bi)
-
-		case '|': // OR
-			bi, stk = stk.PopInt()
-			ai, stk = stk.PopInt()
-			stk = stk.PushInt(ai | bi)
-
-		case '^': // XOR
-			bi, stk = stk.PopInt()
-			ai, stk = stk.PopInt()
-			stk = stk.PushInt(ai ^ bi)
-
-		case '~': // bit complement
-			ai, stk = stk.PopInt()
-			stk = stk.PushInt(ai ^ -1)
-
-		case '!': // logical NOT
-			ai, stk = stk.PopInt()
-			stk = stk.PushBool(ai != 0)
-
-		case '=': // numeric compare or string compare
-			b, stk = stk.Pop()
-			a, stk = stk.Pop()
-			stk = stk.PushBool(a == b)
-
-		case '>': // greater than, numeric
-			bi, stk = stk.PopInt()
-			ai, stk = stk.PopInt()
-			stk = stk.PushBool(ai > bi)
-
-		case '<': // less than, numeric
-			bi, stk = stk.PopInt()
-			ai, stk = stk.PopInt()
-			stk = stk.PushBool(ai < bi)
-
-		case '?': // start conditional
-
-		case 't':
-			ab, stk = stk.PopBool()
-			if ab {
-				// just keep going
-				break
-			}
-			nest = 0
-		ifloop:
-			// this loop consumes everything until we hit our else,
-			// or the end of the conditional
-			for {
-				ch, err = pb.NextCh()
-				if err != nil {
-					break
-				}
-				if ch != '%' {
-					continue
-				}
-				ch, _ = pb.NextCh()
-				switch ch {
-				case ';':
-					if nest == 0 {
-						break ifloop
-					}
-					nest--
-				case '?':
-					nest++
-				case 'e':
-					if nest == 0 {
-						break ifloop
-					}
-				}
-			}
-
-		case 'e':
-			// if we got here, it means we didn't use the else
-			// in the 't' case above, and we should skip until
-			// the end of the conditional
-			nest = 0
-		elloop:
-			for {
-				ch, err = pb.NextCh()
-				if err != nil {
-					break
-				}
-				if ch != '%' {
-					continue
-				}
-				ch, _ = pb.NextCh()
-				switch ch {
-				case ';':
-					if nest == 0 {
-						break elloop
-					}
-					nest--
-				case '?':
-					nest++
-				}
-			}
-
-		case ';': // endif
-
-		}
-	}
-
-	return pb.End()
-}
-
-// TPuts emits the string to the writer, but expands inline padding
-// indications (of the form $<[delay]> where [delay] is msec) to
-// a suitable number of padding characters (usually null bytes) based
-// upon the supplied baud.  At high baud rates, more padding characters
-// will be inserted.  All Terminfo based strings should be emitted using
-// this function.
-func (t *Terminfo) TPuts(w io.Writer, s string, baud int) {
-	for {
-		beg := strings.Index(s, "$<")
-		if beg < 0 {
-			// Most strings don't need padding, which is good news!
-			io.WriteString(w, s)
-			return
-		}
-		io.WriteString(w, s[:beg])
-		s = s[beg+2:]
-		end := strings.Index(s, ">")
-		if end < 0 {
-			// unterminated.. just emit bytes unadulterated
-			io.WriteString(w, "$<"+s)
-			return
-		}
-		val := s[:end]
-		s = s[end+1:]
-		padus := 0
-		unit := 1000
-		dot := false
-	loop:
-		for i := range val {
-			switch val[i] {
-			case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
-				padus *= 10
-				padus += int(val[i] - '0')
-				if dot {
-					unit *= 10
-				}
-			case '.':
-				if !dot {
-					dot = true
-				} else {
-					break loop
-				}
-			default:
-				break loop
-			}
-		}
-		cnt := int(((baud / 8) * padus) / unit)
-		for cnt > 0 {
-			io.WriteString(w, t.PadChar)
-			cnt--
-		}
-	}
-}
-
-// TGoto returns a string suitable for addressing the cursor at the given
-// row and column.  The origin 0, 0 is in the upper left corner of the screen.
-func (t *Terminfo) TGoto(col, row int) string {
-	return t.TParm(t.SetCursor, row, col)
-}
-
-// TColor returns a string corresponding to the given foreground and background
-// colors.  Either fg or bg can be set to -1 to elide.
-func (t *Terminfo) TColor(fi, bi int) string {
-	rv := ""
-	// As a special case, we map bright colors to lower versions if the
-	// color table only holds 8.  For the remaining 240 colors, the user
-	// is out of luck.  Someday we could create a mapping table, but its
-	// not worth it.
-	if t.Colors == 8 {
-		if fi > 7 && fi < 16 {
-			fi -= 8
-		}
-		if bi > 7 && bi < 16 {
-			bi -= 8
-		}
-	}
-	if t.Colors > fi && fi >= 0 {
-		rv += t.TParm(t.SetFg, fi)
-	}
-	if t.Colors > bi && bi >= 0 {
-		rv += t.TParm(t.SetBg, bi)
-	}
-	return rv
-}
-
-var (
-	dblock    sync.Mutex
-	terminfos = make(map[string]*Terminfo)
-	aliases   = make(map[string]string)
-)
-
-// AddTerminfo can be called to register a new Terminfo entry.
-func AddTerminfo(t *Terminfo) {
-	dblock.Lock()
-	terminfos[t.Name] = t
-	for _, x := range t.Aliases {
-		terminfos[x] = t
-	}
-	dblock.Unlock()
-}
-
-func loadFromFile(fname string, term string) (*Terminfo, error) {
-	var e error
-	var f io.Reader
-	if f, e = os.Open(fname); e != nil {
-		return nil, e
-	}
-	if strings.HasSuffix(fname, ".gz") {
-		if f, e = gzip.NewReader(f); e != nil {
-			return nil, e
-		}
-	}
-	d := json.NewDecoder(f)
-	for {
-		t := &Terminfo{}
-		if e := d.Decode(t); e != nil {
-			if e == io.EOF {
-				return nil, ErrTermNotFound
-			}
-			return nil, e
-		}
-		if t.SetCursor == "" {
-			// This must be an alias record, return it.
-			return t, nil
-		}
-		if t.Name == term {
-			return t, nil
-		}
-		for _, a := range t.Aliases {
-			if a == term {
-				return t, nil
-			}
-		}
-	}
-}
-
-// LookupTerminfo attempts to find a definition for the named $TERM.
-// It first looks in the builtin database, which should cover just about
-// everyone.  If it can't find one there, then it will attempt to read
-// one from the JSON file located in either $TCELLDB, $HOME/.tcelldb
-// or in this package's source directory as database.json).
-func LookupTerminfo(name string) (*Terminfo, error) {
-	if name == "" {
-		// else on windows: index out of bounds
-		// on the name[0] reference below
-		return nil, ErrTermNotFound
-	}
-
-	dblock.Lock()
-	t := terminfos[name]
-	dblock.Unlock()
-
-	if t == nil {
-
-		var files []string
-		letter := fmt.Sprintf("%02x", name[0])
-		gzfile := path.Join(letter, name+".gz")
-		jsfile := path.Join(letter, name)
-
-		// Build up the search path.  Old versions of tcell used a
-		// single database file, whereas the new ones locate them
-		// in JSON (optionally compressed) files.
-		//
-		// The search path looks like:
-		//
-		// $TCELLDB/x/xterm.gz
-		// $TCELLDB/x/xterm
-		// $TCELLDB
-		// $HOME/.tcelldb/x/xterm.gz
-		// $HOME/.tcelldb/x/xterm
-		// $HOME/.tcelldb
-		// $GOPATH/terminfo/database/x/xterm.gz
-		// $GOPATH/terminfo/database/x/xterm
-		//
-		if pth := os.Getenv("TCELLDB"); pth != "" {
-			files = append(files, path.Join(pth, gzfile))
-			files = append(files, path.Join(pth, jsfile))
-			files = append(files, pth)
-		}
-		if pth := os.Getenv("HOME"); pth != "" {
-			pth = path.Join(pth, ".tcelldb")
-			files = append(files, path.Join(pth, gzfile))
-			files = append(files, path.Join(pth, jsfile))
-			files = append(files, pth)
-		}
-
-		for _, pth := range strings.Split(os.Getenv("GOPATH"), string(os.PathListSeparator)) {
-			pth = path.Join(pth, "src", "github.com", "gdamore", "tcell", "terminfo", "database")
-			files = append(files, path.Join(pth, gzfile))
-			files = append(files, path.Join(pth, jsfile))
-		}
-
-		for _, fname := range files {
-			t, _ = loadFromFile(fname, name)
-			if t != nil {
-				break
-			}
-		}
-		if t != nil {
-			if t.Name != name {
-				// Check for a database loop (no infinite
-				// recursion).
-				dblock.Lock()
-				if aliases[name] != "" {
-					dblock.Unlock()
-					return nil, ErrTermNotFound
-				}
-				aliases[name] = t.Name
-				dblock.Unlock()
-				return LookupTerminfo(t.Name)
-			}
-			dblock.Lock()
-			terminfos[name] = t
-			dblock.Unlock()
-		}
-	}
-	if t == nil {
-		return nil, ErrTermNotFound
-	}
-	return t, nil
-}

cmd/micro/terminfo/terminfo_test.go

@@ -1,194 +0,0 @@
-// Copyright 2016 The TCell Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use file except in compliance with the License.
-// You may obtain a copy of the license at
-//
-//    http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package terminfo
-
-import (
-	"bytes"
-	"os"
-	"testing"
-
-	. "github.com/smartystreets/goconvey/convey"
-)
-
-// This terminfo entry is a stripped down version from
-// xterm-256color, but I've added some of my own entries.
-var testTerminfo = &Terminfo{
-	Name:      "simulation_test",
-	Columns:   80,
-	Lines:     24,
-	Colors:    256,
-	Bell:      "\a",
-	Blink:     "\x1b2ms$<2>",
-	Reverse:   "\x1b[7m",
-	SetFg:     "\x1b[%?%p1%{8}%<%t3%p1%d%e%p1%{16}%<%t9%p1%{8}%-%d%e38;5;%p1%d%;m",
-	SetBg:     "\x1b[%?%p1%{8}%<%t4%p1%d%e%p1%{16}%<%t10%p1%{8}%-%d%e48;5;%p1%d%;m",
-	AltChars:  "``aaffggiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~",
-	Mouse:     "\x1b[M",
-	MouseMode: "%?%p1%{1}%=%t%'h'%Pa%e%'l'%Pa%;\x1b[?1000%ga%c\x1b[?1003%ga%c\x1b[?1006%ga%c",
-	SetCursor: "\x1b[%i%p1%d;%p2%dH",
-	PadChar:   "\x00",
-}
-
-func TestTerminfo(t *testing.T) {
-
-	ti := testTerminfo
-
-	Convey("Terminfo parameter processing", t, func() {
-		// This tests %i, and basic parameter strings too
-		Convey("TGoto works", func() {
-			s := ti.TGoto(7, 9)
-			So(s, ShouldEqual, "\x1b[10;8H")
-		})
-
-		// This tests some conditionals
-		Convey("TParm extended formats work", func() {
-			s := ti.TParm("A[%p1%2.2X]B", 47)
-			So(s, ShouldEqual, "A[2F]B")
-		})
-
-		// This tests some conditionals
-		Convey("TParm colors work", func() {
-			s := ti.TParm(ti.SetFg, 7)
-			So(s, ShouldEqual, "\x1b[37m")
-
-			s = ti.TParm(ti.SetFg, 15)
-			So(s, ShouldEqual, "\x1b[97m")
-
-			s = ti.TParm(ti.SetFg, 200)
-			So(s, ShouldEqual, "\x1b[38;5;200m")
-		})
-
-		// This tests variables
-		Convey("TParm mouse mode works", func() {
-			s := ti.TParm(ti.MouseMode, 1)
-			So(s, ShouldEqual, "\x1b[?1000h\x1b[?1003h\x1b[?1006h")
-			s = ti.TParm(ti.MouseMode, 0)
-			So(s, ShouldEqual, "\x1b[?1000l\x1b[?1003l\x1b[?1006l")
-		})
-
-	})
-
-	Convey("Terminfo delay handling", t, func() {
-
-		Convey("19200 baud", func() {
-			buf := bytes.NewBuffer(nil)
-			ti.TPuts(buf, ti.Blink, 19200)
-			s := string(buf.Bytes())
-			So(s, ShouldEqual, "\x1b2ms\x00\x00\x00\x00")
-		})
-
-		Convey("50 baud", func() {
-			buf := bytes.NewBuffer(nil)
-			ti.TPuts(buf, ti.Blink, 50)
-			s := string(buf.Bytes())
-			So(s, ShouldEqual, "\x1b2ms")
-		})
-	})
-}
-
-func TestTerminfoDatabase(t *testing.T) {
-
-	Convey("Database Lookups work", t, func() {
-		Convey("Basic lookup works", func() {
-			os.Setenv("TCELLDB", "testdata/test1")
-			ti, err := LookupTerminfo("test1")
-			So(err, ShouldBeNil)
-			So(ti, ShouldNotBeNil)
-			So(ti.Columns, ShouldEqual, 80)
-
-			ti, err = LookupTerminfo("alias1")
-			So(err, ShouldBeNil)
-			So(ti, ShouldNotBeNil)
-			So(ti.Columns, ShouldEqual, 80)
-
-			os.Setenv("TCELLDB", "testdata")
-			ti, err = LookupTerminfo("test2")
-			So(err, ShouldBeNil)
-			So(ti, ShouldNotBeNil)
-			So(ti.Columns, ShouldEqual, 80)
-			So(len(ti.Aliases), ShouldEqual, 1)
-			So(ti.Aliases[0], ShouldEqual, "alias2")
-		})
-
-		Convey("Incorrect primary name works", func() {
-			os.Setenv("TCELLDB", "testdata")
-			ti, err := LookupTerminfo("test3")
-			So(err, ShouldNotBeNil)
-			So(ti, ShouldBeNil)
-		})
-
-		Convey("Loops fail", func() {
-			os.Setenv("TCELLDB", "testdata")
-			ti, err := LookupTerminfo("loop1")
-			So(ti, ShouldBeNil)
-			So(err, ShouldNotBeNil)
-		})
-
-		Convey("Gzip database works", func() {
-			os.Setenv("TCELLDB", "testdata")
-			ti, err := LookupTerminfo("test-gzip")
-			So(err, ShouldBeNil)
-			So(ti, ShouldNotBeNil)
-			So(ti.Columns, ShouldEqual, 80)
-		})
-
-		Convey("Gzip alias lookup works", func() {
-			os.Setenv("TCELLDB", "testdata")
-			ti, err := LookupTerminfo("alias-gzip")
-			So(err, ShouldBeNil)
-			So(ti, ShouldNotBeNil)
-			So(ti.Columns, ShouldEqual, 80)
-		})
-
-		Convey("Broken alias works", func() {
-			os.Setenv("TCELLDB", "testdata")
-			ti, err := LookupTerminfo("alias-none")
-			So(err, ShouldNotBeNil)
-			So(ti, ShouldBeNil)
-		})
-
-		Convey("Combined database works", func() {
-			os.Setenv("TCELLDB", "testdata/combined")
-			ti, err := LookupTerminfo("combined2")
-			So(err, ShouldBeNil)
-			So(ti, ShouldNotBeNil)
-			So(ti.Lines, ShouldEqual, 102)
-
-			ti, err = LookupTerminfo("alias-comb1")
-			So(err, ShouldBeNil)
-			So(ti, ShouldNotBeNil)
-			So(ti.Lines, ShouldEqual, 101)
-
-			ti, err = LookupTerminfo("combined3")
-			So(err, ShouldBeNil)
-			So(ti, ShouldNotBeNil)
-			So(ti.Lines, ShouldEqual, 103)
-
-			ti, err = LookupTerminfo("combined1")
-			So(err, ShouldBeNil)
-			So(ti, ShouldNotBeNil)
-			So(ti.Lines, ShouldEqual, 101)
-		})
-	})
-}
-
-func BenchmarkSetFgBg(b *testing.B) {
-	ti := testTerminfo
-
-	for i := 0; i < b.N; i++ {
-		ti.TParm(ti.SetFg, 100, 200)
-		ti.TParm(ti.SetBg, 100, 200)
-	}
-}

cmd/micro/util.go

@@ -1,8 +1,8 @@
 package main
 
 import (
+	"bytes"
 	"os"
-	"os/user"
 	"path/filepath"
 	"reflect"
 	"runtime"
@@ -23,55 +23,7 @@ func Count(s string) int {
 	return utf8.RuneCountInString(s)
 }
 
-// Convert byte array to rune array
-func toRunes(b []byte) []rune {
-	runes := make([]rune, 0, utf8.RuneCount(b))
-
-	for len(b) > 0 {
-		r, size := utf8.DecodeRune(b)
-		runes = append(runes, r)
-
-		b = b[size:]
-	}
-
-	return runes
-}
-
-func sliceStart(slc []byte, index int) []byte {
-	len := len(slc)
-	i := 0
-	totalSize := 0
-	for totalSize < len {
-		if i >= index {
-			return slc[totalSize:]
-		}
-
-		_, size := utf8.DecodeRune(slc[totalSize:])
-		totalSize += size
-		i++
-	}
-
-	return slc[totalSize:]
-}
-
-func sliceEnd(slc []byte, index int) []byte {
-	len := len(slc)
-	i := 0
-	totalSize := 0
-	for totalSize < len {
-		if i >= index {
-			return slc[:totalSize]
-		}
-
-		_, size := utf8.DecodeRune(slc[totalSize:])
-		totalSize += size
-		i++
-	}
-
-	return slc[:totalSize]
-}
-
-// NumOccurrences counts the number of occurrences of a byte in a string
+// 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++ {
@@ -84,7 +36,11 @@ func NumOccurrences(s string, c byte) int {
 
 // Spaces returns a string with n spaces
 func Spaces(n int) string {
-	return strings.Repeat(" ", n)
+	var str string
+	for i := 0; i < n; i++ {
+		str += " "
+	}
+	return str
 }
 
 // Min takes the min of two ints
@@ -103,20 +59,13 @@ func Max(a, b int) int {
 	return b
 }
 
-// FSize gets the size of a file
-func FSize(f *os.File) int64 {
-	fi, _ := f.Stat()
-	// get the size
-	return fi.Size()
-}
-
 // IsWordChar returns whether or not the string is a 'word character'
 // If it is a unicode character, then it does not match
 // Word characters are defined as [A-Za-z0-9_]
 func IsWordChar(str string) bool {
 	if len(str) > 1 {
 		// Unicode
-		return true
+		return false
 	}
 	c := str[0]
 	return (c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c == '_')
@@ -127,16 +76,6 @@ func IsWhitespace(c rune) bool {
 	return c == ' ' || c == '\t' || c == '\n'
 }
 
-// IsStrWhitespace returns true if the given string is all whitespace
-func IsStrWhitespace(str string) bool {
-	for _, c := range str {
-		if !IsWhitespace(c) {
-			return false
-		}
-	}
-	return true
-}
-
 // Contains returns whether or not a string array contains a given string
 func Contains(list []string, a string) bool {
 	for _, b := range list {
@@ -152,18 +91,6 @@ func Insert(str string, pos int, value string) string {
 	return string([]rune(str)[:pos]) + value + string([]rune(str)[pos:])
 }
 
-// MakeRelative will attempt to make a relative path between path and base
-func MakeRelative(path, base string) (string, error) {
-	if len(path) > 0 {
-		rel, err := filepath.Rel(base, path)
-		if err != nil {
-			return path, err
-		}
-		return rel, nil
-	}
-	return path, nil
-}
-
 // GetLeadingWhitespace returns the leading whitespace of the given string
 func GetLeadingWhitespace(str string) string {
 	ws := ""
@@ -178,7 +105,7 @@ func GetLeadingWhitespace(str string) string {
 }
 
 // IsSpaces checks if a given string is only spaces
-func IsSpaces(str []byte) bool {
+func IsSpaces(str string) bool {
 	for _, c := range str {
 		if c != ' ' {
 			return false
@@ -230,19 +157,7 @@ func GetModTime(path string) (time.Time, bool) {
 // StringWidth returns the width of a string where tabs count as `tabsize` width
 func StringWidth(str string, tabsize int) int {
 	sw := runewidth.StringWidth(str)
-	lineIdx := 0
-	for _, ch := range str {
-		switch ch {
-		case '\t':
-			ts := tabsize - (lineIdx % tabsize)
-			sw += ts
-			lineIdx += ts
-		case '\n':
-			lineIdx = 0
-		default:
-			lineIdx++
-		}
-	}
+	sw += NumOccurrences(str, '\t') * (tabsize - 1)
 	return sw
 }
 
@@ -250,22 +165,16 @@ func StringWidth(str string, tabsize int) int {
 // that have a width larger than 1 (this also counts tabs as `tabsize` width)
 func WidthOfLargeRunes(str string, tabsize int) int {
 	count := 0
-	lineIdx := 0
 	for _, ch := range str {
 		var w int
 		if ch == '\t' {
-			w = tabsize - (lineIdx % tabsize)
+			w = tabsize
 		} else {
 			w = runewidth.RuneWidth(ch)
 		}
 		if w > 1 {
 			count += (w - 1)
 		}
-		if ch == '\n' {
-			lineIdx = 0
-		} else {
-			lineIdx += w
-		}
 	}
 	return count
 }
@@ -294,7 +203,6 @@ func lcs(a, b string) string {
 	return lcs
 }
 
-// CommonSubstring gets a common substring among the inputs
 func CommonSubstring(arr ...string) string {
 	commonStr := arr[0]
 
@@ -313,54 +221,76 @@ func Abs(n int) int {
 	return n
 }
 
-// FuncName returns the full name of a given function object
+// FuncName returns the name of a given function object
 func FuncName(i interface{}) string {
 	return runtime.FuncForPC(reflect.ValueOf(i).Pointer()).Name()
 }
 
-// ShortFuncName returns the name only of a given function object
-func ShortFuncName(i interface{}) string {
-	return strings.TrimPrefix(runtime.FuncForPC(reflect.ValueOf(i).Pointer()).Name(), "main.(*View).")
-}
+// SplitCommandArgs seperates multiple command arguments which may be quoted.
+// The returned slice contains at least one string
+func SplitCommandArgs(input string) []string {
+	var result []string
+	curArg := new(bytes.Buffer)
+	inQuote := false
+	escape := false
 
-// ReplaceHome takes a path as input and replaces ~ at the start of the path with the user's
-// home directory. Does nothing if the path does not start with '~'.
-func ReplaceHome(path string) string {
-	if !strings.HasPrefix(path, "~") {
-		return path
-	}
-
-	var userData *user.User
-	var err error
-
-	homeString := strings.Split(path, "/")[0]
-	if homeString == "~" {
-		userData, err = user.Current()
-		if err != nil {
-			messenger.Error("Could not find user: ", err)
-		}
-	} else {
-		userData, err = user.Lookup(homeString[1:])
-		if err != nil {
-			if messenger != nil {
-				messenger.Error("Could not find user: ", err)
-			} else {
-				TermMessage("Could not find user: ", err)
+	appendResult := func() {
+		str := curArg.String()
+		inQuote = false
+		escape = false
+		if strings.HasPrefix(str, `"`) && strings.HasSuffix(str, `"`) {
+			if unquoted, err := strconv.Unquote(str); err == nil {
+				str = unquoted
 			}
-			return ""
+		}
+		result = append(result, str)
+		curArg.Reset()
+	}
+
+	for _, r := range input {
+		if r == ' ' && !inQuote {
+			appendResult()
+		} else {
+			curArg.WriteRune(r)
+
+			if r == '"' && !inQuote {
+				inQuote = true
+			} else {
+				if inQuote && !escape {
+					if r == '"' {
+						inQuote = false
+					}
+					if r == '\\' {
+						escape = true
+						continue
+					}
+				}
+			}
+		}
+
+		escape = false
+	}
+	appendResult()
+	return result
+}
+
+// JoinCommandArgs joins multiple command arguments and quote the strings if needed.
+func JoinCommandArgs(args ...string) string {
+	buf := new(bytes.Buffer)
+	first := true
+	for _, arg := range args {
+		if first {
+			first = false
+		} else {
+			buf.WriteRune(' ')
+		}
+		quoted := strconv.Quote(arg)
+		if quoted[1:len(quoted)-1] != arg || strings.ContainsRune(arg, ' ') {
+			buf.WriteString(quoted)
+		} else {
+			buf.WriteString(arg)
 		}
 	}
 
-	home := userData.HomeDir
-
-	return strings.Replace(path, homeString, home, 1)
-}
-
-// GetPath returns a filename without everything following a `:`
-// This is used for opening files like util.go:10:5 to specify a line and column
-func GetPath(path string) string {
-	if strings.Contains(path, ":") {
-		path = strings.Split(path, ":")[0]
-	}
-	return path
+	return buf.String()
 }

cmd/micro/util_test.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"reflect"
 	"testing"
 )
 
@@ -49,15 +50,15 @@ func TestIsWordChar(t *testing.T) {
 	if IsWordChar("_") == false {
 		t.Errorf("IsWordChar(_) = false")
 	}
-	if IsWordChar("ß") == false {
-		t.Errorf("IsWordChar(ß) = false")
-	}
 	if IsWordChar("~") == true {
 		t.Errorf("IsWordChar(~) = true")
 	}
 	if IsWordChar(" ") == true {
 		t.Errorf("IsWordChar( ) = true")
 	}
+	if IsWordChar("ß") == true {
+		t.Errorf("IsWordChar(ß) = true")
+	}
 	if IsWordChar(")") == true {
 		t.Errorf("IsWordChar()) = true")
 	}
@@ -66,40 +67,47 @@ func TestIsWordChar(t *testing.T) {
 	}
 }
 
-func TestStringWidth(t *testing.T) {
-	tabsize := 4
-	if w := StringWidth("1\t2", tabsize); w != 5 {
-		t.Error("StringWidth 1 Failed. Got", w)
+func TestJoinAndSplitCommandArgs(t *testing.T) {
+	tests := []struct {
+		Query  []string
+		Wanted string
+	}{
+		{[]string{`test case`}, `"test case"`},
+		{[]string{`quote "test"`}, `"quote \"test\""`},
+		{[]string{`slash\\\ test`}, `"slash\\\\\\ test"`},
+		{[]string{`path 1`, `path\" 2`}, `"path 1" "path\\\" 2"`},
+		{[]string{`foo`}, `foo`},
+		{[]string{`foo\"bar`}, `"foo\\\"bar"`},
+		{[]string{``}, ``},
+		{[]string{`"`}, `"\""`},
+		{[]string{`a`, ``}, `a `},
+		{[]string{``, ``, ``, ``}, `   `},
+		{[]string{"\n"}, `"\n"`},
+		{[]string{"foo\tbar"}, `"foo\tbar"`},
 	}
-	if w := StringWidth("\t", tabsize); w != 4 {
-		t.Error("StringWidth 2 Failed. Got", w)
-	}
-	if w := StringWidth("1\t", tabsize); w != 4 {
-		t.Error("StringWidth 3 Failed. Got", w)
-	}
-	if w := StringWidth("\t\t", tabsize); w != 8 {
-		t.Error("StringWidth 4 Failed. Got", w)
-	}
-	if w := StringWidth("12\t2\t", tabsize); w != 8 {
-		t.Error("StringWidth 5 Failed. Got", w)
-	}
-}
 
-func TestWidthOfLargeRunes(t *testing.T) {
-	tabsize := 4
-	if w := WidthOfLargeRunes("1\t2", tabsize); w != 2 {
-		t.Error("WidthOfLargeRunes 1 Failed. Got", w)
+	for i, test := range tests {
+		if result := JoinCommandArgs(test.Query...); test.Wanted != result {
+			t.Errorf("JoinCommandArgs failed at Test %d\nGot: %q", i, result)
+		}
+
+		if result := SplitCommandArgs(test.Wanted); !reflect.DeepEqual(test.Query, result) {
+			t.Errorf("SplitCommandArgs failed at Test %d\nGot: `%q`", i, result)
+		}
 	}
-	if w := WidthOfLargeRunes("\t", tabsize); w != 3 {
-		t.Error("WidthOfLargeRunes 2 Failed. Got", w)
+
+	splitTests := []struct {
+		Query  string
+		Wanted []string
+	}{
+		{`"hallo""Welt"`, []string{`"hallo""Welt"`}},
+		{`\"`, []string{`\"`}},
+		{`"\"`, []string{`"\"`}},
 	}
-	if w := WidthOfLargeRunes("1\t", tabsize); w != 2 {
-		t.Error("WidthOfLargeRunes 3 Failed. Got", w)
-	}
-	if w := WidthOfLargeRunes("\t\t", tabsize); w != 6 {
-		t.Error("WidthOfLargeRunes 4 Failed. Got", w)
-	}
-	if w := WidthOfLargeRunes("12\t2\t", tabsize); w != 3 {
-		t.Error("WidthOfLargeRunes 5 Failed. Got", w)
+
+	for i, test := range splitTests {
+		if result := SplitCommandArgs(test.Query); !reflect.DeepEqual(test.Wanted, result) {
+			t.Errorf("SplitCommandArgs failed at Split-Test %d\nGot: `%q`", i, result)
+		}
 	}
 }

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

@@ -1,23 +0,0 @@
-<?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>

runtime/README.md

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

runtime/colorschemes/atom-dark-tc.micro

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

runtime/colorschemes/bubblegum.micro

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

runtime/colorschemes/cmc-16.micro

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

runtime/colorschemes/cmc-paper.micro

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

runtime/colorschemes/cmc-tc.micro

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

runtime/colorschemes/darcula.micro

@@ -1,27 +0,0 @@
-color-link default "#CCCCCC,#242424"
-color-link comment "#707070,#242424"
-color-link identifier "#FFC66D,#242424"
-color-link constant "#7A9EC2,#242424"
-color-link constant.string "#6A8759,#242424"
-color-link constant.string.char "#6A8759,#242424"
-color-link statement "#CC8242,#242424"
-color-link symbol "#CCCCCC,#242424"
-color-link preproc "#CC8242,#242424"
-color-link type "#CC8242,#242424"
-color-link special "#CC8242,#242424"
-color-link underlined "#D33682,#242424"
-color-link error "bold #CB4B16,#242424"
-color-link todo "bold #D33682,#242424"
-color-link statusline "#242424,#CCCCCC"
-color-link tabbar "#242424,#CCCCCC"
-color-link indent-char "#4F4F4F,#242424"
-color-link line-number "#666666,#242424"
-color-link current-line-number "#666666,#242424"
-color-link gutter-error "#CB4B16,#242424"
-color-link gutter-warning "#E6DB74,#242424"
-color-link cursor-line "default,#2C2C2C"
-color-link color-column "default,#2C2C2C"
-#No extended types; Plain brackets.
-color-link type.extended "default"
-#color-link symbol.brackets "default"
-color-link symbol.tag "#AE81FF,#242424"

runtime/colorschemes/default.micro

@@ -1,27 +1,20 @@
-color-link default "#F8F8F2,#282828"
-color-link comment "#75715E,#282828"
-color-link identifier "#66D9EF,#282828"
-color-link constant "#AE81FF,#282828"
-color-link constant.string "#E6DB74,#282828"
-color-link constant.string.char "#BDE6AD,#282828"
-color-link statement "#F92672,#282828"
-color-link symbol "#F92672,#282828"
-color-link preproc "#CB4B16,#282828"
-color-link type "#66D9EF,#282828"
-color-link special "#A6E22E,#282828"
-color-link underlined "#D33682,#282828"
-color-link error "bold #CB4B16,#282828"
-color-link todo "bold #D33682,#282828"
-color-link statusline "#282828,#F8F8F2"
-color-link tabbar "#282828,#F8F8F2"
-color-link indent-char "#505050,#282828"
-color-link line-number "#AAAAAA,#323232"
-color-link current-line-number "#AAAAAA,#282828"
-color-link gutter-error "#CB4B16,#282828"
-color-link gutter-warning "#E6DB74,#282828"
-color-link cursor-line "#323232"
-color-link color-column "#323232"
-#No extended types; Plain brackets.
-color-link type.extended "default"
-#color-link symbol.brackets "default"
-color-link symbol.tag "#AE81FF,#282828"
+color-link default "188,237"
+color-link comment "108,237"
+color-link constant.string "174,237"
+color-link constant.number "116,237"
+color-link constant "181,237"
+color-link identifier "223,237"
+color-link statement "223,237"
+color-link preproc "223,237"
+color-link type "187,237"
+color-link special "181,237"
+color-link underlined "188,237"
+color-link error "115,236"
+color-link todo "bold 254,237"
+color-link statusline "186,236"
+color-link indent-char "238,237"
+color-link line-number "188,238"
+color-link gutter-error "237,174"
+color-link gutter-warning "174,237"
+color-link cursor-line "238"
+color-link current-line-number "188,237"

runtime/colorschemes/geany.micro

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

runtime/colorschemes/github-tc.micro

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