Made with Org-Mode

I specified the generation of the sitemap using org-publish-project-alist configuration variable:

 1: ;; org-site/build-site.el
 2: (setq org-publish-project-alist
 3:       (list
 4:        (list "org-site:main"
 5:              ;; other configuration settings
 6:              :base-directly: "./content"
 7:              :auto-sitemap t
 8:              :sitemap-title nil
 9:              :sitemap-format-entry 'my/org-publish-org-sitemap-format
10:              :sitemap-function 'my/org-publish-org-sitemap
11:              :sitemap-sort-files 'anti-chronologically
12:              :sitemap-filename "sitemap.org"
13:              :sitemap-style 'tree)))

You'll notice two functions used to format and publish the sitemap entries. sitemap-format-entry takes three arguments (entry, style, and project). We only need to worry about the former. Each entry is a file or directory in the base-directory specified in the org-publish-project-alist above. My my/org-publish-org-sitemap-format defun closely follows the one here.

 1: ;; org-site/build-site.el
 2: (defun my/org-publish-org-sitemap-format (entry style project)
 3:   "Custom sitemap entry formatting: add date"
 4:   (cond ((not (directory-name-p entry))
 5:          (let ((preview (if (my/get-preview (concat "content/" entry))
 6:                             (my/get-preview (concat "content/" entry))
 7:                           "(No preview)")))
 8:          (format "[[file:%s][(%s) %s]]\n%s"
 9:                  entry
10:                  (format-time-string "%Y-%m-%d"
11:                                      (org-publish-find-date entry project))
12:                  (org-publish-find-title entry project)
13:                  preview)))
14:         ((eq style 'tree)
15:          (file-name-nondirectory (directory-file-name entry)))
16:         (t entry)))

This does the following:

1. Read in each entry's path
2. If the entry is not a directory:
   • Check if the my/get-preview defun returns a value (more on my/get-preview later)
   • Assign the preview text to to the preview variable if my/get-preview is not null and assigns "(No preview)" to preview otherwise
   • Format the output as a link to the entry with (Date) Title as the description (using the org-publish-find-date and org-publish-find-title defuns to get the dates/titles of each entry)
   • include the preview (defined above) after a line break
3. If the entry is a directory (e.g. if the first condition returns nil) and if the sitemap-style is tree, return the name of the last subdirectory (e.g. the entry /projects/org-site/content/posts would return posts)
4. Otherwise, just return the entry unchanged.

The entries formatted above are all added to a list (formatted in a tree style to represent the directory structure). We simply convert this list into an org subtree and publish it to the sitemap.org file. The conversion is handled in the my/org-publish-org-sitemap file (again, adapted from here).

1: ;; org-site/build-site.el
2: (defun my/org-publish-org-sitemap (title list)
3:   "Sitemap generation function."
4:   (concat "#+OPTIONS: toc:nil")
5:   (org-list-to-subtree list))

All this does is specify that we do not want a table of contents and that we want our formatted list of entries (with previews) represented as an org subtree.

One part we haven't addressed yet is the generation of previews. There are different approaches out there, but none of them did exactly what I wanted. I borrowed from posts by Seth Morabito and especially Dennis Ogbe. The biggest change I wanted was making sure a default "No preview" would be inserted if there wasn't a preview. I did this by ensuring the my/get-preview defun would return nil (instead of an error) without a preview, and that the entry formatting defun would return "No preview" if my/get-preview was nil.

 1: ;; org-site/build-site.el
 2: (defun my/get-preview (file)
 3:   "get preview text from a file
 4: 
 5: Uses the function here as a starting point:
 6: https://ogbe.net/blog/blogging_with_org.html"
 7:   (with-temp-buffer
 8:     (insert-file-contents file)
 9:     (goto-char (point-min))
10:     (when (re-search-forward "^#\\+BEGIN_PREVIEW$" nil 1)
11:       (goto-char (point-min))
12:       (let ((beg (+ 1 (re-search-forward "^#\\+BEGIN_PREVIEW$" nil 1)))
13:             (end (progn (re-search-forward "^#\\+END_PREVIEW$" nil 1)
14:                         (match-beginning 0))))
15:         (buffer-substring beg end)))))

This defun takes a file path as an argument and:

1. Inserts the contents of the file into a temporary buffer
2. Navigates to the beginning of the buffer and searches forward for the #+BEGIN_PREVIEW block pattern
   • If it fails to locate this pattern, the defun returns nil
   • If it does locate this pattern, it:
     1. Returns to the beginning of the temporary buffer and repeats the search, recording the location of the block pattern, saving its location under the name beg
     2. Searches forward again for the #+END_PREVIEW pattern, saving its location under the name end
     3. Returns the text between beg and end: the user-selected preview text.