Values go missing when refreshing predicates + predicates called too early

[jdtsmith]

Issue #157 mentions predicate refreshing. I've finally gotten around to testing :refresh-suffixes t. It's a great feature, thanks for implementing.

A couple of small issues I noticed with it:

Values go missing

When hiding a given block, like [:if-not some-predicate..., any existing values, including those passed in via prefix slot :value, go missing when those options are "hidden". I.e. when a hidden block becomes visible (e.g. because some other options are toggled), the values are no longer there, even if they were set in :value or specified by the user during the same active prefix.

Expectation

Hidden infix value should be retained, since they may soon be unhidden.

Predicates are evaluated too early to have reliable access to other infix values

I notice that the :if predicate is usually evaluated too early, prior to the prefix being set, so it cannot reliably respond to the initial value of other arguments. Any additional command (even arrow key, etc.) then refreshes. This is likely related more to internal access to the current prefix state than predicate refresh. Perhaps a single refresh after the prefix is fully setup would help here.

Expectation

The initial state of the prefix reflects all current values.

Example

Here's an example that shows both of these issue. Set the --loo value to an even or odd number to hide the other column.

I'm not sure if this is the current best way to pull the "state of the other infix arguments" in an :if/etc. predicate. I recognize this is using an internal variable, but it's what I've needed to use in the past to get "in flight access" to other state in an active prefix:

(transient-define-prefix my-hidden-block ()
  :value (lambda () '("--foo=7" "--boo=13" "--loo=16"))
  :refresh-suffixes t
  [:description "The Hidden Block is Missing Its Values"
                ["Set to even to show another block:"
                 ("-l" "loo" "--loo=" :always-read t)]
                [:if (lambda ()
                       (let* ((transient-current-command (oref transient--prefix command))
			      (transient-current-suffixes transient--suffixes)
                              (args (transient-args transient-current-command))
                              (loo (transient-arg-value "--loo=" args)))
                         (or (not loo) (= (% (string-to-number loo) 2) 0))))
                 "These values go missing:"
                 ("-b" "a boo" "--boo=" :always-read t)
                 ("-f" "a foo" "--foo=" :always-read t)]])

[tarsius]

When I added the ability to hide groups, what I intended that to be used for is "value-less" suffix commands, not arguments. I also did not intend for the "value" to be used in predicates.

Maybe supporting these things would make sense, but implementing that could turn out to be difficult. Please provide a real-live example where this would be useful.

I consider this a feature request and have thus converted it to a "discussion".

[jdtsmith]

Thanks. So it's an accidental side-effect that it works for groups of arguments (but work it does!). The real-life scenario is having a group of infix arguments appear if and only if other conditions (which may depend on the live value of other arguments) hold true.

For example, in the case of my transient, I'm crafting the arguments to call an external process with, and then as an action, create a comint buffer attached to that process. The comint buffer name is "computed" from various additional argument values. But if that buffer already exists and has a live process, I modify the description of the single Ret suffix (via its :description function) to "visit buffer...". If the buffer and its process already exist, and it is only going to be visited (not created), it makes little sense to provide ways to alter the process' calling arguments. I could of course use :inapt-*, but those also are not live.

All of this relies on :if/:description/etc. functions having access to the value state of other arguments, live. Hence the (oref transient--prefix command). I do not know if there is a better method to do this. I also now believe my direct use of :value could be problematic here (vs. a class which does (oset obj value ....)).

[tarsius]

But if that buffer already exists and has a live process, I modify the description of the single Ret suffix (via its :description function) to "visit buffer...". If the buffer and its process already exist, and it is only going to be visited (not created), it makes little sense to provide ways to alter the process' calling arguments.

Sounds to me like the predicate of the "arguments that are useful, iff we are going to create a new buffer/process" group should use buffer-live-p and/or process-live-p. From this abstract description I am having a hard time imagining why you would look at other arguments instead/also.

[jdtsmith]

Apologies if it was unclear. The other arguments (which are not being hidden) are used to set the name of the process buffer. You can have one or more such buffers at the same time. So I use a combination of inspecting the other arguments to find out what the buffer will be named, and comint-check-proc to see if it is a buffer with a live comint process already.