From 145b4c0a7fadf6dfd8c03b22c735695037930b0a Mon Sep 17 00:00:00 2001 From: nsfisis Date: Sun, 2 Aug 2026 11:08:57 +0900 Subject: feat(console-input): port the suggested-values backport onto InputArgument/InputOption Composer backports symfony/console 6.1's $suggestedValues parameter in Composer\Console\Input\{InputArgument,InputOption}; the Rust newtypes had dropped it. PHP closures are bound to the command ($this), but a command cannot capture a handle to itself while configure() runs inside new(), so the closure receives the bound command as an explicit `this` argument at call time instead. - add SuggestedValues (list | this-taking closure) and wire it through InputArgument::new5 / InputOption::new6 and their complete() methods - track Composer-typed definition entries by name in BaseCommandData side maps, standing in for PHP's instanceof checks (set_definition converts entries to the Symfony types for storage) - add base_command_complete, the BaseCommand::complete dispatch shared by every Composer command - introduce BaseCommand::base_command_data and make command_data a default method on top of it Co-Authored-By: Claude Fable 5 --- crates/shirabe/src/console/input.rs | 85 +++++++++++++++++++++- crates/shirabe/src/console/input/input_argument.rs | 44 ++++++++++- crates/shirabe/src/console/input/input_option.rs | 52 ++++++++++++- 3 files changed, 173 insertions(+), 8 deletions(-) (limited to 'crates/shirabe/src/console') diff --git a/crates/shirabe/src/console/input.rs b/crates/shirabe/src/console/input.rs index 9141f0cb..9661c7ad 100644 --- a/crates/shirabe/src/console/input.rs +++ b/crates/shirabe/src/console/input.rs @@ -4,9 +4,86 @@ pub mod input_option; pub use input_argument::*; pub use input_option::*; +use shirabe_external_packages::symfony::console::completion::completion_input::CompletionInput; +use shirabe_external_packages::symfony::console::completion::completion_suggestions::{ + CompletionSuggestions, StringOrSuggestion, +}; + +/// PHP: `\Closure(CompletionInput,CompletionSuggestions):list`. +/// +/// PHP closures are bound to the command instance (`$this`); commands cannot capture a handle +/// to themselves while `configure()` runs inside `new()`, so the bound command is passed in as +/// `this` at call time instead. +pub type SuggestedValuesClosure = Box< + dyn Fn( + &dyn crate::command::BaseCommand, + &CompletionInput, + &mut CompletionSuggestions, + ) -> anyhow::Result>, +>; + +/// PHP: the `list|\Closure(...)` union taken by the suggestedValues parameter of the +/// `Composer\Console\Input\InputArgument` / `InputOption` backport. +/// +/// The closure returns `Vec` rather than `list`: every Composer +/// closure returns plain strings, and `complete` lifts them into suggestions. PHP's runtime +/// "Closure must return an array" LogicException is statically guaranteed by the type. +pub enum SuggestedValues { + List(Vec), + Closure(SuggestedValuesClosure), +} + +impl std::fmt::Debug for SuggestedValues { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + SuggestedValues::List(values) => f.debug_tuple("List").field(values).finish(), + SuggestedValues::Closure(_) => f.write_str("Closure(..)"), + } + } +} + +impl SuggestedValues { + /// Whether PHP's `[] !== $suggestedValues` is false, i.e. no suggestions were declared. + pub(crate) fn is_empty(&self) -> bool { + matches!(self, SuggestedValues::List(values) if values.is_empty()) + } + + /// The shared body of the `InputArgument::complete` / `InputOption::complete` backport. + pub(crate) fn complete( + &self, + this: &dyn crate::command::BaseCommand, + input: &CompletionInput, + suggestions: &mut CompletionSuggestions, + ) -> anyhow::Result<()> { + let values = match self { + SuggestedValues::List(values) => values.clone(), + SuggestedValues::Closure(closure) => closure(this, input, suggestions)?, + }; + if !values.is_empty() { + suggestions + .suggest_values(values.into_iter().map(StringOrSuggestion::String).collect()); + } + Ok(()) + } + + /// PHP: `$this->suggestX()($input)` — invoking a suggestion closure directly. Calling this + /// on a List is a programming error (PHP would fatal on `$array()`). + pub fn call( + &self, + this: &dyn crate::command::BaseCommand, + input: &CompletionInput, + suggestions: &mut CompletionSuggestions, + ) -> anyhow::Result> { + match self { + SuggestedValues::Closure(closure) => closure(this, input, suggestions), + SuggestedValues::List(_) => panic!("SuggestedValues::call on a non-closure"), + } + } +} + pub enum InputDefinitionItem { - Argument(input_argument::InputArgument), - Option(input_option::InputOption), + Argument(std::rc::Rc), + Option(std::rc::Rc), } impl InputDefinitionItem { @@ -26,12 +103,12 @@ impl InputDefinitionItem { impl From for InputDefinitionItem { fn from(value: input_argument::InputArgument) -> Self { - Self::Argument(value) + Self::Argument(std::rc::Rc::new(value)) } } impl From for InputDefinitionItem { fn from(value: input_option::InputOption) -> Self { - Self::Option(value) + Self::Option(std::rc::Rc::new(value)) } } diff --git a/crates/shirabe/src/console/input/input_argument.rs b/crates/shirabe/src/console/input/input_argument.rs index 5fd9cecc..ab32ffba 100644 --- a/crates/shirabe/src/console/input/input_argument.rs +++ b/crates/shirabe/src/console/input/input_argument.rs @@ -1,11 +1,15 @@ //! ref: composer/src/Composer/Console/Input/InputArgument.php +use crate::console::input::SuggestedValues; +use shirabe_external_packages::symfony::console::completion::completion_input::CompletionInput; +use shirabe_external_packages::symfony::console::completion::completion_suggestions::CompletionSuggestions; use shirabe_external_packages::symfony::console::input::InputArgument as BaseInputArgument; use shirabe_php_shim::PhpMixed; #[derive(Debug)] pub struct InputArgument { inner: BaseInputArgument, + suggested_values: SuggestedValues, } impl InputArgument { @@ -18,7 +22,23 @@ impl InputArgument { mode: Option, description: &str, default: Option, - // TODO(cli-completion): suggested_values closure / list dropped along with completion support + ) -> anyhow::Result { + Self::new5( + name, + mode, + description, + default, + SuggestedValues::List(Vec::new()), + ) + } + + /// PHP's constructor with the fifth parameter, `$suggestedValues`. + pub fn new5( + name: &str, + mode: Option, + description: &str, + default: Option, + suggested_values: SuggestedValues, ) -> anyhow::Result { let inner = BaseInputArgument::new( name.to_string(), @@ -26,7 +46,27 @@ impl InputArgument { description.to_string(), default.unwrap_or(PhpMixed::Null), )?; - Ok(Self { inner }) + Ok(Self { + inner, + suggested_values, + }) + } + + /// Adds suggestions to `suggestions` for the current completion input. + /// + /// PHP closures are bound to the command; `this` is the command dispatching the + /// completion (see [`SuggestedValues`]). + pub fn complete( + &self, + this: &dyn crate::command::BaseCommand, + input: &CompletionInput, + suggestions: &mut CompletionSuggestions, + ) -> anyhow::Result<()> { + self.suggested_values.complete(this, input, suggestions) + } + + pub(crate) fn get_name(&self) -> String { + self.inner.get_name().to_string() } /// Unwraps to the underlying Symfony `InputArgument` (used when forwarding a Composer-typed diff --git a/crates/shirabe/src/console/input/input_option.rs b/crates/shirabe/src/console/input/input_option.rs index 938f5a39..7fa3d699 100644 --- a/crates/shirabe/src/console/input/input_option.rs +++ b/crates/shirabe/src/console/input/input_option.rs @@ -1,11 +1,15 @@ //! ref: composer/src/Composer/Console/Input/InputOption.php +use crate::console::input::SuggestedValues; +use shirabe_external_packages::symfony::console::completion::completion_input::CompletionInput; +use shirabe_external_packages::symfony::console::completion::completion_suggestions::CompletionSuggestions; use shirabe_external_packages::symfony::console::input::InputOption as BaseInputOption; use shirabe_php_shim::PhpMixed; #[derive(Debug)] pub struct InputOption { inner: BaseInputOption, + suggested_values: SuggestedValues, } impl InputOption { @@ -21,13 +25,57 @@ impl InputOption { mode: Option, description: &str, default: Option, - // TODO(cli-completion): suggested_values closure / list dropped along with completion support + ) -> anyhow::Result { + Self::new6( + name, + shortcut, + mode, + description, + default, + SuggestedValues::List(Vec::new()), + ) + } + + /// PHP's constructor with the sixth parameter, `$suggestedValues`. + pub fn new6( + name: &str, + shortcut: Option, + mode: Option, + description: &str, + default: Option, + suggested_values: SuggestedValues, ) -> anyhow::Result { let shortcut = shortcut.unwrap_or(PhpMixed::Null); let default_mixed = default.unwrap_or(PhpMixed::Null); let inner = BaseInputOption::new(name, shortcut, mode, description.to_string(), default_mixed)?; - Ok(Self { inner }) + // PHP throws LogicException here; suggested values on a valueless option cannot happen + // at runtime unless a configure() is wrong, so this is a programming error. + assert!( + suggested_values.is_empty() || inner.accept_value(), + "Cannot set suggested values if the option does not accept a value." + ); + Ok(Self { + inner, + suggested_values, + }) + } + + /// Adds suggestions to `suggestions` for the current completion input. + /// + /// PHP closures are bound to the command; `this` is the command dispatching the + /// completion (see [`SuggestedValues`]). + pub fn complete( + &self, + this: &dyn crate::command::BaseCommand, + input: &CompletionInput, + suggestions: &mut CompletionSuggestions, + ) -> anyhow::Result<()> { + self.suggested_values.complete(this, input, suggestions) + } + + pub(crate) fn get_name(&self) -> String { + self.inner.get_name().to_string() } /// Unwraps to the underlying Symfony `InputOption` (used when forwarding a Composer-typed -- cgit v1.3.1