aliases.go

@@ -9,40 +9,40 @@ import (
 	rt "github.com/arnodel/golua/runtime"
 )
 
-var aliases *aliasModule
+var aliases *aliasHandler
 
-type aliasModule struct {
+type aliasHandler struct {
 	aliases map[string]string
 	mu *sync.RWMutex
 }
 
 // initialize aliases map
-func newAliases() *aliasModule {
+func newAliases() *aliasHandler {
-	return &aliasModule{
+	return &aliasHandler{
 		aliases: make(map[string]string),
 		mu: &sync.RWMutex{},
 	}
 }
 
-func (a *aliasModule) Add(alias, cmd string) {
+func (a *aliasHandler) Add(alias, cmd string) {
 	a.mu.Lock()
 	defer a.mu.Unlock()
 
 	a.aliases[alias] = cmd
 }
 
-func (a *aliasModule) All() map[string]string {
+func (a *aliasHandler) All() map[string]string {
 	return a.aliases
 }
 
-func (a *aliasModule) Delete(alias string) {
+func (a *aliasHandler) Delete(alias string) {
 	a.mu.Lock()
 	defer a.mu.Unlock()
 
 	delete(a.aliases, alias)
 }
 
-func (a *aliasModule) Resolve(cmdstr string) string {
+func (a *aliasHandler) Resolve(cmdstr string) string {
 	a.mu.RLock()
 	defer a.mu.RUnlock()
 
@@ -66,9 +66,7 @@ func (a *aliasModule) Resolve(cmdstr string) string {
 
 // lua section
 
-// #interface
+func (a *aliasHandler) Loader(rtm *rt.Runtime) *rt.Table {
-// ALIAS LOADER TEST
-func (a *aliasModule) Loader(rtm *rt.Runtime) *rt.Table {
 	// create a lua module with our functions
 	hshaliasesLua := map[string]util.LuaExport{
 		"add": util.LuaExport{hlalias, 2, false},
@@ -83,7 +81,7 @@ func (a *aliasModule) Loader(rtm *rt.Runtime) *rt.Table {
 	return mod
 }
 
-func (a *aliasModule) luaList(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+func (a *aliasHandler) luaList(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
 	aliasesList := rt.NewTable()
 	for k, v := range a.All() {
 		aliasesList.Set(rt.StringValue(k), rt.StringValue(v))
@@ -92,7 +90,7 @@ func (a *aliasModule) luaList(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
 	return c.PushingNext1(t.Runtime, rt.TableValue(aliasesList)), nil
 }
 
-func (a *aliasModule) luaDelete(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+func (a *aliasHandler) luaDelete(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
 	if err := c.Check1Arg(); err != nil {
 		return nil, err
 	}
@@ -105,7 +103,7 @@ func (a *aliasModule) luaDelete(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
 	return c.Next(), nil
 }
 
-func (a *aliasModule) luaResolve(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+func (a *aliasHandler) luaResolve(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
 	if err := c.Check1Arg(); err != nil {
 		return nil, err
 	}

api.go

@@ -159,10 +159,10 @@ func hilbishLoad(rtm *rt.Runtime) (rt.Value, func()) {
 	mod.Set(rt.StringValue("jobs"), rt.TableValue(jobModule))
 
 	// hilbish.timers table
-	timers = newTimersModule()
+	timers = newTimerHandler()
-	timersModule := timers.loader(rtm)
+	timerModule := timers.loader(rtm)
-	util.Document(timersModule, "Timer interface, for control of all intervals and timeouts.")
+	util.Document(timerModule, "Timer interface, for control of all intervals and timeouts.")
-	mod.Set(rt.StringValue("timers"), rt.TableValue(timersModule))
+	mod.Set(rt.StringValue("timers"), rt.TableValue(timerModule))
 
 	editorModule := editorLoader(rtm)
 	util.Document(editorModule, "")

cmd/docgen/docgen.go

@@ -9,7 +9,6 @@ import (
 	"go/token"
 	"strings"
 	"os"
-	"sync"
 )
 
 var header = `---
@@ -30,7 +29,6 @@ type module struct {
 	Docs []docPiece
 	ShortDescription string
 	Description string
-	Interface bool
 }
 type docPiece struct {
 	Doc []string
@@ -38,56 +36,6 @@ type docPiece struct {
 	FuncName string
 }
 
-var docs = make(map[string]module)
-var emmyDocs = make(map[string][]emmyPiece)
-var prefix = map[string]string{
-	"main": "hl",
-	"hilbish": "hl",
-	"fs": "f",
-	"commander": "c",
-	"bait": "b",
-	"terminal": "term",
-}
-
-func setupDoc(mod string, fun *doc.Func) *docPiece {
-	if !strings.HasPrefix(fun.Name, "hl") && mod == "main" {
-		return nil
-	}
-	if !strings.HasPrefix(fun.Name, prefix[mod]) || fun.Name == "Loader" {
-		return nil
-	}
-	parts := strings.Split(strings.TrimSpace(fun.Doc), "\n")
-	funcsig := parts[0]
-	doc := parts[1:]
-	funcdoc := []string{}
-	em := emmyPiece{FuncName: strings.TrimPrefix(fun.Name, prefix[mod])}
-	for _, d := range doc {
-		if strings.HasPrefix(d, "---") {
-			emmyLine := strings.TrimSpace(strings.TrimPrefix(d, "---"))
-			emmyLinePieces := strings.Split(emmyLine, " ")
-			emmyType := emmyLinePieces[0]
-			if emmyType == "@param" {
-				em.Params = append(em.Params, emmyLinePieces[1])
-			}
-			if emmyType == "@vararg" {
-				em.Params = append(em.Params, "...") // add vararg
-			}
-			em.Docs = append(em.Docs, d)
-		} else {
-			funcdoc = append(funcdoc, d)
-		}
-	}
-			
-	dps := docPiece{
-		Doc: funcdoc,
-		FuncSig: funcsig,
-		FuncName: strings.TrimPrefix(fun.Name, prefix[mod]),
-	}
-			
-	emmyDocs[mod] = append(emmyDocs[mod], em)
-	return &dps
-}
-
 // feel free to clean this up
 // it works, dont really care about the code
 func main() {
@@ -117,22 +65,88 @@ func main() {
 		}
 	}
 
+	prefix := map[string]string{
+		"hilbish": "hl",
+		"fs": "f",
+		"commander": "c",
+		"bait": "b",
+		"terminal": "term",
+	}
+	docs := make(map[string]module)
+	emmyDocs := make(map[string][]emmyPiece)
+
 	for l, f := range pkgs {
 		p := doc.New(f, "./", doc.AllDecls)
 		pieces := []docPiece{}
 		mod := l
 		for _, t := range p.Funcs {
-			piece := setupDoc(mod, t)
+			if strings.HasPrefix(t.Name, "hl") { mod = "hilbish" }
-			if piece != nil {	
+			if !strings.HasPrefix(t.Name, "hl") && l == "main" { continue }
-				pieces = append(pieces, *piece)
+			if !strings.HasPrefix(t.Name, prefix[mod]) || t.Name == "Loader" { continue }
+			parts := strings.Split(strings.TrimSpace(t.Doc), "\n")
+			funcsig := parts[0]
+			doc := parts[1:]
+			funcdoc := []string{}
+			em := emmyPiece{FuncName: strings.TrimPrefix(t.Name, prefix[mod])}
+			for _, d := range doc {
+				if strings.HasPrefix(d, "---") {
+					emmyLine := strings.TrimSpace(strings.TrimPrefix(d, "---"))
+					emmyLinePieces := strings.Split(emmyLine, " ")
+					emmyType := emmyLinePieces[0]
+					if emmyType == "@param" {
+						em.Params = append(em.Params, emmyLinePieces[1])
 					}
+					if emmyType == "@vararg" {
+						em.Params = append(em.Params, "...") // add vararg
+					}
+					em.Docs = append(em.Docs, d)
+				} else {
+					funcdoc = append(funcdoc, d)
+				}
+			}
+			
+			dps := docPiece{
+				Doc: funcdoc,
+				FuncSig: funcsig,
+				FuncName: strings.TrimPrefix(t.Name, prefix[mod]),
+			}
+			
+			pieces = append(pieces, dps)
+			emmyDocs[mod] = append(emmyDocs[mod], em)
 		}
 		for _, t := range p.Types {
 			for _, m := range t.Methods {
-				piece := setupDoc(mod, m)
+				if !strings.HasPrefix(t.Name, "hl") && l == "main" { continue }
-				if piece != nil {	
+				if !strings.HasPrefix(m.Name, prefix[l]) || m.Name == "Loader" { continue }
-					pieces = append(pieces, *piece)
+				parts := strings.Split(strings.TrimSpace(m.Doc), "\n")
+				funcsig := parts[0]
+				doc := parts[1:]
+				funcdoc := []string{}
+				em := emmyPiece{FuncName: strings.TrimPrefix(m.Name, prefix[l])}
+				for _, d := range doc {
+					if strings.HasPrefix(d, "---") {
+						emmyLine := strings.TrimSpace(strings.TrimPrefix(d, "---"))
+						emmyLinePieces := strings.Split(emmyLine, " ")
+						emmyType := emmyLinePieces[0]
+						if emmyType == "@param" {
+							em.Params = append(em.Params, emmyLinePieces[1])
 						}
+						if emmyType == "@vararg" {
+							em.Params = append(em.Params, "...") // add vararg
+						}
+						em.Docs = append(em.Docs, d)
+					} else {
+						funcdoc = append(funcdoc, d)
+					}
+				}
+				dps := docPiece{
+					Doc: funcdoc,
+					FuncSig: funcsig,
+					FuncName: strings.TrimPrefix(m.Name, prefix[l]),
+				}
+
+				pieces = append(pieces, dps)
+				emmyDocs[l] = append(emmyDocs[l], em)
 			}
 		}
 
@@ -146,22 +160,12 @@ func main() {
 		}
 	}
 
-	var wg sync.WaitGroup
-	wg.Add(len(docs) * 2)
-
 	for mod, v := range docs {
-		modN := mod
+		if mod == "main" { continue }
-		if mod == "main" {
+		f, _ := os.Create("docs/api/" + mod + ".md")
-			modN = "hilbish"
+		f.WriteString(fmt.Sprintf(header, mod, v.ShortDescription))
-		}
+		f.WriteString(fmt.Sprintf("## Introduction\n%s\n\n## Functions\n", v.Description))
-
+		for _, dps := range v.Docs {
-		go func(modName string, modu module) {
-			defer wg.Done()
-
-			f, _ := os.Create("docs/api/" + modName + ".md")
-			f.WriteString(fmt.Sprintf(header, modName, modu.ShortDescription))
-			f.WriteString(fmt.Sprintf("## Introduction\n%s\n\n## Functions\n", modu.Description))
-			for _, dps := range modu.Docs {
 			f.WriteString(fmt.Sprintf("### %s\n", dps.FuncSig))
 			for _, doc := range dps.Doc {
 				if !strings.HasPrefix(doc, "---") {
@@ -170,28 +174,25 @@ func main() {
 			}
 			f.WriteString("\n")
 		}
-		}(modN, v)
+	}
 	
-		go func(md, modName string) {
+	for mod, v := range emmyDocs {
-			defer wg.Done()
+		if mod == "main" { continue }
-
+		f, _ := os.Create("emmyLuaDocs/" + mod + ".lua")
-			ff, _ := os.Create("emmyLuaDocs/" + modName + ".lua")
+		f.WriteString("--- @meta\n\nlocal " + mod + " = {}\n\n")
-			ff.WriteString("--- @meta\n\nlocal " + modName + " = {}\n\n")
+		for _, em := range v {
-			for _, em := range emmyDocs[md] {
+			var funcdocs []string
-				funcdocs := []string{}
+			for _, dps := range docs[mod].Docs {
-				for _, dps := range docs[md].Docs {
 				if dps.FuncName == em.FuncName {
 					funcdocs = dps.Doc
 				}
 			}
-				ff.WriteString("--- " + strings.Join(funcdocs, "\n--- ") + "\n")
+			f.WriteString("--- " + strings.Join(funcdocs, "\n--- ") + "\n")
 			if len(em.Docs) != 0 {
-					ff.WriteString(strings.Join(em.Docs, "\n") + "\n")
+				f.WriteString(strings.Join(em.Docs, "\n") + "\n")
 			}
-				ff.WriteString("function " + modName + "." + em.FuncName + "(" + strings.Join(em.Params, ", ") + ") end\n\n")
+			f.WriteString("function " + mod + "." + em.FuncName + "(" + strings.Join(em.Params, ", ") + ") end\n\n")
 		}
-			ff.WriteString("return " + modName + "\n")
+		f.WriteString("return " + mod + "\n")
-		}(mod, modN)
 	}
-	wg.Wait()
 }

timer.go

@@ -21,7 +21,7 @@ type timer struct{
 	running bool
 	dur time.Duration
 	fun *rt.Closure
-	th *timersModule
+	th *timerHandler
 	ticker *time.Ticker
 	ud *rt.UserData
 	channel chan struct{}

timerhandler.go

@@ -10,10 +10,10 @@ import (
 	rt "github.com/arnodel/golua/runtime"
 )
 
-var timers *timersModule
+var timers *timerHandler
 var timerMetaKey = rt.StringValue("hshtimer")
 
-type timersModule struct {
+type timerHandler struct {
 	mu *sync.RWMutex
 	wg *sync.WaitGroup
 	timers map[int]*timer
@@ -21,8 +21,8 @@ type timersModule struct {
 	running int
 }
 
-func newTimersModule() *timersModule {
+func newTimerHandler() *timerHandler {
-	return &timersModule{
+	return &timerHandler{
 		timers: make(map[int]*timer),
 		latestID: 0,
 		mu: &sync.RWMutex{},
@@ -30,11 +30,11 @@ func newTimersModule() *timersModule {
 	}
 }
 
-func (th *timersModule) wait() {
+func (th *timerHandler) wait() {
 	th.wg.Wait()
 }
 
-func (th *timersModule) create(typ timerType, dur time.Duration, fun *rt.Closure) *timer {
+func (th *timerHandler) create(typ timerType, dur time.Duration, fun *rt.Closure) *timer {
 	th.mu.Lock()
 	defer th.mu.Unlock()
 
@@ -54,14 +54,14 @@ func (th *timersModule) create(typ timerType, dur time.Duration, fun *rt.Closure
 	return t
 }
 
-func (th *timersModule) get(id int) *timer {
+func (th *timerHandler) get(id int) *timer {
 	th.mu.RLock()
 	defer th.mu.RUnlock()
 
 	return th.timers[id]
 }
 
-func (th *timersModule) luaCreate(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+func (th *timerHandler) luaCreate(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
 	if err := c.CheckNArgs(3); err != nil {
 		return nil, err
 	}
@@ -83,7 +83,7 @@ func (th *timersModule) luaCreate(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
 	return c.PushingNext1(t.Runtime, rt.UserDataValue(tmr.ud)), nil
 }
 
-func (th *timersModule) luaGet(thr *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+func (th *timerHandler) luaGet(thr *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
 	if err := c.Check1Arg(); err != nil {
 		return nil, err
 	}
@@ -100,7 +100,7 @@ func (th *timersModule) luaGet(thr *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
 	return c.Next(), nil
 }
 
-func (th *timersModule) loader(rtm *rt.Runtime) *rt.Table {
+func (th *timerHandler) loader(rtm *rt.Runtime) *rt.Table {
 	timerMethods := rt.NewTable()
 	timerFuncs := map[string]util.LuaExport{
 		"start": {timerStart, 1, false},