use encoding/xml for atom feeds

2 files changed, 27 insertions, 65 deletions

diff --git a/internal/builder/builder.go b/internal/builder/builder.go
index b6da17d..63a9999 100644
--- a/internal/builder/builder.go
+++ b/internal/builder/builder.go
@@ -175,7 +175,6 @@ func build(ioConfig *IOConfig, config *config.Config, log *log.Logger) (*Result,
 
 		log.Debug("rendering tags feed", "tag", tag)
 		feed, err := renderFeed(
-			ioConfig.Source,
 			fmt.Sprintf("%s - %s", config.Title, tag),
 			config,
 			matchingPosts,
@@ -184,7 +183,7 @@ func build(ioConfig *IOConfig, config *config.Config, log *log.Logger) (*Result,
 		if err != nil {
 			return nil, errors.WithMessage(err, "could not render tag feed page")
 		}
-		if err := outputToFile(feed, outDir, "tags", tag, "atom.xml"); err != nil {
+		if err := writerToFile(feed, outDir, "tags", tag, "atom.xml"); err != nil {
 			return nil, err
 		}
 	}
@@ -196,11 +195,11 @@ func build(ioConfig *IOConfig, config *config.Config, log *log.Logger) (*Result,
 	sitemap.AddPath("/post/", lastMod)
 
 	log.Debug("rendering feed")
-	feed, err := renderFeed(ioConfig.Source, config.Title, config, posts, "feed")
+	feed, err := renderFeed(config.Title, config, posts, "feed")
 	if err != nil {
 		return nil, errors.WithMessage(err, "could not render feed")
 	}
-	if err := outputToFile(feed, outDir, "atom.xml"); err != nil {
+	if err := writerToFile(feed, outDir, "atom.xml"); err != nil {
 		return nil, err
 	}
 
diff --git a/internal/builder/template.go b/internal/builder/template.go
index 957ea60..9f019df 100644
--- a/internal/builder/template.go
+++ b/internal/builder/template.go
@@ -1,6 +1,7 @@
 package builder
 
 import (
+	"bytes"
 	"encoding/xml"
 	"io"
 	"os"
@@ -19,9 +20,8 @@ import (
 )
 
 var (
-	css           string
-	templateFiles = make(map[string]*os.File)
-	nsMap         = map[string]string{
+	css   string
+	nsMap = map[string]string{
 		"xsl":   "http://www.w3.org/1999/XSL/Transform",
 		"atom":  "http://www.w3.org/2005/Atom",
 		"xhtml": "http://www.w3.org/1999/xhtml",
@@ -36,19 +36,6 @@ func loadCSS(source string) {
 	css = string(bytes)
 }
 
-func loadTemplate(path string) (file *os.File, err error) {
-	if templateFiles[path] == nil {
-		file, err = os.OpenFile(path, os.O_RDONLY, 0)
-		if err != nil {
-			return nil, errors.Wrapf(err, "could not load template at path %s", path)
-		}
-		templateFiles[path] = file
-	}
-	file = templateFiles[path]
-
-	return
-}
-
 type QuerySelection struct {
 	*goquery.Selection
 }
@@ -87,43 +74,31 @@ func renderRobotsTXT(source string, config *config.Config) (io.Reader, error) {
 }
 
 func renderFeed(
-	source string,
 	title string,
 	config *config.Config,
 	posts []content.Post,
 	specific string,
-) (io.Reader, error) {
-	reader, err := loadTemplate(filepath.Join(source, "templates/feed.xml"))
+) (io.WriterTo, error) {
+	buf := &bytes.Buffer{}
+	datetime := posts[0].Date.UTC()
+
+	buf.WriteString(xml.Header)
+	err := atom.LinkXSL(buf, "/feed-styles.xsl")
 	if err != nil {
 		return nil, err
 	}
-	defer func() {
-		_, err := reader.Seek(0, io.SeekStart)
-		if err != nil {
-			panic("could not reset reader: " + err.Error())
-		}
-	}()
-	doc, err := xmlquery.Parse(reader)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not parse XML")
-	}
-	feed := doc.SelectElement("feed")
-	feed.SelectElement("title").FirstChild.Data = title
-	feed.SelectElement("link").SetAttr("href", config.BaseURL.String())
-	feed.SelectElement("id").FirstChild.Data = atom.MakeTagURI(config, specific)
-	datetime, err := posts[0].Date.UTC().MarshalText()
-	if err != nil {
-		return nil, errors.Wrap(err, "could not convert post date to text")
+	feed := &atom.Feed{
+		Title:   title,
+		Link:    atom.MakeLink(config.BaseURL.URL),
+		ID:      atom.MakeTagURI(config, specific),
+		Updated: datetime,
+		Entries: make([]*atom.FeedEntry, len(posts)),
 	}
-	feed.SelectElement("updated").FirstChild.Data = string(datetime)
-	tpl := feed.SelectElement("entry")
-	xmlquery.RemoveFromTree(tpl)
 
-	for _, post := range posts {
-		fullURL := config.BaseURL.JoinPath(post.URL).String()
-		text, err := xml.MarshalIndent(&atom.FeedEntry{
+	for i, post := range posts {
+		feed.Entries[i] = &atom.FeedEntry{
 			Title:   post.Title,
-			Link:    atom.MakeLink(fullURL),
+			Link:    atom.MakeLink(config.BaseURL.JoinPath(post.URL)),
 			ID:      atom.MakeTagURI(config, post.Basename),
 			Updated: post.Date.UTC(),
 			Summary: post.Description,
@@ -132,27 +107,15 @@ func renderFeed(
 				Content: post.Content,
 				Type:    "html",
 			},
-		}, "  ", "    ")
-		if err != nil {
-			return nil, errors.Wrap(err, "could not marshal xml")
-		}
-		entry, err := xmlquery.ParseWithOptions(
-			strings.NewReader(string(text)),
-			xmlquery.ParserOptions{
-				Decoder: &xmlquery.DecoderOptions{
-					Strict:    false,
-					AutoClose: xml.HTMLAutoClose,
-					Entity:    xml.HTMLEntity,
-				},
-			},
-		)
-		if err != nil {
-			return nil, errors.Wrap(err, "could not parse XML")
 		}
-		xmlquery.AddChild(feed, entry.SelectElement("entry"))
+	}
+	enc := xml.NewEncoder(buf)
+	err = enc.Encode(feed)
+	if err != nil {
+		return nil, err
 	}
 
-	return strings.NewReader(doc.OutputXML(true)), nil
+	return buf, nil
 }
 
 func renderFeedStyles(source string) (*strings.Reader, error) {