Update runtime

Merge
Use StartCol in colorcolumn calculation
2026-04-03 00:19:50 +09:00 · 2020-04-10 17:27:57 -04:00 · 2020-04-10 17:27:34 -04:00 · 2020-04-10 17:27:11 -04:00 · 2020-04-10 17:21:02 -04:00 · 2020-04-10 15:58:43 -04:00
31 changed files with 1073 additions and 595 deletions
--- a/README.md
+++ b/README.md
@@ -91,7 +91,7 @@ Running `micro -version` will give you the version information.

 There is a script which can install micro for you by downloading the latest prebuilt binary. You can find it at <https://getmic.ro>.

-Then you can easily install micro:
+You can easily install micro by running

 ```bash
 curl https://getmic.ro | bash
@@ -128,6 +128,8 @@ for other operating systems:
    * `scoop install micro`
 * OpenBSD: Available in the ports tree and also available as a binary package
    * `pkd_add -v micro`
+* Arch Linux, CRUX, Termux for Android
+    * See details in the [wiki page](https://github.com/zyedidia/micro/wiki/Installing-Micro)

 ### Building from source

--- a/cmd/micro/micro.go
+++ b/cmd/micro/micro.go
@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"io/ioutil"
 	"os"
+	"regexp"
 	"runtime"
 	"sort"
 	"time"
@@ -44,6 +45,7 @@ func InitFlags() {
 		fmt.Println("-config-dir dir")
 		fmt.Println("    \tSpecify a custom location for the configuration directory")
 		fmt.Println("[FILE]:LINE:COL")
+		fmt.Println("+LINE:COL")
 		fmt.Println("    \tSpecify a line and column to start the cursor at when opening a buffer")
 		fmt.Println("-options")
 		fmt.Println("    \tShow all option help")
@@ -147,11 +149,32 @@ func LoadInput() []*buffer.Buffer {
 	args := flag.Args()
 	buffers := make([]*buffer.Buffer, 0, len(args))

-	if len(args) > 0 {
+	btype := buffer.BTDefault
+	if !isatty.IsTerminal(os.Stdout.Fd()) {
+		btype = buffer.BTStdout
+	}
+
+	files := make([]string, 0, len(args))
+	flagStartPos := ""
+	flagr := regexp.MustCompile(`^\+\d+(:\d+)?$`)
+	for _, a := range args {
+		if flagr.MatchString(a) {
+			flagStartPos = a[1:]
+		} else {
+			if flagStartPos != "" {
+				files = append(files, a+":"+flagStartPos)
+				flagStartPos = ""
+			} else {
+				files = append(files, a)
+			}
+		}
+	}
+
+	if len(files) > 0 {
 		// Option 1
 		// We go through each file and load it
-		for i := 0; i < len(args); i++ {
-			buf, err := buffer.NewBufferFromFile(args[i], buffer.BTDefault)
+		for i := 0; i < len(files); i++ {
+			buf, err := buffer.NewBufferFromFile(files[i], btype)
 			if err != nil {
 				screen.TermMessage(err)
 				continue
@@ -168,17 +191,22 @@ func LoadInput() []*buffer.Buffer {
 			screen.TermMessage("Error reading from stdin: ", err)
 			input = []byte{}
 		}
-		buffers = append(buffers, buffer.NewBufferFromString(string(input), filename, buffer.BTDefault))
+		buffers = append(buffers, buffer.NewBufferFromString(string(input), filename, btype))
 	} else {
 		// Option 3, just open an empty buffer
-		buffers = append(buffers, buffer.NewBufferFromString(string(input), filename, buffer.BTDefault))
+		buffers = append(buffers, buffer.NewBufferFromString(string(input), filename, btype))
 	}

 	return buffers
 }

 func main() {
-	defer os.Exit(0)
+	defer func() {
+		if util.Stdout.Len() > 0 {
+			fmt.Fprint(os.Stdout, util.Stdout.String())
+		}
+		os.Exit(0)
+	}()

 	// runtime.SetCPUProfileRate(400)
 	// f, _ := os.Create("micro.prof")
--- a/internal/action/actions.go
+++ b/internal/action/actions.go
@@ -291,6 +291,19 @@ func (h *BufPane) StartOfText() bool {
 	return true
 }

+// StartOfTextToggle toggles the cursor between the start of the text of the line
+// and the start of the line
+func (h *BufPane) StartOfTextToggle() bool {
+	h.Cursor.Deselect(true)
+	if h.Cursor.IsStartOfText() {
+		h.Cursor.Start()
+	} else {
+		h.Cursor.StartOfText()
+	}
+	h.Relocate()
+	return true
+}
+
 // StartOfLine moves the cursor to the start of the line
 func (h *BufPane) StartOfLine() bool {
 	h.Cursor.Deselect(true)
@@ -325,6 +338,23 @@ func (h *BufPane) SelectToStartOfText() bool {
 	return true
 }

+// SelectToStartOfTextToggle toggles the selection between the start of the text
+// on the current line and the start of the line
+func (h *BufPane) SelectToStartOfTextToggle() bool {
+	if !h.Cursor.HasSelection() {
+		h.Cursor.OrigSelection[0] = h.Cursor.Loc
+	}
+	if h.Cursor.IsStartOfText() {
+		h.Cursor.Start()
+	} else {
+		h.Cursor.StartOfText()
+	}
+	h.Cursor.SelectTo(h.Cursor.Loc)
+	h.Relocate()
+	return true
+}
+
+
 // SelectToStartOfLine selects to the start of the current line
 func (h *BufPane) SelectToStartOfLine() bool {
 	if !h.Cursor.HasSelection() {
@@ -774,7 +804,7 @@ func (h *BufPane) saveBufToFile(filename string, action string, callback func())
 // Find opens a prompt and searches forward for the input
 func (h *BufPane) Find() bool {
 	h.searchOrig = h.Cursor.Loc
-	InfoBar.Prompt("Find: ", "", "Find", func(resp string) {
+	InfoBar.Prompt("Find (regex): ", "", "Find", func(resp string) {
 		// Event callback
 		match, found, _ := h.Buf.FindNext(resp, h.Buf.Start(), h.Buf.End(), h.searchOrig, true, true)
 		if found {
@@ -1120,6 +1150,16 @@ func (h *BufPane) OpenFile() bool {
 	return true
 }

+// OpenFile opens a new file in the buffer
+func (h *BufPane) JumpLine() bool {
+	InfoBar.Prompt("> ", "goto ", "Command", nil, func(resp string, canceled bool) {
+		if !canceled {
+			h.HandleCommand(resp)
+		}
+	})
+	return true
+}
+
 // Start moves the viewport to the start of the buffer
 func (h *BufPane) Start() bool {
 	v := h.GetView()
--- a/internal/action/bufpane.go
+++ b/internal/action/bufpane.go
@@ -343,10 +343,11 @@ func (h *BufPane) HandleEvent(event tcell.Event) {
 				// release the mouse

 				// if !h.doubleClick && !h.tripleClick {
-				// 	h.Cursor.Loc = mouseLoc
 				// 	h.Cursor.SetSelectionEnd(h.Cursor.Loc)
-				// 	h.Cursor.CopySelection("primary")
 				// }
+				if h.Cursor.HasSelection() {
+					h.Cursor.CopySelection("primary")
+				}
 				h.mouseReleased = true
 			}
 		}
@@ -516,109 +517,112 @@ func (h *BufPane) SetActive(b bool) {

 // BufKeyActions contains the list of all possible key actions the bufhandler could execute
 var BufKeyActions = map[string]BufKeyAction{
-	"CursorUp":               (*BufPane).CursorUp,
-	"CursorDown":             (*BufPane).CursorDown,
-	"CursorPageUp":           (*BufPane).CursorPageUp,
-	"CursorPageDown":         (*BufPane).CursorPageDown,
-	"CursorLeft":             (*BufPane).CursorLeft,
-	"CursorRight":            (*BufPane).CursorRight,
-	"CursorStart":            (*BufPane).CursorStart,
-	"CursorEnd":              (*BufPane).CursorEnd,
-	"SelectToStart":          (*BufPane).SelectToStart,
-	"SelectToEnd":            (*BufPane).SelectToEnd,
-	"SelectUp":               (*BufPane).SelectUp,
-	"SelectDown":             (*BufPane).SelectDown,
-	"SelectLeft":             (*BufPane).SelectLeft,
-	"SelectRight":            (*BufPane).SelectRight,
-	"WordRight":              (*BufPane).WordRight,
-	"WordLeft":               (*BufPane).WordLeft,
-	"SelectWordRight":        (*BufPane).SelectWordRight,
-	"SelectWordLeft":         (*BufPane).SelectWordLeft,
-	"DeleteWordRight":        (*BufPane).DeleteWordRight,
-	"DeleteWordLeft":         (*BufPane).DeleteWordLeft,
-	"SelectLine":             (*BufPane).SelectLine,
-	"SelectToStartOfLine":    (*BufPane).SelectToStartOfLine,
-	"SelectToStartOfText":    (*BufPane).SelectToStartOfText,
-	"SelectToEndOfLine":      (*BufPane).SelectToEndOfLine,
-	"ParagraphPrevious":      (*BufPane).ParagraphPrevious,
-	"ParagraphNext":          (*BufPane).ParagraphNext,
-	"InsertNewline":          (*BufPane).InsertNewline,
-	"Backspace":              (*BufPane).Backspace,
-	"Delete":                 (*BufPane).Delete,
-	"InsertTab":              (*BufPane).InsertTab,
-	"Save":                   (*BufPane).Save,
-	"SaveAll":                (*BufPane).SaveAll,
-	"SaveAs":                 (*BufPane).SaveAs,
-	"Find":                   (*BufPane).Find,
-	"FindNext":               (*BufPane).FindNext,
-	"FindPrevious":           (*BufPane).FindPrevious,
-	"Center":                 (*BufPane).Center,
-	"Undo":                   (*BufPane).Undo,
-	"Redo":                   (*BufPane).Redo,
-	"Copy":                   (*BufPane).Copy,
-	"Cut":                    (*BufPane).Cut,
-	"CutLine":                (*BufPane).CutLine,
-	"DuplicateLine":          (*BufPane).DuplicateLine,
-	"DeleteLine":             (*BufPane).DeleteLine,
-	"MoveLinesUp":            (*BufPane).MoveLinesUp,
-	"MoveLinesDown":          (*BufPane).MoveLinesDown,
-	"IndentSelection":        (*BufPane).IndentSelection,
-	"OutdentSelection":       (*BufPane).OutdentSelection,
-	"Autocomplete":           (*BufPane).Autocomplete,
-	"CycleAutocompleteBack":  (*BufPane).CycleAutocompleteBack,
-	"OutdentLine":            (*BufPane).OutdentLine,
-	"IndentLine":             (*BufPane).IndentLine,
-	"Paste":                  (*BufPane).Paste,
-	"PastePrimary":           (*BufPane).PastePrimary,
-	"SelectAll":              (*BufPane).SelectAll,
-	"OpenFile":               (*BufPane).OpenFile,
-	"Start":                  (*BufPane).Start,
-	"End":                    (*BufPane).End,
-	"PageUp":                 (*BufPane).PageUp,
-	"PageDown":               (*BufPane).PageDown,
-	"SelectPageUp":           (*BufPane).SelectPageUp,
-	"SelectPageDown":         (*BufPane).SelectPageDown,
-	"HalfPageUp":             (*BufPane).HalfPageUp,
-	"HalfPageDown":           (*BufPane).HalfPageDown,
-	"StartOfText":            (*BufPane).StartOfText,
-	"StartOfLine":            (*BufPane).StartOfLine,
-	"EndOfLine":              (*BufPane).EndOfLine,
-	"ToggleHelp":             (*BufPane).ToggleHelp,
-	"ToggleKeyMenu":          (*BufPane).ToggleKeyMenu,
-	"ToggleDiffGutter":       (*BufPane).ToggleDiffGutter,
-	"ToggleRuler":            (*BufPane).ToggleRuler,
-	"ClearStatus":            (*BufPane).ClearStatus,
-	"ShellMode":              (*BufPane).ShellMode,
-	"CommandMode":            (*BufPane).CommandMode,
-	"ToggleOverwriteMode":    (*BufPane).ToggleOverwriteMode,
-	"Escape":                 (*BufPane).Escape,
-	"Quit":                   (*BufPane).Quit,
-	"QuitAll":                (*BufPane).QuitAll,
-	"AddTab":                 (*BufPane).AddTab,
-	"PreviousTab":            (*BufPane).PreviousTab,
-	"NextTab":                (*BufPane).NextTab,
-	"NextSplit":              (*BufPane).NextSplit,
-	"PreviousSplit":          (*BufPane).PreviousSplit,
-	"Unsplit":                (*BufPane).Unsplit,
-	"VSplit":                 (*BufPane).VSplitAction,
-	"HSplit":                 (*BufPane).HSplitAction,
-	"ToggleMacro":            (*BufPane).ToggleMacro,
-	"PlayMacro":              (*BufPane).PlayMacro,
-	"Suspend":                (*BufPane).Suspend,
-	"ScrollUp":               (*BufPane).ScrollUpAction,
-	"ScrollDown":             (*BufPane).ScrollDownAction,
-	"SpawnMultiCursor":       (*BufPane).SpawnMultiCursor,
-	"SpawnMultiCursorUp":     (*BufPane).SpawnMultiCursorUp,
-	"SpawnMultiCursorDown":   (*BufPane).SpawnMultiCursorDown,
-	"SpawnMultiCursorSelect": (*BufPane).SpawnMultiCursorSelect,
-	"RemoveMultiCursor":      (*BufPane).RemoveMultiCursor,
-	"RemoveAllMultiCursors":  (*BufPane).RemoveAllMultiCursors,
-	"SkipMultiCursor":        (*BufPane).SkipMultiCursor,
-	"JumpToMatchingBrace":    (*BufPane).JumpToMatchingBrace,
-	"None":                   (*BufPane).None,
+	"CursorUp":                 (*BufPane).CursorUp,
+	"CursorDown":               (*BufPane).CursorDown,
+	"CursorPageUp":             (*BufPane).CursorPageUp,
+	"CursorPageDown":           (*BufPane).CursorPageDown,
+	"CursorLeft":               (*BufPane).CursorLeft,
+	"CursorRight":              (*BufPane).CursorRight,
+	"CursorStart":              (*BufPane).CursorStart,
+	"CursorEnd":                (*BufPane).CursorEnd,
+	"SelectToStart":            (*BufPane).SelectToStart,
+	"SelectToEnd":              (*BufPane).SelectToEnd,
+	"SelectUp":                 (*BufPane).SelectUp,
+	"SelectDown":               (*BufPane).SelectDown,
+	"SelectLeft":               (*BufPane).SelectLeft,
+	"SelectRight":              (*BufPane).SelectRight,
+	"WordRight":                (*BufPane).WordRight,
+	"WordLeft":                 (*BufPane).WordLeft,
+	"SelectWordRight":          (*BufPane).SelectWordRight,
+	"SelectWordLeft":           (*BufPane).SelectWordLeft,
+	"DeleteWordRight":          (*BufPane).DeleteWordRight,
+	"DeleteWordLeft":           (*BufPane).DeleteWordLeft,
+	"SelectLine":               (*BufPane).SelectLine,
+	"SelectToStartOfLine":      (*BufPane).SelectToStartOfLine,
+	"SelectToStartOfText":      (*BufPane).SelectToStartOfText,
+	"SelectToStartOfTextToggle":(*BufPane).SelectToStartOfTextToggle,
+	"SelectToEndOfLine":        (*BufPane).SelectToEndOfLine,
+	"ParagraphPrevious":        (*BufPane).ParagraphPrevious,
+	"ParagraphNext":            (*BufPane).ParagraphNext,
+	"InsertNewline":            (*BufPane).InsertNewline,
+	"Backspace":                (*BufPane).Backspace,
+	"Delete":                   (*BufPane).Delete,
+	"InsertTab":                (*BufPane).InsertTab,
+	"Save":                     (*BufPane).Save,
+	"SaveAll":                  (*BufPane).SaveAll,
+	"SaveAs":                   (*BufPane).SaveAs,
+	"Find":                     (*BufPane).Find,
+	"FindNext":                 (*BufPane).FindNext,
+	"FindPrevious":             (*BufPane).FindPrevious,
+	"Center":                   (*BufPane).Center,
+	"Undo":                     (*BufPane).Undo,
+	"Redo":                     (*BufPane).Redo,
+	"Copy":                     (*BufPane).Copy,
+	"Cut":                      (*BufPane).Cut,
+	"CutLine":                  (*BufPane).CutLine,
+	"DuplicateLine":            (*BufPane).DuplicateLine,
+	"DeleteLine":               (*BufPane).DeleteLine,
+	"MoveLinesUp":              (*BufPane).MoveLinesUp,
+	"MoveLinesDown":            (*BufPane).MoveLinesDown,
+	"IndentSelection":          (*BufPane).IndentSelection,
+	"OutdentSelection":         (*BufPane).OutdentSelection,
+	"Autocomplete":             (*BufPane).Autocomplete,
+	"CycleAutocompleteBack":    (*BufPane).CycleAutocompleteBack,
+	"OutdentLine":              (*BufPane).OutdentLine,
+	"IndentLine":               (*BufPane).IndentLine,
+	"Paste":                    (*BufPane).Paste,
+	"PastePrimary":             (*BufPane).PastePrimary,
+	"SelectAll":                (*BufPane).SelectAll,
+	"OpenFile":                 (*BufPane).OpenFile,
+	"Start":                    (*BufPane).Start,
+	"End":                      (*BufPane).End,
+	"PageUp":                   (*BufPane).PageUp,
+	"PageDown":                 (*BufPane).PageDown,
+	"SelectPageUp":             (*BufPane).SelectPageUp,
+	"SelectPageDown":           (*BufPane).SelectPageDown,
+	"HalfPageUp":               (*BufPane).HalfPageUp,
+	"HalfPageDown":             (*BufPane).HalfPageDown,
+	"StartOfText":              (*BufPane).StartOfText,
+	"StartOfTextToggle":        (*BufPane).StartOfTextToggle,
+	"StartOfLine":              (*BufPane).StartOfLine,
+	"EndOfLine":                (*BufPane).EndOfLine,
+	"ToggleHelp":               (*BufPane).ToggleHelp,
+	"ToggleKeyMenu":            (*BufPane).ToggleKeyMenu,
+	"ToggleDiffGutter":         (*BufPane).ToggleDiffGutter,
+	"ToggleRuler":              (*BufPane).ToggleRuler,
+	"ClearStatus":              (*BufPane).ClearStatus,
+	"ShellMode":                (*BufPane).ShellMode,
+	"CommandMode":              (*BufPane).CommandMode,
+	"ToggleOverwriteMode":      (*BufPane).ToggleOverwriteMode,
+	"Escape":                   (*BufPane).Escape,
+	"Quit":                     (*BufPane).Quit,
+	"QuitAll":                  (*BufPane).QuitAll,
+	"AddTab":                   (*BufPane).AddTab,
+	"PreviousTab":              (*BufPane).PreviousTab,
+	"NextTab":                  (*BufPane).NextTab,
+	"NextSplit":                (*BufPane).NextSplit,
+	"PreviousSplit":            (*BufPane).PreviousSplit,
+	"Unsplit":                  (*BufPane).Unsplit,
+	"VSplit":                   (*BufPane).VSplitAction,
+	"HSplit":                   (*BufPane).HSplitAction,
+	"ToggleMacro":              (*BufPane).ToggleMacro,
+	"PlayMacro":                (*BufPane).PlayMacro,
+	"Suspend":                  (*BufPane).Suspend,
+	"ScrollUp":                 (*BufPane).ScrollUpAction,
+	"ScrollDown":               (*BufPane).ScrollDownAction,
+	"SpawnMultiCursor":         (*BufPane).SpawnMultiCursor,
+	"SpawnMultiCursorUp":       (*BufPane).SpawnMultiCursorUp,
+	"SpawnMultiCursorDown":     (*BufPane).SpawnMultiCursorDown,
+	"SpawnMultiCursorSelect":   (*BufPane).SpawnMultiCursorSelect,
+	"RemoveMultiCursor":        (*BufPane).RemoveMultiCursor,
+	"RemoveAllMultiCursors":    (*BufPane).RemoveAllMultiCursors,
+	"SkipMultiCursor":          (*BufPane).SkipMultiCursor,
+	"JumpToMatchingBrace":      (*BufPane).JumpToMatchingBrace,
+	"JumpLine":                 (*BufPane).JumpLine,
+	"None":                     (*BufPane).None,

 	// This was changed to InsertNewline but I don't want to break backwards compatibility
-	"InsertEnter": (*BufPane).InsertNewline,
+	"InsertEnter":              (*BufPane).InsertNewline,
 }

 // BufMouseActions contains the list of all possible mouse actions the bufhandler could execute
@@ -632,54 +636,56 @@ var BufMouseActions = map[string]BufMouseAction{
 // Generally actions that modify global editor state like quitting or
 // saving should not be included in this list
 var MultiActions = map[string]bool{
-	"CursorUp":            true,
-	"CursorDown":          true,
-	"CursorPageUp":        true,
-	"CursorPageDown":      true,
-	"CursorLeft":          true,
-	"CursorRight":         true,
-	"CursorStart":         true,
-	"CursorEnd":           true,
-	"SelectToStart":       true,
-	"SelectToEnd":         true,
-	"SelectUp":            true,
-	"SelectDown":          true,
-	"SelectLeft":          true,
-	"SelectRight":         true,
-	"WordRight":           true,
-	"WordLeft":            true,
-	"SelectWordRight":     true,
-	"SelectWordLeft":      true,
-	"DeleteWordRight":     true,
-	"DeleteWordLeft":      true,
-	"SelectLine":          true,
-	"SelectToStartOfLine": true,
-	"SelectToStartOfText": true,
-	"SelectToEndOfLine":   true,
-	"ParagraphPrevious":   true,
-	"ParagraphNext":       true,
-	"InsertNewline":       true,
-	"Backspace":           true,
-	"Delete":              true,
-	"InsertTab":           true,
-	"FindNext":            true,
-	"FindPrevious":        true,
-	"Cut":                 true,
-	"CutLine":             true,
-	"DuplicateLine":       true,
-	"DeleteLine":          true,
-	"MoveLinesUp":         true,
-	"MoveLinesDown":       true,
-	"IndentSelection":     true,
-	"OutdentSelection":    true,
-	"OutdentLine":         true,
-	"IndentLine":          true,
-	"Paste":               true,
-	"PastePrimary":        true,
-	"SelectPageUp":        true,
-	"SelectPageDown":      true,
-	"StartOfLine":         true,
-	"StartOfText":         true,
-	"EndOfLine":           true,
-	"JumpToMatchingBrace": true,
+	"CursorUp":                  true,
+	"CursorDown":                true,
+	"CursorPageUp":              true,
+	"CursorPageDown":            true,
+	"CursorLeft":                true,
+	"CursorRight":               true,
+	"CursorStart":               true,
+	"CursorEnd":                 true,
+	"SelectToStart":             true,
+	"SelectToEnd":               true,
+	"SelectUp":                  true,
+	"SelectDown":                true,
+	"SelectLeft":                true,
+	"SelectRight":               true,
+	"WordRight":                 true,
+	"WordLeft":                  true,
+	"SelectWordRight":           true,
+	"SelectWordLeft":            true,
+	"DeleteWordRight":           true,
+	"DeleteWordLeft":            true,
+	"SelectLine":                true,
+	"SelectToStartOfLine":       true,
+	"SelectToStartOfText":       true,
+	"SelectToStartOfTextToggle": true,
+	"SelectToEndOfLine":         true,
+	"ParagraphPrevious":         true,
+	"ParagraphNext":             true,
+	"InsertNewline":             true,
+	"Backspace":                 true,
+	"Delete":                    true,
+	"InsertTab":                 true,
+	"FindNext":                  true,
+	"FindPrevious":              true,
+	"Cut":                       true,
+	"CutLine":                   true,
+	"DuplicateLine":             true,
+	"DeleteLine":                true,
+	"MoveLinesUp":               true,
+	"MoveLinesDown":             true,
+	"IndentSelection":           true,
+	"OutdentSelection":          true,
+	"OutdentLine":               true,
+	"IndentLine":                true,
+	"Paste":                     true,
+	"PastePrimary":              true,
+	"SelectPageUp":              true,
+	"SelectPageDown":            true,
+	"StartOfLine":               true,
+	"StartOfText":               true,
+	"StartOfTextToggle":         true,
+	"EndOfLine":                 true,
+	"JumpToMatchingBrace":       true,
 }
--- a/internal/action/command.go
+++ b/internal/action/command.go
@@ -733,7 +733,8 @@ func (h *BufPane) ReplaceCmd(args []string) {
 	nreplaced := 0
 	start := h.Buf.Start()
 	end := h.Buf.End()
-	if h.Cursor.HasSelection() {
+	selection := h.Cursor.HasSelection()
+	if selection {
 		start = h.Cursor.CurSelection[0]
 		end = h.Cursor.CurSelection[1]
 	}
@@ -761,6 +762,8 @@ func (h *BufPane) ReplaceCmd(args []string) {
 			h.Cursor.SetSelectionStart(locs[0])
 			h.Cursor.SetSelectionEnd(locs[1])

+			h.Relocate()
+
 			InfoBar.YNPrompt("Perform replacement (y,n,esc)", func(yes, canceled bool) {
 				if !canceled && yes {
 					_, nrunes := h.Buf.ReplaceRegex(locs[0], locs[1], regex, replace)
@@ -785,14 +788,22 @@ func (h *BufPane) ReplaceCmd(args []string) {
 	}

 	h.Buf.RelocateCursors()
+	h.Relocate()

+	var s string
 	if nreplaced > 1 {
-		InfoBar.Message("Replaced ", nreplaced, " occurrences of ", search)
+		s = fmt.Sprintf("Replaced %d occurrences of %s", nreplaced, search)
 	} else if nreplaced == 1 {
-		InfoBar.Message("Replaced ", nreplaced, " occurrence of ", search)
+		s = fmt.Sprintf("Replaced 1 occurrence of %s", search)
 	} else {
-		InfoBar.Message("Nothing matched ", search)
+		s = fmt.Sprintf("Nothing matched %s", search)
 	}
+
+	if selection {
+		s += " in selection"
+	}
+
+	InfoBar.Message(s)
 }

 // ReplaceAllCmd replaces search term all at once
@@ -821,7 +832,11 @@ func (h *BufPane) TermCmd(args []string) {

 	term := func(i int, newtab bool) {
 		t := new(shell.Terminal)
-		t.Start(args, false, true, nil, nil)
+		err := t.Start(args, false, true, nil, nil)
+		if err != nil {
+			InfoBar.Error(err)
+			return
+		}

 		id := h.ID()
 		if newtab {
--- a/internal/action/defaults_darwin.go
+++ b/internal/action/defaults_darwin.go
@@ -17,10 +17,10 @@ func DefaultBindings() map[string]string {
 		"AltDown":        "MoveLinesDown",
 		"AltShiftRight":  "SelectWordRight",
 		"AltShiftLeft":   "SelectWordLeft",
-		"CtrlLeft":       "StartOfText",
+		"CtrlLeft":       "StartOfTextToggle",
 		"CtrlRight":      "EndOfLine",
-		"CtrlShiftLeft":  "SelectToStartOfText",
-		"ShiftHome":      "SelectToStartOfText",
+		"CtrlShiftLeft":  "SelectToStartOfTextToggle",
+		"ShiftHome":      "SelectToStartOfTextToggle",
 		"CtrlShiftRight": "SelectToEndOfLine",
 		"ShiftEnd":       "SelectToEndOfLine",
 		"CtrlUp":         "CursorStart",
@@ -52,7 +52,7 @@ func DefaultBindings() map[string]string {
 		"CtrlT":          "AddTab",
 		"Alt,":           "PreviousTab",
 		"Alt.":           "NextTab",
-		"Home":           "StartOfText",
+		"Home":           "StartOfTextToggle",
 		"End":            "EndOfLine",
 		"CtrlHome":       "CursorStart",
 		"CtrlEnd":        "CursorEnd",
--- a/internal/action/defaults_other.go
+++ b/internal/action/defaults_other.go
@@ -19,10 +19,10 @@ func DefaultBindings() map[string]string {
 		"AltDown":        "MoveLinesDown",
 		"CtrlShiftRight": "SelectWordRight",
 		"CtrlShiftLeft":  "SelectWordLeft",
-		"AltLeft":        "StartOfText",
+		"AltLeft":        "StartOfTextToggle",
 		"AltRight":       "EndOfLine",
-		"AltShiftLeft":   "SelectToStartOfText",
-		"ShiftHome":      "SelectToStartOfText",
+		"AltShiftLeft":   "SelectToStartOfTextToggle",
+		"ShiftHome":      "SelectToStartOfTextToggle",
 		"AltShiftRight":  "SelectToEndOfLine",
 		"ShiftEnd":       "SelectToEndOfLine",
 		"CtrlUp":         "CursorStart",
@@ -54,7 +54,7 @@ func DefaultBindings() map[string]string {
 		"CtrlT":          "AddTab",
 		"Alt,":           "PreviousTab",
 		"Alt.":           "NextTab",
-		"Home":           "StartOfText",
+		"Home":           "StartOfTextToggle",
 		"End":            "EndOfLine",
 		"CtrlHome":       "CursorStart",
 		"CtrlEnd":        "CursorEnd",
--- a/internal/action/tab.go
+++ b/internal/action/tab.go
@@ -166,6 +166,8 @@ type Tab struct {
 	active int

 	resizing *views.Node // node currently being resized
+	// captures whether the mouse is released
+	release bool
 }

 // NewTabFromBuffer creates a new tab from the given buffer
@@ -203,6 +205,8 @@ func (t *Tab) HandleEvent(event tcell.Event) {
 		mx, my := e.Position()
 		switch e.Buttons() {
 		case tcell.Button1:
+			wasReleased := t.release
+			t.release = false
 			if t.resizing != nil {
 				var size int
 				if t.resizing.Kind == views.STVert {
@@ -215,22 +219,25 @@ func (t *Tab) HandleEvent(event tcell.Event) {
 				return
 			}

-			resizeID := t.GetMouseSplitID(buffer.Loc{mx, my})
-			if resizeID != 0 {
-				t.resizing = t.GetNode(uint64(resizeID))
-				return
-			}
+			if wasReleased {
+				resizeID := t.GetMouseSplitID(buffer.Loc{mx, my})
+				if resizeID != 0 {
+					t.resizing = t.GetNode(uint64(resizeID))
+					return
+				}

-			for i, p := range t.Panes {
-				v := p.GetView()
-				inpane := mx >= v.X && mx < v.X+v.Width && my >= v.Y && my < v.Y+v.Height
-				if inpane {
-					t.SetActive(i)
-					break
+				for i, p := range t.Panes {
+					v := p.GetView()
+					inpane := mx >= v.X && mx < v.X+v.Width && my >= v.Y && my < v.Y+v.Height
+					if inpane {
+						t.SetActive(i)
+						break
+					}
 				}
 			}
 		case tcell.ButtonNone:
 			t.resizing = nil
+			t.release = true
 		default:
 			for _, p := range t.Panes {
 				v := p.GetView()
--- a/internal/buffer/buffer.go
+++ b/internal/buffer/buffer.go
@@ -5,6 +5,7 @@ import (
 	"bytes"
 	"crypto/md5"
 	"errors"
+	"fmt"
 	"io"
 	"io/ioutil"
 	"os"
@@ -60,6 +61,9 @@ var (
 	BTRaw = BufType{4, false, true, false}
 	// BTInfo is a buffer for inputting information
 	BTInfo = BufType{5, false, true, false}
+	// BTStdout is a buffer that only writes to stdout
+	// when closed
+	BTStdout = BufType{6, false, true, true}

 	// ErrFileTooLarge is returned when the file is too large to hash
 	// (fastdirty is automatically enabled)
@@ -82,6 +86,8 @@ type SharedBuffer struct {
 	// Name of the buffer on the status line
 	name string

+	toStdout bool
+
 	// Settings customized by the user
 	Settings map[string]interface{}

@@ -355,6 +361,10 @@ func (b *Buffer) Fini() {
 		b.Serialize()
 	}
 	b.RemoveBackup()
+
+	if b.Type == BTStdout {
+		fmt.Fprint(util.Stdout, string(b.Bytes()))
+	}
 }

 // GetName returns the name that should be displayed in the statusline
@@ -538,7 +548,37 @@ func (b *Buffer) UpdateRules() {
 		return
 	}
 	syntaxFile := ""
+	foundDef := false
 	var header *highlight.Header
+	// search for the syntax file in the user's custom syntax files
+	for _, f := range config.ListRealRuntimeFiles(config.RTSyntax) {
+		data, err := f.Data()
+		if err != nil {
+			screen.TermMessage("Error loading syntax file " + f.Name() + ": " + err.Error())
+			continue
+		}
+
+		header, err = highlight.MakeHeaderYaml(data)
+		file, err := highlight.ParseFile(data)
+		if err != nil {
+			screen.TermMessage("Error parsing syntax file " + f.Name() + ": " + err.Error())
+			continue
+		}
+
+		if ((ft == "unknown" || ft == "") && highlight.MatchFiletype(header.FtDetect, b.Path, b.lines[0].data)) || header.FileType == ft {
+			syndef, err := highlight.ParseDef(file, header)
+			if err != nil {
+				screen.TermMessage("Error parsing syntax file " + f.Name() + ": " + err.Error())
+				continue
+			}
+			b.SyntaxDef = syndef
+			syntaxFile = f.Name()
+			foundDef = true
+			break
+		}
+	}
+
+	// search in the default syntax files
 	for _, f := range config.ListRuntimeFiles(config.RTSyntaxHeader) {
 		data, err := f.Data()
 		if err != nil {
@@ -563,33 +603,8 @@ func (b *Buffer) UpdateRules() {
 		}
 	}

-	if syntaxFile == "" {
-		// search for the syntax file in the user's custom syntax files
-		for _, f := range config.ListRealRuntimeFiles(config.RTSyntax) {
-			data, err := f.Data()
-			if err != nil {
-				screen.TermMessage("Error loading syntax file " + f.Name() + ": " + err.Error())
-				continue
-			}
-
-			header, err = highlight.MakeHeaderYaml(data)
-			file, err := highlight.ParseFile(data)
-			if err != nil {
-				screen.TermMessage("Error parsing syntax file " + f.Name() + ": " + err.Error())
-				continue
-			}
-
-			if ((ft == "unknown" || ft == "") && highlight.MatchFiletype(header.FtDetect, b.Path, b.lines[0].data)) || header.FileType == ft {
-				syndef, err := highlight.ParseDef(file, header)
-				if err != nil {
-					screen.TermMessage("Error parsing syntax file " + f.Name() + ": " + err.Error())
-					continue
-				}
-				b.SyntaxDef = syndef
-				break
-			}
-		}
-	} else {
+	if syntaxFile != "" && !foundDef {
+		// we found a syntax file using a syntax header file
 		for _, f := range config.ListRuntimeFiles(config.RTSyntax) {
 			if f.Name() == syntaxFile {
 				data, err := f.Data()
--- a/internal/buffer/buffer_test.go
+++ b/internal/buffer/buffer_test.go
@@ -79,13 +79,14 @@ func check(t *testing.T, before []string, operations []operation, after []string
 		cursor := cursors[i]
 		b.SetCurCursor(cursor.Num)
 		cursor.DeleteSelection()
-		cursor.ResetSelection()
 		b.Insert(cursor.Loc, strings.Join(op.text, "\n"))
 	}

 	checkText(after)

-	for b.UndoStack.Peek() != nil {
+	// must have exactly two events per operation (delete and insert)
+	for range operations {
+		b.UndoOneEvent()
 		b.UndoOneEvent()
 	}

@@ -93,7 +94,7 @@ func check(t *testing.T, before []string, operations []operation, after []string

 	for i, op := range operations {
 		cursor := cursors[i]
-		if !cursor.HasSelection() {
+		if op.start == op.end {
 			assert.Equal(op.start, cursor.Loc)
 		} else {
 			assert.Equal(op.start, cursor.CurSelection[0])
@@ -101,7 +102,8 @@ func check(t *testing.T, before []string, operations []operation, after []string
 		}
 	}

-	for b.RedoStack.Peek() != nil {
+	for range operations {
+		b.RedoOneEvent()
 		b.RedoOneEvent()
 	}

--- a/internal/buffer/cursor.go
+++ b/internal/buffer/cursor.go
@@ -109,6 +109,19 @@ func (c *Cursor) StartOfText() {
 	}
 }

+// IsStartOfText returns whether the cursor is at the first
+// non-whitespace rune of the line it is on
+func (c *Cursor) IsStartOfText() bool {
+	x := 0
+	for util.IsWhitespace(c.RuneUnder(x)) {
+		if x == utf8.RuneCount(c.buf.LineBytes(c.Y)) {
+			break
+		}
+		x++
+	}
+	return c.X == x
+}
+
 // End moves the cursor to the end of the line it is on
 func (c *Cursor) End() {
 	c.X = utf8.RuneCount(c.buf.LineBytes(c.Y))
--- a/internal/buffer/eventhandler.go
+++ b/internal/buffer/eventhandler.go
@@ -270,7 +270,6 @@ func (eh *EventHandler) Undo() {
 		}

 		eh.UndoOneEvent()
-		break
 	}
 }

@@ -320,7 +319,6 @@ func (eh *EventHandler) Redo() {
 		}

 		eh.RedoOneEvent()
-		break
 	}
 }

--- a/internal/buffer/line_array.go
+++ b/internal/buffer/line_array.go
@@ -2,6 +2,7 @@ package buffer

 import (
 	"bufio"
+	"bytes"
 	"io"
 	"sync"
 	"unicode/utf8"
@@ -152,17 +153,19 @@ func NewLineArray(size uint64, endings FileFormat, reader io.Reader) *LineArray
 // Bytes returns the string that should be written to disk when
 // the line array is saved
 func (la *LineArray) Bytes() []byte {
-	str := make([]byte, 0, la.initsize+1000) // initsize should provide a good estimate
+	b := new(bytes.Buffer)
+	// initsize should provide a good estimate
+	b.Grow(int(la.initsize + 4096))
 	for i, l := range la.lines {
-		str = append(str, l.data...)
+		b.Write(l.data)
 		if i != len(la.lines)-1 {
 			if la.Endings == FFDos {
-				str = append(str, '\r')
+				b.WriteByte('\r')
 			}
-			str = append(str, '\n')
+			b.WriteByte('\n')
 		}
 	}
-	return str
+	return b.Bytes()
 }

 // newlineBelow adds a newline below the given line number
--- a/internal/config/runtime.go
+++ b/internal/config/runtime.go
--- a/internal/display/bufwindow.go
+++ b/internal/display/bufwindow.go
@@ -139,6 +139,9 @@ func (w *BufWindow) Relocate() bool {
 	ret := false
 	activeC := w.Buf.GetActiveCursor()
 	cy := activeC.Y
+	if activeC.HasSelection() {
+		cy = activeC.CurSelection[0].Y
+	}
 	scrollmargin := int(b.Settings["scrollmargin"].(float64))
 	if cy < w.StartLine+scrollmargin && cy > scrollmargin-1 {
 		w.StartLine = cy - scrollmargin
@@ -556,7 +559,7 @@ func (w *BufWindow) displayBuffer() {
 				}

 				if s, ok := config.Colorscheme["color-column"]; ok {
-					if colorcolumn != 0 && vloc.X-w.gutterOffset == colorcolumn {
+					if colorcolumn != 0 && vloc.X-w.gutterOffset+w.StartCol == colorcolumn {
 						fg, _, _ := s.Decompose()
 						style = style.Background(fg)
 					}
@@ -650,7 +653,7 @@ func (w *BufWindow) displayBuffer() {
 		for i := vloc.X; i < bufWidth; i++ {
 			curStyle := style
 			if s, ok := config.Colorscheme["color-column"]; ok {
-				if colorcolumn != 0 && i-w.gutterOffset == colorcolumn {
+				if colorcolumn != 0 && i-w.gutterOffset+w.StartCol == colorcolumn {
 					fg, _, _ := s.Decompose()
 					curStyle = style.Background(fg)
 				}
--- a/internal/display/infowindow.go
+++ b/internal/display/infowindow.go
@@ -209,13 +209,13 @@ func (i *InfoWindow) scrollToSuggestion() {
 }

 func (i *InfoWindow) Display() {
-	i.Clear()
-	x := 0
-	if config.GetGlobalOption("keymenu").(bool) {
-		i.displayKeyMenu()
-	}
-
 	if i.HasPrompt || config.GlobalSettings["infobar"].(bool) {
+		i.Clear()
+		x := 0
+		if config.GetGlobalOption("keymenu").(bool) {
+			i.displayKeyMenu()
+		}
+
 		if !i.HasPrompt && !i.HasMessage && !i.HasError {
 			return
 		}
--- a/internal/util/util.go
+++ b/internal/util/util.go
@@ -1,6 +1,7 @@
 package util

 import (
+	"bytes"
 	"errors"
 	"fmt"
 	"os"
@@ -34,6 +35,9 @@ var (
 	// FakeCursor is used to disable the terminal cursor and have micro
 	// draw its own (enabled for windows consoles where the cursor is slow)
 	FakeCursor = false
+
+	// Stdout is a buffer that is written to stdout when micro closes
+	Stdout *bytes.Buffer
 )

 func init() {
@@ -46,6 +50,7 @@ func init() {
 	if runtime.GOOS == "windows" {
 		FakeCursor = true
 	}
+	Stdout = new(bytes.Buffer)
 }

 // SliceEnd returns a byte slice where the index is a rune index
--- a/runtime/colorschemes/dukedark-tc.micro
+++ b/runtime/colorschemes/dukedark-tc.micro
@@ -0,0 +1,34 @@
+color-link color-column "#001e28"
+color-link comment "#608b4e,#001e28"
+color-link constant.bool "#fd971f,#001e28"
+color-link constant "#fd971f,#001e28"
+color-link constant.string "#a0f000,#001e28"
+color-link constant.string.char "#a0f000,#001e28"
+color-link constant.string.url "#a0f000,#001e28"
+color-link current-line-number "bold #fd971f,#001e28"
+color-link cursor-line "#001923"
+color-link default "#ffffff,#001e28"
+color-link diff-added "#00c8a0,#001e28"
+color-link diff-modified "#fd971f,#001e28"
+color-link diff-deleted "#cb4b16,#001e28"
+color-link divider "#001e28,#d0d0d0"
+color-link error "#cb4b16,#001e28"
+color-link gutter-error "#cb4b16,#001e28"
+color-link gutter-warning "#fce94f,#001e28"
+color-link identifier "#00c8a0,#001e28"
+color-link identifier.class "#00c8a0,#001e28"
+color-link indent-char "#a0a0a0,#001e28"
+color-link line-number "#a0a0a0,#001923"
+color-link preproc "bold #5aaae6,#001e28"
+color-link special "#a6e22e,#001e28"
+color-link statement "bold #5aaae6,#001e28"
+color-link statusline "#ffffff,#0078c8"
+color-link symbol "#00c8a0,#001e28"
+color-link symbol.brackets "#ffffff,#001e28"
+color-link symbol.tag "bold #5aaae6,#001e28"
+color-link tabbar "#001e28,#ffffff"
+color-link todo "#fce94f,#001e28"
+color-link type "bold #3cc83c,#001e28"
+color-link type.keyword "bold #5aaae6,#001e28"
+color-link type.extended "#ffffff,#001e28"
+color-link underlined "#608b4e,#001e28"
--- a/runtime/colorschemes/dukelight-tc.micro
+++ b/runtime/colorschemes/dukelight-tc.micro
@@ -0,0 +1,34 @@
+color-link color-column "#f0f0f0"
+color-link comment "#3f7f5f,#f0f0f0"
+color-link constant.bool "#641e00,#f0f0f0"
+color-link constant "#641e00,#f0f0f0"
+color-link constant.string "#0000ff,#f0f0f0"
+color-link constant.string.char "#0000ff,#f0f0f0"
+color-link constant.string.url "#0000ff,#f0f0f0"
+color-link current-line-number "bold #004080,#f0f0f0"
+color-link cursor-line "#e6e6e6"
+color-link default "#000000,#f0f0f0"
+color-link diff-added "#008040,#f0f0f0"
+color-link diff-modified "#641e00,#f0f0f0"
+color-link diff-deleted "#500000,#f0f0f0"
+color-link divider "#f0f0f0,#004080"
+color-link error "#500000,#f0f0f0"
+color-link gutter-error "#500000,#f0f0f0"
+color-link gutter-warning "#dcc800,#f0f0f0"
+color-link identifier "bold #0078a0,#f0f0f0"
+color-link identifier.class "bold #0078a0,#f0f0f0"
+color-link indent-char "#404040,#f0f0f0"
+color-link line-number "#404040,#e6e6e6"
+color-link preproc "bold #780050,#f0f0f0"
+color-link special "bold #0078a0,#f0f0f0"
+color-link statement "bold #780050,#f0f0f0"
+color-link statusline "#ffffff,#0078c8"
+color-link symbol "bold #0078a0,#f0f0f0"
+color-link symbol.brackets "#000000,#f0f0f0"
+color-link symbol.tag "bold #780050,#f0f0f0"
+color-link tabbar "#f0f0f0,#004080"
+color-link todo "#dcc800,#f0f0f0"
+color-link type "bold #004080,#f0f0f0"
+color-link type.keyword "bold #780050,#f0f0f0"
+color-link type.extended "#000000,#f0f0f0"
+color-link underlined "#3f7f5f,#f0f0f0"
--- a/runtime/colorschemes/dukeubuntu-tc.micro
+++ b/runtime/colorschemes/dukeubuntu-tc.micro
@@ -0,0 +1,34 @@
+color-link color-column "#2d0023"
+color-link comment "#886484,#2d0023"
+color-link constant.bool "#fd971f,#2d0023"
+color-link constant "#fd971f,#2d0023"
+color-link constant.string "#a0f000,#2d0023"
+color-link constant.string.char "#a0f000,#2d0023"
+color-link constant.string.url "#a0f000,#2d0023"
+color-link current-line-number "bold #fd971f,#2d0023"
+color-link cursor-line "#230019"
+color-link default "#ffffff,#2d0023"
+color-link diff-added "#00c8a0,#2d0023"
+color-link diff-modified "#fd971f,#2d0023"
+color-link diff-deleted "#cb4b16,#2d0023"
+color-link divider "#2d0023,#d0d0d0"
+color-link error "#cb4b16,#2d0023"
+color-link gutter-error "#cb4b16,#2d0023"
+color-link gutter-warning "#fce94f,#2d0023"
+color-link identifier "#00c8a0,#2d0023"
+color-link identifier.class "#00c8a0,#2d0023"
+color-link indent-char "#a0a0a0,#2d0023"
+color-link line-number "#a0a0a0,#230019"
+color-link preproc "bold #5aaae6,#2d0023"
+color-link special "#a6e22e,#2d0023"
+color-link statement "bold #5aaae6,#2d0023"
+color-link statusline "#ffffff,#0078c8"
+color-link symbol "#00c8a0,#2d0023"
+color-link symbol.brackets "#ffffff,#2d0023"
+color-link symbol.tag "bold #5aaae6,#2d0023"
+color-link tabbar "#2d0023,#ffffff"
+color-link todo "#fce94f,#2d0023"
+color-link type "bold #3cc83c,#2d0023"
+color-link type.keyword "bold #5aaae6,#2d0023"
+color-link type.extended "#ffffff,#2d0023"
+color-link underlined "#886484,#2d0023"
--- a/runtime/help/defaultkeys.md
+++ b/runtime/help/defaultkeys.md
@@ -23,7 +23,7 @@ can change it!
 | Shift+arrows                | Move and select text                                                                      |
 | Alt(Ctrl on Mac)+LeftArrow  | Move to the beginning of the current line                                                 |
 | Alt(Ctrl on Mac)+RightArrow | Move to the end of the current line                                                       |
-| Home                        | Move to the beginning of the current line                                                 |
+| Home                        | Move to the beginning of text on the current line                                                 |
 | End                         | Move to the end of the current line                                                       |
 | Ctrl(Alt on Mac)+LeftArrow  | Move cursor one word left                                                                 |
 | Ctrl(Alt on Mac)+RightArrow | Move cursor one word right                                                                |
--- a/runtime/help/keybindings.md
+++ b/runtime/help/keybindings.md
@@ -162,6 +162,8 @@ SelectUp
 SelectDown
 SelectLeft
 SelectRight
+SelectToStartOfText
+SelectToStartOfTextToggle
 WordRight
 WordLeft
 SelectWordRight
@@ -209,6 +211,8 @@ HalfPageUp
 HalfPageDown
 StartOfLine
 EndOfLine
+StartOfText
+StartOfTextToggle
 ParagraphPrevious
 ParagraphNext
 ToggleHelp
@@ -245,6 +249,9 @@ JumpToMatchingBrace
 Autocomplete
 ```

+The `StartOfTextToggle` and `SelectToStartOfTextToggle` actions toggle between
+jumping to the start of the text (first) and start of the line.
+
 You can also bind some mouse actions (these must be bound to mouse buttons)

 ```
@@ -410,21 +417,21 @@ conventions for text editing defaults.
    "ShiftDown":      "SelectDown",
    "ShiftLeft":      "SelectLeft",
    "ShiftRight":     "SelectRight",
-    "AltLeft":        "WordLeft",
-    "AltRight":       "WordRight",
+    "AltLeft":        "WordLeft", (Mac)
+    "AltRight":       "WordRight", (Mac)
    "AltUp":          "MoveLinesUp",
    "AltDown":        "MoveLinesDown",
    "CtrlShiftRight": "SelectWordRight",
    "CtrlShiftLeft":  "SelectWordLeft",
-    "AltLeft":        "StartOfLine",
+    "AltLeft":        "StartOfTextToggle",
    "AltRight":       "EndOfLine",
    "AltShiftRight":  "SelectWordRight", (Mac)
    "AltShiftLeft":   "SelectWordLeft", (Mac)
    "CtrlLeft":       "StartOfText", (Mac)
    "CtrlRight":      "EndOfLine", (Mac)
-    "AltShiftLeft":   "SelectToStartOfLine",
-    "CtrlShiftLeft":  "SelectToStartOfText", (Mac)
-    "ShiftHome":      "SelectToStartOfLine",
+    "AltShiftLeft":   "SelectToStartOfTextToggle",
+    "CtrlShiftLeft":  "SelectToStartOfTextToggle", (Mac)
+    "ShiftHome":      "SelectToStartOfTextToggle",
    "AltShiftRight":  "SelectToEndOfLine",
    "CtrlShiftRight": "SelectToEndOfLine", (Mac)
    "ShiftEnd":       "SelectToEndOfLine",
@@ -457,7 +464,7 @@ conventions for text editing defaults.
    "CtrlT":          "AddTab",
    "Alt,":           "PreviousTab",
    "Alt.":           "NextTab",
-    "Home":           "StartOfLine",
+    "Home":           "StartOfText",
    "End":            "EndOfLine",
    "CtrlHome":       "CursorStart",
    "CtrlEnd":        "CursorEnd",
--- a/runtime/plugins/comment/comment.lua
+++ b/runtime/plugins/comment/comment.lua
@@ -23,6 +23,7 @@ ft["javascript"] = "// %s"
 ft["ruby"] = "# %s"
 ft["d"] = "// %s"
 ft["swift"] = "// %s"
+ft["elm"] = "-- %s"

 function onBufferOpen(buf)
    if buf.Settings["commenttype"] == nil then
--- a/runtime/plugins/linter/linter.lua
+++ b/runtime/plugins/linter/linter.lua
@@ -66,10 +66,11 @@ function init()
    end

    makeLinter("gcc", "c", "gcc", {"-fsyntax-only", "-Wall", "-Wextra", "%f"}, "%f:%l:%c:.+: %m")
-    makeLinter("gcc", "c++", "gcc", {"-fsyntax-only","-std=c++14", "-Wall", "-Wextra", "%f"}, "%f:%l:%c:.+: %m")
+    makeLinter("g++", "c++", "gcc", {"-fsyntax-only","-std=c++14", "-Wall", "-Wextra", "%f"}, "%f:%l:%c:.+: %m")
    makeLinter("dmd", "d", "dmd", {"-color=off", "-o-", "-w", "-wi", "-c", "%f"}, "%f%(%l%):.+: %m")
    makeLinter("gobuild", "go", "go", {"build", "-o", devnull, "%d"}, "%f:%l:%c:? %m")
    -- makeLinter("golint", "go", "golint", {"%f"}, "%f:%l:%c: %m")
+    makeLinter("hlint", "haskell", "hlint", {"%f"}, "%f:%l:%c: %m")
    makeLinter("javac", "java", "javac", {"-d", "%d", "%f"}, "%f:%l: error: %m")
    makeLinter("jshint", "javascript", "jshint", {"%f"}, "%f: line %l,.+, %m")
    makeLinter("literate", "literate", "lit", {"-c", "%f"}, "%f:%l:%m", {}, false, true)
--- a/runtime/syntax/csx.yaml
+++ b/runtime/syntax/csx.yaml
@@ -0,0 +1,8 @@
+filetype: csharp-script
+detect:
+    filename: "\\.csx$"
+    header: "^#!.*/(env +)?dotnet-script( |$)"
+    
+rules:
+    - include: "csharp"
+    - preproc: "\\B(\\#!|\\#[r|load|]+\\b)"
--- a/runtime/syntax/git-commit.yaml
+++ b/runtime/syntax/git-commit.yaml
@@ -26,7 +26,7 @@ rules:

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

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

    - constant.string: "\"(\\\\.|[^\"])*\"|'(\\\\.|[^']){1}'"

--- a/runtime/syntax/python2.yaml
+++ b/runtime/syntax/python2.yaml
@@ -1,8 +1,8 @@
-filetype: python
+filetype: python2

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

 rules:

--- a/runtime/syntax/python3.yaml
+++ b/runtime/syntax/python3.yaml
@@ -1,8 +1,8 @@
-filename: python3
+filetype: python

 detect:
-    filename: "\\.py3$"
-    header: "^#!.*/(env +)?python3$"
+    filename: "\\.py(3)?$"
+    header: "^#!.*/(env +)?python(3)?$"

 rules:
    # built-in objects
--- a/runtime/syntax/ruby.yaml
+++ b/runtime/syntax/ruby.yaml
@@ -1,7 +1,7 @@
 filetype: ruby

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

 rules:
--- a/runtime/syntax/sage.yaml
+++ b/runtime/syntax/sage.yaml
@@ -0,0 +1,60 @@
+filetype: sage
+
+detect:
+    filename: "\\.sage$"
+    header: "^#!.*/(env +)?sage( |$)"
+
+rules:
+
+    # built-in objects
+    - constant: "\\b(None|self|True|False)\\b"
+      # built-in attributes
+    - constant: "\\b(__bases__|__builtin__|__class__|__debug__|__dict__|__doc__|__file__|__members__|__methods__|__name__|__self__)\\b"
+      # built-in functions
+    - identifier: "\\b(abs|apply|callable|chr|cmp|compile|delattr|dir|divmod|eval|exec|execfile|filter|format|getattr|globals|hasattr|hash|help|hex|id|input|intern|isinstance|issubclass|len|locals|max|min|next|oct|open|ord|pow|range|raw_input|reduce|reload|repr|round|setattr|unichr|vars|zip|__import__)\\b"
+      # special method names
+    - identifier: "\\b(__abs__|__add__|__and__|__call__|__cmp__|__coerce__|__complex__|__concat__|__contains__|__del__|__delattr__|__delitem__|__dict__|__delslice__|__div__|__divmod__|__float__|__getattr__|__getitem__|__getslice__|__hash__|__hex__|__init__|__int__|__inv__|__invert__|__len__|__long__|__lshift__|__mod__|__mul__|__neg__|__nonzero__|__oct__|__or__|__pos__|__pow__|__radd__|__rand__|__rcmp__|__rdiv__|__rdivmod__|__repeat__|__repr__|__rlshift__|__rmod__|__rmul__|__ror__|__rpow__|__rrshift__|__rshift__|__rsub__|__rxor__|__setattr__|__setitem__|__setslice__|__str__|__sub__|__xor__)\\b"
+      # types
+    - type: "\\b(basestring|bool|buffer|bytearray|bytes|classmethod|complex|dict|enumerate|file|float|frozenset|int|list|long|map|memoryview|object|property|reversed|set|slice|staticmethod|str|super|tuple|type|unicode|xrange)\\b"
+      # definitions
+    - identifier: "def [a-zA-Z_0-9]+"
+      # keywords
+    - statement: "\\b(and|as|assert|break|class|continue|def|del|elif|else|except|finally|for|from|global|if|import|in|is|lambda|not|or|pass|print|raise|return|try|while|with|yield)\\b"
+      # decorators
+    - brightgreen: "@.*[(]"
+      # operators
+    - statement: "([.:;,+*|=!\\%@]|<|>|/|-|&)"
+      # parentheses
+    - statement: "([(){}]|\\[|\\])"
+      # numbers
+    - constant.number: "\\b[0-9]+\\b"
+
+    - comment:
+        start: "\"\"\""
+        end: "\"\"\""
+        rules: []
+
+    - comment:
+        start: "'''"
+        end: "'''"
+        rules: []
+
+    - constant.string:
+        start: "\""
+        end: "\""
+        skip: "\\\\."
+        rules:
+            - constant.specialChar: "\\\\."
+
+    - constant.string:
+        start: "'"
+        end: "'"
+        skip: "\\\\."
+        rules:
+            - constant.specialChar: "\\\\."
+
+    - comment:
+        start: "#"
+        end: "$"
+        rules: []
+
Author	SHA1	Message	Date
Zachary Yedidia	f59468642d	Update runtime	2020-04-10 17:27:57 -04:00
Zachary Yedidia	85e85b7ccc	Merge	2020-04-10 17:27:34 -04:00
Zachary Yedidia	8f5888e7bf	Use StartCol in colorcolumn calculation Fixes #1615	2020-04-10 17:27:11 -04:00
Ján Jančár	f0da73bae2	Add StartOfTextToggle and SelectToStartOfTextToggle actions. (#1612 ) These actions reintroduce the behavior of micro where the Home key toggles between the start of text (first) and the start of the line. The same applies for the variant with selection. This commit also sets these bindings as the defaults.	2020-04-10 17:21:02 -04:00
Zachary Yedidia	d92deacf99	Ensure mouse release before focus change Fixes #1613	2020-04-10 15:58:43 -04:00
trrbl	ffd7b5c770	Support csharp-script syntax. (#1425 ) ``` #!/usr/bin/env dotnet-script // Set Runtime #! "netcoreapp3.0" // Imports #load "myAssembly.dll" #r "nuget:CliWrap,2.5.0" ``` This syntax file basically imports the `csharp` rules and adds it's custom pre-processors.	2020-04-10 13:57:36 -04:00
Ján Jančár	bd8c0d25c8	Add sagemath syntax highlight based on python3. (#1227 )	2020-04-09 12:20:48 -04:00
Ján Jančár	052a36b896	Fix docs regarding "Home" key and "StartOfText" and "StartOfLine". (#1611 )	2020-04-07 12:58:30 -04:00
jsyedidia	a76bf02f5f	Add Haskell linter hlint to linter plugin (#1610 )	2020-04-05 14:05:01 -04:00
Nikita Bobko	92f4cb7ef7	Clarify regex for `git commit --verbose` (#1606 )	2020-04-05 14:04:36 -04:00
Zachary Yedidia	1cf9537340	Fix python3 syntax file and make python3 default The python3 syntax had "filename" instead of "filetype" as the header. This commit also makes standard py extensions use the python3 highlighting and requires .py2 or a python2 env to use python2 highlighting because python3 is the standard python now. Fixes #1592	2020-03-24 11:42:23 -04:00
Zachary Yedidia	60c8c81da3	Relocate during replace Fixes #1587	2020-03-24 11:33:52 -04:00
Zachary Yedidia	c76a973877	Merge	2020-03-24 11:17:12 -04:00
Zachary Yedidia	6def99ce24	Clarify replace message if replacing in selection	2020-03-24 11:14:54 -04:00
Koki Fushimi	26930ca81f	Better Julia syntax. (#1567 ) * Fix regex syntax and change to match one or more spaces. * Add constant `nothing` and `missing`. * Add Inf and NaN to constant numbers.	2020-03-24 10:59:48 -04:00
Hugo Locurcio	cd379cd838	Clarify the Find operation being regex-enabled (#1561 ) This makes it more obvious that the Find option accepts regular expressions as input. See discussion in #1560.	2020-03-24 10:59:40 -04:00
allanderek	ee157f6503	Add elm as a default comment type in the comment plugin. (#1586 )	2020-03-24 10:56:50 -04:00
Zachary Yedidia	48ca19873f	Better ordering for reading syntax files Ref #1580	2020-03-24 10:52:15 -04:00
Zachary Yedidia	fee5528309	Fix term emulator crash if invalid exec given Ref #1583	2020-03-24 10:22:10 -04:00
Zachary Yedidia	671a188802	Support +LINE:COL flag syntax for cursor pos Closes #1566	2020-03-24 10:10:44 -04:00
Zachary Yedidia	18d540583b	Don't clear infobar if not enabled Fixes #1584	2020-03-17 14:21:36 -04:00
Zachary Yedidia	943ea15fa3	Fix linter c++ entry Fixes #1578	2020-03-14 15:40:05 -04:00
Cafe Duke	2ef57977d7	Add color schemes dukeubuntu-tc, dukedark-tc and dukelight-tc (#1547 ) * Duke ubuntu, dark and light color schemes * Duke color schemes: Change bgcolor for line number and cursor line Co-authored-by: Raghunandan.Seshadri <raghubs81@gmail.com> Co-authored-by: Raghunandan Seshadri <raghunandan.seshadri@oracle.com>	2020-03-07 22:07:43 -05:00
Zachary Yedidia	527750b68d	Copy selection to primary on mouse release Fixes #1558	2020-03-05 16:00:40 -05:00
Zachary Yedidia	629efe5eb7	Add JumpLine action back You can bind to "command-edit:goto ", but binding to the action "JumpLine" will have the same effect now. Fixes #1550	2020-03-02 20:09:19 -05:00
Andrew Havens	a19cd2e6d0	Add support for Fastlane and Cocoapods file syntax highlighting (#1544 )	2020-03-02 20:03:28 -05:00
Zachary Yedidia	9e8d76f2fa	If stdout is a pipe, output to the pipe If you run micro as `micro \| cat` for example, micro will disallow you from saving the file, and when you quit the buffer, the contents will be sent to the pipe. This allows one to use micro as part of an interactive unix pipeline. Closes #1524	2020-02-27 12:39:19 -05:00
Zachary Yedidia	8a9a14562f	Use bytes.Buffer for LineArray.Bytes	2020-02-27 11:27:00 -05:00
Zachary Yedidia	a6f5dee45c	Fix custom syntax files not highlighting Fixes #1530	2020-02-27 00:58:52 -05:00
Zachary Yedidia	b12886b066	Improve buffer test	2020-02-25 23:59:27 -05:00
Zachary Yedidia	56f5b475eb	Improve buffer test	2020-02-25 23:21:50 -05:00
Zachary Yedidia	c51f84955e	Update runtime	2020-02-25 21:08:22 -05:00
Zachary Yedidia	e4bf1e9984	Undo event chunks instead of single events	2020-02-25 20:53:48 -05:00
Zachary Yedidia	917e2922a1	Update readme	2020-02-25 20:40:57 -05:00