Acknowledge kimsaram32 for commit 840ca21

This was done in pull request 728: <https://github.com/protesilaos/denote/pull/728>.
The change is small, meaning that its author does not need to assign
copyright to the Free Software Foundation.

COPYING

@@ -632,7 +632,7 @@ state the exclusion of warranty; and each file should have at least
 the "copyright" line and a pointer to where the full notice is found.
 
     <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) 2021  Protesilaos Stavrou
+    Copyright (C) 2021  Protesilaos
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -652,7 +652,7 @@ Also add information on how to contact you by electronic and paper mail.
   If the program does terminal interaction, make it output a short
 notice like this when it starts in an interactive mode:
 
-    <program>  Copyright (C) 2021  Protesilaos Stavrou
+    <program>  Copyright (C) 2021  Protesilaos
     This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
     This is free software, and you are welcome to redistribute it
     under certain conditions; type `show c' for details.

README.md

@@ -1,5 +1,10 @@
 # denote: Simple notes with an efficient file-naming scheme
 
+New to Denote? Start reading this from the manual:
+<https://protesilaos.com/emacs/denote#h:c54bedb4-5377-4dbd-853c-5870ace6eb33>.
+
+* * *
+
 Denote is a simple note-taking tool for Emacs.  It is based on the idea
 that notes should follow a predictable and descriptive file-naming
 scheme.  The file name must offer a clear indication of what the note is

tests/denote-test.el

@@ -1,9 +1,9 @@
 ;;; denote-test.el --- Unit tests for Denote -*- lexical-binding: t -*-
 
-;; Copyright (C) 2023-2025  Free Software Foundation, Inc.
+;; Copyright (C) 2023-2026  Free Software Foundation, Inc.
 
-;; Author: Protesilaos Stavrou <info@protesilaos.com>
-;; Maintainer: Protesilaos Stavrou <info@protesilaos.com>
+;; Author: Protesilaos <info@protesilaos.com>
+;; Maintainer: Protesilaos <info@protesilaos.com>
 ;; URL: https://github.com/protesilaos/denote
 
 ;; This file is NOT part of GNU Emacs.
@@ -37,21 +37,68 @@
 
 (require 'denote)
 
+(ert-deftest dt-denote-directories--get-paths ()
+  "Test that `denote-directories--get-paths' returns a list of paths."
+  (let ((path "~/Documents/notes"))
+    (should (equal
+             (denote-directories--get-paths path)
+             (list (file-name-as-directory (expand-file-name path))))))
+  (let ((paths (list "~/Documents/notes" "~/Documents/books")))
+    (should (equal
+             (denote-directories--get-paths paths)
+             (mapcar
+              (lambda (path)
+                (file-name-as-directory (expand-file-name path)))
+              paths)))
+    (should (seq-every-p
+             (lambda (path)
+               (string-suffix-p "/" path))
+             (denote-directories--get-paths paths)))
+    (should-not (null (denote-directories--get-paths paths))))
+  (should-error (denote-directories--get-paths 'hello))
+  (should-error (denote-directories--get-paths '(hello)))
+  (should-error (denote-directories--get-paths '(1 2 3))))
+
 (ert-deftest dt-denote--make-denote-directory ()
   "Test that `denote--make-denote-directory' creates the directory."
-  (should (null (denote--make-denote-directory))))
+  (let* ((names (list "denote-test-made-directory-1" "denote-test-made-directory-2"))
+         (directories (mapcar
+                       (lambda (directory)
+                         (file-name-as-directory (expand-file-name directory temporary-file-directory)))
+                       names)))
+    (should-not (denote-directories--make-paths directories))
+    (should (seq-every-p #'file-name-directory directories))
+    (dolist (directory directories)
+      (delete-directory directory))))
 
-(ert-deftest dt-denote-directory ()
-  "Test that variable `denote-directory' returns an absolute directory name."
-  (let ((path (denote-directory)))
-    (should (and (file-directory-p path)
-                 (file-name-absolute-p path)))))
+(ert-deftest dt-denote-directories ()
+  "Test that `denote-directories' returns list of directories.
+It does so by expanding the value of the user option `denote-directory'.
+
+Also see `denote-test--denote--make-denote-directory',
+`denote-test---denote-directories--get-paths'."
+  (let ((denote-directory "/tmp/denote-test-notes"))
+    (should
+     (equal
+      (denote-directories)
+      (list (file-name-as-directory (expand-file-name denote-directory)))))
+    (should (and (file-directory-p denote-directory)
+                 (file-name-absolute-p denote-directory))))
+  (let ((denote-directory (list "/tmp/denote-test-notes-1" "/tmp/denote-test-notes-2")))
+    (should
+     (equal
+      (denote-directories)
+      (mapcar
+       (lambda (directory)
+         (file-name-as-directory (expand-file-name directory)))
+       denote-directory)))
+    (should (and (seq-every-p #'file-directory-p denote-directory)
+                 (seq-every-p #'file-name-absolute-p denote-directory)))))
 
 (ert-deftest dt-denote-sluggify-title ()
   "Test that `denote-sluggify-title' removes punctuation from the string.
 Concretely, remove anything specified in `denote-sluggify-title'."
-  (should (equal (denote-sluggify-title "this-is-!@#test")
-                 "this-is-test")))
+  (should (equal (denote-sluggify-title "this-is-!@#test") "this-is-test")))
 
 (ert-deftest dt-denote-slug-keep-only-ascii ()
   "Test that `denote-slug-keep-only-ascii' removes non-ASCII characters."
@@ -63,101 +110,89 @@ Concretely, remove anything specified in `denote-sluggify-title'."
   "Test that `denote-slug-hyphenate' hyphenates the string.
 Also replace multiple hyphens with a single one and remove any
 leading and trailing hyphen."
-  (should (equal (denote-slug-hyphenate "__  This is   a    test  __  ")
-                 "This-is-a-test")))
+  (should (equal (denote-slug-hyphenate "__  This is   a    test  __  ") "This-is-a-test")))
 
 (ert-deftest dt-denote-sluggify ()
   "Test that `denote-sluggify' sluggifies the string.
 To sluggify is to (i) downcase, (ii) hyphenate, (iii) de-punctuate, and (iv) remove spaces from the string."
-  (should (equal (denote-sluggify 'title " ___ !~!!$%^ This iS a tEsT ++ ?? ")
-                 "this-is-a-test")))
+  (should (equal (denote-sluggify 'title " ___ !~!!$%^ This iS a tEsT ++ ?? ") "this-is-a-test")))
 
 (ert-deftest Ddenote--slug-put-equals ()
   "Test that `denote-slug-put-equals' replaces spaces/underscores with =.
 Otherwise do the same as what is described in
-`dt-denote-slug-hyphenate'.
+`denote-test--denote-slug-hyphenate'.
 
 The use of the equals sign is for the SIGNATURE field of the
 Denote file name."
-  (should (equal (denote-slug-put-equals "__  This is   a    test  __  ")
-                 "This=is=a=test")))
+  (should (equal (denote-slug-put-equals "__  This is   a    test  __  ") "This=is=a=test")))
 
 (ert-deftest dt-denote-sluggify-signature ()
   "Test that `denote-sluggify-signature' sluggifies the string for file signatures.
-This is like `dt-denote-sluggify', except that it also
-accounts for what we describe in `dt-denote-slug-put-equals'."
-  (should (equal (denote-sluggify-signature "--- ___ !~!!$%^ This -iS- a tEsT ++ ?? ")
-                 "this=is=a=test")))
+This is like `denote-test--denote-sluggify', except that it also
+accounts for what we describe in `denote-test--denote-slug-put-equals'."
+  (should (equal (denote-sluggify-signature "--- ___ !~!!$%^ This -iS- a tEsT ++ ?? ") "this=is=a=test")))
 
 (ert-deftest dt-denote-sluggify-keyword ()
   "Test that `denote-sluggify-keyword' sluggifies the string while joining words.
 In this context, to join words is to elimitate any space or
 delimiter between them.
 
-Otherwise, this is like `dt-denote-sluggify'."
-  (should (equal (denote-sluggify-keyword "--- ___ !~!!$%^ This iS a - tEsT ++ ?? ")
-                 "thisisatest")))
+Otherwise, this is like `denote-test--denote-sluggify'."
+  (should (equal (denote-sluggify-keyword "--- ___ !~!!$%^ This iS a - tEsT ++ ?? ") "thisisatest")))
 
 (ert-deftest dt-denote-sluggify-keywords ()
   "Test that `denote-sluggify-keywords' sluggifies a list of strings.
 The function also account for the value of the user option
 `denote-allow-multi-word-keywords'."
-  (should
-   (equal (denote-sluggify-keywords '("one !@# --- one" "   two" "__  three  __"))
-          '("oneone" "two" "three"))))
+  (should (equal (denote-sluggify-keywords '("one !@# --- one" "   two" "__  three  __")) '("oneone" "two" "three"))))
+
+(ert-deftest dt-denote-slug-remove-accents ()
+  "Test that `denote-slug-remove-accents' removed diacretics."
+  (should (string= (denote-slug-remove-accents "ê") "e"))
+  (should (string= (denote-slug-remove-accents "ñ") "n")))
 
 (ert-deftest dt-denote--file-empty-p ()
   "Test that `denote--file-empty-p' returns non-nil on empty file."
-  ;; (should (null (denote--file-empty-p user-init-file))
-  (should (let ((file (make-temp-file "denote-test")))
-            (prog1
-                (denote--file-empty-p file)
-              (delete-file file)))))
+  (let ((file (make-temp-file "denote-test")))
+    (should (denote--file-empty-p file))
+    (with-current-buffer (find-file-noselect file)
+      (insert "Hello world, this is not empty anymore!")
+      (save-buffer))
+    (should-not (denote--file-empty-p file))
+    (delete-file file)))
 
-(ert-deftest dt-denote-file-is-note-p ()
-  "Test that `denote-file-is-note-p' checks that files is a Denote note.
-For our purposes, a note must note be a directory, must satisfy
-`file-regular-p', its path must be part of the variable
-`denote-directory', it must have a Denote identifier in its name,
-and use one of the extensions implied by the variable `denote-file-type'."
-  (should (let* ((tmp (temporary-file-directory))
-                 (denote-directory tmp)
-                 (file (concat tmp "20230522T154900--test__keyword.txt")))
-            (with-current-buffer (find-file-noselect file)
-              (write-file file))
-            (prog1
-                (denote-file-is-note-p file)
-              (delete-file file)))))
+(ert-deftest dt-denote-file-has-denoted-filename-p ()
+  "Test that `denote-file-has-denoted-filename-p' validates a Denote file name."
+  (should (denote-file-has-denoted-filename-p "20230522T154900--test__keyword.txt"))
+  (should-not (denote-file-has-denoted-filename-p "hello")))
 
 (ert-deftest dt-denote-file-has-identifier-p ()
   "Test that `denote-file-has-identifier-p' checks for a Denote identifier."
   (should (denote-file-has-identifier-p "20230522T154900--test__keyword.txt"))
-  (should (null (denote-file-has-identifier-p "T154900--test__keyword.txt"))))
+  (should-not (denote-file-has-identifier-p "T154900--test__keyword.txt")))
 
 (ert-deftest dt-denote-file-has-signature-p ()
   "Test that `denote-file-has-signature-p' checks for a Denote signature."
   (should (denote-file-has-signature-p "20230522T154900==sig--test__keyword.txt"))
-  (should (null (denote-file-has-signature-p "20230522T154900--test__keyword.txt"))))
+  (should-not (denote-file-has-signature-p "20230522T154900--test__keyword.txt")))
 
 (ert-deftest dt-denote-file-has-supported-extension-p ()
   "Test that `denote-file-has-supported-extension-p' matches a supported extension."
-  (should
-   (member
-    (file-name-extension "20230522T154900==sig--test__keyword.txt" :period)
-    (denote-file-type-extensions-with-encryption)))
-  (should
-   (null
-    (member
-     (file-name-extension "20230522T154900==sig--test__keyword" :period)
-     (denote-file-type-extensions-with-encryption)))))
+  (let ((extensions (denote-file-type-extensions-with-encryption)))
+    (should
+     (member
+      (file-name-extension "20230522T154900==sig--test__keyword.txt" :period)
+      extensions))
+    (should-not
+     (member
+      (file-name-extension "20230522T154900==sig--test__keyword" :period)
+      extensions))))
 
 (ert-deftest dt-denote-file-type-extensions ()
   "Test that `denote-file-type-extensions' returns file extensions.
-We check for the common file type extensions, though the user can
-theoretically set `denote-file-types' to nil and handle things on
-their own.  We do not have to test for that scenario, because
-such a user will be redefining large parts of Denote's behaviour
-with regard to file types."
+We check for the common file type extensions, though the user can set
+`denote-file-types' to nil and handle things on their own or, anyhow,
+modify that variable."
   (let ((extensions (denote-file-type-extensions)))
     (should (or (member ".md" extensions)
                 (member ".org" extensions)
@@ -165,7 +200,7 @@ with regard to file types."
 
 (ert-deftest dt-denote-file-type-extensions-with-encryption ()
   "Test that `denote-file-type-extensions-with-encryption' covers encryption.
-Extend what we do in `dt-denote-file-type-extensions'."
+Extend what we do in `denote-test--denote-file-type-extensions'."
   (let ((extensions (denote-file-type-extensions-with-encryption)))
     (should (or (member ".md" extensions)
                 (member ".org" extensions)
@@ -183,360 +218,263 @@ To make the test reproducible, set `denote-date-format' to a value that
 does not involve the time zone."
   (let ((denote-date-format "%Y-%m-%d")
         (denote-front-matter-components-present-even-if-empty-value '(title keywords signature date identifier)))
-    (should (and (equal (denote--format-front-matter "" (date-to-time "20240101T120000") '("") "" "" 'text)
-                        (mapconcat #'identity
-                                   '("title:      "
-                                     "date:       2024-01-01"
-                                     "tags:       "
-                                     "identifier: "
-                                     "signature:  "
-                                     "---------------------------\n\n")
-                                   "\n"))
-
-                 (equal
-                  (denote--format-front-matter
-                   "Some test" (date-to-time "2023-06-05") '("one" "two")
-                   "20230605T102234" "sig" 'text)
-                  (mapconcat #'identity
-                             '("title:      Some test"
-                               "date:       2023-06-05"
-                               "tags:       one  two"
-                               "identifier: 20230605T102234"
-                               "signature:  sig"
-                               "---------------------------\n\n")
-                             "\n"))))
-
-    (should (and (equal (denote--format-front-matter "" (date-to-time "20240101T120000") nil "" "" 'org)
-                        (mapconcat #'identity
-                                   '("#+title:      "
-                                     "#+date:       2024-01-01"
-                                     "#+filetags:   "
-                                     "#+identifier: "
-                                     "#+signature:  "
-                                     "\n")
-                                   "\n"))
-
-                 (equal
-                  (denote--format-front-matter
-                   "Some test" (date-to-time "2023-06-05") '("one" "two")
-                   "20230605T102234" "sig" 'org)
-                  (mapconcat #'identity
-                             '("#+title:      Some test"
-                               "#+date:       2023-06-05"
-                               "#+filetags:   :one:two:"
-                               "#+identifier: 20230605T102234"
-                               "#+signature:  sig"
-                               "\n")
-                             "\n"))))
-
-    (should (and (equal (denote--format-front-matter "" (date-to-time "20240101T120000") nil "" "" 'markdown-yaml)
-                        (mapconcat #'identity
-                                   '("---"
-                                     "title:      \"\""
-                                     "date:       2024-01-01"
-                                     "tags:       []"
-                                     "identifier: \"\""
-                                     "signature:  \"\""
-                                     "---"
-                                     "\n")
-                                   "\n"))
-
-                 (equal
-                  (denote--format-front-matter
-                   "Some test" (date-to-time "2023-06-05") '("one" "two")
-                   "20230605T102234" "sig" 'markdown-yaml)
-                  (mapconcat #'identity
-                             '("---"
-                               "title:      \"Some test\""
-                               "date:       2023-06-05"
-                               "tags:       [\"one\", \"two\"]"
-                               "identifier: \"20230605T102234\""
-                               "signature:  \"sig\""
-                               "---"
-                               "\n")
-                             "\n"))))
-
-    (should (and (equal (denote--format-front-matter "" (date-to-time "20240101T120000") nil "" "" 'markdown-toml)
-                        (mapconcat #'identity
-                                   '("+++"
-                                     "title      = \"\""
-                                     "date       = 2024-01-01"
-                                     "tags       = []"
-                                     "identifier = \"\""
-                                     "signature  = \"\""
-                                     "+++"
-                                     "\n")
-                                   "\n"))
-
-                 (equal
-                  (denote--format-front-matter
-                   "Some test" (date-to-time "2023-06-05") '("one" "two")
-                   "20230605T102234" "sig" 'markdown-toml)
-                  (mapconcat #'identity
-                             '("+++"
-                               "title      = \"Some test\""
-                               "date       = 2023-06-05"
-                               "tags       = [\"one\", \"two\"]"
-                               "identifier = \"20230605T102234\""
-                               "signature  = \"sig\""
-                               "+++"
-                               "\n")
-                             "\n"))))))
+    (should (equal (denote--format-front-matter "" (date-to-time "20240101T120000") '("") "" "" 'text)
+                   (string-join
+                    '("title:      "
+                      "date:       2024-01-01"
+                      "tags:       "
+                      "identifier: "
+                      "signature:  "
+                      "---------------------------\n\n")
+                    "\n")))
+    (should (equal (denote--format-front-matter "Some test" (date-to-time "2023-06-05") '("one" "two") "20230605T102234" "sig" 'text)
+                   (string-join
+                    '("title:      Some test"
+                      "date:       2023-06-05"
+                      "tags:       one  two"
+                      "identifier: 20230605T102234"
+                      "signature:  sig"
+                      "---------------------------\n\n")
+                    "\n")))
+    (should (equal (denote--format-front-matter "" (date-to-time "20240101T120000") nil "" "" 'org)
+                   (string-join
+                    '("#+title:      "
+                      "#+date:       2024-01-01"
+                      "#+filetags:   "
+                      "#+identifier: "
+                      "#+signature:  "
+                      "\n")
+                    "\n")))
+    (should (equal
+             (denote--format-front-matter
+              "Some test" (date-to-time "2023-06-05") '("one" "two")
+              "20230605T102234" "sig" 'org)
+             (string-join
+              '("#+title:      Some test"
+                "#+date:       2023-06-05"
+                "#+filetags:   :one:two:"
+                "#+identifier: 20230605T102234"
+                "#+signature:  sig"
+                "\n")
+              "\n")))
+    (should (equal (denote--format-front-matter "" (date-to-time "20240101T120000") nil "" "" 'markdown-yaml)
+                   (string-join
+                    '("---"
+                      "title:      \"\""
+                      "date:       2024-01-01"
+                      "tags:       []"
+                      "identifier: \"\""
+                      "signature:  \"\""
+                      "---"
+                      "\n")
+                    "\n")))
+    (should (equal (denote--format-front-matter "Some test" (date-to-time "2023-06-05") '("one" "two") "20230605T102234" "sig" 'markdown-yaml)
+             (string-join
+              '("---"
+                "title:      \"Some test\""
+                "date:       2023-06-05"
+                "tags:       [\"one\", \"two\"]"
+                "identifier: \"20230605T102234\""
+                "signature:  \"sig\""
+                "---"
+                "\n")
+              "\n")))
+    (should (equal (denote--format-front-matter "" (date-to-time "20240101T120000") nil "" "" 'markdown-toml)
+                   (string-join
+                    '("+++"
+                      "title      = \"\""
+                      "date       = 2024-01-01"
+                      "tags       = []"
+                      "identifier = \"\""
+                      "signature  = \"\""
+                      "+++"
+                      "\n")
+                    "\n")))
+    (should (equal (denote--format-front-matter "Some test" (date-to-time "2023-06-05") '("one" "two") "20230605T102234" "sig" 'markdown-toml)
+                   (string-join
+                    '("+++"
+                      "title      = \"Some test\""
+                      "date       = 2023-06-05"
+                      "tags       = [\"one\", \"two\"]"
+                      "identifier = \"20230605T102234\""
+                      "signature  = \"sig\""
+                      "+++"
+                      "\n")
+                    "\n")))))
 
 (ert-deftest dt-denote-format-file-name ()
   "Test that `denote-format-file-name' returns all expected paths."
   (let* ((title "Some test")
-         (id (format-time-string denote-id-format (denote-valid-date-p "2023-11-28 05:53:11")))
+         (id (format-time-string denote-date-identifier-format (denote-valid-date-p "2023-11-28 05:53:11")))
          (denote-directory "/tmp/test-denote")
+         (dir (car (denote-directories)))
+         (ext (denote--file-extension 'org))
          (kws '("one" "two")))
-    (should-error (denote-format-file-name
-                    nil
-                    id
-                    kws
-                    title
-                    (denote--file-extension 'org)
-                    ""))
-
-    (should-error (denote-format-file-name
-                    ""
-                    id
-                    kws
-                    title
-                    (denote--file-extension 'org)
-                    ""))
-
-    (should-error (denote-format-file-name
-                   denote-directory ; notice this is the `let' bound value without the suffix
-                   id
-                   kws
-                   title
-                   (denote--file-extension 'org)
-                   ""))
-
-    (should-error (denote-format-file-name
-                   (denote-directory)
-                   ""
-                   nil
-                   ""
-                   (denote--file-extension 'org)
-                   ""))
-
-    (should (equal (denote-format-file-name
-                    (denote-directory)
-                    nil
-                    kws
-                    title
-                    (denote--file-extension 'org)
-                    "")
-                   "/tmp/test-denote/--some-test__one_two.org"))
-
-    (should (equal (denote-format-file-name
-                    (denote-directory)
-                    ""
-                    kws
-                    title
-                    (denote--file-extension 'org)
-                    "")
-                   "/tmp/test-denote/--some-test__one_two.org"))
-
-    (should (equal (denote-format-file-name
-                    (denote-directory)
-                    "0123456"
-                    kws
-                    title
-                    (denote--file-extension 'org)
-                    "")
-                   "/tmp/test-denote/@@0123456--some-test__one_two.org"))
-
-    (should (equal (denote-format-file-name
-                    (denote-directory)
-                    id
-                    kws
-                    title
-                    (denote--file-extension 'org)
-                    "")
-                   "/tmp/test-denote/20231128T055311--some-test__one_two.org"))
-
-    (should (equal (denote-format-file-name
-                    (denote-directory)
-                    id
-                    nil
-                    ""
-                    (denote--file-extension 'org)
-                    "")
-                   "/tmp/test-denote/20231128T055311.org"))
-
-    (should (equal (denote-format-file-name
-                    (denote-directory)
-                    id
-                    nil
-                    nil
-                    (denote--file-extension 'org)
-                    nil)
-                   "/tmp/test-denote/20231128T055311.org"))
-
-    (should (equal (denote-format-file-name
-                    (denote-directory)
-                    id
-                    kws
-                    title
-                    (denote--file-extension 'org)
-                    "sig")
-                   "/tmp/test-denote/20231128T055311==sig--some-test__one_two.org"))))
+    (should-error (denote-format-file-name nil id kws title ext ""))
+    (should-error (denote-format-file-name "" id kws title ext ""))
+    ;; NOTE that `denote-directory' is the `let' bound value without the suffix
+    (should-error (denote-format-file-name denote-directory id kws title ext ""))
+    (should-error (denote-format-file-name dir "" nil "" ext ""))
+    (should (equal (denote-format-file-name dir nil kws title ext "") "/tmp/test-denote/--some-test__one_two.org"))
+    (should (equal (denote-format-file-name dir "" kws title ext "") "/tmp/test-denote/--some-test__one_two.org"))
+    (should (equal (denote-format-file-name dir "0123456" kws title ext "") "/tmp/test-denote/@@0123456--some-test__one_two.org"))
+    (should (equal (denote-format-file-name dir id kws title ext "") "/tmp/test-denote/20231128T055311--some-test__one_two.org"))
+    (should (equal (denote-format-file-name dir id nil "" ext "") "/tmp/test-denote/20231128T055311.org"))
+    (should (equal (denote-format-file-name dir id nil nil ext nil) "/tmp/test-denote/20231128T055311.org"))
+    (should (equal (denote-format-file-name dir id kws title ext "sig") "/tmp/test-denote/20231128T055311==sig--some-test__one_two.org"))))
 
 (ert-deftest dt-denote-get-file-extension ()
   "Test that `denote-get-file-extension' gets the correct file extension."
-  (should (and (equal (denote-get-file-extension "20231010T105034--some-test-file__denote_testing") "")
-               (equal (denote-get-file-extension "20231010T105034--some-test-file__denote_testing.org") ".org")
-               (equal (denote-get-file-extension "20231010T105034--some-test-file__denote_testing.org.gpg") ".org.gpg")
-               (equal (denote-get-file-extension "20231010T105034--some-test-file__denote_testing.org.age") ".org.age"))))
+  (should (equal (denote-get-file-extension "20231010T105034--some-test-file__denote_testing") ""))
+  (should (equal (denote-get-file-extension "20231010T105034--some-test-file__denote_testing.org") ".org"))
+  (should (equal (denote-get-file-extension "20231010T105034--some-test-file__denote_testing.org.gpg") ".org.gpg"))
+  (should (equal (denote-get-file-extension "20231010T105034--some-test-file__denote_testing.org.age") ".org.age")))
 
 (ert-deftest dt-denote-get-file-extension-sans-encryption ()
   "Test that `denote-get-file-extension-sans-encryption' gets the file extension without encryption."
-  (should (and (equal (denote-get-file-extension-sans-encryption "20231010T105034--some-test-file__denote_testing") "")
-               (equal (denote-get-file-extension-sans-encryption "20231010T105034--some-test-file__denote_testing.org") ".org")
-               (equal (denote-get-file-extension-sans-encryption "20231010T105034--some-test-file__denote_testing.org.gpg") ".org")
-               (equal (denote-get-file-extension-sans-encryption "20231010T105034--some-test-file__denote_testing.org.age") ".org"))))
+  (should (equal (denote-get-file-extension-sans-encryption "20231010T105034--some-test-file__denote_testing") ""))
+  (should (equal (denote-get-file-extension-sans-encryption "20231010T105034--some-test-file__denote_testing.org") ".org"))
+  (should (equal (denote-get-file-extension-sans-encryption "20231010T105034--some-test-file__denote_testing.org.gpg") ".org"))
+  (should (equal (denote-get-file-extension-sans-encryption "20231010T105034--some-test-file__denote_testing.org.age") ".org")))
+
+;; TODO 2026-04-06: For the `denote-file-type'.
 
 (ert-deftest dt-denote-filetype-heuristics ()
   "Test that `denote-filetype-heuristics' gets the correct file type."
-  (should (and (eq (denote-filetype-heuristics "20231010T105034--some-test-file__denote_testing") nil)
-               (eq (denote-filetype-heuristics "20231010T105034--some-test-file__denote_testing.org") 'org)
-               (eq (denote-filetype-heuristics "20231010T105034--some-test-file__denote_testing.org.gpg") 'org)
-               (eq (denote-filetype-heuristics "20231010T105034--some-test-file__denote_testing.org.age") 'org)
-               (eq (denote-filetype-heuristics "20231010T105034--some-test-file__denote_testing.txt") 'text)
-               (eq (denote-filetype-heuristics "20231010T105034--some-test-file__denote_testing.txt.gpg") 'text)
-               (eq (denote-filetype-heuristics "20231010T105034--some-test-file__denote_testing.txt.age") 'text)
-               ;; NOTE 2023-10-11: It returns `markdown-yaml' as a fallback.  In
-               ;; an actual file, it reads the file contents to determine what
-               ;; it is and can return `markdown-toml'.  In principle, we should
-               ;; be testing this here, though I prefer to keep things simple.
-               (eq (denote-filetype-heuristics "20231010T105034--some-test-file__denote_testing.md") 'markdown-yaml)
-               (eq (denote-filetype-heuristics "20231010T105034--some-test-file__denote_testing.md.gpg") 'markdown-yaml)
-               (eq (denote-filetype-heuristics "20231010T105034--some-test-file__denote_testing.md.age") 'markdown-yaml))))
-
-(ert-deftest dt-denote-get-identifier ()
-  "Test that `denote-get-identifier' returns an identifier."
-  (should (and (equal (denote-get-identifier nil) "")
-               (equal (denote-get-identifier 1705644188) "20240119T080308")
-               (equal (denote-get-identifier '(26026 4251)) "20240119T080307"))))
+  (should-not (denote-filetype-heuristics "20231010T105034--some-test-file__denote_testing"))
+  (should (eq (denote-filetype-heuristics "20231010T105034--some-test-file__denote_testing.org") 'org))
+  (should (eq (denote-filetype-heuristics "20231010T105034--some-test-file__denote_testing.org.gpg") 'org))
+  (should (eq (denote-filetype-heuristics "20231010T105034--some-test-file__denote_testing.org.age") 'org))
+  (should (eq (denote-filetype-heuristics "20231010T105034--some-test-file__denote_testing.txt") 'text))
+  (should (eq (denote-filetype-heuristics "20231010T105034--some-test-file__denote_testing.txt.gpg") 'text))
+  (should (eq (denote-filetype-heuristics "20231010T105034--some-test-file__denote_testing.txt.age") 'text))
+  (should (eq (denote-filetype-heuristics "20231010T105034--some-test-file__denote_testing.md")
+              (caar (denote--file-types-with-extension ".md"))))
+  (should (eq (denote-filetype-heuristics "20231010T105034--some-test-file__denote_testing.md.gpg")
+              (caar (denote--file-types-with-extension ".md"))))
+  (should (eq (denote-filetype-heuristics "20231010T105034--some-test-file__denote_testing.md.age")
+              (caar (denote--file-types-with-extension ".md")))))
 
 (ert-deftest dt-denote-retrieve-filename-identifier ()
   "Test that `denote-retrieve-filename-identifier' returns only the identifier."
-  (should (and (null
-                (denote-retrieve-filename-identifier "/path/to/testing/--this-is-a-test-reordered__denote_testing.org"))
-               (equal
-                (denote-retrieve-filename-identifier "/path/to/testing/20240610T194654--this-is-a-test-reordered__denote_testing.org")
-                "20240610T194654")
-               (equal
-                (denote-retrieve-filename-identifier "/path/to/testing/20240610T194654==signature--this-is-a-test-reordered__denote_testing.org")
-                "20240610T194654")
-               (equal
-                (denote-retrieve-filename-identifier "/path/to/testing/--this-is-a-test-reordered__denote_testing@@20240610T194654.org")
-                "20240610T194654")
-               (equal
-                (denote-retrieve-filename-identifier "/path/to/testing/__denote_testing--this-is-a-test-reordered@@20240610T194654.org")
-                "20240610T194654")
-               (equal
-                (denote-retrieve-filename-identifier "/path/to/testing/__denote_testing@@20240610T194654--this-is-a-test-reordered.org")
-                "20240610T194654")
-               (equal
-                (denote-retrieve-filename-identifier "/path/to/testing/==signature__denote_testing@@20240610T194654--this-is-a-test-reordered.org")
-                "20240610T194654"))))
+  (should (null (denote-retrieve-filename-identifier "/path/to/testing/--this-is-a-test-reordered__denote_testing.org")))
+  (should (equal (denote-retrieve-filename-identifier "/path/to/testing/20240610T194654--this-is-a-test-reordered__denote_testing.org") "20240610T194654"))
+  (should (equal (denote-retrieve-filename-identifier "/path/to/testing/20240610T194654==signature--this-is-a-test-reordered__denote_testing.org") "20240610T194654"))
+  (should (equal (denote-retrieve-filename-identifier "/path/to/testing/--this-is-a-test-reordered__denote_testing@@20240610T194654.org") "20240610T194654"))
+  (should (equal (denote-retrieve-filename-identifier "/path/to/testing/__denote_testing--this-is-a-test-reordered@@20240610T194654.org") "20240610T194654"))
+  (should (equal (denote-retrieve-filename-identifier "/path/to/testing/__denote_testing@@20240610T194654--this-is-a-test-reordered.org") "20240610T194654"))
+  (should (equal (denote-retrieve-filename-identifier "/path/to/testing/==signature__denote_testing@@20240610T194654--this-is-a-test-reordered.org") "20240610T194654")))
 
 (ert-deftest dt-denote-retrieve-filename-title ()
   "Test that `denote-retrieve-filename-title' returns only the title."
-  (should (and (null
-                (denote-retrieve-filename-title "/path/to/testing/20240610T194654__denote_testing.org"))
-               (equal
-                (denote-retrieve-filename-title "/path/to/testing/20240610T194654--this-is-a-test-reordered__denote_testing.org")
-                "this-is-a-test-reordered")
-               (equal
-                (denote-retrieve-filename-title "/path/to/testing/20240610T194654==signature--this-is-a-test-reordered__denote_testing.org")
-                "this-is-a-test-reordered")
-               (equal
-                (denote-retrieve-filename-title "/path/to/testing/--this-is-a-test-reordered__denote_testing@@20240610T194654.org")
-                "this-is-a-test-reordered")
-               (equal
-                (denote-retrieve-filename-title "/path/to/testing/__denote_testing--this-is-a-test-reordered@@20240610T194654.org")
-                "this-is-a-test-reordered")
-               (equal
-                (denote-retrieve-filename-title "/path/to/testing/__denote_testing@@20240610T194654--this-is-a-test-reordered.org")
-                "this-is-a-test-reordered")
-               (equal
-                (denote-retrieve-filename-title "/path/to/testing/==signature__denote_testing@@20240610T194654--this-is-a-test-reordered.org")
-                "this-is-a-test-reordered"))))
+  (should (null (denote-retrieve-filename-title "/path/to/testing/20240610T194654__denote_testing.org")))
+  (should (equal (denote-retrieve-filename-title "/path/to/testing/20240610T194654--this-is-a-test-reordered__denote_testing.org") "this-is-a-test-reordered"))
+  (should (equal (denote-retrieve-filename-title "/path/to/testing/20240610T194654==signature--this-is-a-test-reordered__denote_testing.org") "this-is-a-test-reordered"))
+  (should (equal (denote-retrieve-filename-title "/path/to/testing/--this-is-a-test-reordered__denote_testing@@20240610T194654.org") "this-is-a-test-reordered"))
+  (should (equal (denote-retrieve-filename-title "/path/to/testing/__denote_testing--this-is-a-test-reordered@@20240610T194654.org") "this-is-a-test-reordered"))
+  (should (equal (denote-retrieve-filename-title "/path/to/testing/__denote_testing@@20240610T194654--this-is-a-test-reordered.org") "this-is-a-test-reordered"))
+  (should (equal (denote-retrieve-filename-title "/path/to/testing/==signature__denote_testing@@20240610T194654--this-is-a-test-reordered.org") "this-is-a-test-reordered")))
 
 (ert-deftest dt-denote-retrieve-filename-keywords ()
   "Test that `denote-retrieve-filename-keywords' returns only the keywords."
-  (should (and (null
-                (denote-retrieve-filename-keywords "/path/to/testing/20240610T194654--this-is-a-test-reordered.org"))
-               (equal
-                (denote-retrieve-filename-keywords "/path/to/testing/20240610T194654--this-is-a-test-reordered__denote_testing.org")
-                "denote_testing")
-               (equal
-                (denote-retrieve-filename-keywords "/path/to/testing/20240610T194654==signature--this-is-a-test-reordered__denote_testing.org")
-                "denote_testing")
-               (equal
-                (denote-retrieve-filename-keywords "/path/to/testing/--this-is-a-test-reordered__denote_testing@@20240610T194654.org")
-                "denote_testing")
-               (equal
-                (denote-retrieve-filename-keywords "/path/to/testing/__denote_testing--this-is-a-test-reordered@@20240610T194654.org")
-                "denote_testing")
-               (equal
-                (denote-retrieve-filename-keywords "/path/to/testing/__denote_testing@@20240610T194654--this-is-a-test-reordered.org")
-                "denote_testing")
-               (equal
-                (denote-retrieve-filename-keywords "/path/to/testing/==signature__denote_testing@@20240610T194654--this-is-a-test-reordered.org")
-                "denote_testing"))))
+  (should (null (denote-retrieve-filename-keywords "/path/to/testing/20240610T194654--this-is-a-test-reordered.org")))
+  (should (equal (denote-retrieve-filename-keywords "/path/to/testing/20240610T194654--this-is-a-test-reordered__denote_testing.org") "denote_testing"))
+  (should (equal (denote-retrieve-filename-keywords "/path/to/testing/20240610T194654==signature--this-is-a-test-reordered__denote_testing.org") "denote_testing"))
+  (should (equal (denote-retrieve-filename-keywords "/path/to/testing/--this-is-a-test-reordered__denote_testing@@20240610T194654.org") "denote_testing"))
+  (should (equal (denote-retrieve-filename-keywords "/path/to/testing/__denote_testing--this-is-a-test-reordered@@20240610T194654.org") "denote_testing"))
+  (should (equal (denote-retrieve-filename-keywords "/path/to/testing/__denote_testing@@20240610T194654--this-is-a-test-reordered.org") "denote_testing"))
+  (should (equal (denote-retrieve-filename-keywords "/path/to/testing/==signature__denote_testing@@20240610T194654--this-is-a-test-reordered.org") "denote_testing")))
 
 (ert-deftest dt-denote-retrieve-filename-signature ()
   "Test that `denote-retrieve-filename-signature' returns only the signature."
-  (should (and (null
-                (denote-retrieve-filename-signature "/path/to/testing/20240610T194654--this-is-a-test-reordered__denote_testing.org"))
-               (equal
-                (denote-retrieve-filename-signature "/path/to/testing/20240610T194654==signature--this-is-a-test-reordered__denote_testing.org")
-                "signature")
-               (equal
-                (denote-retrieve-filename-signature "/path/to/testing/--this-is-a-test-reordered==signature__denote_testing@@20240610T194654.org")
-                "signature")
-               (equal
-                (denote-retrieve-filename-signature "/path/to/testing/__denote_testing--this-is-a-test-reordered==signature@@20240610T194654.org")
-                "signature")
-               (equal
-                (denote-retrieve-filename-signature "/path/to/testing/__denote_testing@@20240610T194654--this-is-a-test-reordered==signature.org")
-                "signature")
-               (equal
-                (denote-retrieve-filename-signature "/path/to/testing/==signature__denote_testing@@20240610T194654--this-is-a-test-reordered.org")
-                "signature"))))
+  (should (null (denote-retrieve-filename-signature "/path/to/testing/20240610T194654--this-is-a-test-reordered__denote_testing.org")))
+  (should (equal (denote-retrieve-filename-signature "/path/to/testing/20240610T194654==signature--this-is-a-test-reordered__denote_testing.org") "signature"))
+  (should (equal (denote-retrieve-filename-signature "/path/to/testing/--this-is-a-test-reordered==signature__denote_testing@@20240610T194654.org") "signature"))
+  (should (equal (denote-retrieve-filename-signature "/path/to/testing/__denote_testing--this-is-a-test-reordered==signature@@20240610T194654.org") "signature"))
+  (should (equal (denote-retrieve-filename-signature "/path/to/testing/__denote_testing@@20240610T194654--this-is-a-test-reordered==signature.org") "signature"))
+  (should (equal (denote-retrieve-filename-signature "/path/to/testing/==signature__denote_testing@@20240610T194654--this-is-a-test-reordered.org") "signature")))
 
-(ert-deftest dt-denote-identifier-p ()
-  "Test that `denote-identifier-p' works for Denote identifiers."
-  (should (and (denote-identifier-p "20240901T090910")
-               (null (denote-identifier-p "20240901T090910-not-identifier-format")))))
+(ert-deftest dt-denote-date-identifier-p ()
+  "Test that `denote-date-identifier-p' works for Denote identifiers."
+  (should (denote-date-identifier-p "20240901T090910"))
+  (should-not (denote-date-identifier-p "20240901T090910-not-identifier-format")))
 
-(ert-deftest dt-denote--id-to-date ()
-  "Test that `denote--id-to-date' returns the date from an identifier."
-  (should (equal (denote--id-to-date "20240901T090910") "2024-09-01"))
-  (should-error (denote--id-to-date "20240901T090910-not-identifier-format")))
+(ert-deftest dt-denote-id-to-date ()
+  "Test that `denote-id-to-date' returns the date from an identifier."
+  (should (equal (denote-id-to-date "20240901T090910") "2024-09-01"))
+  (should-error (denote-id-to-date "20240901T090910-not-identifier-format")))
 
 (ert-deftest dt-denote--date-convert ()
   "Test that `denote--date-convert' works with dates."
-  (should (and
-           (equal (denote--date-convert '(26454 45206 461174 657000) :list)
-                  '(26454 45206 461174 657000))
-
-           (equal (denote--date-convert '(26454 45206 461174 657000) :string)
-                  "2024-12-09 10:55:50")
-
-           (equal (denote--date-convert nil :string)
-                  "")
-
-           (equal (denote--date-convert nil :list)
-                  nil)))
+  (should (equal (denote--date-convert '(26454 45206 461174 657000) :list) '(26454 45206 461174 657000)))
+  (should (equal (denote--date-convert '(26454 45206 461174 657000) :string) "2024-12-09 10:55:50"))
+  (should (equal (denote--date-convert nil :string) ""))
+  (should (equal (denote--date-convert nil :list) nil))
   (should-error (denote--date-convert '(26454 45206 461174 657000) :not-valid-type))
   (should-error (denote--date-convert nil :not-valid-type)))
 
+;; TODO 2026-02-23: Add support for Windows paths.  But I need somebody who has a Windows machine...
+(ert-deftest dt-denote--get-common-root-directory ()
+  "Test that `denote--get-common-root-directory' returns the right path."
+  (should (string=
+           (denote--get-common-root-directory
+            '("/home/prot/Documents/notes/"
+              "/home/prot/Documents/notes/attachments"))
+           "/home/prot/Documents/notes/"))
+  (should (string=
+           (denote--get-common-root-directory
+            '("/home/prot/Documents/"
+              "/home/prot/Documents/notes/attachments"))
+           "/home/prot/Documents/"))
+  (should (string=
+           (denote--get-common-root-directory
+            '("/home/prot/Books/"
+              "/home/prot/Documents/notes/"))
+           "/home/prot/"))
+  (should (string=
+           (denote--get-common-root-directory
+            '("/tmp/notes/"
+              "/home/prot/Documents/notes/"))
+           "/"))
+  (should (string=
+           (denote--get-common-root-directory
+            '("/home/prot/Documents/notes/"))
+           "/home/prot/Documents/notes/"))
+  (should-error (denote--get-common-root-directory '("~/Documents/notes/"))))
+
+(ert-deftest dt-denote-query--keywords-as-regexp ()
+  "Test that `denote-query--keywords-as-regexp' works as intended."
+  (should (string= (denote-query--keywords-as-regexp '("one" "two")) "_\\(?:one\\|two\\)"))
+  (should-error (denote-query--keywords-as-regexp "one"))
+  (should-error (denote-query--keywords-as-regexp '("one" 1))))
+
+(ert-deftest dt-denote-file-type ()
+  "Test that function `denote-file-type' does what it is meant to."
+  (let* ((create-file-fn (lambda (name extension)
+                           (expand-file-name
+                            (format "denote-test-file-type-%s.%s" name extension)
+                            (temporary-file-directory))))
+         (modify-file-fn (lambda (file contents)
+                           (with-current-buffer (find-file-noselect file)
+                             (erase-buffer)
+                             (insert contents)
+                             (save-buffer))))
+         (yaml-file (funcall create-file-fn "yaml" "md"))
+         (toml-file (funcall create-file-fn "toml" "md"))
+         (org-file (funcall create-file-fn "org" "org")))
+    (progn
+      (funcall modify-file-fn yaml-file denote-yaml-front-matter)
+      (should (eq (denote-file-type yaml-file) 'markdown-yaml)))
+    (progn
+      (funcall modify-file-fn toml-file denote-toml-front-matter)
+      (should (eq (denote-file-type toml-file) 'markdown-toml)))
+    (progn
+      (funcall modify-file-fn org-file denote-org-front-matter)
+      (should (eq (denote-file-type org-file) 'org)))
+    (should-not (denote-file-type "test"))
+    (let ((denote-file-types nil))
+      (should-not (denote-file-type "test.md")))))
+
 (provide 'denote-test)
 ;;; denote-test.el ends here