Another re-structure. Deleting code is wonderful.v0.0.12

6 files changed, 412 insertions, 13 deletions

diff --git a/page/index.go b/page/index.go
new file mode 100644
index 0000000..a453335
--- /dev/null
+++ b/page/index.go
@@ -0,0 +1,78 @@
+package page
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+)
+
+var index map[string]PageList
+var indexMu sync.RWMutex
+
+// RebuildIndex can be called in order to rebuild the entire website
+// index
+func (p *Page) RebuildIndex() error {
+	indexMu.Lock()
+	index = nil
+	indexMu.Unlock()
+	_, err := p.Index()
+	return err
+}
+
+// Index returns a map of all pages in the current directory seperated into
+// their respective tags If a Page has multiple tags it will be listed under
+// each.
+// Pages are located by their Suffix, default being ".md"
+func (p *Page) Index() (map[string]PageList, error) {
+	indexMu.RLock()
+	if index != nil && CacheIndex {
+		indexMu.RUnlock()
+		return index, nil
+	}
+	indexMu.RUnlock()
+	Logger.Println("Rebuilding index...")
+
+	out := make(map[string]PageList)
+
+	filepath.Walk(filepath.Dir("."),
+		func(path string, info os.FileInfo, err error) error {
+			if err != nil {
+				return err
+			}
+
+			if !info.IsDir() && strings.HasSuffix(info.Name(), Suffix) {
+
+				p2 := NewPage(strings.ReplaceAll(path, Suffix, ""))
+				err = p2.Read()
+
+				if err != nil {
+					fmt.Fprintln(os.Stderr, "Error encountered: ", err)
+					return err
+				}
+
+				for tag, _ := range p2.Tags {
+					if _, ok := out[tag]; !ok {
+						out[tag] = []*Page{p2}
+					} else {
+						out[tag] = append(out[tag], p2)
+					}
+				}
+
+			}
+
+			return nil
+		})
+
+	indexMu.Lock()
+	index = out
+	indexMu.Unlock()
+
+	return out, nil
+}
+
+func (p *Page) Time() time.Time {
+	return p.Date.Time
+}
diff --git a/page/main.go b/page/main.go
deleted file mode 100644
index da7feec..0000000
--- a/page/main.go
+++ /dev/null
@@ -1,13 +0,0 @@
-// The only purpose of this package is to define the Page interface
-// that is used by the `http` package
-package page
-
-import (
-	"io"
-)
-
-type Page interface {
-	Render(io.Writer) error
-	RebuildIndex() error
-	SetVars(map[string]interface{})
-}
diff --git a/page/page.go b/page/page.go
new file mode 100644
index 0000000..82f46f2
--- /dev/null
+++ b/page/page.go
@@ -0,0 +1,211 @@
+// page implements the website backed by a local filesystem.
+//
+// Reading the base template off the disk, then any markdown files which are
+// split into two sections by the DocumentSplit global variable.  The first
+// section is parsed as yaml to populate the Page struct.  The second portion is
+// markdown, first executed as part of the text/template then rendered by
+// blackfriday.
+//
+// Usage:
+//
+//    import (
+//    	"fmt"
+//    	"os"
+//    	site "riedstra.dev/mitch/go-website/page"
+//    )
+//    // Where some/path.md exists
+//    p := site.NewPage("/some/path")
+//    // Dump the rendered HTML to stdout
+//    err := p.Render(os.Stdout)
+//    if err != nil {
+//    	fmt.Fprintln(os.Stderr, err)
+//    }
+package page
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"io"
+	"log"
+	"os"
+	"text/template"
+
+	"github.com/russross/blackfriday"
+	"gopkg.in/yaml.v3"
+)
+
+// Page should not be created directly as it will not set the interal path
+// properly. Use NewPage instead.
+//
+// The exported fields can be filled in the yaml at the top of a page and
+// utilized within.
+type Page struct {
+	path        string
+	Title       string
+	Head        string
+	Description string
+	// Tags to apply to the page in question. Useful for Index()
+	Tags      map[string]interface{}
+	Date      *PageTime
+	Published bool
+	Vars      map[string]interface{}
+	markdown  []byte
+}
+
+// Global is meant to be supplied by external users of this package to populate
+// globally accessable information across all of the templates accessiable via
+// .Global care must be taken when utilizing this functionality
+var Global interface{}
+
+// CachePages determines whether or not the rendered page will be stored in
+// memory
+var CachePages = true
+
+// CacheIndex determines whether or not the index will be cached in memory
+// or rebuilt on each call
+var CacheIndex = true
+
+// BaseTemplate can be adjusted to change the base template used in rendering
+var BaseTemplate = "inc/base.html"
+
+// Suffix is applied to all pages for reading off of the disk
+var Suffix = ".md"
+
+// DocumentSplit is used to split the .md files into yaml and markdown
+var DocumentSplit = "|---\n"
+
+// Default logger
+var Logger = log.New(os.Stderr, "", log.LstdFlags)
+
+// NewPage returns a page struct with the path populated
+func NewPage(pth string) *Page {
+	return &Page{path: pth}
+}
+
+// NewPage Allow for the creation of a new page from the current page, does
+// not inlcude any information about the current page.
+func (p Page) NewPage(pth string) *Page {
+	return NewPage(pth)
+}
+
+// Path gets the current path set on the struct for the page in question
+// Useful if you're say iterating across tags to print out a list of
+// relevant posts on a blog or so by topic.
+func (p Page) Path() string {
+	return p.path
+}
+
+// Global is specifically for use inside of a page markdown file or
+// in a base template. This simply returns the package Global variable
+func (p *Page) Global() interface{} {
+	return Global
+}
+
+// SetVars Will set to `nil` if provided
+func (p *Page) SetVars(vars map[string]interface{}) {
+	p.Vars = vars
+}
+
+// Renders a page
+func (p *Page) Render(wr io.Writer) error {
+	if err := p.Read(); err != nil {
+		return err
+	}
+
+	t, err := template.ParseFiles(BaseTemplate)
+	if err != nil {
+		return err
+	}
+
+	// Automatically pull from the yml file if applicable
+	if p.Head != "" {
+		t, err = t.Parse(`
+			{{define "head"}}
+			{{.RenderHead}}
+			{{end}}
+		`)
+		if err != nil {
+			return err
+		}
+	}
+
+	return t.Execute(wr, p)
+}
+
+func (p *Page) RenderHead() (string, error) {
+	buf := &bytes.Buffer{}
+	t, err := template.New("Head").Parse(p.Head)
+	if err != nil {
+		return "", err
+	}
+	err = t.Execute(buf, p)
+	if err != nil {
+		return "", err
+	}
+	return string(buf.Bytes()), nil
+}
+
+// Reads in the special markdown file format for the website off of the disk
+func (p *Page) Read() error {
+	yamlBuf := bytes.NewBuffer(nil)
+	markdownBuf := bytes.NewBuffer(nil)
+
+	fh, err := os.Open(p.path + Suffix)
+	if err != nil {
+		return err
+	}
+	defer fh.Close()
+	rdr := bufio.NewReader(fh)
+
+	// Read in the file and split between markdown and yaml buffers
+	yamlDone := false
+	for {
+
+		bytes, err := rdr.ReadBytes('\n')
+		if err == io.EOF {
+			break
+		} else if err != nil {
+			return err
+		}
+
+		// Is this the line where we stop reading the yaml and start reading markdown?
+		if DocumentSplit == string(bytes) && !yamlDone {
+			yamlDone = true
+			continue
+		}
+
+		if !yamlDone {
+			yamlBuf.Write(bytes)
+		} else {
+			markdownBuf.Write(bytes)
+		}
+	}
+
+	err = yaml.Unmarshal(yamlBuf.Bytes(), p)
+	if err != nil {
+		return err
+	}
+
+	p.markdown = markdownBuf.Bytes()
+	return nil
+}
+
+func (p *Page) RenderBody() (string, error) {
+	buf := &bytes.Buffer{}
+	t, err := template.New("Body").Parse(string(p.markdown))
+	if err != nil {
+		return "", err
+	}
+
+	err = t.Execute(buf, p)
+	if err != nil {
+		return "", err
+	}
+
+	return string(blackfriday.Run(buf.Bytes())), nil
+}
+
+func (p Page) String() string {
+	return fmt.Sprintf("Page: %s", p.path)
+}
diff --git a/page/pagelist.go b/page/pagelist.go
new file mode 100644
index 0000000..a5cf844
--- /dev/null
+++ b/page/pagelist.go
@@ -0,0 +1,23 @@
+package page
+
+import (
+	"sort"
+)
+
+// PageList is a slice of pages, providing a couple of methods to sort
+// by the date, or date reversed
+type PageList []*Page
+
+func (p PageList) SortDate() PageList {
+	sort.Slice(p, func(i, j int) bool {
+		return p[i].Time().After(p[j].Time())
+	})
+	return p
+}
+
+func (p PageList) SortDateReverse() PageList {
+	sort.Slice(p, func(i, j int) bool {
+		return p[i].Time().Before(p[j].Time())
+	})
+	return p
+}
diff --git a/page/render.go b/page/render.go
new file mode 100644
index 0000000..4378675
--- /dev/null
+++ b/page/render.go
@@ -0,0 +1,77 @@
+package page
+
+import (
+	"net/http"
+	"path/filepath"
+	"strings"
+)
+
+// Render is a lower level option, allowing you to specify local
+// variables and the status code in which to return
+func Render(w http.ResponseWriter, r *http.Request,
+	path string, vars map[string]interface{}, statusCode int) {
+
+	u := r.URL.Path
+	if u == "/" {
+		u = "/index"
+	}
+	u = filepath.Join(".", u)
+
+	// Sepcifically use the specified path for the page
+	p := NewPage(path)
+
+	if vars != nil {
+		p.SetVars(vars)
+	}
+
+	err := p.Render(w)
+	if err != nil {
+		if strings.HasSuffix(err.Error(), "no such file or directory") {
+			Logger.Printf("%s %s %d %s",
+				r.RemoteAddr,
+				r.Method,
+				http.StatusNotFound,
+				u)
+			p = NewPage("404")
+			w.WriteHeader(http.StatusNotFound)
+			err := p.Render(w)
+			if err != nil {
+				Logger.Printf("%s %s path: %s while trying 404: %s",
+					r.RemoteAddr,
+					r.Method,
+					u,
+					err)
+				http.Error(w, "Internal server error",
+					http.StatusInternalServerError)
+				return
+			}
+			return
+		} else {
+			Logger.Printf("%s %s path: %s encountered: %s",
+				r.RemoteAddr,
+				r.Method,
+				u,
+				err)
+			http.Error(w, "Internal server error",
+				http.StatusInternalServerError)
+			return
+		}
+	}
+
+	Logger.Printf("%s %s %d %s", r.RemoteAddr, r.Method, statusCode, u)
+}
+
+// RenderWithVars allows you to specify a specific page and whether or not
+// you wish to override vars. If left nil they will not be overridden.
+// Also see RenderForPath if you don't need to override them
+func RenderWithVars(w http.ResponseWriter, r *http.Request,
+	path string, vars map[string]interface{}) {
+
+	Render(w, r, path, vars, http.StatusOK)
+}
+
+// RenderForPath takes the path to a page and finish up the rendering
+// Allowing you to place logic on what page is rendered by your handlers
+func RenderForPath(w http.ResponseWriter, r *http.Request, path string) {
+	RenderWithVars(w, r, path, nil)
+}
diff --git a/page/time.go b/page/time.go
new file mode 100644
index 0000000..958dc38
--- /dev/null
+++ b/page/time.go
@@ -0,0 +1,23 @@
+package page
+
+import (
+	"gopkg.in/yaml.v3"
+	"time"
+)
+
+type PageTime struct {
+	time.Time
+}
+
+// TimeFormat is the format string used when unmarshaling the time
+// from the yaml information.
+var TimeFormat = "01.02.2006 15:04:05 MST"
+
+func (pt *PageTime) UnmarshalYAML(n *yaml.Node) error {
+	t, err := time.Parse(TimeFormat, n.Value)
+	if err != nil {
+		return err
+	}
+	pt.Time = t
+	return nil
+}