Reorganize file structure

cmd/micro/buffer/buffer.go

@@ -0,0 +1,589 @@
+package buffer
+
+import (
+	"bufio"
+	"bytes"
+	"crypto/md5"
+	"encoding/gob"
+	"errors"
+	"io"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"os/signal"
+	"path/filepath"
+	"strings"
+	"time"
+	"unicode/utf8"
+
+	"github.com/zyedidia/micro/cmd/micro/config"
+	"github.com/zyedidia/micro/cmd/micro/highlight"
+
+	. "github.com/zyedidia/micro/cmd/micro/util"
+)
+
+// LargeFileThreshold is the number of bytes when fastdirty is forced
+// because hashing is too slow
+const LargeFileThreshold = 50000
+
+// overwriteFile opens the given file for writing, truncating if one exists, and then calls
+// the supplied function with the file as io.Writer object, also making sure the file is
+// closed afterwards.
+func overwriteFile(name string, fn func(io.Writer) error) (err error) {
+	var file *os.File
+
+	if file, err = os.OpenFile(name, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644); err != nil {
+		return
+	}
+
+	defer func() {
+		if e := file.Close(); e != nil && err == nil {
+			err = e
+		}
+	}()
+
+	w := bufio.NewWriter(file)
+
+	if err = fn(w); err != nil {
+		return
+	}
+
+	err = w.Flush()
+	return
+}
+
+// The BufType defines what kind of buffer this is
+type BufType struct {
+	Kind     int
+	Readonly bool // The file cannot be edited
+	Scratch  bool // The file cannot be saved
+}
+
+var (
+	BTDefault = BufType{0, false, false}
+	BTHelp    = BufType{1, true, true}
+	BTLog     = BufType{2, true, true}
+	BTScratch = BufType{3, false, true}
+	BTRaw     = BufType{4, true, true}
+)
+
+type Buffer struct {
+	*LineArray
+	*EventHandler
+
+	cursors     []*Cursor
+	StartCursor Loc
+
+	// Path to the file on disk
+	Path string
+	// Absolute path to the file on disk
+	AbsPath string
+	// Name of the buffer on the status line
+	name string
+
+	// Whether or not the buffer has been modified since it was opened
+	isModified bool
+
+	// Stores the last modification time of the file the buffer is pointing to
+	ModTime time.Time
+
+	SyntaxDef   *highlight.Def
+	Highlighter *highlight.Highlighter
+
+	// Hash of the original buffer -- empty if fastdirty is on
+	origHash [md5.Size]byte
+
+	// Settings customized by the user
+	Settings map[string]interface{}
+
+	// Type of the buffer (e.g. help, raw, scratch etc..)
+	Type BufType
+}
+
+// The SerializedBuffer holds the types that get serialized when a buffer is saved
+// These are used for the savecursor and saveundo options
+type SerializedBuffer struct {
+	EventHandler *EventHandler
+	Cursor       Loc
+	ModTime      time.Time
+}
+
+// NewBufferFromFile opens a new buffer using the given path
+// It will also automatically handle `~`, and line/column with filename:l:c
+// It will return an empty buffer if the path does not exist
+// and an error if the file is a directory
+func NewBufferFromFile(path string) (*Buffer, error) {
+	var err error
+	filename, cursorPosition := GetPathAndCursorPosition(path)
+	filename, err = ReplaceHome(filename)
+	if err != nil {
+		return nil, err
+	}
+
+	file, err := os.Open(filename)
+	fileInfo, _ := os.Stat(filename)
+
+	if err == nil && fileInfo.IsDir() {
+		return nil, errors.New(filename + " is a directory")
+	}
+
+	defer file.Close()
+
+	var buf *Buffer
+	if err != nil {
+		// File does not exist -- create an empty buffer with that name
+		buf = NewBufferFromString("", filename)
+	} else {
+		buf = NewBuffer(file, FSize(file), filename, cursorPosition)
+	}
+
+	return buf, nil
+}
+
+// NewBufferFromString creates a new buffer containing the given string
+func NewBufferFromString(text, path string) *Buffer {
+	return NewBuffer(strings.NewReader(text), int64(len(text)), path, nil)
+}
+
+// NewBuffer creates a new buffer from a given reader with a given path
+// Ensure that ReadSettings and InitGlobalSettings have been called before creating
+// a new buffer
+func NewBuffer(reader io.Reader, size int64, path string, cursorPosition []string) *Buffer {
+	b := new(Buffer)
+
+	b.Settings = config.DefaultLocalSettings()
+	for k, v := range config.GlobalSettings {
+		if _, ok := b.Settings[k]; ok {
+			b.Settings[k] = v
+		}
+	}
+	config.InitLocalSettings(b.Settings, b.Path)
+
+	b.LineArray = NewLineArray(uint64(size), FFAuto, reader)
+
+	absPath, _ := filepath.Abs(path)
+
+	b.Path = path
+	b.AbsPath = absPath
+
+	// The last time this file was modified
+	b.ModTime, _ = GetModTime(b.Path)
+
+	b.EventHandler = NewEventHandler(b)
+
+	b.UpdateRules()
+
+	if _, err := os.Stat(config.ConfigDir + "/buffers/"); os.IsNotExist(err) {
+		os.Mkdir(config.ConfigDir+"/buffers/", os.ModePerm)
+	}
+
+	// cursorLocation, err := GetBufferCursorLocation(cursorPosition, b)
+	// b.startcursor = Cursor{
+	// 	Loc: cursorLocation,
+	// 	buf: b,
+	// }
+	// TODO flagstartpos
+	if b.Settings["savecursor"].(bool) || b.Settings["saveundo"].(bool) {
+		err := b.Unserialize()
+		if err != nil {
+			TermMessage(err)
+		}
+	}
+
+	if !b.Settings["fastdirty"].(bool) {
+		if size > LargeFileThreshold {
+			// If the file is larger than LargeFileThreshold fastdirty needs to be on
+			b.Settings["fastdirty"] = true
+		} else {
+			calcHash(b, &b.origHash)
+		}
+	}
+
+	return b
+}
+
+// GetName returns the name that should be displayed in the statusline
+// for this buffer
+func (b *Buffer) GetName() string {
+	if b.name == "" {
+		if b.Path == "" {
+			return "No name"
+		}
+		return b.Path
+	}
+	return b.name
+}
+
+// FileType returns the buffer's filetype
+func (b *Buffer) FileType() string {
+	return b.Settings["filetype"].(string)
+}
+
+// ReOpen reloads the current buffer from disk
+func (b *Buffer) ReOpen() error {
+	data, err := ioutil.ReadFile(b.Path)
+	txt := string(data)
+
+	if err != nil {
+		return err
+	}
+	b.EventHandler.ApplyDiff(txt)
+
+	b.ModTime, err = GetModTime(b.Path)
+	b.isModified = false
+	return err
+	// TODO: buffer cursor
+	// b.Cursor.Relocate()
+}
+
+// Saving
+
+// Save saves the buffer to its default path
+func (b *Buffer) Save() error {
+	return b.SaveAs(b.Path)
+}
+
+// SaveAs saves the buffer to a specified path (filename), creating the file if it does not exist
+func (b *Buffer) SaveAs(filename string) error {
+	// TODO: rmtrailingws and updaterules
+	b.UpdateRules()
+	// if b.Settings["rmtrailingws"].(bool) {
+	// 	for i, l := range b.lines {
+	// 		pos := len(bytes.TrimRightFunc(l.data, unicode.IsSpace))
+	//
+	// 		if pos < len(l.data) {
+	// 			b.deleteToEnd(Loc{pos, i})
+	// 		}
+	// 	}
+	//
+	// 	b.Cursor.Relocate()
+	// }
+
+	if b.Settings["eofnewline"].(bool) {
+		end := b.End()
+		if b.RuneAt(Loc{end.X - 1, end.Y}) != '\n' {
+			b.Insert(end, "\n")
+		}
+	}
+
+	// Update the last time this file was updated after saving
+	defer func() {
+		b.ModTime, _ = GetModTime(filename)
+	}()
+
+	// Removes any tilde and replaces with the absolute path to home
+	absFilename, _ := ReplaceHome(filename)
+
+	// TODO: save creates parent dirs
+	// // Get the leading path to the file | "." is returned if there's no leading path provided
+	// if dirname := filepath.Dir(absFilename); dirname != "." {
+	// 	// Check if the parent dirs don't exist
+	// 	if _, statErr := os.Stat(dirname); os.IsNotExist(statErr) {
+	// 		// Prompt to make sure they want to create the dirs that are missing
+	// 		if yes, canceled := messenger.YesNoPrompt("Parent folders \"" + dirname + "\" do not exist. Create them? (y,n)"); yes && !canceled {
+	// 			// Create all leading dir(s) since they don't exist
+	// 			if mkdirallErr := os.MkdirAll(dirname, os.ModePerm); mkdirallErr != nil {
+	// 				// If there was an error creating the dirs
+	// 				return mkdirallErr
+	// 			}
+	// 		} else {
+	// 			// If they canceled the creation of leading dirs
+	// 			return errors.New("Save aborted")
+	// 		}
+	// 	}
+	// }
+
+	var fileSize int
+
+	err := overwriteFile(absFilename, func(file io.Writer) (e error) {
+		if len(b.lines) == 0 {
+			return
+		}
+
+		// end of line
+		var eol []byte
+		if b.Settings["fileformat"] == "dos" {
+			eol = []byte{'\r', '\n'}
+		} else {
+			eol = []byte{'\n'}
+		}
+
+		// write lines
+		if fileSize, e = file.Write(b.lines[0].data); e != nil {
+			return
+		}
+
+		for _, l := range b.lines[1:] {
+			if _, e = file.Write(eol); e != nil {
+				return
+			}
+			if _, e = file.Write(l.data); e != nil {
+				return
+			}
+			fileSize += len(eol) + len(l.data)
+		}
+		return
+	})
+
+	if err != nil {
+		return err
+	}
+
+	if !b.Settings["fastdirty"].(bool) {
+		if fileSize > LargeFileThreshold {
+			// For large files 'fastdirty' needs to be on
+			b.Settings["fastdirty"] = true
+		} else {
+			calcHash(b, &b.origHash)
+		}
+	}
+
+	b.Path = filename
+	absPath, _ := filepath.Abs(filename)
+	b.AbsPath = absPath
+	b.isModified = false
+	return b.Serialize()
+}
+
+// SaveWithSudo saves the buffer to the default path with sudo
+func (b *Buffer) SaveWithSudo() error {
+	return b.SaveAsWithSudo(b.Path)
+}
+
+// SaveAsWithSudo is the same as SaveAs except it uses a neat trick
+// with tee to use sudo so the user doesn't have to reopen micro with sudo
+func (b *Buffer) SaveAsWithSudo(filename string) error {
+	b.UpdateRules()
+	b.Path = filename
+	absPath, _ := filepath.Abs(filename)
+	b.AbsPath = absPath
+
+	// Set up everything for the command
+	cmd := exec.Command(config.GlobalSettings["sucmd"].(string), "tee", filename)
+	cmd.Stdin = bytes.NewBuffer(b.Bytes())
+
+	// This is a trap for Ctrl-C so that it doesn't kill micro
+	// Instead we trap Ctrl-C to kill the program we're running
+	c := make(chan os.Signal, 1)
+	signal.Notify(c, os.Interrupt)
+	go func() {
+		for range c {
+			cmd.Process.Kill()
+		}
+	}()
+
+	// Start the command
+	cmd.Start()
+	err := cmd.Wait()
+
+	if err == nil {
+		b.isModified = false
+		b.ModTime, _ = GetModTime(filename)
+		return b.Serialize()
+	}
+	return err
+}
+
+func (b *Buffer) SetCursors(c []*Cursor) {
+	b.cursors = c
+}
+
+func (b *Buffer) GetActiveCursor() *Cursor {
+	return b.cursors[0]
+}
+
+func (b *Buffer) GetCursor(n int) *Cursor {
+	return b.cursors[n]
+}
+
+func (b *Buffer) GetCursors() []*Cursor {
+	return b.cursors
+}
+
+func (b *Buffer) NumCursors() int {
+	return len(b.cursors)
+}
+
+func (b *Buffer) LineBytes(n int) []byte {
+	if n >= len(b.lines) || n < 0 {
+		return []byte{}
+	}
+	return b.lines[n].data
+}
+
+func (b *Buffer) LinesNum() int {
+	return len(b.lines)
+}
+
+func (b *Buffer) Start() Loc {
+	return Loc{0, 0}
+}
+
+// End returns the location of the last character in the buffer
+func (b *Buffer) End() Loc {
+	numlines := len(b.lines)
+	return Loc{utf8.RuneCount(b.lines[numlines-1].data), numlines - 1}
+}
+
+// RuneAt returns the rune at a given location in the buffer
+func (b *Buffer) RuneAt(loc Loc) rune {
+	line := b.LineBytes(loc.Y)
+	if len(line) > 0 {
+		i := 0
+		for len(line) > 0 {
+			r, size := utf8.DecodeRune(line)
+			line = line[size:]
+			i++
+
+			if i == loc.X {
+				return r
+			}
+		}
+	}
+	return '\n'
+}
+
+// Modified returns if this buffer has been modified since
+// being opened
+func (b *Buffer) Modified() bool {
+	if b.Settings["fastdirty"].(bool) {
+		return b.isModified
+	}
+
+	var buff [md5.Size]byte
+
+	calcHash(b, &buff)
+	return buff != b.origHash
+}
+
+// calcHash calculates md5 hash of all lines in the buffer
+func calcHash(b *Buffer, out *[md5.Size]byte) {
+	h := md5.New()
+
+	if len(b.lines) > 0 {
+		h.Write(b.lines[0].data)
+
+		for _, l := range b.lines[1:] {
+			h.Write([]byte{'\n'})
+			h.Write(l.data)
+		}
+	}
+
+	h.Sum((*out)[:0])
+}
+
+func init() {
+	gob.Register(TextEvent{})
+	gob.Register(SerializedBuffer{})
+}
+
+// Serialize serializes the buffer to config.ConfigDir/buffers
+func (b *Buffer) Serialize() error {
+	if !b.Settings["savecursor"].(bool) && !b.Settings["saveundo"].(bool) {
+		return nil
+	}
+
+	name := config.ConfigDir + "/buffers/" + EscapePath(b.AbsPath)
+
+	return overwriteFile(name, func(file io.Writer) error {
+		return gob.NewEncoder(file).Encode(SerializedBuffer{
+			b.EventHandler,
+			b.GetActiveCursor().Loc,
+			b.ModTime,
+		})
+	})
+}
+
+func (b *Buffer) Unserialize() error {
+	// If either savecursor or saveundo is turned on, we need to load the serialized information
+	// from ~/.config/micro/buffers
+	file, err := os.Open(config.ConfigDir + "/buffers/" + EscapePath(b.AbsPath))
+	defer file.Close()
+	if err == nil {
+		var buffer SerializedBuffer
+		decoder := gob.NewDecoder(file)
+		gob.Register(TextEvent{})
+		err = decoder.Decode(&buffer)
+		if err != nil {
+			return errors.New(err.Error() + "\nYou may want to remove the files in ~/.config/micro/buffers (these files store the information for the 'saveundo' and 'savecursor' options) if this problem persists.")
+		}
+		if b.Settings["savecursor"].(bool) {
+			b.StartCursor = buffer.Cursor
+		}
+
+		if b.Settings["saveundo"].(bool) {
+			// We should only use last time's eventhandler if the file wasn't modified by someone else in the meantime
+			if b.ModTime == buffer.ModTime {
+				b.EventHandler = buffer.EventHandler
+				b.EventHandler.buf = b
+			}
+		}
+	}
+	return err
+}
+
+// UpdateRules updates the syntax rules and filetype for this buffer
+// This is called when the colorscheme changes
+func (b *Buffer) UpdateRules() {
+	rehighlight := false
+	var files []*highlight.File
+	for _, f := range config.ListRuntimeFiles(config.RTSyntax) {
+		data, err := f.Data()
+		if err != nil {
+			TermMessage("Error loading syntax file " + f.Name() + ": " + err.Error())
+		} else {
+			file, err := highlight.ParseFile(data)
+			if err != nil {
+				TermMessage("Error loading syntax file " + f.Name() + ": " + err.Error())
+				continue
+			}
+			ftdetect, err := highlight.ParseFtDetect(file)
+			if err != nil {
+				TermMessage("Error loading syntax file " + f.Name() + ": " + err.Error())
+				continue
+			}
+
+			ft := b.Settings["filetype"].(string)
+			if (ft == "Unknown" || ft == "") && !rehighlight {
+				if highlight.MatchFiletype(ftdetect, b.Path, b.lines[0].data) {
+					header := new(highlight.Header)
+					header.FileType = file.FileType
+					header.FtDetect = ftdetect
+					b.SyntaxDef, err = highlight.ParseDef(file, header)
+					if err != nil {
+						TermMessage("Error loading syntax file " + f.Name() + ": " + err.Error())
+						continue
+					}
+					rehighlight = true
+				}
+			} else {
+				if file.FileType == ft && !rehighlight {
+					header := new(highlight.Header)
+					header.FileType = file.FileType
+					header.FtDetect = ftdetect
+					b.SyntaxDef, err = highlight.ParseDef(file, header)
+					if err != nil {
+						TermMessage("Error loading syntax file " + f.Name() + ": " + err.Error())
+						continue
+					}
+					rehighlight = true
+				}
+			}
+			files = append(files, file)
+		}
+	}
+
+	if b.SyntaxDef != nil {
+		highlight.ResolveIncludes(b.SyntaxDef, files)
+	}
+
+	if b.Highlighter == nil || rehighlight {
+		if b.SyntaxDef != nil {
+			b.Settings["filetype"] = b.SyntaxDef.FileType
+			b.Highlighter = highlight.NewHighlighter(b.SyntaxDef)
+			if b.Settings["syntax"].(bool) {
+				b.Highlighter.HighlightStates(b)
+			}
+		}
+	}
+}

cmd/micro/buffer/cursor.go

@@ -0,0 +1,280 @@
+package buffer
+
+import (
+	"unicode/utf8"
+
+	runewidth "github.com/mattn/go-runewidth"
+	"github.com/zyedidia/clipboard"
+	"github.com/zyedidia/micro/cmd/micro/util"
+)
+
+// InBounds returns whether the given location is a valid character position in the given buffer
+func InBounds(pos Loc, buf *Buffer) bool {
+	if pos.Y < 0 || pos.Y >= len(buf.lines) || pos.X < 0 || pos.X > utf8.RuneCount(buf.LineBytes(pos.Y)) {
+		return false
+	}
+
+	return true
+}
+
+// The Cursor struct stores the location of the cursor in the buffer
+// as well as the selection
+type Cursor struct {
+	Buf *Buffer
+	Loc
+
+	// Last cursor x position
+	LastVisualX int
+
+	// The current selection as a range of character numbers (inclusive)
+	CurSelection [2]Loc
+	// The original selection as a range of character numbers
+	// This is used for line and word selection where it is necessary
+	// to know what the original selection was
+	OrigSelection [2]Loc
+
+	// Which cursor index is this (for multiple cursors)
+	Num int
+}
+
+// Goto puts the cursor at the given cursor's location and gives
+// the current cursor its selection too
+func (c *Cursor) Goto(b Cursor) {
+	c.X, c.Y, c.LastVisualX = b.X, b.Y, b.LastVisualX
+	c.OrigSelection, c.CurSelection = b.OrigSelection, b.CurSelection
+}
+
+// GotoLoc puts the cursor at the given cursor's location and gives
+// the current cursor its selection too
+func (c *Cursor) GotoLoc(l Loc) {
+	c.X, c.Y = l.X, l.Y
+	c.LastVisualX = c.GetVisualX()
+}
+
+// GetVisualX returns the x value of the cursor in visual spaces
+func (c *Cursor) GetVisualX() int {
+	if c.X <= 0 {
+		c.X = 0
+		return 0
+	}
+
+	bytes := c.Buf.LineBytes(c.Y)
+	tabsize := int(c.Buf.Settings["tabsize"].(float64))
+	if c.X > utf8.RuneCount(bytes) {
+		c.X = utf8.RuneCount(bytes) - 1
+	}
+
+	return util.StringWidth(bytes, c.X, tabsize)
+}
+
+// GetCharPosInLine gets the char position of a visual x y
+// coordinate (this is necessary because tabs are 1 char but
+// 4 visual spaces)
+func (c *Cursor) GetCharPosInLine(b []byte, visualPos int) int {
+	tabsize := int(c.Buf.Settings["tabsize"].(float64))
+
+	// Scan rune by rune until we exceed the visual width that we are
+	// looking for. Then we can return the character position we have found
+	i := 0     // char pos
+	width := 0 // string visual width
+	for len(b) > 0 {
+		r, size := utf8.DecodeRune(b)
+		b = b[size:]
+
+		switch r {
+		case '\t':
+			ts := tabsize - (width % tabsize)
+			width += ts
+		default:
+			width += runewidth.RuneWidth(r)
+		}
+
+		i++
+
+		if width >= visualPos {
+			break
+		}
+	}
+
+	return i
+}
+
+// Start moves the cursor to the start of the line it is on
+func (c *Cursor) Start() {
+	c.X = 0
+	c.LastVisualX = c.GetVisualX()
+}
+
+// End moves the cursor to the end of the line it is on
+func (c *Cursor) End() {
+	c.X = utf8.RuneCount(c.Buf.LineBytes(c.Y))
+	c.LastVisualX = c.GetVisualX()
+}
+
+// CopySelection copies the user's selection to either "primary"
+// or "clipboard"
+func (c *Cursor) CopySelection(target string) {
+	if c.HasSelection() {
+		if target != "primary" || c.Buf.Settings["useprimary"].(bool) {
+			clipboard.WriteAll(string(c.GetSelection()), target)
+		}
+	}
+}
+
+// ResetSelection resets the user's selection
+func (c *Cursor) ResetSelection() {
+	c.CurSelection[0] = c.Buf.Start()
+	c.CurSelection[1] = c.Buf.Start()
+}
+
+// SetSelectionStart sets the start of the selection
+func (c *Cursor) SetSelectionStart(pos Loc) {
+	c.CurSelection[0] = pos
+}
+
+// SetSelectionEnd sets the end of the selection
+func (c *Cursor) SetSelectionEnd(pos Loc) {
+	c.CurSelection[1] = pos
+}
+
+// HasSelection returns whether or not the user has selected anything
+func (c *Cursor) HasSelection() bool {
+	return c.CurSelection[0] != c.CurSelection[1]
+}
+
+// DeleteSelection deletes the currently selected text
+func (c *Cursor) DeleteSelection() {
+	if c.CurSelection[0].GreaterThan(c.CurSelection[1]) {
+		c.Buf.Remove(c.CurSelection[1], c.CurSelection[0])
+		c.Loc = c.CurSelection[1]
+	} else if !c.HasSelection() {
+		return
+	} else {
+		c.Buf.Remove(c.CurSelection[0], c.CurSelection[1])
+		c.Loc = c.CurSelection[0]
+	}
+}
+
+// GetSelection returns the cursor's selection
+func (c *Cursor) GetSelection() []byte {
+	if InBounds(c.CurSelection[0], c.Buf) && InBounds(c.CurSelection[1], c.Buf) {
+		if c.CurSelection[0].GreaterThan(c.CurSelection[1]) {
+			return c.Buf.Substr(c.CurSelection[1], c.CurSelection[0])
+		}
+		return c.Buf.Substr(c.CurSelection[0], c.CurSelection[1])
+	}
+	return []byte{}
+}
+
+// SelectLine selects the current line
+func (c *Cursor) SelectLine() {
+	c.Start()
+	c.SetSelectionStart(c.Loc)
+	c.End()
+	if len(c.Buf.lines)-1 > c.Y {
+		c.SetSelectionEnd(c.Loc.Move(1, c.Buf))
+	} else {
+		c.SetSelectionEnd(c.Loc)
+	}
+
+	c.OrigSelection = c.CurSelection
+}
+
+// AddLineToSelection adds the current line to the selection
+func (c *Cursor) AddLineToSelection() {
+	if c.Loc.LessThan(c.OrigSelection[0]) {
+		c.Start()
+		c.SetSelectionStart(c.Loc)
+		c.SetSelectionEnd(c.OrigSelection[1])
+	}
+	if c.Loc.GreaterThan(c.OrigSelection[1]) {
+		c.End()
+		c.SetSelectionEnd(c.Loc.Move(1, c.Buf))
+		c.SetSelectionStart(c.OrigSelection[0])
+	}
+
+	if c.Loc.LessThan(c.OrigSelection[1]) && c.Loc.GreaterThan(c.OrigSelection[0]) {
+		c.CurSelection = c.OrigSelection
+	}
+}
+
+// UpN moves the cursor up N lines (if possible)
+func (c *Cursor) UpN(amount int) {
+	proposedY := c.Y - amount
+	if proposedY < 0 {
+		proposedY = 0
+	} else if proposedY >= len(c.Buf.lines) {
+		proposedY = len(c.Buf.lines) - 1
+	}
+
+	bytes := c.Buf.LineBytes(proposedY)
+	c.X = c.GetCharPosInLine(bytes, c.LastVisualX)
+
+	if c.X > utf8.RuneCount(bytes) || (amount < 0 && proposedY == c.Y) {
+		c.X = utf8.RuneCount(bytes)
+	}
+
+	c.Y = proposedY
+}
+
+// DownN moves the cursor down N lines (if possible)
+func (c *Cursor) DownN(amount int) {
+	c.UpN(-amount)
+}
+
+// Up moves the cursor up one line (if possible)
+func (c *Cursor) Up() {
+	c.UpN(1)
+}
+
+// Down moves the cursor down one line (if possible)
+func (c *Cursor) Down() {
+	c.DownN(1)
+}
+
+// Left moves the cursor left one cell (if possible) or to
+// the previous line if it is at the beginning
+func (c *Cursor) Left() {
+	if c.Loc == c.Buf.Start() {
+		return
+	}
+	if c.X > 0 {
+		c.X--
+	} else {
+		c.Up()
+		c.End()
+	}
+	c.LastVisualX = c.GetVisualX()
+}
+
+// Right moves the cursor right one cell (if possible) or
+// to the next line if it is at the end
+func (c *Cursor) Right() {
+	if c.Loc == c.Buf.End() {
+		return
+	}
+	if c.X < utf8.RuneCount(c.Buf.LineBytes(c.Y)) {
+		c.X++
+	} else {
+		c.Down()
+		c.Start()
+	}
+	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() {
+	if c.Y < 0 {
+		c.Y = 0
+	} else if c.Y >= len(c.Buf.lines) {
+		c.Y = len(c.Buf.lines) - 1
+	}
+
+	if c.X < 0 {
+		c.X = 0
+	} else if c.X > utf8.RuneCount(c.Buf.LineBytes(c.Y)) {
+		c.X = utf8.RuneCount(c.Buf.LineBytes(c.Y))
+	}
+}

cmd/micro/buffer/eventhandler.go

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

cmd/micro/buffer/line_array.go

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

cmd/micro/buffer/line_array_test.go

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

cmd/micro/buffer/loc.go

@@ -0,0 +1,118 @@
+package buffer
+
+import (
+	"unicode/utf8"
+
+	"github.com/zyedidia/micro/cmd/micro/util"
+)
+
+// Loc stores a location
+type Loc struct {
+	X, Y int
+}
+
+// LessThan returns true if b is smaller
+func (l Loc) LessThan(b Loc) bool {
+	if l.Y < b.Y {
+		return true
+	}
+	return l.Y == b.Y && l.X < b.X
+}
+
+// GreaterThan returns true if b is bigger
+func (l Loc) GreaterThan(b Loc) bool {
+	if l.Y > b.Y {
+		return true
+	}
+	return l.Y == b.Y && l.X > b.X
+}
+
+// GreaterEqual returns true if b is greater than or equal to b
+func (l Loc) GreaterEqual(b Loc) bool {
+	if l.Y > b.Y {
+		return true
+	}
+	if l.Y == b.Y && l.X > b.X {
+		return true
+	}
+	return l == b
+}
+
+// LessEqual returns true if b is less than or equal to b
+func (l Loc) LessEqual(b Loc) bool {
+	if l.Y < b.Y {
+		return true
+	}
+	if l.Y == b.Y && l.X < b.X {
+		return true
+	}
+	return l == b
+}
+
+// The following functions require a buffer to know where newlines are
+
+// Diff returns the distance between two locations
+func Diff(a, b Loc, buf *Buffer) int {
+	if a.Y == b.Y {
+		if a.X > b.X {
+			return a.X - b.X
+		}
+		return b.X - a.X
+	}
+
+	// Make sure a is guaranteed to be less than b
+	if b.LessThan(a) {
+		a, b = b, a
+	}
+
+	loc := 0
+	for i := a.Y + 1; i < b.Y; i++ {
+		// + 1 for the newline
+		loc += utf8.RuneCount(buf.LineBytes(i)) + 1
+	}
+	loc += utf8.RuneCount(buf.LineBytes(a.Y)) - a.X + b.X + 1
+	return loc
+}
+
+// This moves the location one character to the right
+func (l Loc) right(buf *Buffer) Loc {
+	if l == buf.End() {
+		return Loc{l.X + 1, l.Y}
+	}
+	var res Loc
+	if l.X < utf8.RuneCount(buf.LineBytes(l.Y)) {
+		res = Loc{l.X + 1, l.Y}
+	} else {
+		res = Loc{0, l.Y + 1}
+	}
+	return res
+}
+
+// This moves the given location one character to the left
+func (l Loc) left(buf *Buffer) Loc {
+	if l == buf.Start() {
+		return Loc{l.X - 1, l.Y}
+	}
+	var res Loc
+	if l.X > 0 {
+		res = Loc{l.X - 1, l.Y}
+	} else {
+		res = Loc{utf8.RuneCount(buf.LineBytes(l.Y - 1)), l.Y - 1}
+	}
+	return res
+}
+
+// Move moves the cursor n characters to the left or right
+// It moves the cursor left if n is negative
+func (l Loc) Move(n int, buf *Buffer) Loc {
+	if n > 0 {
+		for i := 0; i < n; i++ {
+			l = l.right(buf)
+		}
+		return l
+	}
+	for i := 0; i < util.Abs(n); i++ {
+		l = l.left(buf)
+	}
+	return l
+}

cmd/micro/buffer/stack.go

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

cmd/micro/buffer/stack_test.go

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