How to pass infix value of a parent prefix to sub-prefix without first set/save the value

[willvio]

I'm currently working with transient version 0.7.7 (fc03c0b) and looking to access the infix values from a parent prefix within a sub-prefix without saving the parent prefix first. I've read this relevant issue, but it seems the behavior discussed there has changed.

Here’s a revised example based on the original post:

(transient-define-suffix transient-toys--wave ()
  "Wave at the user"
  (interactive)
  (message (propertize
            (format "Waves at %s" (current-time-string))
            'face 'success)))

(transient-define-suffix transient-toys--msg-parent-args ()
  "Show current infix args"
  :key "a"
  :description "show parent args"
  (interactive)
  (let ((args (transient-args 'transient-toys-wave-parent)))
    (message (concat (propertize "Parent args: " 'face 'success)
                     (format "%s\n" args)
		     (propertize "transient-current-command: " 'face 'success)
		     (format "%s\n" transient-current-command)
		     (propertize "transient--prefix command: " 'face 'success)
		     (format "%s" (oref transient--prefix command))))))

(transient-define-prefix transient-toys--wave-sub-prefix ()
  "Wave at the user"
  ["Sub Prefix"
   ["" "Options"
    ("-s" "switch" "--switch")]
   ["" "Commands"
    ("w" "wave" transient-toys--wave :transient transient--do-return)
    (transient-toys--msg-parent-args :transient transient--do-stay)]])

(transient-define-prefix transient-toys-wave-parent ()
  "Wave at the user"
  ["Parent prefix"
   ["" "Options"
    ("-s" "switch" "--switch")]
   ["" "Commands"
    ("w" "wave submenu" transient-toys--wave-sub-prefix)]])

(transient-toys-wave-parent)

When pressing a within the sub-prefix, I expected transient-toys--msg-parent-args to print the infix values set in the parent prefix when the switch option is enabled, which happened according to the original post. However, it doesn’t print the expected values when I tried it. After some investigation, I noticed in the documentation for transient-args that it mentions the following:

If the current command (transient-toys--msg-parent-args) was not invoked from the PREFIX ('transient-toys-wave-parent), it returns the set, saved, or default value.

This leads me to believe that the observed behavior may be expected due to the change in how transient-args works since the original post.

I then modified transient-toys--msg-parent-args to use transient-current-command instead of 'transient-toys-wave-parent directly and added some debug messages:

(transient-define-suffix transient-toys--wave ()
  "Wave at the user"
  (interactive)
  (message (propertize
            (format "Waves at %s" (current-time-string))
            'face 'success)))

(transient-define-suffix transient-toys--msg-parent-args ()
  "Show current infix args"
  :key "a"
  :description "show parent args"
  (interactive)
  (let ((args (transient-args 'transient-toys-wave-parent)))
    (message (concat (propertize "Parent args: " 'face 'success)
                     (format "%s\n" args)
		     (propertize "transient-current-command: " 'face 'success)
		     (format "%s\n" transient-current-command)
		     (propertize "transient--prefix command: " 'face 'success)
		     (format "%s" (oref transient--prefix command))))))

(transient-define-prefix transient-toys--wave-sub-prefix ()
  "Wave at the user"
  ["Info"
   (:info (lambda() (interactive) (concat (propertize "transient-current-command: " 'face 'success)
					   (format "%s" transient-current-command))) :format "%d")]
  ["Sub Prefix"
   ["Options"
    ("-s" "switch" "--switch")]
   ["Commands"
    ("w" "wave" transient-toys--wave :transient transient--do-return)
    (transient-toys--msg-parent-args :transient transient--do-stay)]])

(transient-define-prefix transient-toys-wave-parent ()
  "Wave at the user"
  ["Parent prefix"
   ["" "Options"
    ("-s" "switch" "--switch")]
   ["" "Commands"
    ("w" "wave submenu" transient-toys--wave-sub-prefix)]])

(transient-toys-wave-parent)

In this case, since transient-toys--msg-parent-args is invoked with transient--do-stay, I expected transient--export not executed, so transient-current-command would still be the parent. However, it appears that calling transient-toys--msg-parent-args resets transient-current-command to nil in the sub-prefix rather than preserving the initial command context.

Questions:

1. Is this behavior in the first example expected, due to the change in transient-args?
2. Calling transient-args doesn't seem to work. Is there an approach to pass infix values from a parent prefix to a sub-prefix, allowing access to them in the sub-prefix without saving the parent prefix?

Thank you for any insights or clarifications regarding this behavior!

[tarsius]

The code you are quoting was an experiment by someone else. I am not sure to what extend it was expected to work back then. If some part of it doesn't work now, it probably also didn't work then.

It would be easier for me to help, if you described what you are trying to achieve.

Depending on what you want to do, maybe this is all you need:

(transient-define-prefix demo ()
  [("-a" "Arg" "--arg")
   ("-b" "Bar" "--bar")
   ("s" "Submenu" demo-sub)
   (transient-echo-arguments)])

(transient-define-prefix demo-sub ()
  [("-a" "Arg" "--arg")
   ("-b" "Bar" "--bar")
   (transient-echo-arguments)]
  (interactive)
  (transient-setup 'demo-sub nil nil :value (transient-args 'demo)))

Note that once you have called transient-setup, that prefix becomes the "current prefix" (of which there is only one), and thus you can no longer access the outer prefix as the current prefix. You could still use transient-args to get its saved value, but since that prefix isn't currently active, you also cannot get it's "currently active" value. [That's actually a bit of an oversimplification, but still a good starting point.]

Here we deal with that by calling transient-args before transient-setup.

[willvio]

Thank you very much for the response! I’m working on setting up a transient interface to build a make project, something like this:

(transient-define-prefix demo-build ()
  ["build"
   ("1" "target a" some-shell-command-a)
   ("2" "target b" some-shell-command-b)
   ("3" "target c" some-shell-command-c)
   ("0" "some other sub-prefix that relies on the paths" other-sub-prefix)])
  
(transient-define-prefix demo ()
  ["demo"
   ("-p" "path to the project" "/path/to/project/")
   ("-t" "path to the toolchain" "/path/to/toolchain/")
   ("b" "build" demo-build)])

Each some-shell-command-x needs to access the paths specified in the demo prefix, as does the sub-sub-prefix. I’m looking for a way to pass these paths from the main prefix (demo) down through each level, without needing to redefine the same arguments in each sub-prefix.

Your example nearly solves the problem, but when I tried it, if I removed arguments ("-a" "Arg" "--arg") and ("-b" "Bar" "--bar") from demo-sub, transient-echo-arguments can no longer access them. Did I overlook something? I’d prefer not to duplicate the same arguments across sub-prefixes.

[tarsius]

Your example nearly solves the problem, but when I tried it, if I removed arguments ("-a" "Arg" "--arg") and ("-b" "Bar" "--bar") from demo-sub, transient-echo-arguments can no longer access them. Did I overlook something?

This is the life-cycle of the prefix's value.

1. It is stored in the prefix object's value slot.
2. Each infix argument extracts it's part of that value from the prefix value and stores it in its own value slot.
3. When a user toggles or sets an infix, the value in the infix objects value slot is changed. The value slot of the prefix value is not touched.
4. A suffix calls transient-args. That collects the overall value from the values of all the infixes of the prefix.

I can think of several ways to tackle this but most of them involve some changes to Transient itself. I'll look into some of these, for now we need something else.

[tarsius]

We can (ab?)use the "scope" of the sub-prefix to inherit the value of the parent prefix. The scope is a kind of "secondary value" used by, e.g., magit-branch-configure (which lets you configure some branch; the scope specifies which branch we are configuring this time around).

(transient-define-prefix demo ()
  [("-a" "Arg" "--arg")
   ("-b" "Bar" "--bar")
   ("s" "Submenu" demo-sub)
   (transient-echo-arguments)])

(transient-define-prefix demo-sub ()
  [("-l" "local arg" "--local")
   ("a" "target a" demo-suffix)]
  (interactive)
  (transient-setup 'demo-sub nil nil :scope (transient-args 'demo)))

(defun demo-args ()
  (append (transient-args 'demo-sub)
          (and transient-current-prefix
               (transient-scope))))

(defun demo-suffix (args)
  (interactive (list (demo-args)))
  (message "arguments: %S" args))

I'll probably soon make transient-scope more like transient-value. Once you have done that you'll need:

(defun demo-args ()
  (append (transient-args 'demo-sub)
          (transient-scope 'demo-sub)))

[tarsius]

The scope-value branch changes transient-scope so that it can be used as in the second variant. This will probably make it into the next release, early December.

[tarsius]

Some further experiments on the scope-value branch also make this possible:

(transient-define-prefix demo ()
  [("-a" "Arg" "--arg")
   ("-b" "Bar" "--bar")
   ("s" "Submenu" demo-sub)
   (transient-echo-arguments)])

(defclass demo-sub-prefix (transient-prefix) ())

(cl-defmethod transient-init-scope ((obj demo-sub-prefix))
  (oset obj scope (transient-args 'demo)))

(cl-defmethod transient-prefix-value ((obj demo-sub-prefix))
  (append (cl-call-next-method)
          (transient-scope 'demo-sub)))

(transient-define-prefix demo-sub ()
  :class 'demo-sub-prefix
  [("-l" "local arg" "--local")
   ("a" "target a" demo-suffix)
   ;; Note how that now echos *all* enabled arguments too.
   ("b" "target b" transient-echo-arguments)]
  ;; Note how we no longer need a body; the default will do.
  )

(defun demo-suffix (args)
  ;; Note how we can just use `transient-args' as usual.
  (interactive (list (transient-args 'demo-sub)))
  (message "arguments: %S" args))

Note that the arguments of demo are inherited by demo-sub, even if demo-sub is invoked directly. Invoke demo, set an argument and save the arguments using C-x C-s. Then M-x demo-sub and invoke a suffix. Note how the echoed arguments include the argument you previously saved.