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
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
|
// page implements the website backed by a local filesystem.
//
// Reading the base template off the disk, then any markdown files which are
// split into two sections by the DocumentSplit global variable. The first
// section is parsed as yaml to populate the Page struct. The second portion is
// markdown, first executed as part of the text/template then rendered by
// blackfriday.
//
// Usage:
//
// import (
// "fmt"
// "os"
// site "riedstra.dev/mitch/go-website/page"
// )
// // Where some/path.md exists
// p := site.NewPage("/some/path")
// // Dump the rendered HTML to stdout
// err := p.Render(os.Stdout)
// if err != nil {
// fmt.Fprintln(os.Stderr, err)
// }
package page
import (
"bufio"
"bytes"
"fmt"
"io"
"log"
"os"
"path/filepath"
"text/template"
"github.com/russross/blackfriday"
"gopkg.in/yaml.v3"
)
// Page should not be created directly as it will not set the interal path
// properly. Use NewPage instead.
//
// The exported fields can be filled in the yaml at the top of a page and
// utilized within.
type Page struct {
path string
Title string
Description string
AuthorName string
AuthorEmail string
// Tags to apply to the page in question. Useful for Index()
Tags map[string]interface{}
Date *PageTime
Published bool
Vars map[string]interface{}
markdown []byte
}
// Global is meant to be supplied by external users of this package to populate
// globally accessable information across all of the templates accessiable via
// .Global care must be taken when utilizing this functionality
var Global interface{}
// CacheIndex determines whether or not the index will be cached in memory
// or rebuilt on each call
var CacheIndex = true
// BaseTemplate can be adjusted to change the base template used in rendering
var BaseTemplate = "inc/base.html"
// Suffix is applied to all pages for reading off of the disk
var Suffix = ".md"
// DocumentSplit is used to split the .md files into yaml and markdown
var DocumentSplit = "|---\n"
// Default logger
var Logger = log.New(os.Stderr, "", log.LstdFlags)
// NewPage returns a page struct with the path populated
func NewPage(pth string) *Page {
return &Page{path: filepath.FromSlash(filepath.Clean(pth))}
}
// NewPage Allow for the creation of a new page from the current page, does
// not inlcude any information about the current page.
func (p Page) NewPage(pth string) *Page {
return NewPage(pth)
}
// Path gets the current path set on the struct for the page in question
// Useful if you're say iterating across tags to print out a list of
// relevant posts on a blog or so by topic.
func (p Page) Path() string {
return filepath.ToSlash(p.path)
}
// Global is specifically for use inside of a page markdown file or
// in a base template. This simply returns the package Global variable
func (p *Page) Global() interface{} {
return Global
}
// Renders a page
func (p *Page) Render(wr io.Writer) error {
if err := p.Read(); err != nil {
return err
}
t, err := template.ParseFiles(BaseTemplate)
if err != nil {
return err
}
return t.Execute(wr, p)
}
// Reads in the special markdown file format for the website off of the disk
func (p *Page) Read() error {
yamlBuf := bytes.NewBuffer(nil)
markdownBuf := bytes.NewBuffer(nil)
fh, err := os.Open(p.path + Suffix)
if err != nil {
return err
}
defer fh.Close()
rdr := bufio.NewReader(fh)
// Read in the file and split between markdown and yaml buffers
yamlDone := false
for {
bytes, err := rdr.ReadBytes('\n')
if err == io.EOF {
break
} else if err != nil {
return err
}
// Is this the line where we stop reading the yaml and start reading markdown?
if DocumentSplit == string(bytes) && !yamlDone {
yamlDone = true
continue
}
if !yamlDone {
yamlBuf.Write(bytes)
} else {
markdownBuf.Write(bytes)
}
}
err = yaml.Unmarshal(yamlBuf.Bytes(), p)
if err != nil {
return err
}
p.markdown = markdownBuf.Bytes()
return nil
}
func (p *Page) RenderBody() (string, error) {
buf := &bytes.Buffer{}
t, err := template.New("Body").Parse(string(p.markdown))
if err != nil {
return "", err
}
err = t.Execute(buf, p)
if err != nil {
return "", err
}
return string(blackfriday.Run(buf.Bytes())), nil
}
func (p Page) String() string {
return fmt.Sprintf("Page: %s", p.path)
}
|
