CHANGELOG.md

@@ -56,9 +56,6 @@ This is probably one of (if not the) biggest things in this release.
 user input, exit code, and error. User input has been added to the return to
 account for runners wanting to prompt for continued input, and to add it
 properly to history.
-- **Breaking Change:** Job objects and timers are now Lua userdata instead
-of a table, so their functions require you to call them with a colon instead
-of a dot. (ie. `job.stop()` -> `job:stop()`)
 - All `fs` module functions which take paths now implicitly expand ~ to home.
 
 ### Fixed

api.go

@@ -476,7 +476,7 @@ func hltimeout(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
 	timer := timers.create(timerTimeout, interval, cb)
 	timer.start()
 	
-	return c.PushingNext1(t.Runtime, rt.UserDataValue(timer.ud)), nil
+	return c.PushingNext1(t.Runtime, timer.lua()), nil
 }
 
 // interval(cb, time)
@@ -502,7 +502,7 @@ func hlinterval(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
 	timer := timers.create(timerInterval, interval, cb)
 	timer.start()
 
-	return c.PushingNext1(t.Runtime, rt.UserDataValue(timer.ud)), nil
+	return c.PushingNext1(t.Runtime, timer.lua()), nil
 }
 
 // complete(scope, cb)

docs/jobs.txt

@@ -20,11 +20,8 @@ and `execPath` is an absolute path for the command executable.
 - `disown(id)`: Removes a job by ID from the job table.
 
 # Job Object
-A job object is a piece of `userdata`. All the functions of a job require
+A job object on the Lua side is a table with some functions.
-you to call them with a colon, since they are *methods* for the job object.
+On the under side it represents a job in the job table.
-Example: hilbish.jobs.last():foreground()
-Which will foreground the last job.
-
 You can still have a job object for a disowned job,
 it just won't be *working* anywhere. :^)
 

docs/timers.txt

@@ -16,17 +16,9 @@ a timer via ID.
 when the timer is triggered.
 
 # Timer Object
-All those previously mentioned functions return a `timer` object, to which
+Those previously mentioned functions return a `timer` object, to which you can
-you can stop and start a timer again.
+stop and start a timer again. The functions of the timers interface also
-
+return a timer object.
-An example of usage:
-local t = hilbish.timers.create(1, 5000, function()
-	print 'hello!'
-end)
-
-t:stop()
-print(t.running, t.duration, t.type)
-t:start()
 
 ## Properties
 - `duration`: amount of time the timer runs for in milliseconds

init_windows.go

@@ -1,11 +0,0 @@
-// +build windows
-
-package main
-
-import "golang.org/x/sys/windows"
-
-func init() {
-	var mode uint32
-	windows.GetConsoleMode(windows.Stdout, &mode)
-	windows.SetConsoleMode(windows.Stdout, mode | windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING)
-}

job.go

@@ -82,7 +82,7 @@ func (j *job) stop() {
 
 func (j *job) finish() {
 	j.running = false
-	hooks.Em.Emit("job.done", rt.UserDataValue(j.ud))
+	hooks.Em.Emit("job.done", j.ud)
 }
 
 func (j *job) wait() {

timer.go

@@ -6,6 +6,8 @@ import (
 	"os"
 	"time"
 
+	"hilbish/util"
+	
 	rt "github.com/arnodel/golua/runtime"
 )
 
@@ -23,7 +25,6 @@ type timer struct{
 	fun *rt.Closure
 	th *timerHandler
 	ticker *time.Ticker
-	ud *rt.UserData
 	channel chan struct{}
 }
 
@@ -73,17 +74,8 @@ func (t *timer) stop() error {
 	return nil
 }
 
-func timerStart(thr *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+func (t *timer) luaStart(thr *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
-	if err := c.Check1Arg(); err != nil {
+	err := t.start()
-		return nil, err
-	}
-
-	t, err := timerArg(c, 0)
-	if err != nil {
-		return nil, err
-	}
-
-	err = t.start()
 	if err != nil {
 		return nil, err
 	}
@@ -91,20 +83,26 @@ func timerStart(thr *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
 	return c.Next(), nil
 }
 
-func timerStop(thr *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
+func (t *timer) luaStop(thr *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
-	if err := c.Check1Arg(); err != nil {
+	err := t.stop()
-		return nil, err
-	}
-
-	t, err := timerArg(c, 0)
-	if err != nil {
-		return nil, err
-	}
-
-	err = t.stop()
 	if err != nil {
 		return nil, err
 	}
 	
 	return c.Next(), nil
 }
+
+func (t *timer) lua() rt.Value {
+	tExports := map[string]util.LuaExport{
+		"start": {t.luaStart, 0, false},
+		"stop": {t.luaStop, 0, false},
+	}
+	luaTimer := rt.NewTable()
+	util.SetExports(l, luaTimer, tExports)
+
+	luaTimer.Set(rt.StringValue("type"), rt.IntValue(int64(t.typ)))
+	luaTimer.Set(rt.StringValue("running"), rt.BoolValue(t.running))
+	luaTimer.Set(rt.StringValue("duration"), rt.IntValue(int64(t.dur / time.Millisecond)))
+
+	return rt.TableValue(luaTimer)
+}

timerhandler.go

@@ -1,7 +1,6 @@
 package main
 
 import (
-	"fmt"
 	"sync"
 	"time"
 
@@ -11,8 +10,6 @@ import (
 )
 
 var timers *timerHandler
-var timerMetaKey = rt.StringValue("hshtimer")
-
 type timerHandler struct {
 	mu *sync.RWMutex
 	wg *sync.WaitGroup
@@ -47,8 +44,6 @@ func (th *timerHandler) create(typ timerType, dur time.Duration, fun *rt.Closure
 		th: th,
 		id: th.latestID,
 	}
-	t.ud = timerUserData(t)
-
 	th.timers[th.latestID] = t
 	
 	return t
@@ -80,7 +75,7 @@ func (th *timerHandler) luaCreate(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
 
 	timerTyp := timerType(timerTypInt)
 	tmr := th.create(timerTyp, time.Duration(ms) * time.Millisecond, cb)
-	return c.PushingNext1(t.Runtime, rt.UserDataValue(tmr.ud)), nil
+	return c.PushingNext1(t.Runtime, tmr.lua()), nil
 }
 
 func (th *timerHandler) luaGet(thr *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
@@ -94,45 +89,13 @@ func (th *timerHandler) luaGet(thr *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
 
 	t := th.get(int(id))
 	if t != nil {
-		return c.PushingNext1(thr.Runtime, rt.UserDataValue(t.ud)), nil
+		return c.PushingNext1(thr.Runtime, t.lua()), nil
 	}
 
 	return c.Next(), nil
 }
 
 func (th *timerHandler) loader(rtm *rt.Runtime) *rt.Table {
-	timerMethods := rt.NewTable()
-	timerFuncs := map[string]util.LuaExport{
-		"start": {timerStart, 1, false},
-		"stop": {timerStop, 1, false},
-	}
-	util.SetExports(rtm, timerMethods, timerFuncs)
-
-	timerMeta := rt.NewTable()
-	timerIndex := func(t *rt.Thread, c *rt.GoCont) (rt.Cont, error) {
-		ti, _ := timerArg(c, 0)
-
-		arg := c.Arg(1)
-		val := timerMethods.Get(arg)
-
-		if val != rt.NilValue {
-			return c.PushingNext1(t.Runtime, val), nil
-		}
-
-		keyStr, _ := arg.TryString()
-
-		switch keyStr {
-			case "type": val = rt.IntValue(int64(ti.typ))
-			case "running": val = rt.BoolValue(ti.running)
-			case "duration": val = rt.IntValue(int64(ti.dur / time.Millisecond))
-		}
-
-		return c.PushingNext1(t.Runtime, val), nil
-	}
-
-	timerMeta.Set(rt.StringValue("__index"), rt.FunctionValue(rt.NewGoFunction(timerIndex, "__index", 2, false)))
-	l.SetRegistry(timerMetaKey, rt.TableValue(timerMeta))
-
 	thExports := map[string]util.LuaExport{
 		"create": {th.luaCreate, 3, false},
 		"get": {th.luaGet, 1, false},
@@ -143,27 +106,3 @@ func (th *timerHandler) loader(rtm *rt.Runtime) *rt.Table {
 
 	return luaTh
 }
-
-func timerArg(c *rt.GoCont, arg int) (*timer, error) {
-	j, ok := valueToTimer(c.Arg(arg))
-	if !ok {
-		return nil, fmt.Errorf("#%d must be a timer", arg + 1)
-	}
-
-	return j, nil
-}
-
-func valueToTimer(val rt.Value) (*timer, bool) {
-	u, ok := val.TryUserData()
-	if !ok {
-		return nil, false
-	}
-
-	j, ok := u.Value().(*timer)
-	return j, ok
-}
-
-func timerUserData(j *timer) *rt.UserData {
-	timerMeta := l.Registry(timerMetaKey)
-	return rt.NewUserData(j, timerMeta.AsTable())
-}