463 lines
11 KiB
Go
463 lines
11 KiB
Go
package sitebuilder
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"fmt"
|
|
"html/template"
|
|
"io"
|
|
"iter"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/PuerkitoBio/goquery"
|
|
"github.com/gopherlibs/feedhub/feedhub"
|
|
"golang.org/x/sync/errgroup"
|
|
"lmika.dev/lmika/weiro/models"
|
|
"lmika.dev/lmika/weiro/models/pubmodel"
|
|
"lmika.dev/lmika/weiro/providers/markdown"
|
|
)
|
|
|
|
type Builder struct {
|
|
site pubmodel.Site
|
|
mdRenderer *markdown.Renderer
|
|
opts Options
|
|
tmpls *template.Template
|
|
postMDProcessors []postMDProcessor
|
|
}
|
|
|
|
func New(site pubmodel.Site, opts Options) (*Builder, error) {
|
|
tmpls, err := template.New("").
|
|
Funcs(templateFns(site, opts)).
|
|
ParseFS(opts.TemplatesFS, tmplNamePostSingle, tmplNamePostList, tmplNameLayoutMain, tmplNameCategoryList, tmplNameCategorySingle)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &Builder{
|
|
site: site,
|
|
opts: opts,
|
|
tmpls: tmpls,
|
|
mdRenderer: markdown.NewRendererForSite(),
|
|
postMDProcessors: []postMDProcessor{
|
|
uploadAbsoluteURL,
|
|
},
|
|
}, nil
|
|
}
|
|
|
|
func (b *Builder) BuildSite(outDir string) error {
|
|
buildCtx := buildContext{outDir: outDir}
|
|
|
|
if err := os.RemoveAll(outDir); err != nil {
|
|
return err
|
|
}
|
|
|
|
eg, ctx := errgroup.WithContext(context.Background())
|
|
|
|
eg.Go(func() error {
|
|
for mp := range b.site.PostIter(ctx) {
|
|
post, err := mp.Get()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
rp, err := b.renderPostWithCategories(ctx, post)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := b.createAtPath(buildCtx, rp.Path, func(f io.Writer) error {
|
|
return b.renderTemplate(f, tmplNamePostSingle, rp)
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
})
|
|
|
|
eg.Go(func() error {
|
|
return b.renderPostListWithCategories(buildCtx, ctx)
|
|
})
|
|
|
|
eg.Go(func() error {
|
|
if err := b.renderFeeds(buildCtx, b.site.PostIter(ctx), feedOptions{
|
|
targetNamePrefix: "/feed",
|
|
titlePrefix: "",
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := b.renderFeeds(buildCtx, b.site.PostIter(ctx), feedOptions{
|
|
targetNamePrefix: "/feeds/microblog-crosspost",
|
|
titlePrefix: "Devlog: ",
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
})
|
|
|
|
// Category pages
|
|
eg.Go(func() error {
|
|
if err := b.renderCategoryList(buildCtx); err != nil {
|
|
return err
|
|
}
|
|
return b.renderCategoryPages(buildCtx, ctx)
|
|
})
|
|
|
|
// Copy uploads
|
|
eg.Go(func() error {
|
|
return b.writeUploads(buildCtx, b.site.Uploads)
|
|
})
|
|
|
|
return eg.Wait()
|
|
}
|
|
|
|
func (b *Builder) renderPostListWithCategories(bctx buildContext, ctx context.Context) error {
|
|
var posts []postSingleData
|
|
for mp := range b.site.PostIter(ctx) {
|
|
post, err := mp.Get()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
rp, err := b.renderPostWithCategories(ctx, post)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
posts = append(posts, rp)
|
|
}
|
|
|
|
pl := postListData{
|
|
commonData: commonData{Site: b.site},
|
|
Posts: posts,
|
|
}
|
|
|
|
return b.createAtPath(bctx, "", func(f io.Writer) error {
|
|
return b.renderTemplate(f, tmplNamePostList, pl)
|
|
})
|
|
}
|
|
|
|
func (b *Builder) renderFeeds(ctx buildContext, postIter iter.Seq[models.Maybe[*models.Post]], opts feedOptions) error {
|
|
now := time.Now()
|
|
feed := &feedhub.Feed{
|
|
Title: b.site.Title,
|
|
Link: &feedhub.Link{Href: b.site.BaseURL},
|
|
Description: b.site.Tagline,
|
|
// TO FIX: Author
|
|
Created: now,
|
|
}
|
|
|
|
items := 0
|
|
for mp := range postIter {
|
|
post, err := mp.Get()
|
|
if err != nil {
|
|
return fmt.Errorf("failed to get post: %w", err)
|
|
}
|
|
|
|
renderedPost, err := b.renderPost(post)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var catName string
|
|
if b.site.CategoriesOfPost != nil {
|
|
cats, err := b.site.CategoriesOfPost(context.Background(), post.ID)
|
|
if err == nil && len(cats) > 0 {
|
|
names := make([]string, len(cats))
|
|
for i, c := range cats {
|
|
names[i] = c.Name
|
|
}
|
|
catName = strings.Join(names, ", ")
|
|
}
|
|
}
|
|
|
|
postTitle := post.Title
|
|
if postTitle != "" {
|
|
postTitle = opts.titlePrefix + postTitle
|
|
}
|
|
|
|
feed.Items = append(feed.Items, &feedhub.Item{
|
|
Id: filepath.Join(b.site.BaseURL, post.GUID),
|
|
Title: postTitle,
|
|
Link: &feedhub.Link{Href: renderedPost.PostURL},
|
|
Content: string(renderedPost.HTML),
|
|
// TO FIX: Why the heck does this only include the first category?
|
|
Category: catName,
|
|
// TO FIX: Created should be first published
|
|
Created: post.PublishedAt,
|
|
Updated: post.UpdatedAt,
|
|
})
|
|
|
|
items++
|
|
if items >= b.opts.FeedItems {
|
|
break
|
|
}
|
|
}
|
|
|
|
if err := b.createAtPath(ctx, opts.targetNamePrefix+".xml", func(f io.Writer) error {
|
|
rss, err := feed.ToRss()
|
|
if err != nil {
|
|
return fmt.Errorf("failed to convert feed to RSS: %w", err)
|
|
}
|
|
_, err = io.WriteString(f, rss)
|
|
return err
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := b.createAtPath(ctx, opts.targetNamePrefix+".json", func(f io.Writer) error {
|
|
rss, err := feed.ToJSON()
|
|
if err != nil {
|
|
return fmt.Errorf("failed to convert feed to JSON feed: %w", err)
|
|
}
|
|
_, err = io.WriteString(f, rss)
|
|
return err
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (b *Builder) renderPost(post *models.Post) (postSingleData, error) {
|
|
postPath := post.Slug
|
|
if b.opts.BasePosts != "" {
|
|
postPath = filepath.Join(b.opts.BasePosts, strings.TrimPrefix(postPath, "/"))
|
|
}
|
|
|
|
var md bytes.Buffer
|
|
if err := b.mdRenderer.RenderTo(context.Background(), &md, post.Body); err != nil {
|
|
return postSingleData{}, fmt.Errorf("failed to write post %s: %w", post.Slug, err)
|
|
}
|
|
|
|
if len(b.postMDProcessors) > 0 {
|
|
dom, err := goquery.NewDocumentFromReader(&md)
|
|
if err != nil {
|
|
return postSingleData{}, fmt.Errorf("failed to parse post %s: %w", post.Slug, err)
|
|
}
|
|
|
|
for _, processor := range b.postMDProcessors {
|
|
if err := processor(b.site, dom); err != nil {
|
|
return postSingleData{}, fmt.Errorf("failed to process post %s: %w", post.Slug, err)
|
|
}
|
|
}
|
|
|
|
outHTML, err := dom.Find("body").Html()
|
|
if err != nil {
|
|
return postSingleData{}, fmt.Errorf("failed to render post %s: %w", post.Slug, err)
|
|
}
|
|
md.Reset()
|
|
md.WriteString(outHTML)
|
|
}
|
|
|
|
postURL := strings.TrimSuffix(b.site.BaseURL, "/") + "/" + strings.TrimPrefix(postPath, "/")
|
|
|
|
return postSingleData{
|
|
commonData: commonData{Site: b.site},
|
|
Path: postPath,
|
|
Post: post,
|
|
PostURL: postURL,
|
|
HTML: template.HTML(md.String()),
|
|
}, nil
|
|
}
|
|
|
|
// renderPostWithCategories renders a post and attaches its categories.
|
|
func (b *Builder) renderPostWithCategories(ctx context.Context, post *models.Post) (postSingleData, error) {
|
|
rp, err := b.renderPost(post)
|
|
if err != nil {
|
|
return postSingleData{}, err
|
|
}
|
|
|
|
if b.site.CategoriesOfPost != nil {
|
|
cats, err := b.site.CategoriesOfPost(ctx, post.ID)
|
|
if err != nil {
|
|
return postSingleData{}, err
|
|
}
|
|
rp.Categories = cats
|
|
}
|
|
|
|
return rp, nil
|
|
}
|
|
|
|
func (b *Builder) renderCategoryList(ctx buildContext) error {
|
|
var items []categoryListItem
|
|
for _, cwc := range b.site.Categories {
|
|
if cwc.PostCount == 0 {
|
|
continue
|
|
}
|
|
items = append(items, categoryListItem{
|
|
CategoryWithCount: cwc,
|
|
Path: fmt.Sprintf("/categories/%s", cwc.Slug),
|
|
})
|
|
}
|
|
|
|
if len(items) == 0 {
|
|
return nil
|
|
}
|
|
|
|
data := categoryListData{
|
|
commonData: commonData{Site: b.site},
|
|
Categories: items,
|
|
}
|
|
|
|
return b.createAtPath(ctx, "/categories", func(f io.Writer) error {
|
|
return b.renderTemplate(f, tmplNameCategoryList, data)
|
|
})
|
|
}
|
|
|
|
func (b *Builder) renderCategoryPages(ctx buildContext, goCtx context.Context) error {
|
|
for _, cwc := range b.site.Categories {
|
|
if cwc.PostCount == 0 {
|
|
continue
|
|
}
|
|
|
|
var posts []postSingleData
|
|
for mp := range b.site.PostIterByCategory(goCtx, cwc.ID) {
|
|
post, err := mp.Get()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
rp, err := b.renderPostWithCategories(goCtx, post)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
posts = append(posts, rp)
|
|
}
|
|
|
|
var descHTML bytes.Buffer
|
|
if cwc.Description != "" {
|
|
if err := b.mdRenderer.RenderTo(goCtx, &descHTML, cwc.Description); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
data := categorySingleData{
|
|
commonData: commonData{Site: b.site},
|
|
Category: &cwc.Category,
|
|
DescriptionHTML: template.HTML(descHTML.String()),
|
|
Posts: posts,
|
|
Path: fmt.Sprintf("/categories/%s", cwc.Slug),
|
|
}
|
|
|
|
if err := b.createAtPath(ctx, data.Path, func(f io.Writer) error {
|
|
return b.renderTemplate(f, tmplNameCategorySingle, data)
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
|
|
// Per-category feeds
|
|
if err := b.renderCategoryFeed(ctx, cwc, posts); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (b *Builder) renderCategoryFeed(ctx buildContext, cwc models.CategoryWithCount, posts []postSingleData) error {
|
|
now := time.Now()
|
|
feed := &feedhub.Feed{
|
|
Title: b.site.Title + " - " + cwc.Name,
|
|
Link: &feedhub.Link{Href: b.site.BaseURL},
|
|
Description: cwc.DescriptionBrief,
|
|
Created: now,
|
|
}
|
|
|
|
for i, rp := range posts {
|
|
if i >= b.opts.FeedItems {
|
|
break
|
|
}
|
|
feed.Items = append(feed.Items, &feedhub.Item{
|
|
Id: filepath.Join(b.site.BaseURL, rp.Post.GUID),
|
|
Title: rp.Post.Title,
|
|
Link: &feedhub.Link{Href: rp.PostURL},
|
|
Content: string(rp.HTML),
|
|
Created: rp.Post.PublishedAt,
|
|
Updated: rp.Post.UpdatedAt,
|
|
})
|
|
}
|
|
|
|
prefix := fmt.Sprintf("/categories/%s/feed", cwc.Slug)
|
|
|
|
if err := b.createAtPath(ctx, prefix+".xml", func(f io.Writer) error {
|
|
rss, err := feed.ToRss()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, err = io.WriteString(f, rss)
|
|
return err
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
|
|
return b.createAtPath(ctx, prefix+".json", func(f io.Writer) error {
|
|
j, err := feed.ToJSON()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, err = io.WriteString(f, j)
|
|
return err
|
|
})
|
|
}
|
|
|
|
func (b *Builder) createAtPath(ctx buildContext, path string, fn func(f io.Writer) error) error {
|
|
outFile := filepath.Join(ctx.outDir, strings.TrimPrefix(path, "/"))
|
|
if filepath.Ext(outFile) == "" {
|
|
outFile = filepath.Join(outFile, "index.html")
|
|
}
|
|
|
|
// Render it within the template
|
|
if err := os.MkdirAll(filepath.Dir(outFile), 0755); err != nil {
|
|
return err
|
|
}
|
|
|
|
f, err := os.Create(outFile)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer f.Close()
|
|
|
|
return fn(f)
|
|
}
|
|
|
|
func (b *Builder) renderTemplate(w io.Writer, name string, data interface{}) error {
|
|
var buf bytes.Buffer
|
|
if err := b.tmpls.ExecuteTemplate(&buf, name, data); err != nil {
|
|
return err
|
|
}
|
|
|
|
return b.tmpls.ExecuteTemplate(w, tmplNameLayoutMain, layoutData{
|
|
commonData: commonData{Site: b.site},
|
|
Body: template.HTML(buf.String()),
|
|
})
|
|
}
|
|
|
|
func (b *Builder) writeUploads(ctx buildContext, uploads []models.Upload) error {
|
|
for _, u := range uploads {
|
|
fullPath := filepath.Join(ctx.outDir, "uploads", u.Slug)
|
|
if err := os.MkdirAll(filepath.Dir(fullPath), 0755); err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := func() error {
|
|
r, err := b.site.OpenUpload(u)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer r.Close()
|
|
|
|
w, err := os.Create(fullPath)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer w.Close()
|
|
|
|
if _, err := io.Copy(w, r); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|