Add bracket surround

Allow GitHub to detect license

LICENSE

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

README.md

@@ -4,6 +4,7 @@
 [![Go Report Card](https://goreportcard.com/badge/github.com/zyedidia/micro)](https://goreportcard.com/report/github.com/zyedidia/micro)
 [![Join the chat at https://gitter.im/zyedidia/micro](https://badges.gitter.im/zyedidia/micro.svg)](https://gitter.im/zyedidia/micro?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 [![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/zyedidia/micro/blob/master/LICENSE)
+[![Snap Status](https://build.snapcraft.io/badge/zyedidia/micro.svg)](https://build.snapcraft.io/user/zyedidia/micro)
 
 Micro is a terminal-based text editor that aims to be easy to use and intuitive, while also taking advantage of the full capabilities
 of modern terminals. It comes as one single, batteries-included, static binary with no dependencies, and you can download and use it right now.
@@ -142,11 +143,11 @@ that micro's default colorscheme won't look very good. You can either set
 the colorscheme to `simple`, or download a better terminal emulator, like
 mintty.
 
-### Plan9, NaCl, Cygwin
+### Plan9, Cygwin
 
 Please note that micro uses the amazing [tcell library](https://github.com/gdamore/tcell), but this
 means that micro is restricted to the platforms tcell supports. As a result, micro does not support
-Plan9, NaCl, and Cygwin (although this may change in the future).
+Plan9, and Cygwin (although this may change in the future). Micro also doesn't support NaCl (but NaCl is deprecated anyways).
 
 # Usage
 

cmd/micro/actions.go

@@ -3,6 +3,7 @@ package main
 import (
 	"fmt"
 	"os"
+	"regexp"
 	"strconv"
 	"strings"
 	"time"
@@ -249,7 +250,7 @@ func (v *View) CursorRight(usePlugin bool) bool {
 	}
 
 	if v.Cursor.HasSelection() {
-		v.Cursor.Loc = v.Cursor.CurSelection[1].Move(-1, v.Buf)
+		v.Cursor.Loc = v.Cursor.CurSelection[1]
 		v.Cursor.ResetSelection()
 		v.Cursor.StoreVisualX()
 	} else {
@@ -347,7 +348,7 @@ func (v *View) SelectLeft(usePlugin bool) bool {
 	}
 
 	loc := v.Cursor.Loc
-	count := v.Buf.End().Move(-1, v.Buf)
+	count := v.Buf.End()
 	if loc.GreaterThan(count) {
 		loc = count
 	}
@@ -370,7 +371,7 @@ func (v *View) SelectRight(usePlugin bool) bool {
 	}
 
 	loc := v.Cursor.Loc
-	count := v.Buf.End().Move(-1, v.Buf)
+	count := v.Buf.End()
 	if loc.GreaterThan(count) {
 		loc = count
 	}
@@ -996,6 +997,10 @@ func (v *View) Undo(usePlugin bool) bool {
 		return false
 	}
 
+	if v.Buf.curCursor == 0 {
+		v.Buf.clearCursors()
+	}
+
 	v.Buf.Undo()
 	messenger.Message("Undid action")
 
@@ -1011,6 +1016,10 @@ func (v *View) Redo(usePlugin bool) bool {
 		return false
 	}
 
+	if v.Buf.curCursor == 0 {
+		v.Buf.clearCursors()
+	}
+
 	v.Buf.Redo()
 	messenger.Message("Redid action")
 
@@ -1843,6 +1852,68 @@ func (v *View) PreviousSplit(usePlugin bool) bool {
 	return false
 }
 
+func (v *View) WrapBracket(usePlugin bool) bool {
+	if v.Cursor.HasSelection() {
+		lockPollEvent = true
+		event := screen.PollEvent()
+		lockPollEvent = false
+
+		ev, ok := event.(*tcell.EventKey)
+		if !ok {
+			return false
+		}
+		if !strings.Contains("()[]{}\"'", string(ev.Rune())) {
+			return false
+		}
+		start := v.Cursor.CurSelection[0]
+		end := v.Cursor.CurSelection[1]
+		if start.Y != end.Y {
+			return false
+		}
+
+		close := map[string]string{
+			")":  ")",
+			"]":  "]",
+			"}":  "}",
+			"(":  ")",
+			"[":  "]",
+			"{":  "}",
+			"\"": "\"",
+			"'":  "'",
+		}
+
+		open := map[string]string{
+			")":  "(",
+			"]":  "[",
+			"}":  "{",
+			"(":  "(",
+			"[":  "[",
+			"{":  "{",
+			"\"": "\"",
+			"'":  "'",
+		}
+
+		if usePlugin && !PreActionCall("WrapBracket", v) {
+			return false
+		}
+		r := string(ev.Rune())
+		if start.GreaterThan(end) {
+			start, end = end, start
+			v.Buf.Insert(start, open[r])
+			v.Buf.Insert(end.Move(1, v.Buf), close[r])
+			v.Cursor.CurSelection[1] = start
+		} else {
+			v.Buf.Insert(start, open[r])
+			v.Buf.Insert(end.Move(1, v.Buf), close[r])
+			v.Cursor.CurSelection[0] = start
+		}
+		if usePlugin {
+			return PostActionCall("WrapBracket", v)
+		}
+	}
+	return false
+}
+
 var curMacro []interface{}
 var recordingMacro bool
 
@@ -1903,7 +1974,7 @@ func (v *View) PlayMacro(usePlugin bool) bool {
 	return true
 }
 
-// SpawnMultiCursor creates a new multiple cursor at the next occurence of the current selection or current word
+// SpawnMultiCursor creates a new multiple cursor at the next occurrence of the current selection or current word
 func (v *View) SpawnMultiCursor(usePlugin bool) bool {
 	spawner := v.Buf.cursors[len(v.Buf.cursors)-1]
 	// You can only spawn a cursor from the main cursor
@@ -1923,7 +1994,7 @@ func (v *View) SpawnMultiCursor(usePlugin bool) bool {
 
 			searchStart = spawner.CurSelection[1]
 			v.Cursor = c
-			Search(sel, v, true)
+			Search(regexp.QuoteMeta(sel), v, true)
 
 			for _, cur := range v.Buf.cursors {
 				if c.Loc == cur.Loc {
@@ -1985,7 +2056,7 @@ func (v *View) SkipMultiCursor(usePlugin bool) bool {
 
 		searchStart = cursor.CurSelection[1]
 		v.Cursor = cursor
-		Search(sel, v, true)
+		Search(regexp.QuoteMeta(sel), v, true)
 		v.Relocate()
 		v.Cursor = cursor
 
@@ -2028,12 +2099,7 @@ func (v *View) RemoveAllMultiCursors(usePlugin bool) bool {
 			return false
 		}
 
-		for i := 1; i < len(v.Buf.cursors); i++ {
-			v.Buf.cursors[i] = nil
-		}
-		v.Buf.cursors = v.Buf.cursors[:1]
-		v.Buf.UpdateCursors()
-		v.Cursor.ResetSelection()
+		v.Buf.clearCursors()
 		v.Relocate()
 
 		if usePlugin {

cmd/micro/bindings.go

@@ -69,6 +69,7 @@ var bindingActions = map[string]func(*View, bool) bool{
 	"PastePrimary":          (*View).PastePrimary,
 	"SelectAll":             (*View).SelectAll,
 	"OpenFile":              (*View).OpenFile,
+	"WrapBracket":           (*View).WrapBracket,
 	"Start":                 (*View).Start,
 	"End":                   (*View).End,
 	"PageUp":                (*View).PageUp,
@@ -438,6 +439,7 @@ func DefaultBindings() map[string]string {
 		"Down":           "CursorDown",
 		"Right":          "CursorRight",
 		"Left":           "CursorLeft",
+		"Alt-j":          "WrapBracket",
 		"ShiftUp":        "SelectUp",
 		"ShiftDown":      "SelectDown",
 		"ShiftLeft":      "SelectLeft",

cmd/micro/buffer.go

@@ -19,6 +19,13 @@ import (
 	"github.com/zyedidia/micro/cmd/micro/highlight"
 )
 
+var (
+	// 0 - no line type detected
+	// 1 - lf detected
+	// 2 - crlf detected
+	fileformat = 0
+)
+
 // Buffer stores the text for files that are loaded into the text editor
 // It uses a rope to efficiently store the string and contains some
 // simple functions for saving and wrapper functions for modifying the rope
@@ -88,6 +95,12 @@ func NewBuffer(reader io.Reader, size int64, path string) *Buffer {
 		}
 	}
 
+	if fileformat == 1 {
+		b.Settings["fileformat"] = "unix"
+	} else if fileformat == 2 {
+		b.Settings["fileformat"] = "dos"
+	}
+
 	absPath, _ := filepath.Abs(path)
 
 	b.Path = path
@@ -171,6 +184,10 @@ func NewBuffer(reader io.Reader, size int64, path string) *Buffer {
 		file.Close()
 	}
 
+	if b.Settings["mouse"].(bool) {
+		screen.EnableMouse()
+	}
+
 	b.cursors = []*Cursor{&b.Cursor}
 
 	return b
@@ -240,7 +257,6 @@ func (b *Buffer) UpdateRules() {
 	if b.syntaxDef != nil {
 		highlight.ResolveIncludes(b.syntaxDef, files)
 	}
-	files = nil
 
 	if b.highlighter == nil || rehighlight {
 		if b.syntaxDef != nil {
@@ -356,7 +372,7 @@ func (b *Buffer) Serialize() error {
 				b.ModTime,
 			})
 		}
-		file.Close()
+		err = file.Close()
 		return err
 	}
 	return nil
@@ -384,7 +400,7 @@ func (b *Buffer) SaveAs(filename string) error {
 			b.Insert(end, "\n")
 		}
 	}
-	str := b.String()
+	str := b.SaveString(b.Settings["fileformat"] == "dos")
 	data := []byte(str)
 	err := ioutil.WriteFile(filename, data, 0644)
 	if err == nil {
@@ -409,7 +425,7 @@ func (b *Buffer) SaveAsWithSudo(filename string) error {
 
 	// Set up everything for the command
 	cmd := exec.Command("sudo", "tee", filename)
-	cmd.Stdin = bytes.NewBufferString(b.String())
+	cmd.Stdin = bytes.NewBufferString(b.SaveString(b.Settings["fileformat"] == "dos"))
 
 	// 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
@@ -550,3 +566,12 @@ func (b *Buffer) ClearMatches() {
 		b.SetState(i, nil)
 	}
 }
+
+func (b *Buffer) clearCursors() {
+	for i := 1; i < len(b.cursors); i++ {
+		b.cursors[i] = nil
+	}
+	b.cursors = b.cursors[:1]
+	b.UpdateCursors()
+	b.Cursor.ResetSelection()
+}

cmd/micro/cursor.go

@@ -250,19 +250,19 @@ func (c *Cursor) UpN(amount int) {
 	proposedY := c.Y - amount
 	if proposedY < 0 {
 		proposedY = 0
+		c.LastVisualX = 0
 	} else if proposedY >= c.buf.NumLines {
 		proposedY = c.buf.NumLines - 1
 	}
-	if proposedY == c.Y {
-		return
-	}
 
-	c.Y = proposedY
 	runes := []rune(c.buf.Line(c.Y))
-	c.X = c.GetCharPosInLine(c.Y, c.LastVisualX)
+	c.X = c.GetCharPosInLine(proposedY, c.LastVisualX)
+
 	if c.X > len(runes) {
 		c.X = len(runes)
 	}
+
+	c.Y = proposedY
 }
 
 // DownN moves the cursor down N lines (if possible)

cmd/micro/eventhandler.go

@@ -48,6 +48,11 @@ func ExecuteTextEvent(t *TextEvent, buf *Buffer) {
 		for i, d := range t.Deltas {
 			t.Deltas[i].Text = buf.remove(d.Start, d.End)
 			buf.insert(d.Start, []byte(d.Text))
+			t.Deltas[i].Start = d.Start
+			t.Deltas[i].End = Loc{d.Start.X + Count(d.Text), d.Start.Y}
+		}
+		for i, j := 0, len(t.Deltas)-1; i < j; i, j = i+1, j-1 {
+			t.Deltas[i], t.Deltas[j] = t.Deltas[j], t.Deltas[i]
 		}
 	}
 }
@@ -99,7 +104,7 @@ func (eh *EventHandler) Insert(start Loc, text string) {
 	e := &TextEvent{
 		C:         *eh.buf.cursors[eh.buf.curCursor],
 		EventType: TextEventInsert,
-		Deltas:    []Delta{Delta{text, start, Loc{0, 0}}},
+		Deltas:    []Delta{{text, start, Loc{0, 0}}},
 		Time:      time.Now(),
 	}
 	eh.Execute(e)
@@ -129,7 +134,7 @@ func (eh *EventHandler) Remove(start, end Loc) {
 	e := &TextEvent{
 		C:         *eh.buf.cursors[eh.buf.curCursor],
 		EventType: TextEventRemove,
-		Deltas:    []Delta{Delta{"", start, end}},
+		Deltas:    []Delta{{"", start, end}},
 		Time:      time.Now(),
 	}
 	eh.Execute(e)

cmd/micro/lineArray.go

@@ -71,6 +71,16 @@ func NewLineArray(size int64, reader io.Reader) *LineArray {
 	n := 0
 	for {
 		data, err := br.ReadBytes('\n')
+		if len(data) > 1 && data[len(data)-2] == '\r' {
+			data = append(data[:len(data)-2], '\n')
+			if fileformat == 0 {
+				fileformat = 2
+			}
+		} else if len(data) > 0 {
+			if fileformat == 0 {
+				fileformat = 1
+			}
+		}
 
 		if n >= 1000 && loaded >= 0 {
 			totalLinesNum := int(float64(size) * (float64(n) / float64(loaded)))
@@ -87,7 +97,7 @@ func NewLineArray(size int64, reader io.Reader) *LineArray {
 
 		if err != nil {
 			if err == io.EOF {
-				la.lines = Append(la.lines, Line{data[:len(data)], nil, nil, false})
+				la.lines = Append(la.lines, Line{data[:], nil, nil, false})
 				// la.lines = Append(la.lines, Line{data[:len(data)]})
 			}
 			// Last line was read
@@ -114,6 +124,23 @@ func (la *LineArray) String() string {
 	return str
 }
 
+// SaveString returns the string that should be written to disk when
+// the line array is saved
+// It is the same as string but uses crlf or lf line endings depending
+func (la *LineArray) SaveString(useCrlf bool) string {
+	str := ""
+	for i, l := range la.lines {
+		str += string(l.data)
+		if i != len(la.lines)-1 {
+			if useCrlf {
+				str += "\r"
+			}
+			str += "\n"
+		}
+	}
+	return str
+}
+
 // 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})

cmd/micro/lua.go

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

cmd/micro/messenger.go

@@ -7,9 +7,9 @@ import (
 	"os"
 	"strconv"
 
+	"github.com/mattn/go-runewidth"
 	"github.com/zyedidia/clipboard"
 	"github.com/zyedidia/tcell"
-	"github.com/mattn/go-runewidth"
 )
 
 // TermMessage sends a message to the user in the terminal. This usually occurs before
@@ -70,9 +70,11 @@ type Messenger struct {
 	gutterMessage bool
 }
 
-func (m *Messenger) AddLog(msg string) {
+// AddLog sends a message to the log view
+func (m *Messenger) AddLog(msg ...interface{}) {
+	logMessage := fmt.Sprint(msg...)
 	buffer := m.getBuffer()
-	buffer.insert(buffer.End(), []byte(msg+"\n"))
+	buffer.insert(buffer.End(), []byte(logMessage+"\n"))
 	buffer.Cursor.Loc = buffer.End()
 	buffer.Cursor.Relocate()
 }

cmd/micro/micro.go

@@ -48,10 +48,6 @@ var (
 	CommitHash  = "Unknown"
 	CompileDate = "Unknown"
 
-	// L is the lua state
-	// This is the VM that runs the plugins
-	L *lua.LState
-
 	// The list of views
 	tabs []*Tab
 	// This is the currently open tab
@@ -63,6 +59,9 @@ var (
 	// Event channel
 	events   chan tcell.Event
 	autosave chan bool
+
+	// Read events on another thread or wait for a temporary read
+	lockPollEvent bool
 )
 
 // LoadInput determines which files should be loaded into buffers
@@ -147,6 +146,15 @@ func InitConfigDir() {
 	}
 	configDir = xdgHome + "/micro"
 
+	if len(*flagConfigDir) > 0 {
+		if _, err := os.Stat(*flagConfigDir); os.IsNotExist(err) {
+			TermMessage("Error: " + *flagConfigDir + " does not exist. Defaulting to " + configDir + ".")
+		} else {
+			configDir = *flagConfigDir
+			return
+		}
+	}
+
 	if _, err := os.Stat(xdgHome); os.IsNotExist(err) {
 		// If the xdgHome doesn't exist we should create it
 		err = os.Mkdir(xdgHome, os.ModePerm)
@@ -198,7 +206,6 @@ func InitScreen() {
 	}
 
 	screen.SetStyle(defStyle)
-	screen.EnableMouse()
 }
 
 // RedrawAll redraws everything -- all the views and the messenger
@@ -245,19 +252,24 @@ func LoadAll() {
 // Passing -version as a flag will have micro print out the version number
 var flagVersion = flag.Bool("version", false, "Show the version number and information")
 var flagStartPos = flag.String("startpos", "", "LINE,COL to start the cursor at when opening a buffer.")
+var flagConfigDir = flag.String("config-dir", "", "Specify a custom location for the configuration directory")
+var optionFlagSet = flag.NewFlagSet("option", flag.ExitOnError)
 
 func main() {
 	flag.Usage = func() {
 		fmt.Println("Usage: micro [OPTIONS] [FILE]...")
-		fmt.Print("Micro's options can be set via command line arguments for quick adjustments. For real configuration, please use the bindings.json file (see 'help options').\n\n")
 		flag.CommandLine.SetOutput(os.Stdout)
 		flag.PrintDefaults()
+		optionFlagSet.SetOutput(os.Stdout)
+		fmt.Print("\n------------------------------------------------------------------\n")
+		fmt.Print("Micro's options can also be set via command line arguments for quick\nadjustments. For real configuration, please use the bindings.json\nfile (see 'help options').\n\n")
+		optionFlagSet.PrintDefaults()
 	}
 
 	optionFlags := make(map[string]*string)
 
 	for k, v := range DefaultGlobalSettings() {
-		optionFlags[k] = flag.String(k, "", fmt.Sprintf("The %s option. Default value: '%v'", k, v))
+		optionFlags[k] = optionFlagSet.String(k, "", fmt.Sprintf("The %s option. Default value: '%v'", k, v))
 	}
 
 	flag.Parse()
@@ -363,6 +375,7 @@ func main() {
 	L.SetGlobal("Loc", luar.New(L, func(x, y int) Loc {
 		return Loc{x, y}
 	}))
+	L.SetGlobal("WorkingDirectory", luar.New(L, os.Getwd))
 	L.SetGlobal("JoinPaths", luar.New(L, filepath.Join))
 	L.SetGlobal("DirectoryName", luar.New(L, filepath.Dir))
 	L.SetGlobal("configDir", luar.New(L, configDir))
@@ -383,6 +396,9 @@ func main() {
 	L.SetGlobal("AddRuntimeFilesFromDirectory", luar.New(L, PluginAddRuntimeFilesFromDirectory))
 	L.SetGlobal("AddRuntimeFileFromMemory", luar.New(L, PluginAddRuntimeFileFromMemory))
 
+	// Access to Go stdlib
+	L.SetGlobal("import", luar.New(L, Import))
+
 	jobs = make(chan JobFunction, 100)
 	events = make(chan tcell.Event, 100)
 	autosave = make(chan bool)
@@ -406,8 +422,9 @@ func main() {
 	// Here is the event loop which runs in a separate thread
 	go func() {
 		for {
-			if screen != nil {
+			if screen != nil && !lockPollEvent {
 				events <- screen.PollEvent()
+				time.Sleep(1 * time.Millisecond)
 			}
 		}
 	}()

cmd/micro/plugin.go

@@ -130,11 +130,9 @@ func luaPluginName(name string) string {
 
 // LoadPlugins loads the pre-installed plugins and the plugins located in ~/.config/micro/plugins
 func LoadPlugins() {
-
 	loadedPlugins = make(map[string]string)
 
 	for _, plugin := range ListRuntimeFiles(RTPlugin) {
-
 		pluginName := plugin.Name()
 		if _, ok := loadedPlugins[pluginName]; ok {
 			continue
@@ -147,9 +145,8 @@ func LoadPlugins() {
 		}
 
 		pluginLuaName := luaPluginName(pluginName)
-		pluginDef := "\nlocal P = {}\n" + pluginLuaName + " = P\nsetmetatable(" + pluginLuaName + ", {__index = _G})\nsetfenv(1, P)\n"
 
-		if err := L.DoString(pluginDef + string(data)); err != nil {
+		if err := LoadFile(pluginName, pluginName, string(data)); err != nil {
 			TermMessage(err)
 			continue
 		}
@@ -159,9 +156,8 @@ func LoadPlugins() {
 	}
 
 	if _, err := os.Stat(configDir + "/init.lua"); err == nil {
-		pluginDef := "\nlocal P = {}\n" + "init" + " = P\nsetmetatable(" + "init" + ", {__index = _G})\nsetfenv(1, P)\n"
 		data, _ := ioutil.ReadFile(configDir + "/init.lua")
-		if err := L.DoString(pluginDef + string(data)); err != nil {
+		if err := LoadFile("init", configDir+"init.lua", string(data)); err != nil {
 			TermMessage(err)
 		}
 		loadedPlugins["init"] = "init"

cmd/micro/pluginmanager.go

@@ -8,6 +8,7 @@ import (
 	"io/ioutil"
 	"net/http"
 	"os"
+	"path"
 	"path/filepath"
 	"sort"
 	"strings"
@@ -434,6 +435,12 @@ func (pv *PluginVersion) DownloadAndInstall() error {
 				return err
 			}
 		} else {
+			basepath := path.Dir(targetName)
+
+			if err := os.MkdirAll(basepath, dirPerm); err != nil {
+				return err
+			}
+
 			content, err := f.Open()
 			if err != nil {
 				return err

cmd/micro/search.go

@@ -113,6 +113,8 @@ func searchDown(r *regexp.Regexp, v *View, start, end Loc) bool {
 		if match != nil {
 			v.Cursor.SetSelectionStart(Loc{charPos + runePos(match[0], string(l)), i})
 			v.Cursor.SetSelectionEnd(Loc{charPos + runePos(match[1], string(l)), i})
+			v.Cursor.OrigSelection[0] = v.Cursor.CurSelection[0]
+			v.Cursor.OrigSelection[1] = v.Cursor.CurSelection[1]
 			v.Cursor.Loc = v.Cursor.CurSelection[1]
 
 			return true
@@ -140,6 +142,8 @@ func searchUp(r *regexp.Regexp, v *View, start, end Loc) bool {
 		if match != nil {
 			v.Cursor.SetSelectionStart(Loc{runePos(match[0], string(l)), i})
 			v.Cursor.SetSelectionEnd(Loc{runePos(match[1], string(l)), i})
+			v.Cursor.OrigSelection[0] = v.Cursor.CurSelection[0]
+			v.Cursor.OrigSelection[1] = v.Cursor.CurSelection[1]
 			v.Cursor.Loc = v.Cursor.CurSelection[1]
 
 			return true

cmd/micro/settings.go

@@ -27,6 +27,7 @@ var optionValidators = map[string]optionValidator{
 	"scrollspeed":  validateNonNegativeValue,
 	"colorscheme":  validateColorscheme,
 	"colorcolumn":  validateNonNegativeValue,
+	"fileformat":   validateLineEnding,
 }
 
 // InitGlobalSettings initializes the options map and sets all options to their default values
@@ -220,6 +221,8 @@ func DefaultGlobalSettings() map[string]interface{} {
 		},
 		"pluginrepos": []string{},
 		"useprimary":  true,
+		"fileformat":  "unix",
+		"mouse":       true,
 	}
 }
 
@@ -251,6 +254,8 @@ func DefaultLocalSettings() map[string]interface{} {
 		"tabsize":        float64(4),
 		"tabstospaces":   false,
 		"useprimary":     true,
+		"fileformat":     "unix",
+		"mouse":          true,
 	}
 }
 
@@ -365,6 +370,10 @@ func SetLocalOption(option, value string, view *View) error {
 		buf.UpdateRules()
 	}
 
+	if option == "fileformat" {
+		buf.IsModified = true
+	}
+
 	if option == "syntax" {
 		if !nativeValue.(bool) {
 			buf.ClearMatches()
@@ -373,6 +382,14 @@ func SetLocalOption(option, value string, view *View) error {
 		}
 	}
 
+	if option == "mouse" {
+		if !nativeValue.(bool) {
+			screen.DisableMouse()
+		} else {
+			screen.EnableMouse()
+		}
+	}
+
 	return nil
 }
 
@@ -445,3 +462,17 @@ func validateColorscheme(option string, value interface{}) error {
 
 	return nil
 }
+
+func validateLineEnding(option string, value interface{}) error {
+	endingType, ok := value.(string)
+
+	if !ok {
+		return errors.New("Expected string type for file format")
+	}
+
+	if endingType != "unix" && endingType != "dos" {
+		return errors.New("File format must be either 'unix' or 'dos'")
+	}
+
+	return nil
+}

cmd/micro/statusline.go

@@ -36,6 +36,8 @@ func (sline *Statusline) Display() {
 	// Add the filetype
 	file += " " + sline.view.Buf.FileType()
 
+	file += " " + sline.view.Buf.Settings["fileformat"].(string)
+
 	rightText := ""
 	if len(helpBinding) > 0 {
 		rightText = helpBinding + " for help "

cmd/micro/view.go

@@ -479,9 +479,14 @@ func (v *View) ExecuteActions(actions []func(*View, bool) bool) bool {
 	return relocate
 }
 
-func (v *View) SetCursor(c *Cursor) {
+func (v *View) SetCursor(c *Cursor) bool {
+	if c == nil {
+		return false
+	}
 	v.Cursor = c
 	v.Buf.curCursor = c.Num
+
+	return true
 }
 
 // HandleEvent handles an event passed by the main loop
@@ -505,7 +510,10 @@ func (v *View) HandleEvent(event tcell.Event) {
 				}
 				if e.Modifiers() == key.modifiers {
 					for _, c := range v.Buf.cursors {
-						v.SetCursor(c)
+						ok := v.SetCursor(c)
+						if !ok {
+							break
+						}
 						relocate = false
 						isBinding = true
 						relocate = v.ExecuteActions(actions) || relocate
@@ -553,7 +561,6 @@ func (v *View) HandleEvent(event tcell.Event) {
 			for _, c := range v.Buf.cursors {
 				v.SetCursor(c)
 				v.paste(e.Text())
-
 			}
 			v.SetCursor(&v.Buf.Cursor)
 
@@ -568,7 +575,10 @@ func (v *View) HandleEvent(event tcell.Event) {
 		for key, actions := range bindings {
 			if button == key.buttons && e.Modifiers() == key.modifiers {
 				for _, c := range v.Buf.cursors {
-					v.SetCursor(c)
+					ok := v.SetCursor(c)
+					if !ok {
+						break
+					}
 					relocate = v.ExecuteActions(actions) || relocate
 				}
 				v.SetCursor(&v.Buf.Cursor)
@@ -935,7 +945,7 @@ func (v *View) DisplayView() {
 
 		if v.Buf.Settings["cursorline"].(bool) && tabs[curTab].CurView == v.Num &&
 			!v.Cursor.HasSelection() && v.Cursor.Y == realLineN {
-			for i := lastX; i < xOffset+v.Width; i++ {
+			for i := lastX; i < xOffset+v.Width-v.lineNumOffset; i++ {
 				style := GetColor("cursor-line")
 				fg, _, _ := style.Decompose()
 				style = style.Background(fg)

runtime/help/options.md

@@ -155,6 +155,12 @@ Here are the options that you can set:
 
     default value: `off`
 
+* `mouse`: whether to enable mouse support. When mouse support is disabled, usually the terminal will be able
+   to access mouse events which can be useful if you want to copy from the terminal instead of from micro (if
+   over ssh for example, because the terminal has access to the local clipboard and micro does not).
+
+    default value: `on`
+
 ---
 
 Default plugin options:
@@ -173,6 +179,13 @@ Default plugin options:
 
 	default value: `on`
 
+* `fileformat`: this determines what kind of line endings micro will use for the file. Unix line endings
+   are just `\n` (lf) whereas dos line endings are `\r\n` (crlf). The two possible values for this option
+   are `unix` and `dos`. The fileformat will be automatically detected and displayed on the statusline but
+   this option is useful if you would like to change the line endings or if you are starting a new file.
+
+    default value: `unix`
+
 Any option you set in the editor will be saved to the file 
 ~/.config/micro/settings.json so, in effect, your configuration file will be 
 created for you. If you'd like to take your configuration with you to another

runtime/help/plugins.md

@@ -71,9 +71,11 @@ as Go's GOOS variable, so `darwin`, `windows`, `linux`, `freebsd`...)
 
 * `Loc(x, y int) Loc`: returns a new `Loc` struct
 
-* `JoinPaths(dir... string) string` combines multiple directories to a full path
+* `WorkingDirectory() string`: returns a rooted path name to the current working directory
 
-* `DirectoryName(path string)` returns all but the last element of path ,typically the path's directory
+* `JoinPaths(dir... string) string`: combines multiple directories to a full path
+
+* `DirectoryName(path string)`: returns all but the last element of path ,typically the path's directory
 
 * `GetOption(name string)`: returns the value of the requested option
 
@@ -140,10 +142,63 @@ The possible methods which you can call using the `messenger` variable are:
 
 * `messenger.Message(msg ...interface{})`
 * `messenger.Error(msg ...interface{})`
-* `messenger.YesNoPrompt(prompt string) (bool, bool)`
+* `messenger.YesNoPrompt(prompt string) (bool,bool)`
 * `messenger.Prompt(prompt, historyType string, completionType Completion) (string, bool)`
+* `messenger.AddLog(msg ...interface{})`
 
-If you want a standard prompt, just use `messenger.Prompt(prompt, "", 0)`
+## Note 
+Go function signatures use `.` and lua uses `:` so
+
+```go
+messenger.Message()
+```
+
+turns to
+
+```lua
+messenger:Message()
+```
+
+If you want a standard prompt, just use
+```lua
+messenger:Prompt(prompt, "", 0)
+```
+
+Debug or logging your plugin can be done with below lua example code.
+```lua
+messenger:AddLog("Message goes here ",pluginVariableToPrintHere)
+```
+
+In Micro to see your plugin logging output press `CtrlE` then type `log`
+A logging window will open and any logging sent from your plugin will be displayed here.
+
+# Accessing the Go standard library
+
+It is possible for your lua code to access many of the functions in the Go standard library.
+
+Simply import the package you'd like and then you can use it. For example:
+
+```lua
+local ioutil = import("ioutil")
+local fmt = import("fmt")
+
+local data, err = ioutil.ReadFile("SomeFile.txt")
+
+if err ~= nil then
+    messenger:Error("Error reading file: SomeFile.txt")
+else
+    -- Data is returned as an array of bytes
+    -- Using Sprintf will convert it to a string
+    local str = fmt.Sprintf("%s", data)
+
+    -- Do something with the file you just read!
+    -- ...
+end
+```
+
+For a full list of which packages and functions from the standard library
+you can access, look at `lua.go` in the source code (it shouldn't be
+too hard to look through).
 
 # Adding help files, syntax files, or colorschemes in your plugin
 

runtime/plugins/autoclose/autoclose.lua

@@ -1108,6 +1108,7 @@ function preInsertNewline(v)
                 v:InsertNewline(false)
                 v:InsertTab(false)
                 v.Buf:Insert(-v.Cursor.Loc, "\n" .. ws)
+                v:StartOfLine(false)
                 v:CursorLeft(false)
                 return false
             end

runtime/syntax/julia.yaml

@@ -0,0 +1,41 @@
+filetype: julia
+
+detect:
+    filename: "\\.jl$"
+    header: "^#!.*/(env +)?julia( |$)"
+
+rules:
+
+    # built-in objects
+    - constant.bool: "\\b(true|false)\\b"
+      # built-in attributes
+    - constant: "__[A-Za-z0-9_]+__"
+      # definitions
+    - identifier: "[A-Za-z_][A-Za-z0-9_]*[[:space:]]*[(]"
+      # keywords
+    - statement: "\\b(begin|break|catch|continue|function|elseif|else|end|finally|for|global|local|if|include|using|require|macro|println|return|try|type|while|module)\\b"
+      # decorators
+    - identifier.macro: "@[A-Za-z0-9_]+"
+      # operators
+    - symbol.operator: "[-+*/|=%<>&~^]|\\b(and|not|or|is|in)\\b"
+      # parentheses
+    - symbol.brackets: "([(){}]|\\[|\\])"
+      # numbers
+    - constant.number: "\\b[0-9]+\\b"
+
+    - constant.string: "\"(\\\\.|[^\"])*\"|'(\\\\.|[^'])*'"
+
+    - constant.string:
+        start: "\"\"\""
+        end: "\"\"\""
+        rules: []
+
+    - constant.string:
+        start: "'''"
+        end: "'''"
+        rules: []
+
+    - comment:
+        start: "#"
+        end: "$"
+        rules: []

runtime/syntax/ledger.yaml

@@ -1,7 +1,7 @@
 filetype: ledger
 
 detect: 
-    filename: "(^|\\.|/)ledger|ldgr|beancount|bnct$"
+    filename: "(^|\\.|/)(ledger|ldgr|beancount|bnct)$"
 
 rules:
     - special: "^([0-9]{4}(/|-)[0-9]{2}(/|-)[0-9]{2}|[=~]) .*"

runtime/syntax/syntax_checker.go

@@ -15,16 +15,24 @@ func main() {
 	for _, f := range files {
 		if strings.HasSuffix(f.Name(), ".yaml") {
 			input, _ := ioutil.ReadFile(f.Name())
-			_, err := highlight.ParseDef(input)
+			//fmt.Println("Checking file -> ", f.Name())
+			file, err := highlight.ParseFile(input)
 			if err != nil {
 				hadErr = true
-				fmt.Printf("%s:\n", f.Name())
+				fmt.Printf("Could not parse file -> %s:\n", f.Name())
 				fmt.Println(err)
 				continue
 			}
+			_, err1 := highlight.ParseDef(file, nil)
+			if err1 != nil {
+				hadErr = true
+				fmt.Printf("Could not parse input file using highlight.ParseDef(%s):\n", f.Name())
+				fmt.Println(err1)
+				continue
+			}
 		}
 	}
 	if !hadErr {
-		fmt.Println("No issues!")
+		fmt.Println("No issues found!")
 	}
 }

runtime/syntax/syntax_converter.go

@@ -105,11 +105,9 @@ func parseFile(text, filename string) (filetype, syntax, header string, rules []
 			var start string
 			var end string
 			// Use m and s flags by default
-			flags := "ms"
 			if len(submatch) == 5 {
 				// If len is 5 the user provided some additional flags
 				color = string(submatch[1])
-				flags += string(submatch[2])
 				start = string(submatch[3])
 				end = string(submatch[4])
 			} else if len(submatch) == 4 {

runtime/syntax/yaml.yaml

@@ -15,16 +15,16 @@ rules:
     - special:  "(^---|^\\.\\.\\.|^%YAML|^%TAG)"
 
     - constant.string:
-        start: "\""
+        start: "(^| )\""
         end: "\""
         skip: "\\\\."
         rules:
             - constant.specialChar: "\\\\."
 
     - constant.string:
-        start: "'"
+        start: "(^| )'"
         end: "'"
-        skip: "\\\\."
+        skip: "(\\\\.)|('')"
         rules:
             - constant.specialChar: "\\\\."
 

tools/semver/semver.go

@@ -26,7 +26,7 @@ type Version struct {
 	Minor uint64
 	Patch uint64
 	Pre   []PRVersion
-	Build []string //No Precendence
+	Build []string //No Precedence
 }
 
 // Version to string