From 5e4be6f2a2a39b05e8e05050735ed824c64e74e3 Mon Sep 17 00:00:00 2001
From: Gwyn <gwyn@playtechnique.io>
Date: Thu, 11 Jul 2024 20:45:36 -0600
Subject: [PATCH 1/7] Passing simple case of grouping pages by directory.

---
 andrew_server_test.go |   8 ++-
 linksbuilder.go       | 101 +++++++++++++++++++++++++++++++++++--
 linksbuilder_test.go  | 115 +++++++++++++++++++++---------------------
 page.html             |  14 +++++
 4 files changed, 171 insertions(+), 67 deletions(-)
 create mode 100644 page.html

diff --git a/andrew_server_test.go b/andrew_server_test.go
index adbd4eb..460f45a 100644
--- a/andrew_server_test.go
+++ b/andrew_server_test.go
@@ -422,13 +422,11 @@ func TestMainCalledWithInvalidAddressPanics(t *testing.T) {
 // what file attribute andrew is actually sorting on.
 func TestArticlesInAndrewTableOfContentsAreDefaultSortedByModTime(t *testing.T) {
 
-	expected, err := regexp.Compile(`.*b_newer.*a_older.*`)
+	expectedOrder, err := regexp.Compile(`(?s).*b_newer.*a_older.*`)
 
 	if err != nil {
 		t.Fatal(err)
 	}
-	// expected := `<a class="andrewtableofcontentslink" id="andrewtableofcontentslink0" href="b_newer.html">b_newer.html</a>` +
-	// `<a class="andrewtableofcontentslink" id="andrewtableofcontentslink1" href="a_older.html">a_older.html</a>`
 
 	contentRoot := t.TempDir()
 
@@ -465,8 +463,8 @@ func TestArticlesInAndrewTableOfContentsAreDefaultSortedByModTime(t *testing.T)
 
 	received := page.Content
 
-	if expected.FindString(received) == "" {
-		t.Fatalf(cmp.Diff(expected, received))
+	if expectedOrder.FindString(received) == "" {
+		t.Fatalf(cmp.Diff(expectedOrder, received))
 	}
 
 }
diff --git a/linksbuilder.go b/linksbuilder.go
index f6b7ac7..6c84156 100644
--- a/linksbuilder.go
+++ b/linksbuilder.go
@@ -3,6 +3,10 @@ package andrew
 import (
 	"bytes"
 	"fmt"
+	"path"
+	"regexp"
+	"sort"
+	"strings"
 	"text/template"
 	"time"
 )
@@ -13,20 +17,107 @@ import (
 // as a list of html links to those pages.
 func RenderTemplates(siblings []Page, startingPage Page) ([]byte, error) {
 
+	tableOfContents, err := regexp.Compile(`.*{{\s*\.AndrewTableOfContents\s*}}.*`)
+	if err != nil {
+		return nil, err
+	}
+
+	if tableOfContents.FindString(startingPage.Content) != "" {
+		return renderAndrewTableOfContents(siblings, startingPage)
+	}
+
+	tableOfContentsWithDirs, err := regexp.Compile(`.*{{\s*\.AndrewTableOfContentsWithDirectories\s*}}.*`)
+	if err != nil {
+		return nil, err
+	}
+
+	if tableOfContentsWithDirs.FindString(startingPage.Content) != "" {
+		return renderAndrewTableOfContentsWithDirectories(siblings, startingPage)
+	}
+
+	return []byte(startingPage.Content), nil
+}
+
+func countSlashes(s string) int {
+	return strings.Count(s, "/")
+}
+
+func renderAndrewTableOfContentsWithDirectories(siblings []Page, startingPage Page) ([]byte, error) {
+	var links bytes.Buffer
+	var templateBuffer bytes.Buffer
+	directoriesAndContents := make(map[string][]Page)
+
+	for _, sibling := range siblings {
+		path, _ := path.Split(sibling.UrlPath)
+		directoriesAndContents[path] = append(directoriesAndContents[path], sibling)
+	}
+
+	keys := make([]string, 0, len(directoriesAndContents))
+	for k := range directoriesAndContents {
+		keys = append(keys, k)
+	}
+
+	sort.Slice(keys, func(i, j int) bool {
+		slashesI := countSlashes(keys[i])
+		slashesJ := countSlashes(keys[j])
+		if slashesI == slashesJ {
+			return keys[i] < keys[j] // Lexicographical order if the number of slashes is the same
+		}
+		return slashesI < slashesJ // Primary order by number of slashes
+	})
+
+	linkCount := 0
+	dirCount := 1
+
+	links.Write([]byte("<ul style=\"padding-left: 10px;\">\n"))
+
+	for parentDir, siblingPages := range directoriesAndContents {
+		if linkCount != 0 {
+			links.Write([]byte("<ul>\n"))
+		}
+		if parentDir != "" {
+			links.Write([]byte("<h5 style=\"display: inline;\">" + parentDir + "</h5>\n"))
+		}
+		for _, sibling := range siblingPages {
+			links.Write(buildAndrewTableOfContentsLink(sibling.UrlPath, sibling.Title, sibling.PublishTime.Format(time.DateOnly), linkCount))
+			linkCount = linkCount + 1
+		}
+		dirCount = dirCount + 1
+	}
+
+	for range dirCount - 1 {
+		links.Write([]byte("</ul>\n"))
+	}
+
+	t, err := template.New(startingPage.UrlPath).Parse(startingPage.Content)
+
+	if err != nil {
+		panic(err)
+	}
+
+	err = t.Execute(&templateBuffer, map[string]string{"AndrewTableOfContentsWithDirectories": links.String()})
+	if err != nil {
+		return templateBuffer.Bytes(), err
+	}
+
+	return templateBuffer.Bytes(), nil
+}
+
+func renderAndrewTableOfContents(siblings []Page, startingPage Page) ([]byte, error) {
 	var links bytes.Buffer
 
-	links.Write([]byte("<ul>"))
+	links.Write([]byte("<ul>\n"))
 	for i, sibling := range siblings {
 		links.Write(buildAndrewTableOfContentsLink(sibling.UrlPath, sibling.Title, sibling.PublishTime.Format(time.DateOnly), i))
 	}
-	links.Write([]byte("</ul>"))
+	links.Write([]byte("</ul>\n"))
 
 	templateBuffer := bytes.Buffer{}
-	// execute template here, write it to something and then return it as the pageContent
+
 	t, err := template.New(startingPage.UrlPath).Parse(startingPage.Content)
 
 	if err != nil {
-		// TODO: swap this for proper error handling
+
 		panic(err)
 	}
 
@@ -40,7 +131,7 @@ func RenderTemplates(siblings []Page, startingPage Page) ([]byte, error) {
 
 // buildAndrewTableOfContentsLink encapsulates the format of the link
 func buildAndrewTableOfContentsLink(urlPath string, title string, publishDate string, cssIdNumber int) []byte {
-	link := fmt.Sprintf("<li><a class=\"andrewtableofcontentslink\" id=\"andrewtableofcontentslink%s\" href=\"%s\">%s</a> - <span class=\"publish-date\">%s</span></li>", fmt.Sprint(cssIdNumber), urlPath, title, publishDate)
+	link := fmt.Sprintf("<li><a class=\"andrewtableofcontentslink\" id=\"andrewtableofcontentslink%s\" href=\"%s\">%s</a> - <span class=\"publish-date\">%s</span></li>\n", fmt.Sprint(cssIdNumber), urlPath, title, publishDate)
 	b := []byte(link)
 	return b
 }
diff --git a/linksbuilder_test.go b/linksbuilder_test.go
index 5ecda4b..2927383 100644
--- a/linksbuilder_test.go
+++ b/linksbuilder_test.go
@@ -2,8 +2,8 @@ package andrew_test
 
 import (
 	"fmt"
+	"io"
 	"net/http"
-	"os"
 	"regexp"
 	"testing"
 	"testing/fstest"
@@ -21,45 +21,24 @@ import (
 // by modtime and in another order by andrew-publish-time time, so that we can tell
 // what file attribute andrew is actually sorting on.
 func TestArticlesOrderInAndrewTableOfContentsIsOverridable(t *testing.T) {
-	expected, err := regexp.Compile(".*b_newest.html.*c_newer.html.*a_older.html.*")
+	expected, err := regexp.Compile("(?s).*b_newest.html.*c_newer.html.*a_older.html.*")
 	if err != nil {
 		t.Fatal(err)
 	}
-
-	contentRoot := t.TempDir()
-
-	err = os.WriteFile(contentRoot+"/index.html", []byte("{{.AndrewTableOfContents}}"), 0o700)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = os.WriteFile(contentRoot+"/a_older.html", []byte{}, 0o700)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = os.WriteFile(contentRoot+"/c_newer.html", []byte{}, 0o700)
-	if err != nil {
-		t.Fatal(err)
-	}
-
 	now := time.Now().UTC()
+	newer := now.Add(24 * time.Hour)
+	newest := now.Add(48 * time.Hour)
 
-	newest := now.Add(24 * time.Hour)
-	content := fmt.Sprintf(`<meta name="andrew-publish-time" content="%s">`, newest.Format("2006-01-02"))
-
-	err = os.WriteFile(contentRoot+"/b_newest.html", []byte(content), 0o700)
-	if err != nil {
-		t.Fatal(err)
+	contentRoot := fstest.MapFS{
+		"index.html": &fstest.MapFile{Data: []byte(`
+{{ .AndrewTableOfContents }}
+`)},
+		"a_older.html":  &fstest.MapFile{ModTime: now},
+		"b_newest.html": &fstest.MapFile{ModTime: newest, Data: []byte(fmt.Sprintf(`<meta name="andrew-publish-time" content="%s">`, newest.Format("2006-01-02")))},
+		"c_newer.html":  &fstest.MapFile{ModTime: newer},
 	}
 
-	older := now.Add(-24 * time.Hour)
-
-	os.Chtimes(contentRoot+"/a_older.html", older, older)
-	os.Chtimes(contentRoot+"/b_newest.html", older, older)
-	os.Chtimes(contentRoot+"/c_newer.html", now, now)
-
-	server := andrew.Server{SiteFiles: os.DirFS(contentRoot)}
+	server := andrew.Server{SiteFiles: contentRoot}
 
 	page, err := andrew.NewPage(server, "index.html")
 
@@ -115,32 +94,54 @@ func TestInvalidAndrewPublishTimeContentDoesNotCrashTheWebServer(t *testing.T) {
 // This test requires having several files which are in one order when sorted
 // by modtime and in another order by andrew-publish-time time, so that we can tell
 // what file attribute andrew is actually sorting on.
-// func TestArticlesAppearUnderParentDirectoryForAndrewTableOfContentsGrouped(t *testing.T) {
-// 	expected := `<a class="andrewtableofcontentslink" id="andrewtableofcontentslink1" href="parentDir/displayMe.html">parentDir/displayMe.html</a>` +
-// 		`<a class="andrewtableofcontentslink" id="andrewtableofcontentslink2" href="parentDir/childDir/1-2-3.html">parentDir/childDir/1-2-3.html</a>`
+func TestOneArticleAppearsUnderParentDirectoryForAndrewTableOfContentsGrouped(t *testing.T) {
+	expected := `<ul style="padding-left: 10px;">
+<li><a class="andrewtableofcontentslink" id="andrewtableofcontentslink0" href="groupedContents.html">groupedContents.html</a> - <span class="publish-date">0001-01-01</span></li>
+<li><a class="andrewtableofcontentslink" id="andrewtableofcontentslink1" href="otherPage.html">otherPage.html</a> - <span class="publish-date">0001-01-01</span></li>
+</ul>
+`
+	contentRoot := fstest.MapFS{
+		"groupedContents.html": &fstest.MapFile{Data: []byte(`{{.AndrewTableOfContentsWithDirectories}}`)},
+		"otherPage.html":       &fstest.MapFile{},
+	}
 
+	s := newTestAndrewServer(t, contentRoot)
+	resp, err := http.Get(s.BaseUrl + "/groupedContents.html")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		t.Fatalf("unexpected status %q", resp.Status)
+	}
+	received, err := io.ReadAll(resp.Body)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if expected != string(received) {
+
+		t.Errorf("Expected:\n" + expected + "\n Received:\n" + string(received))
+
+	}
+}
+
+// func TestArticlesAppearUnderParentDirectoryForAndrewTableOfContentsGrouped(t *testing.T) {
+// 	expected := `<ul style="padding-left: 10px;">
+// <h5 style="display: inline;">parentDir/</h5>
+// <li><a class="andrewtableofcontentslink" id="andrewtableofcontentslink0" href="parentDir/displayme.html">displayme.html</a></li>
+// <h5 style="display: inline;">childDir/</h5>
+// <ul>
+// <li><a class="andrewtableofcontentslink" id="andrewtableofcontentslink1" href="parentDir/childDir/1-2-3.html">1-2-3.html</li>
+// </ul>
+// </ul>
+// </ul>
+// `
 // 	contentRoot := fstest.MapFS{
-// 		"groupedContents.html": &fstest.MapFile{Data: []byte(`
-// {{ .AndrewTableOfContentsGrouped}}`)},
-
-// 		"parentDir/index.html": &fstest.MapFile{Data: []byte(`
-// 	<!doctype HTML>
-// 	<head> </head>
-// 	<body>
-// 	</body>
-// 	`)},
-// 		"parentDir/displayme.html": &fstest.MapFile{Data: []byte(`
-// 	<!doctype HTML>
-// 	<head> </head>
-// 	<body>
-// 	</body>
-// 	`)},
-// 		"parentDir/childDir/1-2-3.html": &fstest.MapFile{Data: []byte(`
-// 	<!doctype HTML>
-// 	<head>
-// 	<title>1-2-3 Page</title>
-// 	</head>
-// 	`)},
+// 		"groupedContents.html":          &fstest.MapFile{Data: []byte(`{{.AndrewTableOfContentsWithDirectories}}`)},
+// 		"parentDir/index.html":          &fstest.MapFile{},
+// 		"parentDir/displayme.html":      &fstest.MapFile{},
+// 		"parentDir/childDir/1-2-3.html": &fstest.MapFile{},
 // 	}
 
 // 	s := newTestAndrewServer(t, contentRoot)
diff --git a/page.html b/page.html
new file mode 100644
index 0000000..3983a30
--- /dev/null
+++ b/page.html
@@ -0,0 +1,14 @@
+<!doctype HTML>
+<head>
+<title>directory layout page</title>
+</head>
+
+<body>
+    <ul style="padding-left: 10px;"">
+        <li><a href="index.html">index.html</a></li>
+        <h5 style="display: inline;">parentDir</h5>
+        <ul>
+            <li><a href="parentDir/page.html">page.html</a></li>
+        </ul>
+    </ul>
+</body>
\ No newline at end of file

From f3aa4be12aa68be839b517d39d4e669f97723920 Mon Sep 17 00:00:00 2001
From: Gwyn <gwyn@playtechnique.io>
Date: Thu, 11 Jul 2024 20:53:07 -0600
Subject: [PATCH 2/7] Remove the starting page from the results being shown.

We already know where we are, after all.
---
 linksbuilder.go      | 6 ++++++
 linksbuilder_test.go | 3 +--
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/linksbuilder.go b/linksbuilder.go
index 6c84156..1a6d0cc 100644
--- a/linksbuilder.go
+++ b/linksbuilder.go
@@ -72,6 +72,7 @@ func renderAndrewTableOfContentsWithDirectories(siblings []Page, startingPage Pa
 	links.Write([]byte("<ul style=\"padding-left: 10px;\">\n"))
 
 	for parentDir, siblingPages := range directoriesAndContents {
+
 		if linkCount != 0 {
 			links.Write([]byte("<ul>\n"))
 		}
@@ -79,6 +80,11 @@ func renderAndrewTableOfContentsWithDirectories(siblings []Page, startingPage Pa
 			links.Write([]byte("<h5 style=\"display: inline;\">" + parentDir + "</h5>\n"))
 		}
 		for _, sibling := range siblingPages {
+			//Do not include the page we're starting with. These and index.html pages are both to be skipped.
+			if sibling == startingPage {
+				continue
+			}
+
 			links.Write(buildAndrewTableOfContentsLink(sibling.UrlPath, sibling.Title, sibling.PublishTime.Format(time.DateOnly), linkCount))
 			linkCount = linkCount + 1
 		}
diff --git a/linksbuilder_test.go b/linksbuilder_test.go
index 2927383..0944d20 100644
--- a/linksbuilder_test.go
+++ b/linksbuilder_test.go
@@ -96,8 +96,7 @@ func TestInvalidAndrewPublishTimeContentDoesNotCrashTheWebServer(t *testing.T) {
 // what file attribute andrew is actually sorting on.
 func TestOneArticleAppearsUnderParentDirectoryForAndrewTableOfContentsGrouped(t *testing.T) {
 	expected := `<ul style="padding-left: 10px;">
-<li><a class="andrewtableofcontentslink" id="andrewtableofcontentslink0" href="groupedContents.html">groupedContents.html</a> - <span class="publish-date">0001-01-01</span></li>
-<li><a class="andrewtableofcontentslink" id="andrewtableofcontentslink1" href="otherPage.html">otherPage.html</a> - <span class="publish-date">0001-01-01</span></li>
+<li><a class="andrewtableofcontentslink" id="andrewtableofcontentslink0" href="otherPage.html">otherPage.html</a> - <span class="publish-date">0001-01-01</span></li>
 </ul>
 `
 	contentRoot := fstest.MapFS{

From ce6306c56b11d2924125859e330df57bd08d55c4 Mon Sep 17 00:00:00 2001
From: Gwyn <gwyn@playtechnique.io>
Date: Mon, 12 Aug 2024 20:19:33 -0600
Subject: [PATCH 3/7] Styling changes for the table of contents with dir.

I kept exploring the old layout in a web page and there were a couple of
issues.

First I didn't like the recursive descent. It was too much information,
poorly presented.

Second the recursive descent meant that I had all these nested lists. They were
fine, but the nesting was hard-coded. I swapped that out for a CSS
class. Let the user provide their own styling.
---
 linksbuilder.go      | 52 ++++++++++++++++++--------------
 linksbuilder_test.go | 72 +++++++++++++++++++++-----------------------
 2 files changed, 65 insertions(+), 59 deletions(-)

diff --git a/linksbuilder.go b/linksbuilder.go
index 1a6d0cc..c3ae6d0 100644
--- a/linksbuilder.go
+++ b/linksbuilder.go
@@ -52,34 +52,22 @@ func renderAndrewTableOfContentsWithDirectories(siblings []Page, startingPage Pa
 		directoriesAndContents[path] = append(directoriesAndContents[path], sibling)
 	}
 
-	keys := make([]string, 0, len(directoriesAndContents))
-	for k := range directoriesAndContents {
-		keys = append(keys, k)
-	}
-
-	sort.Slice(keys, func(i, j int) bool {
-		slashesI := countSlashes(keys[i])
-		slashesJ := countSlashes(keys[j])
-		if slashesI == slashesJ {
-			return keys[i] < keys[j] // Lexicographical order if the number of slashes is the same
-		}
-		return slashesI < slashesJ // Primary order by number of slashes
-	})
+	// Lexicographical order if the number of slashes is the same
+	// Primary order by number of slashes
+	directoriesInDepthOrder := keysOrderedByNumberOfSlashes(directoriesAndContents)
 
 	linkCount := 0
 	dirCount := 1
 
-	links.Write([]byte("<ul style=\"padding-left: 10px;\">\n"))
+	links.Write([]byte("<div class=\"AndrewTableOfContentsWithDirectories\">\n"))
+	for _, parentDir := range directoriesInDepthOrder {
 
-	for parentDir, siblingPages := range directoriesAndContents {
+		links.Write([]byte("<ul>\n"))
 
-		if linkCount != 0 {
-			links.Write([]byte("<ul>\n"))
-		}
 		if parentDir != "" {
 			links.Write([]byte("<h5 style=\"display: inline;\">" + parentDir + "</h5>\n"))
 		}
-		for _, sibling := range siblingPages {
+		for _, sibling := range directoriesAndContents[parentDir] {
 			//Do not include the page we're starting with. These and index.html pages are both to be skipped.
 			if sibling == startingPage {
 				continue
@@ -88,12 +76,15 @@ func renderAndrewTableOfContentsWithDirectories(siblings []Page, startingPage Pa
 			links.Write(buildAndrewTableOfContentsLink(sibling.UrlPath, sibling.Title, sibling.PublishTime.Format(time.DateOnly), linkCount))
 			linkCount = linkCount + 1
 		}
+		// If I write the </ul> for dirCount 0 here, it closes the <ul> that establishes the style
+		// of padding that we have. I don't want that.
+		if dirCount != 0 {
+			links.Write([]byte("</ul>\n"))
+		}
 		dirCount = dirCount + 1
 	}
 
-	for range dirCount - 1 {
-		links.Write([]byte("</ul>\n"))
-	}
+	links.Write([]byte("</div>\n"))
 
 	t, err := template.New(startingPage.UrlPath).Parse(startingPage.Content)
 
@@ -109,6 +100,23 @@ func renderAndrewTableOfContentsWithDirectories(siblings []Page, startingPage Pa
 	return templateBuffer.Bytes(), nil
 }
 
+func keysOrderedByNumberOfSlashes(directoriesAndContents map[string][]Page) []string {
+	keysOrderedByLength := make([]string, 0, len(directoriesAndContents))
+	for k := range directoriesAndContents {
+		keysOrderedByLength = append(keysOrderedByLength, k)
+	}
+
+	sort.Slice(keysOrderedByLength, func(i, j int) bool {
+		slashesI := countSlashes(keysOrderedByLength[i])
+		slashesJ := countSlashes(keysOrderedByLength[j])
+		if slashesI == slashesJ {
+			return keysOrderedByLength[i] < keysOrderedByLength[j]
+		}
+		return slashesI < slashesJ
+	})
+	return keysOrderedByLength
+}
+
 func renderAndrewTableOfContents(siblings []Page, startingPage Page) ([]byte, error) {
 	var links bytes.Buffer
 
diff --git a/linksbuilder_test.go b/linksbuilder_test.go
index 0944d20..9808324 100644
--- a/linksbuilder_test.go
+++ b/linksbuilder_test.go
@@ -95,9 +95,11 @@ func TestInvalidAndrewPublishTimeContentDoesNotCrashTheWebServer(t *testing.T) {
 // by modtime and in another order by andrew-publish-time time, so that we can tell
 // what file attribute andrew is actually sorting on.
 func TestOneArticleAppearsUnderParentDirectoryForAndrewTableOfContentsGrouped(t *testing.T) {
-	expected := `<ul style="padding-left: 10px;">
+	expected := `<div class="AndrewTableOfContentsWithDirectories">
+<ul>
 <li><a class="andrewtableofcontentslink" id="andrewtableofcontentslink0" href="otherPage.html">otherPage.html</a> - <span class="publish-date">0001-01-01</span></li>
 </ul>
+</div>
 `
 	contentRoot := fstest.MapFS{
 		"groupedContents.html": &fstest.MapFile{Data: []byte(`{{.AndrewTableOfContentsWithDirectories}}`)},
@@ -125,39 +127,35 @@ func TestOneArticleAppearsUnderParentDirectoryForAndrewTableOfContentsGrouped(t
 	}
 }
 
-// func TestArticlesAppearUnderParentDirectoryForAndrewTableOfContentsGrouped(t *testing.T) {
-// 	expected := `<ul style="padding-left: 10px;">
-// <h5 style="display: inline;">parentDir/</h5>
-// <li><a class="andrewtableofcontentslink" id="andrewtableofcontentslink0" href="parentDir/displayme.html">displayme.html</a></li>
-// <h5 style="display: inline;">childDir/</h5>
-// <ul>
-// <li><a class="andrewtableofcontentslink" id="andrewtableofcontentslink1" href="parentDir/childDir/1-2-3.html">1-2-3.html</li>
-// </ul>
-// </ul>
-// </ul>
-// `
-// 	contentRoot := fstest.MapFS{
-// 		"groupedContents.html":          &fstest.MapFile{Data: []byte(`{{.AndrewTableOfContentsWithDirectories}}`)},
-// 		"parentDir/index.html":          &fstest.MapFile{},
-// 		"parentDir/displayme.html":      &fstest.MapFile{},
-// 		"parentDir/childDir/1-2-3.html": &fstest.MapFile{},
-// 	}
-
-// 	s := newTestAndrewServer(t, contentRoot)
-// 	resp, err := http.Get(s.BaseUrl + "/groupedContents.html")
-// 	if err != nil {
-// 		t.Fatal(err)
-// 	}
-
-// 	if resp.StatusCode != http.StatusOK {
-// 		t.Fatalf("unexpected status %q", resp.Status)
-// 	}
-// 	received, err := io.ReadAll(resp.Body)
-// 	if err != nil {
-// 		t.Fatal(err)
-// 	}
-
-// 	if expected != string(received) {
-// 		t.Errorf(cmp.Diff(expected, received))
-// 	}
-// }
+func TestArticlesFromChildDirectoriesAreNotShown(t *testing.T) {
+	expected := `<div class="AndrewTableOfContentsWithDirectories"><ul>
+<h5>parentDir/</h5>
+<li><a class="andrewtableofcontentslink" id="andrewtableofcontentslink0" href="parentDir/displayme.html">displayme.html</a> - <span class="publish-date">0001-01-01</span></li>
+</ul>
+</div>
+`
+	contentRoot := fstest.MapFS{
+		"groupedContents.html":          &fstest.MapFile{Data: []byte(`{{.AndrewTableOfContentsWithDirectories}}`)},
+		"parentDir/index.html":          &fstest.MapFile{},
+		"parentDir/displayme.html":      &fstest.MapFile{},
+		"parentDir/childDir/1-2-3.html": &fstest.MapFile{},
+	}
+
+	s := newTestAndrewServer(t, contentRoot)
+	resp, err := http.Get(s.BaseUrl + "/groupedContents.html")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		t.Fatalf("unexpected status %q", resp.Status)
+	}
+	received, err := io.ReadAll(resp.Body)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if expected != string(received) {
+		t.Errorf("Expected:\n" + expected + "\n Received:\n" + string(received))
+	}
+}

From ada963ad6c2faf3f1ca8307746f5d7b9a1b73476 Mon Sep 17 00:00:00 2001
From: Gwyn <gwyn@playtechnique.io>
Date: Sat, 17 Aug 2024 07:22:06 -0600
Subject: [PATCH 4/7] Handle the case of a single page in the starting page
 directory.

---
 linksbuilder.go      | 69 +++++++++++++++++++++++++++-----------------
 linksbuilder_test.go | 11 +++++--
 2 files changed, 50 insertions(+), 30 deletions(-)

diff --git a/linksbuilder.go b/linksbuilder.go
index c3ae6d0..74a8fbc 100644
--- a/linksbuilder.go
+++ b/linksbuilder.go
@@ -43,56 +43,55 @@ func countSlashes(s string) int {
 }
 
 func renderAndrewTableOfContentsWithDirectories(siblings []Page, startingPage Page) ([]byte, error) {
-	var links bytes.Buffer
+	var html bytes.Buffer
 	var templateBuffer bytes.Buffer
-	directoriesAndContents := make(map[string][]Page)
-
-	for _, sibling := range siblings {
-		path, _ := path.Split(sibling.UrlPath)
-		directoriesAndContents[path] = append(directoriesAndContents[path], sibling)
-	}
+	directoriesAndContents := mapFromPagePaths(siblings)
 
-	// Lexicographical order if the number of slashes is the same
-	// Primary order by number of slashes
 	directoriesInDepthOrder := keysOrderedByNumberOfSlashes(directoriesAndContents)
-
 	linkCount := 0
-	dirCount := 1
 
-	links.Write([]byte("<div class=\"AndrewTableOfContentsWithDirectories\">\n"))
+	html.Write([]byte("<div class=\"AndrewTableOfContentsWithDirectories\">\n"))
+
 	for _, parentDir := range directoriesInDepthOrder {
+		// Skip the root directory if it only contains the starting page
+		if parentDir == "" && len(directoriesAndContents[parentDir]) == 1 && directoriesAndContents[parentDir][0] == startingPage {
+			continue
+		}
 
-		links.Write([]byte("<ul>\n"))
+		// Start the list for the directory
+		html.Write([]byte("<ul>\n"))
 
+		// Add the directory heading inside the <ul>
 		if parentDir != "" {
-			links.Write([]byte("<h5 style=\"display: inline;\">" + parentDir + "</h5>\n"))
+			if countSlashes(parentDir) == 1 {
+				html.Write([]byte("<h5>" + parentDir + "</h5>\n"))
+			} else {
+				dirs := strings.Split(parentDir, "/")
+				html.Write([]byte("<h5><span class=\"AndrewParentDir\">" + dirs[0] + "/</span>" + strings.Join(dirs[1:], "/") + "</h5>\n"))
+			}
 		}
+
+		// Add the links to the list
 		for _, sibling := range directoriesAndContents[parentDir] {
-			//Do not include the page we're starting with. These and index.html pages are both to be skipped.
+			// Skip the starting page
 			if sibling == startingPage {
 				continue
 			}
-
-			links.Write(buildAndrewTableOfContentsLink(sibling.UrlPath, sibling.Title, sibling.PublishTime.Format(time.DateOnly), linkCount))
-			linkCount = linkCount + 1
-		}
-		// If I write the </ul> for dirCount 0 here, it closes the <ul> that establishes the style
-		// of padding that we have. I don't want that.
-		if dirCount != 0 {
-			links.Write([]byte("</ul>\n"))
+			html.Write(buildAndrewTableOfContentsLink(sibling.UrlPath, sibling.Title, sibling.PublishTime.Format(time.DateOnly), linkCount))
+			linkCount++
 		}
-		dirCount = dirCount + 1
+
+		html.Write([]byte("</ul>\n"))
 	}
 
-	links.Write([]byte("</div>\n"))
+	html.Write([]byte("</div>\n"))
 
 	t, err := template.New(startingPage.UrlPath).Parse(startingPage.Content)
-
 	if err != nil {
 		panic(err)
 	}
 
-	err = t.Execute(&templateBuffer, map[string]string{"AndrewTableOfContentsWithDirectories": links.String()})
+	err = t.Execute(&templateBuffer, map[string]string{"AndrewTableOfContentsWithDirectories": html.String()})
 	if err != nil {
 		return templateBuffer.Bytes(), err
 	}
@@ -100,6 +99,22 @@ func renderAndrewTableOfContentsWithDirectories(siblings []Page, startingPage Pa
 	return templateBuffer.Bytes(), nil
 }
 
+// mapFromPagePaths takes an array of pages and returns a map of those pages in which the keys
+// are the directories containing a specific page and the value is the path inside the directory
+// to that page.
+// So pages at page.html, parent/page1.html, parent/page2.html and parent/child/page.html
+// become {"": "page.html", "parent": ["page1.html","page2.html"], "parent/child": ["page.html"]}
+// The indexes are directory names as strings; the values are arrays of Pages.
+func mapFromPagePaths(siblings []Page) map[string][]Page {
+	directoriesAndContents := make(map[string][]Page)
+
+	for _, sibling := range siblings {
+		path, _ := path.Split(sibling.UrlPath)
+		directoriesAndContents[path] = append(directoriesAndContents[path], sibling)
+	}
+	return directoriesAndContents
+}
+
 func keysOrderedByNumberOfSlashes(directoriesAndContents map[string][]Page) []string {
 	keysOrderedByLength := make([]string, 0, len(directoriesAndContents))
 	for k := range directoriesAndContents {
diff --git a/linksbuilder_test.go b/linksbuilder_test.go
index 9808324..1f5e290 100644
--- a/linksbuilder_test.go
+++ b/linksbuilder_test.go
@@ -94,7 +94,7 @@ func TestInvalidAndrewPublishTimeContentDoesNotCrashTheWebServer(t *testing.T) {
 // This test requires having several files which are in one order when sorted
 // by modtime and in another order by andrew-publish-time time, so that we can tell
 // what file attribute andrew is actually sorting on.
-func TestOneArticleAppearsUnderParentDirectoryForAndrewTableOfContentsGrouped(t *testing.T) {
+func TestOneArticleAppearsUnderParentDirectoryForAndrewTableOfContentsWithDirectories(t *testing.T) {
 	expected := `<div class="AndrewTableOfContentsWithDirectories">
 <ul>
 <li><a class="andrewtableofcontentslink" id="andrewtableofcontentslink0" href="otherPage.html">otherPage.html</a> - <span class="publish-date">0001-01-01</span></li>
@@ -127,11 +127,16 @@ func TestOneArticleAppearsUnderParentDirectoryForAndrewTableOfContentsGrouped(t
 	}
 }
 
-func TestArticlesFromChildDirectoriesAreNotShown(t *testing.T) {
-	expected := `<div class="AndrewTableOfContentsWithDirectories"><ul>
+func TestArticlesFromChildDirectoriesAreShownForAndrewTableOfContentsWithDirectories(t *testing.T) {
+	expected := `<div class="AndrewTableOfContentsWithDirectories">
+<ul>
 <h5>parentDir/</h5>
 <li><a class="andrewtableofcontentslink" id="andrewtableofcontentslink0" href="parentDir/displayme.html">displayme.html</a> - <span class="publish-date">0001-01-01</span></li>
 </ul>
+<ul>
+<h5><span class="AndrewParentDir">parentDir/</span>childDir/</h5>
+<li><a class="andrewtableofcontentslink" id="andrewtableofcontentslink1" href="parentDir/childDir/1-2-3.html">1-2-3.html</a> - <span class="publish-date">0001-01-01</span></li>
+</ul>
 </div>
 `
 	contentRoot := fstest.MapFS{

From 44c73b0130c804dfc32c62c4083ded874faabb68 Mon Sep 17 00:00:00 2001
From: Gwyn <gwyn@playtechnique.io>
Date: Sat, 17 Aug 2024 07:36:42 -0600
Subject: [PATCH 5/7] Removing test styling page

---
 page.html | 14 --------------
 1 file changed, 14 deletions(-)
 delete mode 100644 page.html

diff --git a/page.html b/page.html
deleted file mode 100644
index 3983a30..0000000
--- a/page.html
+++ /dev/null
@@ -1,14 +0,0 @@
-<!doctype HTML>
-<head>
-<title>directory layout page</title>
-</head>
-
-<body>
-    <ul style="padding-left: 10px;"">
-        <li><a href="index.html">index.html</a></li>
-        <h5 style="display: inline;">parentDir</h5>
-        <ul>
-            <li><a href="parentDir/page.html">page.html</a></li>
-        </ul>
-    </ul>
-</body>
\ No newline at end of file

From 8602114edd02d64a9d95ef1e9a0272850512403c Mon Sep 17 00:00:00 2001
From: Gwyn <gwyn@playtechnique.io>
Date: Sat, 17 Aug 2024 08:21:56 -0600
Subject: [PATCH 6/7] Commit to andrew-page- prefix for the publish dates

---
 linksbuilder.go      | 2 +-
 linksbuilder_test.go | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/linksbuilder.go b/linksbuilder.go
index 74a8fbc..05f12bf 100644
--- a/linksbuilder.go
+++ b/linksbuilder.go
@@ -160,7 +160,7 @@ func renderAndrewTableOfContents(siblings []Page, startingPage Page) ([]byte, er
 
 // buildAndrewTableOfContentsLink encapsulates the format of the link
 func buildAndrewTableOfContentsLink(urlPath string, title string, publishDate string, cssIdNumber int) []byte {
-	link := fmt.Sprintf("<li><a class=\"andrewtableofcontentslink\" id=\"andrewtableofcontentslink%s\" href=\"%s\">%s</a> - <span class=\"publish-date\">%s</span></li>\n", fmt.Sprint(cssIdNumber), urlPath, title, publishDate)
+	link := fmt.Sprintf("<li><a class=\"andrewtableofcontentslink\" id=\"andrewtableofcontentslink%s\" href=\"%s\">%s</a> - <span class=\"andrew-page-publish-date\">%s</span></li>\n", fmt.Sprint(cssIdNumber), urlPath, title, publishDate)
 	b := []byte(link)
 	return b
 }
diff --git a/linksbuilder_test.go b/linksbuilder_test.go
index 1f5e290..03e3db2 100644
--- a/linksbuilder_test.go
+++ b/linksbuilder_test.go
@@ -97,7 +97,7 @@ func TestInvalidAndrewPublishTimeContentDoesNotCrashTheWebServer(t *testing.T) {
 func TestOneArticleAppearsUnderParentDirectoryForAndrewTableOfContentsWithDirectories(t *testing.T) {
 	expected := `<div class="AndrewTableOfContentsWithDirectories">
 <ul>
-<li><a class="andrewtableofcontentslink" id="andrewtableofcontentslink0" href="otherPage.html">otherPage.html</a> - <span class="publish-date">0001-01-01</span></li>
+<li><a class="andrewtableofcontentslink" id="andrewtableofcontentslink0" href="otherPage.html">otherPage.html</a> - <span class="andrew-page-publish-date">0001-01-01</span></li>
 </ul>
 </div>
 `
@@ -131,11 +131,11 @@ func TestArticlesFromChildDirectoriesAreShownForAndrewTableOfContentsWithDirecto
 	expected := `<div class="AndrewTableOfContentsWithDirectories">
 <ul>
 <h5>parentDir/</h5>
-<li><a class="andrewtableofcontentslink" id="andrewtableofcontentslink0" href="parentDir/displayme.html">displayme.html</a> - <span class="publish-date">0001-01-01</span></li>
+<li><a class="andrewtableofcontentslink" id="andrewtableofcontentslink0" href="parentDir/displayme.html">displayme.html</a> - <span class="andrew-page-publish-date">0001-01-01</span></li>
 </ul>
 <ul>
 <h5><span class="AndrewParentDir">parentDir/</span>childDir/</h5>
-<li><a class="andrewtableofcontentslink" id="andrewtableofcontentslink1" href="parentDir/childDir/1-2-3.html">1-2-3.html</a> - <span class="publish-date">0001-01-01</span></li>
+<li><a class="andrewtableofcontentslink" id="andrewtableofcontentslink1" href="parentDir/childDir/1-2-3.html">1-2-3.html</a> - <span class="andrew-page-publish-date">0001-01-01</span></li>
 </ul>
 </div>
 `

From 4c2b0db323bdc43fbb6b6091843ff4ae3fe3c9e5 Mon Sep 17 00:00:00 2001
From: Gwyn <gwyn@playtechnique.io>
Date: Sat, 17 Aug 2024 09:13:58 -0600
Subject: [PATCH 7/7] Primarily improves the README

---
 README.md            | 115 ++++++++++++++++++++++++++++++++++++-------
 linksbuilder_test.go |   1 +
 2 files changed, 98 insertions(+), 18 deletions(-)

diff --git a/README.md b/README.md
index 85804aa..218898a 100644
--- a/README.md
+++ b/README.md
@@ -1,9 +1,18 @@
 # andrew
+Andrew is a web server like 90s web servers used to be™. It renders web pages from the file system, no databases
+involved. This is the basic design restriction that informs feature decisions. You get started by writing an "index.html"
+file and then running Andrew from that directory. 
 
-I wanted an http server that allows me to add a simple annotation into an index.html that is replaced
+I wanted an http server that allows me to add a simple go template instruction into an index.html that is replaced
 with the contents of any html files that are below the current index.html in the file system hierarchy.
 
-It's grown a little to include a small sitemap generator.  
+Andrew contains the concept of an AndrewPage. This structure makes various pieces of metadata stored within your web page
+available to Andrew for creating links and sorting pages in the various tables of contents available (see below). The specifics
+are explained below, but conceptually I'm trying to use standard html elements to inform Andrew about site metadata. For more 
+you may want to check the [Architecture.md](./ARCHITECTURE.md)
+
+Andrew includes a simple sitemap generator. Your new website needs some way to establish its identity with search engines,
+after all.
 
 ## To install it
 
@@ -24,8 +33,50 @@ address is the address you want to bind the server to. Specify as an address:por
 baseUrl is the hostname you're serving from. This is a part of sitemaps and future rss feeds. It also contains the protocol
 e.g. `https://playtechnique.io`
 
+It, unfortunately, does not terminate SSL at this point. If you include a copy of Nginx as a reverse proxy, as is standard
+in kubernetes, nginx can terminate SSL for you. I'll get to SSL, just be patient with me ❤️
+
+# Feature Specifics
+## Andrew's Custom Page Elements
+### Valid Go Template Instructions for Rendering Page Structures
+```text
+.AndrewTableOfContents
+.AndrewTableOfContentsWithDirectories
+```
+These are for generating lists of web pages that exist at the same level in the file system as the web page and in child directories. 
+
+Andrew sorts by page publish date. This publish date is tricky for a file-based web server to get consistent, so here's the rules:
+1. If you have the tag `<meta name="andrew-publish-time" content="YYYY-MM-DD"/>`, Andrew uses this date.
+2. Andrew uses the page's mtime. This means that if you edit a page that does not contain the `andrew-publish-time` element, then you will push it back to the top of the list.
+
+If your page contains an `andrew-publish-time` meta element, the time must be formatted in YYYY-MM-DD format. Minutes and hours aren't supported yet.
+I don't write a lot, so I don't need granularity beyond a single day. Adding finer granularity isn't hard; feel free to ask for it or write a PR.
+
+
+### Semantically Meaningful Andrew-specific HTML elements
+```html    
+<meta name="andrew-publish-time" content="YYYY-MM-DD"/>
+<title>Your page title</title>
+```
+
+All `meta` elements are actually parsed in the [Andrew Page](./page.go), but Andrew doesn't use a lot of them just yet.
+
+### Custom CSS IDs and classes
+I've tried to consistently include the string `andrew` in front of any CSS classes or IDs, so they're less likely to
+clash with your whimsy for laying out your own site.
+
+The reason these classes and IDs exist is simple: it makes it easier for you to style Andrew's unstyled HTML. I don't want
+Andrew making decisions about your website's layout.
+
+I include classes and IDs that get my sites looking how I want. If you need more, file a request.
+
+### How does the .AndrewTableOfContents render?
+AndrewTableOfContents is for rendering a table of contents of the pages beneath the current page. It only lists page links.
+If you want your links grouped by directories, check out `.AndrewTableOfContentsWithDirectories`.
+
+This is handled in linksbuilder.go. I try to keep this README up to date, but if seems like it doesn't sync with reality
+the final word is the source code.
 
-## rendering the .AndrewTableOfContents
 Given this file system structure:
 ```text
 index.html
@@ -47,18 +98,56 @@ fanfics/
 if articles/index.html contains `{{ .AndrewTableOfContents }}` anywhere, that will be replaced with:
 
 ```html
-    <a class="andrewtableofcontentslink" id="andrewtableofcontentslink0" href="article-1.html">article 1</a>
-    <a class="andrewtableofcontentslink" id="andrewtableofcontentslink1" href="article-2.html">article 2</a>
+    <a class="andrewtableofcontentslink" id="andrewtableofcontentslink0" href="article-1.html">article 1</a>  - <span class=\"publish-date\">0000-00-01</span></li>
+    <a class="andrewtableofcontentslink" id="andrewtableofcontentslink1" href="article-2.html">article 2</a>  - <span class=\"publish-date\">0000-00-01</span></li>
 ```
 
 if fanfics/index.html contains `{{ .AndrewTableOfContents }}`, that'll be replaced with:
 
 ```html
-    <a class="andrewtableofcontentslink" id="andrewtableofcontentslink0" href="story-1/potter-and-draco.html">Potter and Draco</a>
-    <a class="andrewtableofcontentslink" id="andrewtableofcontentslink1" href="story-2/what-if-elves-rode-mice-pt1.html">what-if-elves-rode-mice-pt1.html</a>
-    <a class="andrewtableofcontentslink" id="andrewtableofcontentslink2" href="story-2/what-if-elves-rode-mice-pt1.html">what-if-elves-rode-mice-pt2.html</a>
+    <a class="andrewtableofcontentslink" id="andrewtableofcontentslink0" href="story-1/potter-and-draco.html">Potter and Draco</a>  - <span class=\"publish-date\">0000-00-01</span></li>
+    <a class="andrewtableofcontentslink" id="andrewtableofcontentslink1" href="story-2/what-if-elves-rode-mice-pt1.html">what-if-elves-rode-mice-pt1.html</a>  - <span class=\"andrew-page-publish-date\">0000-00-01</span></li>
+    <a class="andrewtableofcontentslink" id="andrewtableofcontentslink2" href="story-2/what-if-elves-rode-mice-pt1.html">what-if-elves-rode-mice-pt2.html</a>  - <span class=\"andrew-page-publish-date\">0000-00-01</span></li>
 ```
 
+
+## how is the .AndrewTableOfContentsWithDirectories rendered?
+Given this file system structure:
+```text
+groupedContents.html
+articles/
+        index.html #this will be ignored. index.html normally contains its own listing of pages, but this is already a page list.
+        article-1.html
+        article-2.css #this will be ignored; Andrew only links to html files.
+        articles-series/
+                dragons-are-lovely.html
+                dragons-are-fierce.html
+```
+if index.html contains `{{ .AndrewTableOfContentsWithDirectories }}` anywhere, that will be replaced with a `<div>` called AndrewTableOfContentsWithDirectories.
+Inside the `<div>` is a decent representation of all of your content:
+
+```html
+<div class="AndrewTableOfContentsWithDirectories">
+<ul>
+        <h5>articles/</h5>
+        <li><a class="andrewtableofcontentslink" id="andrewtableofcontentslink0" href="articles/article-1.html">article-1.html</a> - <span class="andrew-page-publish-date">0001-01-01</span></li>
+</ul>
+
+<ul>
+        <h5><span class="AndrewParentDir">articles/</span>articles-series/</h5>
+        <li><a class="andrewtableofcontentslink" id="andrewtableofcontentslink1" href="articles/articles-series/dragons-are-lovely.html">dragons-are-lovely.html</a> - <span class="andrew-page-publish-date">0001-01-01</span></li>
+        <li><a class="andrewtableofcontentslink" id="andrewtableofcontentslink1" href="articles/articles-series/dragons-are-fierce.html">dragons-are-fierce.html</a> - <span class="andrew-page-publish-date">0001-01-01</span></li>
+</ul>
+
+</div>
+```
+
+Note the inclusion of a `<span>` around the name of the parent directory. The parent directory name is a bit repetitive, so I wanted to
+be able to style it to not draw attention to it.
+
+If the above seems out of sync with reality, the easiest place to get a canonical representation of what Andrew's building will be
+in [linksbuilder_test.go](./linksbuilder_test.go)
+
 ## page titles
 If a page contains a `<title>` element, Andrew picks it up and uses that as the name of a link.
 If the page does not contain a `<title>` element, then Andrew will use the file name of that file as the link name.
@@ -66,18 +155,8 @@ If the page does not contain a `<title>` element, then Andrew will use the file
 ## meta elements
 Andrew parses meta tags and makes them accessible on its AndrewPage object.
 
-For a meta element to be picked up, it must be formatted with andrew- prepending the meta element's name, like this `<meta name="andrew-<rest of the name>" value="your-value">`
-
 ### valid meta elements
 <meta name="andrew-publish-time" value="2024-03-12">
-<meta name="andrew-tag" value="diary entry">
-
-## ordering of pages
-If a page contains the meta element `<meta name=andrew-publish-time value="2024-03-12">` in its `<head>`, Andrew orders on these tags.
-If the page does not contain the meta element, it uses the mtime of the file to try and determine ordering. This means that if you edit a page
-that does not contain the `andrew-publish-time` element, then you will push it back to the top of the list.
-
-If your page contains an `andrew-publish-time` meta element, the time must be formatted in YYYY-MM-DD format. Minutes and hours aren't supported yet.
 
 ## sitemap.xml
 When the endpoint `baseUrl/sitemap.xml` is visited, Andrew will automatically generate a sitemap containing paths to all html pages.
diff --git a/linksbuilder_test.go b/linksbuilder_test.go
index 03e3db2..7bf655e 100644
--- a/linksbuilder_test.go
+++ b/linksbuilder_test.go
@@ -142,6 +142,7 @@ func TestArticlesFromChildDirectoriesAreShownForAndrewTableOfContentsWithDirecto
 	contentRoot := fstest.MapFS{
 		"groupedContents.html":          &fstest.MapFile{Data: []byte(`{{.AndrewTableOfContentsWithDirectories}}`)},
 		"parentDir/index.html":          &fstest.MapFile{},
+		"parentDir/styles.css":          &fstest.MapFile{},
 		"parentDir/displayme.html":      &fstest.MapFile{},
 		"parentDir/childDir/1-2-3.html": &fstest.MapFile{},
 	}