Enable support for rendering all markdown files. (#175)

Author: patrickdappollonio

README.md

@@ -92,8 +92,10 @@ Flags:
       --disable-redirects           disable redirection file handling
       --ensure-unexpired-jwt        enable time validation for JWT claims "exp" and "nbf"
       --etag-max-size string        maximum size for etag header generation, where bigger size = more memory usage (default "5M")
+      --render-all-markdown         if enabled, all Markdown files will be rendered using the same rendering as the directory listing READMEs
       --gzip                        enable gzip compression for supported content-types
   -h, --help                        help for http-server
+      --hide-files-in-markdown      hide file and directory listing in markdown rendering
       --hide-links                  hide the links to this project's source code visible in the header and footer
       --jwt-key string              signing key for JWT authentication
       --markdown-before-dir         render markdown content before the directory listing

app.go

@@ -124,6 +124,7 @@ func run() error {
 	flags.StringVar(&srv.CustomNotFoundPage, "custom-404", "", "custom \"page not found\" to serve")
 	flags.IntVar(&srv.CustomNotFoundStatusCode, "custom-404-code", 0, "custtom status code for pages not found")
 	flags.BoolVar(&srv.HideFilesInMarkdown, "hide-files-in-markdown", false, "hide file and directory listing in markdown rendering")
+	flags.BoolVar(&srv.FullMarkdownRender, "render-all-markdown", false, "if enabled, all Markdown files will be rendered using the same rendering as the directory listing READMEs")
 
 	//nolint:wrapcheck // no need to wrap this error
 	return rootCmd.Execute()

internal/server/handlers.go

@@ -76,10 +76,52 @@ func (s *Server) showOrRender(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	// If the path is not a directory, then it's a file, so we can render it
+	// If the path is not a directory, then it's a file, so we can render it,
+	// let's check first if it's a markdown file
+	if ext := strings.ToLower(filepath.Ext(currentPath)); ext == ".md" || ext == ".markdown" {
+		s.serveMarkdown(currentPath, w, r)
+		return
+	}
+
 	s.serveFile(0, currentPath, w, r)
 }
 
+func (s *Server) serveMarkdown(requestedPath string, w http.ResponseWriter, r *http.Request) {
+	// Find if among the files there's a markdown readme
+	var markdownContent bytes.Buffer
+	if err := s.renderMarkdownFile(requestedPath, &markdownContent); err != nil {
+		s.printWarningf("unable to generate markdown: %s", err)
+		httpError(http.StatusInternalServerError, w, "unable to generate markdown for current directory -- see application logs for more information")
+		return
+	}
+
+	// Define the parent directory
+	parent := getParentURL(s.PathPrefix, r.URL.Path)
+
+	// Render the directory listing
+	content := map[string]any{
+		"DirectoryRootPath":      s.PathPrefix,
+		"PageTitle":              s.PageTitle,
+		"CurrentPath":            r.URL.Path,
+		"CacheBuster":            s.cacheBuster,
+		"RequestedPath":          requestedPath,
+		"IsRoot":                 s.PathPrefix == r.URL.Path,
+		"UpDirectory":            parent,
+		"Files":                  nil,
+		"ShouldRenderFiles":      false, // we don't want file rendering for non index pages
+		"IsSingleMarkdownRender": true,  // we want to differentiate single markdown render pages
+		"HideLinks":              s.HideLinks,
+		"MarkdownContent":        markdownContent.String(),
+		"MarkdownBeforeDir":      s.MarkdownBeforeDir,
+	}
+
+	if err := s.templates.ExecuteTemplate(w, "app.tmpl", content); err != nil {
+		s.printWarningf("unable to render directory listing: %s", err)
+		httpError(http.StatusInternalServerError, w, "unable to render directory listing -- see application logs for more information")
+		return
+	}
+}
+
 func (s *Server) walk(requestedPath string, w http.ResponseWriter, r *http.Request) {
 	// Append index.html or index.htm to the path and see if the index
 	// file exists, if so, return it instead
@@ -148,7 +190,7 @@ func (s *Server) walk(requestedPath string, w http.ResponseWriter, r *http.Reque
 
 	// Find if among the files there's a markdown readme
 	var markdownContent bytes.Buffer
-	if err := s.generateMarkdown(requestedPath, files, &markdownContent); err != nil {
+	if err := s.findAndGenerateMarkdown(requestedPath, files, &markdownContent); err != nil {
 		s.printWarningf("unable to generate markdown: %s", err)
 		httpError(http.StatusInternalServerError, w, "unable to generate markdown for current directory -- see application logs for more information")
 		return

internal/server/markdown.go

@@ -22,36 +22,12 @@ import (
 // in the directory listing page.
 var allowedIndexFiles = []string{"README.md", "README.markdown", "readme.md", "readme.markdown", "index.md", "index.markdown"}
 
-// generateMarkdown generates the markdown needed to render the content
-// in the directory listing page
-func (s *Server) generateMarkdown(pathLocation string, files []os.FileInfo, placeholder *bytes.Buffer) error {
-	// Check if markdown is enabled or not, if not, don't bother running
-	// the rest of the code
-	if s.DisableMarkdown {
-		return nil
-	}
-
-	// Find a file name among the available options that can be rendered
-	var foundFilename string
-	for _, f := range files {
-		for _, allowed := range allowedIndexFiles {
-			if f.Name() == allowed {
-				foundFilename = allowed
-				break
-			}
-		}
-	}
-
-	// If we couldn't find one, we exit
-	if foundFilename == "" {
-		return nil
-	}
-
+// renderMarkdownFile renders a markdown file from a given location
+func (s *Server) renderMarkdownFile(location string, v *bytes.Buffer) error {
 	// Generate a full path then open the file
-	fullpath := path.Join(pathLocation, foundFilename)
-	f, err := os.Open(fullpath)
+	f, err := os.Open(location)
 	if err != nil {
-		return fmt.Errorf("unable to open markdown file %q: %w", fullpath, err)
+		return fmt.Errorf("unable to open markdown file %q: %w", location, err)
 	}
 
 	// Close the file when we're done
@@ -60,7 +36,7 @@ func (s *Server) generateMarkdown(pathLocation string, files []os.FileInfo, plac
 	// Copy the file contents to an intermediate buffer
 	var buf bytes.Buffer
 	if _, err := io.Copy(&buf, f); err != nil {
-		return fmt.Errorf("unable to read markdown file %q: %w", fullpath, err)
+		return fmt.Errorf("unable to read markdown file %q: %w", location, err)
 	}
 
 	// Configure goldmark
@@ -84,13 +60,43 @@ func (s *Server) generateMarkdown(pathLocation string, files []os.FileInfo, plac
 	)
 
 	// Render the markdown
-	if err := md.Convert(buf.Bytes(), placeholder); err != nil {
-		return fmt.Errorf("unable to render markdown file %q: %w", fullpath, err)
+	if err := md.Convert(buf.Bytes(), v); err != nil {
+		return fmt.Errorf("unable to render markdown file %q: %w", location, err)
 	}
 
 	return nil
 }
 
+// generateMarkdown generates the markdown needed to render the content
+// in the directory listing page
+func (s *Server) findAndGenerateMarkdown(pathLocation string, files []os.FileInfo, placeholder *bytes.Buffer) error {
+	// Check if markdown is enabled or not, if not, don't bother running
+	// the rest of the code
+	if s.DisableMarkdown {
+		return nil
+	}
+
+	// Find a file name among the available options that can be rendered
+	var foundFilename string
+	for _, f := range files {
+		for _, allowed := range allowedIndexFiles {
+			if f.Name() == allowed {
+				foundFilename = allowed
+				break
+			}
+		}
+	}
+
+	// If we couldn't find one, we exit
+	if foundFilename == "" {
+		return nil
+	}
+
+	// Generate the full path of the found file
+	fullpath := path.Join(pathLocation, foundFilename)
+	return s.renderMarkdownFile(fullpath, placeholder)
+}
+
 // generateBannerMarkdown generates the markdown needed to render the banner
 // in the directory listing page.
 func (s *Server) generateBannerMarkdown() (string, error) {

internal/server/server.go

@@ -40,6 +40,7 @@ type Server struct {
 	DisableMarkdown     bool
 	MarkdownBeforeDir   bool
 	HideFilesInMarkdown bool
+	FullMarkdownRender  bool
 
 	// Redirection handling
 	DisableRedirects bool

internal/server/startup.go

@@ -78,6 +78,10 @@ func (s *Server) PrintStartup() {
 		fmt.Fprintln(s.LogOutput, startupPrefix, "Markdown rendering before directory listing enabled")
 	}
 
+	if s.FullMarkdownRender {
+		fmt.Fprintln(s.LogOutput, startupPrefix, "All markdown file rendering enabled")
+	}
+
 	if !s.DisableRedirects {
 		if s.redirects != nil {
 			fmt.Fprintf(s.LogOutput, "%s Redirections enabled from %q (found %d redirections)\n", startupPrefix, s.getPathToRedirectionsFile(), len(s.redirects.Rules))

internal/server/templates/listing.tmpl

@@ -45,17 +45,16 @@
     </div>
     {{- end }}
 
-    {{- if not .MarkdownBeforeDir }}{{- with .MarkdownContent }}
+    {{- if not .MarkdownBeforeDir }}{{- if .MarkdownContent }}
     {{ template "markdown" . }}
     {{- end }}{{- end }}
   </div>
 </section>
 
 {{- end }}
 
-
 {{- define "markdown" }}
 <div class="card-large">
-  <div class="markdown-body">{{- . | unsafeHTML }}</div>
+  <div class="markdown-body">{{- .MarkdownContent | unsafeHTML }}</div>
 </div>
 {{- end }}