/
pagestate.go
146 lines (123 loc) · 3.1 KB
/
pagestate.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
package entity
import (
"errors"
"fmt"
"github.com/gohugonet/hugoverse/internal/domain/contenthub"
"github.com/gohugonet/hugoverse/internal/domain/contenthub/valueobject"
"github.com/gohugonet/hugoverse/pkg/parser/pageparser"
)
type pageState struct {
// This will be shifted out when we start to render a new output format.
*pageOutput
// Common for all output formats.
*pageCommon
}
func (p *pageState) mapContent(meta *pageMeta) error {
p.cmap = &pageContentMap{
items: make([]any, 0, 20),
}
return p.mapContentForResult(
p.source.parsed,
p.cmap,
meta.markup,
)
}
func (p *pageState) mapContentForResult(result pageparser.Result, rn *pageContentMap, markup string) error {
iter := result.Iterator()
fail := func(err error, i pageparser.Item) error {
return errors.New("fail fail fail")
}
Loop:
for {
it := iter.Next()
switch {
case it.Type == pageparser.TypeIgnore:
case it.IsFrontMatter():
panic("not implemented front matter yet")
case it.Type == pageparser.TypeLeadSummaryDivider:
panic("not implemented lead summary divider yet")
case it.Type == pageparser.TypeEmoji:
panic("not implemented emoji yet")
case it.IsEOF():
break Loop
case it.IsError():
err := fail(errors.New(it.ValStr(result.Input())), it)
return err
default:
rn.AddBytes(it)
}
}
return nil
}
// This is serialized
func (p *pageState) initOutputFormat() error {
if err := p.shiftToOutputFormat(); err != nil {
return err
}
return nil
}
// shiftToOutputFormat is serialized. The output format idx refers to the
// full set of output formats for all sites.
func (p *pageState) shiftToOutputFormat() error {
if err := p.initPage(); err != nil {
return err
}
if p.pageOutput == nil {
panic(fmt.Sprintf("pageOutput is nil for output idx %d", 0))
}
cp := p.pageOutput.cp
if cp == nil {
var err error
cp, err = newPageContentOutput(p)
if err != nil {
return err
}
}
p.pageOutput.initContentProvider(cp)
return nil
}
// Must be run after the site section tree etc. is built and ready.
func (p *pageState) initPage() error {
if _, err := p.init.Do(); err != nil {
return err
}
return nil
}
func (p *pageState) getContentConverter() contenthub.Converter {
var err error
p.m.contentConverterInit.Do(func() {
markup := p.m.markup
if markup == "html" {
// Only used for shortcode inner content.
markup = "markdown"
}
p.m.contentConverter, err = p.m.newContentConverter(p, markup)
})
if err != nil {
fmt.Printf("Failed to create content converter: %v", err)
}
return p.m.contentConverter
}
func (p *pageState) getLayoutDescriptor(tmpl contenthub.TemplateDescriptor) valueobject.LayoutDescriptor {
p.layoutDescriptorInit.Do(func() {
var section string
sections := p.SectionsEntries()
switch p.Kind() {
case contenthub.KindSection:
if len(sections) > 0 {
section = sections[0]
}
default:
}
p.layoutDescriptor = valueobject.LayoutDescriptor{
Kind: p.Kind(),
Type: p.Type(),
Lang: "en",
Layout: p.Layout(),
Section: section,
FormatName: tmpl.Name(),
Extension: tmpl.Extension(),
}
})
return p.layoutDescriptor
}