2020-09-22 23:46:30 +00:00
|
|
|
package main
|
|
|
|
|
|
|
|
import (
|
|
|
|
"io/ioutil"
|
|
|
|
"os"
|
|
|
|
"path/filepath"
|
|
|
|
"regexp"
|
|
|
|
"strings"
|
|
|
|
"text/template"
|
|
|
|
"time"
|
|
|
|
)
|
|
|
|
|
|
|
|
type Site struct {
|
2020-09-23 01:11:56 +00:00
|
|
|
Static map[string][]byte // Static files
|
|
|
|
Directory *Directory // Site directory
|
|
|
|
Templates *template.Template // Templates
|
2020-09-22 23:46:30 +00:00
|
|
|
}
|
|
|
|
|
2020-09-23 01:11:56 +00:00
|
|
|
// LoadSite loads and returns a Site.
|
|
|
|
// It reads site content from the specified source directory.
|
2020-09-22 23:46:30 +00:00
|
|
|
func LoadSite(srcDir string) (*Site, error) {
|
|
|
|
tmpl, err := template.New("templates").ParseGlob("templates/*.gmi")
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
site := &Site{
|
2020-09-23 01:11:56 +00:00
|
|
|
Static: map[string][]byte{},
|
|
|
|
Directory: NewDirectory(""),
|
2020-09-22 23:46:30 +00:00
|
|
|
Templates: tmpl,
|
|
|
|
}
|
|
|
|
|
2020-09-23 01:11:56 +00:00
|
|
|
if err := site.Directory.Read(site, srcDir, ""); err != nil {
|
2020-09-22 23:46:30 +00:00
|
|
|
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
|
|
|
|
}
|
2020-09-23 01:11:56 +00:00
|
|
|
// Create the destination directory
|
2020-09-22 23:46:30 +00:00
|
|
|
if err := os.MkdirAll(dstDir, 0755); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2020-09-23 01:11:56 +00:00
|
|
|
// Write the static files
|
|
|
|
for path := range s.Static {
|
2020-09-22 23:46:30 +00:00
|
|
|
// 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
|
|
|
|
}
|
2020-09-23 01:11:56 +00:00
|
|
|
data := s.Static[path]
|
2020-09-22 23:46:30 +00:00
|
|
|
if _, err := f.Write(data); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
2020-09-23 01:11:56 +00:00
|
|
|
|
|
|
|
// Write the directory
|
|
|
|
return s.Directory.Write(dstDir)
|
2020-09-22 23:46:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Manipulate processes and manipulates the site's content.
|
2020-09-23 01:11:56 +00:00
|
|
|
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")
|
|
|
|
builder := &strings.Builder{}
|
|
|
|
tmpl := s.Templates.Lookup("directory.gmi")
|
|
|
|
if err := tmpl.Execute(builder, dir); err != nil {
|
|
|
|
return err
|
2020-09-22 23:46:30 +00:00
|
|
|
}
|
2020-09-23 01:11:56 +00:00
|
|
|
content := builder.String()
|
|
|
|
permalink := filepath.Dir(path)
|
|
|
|
if permalink == "." {
|
|
|
|
permalink = ""
|
2020-09-22 23:46:30 +00:00
|
|
|
}
|
2020-09-23 01:11:56 +00:00
|
|
|
page := &Page{
|
|
|
|
Path: path,
|
|
|
|
Permalink: "/" + permalink,
|
|
|
|
Content: content,
|
|
|
|
}
|
|
|
|
dir.Index = page
|
|
|
|
}
|
2020-09-22 23:46:30 +00:00
|
|
|
|
2020-09-23 01:11:56 +00:00
|
|
|
// Manipulate pages
|
|
|
|
for i := range dir.Pages {
|
2020-09-22 23:46:30 +00:00
|
|
|
builder := &strings.Builder{}
|
2020-09-23 01:11:56 +00:00
|
|
|
tmpl := s.Templates.Lookup("page.gmi")
|
|
|
|
if err := tmpl.Execute(builder, dir.Pages[i]); err != nil {
|
2020-09-22 23:46:30 +00:00
|
|
|
return err
|
|
|
|
}
|
2020-09-23 01:11:56 +00:00
|
|
|
dir.Pages[i].Content = builder.String()
|
2020-09-22 23:46:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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 string
|
|
|
|
}
|
|
|
|
|
2020-09-23 01:15:03 +00:00
|
|
|
var titleRE = regexp.MustCompile("^# ?([^#\r\n]+)\r?\n?\r?\n?")
|
2020-09-22 23:46:30 +00:00
|
|
|
|
|
|
|
func NewPage(path string, content string) *Page {
|
|
|
|
// Try to parse the date from the page filename
|
2020-09-23 01:11:56 +00:00
|
|
|
var date time.Time
|
2020-09-22 23:46:30 +00:00
|
|
|
const layout = "2006-01-02"
|
|
|
|
base := filepath.Base(path)
|
|
|
|
if len(base) >= len(layout) {
|
|
|
|
dateStr := base[:len(layout)]
|
2020-09-23 01:11:56 +00:00
|
|
|
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)
|
|
|
|
}
|
2020-09-22 23:46:30 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Try to parse the title from the contents
|
2020-09-23 01:11:56 +00:00
|
|
|
var title string
|
2020-09-22 23:46:30 +00:00
|
|
|
if submatches := titleRE.FindStringSubmatch(content); submatches != nil {
|
2020-09-23 01:11:56 +00:00
|
|
|
title = submatches[1]
|
|
|
|
// Remove the title from the contents
|
|
|
|
content = content[len(submatches[0]):]
|
2020-09-22 23:46:30 +00:00
|
|
|
}
|
|
|
|
|
2020-09-23 01:11:56 +00:00
|
|
|
return &Page{
|
|
|
|
Path: path,
|
|
|
|
Permalink: "/" + path,
|
|
|
|
Title: title,
|
|
|
|
Date: date,
|
|
|
|
Content: content,
|
|
|
|
}
|
2020-09-22 23:46:30 +00:00
|
|
|
}
|
|
|
|
|
2020-09-23 01:11:56 +00:00
|
|
|
// Directory represents a directory of pages.
|
|
|
|
type Directory struct {
|
|
|
|
// The path to this directory.
|
2020-09-22 23:46:30 +00:00
|
|
|
Path string
|
2020-09-23 01:11:56 +00:00
|
|
|
// The permalink to this directory.
|
2020-09-22 23:46:30 +00:00
|
|
|
Permalink string
|
2020-09-23 01:11:56 +00:00
|
|
|
// The pages in this directory.
|
2020-09-22 23:46:30 +00:00
|
|
|
Pages []*Page
|
2020-09-23 01:11:56 +00:00
|
|
|
// The subdirectories of this directory.
|
|
|
|
Directories []*Directory
|
|
|
|
// The index file (index.gmi).
|
|
|
|
Index *Page
|
2020-09-22 23:46:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// NewSection returns a new Section with the given path.
|
2020-09-23 01:11:56 +00:00
|
|
|
func NewDirectory(path string) *Directory {
|
2020-09-22 23:46:30 +00:00
|
|
|
var permalink string
|
|
|
|
if path == "" {
|
|
|
|
permalink = "/"
|
|
|
|
} else {
|
|
|
|
permalink = "/" + path + "/"
|
|
|
|
}
|
2020-09-23 01:11:56 +00:00
|
|
|
return &Directory{
|
2020-09-22 23:46:30 +00:00
|
|
|
Path: path,
|
|
|
|
Permalink: permalink,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-09-23 01:11:56 +00:00
|
|
|
// 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
|
|
|
|
content := string(content)
|
|
|
|
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) 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 {
|
|
|
|
dstPath := filepath.Join(dstDir, page.Path)
|
|
|
|
f, err := os.Create(dstPath)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
data := []byte(page.Content)
|
|
|
|
if _, err := f.Write(data); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Write the index file
|
|
|
|
if d.Index != nil {
|
|
|
|
dstPath := filepath.Join(dstDir, d.Index.Path)
|
|
|
|
f, err := os.Create(dstPath)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
data := []byte(d.Index.Content)
|
|
|
|
if _, err := f.Write(data); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Write subdirectories
|
|
|
|
for _, dir := range d.Directories {
|
|
|
|
dir.Write(dstDir)
|
|
|
|
}
|
|
|
|
return nil
|
2020-09-22 23:46:30 +00:00
|
|
|
}
|