Use dep for dependency management

.gitignore

@@ -1,5 +1,3 @@
-.DS_Store
-
 micro
 !cmd/micro
 binaries/
@@ -7,3 +5,4 @@ tmp.sh
 test/
 .idea/
 packages/
+cmd/micro/vendor

.gitmodules

@@ -1,57 +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/json5"]
-	path = cmd/micro/vendor/github.com/zyedidia/json5
-	url = https://github.com/zyedidia/json5
-[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

Makefile

@@ -11,7 +11,7 @@ ADDITIONAL_GO_LINKER_FLAGS := $(shell GOOS=$(shell go env GOHOSTOS) \
 GOBIN ?= $(shell go env GOPATH)/bin
 
 # Builds micro after checking dependencies but without updating the runtime
-build: update
+build: deps
 	go build -ldflags "-s -w -X main.Version=$(VERSION) -X main.CommitHash=$(HASH) -X 'main.CompileDate=$(DATE)' $(ADDITIONAL_GO_LINKER_FLAGS)" ./cmd/micro
 
 # Builds micro after building the runtime and checking dependencies
@@ -22,7 +22,7 @@ build-quick:
 	go build -ldflags "-s -w -X main.Version=$(VERSION) -X main.CommitHash=$(HASH) -X 'main.CompileDate=$(DATE)' $(ADDITIONAL_GO_LINKER_FLAGS)" ./cmd/micro
 
 # Same as 'build' but installs to $GOBIN afterward
-install: update
+install: deps
 	go install -ldflags "-s -w -X main.Version=$(VERSION) -X main.CommitHash=$(HASH) -X 'main.CompileDate=$(DATE)' $(ADDITIONAL_GO_LINKER_FLAGS)" ./cmd/micro
 
 # Same as 'build-all' but installs to $GOBIN afterward
@@ -32,9 +32,13 @@ install-all: runtime install
 install-quick:
 	go install -ldflags "-s -w -X main.Version=$(VERSION) -X main.CommitHash=$(HASH) -X 'main.CompileDate=$(DATE)' $(ADDITIONAL_GO_LINKER_FLAGS)"  ./cmd/micro
 
+# Checks for dependencies
+deps:
+	go get -d ./cmd/micro
+
 update:
 	git pull
-	git submodule update --init
+	go get -u -d ./cmd/micro
 
 # Builds the runtime
 runtime:
@@ -43,6 +47,7 @@ runtime:
 	mv runtime.go cmd/micro
 
 test:
+	go get -d ./cmd/micro
 	go test ./cmd/micro
 
 clean:

README.md

@@ -23,7 +23,6 @@ You can also check out the website for Micro at https://micro-editor.github.io.
 
 * 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
@@ -95,15 +94,15 @@ If your operating system does not have a binary release, but does run Go, you ca
 Make sure that you have Go version 1.5 or greater (Go 1.4 will work if your version supports CGO) and that your `GOPATH` env variable is set (I recommand setting it to `~/go` if you don't have one).
 
 ```
-go get -d github.com/zyedidia/micro/cmd/micro
+go get -d github.com/zyedidia/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`.
 
+The binary will then be installed to `$GOPATH/bin` (or your `$GOBIN`).
+
 You can install directly with `go get` (`go get -u github.com/zyedidia/micro/cmd/micro`) but this isn't recommended because it doesn't build micro with version information which is useful for the plugin manager.
 
 ### MacOS terminal

cmd/micro/Gopkg.lock

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

cmd/micro/Gopkg.toml

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

cmd/micro/bindings.go

@@ -10,114 +10,92 @@ import (
 )
 
 var bindings map[Key][]func(*View, bool) bool
-var mouseBindings map[Key][]func(*View, bool, *tcell.EventMouse) bool
 var helpBinding 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,
-	"SelectToStartOfLine":   (*View).SelectToStartOfLine,
-	"SelectToEndOfLine":     (*View).SelectToEndOfLine,
-	"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,
-	"ToggleRuler":           (*View).ToggleRuler,
-	"JumpLine":              (*View).JumpLine,
-	"ClearStatus":           (*View).ClearStatus,
-	"ShellMode":             (*View).ShellMode,
-	"CommandMode":           (*View).CommandMode,
-	"Escape":                (*View).Escape,
-	"Quit":                  (*View).Quit,
-	"QuitAll":               (*View).QuitAll,
-	"AddTab":                (*View).AddTab,
-	"PreviousTab":           (*View).PreviousTab,
-	"NextTab":               (*View).NextTab,
-	"NextSplit":             (*View).NextSplit,
-	"PreviousSplit":         (*View).PreviousSplit,
-	"Unsplit":               (*View).Unsplit,
-	"VSplit":                (*View).VSplitBinding,
-	"HSplit":                (*View).HSplitBinding,
-	"ToggleMacro":           (*View).ToggleMacro,
-	"PlayMacro":             (*View).PlayMacro,
-	"Suspend":               (*View).Suspend,
-	"ScrollUp":              (*View).ScrollUpAction,
-	"ScrollDown":            (*View).ScrollDownAction,
-	"SpawnMultiCursor":      (*View).SpawnMultiCursor,
-	"RemoveMultiCursor":     (*View).RemoveMultiCursor,
-	"RemoveAllMultiCursors": (*View).RemoveAllMultiCursors,
-	"SkipMultiCursor":       (*View).SkipMultiCursor,
+	"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,
+	"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,
+	"ToggleRuler":         (*View).ToggleRuler,
+	"JumpLine":            (*View).JumpLine,
+	"ClearStatus":         (*View).ClearStatus,
+	"ShellMode":           (*View).ShellMode,
+	"CommandMode":         (*View).CommandMode,
+	"Escape":              (*View).Escape,
+	"Quit":                (*View).Quit,
+	"QuitAll":             (*View).QuitAll,
+	"AddTab":              (*View).AddTab,
+	"PreviousTab":         (*View).PreviousTab,
+	"NextTab":             (*View).NextTab,
+	"NextSplit":           (*View).NextSplit,
+	"PreviousSplit":       (*View).PreviousSplit,
+	"Unsplit":             (*View).Unsplit,
+	"VSplit":              (*View).VSplitBinding,
+	"HSplit":              (*View).HSplitBinding,
+	"ToggleMacro":         (*View).ToggleMacro,
+	"PlayMacro":           (*View).PlayMacro,
+	"Suspend":             (*View).Suspend,
 
 	// This was changed to InsertNewline but I don't want to break backwards compatibility
 	"InsertEnter": (*View).InsertNewline,
 }
 
-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,
@@ -237,8 +215,6 @@ var bindingKeys = map[string]tcell.Key{
 	"CtrlRightSq":    tcell.KeyCtrlRightSq,
 	"CtrlCarat":      tcell.KeyCtrlCarat,
 	"CtrlUnderscore": tcell.KeyCtrlUnderscore,
-	"CtrlPageUp":     tcell.KeyCtrlPgUp,
-	"CtrlPageDown":   tcell.KeyCtrlPgDn,
 	"Tab":            tcell.KeyTab,
 	"Esc":            tcell.KeyEsc,
 	"Escape":         tcell.KeyEscape,
@@ -254,14 +230,12 @@ var bindingKeys = map[string]tcell.Key{
 type Key struct {
 	keyCode   tcell.Key
 	modifiers tcell.ModMask
-	buttons   tcell.ButtonMask
 	r         rune
 }
 
 // InitBindings initializes the keybindings for micro
 func InitBindings() {
 	bindings = make(map[Key][]func(*View, bool) bool)
-	mouseBindings = make(map[Key][]func(*View, bool, *tcell.EventMouse) bool)
 
 	var parsed map[string]string
 	defaults := DefaultBindings()
@@ -327,7 +301,6 @@ modSearch:
 			return Key{
 				keyCode:   code,
 				modifiers: modifiers,
-				buttons:   -1,
 				r:         0,
 			}, true
 		}
@@ -338,16 +311,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
 	}
@@ -357,13 +320,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'
@@ -377,16 +339,6 @@ 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
-}
-
 // BindKey takes a key and an action and binds the two together
 func BindKey(k, v string) {
 	key, ok := findKey(k)
@@ -404,31 +356,18 @@ func BindKey(k, v string) {
 	actionNames := strings.Split(v, ",")
 	if actionNames[0] == "UnbindKey" {
 		delete(bindings, key)
-		delete(mouseBindings, key)
 		if len(actionNames) == 1 {
-			return
+			actionNames = make([]string, 0, 0)
+		} else {
+			actionNames = append(actionNames[:0], actionNames[1:]...)
 		}
-		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 {
-			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
-	} 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
@@ -487,8 +426,6 @@ func DefaultBindings() map[string]string {
 		"CtrlEnd":        "CursorEnd",
 		"PageUp":         "CursorPageUp",
 		"PageDown":       "CursorPageDown",
-		"CtrlPageUp":     "PreviousTab",
-		"CtrlPageDown":   "NextTab",
 		"CtrlG":          "ToggleHelp",
 		"CtrlR":          "ToggleRuler",
 		"CtrlL":          "JumpLine",
@@ -505,8 +442,8 @@ func DefaultBindings() map[string]string {
 		"Alt-b": "WordLeft",
 		"Alt-a": "StartOfLine",
 		"Alt-e": "EndOfLine",
-		// "Alt-p": "CursorUp",
-		// "Alt-n": "CursorDown",
+		"Alt-p": "CursorUp",
+		"Alt-n": "CursorDown",
 
 		// Integration with file managers
 		"F1":  "ToggleHelp",
@@ -516,17 +453,5 @@ func DefaultBindings() map[string]string {
 		"F7":  "Find",
 		"F10": "Quit",
 		"Esc": "Escape",
-
-		// Mouse bindings
-		"MouseWheelUp":   "ScrollUp",
-		"MouseWheelDown": "ScrollDown",
-		"MouseLeft":      "MousePress",
-		"MouseMiddle":    "PastePrimary",
-		"Ctrl-MouseLeft": "MouseMultiCursor",
-
-		"Alt-n": "SpawnMultiCursor",
-		"Alt-p": "RemoveMultiCursor",
-		"Alt-c": "RemoveAllMultiCursors",
-		"Alt-x": "SkipMultiCursor",
 	}
 }

cmd/micro/buffer.go

@@ -28,9 +28,7 @@ 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
@@ -171,8 +169,6 @@ func NewBuffer(reader io.Reader, size int64, path string) *Buffer {
 		file.Close()
 	}
 
-	b.cursors = []*Cursor{&b.Cursor}
-
 	return b
 }
 
@@ -208,7 +204,7 @@ func (b *Buffer) UpdateRules() {
 			}
 
 			ft := b.Settings["filetype"].(string)
-			if (ft == "Unknown" || ft == "") && !rehighlight {
+			if ft == "Unknown" || ft == "" {
 				if highlight.MatchFiletype(ftdetect, b.Path, b.lines[0].data) {
 					header := new(highlight.Header)
 					header.FileType = file.FileType
@@ -221,7 +217,7 @@ func (b *Buffer) UpdateRules() {
 					rehighlight = true
 				}
 			} else {
-				if file.FileType == ft && !rehighlight {
+				if file.FileType == ft {
 					header := new(highlight.Header)
 					header.FileType = file.FileType
 					header.FtDetect = ftdetect
@@ -309,30 +305,6 @@ func (b *Buffer) Update() {
 	b.NumLines = len(b.lines)
 }
 
-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
-}
-
-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)
@@ -403,9 +375,17 @@ func (b *Buffer) SaveAsWithSudo(filename string) error {
 	b.UpdateRules()
 	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("sudo", "tee", filename)
@@ -423,10 +403,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)

cmd/micro/command.go

@@ -35,28 +35,27 @@ var commandActions map[string]func([]string)
 
 func init() {
 	commandActions = map[string]func([]string){
-		"Set":        Set,
-		"SetLocal":   SetLocal,
-		"Show":       Show,
-		"Run":        Run,
-		"Bind":       Bind,
-		"Quit":       Quit,
-		"Save":       Save,
-		"Replace":    Replace,
-		"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,
-		"MemUsage":   MemUsage,
+		"Set":       Set,
+		"SetLocal":  SetLocal,
+		"Show":      Show,
+		"Run":       Run,
+		"Bind":      Bind,
+		"Quit":      Quit,
+		"Save":      Save,
+		"Replace":   Replace,
+		"VSplit":    VSplit,
+		"HSplit":    HSplit,
+		"Tab":       NewTab,
+		"Help":      Help,
+		"Eval":      Eval,
+		"ToggleLog": ToggleLog,
+		"Plugin":    PluginCmd,
+		"Reload":    Reload,
+		"Cd":        Cd,
+		"Pwd":       Pwd,
+		"Open":      Open,
+		"TabSwitch": TabSwitch,
+		"MemUsage":  MemUsage,
 	}
 }
 
@@ -90,28 +89,27 @@ 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, 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}},
-		"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}},
-		"memusage":   {"MemUsage", []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}},
+		"eval":      {"Eval", []Completion{NoCompletion}},
+		"log":       {"ToggleLog", []Completion{NoCompletion}},
+		"plugin":    {"Plugin", []Completion{PluginCmdCompletion, PluginNameCompletion}},
+		"reload":    {"Reload", []Completion{NoCompletion}},
+		"cd":        {"Cd", []Completion{FileCompletion}},
+		"pwd":       {"Pwd", []Completion{NoCompletion}},
+		"open":      {"Open", []Completion{FileCompletion}},
+		"tabswitch": {"TabSwitch", []Completion{NoCompletion}},
+		"memusage":  {"MemUsage", []Completion{NoCompletion}},
 	}
 }
 
@@ -508,21 +506,16 @@ func Save(args []string) {
 
 // Replace runs search and replace
 func Replace(args []string) {
-	if len(args) < 2 || len(args) > 3 {
+	if len(args) < 2 {
 		// We need to find both a search and replace expression
 		messenger.Error("Invalid replace statement: " + strings.Join(args, " "))
 		return
 	}
 
-	allAtOnce := false
+	var flags string
 	if len(args) == 3 {
-		// user added -a flag
-		if args[2] == "-a" {
-			allAtOnce = true
-		} else {
-			messenger.Error("Invalid replace flag: " + args[2])
-			return
-		}
+		// The user included some flags
+		flags = args[2]
 	}
 
 	search := string(args[0])
@@ -538,32 +531,7 @@ func Replace(args []string) {
 	view := CurView()
 
 	found := 0
-	replaceAll := func() {
-		var deltas []Delta
-		deltaXOffset := Count(replace) - Count(search)
-		for i := 0; i < view.Buf.LinesNum(); i++ {
-			matches := regex.FindAllIndex(view.Buf.lines[i].data, -1)
-			str := string(view.Buf.lines[i].data)
-
-			if matches != nil {
-				xOffset := 0
-				for _, m := range matches {
-					from := Loc{runePos(m[0], str) + xOffset, i}
-					to := Loc{runePos(m[1], str) + xOffset, i}
-
-					xOffset += deltaXOffset
-
-					deltas = append(deltas, Delta{replace, from, to})
-					found++
-				}
-			}
-		}
-		view.Buf.MultipleReplace(deltas)
-	}
-
-	if allAtOnce {
-		replaceAll()
-	} else {
+	if strings.Contains(flags, "c") {
 		for {
 			// The 'check' flag was used
 			Search(search, view, true)
@@ -572,7 +540,7 @@ func Replace(args []string) {
 			}
 			view.Relocate()
 			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]
@@ -580,27 +548,42 @@ 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 {
+		// var deltas []Delta
+		for i := 0; i < view.Buf.LinesNum(); i++ {
+			// view.Buf.lines[i].data = regex.ReplaceAll(view.Buf.lines[i].data, []byte(replace))
+			for {
+				m := regex.FindIndex(view.Buf.lines[i].data)
+
+				if m != nil {
+					from := Loc{m[0], i}
+					to := Loc{m[1], i}
+
+					// deltas = append(deltas, Delta{replace, from, to})
+					view.Buf.Replace(from, to, replace)
+					found++
+				} else {
+					break
+				}
+			}
+		}
+		// view.Buf.MultipleReplace(deltas)
 	}
 	view.Cursor.Relocate()
 
@@ -613,12 +596,6 @@ 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]

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,9 +21,6 @@ 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
@@ -339,22 +334,9 @@ 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
 func (c *Cursor) Relocate() {

cmd/micro/eventhandler.go

@@ -97,65 +97,30 @@ 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{Delta{text, start, Loc{0, 0}}},
 		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()
-	}
 }
 
 // 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{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],
+		C:         eh.buf.Cursor,
 		EventType: TextEventReplace,
 		Deltas:    deltas,
 		Time:      time.Now(),
@@ -230,12 +195,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)
@@ -277,12 +238,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/highlight/parser.go

@@ -1,7 +1,6 @@
 package highlight
 
 import (
-	"errors"
 	"fmt"
 	"regexp"
 
@@ -83,16 +82,6 @@ func init() {
 }
 
 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
@@ -123,22 +112,14 @@ func ParseFtDetect(file *File) (r [2]*regexp.Regexp, err error) {
 		}
 	}
 
-	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)
-			}
+		if e := recover(); e != nil {
+			err = e.(error)
 		}
 	}()
 
@@ -166,12 +147,8 @@ func ParseFile(input []byte) (f *File, err error) {
 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)
-			}
+		if e := recover(); e != nil {
+			err = e.(error)
 		}
 	}()
 
@@ -234,17 +211,8 @@ func resolveIncludesInRegion(files []*File, region *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)
+func parseRules(input []interface{}, curRegion *region) (*rules, error) {
+	rules := new(rules)
 
 	for _, v := range input {
 		rule := v.(map[interface{}]interface{})
@@ -254,7 +222,7 @@ func parseRules(input []interface{}, curRegion *region) (ru *rules, err error) {
 			switch object := val.(type) {
 			case string:
 				if k == "include" {
-					ru.includes = append(ru.includes, object)
+					rules.includes = append(rules.includes, object)
 				} else {
 					// Pattern
 					r, err := regexp.Compile(object)
@@ -268,7 +236,7 @@ func parseRules(input []interface{}, curRegion *region) (ru *rules, err error) {
 						Groups[groupStr] = numGroups
 					}
 					groupNum := Groups[groupStr]
-					ru.patterns = append(ru.patterns, &pattern{groupNum, r})
+					rules.patterns = append(rules.patterns, &pattern{groupNum, r})
 				}
 			case map[interface{}]interface{}:
 				// region
@@ -276,43 +244,35 @@ func parseRules(input []interface{}, curRegion *region) (ru *rules, err error) {
 				if err != nil {
 					return nil, err
 				}
-				ru.regions = append(ru.regions, region)
+				rules.regions = append(rules.regions, region)
 			default:
 				return nil, fmt.Errorf("Bad type %T", object)
 			}
 		}
 	}
 
-	return ru, nil
+	return rules, 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)
-			}
-		}
-	}()
+func parseRegion(group string, regionInfo map[interface{}]interface{}, prevRegion *region) (*region, error) {
+	var err error
 
-	r = new(region)
+	region := new(region)
 	if _, ok := Groups[group]; !ok {
 		numGroups++
 		Groups[group] = numGroups
 	}
 	groupNum := Groups[group]
-	r.group = groupNum
-	r.parent = prevRegion
+	region.group = groupNum
+	region.parent = prevRegion
 
-	r.start, err = regexp.Compile(regionInfo["start"].(string))
+	region.start, err = regexp.Compile(regionInfo["start"].(string))
 
 	if err != nil {
 		return nil, err
 	}
 
-	r.end, err = regexp.Compile(regionInfo["end"].(string))
+	region.end, err = regexp.Compile(regionInfo["end"].(string))
 
 	if err != nil {
 		return nil, err
@@ -320,7 +280,7 @@ func parseRegion(group string, regionInfo map[interface{}]interface{}, prevRegio
 
 	// skip is optional
 	if _, ok := regionInfo["skip"]; ok {
-		r.skip, err = regexp.Compile(regionInfo["skip"].(string))
+		region.skip, err = regexp.Compile(regionInfo["skip"].(string))
 
 		if err != nil {
 			return nil, err
@@ -335,20 +295,20 @@ func parseRegion(group string, regionInfo map[interface{}]interface{}, prevRegio
 			Groups[groupStr] = numGroups
 		}
 		groupNum := Groups[groupStr]
-		r.limitGroup = groupNum
+		region.limitGroup = groupNum
 
 		if err != nil {
 			return nil, err
 		}
 	} else {
-		r.limitGroup = r.group
+		region.limitGroup = region.group
 	}
 
-	r.rules, err = parseRules(regionInfo["rules"].([]interface{}), r)
+	region.rules, err = parseRules(regionInfo["rules"].([]interface{}), region)
 
 	if err != nil {
 		return nil, err
 	}
 
-	return r, nil
+	return region, nil
 }

cmd/micro/loc.go

@@ -54,28 +54,6 @@ type Loc struct {
 	X, Y int
 }
 
-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/messenger.go

@@ -9,7 +9,6 @@ import (
 
 	"github.com/zyedidia/clipboard"
 	"github.com/zyedidia/tcell"
-	"github.com/mattn/go-runewidth"
 )
 
 // TermMessage sends a message to the user in the terminal. This usually occurs before
@@ -464,10 +463,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)
 			}
 		}
 	}

cmd/micro/micro.go

@@ -252,7 +252,6 @@ func main() {
 	flag.Usage = func() {
 		fmt.Println("Usage: micro [OPTIONS] [FILE]...")
 		fmt.Print("Micro's options can be set via command line arguments for quick adjustments. For real configuration, please use the bindings.json file (see 'help options').\n\n")
-		flag.CommandLine.SetOutput(os.Stdout)
 		flag.PrintDefaults()
 	}
 
@@ -408,9 +407,7 @@ func main() {
 	// Here is the event loop which runs in a separate thread
 	go func() {
 		for {
-			if screen != nil {
-				events <- screen.PollEvent()
-			}
+			events <- screen.PollEvent()
 		}
 	}()
 

cmd/micro/plugin.go

@@ -7,7 +7,6 @@ import (
 	"strings"
 
 	"github.com/yuin/gopher-lua"
-	"github.com/zyedidia/tcell"
 	"layeh.com/gopher-luar"
 )
 
@@ -61,16 +60,6 @@ func LuaFunctionBinding(function string) func(*View, bool) bool {
 	}
 }
 
-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 {

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
@@ -44,7 +43,7 @@ func EndSearch() {
 	}
 }
 
-// ExitSearch exits the search mode, reset active search phrase, and clear status bar
+// exit the search mode, reset active search phrase, and clear status bar
 func ExitSearch(v *View) {
 	lastSearch = ""
 	searching = false
@@ -92,62 +91,6 @@ func HandleSearchEvent(event tcell.Event, v *View) {
 	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.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.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
@@ -155,6 +98,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)
@@ -162,22 +114,37 @@ 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)
-		}
-	} else {
-		found = searchUp(r, v, searchStart, v.Buf.Start())
-		if !found {
-			found = searchUp(r, v, v.Buf.End(), searchStart)
+		if !down {
+			match = matches[len(matches)-1]
+		} else {
+			match = matches[0]
 		}
+		str = text
 	}
-	if found {
-		lastSearch = searchStr
+
+	if !down {
+		match = matches[len(matches)-1]
 	} else {
-		v.Cursor.ResetSelection()
+		match = matches[0]
 	}
+
+	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]
+	lastSearch = searchStr
 }

cmd/micro/util.go

@@ -36,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

cmd/micro/view.go

@@ -169,7 +169,7 @@ func (v *View) paste(clip string) {
 	}
 	clip = strings.Replace(clip, "\n", "\n"+leadingWS, -1)
 	v.Buf.Insert(v.Cursor.Loc, clip)
-	// v.Cursor.Loc = v.Cursor.Loc.Move(Count(clip), v.Buf)
+	v.Cursor.Loc = v.Cursor.Loc.Move(Count(clip), v.Buf)
 	v.freshClip = false
 	messenger.Message("Pasted clipboard")
 }
@@ -450,40 +450,6 @@ func (v *View) MoveToMouseClick(x, y int) {
 	v.Cursor.LastVisualX = v.Cursor.GetVisualX()
 }
 
-func (v *View) ExecuteActions(actions []func(*View, bool) bool) bool {
-	relocate := false
-	readonlyBindingsList := []string{"Delete", "Insert", "Backspace", "Cut", "Play", "Paste", "Move", "Add", "DuplicateLine", "Macro"}
-	for _, action := range actions {
-		readonlyBindingsResult := false
-		funcName := ShortFuncName(action)
-		if v.Type.readonly == true {
-			// check for readonly and if true only let key bindings get called if they do not change the contents.
-			for _, readonlyBindings := range readonlyBindingsList {
-				if strings.Contains(funcName, readonlyBindings) {
-					readonlyBindingsResult = true
-				}
-			}
-		}
-		if !readonlyBindingsResult {
-			// call the key binding
-			relocate = action(v, true) || relocate
-			// Macro
-			if funcName != "ToggleMacro" && funcName != "PlayMacro" {
-				if recordingMacro {
-					curMacro = append(curMacro, action)
-				}
-			}
-		}
-	}
-
-	return relocate
-}
-
-func (v *View) SetCursor(c *Cursor) {
-	v.Cursor = c
-	v.Buf.curCursor = c.Num
-}
-
 // HandleEvent handles an event passed by the main loop
 func (v *View) HandleEvent(event tcell.Event) {
 	// This bool determines whether the view is relocated at the end of the function
@@ -496,51 +462,66 @@ func (v *View) HandleEvent(event tcell.Event) {
 	case *tcell.EventKey:
 		// Check first if input is a key binding, if it is we 'eat' the input and don't insert a rune
 		isBinding := false
-		for key, actions := range bindings {
-			if e.Key() == key.keyCode {
-				if e.Key() == tcell.KeyRune {
-					if e.Rune() != key.r {
-						continue
+		readonlyBindingsList := []string{"Delete", "Insert", "Backspace", "Cut", "Play", "Paste", "Move", "Add", "DuplicateLine", "Macro"}
+		if e.Key() != tcell.KeyRune || e.Modifiers() != 0 {
+			for key, actions := range bindings {
+				if e.Key() == key.keyCode {
+					if e.Key() == tcell.KeyRune {
+						if e.Rune() != key.r {
+							continue
+						}
 					}
-				}
-				if e.Modifiers() == key.modifiers {
-					for _, c := range v.Buf.cursors {
-						v.SetCursor(c)
+					if e.Modifiers() == key.modifiers {
 						relocate = false
 						isBinding = true
-						relocate = v.ExecuteActions(actions) || relocate
+						for _, action := range actions {
+							readonlyBindingsResult := false
+							funcName := ShortFuncName(action)
+							if v.Type.readonly == true {
+								// check for readonly and if true only let key bindings get called if they do not change the contents.
+								for _, readonlyBindings := range readonlyBindingsList {
+									if strings.Contains(funcName, readonlyBindings) {
+										readonlyBindingsResult = true
+									}
+								}
+							}
+							if !readonlyBindingsResult {
+								// call the key binding
+								relocate = action(v, true) || relocate
+								// Macro
+								if funcName != "ToggleMacro" && funcName != "PlayMacro" {
+									if recordingMacro {
+										curMacro = append(curMacro, action)
+									}
+								}
+							}
+						}
+						break
 					}
-					v.SetCursor(&v.Buf.Cursor)
-					v.Buf.MergeCursors()
-					break
 				}
 			}
 		}
 		if !isBinding && e.Key() == tcell.KeyRune {
 			// Check viewtype if readonly don't insert a rune (readonly help and log view etc.)
 			if v.Type.readonly == false {
-				for _, c := range v.Buf.cursors {
-					v.SetCursor(c)
+				// Insert a character
+				if v.Cursor.HasSelection() {
+					v.Cursor.DeleteSelection()
+					v.Cursor.ResetSelection()
+				}
+				v.Buf.Insert(v.Cursor.Loc, string(e.Rune()))
+				v.Cursor.Right()
 
-					// Insert a character
-					if v.Cursor.HasSelection() {
-						v.Cursor.DeleteSelection()
-						v.Cursor.ResetSelection()
-					}
-					v.Buf.Insert(v.Cursor.Loc, string(e.Rune()))
-
-					for pl := range loadedPlugins {
-						_, err := Call(pl+".onRune", string(e.Rune()), v)
-						if err != nil && !strings.HasPrefix(err.Error(), "function does not exist") {
-							TermMessage(err)
-						}
-					}
-
-					if recordingMacro {
-						curMacro = append(curMacro, e.Rune())
+				for pl := range loadedPlugins {
+					_, err := Call(pl+".onRune", string(e.Rune()), v)
+					if err != nil && !strings.HasPrefix(err.Error(), "function does not exist") {
+						TermMessage(err)
 					}
 				}
-				v.SetCursor(&v.Buf.Cursor)
+
+				if recordingMacro {
+					curMacro = append(curMacro, e.Rune())
+				}
 			}
 		}
 	case *tcell.EventPaste:
@@ -550,50 +531,77 @@ func (v *View) HandleEvent(event tcell.Event) {
 				break
 			}
 
-			for _, c := range v.Buf.cursors {
-				v.SetCursor(c)
-				v.paste(e.Text())
-
-			}
-			v.SetCursor(&v.Buf.Cursor)
+			v.paste(e.Text())
 
 			PostActionCall("Paste", v)
 		}
 	case *tcell.EventMouse:
+		x, y := e.Position()
+		x -= v.lineNumOffset - v.leftCol + v.x
+		y += v.Topline - v.y
 		// Don't relocate for mouse events
 		relocate = false
 
 		button := e.Buttons()
 
-		for key, actions := range bindings {
-			if button == key.buttons && e.Modifiers() == key.modifiers {
-				for _, c := range v.Buf.cursors {
-					v.SetCursor(c)
-					relocate = v.ExecuteActions(actions) || relocate
-				}
-				v.SetCursor(&v.Buf.Cursor)
-				v.Buf.MergeCursors()
-			}
-		}
-
-		for key, actions := range mouseBindings {
-			if button == key.buttons && e.Modifiers() == key.modifiers {
-				for _, action := range actions {
-					action(v, true, e)
-				}
-			}
-		}
-
 		switch button {
+		case tcell.Button1:
+			// Left click
+			if v.mouseReleased {
+				v.MoveToMouseClick(x, y)
+				if time.Since(v.lastClickTime)/time.Millisecond < doubleClickThreshold {
+					if v.doubleClick {
+						// Triple click
+						v.lastClickTime = time.Now()
+
+						v.tripleClick = true
+						v.doubleClick = false
+
+						v.Cursor.SelectLine()
+						v.Cursor.CopySelection("primary")
+					} else {
+						// Double click
+						v.lastClickTime = time.Now()
+
+						v.doubleClick = true
+						v.tripleClick = false
+
+						v.Cursor.SelectWord()
+						v.Cursor.CopySelection("primary")
+					}
+				} else {
+					v.doubleClick = false
+					v.tripleClick = false
+					v.lastClickTime = time.Now()
+
+					v.Cursor.OrigSelection[0] = v.Cursor.Loc
+					v.Cursor.CurSelection[0] = v.Cursor.Loc
+					v.Cursor.CurSelection[1] = v.Cursor.Loc
+				}
+				v.mouseReleased = false
+			} else if !v.mouseReleased {
+				v.MoveToMouseClick(x, y)
+				if v.tripleClick {
+					v.Cursor.AddLineToSelection()
+				} else if v.doubleClick {
+					v.Cursor.AddWordToSelection()
+				} else {
+					v.Cursor.SetSelectionEnd(v.Cursor.Loc)
+					v.Cursor.CopySelection("primary")
+				}
+			}
+		case tcell.Button2:
+			// Check viewtype if readonly don't paste (readonly help and log view etc.)
+			if v.Type.readonly == false {
+				// Middle mouse button was clicked,
+				// We should paste primary
+				v.PastePrimary(true)
+			}
 		case tcell.ButtonNone:
 			// Mouse event with no click
 			if !v.mouseReleased {
 				// Mouse was just released
 
-				x, y := e.Position()
-				x -= v.lineNumOffset - v.leftCol + v.x
-				y += v.Topline - v.y
-
 				// Relocating here isn't really necessary because the cursor will
 				// be in the right place from the last mouse event
 				// However, if we are running in a terminal that doesn't support mouse motion
@@ -607,6 +615,14 @@ func (v *View) HandleEvent(event tcell.Event) {
 				}
 				v.mouseReleased = true
 			}
+		case tcell.WheelUp:
+			// Scroll up
+			scrollspeed := int(v.Buf.Settings["scrollspeed"].(float64))
+			v.ScrollUp(scrollspeed)
+		case tcell.WheelDown:
+			// Scroll down
+			scrollspeed := int(v.Buf.Settings["scrollspeed"].(float64))
+			v.ScrollDown(scrollspeed)
 		}
 	}
 
@@ -621,10 +637,6 @@ func (v *View) HandleEvent(event tcell.Event) {
 	}
 }
 
-func (v *View) mainCursor() bool {
-	return v.Buf.curCursor == len(v.Buf.cursors)-1
-}
-
 // GutterMessage creates a message in this view's gutter
 func (v *View) GutterMessage(section string, lineN int, msg string, kind int) {
 	lineN--
@@ -851,20 +863,22 @@ func (v *View) DisplayView() {
 				}
 
 				charLoc := char.realLoc
-				for _, c := range v.Buf.cursors {
-					v.SetCursor(c)
-					if v.Cursor.HasSelection() &&
-						(charLoc.GreaterEqual(v.Cursor.CurSelection[0]) && charLoc.LessThan(v.Cursor.CurSelection[1]) ||
-							charLoc.LessThan(v.Cursor.CurSelection[0]) && charLoc.GreaterEqual(v.Cursor.CurSelection[1])) {
-						// The current character is selected
-						lineStyle = defStyle.Reverse(true)
+				if v.Cursor.HasSelection() &&
+					(charLoc.GreaterEqual(v.Cursor.CurSelection[0]) && charLoc.LessThan(v.Cursor.CurSelection[1]) ||
+						charLoc.LessThan(v.Cursor.CurSelection[0]) && charLoc.GreaterEqual(v.Cursor.CurSelection[1])) {
+					// The current character is selected
+					lineStyle = defStyle.Reverse(true)
 
-						if style, ok := colorscheme["selection"]; ok {
-							lineStyle = style
-						}
+					if style, ok := colorscheme["selection"]; ok {
+						lineStyle = style
 					}
 				}
-				v.SetCursor(&v.Buf.Cursor)
+
+				if tabs[curTab].CurView == v.Num && !v.Cursor.HasSelection() &&
+					v.Cursor.Y == char.realLoc.Y && v.Cursor.X == char.realLoc.X && !cursorSet {
+					screen.ShowCursor(xOffset+char.visualLoc.X, yOffset+char.visualLoc.Y)
+					cursorSet = true
+				}
 
 				if v.Buf.Settings["cursorline"].(bool) && tabs[curTab].CurView == v.Num &&
 					!v.Cursor.HasSelection() && v.Cursor.Y == realLineN {
@@ -875,16 +889,6 @@ func (v *View) DisplayView() {
 
 				screen.SetContent(xOffset+char.visualLoc.X, yOffset+char.visualLoc.Y, char.drawChar, nil, lineStyle)
 
-				for i, c := range v.Buf.cursors {
-					v.SetCursor(c)
-					if tabs[curTab].CurView == v.Num && !v.Cursor.HasSelection() &&
-						v.Cursor.Y == char.realLoc.Y && v.Cursor.X == char.realLoc.X && (!cursorSet || i != 0) {
-						ShowMultiCursor(xOffset+char.visualLoc.X, yOffset+char.visualLoc.Y, i)
-						cursorSet = true
-					}
-				}
-				v.SetCursor(&v.Buf.Cursor)
-
 				lastChar = char
 			}
 		}
@@ -895,27 +899,19 @@ func (v *View) DisplayView() {
 		var cx, cy int
 		if lastChar != nil {
 			lastX = xOffset + lastChar.visualLoc.X + lastChar.width
-			for i, c := range v.Buf.cursors {
-				v.SetCursor(c)
-				if tabs[curTab].CurView == v.Num && !v.Cursor.HasSelection() &&
-					v.Cursor.Y == lastChar.realLoc.Y && v.Cursor.X == lastChar.realLoc.X+1 {
-					ShowMultiCursor(lastX, yOffset+lastChar.visualLoc.Y, i)
-					cx, cy = lastX, yOffset+lastChar.visualLoc.Y
-				}
+			if tabs[curTab].CurView == v.Num && !v.Cursor.HasSelection() &&
+				v.Cursor.Y == lastChar.realLoc.Y && v.Cursor.X == lastChar.realLoc.X+1 {
+				screen.ShowCursor(lastX, yOffset+lastChar.visualLoc.Y)
+				cx, cy = lastX, yOffset+lastChar.visualLoc.Y
 			}
-			v.SetCursor(&v.Buf.Cursor)
-			realLoc = Loc{lastChar.realLoc.X + 1, realLineN}
+			realLoc = Loc{lastChar.realLoc.X, realLineN}
 			visualLoc = Loc{lastX - xOffset, lastChar.visualLoc.Y}
 		} else if len(line) == 0 {
-			for i, c := range v.Buf.cursors {
-				v.SetCursor(c)
-				if tabs[curTab].CurView == v.Num && !v.Cursor.HasSelection() &&
-					v.Cursor.Y == realLineN {
-					ShowMultiCursor(xOffset, yOffset+visualLineN, i)
-					cx, cy = xOffset, yOffset+visualLineN
-				}
+			if tabs[curTab].CurView == v.Num && !v.Cursor.HasSelection() &&
+				v.Cursor.Y == realLineN {
+				screen.ShowCursor(xOffset, yOffset+visualLineN)
+				cx, cy = xOffset, yOffset+visualLineN
 			}
-			v.SetCursor(&v.Buf.Cursor)
 			lastX = xOffset
 			realLoc = Loc{0, realLineN}
 			visualLoc = Loc{0, visualLineN}
@@ -957,18 +953,6 @@ func (v *View) DisplayView() {
 	}
 }
 
-// ShowMultiCursor will display a cursor at a location
-// If i == 0 then the terminal cursor will be used
-// Otherwise a fake cursor will be drawn at the position
-func ShowMultiCursor(x, y, i int) {
-	if i == 0 {
-		screen.ShowCursor(x, y)
-	} else {
-		r, _, _, _ := screen.GetContent(x, y)
-		screen.SetContent(x, y, r, nil, defStyle.Reverse(true))
-	}
-}
-
 // Display renders the view, the cursor, and statusline
 func (v *View) Display() {
 	if globalSettings["termtitle"].(bool) {

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 "#2C2C2C"
-color-link color-column "#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,3 +1,4 @@
+# This is the monokai colorscheme
 color-link default "#F8F8F2,#282828"
 color-link comment "#75715E,#282828"
 color-link identifier "#66D9EF,#282828"
@@ -13,7 +14,7 @@ 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 tabbar "#282828,#f8f8f2"
 color-link indent-char "#505050,#282828"
 color-link line-number "#AAAAAA,#323232"
 color-link current-line-number "#AAAAAA,#282828"
@@ -21,7 +22,6 @@ 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.
+#No extended types; plain brackets
 color-link type.extended "default"
-#color-link symbol.brackets "default"
-color-link symbol.tag "#AE81FF,#282828"
+color-link symbol.brackets "default"

runtime/help/commands.md

@@ -10,17 +10,12 @@ Here are the possible commands that you can use.
 
 * `replace "search" "value" flags`: This will replace `search` with `value`. 
    The `flags` are optional.
-   At this point, there is only one flag: `-a`, which replaces all occurrences
-   at once.
+   At this point, there is only one flag: `c`, which enables `check` mode 
+   which asks if you'd like to perform the replacement each time.
 
    Note that `search` must be a valid regex.  If one of the arguments
    does not have any spaces in it, you may omit the quotes.
 
-* `replaceall "search" "value"`: This will replace `search` with `value` without
-    user confirmation.
-
-    See `replace` command for more information.
-
 * `set option value`: sets the option to value. See the `options` help topic
    for a list of options you can set.
 

runtime/help/defaultkeys.md

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

runtime/help/help.md

@@ -15,9 +15,9 @@ and you can see which commands are available by pressing tab, or by
 viewing the help topic `> help commands`. When I write `> ...` I mean press
 CtrlE and then type whatever is there. 
 
-Move the cursor around with the mouse or the arrow keys. Type `> help defaultkeys` to 
+Move the cursor around with the mouse or the arrow keys. Type `>help defaultkeys` to 
 get a quick, easy overview of the default hotkeys and what they do. For more info
-on rebinding keys, see type `> help keybindings`
+on rebinding keys, see type `>help keybindings`
 
 If the colorscheme doesn't look good, you can change it with `> set colorscheme ...`.
 You can press tab to see the available colorschemes, or see more information with

runtime/help/keybindings.md

@@ -131,22 +131,9 @@ HSplit
 PreviousSplit
 ToggleMacro
 PlayMacro
-Suspend (Linux only)
-ScrollUp
-ScrollDown
-SpawnMultiCursor
-RemoveMultiCursor
-RemoveAllMultiCursors
-SkipMultiCursor
 UnbindKey
 ```
 
-You can also bind some mouse actions (these must be bound to mouse buttons)
-```
-MousePress
-MouseMultiCursor
-```
-
 Here is the list of all possible keys you can bind:
 
 ```
@@ -275,18 +262,6 @@ Escape
 Enter
 ```
 
-You can also bind some mouse buttons (they may be bound to normal actions or mouse actions)
-
-```
-MouseLeft
-MouseMiddle
-MouseRight
-MouseWheelUp
-MouseWheelDown
-MouseWheelLeft
-MouseWheelRight
-```
-
 # Default keybinding configuration.
 
 ```json
@@ -301,10 +276,10 @@ MouseWheelRight
     "ShiftRight":     "SelectRight",
     "AltLeft":        "WordLeft",
     "AltRight":       "WordRight",
-    "AltUp":          "MoveLinesUp",
-    "AltDown":        "MoveLinesDown",
     "AltShiftRight":  "SelectWordRight",
     "AltShiftLeft":   "SelectWordLeft",
+    "AltUp":          "MoveLinesUp",
+    "AltDown":        "MoveLinesDown",
     "CtrlLeft":       "StartOfLine",
     "CtrlRight":      "EndOfLine",
     "CtrlShiftLeft":  "SelectToStartOfLine",
@@ -316,12 +291,13 @@ MouseWheelRight
     "CtrlShiftUp":    "SelectToStart",
     "CtrlShiftDown":  "SelectToEnd",
     "Enter":          "InsertNewline",
+    "Space":          "InsertSpace",
     "CtrlH":          "Backspace",
     "Backspace":      "Backspace",
     "Alt-CtrlH":      "DeleteWordLeft",
     "Alt-Backspace":  "DeleteWordLeft",
     "Tab":            "IndentSelection,InsertTab",
-    "Backtab":        "OutdentSelection,OutdentLine",
+    "Backtab":        "OutdentSelection",
     "CtrlO":          "OpenFile",
     "CtrlS":          "Save",
     "CtrlF":          "Find",
@@ -360,6 +336,8 @@ MouseWheelRight
     "Alt-b": "WordLeft",
     "Alt-a": "StartOfLine",
     "Alt-e": "EndOfLine",
+    "Alt-p": "CursorUp",
+    "Alt-n": "CursorDown",
 
     // Integration with file managers
     "F1":  "ToggleHelp",
@@ -369,23 +347,10 @@ MouseWheelRight
     "F7":  "Find",
     "F10": "Quit",
     "Esc": "Escape",
-
-    // Mouse bindings
-    "MouseWheelUp":   "ScrollUp",
-    "MouseWheelDown": "ScrollDown",
-    "MouseLeft":      "MousePress",
-    "MouseMiddle":    "PastePrimary",
-    "Ctrl-MouseLeft": "MouseMultiCursor",
-
-    // Multiple cursors bindings
-    "Alt-n": "SpawnMultiCursor",
-    "Alt-p": "RemoveMultiCursor",
-    "Alt-c": "RemoveAllMultiCursors",
-    "Alt-x": "SkipMultiCursor",
 }
 ```
 
-# Final notes
+#Final notes
 Note: On some old terminal emulators and on Windows machines, `CtrlH` should be used
 for backspace.
 

runtime/help/plugins.md

@@ -21,16 +21,6 @@ This is almost always the current view, which you can get with `CurView()` as we
 
 All available actions are listed in the keybindings section of the help.
 
-For callbacks to mouse actions, you are also given the event info:
-
-```lua
-function onMousePress(view, event)
-    local x, y = event:Position()
-
-    return false
-end
-```
-
 These functions should also return a boolean specifying whether the view
 should be relocated to the cursor or not after the action is complete.
 
@@ -166,25 +156,25 @@ See this example to learn how to use `MakeCompletion` and `MakeCommand`
 
 ```lua
 local function StartsWith(String,Start)
-    String = String:upper()
-    Start = Start:upper() 
-    return string.sub(String,1,string.len(Start))==Start
+  String = String:upper()
+  Start = Start:upper() 
+  return string.sub(String,1,string.len(Start))==Start
 end
 
 function complete(input)
-    local allCompletions = {"Hello", "World", "Foo", "Bar"}
-    local result = {}
-
-    for i,v in pairs(allCompletions) do
-        if StartsWith(v, input) then
-            table.insert(result, v)
-        end
-    end
-    return result
+  local allCompletions = {"Hello", "World", "Foo", "Bar"}
+  local result = {}
+   
+  for i,v in pairs(allCompletions) do
+  if StartsWith(v, input) then
+       table.insert(result, v)
+     end
+   end
+   return result
 end
 
 function foo(arg)
-    messenger:Message(arg)
+  messenger:Message(arg)
 end
 
 MakeCommand("foo", "example.foo", MakeCompletion("example.complete"))

runtime/plugins/autoclose/autoclose.lua

@@ -1085,7 +1085,6 @@ function onRune(r, v)
                 -- when converting go structs to lua
                 -- It needs to be dereferenced because the function expects a non pointer struct
                 v.Buf:Insert(-v.Cursor.Loc, charAt(autoclosePairs[i], 2))
-                v:CursorLeft(false)
                 break
             end
         end
@@ -1108,7 +1107,6 @@ function preInsertNewline(v)
                 v:InsertNewline(false)
                 v:InsertTab(false)
                 v.Buf:Insert(-v.Cursor.Loc, "\n" .. ws)
-                v:CursorLeft(false)
                 return false
             end
         end

runtime/plugins/linter/linter.lua

@@ -92,10 +92,6 @@ function split(str, sep)
 end
 
 function basename(file)
-    local sep = "/"
-    if OS == "windows" then
-        sep = "\\"
-    end
-    local name = string.gsub(file, "(.*" .. sep .. ")(.*)", "%2")
+    local name = string.gsub(file, "(.*/)(.*)", "%2")
     return name
 end

runtime/syntax/c.yaml

@@ -10,7 +10,7 @@ rules:
     - type.extended: "\\b(bool)\\b"
     - statement: "\\b(typename|mutable|volatile|register|explicit)\\b"
     - statement: "\\b(for|if|while|do|else|case|default|switch)\\b"
-    - statement: "\\b(try|throw|catch|operator|delete)\\b"
+    - statement: "\\b(try|throw|catch|operator|new|delete)\\b"
     - statement: "\\b(goto|continue|break|return)\\b"
     - preproc: "^[[:space:]]*#[[:space:]]*(define|pragma|include|(un|ifn?)def|endif|el(if|se)|if|warning|error)"
     - constant: "'([^'\\\\]|(\\\\[\"'abfnrtv\\\\]))'"

runtime/syntax/crontab.yaml

@@ -1,36 +0,0 @@
-filetype: crontab
-
-detect:
-    filename: "crontab$"
-    header: "^#.*?/etc/crontab"
-
-rules:
-      #              The time and date fields are:
-      #              field          allowed values
-      #              -----          --------------
-      #              minute         0-59
-      #              hour           0-23
-      #              day of month   0-31
-      #              month          0-12 (or names, see below)
-      #              day of week    0-7 (0 or 7 is Sun, or use names)
-
-    - statement: "^([\\*0-9,\\-\\/]+)\\s+([\\*0-9,\\-\\/]+)\\s+([\\*0-9,\\-\\/]+)\\s+([\\*0-9,\\-\\/]+)\\s+([\\*0-9,\\-\\/]+)\\s+(.*)$\\n?"
-    - constant: "^([\\*0-9,\\-\\/]+)\\s+([\\*0-9,\\-\\/]+)\\s+([\\*0-9,\\-\\/]+)\\s+([\\*0-9,\\-\\/]+)\\s+([\\*0-9,\\-\\/]+)"
-    
-      # Shell Values
-    - type: "^[A-Z]+\\="
-
-      # Months and weekday keywords
-    - type: "jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec"
-    - constant: "sun|mon|tue|wed|thu|fri|sat"
-    - type: "\\@(reboot|yearly|annually|monthly|weekly|daily|midnight|hourly)"
-
-      # Conditionals
-    - special: "(\\{|\\}|\\(|\\)|\\;|\\]|\\[|`|\\\\|\\$|<|>|^|!|=|&|\\|)"
-
-    - comment:
-        start: "#"
-        end: "$"
-        rules:
-            - todo: "(TODO|XXX|FIXME):?"
-

runtime/syntax/twig.yaml

@@ -1,55 +0,0 @@
-filetype: twig
-
-detect:
-    filename: "\\.twig$"
-
-rules:
-    - include: "html"
-    - symbol.tag:
-        start: "\\{\\{[[:space:]]"
-        end: "[[:space:]]\\}\\}"
-        rules:
-            - identifier: "\\b(abs|batch|capitalize|convert|encoding|date(_modify)?|default|escape|first|format|join|json_encode|keys|last|length|lower|merge|nl2br|number_format|raw|replace|reverse|round|slice|sort|split|striptags|title|trim|upper|url_encode)\\b"
-            - identifier.class: "\\b(attribute|block|constant|cycle|date|dump|include|max|min|parent|random|range|source|template_from_string)\\b"
-            - type.keyword: "\\b(and|as|constant|defined|divisibleby|empty|even|false|in|is|iterable|not|null|odd|or|same(as)?|true|with)\\b"
-            - symbol.operator: "[.:;,+*?|=!\\%]|<|>|/|-|&"
-            - symbol.brackets: "[(){}]|\\[|\\]"
-            - constant.number: "\\b[0-9]+\\b|\\b0x[0-9A-Fa-f]+\\b"
-            - constant.string:
-                start: "\""
-                end: "\""
-                skip: "\\\\"
-                rules:
-                    - constant.specialChar: "\\\\."
-            - constant.string:
-                start: "'"
-                end: "'"
-                skip: "\\\\"
-                rules:
-                    - constant.specialChar: "\\\\."
-    - symbol.tag:
-        start: "\\{%[[:space:]]"
-        end: "[[:space:]]%\\}"
-        rules:
-            - identifier: "\\b(abs|batch|capitalize|convert|encoding|date(_modify)?|default|escape|first|format|join|json_encode|keys|last|length|lower|merge|nl2br|number_format|raw|replace|reverse|round|slice|sort|split|striptags|title|trim|upper|url_encode)\\b"
-            - identifier.class: "\\b(attribute|block|constant|cycle|date|dump|include|max|min|parent|random|range|source|template_from_string)\\b"
-            - type.keyword: "\\b(and|as|constant|defined|divisibleby|empty|even|false|in|is|iterable|not|null|odd|or|same(as)?|true|with)\\b"
-            - symbol.operator: "[.:;,+*?|=!\\%]|<|>|/|-|&"
-            - symbol.brackets: "[(){}]|\\[|\\]"
-            - constant.number: "\\b[0-9]+\\b|\\b0x[0-9A-Fa-f]+\\b"
-            - constant.string:
-                start: "\""
-                end: "\""
-                skip: "\\\\"
-                rules:
-                    - constant.specialChar: "\\\\."
-            - constant.string:
-                start: "'"
-                end: "'"
-                skip: "\\\\"
-                rules:
-                   - constant.specialChar: "\\\\."
-    - comment:
-        start: "\\{#"
-        end: "#\\}"
-        rules: []

runtime/syntax/vala.yaml

@@ -4,7 +4,7 @@ detect:
     filename: "\\.vala$"
 
 rules:
-    - type: "\\b(float|double|bool|u?char|u?int(8|16|32|64)?|u?short|u?long|void|s?size_t|unichar)\\b"
+    - type: "\\b(float|double|bool|char|int|uint|short|long|void|(un)?signed)\\b"
     - identifier.class: "[A-Za-z_][A-Za-z0-9_]*[[:space:]]*[()]"
     - statement: "\\b(for|if|while|do|else|case|default|switch|try|throw|catch)\\b"
     - statement: "\\b(inline|typedef|struct|enum|union|extern|static|const)\\b"

snapcraft.yaml

@@ -14,17 +14,5 @@ apps:
 parts:
   micro:
     source: .
-    source-type: git
-    plugin: nil
-    build-packages: [golang-go, make]
-    prepare: |
-      mkdir -p ../go/src/github.com/zyedidia/micro
-      cp -R . ../go/src/github.com/zyedidia/micro
-    build: |
-      export GOPATH=$(pwd)/../go
-      export GOBIN=$(pwd)/../go/bin
-      cd ../go/src/github.com/zyedidia/micro
-      make install
-    install: |
-      mkdir $SNAPCRAFT_PART_INSTALL/bin
-      mv ../go/bin/micro $SNAPCRAFT_PART_INSTALL/bin/
+    plugin: go
+    go-importpath: github.com/zyedidia/micro/cmd/micro

tools/build-version.go

@@ -5,7 +5,7 @@ import (
 	"os/exec"
 	"strings"
 
-	"github.com/zyedidia/micro/tools/semver"
+	"github.com/blang/semver"
 )
 
 func getTag(match ...string) (string, *semver.PRVersion) {

tools/nightly-release.sh

@@ -1,4 +1,5 @@
 # This script creates the nightly release on Github for micro
+# It assumes that the binaries are in the current directory
 # You must have the correct Github access token to run this script
 
 echo "Deleting old release"
@@ -22,10 +23,6 @@ github-release release \
     --description "Autogenerated nightly build of micro" \
     --pre-release
 
-echo "Cross compiling binaries"
-./cross-compile.sh $1
-mv ../binaries .
-
 echo "Uploading OSX binary"
 github-release upload \
     --user zyedidia \

tools/pre-release.sh

@@ -1,4 +1,5 @@
 # This script creates releases on Github for micro
+# It assumes that the binaries are in the current directory
 # You must have the correct Github access token to run this script
 
 # $1 is the title, $2 is the description
@@ -19,10 +20,6 @@ github-release release \
     --description "$2" \
     --pre-release
 
-echo "Cross compiling binaries"
-./cross-compile.sh $1
-mv ../binaries .
-
 echo "Uploading OSX binary"
 github-release upload \
     --user zyedidia \

tools/release.sh

@@ -1,4 +1,5 @@
 # This script creates releases on Github for micro
+# It assumes that the binaries are in the current directory
 # You must have the correct Github access token to run this script
 
 # $1 is the title, $2 is the description
@@ -18,10 +19,6 @@ github-release release \
     --name "$1" \
     --description "$2" \
 
-echo "Cross compiling binaries"
-./cross-compile.sh $1
-mv ../binaries .
-
 echo "Uploading OSX binary"
 github-release upload \
     --user zyedidia \

tools/semver/json.go

@@ -1,23 +0,0 @@
-package semver
-
-import (
-	"encoding/json"
-)
-
-// MarshalJSON implements the encoding/json.Marshaler interface.
-func (v Version) MarshalJSON() ([]byte, error) {
-	return json.Marshal(v.String())
-}
-
-// UnmarshalJSON implements the encoding/json.Unmarshaler interface.
-func (v *Version) UnmarshalJSON(data []byte) (err error) {
-	var versionString string
-
-	if err = json.Unmarshal(data, &versionString); err != nil {
-		return
-	}
-
-	*v, err = Parse(versionString)
-
-	return
-}

tools/semver/range.go

@@ -1,416 +0,0 @@
-package semver
-
-import (
-	"fmt"
-	"strconv"
-	"strings"
-	"unicode"
-)
-
-type wildcardType int
-
-const (
-	noneWildcard  wildcardType = iota
-	majorWildcard wildcardType = 1
-	minorWildcard wildcardType = 2
-	patchWildcard wildcardType = 3
-)
-
-func wildcardTypefromInt(i int) wildcardType {
-	switch i {
-	case 1:
-		return majorWildcard
-	case 2:
-		return minorWildcard
-	case 3:
-		return patchWildcard
-	default:
-		return noneWildcard
-	}
-}
-
-type comparator func(Version, Version) bool
-
-var (
-	compEQ comparator = func(v1 Version, v2 Version) bool {
-		return v1.Compare(v2) == 0
-	}
-	compNE = func(v1 Version, v2 Version) bool {
-		return v1.Compare(v2) != 0
-	}
-	compGT = func(v1 Version, v2 Version) bool {
-		return v1.Compare(v2) == 1
-	}
-	compGE = func(v1 Version, v2 Version) bool {
-		return v1.Compare(v2) >= 0
-	}
-	compLT = func(v1 Version, v2 Version) bool {
-		return v1.Compare(v2) == -1
-	}
-	compLE = func(v1 Version, v2 Version) bool {
-		return v1.Compare(v2) <= 0
-	}
-)
-
-type versionRange struct {
-	v Version
-	c comparator
-}
-
-// rangeFunc creates a Range from the given versionRange.
-func (vr *versionRange) rangeFunc() Range {
-	return Range(func(v Version) bool {
-		return vr.c(v, vr.v)
-	})
-}
-
-// Range represents a range of versions.
-// A Range can be used to check if a Version satisfies it:
-//
-//     range, err := semver.ParseRange(">1.0.0 <2.0.0")
-//     range(semver.MustParse("1.1.1") // returns true
-type Range func(Version) bool
-
-// OR combines the existing Range with another Range using logical OR.
-func (rf Range) OR(f Range) Range {
-	return Range(func(v Version) bool {
-		return rf(v) || f(v)
-	})
-}
-
-// AND combines the existing Range with another Range using logical AND.
-func (rf Range) AND(f Range) Range {
-	return Range(func(v Version) bool {
-		return rf(v) && f(v)
-	})
-}
-
-// ParseRange parses a range and returns a Range.
-// If the range could not be parsed an error is returned.
-//
-// Valid ranges are:
-//   - "<1.0.0"
-//   - "<=1.0.0"
-//   - ">1.0.0"
-//   - ">=1.0.0"
-//   - "1.0.0", "=1.0.0", "==1.0.0"
-//   - "!1.0.0", "!=1.0.0"
-//
-// A Range can consist of multiple ranges separated by space:
-// Ranges can be linked by logical AND:
-//   - ">1.0.0 <2.0.0" would match between both ranges, so "1.1.1" and "1.8.7" but not "1.0.0" or "2.0.0"
-//   - ">1.0.0 <3.0.0 !2.0.3-beta.2" would match every version between 1.0.0 and 3.0.0 except 2.0.3-beta.2
-//
-// Ranges can also be linked by logical OR:
-//   - "<2.0.0 || >=3.0.0" would match "1.x.x" and "3.x.x" but not "2.x.x"
-//
-// AND has a higher precedence than OR. It's not possible to use brackets.
-//
-// Ranges can be combined by both AND and OR
-//
-//  - `>1.0.0 <2.0.0 || >3.0.0 !4.2.1` would match `1.2.3`, `1.9.9`, `3.1.1`, but not `4.2.1`, `2.1.1`
-func ParseRange(s string) (Range, error) {
-	parts := splitAndTrim(s)
-	orParts, err := splitORParts(parts)
-	if err != nil {
-		return nil, err
-	}
-	expandedParts, err := expandWildcardVersion(orParts)
-	if err != nil {
-		return nil, err
-	}
-	var orFn Range
-	for _, p := range expandedParts {
-		var andFn Range
-		for _, ap := range p {
-			opStr, vStr, err := splitComparatorVersion(ap)
-			if err != nil {
-				return nil, err
-			}
-			vr, err := buildVersionRange(opStr, vStr)
-			if err != nil {
-				return nil, fmt.Errorf("Could not parse Range %q: %s", ap, err)
-			}
-			rf := vr.rangeFunc()
-
-			// Set function
-			if andFn == nil {
-				andFn = rf
-			} else { // Combine with existing function
-				andFn = andFn.AND(rf)
-			}
-		}
-		if orFn == nil {
-			orFn = andFn
-		} else {
-			orFn = orFn.OR(andFn)
-		}
-
-	}
-	return orFn, nil
-}
-
-// splitORParts splits the already cleaned parts by '||'.
-// Checks for invalid positions of the operator and returns an
-// error if found.
-func splitORParts(parts []string) ([][]string, error) {
-	var ORparts [][]string
-	last := 0
-	for i, p := range parts {
-		if p == "||" {
-			if i == 0 {
-				return nil, fmt.Errorf("First element in range is '||'")
-			}
-			ORparts = append(ORparts, parts[last:i])
-			last = i + 1
-		}
-	}
-	if last == len(parts) {
-		return nil, fmt.Errorf("Last element in range is '||'")
-	}
-	ORparts = append(ORparts, parts[last:])
-	return ORparts, nil
-}
-
-// buildVersionRange takes a slice of 2: operator and version
-// and builds a versionRange, otherwise an error.
-func buildVersionRange(opStr, vStr string) (*versionRange, error) {
-	c := parseComparator(opStr)
-	if c == nil {
-		return nil, fmt.Errorf("Could not parse comparator %q in %q", opStr, strings.Join([]string{opStr, vStr}, ""))
-	}
-	v, err := Parse(vStr)
-	if err != nil {
-		return nil, fmt.Errorf("Could not parse version %q in %q: %s", vStr, strings.Join([]string{opStr, vStr}, ""), err)
-	}
-
-	return &versionRange{
-		v: v,
-		c: c,
-	}, nil
-
-}
-
-// inArray checks if a byte is contained in an array of bytes
-func inArray(s byte, list []byte) bool {
-	for _, el := range list {
-		if el == s {
-			return true
-		}
-	}
-	return false
-}
-
-// splitAndTrim splits a range string by spaces and cleans whitespaces
-func splitAndTrim(s string) (result []string) {
-	last := 0
-	var lastChar byte
-	excludeFromSplit := []byte{'>', '<', '='}
-	for i := 0; i < len(s); i++ {
-		if s[i] == ' ' && !inArray(lastChar, excludeFromSplit) {
-			if last < i-1 {
-				result = append(result, s[last:i])
-			}
-			last = i + 1
-		} else if s[i] != ' ' {
-			lastChar = s[i]
-		}
-	}
-	if last < len(s)-1 {
-		result = append(result, s[last:])
-	}
-
-	for i, v := range result {
-		result[i] = strings.Replace(v, " ", "", -1)
-	}
-
-	// parts := strings.Split(s, " ")
-	// for _, x := range parts {
-	// 	if s := strings.TrimSpace(x); len(s) != 0 {
-	// 		result = append(result, s)
-	// 	}
-	// }
-	return
-}
-
-// splitComparatorVersion splits the comparator from the version.
-// Input must be free of leading or trailing spaces.
-func splitComparatorVersion(s string) (string, string, error) {
-	i := strings.IndexFunc(s, unicode.IsDigit)
-	if i == -1 {
-		return "", "", fmt.Errorf("Could not get version from string: %q", s)
-	}
-	return strings.TrimSpace(s[0:i]), s[i:], nil
-}
-
-// getWildcardType will return the type of wildcard that the
-// passed version contains
-func getWildcardType(vStr string) wildcardType {
-	parts := strings.Split(vStr, ".")
-	nparts := len(parts)
-	wildcard := parts[nparts-1]
-
-	possibleWildcardType := wildcardTypefromInt(nparts)
-	if wildcard == "x" {
-		return possibleWildcardType
-	}
-
-	return noneWildcard
-}
-
-// createVersionFromWildcard will convert a wildcard version
-// into a regular version, replacing 'x's with '0's, handling
-// special cases like '1.x.x' and '1.x'
-func createVersionFromWildcard(vStr string) string {
-	// handle 1.x.x
-	vStr2 := strings.Replace(vStr, ".x.x", ".x", 1)
-	vStr2 = strings.Replace(vStr2, ".x", ".0", 1)
-	parts := strings.Split(vStr2, ".")
-
-	// handle 1.x
-	if len(parts) == 2 {
-		return vStr2 + ".0"
-	}
-
-	return vStr2
-}
-
-// incrementMajorVersion will increment the major version
-// of the passed version
-func incrementMajorVersion(vStr string) (string, error) {
-	parts := strings.Split(vStr, ".")
-	i, err := strconv.Atoi(parts[0])
-	if err != nil {
-		return "", err
-	}
-	parts[0] = strconv.Itoa(i + 1)
-
-	return strings.Join(parts, "."), nil
-}
-
-// incrementMajorVersion will increment the minor version
-// of the passed version
-func incrementMinorVersion(vStr string) (string, error) {
-	parts := strings.Split(vStr, ".")
-	i, err := strconv.Atoi(parts[1])
-	if err != nil {
-		return "", err
-	}
-	parts[1] = strconv.Itoa(i + 1)
-
-	return strings.Join(parts, "."), nil
-}
-
-// expandWildcardVersion will expand wildcards inside versions
-// following these rules:
-//
-// * when dealing with patch wildcards:
-// >= 1.2.x    will become    >= 1.2.0
-// <= 1.2.x    will become    <  1.3.0
-// >  1.2.x    will become    >= 1.3.0
-// <  1.2.x    will become    <  1.2.0
-// != 1.2.x    will become    <  1.2.0 >= 1.3.0
-//
-// * when dealing with minor wildcards:
-// >= 1.x      will become    >= 1.0.0
-// <= 1.x      will become    <  2.0.0
-// >  1.x      will become    >= 2.0.0
-// <  1.0      will become    <  1.0.0
-// != 1.x      will become    <  1.0.0 >= 2.0.0
-//
-// * when dealing with wildcards without
-// version operator:
-// 1.2.x       will become    >= 1.2.0 < 1.3.0
-// 1.x         will become    >= 1.0.0 < 2.0.0
-func expandWildcardVersion(parts [][]string) ([][]string, error) {
-	var expandedParts [][]string
-	for _, p := range parts {
-		var newParts []string
-		for _, ap := range p {
-			if strings.Index(ap, "x") != -1 {
-				opStr, vStr, err := splitComparatorVersion(ap)
-				if err != nil {
-					return nil, err
-				}
-
-				versionWildcardType := getWildcardType(vStr)
-				flatVersion := createVersionFromWildcard(vStr)
-
-				var resultOperator string
-				var shouldIncrementVersion bool
-				switch opStr {
-				case ">":
-					resultOperator = ">="
-					shouldIncrementVersion = true
-				case ">=":
-					resultOperator = ">="
-				case "<":
-					resultOperator = "<"
-				case "<=":
-					resultOperator = "<"
-					shouldIncrementVersion = true
-				case "", "=", "==":
-					newParts = append(newParts, ">="+flatVersion)
-					resultOperator = "<"
-					shouldIncrementVersion = true
-				case "!=", "!":
-					newParts = append(newParts, "<"+flatVersion)
-					resultOperator = ">="
-					shouldIncrementVersion = true
-				}
-
-				var resultVersion string
-				if shouldIncrementVersion {
-					switch versionWildcardType {
-					case patchWildcard:
-						resultVersion, _ = incrementMinorVersion(flatVersion)
-					case minorWildcard:
-						resultVersion, _ = incrementMajorVersion(flatVersion)
-					}
-				} else {
-					resultVersion = flatVersion
-				}
-
-				ap = resultOperator + resultVersion
-			}
-			newParts = append(newParts, ap)
-		}
-		expandedParts = append(expandedParts, newParts)
-	}
-
-	return expandedParts, nil
-}
-
-func parseComparator(s string) comparator {
-	switch s {
-	case "==":
-		fallthrough
-	case "":
-		fallthrough
-	case "=":
-		return compEQ
-	case ">":
-		return compGT
-	case ">=":
-		return compGE
-	case "<":
-		return compLT
-	case "<=":
-		return compLE
-	case "!":
-		fallthrough
-	case "!=":
-		return compNE
-	}
-
-	return nil
-}
-
-// MustParseRange is like ParseRange but panics if the range cannot be parsed.
-func MustParseRange(s string) Range {
-	r, err := ParseRange(s)
-	if err != nil {
-		panic(`semver: ParseRange(` + s + `): ` + err.Error())
-	}
-	return r
-}

tools/semver/semver.go

@@ -1,418 +0,0 @@
-package semver
-
-import (
-	"errors"
-	"fmt"
-	"strconv"
-	"strings"
-)
-
-const (
-	numbers  string = "0123456789"
-	alphas          = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-"
-	alphanum        = alphas + numbers
-)
-
-// SpecVersion is the latest fully supported spec version of semver
-var SpecVersion = Version{
-	Major: 2,
-	Minor: 0,
-	Patch: 0,
-}
-
-// Version represents a semver compatible version
-type Version struct {
-	Major uint64
-	Minor uint64
-	Patch uint64
-	Pre   []PRVersion
-	Build []string //No Precendence
-}
-
-// Version to string
-func (v Version) String() string {
-	b := make([]byte, 0, 5)
-	b = strconv.AppendUint(b, v.Major, 10)
-	b = append(b, '.')
-	b = strconv.AppendUint(b, v.Minor, 10)
-	b = append(b, '.')
-	b = strconv.AppendUint(b, v.Patch, 10)
-
-	if len(v.Pre) > 0 {
-		b = append(b, '-')
-		b = append(b, v.Pre[0].String()...)
-
-		for _, pre := range v.Pre[1:] {
-			b = append(b, '.')
-			b = append(b, pre.String()...)
-		}
-	}
-
-	if len(v.Build) > 0 {
-		b = append(b, '+')
-		b = append(b, v.Build[0]...)
-
-		for _, build := range v.Build[1:] {
-			b = append(b, '.')
-			b = append(b, build...)
-		}
-	}
-
-	return string(b)
-}
-
-// Equals checks if v is equal to o.
-func (v Version) Equals(o Version) bool {
-	return (v.Compare(o) == 0)
-}
-
-// EQ checks if v is equal to o.
-func (v Version) EQ(o Version) bool {
-	return (v.Compare(o) == 0)
-}
-
-// NE checks if v is not equal to o.
-func (v Version) NE(o Version) bool {
-	return (v.Compare(o) != 0)
-}
-
-// GT checks if v is greater than o.
-func (v Version) GT(o Version) bool {
-	return (v.Compare(o) == 1)
-}
-
-// GTE checks if v is greater than or equal to o.
-func (v Version) GTE(o Version) bool {
-	return (v.Compare(o) >= 0)
-}
-
-// GE checks if v is greater than or equal to o.
-func (v Version) GE(o Version) bool {
-	return (v.Compare(o) >= 0)
-}
-
-// LT checks if v is less than o.
-func (v Version) LT(o Version) bool {
-	return (v.Compare(o) == -1)
-}
-
-// LTE checks if v is less than or equal to o.
-func (v Version) LTE(o Version) bool {
-	return (v.Compare(o) <= 0)
-}
-
-// LE checks if v is less than or equal to o.
-func (v Version) LE(o Version) bool {
-	return (v.Compare(o) <= 0)
-}
-
-// Compare compares Versions v to o:
-// -1 == v is less than o
-// 0 == v is equal to o
-// 1 == v is greater than o
-func (v Version) Compare(o Version) int {
-	if v.Major != o.Major {
-		if v.Major > o.Major {
-			return 1
-		}
-		return -1
-	}
-	if v.Minor != o.Minor {
-		if v.Minor > o.Minor {
-			return 1
-		}
-		return -1
-	}
-	if v.Patch != o.Patch {
-		if v.Patch > o.Patch {
-			return 1
-		}
-		return -1
-	}
-
-	// Quick comparison if a version has no prerelease versions
-	if len(v.Pre) == 0 && len(o.Pre) == 0 {
-		return 0
-	} else if len(v.Pre) == 0 && len(o.Pre) > 0 {
-		return 1
-	} else if len(v.Pre) > 0 && len(o.Pre) == 0 {
-		return -1
-	}
-
-	i := 0
-	for ; i < len(v.Pre) && i < len(o.Pre); i++ {
-		if comp := v.Pre[i].Compare(o.Pre[i]); comp == 0 {
-			continue
-		} else if comp == 1 {
-			return 1
-		} else {
-			return -1
-		}
-	}
-
-	// If all pr versions are the equal but one has further prversion, this one greater
-	if i == len(v.Pre) && i == len(o.Pre) {
-		return 0
-	} else if i == len(v.Pre) && i < len(o.Pre) {
-		return -1
-	} else {
-		return 1
-	}
-
-}
-
-// Validate validates v and returns error in case
-func (v Version) Validate() error {
-	// Major, Minor, Patch already validated using uint64
-
-	for _, pre := range v.Pre {
-		if !pre.IsNum { //Numeric prerelease versions already uint64
-			if len(pre.VersionStr) == 0 {
-				return fmt.Errorf("Prerelease can not be empty %q", pre.VersionStr)
-			}
-			if !containsOnly(pre.VersionStr, alphanum) {
-				return fmt.Errorf("Invalid character(s) found in prerelease %q", pre.VersionStr)
-			}
-		}
-	}
-
-	for _, build := range v.Build {
-		if len(build) == 0 {
-			return fmt.Errorf("Build meta data can not be empty %q", build)
-		}
-		if !containsOnly(build, alphanum) {
-			return fmt.Errorf("Invalid character(s) found in build meta data %q", build)
-		}
-	}
-
-	return nil
-}
-
-// New is an alias for Parse and returns a pointer, parses version string and returns a validated Version or error
-func New(s string) (vp *Version, err error) {
-	v, err := Parse(s)
-	vp = &v
-	return
-}
-
-// Make is an alias for Parse, parses version string and returns a validated Version or error
-func Make(s string) (Version, error) {
-	return Parse(s)
-}
-
-// ParseTolerant allows for certain version specifications that do not strictly adhere to semver
-// specs to be parsed by this library. It does so by normalizing versions before passing them to
-// Parse(). It currently trims spaces, removes a "v" prefix, and adds a 0 patch number to versions
-// with only major and minor components specified
-func ParseTolerant(s string) (Version, error) {
-	s = strings.TrimSpace(s)
-	s = strings.TrimPrefix(s, "v")
-
-	// Split into major.minor.(patch+pr+meta)
-	parts := strings.SplitN(s, ".", 3)
-	if len(parts) < 3 {
-		if strings.ContainsAny(parts[len(parts)-1], "+-") {
-			return Version{}, errors.New("Short version cannot contain PreRelease/Build meta data")
-		}
-		for len(parts) < 3 {
-			parts = append(parts, "0")
-		}
-		s = strings.Join(parts, ".")
-	}
-
-	return Parse(s)
-}
-
-// Parse parses version string and returns a validated Version or error
-func Parse(s string) (Version, error) {
-	if len(s) == 0 {
-		return Version{}, errors.New("Version string empty")
-	}
-
-	// Split into major.minor.(patch+pr+meta)
-	parts := strings.SplitN(s, ".", 3)
-	if len(parts) != 3 {
-		return Version{}, errors.New("No Major.Minor.Patch elements found")
-	}
-
-	// Major
-	if !containsOnly(parts[0], numbers) {
-		return Version{}, fmt.Errorf("Invalid character(s) found in major number %q", parts[0])
-	}
-	if hasLeadingZeroes(parts[0]) {
-		return Version{}, fmt.Errorf("Major number must not contain leading zeroes %q", parts[0])
-	}
-	major, err := strconv.ParseUint(parts[0], 10, 64)
-	if err != nil {
-		return Version{}, err
-	}
-
-	// Minor
-	if !containsOnly(parts[1], numbers) {
-		return Version{}, fmt.Errorf("Invalid character(s) found in minor number %q", parts[1])
-	}
-	if hasLeadingZeroes(parts[1]) {
-		return Version{}, fmt.Errorf("Minor number must not contain leading zeroes %q", parts[1])
-	}
-	minor, err := strconv.ParseUint(parts[1], 10, 64)
-	if err != nil {
-		return Version{}, err
-	}
-
-	v := Version{}
-	v.Major = major
-	v.Minor = minor
-
-	var build, prerelease []string
-	patchStr := parts[2]
-
-	if buildIndex := strings.IndexRune(patchStr, '+'); buildIndex != -1 {
-		build = strings.Split(patchStr[buildIndex+1:], ".")
-		patchStr = patchStr[:buildIndex]
-	}
-
-	if preIndex := strings.IndexRune(patchStr, '-'); preIndex != -1 {
-		prerelease = strings.Split(patchStr[preIndex+1:], ".")
-		patchStr = patchStr[:preIndex]
-	}
-
-	if !containsOnly(patchStr, numbers) {
-		return Version{}, fmt.Errorf("Invalid character(s) found in patch number %q", patchStr)
-	}
-	if hasLeadingZeroes(patchStr) {
-		return Version{}, fmt.Errorf("Patch number must not contain leading zeroes %q", patchStr)
-	}
-	patch, err := strconv.ParseUint(patchStr, 10, 64)
-	if err != nil {
-		return Version{}, err
-	}
-
-	v.Patch = patch
-
-	// Prerelease
-	for _, prstr := range prerelease {
-		parsedPR, err := NewPRVersion(prstr)
-		if err != nil {
-			return Version{}, err
-		}
-		v.Pre = append(v.Pre, parsedPR)
-	}
-
-	// Build meta data
-	for _, str := range build {
-		if len(str) == 0 {
-			return Version{}, errors.New("Build meta data is empty")
-		}
-		if !containsOnly(str, alphanum) {
-			return Version{}, fmt.Errorf("Invalid character(s) found in build meta data %q", str)
-		}
-		v.Build = append(v.Build, str)
-	}
-
-	return v, nil
-}
-
-// MustParse is like Parse but panics if the version cannot be parsed.
-func MustParse(s string) Version {
-	v, err := Parse(s)
-	if err != nil {
-		panic(`semver: Parse(` + s + `): ` + err.Error())
-	}
-	return v
-}
-
-// PRVersion represents a PreRelease Version
-type PRVersion struct {
-	VersionStr string
-	VersionNum uint64
-	IsNum      bool
-}
-
-// NewPRVersion creates a new valid prerelease version
-func NewPRVersion(s string) (PRVersion, error) {
-	if len(s) == 0 {
-		return PRVersion{}, errors.New("Prerelease is empty")
-	}
-	v := PRVersion{}
-	if containsOnly(s, numbers) {
-		if hasLeadingZeroes(s) {
-			return PRVersion{}, fmt.Errorf("Numeric PreRelease version must not contain leading zeroes %q", s)
-		}
-		num, err := strconv.ParseUint(s, 10, 64)
-
-		// Might never be hit, but just in case
-		if err != nil {
-			return PRVersion{}, err
-		}
-		v.VersionNum = num
-		v.IsNum = true
-	} else if containsOnly(s, alphanum) {
-		v.VersionStr = s
-		v.IsNum = false
-	} else {
-		return PRVersion{}, fmt.Errorf("Invalid character(s) found in prerelease %q", s)
-	}
-	return v, nil
-}
-
-// IsNumeric checks if prerelease-version is numeric
-func (v PRVersion) IsNumeric() bool {
-	return v.IsNum
-}
-
-// Compare compares two PreRelease Versions v and o:
-// -1 == v is less than o
-// 0 == v is equal to o
-// 1 == v is greater than o
-func (v PRVersion) Compare(o PRVersion) int {
-	if v.IsNum && !o.IsNum {
-		return -1
-	} else if !v.IsNum && o.IsNum {
-		return 1
-	} else if v.IsNum && o.IsNum {
-		if v.VersionNum == o.VersionNum {
-			return 0
-		} else if v.VersionNum > o.VersionNum {
-			return 1
-		} else {
-			return -1
-		}
-	} else { // both are Alphas
-		if v.VersionStr == o.VersionStr {
-			return 0
-		} else if v.VersionStr > o.VersionStr {
-			return 1
-		} else {
-			return -1
-		}
-	}
-}
-
-// PreRelease version to string
-func (v PRVersion) String() string {
-	if v.IsNum {
-		return strconv.FormatUint(v.VersionNum, 10)
-	}
-	return v.VersionStr
-}
-
-func containsOnly(s string, set string) bool {
-	return strings.IndexFunc(s, func(r rune) bool {
-		return !strings.ContainsRune(set, r)
-	}) == -1
-}
-
-func hasLeadingZeroes(s string) bool {
-	return len(s) > 1 && s[0] == '0'
-}
-
-// NewBuildVersion creates a new valid build version
-func NewBuildVersion(s string) (string, error) {
-	if len(s) == 0 {
-		return "", errors.New("Buildversion is empty")
-	}
-	if !containsOnly(s, alphanum) {
-		return "", fmt.Errorf("Invalid character(s) found in build meta data %q", s)
-	}
-	return s, nil
-}

tools/semver/sort.go

@@ -1,28 +0,0 @@
-package semver
-
-import (
-	"sort"
-)
-
-// Versions represents multiple versions.
-type Versions []Version
-
-// Len returns length of version collection
-func (s Versions) Len() int {
-	return len(s)
-}
-
-// Swap swaps two versions inside the collection by its indices
-func (s Versions) Swap(i, j int) {
-	s[i], s[j] = s[j], s[i]
-}
-
-// Less checks if version at index i is less than version at index j
-func (s Versions) Less(i, j int) bool {
-	return s[i].LT(s[j])
-}
-
-// Sort sorts a slice of versions
-func Sort(versions []Version) {
-	sort.Sort(Versions(versions))
-}

tools/semver/sql.go

@@ -1,30 +0,0 @@
-package semver
-
-import (
-	"database/sql/driver"
-	"fmt"
-)
-
-// Scan implements the database/sql.Scanner interface.
-func (v *Version) Scan(src interface{}) (err error) {
-	var str string
-	switch src := src.(type) {
-	case string:
-		str = src
-	case []byte:
-		str = string(src)
-	default:
-		return fmt.Errorf("Version.Scan: cannot convert %T to string.", src)
-	}
-
-	if t, err := Parse(str); err == nil {
-		*v = t
-	}
-
-	return
-}
-
-// Value implements the database/sql/driver.Valuer interface.
-func (v Version) Value() (driver.Value, error) {
-	return v.String(), nil
-}

tools/vendor-src.sh

@@ -1,6 +1,14 @@
-cd ../..
+cd ../cmd/micro
+
+govendor init
+govendor add +e
+
+cd ../../..
 
 tar czf "$1".tar.gz micro
 zip -rq "$1".zip micro
 mv "$1".tar.gz micro
 mv "$1".zip micro
+
+cd micro/cmd/micro
+rm -rf vendor