├── .gitignore ├── test ├── output │ ├── function.html │ ├── vHtml.html │ ├── voidElements.html │ ├── slot.html │ ├── component_dynamic.html │ ├── parallel.html │ ├── class.html │ ├── component_fragment.html │ ├── directive.html │ ├── main.html │ ├── style.html │ └── component.html ├── api_test.go ├── parallel_test.go ├── dev │ └── map_mem_test.go ├── class_test.go ├── style_test.go ├── parallel_comp_test.go ├── slot_test.go ├── func_test.go ├── directive_test.go ├── base_test.go └── component_test.go ├── internal ├── lib │ ├── parse │ │ ├── readme.md │ │ └── html │ │ │ ├── util_test.go │ │ │ ├── hash.go │ │ │ ├── README.md │ │ │ ├── util.go │ │ │ ├── lex_test.go │ │ │ └── lex.go │ └── log │ │ └── log.go ├── parser │ ├── parsevue_output.txt │ ├── parsevue_test.go │ ├── parsehtml_output.txt │ ├── parsehtml_test.go │ ├── parsehtml.go │ └── parsevue.go └── util │ └── util.go ├── util_test.go ├── bench ├── jetviews │ └── bench.jet ├── struct.go ├── bench.qtpl ├── quicktemplate.qtpl.go └── timing_test.go ├── statement.txt ├── go.mod ├── doc ├── internal.md ├── api.md └── syntax.md ├── LICENSE ├── example └── hello │ └── main.go ├── statement_test.go ├── jsexpression_test.go ├── go.sum ├── README.md ├── util.go ├── vpl.go ├── jsexpression.go └── statement.go /.gitignore: -------------------------------------------------------------------------------- 1 | /.idea/ 2 | -------------------------------------------------------------------------------- /test/output/function.html: -------------------------------------------------------------------------------- 1 | appendName: z|bysir | fullName: z|bysir | getVar: z|bysir -------------------------------------------------------------------------------- /internal/lib/parse/readme.md: -------------------------------------------------------------------------------- 1 | Copy from github.com/tdewolff/parse/v2 2 | 3 | - Vue模板不同于html模板, vue模板对大小写敏感, 所以删除了 parse 库中的大小写转换. -------------------------------------------------------------------------------- /test/output/vHtml.html: -------------------------------------------------------------------------------- 1 |

富文本-

<h1>富文本<span>-</span></h1> -------------------------------------------------------------------------------- /test/output/voidElements.html: -------------------------------------------------------------------------------- 1 | Title -------------------------------------------------------------------------------- /test/output/slot.html: -------------------------------------------------------------------------------- 1 |

author3: bysirauthor2: bysir

(2)条信息 Infos:

标题2 备选

性别: 男

年龄: 25

author1: bysir

-------------------------------------------------------------------------------- /test/output/component_dynamic.html: -------------------------------------------------------------------------------- 1 |

2main propsClass 1

-------------------------------------------------------------------------------- /test/output/parallel.html: -------------------------------------------------------------------------------- 1 |

sleep 3

sleep 1

sleep 2

sleep 3

sleep 1

-------------------------------------------------------------------------------- /test/output/class.html: -------------------------------------------------------------------------------- 1 | Title

Text

-------------------------------------------------------------------------------- /test/output/component_fragment.html: -------------------------------------------------------------------------------- 1 |

性别: 男

年龄: 25

-------------------------------------------------------------------------------- /util_test.go: -------------------------------------------------------------------------------- 1 | package vpl 2 | 3 | import "testing" 4 | 5 | func TestGetClassFromProps(t *testing.T) { 6 | c := getClassFromProps([]interface{}{ 7 | map[string]interface{}{ 8 | "t": true, 9 | }, 10 | "d", 11 | "c", 12 | }) 13 | 14 | // t d c 15 | t.Logf("%+v", c) 16 | } 17 | -------------------------------------------------------------------------------- /test/output/directive.html: -------------------------------------------------------------------------------- 1 |

v-animate

v-style-important

v-let:hello

-------------------------------------------------------------------------------- /bench/jetviews/bench.jet: -------------------------------------------------------------------------------- 1 | 2 | test 3 | 4 |

7 | {{if item.Print}} 8 |

ID={{item.ID}}, Message={{item.Message}}

9 | {{end}} 10 |

13 | 14 | -------------------------------------------------------------------------------- /bench/struct.go: -------------------------------------------------------------------------------- 1 | package templates 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func getBenchRows(n int) []BenchRow { 8 | rows := make([]BenchRow, n) 9 | for i := 0; i < n; i++ { 10 | rows[i] = BenchRow{ 11 | ID: i, 12 | Message: fmt.Sprintf("message %d", i), 13 | Print: ((i & 1) == 0), 14 | } 15 | } 16 | return rows 17 | } 18 | -------------------------------------------------------------------------------- /test/output/main.html: -------------------------------------------------------------------------------- 1 | Title

Text

Infos:

Startingspan
状态: Sleeping
性别: 男
年龄: 25
End

author: bysir -------------------------------------------------------------------------------- /internal/parser/parsevue_output.txt: -------------------------------------------------------------------------------- 1 | 2 |

4 |
5 | 我的名字：{{name}} 6 |
7 | 我的年龄：25 8 |
9 | 我的性别：男 10 | -------------------------------------------------------------------------------- /test/output/style.html: -------------------------------------------------------------------------------- 1 | Title
Text
-------------------------------------------------------------------------------- /bench/bench.qtpl: -------------------------------------------------------------------------------- 1 | {% code 2 | 3 | type BenchRow struct { 4 | ID int 5 | Message string 6 | Print bool 7 | } 8 | 9 | %} 10 | 11 | {% func BenchPage(rows []BenchRow) %} 12 | test 13 | 14 |
- ID={%d row.ID %}, Message={%s row.Message %}
21 | 22 | 23 | {% endfunc %} 24 | -------------------------------------------------------------------------------- /test/output/component.html: -------------------------------------------------------------------------------- 1 |
Infos:
0
性别: 男
年龄: 25

我是错误的组件 2

Text

Startspan
Not Start
End

我的名字：{{name}}
我的年龄：25
我的性别：男

begin
{{txt}}
end

begin
" 20 | {{txt}} 21 | "
end

` component. 34 | 35 | Please refer to [syntax-parallel](./syntax.md#parallel) 36 | -------------------------------------------------------------------------------- /doc/api.md: -------------------------------------------------------------------------------- 1 | # Go API 2 | 3 | ## Vpl Instance 4 | ``` 5 | import "github.com/zbysir/vpl" 6 | v := vpl.New() 7 | ``` 8 | 9 | > The recommended practice is to have only one Vpl instance for the whole program. 10 | 11 | ## Declare a component 12 | ``` 13 | vue := vpl.New() 14 | // by file 15 | vue.ComponentFile("app", "./app.vue") 16 | // by txt 17 | vue.ComponentTxt("app", ` 18 |

hello {{name}}

19 | `) 20 | ``` 21 | 22 | ## Render a component 23 | ``` 24 | props := vpl.NewProps() 25 | props.Append("name", "tom") 26 | html, err := v.RenderComponent("app", &vpl.RenderParam{ 27 | Props: props, 28 | }) 29 | ``` 30 | 31 | ## vpl.Props 32 | ``` 33 | props := vpl.NewProps() 34 | // use Append to add a variable 35 | props.Append("lang", "en") 36 | 37 | // use AppendMap to add multiple variables 38 | props.AppendMap(map[string]interface{}{ 39 | "title": "hello vpl", 40 | "color": "red", 41 | }) 42 | ``` 43 | 44 | ## vpl.RenderParam 45 | 46 | ``` 47 | vpl.RenderParam{ 48 | Global: nil, // Defined Global Variable in this Render Context. 49 | Props: props, // Props to Render Component. 50 | } 51 | ``` 52 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2020 bysir 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. -------------------------------------------------------------------------------- /internal/parser/parsehtml_output.txt: -------------------------------------------------------------------------------- 1 | ROOT 2 | 3 | 4 | 5 | 6 | 123123 7 | 8 | Pagser Title 9 | <meta [{Key:name Value:keywords} {Key:content Value:golang,pagser,goquery,html,page,parser,colly}]> 10 | <body []> 11 |  12 | <h1 []> 13 | H1 Pagser Example 14 | <span []> 15 | span 16 | <Br []> 17 | <img []> 18 | <input []> 19 | 123123 20 | <input []> 21 | <div []> 22 | bad close 23 | <div [{Key:class Value:navlink}]> 24 | <div [{Key:class Value:container}]> 25 | <ul [{Key:class Value:clearfix}]> 26 | <li [{Key::id Value:} {Key:class Value:tt} {Key:data-b Value:} {Key:dataC Value:}]> 27 | <a [{Key:href Value:/}]> 28 | Index 29 | <li [{Key:@id Value:2}]> 30 | <a [{Key:href Value:/list/web} {Key:title Value:web site}]> 31 | Web page 32 | <li [{Key:id Value:3}]> 33 | <a [{Key:href Value:/list/pc} {Key:title Value:pc page}]> 34 | Pc Page 35 | <li [{Key:id Value:4}]> 36 | <a [{Key:href Value:/list/mobile} {Key:title Value:mobile page}]> 37 | Mobile Page 38 | <select []> 39 | <slot []> 40 | -------------------------------------------------------------------------------- /internal/parser/parsehtml_test.go: -------------------------------------------------------------------------------- 1 | package parser 2 | 3 | import ( 4 | "io/ioutil" 5 | "os" 6 | "testing" 7 | ) 8 | 9 | func TestParse(t *testing.T) { 10 | const rawPageHtml = `<!doctype html> 11 | <html> 12 | <head> 13 | <meta charset="utf-8"> 14 | 123123 15 | <title>Pagser Title 16 | 17 | 18 | 19 | 20 | 21 |

H1 Pagser Example span

22 |
23 | 24 | 123123 25 | 26 |

bad close 27 |

28 |

29 |

Index
Web page
Pc Page
Mobile Page

35 |

36 |

37 | 38 | 41 | 42 | 43 | ` 44 | 45 | nt, err := ParseHtml(rawPageHtml) 46 | if err != nil { 47 | t.Fatal(err) 48 | } 49 | 50 | ioutil.WriteFile("parsehtml_output.txt", []byte(nt.NicePrint(0)), os.ModePerm) 51 | 52 | t.Logf("%s", nt.NicePrint(0)) 53 | } 54 | -------------------------------------------------------------------------------- /test/api_test.go: -------------------------------------------------------------------------------- 1 | package test_test 2 | 3 | import ( 4 | "github.com/zbysir/vpl" 5 | "testing" 6 | ) 7 | 8 | // 测试RenderComponent Api 9 | func TestRenderComponent(t *testing.T) { 10 | layout := ` 11 | 12 | 13 | 14 | {{title}} 15 | 16 | 17 | 18 | 19 | 20 | {{global}} 21 | 22 | 23 | ` 24 | 25 | // 如果直接将组件作为slot渲染, 那么它的作用域就丢失了. 26 | // 所以lang为空 27 | contentTpl := ` 28 |

29 | Title from content {{global}} {{lang}} 30 |

31 | ` 32 | 33 | v := vpl.New() 34 | err := v.ComponentTxt("layout", layout) 35 | if err != nil { 36 | return 37 | } 38 | 39 | props := vpl.NewProps() 40 | props.Append("title", "title") 41 | props.Append("lang", "zh") 42 | 43 | contentStatement, slots, err := vpl.ParseHtmlToStatement(contentTpl, nil) 44 | if err != nil { 45 | t.Fatal(err) 46 | } 47 | 48 | html, err := v.RenderComponent("layout", &vpl.RenderParam{ 49 | Global: map[string]interface{}{ 50 | "global": "global", 51 | }, 52 | Store: nil, 53 | Ctx: nil, 54 | Props: props, 55 | Slots: &vpl.SlotsC{ 56 | Default: &vpl.SlotC{ 57 | Children: contentStatement, 58 | }, 59 | NamedSlot: slots.NamedSlot, 60 | }, 61 | }) 62 | if err != nil { 63 | t.Fatal(err) 64 | return 65 | } 66 | 67 | if html != `title

Title from content global null

global` { 68 | t.Fatalf("组件渲染有误输出: %s", html) 69 | } 70 | t.Logf("%s", html) 71 | } 72 | -------------------------------------------------------------------------------- /internal/lib/parse/html/util_test.go: -------------------------------------------------------------------------------- 1 | package html 2 | 3 | import ( 4 | "testing" 5 | 6 | "github.com/tdewolff/test" 7 | ) 8 | 9 | func TestEscapeAttrVal(t *testing.T) { 10 | var escapeAttrValTests = []struct { 11 | attrVal string 12 | expected string 13 | }{ 14 | {`xyz`, `xyz`}, 15 | {``, ``}, 16 | {`x/z`, `x/z`}, 17 | {`x'z`, `"x'z"`}, 18 | {`x"z`, `'x"z'`}, 19 | {`'x"z'`, `'x"z'`}, 20 | {`'x'"'z'`, `"x'"'z"`}, 21 | {`"x"'"z"`, `'x"'"z'`}, 22 | {`"x'z"`, `"x'z"`}, 23 | {`'x'z'`, `"x'z"`}, 24 | {`a'b=""`, `'a'b=""'`}, 25 | {`x 1 && (b[0] == '"' || b[0] == '\'') && b[0] == b[len(b)-1] { 34 | b = b[1 : len(b)-1] 35 | } 36 | val := EscapeAttrVal(&buf, orig, []byte(b), false) 37 | test.String(t, string(val), tt.expected) 38 | }) 39 | } 40 | } 41 | 42 | func TestEscapeAttrValXML(t *testing.T) { 43 | var escapeAttrValTests = []struct { 44 | attrVal string 45 | expected string 46 | }{ 47 | {`xyz`, `"xyz"`}, 48 | {``, `""`}, 49 | } 50 | var buf []byte 51 | for _, tt := range escapeAttrValTests { 52 | t.Run(tt.attrVal, func(t *testing.T) { 53 | b := []byte(tt.attrVal) 54 | orig := b 55 | if len(b) > 1 && (b[0] == '"' || b[0] == '\'') && b[0] == b[len(b)-1] { 56 | b = b[1 : len(b)-1] 57 | } 58 | val := EscapeAttrVal(&buf, orig, []byte(b), true) 59 | test.String(t, string(val), tt.expected) 60 | }) 61 | } 62 | } 63 | -------------------------------------------------------------------------------- /example/hello/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "context" 5 | "github.com/zbysir/vpl" 6 | ) 7 | 8 | func main() { 9 | v := vpl.New() 10 | 11 | err := v.ComponentTxt("app", ` 12 | 13 | 14 | 15 | 16 | {{title}} 17 | 18 | 19 | 20 |

21 | 22 | color is red 23 | 24 | 25 | color is {{color}} 26 | 27 | 28 |

30 | {{item}} - {{index}} 31 |

33 |

34 | 35 | 36 | 37 | `) 38 | if err != nil { 39 | panic(err) 40 | } 41 | 42 | props := vpl.NewProps() 43 | props.AppendMap(map[string]interface{}{ 44 | "title": "hello vpl", 45 | "color": "red", 46 | "id": "content", 47 | "lang": "en", 48 | "list": []interface{}{1, 2, 3}, 49 | // All data used by Vpl must be a golang base types. 50 | // Use vpl.Copy convert a complex structure to a structure containing only basic types. 51 | "list2": vpl.Copy([3]int{1, 2, 3}), 52 | }) 53 | html, err := v.RenderComponent("app", &vpl.RenderParam{ 54 | Global: nil, 55 | Ctx: context.Background(), 56 | Props: props, 57 | }) 58 | if err != nil { 59 | panic(err) 60 | } 61 | 62 | print(html) 63 | // Output: hello vpl

color is red

1 - 0
2 - 1
3 - 2

64 | } 65 | -------------------------------------------------------------------------------- /statement_test.go: -------------------------------------------------------------------------------- 1 | package vpl 2 | 3 | import ( 4 | "github.com/zbysir/vpl/internal/parser" 5 | "io/ioutil" 6 | "os" 7 | "testing" 8 | ) 9 | 10 | func TestSimpleNodeVue(t *testing.T) { 11 | const rawPageHtml = ` 12 |

13 |

14 | Text 15 |

16 |

17 | Infos: 18 |

Start span
Not Start
{{item.label}}: {{item.value}}
VShow
End

25 |

26 |

27 | ` 28 | 29 | // 将会优化成另一个AST: 30 | // Tag(div, [style(attr): map[color:red]], BindProps) 31 | //

Text

32 | // Tag(div, [id(attr): id, style(attr): map[color:red], style(attr): {'a': 1}]) 33 | // Infos: 34 | // Tag(ul, [class(attr): 'c' + ulClass, class(attr): [b], style(attr): color: red;]) 35 | // If(ifStart) 36 | //

Startspan

37 | // Else 38 | //

Not Start

39 | // For(item in infos) 40 | // Tag(li, [id(attr): item.id, key: item.id]) 41 | // {{item.label}} 42 | // : 43 | // {{item.value}} 44 | // Tag(li, [style(attr): map[top:1px]], v-show) 45 | // VShow 46 | //

End

47 | 48 | nt, err := parser.ParseHtml(rawPageHtml) 49 | if err != nil { 50 | t.Fatal(err) 51 | } 52 | vn, err := parser.ToVueNode(nt, nil) 53 | if err != nil { 54 | t.Fatal(err) 55 | } 56 | 57 | c, _, err := toStatement(vn) 58 | if err != nil { 59 | t.Fatal(err) 60 | } 61 | 62 | ioutil.WriteFile("statement.txt", []byte(NicePrintStatement(c, 0)), os.ModePerm) 63 | } 64 | -------------------------------------------------------------------------------- /test/parallel_test.go: -------------------------------------------------------------------------------- 1 | package test 2 | 3 | import ( 4 | "context" 5 | "encoding/json" 6 | "fmt" 7 | "github.com/zbysir/vpl" 8 | "sync" 9 | "testing" 10 | ) 11 | 12 | type BenchRow struct { 13 | ID int 14 | Message string 15 | Print bool 16 | } 17 | 18 | func getBenchRows(n int) []BenchRow { 19 | rows := make([]BenchRow, n) 20 | for i := 0; i < n; i++ { 21 | rows[i] = BenchRow{ 22 | ID: i, 23 | Message: fmt.Sprintf("message %d", i), 24 | Print: (i & 1) == 0, 25 | //Print: true, 26 | } 27 | } 28 | return rows 29 | } 30 | 31 | // 测试并发渲染 32 | func TestGoParallel(t *testing.T) { 33 | rows := getBenchRows(10) 34 | vue := vpl.New() 35 | err := vue.ComponentTxt("main", ` 36 | test 37 | 38 |

43 | 44 | `) 45 | if err != nil { 46 | t.Fatal(err) 47 | } 48 | var ii interface{} 49 | bs, _ := json.Marshal(rows) 50 | json.Unmarshal(bs, &ii) 51 | props := vpl.NewProps() 52 | props.AppendMap(map[string]interface{}{ 53 | "rows": ii, 54 | }) 55 | 56 | var wg sync.WaitGroup 57 | 58 | for i := 0; i < 400; i++ { 59 | wg.Add(1) 60 | go func() { 61 | defer wg.Done() 62 | ht, err := vue.RenderComponent("main", &vpl.RenderParam{ 63 | Global: nil, 64 | Ctx: context.Background(), 65 | Props: props, 66 | }) 67 | if err != nil { 68 | t.Fatal(err) 69 | } 70 | 71 | if ht != "test

ID=0, Message=message 0
ID=2, Message=message 2
ID=4, Message=message 4
ID=6, Message=message 6
ID=8, Message=message 8

" { 72 | t.Fatal(ht) 73 | } 74 | 75 | //t.Logf("%v %s", rows[0].ID, ht) 76 | }() 77 | } 78 | 79 | wg.Wait() 80 | } 81 | -------------------------------------------------------------------------------- /test/dev/map_mem_test.go: -------------------------------------------------------------------------------- 1 | package dev 2 | 3 | import ( 4 | "fmt" 5 | "runtime" 6 | "strconv" 7 | "testing" 8 | ) 9 | 10 | // 测试map的内存占用 11 | // Alloc = 124008.7578125 TotalAlloc = 166458.078125 Sys = 176679.3671875 NumGC = 6 12 | func TestMap(t *testing.T) { 13 | a := map[string]interface{}{ 14 | "a": 1, 15 | "b": 1, 16 | "c": 1, 17 | "d": 1, 18 | } 19 | d := map[string]interface{}{} 20 | for i := 0; i < 1000000; i++ { 21 | d[strconv.FormatInt(int64(i), 10)] = a 22 | } 23 | 24 | (d["1"].(map[string]interface{}))["a"] = 2 25 | 26 | // 修改的是同一个map, 不存在复制的情况 27 | t.Logf("%+v", d["1"]) 28 | t.Logf("%+v", d["2"]) 29 | 30 | var m runtime.MemStats 31 | runtime.ReadMemStats(&m) 32 | kb := 1024.0 33 | 34 | logstr := fmt.Sprintf("\nAlloc = %v\tTotalAlloc = %v\tSys = %v\t NumGC = %v\n\n", float64(m.Alloc)/kb, float64(m.TotalAlloc)/kb, float64(m.Sys)/kb, m.NumGC) 35 | t.Log(logstr) 36 | } 37 | 38 | type A struct { 39 | a int64 40 | b int 41 | c int 42 | d int 43 | } 44 | 45 | // Alloc = 96430.1640625 TotalAlloc = 128611.578125 Sys = 129657.9921875 NumGC = 6 46 | // 如果使用对象, 存放值, 47 | func TestStruct(t *testing.T) { 48 | a := A{ 49 | a: 1, 50 | b: 1, 51 | c: 1, 52 | d: 1, 53 | } 54 | 55 | // 如果用interface接受参数. 内存占用会更高(比用指针高1/4) 56 | // 124011.0703125 TotalAlloc = 166424.15625 Sys = 176423.3671875 NumGC = 6 57 | // d := map[string]interface{}{} 58 | // 59 | // 用值, 会产生copy, 内存最多 60 | // 178689.0078125 TotalAlloc = 240875.03125 Sys = 239845.2421875 NumGC = 7 61 | // d := map[string]A{} 62 | // 63 | // 如果直接用指针类型, 内存最少 64 | // 96430.1640625 TotalAlloc = 128611.578125 Sys = 129657.9921875 NumGC = 6 65 | d := map[string]*A{} 66 | 67 | for i := 0; i < 1000000; i++ { 68 | d[strconv.FormatInt(int64(i), 10)] = &a 69 | } 70 | 71 | t.Logf("%+v", d["1"]) 72 | t.Logf("%+v", d["2"]) 73 | 74 | var m runtime.MemStats 75 | runtime.ReadMemStats(&m) 76 | kb := 1024.0 77 | 78 | logstr := fmt.Sprintf("\nAlloc = %v\tTotalAlloc = %v\tSys = %v\t NumGC = %v\n\n", float64(m.Alloc)/kb, float64(m.TotalAlloc)/kb, float64(m.Sys)/kb, m.NumGC) 79 | t.Log(logstr) 80 | } 81 | -------------------------------------------------------------------------------- /internal/lib/parse/html/hash.go: -------------------------------------------------------------------------------- 1 | package html 2 | 3 | // generated by hasher -type=Hash -file=hash.go; DO NOT EDIT, except for adding more constants to the list and rerun go generate 4 | 5 | // uses github.com/tdewolff/hasher 6 | //go:generate hasher -type=Hash -file=hash.go 7 | 8 | // Hash defines perfect hashes for a predefined list of strings 9 | type Hash uint32 10 | 11 | // Unique hash definitions to be used instead of strings 12 | const ( 13 | Iframe Hash = 0x6 // iframe 14 | Math Hash = 0x604 // math 15 | Plaintext Hash = 0x1e09 // plaintext 16 | Script Hash = 0xa06 // script 17 | Style Hash = 0x1405 // style 18 | Svg Hash = 0x1903 // svg 19 | Textarea Hash = 0x2308 // textarea 20 | Title Hash = 0xf05 // title 21 | Xmp Hash = 0x1c03 // xmp 22 | ) 23 | 24 | // String returns the hash' name. 25 | func (i Hash) String() string { 26 | start := uint32(i >> 8) 27 | n := uint32(i & 0xff) 28 | if start+n > uint32(len(_Hash_text)) { 29 | return "" 30 | } 31 | return _Hash_text[start : start+n] 32 | } 33 | 34 | // ToHash returns the hash whose name is s. It returns zero if there is no 35 | // such hash. It is case sensitive. 36 | func ToHash(s []byte) Hash { 37 | if len(s) == 0 || len(s) > _Hash_maxLen { 38 | return 0 39 | } 40 | h := uint32(_Hash_hash0) 41 | for i := 0; i < len(s); i++ { 42 | h ^= uint32(s[i]) 43 | h *= 16777619 44 | } 45 | if i := _Hash_table[h&uint32(len(_Hash_table)-1)]; int(i&0xff) == len(s) { 46 | t := _Hash_text[i>>8 : i>>8+i&0xff] 47 | for i := 0; i < len(s); i++ { 48 | if t[i] != s[i] { 49 | goto NEXT 50 | } 51 | } 52 | return i 53 | } 54 | NEXT: 55 | if i := _Hash_table[(h>>16)&uint32(len(_Hash_table)-1)]; int(i&0xff) == len(s) { 56 | t := _Hash_text[i>>8 : i>>8+i&0xff] 57 | for i := 0; i < len(s); i++ { 58 | if t[i] != s[i] { 59 | return 0 60 | } 61 | } 62 | return i 63 | } 64 | return 0 65 | } 66 | 67 | const _Hash_hash0 = 0x9acb0442 68 | const _Hash_maxLen = 9 69 | const _Hash_text = "iframemathscriptitlestylesvgxmplaintextarea" 70 | 71 | var _Hash_table = [1 << 4]Hash{ 72 | 0x0: 0x2308, // textarea 73 | 0x2: 0x6, // iframe 74 | 0x4: 0xf05, // title 75 | 0x5: 0x1e09, // plaintext 76 | 0x7: 0x1405, // style 77 | 0x8: 0x604, // math 78 | 0x9: 0xa06, // script 79 | 0xa: 0x1903, // svg 80 | 0xb: 0x1c03, // xmp 81 | } 82 | -------------------------------------------------------------------------------- /test/class_test.go: -------------------------------------------------------------------------------- 1 | package test 2 | 3 | import ( 4 | "context" 5 | "errors" 6 | "fmt" 7 | "github.com/zbysir/vpl" 8 | "io/ioutil" 9 | "os" 10 | "strings" 11 | "testing" 12 | ) 13 | 14 | func TestClassStyle(t *testing.T) { 15 | cases := []struct { 16 | Name string 17 | IndexComponent string 18 | Tpl []struct { 19 | Name string 20 | Txt string 21 | } 22 | Output string 23 | Checker func(html string) error 24 | }{ 25 | { 26 | // 基础测试 27 | Name: "class", 28 | IndexComponent: `main`, 29 | Tpl: []struct { 30 | Name string 31 | Txt string 32 | }{{ 33 | Name: "main", 34 | Txt: ` 35 | 36 | 37 | 38 | 39 | Title 40 | 41 | 42 |

43 | Text 44 |

45 |

46 | Text 47 |

48 | 49 | 50 | 51 | `, 52 | }}, 53 | Output: "output/%s.html", 54 | Checker: func(html string) error { 55 | if !strings.Contains(html, `style="color: red; top: 10px;"`) { 56 | return errors.New("处理style有误") 57 | } 58 | 59 | if !strings.Contains(html, `class="a b"`) { 60 | return errors.New("处理class有误") 61 | } 62 | 63 | return nil 64 | }, 65 | }, 66 | } 67 | 68 | for _, c := range cases { 69 | t.Run(c.Name, func(t *testing.T) { 70 | vue := vpl.New() 71 | t.Logf("compile....") 72 | 73 | for _, tp := range c.Tpl { 74 | err := vue.ComponentTxt(tp.Name, tp.Txt) 75 | if err != nil { 76 | t.Fatal(err) 77 | } 78 | } 79 | 80 | t.Logf("run....") 81 | 82 | props := vpl.NewProps() 83 | props.AppendMap(map[string]interface{}{ 84 | "css": []interface{}{"b", "c"}, 85 | "color": "red", 86 | }) 87 | var html string 88 | var err error 89 | 90 | html, err = vue.RenderComponent(c.IndexComponent, &vpl.RenderParam{ 91 | Global: nil, 92 | Ctx: context.Background(), 93 | Props: props, 94 | }) 95 | 96 | if err != nil { 97 | t.Fatal(err) 98 | } 99 | ioutil.WriteFile(fmt.Sprintf(c.Output, c.Name), []byte(html), os.ModePerm) 100 | 101 | t.Logf("%s", html) 102 | }) 103 | 104 | } 105 | } 106 | -------------------------------------------------------------------------------- /internal/lib/parse/html/README.md: -------------------------------------------------------------------------------- 1 | # HTML [![GoDoc](http://godoc.org/github.com/tdewolff/parse/html?status.svg)](http://godoc.org/github.com/tdewolff/parse/html) 2 | 3 | This package is an HTML5 lexer written in [Go][1]. It follows the specification at [The HTML syntax](http://www.w3.org/TR/html5/syntax.html). The lexer takes an io.Reader and converts it into tokens until the EOF. 4 | 5 | ## Installation 6 | Run the following command 7 | 8 | go get -u github.com/tdewolff/parse/v2/html 9 | 10 | or add the following import and run project with `go get` 11 | 12 | import "github.com/tdewolff/parse/v2/html" 13 | 14 | ## Lexer 15 | ### Usage 16 | The following initializes a new Lexer with io.Reader `r`: 17 | ``` go 18 | l := html.NewLexer(r) 19 | ``` 20 | 21 | To tokenize until EOF an error, use: 22 | ``` go 23 | for { 24 | tt, data := l.Next() 25 | switch tt { 26 | case html.ErrorToken: 27 | // error or EOF set in l.Err() 28 | return 29 | case html.StartTagToken: 30 | // ... 31 | for { 32 | ttAttr, dataAttr := l.Next() 33 | if ttAttr != html.AttributeToken { 34 | break 35 | } 36 | // ... 37 | } 38 | // ... 39 | } 40 | } 41 | ``` 42 | 43 | All tokens: 44 | ``` go 45 | ErrorToken TokenType = iota // extra token when errors occur 46 | CommentToken 47 | DoctypeToken 48 | StartTagToken 49 | StartTagCloseToken 50 | StartTagVoidToken 51 | EndTagToken 52 | AttributeToken 53 | TextToken 54 | ``` 55 | 56 | ### Examples 57 | ``` go 58 | package main 59 | 60 | import ( 61 | "os" 62 | 63 | "github.com/tdewolff/parse/v2/html" 64 | ) 65 | 66 | // Tokenize HTML from stdin. 67 | func main() { 68 | l := html.NewLexer(os.Stdin) 69 | for { 70 | tt, data := l.Next() 71 | switch tt { 72 | case html.ErrorToken: 73 | if l.Err() != io.EOF { 74 | fmt.Println("Error on line", l.Line(), ":", l.Err()) 75 | } 76 | return 77 | case html.StartTagToken: 78 | fmt.Println("Tag", string(data)) 79 | for { 80 | ttAttr, dataAttr := l.Next() 81 | if ttAttr != html.AttributeToken { 82 | break 83 | } 84 | 85 | key := dataAttr 86 | val := l.AttrVal() 87 | fmt.Println("Attribute", string(key), "=", string(val)) 88 | } 89 | // ... 90 | } 91 | } 92 | } 93 | ``` 94 | 95 | ## License 96 | Released under the [MIT license](https://github.com/tdewolff/parse/blob/master/LICENSE.md). 97 | 98 | [1]: http://golang.org/ "Go Language" 99 | -------------------------------------------------------------------------------- /test/style_test.go: -------------------------------------------------------------------------------- 1 | package test 2 | 3 | import ( 4 | "context" 5 | "errors" 6 | "fmt" 7 | "github.com/zbysir/vpl" 8 | "io/ioutil" 9 | "os" 10 | "strings" 11 | "testing" 12 | ) 13 | 14 | func TestStyle(t *testing.T) { 15 | cases := []struct { 16 | Name string 17 | IndexComponent string 18 | Tpl []struct { 19 | Name string 20 | Txt string 21 | } 22 | Output string 23 | Checker func(html string) error 24 | }{ 25 | { 26 | // 基础测试 27 | Name: "style", 28 | IndexComponent: `main`, 29 | Tpl: []struct { 30 | Name string 31 | Txt string 32 | }{{ 33 | Name: "main", 34 | Txt: ` 35 | 36 | 37 | 38 | 39 | Title 40 | 41 | 42 |

43 | Text 44 |

45 | 46 | 47 | 48 | `, 49 | }}, 50 | Output: "output/%s.html", 51 | Checker: func(html string) error { 52 | if !strings.Contains(html, `font-family: 'Lato',`) { 53 | return errors.New("处理style有误") 54 | } 55 | 56 | return nil 57 | }, 58 | }, 59 | } 60 | 61 | for _, c := range cases { 62 | t.Run(c.Name, func(t *testing.T) { 63 | vue := vpl.New() 64 | t.Logf("compile....") 65 | 66 | for _, tp := range c.Tpl { 67 | err := vue.ComponentTxt(tp.Name, tp.Txt) 68 | if err != nil { 69 | t.Fatal(err) 70 | } 71 | } 72 | 73 | t.Logf("run....") 74 | 75 | props := vpl.NewProps() 76 | props.AppendMap(map[string]interface{}{ 77 | "css": []interface{}{"b", "c"}, 78 | "color": "red", 79 | }) 80 | var html string 81 | var err error 82 | 83 | html, err = vue.RenderComponent(c.IndexComponent, &vpl.RenderParam{ 84 | Global: nil, 85 | Ctx: context.Background(), 86 | Props: props, 87 | }) 88 | 89 | if err != nil { 90 | t.Fatal(err) 91 | } 92 | 93 | if c.Checker != nil { 94 | err = c.Checker(html) 95 | if err != nil { 96 | t.Fatal(err) 97 | } 98 | } 99 | 100 | ioutil.WriteFile(fmt.Sprintf(c.Output, c.Name), []byte(html), os.ModePerm) 101 | 102 | t.Logf("%s", html) 103 | }) 104 | 105 | } 106 | } 107 | -------------------------------------------------------------------------------- /bench/quicktemplate.qtpl.go: -------------------------------------------------------------------------------- 1 | // Code generated by qtc from "bench.qtpl". DO NOT EDIT. 2 | // See https://github.com/valyala/quicktemplate for details. 3 | 4 | //line testdata/templates/bench.qtpl:1 5 | package templates 6 | 7 | //line testdata/templates/bench.qtpl:1 8 | import ( 9 | qtio422016 "io" 10 | 11 | qt422016 "github.com/valyala/quicktemplate" 12 | ) 13 | 14 | //line testdata/templates/bench.qtpl:1 15 | var ( 16 | _ = qtio422016.Copy 17 | _ = qt422016.AcquireByteBuffer 18 | ) 19 | 20 | //line testdata/templates/bench.qtpl:3 21 | type BenchRow struct { 22 | ID int 23 | Message string 24 | Print bool 25 | } 26 | 27 | //line testdata/templates/bench.qtpl:11 28 | func StreamBenchPage(qw422016 *qt422016.Writer, rows []BenchRow) { 29 | //line testdata/templates/bench.qtpl:11 30 | qw422016.N().S(` 31 | test 32 | 33 |

ID=`) 45 | //line testdata/templates/bench.qtpl:17 46 | qw422016.N().D(row.ID) 47 | //line testdata/templates/bench.qtpl:17 48 | qw422016.N().S(`, Message=`) 49 | //line testdata/templates/bench.qtpl:17 50 | qw422016.E().S(row.Message) 51 | //line testdata/templates/bench.qtpl:17 52 | qw422016.N().S(`

64 | 65 | 66 | `) 67 | //line testdata/templates/bench.qtpl:23 68 | } 69 | 70 | //line testdata/templates/bench.qtpl:23 71 | func WriteBenchPage(qq422016 qtio422016.Writer, rows []BenchRow) { 72 | //line testdata/templates/bench.qtpl:23 73 | qw422016 := qt422016.AcquireWriter(qq422016) 74 | //line testdata/templates/bench.qtpl:23 75 | StreamBenchPage(qw422016, rows) 76 | //line testdata/templates/bench.qtpl:23 77 | qt422016.ReleaseWriter(qw422016) 78 | //line testdata/templates/bench.qtpl:23 79 | } 80 | 81 | //line testdata/templates/bench.qtpl:23 82 | func BenchPage(rows []BenchRow) string { 83 | //line testdata/templates/bench.qtpl:23 84 | qb422016 := qt422016.AcquireByteBuffer() 85 | //line testdata/templates/bench.qtpl:23 86 | WriteBenchPage(qb422016, rows) 87 | //line testdata/templates/bench.qtpl:23 88 | qs422016 := string(qb422016.B) 89 | //line testdata/templates/bench.qtpl:23 90 | qt422016.ReleaseByteBuffer(qb422016) 91 | //line testdata/templates/bench.qtpl:23 92 | return qs422016 93 | //line testdata/templates/bench.qtpl:23 94 | } 95 | -------------------------------------------------------------------------------- /doc/syntax.md: -------------------------------------------------------------------------------- 1 | Almost all template syntax comes from [vuejs](https://vuejs.org/), please refer to it. Here is just a preview. 2 | 3 | ## Control Structures 4 | 5 | #### if / else if / else 6 | ```vue 7 |

8 | fooVariable is truthy 9 |

10 |

11 | barVariable is truthy 12 |

13 |

14 | both fooVariable or barVariable are flasey 15 |

16 | ``` 17 | 18 | > tip: If you don't want to generate div tag, use `template` instead of `div`. 19 | 20 | #### range 21 | ```vue 22 |

{{item}}

25 | ``` 26 | ```vue 27 |

{{index}}: {{item}}

30 | ``` 31 | 32 | ## Component 33 | defined component: 34 | ```go 35 | v := vpl.New() 36 | 37 | err := v.ComponentTxt("myComponent", ` 38 |

Hello

39 | `) 40 | ``` 41 | 42 | use the component: 43 | ```vue 44 |

45 | 46 |

47 | ``` 48 | 49 | ### Dynamic-Component 50 | call component by a variable name. 51 | ```vue 52 | 53 | ``` 54 | 55 | ## Slot 56 | Component A: 57 | ```vue 58 |

59 | 60 | Tom 61 | 62 |

63 | ``` 64 | 65 | Component B: 66 | ```vue 67 |

68 | Hello: 69 | 70 |

71 | ``` 72 | 73 | When the componentB renders, `` will be replaced by "Tom". 74 | 75 | For more usage, please see the document of Vuejs: https://vuejs.org/v2/guide/components-slots.html 76 | 77 | ## Fragments 78 | In Vue 3, components now have official support for multi-root node components, i.e., [fragments!](https://v3.vuejs.org/guide/migration/fragments) 79 | 80 | > Components now can have multiple root nodes! However, this does require developers to explicitly define where attributes should be distributed. 81 | 82 | The difference with vue is: vpl uses the `$props` attribute instead of `$attrs` 83 | ```vue 84 | 85 |

...

86 |

...

87 | 88 | ``` 89 | 90 | ## Parallel 91 | The advantage of go is concurrency, can vpl use it? 92 | 93 | Let's see this example: 94 | ```vue 95 |

96 |

97 | 98 | {{ sleep(1) }} 99 |

100 |

101 | 102 | {{ sleep(2) }} 103 |

104 |

105 | ``` 106 | It will take 3s if the template is executed in order. You can wrap them with `parallel` to parallel them. 107 | 108 | ```vue 109 |

110 | 111 |

112 | 113 | {{ sleep(1) }} 114 |

115 | 116 | 117 |

118 | 119 | {{ sleep(2) }} 120 |

121 | 122 |

123 | ``` 124 | Now it only takes 2s. 125 | -------------------------------------------------------------------------------- /test/parallel_comp_test.go: -------------------------------------------------------------------------------- 1 | package test 2 | 3 | import ( 4 | "context" 5 | "fmt" 6 | "github.com/zbysir/vpl" 7 | "io/ioutil" 8 | "os" 9 | "testing" 10 | "time" 11 | ) 12 | 13 | // 测试parallel组件 14 | func TestParallel(t *testing.T) { 15 | cases := []Cases{ 16 | { 17 | // 测试方法调用 18 | Name: "parallel", 19 | IndexTpl: "", 20 | IndexComponent: `main`, 21 | Tpl: []struct { 22 | Name string 23 | Txt string 24 | }{{ 25 | Name: "main", 26 | Txt: ` 27 | 28 | 29 |

30 | 31 | {{ sleep(3) }} 32 |

33 | 34 | 35 |

36 | {{ sleep(1) }} 37 |

38 | 39 | 40 |

41 | {{ sleep(2) }} 42 |

43 | 44 |

45 |

46 | 47 |

48 | 49 | 50 |

51 | 52 | 53 |

54 | 55 |

`, 56 | }}, 57 | Output: "output/%s.html", 58 | Checker: func(html string) error { 59 | 60 | return nil 61 | }, 62 | }, 63 | } 64 | 65 | for _, c := range cases { 66 | t.Run(c.Name, func(t *testing.T) { 67 | vue := vpl.New() 68 | t.Logf("compile....") 69 | 70 | for _, tp := range c.Tpl { 71 | err := vue.ComponentTxt(tp.Name, tp.Txt) 72 | if err != nil { 73 | t.Fatal(err) 74 | } 75 | } 76 | 77 | t.Logf("run....") 78 | 79 | props := vpl.NewProps() 80 | props.AppendMap(map[string]interface{}{ 81 | "sleep": func(r *vpl.RenderCtx, args ...interface{}) interface{} { 82 | ti := interfaceToFloat(args[0]) 83 | time.Sleep(time.Duration(ti) * time.Second) 84 | return fmt.Sprintf("sleep %+v", ti) 85 | }, 86 | }) 87 | var html string 88 | var err error 89 | if c.IndexComponent != "" { 90 | html, err = vue.RenderComponent(c.IndexComponent, &vpl.RenderParam{ 91 | Global: nil, 92 | Ctx: context.Background(), 93 | Props: props, 94 | }) 95 | } else { 96 | html, err = vue.RenderTpl(c.IndexTpl, &vpl.RenderParam{ 97 | Global: nil, 98 | Ctx: context.Background(), 99 | Props: props, 100 | }) 101 | } 102 | 103 | if err != nil { 104 | t.Fatal(err) 105 | } 106 | 107 | if c.Checker != nil { 108 | err = c.Checker(html) 109 | if err != nil { 110 | t.Fatal(err) 111 | } 112 | } 113 | ioutil.WriteFile(fmt.Sprintf(c.Output, c.Name), []byte(html), os.ModePerm) 114 | 115 | t.Logf("%s", html) 116 | }) 117 | } 118 | } 119 | 120 | func interfaceToFloat(s interface{}) (d float64) { 121 | if s == nil { 122 | return 0 123 | } 124 | switch a := s.(type) { 125 | case int: 126 | return float64(a) 127 | case int8: 128 | return float64(a) 129 | case int16: 130 | return float64(a) 131 | case int32: 132 | return float64(a) 133 | case int64: 134 | return float64(a) 135 | case float32: 136 | return float64(a) 137 | case float64: 138 | return a 139 | default: 140 | return 0 141 | } 142 | } 143 | -------------------------------------------------------------------------------- /test/slot_test.go: -------------------------------------------------------------------------------- 1 | package test 2 | 3 | import ( 4 | "context" 5 | "fmt" 6 | "github.com/zbysir/vpl" 7 | "io/ioutil" 8 | "os" 9 | "testing" 10 | ) 11 | 12 | func TestSlot(t *testing.T) { 13 | cases := []struct { 14 | Name string 15 | IndexTpl string 16 | IndexComponent string 17 | Tpl []struct { 18 | Name string 19 | Txt string 20 | } 21 | Output string 22 | Checker func(html string) error 23 | }{ 24 | { 25 | // 测试 slot 26 | // - 具名插槽 27 | // - 备选 28 | // - 插槽作用域 29 | Name: "slot", 30 | // https://cn.vuejs.org/v2/api/#v-bind 31 | // 通过 $props 将父组件的 props 一起传给子组件 32 | // 或者通过 $scope 将父组件中所有变量一起传递给子组件 33 | IndexTpl: "

", 34 | //IndexComponent: "main", 35 | Tpl: []struct { 36 | Name string 37 | Txt string 38 | }{ 39 | { 40 | Name: "main", 41 | Txt: ` 42 |

43 | 44 | 45 |

({{infos.length}})条信息 {{props.title}}:

46 | author2: {{author}} 47 | 48 | author1: {{author}} 49 |

`, 50 | }, 51 | { 52 | Name: "Infos", 53 | Txt: ` 54 | author3: {{author}} 55 | 默认备选 56 | 57 | 标题2 备选 58 | 61 | `, 62 | }, 63 | }, 64 | Output: "output/%s.html", 65 | }, 66 | } 67 | 68 | for _, c := range cases { 69 | t.Run(c.Name, func(t *testing.T) { 70 | vue := vpl.New() 71 | t.Logf("compile....") 72 | 73 | for _, tp := range c.Tpl { 74 | err := vue.ComponentTxt(tp.Name, tp.Txt) 75 | if err != nil { 76 | t.Fatal(err) 77 | } 78 | } 79 | 80 | vue.Global("author", "bysir") 81 | 82 | t.Logf("run....") 83 | 84 | props := vpl.NewProps() 85 | props.AppendMap(map[string]interface{}{ 86 | "id": "helloID", 87 | "infos": []interface{}{ 88 | map[string]interface{}{ 89 | "id": "sex", 90 | "label": "性别", 91 | "value": "男", 92 | }, 93 | map[string]interface{}{ 94 | "id": "age", 95 | "label": "年龄", 96 | "value": "25", 97 | }, 98 | }, 99 | }) 100 | var html string 101 | var err error 102 | if c.IndexComponent != "" { 103 | html, err = vue.RenderComponent(c.IndexComponent, &vpl.RenderParam{ 104 | Global: nil, 105 | Ctx: context.Background(), 106 | Props: props, 107 | }) 108 | } else { 109 | html, err = vue.RenderTpl(c.IndexTpl, &vpl.RenderParam{ 110 | Global: nil, 111 | Ctx: context.Background(), 112 | Props: props, 113 | }) 114 | } 115 | 116 | if err != nil { 117 | t.Fatal(err) 118 | } 119 | 120 | ioutil.WriteFile(fmt.Sprintf(c.Output, c.Name), []byte(html), os.ModePerm) 121 | 122 | t.Logf("%s", html) 123 | 124 | if c.Checker != nil { 125 | err := c.Checker(html) 126 | if err != nil { 127 | t.Fatal(err) 128 | } 129 | } 130 | }) 131 | } 132 | } 133 | -------------------------------------------------------------------------------- /test/func_test.go: -------------------------------------------------------------------------------- 1 | package test 2 | 3 | import ( 4 | "context" 5 | "errors" 6 | "fmt" 7 | "github.com/zbysir/vpl" 8 | "io/ioutil" 9 | "os" 10 | "strings" 11 | "testing" 12 | ) 13 | 14 | type Cases struct { 15 | Name string 16 | IndexTpl string 17 | IndexComponent string 18 | Tpl []struct { 19 | Name string 20 | Txt string 21 | } 22 | Output string 23 | Checker func(html string) error 24 | } 25 | 26 | // 测试function调用 27 | func TestFunc(t *testing.T) { 28 | cases := []Cases{ 29 | { 30 | // 测试方法调用 31 | Name: "function", 32 | IndexTpl: "", 33 | IndexComponent: `main`, 34 | Tpl: []struct { 35 | Name string 36 | Txt string 37 | }{{ 38 | Name: "main", 39 | Txt: `appendName: {{appendName('z', 'bysir')}} | fullName: {{fullName}} {{setVar('fullName', fullName)}} | getVar: {{getVar('fullName')}}`, 40 | }}, 41 | Output: "output/%s.html", 42 | Checker: func(html string) error { 43 | if !strings.Contains(html, "appendName: z|bysir") { 44 | return errors.New("方法返回有误") 45 | } 46 | if !strings.Contains(html, "fullName: z|bysir") { 47 | return errors.New("方法设置Scope有误") 48 | } 49 | if !strings.Contains(html, "getVar: z|bysir") { 50 | return errors.New("方法设置Store有误") 51 | } 52 | 53 | return nil 54 | }, 55 | }, 56 | } 57 | 58 | for _, c := range cases { 59 | t.Run(c.Name, func(t *testing.T) { 60 | vue := vpl.New() 61 | t.Logf("compile....") 62 | 63 | for _, tp := range c.Tpl { 64 | err := vue.ComponentTxt(tp.Name, tp.Txt) 65 | if err != nil { 66 | t.Fatal(err) 67 | } 68 | } 69 | 70 | vue.Global("author", "bysir") 71 | vue.Function("appendName", func(ctx *vpl.RenderCtx, args ...interface{}) interface{} { 72 | fullName := fmt.Sprintf("%s|%s", args[0], args[1]) 73 | ctx.Scope.Set("fullName", fullName) 74 | return fullName 75 | }) 76 | vue.Function("setVar", func(ctx *vpl.RenderCtx, args ...interface{}) interface{} { 77 | ctx.Store.Set(args[0].(string), args[1]) 78 | return "" 79 | }) 80 | vue.Function("getVar", func(ctx *vpl.RenderCtx, args ...interface{}) interface{} { 81 | x, _ := ctx.Store.Get(args[0].(string)) 82 | return x 83 | }) 84 | 85 | t.Logf("run....") 86 | 87 | props := vpl.NewProps() 88 | var html string 89 | var err error 90 | if c.IndexComponent != "" { 91 | html, err = vue.RenderComponent(c.IndexComponent, &vpl.RenderParam{ 92 | Global: nil, 93 | Ctx: context.Background(), 94 | Props: props, 95 | Store: vpl.MapStore{}, 96 | }) 97 | } else { 98 | html, err = vue.RenderTpl(c.IndexTpl, &vpl.RenderParam{ 99 | Global: nil, 100 | Ctx: context.Background(), 101 | Props: props, 102 | Store: vpl.MapStore{}, 103 | }) 104 | } 105 | 106 | if err != nil { 107 | t.Fatal(err) 108 | } 109 | 110 | if c.Checker != nil { 111 | err = c.Checker(html) 112 | if err != nil { 113 | t.Fatal(err) 114 | } 115 | } 116 | ioutil.WriteFile(fmt.Sprintf(c.Output, c.Name), []byte(html), os.ModePerm) 117 | 118 | t.Logf("%s", html) 119 | }) 120 | 121 | } 122 | } 123 | -------------------------------------------------------------------------------- /jsexpression_test.go: -------------------------------------------------------------------------------- 1 | package vpl 2 | 3 | import ( 4 | "fmt" 5 | "testing" 6 | 7 | "github.com/dop251/goja" 8 | "github.com/robertkrimen/otto/parser" 9 | "github.com/zbysir/vpl/internal/lib/log" 10 | ) 11 | 12 | type DataGet struct { 13 | data map[string]interface{} 14 | } 15 | 16 | func (d DataGet) Get(k string) interface{} { 17 | x, _, _ := ShouldLookInterface(d.data, k) 18 | return x 19 | } 20 | 21 | func TestRunJs(t *testing.T) { 22 | cases := []struct { 23 | Code string 24 | Value interface{} 25 | }{ 26 | 27 | {Code: "1+1", Value: 2}, 28 | {Code: "a+1", Value: 2}, 29 | {Code: "a-1", Value: 0}, 30 | 31 | {Code: "-a", Value: -1}, 32 | {Code: "!a", Value: false}, 33 | {Code: "!!a", Value: true}, 34 | {Code: "!0", Value: true}, 35 | {Code: "!(a+1)", Value: false}, 36 | {Code: "!(a-1)", Value: true}, 37 | 38 | {Code: "2 > 1", Value: true}, 39 | {Code: "2 >= 1", Value: true}, 40 | {Code: "1 < 2", Value: true}, 41 | {Code: "1 <= 2", Value: true}, 42 | 43 | {Code: "info.sex", Value: 26}, 44 | {Code: "info.sex+1", Value: 27}, 45 | {Code: "info.sexkey", Value: "sex"}, 46 | {Code: "info[info.sexkey]", Value: 26}, 47 | 48 | {Code: "{'abc': 'abc'}['abc']", Value: "abc"}, 49 | {Code: "{2: 3}['2']", Value: "3"}, 50 | 51 | // getter 52 | {Code: "getter.a", Value: "1"}, 53 | 54 | // call function 55 | {Code: "concat(1,2)", Value: "12"}, 56 | } 57 | 58 | scope := NewScope(nil) 59 | scope.Value = map[string]interface{}{ 60 | "a": 1, 61 | "info": map[string]interface{}{ 62 | "sex": 26, 63 | "sexkey": "sex", 64 | }, 65 | "getter": DataGet{ 66 | data: map[string]interface{}{ 67 | "a": 1, 68 | }, 69 | }, 70 | "concat": func(ctx *RenderCtx, args ...interface{}) interface{} { 71 | return fmt.Sprintf("%+v%+v", args[0], args[1]) 72 | }, 73 | } 74 | 75 | for _, c := range cases { 76 | p, err := parser.ParseFile(nil, "", "("+c.Code+")", 0) 77 | if err != nil { 78 | err = fmt.Errorf("GetAst err: %w, code:%s", err, c.Code) 79 | log.Warning(err) 80 | t.Fatal(err) 81 | } 82 | v, err := runJsExpression(p.Body[0], &RenderCtx{ 83 | Scope: scope, 84 | Store: nil, 85 | }) 86 | if err != nil { 87 | log.Warningf("runJsExpression err:%v", err) 88 | t.Fatal(err) 89 | } 90 | 91 | if fmt.Sprintf("%v", v) != fmt.Sprintf("%v", c.Value) { 92 | t.Fatal(fmt.Sprintf("code %s, want:%+v, get:%+v", c.Code, c.Value, v)) 93 | } 94 | } 95 | 96 | t.Logf("OK") 97 | 98 | } 99 | 100 | func TestInterfaceToBool(t *testing.T) { 101 | var a int64 = 0 102 | if false != interfaceToBool(a) { 103 | t.Fatalf("%v , want false, but:%v", a, interfaceToBool(a)) 104 | } 105 | 106 | } 107 | 108 | func TestGoja(t *testing.T) { 109 | vm := goja.New() 110 | v, err := vm.RunString("2 + 2") 111 | if err != nil { 112 | panic(err) 113 | } 114 | if num := v.Export().(int64); num != 4 { 115 | panic(num) 116 | } 117 | } 118 | 119 | func TestGojaEs6(t *testing.T) { 120 | vm := goja.New() 121 | // panic 122 | // not support es6 feature: Destructuring 123 | v, err := vm.RunString("var a = {a:1}; var b = {...a, c:1}; b") 124 | if err != nil { 125 | panic(err) 126 | } 127 | t.Log(v.Export()) 128 | } 129 | -------------------------------------------------------------------------------- /internal/lib/log/log.go: -------------------------------------------------------------------------------- 1 | package log 2 | 3 | import ( 4 | "github.com/op/go-logging" 5 | "os" 6 | ) 7 | 8 | var logger *logging.Logger 9 | var logger2 *logging.Logger 10 | 11 | func Debug(args ...interface{}) { logger.Debug(args...) } 12 | func Info(args ...interface{}) { logger.Info(args...) } 13 | func Warning(args ...interface{}) { logger.Warning(args...) } 14 | func Error(args ...interface{}) { logger.Error(args...) } 15 | func Fatal(args ...interface{}) { logger.Fatal(args...) } 16 | func Panic(args ...interface{}) { logger.Panic(args...) } 17 | 18 | func Debugf(format string, args ...interface{}) { logger.Debugf(format, args...) } 19 | func Infof(format string, args ...interface{}) { logger.Infof(format, args...) } 20 | func Warningf(format string, args ...interface{}) { logger.Warningf(format, args...) } 21 | func Errorf(format string, args ...interface{}) { logger.Errorf(format, args...) } 22 | func Fatalf(format string, args ...interface{}) { logger.Fatalf(format, args...) } 23 | func Panicf(format string, args ...interface{}) { logger.Panicf(format, args...) } 24 | 25 | // 专门为response提供, 可以传递where 26 | func Errorf2(format string, where string, args ...interface{}) { 27 | logger2.Module = where 28 | logger2.Errorf(format, args...) 29 | } 30 | 31 | func Warningf2(format string, where string, args ...interface{}) { 32 | logger2.Module = where 33 | logger2.Warningf(format, args...) 34 | } 35 | 36 | func Native() *logging.Logger { 37 | return logger 38 | } 39 | 40 | func init() { 41 | SetDebug(true) 42 | } 43 | 44 | // Deprecated: use SetDebug func. 45 | func Init(logDebug bool) { 46 | SetDebug(logDebug) 47 | } 48 | 49 | // debug会影响颜色和最低等级 50 | func SetDebug(logDebug bool) { 51 | logger = New(logDebug) 52 | logger2 = New2(logDebug) 53 | } 54 | 55 | func New(logDebug bool) *logging.Logger { 56 | backend := logging.NewLogBackend(os.Stdout, "", 0) 57 | format := "%{time:2006-01-02 15:04:05.999} %{longfile} %{shortfunc} >> [%{level:.4s}] %{message}" 58 | // debug模式会有颜色, 但在主机上, 颜色代码会乱码, 所以生产环境不应该启用 59 | if logDebug { 60 | format = "%{color}%{time:2006-01-02 15:04:05.999} %{longfile} %{shortfunc} >> [%{level:.4s}]%{color:reset} %{message}" 61 | } 62 | f := logging.MustStringFormatter(format) 63 | backendFormatter := logging.NewBackendFormatter(backend, f) 64 | b := logging.MultiLogger(backendFormatter) 65 | if !logDebug { 66 | b.SetLevel(logging.INFO, "") 67 | } 68 | 69 | logger := logging.MustGetLogger("") 70 | logger.ExtraCalldepth = 1 71 | logger.SetBackend(b) 72 | return logger 73 | } 74 | 75 | // 专门为ginsrv.response提供 76 | func New2(logDebug bool) *logging.Logger { 77 | backend := logging.NewLogBackend(os.Stdout, "", 0) 78 | format := "%{time:2006-01-02 15:04:05.999} %{module} %{shortfunc} >> [%{level:.4s}] %{message}" 79 | // debug模式会有颜色, 但在主机上, 颜色代码会乱码, 所以生产环境不应该启用 80 | if logDebug { 81 | format = "%{color}%{time:2006-01-02 15:04:05.999} %{module} %{shortfunc} >> [%{level:.4s}]%{color:reset} %{message}" 82 | } 83 | f := logging.MustStringFormatter(format) 84 | backendFormatter := logging.NewBackendFormatter(backend, f) 85 | b := logging.MultiLogger(backendFormatter) 86 | if !logDebug { 87 | b.SetLevel(logging.INFO, "") 88 | } 89 | 90 | logger := logging.MustGetLogger("1") 91 | logger.ExtraCalldepth = 1 92 | logger.SetBackend(b) 93 | return logger 94 | } 95 | -------------------------------------------------------------------------------- /bench/timing_test.go: -------------------------------------------------------------------------------- 1 | package templates 2 | 3 | import ( 4 | "context" 5 | "encoding/json" 6 | "github.com/CloudyKit/jet" 7 | "github.com/valyala/quicktemplate" 8 | "github.com/zbysir/vpl" 9 | "log" 10 | "strings" 11 | "testing" 12 | ) 13 | 14 | // cd bench 15 | // go test -bench=. -benchmem 16 | func BenchmarkQuickTemplate1(b *testing.B) { 17 | benchmarkQuickTemplate(b, 1) 18 | } 19 | 20 | func BenchmarkQuickTemplate10(b *testing.B) { 21 | benchmarkQuickTemplate(b, 10) 22 | } 23 | 24 | func BenchmarkQuickTemplate100(b *testing.B) { 25 | benchmarkQuickTemplate(b, 100) 26 | } 27 | func BenchmarkVpl1(b *testing.B) { 28 | benchmarkVpl(b, 1) 29 | } 30 | 31 | func BenchmarkVpl10(b *testing.B) { 32 | benchmarkVpl(b, 10) 33 | } 34 | 35 | func BenchmarkVpl100(b *testing.B) { 36 | benchmarkVpl(b, 100) 37 | } 38 | 39 | func BenchmarkJet1(b *testing.B) { 40 | benchmarkJet(b, 1) 41 | } 42 | 43 | func BenchmarkJet10(b *testing.B) { 44 | benchmarkJet(b, 10) 45 | } 46 | 47 | func BenchmarkJet100(b *testing.B) { 48 | benchmarkJet(b, 100) 49 | } 50 | 51 | func benchmarkQuickTemplate(b *testing.B, rowsCount int) { 52 | b.ReportAllocs() 53 | rows := getBenchRows(rowsCount) 54 | b.RunParallel(func(pb *testing.PB) { 55 | bb := quicktemplate.AcquireByteBuffer() 56 | for pb.Next() { 57 | WriteBenchPage(bb, rows) 58 | bb.Reset() 59 | } 60 | quicktemplate.ReleaseByteBuffer(bb) 61 | }) 62 | } 63 | 64 | func benchmarkVpl(b *testing.B, rowsCount int) { 65 | rows := getBenchRows(rowsCount) 66 | vue := vpl.New() 67 | err := vue.ComponentTxt("main", ` 68 | test 69 | 70 |

75 | 76 | `) 77 | if err != nil { 78 | b.Fatal(err) 79 | } 80 | var ii interface{} 81 | bs, _ := json.Marshal(rows) 82 | json.Unmarshal(bs, &ii) 83 | props := vpl.NewProps() 84 | props.AppendMap(map[string]interface{}{ 85 | "rows": ii, 86 | }) 87 | 88 | b.ResetTimer() 89 | b.ReportAllocs() 90 | b.RunParallel(func(pb *testing.PB) { 91 | for pb.Next() { 92 | _, err := vue.RenderComponent("main", &vpl.RenderParam{ 93 | Global: nil, 94 | Ctx: context.Background(), 95 | Props: props, 96 | }) 97 | if err != nil { 98 | b.Fatal(err) 99 | } 100 | } 101 | }) 102 | } 103 | 104 | func benchmarkJet(b *testing.B, rowsCount int) { 105 | var views = jet.NewHTMLSet("./jetviews") 106 | 107 | view, err := views.GetTemplate("bench.jet") 108 | if err != nil { 109 | log.Println("Unexpected template err:", err.Error()) 110 | } 111 | 112 | rows := getBenchRows(rowsCount) 113 | 114 | b.ResetTimer() 115 | b.ReportAllocs() 116 | b.RunParallel(func(pb *testing.PB) { 117 | for pb.Next() { 118 | var s strings.Builder 119 | view.Execute(&s, nil, rows) 120 | } 121 | }) 122 | } 123 | 124 | func TestJet(t *testing.T) { 125 | var views = jet.NewHTMLSet("./jetviews") 126 | 127 | view, err := views.GetTemplate("bench.jet") 128 | if err != nil { 129 | t.Fatal(err) 130 | } 131 | 132 | rows := getBenchRows(10) 133 | var s strings.Builder 134 | err = view.Execute(&s, nil, rows) 135 | if err != nil { 136 | t.Fatal(err) 137 | } 138 | 139 | t.Logf("%s", s.String()) 140 | } 141 | -------------------------------------------------------------------------------- /go.sum: -------------------------------------------------------------------------------- 1 | github.com/CloudyKit/fastprinter v0.0.0-20200109182630-33d98a066a53 h1:sR+/8Yb4slttB4vD+b9btVEnWgL3Q00OBTzVT8B9C0c= 2 | github.com/CloudyKit/fastprinter v0.0.0-20200109182630-33d98a066a53/go.mod h1:+3IMCy2vIlbG1XG/0ggNQv0SvxCAIpPM5b1nCz56Xno= 3 | github.com/CloudyKit/jet v2.1.2+incompatible h1:ybZoYzMBdoijK6I+Ke3vg9GZsmlKo/ZhKdNMWz0P26c= 4 | github.com/CloudyKit/jet v2.1.2+incompatible/go.mod h1:HPYO+50pSWkPoj9Q/eq0aRGByCL6ScRlUmiEX5Zgm+w= 5 | github.com/andybalholm/brotli v1.0.0/go.mod h1:loMXtMfwqflxFJPmdbJO0a3KNoPuLBgiu3qAvBg8x/Y= 6 | github.com/dlclark/regexp2 v1.4.0 h1:F1rxgk7p4uKjwIQxBs9oAXe5CqrXlCduYEJvrF4u93E= 7 | github.com/dlclark/regexp2 v1.4.0/go.mod h1:2pZnwuY/m+8K6iRw6wQdMtk+rH5tNGR1i55kozfMjCc= 8 | github.com/dop251/goja v0.0.0-20201107160812-7545ac6de48a h1:RYcWAh8DBgQQ7Fi3YhoyMhtGiF8JHKBDSeym7wd9o10= 9 | github.com/dop251/goja v0.0.0-20201107160812-7545ac6de48a/go.mod h1:Mw6PkjjMXWbTj+nnj4s3QPXq1jaT0s5pC0iFD4+BOAA= 10 | github.com/go-sourcemap/sourcemap v1.0.5 h1:oaGf6nqLxwhWPrW5jjNWUYM1SWqHIsJSFcPZojn23Mc= 11 | github.com/go-sourcemap/sourcemap v2.1.3+incompatible h1:W1iEw64niKVGogNgBN3ePyLFfuisuzeidWPMPWmECqU= 12 | github.com/go-sourcemap/sourcemap v2.1.3+incompatible/go.mod h1:F8jJfvm2KbVjc5NqelyYJmf/v5J0dwNLS2mL4sNA1Jg= 13 | github.com/klauspost/compress v1.10.7/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs= 14 | github.com/klauspost/compress v1.11.0/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs= 15 | github.com/op/go-logging v0.0.0-20160315200505-970db520ece7 h1:lDH9UUVJtmYCjyT0CI4q8xvlXPxeZ0gYCVvWbmPlp88= 16 | github.com/op/go-logging v0.0.0-20160315200505-970db520ece7/go.mod h1:HzydrMdWErDVzsI23lYNej1Htcns9BCg93Dk0bBINWk= 17 | github.com/robertkrimen/otto v0.0.0-20200922221731-ef014fd054ac h1:kYPjbEN6YPYWWHI6ky1J813KzIq/8+Wg4TO4xU7A/KU= 18 | github.com/robertkrimen/otto v0.0.0-20200922221731-ef014fd054ac/go.mod h1:xvqspoSXJTIpemEonrMDFq6XzwHYYgToXWj5eRX1OtY= 19 | github.com/tdewolff/parse/v2 v2.5.5 h1:b7ICJa4I/54JQGEGgTte8DiyJPKcC5g8V773QMzkeUM= 20 | github.com/tdewolff/parse/v2 v2.5.5/go.mod h1:WzaJpRSbwq++EIQHYIRTpbYKNA3gn9it1Ik++q4zyho= 21 | github.com/tdewolff/test v1.0.6 h1:76mzYJQ83Op284kMT+63iCNCI7NEERsIN8dLM+RiKr4= 22 | github.com/tdewolff/test v1.0.6/go.mod h1:6DAvZliBAAnD7rhVgwaM7DE5/d9NMOAJ09SqYqeK4QE= 23 | github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw= 24 | github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc= 25 | github.com/valyala/fasthttp v1.16.0/go.mod h1:YOKImeEosDdBPnxc0gy7INqi3m1zK6A+xl6TwOBhHCA= 26 | github.com/valyala/quicktemplate v1.6.3 h1:O7EuMwuH7Q94U2CXD6sOX8AYHqQqWtmIk690IhmpkKA= 27 | github.com/valyala/quicktemplate v1.6.3/go.mod h1:fwPzK2fHuYEODzJ9pkw0ipCPNHZ2tD5KW4lOuSdPKzY= 28 | github.com/valyala/tcplisten v0.0.0-20161114210144-ceec8f93295a/go.mod h1:v3UYOV9WzVtRmSR+PDvWpU/qWl4Wa5LApYYX4ZtKbio= 29 | golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= 30 | golang.org/x/net v0.0.0-20200602114024-627f9648deb9/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= 31 | golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= 32 | golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= 33 | golang.org/x/sys v0.0.0-20200602225109-6fdc65e7d980/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= 34 | golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg= 35 | golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= 36 | gopkg.in/sourcemap.v1 v1.0.5 h1:inv58fC9f9J3TK2Y2R1NPntXEn3/wjWHkonhIUODNTI= 37 | gopkg.in/sourcemap.v1 v1.0.5/go.mod h1:2RlvNNSMglmRrcvhfuzp4hQHwOtjxlbjX7UPY/GXb78= 38 | -------------------------------------------------------------------------------- /internal/lib/parse/html/util.go: -------------------------------------------------------------------------------- 1 | package html 2 | 3 | var ( 4 | singleQuoteEntityBytes = []byte("'") 5 | doubleQuoteEntityBytes = []byte(""") 6 | ) 7 | 8 | // EscapeAttrVal returns the escaped attribute value bytes without quotes. 9 | func EscapeAttrVal(buf *[]byte, orig, b []byte, isXML bool) []byte { 10 | singles := 0 11 | doubles := 0 12 | unquoted := true 13 | entities := false 14 | for _, c := range b { 15 | if charTable[c] { 16 | unquoted = false 17 | if c == '"' { 18 | doubles++ 19 | } else if c == '\'' { 20 | singles++ 21 | } 22 | } 23 | } 24 | if unquoted && !isXML { 25 | return b 26 | } else if !entities && len(orig) == len(b)+2 && (singles == 0 && orig[0] == '\'' || doubles == 0 && orig[0] == '"') { 27 | return orig 28 | } 29 | 30 | n := len(b) + 2 31 | var quote byte 32 | var escapedQuote []byte 33 | if singles >= doubles || isXML { 34 | n += doubles * 4 35 | quote = '"' 36 | escapedQuote = doubleQuoteEntityBytes 37 | } else { 38 | n += singles * 4 39 | quote = '\'' 40 | escapedQuote = singleQuoteEntityBytes 41 | } 42 | if n > cap(*buf) { 43 | *buf = make([]byte, 0, n) // maximum size, not actual size 44 | } 45 | t := (*buf)[:n] // maximum size, not actual size 46 | t[0] = quote 47 | j := 1 48 | start := 0 49 | for i, c := range b { 50 | if c == quote { 51 | j += copy(t[j:], b[start:i]) 52 | j += copy(t[j:], escapedQuote) 53 | start = i + 1 54 | } 55 | } 56 | j += copy(t[j:], b[start:]) 57 | t[j] = quote 58 | return t[:j+1] 59 | } 60 | 61 | var charTable = [256]bool{ 62 | // ASCII 63 | false, false, false, false, false, false, false, false, 64 | false, true, true, false, true, true, false, false, // tab, line feed, form feed, carriage return 65 | false, false, false, false, false, false, false, false, 66 | false, false, false, false, false, false, false, false, 67 | 68 | true, false, true, false, false, false, false, true, // space, "), ' 69 | false, false, false, false, false, false, false, false, 70 | false, false, false, false, false, false, false, false, 71 | false, false, false, false, true, true, true, false, // <, =, > 72 | 73 | false, false, false, false, false, false, false, false, 74 | false, false, false, false, false, false, false, false, 75 | false, false, false, false, false, false, false, false, 76 | false, false, false, false, false, false, false, false, 77 | 78 | true, false, false, false, false, false, false, false, // ` 79 | false, false, false, false, false, false, false, false, 80 | false, false, false, false, false, false, false, false, 81 | false, false, false, false, false, false, false, false, 82 | 83 | // non-ASCII 84 | false, false, false, false, false, false, false, false, 85 | false, false, false, false, false, false, false, false, 86 | false, false, false, false, false, false, false, false, 87 | false, false, false, false, false, false, false, false, 88 | 89 | false, false, false, false, false, false, false, false, 90 | false, false, false, false, false, false, false, false, 91 | false, false, false, false, false, false, false, false, 92 | false, false, false, false, false, false, false, false, 93 | 94 | false, false, false, false, false, false, false, false, 95 | false, false, false, false, false, false, false, false, 96 | false, false, false, false, false, false, false, false, 97 | false, false, false, false, false, false, false, false, 98 | 99 | false, false, false, false, false, false, false, false, 100 | false, false, false, false, false, false, false, false, 101 | false, false, false, false, false, false, false, false, 102 | false, false, false, false, false, false, false, false, 103 | } 104 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Vpl 2 | [![Go Report Card](https://goreportcard.com/badge/github.com/zbysir/vpl)](https://goreportcard.com/report/github.com/zbysir/vpl) 3 | 4 | Vpl is a [Vuejs](https://vuejs.org)-syntax like template-engine for Golang. 5 | 6 | - Componentization 7 | - Powerful template syntax for the modern html 8 | - Supports Js(Es5) expressions 9 | - A little faster (I tried my best to optimize :) 10 | 11 | ## Installation 12 | ``` 13 | go get github.com/zbysir/vpl 14 | ``` 15 | 16 | ## Getting Started 17 | Write the `main.go` file as follows 18 | 19 | ```go 20 | package main 21 | 22 | import ( 23 | "context" 24 | "github.com/zbysir/vpl" 25 | ) 26 | 27 | func main() { 28 | v := vpl.New() 29 | 30 | err := v.ComponentTxt("app", ` 31 | 32 | 33 | 34 | 35 | {{title}} 36 | 37 | 38 | 39 |

40 | 41 | color is red 42 | 43 | 44 | color is {{color}} 45 | 46 |

47 | 48 | 49 | 50 | `) 51 | if err != nil { 52 | panic(err) 53 | } 54 | 55 | props := vpl.NewProps() 56 | props.AppendMap(map[string]interface{}{ 57 | "title": "hello vpl", 58 | "color": "red", 59 | "id": "content", 60 | "lang": "en", 61 | }) 62 | 63 | html, err := v.RenderComponent("app", &vpl.RenderParam{ 64 | Global: nil, 65 | Ctx: context.Background(), 66 | Props: props, 67 | }) 68 | if err != nil { 69 | panic(err) 70 | } 71 | 72 | print(html) 73 | // Output: hello vpl

color is red

74 | } 75 | 76 | ``` 77 | 78 | Then run it. 79 | 80 | > More examples in `/example` and `/test` 81 | 82 | ### Description of the parameters 83 | You only need to understand a few parameters. 84 | 85 | #### vpl.Props 86 | ``` 87 | props := vpl.NewProps() 88 | // use Append to add a variable 89 | props.Append("lang", "en") 90 | 91 | // use AppendMap to add multiple variables 92 | props.AppendMap(map[string]interface{}{ 93 | "title": "hello vpl", 94 | "color": "red", 95 | }) 96 | ``` 97 | 98 | #### vpl.RenderParam 99 | 100 | ``` 101 | vpl.RenderParam{ 102 | Global: nil, // Defined Global Variable in this rendering. 103 | Props: props, // Parameters of the rendering component. 104 | } 105 | ``` 106 | 107 | ### Admonition 108 | 109 | All data used by Vpl must be a golang base types, such as `int64`, `int`, `float32`, `float64`, `[]interface`, `map[string]interface{}`. 110 | 111 | The following example is wrong: 112 | ```go 113 | props.Append("list", [3]int{1, 2, 3}) 114 | ``` 115 | You should use `[]interface` type instead of `[3]int`: 116 | ``` 117 | props.Append("list", []interface{}{1, 2, 3}) 118 | ``` 119 | 120 | For convenience, vpl provides vpl.Copy function to convert a complex structure to a structure containing only basic types. 121 | ``` 122 | props.Append("list", vpl.Copy([3]int{1, 2, 3})) 123 | ``` 124 | 125 | Don't worry too much about performance, it is only executed once in each render. 126 | 127 | ## With Go features 128 | Let's add some go features to vpl. 129 | 130 | ### Parallel 131 | The advantage of go is concurrency, can vpl use it? 132 | 133 | YES! Use the `` component. 134 | 135 | Let's see this example: 136 | ```vue 137 |

138 |

139 | 140 | {{ sleep(1) }} 141 |

142 |

143 | 144 | {{ sleep(2) }} 145 |

146 |

147 | ``` 148 | It will take 3s if the template is executed in order. You can wrap them with `parallel` component to parallel them. 149 | 150 | ```vue 151 |

152 | 153 |

154 | 155 | {{ sleep(1) }} 156 |

157 | 158 | 159 |

160 | 161 | {{ sleep(2) }} 162 |

163 | 164 |

165 | ``` 166 | It only takes 2s now. 167 | 168 | ## Docs 169 | - [Syntax Reference](./doc/syntax.md) 170 | - [Golang API](./doc/api.md) 171 | - [Vpl Internals](./doc/internal.md) 172 | 173 | ## IntelliJ Plugin 174 | Just use the Vuejs plugin. 175 | 176 | ## Dependencies 177 | - github.com/robertkrimen/otto: It is used to parse Js expression. 178 | -------------------------------------------------------------------------------- /internal/util/util.go: -------------------------------------------------------------------------------- 1 | package util 2 | 3 | import ( 4 | "encoding/json" 5 | "fmt" 6 | "html" 7 | "reflect" 8 | "sort" 9 | "strconv" 10 | "strings" 11 | "unsafe" 12 | ) 13 | 14 | func GetSortedKey(m interface{}) (keys []string) { 15 | switch t := m.(type) { 16 | case map[string]string: 17 | keys = make([]string, len(t)) 18 | index := 0 19 | for k := range t { 20 | keys[index] = k 21 | index++ 22 | } 23 | if len(t) < 2 { 24 | return keys 25 | } 26 | 27 | sort.Strings(keys) 28 | case map[string]interface{}: 29 | keys = make([]string, len(t)) 30 | index := 0 31 | for k := range t { 32 | keys[index] = k 33 | index++ 34 | } 35 | if len(t) < 2 { 36 | return keys 37 | } 38 | 39 | sort.Strings(keys) 40 | default: 41 | panic(fmt.Sprintf("不支持的类型 %T, %+v", m, m)) 42 | } 43 | 44 | return 45 | } 46 | 47 | func CopyMap(data map[string]interface{}) map[string]interface{} { 48 | if data == nil { 49 | return nil 50 | } 51 | m := make(map[string]interface{}, len(data)) 52 | for k, v := range data { 53 | m[k] = v 54 | } 55 | return m 56 | } 57 | 58 | func UnsafeStrToBytes(s string) (b []byte) { 59 | sh := (*reflect.StringHeader)(unsafe.Pointer(&s)) 60 | bh := (*reflect.SliceHeader)(unsafe.Pointer(&b)) 61 | bh.Data = sh.Data 62 | bh.Len = sh.Len 63 | bh.Cap = sh.Len 64 | return b 65 | } 66 | 67 | func UnsafeBytesToStr(z []byte) string { 68 | return *(*string)(unsafe.Pointer(&z)) 69 | } 70 | 71 | func InterfaceToStr(s interface{}, escaped ...bool) (d string) { 72 | switch a := s.(type) { 73 | case string: 74 | d = a 75 | case int: 76 | d = strconv.FormatInt(int64(a), 10) 77 | case int32: 78 | d = strconv.FormatInt(int64(a), 10) 79 | case int64: 80 | d = strconv.FormatInt(a, 10) 81 | case float64: 82 | d = strconv.FormatFloat(a, 'f', -1, 64) 83 | case interface{ MarshalJSON() ([]byte, error) }: 84 | bs, _ := a.MarshalJSON() 85 | d = string(bs) 86 | case interface{ String() string }: 87 | d = a.String() 88 | default: 89 | bs, _ := json.Marshal(a) 90 | d = string(bs) 91 | } 92 | 93 | if len(escaped) == 1 && escaped[0] { 94 | d = Escape(d) 95 | } 96 | return 97 | } 98 | 99 | func Escape(src string) string { 100 | return html.EscapeString(src) 101 | } 102 | 103 | // 104 | var styleEscaper = strings.NewReplacer( 105 | `&`, "&", 106 | // 单引号在style中是合法的. 107 | //`'`, "'", // "'" is shorter than "'" and apos was not in HTML until HTML5. 108 | `<`, "<", 109 | `>`, ">", 110 | `"`, """, // """ is shorter than """. 111 | ) 112 | 113 | // EscapeStyle 和 html.EscapeString() 不同, EscapeStyle 不会再替换单引号 ', 因为单引号在style中是合法的. 114 | func EscapeStyle(src string) string { 115 | return styleEscaper.Replace(src) 116 | } 117 | 118 | // 字符串false,0 会被认定为false 119 | func InterfaceToBool(s interface{}) (d bool) { 120 | if s == nil { 121 | return false 122 | } 123 | switch a := s.(type) { 124 | case bool: 125 | return a 126 | case int: 127 | return a != 0 128 | case int8: 129 | return a != 0 130 | case int16: 131 | return a != 0 132 | case int32: 133 | return a != 0 134 | case int64: 135 | return a != 0 136 | case float64: 137 | return a != 0 138 | case float32: 139 | return a != 0 140 | case string: 141 | return a != "" && a != "false" && a != "0" 142 | default: 143 | return true 144 | } 145 | } 146 | 147 | func ForInterface(s interface{}, cb func(index int, v interface{}) error) error { 148 | switch a := s.(type) { 149 | case []interface{}: 150 | for i := range a { 151 | if err := cb(i, a[i]); err != nil { 152 | return err 153 | } 154 | } 155 | case []map[string]interface{}: 156 | for i := range a { 157 | if err := cb(i, a[i]); err != nil { 158 | return err 159 | } 160 | } 161 | case []int: 162 | for i := range a { 163 | if err := cb(i, a[i]); err != nil { 164 | return err 165 | } 166 | } 167 | case []int64: 168 | for i := range a { 169 | if err := cb(i, a[i]); err != nil { 170 | return err 171 | } 172 | } 173 | case []int32: 174 | for i := range a { 175 | if err := cb(i, a[i]); err != nil { 176 | return err 177 | } 178 | } 179 | case []string: 180 | for i := range a { 181 | if err := cb(i, a[i]); err != nil { 182 | return err 183 | } 184 | } 185 | case []float64: 186 | for i := range a { 187 | if err := cb(i, a[i]); err != nil { 188 | return err 189 | } 190 | } 191 | } 192 | 193 | return nil 194 | } 195 | 196 | func Interface2Slice(s interface{}) (d []interface{}) { 197 | 198 | return 199 | } 200 | -------------------------------------------------------------------------------- /test/directive_test.go: -------------------------------------------------------------------------------- 1 | package test 2 | 3 | import ( 4 | "context" 5 | "encoding/json" 6 | "errors" 7 | "fmt" 8 | "github.com/zbysir/vpl" 9 | "github.com/zbysir/vpl/internal/lib/log" 10 | "io/ioutil" 11 | "os" 12 | "strings" 13 | "testing" 14 | ) 15 | 16 | func TestDirective(t *testing.T) { 17 | cases := []struct { 18 | Name string 19 | IndexComponent string 20 | Tpl []struct { 21 | Name string 22 | Txt string 23 | } 24 | Output string 25 | Checker func(html string) error 26 | }{ 27 | { 28 | Name: "directive", 29 | IndexComponent: `main`, 30 | Tpl: []struct { 31 | Name string 32 | Txt string 33 | }{{ 34 | Name: "main", 35 | Txt: ` 36 | 37 |

38 | v-animate 39 |

40 |

41 | v-style-important 42 |

43 | 46 | 47 |

48 | v-show 49 |

50 | 51 |

52 | v-let:{{testData}} 53 |

54 | 55 | 56 | 57 | `, 58 | }}, 59 | Output: "output/%s.html", 60 | Checker: func(html string) error { 61 | if !strings.Contains(html, `data-wow-iteration`) || !strings.Contains(html, `class="wow"`) { 62 | return errors.New("自定义指令执行v-animate有误") 63 | } 64 | 65 | if !strings.Contains(html, `color: red !important`) { 66 | return errors.New("自定义指令v-style-important执行有误") 67 | } 68 | 69 | if !strings.Contains(html, `display: none; top: 10px;`) { 70 | return errors.New("自定义指令v-show执行有误") 71 | } 72 | 73 | if !strings.Contains(html, `v-let:hello`) { 74 | return errors.New("自定义指令v-let执行有误") 75 | } 76 | 77 | return nil 78 | }, 79 | }, 80 | } 81 | 82 | for _, c := range cases { 83 | t.Run(c.Name, func(t *testing.T) { 84 | v := vpl.New() 85 | t.Logf("compile....") 86 | 87 | type Animate struct { 88 | Type string `json:"type"` 89 | Direction string `json:"direction"` 90 | Iteration int `json:"iteration"` 91 | Delay float64 `json:"delay"` 92 | Duration float64 `json:"duration"` 93 | } 94 | v.Directive("animate", func(ctx *vpl.RenderCtx, nodeData *vpl.NodeData, binding *vpl.DirectivesBinding) { 95 | var a Animate 96 | Copy(binding.Value, &a) 97 | 98 | if nodeData.Props==nil{ 99 | nodeData.Props = vpl.NewProps() 100 | } 101 | nodeData.Props.AppendAttr("data-wow-iteration", fmt.Sprintf("%v", a.Iteration)) 102 | nodeData.Props.AppendAttr("data-wow-delay", fmt.Sprintf("%0.2fs", a.Delay)) 103 | nodeData.Props.AppendAttr("data-wow-duration", fmt.Sprintf("%0.2fs", a.Duration)) 104 | 105 | nodeData.Props.AppendClass("wow") 106 | }) 107 | 108 | v.Directive("style-important", func(ctx *vpl.RenderCtx, nodeData *vpl.NodeData, binding *vpl.DirectivesBinding) { 109 | m := binding.Value.(map[string]interface{}) 110 | if nodeData.Props==nil{ 111 | nodeData.Props = vpl.NewProps() 112 | } 113 | for k, v := range m { 114 | nodeData.Props.AppendStyle(map[string]string{ 115 | k: v.(string) + " !important", 116 | }) 117 | } 118 | }) 119 | 120 | v.Directive("show", func(ctx *vpl.RenderCtx, nodeData *vpl.NodeData, binding *vpl.DirectivesBinding) { 121 | if nodeData.Props==nil{ 122 | log.Infof("nodeData.Props==nil") 123 | nodeData.Props = vpl.NewProps() 124 | } 125 | nodeData.Props.AppendStyle(map[string]string{ 126 | "display": "none", 127 | }) 128 | }) 129 | v.Directive("let", func(ctx *vpl.RenderCtx, nodeData *vpl.NodeData, binding *vpl.DirectivesBinding) { 130 | ctx.Scope.Set(binding.Arg, binding.Value) 131 | }) 132 | 133 | v.Directive("js-set", func(ctx *vpl.RenderCtx, nodeData *vpl.NodeData, binding *vpl.DirectivesBinding) { 134 | bs, _ := json.Marshal(binding.Value) 135 | 136 | nodeData.Slots.Default = &vpl.Slot{ 137 | SlotC: &vpl.SlotC{ 138 | Name: "", 139 | Children: &vpl.StrStatement{Str: fmt.Sprintf("var %s=%s;", binding.Arg, bs)}, 140 | }, 141 | Declarer: nil, 142 | } 143 | }) 144 | 145 | for _, tp := range c.Tpl { 146 | err := v.ComponentTxt(tp.Name, tp.Txt) 147 | if err != nil { 148 | t.Fatal(err) 149 | } 150 | } 151 | 152 | t.Logf("run....") 153 | 154 | props := vpl.NewProps() 155 | props.AppendMap(map[string]interface{}{ 156 | "css": []interface{}{"b", "c"}, 157 | "color": "red", 158 | "show": false, 159 | }) 160 | var html string 161 | var err error 162 | 163 | html, err = v.RenderComponent(c.IndexComponent, &vpl.RenderParam{ 164 | Global: nil, 165 | Ctx: context.Background(), 166 | Props: props, 167 | }) 168 | 169 | if err != nil { 170 | t.Fatal(err) 171 | } 172 | ioutil.WriteFile(fmt.Sprintf(c.Output, c.Name), []byte(html), os.ModePerm) 173 | 174 | t.Logf("%s", html) 175 | 176 | if c.Checker != nil { 177 | err = c.Checker(html) 178 | if err != nil { 179 | t.Fatal(err) 180 | } 181 | } 182 | }) 183 | 184 | } 185 | } 186 | 187 | func Copy(src, dst interface{}) (err error) { 188 | //json := jsoniter.ConfigCompatibleWithStandardLibrary 189 | bs, err := json.Marshal(src) 190 | if err != nil { 191 | return 192 | } 193 | err = json.Unmarshal(bs, dst) 194 | if err != nil { 195 | return 196 | } 197 | 198 | return 199 | } 200 | -------------------------------------------------------------------------------- /util.go: -------------------------------------------------------------------------------- 1 | package vpl 2 | 3 | import ( 4 | "encoding/json" 5 | "fmt" 6 | "github.com/zbysir/vpl/internal/lib/log" 7 | "github.com/zbysir/vpl/internal/parser" 8 | "github.com/zbysir/vpl/internal/util" 9 | "sort" 10 | "strings" 11 | ) 12 | 13 | // classProps: 支持 obj, array, string 14 | func getClassFromProps(classProps interface{}) parser.Class { 15 | if classProps == nil { 16 | return nil 17 | } 18 | var cs []string 19 | switch t := classProps.(type) { 20 | case []string: 21 | cs = t 22 | case string: 23 | cs = []string{t} 24 | case map[string]interface{}: 25 | c := make([]string, 0, len(t)/2) 26 | for k, v := range t { 27 | if util.InterfaceToBool(v) { 28 | c = append(c, k) 29 | } 30 | } 31 | sort.Strings(c) 32 | cs = c 33 | case []interface{}: 34 | var c []string 35 | for _, v := range t { 36 | cc := getClassFromProps(v) 37 | c = append(c, cc...) 38 | } 39 | 40 | cs = c 41 | } 42 | 43 | for i := range cs { 44 | cs[i] = util.Escape(cs[i]) 45 | } 46 | 47 | return cs 48 | } 49 | 50 | func writeClass(classProps interface{}, w *strings.Builder) { 51 | if classProps == nil { 52 | return 53 | } 54 | switch t := classProps.(type) { 55 | case []string: 56 | for _, c := range t { 57 | if w.Len() != 0 { 58 | w.WriteString(" ") 59 | } 60 | w.WriteString(util.Escape(c)) 61 | } 62 | case string: 63 | if w.Len() != 0 { 64 | w.WriteString(" ") 65 | } 66 | w.WriteString(util.Escape(t)) 67 | 68 | case map[string]interface{}: 69 | c := make([]string, 0, len(t)/2) 70 | for k, v := range t { 71 | if util.InterfaceToBool(v) { 72 | c = append(c, k) 73 | } 74 | } 75 | sort.Strings(c) 76 | for _, c := range c { 77 | if w.Len() != 0 { 78 | w.WriteString(" ") 79 | } 80 | w.WriteString(util.Escape(c)) 81 | } 82 | case []interface{}: 83 | for _, v := range t { 84 | writeClass(v, w) 85 | } 86 | } 87 | } 88 | 89 | // 将静态props生成attr字符串 90 | // 用于预编译 91 | func genAttrFromProps(props parser.Props) string { 92 | s := strings.Builder{} 93 | for _, a := range props { 94 | if !a.IsStatic { 95 | continue 96 | } 97 | if a.Key == "style" { 98 | sty := getStyleFromProps(a.StaticVal) 99 | if len(sty) != 0 { 100 | if s.Len() != 0 { 101 | s.WriteString(" ") 102 | } 103 | s.WriteString(`style="`) 104 | s.WriteString(sty.ToAttr()) 105 | s.WriteString(`"`) 106 | } 107 | } else if a.Key == "class" { 108 | cla := getClassFromProps(a.StaticVal) 109 | if len(cla) != 0 { 110 | if s.Len() != 0 { 111 | s.WriteString(" ") 112 | } 113 | s.WriteString(`class="`) 114 | s.WriteString(cla.ToAttr()) 115 | s.WriteString(`"`) 116 | } 117 | } else { 118 | if s.Len() != 0 { 119 | s.WriteString(" ") 120 | } 121 | v := a.StaticVal.(string) 122 | if v != "" { 123 | s.WriteString(fmt.Sprintf(`%s="%s"`, a.Key, v)) 124 | } else { 125 | s.WriteString(fmt.Sprintf(`%s`, a.Key)) 126 | } 127 | } 128 | } 129 | 130 | return s.String() 131 | } 132 | 133 | // 打印Statement, 方便调试 134 | func NicePrintStatement(st Statement, lev int) string { 135 | index := strings.Repeat(" ", lev*2) 136 | 137 | s := "" 138 | switch t := st.(type) { 139 | case *EmptyStatement: 140 | s += fmt.Sprintf("%sEmptyStatement\n", index) 141 | case *StrStatement: 142 | s += fmt.Sprintf("%s%s\n", index, t.Str) 143 | case *groupStatement: 144 | s = "" 145 | for _, v := range t.s { 146 | s += fmt.Sprintf("%s", NicePrintStatement(v, lev)) 147 | } 148 | case *ComponentStatement: 149 | s += fmt.Sprintf("%s<%s>\n", index, t.ComponentKey) 150 | if t.ComponentStruct.Slots.Default != nil { 151 | s += fmt.Sprintf("%s", NicePrintStatement(t.ComponentStruct.Slots.Default.Children, lev+1)) 152 | } 153 | s += fmt.Sprintf("%s<%s/>\n", index, t.ComponentKey) 154 | case *tagStatement: 155 | s += fmt.Sprintf("%sTag(%s, %+v", index, t.tag, t.tagStruct.Props) 156 | if t.tagStruct.VBind != nil { 157 | if t.tagStruct.VBind.useProps { 158 | s += fmt.Sprintf(", BindProps") 159 | } 160 | } 161 | 162 | if len(t.tagStruct.Directives) != 0 { 163 | s += fmt.Sprintf(",") 164 | for _, v := range t.tagStruct.Directives { 165 | s += fmt.Sprintf(" v-%s", v.Name) 166 | } 167 | } 168 | 169 | s += fmt.Sprintf(")\n") 170 | 171 | if t.tagStruct.Slots != nil && t.tagStruct.Slots.Default != nil { 172 | s += fmt.Sprintf("%s", NicePrintStatement(t.tagStruct.Slots.Default.Children, lev+1)) 173 | } 174 | 175 | case *ifStatement: 176 | s += fmt.Sprintf("%sIf(%+v)\n", index, t.conditionCode) 177 | s += fmt.Sprintf("%s", NicePrintStatement(t.ChildStatement, lev+1)) 178 | 179 | for _, ef := range t.ElseIf { 180 | if ef.conditionCode != "" { 181 | s += fmt.Sprintf("%sElseIf(%+v)\n", index, ef.conditionCode) 182 | } else { 183 | s += fmt.Sprintf("%sElse\n", index) 184 | } 185 | 186 | s += fmt.Sprintf("%s", NicePrintStatement(ef.ChildStatement, lev+1)) 187 | } 188 | case *forStatement: 189 | s += fmt.Sprintf("%sFor(%s in %s)\n", index, t.ItemKey, t.ArrayKey) 190 | s += fmt.Sprintf("%s", NicePrintStatement(t.ChildChunks, lev+1)) 191 | case *mustacheStatement: 192 | s += fmt.Sprintf("%s{{%s}}\n", index, t.exp) 193 | case *rawHtmlStatement: 194 | s += fmt.Sprintf("%s{{{%s}}}\n", index, t.exp) 195 | default: 196 | 197 | } 198 | 199 | return s 200 | } 201 | 202 | // 不支持json序列化的map, 解决循环引用时Marshal报错的问题 203 | type skipMarshalMap map[string]interface{} 204 | 205 | func (s skipMarshalMap) MarshalJSON() ([]byte, error) { 206 | return nil, nil 207 | } 208 | 209 | // Copy convert a complex structure to a structure containing only basic types. 210 | // Please refer to README.md#Admonition 211 | func Copy(i interface{}) (dst interface{}) { 212 | bs, err := json.Marshal(i) 213 | if err != nil { 214 | log.Warningf("Copy error on Marshal: %v", err) 215 | return nil 216 | } 217 | 218 | err = json.Unmarshal(bs, &dst) 219 | if err != nil { 220 | log.Warningf("Copy error on Unmarshal: %v", err) 221 | return nil 222 | } 223 | return 224 | } 225 | -------------------------------------------------------------------------------- /internal/parser/parsehtml.go: -------------------------------------------------------------------------------- 1 | package parser 2 | 3 | import ( 4 | "fmt" 5 | "github.com/tdewolff/parse/v2" 6 | "github.com/zbysir/vpl/internal/lib/log" 7 | "github.com/zbysir/vpl/internal/lib/parse/html" 8 | "io" 9 | "strings" 10 | ) 11 | 12 | // NodeType is the type of a Node. 13 | type NodeType uint32 14 | 15 | const ( 16 | ErrorNode NodeType = iota 17 | TextNode 18 | DocumentNode 19 | ElementNode 20 | CommentNode 21 | DoctypeNode 22 | scopeMarkerNode 23 | // Root节点只是一个虚拟节点, 方便管理, 不会参与渲染, 而是直接渲染子级 24 | RootNode 25 | ) 26 | 27 | type Node struct { 28 | NodeType NodeType 29 | Tag string 30 | Text string // value of TextNode 31 | Attrs []Attr 32 | Parent *Node 33 | Child []*Node 34 | } 35 | 36 | type Attr struct { 37 | Key string 38 | Value string 39 | } 40 | 41 | func (p *Node) AddChild(n *Node) { 42 | p.Child = append(p.Child, n) 43 | n.Parent = p 44 | return 45 | } 46 | 47 | func (p *Node) AddBor(n *Node) { 48 | p.Parent.AddChild(n) 49 | 50 | return 51 | } 52 | 53 | func (p *Node) Add(n *Node) { 54 | // 如果是容器, 则往里添加, 否则添加为兄弟节点 55 | if p.NodeType == ElementNode || p.NodeType == RootNode { 56 | if VoidElements[p.Tag] { 57 | p.AddBor(n) 58 | } else { 59 | p.AddChild(n) 60 | } 61 | } else { 62 | p.AddBor(n) 63 | } 64 | return 65 | } 66 | 67 | func (p *Node) GetParent(deep int) *Node { 68 | curr := p 69 | for i := 0; i < deep; i++ { 70 | if curr.Parent == nil { 71 | return curr 72 | } 73 | curr = curr.Parent 74 | } 75 | 76 | return curr 77 | } 78 | 79 | // 单标签, 在渲染和解析为节点树会使用. 80 | var VoidElements = map[string]bool{ 81 | "area": true, 82 | "base": true, 83 | "br": true, 84 | "col": true, 85 | "embed": true, 86 | "hr": true, 87 | "img": true, 88 | "input": true, 89 | "keygen": true, 90 | "link": true, 91 | "meta": true, 92 | "param": true, 93 | "source": true, 94 | "track": true, 95 | "wbr": true, 96 | } 97 | 98 | // Close当前节点, 返回父级节点 99 | func (p *Node) Close(tag string) *Node { 100 | if p == nil { 101 | return nil 102 | } 103 | if p.NodeType == ElementNode { 104 | // case for '

' 105 | if _, void := VoidElements[p.Tag]; void { 106 | if p.Tag != tag { 107 | return p.GetParent(2) 108 | } else { 109 | return p.GetParent(1) 110 | } 111 | } else { 112 | // 如果上一层的tag不是当前关闭的tag 113 | // 则说明有误: '

12311' 114 | // 则忽略关闭: Closing tag matches nothing 115 | if p.Tag != tag { 116 | log.Warningf("bad close: currTag: %s, wantTag: %s", tag, p.Tag) 117 | return p 118 | } else { 119 | return p.GetParent(1) 120 | } 121 | } 122 | } else { 123 | // case for : 124 | // '

Title

' 125 | // '

' 126 | 127 | // 如果上一层的tag不是当前关闭的tag 则说明有误: '12311' 128 | // 则忽略关闭: Closing tag matches nothing 129 | if p.Parent.Tag != tag { 130 | return p 131 | } else { 132 | // 否则关闭父级 133 | return p.GetParent(2) 134 | } 135 | } 136 | } 137 | 138 | func (p *Node) NicePrint(lev int) string { 139 | s := strings.Repeat(" ", lev) 140 | switch p.NodeType { 141 | case ElementNode: 142 | s += fmt.Sprintf("<%v %+v>\n", p.Tag, p.Attrs) 143 | 144 | for _, v := range p.Child { 145 | s += fmt.Sprintf("%s", v.NicePrint(lev+1)) 146 | } 147 | case TextNode: 148 | s += fmt.Sprintf("%s\n", p.Text) 149 | case CommentNode: 150 | s += fmt.Sprintf("%s\n", p.Text) 151 | case DoctypeNode: 152 | s += fmt.Sprintf("%s\n", p.Text) 153 | case RootNode: 154 | s += fmt.Sprintf("%s\n", "ROOT") 155 | 156 | for _, v := range p.Child { 157 | s += fmt.Sprintf("%s", v.NicePrint(lev+1)) 158 | } 159 | default: 160 | panic(fmt.Sprintf("uncased type of Node: %v", p.NodeType)) 161 | } 162 | 163 | return s 164 | } 165 | 166 | type NodeParser struct { 167 | } 168 | 169 | func NewNodeParser() *NodeParser { 170 | return &NodeParser{ 171 | } 172 | } 173 | 174 | const whitespace = " \t\r\n\f" 175 | 176 | func (p *NodeParser) Parse(l *html.Lexer) (node *Node, err error) { 177 | rootNode := &Node{ 178 | NodeType: RootNode, 179 | Tag: "ROOT", 180 | Text: "", 181 | Attrs: nil, 182 | Parent: nil, 183 | } 184 | currNode := rootNode 185 | 186 | for { 187 | tt, data := l.Next() 188 | switch tt { 189 | case html.ErrorToken: 190 | // error or EOF set in l.Err() 191 | err = l.Err() 192 | if err != nil { 193 | if err == io.EOF { 194 | err = nil 195 | } 196 | } 197 | return rootNode, err 198 | case html.StartTagToken: 199 | tag := string(l.Text()) 200 | nn := &Node{ 201 | NodeType: ElementNode, 202 | Tag: tag, 203 | Attrs: nil, 204 | Child: nil, 205 | } 206 | 207 | currNode.Add(nn) 208 | currNode = nn 209 | case html.StartTagCloseToken: 210 | case html.EndTagToken: 211 | tag := string(l.Text()) 212 | 213 | currNode = currNode.Close(tag) 214 | 215 | case html.CommentToken: 216 | nn := &Node{ 217 | NodeType: CommentNode, 218 | Tag: "", 219 | Text: byte2str(data), 220 | Attrs: nil, 221 | Child: nil, 222 | } 223 | currNode.Add(nn) 224 | currNode = nn 225 | case html.TextToken: 226 | text := strings.Trim(byte2str(data), whitespace) 227 | if len(text) == 0 { 228 | break 229 | } 230 | 231 | nn := &Node{ 232 | NodeType: TextNode, 233 | Tag: "", 234 | Text: text, 235 | Attrs: nil, 236 | Child: nil, 237 | } 238 | currNode.Add(nn) 239 | currNode = nn 240 | case html.AttributeToken: 241 | // 删除引号 242 | attrVal := byte2str(l.AttrVal()) 243 | if strings.HasPrefix(attrVal, `"`) && strings.HasSuffix(attrVal, `"`) { 244 | attrVal = attrVal[1 : len(attrVal)-1] 245 | } else if strings.HasPrefix(attrVal, `'`) && strings.HasSuffix(attrVal, `'`) { 246 | attrVal = attrVal[1 : len(attrVal)-1] 247 | } 248 | 249 | currNode.Attrs = append(currNode.Attrs, Attr{ 250 | Key: byte2str(l.Text()), 251 | Value: attrVal, 252 | }) 253 | case html.StartTagVoidToken: 254 | currNode = currNode.Parent 255 | case html.DoctypeToken: 256 | nn := &Node{ 257 | NodeType: DoctypeNode, 258 | Tag: "", 259 | Text: byte2str(data), 260 | Attrs: nil, 261 | Child: nil, 262 | } 263 | currNode.Add(nn) 264 | currNode = nn 265 | default: 266 | log.Infof("xxx %s: %s %v", tt, l.Text(), l.AttrVal()) 267 | } 268 | } 269 | } 270 | 271 | func ParseHtml(str string) (nt *Node, err error) { 272 | l := html.NewLexer(parse.NewInputString(str)) 273 | return NewNodeParser().Parse(l) 274 | } 275 | 276 | func byte2str(bs []byte) string { 277 | return string(bs) 278 | } 279 | func str2byte(s string) []byte { 280 | return []byte(s) 281 | } 282 | -------------------------------------------------------------------------------- /test/base_test.go: -------------------------------------------------------------------------------- 1 | package test 2 | 3 | import ( 4 | "context" 5 | "encoding/json" 6 | "errors" 7 | "fmt" 8 | "github.com/zbysir/vpl" 9 | "github.com/zbysir/vpl/internal/lib/log" 10 | "io/ioutil" 11 | _ "net/http/pprof" 12 | "os" 13 | "runtime" 14 | "strings" 15 | "testing" 16 | "time" 17 | ) 18 | 19 | func TestBase(t *testing.T) { 20 | cases := []struct { 21 | Name string 22 | IndexTpl string 23 | IndexComponent string 24 | Tpl []struct { 25 | Name string 26 | Txt string 27 | } 28 | Output string 29 | Checker func(html string) error 30 | }{ 31 | { 32 | // 基础测试 33 | Name: "main", 34 | IndexTpl: `{{id}}

`, 35 | IndexComponent: `main`, 36 | Tpl: []struct { 37 | Name string 38 | Txt string 39 | }{{ 40 | Name: "main", 41 | Txt: ` 42 | 43 | 44 | 45 | 46 | Title 47 | 48 | 49 |

50 | Text 51 |

52 |

53 | Infos: 54 |

Starting span
Not Start
状态: Running
状态: Sleeping
状态未知: {{status}}

66 |

67 | 68 | {{$props}}author: {{author}} 69 | 70 | 71 | `, 72 | }}, 73 | Output: "output/%s.html", 74 | Checker: func(html string) error { 75 | if !strings.Contains(html, `class="t d cuuu b a b`) { 76 | return errors.New("处理class有误") 77 | } 78 | 79 | return nil 80 | }, 81 | }, 82 | { 83 | // 测试单标签 84 | Name: "voidElements", 85 | IndexTpl: "

", 86 | Tpl: []struct { 87 | Name string 88 | Txt string 89 | }{ 90 | { 91 | Name: "main", 92 | Txt: ` 93 | 94 | 95 | 96 | 97 | Title 98 | 99 | 100 | 101 | 102 | `, 103 | }, 104 | }, 105 | Output: "output/%s.html", 106 | }, 107 | { 108 | // 测试单标签 109 | Name: "vHtml", 110 | IndexComponent: "main", 111 | Tpl: []struct { 112 | Name string 113 | Txt string 114 | }{ 115 | { 116 | Name: "main", 117 | Txt: ` 118 | 119 |

120 | 121 | 122 | `, 123 | }, 124 | }, 125 | Output: "output/%s.html", 126 | Checker: func(html string) error { 127 | if !strings.Contains(html, `富文本`) { 128 | return errors.New("VHtml指令执行有误") 129 | } 130 | 131 | if !strings.Contains(html, `富文本<span`) { 132 | return errors.New("VText指令执行有误") 133 | } 134 | 135 | return nil 136 | }, 137 | }, 138 | } 139 | 140 | for _, c := range cases { 141 | t.Run(c.Name, func(t *testing.T) { 142 | vue := vpl.New() 143 | t.Logf("compile....") 144 | 145 | for _, tp := range c.Tpl { 146 | err := vue.ComponentTxt(tp.Name, tp.Txt) 147 | if err != nil { 148 | t.Fatal(err) 149 | } 150 | } 151 | 152 | vue.Global("author", "bysir") 153 | 154 | t.Logf("run....") 155 | 156 | props := vpl.NewProps() 157 | props.AppendMap(map[string]interface{}{ 158 | "id": "helloID", 159 | "ulClass": "uuu", 160 | "status": "Sleeping", 161 | "html": "

富文本-

", 162 | "isStart": 1, 163 | "infos": []interface{}{ 164 | map[string]interface{}{ 165 | "id": "sex", 166 | "label": "性别", 167 | "value": "男", 168 | }, 169 | map[string]interface{}{ 170 | "id": "age", 171 | "label": "年龄", 172 | "value": "25", 173 | }, 174 | }, 175 | }) 176 | var html string 177 | var err error 178 | if c.IndexComponent != "" { 179 | html, err = vue.RenderComponent(c.IndexComponent, &vpl.RenderParam{ 180 | Global: nil, 181 | Ctx: context.Background(), 182 | Props: props, 183 | }) 184 | } else { 185 | html, err = vue.RenderTpl(c.IndexTpl, &vpl.RenderParam{ 186 | Global: nil, 187 | Ctx: context.Background(), 188 | Props: props, 189 | }) 190 | } 191 | 192 | if err != nil { 193 | t.Fatal(err) 194 | } 195 | 196 | ioutil.WriteFile(fmt.Sprintf(c.Output, c.Name), []byte(html), os.ModePerm) 197 | 198 | t.Logf("%s", html) 199 | 200 | if c.Checker != nil { 201 | err := c.Checker(html) 202 | if err != nil { 203 | t.Fatal(err) 204 | } 205 | } 206 | }) 207 | } 208 | } 209 | 210 | type data struct { 211 | C []*data `json:"c"` 212 | Msg string `json:"msg"` 213 | } 214 | 215 | func TestRender(t *testing.T) { 216 | vue := vpl.New() 217 | t.Logf("compile....") 218 | err := vue.ComponentTxt("main", ` 219 |

220 | 221 | {{data.msg}} 222 | 223 |

224 |

225 |

226 |

227 | `) 228 | 229 | if err != nil { 230 | t.Fatal(err) 231 | } 232 | 233 | var ii interface{} 234 | // 生成10000个数据 235 | index := 0 236 | var ds []*data 237 | for i := 0; i < 1000; i++ { 238 | ds = append(ds, &data{ 239 | C: nil, 240 | Msg: fmt.Sprintf("%d", index), 241 | }) 242 | index++ 243 | } 244 | 245 | d := data{ 246 | C: ds, 247 | Msg: "1", 248 | } 249 | bs, _ := json.Marshal(d) 250 | json.Unmarshal(bs, &ii) 251 | 252 | time.Sleep(1 * time.Second) 253 | 254 | props := vpl.NewProps() 255 | props.AppendMap(map[string]interface{}{ 256 | "data": ii, 257 | "a": 1, 258 | "class": "ccc", 259 | }) 260 | 261 | log.Infof("run") 262 | 263 | html, err := vue.RenderComponent("main", &vpl.RenderParam{ 264 | Global: nil, 265 | Ctx: context.Background(), 266 | Props: props, 267 | }) 268 | if err != nil { 269 | t.Fatal(err) 270 | } 271 | 272 | t.Logf("%+v", html) 273 | 274 | // 启动一个 http server 275 | // http://localhost:6060/debug/pprof/ 276 | //if err := http.ListenAndServe(":6060", nil); err != nil { 277 | // log.Fatal(err) 278 | //} 279 | } 280 | 281 | // 100 539,790 ns/op 282 | // 10000 53,219,775 ns/op 283 | // -- 2020-10-23 284 | // 100 565072 ns/op 285 | // -- 2020-10-24 删除掉多余的NewProps() 286 | // 511415 ns/op 482172 B/op 6983 allocs/op(WIN) 287 | // -- 2020-10-24 删除掉copyMap 288 | // 453217 ns/op 402995 B/op 6177 allocs/op(WIN) 289 | // -- 2020-10-24 使用pool管理RenderCtx 290 | // 474725 ns/op 390092 B/op 5774 allocs/op(WIN) 291 | // -- 2020-10-24 优化slot存储方式 292 | // 386870 ns/op 339223 B/op 5268 allocs/op(MAC) 293 | // 400494 ns/op 327072 B/op 5266 allocs/op(Win) 294 | // -- 2020-10-16 支持分发props为attr 295 | // 495476 ns/op 379483 B/op 6279 allocs/op(WIN) 296 | // -- 2020-10-27 优化在tag上的props执行 297 | // 323031 ns/op 227109 B/op 3448 allocs/op 298 | // -- 2020-10-28 优化在tag上slot执行 299 | // 378267 ns/op 227844 B/op 3247 allocs/op 300 | func BenchmarkRender(b *testing.B) { 301 | vue := vpl.New() 302 | b.Logf("compile....") 303 | err := vue.ComponentTxt("main", ` 304 |

305 | 306 | {{data.msg}} 307 | 308 |

309 |

310 |

311 |

312 | `) 313 | 314 | if err != nil { 315 | b.Fatal(err) 316 | } 317 | 318 | var ii interface{} 319 | // 生成10000个数据 320 | index := 0 321 | var ds []*data 322 | for i := 0; i < 100; i++ { 323 | ds = append(ds, &data{ 324 | C: nil, 325 | Msg: fmt.Sprintf("%d", index), 326 | }) 327 | index++ 328 | } 329 | 330 | d := data{ 331 | C: ds, 332 | Msg: "1", 333 | } 334 | bs, _ := json.Marshal(d) 335 | json.Unmarshal(bs, &ii) 336 | 337 | props := vpl.NewProps() 338 | props.AppendMap(map[string]interface{}{ 339 | "data": ii, 340 | }) 341 | 342 | b.ResetTimer() 343 | b.ReportAllocs() 344 | 345 | for i := 0; i < b.N; i++ { 346 | _, err := vue.RenderComponent("main", &vpl.RenderParam{ 347 | Global: nil, 348 | Ctx: context.Background(), 349 | Props: props, 350 | }) 351 | if err != nil { 352 | b.Fatal(err) 353 | } 354 | 355 | //b.Logf("%+v", html) 356 | } 357 | 358 | var m runtime.MemStats 359 | runtime.ReadMemStats(&m) 360 | kb := 1024.0 361 | 362 | logstr := fmt.Sprintf("\nAlloc = %v\tTotalAlloc = %v\tSys = %v\t NumGC = %v\n\n", float64(m.Alloc)/kb, float64(m.TotalAlloc)/kb, float64(m.Sys)/kb, m.NumGC) 363 | b.Log(logstr) 364 | } 365 | -------------------------------------------------------------------------------- /test/component_test.go: -------------------------------------------------------------------------------- 1 | package test 2 | 3 | import ( 4 | "context" 5 | "errors" 6 | "fmt" 7 | "github.com/zbysir/vpl" 8 | "io/ioutil" 9 | "os" 10 | "strings" 11 | "testing" 12 | ) 13 | 14 | // 测试组件调用 15 | func TestComponent(t *testing.T) { 16 | cases := []struct { 17 | Name string 18 | IndexTpl string 19 | IndexComponent string 20 | Tpl []struct { 21 | Name string 22 | Txt string 23 | } 24 | Output string 25 | Checker func(html string) error 26 | }{ 27 | { 28 | // 测试组件 29 | Name: "component", 30 | IndexComponent: `main`, 31 | Tpl: []struct { 32 | Name string 33 | Txt string 34 | }{ 35 | { 36 | Name: "main", 37 | Txt: ` 38 |

39 | Infos: 40 | 41 | 我是错误的组件 {{infos.length}} 42 |

`, 43 | }, 44 | { 45 | Name: "Infos", 46 | Txt: ` 47 |

48 | 52 |

53 | `, 54 | }, 55 | }, 56 | Output: "output/%s.html", 57 | Checker: func(html string) error { 58 | if !strings.Contains(html, `性别: 男`) { 59 | return errors.New("调用组件有误") 60 | } 61 | 62 | if !strings.Contains(html, `是错误的组件 2`) { 63 | return errors.New("处理Slot有误") 64 | } 65 | 66 | if !strings.Contains(html, `class="a propsClass"`) { 67 | return errors.New("处理class继承有误") 68 | } 69 | 70 | if !strings.Contains(html, `style="color: red; top: 1px;"`) { 71 | return errors.New("处理style继承有误") 72 | } 73 | 74 | if !strings.Contains(html, `id="id"`) { 75 | return errors.New("处理attr继承有误") 76 | } 77 | 78 | if !strings.Contains(html, `style="a: b;"`) { 79 | return errors.New("处理错误的组件有误") 80 | } 81 | 82 | return nil 83 | }, 84 | }, 85 | { 86 | // 测试组件-fragment, 多个root节点 87 | Name: "component_fragment", 88 | IndexComponent: `main`, 89 | Tpl: []struct { 90 | Name string 91 | Txt string 92 | }{ 93 | { 94 | Name: "main", 95 | Txt: ` 96 |

97 | 98 |

`, 99 | }, 100 | { 101 | Name: "Infos", 102 | Txt: ` 103 |

104 |

105 | 109 |

110 | `, 111 | }, 112 | }, 113 | Output: "output/%s.html", 114 | Checker: func(html string) error { 115 | if !strings.Contains(html, `性别: 男`) { 116 | return errors.New("调用组件有误") 117 | } 118 | 119 | if !strings.Contains(html, `class="a propsClass"`) { 120 | return errors.New("处理class继承有误") 121 | } 122 | 123 | if !strings.Contains(html, `style="color: red; top: 2px;"`) { 124 | return errors.New("处理style继承有误") 125 | } 126 | 127 | if !strings.Contains(html, `id="id"`) { 128 | return errors.New("处理attr继承有误") 129 | } 130 | 131 | return nil 132 | }, 133 | }, 134 | } 135 | 136 | for _, c := range cases { 137 | t.Run(c.Name, func(t *testing.T) { 138 | vue := vpl.New(vpl.WithCanBeAttrsKey(func(k string) bool { 139 | if k == "id" { 140 | return true 141 | } 142 | if strings.HasPrefix(k, "data") { 143 | return true 144 | } 145 | 146 | return false 147 | })) 148 | t.Logf("compile....") 149 | 150 | for _, tp := range c.Tpl { 151 | err := vue.ComponentTxt(tp.Name, tp.Txt) 152 | if err != nil { 153 | t.Fatal(err) 154 | } 155 | } 156 | 157 | vue.Global("author", "bysir") 158 | 159 | t.Logf("run....") 160 | 161 | props := vpl.NewProps() 162 | props.AppendMap(map[string]interface{}{ 163 | "id": "id", 164 | "cla": "propsClass", 165 | "cla1": "compClass", 166 | "class": []interface{}{"abc"}, 167 | "infos": []interface{}{ 168 | map[string]interface{}{ 169 | "id": "sex", 170 | "label": "性别", 171 | "value": "男", 172 | }, 173 | map[string]interface{}{ 174 | "id": "age", 175 | "label": "年龄", 176 | "value": "25", 177 | }, 178 | }, 179 | }) 180 | var html string 181 | var err error 182 | if c.IndexComponent != "" { 183 | html, err = vue.RenderComponent(c.IndexComponent, &vpl.RenderParam{ 184 | Global: nil, 185 | Ctx: context.Background(), 186 | Props: props, 187 | }) 188 | } else { 189 | html, err = vue.RenderTpl(c.IndexTpl, &vpl.RenderParam{ 190 | Global: nil, 191 | Ctx: context.Background(), 192 | Props: props, 193 | }) 194 | } 195 | 196 | if err != nil { 197 | t.Fatal(err) 198 | } 199 | 200 | ioutil.WriteFile(fmt.Sprintf(c.Output, c.Name), []byte(html), os.ModePerm) 201 | 202 | t.Logf("%s", html) 203 | 204 | if c.Checker != nil { 205 | err := c.Checker(html) 206 | if err != nil { 207 | t.Fatal(err) 208 | } 209 | } 210 | }) 211 | } 212 | } 213 | 214 | // 测试动态组件 215 | func TestComponentDynamic(t *testing.T) { 216 | cases := []struct { 217 | Name string 218 | IndexTpl string 219 | IndexComponent string 220 | Tpl []struct { 221 | Name string 222 | Txt string 223 | } 224 | Output string 225 | Checker func(html string) error 226 | }{ 227 | { 228 | // 动态组件 229 | Name: "component_dynamic", 230 | IndexComponent: `main`, 231 | Tpl: []struct { 232 | Name string 233 | Txt string 234 | }{ 235 | { 236 | Name: "main", 237 | Txt: ` 238 |

239 | 241 | 242 | 243 |

`, 244 | }, 245 | { 246 | Name: "Infos", 247 | Txt: ` 248 |

249 | 250 |

251 | {{props['data-a']}} 252 | fullback 253 |

254 | 255 |

256 | `, 257 | }, 258 | { 259 | Name: "item", 260 | Txt: ` 261 |

262 | 263 | 264 |

265 | `, 266 | }, 267 | }, 268 | Output: "output/%s.html", 269 | Checker: func(html string) error { 270 | if !strings.Contains(html, `class="infos propsClass"`) { 271 | return errors.New("处理class继承有误") 272 | } 273 | 274 | if !strings.Contains(html, `style="color: red; top: 2px;"`) { 275 | return errors.New("处理style继承有误") 276 | } 277 | 278 | if !strings.Contains(html, `

2`) { 279 | return errors.New("处理slot有误") 280 | } 281 | 282 | if !strings.Contains(html, `
2main propsClass 1
`) { 283 | return errors.New("处理嵌套slot有误") 284 | } 285 | 286 | return nil 287 | }, 288 | }, 289 | } 290 | 291 | for _, c := range cases { 292 | t.Run(c.Name, func(t testing.T) { 293 | vue := vpl.New(vpl.WithCanBeAttrsKey(func(k string) bool { 294 | if k == "id" { 295 | return true 296 | } 297 | if strings.HasPrefix(k, "data") { 298 | return true 299 | } 300 | 301 | return false 302 | })) 303 | t.Logf("compile....") 304 | 305 | for _, tp := range c.Tpl { 306 | err := vue.ComponentTxt(tp.Name, tp.Txt) 307 | if err != nil { 308 | t.Fatal(err) 309 | } 310 | } 311 | 312 | vue.Global("author", "bysir") 313 | 314 | t.Logf("run....") 315 | 316 | props := vpl.NewProps() 317 | props.AppendMap(map[string]interface{}{ 318 | "id": "id", 319 | "cla": "propsClass", 320 | "cla1": "compClass", 321 | "class": []interface{}{"abc"}, 322 | "infos": []interface{}{ 323 | map[string]interface{}{ 324 | "id": "sex", 325 | "label": "性别", 326 | "value": "男", 327 | }, 328 | map[string]interface{}{ 329 | "id": "age", 330 | "label": "年龄", 331 | "value": "25", 332 | }, 333 | }, 334 | }) 335 | var html string 336 | var err error 337 | if c.IndexComponent != "" { 338 | html, err = vue.RenderComponent(c.IndexComponent, &vpl.RenderParam{ 339 | Global: nil, 340 | Ctx: context.Background(), 341 | Props: props, 342 | }) 343 | } else { 344 | html, err = vue.RenderTpl(c.IndexTpl, &vpl.RenderParam{ 345 | Global: nil, 346 | Ctx: context.Background(), 347 | Props: props, 348 | }) 349 | } 350 | 351 | if err != nil { 352 | t.Fatal(err) 353 | } 354 | 355 | ioutil.WriteFile(fmt.Sprintf(c.Output, c.Name), []byte(html), os.ModePerm) 356 | 357 | t.Logf("%s", html) 358 | 359 | if c.Checker != nil { 360 | err := c.Checker(html) 361 | if err != nil { 362 | t.Fatal(err) 363 | } 364 | } 365 | }) 366 | } 367 | } 368 | -------------------------------------------------------------------------------- /vpl.go: -------------------------------------------------------------------------------- 1 | package vpl 2 | 3 | import ( 4 | "context" 5 | "fmt" 6 | "github.com/valyala/bytebufferpool" 7 | "github.com/zbysir/vpl/internal/parser" 8 | "io/ioutil" 9 | "strings" 10 | "sync" 11 | ) 12 | 13 | // 常驻实例, 一个程序只应该有一个实例. 14 | // 在运行期间是无副作用的 15 | type Vpl struct { 16 | components map[string]Statement 17 | 18 | // 类似原型链, 用于注册方法/等全局变量, 这些变量在每一个组件中都可以使用 19 | prototype Scope 20 | 21 | // 指令 22 | directives map[string]Directive 23 | 24 | // 什么prop可以被写成attr(编译时) 25 | canBeAttrsKey func(k string) bool 26 | 27 | skipComment bool 28 | } 29 | 30 | type Options func(o Vpl) 31 | 32 | func WithCanBeAttrsKey(canBeAttr func(k string) bool) Options { 33 | return func(o Vpl) { 34 | o.canBeAttrsKey = canBeAttr 35 | } 36 | } 37 | 38 | func WithSkipComment(skip bool) Options { 39 | return func(o Vpl) { 40 | o.skipComment = skip 41 | } 42 | } 43 | 44 | // New return a Vpl instance, 45 | // This instance should be shared in multiple renderings. 46 | // The recommended practice is to have only one Vpl instance for the whole program. 47 | func New(options ...Options) Vpl { 48 | vpl := &Vpl{ 49 | components: map[string]Statement{ 50 | // 模板, 直接渲染子组件 51 | // 注意, 所有slot执行都有"编译作用域的问题"(https://cn.vuejs.org/v2/guide/components-slots.html#%E7%BC%96%E8%AF%91%E4%BD%9C%E7%94%A8%E5%9F%9F) 52 | // slot是在父组件声明并会使用变量, 却在子组件中运行, 所以在执行slot时需要使用父组件环境. 53 | "template": FuncStatement(func(ctx StatementCtx, o StatementOptions) error { 54 | if o.Slots == nil { 55 | return nil 56 | } 57 | slot := o.Slots.Default 58 | if slot == nil { 59 | return nil 60 | } 61 | err := slot.Exec(ctx, nil) 62 | if err != nil { 63 | return nil 64 | } 65 | return nil 66 | }), 67 | // 语句 68 | // 注意, 所有slot执行都有"编译作用域的问题"(https://cn.vuejs.org/v2/guide/components-slots.html#%E7%BC%96%E8%AF%91%E4%BD%9C%E7%94%A8%E5%9F%9F) 69 | // slot是在父组件声明并会使用变量, 却在子组件中运行, 所以在执行slot时需要使用父组件环境. 70 | "slot": FuncStatement(func(ctx StatementCtx, o StatementOptions) error { 71 | slotName := "" 72 | attr, exist := o.Props.Get("name") 73 | if exist { 74 | slotName, _ = attr.(string) 75 | } 76 | var slot Slot 77 | 78 | p := o.Parent 79 | if p.Slots != nil { 80 | if slotName == "" { 81 | slot = p.Slots.Default 82 | } else { 83 | slot = p.Slots.Get(slotName) 84 | } 85 | } 86 | 87 | if slot == nil { 88 | // 备选内容 89 | if o.Slots != nil { 90 | fullback := o.Slots.Default 91 | if fullback != nil { 92 | err := fullback.Exec(ctx, nil) 93 | if err != nil { 94 | return err 95 | } 96 | } 97 | } 98 | 99 | return nil 100 | } 101 | 102 | err := slot.Exec(ctx, o) 103 | if err != nil { 104 | return nil 105 | } 106 | return nil 107 | }), 108 | // 并行语句 109 | // 被parallel组件包裹起来的子组件都会被同时渲染, 110 | // 假如有3个耗时组件分别用时 3/2/1 s, 如果都使用parallel组件包裹起来, 最终渲染耗时应该是 3 s. 111 | "parallel": FuncStatement(func(ctx StatementCtx, o StatementOptions) error { 112 | s := NewChanSpan() 113 | go func() { 114 | ctx := ctx.Clone() 115 | ctx.W = NewListWriter() 116 | child := o.Slots.Default 117 | if child == nil { 118 | s.Done("") 119 | return 120 | } 121 | err := child.Exec(ctx, nil) 122 | if err != nil { 123 | s.Done(fmt.Sprintf("err: %+v", err)) 124 | } else { 125 | s.Done(ctx.W.Result()) 126 | } 127 | }() 128 | 129 | ctx.W.WriteSpan(s) 130 | 131 | return nil 132 | }), 133 | // 动态组件 134 | "component": FuncStatement(func(ctx StatementCtx, o StatementOptions) error { 135 | is := "" 136 | attr, exist := o.Props.Get("is") 137 | if exist { 138 | is, _ = attr.(string) 139 | } 140 | 141 | if is == "" { 142 | return nil 143 | } 144 | cp, exist := ctx.Components[is] 145 | if !exist { 146 | return nil 147 | } 148 | 149 | return cp.Exec(ctx, o) 150 | }), 151 | }, 152 | prototype: NewScope(nil), 153 | directives: map[string]Directive{}, 154 | canBeAttrsKey: DefaultCanBeAttr, 155 | skipComment: true, 156 | } 157 | 158 | for _, o := range options { 159 | o(vpl) 160 | } 161 | 162 | if vpl.canBeAttrsKey == nil { 163 | vpl.canBeAttrsKey = DefaultCanBeAttr 164 | } 165 | return vpl 166 | } 167 | 168 | var DefaultCanBeAttr = func(k string) bool { 169 | if k == "id" { 170 | return true 171 | } 172 | if strings.HasPrefix(k, "data-") { 173 | return true 174 | } 175 | 176 | return false 177 | } 178 | 179 | func (v Vpl) Component(name string, c Statement) (err error) { 180 | v.components[name] = c 181 | return nil 182 | } 183 | 184 | // Declare a component by file 185 | func (v Vpl) ComponentFile(name string, path string) (err error) { 186 | fileBs, err := ioutil.ReadFile(path) 187 | if err != nil { 188 | return fmt.Errorf("readFile err: %w", err) 189 | } 190 | 191 | return v.ComponentTxt(name, string(fileBs)) 192 | } 193 | 194 | // Declare a component by txt 195 | func (v Vpl) ComponentTxt(name string, txt string) (err error) { 196 | // 类似以下代码中的v-slot是无效的写法. 197 | // 200 | // 而v-slot只能使用在调用组件时: 201 | // 206 | // 在这个情况下, 编译组件不会返回slot(此时的slot被存放在ComponentStatement上). 207 | // 208 | // 综上, 这里不需要管ParseHtmlToStatement返回的slots值. 209 | s, _, err := ParseHtmlToStatement(txt, &parser.ParseVueNodeOptions{ 210 | CanBeAttr: v.canBeAttrsKey, 211 | SkipComment: v.skipComment, 212 | }) 213 | if err != nil { 214 | return 215 | } 216 | 217 | return v.Component(name, s) 218 | } 219 | 220 | // Global 设置全局变量, 在所有的组件中都生效 221 | // 也可用于设置全局方法 222 | func (v Vpl) Global(name string, val interface{}) () { 223 | v.prototype.Set(name, val) 224 | return 225 | } 226 | 227 | // Function 是对 Global 方法设置全局方法的再次封装 228 | func (v Vpl) Function(name string, val Function) () { 229 | v.prototype.Set(name, val) 230 | return 231 | } 232 | 233 | // Directive 声明一个指令 234 | func (v Vpl) Directive(name string, val Directive) () { 235 | v.directives[name] = val 236 | return 237 | } 238 | 239 | func (v Vpl) NewScope() Scope { 240 | s := NewScope(v.prototype) 241 | return s 242 | } 243 | 244 | // tpl e.g.:
245 | func (v Vpl) RenderTpl(tpl string, p RenderParam) (html string, err error) { 246 | // 类似以下代码中的v-slot是无效的写法. 247 | // 250 | // 而v-slot只能使用在调用组件时: 251 | // 256 | // 在这个情况下, 编译组件不会返回slot(此时的slot被存放在ComponentStatement上). 257 | // 258 | // 综上, 这里不需要管ParseHtmlToStatement返回的slots值. 259 | statement, _, err := ParseHtmlToStatement(tpl, &parser.ParseVueNodeOptions{ 260 | CanBeAttr: v.canBeAttrsKey, 261 | }) 262 | if err != nil { 263 | return "", fmt.Errorf("parseHtmlToStatement err: %w", err) 264 | } 265 | 266 | var w = NewListWriter() 267 | 268 | global := v.NewScope() 269 | 270 | if p.Global != nil { 271 | global = global.Extend(p.Global) 272 | } 273 | ctx := &StatementCtx{ 274 | Global: global, 275 | Store: nil, 276 | Ctx: p.Ctx, 277 | W: w, 278 | Components: v.components, 279 | Directives: v.directives, 280 | CanBeAttrsKey: v.canBeAttrsKey, 281 | } 282 | 283 | propsMap := p.Props.ToMap() 284 | // 将所有props放入scope 285 | scope := ctx.NewScope().Extend(propsMap) 286 | // copyMap是为了让$props和scope的value不相等, 否则在打印$props就会出现循环引用. 287 | scope.Set("$props", skipMarshalMap(propsMap)) 288 | 289 | err = statement.Exec(ctx, &StatementOptions{ 290 | Slots: nil, 291 | Props: p.Props, 292 | Scope: scope, 293 | Parent: nil, 294 | }) 295 | 296 | if err != nil { 297 | err = fmt.Errorf("RenderTpl err: %w", err) 298 | return 299 | } 300 | html = w.Result() 301 | return 302 | } 303 | 304 | // 渲染一个已经编译好的组件 305 | func (v Vpl) RenderComponent(component string, p RenderParam) (html string, err error) { 306 | statement := ComponentStatement{ 307 | ComponentKey: component, 308 | ComponentStruct: ComponentStruct{ 309 | Props: nil, 310 | // 将所有Props传递到组件中 311 | VBind: &vBindC{useProps: true}, 312 | Directives: nil, 313 | Slots: p.Slots, 314 | }, 315 | } 316 | 317 | var w = NewListWriter() 318 | 319 | global := v.NewScope() 320 | 321 | if p.Global != nil { 322 | global = global.Extend(p.Global) 323 | } 324 | ctx := &StatementCtx{ 325 | Global: global, 326 | Store: p.Store, 327 | Ctx: p.Ctx, 328 | W: w, 329 | Components: v.components, 330 | Directives: v.directives, 331 | CanBeAttrsKey: v.canBeAttrsKey, 332 | } 333 | 334 | scope := ctx.NewScope() 335 | scope.Set("$props", p.Props) 336 | err = statement.Exec(ctx, &StatementOptions{ 337 | Slots: nil, 338 | Props: p.Props, 339 | Scope: scope, 340 | Parent: nil, 341 | }) 342 | 343 | if err != nil { 344 | err = fmt.Errorf("RenderComponent err: %w", err) 345 | return 346 | } 347 | 348 | html = w.Result() 349 | return 350 | } 351 | 352 | // 支持同时写Span和string的Write 353 | // 优化多个字符串拼接 354 | type ListWriter struct { 355 | s bytebufferpool.ByteBuffer 356 | 357 | // 可以优化为链表, 减少append消耗 358 | spans []Span 359 | } 360 | 361 | func (p ListWriter) Result() string { 362 | if len(p.spans) == 0 { 363 | s := p.s.String() 364 | p.s.Reset() 365 | return s 366 | } 367 | 368 | if p.s.Len() != 0 { 369 | p.spans = append(p.spans, &StringSpan{s: p.s.String()}) 370 | p.s.Reset() 371 | } 372 | 373 | var s bytebufferpool.ByteBuffer 374 | for _, p := range p.spans { 375 | s.WriteString(p.Result()) 376 | } 377 | 378 | return s.String() 379 | } 380 | 381 | func (p ListWriter) WriteString(s string) { 382 | p.s.WriteString(s) 383 | } 384 | 385 | func (p ListWriter) WriteSpan(span Span) { 386 | if p.s.Len() != 0 { 387 | p.spans = append(p.spans, &StringSpan{s: p.s.String()}) 388 | p.s.Reset() 389 | } 390 | p.spans = append(p.spans, span) 391 | } 392 | 393 | type StringSpan struct { 394 | s string 395 | } 396 | 397 | func (s StringSpan) Result() string { 398 | return s.s 399 | } 400 | 401 | func NewListWriter() ListWriter { 402 | return &ListWriter{} 403 | } 404 | 405 | type ChanSpan struct { 406 | c chan string 407 | getOnce sync.Once 408 | setOnce sync.Once 409 | r string 410 | } 411 | 412 | func (p ChanSpan) Result() string { 413 | p.getOnce.Do(func() { 414 | p.r = <-p.c 415 | }) 416 | return p.r 417 | } 418 | 419 | func (p ChanSpan) Done(s string) { 420 | p.setOnce.Do(func() { 421 | p.c <- s 422 | }) 423 | } 424 | 425 | func NewChanSpan() ChanSpan { 426 | return &ChanSpan{ 427 | c: make(chan string, 1), 428 | getOnce: sync.Once{}, 429 | setOnce: sync.Once{}, 430 | } 431 | } 432 | 433 | type RenderParam struct { 434 | // 声明本次渲染的全局变量, 和vpl.Global()功能类似, 在所有组件中都有效. 435 | // 可以用来存放诸如版本号/作者等全部组件都可能需要访问的数据, 还可以存放方法. 436 | // Global设置的值会覆盖vpl.Global()设置的值. 437 | // 438 | // Q: 如何区分应该使用RenderParam.Global设置全局变量还是vpl.Global()设置全局变量? 439 | // A: 440 | // 根据这个"全局"变量的真正范围而定. 441 | // 如果这个变量是"整个程序"的全局变量, 如一个全局方法, 那么它应该使用vpl.Global()设置 442 | // 如果这个变量是"这一次渲染过程中"的全局变量, 如在渲染每个页面时的页面ID, 那么它应该使用RenderParam.Global设置. 443 | Global map[string]interface{} 444 | // 用于在整个运行环境共享变量, 如在一个方法/指令中读取另一个方法/指令里存储的数据 445 | Store Store 446 | 447 | // unused so far 448 | Ctx context.Context 449 | Props Props 450 | // 渲染组件时给组件传递slots 451 | Slots SlotsC 452 | } 453 | -------------------------------------------------------------------------------- /jsexpression.go: -------------------------------------------------------------------------------- 1 | package vpl 2 | 3 | import ( 4 | "encoding/json" 5 | "fmt" 6 | "strconv" 7 | 8 | "github.com/robertkrimen/otto/ast" 9 | "github.com/robertkrimen/otto/parser" 10 | "github.com/robertkrimen/otto/token" 11 | ) 12 | 13 | func compileJS(code string) (node ast.Node, err error) { 14 | // 用括号包裹的原因是让"{x: 1}"这样的语法解析成对象, 而不是label 15 | code = "(" + code + ")" 16 | p, err := parser.ParseFile(nil, "", code, 0) 17 | if err != nil { 18 | err = fmt.Errorf("ParseFile err: %w, code:%s", err, code) 19 | return nil, err 20 | } 21 | 22 | return p.Body[0], nil 23 | } 24 | 25 | func runJsExpression(node ast.Node, ctx RenderCtx) (r interface{}, err error) { 26 | switch t := node.(type) { 27 | case ast.ExpressionStatement: 28 | return runJsExpression(t.Expression, ctx) 29 | case ast.Identifier: 30 | return ctx.Scope.Get(t.Name), nil 31 | case ast.DotExpression: 32 | // a.b 33 | left, err := runJsExpression(t.Left, ctx) 34 | if err != nil { 35 | return nil, err 36 | } 37 | 38 | r, _, _ := ShouldLookInterface(left, t.Identifier.Name) 39 | return r, nil 40 | case ast.BracketExpression: 41 | // a[b] 42 | left, err := runJsExpression(t.Left, ctx) 43 | if err != nil { 44 | return nil, err 45 | } 46 | var key string 47 | switch m := t.Member.(type) { 48 | case ast.StringLiteral: 49 | // a['b'] 50 | // 也可以走default语句, 但这是fastPath, 可以少调用interfaceToStr函数 51 | key = m.Value 52 | default: 53 | // a[b+c] 54 | v, err := runJsExpression(t.Member, ctx) 55 | if err != nil { 56 | return nil, err 57 | } 58 | 59 | key = interfaceToStr(v) 60 | } 61 | 62 | r, _, _ := ShouldLookInterface(left, key) 63 | return r, nil 64 | case ast.StringLiteral: 65 | return t.Value, nil 66 | case ast.NumberLiteral: 67 | return t.Value, nil 68 | case ast.BooleanLiteral: 69 | return t.Value, nil 70 | case ast.NullLiteral: 71 | return nil, nil 72 | case ast.BinaryExpression: 73 | left, err := runJsExpression(t.Left, ctx) 74 | if err != nil { 75 | return nil, err 76 | } 77 | right, err := runJsExpression(t.Right, ctx) 78 | if err != nil { 79 | return nil, err 80 | } 81 | o := t.Operator 82 | switch o { 83 | case token.STRICT_EQUAL, token.EQUAL: 84 | return left == right, nil 85 | case token.NOT_EQUAL, token.STRICT_NOT_EQUAL: 86 | return left != right, nil 87 | case token.PLUS: 88 | return interfaceAdd(left, right), nil 89 | case token.MINUS: 90 | return interfaceToFloat(left) - interfaceToFloat(right), nil 91 | case token.MULTIPLY: 92 | return interfaceToFloat(left) * interfaceToFloat(right), nil 93 | case token.SLASH: 94 | return interfaceToFloat(left) / interfaceToFloat(right), nil 95 | case token.LOGICAL_AND: 96 | return interfaceToBool(left) && interfaceToBool(right), nil 97 | case token.LOGICAL_OR: 98 | return interfaceToBool(left) || interfaceToBool(right), nil 99 | case token.LESS: 100 | return interfaceLess(left, right), nil 101 | case token.GREATER: 102 | return interfaceGreater(left, right), nil 103 | case token.LESS_OR_EQUAL: 104 | return interfaceLessOrEqual(left, right), nil 105 | case token.GREATER_OR_EQUAL: 106 | return interfaceGreaterOrEqual(left, right), nil 107 | 108 | default: 109 | panic(fmt.Sprintf("bad Operator for BinaryExpression: %s", o)) 110 | } 111 | 112 | case ast.UnaryExpression: 113 | // 一元运算符 114 | // -1 115 | // !b 116 | arg, err := runJsExpression(t.Operand, ctx) 117 | if err != nil { 118 | return nil, err 119 | } 120 | switch t.Operator { 121 | case token.NOT: 122 | return !interfaceToBool(arg), nil 123 | case token.MINUS: 124 | // -1 125 | return -interfaceToFloat(arg), nil 126 | default: 127 | panic(fmt.Sprintf("not handle UnaryExpression: %s", t.Operator)) 128 | } 129 | case ast.ObjectLiteral: 130 | if len(t.Value) == 0 { 131 | return nil, nil 132 | } 133 | 134 | // 对象, 翻译成map[string]interface{} 135 | mp := make(map[string]interface{}, len(t.Value)) 136 | for _, v := range t.Value { 137 | k := "" 138 | 139 | switch v.Kind { 140 | case "value": 141 | k = v.Key 142 | default: 143 | panic(fmt.Sprintf("bad Value kind of ObjectLiteral: %v", v.Kind)) 144 | } 145 | 146 | val, err := runJsExpression(v.Value, ctx) 147 | if err != nil { 148 | return nil, err 149 | } 150 | mp[k] = val 151 | } 152 | return mp, nil 153 | case ast.CallExpression: 154 | // fun(1,2,3, ...) 155 | funcName, err := runJsExpression(t.Callee, ctx) 156 | if err != nil { 157 | return nil, err 158 | } 159 | 160 | args := make([]interface{}, len(t.ArgumentList)) 161 | for i, v := range t.ArgumentList { 162 | args[i], err = runJsExpression(v, ctx) 163 | if err != nil { 164 | return nil, err 165 | } 166 | } 167 | return interfaceToFunc(funcName)(ctx, args...), nil 168 | case ast.ArrayLiteral: 169 | args := make([]interface{}, len(t.Value)) 170 | for i, v := range t.Value { 171 | args[i], err = runJsExpression(v, ctx) 172 | if err != nil { 173 | return nil, err 174 | } 175 | } 176 | return args, nil 177 | case ast.ConditionalExpression: 178 | // 三元运算 179 | consequent, err := runJsExpression(t.Consequent, ctx) 180 | if err != nil { 181 | return nil, err 182 | } 183 | alternate, err := runJsExpression(t.Alternate, ctx) 184 | if err != nil { 185 | return nil, err 186 | } 187 | test, err := runJsExpression(t.Test, ctx) 188 | if err != nil { 189 | return nil, err 190 | } 191 | 192 | if interfaceToBool(test) { 193 | return consequent, err 194 | } else { 195 | return alternate, err 196 | } 197 | 198 | default: 199 | panic(fmt.Sprintf("bad type %T for runJsExpression", t)) 200 | //bs, _ := json.Marshal(t) 201 | //log.Panicf("%s", bs) 202 | } 203 | return 204 | } 205 | 206 | func isNumber(s interface{}) (d float64, is bool) { 207 | if s == nil { 208 | return 0, false 209 | } 210 | switch a := s.(type) { 211 | case int: 212 | return float64(a), true 213 | case int32: 214 | return float64(a), true 215 | case int64: 216 | return float64(a), true 217 | case float64: 218 | return a, true 219 | case float32: 220 | return float64(a), true 221 | default: 222 | return 0, false 223 | } 224 | } 225 | 226 | // 用来模拟js两个变量相加 227 | // 如果两个变量都是number, 则相加后也是number 228 | // 只有有一个不是number, 则都按字符串处理相加 229 | func interfaceAdd(a, b interface{}) interface{} { 230 | an, ok := isNumber(a) 231 | if !ok { 232 | return interfaceToStr(a) + interfaceToStr(b) 233 | } 234 | bn, ok := isNumber(b) 235 | if !ok { 236 | return interfaceToStr(a) + interfaceToStr(b) 237 | } 238 | 239 | return an + bn 240 | } 241 | 242 | func interfaceToStr(s interface{}) (d string) { 243 | switch a := s.(type) { 244 | case string: 245 | d = a 246 | case int: 247 | d = strconv.FormatInt(int64(a), 10) 248 | case int32: 249 | d = strconv.FormatInt(int64(a), 10) 250 | case int64: 251 | d = strconv.FormatInt(a, 10) 252 | case float64: 253 | d = strconv.FormatFloat(a, 'f', -1, 64) 254 | default: 255 | bs, _ := json.Marshal(a) 256 | d = string(bs) 257 | } 258 | 259 | return 260 | } 261 | 262 | // 字符串false,0 会被认定为false 263 | func interfaceToBool(s interface{}) (d bool) { 264 | if s == nil { 265 | return false 266 | } 267 | switch a := s.(type) { 268 | case bool: 269 | return a 270 | case int: 271 | return a != 0 272 | case int8: 273 | return a != 0 274 | case int16: 275 | return a != 0 276 | case int32: 277 | return a != 0 278 | case int64: 279 | return a != 0 280 | case float64: 281 | return a != 0 282 | case float32: 283 | return a != 0 284 | case string: 285 | return a != "" && a != "false" && a != "0" 286 | default: 287 | return true 288 | } 289 | } 290 | 291 | func interfaceToFloat(s interface{}) (d float64) { 292 | if s == nil { 293 | return 0 294 | } 295 | switch a := s.(type) { 296 | case int: 297 | return float64(a) 298 | case int8: 299 | return float64(a) 300 | case int16: 301 | return float64(a) 302 | case int32: 303 | return float64(a) 304 | case int64: 305 | return float64(a) 306 | case float32: 307 | return float64(a) 308 | case float64: 309 | return a 310 | default: 311 | return 0 312 | } 313 | } 314 | 315 | func interfaceLess(a, b interface{}) interface{} { 316 | an, ok := isNumber(a) 317 | if !ok { 318 | return interfaceToStr(a) < interfaceToStr(b) 319 | } 320 | bn, ok := isNumber(b) 321 | if !ok { 322 | return interfaceToStr(a) < interfaceToStr(b) 323 | } 324 | 325 | return an < bn 326 | } 327 | 328 | func interfaceLessOrEqual(a, b interface{}) interface{} { 329 | an, ok := isNumber(a) 330 | if !ok { 331 | return interfaceToStr(a) <= interfaceToStr(b) 332 | } 333 | bn, ok := isNumber(b) 334 | if !ok { 335 | return interfaceToStr(a) <= interfaceToStr(b) 336 | } 337 | 338 | return an <= bn 339 | } 340 | 341 | func interfaceGreater(a, b interface{}) interface{} { 342 | an, ok := isNumber(a) 343 | if !ok { 344 | return interfaceToStr(a) > interfaceToStr(b) 345 | } 346 | bn, ok := isNumber(b) 347 | if !ok { 348 | return interfaceToStr(a) > interfaceToStr(b) 349 | } 350 | 351 | return an > bn 352 | } 353 | 354 | func interfaceGreaterOrEqual(a, b interface{}) interface{} { 355 | an, ok := isNumber(a) 356 | if !ok { 357 | return interfaceToStr(a) >= interfaceToStr(b) 358 | } 359 | bn, ok := isNumber(b) 360 | if !ok { 361 | return interfaceToStr(a) >= interfaceToStr(b) 362 | } 363 | 364 | return an >= bn 365 | } 366 | 367 | // 用于{{func(a)}}语法 368 | func interfaceToFunc(s interface{}) (d Function) { 369 | if s == nil { 370 | return emptyFunc 371 | } 372 | 373 | switch a := s.(type) { 374 | case func(RenderCtx, ...interface{}) interface{}: 375 | return a 376 | case Function: 377 | return a 378 | default: 379 | panic(fmt.Sprintf("bad Type of func: %T", a)) 380 | return emptyFunc 381 | } 382 | } 383 | 384 | type Function func(ctx RenderCtx, args ...interface{}) interface{} 385 | 386 | func emptyFunc(ctx RenderCtx, args ...interface{}) interface{} { 387 | if len(args) != 0 { 388 | return args[0] 389 | } 390 | return nil 391 | } 392 | 393 | // shouldLookInterface会返回interface(map[string]interface{})中指定的keys路径的值 394 | func ShouldLookInterface(data interface{}, keys ...string) (desc interface{}, rootExist bool, exist bool) { 395 | if len(keys) == 0 { 396 | return data, true, true 397 | } 398 | 399 | currKey := keys[0] 400 | 401 | switch data := data.(type) { 402 | case interface{ Get(string) interface{} }: 403 | c := data.Get(currKey) 404 | if c == nil { 405 | return 406 | } 407 | rootExist = true 408 | desc, _, exist = ShouldLookInterface(c, keys[1:]...) 409 | return 410 | case map[string]interface{}: 411 | // 对象 412 | c, ok := data[currKey] 413 | if !ok { 414 | return 415 | } 416 | rootExist = true 417 | desc, _, exist = ShouldLookInterface(c, keys[1:]...) 418 | return 419 | case skipMarshalMap: 420 | // 解决循环引用的map 421 | c, ok := data[currKey] 422 | if !ok { 423 | return 424 | } 425 | rootExist = true 426 | desc, _, exist = ShouldLookInterface(c, keys[1:]...) 427 | return 428 | 429 | case []interface{}: 430 | // 数组 431 | switch currKey { 432 | case "length": 433 | // length 434 | return len(data), true, true 435 | default: 436 | // index 437 | index, ok := strconv.ParseInt(currKey, 10, 64) 438 | if ok != nil { 439 | return 440 | } 441 | 442 | if int(index) >= len(data) || index < 0 { 443 | return 444 | } 445 | return ShouldLookInterface(data[index], keys[1:]...) 446 | } 447 | case string: 448 | switch currKey { 449 | case "length": 450 | // length 451 | return len(data), true, true 452 | default: 453 | } 454 | } 455 | 456 | return 457 | } 458 | -------------------------------------------------------------------------------- /internal/lib/parse/html/lex_test.go: -------------------------------------------------------------------------------- 1 | package html 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "testing" 7 | 8 | "github.com/tdewolff/parse/v2" 9 | "github.com/tdewolff/test" 10 | ) 11 | 12 | type TTs []TokenType 13 | 14 | func TestTokens(t testing.T) { 15 | var tokenTests = []struct { 16 | html string 17 | expected []TokenType 18 | }{ 19 | {"", TTs{StartTagToken, StartTagCloseToken, EndTagToken}}, 20 | {"", TTs{StartTagToken, StartTagVoidToken}}, 21 | {"", TTs{CommentToken}}, 22 | {"", TTs{CommentToken}}, 23 | {"
text
", TTs{StartTagToken, StartTagCloseToken, TextToken, EndTagToken}}, 24 | {"", TTs{StartTagToken, AttributeToken, StartTagVoidToken}}, 25 | {"", TTs{StartTagToken, AttributeToken, AttributeToken, StartTagVoidToken}}, 26 | {"", TTs{StartTagToken, AttributeToken, AttributeToken, AttributeToken, AttributeToken, StartTagVoidToken}}, 27 | {"", TTs{DoctypeToken}}, 28 | {"", TTs{DoctypeToken}}, 29 | {"", TTs{CommentToken}}, 30 | {"", TTs{CommentToken}}, 31 | {"", TTs{CommentToken}}, 32 | {"< ", TTs{TextToken}}, 33 | {"
", TTs{StartTagToken, StartTagCloseToken, TextToken, EndTagToken}}, 37 | {"<p></p>", TTs{StartTagToken, StartTagCloseToken, TextToken, EndTagToken}}, 38 | {"</plaintext>", TTs{StartTagToken, StartTagCloseToken, TextToken}}, 39 | {"<script></script>", TTs{StartTagToken, StartTagCloseToken, EndTagToken}}, 40 | {"<script>var x='</script>';</script>", TTs{StartTagToken, StartTagCloseToken, TextToken, EndTagToken, TextToken, EndTagToken}}, 41 | {"<script></script>", TTs{StartTagToken, StartTagCloseToken, TextToken, EndTagToken, TextToken, EndTagToken}}, 42 | {"<script></script>", TTs{StartTagToken, StartTagCloseToken, TextToken, EndTagToken}}, 43 | {"<script></script>", TTs{StartTagToken, StartTagCloseToken, TextToken, EndTagToken}}, 44 | {"<![CDATA[ test ]]>", TTs{TextToken}}, 45 | {"<svg>text</svg>", TTs{SvgToken}}, 46 | {"<math>text</math gibberish>", TTs{MathToken}}, 47 | {`<svg>text<x a="</svg>"></x></svg>`, TTs{SvgToken}}, 48 | {"<a><svg>text</svg></a>", TTs{StartTagToken, StartTagCloseToken, SvgToken, EndTagToken}}, 49 | 50 | // early endings 51 | {"", TTs{StartTagToken, StartTagCloseToken, TextToken}}, 64 | 65 | // NULL 66 | {"foo\x00bar", TTs{TextToken}}, 67 | {"<\x00foo>", TTs{TextToken}}, 68 | {"<foo\x00>", TTs{StartTagToken, StartTagCloseToken}}, 69 | {"</\x00bogus>", TTs{CommentToken}}, 70 | {"</foo\x00>", TTs{EndTagToken}}, 71 | {"<plaintext>\x00</plaintext>", TTs{StartTagToken, StartTagCloseToken, TextToken}}, 72 | {"<script>\x00</script>", TTs{StartTagToken, StartTagCloseToken, TextToken, EndTagToken}}, 73 | {"", TTs{CommentToken}}, 74 | {"<![CDATA[\x00]]>", TTs{TextToken}}, 75 | {"<!doctype\x00>", TTs{DoctypeToken}}, 76 | {"<?bogus\x00>", TTs{CommentToken}}, 77 | {"<?bogus\x00>", TTs{CommentToken}}, 78 | 79 | // go-fuzz 80 | {"</>", TTs{TextToken}}, 81 | } 82 | for _, tt := range tokenTests { 83 | t.Run(tt.html, func(t testing.T) { 84 | l := NewLexer(parse.NewInputString(tt.html)) 85 | i := 0 86 | tokens := []TokenType{} 87 | for { 88 | token, _ := l.Next() 89 | if token == ErrorToken { 90 | test.T(t, l.Err(), io.EOF) 91 | break 92 | } 93 | tokens = append(tokens, token) 94 | i++ 95 | } 96 | test.T(t, tokens, tt.expected, "token types must match") 97 | }) 98 | } 99 | 100 | // coverage 101 | for i := 0; ; i++ { 102 | if TokenType(i).String() == fmt.Sprintf("Invalid(%d)", i) { 103 | break 104 | } 105 | } 106 | } 107 | 108 | func TestTags(t testing.T) { 109 | var tagTests = []struct { 110 | html string 111 | expected string 112 | }{ 113 | {"<foo:bar.qux-norf/>", "foo:bar.qux-norf"}, 114 | {"<foo?bar/qux>", "foo?bar/qux"}, 115 | {"<!DOCTYPE note SYSTEM \"Note.dtd\">", " note SYSTEM \"Note.dtd\""}, 116 | {"</foo >", "foo"}, 117 | 118 | // early endings 119 | {"<foo ", "foo"}, 120 | } 121 | for _, tt := range tagTests { 122 | t.Run(tt.html, func(t testing.T) { 123 | l := NewLexer(parse.NewInputString(tt.html)) 124 | for { 125 | token, _ := l.Next() 126 | if token == ErrorToken { 127 | test.T(t, l.Err(), io.EOF) 128 | test.Fail(t, "when error occurred we must be at the end") 129 | break 130 | } else if token == StartTagToken || token == EndTagToken || token == DoctypeToken { 131 | test.String(t, string(l.Text()), tt.expected) 132 | break 133 | } 134 | } 135 | }) 136 | } 137 | } 138 | 139 | func TestAttributes(t testing.T) { 140 | var attributeTests = []struct { 141 | attr string 142 | expected []string 143 | }{ 144 | {"<foo a=\"b\" />", []string{"a", "\"b\""}}, 145 | {"<foo \nchecked \r\n value\r=\t'=/>\"' />", []string{"checked", "", "value", "'=/>\"'"}}, 146 | {"<foo bar=\" a \n\t\r b \" />", []string{"bar", "\" a \n\t\r b \""}}, 147 | {"<foo a/>", []string{"a", ""}}, 148 | {"<foo /=/>", []string{"/", "/"}}, 149 | 150 | // early endings 151 | {"<foo x", []string{"x", ""}}, 152 | {"<foo x=", []string{"x", ""}}, 153 | {"<foo x='", []string{"x", "'"}}, 154 | 155 | // NULL 156 | {"<foo \x00>", []string{"\x00", ""}}, 157 | {"<foo \x00=\x00>", []string{"\x00", "\x00"}}, 158 | {"<foo \x00='\x00'>", []string{"\x00", "'\x00'"}}, 159 | } 160 | for _, tt := range attributeTests { 161 | t.Run(tt.attr, func(t testing.T) { 162 | l := NewLexer(parse.NewInputString(tt.attr)) 163 | i := 0 164 | for { 165 | token, _ := l.Next() 166 | if token == ErrorToken { 167 | test.T(t, l.Err(), io.EOF) 168 | test.T(t, i, len(tt.expected), "when error occurred we must be at the end") 169 | break 170 | } else if token == AttributeToken { 171 | test.That(t, i+1 < len(tt.expected), "index", i+1, "must not exceed expected attributes size", len(tt.expected)) 172 | if i+1 < len(tt.expected) { 173 | test.String(t, string(l.Text()), tt.expected[i], "attribute keys must match") 174 | test.String(t, string(l.AttrVal()), tt.expected[i+1], "attribute keys must match") 175 | i += 2 176 | } 177 | } 178 | } 179 | }) 180 | } 181 | } 182 | 183 | func TestErrors(t testing.T) { 184 | var errorTests = []struct { 185 | html string 186 | col int 187 | }{ 188 | {"<svg>\x00</svg>", 6}, 189 | {"<svg></svg\x00>", 11}, 190 | } 191 | for _, tt := range errorTests { 192 | t.Run(tt.html, func(t testing.T) { 193 | l := NewLexer(parse.NewInputString(tt.html)) 194 | for { 195 | token, _ := l.Next() 196 | if token == ErrorToken { 197 | if tt.col == 0 { 198 | test.T(t, l.Err(), io.EOF) 199 | } else if perr, ok := l.Err().(parse.Error); ok { 200 | _, col, _ := perr.Position() 201 | test.T(t, col, tt.col) 202 | } else { 203 | test.Fail(t, "bad error:", l.Err()) 204 | } 205 | break 206 | } 207 | } 208 | }) 209 | } 210 | } 211 | 212 | func TestTextAndAttrVal(t testing.T) { 213 | l := NewLexer(parse.NewInputString(`<div attr="val" >text<!DOCTYPE doctype><![CDATA[cdata]]><script>js</script><svg>image</svg>`)) 214 | _, data := l.Next() 215 | test.Bytes(t, data, []byte("<div")) 216 | test.Bytes(t, l.Text(), []byte("div")) 217 | test.Bytes(t, l.AttrVal(), nil) 218 | 219 | _, data = l.Next() 220 | test.Bytes(t, data, []byte(` attr="val"`)) 221 | test.Bytes(t, l.Text(), []byte("attr")) 222 | test.Bytes(t, l.AttrVal(), []byte(`"val"`)) 223 | 224 | _, data = l.Next() 225 | test.Bytes(t, data, []byte(">")) 226 | test.Bytes(t, l.Text(), nil) 227 | test.Bytes(t, l.AttrVal(), nil) 228 | 229 | _, data = l.Next() 230 | test.Bytes(t, data, []byte("text")) 231 | test.Bytes(t, l.Text(), []byte("text")) 232 | test.Bytes(t, l.AttrVal(), nil) 233 | 234 | _, data = l.Next() 235 | test.Bytes(t, data, []byte("")) 236 | test.Bytes(t, l.Text(), []byte("comment")) 237 | test.Bytes(t, l.AttrVal(), nil) 238 | 239 | _, data = l.Next() 240 | test.Bytes(t, data, []byte("<!DOCTYPE doctype>")) 241 | test.Bytes(t, l.Text(), []byte(" doctype")) 242 | test.Bytes(t, l.AttrVal(), nil) 243 | 244 | _, data = l.Next() 245 | test.Bytes(t, data, []byte("<![CDATA[cdata]]>")) 246 | test.Bytes(t, l.Text(), []byte("cdata")) 247 | test.Bytes(t, l.AttrVal(), nil) 248 | 249 | _, data = l.Next() 250 | test.Bytes(t, data, []byte("<script")) 251 | test.Bytes(t, l.Text(), []byte("script")) 252 | test.Bytes(t, l.AttrVal(), nil) 253 | 254 | _, data = l.Next() 255 | test.Bytes(t, data, []byte(">")) 256 | test.Bytes(t, l.Text(), nil) 257 | test.Bytes(t, l.AttrVal(), nil) 258 | 259 | _, data = l.Next() 260 | test.Bytes(t, data, []byte("js")) 261 | test.Bytes(t, l.Text(), nil) 262 | test.Bytes(t, l.AttrVal(), nil) 263 | 264 | _, data = l.Next() 265 | test.Bytes(t, data, []byte("</script>")) 266 | test.Bytes(t, l.Text(), []byte("script")) 267 | test.Bytes(t, l.AttrVal(), nil) 268 | 269 | _, data = l.Next() 270 | test.Bytes(t, data, []byte("<svg>image</svg>")) 271 | test.Bytes(t, l.Text(), []byte("svg")) 272 | test.Bytes(t, l.AttrVal(), nil) 273 | } 274 | 275 | func TestOffset(t testing.T) { 276 | z := parse.NewInputString(`<div attr="val">text</div>`) 277 | l := NewLexer(z) 278 | test.T(t, z.Offset(), 0) 279 | _, _ = l.Next() 280 | test.T(t, z.Offset(), 4) // <div 281 | _, _ = l.Next() 282 | test.T(t, z.Offset(), 15) // attr="val" 283 | _, _ = l.Next() 284 | test.T(t, z.Offset(), 16) // > 285 | _, _ = l.Next() 286 | test.T(t, z.Offset(), 20) // text 287 | _, _ = l.Next() 288 | test.T(t, z.Offset(), 26) // </div> 289 | } 290 | 291 | //////////////////////////////////////////////////////////////// 292 | 293 | var J int 294 | var ss = [][]byte{ 295 | []byte(" style"), 296 | []byte("style"), 297 | []byte(" \r\n\tstyle"), 298 | []byte(" style"), 299 | []byte(" x"), 300 | []byte("x"), 301 | } 302 | 303 | func BenchmarkWhitespace1(b testing.B) { 304 | for i := 0; i < b.N; i++ { 305 | for _, s := range ss { 306 | j := 0 307 | for { 308 | if c := s[j]; c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f' { 309 | j++ 310 | } else { 311 | break 312 | } 313 | } 314 | J += j 315 | } 316 | } 317 | } 318 | 319 | func BenchmarkWhitespace2(b testing.B) { 320 | for i := 0; i < b.N; i++ { 321 | for _, s := range ss { 322 | j := 0 323 | for { 324 | if c := s[j]; c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f' { 325 | j++ 326 | continue 327 | } 328 | break 329 | } 330 | J += j 331 | } 332 | } 333 | } 334 | 335 | func BenchmarkWhitespace3(b testing.B) { 336 | for i := 0; i < b.N; i++ { 337 | for _, s := range ss { 338 | j := 0 339 | for { 340 | if c := s[j]; c != ' ' && c != '\t' && c != '\n' && c != '\r' && c != '\f' { 341 | break 342 | } 343 | j++ 344 | } 345 | J += j 346 | } 347 | } 348 | } 349 | 350 | //////////////////////////////////////////////////////////////// 351 | 352 | func ExampleNewLexer() { 353 | l := NewLexer(parse.NewInputString("<span class='user'>John Doe</span>")) 354 | out := "" 355 | for { 356 | tt, data := l.Next() 357 | if tt == ErrorToken { 358 | break 359 | } 360 | out += string(data) 361 | } 362 | fmt.Println(out) 363 | // Output: <span class='user'>John Doe</span> 364 | } 365 | -------------------------------------------------------------------------------- /internal/lib/parse/html/lex.go: -------------------------------------------------------------------------------- 1 | // Package html is an HTML5 lexer following the specifications at http://www.w3.org/TR/html5/syntax.html. 2 | package html 3 | 4 | import ( 5 | "strconv" 6 | 7 | "github.com/tdewolff/parse/v2" 8 | ) 9 | 10 | // TokenType determines the type of token, eg. a number or a semicolon. 11 | type TokenType uint32 12 | 13 | // TokenType values. 14 | const ( 15 | ErrorToken TokenType = iota // extra token when errors occur 16 | CommentToken 17 | DoctypeToken 18 | StartTagToken 19 | StartTagCloseToken 20 | StartTagVoidToken 21 | EndTagToken 22 | AttributeToken 23 | TextToken 24 | SvgToken 25 | MathToken 26 | ) 27 | 28 | // String returns the string representation of a TokenType. 29 | func (tt TokenType) String() string { 30 | switch tt { 31 | case ErrorToken: 32 | return "Error" 33 | case CommentToken: 34 | return "Comment" 35 | case DoctypeToken: 36 | return "Doctype" 37 | case StartTagToken: 38 | return "StartTag" 39 | case StartTagCloseToken: 40 | return "StartTagClose" 41 | case StartTagVoidToken: 42 | return "StartTagVoid" 43 | case EndTagToken: 44 | return "EndTag" 45 | case AttributeToken: 46 | return "Attribute" 47 | case TextToken: 48 | return "Text" 49 | case SvgToken: 50 | return "Svg" 51 | case MathToken: 52 | return "Math" 53 | } 54 | return "Invalid(" + strconv.Itoa(int(tt)) + ")" 55 | } 56 | 57 | //////////////////////////////////////////////////////////////// 58 | 59 | // Lexer is the state for the lexer. 60 | type Lexer struct { 61 | r parse.Input 62 | err error 63 | 64 | rawTag Hash 65 | inTag bool 66 | 67 | text []byte 68 | attrVal []byte 69 | } 70 | 71 | // NewLexer returns a new Lexer for a given io.Reader. 72 | func NewLexer(r parse.Input) Lexer { 73 | return &Lexer{ 74 | r: r, 75 | } 76 | } 77 | 78 | // Err returns the error encountered during lexing, this is often io.EOF but also other errors can be returned. 79 | func (l Lexer) Err() error { 80 | if l.err != nil { 81 | return l.err 82 | } 83 | return l.r.Err() 84 | } 85 | 86 | // Text returns the textual representation of a token. This excludes delimiters and additional leading/trailing characters. 87 | func (l Lexer) Text() []byte { 88 | return l.text 89 | } 90 | 91 | // AttrVal returns the attribute value when an AttributeToken was returned from Next. 92 | func (l Lexer) AttrVal() []byte { 93 | return l.attrVal 94 | } 95 | 96 | // Next returns the next Token. It returns ErrorToken when an error was encountered. Using Err() one can retrieve the error message. 97 | func (l Lexer) Next() (TokenType, []byte) { 98 | l.text = nil 99 | var c byte 100 | if l.inTag { 101 | l.attrVal = nil 102 | for { // before attribute name state 103 | if c = l.r.Peek(0); c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f' { 104 | l.r.Move(1) 105 | continue 106 | } 107 | break 108 | } 109 | if c == 0 && l.r.Err() != nil { 110 | return ErrorToken, nil 111 | } else if c != '>' && (c != '/' || l.r.Peek(1) != '>') { 112 | return AttributeToken, l.shiftAttribute() 113 | } 114 | l.r.Skip() 115 | l.inTag = false 116 | if c == '/' { 117 | l.r.Move(2) 118 | return StartTagVoidToken, l.r.Shift() 119 | } 120 | l.r.Move(1) 121 | return StartTagCloseToken, l.r.Shift() 122 | } 123 | 124 | if l.rawTag != 0 { 125 | if rawText := l.shiftRawText(); len(rawText) > 0 { 126 | l.rawTag = 0 127 | return TextToken, rawText 128 | } 129 | l.rawTag = 0 130 | } 131 | 132 | for { 133 | c = l.r.Peek(0) 134 | if c == '<' { 135 | c = l.r.Peek(1) 136 | isEndTag := c == '/' && l.r.Peek(2) != '>' && (l.r.Peek(2) != 0 || l.r.PeekErr(2) == nil) 137 | if l.r.Pos() > 0 { 138 | if isEndTag || 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z' || c == '!' || c == '?' { 139 | // return currently buffered texttoken so that we can return tag next iteration 140 | l.text = l.r.Shift() 141 | return TextToken, l.text 142 | } 143 | } else if isEndTag { 144 | l.r.Move(2) 145 | // only endtags that are not followed by > or EOF arrive here 146 | if c = l.r.Peek(0); !('a' <= c && c <= 'z' || 'A' <= c && c <= 'Z') { 147 | return CommentToken, l.shiftBogusComment() 148 | } 149 | return EndTagToken, l.shiftEndTag() 150 | } else if 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z' { 151 | l.r.Move(1) 152 | l.inTag = true 153 | return l.shiftStartTag() 154 | } else if c == '!' { 155 | l.r.Move(2) 156 | return l.readMarkup() 157 | } else if c == '?' { 158 | l.r.Move(1) 159 | return CommentToken, l.shiftBogusComment() 160 | } 161 | } else if c == 0 && l.r.Err() != nil { 162 | if l.r.Pos() > 0 { 163 | l.text = l.r.Shift() 164 | return TextToken, l.text 165 | } 166 | return ErrorToken, nil 167 | } 168 | l.r.Move(1) 169 | } 170 | } 171 | 172 | //////////////////////////////////////////////////////////////// 173 | 174 | // The following functions follow the specifications at https://html.spec.whatwg.org/multipage/parsing.html 175 | 176 | func (l Lexer) shiftRawText() []byte { 177 | if l.rawTag == Plaintext { 178 | for { 179 | if l.r.Peek(0) == 0 && l.r.Err() != nil { 180 | return l.r.Shift() 181 | } 182 | l.r.Move(1) 183 | } 184 | } else { // RCDATA, RAWTEXT and SCRIPT 185 | for { 186 | c := l.r.Peek(0) 187 | if c == '<' { 188 | if l.r.Peek(1) == '/' { 189 | mark := l.r.Pos() 190 | l.r.Move(2) 191 | for { 192 | if c = l.r.Peek(0); !('a' <= c && c <= 'z' || 'A' <= c && c <= 'Z') { 193 | break 194 | } 195 | l.r.Move(1) 196 | } 197 | if h := ToHash(parse.Copy(l.r.Lexeme()[mark+2:])); h == l.rawTag { // copy so that doesn't change the case of the underlying slice 198 | l.r.Rewind(mark) 199 | return l.r.Shift() 200 | } 201 | } else if l.rawTag == Script && l.r.Peek(1) == '!' && l.r.Peek(2) == '-' && l.r.Peek(3) == '-' { 202 | l.r.Move(4) 203 | inScript := false 204 | for { 205 | c := l.r.Peek(0) 206 | if c == '-' && l.r.Peek(1) == '-' && l.r.Peek(2) == '>' { 207 | l.r.Move(3) 208 | break 209 | } else if c == '<' { 210 | isEnd := l.r.Peek(1) == '/' 211 | if isEnd { 212 | l.r.Move(2) 213 | } else { 214 | l.r.Move(1) 215 | } 216 | mark := l.r.Pos() 217 | for { 218 | if c = l.r.Peek(0); !('a' <= c && c <= 'z' || 'A' <= c && c <= 'Z') { 219 | break 220 | } 221 | l.r.Move(1) 222 | } 223 | if h := ToHash(parse.Copy(l.r.Lexeme()[mark:])); h == Script { // copy so that doesn't change the case of the underlying slice 224 | if !isEnd { 225 | inScript = true 226 | } else { 227 | if !inScript { 228 | l.r.Rewind(mark - 2) 229 | return l.r.Shift() 230 | } 231 | inScript = false 232 | } 233 | } 234 | } else if c == 0 && l.r.Err() != nil { 235 | return l.r.Shift() 236 | } else { 237 | l.r.Move(1) 238 | } 239 | } 240 | } else { 241 | l.r.Move(1) 242 | } 243 | } else if c == 0 && l.r.Err() != nil { 244 | return l.r.Shift() 245 | } else { 246 | l.r.Move(1) 247 | } 248 | } 249 | } 250 | } 251 | 252 | func (l Lexer) readMarkup() (TokenType, []byte) { 253 | if l.at('-', '-') { 254 | l.r.Move(2) 255 | for { 256 | if l.r.Peek(0) == 0 && l.r.Err() != nil { 257 | l.text = l.r.Lexeme()[4:] 258 | return CommentToken, l.r.Shift() 259 | } else if l.at('-', '-', '>') { 260 | l.text = l.r.Lexeme()[4:] 261 | l.r.Move(3) 262 | return CommentToken, l.r.Shift() 263 | } else if l.at('-', '-', '!', '>') { 264 | l.text = l.r.Lexeme()[4:] 265 | l.r.Move(4) 266 | return CommentToken, l.r.Shift() 267 | } 268 | l.r.Move(1) 269 | } 270 | } else if l.at('[', 'C', 'D', 'A', 'T', 'A', '[') { 271 | l.r.Move(7) 272 | for { 273 | if l.r.Peek(0) == 0 && l.r.Err() != nil { 274 | l.text = l.r.Lexeme()[9:] 275 | return TextToken, l.r.Shift() 276 | } else if l.at(']', ']', '>') { 277 | l.text = l.r.Lexeme()[9:] 278 | l.r.Move(3) 279 | return TextToken, l.r.Shift() 280 | } 281 | l.r.Move(1) 282 | } 283 | } else { 284 | if l.atCaseInsensitive('d', 'o', 'c', 't', 'y', 'p', 'e') { 285 | l.r.Move(7) 286 | if l.r.Peek(0) == ' ' { 287 | l.r.Move(1) 288 | } 289 | for { 290 | if c := l.r.Peek(0); c == '>' || c == 0 && l.r.Err() != nil { 291 | l.text = l.r.Lexeme()[9:] 292 | if c == '>' { 293 | l.r.Move(1) 294 | } 295 | return DoctypeToken, l.r.Shift() 296 | } 297 | l.r.Move(1) 298 | } 299 | } 300 | } 301 | return CommentToken, l.shiftBogusComment() 302 | } 303 | 304 | func (l Lexer) shiftBogusComment() []byte { 305 | for { 306 | c := l.r.Peek(0) 307 | if c == '>' { 308 | l.text = l.r.Lexeme()[2:] 309 | l.r.Move(1) 310 | return l.r.Shift() 311 | } else if c == 0 && l.r.Err() != nil { 312 | l.text = l.r.Lexeme()[2:] 313 | return l.r.Shift() 314 | } 315 | l.r.Move(1) 316 | } 317 | } 318 | 319 | func (l Lexer) shiftStartTag() (TokenType, []byte) { 320 | for { 321 | if c := l.r.Peek(0); c == ' ' || c == '>' || c == '/' && l.r.Peek(1) == '>' || c == '\t' || c == '\n' || c == '\r' || c == '\f' || c == 0 && l.r.Err() != nil { 322 | break 323 | } 324 | l.r.Move(1) 325 | } 326 | l.text = l.r.Lexeme()[1:] 327 | if h := ToHash(l.text); h == Textarea || h == Title || h == Style || h == Xmp || h == Iframe || h == Script || h == Plaintext || h == Svg || h == Math { 328 | if h == Svg || h == Math { 329 | data := l.shiftXml(h) 330 | if l.err != nil { 331 | return ErrorToken, nil 332 | } 333 | 334 | l.inTag = false 335 | if h == Svg { 336 | return SvgToken, data 337 | } 338 | return MathToken, data 339 | } 340 | l.rawTag = h 341 | } 342 | return StartTagToken, l.r.Shift() 343 | } 344 | 345 | func (l Lexer) shiftAttribute() []byte { 346 | nameStart := l.r.Pos() 347 | var c byte 348 | for { // attribute name state 349 | if c = l.r.Peek(0); c == ' ' || c == '=' || c == '>' || c == '/' && l.r.Peek(1) == '>' || c == '\t' || c == '\n' || c == '\r' || c == '\f' || c == 0 && l.r.Err() != nil { 350 | break 351 | } 352 | l.r.Move(1) 353 | } 354 | nameEnd := l.r.Pos() 355 | for { // after attribute name state 356 | if c = l.r.Peek(0); c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f' { 357 | l.r.Move(1) 358 | continue 359 | } 360 | break 361 | } 362 | if c == '=' { 363 | l.r.Move(1) 364 | for { // before attribute value state 365 | if c = l.r.Peek(0); c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f' { 366 | l.r.Move(1) 367 | continue 368 | } 369 | break 370 | } 371 | attrPos := l.r.Pos() 372 | delim := c 373 | if delim == '"' || delim == '\'' { // attribute value single- and double-quoted state 374 | l.r.Move(1) 375 | for { 376 | c := l.r.Peek(0) 377 | if c == delim { 378 | l.r.Move(1) 379 | break 380 | } else if c == 0 && l.r.Err() != nil { 381 | break 382 | } 383 | l.r.Move(1) 384 | } 385 | } else { // attribute value unquoted state 386 | for { 387 | if c := l.r.Peek(0); c == ' ' || c == '>' || c == '\t' || c == '\n' || c == '\r' || c == '\f' || c == 0 && l.r.Err() != nil { 388 | break 389 | } 390 | l.r.Move(1) 391 | } 392 | } 393 | l.attrVal = l.r.Lexeme()[attrPos:] 394 | } else { 395 | l.r.Rewind(nameEnd) 396 | l.attrVal = nil 397 | } 398 | l.text = l.r.Lexeme()[nameStart:nameEnd] 399 | return l.r.Shift() 400 | } 401 | 402 | func (l Lexer) shiftEndTag() []byte { 403 | for { 404 | c := l.r.Peek(0) 405 | if c == '>' { 406 | l.text = l.r.Lexeme()[2:] 407 | l.r.Move(1) 408 | break 409 | } else if c == 0 && l.r.Err() != nil { 410 | l.text = l.r.Lexeme()[2:] 411 | break 412 | } 413 | l.r.Move(1) 414 | } 415 | 416 | end := len(l.text) 417 | for end > 0 { 418 | if c := l.text[end-1]; c == ' ' || c == '\t' || c == '\n' || c == '\r' { 419 | end-- 420 | continue 421 | } 422 | break 423 | } 424 | l.text = l.text[:end] 425 | return l.r.Shift() 426 | } 427 | 428 | // shiftXml parses the content of a svg or math tag according to the XML 1.1 specifications, including the tag itself. 429 | // So far we have already parsed `<svg` or `<math`. 430 | func (l Lexer) shiftXml(rawTag Hash) []byte { 431 | inQuote := false 432 | for { 433 | c := l.r.Peek(0) 434 | if c == '"' { 435 | inQuote = !inQuote 436 | l.r.Move(1) 437 | } else if c == '<' && !inQuote && l.r.Peek(1) == '/' { 438 | mark := l.r.Pos() 439 | l.r.Move(2) 440 | for { 441 | if c = l.r.Peek(0); !('a' <= c && c <= 'z' || 'A' <= c && c <= 'Z') { 442 | break 443 | } 444 | l.r.Move(1) 445 | } 446 | if h := ToHash(parse.Copy(l.r.Lexeme()[mark+2:])); h == rawTag { // copy so that doesn't change the case of the underlying slice 447 | break 448 | } 449 | } else if c == 0 { 450 | if l.r.Err() == nil { 451 | l.err = parse.NewErrorLexer(l.r, "HTML parse error: unexpected NULL character") 452 | } 453 | return l.r.Shift() 454 | } else { 455 | l.r.Move(1) 456 | } 457 | } 458 | 459 | for { 460 | c := l.r.Peek(0) 461 | if c == '>' { 462 | l.r.Move(1) 463 | break 464 | } else if c == 0 { 465 | if l.r.Err() == nil { 466 | l.err = parse.NewErrorLexer(l.r, "HTML parse error: unexpected NULL character") 467 | } 468 | return l.r.Shift() 469 | } 470 | l.r.Move(1) 471 | } 472 | return l.r.Shift() 473 | } 474 | 475 | //////////////////////////////////////////////////////////////// 476 | 477 | func (l Lexer) at(b ...byte) bool { 478 | for i, c := range b { 479 | if l.r.Peek(i) != c { 480 | return false 481 | } 482 | } 483 | return true 484 | } 485 | 486 | func (l Lexer) atCaseInsensitive(b ...byte) bool { 487 | for i, c := range b { 488 | if l.r.Peek(i) != c && (l.r.Peek(i)+('a'-'A')) != c { 489 | return false 490 | } 491 | } 492 | return true 493 | } 494 | -------------------------------------------------------------------------------- /internal/parser/parsevue.go: -------------------------------------------------------------------------------- 1 | package parser 2 | 3 | import ( 4 | "errors" 5 | "fmt" 6 | "github.com/zbysir/vpl/internal/util" 7 | "strings" 8 | ) 9 | 10 | type Prop struct { 11 | IsStatic bool // 是否是静态的(v-bind:语法是动态, 之外是静态) 12 | CanBeAttr bool // 是否当成attr输出 13 | Key string 14 | StaticVal interface{} // 静态的value, 如style和class在编译时就会被解析成map和slice 15 | ValCode string // 如果props是动态的, valCode存储js表达式 16 | } 17 | 18 | type Style struct { 19 | Key, Val string 20 | } 21 | 22 | type Attribute struct { 23 | Key, Val string 24 | } 25 | 26 | type Props []Prop 27 | 28 | type Styles map[string]string 29 | 30 | func (p Styles) ToAttr() string { 31 | sortedKeys := util.GetSortedKey(map[string]string(p)) 32 | var st strings.Builder 33 | for _, k := range sortedKeys { 34 | v := p[k] 35 | if st.Len() != 0 { 36 | st.WriteByte(' ') 37 | } 38 | st.WriteString(k + ": " + v + ";") 39 | } 40 | return st.String() 41 | } 42 | 43 | func (p Styles) Add(key string, val string) { 44 | p[key] = val 45 | return 46 | } 47 | 48 | func (p Styles) Merge(a Styles) { 49 | for k, v := range a { 50 | p[k] = v 51 | } 52 | return 53 | } 54 | 55 | func (p Styles) Del(key string) { 56 | delete(p, key) 57 | } 58 | 59 | type Class []string 60 | 61 | func (c Class) ToAttr() string { 62 | return strings.Join(c, " ") 63 | } 64 | 65 | func (c Class) Remove(i string) { 66 | for index, k := range c { 67 | if k == i { 68 | c = append((c)[:index], (c)[index+1:]...) 69 | break 70 | } 71 | } 72 | } 73 | 74 | func (c Class) Merge(a Class) { 75 | for _, v := range a { 76 | if c.Exist(v) { 77 | continue 78 | } 79 | 80 | c = append(c, v) 81 | } 82 | } 83 | func (c Class) Exist(a string) bool { 84 | for _, v := range c { 85 | if a == v { 86 | return true 87 | } 88 | } 89 | return false 90 | } 91 | 92 | func NewClass() Class { 93 | return make(Class, 0, 4) 94 | } 95 | 96 | type Attributes []Attribute 97 | type Directives []Directive 98 | 99 | func (p Props) Get(key string) (val string, exist bool) { 100 | for _, v := range p { 101 | if v.Key == key { 102 | return v.ValCode, true 103 | } 104 | } 105 | return 106 | } 107 | 108 | // 是否全部是静态Prop 109 | func (p Props) IsStatic() bool { 110 | if len(p) == 0 { 111 | return true 112 | } 113 | 114 | for _, item := range p { 115 | if !item.IsStatic { 116 | return false 117 | } 118 | } 119 | 120 | return true 121 | } 122 | func (p Props) Del(key string) { 123 | for index, k := range p { 124 | if k.Key == key { 125 | p = append((p)[:index], (p)[index+1:]...) 126 | break 127 | } 128 | } 129 | } 130 | 131 | type Directive struct { 132 | Name string // animate 133 | Value string // {'a': 1} 134 | Arg string // v-set:arg 135 | } 136 | 137 | type ElseIf struct { 138 | Types string // else / elseif 139 | Condition string // elseif语句的condition表达式 140 | VueElement VueElement 141 | } 142 | 143 | type VIf struct { 144 | Condition string // 条件表达式 145 | // 当此节点是if节点是, 将与if指令匹配的elseif/else节点关联在一起 146 | ElseIf []ElseIf 147 | } 148 | 149 | func (p VIf) AddElseIf(v ElseIf) { 150 | p.ElseIf = append(p.ElseIf, v) 151 | } 152 | 153 | type VFor struct { 154 | ArrayKey string 155 | ItemKey string 156 | IndexKey string 157 | } 158 | 159 | type VSlot struct { 160 | SlotName string 161 | PropsKey string 162 | } 163 | type VBind struct { 164 | Val string 165 | } 166 | 167 | type VueElement struct { 168 | NodeType NodeType 169 | Tag string 170 | Text string 171 | // 是否分配调用组件时传递来的属性. 172 | // 如果组件中只存在一个root节点, 则此节点会自动分配属性. 否则所有root节点都不会. 173 | // (fragments: https://v3.vuejs.org/guide/migration/fragments.html#overview) 174 | DistributionAttr bool 175 | 176 | //PropClass Prop // 动态Class 177 | //PropStyle Prop // 动态style 178 | Props Props // props, 动态和静态, 包括class和style 179 | VBind VBind 180 | Directives Directives // 自定义指令, 运行时 181 | //Class Class // 静态class 182 | //Style Styles // 静态style 183 | Children []VueElement // 子节点 184 | VIf VIf // 处理v-if需要的数据 185 | VFor VFor 186 | VSlot VSlot 187 | VElse bool // 如果是VElse节点则不会生成代码(而是在vif里生成代码) 188 | VElseIf bool 189 | // v-html / v-text 190 | // 支持v-html / v-text指令覆盖子级内容的组件有: template / html基本标签 191 | // component/slot和自定义组件不支持(没有必要)v-html/v-text覆盖子级 192 | VHtml string 193 | VText string 194 | } 195 | 196 | type ParseVueNodeOptions struct { 197 | CanBeAttr func(k string) bool 198 | SkipComment bool 199 | } 200 | 201 | type VueElementParser struct { 202 | options ParseVueNodeOptions 203 | } 204 | 205 | func (p VueElementParser) Parse(e Node) (VueElement, error) { 206 | vs, err := p.parseList([]Node{e}) 207 | if err != nil { 208 | return nil, err 209 | } 210 | 211 | ve := vs[0] 212 | 213 | // 如果根节点只有要给并且是template，则是vue写法, 需要删除掉template来兼容此语法 214 | if len(ve.Children) == 1 && ve.Children[0].Tag == "template" { 215 | ve.Children = ve.Children[0].Children 216 | } 217 | 218 | // 如果只有一个root节点, 则将自动分配attr 219 | var childLen int64 220 | for _, c := range ve.Children { 221 | if c.NodeType != CommentNode { 222 | childLen++ 223 | } 224 | } 225 | 226 | if childLen == 1 { 227 | for _, c := range ve.Children { 228 | if c.NodeType == ElementNode { 229 | c.DistributionAttr = true 230 | 231 | // 如果if节点需要分发attr，那么else节点也需要 232 | if c.VIf != nil { 233 | for _, e := range c.VIf.ElseIf { 234 | e.VueElement.DistributionAttr = true 235 | } 236 | } 237 | } 238 | 239 | } 240 | } 241 | 242 | return ve, nil 243 | } 244 | 245 | // 递归处理同级节点 246 | // 使用数组有一个好处就是方便的处理串联的v-if 247 | func (p VueElementParser) parseList(es []Node) (ve []VueElement, err error) { 248 | vs := make([]VueElement, 0) 249 | 250 | var ifVueEle VueElement 251 | for _, e := range es { 252 | if p.options.SkipComment { 253 | if e.NodeType == CommentNode { 254 | continue 255 | } 256 | } 257 | 258 | var props Props 259 | //var propClass Prop 260 | //var propStyle Prop 261 | var vBind VBind 262 | var ds Directives 263 | //var class []string 264 | //var styles = Styles{} 265 | 266 | var vIf VIf 267 | var vFor VFor 268 | var vSlot VSlot 269 | var vElse ElseIf 270 | var vElseIf ElseIf 271 | 272 | // v-html与v-text表达式 273 | var vHtml string 274 | var vText string 275 | 276 | for _, attr := range e.Attrs { 277 | oriKey := attr.Key 278 | ss := strings.Split(oriKey, ":") 279 | nameSpace := "-" 280 | key := oriKey 281 | if len(ss) == 2 { 282 | key = ss[1] 283 | nameSpace = ss[0] 284 | } 285 | 286 | if nameSpace == "v-bind" || nameSpace == "" { 287 | // v-bind:abc & :abc 288 | 289 | // 单独处理class和style 290 | if key == "class" { 291 | props = append(props, &Prop{ 292 | IsStatic: false, 293 | CanBeAttr: true, 294 | Key: "class", 295 | ValCode: attr.Value, 296 | }) 297 | } else if key == "style" { 298 | props = append(props, &Prop{ 299 | IsStatic: false, 300 | CanBeAttr: true, 301 | Key: "style", 302 | ValCode: attr.Value, 303 | }) 304 | } else { 305 | // 动态prosp 306 | props = append(props, &Prop{ 307 | IsStatic: false, 308 | CanBeAttr: p.options.CanBeAttr(key), 309 | Key: key, 310 | ValCode: attr.Value, 311 | }) 312 | } 313 | } else if strings.HasPrefix(oriKey, "v-") { 314 | // 指令 315 | // v-bind="" 316 | // v-if="" 317 | // v-slot:name="" 318 | // v-else-if="" 319 | // v-else 320 | // v-html 321 | // v-text 322 | // 自定义 323 | switch { 324 | case key == "v-bind": 325 | vBind = &VBind{ 326 | Val: attr.Value, 327 | } 328 | case key == "v-for": 329 | val := attr.Value 330 | 331 | ss := strings.Split(val, " in ") 332 | arrayKey := strings.Trim(ss[1], " ") 333 | 334 | left := strings.Trim(ss[0], " ") 335 | var itemKey string 336 | var indexKey string 337 | // (item, index) in list 338 | if strings.Contains(left, ",") { 339 | left = strings.Trim(left, "()") 340 | ss := strings.Split(left, ",") 341 | itemKey = strings.Trim(ss[0], " ") 342 | indexKey = strings.Trim(ss[1], " ") 343 | } else { 344 | // (item) or item 345 | left = strings.Trim(left, "()") 346 | itemKey = left 347 | indexKey = "$index" 348 | } 349 | 350 | vFor = &VFor{ 351 | ArrayKey: arrayKey, 352 | ItemKey: itemKey, 353 | IndexKey: indexKey, 354 | } 355 | case key == "v-if": 356 | vIf = &VIf{ 357 | Condition: strings.Trim(attr.Value, " "), 358 | ElseIf: nil, 359 | } 360 | case nameSpace == "v-slot": 361 | slotName := key 362 | propsKey := attr.Value 363 | // 不应该为空, 否则可能会导致生成的go代码有误 364 | vSlot = &VSlot{ 365 | SlotName: slotName, 366 | PropsKey: propsKey, 367 | } 368 | case key == "v-else-if": 369 | vElseIf = &ElseIf{ 370 | Types: "elseif", 371 | Condition: strings.Trim(attr.Value, " "), 372 | } 373 | case key == "v-else": 374 | vElse = &ElseIf{ 375 | Types: "else", 376 | Condition: strings.Trim(attr.Value, " "), 377 | } 378 | case key == "v-html": 379 | vHtml = strings.Trim(attr.Value, " ") 380 | case key == "v-text": 381 | vText = strings.Trim(attr.Value, " ") 382 | default: 383 | // 自定义指令 384 | var name string 385 | var arg string 386 | if nameSpace != "-" { 387 | name = nameSpace 388 | arg = key 389 | } else { 390 | name = key 391 | } 392 | ds = append(ds, Directive{ 393 | Name: strings.TrimPrefix(name, "v-"), 394 | Value: strings.Trim(attr.Value, " "), 395 | Arg: arg, 396 | }) 397 | } 398 | } else if strings.HasPrefix(key, "#") { 399 | // v-slot:缩小 400 | slotName := key[1:] 401 | propsKey := attr.Value 402 | vSlot = &VSlot{ 403 | SlotName: slotName, 404 | PropsKey: propsKey, 405 | } 406 | } else if key == "class" { 407 | ss := strings.Split(attr.Value, " ") 408 | // class的基础类型是[]interface. 和js表达式运行之后的结果类型保持一致. 409 | var staticVal []interface{} 410 | for _, v := range ss { 411 | if v != "" { 412 | staticVal = append(staticVal, v) 413 | } 414 | } 415 | props = append(props, &Prop{ 416 | IsStatic: true, 417 | CanBeAttr: true, 418 | Key: "class", 419 | //Val: attr.Value, 420 | StaticVal: staticVal, 421 | }) 422 | 423 | } else if key == "style" { 424 | ss := strings.Split(attr.Value, ";") 425 | // style的基础类型是map[string]interface{}, 和js表达式运行之后的结果类型保持一致. 426 | staticVal := map[string]interface{}{} 427 | 428 | for _, v := range ss { 429 | v = strings.Trim(v, " ") 430 | ss := strings.Split(v, ":") 431 | if len(ss) != 2 { 432 | continue 433 | } 434 | key := strings.Trim(ss[0], " ") 435 | val := strings.Trim(ss[1], " ") 436 | 437 | staticVal[key] = val 438 | } 439 | 440 | props = append(props, &Prop{ 441 | IsStatic: true, 442 | CanBeAttr: true, 443 | Key: "style", 444 | //Val: attr.Value, 445 | StaticVal: staticVal, 446 | }) 447 | } else { 448 | // 静态props 449 | props = append(props, &Prop{ 450 | CanBeAttr: p.options.CanBeAttr(key), 451 | Key: key, 452 | //Val: attr.Value, 453 | StaticVal: attr.Value, 454 | IsStatic: true, 455 | }) 456 | } 457 | } 458 | 459 | ch, er := p.parseList(e.Child) 460 | if er != nil { 461 | err = er 462 | return 463 | } 464 | 465 | v := &VueElement{ 466 | NodeType: e.NodeType, 467 | Tag: e.Tag, 468 | Text: e.Text, 469 | //PropClass: propClass, 470 | //PropStyle: propStyle, 471 | Props: props, 472 | Directives: ds, 473 | //Class: class, 474 | //Style: styles, 475 | Children: ch, 476 | VIf: vIf, 477 | VFor: vFor, 478 | VSlot: vSlot, 479 | VElse: vElse != nil, 480 | VElseIf: vElseIf != nil, 481 | VHtml: vHtml, 482 | VText: vText, 483 | VBind: vBind, 484 | } 485 | 486 | // 记录vif, 接下来的elseif将与这个节点关联 487 | if vIf != nil { 488 | ifVueEle = v 489 | } else { 490 | // 如果有vif环境了, 但是中间跳过了, 则需要取消掉vif环境 (v-else 必须与v-if 相邻) 491 | skipNode := e.NodeType == CommentNode 492 | if !skipNode && vElse == nil && vElseIf == nil { 493 | ifVueEle = nil 494 | } 495 | } 496 | 497 | if vElseIf != nil { 498 | if ifVueEle == nil { 499 | err = errors.New("v-else-if must below v-if") 500 | return 501 | } 502 | vElseIf.VueElement = v 503 | ifVueEle.VIf.AddElseIf(vElseIf) 504 | 505 | // else 节点会被包括到if节点中, 不再放在当前节点中 506 | continue 507 | } 508 | if vElse != nil { 509 | if ifVueEle == nil { 510 | err = errors.New("v-else must below v-if") 511 | return 512 | } 513 | vElse.VueElement = v 514 | ifVueEle.VIf.AddElseIf(vElse) 515 | ifVueEle = nil 516 | continue 517 | } 518 | 519 | vs = append(vs, v) 520 | } 521 | 522 | return vs, nil 523 | } 524 | 525 | // 将html节点转换为Vue节点 526 | func ToVueNode(node Node, options ParseVueNodeOptions) (vn VueElement, err error) { 527 | if options == nil { 528 | options = &ParseVueNodeOptions{ 529 | CanBeAttr: func(k string) bool { 530 | if k == "id" || k == "class" || k == "style" { 531 | return true 532 | } 533 | 534 | if strings.HasPrefix(k, "data-") { 535 | return true 536 | } 537 | 538 | return false 539 | }, 540 | SkipComment: false, 541 | } 542 | } 543 | return VueElementParser{ 544 | options: options, 545 | }.Parse(node) 546 | } 547 | 548 | func (p VueElement) NicePrint(showChild bool, lev int) string { 549 | s := strings.Repeat(" ", lev) 550 | index := strings.Repeat(" ", lev) 551 | switch p.NodeType { 552 | case ElementNode, RootNode: 553 | s += fmt.Sprintf("<%v", p.Tag) 554 | if p.VIf != nil { 555 | s += " v-if=" + p.VIf.Condition 556 | } 557 | if p.VFor != nil { 558 | s += " v-for=" + p.VFor.ItemKey 559 | } 560 | if p.DistributionAttr { 561 | s += " DistributionAttr" 562 | } 563 | if len(p.Props) != 0 { 564 | s += fmt.Sprintf(" Props: %s", nicePrintProps(p.Props)) 565 | } 566 | 567 | s += ">\n" 568 | if showChild { 569 | for _, v := range p.Children { 570 | s += fmt.Sprintf("%s", v.NicePrint(showChild, lev+1)) 571 | } 572 | } 573 | 574 | // velse 575 | if p.VIf != nil { 576 | for _, ef := range p.VIf.ElseIf { 577 | if ef.Condition != "" { 578 | s += fmt.Sprintf("%sElseIf(%+v)\n", index, ef.Condition) 579 | } else { 580 | s += fmt.Sprintf("%sElse\n", index) 581 | } 582 | 583 | s += fmt.Sprintf("%s", ef.VueElement.NicePrint(showChild, lev+1)) 584 | } 585 | 586 | } 587 | case TextNode: 588 | s += fmt.Sprintf("%s\n", p.Text) 589 | case CommentNode: 590 | s += fmt.Sprintf("%s\n", p.Text) 591 | case DoctypeNode: 592 | s += fmt.Sprintf("%s\n", p.Text) 593 | //case RootNode: 594 | // s += fmt.Sprintf("<ROOT>\n") 595 | } 596 | 597 | return s 598 | } 599 | 600 | func nicePrintProps(p Props) string { 601 | var s strings.Builder 602 | s.WriteString("[") 603 | for _, i := range p { 604 | s.WriteString(fmt.Sprintf("%+v, ", i)) 605 | } 606 | s.WriteString("]") 607 | 608 | return s.String() 609 | } 610 | -------------------------------------------------------------------------------- /statement.go: -------------------------------------------------------------------------------- 1 | package vpl 2 | 3 | import ( 4 | "context" 5 | "encoding/json" 6 | "fmt" 7 | "github.com/robertkrimen/otto/ast" 8 | "github.com/zbysir/vpl/internal/lib/log" 9 | "github.com/zbysir/vpl/internal/parser" 10 | "github.com/zbysir/vpl/internal/util" 11 | "strings" 12 | "sync" 13 | ) 14 | 15 | // 执行每一个块的上下文 16 | type Scope struct { 17 | Parent Scope 18 | Value map[string]interface{} 19 | } 20 | 21 | func (s Scope) Get(k string) interface{} { 22 | return s.GetDeep(k) 23 | } 24 | 25 | func NewScope(outer Scope) Scope { 26 | return &Scope{ 27 | Parent: outer, 28 | Value: nil, 29 | } 30 | } 31 | 32 | // 获取作用域中的变量 33 | // 会向上查找 34 | func (s Scope) GetDeep(k ...string) (v interface{}) { 35 | var rootExist bool 36 | var ok bool 37 | 38 | curr := s 39 | for curr != nil { 40 | v, rootExist, ok = ShouldLookInterface(curr.Value, k...) 41 | // 如果root存在, 则说明就应该读取当前作用域, 否则向上层作用域查找 42 | if rootExist { 43 | if !ok { 44 | return nil 45 | } else { 46 | return 47 | } 48 | } 49 | 50 | curr = curr.Parent 51 | } 52 | 53 | return 54 | } 55 | 56 | func (s Scope) Extend(data map[string]interface{}) Scope { 57 | return &Scope{ 58 | Parent: s, 59 | Value: data, 60 | } 61 | } 62 | 63 | // 设置暂时只支持在当前作用域设置变量 64 | // 避免对上层变量造成副作用 65 | func (s Scope) Set(k string, v interface{}) { 66 | if s.Value == nil { 67 | s.Value = map[string]interface{}{} 68 | } 69 | (s.Value)[k] = v 70 | } 71 | 72 | // 在渲染中的上下文, 用在function和directive 73 | type RenderCtx struct { 74 | Scope Scope // 当前作用域, 用于向当前作用域声明一个值 75 | Store Store // 用于共享数据, 此Store是RenderParam中传递的Store 76 | } 77 | 78 | type Directive func(ctx RenderCtx, nodeData NodeData, binding DirectivesBinding) 79 | 80 | type DirectivesBinding struct { 81 | Value interface{} 82 | Arg string 83 | Name string 84 | } 85 | 86 | // 编译之后的Prop 87 | // 将js表达式解析成AST, 加速运行 88 | type propC struct { 89 | CanBeAttr bool 90 | Key string 91 | Val expression 92 | IsStatic bool 93 | ValStatic string // 如果Prop是静态的, 那么会在编译时优化为字符串 94 | } 95 | 96 | type propsC []propC 97 | 98 | // for nicePrint 99 | func (r propsC) String() string { 100 | str := "[" 101 | for _, v := range r { 102 | beAttr := "" 103 | if v.CanBeAttr { 104 | beAttr = "(attr)" 105 | } 106 | var val interface{} = v.Val 107 | 108 | if v.IsStatic { 109 | val = v.ValStatic 110 | } 111 | 112 | str += fmt.Sprintf("%+v%v: %+v, ", v.Key, beAttr, val) 113 | } 114 | str = strings.TrimSuffix(str, ", ") 115 | str += "]" 116 | return str 117 | } 118 | 119 | func (r propsC) execTo(ctx RenderCtx, ps Props) { 120 | if len(r) == 0 { 121 | return 122 | } 123 | 124 | for _, p := range r { 125 | c := CanNotBeAttr 126 | if p.CanBeAttr { 127 | c = CanBeAttr 128 | } 129 | 130 | ps.append(&PropKeys{ 131 | AttrWay: c, 132 | Key: p.Key, 133 | }, p.exec(ctx).Val) 134 | } 135 | return 136 | } 137 | 138 | func (r propC) exec(ctx RenderCtx) Prop { 139 | if r == nil { 140 | return &Prop{} 141 | } 142 | if r.IsStatic { 143 | return &Prop{Key: r.Key, Val: r.ValStatic} 144 | } else { 145 | return &Prop{Key: r.Key, Val: r.Val.Exec(ctx)} 146 | } 147 | } 148 | 149 | // 数值Prop 150 | // 执行PropC会得到PropR 151 | type Prop struct { 152 | Key string 153 | Val interface{} 154 | } 155 | 156 | //type PropKey struct { 157 | // AttrWay AttrWay // 能否被当成Attr输出 158 | // Key string 159 | //} 160 | 161 | type AttrWay uint8 162 | 163 | const ( 164 | MayBeAttr AttrWay = 0 // 无法在编译时确定, 还需要在运行时判断 165 | CanBeAttr AttrWay = 1 // 在编译时就确定能够当做attr 166 | CanNotBeAttr AttrWay = 2 // 在编译时就确定不能够当做attr 167 | ) 168 | 169 | type PropKeys struct { 170 | AttrWay AttrWay // 能否被当成Attr输出 171 | Key string 172 | Last PropKeys // 如果LinkKey只有一个元素, 则last是自己 173 | Next PropKeys 174 | } 175 | 176 | func (l PropKeys) Append(a PropKeys) { 177 | if l.Key == "" { 178 | l.Key = a.Key 179 | l.Last = l 180 | l.Next = nil 181 | l.AttrWay = a.AttrWay 182 | return 183 | } 184 | 185 | if l.Last == nil { 186 | l.Last = l 187 | } 188 | l.Last.Next = a 189 | l.Last = a 190 | } 191 | 192 | type Props struct { 193 | keys PropKeys // 在生成attr时会用到顺序 194 | data map[string]interface{} // 存储map有利于快速取值 195 | } 196 | 197 | func NewProps() Props { 198 | return &Props{ 199 | keys: nil, 200 | data: nil, 201 | } 202 | } 203 | 204 | func (r Props) ForEach(cb func(index int, k PropKeys, v interface{})) { 205 | if r == nil { 206 | return 207 | } 208 | i := 0 209 | h := r.keys 210 | for h != nil { 211 | cb(i, h, r.data[h.Key]) 212 | h = h.Next 213 | i++ 214 | } 215 | return 216 | } 217 | 218 | func (r Props) ToMap() map[string]interface{} { 219 | if r == nil { 220 | return nil 221 | } 222 | return r.data 223 | } 224 | 225 | func (r Props) append(k PropKeys, v interface{}) { 226 | if r.data == nil { 227 | r.data = map[string]interface{}{} 228 | } 229 | if r.keys == nil { 230 | r.keys = &PropKeys{} 231 | } 232 | 233 | // 合并class/style 234 | ve, exist := r.data[k.Key] 235 | if !exist { 236 | r.keys.Append(k) 237 | } else { 238 | switch k.Key { 239 | case "class": 240 | v = margeClass(ve, v) 241 | case "style": 242 | v = margeStyle(ve, v) 243 | } 244 | } 245 | 246 | r.data[k.Key] = v 247 | } 248 | 249 | // AppendAttr 向当前tag添加属性 250 | func (r Props) AppendAttr(k, v string) { 251 | r.append(&PropKeys{ 252 | AttrWay: CanBeAttr, 253 | Key: k, 254 | }, v) 255 | } 256 | 257 | func (r Props) Append(k string, v interface{}) { 258 | r.append(&PropKeys{ 259 | AttrWay: MayBeAttr, 260 | Key: k, 261 | }, v) 262 | } 263 | 264 | func (r Props) AppendClass(c ...string) { 265 | cla := make([]interface{}, len(c)) 266 | for i, v := range c { 267 | cla[i] = v 268 | } 269 | r.append(&PropKeys{ 270 | AttrWay: CanBeAttr, 271 | Key: "class", 272 | }, cla) 273 | } 274 | 275 | func (r Props) AppendStyle(st map[string]string) { 276 | stm := make(map[string]interface{}, len(st)) 277 | for k, v := range st { 278 | stm[k] = v 279 | } 280 | r.append(&PropKeys{ 281 | AttrWay: CanBeAttr, 282 | Key: "style", 283 | }, stm) 284 | } 285 | 286 | func margeClass(a interface{}, b interface{}) (d interface{}) { 287 | ar := []interface{}{a, b} 288 | return ar 289 | } 290 | 291 | func margeStyle(a interface{}, b interface{}) (d interface{}) { 292 | var ar map[string]interface{} 293 | if at, ok := a.(map[string]interface{}); ok { 294 | ar = at 295 | } else { 296 | ar = map[string]interface{}{} 297 | } 298 | 299 | if bt, ok := b.(map[string]interface{}); ok { 300 | for k, v := range bt { 301 | ar[k] = v 302 | } 303 | } 304 | 305 | return ar 306 | } 307 | 308 | // 无序添加多个props 309 | func (r Props) AppendMap(mp map[string]interface{}) { 310 | keys := util.GetSortedKey(mp) 311 | 312 | for _, k := range keys { 313 | v := mp[k] 314 | r.append(&PropKeys{ 315 | AttrWay: MayBeAttr, 316 | Key: k, 317 | }, v) 318 | } 319 | } 320 | 321 | // 有序添加多个props 322 | func (r Props) appendProps(ps Props) { 323 | if ps == nil { 324 | return 325 | } 326 | 327 | ps.ForEach(func(index int, k PropKeys, v interface{}) { 328 | r.append(k, v) 329 | }) 330 | } 331 | 332 | func (r Props) Get(key string) (interface{}, bool) { 333 | v, exist := r.data[key] 334 | return v, exist 335 | } 336 | 337 | // 如果 style和class动态与静态不冲突 ,并且沒有指令, 则可以将静态style/class优化为 string 338 | func compileProps(p parser.Props, staticProp bool) (propsC, error) { 339 | pc := make(propsC, len(p)) 340 | hasBindStyle := false 341 | hasBindClass := false 342 | for _, v := range p { 343 | if !v.IsStatic && v.Key == "class" { 344 | hasBindClass = true 345 | } 346 | if !v.IsStatic && v.Key == "style" { 347 | hasBindStyle = true 348 | } 349 | } 350 | for i, v := range p { 351 | static := staticProp 352 | if staticProp { 353 | if v.Key == "class" && v.IsStatic && hasBindClass { 354 | static = false 355 | } 356 | if v.Key == "style" && v.IsStatic && hasBindStyle { 357 | static = false 358 | } 359 | } 360 | 361 | p, err := compileProp(v, static) 362 | if err != nil { 363 | return nil, err 364 | } 365 | pc[i] = p 366 | } 367 | return pc, nil 368 | } 369 | 370 | func compileProp(p parser.Prop, staticProp bool) (propC, error) { 371 | if p == nil { 372 | return nil, nil 373 | } 374 | 375 | pc := &propC{ 376 | Key: p.Key, 377 | CanBeAttr: p.CanBeAttr, 378 | } 379 | if p.IsStatic { 380 | // 如果是静态的, 并且需要优化为字符串, 则修改为字符串 381 | if staticProp { 382 | switch p.Key { 383 | case "style": 384 | pc.ValStatic = getStyleFromProps(p.StaticVal).ToAttr() 385 | case "class": 386 | pc.ValStatic = getClassFromProps(p.StaticVal).ToAttr() 387 | default: 388 | pc.ValStatic = p.StaticVal.(string) 389 | } 390 | pc.IsStatic = true 391 | } else { 392 | pc.Val = newRawExpression(p.StaticVal) 393 | } 394 | } else { 395 | if p.ValCode != "" { 396 | node, err := compileJS(p.ValCode) 397 | if err != nil { 398 | return nil, fmt.Errorf("parseJs err: %w", err) 399 | } 400 | pc.Val = &jsExpression{node: node, code: p.ValCode} 401 | } else { 402 | pc.Val = &nullExpression{} 403 | } 404 | } 405 | 406 | return pc, nil 407 | } 408 | 409 | func compileVBind(v parser.VBind) (vBindC, error) { 410 | if v == nil { 411 | return nil, nil 412 | } 413 | 414 | if v.Val == "" { 415 | return nil, nil 416 | } 417 | 418 | node, err := compileJS(v.Val) 419 | if err != nil { 420 | return nil, fmt.Errorf("parseJs err: %w", err) 421 | } 422 | 423 | return &vBindC{val: &jsExpression{node: node, code: v.Val}}, nil 424 | } 425 | 426 | func compileDirective(ds parser.Directives) (directivesC, error) { 427 | if len(ds) == 0 { 428 | return nil, nil 429 | } 430 | 431 | pc := make(directivesC, len(ds)) 432 | for i, v := range ds { 433 | node, err := compileJS(v.Value) 434 | if err != nil { 435 | return nil, fmt.Errorf("parseJs err: %w", err) 436 | } 437 | pc[i] = directiveC{ 438 | Name: v.Name, 439 | Value: &jsExpression{node: node, code: v.Value}, 440 | Arg: v.Arg, 441 | } 442 | } 443 | return pc, nil 444 | } 445 | 446 | // 作用在tag的所有属性 447 | type tagStruct struct { 448 | // Props: 无论动态还是静态, 都是Props(包括class与style, 这是为了实现v-bind='$props'语法). 449 | // 静态的attr也处理成Props是为了保持顺序, 当然也是为了减少概念 450 | // 451 | // 如: <div id="abc" :data-id="id" :style="{left: '1px'}"> 452 | // 其中 Props 值为: id=string, data-id=string, style=map[string]interface 453 | // 454 | // 另外tag上的 Props 会根据CanBeAttrKey设置被转为html attr. 455 | Props propsC 456 | VBind vBindC 457 | 458 | Directives directivesC 459 | Slots SlotsC 460 | } 461 | 462 | // 编译时的指令 463 | type directiveC struct { 464 | Name string // v-animate 465 | Value expression // {'a': 1} 466 | Arg string // v-set:arg 467 | } 468 | 469 | type directivesC []directiveC 470 | 471 | // 组件的属性 472 | type ComponentStruct = tagStruct 473 | 474 | 475 | // VBind 语法, 一次传递多个prop 476 | // v-bind='{id: id, 'other-attr': otherAttr}' 477 | // 有一个特殊用法: 478 | // v-bind='$props': 将父组件所有的 props(不包括class和style) 一起传给子组件 479 | type vBindC struct { 480 | useProps bool 481 | val expression 482 | } 483 | 484 | func (v vBindC) execTo(ctx RenderCtx, ps Props) { 485 | if v == nil { 486 | return 487 | } 488 | var b interface{} 489 | if v.useProps { 490 | b = ctx.Scope.Get("$props") 491 | } else { 492 | b = v.val.Exec(ctx) 493 | } 494 | switch t := b.(type) { 495 | case map[string]interface{}: 496 | ps.AppendMap(t) 497 | case skipMarshalMap: 498 | ps.AppendMap(t) 499 | case Props: 500 | ps.appendProps(t) 501 | default: 502 | panic(fmt.Sprintf("bad Type of Vbind: %T", b)) 503 | } 504 | } 505 | 506 | func (v vBindC) exec(ctx RenderCtx) interface{} { 507 | if v == nil { 508 | return nil 509 | } 510 | if v.useProps { 511 | return ctx.Scope.Get("$props") 512 | } else { 513 | return v.val.Exec(ctx) 514 | } 515 | 516 | } 517 | 518 | // 表达式, 所有js表达式都会被预编译成为expression 519 | type expression interface { 520 | // 根据scope计算表达式值 521 | Exec(ctx RenderCtx) interface{} 522 | } 523 | 524 | // 原始值 525 | type rawExpression struct { 526 | raw interface{} 527 | } 528 | 529 | func (r rawExpression) String() string { 530 | return fmt.Sprintf("%v", r.raw) 531 | } 532 | 533 | func (r rawExpression) Exec(RenderCtx) interface{} { 534 | return r.raw 535 | } 536 | 537 | func newRawExpression(raw interface{}) rawExpression { 538 | return &rawExpression{raw: raw} 539 | } 540 | 541 | type jsExpression struct { 542 | node ast.Node 543 | code string 544 | } 545 | 546 | func (r jsExpression) Exec(ctx RenderCtx) interface{} { 547 | v, err := runJsExpression(r.node, ctx) 548 | if err != nil { 549 | log.Warningf("runJsExpression err:%v", err) 550 | return err 551 | } 552 | 553 | return v 554 | } 555 | 556 | func (r jsExpression) String() string { 557 | return r.code 558 | } 559 | 560 | type nullExpression struct { 561 | } 562 | 563 | func (r nullExpression) Exec(RenderCtx) interface{} { 564 | return nil 565 | } 566 | 567 | // vue语法会被编译成一组Statement 568 | // 为了避免多次运行造成副作用, 所有的运行时代码都不应该修改编译时 569 | type Statement interface { 570 | Exec(ctx StatementCtx, o StatementOptions) error 571 | } 572 | 573 | type FuncStatement func(StatementCtx, StatementOptions) error 574 | 575 | func (f FuncStatement) Exec(ctx StatementCtx, o StatementOptions) error { 576 | return f(ctx, o) 577 | } 578 | 579 | type Writer interface { 580 | // 如果需要实现异步计算, 则需要将span存储, 在最后统一计算出string. 581 | WriteSpan(Span) 582 | // 如果是同步计算, 使用WriteString会将string结果直接存储或者拼接 583 | WriteString(string) 584 | Result() string 585 | } 586 | 587 | type Span interface { 588 | Result() string 589 | } 590 | 591 | // 静态字符串块 592 | type StrStatement struct { 593 | Str string 594 | } 595 | 596 | func (s StrStatement) Exec(ctx StatementCtx, _ StatementOptions) error { 597 | ctx.W.WriteString(s.Str) 598 | return nil 599 | } 600 | 601 | type EmptyStatement struct { 602 | } 603 | 604 | func (s EmptyStatement) Exec(_ StatementCtx, _ StatementOptions) error { 605 | return nil 606 | } 607 | 608 | // tag块 609 | type tagStatement struct { 610 | tag string 611 | tagStruct tagStruct 612 | } 613 | 614 | // 执行map格式的props(来至v-bind语法) 615 | func execBindProps(t map[string]interface{}, ctx StatementCtx, attrKeys []string, attr map[string]string, class strings.Builder, style map[string]interface{}) { 616 | keys := util.GetSortedKey(t) 617 | 618 | for _, k := range keys { 619 | v := t[k] 620 | if k == "class" { 621 | writeClass(v, class) 622 | if _, exist := (attr)["class"]; !exist { 623 | attrKeys = append(attrKeys, "class") 624 | (attr)["class"] = "" 625 | } 626 | } else if k == "style" { 627 | switch t := v.(type) { 628 | case map[string]interface{}: 629 | if style == nil { 630 | style = t 631 | } else { 632 | for k, v := range t { 633 | (style)[k] = v 634 | } 635 | } 636 | } 637 | if _, exist := (attr)["style"]; !exist { 638 | attrKeys = append(attrKeys, "style") 639 | (attr)["style"] = "" 640 | } 641 | } else { 642 | if ctx.CanBeAttrsKey(k) { 643 | if _, exist := (attr)[k]; !exist { 644 | attrKeys = append(attrKeys, k) 645 | } 646 | 647 | switch v := v.(type) { 648 | case string: 649 | (attr)[k] = v 650 | default: 651 | (attr)[k] = util.InterfaceToStr(v, true) 652 | } 653 | } 654 | } 655 | } 656 | } 657 | 658 | // 如果tag没有指令, 则也不需要生成props, 而是将propsC直接运行成为attr. 659 | func (t tagStruct) ExecAttr(ctx StatementCtx, rCtx RenderCtx) error { 660 | var style map[string]interface{} 661 | var class strings.Builder 662 | 663 | // 使用attr来解决attr会合并的问题. 664 | // 如组件外传递的attr会覆盖与根组件相同的attr 665 | attrKeys := make([]string, 0, len(t.Props)) 666 | attr := make(map[string]string, len(t.Props)) 667 | 668 | if len(t.Props) != 0 { 669 | for _, p := range t.Props { 670 | if p.Key == "class" { 671 | // 如果class是静态的, 则不会发生合并的情况, 直接写入到write. 672 | if p.IsStatic { 673 | ctx.W.WriteString(` class="`) 674 | ctx.W.WriteString(p.ValStatic) 675 | ctx.W.WriteString(`"`) 676 | } else { 677 | writeClass(p.Val.Exec(rCtx), &class) 678 | if _, exist := attr["class"]; !exist { 679 | attrKeys = append(attrKeys, "class") 680 | attr["class"] = "" 681 | } 682 | } 683 | } else if p.Key == "style" { 684 | if p.IsStatic { 685 | ctx.W.WriteString(` style="`) 686 | ctx.W.WriteString(p.ValStatic) 687 | ctx.W.WriteString(`"`) 688 | } else { 689 | switch t := p.Val.Exec(rCtx).(type) { 690 | case map[string]interface{}: 691 | if style == nil { 692 | style = t 693 | } else { 694 | for k, v := range t { 695 | style[k] = v 696 | } 697 | } 698 | } 699 | if _, exist := attr["style"]; !exist { 700 | attrKeys = append(attrKeys, "style") 701 | attr["style"] = "" 702 | } 703 | } 704 | } else { 705 | if p.IsStatic { 706 | if p.ValStatic != "" { 707 | if _, exist := attr[p.Key]; !exist { 708 | attrKeys = append(attrKeys, p.Key) 709 | } 710 | attr[p.Key] = p.ValStatic 711 | } 712 | } else { 713 | v := p.Val.Exec(rCtx) 714 | if _, exist := attr[p.Key]; !exist { 715 | attrKeys = append(attrKeys, p.Key) 716 | } 717 | 718 | switch v := v.(type) { 719 | case string: 720 | attr[p.Key] = v 721 | default: 722 | attr[p.Key] = util.InterfaceToStr(v, true) 723 | } 724 | } 725 | } 726 | } 727 | } 728 | 729 | // 可能需要将 props和vBind中重复的attr去重 730 | if t.VBind != nil { 731 | var b = t.VBind.exec(rCtx) 732 | switch t := b.(type) { 733 | case nil: 734 | case map[string]interface{}: 735 | execBindProps(t, ctx, &attrKeys, &attr, &class, &style) 736 | case skipMarshalMap: 737 | execBindProps(t, ctx, &attrKeys, &attr, &class, &style) 738 | case Props: 739 | execBindProps(t.ToMap(), ctx, &attrKeys, &attr, &class, &style) 740 | default: 741 | panic(fmt.Sprintf("bad Type of Vbind: %T", b)) 742 | } 743 | } 744 | 745 | // 保证attr排序和写的一致 746 | // style和class会出现合并的情况, 所以在运行完所有props和vBind之后处理. 747 | for i := range attrKeys { 748 | switch attrKeys[i] { 749 | case "style": 750 | ctx.W.WriteString(` style="`) 751 | sortedKeys := util.GetSortedKey(style) 752 | var st strings.Builder 753 | for _, k := range sortedKeys { 754 | v := style[k] 755 | if st.Len() != 0 { 756 | st.WriteByte(' ') 757 | } 758 | 759 | st.WriteString(k) 760 | st.WriteString(": ") 761 | switch v := v.(type) { 762 | case string: 763 | st.WriteString(util.EscapeStyle(v)) 764 | default: 765 | bs, _ := json.Marshal(v) 766 | st.WriteString(util.Escape(string(bs))) 767 | } 768 | st.WriteByte(';') 769 | } 770 | ctx.W.WriteString(st.String()) 771 | ctx.W.WriteString(`"`) 772 | case "class": 773 | ctx.W.WriteString(` class="`) 774 | ctx.W.WriteString(class.String()) 775 | ctx.W.WriteString(`"`) 776 | default: 777 | ctx.W.WriteString(` `) 778 | ctx.W.WriteString(attrKeys[i]) 779 | v := attr[attrKeys[i]] 780 | if v != "" { 781 | ctx.W.WriteString(`="`) 782 | ctx.W.WriteString(v) 783 | ctx.W.WriteString(`"`) 784 | } 785 | } 786 | } 787 | 788 | return nil 789 | } 790 | 791 | func (t tagStatement) Exec(ctx StatementCtx, o StatementOptions) error { 792 | rCtx := ctxPool.Get().(RenderCtx) 793 | rCtx.Store = ctx.Store 794 | rCtx.Scope = o.Scope 795 | defer ctxPool.Put(rCtx) 796 | 797 | ctx.W.WriteString("<" + t.tag) 798 | 799 | // 如果没有指令, 则优化props执行流程 800 | // - 只执行CanBeAttr的props 801 | // - 优化class与style 802 | // - 直接写入Writer, 减少props声明 803 | 804 | // 如果没有指令, 则不需要闭包slot作用域 805 | var slots Slots 806 | 807 | if len(t.tagStruct.Directives) != 0 { 808 | // 处理attr 809 | // 计算Props 810 | var props Props 811 | if len(t.tagStruct.Props) != 0 || t.tagStruct.VBind != nil { 812 | props = NewProps() 813 | 814 | if len(t.tagStruct.Props) != 0 { 815 | t.tagStruct.Props.execTo(rCtx, props) 816 | } 817 | 818 | // v-bind="{id: 1}" 语法, 将计算出整个PropsR 819 | if t.tagStruct.VBind != nil { 820 | t.tagStruct.VBind.execTo(rCtx, props) 821 | } 822 | } 823 | 824 | // 只有指令有修改slots的需求, 如果没有指令, 则不需要闭包slot作用域 825 | slots = t.tagStruct.Slots.WrapScope(o) 826 | 827 | // 执行指令 828 | // 指令可以修改scope/props/style/class/children 829 | data := &NodeData{ 830 | Props: props, 831 | Slots: slots, 832 | } 833 | execDirectives(t.tagStruct.Directives, ctx, o.Scope, data) 834 | props = data.Props 835 | slots = data.Slots 836 | 837 | if props != nil { 838 | props.ForEach(func(index int, k PropKeys, v interface{}) { 839 | // 如果在编译期就确定了不能被转为attr, 则始终不能 840 | // 如果无法在编译期间确定(如通过props.AppendMap()的方式添加的props/通过v-bind="$props"方式而来的props), 则还需要再次调用函数判断 841 | if k.AttrWay == CanNotBeAttr { 842 | return 843 | } 844 | if k.AttrWay == MayBeAttr { 845 | // style和class字段始终会作为attr 846 | if k.Key != "style" && k.Key != "class" { 847 | if !ctx.CanBeAttrsKey(k.Key) { 848 | return 849 | } 850 | } 851 | } 852 | 853 | if k.Key == "style" { 854 | if v != nil { 855 | ctx.W.WriteString(` style="`) 856 | var s strings.Builder 857 | writeStyle(v, &s) 858 | ctx.W.WriteString(s.String()) 859 | ctx.W.WriteString(`"`) 860 | } 861 | } else if k.Key == "class" { 862 | if v != nil { 863 | ctx.W.WriteString(` class="`) 864 | var s strings.Builder 865 | writeClass(v, &s) 866 | ctx.W.WriteString(s.String()) 867 | ctx.W.WriteString(`"`) 868 | } 869 | } else { 870 | ctx.W.WriteString(" ") 871 | ctx.W.WriteString(k.Key) 872 | 873 | if v != nil { 874 | ctx.W.WriteString(`="`) 875 | 876 | switch v := v.(type) { 877 | case string: 878 | ctx.W.WriteString(v) 879 | default: 880 | ctx.W.WriteString(util.InterfaceToStr(v, true)) 881 | } 882 | ctx.W.WriteString(`"`) 883 | } 884 | } 885 | 886 | }) 887 | } 888 | 889 | } else { 890 | err := t.tagStruct.ExecAttr(ctx, rCtx) 891 | if err != nil { 892 | return err 893 | } 894 | } 895 | 896 | ctx.W.WriteString(">") 897 | 898 | // 如果没有指令, 则不需要闭包slot作用域 899 | if slots != nil { 900 | // 子节点 901 | children := slots.Default 902 | if children != nil { 903 | err := children.Exec(ctx, nil) 904 | if err != nil { 905 | return err 906 | } 907 | } 908 | } else if t.tagStruct.Slots != nil { 909 | // 直接执行children, 而不当做slots 910 | children := t.tagStruct.Slots.Default 911 | if children != nil && children.Children != nil { 912 | err := children.Children.Exec(ctx, o) 913 | if err != nil { 914 | return err 915 | } 916 | } 917 | } 918 | 919 | ctx.W.WriteString("</" + t.tag + ">") 920 | return nil 921 | } 922 | 923 | func execDirectives(ds directivesC, ctx StatementCtx, scope Scope, o NodeData) { 924 | rCtx := ctxPool.Get().(RenderCtx) 925 | rCtx.Store = ctx.Store 926 | rCtx.Scope = scope 927 | defer ctxPool.Put(rCtx) 928 | 929 | for _, v := range ds { 930 | val := v.Value.Exec(rCtx) 931 | d, exist := ctx.Directives[v.Name] 932 | if exist { 933 | d( 934 | rCtx, 935 | o, 936 | &DirectivesBinding{ 937 | Value: val, 938 | Arg: v.Arg, 939 | Name: v.Name, 940 | }, 941 | ) 942 | } 943 | 944 | } 945 | } 946 | 947 | type Class = parser.Class 948 | type Styles = parser.Styles 949 | 950 | type NodeData struct { 951 | Props Props // 给组件添加attr 952 | Slots Slots 953 | } 954 | 955 | // 支持的格式: map[string]interface{} 956 | func getStyleFromProps(styleProps interface{}) Styles { 957 | if styleProps == nil { 958 | return Styles{} 959 | } 960 | st := Styles{} 961 | switch t := styleProps.(type) { 962 | case map[string]interface{}: 963 | for k, v := range t { 964 | switch v := v.(type) { 965 | case string: 966 | st.Add(k, util.EscapeStyle(v)) 967 | default: 968 | bs, _ := json.Marshal(v) 969 | st.Add(k, util.EscapeStyle(string(bs))) 970 | } 971 | } 972 | } 973 | 974 | return st 975 | } 976 | 977 | // 支持的格式: map[string]interface{} 978 | func writeStyle(styleProps interface{}, w strings.Builder) { 979 | if styleProps == nil { 980 | return 981 | } 982 | 983 | switch t := styleProps.(type) { 984 | case map[string]interface{}: 985 | sortedKeys := util.GetSortedKey(t) 986 | for _, k := range sortedKeys { 987 | v := t[k] 988 | if w.Len() != 0 { 989 | w.WriteByte(' ') 990 | } 991 | w.WriteString(k + ": ") 992 | 993 | switch v := v.(type) { 994 | case string: 995 | w.WriteString(util.Escape(v)) 996 | default: 997 | bs, _ := json.Marshal(v) 998 | w.WriteString(util.Escape(string(bs))) 999 | } 1000 | 1001 | w.WriteString(";") 1002 | } 1003 | } 1004 | 1005 | return 1006 | } 1007 | 1008 | type ifStatement struct { 1009 | conditionCode string 1010 | condition expression 1011 | ChildStatement Statement 1012 | ElseIf []elseStatement 1013 | } 1014 | 1015 | type elseStatement struct { 1016 | conditionCode string 1017 | // 如果condition为空则说明是else节点, 否则是elseif节点 1018 | condition expression 1019 | ChildStatement Statement 1020 | } 1021 | 1022 | func (i ifStatement) Exec(ctx StatementCtx, o StatementOptions) error { 1023 | rCtx := ctxPool.Get().(RenderCtx) 1024 | rCtx.Store = ctx.Store 1025 | rCtx.Scope = o.Scope 1026 | defer ctxPool.Put(rCtx) 1027 | r := i.condition.Exec(rCtx) 1028 | if util.InterfaceToBool(r) { 1029 | err := i.ChildStatement.Exec(ctx, o) 1030 | if err != nil { 1031 | return err 1032 | } 1033 | } else { 1034 | // 如果if没有判断成功, 则循环执行elseIf 1035 | for _, ef := range i.ElseIf { 1036 | // 如果condition为空则说明是else节点 1037 | if ef.condition == nil { 1038 | err := ef.ChildStatement.Exec(ctx, o) 1039 | if err != nil { 1040 | return err 1041 | } 1042 | break 1043 | } 1044 | if util.InterfaceToBool(ef.condition.Exec(rCtx)) { 1045 | err := ef.ChildStatement.Exec(ctx, o) 1046 | if err != nil { 1047 | return err 1048 | } 1049 | break 1050 | } 1051 | } 1052 | } 1053 | 1054 | return nil 1055 | } 1056 | 1057 | type forStatement struct { 1058 | ArrayKey string 1059 | Array expression 1060 | ItemKey string 1061 | IndexKey string 1062 | ChildChunks Statement 1063 | } 1064 | 1065 | func (f forStatement) Exec(ctx StatementCtx, o StatementOptions) error { 1066 | rCtx := ctxPool.Get().(RenderCtx) 1067 | rCtx.Store = ctx.Store 1068 | rCtx.Scope = o.Scope 1069 | array := f.Array.Exec(rCtx) 1070 | ctxPool.Put(rCtx) 1071 | 1072 | return util.ForInterface(array, func(index int, v interface{}) error { 1073 | scope := o.Scope.Extend(map[string]interface{}{ 1074 | f.IndexKey: index, 1075 | f.ItemKey: v, 1076 | }) 1077 | 1078 | err := f.ChildChunks.Exec(ctx, &StatementOptions{ 1079 | Scope: scope, 1080 | }) 1081 | if err != nil { 1082 | return err 1083 | } 1084 | 1085 | return nil 1086 | }) 1087 | } 1088 | 1089 | type groupStatement struct { 1090 | s []Statement 1091 | strBuffer strings.Builder 1092 | } 1093 | 1094 | // 调用GroupStatement.Append之后还必须调用Finish才能保证GroupStatement中的数据是正确的 1095 | func (g groupStatement) Finish() Statement { 1096 | if g.strBuffer.Len() != 0 { 1097 | g.s = append(g.s, &StrStatement{Str: g.strBuffer.String()}) 1098 | g.strBuffer.Reset() 1099 | } 1100 | 1101 | if len(g.s) == 0 { 1102 | return &EmptyStatement{} 1103 | } 1104 | 1105 | if len(g.s) == 1 { 1106 | return g.s[0] 1107 | } 1108 | return g 1109 | } 1110 | 1111 | func (g groupStatement) Exec(ctx StatementCtx, o StatementOptions) error { 1112 | for i := range g.s { 1113 | err := g.s[i].Exec(ctx, o) 1114 | if err != nil { 1115 | return err 1116 | } 1117 | } 1118 | 1119 | return nil 1120 | } 1121 | 1122 | // Append 拼接一个新的语句到组里, 如果有连续的字符串语句则会合并成为一个字符串语句. 1123 | func (g groupStatement) Append(st Statement) { 1124 | if st == nil { 1125 | return 1126 | } 1127 | switch appT := st.(type) { 1128 | case EmptyStatement: 1129 | return 1130 | case StrStatement: 1131 | g.strBuffer.WriteString(appT.Str) 1132 | case groupStatement: 1133 | for _, v := range appT.s { 1134 | g.Append(v) 1135 | } 1136 | default: 1137 | if g.strBuffer.Len() != 0 { 1138 | g.s = append(g.s, &StrStatement{Str: g.strBuffer.String()}) 1139 | g.strBuffer.Reset() 1140 | } 1141 | g.s = append(g.s, st) 1142 | } 1143 | } 1144 | 1145 | // 调用组件 1146 | type ComponentStatement struct { 1147 | ComponentKey string 1148 | ComponentStruct ComponentStruct 1149 | } 1150 | 1151 | // 调用组件语句 1152 | // o是上层options. 1153 | // 根据组件attr拼接出新的scope, 再执行组件 1154 | // 处理slot作用域 1155 | func (c ComponentStatement) Exec(ctx StatementCtx, o StatementOptions) error { 1156 | rCtx := ctxPool.Get().(RenderCtx) 1157 | rCtx.Store = ctx.Store 1158 | rCtx.Scope = o.Scope 1159 | defer ctxPool.Put(rCtx) 1160 | 1161 | // 计算Props 1162 | var props Props 1163 | if c.ComponentStruct.VBind != nil || c.ComponentStruct.Props != nil { 1164 | props = NewProps() 1165 | // v-bind="{id: 1}" 语法, 将计算出整个PropsR 1166 | if c.ComponentStruct.VBind != nil { 1167 | c.ComponentStruct.VBind.execTo(rCtx, props) 1168 | } 1169 | 1170 | // 如果还传递了其他props, 则覆盖 1171 | if c.ComponentStruct.Props != nil { 1172 | c.ComponentStruct.Props.execTo(rCtx, props) 1173 | } 1174 | } 1175 | 1176 | // 处理slot作用域 1177 | slots := c.ComponentStruct.Slots.WrapScope(o) 1178 | 1179 | cp, exist := ctx.Components[c.ComponentKey] 1180 | // 没有找到组件时直接渲染自身的子组件 1181 | if !exist { 1182 | ctx.W.WriteString(fmt.Sprintf(`<%s data-err="not found component"`, c.ComponentKey)) 1183 | c.ComponentStruct.ExecAttr(ctx, rCtx) 1184 | ctx.W.WriteString(`>`) 1185 | 1186 | if slots != nil { 1187 | child := slots.Default 1188 | if child != nil { 1189 | err := child.Exec(ctx, nil) 1190 | if err != nil { 1191 | return nil 1192 | } 1193 | } 1194 | } 1195 | 1196 | ctx.W.WriteString(fmt.Sprintf("</%s>", c.ComponentKey)) 1197 | return nil 1198 | } 1199 | 1200 | // 执行指令 1201 | // 指令可以修改scope/props/style/class/children 1202 | if len(c.ComponentStruct.Directives) != 0 { 1203 | data := &NodeData{ 1204 | Props: props, 1205 | Slots: slots, 1206 | } 1207 | execDirectives(c.ComponentStruct.Directives, ctx, o.Scope, data) 1208 | props = data.Props 1209 | slots = data.Slots 1210 | } 1211 | 1212 | //json.Marshal() 1213 | 1214 | // 运行组件应该重新使用新的scope 1215 | // 和vue不同的是, props只有在子组件中申明才能在子组件中使用, 而vtpl不同, 它将所有props放置到变量域中. 1216 | scope := ctx.NewScope() 1217 | if props != nil { 1218 | propsMap := props.ToMap() 1219 | scope = scope.Extend(propsMap) 1220 | // 使用skipMarshalMap解决循环引用时Marshal报错的问题 1221 | scope.Set("$props", skipMarshalMap(propsMap)) 1222 | } 1223 | 1224 | return cp.Exec(ctx, &StatementOptions{ 1225 | // 此组件在声明时拥有的所有slots 1226 | Slots: slots, 1227 | // 此组件上的props 1228 | // 用于: 1229 | // - root组件使用props转为attr, 1230 | // - slot组件收集所有的props实现作用域插槽(https://cn.vuejs.org/v2/guide/components-slots.html#%E4%BD%9C%E7%94%A8%E5%9F%9F%E6%8F%92%E6%A7%BD) 1231 | // <slot :user="user"> 1232 | Props: props, 1233 | 1234 | // 此组件和其下的子组件所能访问到的所有变量(包括了当前组件的props) 1235 | Scope: scope, 1236 | // 父级作用域 1237 | // 只有组件有父级作用域, 用来执行slot 1238 | Parent: o, 1239 | }) 1240 | } 1241 | 1242 | // 声明Slot的语句(编译时) 1243 | // <h1 v-slot:default="SlotProps"> </h1> 1244 | type SlotC struct { 1245 | Name string 1246 | propsKey string 1247 | Children Statement 1248 | } 1249 | 1250 | // Slot的运行时 1251 | type Slot struct { 1252 | SlotC 1253 | 1254 | // 在运行时被赋值 1255 | // Declarer 存储在当slot声明时的组件数据 1256 | Declarer StatementOptions 1257 | } 1258 | 1259 | type ExecSlotOptions struct { 1260 | // <slot :abc="abc"> 语法传递的slot props. 1261 | SlotProps Props 1262 | } 1263 | 1264 | func (s Slot) Exec(ctx StatementCtx, o StatementOptions) error { 1265 | if s.Children == nil { 1266 | return nil 1267 | } 1268 | 1269 | var no StatementOptions 1270 | // 将申明时的scope和传递的slot-props合并 1271 | if s.Declarer != nil { 1272 | no = &StatementOptions{} 1273 | no.Slots = s.Declarer.Slots 1274 | 1275 | scope := s.Declarer.Scope 1276 | if o != nil && o.Props != nil && s.propsKey != "" { 1277 | scope = scope.Extend(map[string]interface{}{ 1278 | s.propsKey: o.Props.ToMap(), 1279 | }) 1280 | } 1281 | 1282 | no.Scope = scope 1283 | } 1284 | return s.Children.Exec(ctx, no) 1285 | } 1286 | 1287 | // 胡子语法: {{a}} 1288 | // 会进行html转义 1289 | type mustacheStatement struct { 1290 | exp expression 1291 | } 1292 | 1293 | var ctxPool sync.Pool 1294 | 1295 | func init() { 1296 | ctxPool = sync.Pool{New: func() interface{} { 1297 | return &RenderCtx{} 1298 | }} 1299 | } 1300 | 1301 | func (i mustacheStatement) Exec(ctx StatementCtx, o StatementOptions) error { 1302 | rCtx := ctxPool.Get().(RenderCtx) 1303 | rCtx.Store = ctx.Store 1304 | rCtx.Scope = o.Scope 1305 | defer ctxPool.Put(rCtx) 1306 | 1307 | //rCtx := &RenderCtx{ 1308 | // Store: ctx.Store, Scope: o.Scope, 1309 | //} 1310 | 1311 | r := i.exp.Exec(rCtx) 1312 | 1313 | ctx.W.WriteString(util.InterfaceToStr(r, true)) 1314 | return nil 1315 | } 1316 | 1317 | // 不会转义的html语句 1318 | // 用于v-html 1319 | type rawHtmlStatement struct { 1320 | exp expression 1321 | } 1322 | 1323 | func (i rawHtmlStatement) Exec(ctx StatementCtx, o StatementOptions) error { 1324 | rCtx := ctxPool.Get().(RenderCtx) 1325 | rCtx.Store = ctx.Store 1326 | rCtx.Scope = o.Scope 1327 | defer ctxPool.Put(rCtx) 1328 | 1329 | r := i.exp.Exec(rCtx) 1330 | 1331 | ctx.W.WriteString(util.InterfaceToStr(r, false)) 1332 | return nil 1333 | } 1334 | 1335 | // https://cn.vuejs.org/v2/guide/components-slots.html 1336 | // SlotsC 存放传递给组件的所有Slot（默认与具名）(编译时), vue语法: <h1 v-slot:default="xxx"></h1> 1337 | type SlotsC struct { 1338 | Default SlotC 1339 | NamedSlot map[string]SlotC 1340 | } 1341 | 1342 | func (s SlotsC) marge(x SlotsC) { 1343 | if x == nil { 1344 | return 1345 | } 1346 | 1347 | if x.Default != nil { 1348 | s.Default = x.Default 1349 | } 1350 | 1351 | if x.NamedSlot != nil { 1352 | if s.NamedSlot == nil { 1353 | s.NamedSlot = make(map[string]SlotC, len(x.NamedSlot)) 1354 | } 1355 | for k, xs := range x.NamedSlot { 1356 | s.NamedSlot[k] = xs 1357 | } 1358 | } 1359 | } 1360 | 1361 | // WrapScope 设置在slot声明时的scope, 用于在运行slot时使用声明slot时的scope 1362 | func (s SlotsC) WrapScope(o StatementOptions) (sr Slots) { 1363 | if s == nil { 1364 | return nil 1365 | } 1366 | if s.Default != nil { 1367 | sr = &Slots{ 1368 | Default: &Slot{ 1369 | SlotC: s.Default, 1370 | Declarer: o, 1371 | }, 1372 | } 1373 | } 1374 | if s.NamedSlot != nil { 1375 | if sr == nil { 1376 | sr = &Slots{} 1377 | } 1378 | 1379 | sr.NamedSlot = make(map[string]Slot, len(s.NamedSlot)) 1380 | for k, v := range s.NamedSlot { 1381 | sr.NamedSlot[k] = &Slot{ 1382 | SlotC: v, 1383 | Declarer: o, 1384 | } 1385 | } 1386 | } 1387 | 1388 | return 1389 | } 1390 | 1391 | type Slots struct { 1392 | Default Slot // 大多数都是Default插槽，放入map里会有性能损耗，所以优化为单独一个字段 1393 | NamedSlot map[string]Slot 1394 | } 1395 | 1396 | func (s Slots) Get(key string) Slot { 1397 | if s == nil { 1398 | return nil 1399 | } 1400 | if key == "default" { 1401 | return s.Default 1402 | } 1403 | return s.NamedSlot[key] 1404 | } 1405 | 1406 | func ParseHtmlToStatement(tpl string, options parser.ParseVueNodeOptions) (Statement, SlotsC, error) { 1407 | nt, err := parser.ParseHtml(tpl) 1408 | if err != nil { 1409 | return nil, nil, err 1410 | } 1411 | vn, err := parser.ToVueNode(nt, options) 1412 | if err != nil { 1413 | return nil, nil, fmt.Errorf("parseToVue err: %w", err) 1414 | } 1415 | statement, slots, err := toStatement(vn) 1416 | if err != nil { 1417 | return nil, nil, err 1418 | } 1419 | return statement, slots, nil 1420 | } 1421 | 1422 | // 执行语句(组件/Tag)所需的参数 1423 | type StatementOptions struct { 1424 | Slots Slots 1425 | 1426 | // 渲染组件时, 组件上的props 1427 | // 如 1428 | // <Menu :data="data"> 1429 | // <slot name="default"> 1430 | Props Props 1431 | 1432 | // 如果是渲染tag, scope是当前组件的scope(如果在For语句中, 则也有For的scope). 1433 | // 如果渲染其他组件, scope也是当前组件的scope. 1434 | Scope Scope 1435 | 1436 | // 上一层参数, 用于: 1437 | // - 渲染slot时获取声明slot时的scope. 1438 | // - 渲染slot时获取上一层的slots, 从中取出slot渲染. (slot组件自己的slot是备选内容) 1439 | Parent StatementOptions 1440 | } 1441 | 1442 | // 整个渲染期间的上下文. 1443 | // Ctx贯穿整个渲染流程, 意味着每一个组件/方法/指令都可以拿到同一个ctx, 只有其中的值会变化. 1444 | type StatementCtx struct { 1445 | Global Scope 1446 | 1447 | Store Store 1448 | 1449 | Ctx context.Context 1450 | W Writer 1451 | 1452 | Components map[string]Statement 1453 | Directives map[string]Directive 1454 | CanBeAttrsKey func(k string) bool 1455 | } 1456 | 1457 | func (c StatementCtx) NewScope() Scope { 1458 | return NewScope(c.Global) 1459 | } 1460 | 1461 | func (c StatementCtx) Clone() StatementCtx { 1462 | return &StatementCtx{ 1463 | Global: c.Global, 1464 | Store: c.Store, 1465 | Ctx: c.Ctx, 1466 | W: c.W, 1467 | Components: c.Components, 1468 | Directives: c.Directives, 1469 | CanBeAttrsKey: c.CanBeAttrsKey, 1470 | } 1471 | } 1472 | 1473 | func (c StatementCtx) Set(k string, v interface{}) { 1474 | c.Store.Set(k, v) 1475 | } 1476 | func (c StatementCtx) Get(k string) (v interface{}, exist bool) { 1477 | return c.Store.Get(k) 1478 | } 1479 | 1480 | type Store interface { 1481 | Get(key string) (interface{}, bool) 1482 | Set(key string, val interface{}) 1483 | } 1484 | 1485 | type MapStore map[string]interface{} 1486 | 1487 | func (g MapStore) Get(key string) (interface{}, bool) { 1488 | v, exist := g[key] 1489 | return v, exist 1490 | } 1491 | 1492 | func (g MapStore) Set(key string, val interface{}) { 1493 | g[key] = val 1494 | } 1495 | 1496 | // 如果全部是静态Props, 则能被渲染为静态字符串 1497 | func canBeStr(v parser.VueElement) bool { 1498 | return v.Props.IsStatic() && 1499 | //v.PropClass == nil && 1500 | //v.PropStyle == nil && 1501 | v.VBind == nil && 1502 | v.VHtml == "" && 1503 | v.VText == "" && 1504 | len(v.Directives) == 0 && 1505 | v.DistributionAttr == false 1506 | } 1507 | 1508 | var htmlTag = map[string]struct{}{ 1509 | "html": {}, 1510 | "head": {}, 1511 | "header": {}, 1512 | "footer": {}, 1513 | "body": {}, 1514 | "meta": {}, 1515 | "title": {}, 1516 | "div": {}, 1517 | "input": {}, 1518 | "p": {}, 1519 | "h1": {}, 1520 | "h2": {}, 1521 | "h3": {}, 1522 | "h4": {}, 1523 | "h5": {}, 1524 | "h6": {}, 1525 | "hr": {}, 1526 | "blockquote": {}, 1527 | "ul": {}, 1528 | "li": {}, 1529 | "span": {}, 1530 | "style": {}, 1531 | "script": {}, 1532 | "link": {}, 1533 | "a": {}, 1534 | "object": {}, 1535 | "button": {}, 1536 | "img": {}, 1537 | "i": {}, 1538 | "center": {}, 1539 | "table": {}, 1540 | "tbody": {}, 1541 | "thead": {}, 1542 | "th": {}, 1543 | "tr": {}, 1544 | "td": {}, 1545 | "pre": {}, 1546 | "code": {}, 1547 | "br": {}, 1548 | } 1549 | 1550 | // 通过Vue树，生成运行程序 1551 | // 需要做的事： 1552 | // - 简化vue树 1553 | // - 将连在一起的静态节点预渲染为字符串 1554 | // - 预编译JS 1555 | // 原则是将运行时消耗减到最小 1556 | func toStatement(v parser.VueElement) (Statement, SlotsC, error) { 1557 | slots := &SlotsC{} 1558 | switch v.NodeType { 1559 | case parser.RootNode: 1560 | // Root节点只是一个虚拟节点, 不渲染自己, 直接渲染子级 1561 | 1562 | // 子集 1563 | var sg groupStatement 1564 | for _, c := range v.Children { 1565 | s, slotsc, err := toStatement(c) 1566 | if err != nil { 1567 | return nil, nil, err 1568 | } 1569 | slots.marge(slotsc) 1570 | sg.Append(s) 1571 | } 1572 | return sg.Finish(), slots, nil 1573 | case parser.DoctypeNode: 1574 | return &StrStatement{Str: v.Text}, nil, nil 1575 | case parser.ElementNode: 1576 | var st Statement 1577 | 1578 | // 静态节点(不是自定义组件)，则走渲染tag逻辑, 否则调用渲染组件方法 1579 | if _, ok := htmlTag[v.Tag]; ok { 1580 | var sg groupStatement 1581 | 1582 | // 如果没使用任何变量, 则是静态组件, 则编译成字符串 1583 | if canBeStr(v) { 1584 | attrs := "" 1585 | 1586 | //if len(v.Class) != 0 { 1587 | // attrs += v.Class.ToAttr() 1588 | //} 1589 | // 1590 | //if len(v.Style) != 0 { 1591 | // if attrs != "" { 1592 | // attrs += " " 1593 | // } 1594 | // attrs += v.Style.ToAttr() 1595 | //} 1596 | 1597 | // 静态props 1598 | if len(v.Props) != 0 { 1599 | attrs += genAttrFromProps(v.Props) 1600 | } 1601 | 1602 | if attrs != "" { 1603 | attrs = " " + attrs 1604 | } 1605 | 1606 | sg.Append(&StrStatement{Str: fmt.Sprintf("<%s%s>", v.Tag, attrs)}) 1607 | 1608 | // 子集 1609 | for _, c := range v.Children { 1610 | s, slotsc, err := toStatement(c) 1611 | if err != nil { 1612 | return nil, nil, err 1613 | } 1614 | slots.marge(slotsc) 1615 | sg.Append(s) 1616 | } 1617 | 1618 | // 单标签不需要结束 1619 | if !parser.VoidElements[v.Tag] { 1620 | sg.Append(&StrStatement{Str: fmt.Sprintf("</%s>", v.Tag)}) 1621 | } 1622 | } else { 1623 | // 动态的（依赖变量）节点渲染 1624 | 1625 | //pc, err := compileProp(v.PropClass) 1626 | //if err != nil { 1627 | // return nil, nil, err 1628 | //} 1629 | //ps, err := compileProp(v.PropStyle) 1630 | //if err != nil { 1631 | // return nil, nil, err 1632 | //} 1633 | 1634 | // 如果 style和class动态与静态不冲突 ,并且沒有指令, 则可以将静态style/class优化为 string 1635 | staticProp := !v.DistributionAttr && v.VBind == nil && len(v.Directives) == 0 1636 | p, err := compileProps(v.Props, staticProp) 1637 | if err != nil { 1638 | return nil, nil, err 1639 | } 1640 | 1641 | // 如果被自动分配attr, 那么直接继承上一层的props 1642 | var vbind vBindC 1643 | if v.DistributionAttr { 1644 | vbind = &vBindC{useProps: true} 1645 | } else { 1646 | vbind, err = compileVBind(v.VBind) 1647 | if err != nil { 1648 | return nil, nil, err 1649 | } 1650 | } 1651 | 1652 | dir, err := compileDirective(v.Directives) 1653 | if err != nil { 1654 | return nil, nil, err 1655 | 1656 | } 1657 | 1658 | var childStatement Statement 1659 | 1660 | if v.VHtml != "" { 1661 | node, err := compileJS(v.VHtml) 1662 | if err != nil { 1663 | return nil, nil, err 1664 | } 1665 | childStatement = &rawHtmlStatement{ 1666 | exp: &jsExpression{node: node, code: v.VHtml}, 1667 | } 1668 | } else if v.VText != "" { 1669 | node, err := compileJS(v.VText) 1670 | if err != nil { 1671 | return nil, nil, err 1672 | } 1673 | childStatement = &mustacheStatement{ 1674 | exp: &jsExpression{node: node, code: v.VText}, 1675 | } 1676 | } else { 1677 | var childStatementG groupStatement 1678 | for _, c := range v.Children { 1679 | s, slotsc, err := toStatement(c) 1680 | if err != nil { 1681 | return nil, nil, err 1682 | } 1683 | slots.marge(slotsc) 1684 | 1685 | childStatementG.Append(s) 1686 | } 1687 | 1688 | childStatement = childStatementG.Finish() 1689 | } 1690 | 1691 | // 子集作为default slot 1692 | var slots SlotsC 1693 | if childStatement != nil { 1694 | slots = &SlotsC{ 1695 | Default: &SlotC{ 1696 | Name: "default", 1697 | propsKey: "", 1698 | Children: childStatement, 1699 | }, 1700 | NamedSlot: nil, 1701 | } 1702 | } 1703 | 1704 | sg.Append(&tagStatement{ 1705 | tag: v.Tag, 1706 | tagStruct: tagStruct{ 1707 | Props: p, 1708 | //PropClass: pc, 1709 | //PropStyle: ps, 1710 | //StaticClass: v.Class, 1711 | //StaticStyle: v.Style, 1712 | Directives: dir, 1713 | Slots: slots, 1714 | VBind: vbind, 1715 | }, 1716 | }) 1717 | } 1718 | 1719 | st = sg.Finish() 1720 | } else { 1721 | // 自定义组件 1722 | var childStatement Statement 1723 | 1724 | if v.VHtml != "" { 1725 | node, err := compileJS(v.VHtml) 1726 | if err != nil { 1727 | return nil, nil, err 1728 | } 1729 | childStatement = &rawHtmlStatement{ 1730 | exp: &jsExpression{node: node, code: v.VHtml}, 1731 | } 1732 | } else if v.VText != "" { 1733 | node, err := compileJS(v.VText) 1734 | if err != nil { 1735 | return nil, nil, err 1736 | } 1737 | childStatement = &mustacheStatement{ 1738 | exp: &jsExpression{node: node, code: v.VText}, 1739 | } 1740 | } else { 1741 | // 子集作为default slot 1742 | var childStatementG groupStatement 1743 | for _, c := range v.Children { 1744 | s, slotsc, err := toStatement(c) 1745 | if err != nil { 1746 | return nil, nil, err 1747 | } 1748 | slots.marge(slotsc) 1749 | childStatementG.Append(s) 1750 | } 1751 | 1752 | childStatement = childStatementG.Finish() 1753 | } 1754 | 1755 | if v.Tag == "template" && len(v.Directives) == 0 { 1756 | // 如果是template 并且没有自定义指令, 则可以简化语句 1757 | st = childStatement 1758 | } else { 1759 | if childStatement != nil { 1760 | slots.Default = &SlotC{ 1761 | Name: "default", 1762 | propsKey: "", 1763 | Children: childStatement, 1764 | } 1765 | } 1766 | 1767 | vbind, err := compileVBind(v.VBind) 1768 | if err != nil { 1769 | return nil, nil, err 1770 | } 1771 | 1772 | dir, err := compileDirective(v.Directives) 1773 | if err != nil { 1774 | return nil, nil, err 1775 | } 1776 | p, err := compileProps(v.Props, !v.DistributionAttr && v.VBind == nil) 1777 | if err != nil { 1778 | return nil, nil, err 1779 | } 1780 | 1781 | st = &ComponentStatement{ 1782 | ComponentKey: v.Tag, 1783 | ComponentStruct: ComponentStruct{ 1784 | Props: p, 1785 | VBind: vbind, 1786 | Directives: dir, 1787 | Slots: slots, 1788 | }, 1789 | } 1790 | } 1791 | 1792 | // 如果调用了自定义组件, 则slots就算这个自定义组件当中, 而不算在父级当中. 1793 | slots = &SlotsC{} 1794 | } 1795 | 1796 | if v.VIf != nil { 1797 | ifCondition, err := compileJS(v.VIf.Condition) 1798 | if err != nil { 1799 | return nil, nil, err 1800 | } 1801 | // 解析else节点 1802 | elseIfStatements := make([]elseStatement, len(v.VIf.ElseIf)) 1803 | for i, f := range v.VIf.ElseIf { 1804 | st, slotsc, err := toStatement(f.VueElement) 1805 | if err != nil { 1806 | return nil, nil, err 1807 | } 1808 | slots.marge(slotsc) 1809 | 1810 | s := &elseStatement{ 1811 | conditionCode: f.Condition, 1812 | condition: nil, 1813 | ChildStatement: st, 1814 | } 1815 | 1816 | if f.Types == "elseif" && f.Condition != "" { 1817 | n, err := compileJS(f.Condition) 1818 | if err != nil { 1819 | return nil, nil, err 1820 | } 1821 | 1822 | s.condition = &jsExpression{node: n, code: f.Condition} 1823 | } 1824 | 1825 | elseIfStatements[i] = s 1826 | } 1827 | 1828 | st = &ifStatement{ 1829 | condition: &jsExpression{node: ifCondition, code: v.VIf.Condition}, 1830 | conditionCode: v.VIf.Condition, 1831 | ChildStatement: st, 1832 | ElseIf: elseIfStatements, 1833 | } 1834 | } 1835 | 1836 | if v.VFor != nil { 1837 | p, err := compileJS(v.VFor.ArrayKey) 1838 | if err != nil { 1839 | return nil, nil, err 1840 | } 1841 | 1842 | st = &forStatement{ 1843 | ArrayKey: v.VFor.ArrayKey, 1844 | Array: &jsExpression{node: p, code: v.VFor.ArrayKey}, 1845 | ItemKey: v.VFor.ItemKey, 1846 | IndexKey: v.VFor.IndexKey, 1847 | ChildChunks: st, 1848 | } 1849 | } 1850 | 1851 | if v.VSlot != nil { 1852 | if v.VSlot.SlotName == "default" { 1853 | slots.Default = &SlotC{ 1854 | Name: v.VSlot.SlotName, 1855 | propsKey: v.VSlot.PropsKey, 1856 | Children: st, 1857 | } 1858 | } else { 1859 | if slots.NamedSlot == nil { 1860 | slots.NamedSlot = map[string]*SlotC{} 1861 | } 1862 | slots.NamedSlot[v.VSlot.SlotName] = &SlotC{ 1863 | Name: v.VSlot.SlotName, 1864 | propsKey: v.VSlot.PropsKey, 1865 | Children: st, 1866 | } 1867 | } 1868 | 1869 | // 自己不是语句, 而是slot 1870 | st = nil 1871 | } 1872 | 1873 | return st, slots, nil 1874 | case parser.TextNode: 1875 | s, err := parseBeard(v.Text) 1876 | if err != nil { 1877 | return nil, nil, err 1878 | } 1879 | return s, slots, nil 1880 | case parser.CommentNode: 1881 | return &StrStatement{Str: v.Text}, nil, nil 1882 | default: 1883 | return &StrStatement{Str: fmt.Sprintf("not case NodeType: %+v", v.NodeType)}, nil, nil 1884 | } 1885 | 1886 | } 1887 | 1888 | // 将胡子语法处理成多个语句 1889 | func parseBeard(txt string) (Statement, error) { 1890 | var sg groupStatement 1891 | 1892 | if strings.Contains(txt, "{{") { 1893 | for index, v := range strings.Split(txt, "{{") { 1894 | if len(v) == 0 { 1895 | continue 1896 | } 1897 | if index == 0 { 1898 | sg.Append(&StrStatement{Str: v}) 1899 | } else { 1900 | sp := strings.Split(v, "}}") 1901 | if len(sp) == 2 { 1902 | code := sp[0] 1903 | if len(code) != 0 { 1904 | node, err := compileJS(code) 1905 | if err != nil { 1906 | return nil, err 1907 | } 1908 | sg.Append(&mustacheStatement{ 1909 | exp: &jsExpression{node: node, code: code}, 1910 | }) 1911 | } 1912 | if len(sp[1]) != 0 { 1913 | sg.Append(&StrStatement{Str: sp[1]}) 1914 | } 1915 | } else { 1916 | // bad token 1917 | sg.Append(&StrStatement{Str: v}) 1918 | } 1919 | } 1920 | } 1921 | } else { 1922 | sg.Append(&StrStatement{Str: txt}) 1923 | } 1924 | 1925 | return sg.Finish(), nil 1926 | } 1927 | --------------------------------------------------------------------------------

富文本-

(2)条信息 Infos:

2main propsClass 1

H1 Pagser Example span

29 | Title from content {{global}} {{lang}} 30 |

Title from content global null

Hello

({{infos.length}})条信息 {{props.title}}:

富文本-

251 | {{props['data-a']}} 252 | fullback 253 |

2main propsClass 1

199 | //

204 | // 205 | //

249 | //

254 | // 255 | //