mirror/hugo
1
0
Fork 0
mirror of https://github.com/gohugoio/hugo.git synced 2025-08-11 20:03:58 +02:00
Code Issues Packages Projects Releases Wiki Activity

parser/metadecoders: Consolidate the metadata decoders

Browse Source 
See #5324
This commit is contained in:
Bjørn Erik Pedersen
2018-10-20 11:16:18 +02:00
parent 44da60d869
commit 129c27ee6e
22 changed files with 624 additions and 808 deletions
Download Patch File Download Diff File Expand all files Collapse all files

266
parser/frontmatter_test.go
View File

@@ -132,116 +132,6 @@ func TestInterfaceToFrontMatter(t *testing.T) {
}
}
func TestHandleTOMLMetaData(t *testing.T) {
cases := []struct {
input []byte
want interface{}
isErr bool
}{
{nil, map[string]interface{}{}, false},
{[]byte("title = \"test 1\""), map[string]interface{}{"title": "test 1"}, false},
{[]byte("a = [1, 2, 3]"), map[string]interface{}{"a": []interface{}{int64(1), int64(2), int64(3)}}, false},
{[]byte("b = [\n[1, 2],\n[3, 4]\n]"), map[string]interface{}{"b": []interface{}{[]interface{}{int64(1), int64(2)}, []interface{}{int64(3), int64(4)}}}, false},
// errors
{[]byte("z = [\n[1, 2]\n[3, 4]\n]"), nil, true},
}
for i, c := range cases {
res, err := HandleTOMLMetaData(c.input)
if err != nil {
if c.isErr {
continue
}
t.Fatalf("[%d] unexpected error value: %v", i, err)
}
if !reflect.DeepEqual(res, c.want) {
t.Errorf("[%d] not equal: given %q\nwant %#v,\n got %#v", i, c.input, c.want, res)
}
}
}
func TestHandleYAMLMetaData(t *testing.T) {
cases := []struct {
input []byte
want interface{}
isErr bool
}{
{nil, map[string]interface{}{}, false},
{[]byte("title: test 1"), map[string]interface{}{"title": "test 1"}, false},
{[]byte("a: Easy!\nb:\n c: 2\n d: [3, 4]"), map[string]interface{}{"a": "Easy!", "b": map[string]interface{}{"c": 2, "d": []interface{}{3, 4}}}, false},
{[]byte("a:\n true: 1\n false: 2"), map[string]interface{}{"a": map[string]interface{}{"true": 1, "false": 2}}, false},
// errors
{[]byte("z = not toml"), nil, true},
}
for i, c := range cases {
res, err := HandleYAMLMetaData(c.input)
if err != nil {
if c.isErr {
continue
}
t.Fatalf("[%d] unexpected error value: %v", i, err)
}
if !reflect.DeepEqual(res, c.want) {
t.Errorf("[%d] not equal: given %q\nwant %#v,\n got %#v", i, c.input, c.want, res)
}
}
}
func TestHandleJSONMetaData(t *testing.T) {
cases := []struct {
input []byte
want interface{}
isErr bool
}{
{nil, map[string]interface{}{}, false},
{[]byte("{\"title\": \"test 1\"}"), map[string]interface{}{"title": "test 1"}, false},
// errors
{[]byte("{noquotes}"), nil, true},
}
for i, c := range cases {
res, err := HandleJSONMetaData(c.input)
if err != nil {
if c.isErr {
continue
}
t.Fatalf("[%d] unexpected error value: %v", i, err)
}
if !reflect.DeepEqual(res, c.want) {
t.Errorf("[%d] not equal: given %q\nwant %#v,\n got %#v", i, c.input, c.want, res)
}
}
}
func TestHandleOrgMetaData(t *testing.T) {
cases := []struct {
input []byte
want interface{}
isErr bool
}{
{nil, map[string]interface{}{}, false},
{[]byte("#+title: test 1\n"), map[string]interface{}{"title": "test 1"}, false},
}
for i, c := range cases {
res, err := HandleOrgMetaData(c.input)
if err != nil {
if c.isErr {
continue
}
t.Fatalf("[%d] unexpected error value: %v", i, err)
}
if !reflect.DeepEqual(res, c.want) {
t.Errorf("[%d] not equal: given %q\nwant %#v,\n got %#v", i, c.input, c.want, res)
}
}
}
func TestFormatToLeadRune(t *testing.T) {
for i, this := range []struct {
kind string
@@ -264,41 +154,6 @@ func TestFormatToLeadRune(t *testing.T) {
}
}
func TestDetectFrontMatter(t *testing.T) {
cases := []struct {
mark rune
want *FrontmatterType
}{
// funcs are uncomparable, so we ignore FrontmatterType.Parse in these tests
{'-', &FrontmatterType{nil, []byte(YAMLDelim), []byte(YAMLDelim), false}},
{'+', &FrontmatterType{nil, []byte(TOMLDelim), []byte(TOMLDelim), false}},
{'{', &FrontmatterType{nil, []byte("{"), []byte("}"), true}},
{'#', &FrontmatterType{nil, []byte("#+"), []byte("\n"), false}},
{'$', nil},
}
for _, c := range cases {
res := DetectFrontMatter(c.mark)
if res == nil {
if c.want == nil {
continue
}
t.Fatalf("want %v, got %v", *c.want, res)
}
if !reflect.DeepEqual(res.markstart, c.want.markstart) {
t.Errorf("markstart mismatch: want %v, got %v", c.want.markstart, res.markstart)
}
if !reflect.DeepEqual(res.markend, c.want.markend) {
t.Errorf("markend mismatch: want %v, got %v", c.want.markend, res.markend)
}
if !reflect.DeepEqual(res.includeMark, c.want.includeMark) {
t.Errorf("includeMark mismatch: want %v, got %v", c.want.includeMark, res.includeMark)
}
}
}
func TestRemoveTOMLIdentifier(t *testing.T) {
cases := []struct {
input string
@@ -321,64 +176,6 @@ func TestRemoveTOMLIdentifier(t *testing.T) {
}
}
func TestStringifyYAMLMapKeys(t *testing.T) {
cases := []struct {
input interface{}
want interface{}
replaced bool
}{
{
map[interface{}]interface{}{"a": 1, "b": 2},
map[string]interface{}{"a": 1, "b": 2},
true,
},
{
map[interface{}]interface{}{"a": []interface{}{1, map[interface{}]interface{}{"b": 2}}},
map[string]interface{}{"a": []interface{}{1, map[string]interface{}{"b": 2}}},
true,
},
{
map[interface{}]interface{}{true: 1, "b": false},
map[string]interface{}{"true": 1, "b": false},
true,
},
{
map[interface{}]interface{}{1: "a", 2: "b"},
map[string]interface{}{"1": "a", "2": "b"},
true,
},
{
map[interface{}]interface{}{"a": map[interface{}]interface{}{"b": 1}},
map[string]interface{}{"a": map[string]interface{}{"b": 1}},
true,
},
{
map[string]interface{}{"a": map[string]interface{}{"b": 1}},
map[string]interface{}{"a": map[string]interface{}{"b": 1}},
false,
},
{
[]interface{}{map[interface{}]interface{}{1: "a", 2: "b"}},
[]interface{}{map[string]interface{}{"1": "a", "2": "b"}},
false,
},
}
for i, c := range cases {
res, replaced := stringifyMapKeys(c.input)
if c.replaced != replaced {
t.Fatalf("[%d] Replaced mismatch: %t", i, replaced)
}
if !c.replaced {
res = c.input
}
if !reflect.DeepEqual(res, c.want) {
t.Errorf("[%d] given %q\nwant: %q\n got: %q", i, c.input, c.want, res)
}
}
}
func BenchmarkFrontmatterTags(b *testing.B) {
for _, frontmatter := range []string{"JSON", "YAML", "YAML2", "TOML"} {
@@ -388,69 +185,6 @@ func BenchmarkFrontmatterTags(b *testing.B) {
}
}
func BenchmarkStringifyMapKeysStringsOnlyInterfaceMaps(b *testing.B) {
maps := make([]map[interface{}]interface{}, b.N)
for i := 0; i < b.N; i++ {
maps[i] = map[interface{}]interface{}{
"a": map[interface{}]interface{}{
"b": 32,
"c": 43,
"d": map[interface{}]interface{}{
"b": 32,
"c": 43,
},
},
"b": []interface{}{"a", "b"},
"c": "d",
}
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
stringifyMapKeys(maps[i])
}
}
func BenchmarkStringifyMapKeysStringsOnlyStringMaps(b *testing.B) {
m := map[string]interface{}{
"a": map[string]interface{}{
"b": 32,
"c": 43,
"d": map[string]interface{}{
"b": 32,
"c": 43,
},
},
"b": []interface{}{"a", "b"},
"c": "d",
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
stringifyMapKeys(m)
}
}
func BenchmarkStringifyMapKeysIntegers(b *testing.B) {
maps := make([]map[interface{}]interface{}, b.N)
for i := 0; i < b.N; i++ {
maps[i] = map[interface{}]interface{}{
1: map[interface{}]interface{}{
4: 32,
5: 43,
6: map[interface{}]interface{}{
7: 32,
8: 43,
},
},
2: []interface{}{"a", "b"},
3: "d",
}
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
stringifyMapKeys(maps[i])
}
}
func doBenchmarkFrontmatter(b *testing.B, fileformat string, numTags int) {
yamlTemplate := `---
name: "Tags"