1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
package koushin
import (
"fmt"
"html/template"
"path/filepath"
"github.com/labstack/echo/v4"
"github.com/yuin/gopher-lua"
"layeh.com/gopher-luar"
)
type Plugin interface {
Name() string
Filters() template.FuncMap
Render(name string, data interface{}) error
Close() error
}
type luaPlugin struct {
filename string
state *lua.LState
renderCallbacks map[string]*lua.LFunction
filters template.FuncMap
}
func (p *luaPlugin) Name() string {
return p.filename
}
func (p *luaPlugin) onRender(l *lua.LState) int {
name := l.CheckString(1)
f := l.CheckFunction(2)
p.renderCallbacks[name] = f
return 0
}
func (p *luaPlugin) setFilter(l *lua.LState) int {
name := l.CheckString(1)
f := l.CheckFunction(2)
p.filters[name] = func(args... interface{}) string {
luaArgs := make([]lua.LValue, len(args))
for i, v := range args {
luaArgs[i] = luar.New(l, v)
}
err := l.CallByParam(lua.P{
Fn: f,
NRet: 1,
Protect: true,
}, luaArgs...)
if err != nil {
panic(err) // TODO: better error handling?
}
ret := l.CheckString(-1)
l.Pop(1)
return ret
}
return 0
}
func (p *luaPlugin) Render(name string, data interface{}) error {
f, ok := p.renderCallbacks[name]
if !ok {
return nil
}
err := p.state.CallByParam(lua.P{
Fn: f,
NRet: 0,
Protect: true,
}, luar.New(p.state, data))
if err != nil {
return err
}
return nil
}
func (p *luaPlugin) Filters() template.FuncMap {
return p.filters
}
func (p *luaPlugin) Close() error {
p.state.Close()
return nil
}
func loadLuaPlugin(filename string) (*luaPlugin, error) {
l := lua.NewState()
p := &luaPlugin{
filename: filename,
state: l,
renderCallbacks: make(map[string]*lua.LFunction),
filters: make(template.FuncMap),
}
mt := l.NewTypeMetatable("koushin")
l.SetGlobal("koushin", mt)
l.SetField(mt, "on_render", l.NewFunction(p.onRender))
l.SetField(mt, "set_filter", l.NewFunction(p.setFilter))
if err := l.DoFile(filename); err != nil {
l.Close()
return nil, err
}
return p, nil
}
func loadAllLuaPlugins(log echo.Logger) ([]Plugin, error) {
filenames, err := filepath.Glob("plugins/*.lua")
if err != nil {
return nil, fmt.Errorf("filepath.Glob failed: %v", err)
}
plugins := make([]Plugin, 0, len(filenames))
for _, filename := range filenames {
log.Printf("Loading Lua plugin '%v'", filename)
p, err := loadLuaPlugin(filename)
if err != nil {
for _, p := range plugins {
p.Close()
}
return nil, fmt.Errorf("failed to load Lua plugin '%v': %v", filename, err)
}
plugins = append(plugins, p)
}
return plugins, nil
}
|
