feat: simplify transformations

Author: barelyhuman

pkg/alvu/alvu.go

@@ -80,6 +80,8 @@ func (ac *AlvuConfig) Run() error {
 		return err
 	}
 
+	ac.logger.Debug(fmt.Sprintf("filesToProcess: %v", filesToProcess))
+
 	publicFiles, err := ac.ReadDir(filepath.Join(ac.RootPath, "public"))
 	if err != nil {
 		return err
@@ -140,6 +142,22 @@ func (ac *AlvuConfig) HandlePublicFiles(files []string) (err error) {
 	return
 }
 
+func (ac *AlvuConfig) createTransformedFile(filePath string, content string) (tranformedFile transformers.TransformedFile, err error) {
+	fileExt := filepath.Ext(filePath)
+	fileWriter, err := os.CreateTemp("", "alvu-")
+	if err != nil {
+		return
+	}
+	_, err = fileWriter.WriteString(content)
+	if err != nil {
+		return
+	}
+	tranformedFile.TransformedFile = fileWriter.Name()
+	tranformedFile.SourcePath = filePath
+	tranformedFile.Extension = fileExt
+	return
+}
+
 func (ac *AlvuConfig) FlushFiles(files []HookedFile) error {
 	if err := os.MkdirAll(ac.OutDir, os.ModePerm); err != nil {
 		return err
@@ -171,12 +189,31 @@ func (ac *AlvuConfig) FlushFiles(files []HookedFile) error {
 		}
 		defer destWriter.Close()
 
+		if len(hookedFile.transform) > 1 {
+			for _, t := range ac.Transformers[hookedFile.transform] {
+				afterTransform, err := t.TransformContent(hookedFile.content)
+				if err != nil {
+					return err
+				}
+				hookedFile.content = afterTransform
+			}
+		}
+
 		replaced, _ := ac.injectInSlot(
 			ac.ReadLayout(),
 			string(hookedFile.content),
 		)
 
 		template := templateHTML.New("temporaryTemplate")
+		template = template.Funcs(templateHTML.FuncMap{
+			"transform": func(extension string, content string) templateHTML.HTML {
+				var transformed []byte = []byte(content)
+				for _, t := range ac.Transformers[extension] {
+					transformed, _ = t.TransformContent(transformed)
+				}
+				return templateHTML.HTML(transformed)
+			},
+		})
 		template, err = template.Parse(replaced)
 		if err != nil {
 			ac.logger.Error(fmt.Sprintf("Failed to write to dist file with error: %v", err))
@@ -214,13 +251,25 @@ func runTransfomers(filesToProcess []string, ac *AlvuConfig) ([]transformers.Tra
 			continue
 		}
 
+		originalContent, err := os.ReadFile(fileToNormalize)
+		if err != nil {
+			return nil, fmt.Errorf("failed to read file %v with error %v", fileToNormalize, err)
+		}
+
 		for _, transformer := range ac.Transformers[extension] {
-			transformedFile, err := transformer.Transform(fileToNormalize)
+			nextContent, err := transformer.TransformContent(originalContent)
 			if err != nil {
 				return nil, fmt.Errorf("failed to transform file: %v, with error: %v", fileToNormalize, err)
 			}
-			normalizedFiles = append(normalizedFiles, transformedFile)
+			originalContent = nextContent
 		}
+
+		transformedFile, err := ac.createTransformedFile(fileToNormalize, string(originalContent))
+		if err != nil {
+			return nil, fmt.Errorf("failed to transform file: %v, with error: %v", fileToNormalize, err)
+		}
+
+		normalizedFiles = append(normalizedFiles, transformedFile)
 	}
 	return normalizedFiles, nil
 }

pkg/alvu/hooks.go

@@ -35,9 +35,10 @@ type Hooks struct {
 
 type HookedFile struct {
 	transformers.TransformedFile
-	content []byte
-	data    map[string]interface{}
-	extras  map[string]interface{}
+	content   []byte
+	transform string
+	data      map[string]interface{}
+	extras    map[string]interface{}
 }
 
 func (h *Hooks) Load() {
@@ -162,7 +163,7 @@ func (h *Hooks) ProcessFile(file transformers.TransformedFile) (hookedFile Hooke
 		WriteableContent string `json:"content"`
 		// HTMLContent      string                 `json:"html"`
 	}{
-		Name:             strings.TrimPrefix(file.SourcePath, filepath.Join(h.ac.RootPath, "pages")),
+		Name:             filepath.Clean(strings.TrimPrefix(strings.TrimPrefix(file.SourcePath, filepath.Join(h.ac.RootPath, "pages")), "/")),
 		SourcePath:       file.SourcePath,
 		WriteableContent: string(fileData),
 	}
@@ -215,9 +216,9 @@ func (h *Hooks) ProcessFile(file transformers.TransformedFile) (hookedFile Hooke
 			hookedFile.content = []byte(stringVal)
 		}
 
-		// if fromPlug["name"] != nil {
-		// 	hookedFile.content = []byte(fmt.Sprintf("%v", fromPlug["name"]))
-		// }
+		if fromPlug["transform"] != nil {
+			hookedFile.transform = fmt.Sprintf("%v", fromPlug["transform"])
+		}
 
 		if fromPlug["data"] != nil {
 			hookedFile.data = mergeMapWithCheck(hookedFile.data, fromPlug["data"])

transformers/html/html.go

@@ -1,22 +1,10 @@
 package html
 
-import (
-	"path/filepath"
+type HTMLTransformer struct{}
 
-	"github.com/barelyhuman/alvu/transformers"
-)
-
-type HTMLTransformer struct {
-}
-
-func (mt *HTMLTransformer) Transform(filePath string) (transformedFile transformers.TransformedFile, err error) {
-	return transformers.TransformedFile{
-		SourcePath:      filePath,
-		TransformedFile: filePath,
-		Extension:       filepath.Ext(filePath),
-	}, nil
+func (mt *HTMLTransformer) TransformContent(input []byte) (result []byte, err error) {
+	result = input
+	return
 }
 
-func (mt *HTMLTransformer) Init() {
-
-}
+func (mt *HTMLTransformer) Init() {}

transformers/markdown/markdown.go

@@ -1,11 +1,8 @@
 package markdown
 
 import (
-	"os"
-	"path/filepath"
-	"strings"
+	"bytes"
 
-	"github.com/barelyhuman/alvu/transformers"
 	"github.com/yuin/goldmark"
 	highlighting "github.com/yuin/goldmark-highlighting"
 	"github.com/yuin/goldmark/extension"
@@ -21,41 +18,24 @@ type MarkdownTransformer struct {
 	HighlightingTheme  string
 }
 
-func (mt *MarkdownTransformer) Transform(filePath string) (transformedFile transformers.TransformedFile, err error) {
-	if mt.processor == nil {
-		mt.Init()
-	}
+func (mt *MarkdownTransformer) TransformContent(input []byte) (result []byte, err error) {
+	mt.EnsureProcessor()
 
-	fileBytes, err := os.ReadFile(filePath)
+	var buffer bytes.Buffer
+	err = mt.processor.Convert(input, &buffer)
 	if err != nil {
 		return
 	}
 
-	tmpDir := os.TempDir()
-	filename := filepath.Base(filePath)
-	fileExt := filepath.Ext(filename)
-	filename = strings.TrimSuffix(filename, fileExt)
-	filename += ".html"
-	tmpFile := filepath.Join(tmpDir, filename)
-
-	fileWriter, err := os.Create(tmpFile)
-	if err != nil {
-		return
-	}
+	result = buffer.Bytes()
+	return
+}
 
-	err = mt.processor.Convert(fileBytes, fileWriter)
-	if err != nil {
+func (mt *MarkdownTransformer) EnsureProcessor() {
+	if mt.processor != nil {
 		return
 	}
 
-	return transformers.TransformedFile{
-		SourcePath:      filePath,
-		TransformedFile: tmpFile,
-		Extension:       fileExt,
-	}, nil
-}
-
-func (mt *MarkdownTransformer) Init() {
 	rendererOptions := []renderer.Option{
 		html.WithXHTML(),
 		html.WithUnsafe(),

transformers/transformers.go

@@ -7,5 +7,5 @@ type TransformedFile struct {
 }
 
 type Transfomer interface {
-	Transform(filePath string) (TransformedFile, error)
+	TransformContent(data []byte) ([]byte, error)
 }