mirror of
https://git.sr.ht/~adnano/kiln
synced 2024-10-30 01:13:08 +00:00
316 lines
6.9 KiB
Go
316 lines
6.9 KiB
Go
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"io/ioutil"
|
|
"os"
|
|
"path/filepath"
|
|
"regexp"
|
|
"strings"
|
|
"text/template"
|
|
"time"
|
|
)
|
|
|
|
// Site represents a kiln site.
|
|
type Site struct {
|
|
Static map[string][]byte // Static files
|
|
Directory *Directory // Site directory
|
|
Templates *template.Template // Templates
|
|
}
|
|
|
|
// LoadSite loads and returns a Site.
|
|
// It reads site content from the specified source directory.
|
|
func LoadSite(srcDir string) (*Site, error) {
|
|
tmpl, err := template.New("templates").ParseGlob("templates/*.gmi")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
site := &Site{
|
|
Static: map[string][]byte{},
|
|
Directory: NewDirectory(""),
|
|
Templates: tmpl,
|
|
}
|
|
|
|
if err := site.Directory.Read(site, srcDir, ""); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return site, nil
|
|
}
|
|
|
|
// Write writes the contents of the Index to the provided destination directory.
|
|
func (s *Site) Write(dstDir string) error {
|
|
// Empty the destination directory
|
|
if err := os.RemoveAll(dstDir); err != nil {
|
|
return err
|
|
}
|
|
// Create the destination directory
|
|
if err := os.MkdirAll(dstDir, 0755); err != nil {
|
|
return err
|
|
}
|
|
|
|
// Write the static files
|
|
for path := range s.Static {
|
|
// Create any parent directories
|
|
if dir := filepath.Dir(path); dir != "." {
|
|
dstPath := filepath.Join(dstDir, dir)
|
|
if err := os.MkdirAll(dstPath, 0755); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
// Write the file
|
|
dstPath := filepath.Join(dstDir, path)
|
|
f, err := os.Create(dstPath)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
data := s.Static[path]
|
|
if _, err := f.Write(data); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
// Write the directory
|
|
return s.Directory.Write(dstDir, OutputGemini)
|
|
}
|
|
|
|
// Manipulate processes and manipulates the site's content.
|
|
func (s *Site) Manipulate(dir *Directory) error {
|
|
// Write the directory index file, if it doesn't exist
|
|
if dir.Index == nil {
|
|
path := filepath.Join(dir.Path, "index.gmi")
|
|
var b bytes.Buffer
|
|
tmpl := s.Templates.Lookup("index.gmi")
|
|
if tmpl != nil {
|
|
if err := tmpl.Execute(&b, dir); err != nil {
|
|
return err
|
|
}
|
|
content := b.Bytes()
|
|
permalink := filepath.Dir(path)
|
|
if permalink == "." {
|
|
permalink = ""
|
|
}
|
|
page := &Page{
|
|
Path: path,
|
|
Permalink: "/" + permalink,
|
|
content: content,
|
|
}
|
|
dir.Index = page
|
|
}
|
|
}
|
|
|
|
// Manipulate pages
|
|
for i := range dir.Pages {
|
|
var b bytes.Buffer
|
|
tmpl := s.Templates.Lookup("page.gmi")
|
|
if err := tmpl.Execute(&b, dir.Pages[i]); err != nil {
|
|
return err
|
|
}
|
|
dir.Pages[i].content = b.Bytes()
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// Page represents a page.
|
|
type Page struct {
|
|
// The path to this page.
|
|
Path string
|
|
// The permalink to this page.
|
|
Permalink string
|
|
// The title of this page, parsed from the Gemini contents.
|
|
Title string
|
|
// The date of the page. Dates are specified in the filename.
|
|
// Ex: 2020-09-22-hello-world.gmi
|
|
Date time.Time
|
|
// The content of this page.
|
|
content []byte
|
|
}
|
|
|
|
func (p *Page) Content() string {
|
|
return string(p.content)
|
|
}
|
|
|
|
var titleRE = regexp.MustCompile("^# ?([^#\r\n]+)\r?\n?\r?\n?")
|
|
|
|
// NewPage returns a new Page with the given path and content.
|
|
func NewPage(path string, content []byte) *Page {
|
|
// Try to parse the date from the page filename
|
|
var date time.Time
|
|
const layout = "2006-01-02"
|
|
base := filepath.Base(path)
|
|
if len(base) >= len(layout) {
|
|
dateStr := base[:len(layout)]
|
|
if time, err := time.Parse(layout, dateStr); err == nil {
|
|
date = time
|
|
}
|
|
// Remove the date from the path
|
|
base = base[len(layout):]
|
|
if len(base) > 0 {
|
|
// Remove a leading dash
|
|
if base[0] == '-' {
|
|
base = base[1:]
|
|
}
|
|
if len(base) > 0 {
|
|
dir := filepath.Dir(path)
|
|
if dir == "." {
|
|
dir = ""
|
|
}
|
|
path = filepath.Join(dir, base)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Try to parse the title from the contents
|
|
var title string
|
|
if submatches := titleRE.FindSubmatch(content); submatches != nil {
|
|
title = string(submatches[1])
|
|
// Remove the title from the contents
|
|
content = content[len(submatches[0]):]
|
|
}
|
|
|
|
permalink := strings.TrimSuffix(path, ".gmi")
|
|
|
|
return &Page{
|
|
Path: path,
|
|
Permalink: "/" + permalink + "/",
|
|
Title: title,
|
|
Date: date,
|
|
content: content,
|
|
}
|
|
}
|
|
|
|
// Directory represents a directory of pages.
|
|
type Directory struct {
|
|
// The path to this directory.
|
|
Path string
|
|
// The permalink to this directory.
|
|
Permalink string
|
|
// The pages in this directory.
|
|
Pages []*Page
|
|
// The subdirectories of this directory.
|
|
Directories []*Directory
|
|
// The index file (index.gmi).
|
|
Index *Page
|
|
}
|
|
|
|
// NewDirectory returns a new Directory with the given path.
|
|
func NewDirectory(path string) *Directory {
|
|
var permalink string
|
|
if path == "" {
|
|
permalink = "/"
|
|
} else {
|
|
permalink = "/" + path + "/"
|
|
}
|
|
return &Directory{
|
|
Path: path,
|
|
Permalink: permalink,
|
|
}
|
|
}
|
|
|
|
// Read reads from a directory and indexes the files and directories within it.
|
|
func (d *Directory) Read(site *Site, srcDir string, path string) error {
|
|
entries, err := ioutil.ReadDir(srcDir)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
for _, entry := range entries {
|
|
name := entry.Name()
|
|
path := filepath.Join(path, name)
|
|
srcPath := filepath.Join(srcDir, path)
|
|
|
|
if entry.IsDir() {
|
|
// Gather directory data
|
|
dir := NewDirectory(path)
|
|
dir.Read(site, srcPath, path)
|
|
d.Directories = append(d.Directories, dir)
|
|
} else {
|
|
content, err := ioutil.ReadFile(srcPath)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
switch filepath.Ext(name) {
|
|
case ".gmi", ".gemini":
|
|
// Gather page data
|
|
page := NewPage(path, content)
|
|
|
|
if name == "index.gmi" {
|
|
d.Index = page
|
|
} else {
|
|
d.Pages = append(d.Pages, page)
|
|
}
|
|
|
|
default:
|
|
// Static file
|
|
site.Static[path] = content
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Write writes the Directory to the provided destination path.
|
|
func (d *Directory) Write(dstDir string, format OutputFormat) error {
|
|
// Create the directory
|
|
dirPath := filepath.Join(dstDir, d.Path)
|
|
if err := os.MkdirAll(dirPath, 0755); err != nil {
|
|
return err
|
|
}
|
|
|
|
// Write the files
|
|
for _, page := range d.Pages {
|
|
path, content := format(page)
|
|
dstPath := filepath.Join(dstDir, path)
|
|
dir := filepath.Dir(dstPath)
|
|
os.MkdirAll(dir, 0755)
|
|
f, err := os.Create(dstPath)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if _, err := f.Write(content); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
// Write the index file
|
|
if d.Index != nil {
|
|
path, content := format(d.Index)
|
|
dstPath := filepath.Join(dstDir, path)
|
|
f, err := os.Create(dstPath)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if _, err := f.Write(content); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
// Write subdirectories
|
|
for _, dir := range d.Directories {
|
|
dir.Write(dstDir, format)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// OutputFormat represents an output format.
|
|
type OutputFormat func(*Page) (path string, content []byte)
|
|
|
|
func OutputGemini(p *Page) (path string, content []byte) {
|
|
const indexPath = "index.gmi"
|
|
path = filepath.Join(p.Permalink, indexPath)
|
|
content = p.content
|
|
return
|
|
}
|
|
|
|
func OutputHTML(p *Page) (path string, content []byte) {
|
|
const indexPath = "index.html"
|
|
path = filepath.Join(p.Permalink, indexPath)
|
|
r := bytes.NewReader(p.content)
|
|
content = GeminiToHTML(r)
|
|
return
|
|
}
|