Is there a way to dynamically generate multiple columns?

[antifuchs]

I've long wanted to make a "universal" transient that allows me to activate shortcuts based on the things that are active in the current buffer. Yep, that sounds like context-transient, except multiple contexts can be active for a buffer at the same time (say, it could be both in rust-ts-mode and could be eglot-managed, as well as under git version control), which context-transient solves by prompting for the context's transient menu to show... I'd like instead to have a single transient menu with columns that get activated or deactivated based on the context.

I thought something like the following could work:

(defvar asf--transient-groups (make-hash-table))

(cl-defmacro asf-transient-define-group (name (&key major-mode) group)
  `(setf (gethash ',name asf--transient-groups)
         (lambda ()
           (when (and ,@(when major-mode `((eq major-mode ,major-mode))))
             ',group))))

(defun asf--transient-setup-general-children (g)
  (list
   (eval (transient--parse-group
          'asf-transient
          `[:class transient-subgroups
                   ,@(cl-loop for group-fn being the hash-values of asf--transient-groups
                              for maybe-group = (funcall group-fn)
                              if maybe-group collect maybe-group)]))
   t))

(transient-define-prefix asf-transient ()
  [[("q" "quit" transient-quit-all)]
   [
    :class transient-subgroups
    :setup-children asf--transient-setup-general-children
    ;; content to compare with in the debugger:
    ["hi" ("b" "nothing" text-mode)]
    ["ho" ("d" "nothing 2" text-mode)]]])

(defun asf--cargo-process-doc ()
  (interactive)
  (let ((cargo-process--command-doc "+nightly doc"))
    (cargo-process-doc)))

(defun asf--cargo-process-doc-open ()
  (interactive)
  (let ((cargo-process--command-doc-open "+nightly doc --open"))
    (cargo-process-doc-open)))

(asf-transient-define-group rust-cargo (:major-mode 'rust-ts-mode)
                            ["Cargo"
                             :class transient-column
                             ("d" "doc" asf--cargo-process-doc)
                             ("D" "doc --open" asf--cargo-process-doc-open)
                             ("r" "run" cargo-process-run)])

But when invoking that transient in rust-ts-mode, I get the error (error "cl-etypecase failed: t, (vector list string)") from transient--init-child, which seems to indicate that either I'm doing something that isn't supported by transient, or I'm getting the data format wrong. It does look like transient--parse-group is returning the parsed group in a format different from what the :setup-children function is expected to return.

...or something else is wrong. So, how do I set things up such that I can have these dynamic columns?

[tarsius]

That's what the :if* and :inapt-if* predicates are for. No need to generate anything dynamically.

(transient-define-prefix demo ()
  [["Rust"
    :if-derived rust-ts-mode
    ("a" "A" transient-echo-arguments)
    ("b" "B" transient-echo-arguments)]
   ["Elisp"
    :if-derived emacs-lisp-mode
    ("c" "C" transient-echo-arguments)
    ("d" "D" transient-echo-arguments)]
   ["Outline-Minor"
    :if-non-nil outline-minor-mode
    ("c" "C" transient-echo-arguments)
    ("d" "D" transient-echo-arguments)]])

Instead of hiding the commands that are currently not useful, you can alternatively disable and dim them, by using, e.g., :inapt-if-not-derived rust-ts-mode.

For an example for when it is appropriate and necessary to use :setup-children and how to do it, see notmuch-search-transient in my notmuch-transient package. notmuch-saved-searches is a user option.

[antifuchs]

Yep, I'm aware of :if and its friends; that does work but I was hoping to break the transient "parts" into pieces across my literate emacs configuration - one piece per language major-mode, one piece per utility minor-mode, that kind of thing.

I guess I'll keep using this :if-based version. Thanks.

Another question that came up in my multi-hour journey digging into this yesterday: How is transient-subgroups supposed to be used in the first place? I couldn't get that to work with :setup-children functions at all, so is there something that needs to be overridden in the transient group protocol by users of that?

[tarsius]

I was hoping to break the transient "parts" into pieces

That too is possible without doing it dynamically:

(defvar demo-rust
  ["Rust"
   :inapt-if-not-derived rust-ts-mode
   ("a" "A" (lambda () (interactive) (message "aaaa")))
   ("b" "B" transient-echo-arguments)])

(defvar demo-elisp
  ["Elisp"
   :if-derived emacs-lisp-mode
   ("c" "C" transient-echo-arguments)
   ("d" "D" transient-echo-arguments)])

(defvar demo-outline-minor
  ["Outline-Minor"
   :if-non-nil outline-minor-mode
   ("e" "E" transient-echo-arguments)
   ("f" "F" transient-echo-arguments)])

(transient-define-prefix demo ()
  [demo-rust
   demo-elisp
   demo-outline-minor])