Dendron-like hierarchy navigation

[theianjones]

In dendron, you can run commands to navigate your hierarch. So you have some notes like this:

lang.clojure.func.org
lang.clojure.operators.org
lang.clojure.org

You could run a command to navigate to siblings in the hierarchy. In this case, back and forth between lang.clojure.func.org and lang.clojure.operators.org.

Then there would be a command to navigate to the parent hierarchy. If you were viewing lang.clojure.func.org you could run the command and navigate up to lang.clojure.org.

Lastly, a command to navigate to the children, this could filter the current hierarchies children for selection in a mini buffer.

What do you think?

[vicrdguez]

This is something I've been thinking as well, and I think we can add something more.
Recompiling the use cases:

• Search through all the siblings
  This command can launch search in the minibuffer with results limited to
  all the siblings of the direct parent. This is easy to implement, is a variation of
  the initial-input command but with one hierarchy node less
• Go to next/previous sibling
  This is the main one you describe. We should define an order for selecting which one is
  the next or the previous. I would say we can use alphabetical order, or time order.
• Go to parent
  Really similar to the first one, but instead of running the search, we can just open the file
• Navigate to children
  I think we "have" this one already. The initial input basically open search in the minibuffer
  with the current hierarchy and will only show children. Is this what you mean?

For implementing this I would say (file-name-base) is our best friend. It says to get the file name
without path and without extension but I found that what it does to remove the extensions is
truncate the file name until the first dot (included) from the end. This is really useful for dendroam
because if you apply it to a hierarchy it will basically return its parent, like if the last hierarchy
node was the file extension.

So I think this should be easy to implement.

[clemera]

I think a UI similar to find-file could be nice, you could easily navigate through the note hierarchy like you do with the file system hierarchy.

[vicrdguez]

I thought before about implementing a tree-view for hierarchies but this idea sound quite more useful!
Do you have any ideas or suggestion for the implementation?
I would say the first step is implement the logic to understand hierarchies as folders, but I'm not
sure about how find-file works under the hood.

I will do some research anyways

[clemera]

You can use programmed completion, see (info "(elisp) Programmed Completion"). @oantolin posted a nice example using file paths here. Here is a version adapted to the node paths to test (using default completion):

(defun complete-paths (paths)
  (lambda (string predicate action)
    (let ((last-dot (cl-position ?. string :from-end t)))
      (when last-dot (setq last-dot (1+ last-dot)))
      (if (eq (car-safe action) 'boundaries)
          (let ((suffix (cdr action)))
            (cons 'boundaries
                  (cons
                   (or last-dot 0)
                   (or (cl-position ?. suffix) (length suffix)))))
        (let ((dir (if last-dot (substring string 0 last-dot) "")))
          (if (and (eq action 'lambda)
                   (equal dir (minibuffer-contents)))
              t
            (cl-flet ((component-after-dir (p)
                        (let* ((relative (string-remove-prefix dir p))
                               (trail (cl-position ?. relative)))
                          (substring relative 0 trail))))
              (complete-with-action
               action
               (cl-remove-duplicates
                (cl-loop for path in paths
                         for component = (component-after-dir path)
                         when (string-prefix-p dir path)
                         collect (concat component "."))
                :test #'string=)
               (component-after-dir string)
               predicate))))))))

(completing-read "Open: "             
                 (complete-paths      
                  (list
                   "lang.clojure.func"
                   "lang.clojure.operators"
                   "lang.clojure"
                   "lang.python.func"            
                   "lang.python.operators"
                   "lang.python")) nil t "lang.")

It needs more work but its a great starting point and shows how one could achieve this.

[clemera]

For an ivy like UI try the above with verico

[vicrdguez]

This is awesome @clemera ! I was looking for something like this for the #5 discussion, because I wanted programmed completion there.
Definitely a great starting point, I will give it a try!

Also verico is pretty interesting, worth a deeper look

Thanks for the recommendation!