liubin/icebergs
1
0
Fork 0
forked from x/icebergs
Code Pull Requests Activity

opt wiki.title

Browse Source
This commit is contained in:
shaoying 2019-12-20 18:46:21 +08:00
parent 8e432deab6
commit 6c32418390
10 changed files with 290 additions and 208 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

125
base/web/web.go
View File

@ -21,7 +21,7 @@ const (
MSG_MAPS = 1
)
type WEB struct {
type Frame struct {
*http.Client
*http.Server
*http.ServeMux
@ -37,7 +37,7 @@ func Cookie(msg *ice.Message, sessid string) string {
return sessid
}
func (web *WEB) Login(msg *ice.Message, w http.ResponseWriter, r *http.Request) bool {
func (web *Frame) Login(msg *ice.Message, w http.ResponseWriter, r *http.Request) bool {
if msg.Options(ice.WEB_SESS) {
sub := msg.Cmd("aaa.sess", "check", msg.Option(ice.WEB_SESS))
msg.Log("info", "role: %s user: %s", msg.Option("userrole", sub.Append("userrole")),
@ -47,7 +47,7 @@ func (web *WEB) Login(msg *ice.Message, w http.ResponseWriter, r *http.Request)
msg.Runs("_login", msg.Option("url"), kit.Simple(msg.Optionv("cmds"))...)
return true
}
func (web *WEB) HandleWSS(m *ice.Message, safe bool, c *websocket.Conn) bool {
func (web *Frame) HandleWSS(m *ice.Message, safe bool, c *websocket.Conn) bool {
for {
if t, b, e := c.ReadMessage(); e != nil {
m.Log("warn", "space recv %d msg %v", t, e)
@ -107,44 +107,52 @@ func (web *WEB) HandleWSS(m *ice.Message, safe bool, c *websocket.Conn) bool {
}
return false
}
func (web *WEB) HandleCGI(m *ice.Message, which string) *template.Template {
func (web *Frame) HandleCGI(m *ice.Message, alias map[string]interface{}, which string) *template.Template {
cgi := template.FuncMap{
"result": func(msg *ice.Message) string {
return msg.Result()
},
}
tmpl := template.New("render")
tmpl := template.New(ice.WEB_TMPL)
cb := func(k string, p []string, v *ice.Command) {
cgi[k] = func(arg ...interface{}) (res interface{}) {
m.TryCatch(m.Spawn(), true, func(msg *ice.Message) {
v.Hand(msg, m.Target(), k, kit.Simple(p, arg)...)
buffer := bytes.NewBuffer([]byte{})
m.Assert(tmpl.ExecuteTemplate(buffer, msg.Option(ice.WEB_TMPL), msg))
res = string(buffer.Bytes())
})
return
}
}
for k, v := range alias {
list := kit.Simple(v)
if v, ok := m.Target().Commands[list[0]]; ok {
m.Log("info", "%v, %v", k, v.Name)
cb(k, list[1:], v)
}
}
for k, v := range m.Target().Commands {
m.Log("info", "%v, %v", k, v.Name)
if strings.HasPrefix(k, "/") || strings.HasPrefix(k, "_") {
continue
}
func(k string, v *ice.Command) {
cgi[k] = func(arg ...interface{}) (res interface{}) {
m.TryCatch(m.Spawn(), true, func(msg *ice.Message) {
msg.Option("render", "table")
v.Hand(msg, m.Target(), k, kit.Simple(arg)...)
buffer := bytes.NewBuffer([]byte{})
m.Assert(tmpl.ExecuteTemplate(buffer, msg.Option("render"), msg))
res = string(buffer.Bytes())
})
return
}
}(k, v)
cb(k, nil, v)
}
tmpl = tmpl.Funcs(cgi)
// tmpl = template.Must(tmpl.ParseGlob(path.Join(m.Conf("serve", "template.path"), "/*.tmpl")))
// tmpl = template.Must(tmpl.ParseGlob(path.Join(m.Conf("serve", "template.path"), m.Target().Name, "/*.tmpl")))
// tmpl = template.Must(tmpl.ParseGlob(path.Join(m.Conf(ice.WEB_SERVE, "template.path"), "/*.tmpl")))
// tmpl = template.Must(tmpl.ParseGlob(path.Join(m.Conf(ice.WEB_SERVE, "template.path"), m.Target().Name, "/*.tmpl")))
tmpl = template.Must(tmpl.ParseFiles(which))
m.Confm("serve", "template.list", func(index int, value string) { tmpl = template.Must(tmpl.Parse(value)) })
m.Confm(ice.WEB_SERVE, "template.list", func(index int, value string) { tmpl = template.Must(tmpl.Parse(value)) })
for i, v := range tmpl.Templates() {
m.Log("info", "%v, %v", i, v.Name())
}
return tmpl
}
func (web *WEB) HandleCmd(m *ice.Message, key string, cmd *ice.Command) {
func (web *Frame) HandleCmd(m *ice.Message, key string, cmd *ice.Command) {
web.HandleFunc(key, func(w http.ResponseWriter, r *http.Request) {
m.TryCatch(m.Spawns(), true, func(msg *ice.Message) {
defer func() {
@ -210,7 +218,7 @@ func (web *WEB) HandleCmd(m *ice.Message, key string, cmd *ice.Command) {
})
})
}
func (web *WEB) ServeHTTP(w http.ResponseWriter, r *http.Request) {
func (web *Frame) ServeHTTP(w http.ResponseWriter, r *http.Request) {
m := web.m
index := r.Header.Get("index.module") == ""
@ -233,16 +241,16 @@ func (web *WEB) ServeHTTP(w http.ResponseWriter, r *http.Request) {
web.ServeMux.ServeHTTP(w, r)
}
func (web *WEB) Spawn(m *ice.Message, c *ice.Context, arg ...string) ice.Server {
return &WEB{}
func (web *Frame) Spawn(m *ice.Message, c *ice.Context, arg ...string) ice.Server {
return &Frame{}
}
func (web *WEB) Begin(m *ice.Message, arg ...string) ice.Server {
func (web *Frame) Begin(m *ice.Message, arg ...string) ice.Server {
web.send = map[string]*ice.Message{}
return web
}
func (web *WEB) Start(m *ice.Message, arg ...string) bool {
func (web *Frame) Start(m *ice.Message, arg ...string) bool {
m.Travel(func(p *ice.Context, s *ice.Context) {
if w, ok := s.Server().(*WEB); ok {
if w, ok := s.Server().(*Frame); ok {
if w.ServeMux != nil {
return
}
@ -251,7 +259,7 @@ func (web *WEB) Start(m *ice.Message, arg ...string) bool {
// 级联路由
route := "/" + s.Name + "/"
if n, ok := p.Server().(*WEB); ok && n.ServeMux != nil {
if n, ok := p.Server().(*Frame); ok && n.ServeMux != nil {
msg.Log("route", "%s <= %s", p.Name, route)
n.Handle(route, http.StripPrefix(path.Dir(route), w))
}
@ -272,41 +280,31 @@ func (web *WEB) Start(m *ice.Message, arg ...string) bool {
}
})
port := kit.Select(m.Conf("spide", "self.port"), arg, 0)
m.Cap(ice.CTX_STREAM, port)
web.m = m
web.Server = &http.Server{Addr: port, Handler: web}
m.Log("serve", "node %v", m.Conf("cli.runtime", "node"))
m.Log("serve", "listen %s", port)
port := m.Cap(ice.CTX_STREAM, kit.Select(m.Conf(ice.WEB_SPIDE, "self.port"), arg, 0))
m.Log("serve", "listen %s %v", port, m.Conf("cli.runtime", "node"))
web.m, web.Server = m, &http.Server{Addr: port, Handler: web}
m.Log("serve", "listen %s", web.Server.ListenAndServe())
return true
}
func (web *WEB) Close(m *ice.Message, arg ...string) bool {
func (web *Frame) Close(m *ice.Message, arg ...string) bool {
return true
}
var Index = &ice.Context{Name: "web", Help: "网页模块",
Caches: map[string]*ice.Cache{},
Configs: map[string]*ice.Config{
"spide": {Name: "客户端", Value: map[string]interface{}{
ice.WEB_SPIDE: {Name: "客户端", Value: map[string]interface{}{
"self": map[string]interface{}{"port": ice.WEB_PORT},
}},
"serve": {Name: "服务端", Value: map[string]interface{}{
ice.WEB_SERVE: {Name: "服务端", Value: map[string]interface{}{
"static": map[string]interface{}{"/": "usr/volcanos/",
"/static/volcanos/": "usr/volcanos/",
},
"template": map[string]interface{}{
"path": "usr/template",
"list": []interface{}{
"template": map[string]interface{}{"path": "usr/template", "list": []interface{}{
`{{define "raw"}}{{.|result}}{{end}}`,
`{{define "title"}}{{.|result}}{{end}}`,
`{{define "chapter"}}{{.|result}}{{end}}`,
`{{define "section"}}{{.|result}}{{end}}`,
`{{define "block"}}<div>{{.|result}}<div>{{end}}`,
},
},
}},
"space": {Name: "空间端", Value: map[string]interface{}{
}},
ice.WEB_SPACE: {Name: "空间端", Value: map[string]interface{}{
ice.MDB_META: map[string]interface{}{"buffer": 4096, "redial": 3000},
ice.MDB_HASH: map[string]interface{}{},
ice.MDB_LIST: map[string]interface{}{},
@ -314,17 +312,16 @@ var Index = &ice.Context{Name: "web", Help: "网页模块",
},
Commands: map[string]*ice.Command{
ice.ICE_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Echo("hello %s world", c.Name)
}},
ice.ICE_EXIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Done()
}},
"serve": {Name: "hi", Help: "hello", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Conf("cli.runtime", "node.type", "server")
ice.WEB_SERVE: {Name: "serve", Help: "服务器", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Conf("cli.runtime", "node.name", m.Conf("cli.runtime", "boot.hostname"))
m.Conf("cli.runtime", "node.type", "server")
m.Target().Start(m, arg...)
}},
"/space": &ice.Command{Name: "/space", Help: "", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
"/space": &ice.Command{Name: "/space", Help: "工作间", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
r := m.Optionv("request").(*http.Request)
w := m.Optionv("response").(http.ResponseWriter)
if s, e := websocket.Upgrade(w, r, nil, m.Confi("web.space", "meta.buffer"), m.Confi("web.space", "meta.buffer")); m.Assert(e) {
@ -336,26 +333,26 @@ var Index = &ice.Context{Name: "web", Help: "网页模块",
"type": m.Option("node"),
"name": m.Option("name"),
}
m.Confv("space", []string{ice.MDB_HASH, h}, meta)
m.Log("space", "conn %v %v", h, kit.Formats(m.Confv("space")))
m.Confv(ice.WEB_SPACE, []string{ice.MDB_HASH, h}, meta)
m.Log("space", "conn %v %v", h, kit.Formats(m.Confv(ice.WEB_SPACE)))
web := m.Target().Server().(*WEB)
web := m.Target().Server().(*Frame)
m.Gos(m, func(m *ice.Message) {
web.HandleWSS(m, false, s)
m.Log("space", "close %v %v", h, kit.Formats(m.Confv("space")))
m.Confv("space", []string{ice.MDB_HASH, h}, "")
m.Log("space", "close %v %v", h, kit.Formats(m.Confv(ice.WEB_SPACE)))
m.Confv(ice.WEB_SPACE, []string{ice.MDB_HASH, h}, "")
})
}
}},
"space": &ice.Command{Name: "space", Help: "", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
ice.WEB_SPACE: &ice.Command{Name: "space", Help: "工作间", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
if len(arg) == 0 {
m.Conf("space", ice.MDB_HASH, func(key string, value map[string]interface{}) {
m.Conf(ice.WEB_SPACE, ice.MDB_HASH, func(key string, value map[string]interface{}) {
m.Push(key, value)
})
return
}
web := m.Target().Server().(*WEB)
web := m.Target().Server().(*Frame)
switch arg[0] {
case "connect":
node, name := m.Conf("cli.runtime", "node.type"), m.Conf("cli.runtime", "boot.hostname")
@ -395,7 +392,7 @@ var Index = &ice.Context{Name: "web", Help: "网页模块",
}
target := strings.Split(arg[0], ".")
if socket, ok := m.Confv("space", "hash."+target[0]+".socket").(*websocket.Conn); !ok {
if socket, ok := m.Confv(ice.WEB_SPACE, "hash."+target[0]+".socket").(*websocket.Conn); !ok {
m.Echo("error").Echo("not found")
} else {
id := kit.Format(c.ID())
@ -403,7 +400,7 @@ var Index = &ice.Context{Name: "web", Help: "网页模块",
m.Optionv("_target", target[1:])
m.Set(ice.MSG_DETAIL, arg[1:]...)
web := m.Target().Server().(*WEB)
web := m.Target().Server().(*Frame)
web.send[id] = m
now := time.Now()
@ -419,4 +416,4 @@ var Index = &ice.Context{Name: "web", Help: "网页模块",
},
}
func init() { ice.Index.Register(Index, &WEB{}) }
func init() { ice.Index.Register(Index, &Frame{}) }

17
conf.go
View File

@ -22,15 +22,20 @@ const (
MDB_LIST = "list"
MDB_HASH = "hash"
)
const (
WEB_PORT = ":9020"
WEB_SESS = "sessid"
WEB_TMPL = "render"
WEB_SPIDE = "spide"
WEB_SERVE = "serve"
WEB_SPACE = "space"
)
const (
GDB_SIGNAL = "signal"
GDB_TIMER = "timer"
GDB_EVENT = "event"
)
const (
WEB_PORT = ":9020"
WEB_SESS = "sessid"
)
const (
LOG_CMD = "cmd"
LOG_INFO = "info"
@ -47,4 +52,8 @@ var Alias = map[string]string{
GDB_SIGNAL: "gdb.signal",
GDB_TIMER: "gdb.timer",
GDB_EVENT: "gdb.event",
WEB_SPIDE: "web.spide",
WEB_SPACE: "web.space",
"note": "web.wiki.note",
}

2
core/chat/chat.go
View File

@ -191,4 +191,4 @@ var Index = &ice.Context{Name: "chat", Help: "聊天模块",
},
}
func init() { web.Index.Register(Index, &web.WEB{}) }
func init() { web.Index.Register(Index, &web.Frame{}) }

2
core/code/code.go
View File

@ -488,4 +488,4 @@ var Index = &ice.Context{Name: "code", Help: "编程模块",
},
}
func init() { web.Index.Register(Index, &web.WEB{}) }
func init() { web.Index.Register(Index, &web.Frame{}) }

2
core/mall/mall.go
View File

@ -137,4 +137,4 @@ var Index = &ice.Context{Name: "mall", Help: "团队模块",
},
}
func init() { web.Index.Register(Index, &web.WEB{}) }
func init() { web.Index.Register(Index, &web.Frame{}) }

2
core/team/team.go
View File

@ -69,4 +69,4 @@ var Index = &ice.Context{Name: "team", Help: "团队模块",
},
}
func init() { web.Index.Register(Index, &web.WEB{}) }
func init() { web.Index.Register(Index, &web.Frame{}) }

4
core/wiki/chart.go
View File

@ -51,10 +51,10 @@ func (b *Block) Draw(m *ice.Message, x, y int) Chart {
return b
}
func (b *Block) Data(root interface{}) {
kit.Table(kit.Value(root, "data"), 0, 100, func(key string, value string) {
kit.Fetch(kit.Value(root, "data"), func(key string, value string) {
b.TextData += key + "='" + value + "' "
})
kit.Table(kit.Value(root, "rect"), 0, 100, func(key string, value string) {
kit.Fetch(kit.Value(root, "rect"), func(key string, value string) {
b.RectData += key + "='" + value + "' "
})
b.FontColor = kit.Select(b.FontColor, kit.Value(root, "fg"))

125
core/wiki/wiki.go
View File

@ -2,35 +2,67 @@ package wiki
import (
"github.com/gomarkdown/markdown"
"github.com/shylinux/toolkits"
"github.com/shylinux/icebergs"
_ "github.com/shylinux/icebergs/base"
"github.com/shylinux/icebergs/base/web"
"github.com/shylinux/toolkits"
"bytes"
"fmt"
"path"
"strings"
)
var prefix = `<svg vertion="1.1" xmlns="http://www.w3.org/2000/svg"
width="{{.Option "width"}}" height="{{.Option "height"}}" style="{{.Option "style"}}"
data-name="{{.Option "name"}}"
>`
var title = `<span>{{.Option "prefix"}}{{.Option "content"}}</span>`
var Index = &ice.Context{Name: "wiki", Help: "文档模块",
Caches: map[string]*ice.Cache{},
Configs: map[string]*ice.Config{
"note": {Name: "note", Value: map[string]interface{}{
"note": {Name: "note", Help: "笔记", Value: map[string]interface{}{
ice.MDB_META: map[string]interface{}{
"temp": "var/tmp/file",
"path": "usr/local/wiki",
"head": "time size line path",
"alias": map[string]interface{}{
"block": []interface{}{"chart", "block"},
"chain": []interface{}{"chart", "chain"},
"table": []interface{}{"chart", "table"},
"chapter": []interface{}{"title", "chapter"},
"section": []interface{}{"title", "section"},
},
},
ice.MDB_LIST: map[string]interface{}{},
ice.MDB_HASH: map[string]interface{}{},
}},
"chart": {Name: "chart", Help: "绘图", Value: map[string]interface{}{
ice.MDB_META: map[string]interface{}{
"prefix": prefix, "suffix": `</svg>`,
},
ice.MDB_LIST: map[string]interface{}{},
ice.MDB_HASH: map[string]interface{}{},
}},
"title": {Name: "title", Help: "标题", Value: map[string]interface{}{
ice.MDB_META: map[string]interface{}{
"title": title,
},
ice.MDB_LIST: map[string]interface{}{},
ice.MDB_HASH: map[string]interface{}{},
}},
},
Commands: map[string]*ice.Command{
"chart": {Name: "chart", Help: "绘图", List: []interface{}{
map[string]interface{}{"type": "select", "value": "chain", "values": "chain table"},
"chart": {Name: "chart block|chain|table name text [fg bg fs ls p m]", Help: "绘图", Meta: map[string]interface{}{
"display": "inner",
}, List: []interface{}{
map[string]interface{}{"type": "select", "value": "chain", "values": "block chain table"},
map[string]interface{}{"type": "text", "value": ""},
map[string]interface{}{"type": "button", "value": "执行"},
map[string]interface{}{"type": "button", "value": "生成"},
}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
m.Option("render", "raw")
// 创建类型
var chart Chart
switch arg[0] {
case "block":
@ -41,64 +73,79 @@ var Index = &ice.Context{Name: "wiki", Help: "文档模块",
chart = &Table{}
}
arg[1] = strings.TrimSpace(arg[1])
arg[2] = strings.TrimSpace(arg[2])
chart.Init(m, arg[1:]...)
m.Echo(`<svg vertion="1.1" xmlns="http://www.w3.org/2000/svg" width="%d", height="%d" style="%s">`,
chart.GetWidth(), chart.GetHeight(), m.Option("style"))
m.Echo("\n")
// 构造数据
m.Option(ice.WEB_TMPL, "raw")
m.Option("name", arg[1])
m.Option("text", arg[2])
chart.Init(m, arg[2:]...)
m.Option("width", chart.GetWidth())
m.Option("height", chart.GetHeight())
// 生成网页
m.Render(m.Conf("chart", ice.Meta("prefix")))
chart.Draw(m, 0, 0)
m.Echo(`</svg>`)
m.Echo("\n")
m.Render(m.Conf("chart", ice.Meta("suffix")))
return
}},
"_tree": {Name: "_tree", Help: "目录", Hand: func(m *ice.Message, c *ice.Context, key string, arg ...string) {
m.Cmdy("nfs.dir", m.Conf("note", "meta.path"), kit.Select("", arg, 0), "time size line path")
}},
"_text": {Name: "_text", Help: "文章", Hand: func(m *ice.Message, c *ice.Context, key string, arg ...string) {
tmpl := m.Target().Server().(*web.WEB).HandleCGI(m, path.Join(m.Conf("note", "meta.path"), arg[0]))
"_text": {Name: "_text file", Help: "文章", Hand: func(m *ice.Message, c *ice.Context, key string, arg ...string) {
m.Option(ice.WEB_TMPL, "raw")
m.Optionv("title", map[string]int{})
// 生成文章
buffer := bytes.NewBuffer([]byte{})
f := m.Target().Server().(*web.Frame)
tmpl := f.HandleCGI(m, m.Confm("note", ice.Meta("alias")), path.Join(m.Conf("note", ice.Meta("path")), arg[0]))
m.Assert(tmpl.ExecuteTemplate(buffer, m.Option("filename", path.Base(arg[0])), m))
if f, p, e := kit.Create(path.Join("var/tmp/file", arg[0])); e == nil {
// 缓存文章
if f, p, e := kit.Create(path.Join(m.Conf("note", ice.Meta("temp")), arg[0])); e == nil {
defer f.Close()
if n, e := f.Write(buffer.Bytes()); e == nil {
m.Log("info", "save %d %v", n, p)
}
}
data := markdown.ToHTML(buffer.Bytes(), nil, nil)
m.Echo(string(data))
// 生成网页
m.Echo(string(markdown.ToHTML(buffer.Bytes(), nil, nil)))
}},
"note": {Name: "note file|favor|commit", Help: "笔记", Meta: map[string]interface{}{
"display": "inner",
"remote": "true",
"_tree": {Name: "_tree path", Help: "文库", Hand: func(m *ice.Message, c *ice.Context, key string, arg ...string) {
m.Cmdy("nfs.dir", m.Conf("note", ice.Meta("path")),
kit.Select("", arg, 0), m.Conf("note", ice.Meta("head")))
}},
"note": {Name: "note file", Help: "笔记", Meta: map[string]interface{}{
"remote": "true", "display": "inner",
}, List: []interface{}{
map[string]interface{}{"type": "text", "value": "miss.md", "name": "path"},
map[string]interface{}{"type": "button", "value": "执行", "action": "auto"},
map[string]interface{}{"type": "button", "value": "返回", "cb": "Last"},
}, Hand: func(m *ice.Message, c *ice.Context, key string, arg ...string) {
if len(arg) == 0 {
m.Cmdy("_tree")
return
}
switch arg[0] {
case "favor", "commit":
m.Cmdy("story", arg[0], arg[1:])
default:
m.Cmdy(kit.Select("_tree", "_text", strings.HasSuffix(arg[0], ".md")), arg[0])
}
m.Cmdy(kit.Select("_tree", "_text", len(arg) > 0 && strings.HasSuffix(arg[0], ".md")), arg)
}},
"title": {Name: "title text", Help: "一级标题", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
"title": {Name: "title text", Help: "标题", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
title, _ := m.Optionv("title").(map[string]int)
switch arg[0] {
case "section":
arg = arg[1:]
title["section"]++
m.Option("prefix", fmt.Sprintf("%d.%d ", title["chapter"], title["section"]))
case "chapter":
arg = arg[1:]
title["chapter"]++
title["section"] = 0
m.Option("prefix", fmt.Sprintf("%d ", title["chapter"]))
default:
m.Option("prefix", "")
}
ns := strings.Split(m.Conf("runtime", "node.name"), "-")
m.Option("render", cmd)
m.Echo(kit.Select(ns[len(ns)-1], arg, 0))
m.Option("content", kit.Select(ns[len(ns)-1], arg, 0))
m.Render(m.Conf("title", ice.Meta("title")))
}},
},
}
func init() { web.Index.Register(Index, &web.WEB{}) }
func init() { web.Index.Register(Index, &web.Frame{}) }

47
demo/usr/local/wiki/miss.md
View File

@ -1,31 +1,50 @@
# {{title "hello world"}}
init.register
ice.Begin
ice.Start
ice.Close
{{table "项目" `
volcano iceberg
context toolkit
preload appframe
`}}
{{chart "table" `
## {{chapter "hello world"}}
{{table "框架" `
ctx cli aaa web
lex yac gdb log
tcp nfs ssh mdb
`}}
{{chart "chain" `
### {{section "hello world"}}
{{chain "孵化" `
context
volcanos
proto.js
frame.js
frame.js bg blue
Page
Pane
Plugin
Inputs
Output
order.js
style.css
index.html
icebergs bg blue
web.go
aaa.go
cli.go
ctx.go
type.go
base.go bg red
code
wiki
chat
team
mall
conf.go
toolkits
type.go
core.go
core.go bg blue
Split
Parse
Value
Fetch
Favor
misc.go
`}}
### {{section "hello world"}}

170
type.go
View File

@ -505,11 +505,18 @@ func (m *Message) Table(cbs ...interface{}) *Message {
}
return m
}
func (m *Message) Option(key string, arg ...interface{}) string {
return kit.Select("", kit.Simple(m.Optionv(key, arg...)), 0)
func (m *Message) Render(str string) *Message {
if res, err := kit.Render(str, m); m.Assert(err) {
m.Echo(string(res))
}
func (m *Message) Options(key string, arg ...interface{}) bool {
return kit.Select("", kit.Simple(m.Optionv(key, arg...)), 0) != ""
return m
}
func (m *Message) Detail(arg ...interface{}) string {
return kit.Select("", m.meta[MSG_DETAIL], 0)
}
func (m *Message) Detailv(arg ...interface{}) []string {
return m.meta[MSG_DETAIL]
}
func (m *Message) Optionv(key string, arg ...interface{}) interface{} {
if len(arg) > 0 {
@ -537,6 +544,12 @@ func (m *Message) Optionv(key string, arg ...interface{}) interface{} {
}
return nil
}
func (m *Message) Options(key string, arg ...interface{}) bool {
return kit.Select("", kit.Simple(m.Optionv(key, arg...)), 0) != ""
}
func (m *Message) Option(key string, arg ...interface{}) string {
return kit.Select("", kit.Simple(m.Optionv(key, arg...)), 0)
}
func (m *Message) Append(key string, arg ...interface{}) string {
return kit.Select("", m.meta[key], 0)
}
@ -549,12 +562,6 @@ func (m *Message) Resultv(arg ...interface{}) []string {
func (m *Message) Result(arg ...interface{}) string {
return strings.Join(m.Resultv(), "")
}
func (m *Message) Detailv(arg ...interface{}) []string {
return m.meta[MSG_DETAIL]
}
func (m *Message) Detail(arg ...interface{}) string {
return kit.Select("", m.meta[MSG_DETAIL], 0)
}
func (m *Message) Log(level string, str string, arg ...interface{}) *Message {
if Log != nil {
@ -609,76 +616,6 @@ func (m *Message) TryCatch(msg *Message, safe bool, hand ...func(msg *Message))
}
return m
}
func (m *Message) Travel(cb interface{}) *Message {
list := []*Context{m.target}
for i := 0; i < len(list); i++ {
switch cb := cb.(type) {
case func(*Context, *Context):
cb(list[i].context, list[i])
case func(*Context, *Context, string, *Command):
ls := []string{}
for k := range list[i].Commands {
ls = append(ls, k)
}
sort.Strings(ls)
for _, k := range ls {
cb(list[i].context, list[i], k, list[i].Commands[k])
}
case func(*Context, *Context, string, *Config):
ls := []string{}
for k := range list[i].Configs {
ls = append(ls, k)
}
sort.Strings(ls)
for _, k := range ls {
cb(list[i].context, list[i], k, list[i].Configs[k])
}
}
ls := []string{}
for k := range list[i].contexts {
ls = append(ls, k)
}
sort.Strings(ls)
for _, k := range ls {
list = append(list, list[i].contexts[k])
}
}
return m
}
func (m *Message) Search(key interface{}, cb func(p *Context, s *Context, key string)) *Message {
switch key := key.(type) {
case string:
if k, ok := Alias[key]; ok {
key = k
}
fmt.Printf("%v fuck %v\n", m.Time(), key)
if strings.Contains(key, ":") {
} else if strings.Contains(key, ".") {
list := strings.Split(key, ".")
p := m.target.root
for _, v := range list[:len(list)-1] {
if s, ok := p.contexts[v]; ok {
p = s
} else {
p = nil
break
}
}
if p == nil {
m.Log(LOG_WARN, "not found %s", key)
break
}
cb(p.context, p, list[len(list)-1])
} else {
cb(m.target.context, m.target, key)
}
}
return m
}
func (m *Message) Gos(msg *Message, cb func(*Message)) *Message {
go func() { msg.TryCatch(msg, true, func(msg *Message) { cb(msg) }) }()
return m
@ -730,6 +667,79 @@ func (m *Message) Back(sub *Message) *Message {
return m
}
func (m *Message) Travel(cb interface{}) *Message {
list := []*Context{m.target}
for i := 0; i < len(list); i++ {
switch cb := cb.(type) {
case func(*Context, *Context):
cb(list[i].context, list[i])
case func(*Context, *Context, string, *Command):
ls := []string{}
for k := range list[i].Commands {
ls = append(ls, k)
}
sort.Strings(ls)
for _, k := range ls {
cb(list[i].context, list[i], k, list[i].Commands[k])
}
case func(*Context, *Context, string, *Config):
ls := []string{}
for k := range list[i].Configs {
ls = append(ls, k)
}
sort.Strings(ls)
for _, k := range ls {
cb(list[i].context, list[i], k, list[i].Configs[k])
}
}
ls := []string{}
for k := range list[i].contexts {
ls = append(ls, k)
}
sort.Strings(ls)
for _, k := range ls {
list = append(list, list[i].contexts[k])
}
}
return m
}
func (m *Message) Search(key interface{}, cb func(p *Context, s *Context, key string)) *Message {
switch key := key.(type) {
case string:
if k, ok := Alias[key]; ok {
key = k
}
if strings.Contains(key, ":") {
} else if strings.Contains(key, ".") {
list := strings.Split(key, ".")
p := m.target.root
for _, v := range list[:len(list)-1] {
if s, ok := p.contexts[v]; ok {
p = s
} else {
p = nil
break
}
}
if p == nil {
m.Log(LOG_WARN, "not found %s", key)
break
}
cb(p.context, p, list[len(list)-1])
} else {
cb(m.target.context, m.target, key)
}
}
return m
}
func Meta(arg ...interface{}) string {
return MDB_META + "." + kit.Keys(arg...)
}
func (m *Message) Rich(key string, args interface{}, data interface{}) map[string]interface{} {
cache := m.Confm(key, args)
if cache == nil {