From 6051927c8fa32cfffa102d2a170c5a6cf747a1b9 Mon Sep 17 00:00:00 2001 From: nsfisis Date: Sun, 9 Aug 2026 11:19:03 +0900 Subject: refactor(symfony-console): extract symfony/console into the shirabe-symfony-console crate Move `Symfony\Component\Console` out of shirabe-external-packages and into its own crate, so the path is `shirabe_symfony_console::application::Application` instead of `shirabe_external_packages::symfony::console::application::Application`. The `delegate_to_inner!` and `delegate_command_trait_impls_to_inner!` macros move with it. Co-Authored-By: Claude Opus 5 (1M context) --- .../src/command/dump_completion_command.rs | 295 +++++++++++++++++++++ 1 file changed, 295 insertions(+) create mode 100644 crates/shirabe-symfony-console/src/command/dump_completion_command.rs (limited to 'crates/shirabe-symfony-console/src/command/dump_completion_command.rs') diff --git a/crates/shirabe-symfony-console/src/command/dump_completion_command.rs b/crates/shirabe-symfony-console/src/command/dump_completion_command.rs new file mode 100644 index 00000000..efe116a9 --- /dev/null +++ b/crates/shirabe-symfony-console/src/command/dump_completion_command.rs @@ -0,0 +1,295 @@ +//! ref: composer/vendor/symfony/console/Command/DumpCompletionCommand.php + +use crate::command::command::{Command, CommandData}; +use crate::completion::completion_input::CompletionInput; +use crate::completion::completion_suggestions::{CompletionSuggestions, StringOrSuggestion}; +use crate::input::input_argument::InputArgument; +use crate::input::input_interface::InputInterface; +use crate::input::input_option::InputOption; +use crate::output::output_interface::{self, OutputInterface}; +use shirabe_php_shim::{PhpMixed, impl_php_class}; +use shirabe_symfony_process::process::Process; +use std::ops::{Deref, DerefMut}; + +/// __DIR__.'/../Resources/completion.bash', embedded at compile time (this port ships as a +/// single binary and does not install the Resources directory alongside it). +const COMPLETION_BASH: &str = include_str!("../Resources/completion.bash"); + +/// Dumps the completion script for the current shell. +#[derive(Debug)] +pub struct DumpCompletionCommand { + inner: CommandData, +} + +impl_php_class!( + DumpCompletionCommand, + r"Symfony\Component\Console\Command\DumpCompletionCommand" +); + +impl Deref for DumpCompletionCommand { + type Target = CommandData; + + fn deref(&self) -> &Self::Target { + &self.inner + } +} + +impl DerefMut for DumpCompletionCommand { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} + +impl Default for DumpCompletionCommand { + fn default() -> Self { + Self::new() + } +} + +impl DumpCompletionCommand { + pub const DEFAULT_NAME: &'static str = "completion"; + pub const DEFAULT_DESCRIPTION: &'static str = "Dump the shell completion script"; + + pub fn new() -> Self { + let command = DumpCompletionCommand { + inner: CommandData::new(None), + }; + // PHP: static $defaultName = 'completion' / $defaultDescription, applied by the parent + // constructor before configure(). + command + .inner + .apply_default_name(Self::DEFAULT_NAME) + .expect("DumpCompletionCommand default name is valid"); + command.inner.set_description(Self::DEFAULT_DESCRIPTION); + command + .configure() + .expect("DumpCompletionCommand::configure uses static, valid metadata"); + command + } + + pub fn complete_impl( + &self, + input: &CompletionInput, + suggestions: &mut CompletionSuggestions, + ) -> anyhow::Result<()> { + if input.must_suggest_argument_values_for("shell") { + suggestions.suggest_values( + self.get_supported_shells()? + .into_iter() + .map(StringOrSuggestion::String) + .collect(), + ); + } + Ok(()) + } + + fn guess_shell() -> String { + shirabe_php_shim::basename( + &shirabe_php_shim::PHP_SERVER + .lock() + .unwrap() + .get("SHELL") + .unwrap_or_default() + .to_string_lossy(), + ) + } + + /// The PHP closure captures `$output` by reference; `Process::run` needs a `'static` + /// callback, so the shared handle is moved into it instead. + fn tail_debug_log( + &self, + command_name: &str, + output: std::rc::Rc>, + ) -> anyhow::Result<()> { + let debug_file = format!( + "{}/sf_{}.log", + shirabe_php_shim::sys_get_temp_dir(), + command_name + ); + if !shirabe_php_shim::file_exists(&debug_file) { + shirabe_php_shim::touch(&debug_file); + } + // new Process(['tail', '-f', $debugFile], null, null, null, 0) — timeout 0 disables it; + // like PHP, this tails forever until the user interrupts. + let mut process = Process::new( + vec!["tail".to_string(), "-f".to_string(), debug_file], + None, + None, + PhpMixed::Null, + Some(0.0), + )?; + process.run( + Some(Box::new(move |_type: &str, line: &str| { + output.borrow_mut().write( + &[line.to_string()], + false, + output_interface::OUTPUT_NORMAL, + ); + false + })), + indexmap::IndexMap::new(), + )?; + Ok(()) + } + + fn get_supported_shells(&self) -> anyhow::Result> { + // Deviation from PHP: the PHP implementation scans __DIR__.'/../Resources/' with a + // DirectoryIterator at runtime; the resources are embedded at compile time in this + // port, so the supported shells are a static list. + Ok(vec!["bash".to_string()]) + } +} + +impl Command for DumpCompletionCommand { + fn configure(&self) -> anyhow::Result<()> { + let full_command = shirabe_php_shim::PHP_SERVER + .lock() + .unwrap() + .php_self() + .unwrap_or_default() + .to_string_lossy() + .into_owned(); + let command_name = shirabe_php_shim::basename(&full_command); + // @realpath($fullCommand) ?: $fullCommand + let full_command = match shirabe_php_shim::realpath(&full_command) { + Some(p) if !p.is_empty() => p, + _ => full_command, + }; + + self.inner.set_help(&format!( + "The %command.name% command dumps the shell completion script required\n\ + to use shell autocompletion (currently only bash completion is supported).\n\ + \n\ + Static installation\n\ + -------------------\n\ + \n\ + Dump the script to a global completion file and restart your shell:\n\ + \n\ + \x20\x20\x20\x20%command.full_name% bash | sudo tee /etc/bash_completion.d/{command_name}\n\ + \n\ + Or dump the script to a local file and source it:\n\ + \n\ + \x20\x20\x20\x20%command.full_name% bash > completion.sh\n\ + \n\ + \x20\x20\x20\x20# source the file whenever you use the project\n\ + \x20\x20\x20\x20source completion.sh\n\ + \n\ + \x20\x20\x20\x20# or add this line at the end of your \"~/.bashrc\" file:\n\ + \x20\x20\x20\x20source /path/to/completion.sh\n\ + \n\ + Dynamic installation\n\ + --------------------\n\ + \n\ + Add this to the end of your shell configuration file (e.g. \"~/.bashrc\"):\n\ + \n\ + \x20\x20\x20\x20eval \"$({full_command} completion bash)\"", + )); + self.inner.add_argument( + "shell", + Some(InputArgument::OPTIONAL), + "The shell type (e.g. \"bash\"), the value of the \"$SHELL\" env var will be used if this is not given", + PhpMixed::Null, + )?; + self.inner.add_option( + "debug", + PhpMixed::Null, + Some(InputOption::VALUE_NONE), + "Tail the completion debug log", + PhpMixed::Null, + )?; + + Ok(()) + } + + fn execute( + &self, + input: std::rc::Rc>, + output: std::rc::Rc>, + ) -> anyhow::Result { + let command_name = shirabe_php_shim::basename( + &shirabe_php_shim::PHP_SERVER + .lock() + .unwrap() + .argv() + .next() + .unwrap_or_default() + .to_string_lossy(), + ); + + if input.borrow().get_option("debug")?.to_bool() { + self.tail_debug_log(&command_name, output.clone())?; + + return Ok(0); + } + + let shell = match input.borrow().get_argument("shell")?.as_string() { + Some(s) => s.to_string(), + None => Self::guess_shell(), + }; + // __DIR__.'/../Resources/completion.'.$shell — resolved against the embedded + // resources; a shell without an embedded script is PHP's !file_exists() branch. + let completion_file = match shell.as_str() { + "bash" => Some(COMPLETION_BASH), + _ => None, + }; + let Some(completion_file) = completion_file else { + let supported_shells = self.get_supported_shells()?; + + // if ($output instanceof ConsoleOutputInterface) { $output = $output->getErrorOutput(); } + let output = { + let error_output = output + .borrow() + .as_console_output() + .map(|console_output| console_output.get_error_output()); + error_output.unwrap_or_else(|| output.clone()) + }; + if !shell.is_empty() { + output.borrow_mut().writeln( + &[format!( + "Detected shell \"{}\", which is not supported by Symfony shell completion (supported shells: \"{}\").", + shell, + supported_shells.join("\", \"") + )], + output_interface::OUTPUT_NORMAL, + ); + } else { + output.borrow_mut().writeln( + &[format!( + "Shell not detected, Symfony shell completion only supports \"{}\").", + supported_shells.join("\", \"") + )], + output_interface::OUTPUT_NORMAL, + ); + } + + return Ok(2); + }; + + let application = self.get_application().unwrap(); + let version = application.borrow().get_version(); + output.borrow_mut().write( + &[shirabe_php_shim::str_replace_arrays( + &[ + "{{ COMMAND_NAME }}".to_string(), + "{{ VERSION }}".to_string(), + ], + &[command_name, version], + completion_file, + )], + false, + output_interface::OUTPUT_NORMAL, + ); + + Ok(0) + } + + fn complete( + &self, + input: &CompletionInput, + suggestions: &mut CompletionSuggestions, + ) -> anyhow::Result<()> { + self.complete_impl(input, suggestions) + } + + crate::delegate_command_trait_impls_to_inner!(inner); +} -- cgit v1.3.1-4-g156e