pagr

commit b99b08c1909ab94a88316886b1c7aa4d2e2dc190
parent 8d32449a46504c61f784604740d9bd02ddcbabde
Author: gearsix <gearsix@tuta.io>
Date:   Tue,  8 Jun 2021 18:14:19 +0100

added content.go: Content, Page, Meta; condensed pagr.go

I kept everything in pagr.go in main(), seemed cleaner. Moved
loadContents() to content.go#LoadContentsDir which returns a Content
([]Page). Page is a struct containing all Page information to be
accessed in templates and Meta is a typical map[string]data object.

Diffstat:
A
content.go
 | 
82
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
M
pagr.go
 | 
70
+++++++++++++---------------------------------------------------------

2 files changed, 95 insertions(+), 57 deletions(-)
diff --git a/content.go b/content.go
@@ -0,0 +1,82 @@
+package main
+
+import (
+    "path/filepath"
+    "io/fs"
+    "strings"
+    "notabug.org/gearsix/suti"
+)
+
+type Content []Page
+
+func LoadContentDir(dirpath string) (c Content, e error) {
+    pages := make(map[string]Page)
+    defaults := make(map[string]Meta)
+    e = filepath.Walk(dirpath, func(fpath string, info fs.FileInfo, err error) error {
+        if err != nil {
+            return nil
+        }
+
+        if info.IsDir() {
+            p := NewPage(strings.TrimPrefix(fpath, dirpath))
+            for _, dir := range strings.Split(fpath, "/") {
+                if _, ok := defaults[dir]; ok {
+                    p.Meta.MergeMeta(defaults[dir])
+                }
+            }
+            return nil
+        }
+
+        pdir := filepath.Dir(fpath)
+        page := pages[pdir]
+        if strings.Contains(fpath, ".page") || strings.Contains(fpath, ".defaults") {
+            var m Meta
+            if err = suti.LoadDataFile(fpath, &m); err != nil {
+                return err
+            }
+            if strings.Contains(fpath, ".page") {
+                page.Meta.MergeMeta(m)
+            } else if strings.Contains(fpath, ".defaults") {
+                defaults[pdir] = m
+            }
+        } else if ext := filepath.Ext(fpath); ext == ".txt" || ext == ".md" || ext == ".html" {
+            page.NewBodyFromFile(fpath)
+        } else {
+            page.Assets = append(page.Assets, strings.TrimPrefix(fpath, dirpath))
+        }
+
+        pages[pdir] = page
+        return nil
+    })
+
+    for _, page := range pages {
+        c = append(c, page)
+    }
+
+    return c, e
+}
+
+type Meta map[string]interface{}
+
+func (m *Meta) MergeMeta(meta Meta) {
+}
+
+type Page struct {
+    Path string
+    Meta Meta
+    Body []string
+    Assets []string
+}
+
+func NewPage(path string) Page {
+    return Page {
+        Path: path,
+        Meta: make(Meta),
+        Body: make([]string, 0),
+        Assets: make([]string, 0),
+    }
+}
+
+func (p *Page) NewBodyFromFile(fpath string) {
+}
+
diff --git a/pagr.go b/pagr.go
@@ -2,7 +2,6 @@ package main
 
 import (
     "flag"
-    "io/fs"
     "log"
 )
 
@@ -10,14 +9,22 @@ const Name = "pagr"
 const Version = "0.0.0"
 
 func main() {
-    flag.StringVar(&cfg, "cfg", "", "path to pagr project configuration file")
-    flag.BoolVar(&verbose, "verbose", false, "print verbose logs")
+    cfg := flag.String("cfg", "", "path to pagr project configuration file")
+    verbose := flag.Bool("verbose", false, "print verbose logs")
     flag.Parse()
 
-    config, err := loadConfig(cfg)
-    check(err)
+    var err error
+
+    var config Config
+    if len(*cfg) > 0 {
+        config, err = NewConfigFromFile(*cfg)
+        check(err)
+    } else {
+        config = NewConfig()
+    }
 
-    pages, err := loadContent(config.Contents)
+    var content Content
+    content, err = LoadContentDir(config.Contents)
     check(err)
 
     return
@@ -29,54 +36,3 @@ func check(err error) {
     }
 }
 
-func loadConfig(fpath string) (c Config, e error) {
-    if len(cfg) > 0 {
-        c, e = NewConfigFromFile(cfg)
-    } else {
-        c = NewConfig()
-    }
-    return
-}
-
-func loadContent(root string) (p map[string]Page, e error) {
-    p = make(map[string]Page)
-    defaults := make(map[string]Meta)
-    e = filepath.Walk(root, func(path string, info fs.FileInfo, err error) error {
-        if err != nil {
-            return
-        }
-
-        if info.IsDir() {
-            p := NewPage(strings.TrimPrefix(path, root))
-            for _, dir := range strings.Split(path, "/") {
-                if _, ok := defaults[dir]; ok {
-                    p.MergeMeta(defaults[dir].Meta)
-                }
-            }
-            return
-        }
-
-        pdir := filepath.Dir(path)
-        page := p[pdir]
-
-        if strings.Contains(path, ".page") || strings.Contains(path, ".defaults") {
-            var m Meta
-            err = suti.LoadDataFile(path, &m); err != nil {
-                return err
-            }
-            if strings.Contains(path, ".page") {
-                page.MergeMeta(m)
-            } else if strings.Contains(path, ".defaults") {
-                defaults[pdir] = m
-            }
-        } else if ext := filepath.Ext(path); ext == ".txt" || ext == ".md" || ext == ".html" {
-            page.Body = append(page.Body, NewContentFromFile(path))
-        } else {
-            page.Assets = append(page.Assets, filepath.TrimPrefix(path, root))
-        }
-
-        p[pdir] = page
-        return
-    }
-}
-