awesome-emacs/org-roam
1
0
Fork 0
mirror of https://github.com/org-roam/org-roam synced 2025-08-01 12:17:21 -05:00
Code Issues Packages Projects Releases Wiki Activity

(refactor): refactor title extraction (#625)

Browse Source 
Introduces '(org-roam-title-sources), which can be a list of lists. Each symbol corresponds to a function, that when called returns a list of titles. If the element is a list, use the first function in the list that returns a successful result.
This commit is contained in:
Jethro Kuan
2020-05-14 19:45:07 +08:00
committed by GitHub
parent abb36d11ef
commit b47b76aa41
8 changed files with 269 additions and 103 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
doc/org-roam.org
View File

@ -174,17 +174,43 @@ Org-mode. However, to support additional functionality, Org-roam adds
several Org-roam-specific keywords. These functionality are not crucial several Org-roam-specific keywords. These functionality are not crucial
to effective use of Org-roam. to effective use of Org-roam.
** File Aliases ** File Titles
Suppose you want a note to be referred to by different names (e.g. To easily find a note, a title needs to be prescribed to a note. A note can have
"World War 2", "WWII"). You may specify such aliases using the many titles: this allows a note to be referred to by different names, which is
=#+ROAM_ALIAS= attribute: especially useful for topics or concepts with acronyms. For example, for a note
like "World War 2", it may be desirable to also refer to it using the acronym
"WWII".
Org-roam calls =org-roam--extract-titles= to extract titles. It uses the
variable =org-roam-title-sources=, to control how the titles are extracted. The
title extraction methods supported are:
1. ='title=: This extracts the title using the file =#+TITLE= property
2. ='headline=: This extracts the title from the first headline in the Org file
3. ='alias=: This extracts a list of titles using the =#ROAM_ALIAS= property.
The aliases are space-delimited, and can be multi-worded using quotes
Take for example the following org file:
#+BEGIN_SRC org #+BEGIN_SRC org
#+TITLE: World War 2 #+TITLE: World War 2
#+ROAM_ALIAS: "WWII" "World War II" #+ROAM_ALIAS: "WWII" "World War II"
* Headline
#+END_SRC #+END_SRC
| Method | Titles |
|-------------+--------------------------|
| ='title= | '("World War 2") |
| ='headline= | '("Headline") |
| ='alias= | '("WWII" "World War II") |
One can freely control which extraction methods to use by customizing
=org-roam-title-sources=: see the doc-string for the variable for more
information. If all methods of title extraction return no results, the file-name
is used in place of the titles for completions.
** File Refs ** File Refs
Refs are unique identifiers for files. Each note can only have 1 ref. Refs are unique identifiers for files. Each note can only have 1 ref.

85
org-roam.el
View File

@ -106,6 +106,34 @@ ensure that."
:type '(repeat string) :type '(repeat string)
:group 'org-roam) :group 'org-roam)
(defcustom org-roam-title-sources '((title headline) alias)
"The list of sources from which to retrieve a note title.
Each element in the list is either:
1. a symbol -- this symbol corresponds to a title retrieval
function, which returns the list of titles for the current buffer
2. a list of symbols -- symbols in the list are treated as
with (1). The return value of this list is the first symbol in
the list returning a non-nil value.
The return results of the root list are concatenated.
For example the setting: '((title headline) alias) means the following:
1. Return the 'title + 'alias, if the title of current buffer is non-empty;
2. Or return 'headline + 'alias otherwise.
The currently supported symbols are:
1. 'title: The \"#+TITLE\" property of org file.
2. 'alias: The \"#+ROAM_ALIAS\" property of the org file, using
space-delimited strings.
3. 'headline: The first headline in the org file."
:type '(repeat
(choice
(repeat symbol)
(symbol)))
:group 'org-roam)
;;;; Dynamic variables ;;;; Dynamic variables
(defvar org-roam-last-window nil (defvar org-roam-last-window nil
"Last window `org-roam' was called from.") "Last window `org-roam' was called from.")
@ -349,25 +377,46 @@ current buffer is used."
,wrong-type))))) ,wrong-type)))))
title)) title))
(defun org-roam--extract-titles () (defun org-roam--extract-titles-title ()
"Extract the titles from current buffer. "Return title from \"#+TITLE\" of the current buffer."
Titles are obtained via: (let* ((prop (org-roam--extract-global-props '("TITLE")))
(title (cdr (assoc "TITLE" prop))))
(when title
(list title))))
1. The #+TITLE property or the first headline (defun org-roam--extract-titles-alias ()
2. The aliases specified via the #+ROAM_ALIAS property." "Return the aliases from the current buffer.
(let* ((props (org-roam--extract-global-props '("TITLE" "ROAM_ALIAS"))) Reads from the \"ROAM_ALIAS\" property."
(aliases (cdr (assoc "ROAM_ALIAS" props))) (let* ((prop (org-roam--extract-global-props '("ROAM_ALIAS")))
(title (or (cdr (assoc "TITLE" props)) (aliases (cdr (assoc "ROAM_ALIAS" prop))))
(org-element-map (org-roam--aliases-str-to-list aliases)))
(org-element-parse-buffer)
'headline (defun org-roam--extract-titles-headline ()
(lambda (h) "Return the first headline of the current buffer."
(org-no-properties (org-element-property :raw-value h))) (let ((headline (org-element-map
:first-match t))) (org-element-parse-buffer)
(alias-list (org-roam--aliases-str-to-list aliases))) 'headline
(if title (lambda (h)
(cons title alias-list) (org-no-properties (org-element-property :raw-value h)))
alias-list))) :first-match t)))
(when headline
(list headline))))
(defun org-roam--extract-titles (&optional sources nested)
"Extract the titles from current buffer using SOURCES.
If NESTED, return the first successful result from SOURCES."
(let (coll res)
(cl-dolist (source (or sources
org-roam-title-sources))
(setq res (if (symbolp source)
(funcall (intern (concat "org-roam--extract-titles-" (symbol-name source))))
(org-roam--extract-titles source t)))
(when res
(if (not nested)
(setq coll (nconc coll res))
(setq coll res)
(cl-return))))
coll))
(defun org-roam--extract-and-format-titles (&optional file-path) (defun org-roam--extract-and-format-titles (&optional file-path)
"Extract the titles from the current buffer and format them. "Extract the titles from the current buffer and format them.

2
tests/roam-files/no-title.org
View File

@ -1,3 +1,5 @@
no title in this file :O no title in this file :O
links to itself, with no title: [[file:no-title.org][no-title]] links to itself, with no title: [[file:no-title.org][no-title]]
* Headline title

1
tests/roam-files/titles/aliases.org Normal file
View File

@ -0,0 +1 @@
#+ROAM_ALIAS: "roam" "alias"

4
tests/roam-files/titles/combination.org Normal file
View File

@ -0,0 +1,4 @@
#+TITLE: TITLE PROP
#+ROAM_ALIAS: "roam" "alias"
* Headline

1
tests/roam-files/titles/headline.org Normal file
View File

@ -0,0 +1 @@
* Headline

1
tests/roam-files/titles/title.org Normal file
View File

@ -0,0 +1 @@
#+TITLE: Title

244
tests/test-org-roam.el
View File

@ -19,52 +19,135 @@
;; along with this program. If not, see <https://www.gnu.org/licenses/>. ;; along with this program. If not, see <https://www.gnu.org/licenses/>.
;;; Commentary: ;;; Commentary:
;;
;;; Code: ;;; Code:
;;;; Requirements
(require 'buttercup) (require 'buttercup)
(require 'with-simulated-input) (require 'with-simulated-input)
(require 'org-roam) (require 'org-roam)
(require 'dash) (require 'dash)
(defun org-roam-test-abs-path (file-path) (defun test-org-roam--abs-path (file-path)
"Get absolute FILE-PATH from `org-roam-directory'." "Get absolute FILE-PATH from `org-roam-directory'."
(file-truename (expand-file-name file-path org-roam-directory))) (file-truename (expand-file-name file-path org-roam-directory)))
(defun org-roam-test-find-new-file (path) (defun test-org-roam--find-file (path)
"PATH." "PATH."
(let ((path (org-roam-test-abs-path path))) (let ((path (test-org-roam--abs-path path)))
(make-directory (file-name-directory path) t) (make-directory (file-name-directory path) t)
(find-file path))) (find-file path)))
(defvar org-roam-test-directory (file-truename (concat default-directory "tests/roam-files")) (defvar test-org-roam-directory (file-truename (concat default-directory "tests/roam-files"))
"Directory containing org-roam test org files.") "Directory containing org-roam test org files.")
(defun org-roam-test-init () (defun test-org-roam--init ()
"." "."
(let ((original-dir org-roam-test-directory) (let ((original-dir test-org-roam-directory)
(new-dir (expand-file-name (make-temp-name "org-roam") temporary-file-directory))) (new-dir (expand-file-name (make-temp-name "org-roam") temporary-file-directory)))
(copy-directory original-dir new-dir) (copy-directory original-dir new-dir)
(setq org-roam-directory new-dir) (setq org-roam-directory new-dir)
(org-roam-mode +1) (org-roam-mode +1)
(sleep-for 2))) (sleep-for 2)))
(defun org-roam-test-teardown () (defun test-org-roam--teardown ()
(org-roam-mode -1) (org-roam-mode -1)
(delete-file (org-roam-db--get)) (delete-file (org-roam-db--get))
(org-roam-db--close)) (org-roam-db--close))
(describe "Title extraction"
:var (org-roam-title-sources)
(before-all
(test-org-roam--init))
(after-all
(test-org-roam--teardown))
(cl-flet
((test (fn file)
(let ((buf (find-file-noselect
(test-org-roam--abs-path file))))
(with-current-buffer buf
(funcall fn)))))
(it "extracts title from title property"
(expect (test #'org-roam--extract-titles-title
"titles/title.org")
:to-equal
'("Title"))
(expect (test #'org-roam--extract-titles-title
"titles/aliases.org")
:to-equal
nil)
(expect (test #'org-roam--extract-titles-title
"titles/headline.org")
:to-equal
nil)
(expect (test #'org-roam--extract-titles-title
"titles/combination.org")
:to-equal
'("TITLE PROP")))
(it "extracts alias"
(expect (test #'org-roam--extract-titles-alias
"titles/title.org")
:to-equal
nil)
(expect (test #'org-roam--extract-titles-alias
"titles/aliases.org")
:to-equal
'("roam" "alias"))
(expect (test #'org-roam--extract-titles-alias
"titles/headline.org")
:to-equal
nil)
(expect (test #'org-roam--extract-titles-alias
"titles/combination.org")
:to-equal
'("roam" "alias")))
(it "extracts headlines"
(expect (test #'org-roam--extract-titles-alias
"titles/title.org")
:to-equal
nil)
(expect (test #'org-roam--extract-titles-headline
"titles/aliases.org")
:to-equal
nil)
(expect (test #'org-roam--extract-titles-headline
"titles/headline.org")
:to-equal
'("Headline"))
(expect (test #'org-roam--extract-titles-headline
"titles/combination.org")
:to-equal
'("Headline")))
(describe "uses org-roam-title-sources correctly"
(it "'((title headline) alias)"
(expect (let ((org-roam-title-sources '((title headline) alias)))
(test #'org-roam--extract-titles
"titles/combination.org"))
:to-equal
'("TITLE PROP" "roam" "alias")))
(it "'((headline title) alias)"
(expect (let ((org-roam-title-sources '((headline title) alias)))
(test #'org-roam--extract-titles
"titles/combination.org"))
:to-equal
'("Headline" "roam" "alias")))
(it "'(headline alias title)"
(expect (let ((org-roam-title-sources '(headline alias title)))
(test #'org-roam--extract-titles
"titles/combination.org"))
:to-equal
'("Headline" "roam" "alias" "TITLE PROP"))))))
;;; Tests ;;; Tests
(describe "org-roam-db-build-cache" (xdescribe "org-roam-db-build-cache"
(before-each (before-each
(org-roam-test-init)) (test-org-roam--init))
(after-each (after-each
(org-roam-test-teardown)) (test-org-roam--teardown))
(it "initializes correctly" (it "initializes correctly"
;; Cache ;; Cache
@ -72,65 +155,64 @@
(expect (caar (org-roam-db-query [:select (funcall count) :from links])) :to-be 5) (expect (caar (org-roam-db-query [:select (funcall count) :from links])) :to-be 5)
(expect (caar (org-roam-db-query [:select (funcall count) :from titles])) :to-be 8) (expect (caar (org-roam-db-query [:select (funcall count) :from titles])) :to-be 8)
(expect (caar (org-roam-db-query [:select (funcall count) :from titles (expect (caar (org-roam-db-query [:select (funcall count) :from titles
:where titles :is-null])) :to-be 2) :where titles :is-null])) :to-be 1)
(expect (caar (org-roam-db-query [:select (funcall count) :from refs])) :to-be 1) (expect (caar (org-roam-db-query [:select (funcall count) :from refs])) :to-be 1)
;; TODO Test files
;; Links ;; Links
(expect (caar (org-roam-db-query [:select (funcall count) :from links (expect (caar (org-roam-db-query [:select (funcall count) :from links
:where (= from $s1)] :where (= from $s1)]
(org-roam-test-abs-path "foo.org"))) :to-be 1) (test-org-roam--abs-path "foo.org"))) :to-be 1)
(expect (caar (org-roam-db-query [:select (funcall count) :from links (expect (caar (org-roam-db-query [:select (funcall count) :from links
:where (= from $s1)] :where (= from $s1)]
(org-roam-test-abs-path "nested/bar.org"))) :to-be 2) (test-org-roam--abs-path "nested/bar.org"))) :to-be 2)
;; Links -- File-to ;; Links -- File-to
(expect (caar (org-roam-db-query [:select (funcall count) :from links (expect (caar (org-roam-db-query [:select (funcall count) :from links
:where (= to $s1)] :where (= to $s1)]
(org-roam-test-abs-path "nested/foo.org"))) :to-be 1) (test-org-roam--abs-path "nested/foo.org"))) :to-be 1)
(expect (caar (org-roam-db-query [:select (funcall count) :from links (expect (caar (org-roam-db-query [:select (funcall count) :from links
:where (= to $s1)] :where (= to $s1)]
(org-roam-test-abs-path "nested/bar.org"))) :to-be 1) (test-org-roam--abs-path "nested/bar.org"))) :to-be 1)
(expect (caar (org-roam-db-query [:select (funcall count) :from links (expect (caar (org-roam-db-query [:select (funcall count) :from links
:where (= to $s1)] :where (= to $s1)]
(org-roam-test-abs-path "unlinked.org"))) :to-be 0) (test-org-roam--abs-path "unlinked.org"))) :to-be 0)
;; TODO Test titles ;; TODO Test titles
(expect (org-roam-db-query [:select * :from titles]) (expect (org-roam-db-query [:select * :from titles])
:to-have-same-items-as :to-have-same-items-as
(list (list (org-roam-test-abs-path "alias.org") (list (list (test-org-roam--abs-path "alias.org")
(list "t1" "a1" "a 2")) (list "t1" "a1" "a 2"))
(list (org-roam-test-abs-path "bar.org") (list (test-org-roam--abs-path "bar.org")
(list "Bar")) (list "Bar"))
(list (org-roam-test-abs-path "foo.org") (list (test-org-roam--abs-path "foo.org")
(list "Foo")) (list "Foo"))
(list (org-roam-test-abs-path "nested/bar.org") (list (test-org-roam--abs-path "nested/bar.org")
(list "Nested Bar")) (list "Nested Bar"))
(list (org-roam-test-abs-path "nested/foo.org") (list (test-org-roam--abs-path "nested/foo.org")
(list "Nested Foo")) (list "Nested Foo"))
(list (org-roam-test-abs-path "no-title.org") nil) (list (test-org-roam--abs-path "no-title.org")
(list (org-roam-test-abs-path "web_ref.org") nil) (list "Headline title"))
(list (org-roam-test-abs-path "unlinked.org") (list (test-org-roam--abs-path "web_ref.org") nil)
(list (test-org-roam--abs-path "unlinked.org")
(list "Unlinked")))) (list "Unlinked"))))
(expect (org-roam-db-query [:select * :from refs]) (expect (org-roam-db-query [:select * :from refs])
:to-have-same-items-as :to-have-same-items-as
(list (list "https://google.com/" (org-roam-test-abs-path "web_ref.org") "website"))) (list (list "https://google.com/" (test-org-roam--abs-path "web_ref.org") "website")))
;; Expect rebuilds to be really quick (nothing changed) ;; Expect rebuilds to be really quick (nothing changed)
(expect (org-roam-db-build-cache) (expect (org-roam-db-build-cache)
:to-equal :to-equal
(list :files 0 :links 0 :titles 0 :refs 0 :deleted 0)))) (list :files 0 :links 0 :titles 0 :refs 0 :deleted 0))))
(describe "org-roam-insert" (xdescribe "org-roam-insert"
(before-each (before-each
(org-roam-test-init)) (test-org-roam--init))
(after-each (after-each
(org-roam-test-teardown)) (test-org-roam--teardown))
(it "temp1 -> foo" (it "temp1 -> foo"
(let ((buf (org-roam-test-find-new-file "temp1.org"))) (let ((buf (test-org-roam--find-file "temp1.org")))
(with-current-buffer buf (with-current-buffer buf
(with-simulated-input (with-simulated-input
"Foo RET" "Foo RET"
@ -138,7 +220,7 @@
(expect (buffer-string) :to-match (regexp-quote "file:foo.org"))) (expect (buffer-string) :to-match (regexp-quote "file:foo.org")))
(it "temp2 -> nested/foo" (it "temp2 -> nested/foo"
(let ((buf (org-roam-test-find-new-file "temp2.org"))) (let ((buf (test-org-roam--find-file "temp2.org")))
(with-current-buffer buf (with-current-buffer buf
(with-simulated-input (with-simulated-input
"Nested SPC Foo RET" "Nested SPC Foo RET"
@ -146,7 +228,7 @@
(expect (buffer-string) :to-match (regexp-quote "file:nested/foo.org"))) (expect (buffer-string) :to-match (regexp-quote "file:nested/foo.org")))
(it "nested/temp3 -> foo" (it "nested/temp3 -> foo"
(let ((buf (org-roam-test-find-new-file "nested/temp3.org"))) (let ((buf (test-org-roam--find-file "nested/temp3.org")))
(with-current-buffer buf (with-current-buffer buf
(with-simulated-input (with-simulated-input
"Foo RET" "Foo RET"
@ -154,112 +236,112 @@
(expect (buffer-string) :to-match (regexp-quote "file:../foo.org"))) (expect (buffer-string) :to-match (regexp-quote "file:../foo.org")))
(it "a/b/temp4 -> nested/foo" (it "a/b/temp4 -> nested/foo"
(let ((buf (org-roam-test-find-new-file "a/b/temp4.org"))) (let ((buf (test-org-roam--find-file "a/b/temp4.org")))
(with-current-buffer buf (with-current-buffer buf
(with-simulated-input (with-simulated-input
"Nested SPC Foo RET" "Nested SPC Foo RET"
(org-roam-insert nil)))) (org-roam-insert nil))))
(expect (buffer-string) :to-match (regexp-quote "file:../../nested/foo.org")))) (expect (buffer-string) :to-match (regexp-quote "file:../../nested/foo.org"))))
(describe "rename file updates cache" (xdescribe "rename file updates cache"
(before-each (before-each
(org-roam-test-init)) (test-org-roam--init))
(after-each (after-each
(org-roam-test-teardown)) (test-org-roam--teardown))
(it "foo -> new_foo" (it "foo -> new_foo"
(rename-file (org-roam-test-abs-path "foo.org") (rename-file (test-org-roam--abs-path "foo.org")
(org-roam-test-abs-path "new_foo.org")) (test-org-roam--abs-path "new_foo.org"))
;; Cache should be cleared of old file ;; Cache should be cleared of old file
(expect (caar (org-roam-db-query [:select (funcall count) (expect (caar (org-roam-db-query [:select (funcall count)
:from titles :from titles
:where (= file $s1)] :where (= file $s1)]
(org-roam-test-abs-path "foo.org"))) :to-be 0) (test-org-roam--abs-path "foo.org"))) :to-be 0)
(expect (caar (org-roam-db-query [:select (funcall count) (expect (caar (org-roam-db-query [:select (funcall count)
:from refs :from refs
:where (= file $s1)] :where (= file $s1)]
(org-roam-test-abs-path "foo.org"))) :to-be 0) (test-org-roam--abs-path "foo.org"))) :to-be 0)
(expect (caar (org-roam-db-query [:select (funcall count) (expect (caar (org-roam-db-query [:select (funcall count)
:from links :from links
:where (= from $s1)] :where (= from $s1)]
(org-roam-test-abs-path "foo.org"))) :to-be 0) (test-org-roam--abs-path "foo.org"))) :to-be 0)
;; Cache should be updated ;; Cache should be updated
(expect (org-roam-db-query [:select [to] (expect (org-roam-db-query [:select [to]
:from links :from links
:where (= from $s1)] :where (= from $s1)]
(org-roam-test-abs-path "new_foo.org")) (test-org-roam--abs-path "new_foo.org"))
:to-have-same-items-as :to-have-same-items-as
(list (list (org-roam-test-abs-path "bar.org")))) (list (list (test-org-roam--abs-path "bar.org"))))
(expect (org-roam-db-query [:select [from] (expect (org-roam-db-query [:select [from]
:from links :from links
:where (= to $s1)] :where (= to $s1)]
(org-roam-test-abs-path "new_foo.org")) (test-org-roam--abs-path "new_foo.org"))
:to-have-same-items-as :to-have-same-items-as
(list (list (org-roam-test-abs-path "nested/bar.org")))) (list (list (test-org-roam--abs-path "nested/bar.org"))))
;; Links are updated ;; Links are updated
(expect (with-temp-buffer (expect (with-temp-buffer
(insert-file-contents (org-roam-test-abs-path "nested/bar.org")) (insert-file-contents (test-org-roam--abs-path "nested/bar.org"))
(buffer-string)) (buffer-string))
:to-match :to-match
(regexp-quote "[[file:../new_foo.org][Foo]]"))) (regexp-quote "[[file:../new_foo.org][Foo]]")))
(it "foo -> foo with spaces" (it "foo -> foo with spaces"
(rename-file (org-roam-test-abs-path "foo.org") (rename-file (test-org-roam--abs-path "foo.org")
(org-roam-test-abs-path "foo with spaces.org")) (test-org-roam--abs-path "foo with spaces.org"))
;; Cache should be cleared of old file ;; Cache should be cleared of old file
(expect (caar (org-roam-db-query [:select (funcall count) (expect (caar (org-roam-db-query [:select (funcall count)
:from titles :from titles
:where (= file $s1)] :where (= file $s1)]
(org-roam-test-abs-path "foo.org"))) :to-be 0) (test-org-roam--abs-path "foo.org"))) :to-be 0)
(expect (caar (org-roam-db-query [:select (funcall count) (expect (caar (org-roam-db-query [:select (funcall count)
:from refs :from refs
:where (= file $s1)] :where (= file $s1)]
(org-roam-test-abs-path "foo.org"))) :to-be 0) (test-org-roam--abs-path "foo.org"))) :to-be 0)
(expect (caar (org-roam-db-query [:select (funcall count) (expect (caar (org-roam-db-query [:select (funcall count)
:from links :from links
:where (= from $s1)] :where (= from $s1)]
(org-roam-test-abs-path "foo.org"))) :to-be 0) (test-org-roam--abs-path "foo.org"))) :to-be 0)
;; Cache should be updated ;; Cache should be updated
(expect (org-roam-db-query [:select [to] (expect (org-roam-db-query [:select [to]
:from links :from links
:where (= from $s1)] :where (= from $s1)]
(org-roam-test-abs-path "foo with spaces.org")) (test-org-roam--abs-path "foo with spaces.org"))
:to-have-same-items-as :to-have-same-items-as
(list (list (org-roam-test-abs-path "bar.org")))) (list (list (test-org-roam--abs-path "bar.org"))))
(expect (org-roam-db-query [:select [from] (expect (org-roam-db-query [:select [from]
:from links :from links
:where (= to $s1)] :where (= to $s1)]
(org-roam-test-abs-path "foo with spaces.org")) (test-org-roam--abs-path "foo with spaces.org"))
:to-have-same-items-as :to-have-same-items-as
(list (list (org-roam-test-abs-path "nested/bar.org")))) (list (list (test-org-roam--abs-path "nested/bar.org"))))
;; Links are updated ;; Links are updated
(expect (with-temp-buffer (expect (with-temp-buffer
(insert-file-contents (org-roam-test-abs-path "nested/bar.org")) (insert-file-contents (test-org-roam--abs-path "nested/bar.org"))
(buffer-string)) (buffer-string))
:to-match :to-match
(regexp-quote "[[file:../foo with spaces.org][Foo]]"))) (regexp-quote "[[file:../foo with spaces.org][Foo]]")))
(it "no-title -> meaningful-title" (it "no-title -> meaningful-title"
(rename-file (org-roam-test-abs-path "no-title.org") (rename-file (test-org-roam--abs-path "no-title.org")
(org-roam-test-abs-path "meaningful-title.org")) (test-org-roam--abs-path "meaningful-title.org"))
;; File has no forward links ;; File has no forward links
(expect (caar (org-roam-db-query [:select (funcall count) (expect (caar (org-roam-db-query [:select (funcall count)
:from links :from links
:where (= from $s1)] :where (= from $s1)]
(org-roam-test-abs-path "no-title.org"))) :to-be 0) (test-org-roam--abs-path "no-title.org"))) :to-be 0)
(expect (caar (org-roam-db-query [:select (funcall count) (expect (caar (org-roam-db-query [:select (funcall count)
:from links :from links
:where (= from $s1)] :where (= from $s1)]
(org-roam-test-abs-path "meaningful-title.org"))) :to-be 1) (test-org-roam--abs-path "meaningful-title.org"))) :to-be 1)
;; Links are updated with the appropriate name ;; Links are updated with the appropriate name
(expect (with-temp-buffer (expect (with-temp-buffer
(insert-file-contents (org-roam-test-abs-path "meaningful-title.org")) (insert-file-contents (test-org-roam--abs-path "meaningful-title.org"))
(buffer-string)) (buffer-string))
:to-match :to-match
(regexp-quote "[[file:meaningful-title.org][meaningful-title]]"))) (regexp-quote "[[file:meaningful-title.org][meaningful-title]]")))
@ -270,47 +352,47 @@
:where (= ref $s1)] :where (= ref $s1)]
"https://google.com/") "https://google.com/")
:to-equal :to-equal
(list (list (org-roam-test-abs-path "web_ref.org")))) (list (list (test-org-roam--abs-path "web_ref.org"))))
(rename-file (org-roam-test-abs-path "web_ref.org") (rename-file (test-org-roam--abs-path "web_ref.org")
(org-roam-test-abs-path "hello.org")) (test-org-roam--abs-path "hello.org"))
(expect (org-roam-db-query (expect (org-roam-db-query
[:select [file] :from refs [:select [file] :from refs
:where (= ref $s1)] :where (= ref $s1)]
"https://google.com/") "https://google.com/")
:to-equal (list (list (org-roam-test-abs-path "hello.org")))) :to-equal (list (list (test-org-roam--abs-path "hello.org"))))
(expect (caar (org-roam-db-query (expect (caar (org-roam-db-query
[:select [ref] :from refs [:select [ref] :from refs
:where (= file $s1)] :where (= file $s1)]
(org-roam-test-abs-path "web_ref.org"))) (test-org-roam--abs-path "web_ref.org")))
:to-equal nil))) :to-equal nil)))
(describe "delete file updates cache" (xdescribe "delete file updates cache"
(before-each (before-each
(org-roam-test-init)) (test-org-roam--init))
(after-each (after-each
(org-roam-test-teardown)) (test-org-roam--teardown))
(it "delete foo" (it "delete foo"
(delete-file (org-roam-test-abs-path "foo.org")) (delete-file (test-org-roam--abs-path "foo.org"))
(expect (caar (org-roam-db-query [:select (funcall count) (expect (caar (org-roam-db-query [:select (funcall count)
:from titles :from titles
:where (= file $s1)] :where (= file $s1)]
(org-roam-test-abs-path "foo.org"))) :to-be 0) (test-org-roam--abs-path "foo.org"))) :to-be 0)
(expect (caar (org-roam-db-query [:select (funcall count) (expect (caar (org-roam-db-query [:select (funcall count)
:from refs :from refs
:where (= file $s1)] :where (= file $s1)]
(org-roam-test-abs-path "foo.org"))) :to-be 0) (test-org-roam--abs-path "foo.org"))) :to-be 0)
(expect (caar (org-roam-db-query [:select (funcall count) (expect (caar (org-roam-db-query [:select (funcall count)
:from links :from links
:where (= from $s1)] :where (= from $s1)]
(org-roam-test-abs-path "foo.org"))) :to-be 0)) (test-org-roam--abs-path "foo.org"))) :to-be 0))
(it "delete web_ref" (it "delete web_ref"
(expect (org-roam-db-query [:select * :from refs]) (expect (org-roam-db-query [:select * :from refs])
:to-have-same-items-as :to-have-same-items-as
(list (list "https://google.com/" (org-roam-test-abs-path "web_ref.org") "website"))) (list (list "https://google.com/" (test-org-roam--abs-path "web_ref.org") "website")))
(delete-file (org-roam-test-abs-path "web_ref.org")) (delete-file (test-org-roam--abs-path "web_ref.org"))
(expect (org-roam-db-query [:select * :from refs]) (expect (org-roam-db-query [:select * :from refs])
:to-have-same-items-as :to-have-same-items-as
(list)))) (list))))