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/input/argv_input.rs | 657 +++++++++++++++++++++ .../src/input/array_input.rs | 386 ++++++++++++ crates/shirabe-symfony-console/src/input/input.rs | 225 +++++++ .../src/input/input_argument.rs | 96 +++ .../src/input/input_aware_interface.rs | 7 + .../src/input/input_definition.rs | 450 ++++++++++++++ .../src/input/input_interface.rs | 60 ++ .../src/input/input_option.rs | 193 ++++++ .../src/input/streamable_input_interface.rs | 10 + .../src/input/string_input.rs | 243 ++++++++ 10 files changed, 2327 insertions(+) create mode 100644 crates/shirabe-symfony-console/src/input/argv_input.rs create mode 100644 crates/shirabe-symfony-console/src/input/array_input.rs create mode 100644 crates/shirabe-symfony-console/src/input/input.rs create mode 100644 crates/shirabe-symfony-console/src/input/input_argument.rs create mode 100644 crates/shirabe-symfony-console/src/input/input_aware_interface.rs create mode 100644 crates/shirabe-symfony-console/src/input/input_definition.rs create mode 100644 crates/shirabe-symfony-console/src/input/input_interface.rs create mode 100644 crates/shirabe-symfony-console/src/input/input_option.rs create mode 100644 crates/shirabe-symfony-console/src/input/streamable_input_interface.rs create mode 100644 crates/shirabe-symfony-console/src/input/string_input.rs (limited to 'crates/shirabe-symfony-console/src/input') diff --git a/crates/shirabe-symfony-console/src/input/argv_input.rs b/crates/shirabe-symfony-console/src/input/argv_input.rs new file mode 100644 index 00000000..d8619df9 --- /dev/null +++ b/crates/shirabe-symfony-console/src/input/argv_input.rs @@ -0,0 +1,657 @@ +//! ref: composer/vendor/symfony/console/Input/ArgvInput.php + +use crate::exception::runtime_exception::RuntimeException; +use crate::input::input::Input; +use crate::input::input_definition::InputDefinition; +use crate::input::input_interface::InputInterface; +use crate::input::streamable_input_interface::StreamableInputInterface; +use indexmap::IndexMap; +use shirabe_php_shim::{PhpMixed, php_regex}; + +/// ArgvInput represents an input coming from the CLI arguments. +/// +/// Usage: +/// +/// ```php +/// $input = new ArgvInput(); +/// ``` +/// +/// By default, the `$_SERVER['argv']` array is used for the input values. +/// +/// This can be overridden by explicitly passing the input values in the constructor: +/// +/// ```php +/// $input = new ArgvInput($_SERVER['argv']); +/// ``` +/// +/// If you pass it yourself, don't forget that the first element of the array +/// is the name of the running application. +/// +/// When passing an argument to the constructor, be sure that it respects +/// the same rules as the argv one. It's almost always better to use the +/// `StringInput` when you want to provide your own input. +#[derive(Debug, Clone)] +pub struct ArgvInput { + pub(crate) inner: Input, + tokens: Vec, + parsed: Vec, +} + +impl ArgvInput { + pub fn new( + argv: Option>, + definition: Option, + ) -> anyhow::Result { + // $argv = $argv ?? $_SERVER['argv'] ?? []; + let mut argv = match argv { + Some(argv) => argv, + None => std::env::args().collect(), + }; + + // strip the application name + if !argv.is_empty() { + argv.remove(0); + } + + let mut input = ArgvInput { + inner: Input::new(None)?, + tokens: argv, + parsed: vec![], + }; + + // parent::__construct($definition) + match definition { + None => {} + Some(definition) => { + input.bind(&definition)?; + input.inner.validate()?; + } + } + + Ok(input) + } + + pub(crate) fn set_tokens(&mut self, tokens: Vec) { + self.tokens = tokens; + } + + pub fn bind(&mut self, definition: &InputDefinition) -> anyhow::Result<()> { + self.base_bind(definition, ArgvInput::parse_token) + } + + /// Shared body of `bind` (PHP `Input::bind`). PHP's `$this->parse()` ends in + /// `$this->parseToken()`, which late-binds to `CompletionInput::parseToken`; `parseToken` + /// is protected and not part of any trait, so the concrete implementation is threaded in + /// as a callback taking the embedded ArgvInput. + pub(crate) fn base_bind( + &mut self, + definition: &InputDefinition, + parse_token: impl FnMut(&mut ArgvInput, &str, bool) -> anyhow::Result, + ) -> anyhow::Result<()> { + self.inner.arguments = IndexMap::new(); + self.inner.options = IndexMap::new(); + self.inner.definition = definition.clone(); + + self.base_parse(parse_token)?; + + Ok(()) + } + + /// Shared body of `parse`; see `base_bind` for why `parse_token` is a parameter. + fn base_parse( + &mut self, + mut parse_token: impl FnMut(&mut ArgvInput, &str, bool) -> anyhow::Result, + ) -> anyhow::Result<()> { + let mut parse_options = true; + self.parsed = self.tokens.clone(); + while !self.parsed.is_empty() { + let token = self.parsed.remove(0); + parse_options = parse_token(self, &token, parse_options)?; + } + Ok(()) + } + + pub(crate) fn parse_token(&mut self, token: &str, parse_options: bool) -> anyhow::Result { + if parse_options && token.is_empty() { + self.parse_argument(token)?; + } else if parse_options && token == "--" { + return Ok(false); + } else if parse_options && shirabe_php_shim::str_starts_with(token, "--") { + self.parse_long_option(token)?; + } else if parse_options && token.as_bytes().first() == Some(&b'-') && token != "-" { + self.parse_short_option(token)?; + } else { + self.parse_argument(token)?; + } + + Ok(parse_options) + } + + /// Parses a short option. + fn parse_short_option(&mut self, token: &str) -> anyhow::Result<()> { + let name = shirabe_php_shim::substr(token, 1, None); + + if shirabe_php_shim::strlen(&name) > 1 { + let first = shirabe_php_shim::substr(&name, 0, Some(1)); + if self.inner.definition.has_shortcut(&first) + && self + .inner + .definition + .get_option_for_shortcut(&first)? + .accept_value() + { + // an option with a value (with no space) + self.add_short_option( + &first, + PhpMixed::String(shirabe_php_shim::substr(&name, 1, None)), + )?; + } else { + self.parse_short_option_set(&name)?; + } + } else { + self.add_short_option(&name, PhpMixed::Null)?; + } + + Ok(()) + } + + /// Parses a short option set. + fn parse_short_option_set(&mut self, name: &str) -> anyhow::Result<()> { + let len = shirabe_php_shim::strlen(name); + let mut i = 0; + while i < len { + let name_i = shirabe_php_shim::substr(name, i, Some(1)); + if !self.inner.definition.has_shortcut(&name_i) { + let encoding = shirabe_php_shim::mb_detect_encoding(name, None, true); + let bad = match encoding { + None => name_i, + Some(encoding) => { + shirabe_php_shim::mb_substr(name, i, Some(1), Some(&encoding)) + } + }; + return Err(RuntimeException::new(format!( + "The \"-{}\" option does not exist.", + bad + )) + .into()); + } + + let option = self.inner.definition.get_option_for_shortcut(&name_i)?; + if option.accept_value() { + let value = if i == len - 1 { + PhpMixed::Null + } else { + PhpMixed::String(shirabe_php_shim::substr(name, i + 1, None)) + }; + self.add_long_option(option.get_name(), value)?; + + break; + } else { + self.add_long_option(option.get_name(), PhpMixed::Null)?; + } + i += 1; + } + + Ok(()) + } + + /// Parses a long option. + fn parse_long_option(&mut self, token: &str) -> anyhow::Result<()> { + let name = shirabe_php_shim::substr(token, 2, None); + + match shirabe_php_shim::strpos(&name, "=") { + Some(pos) => { + let pos = pos as i64; + let value = shirabe_php_shim::substr(&name, pos + 1, None); + if value.is_empty() { + self.parsed.insert(0, value.clone()); + } + self.add_long_option( + &shirabe_php_shim::substr(&name, 0, Some(pos)), + PhpMixed::String(value), + )?; + } + None => { + self.add_long_option(&name, PhpMixed::Null)?; + } + } + + Ok(()) + } + + /// Parses an argument. + fn parse_argument(&mut self, token: &str) -> anyhow::Result<()> { + let c = self.inner.arguments.len() as i64; + + // if input is expecting another argument, add it + if self.inner.definition.has_argument(&PhpMixed::Int(c)) { + let arg = self.inner.definition.get_argument(&PhpMixed::Int(c))?; + let value = if arg.is_array() { + PhpMixed::List(vec![PhpMixed::String(token.to_string())]) + } else { + PhpMixed::String(token.to_string()) + }; + self.inner + .arguments + .insert(arg.get_name().to_string(), value); + + // if last argument isArray(), append token to last argument + } else if self.inner.definition.has_argument(&PhpMixed::Int(c - 1)) + && self + .inner + .definition + .get_argument(&PhpMixed::Int(c - 1))? + .is_array() + { + let arg = self.inner.definition.get_argument(&PhpMixed::Int(c - 1))?; + if let Some(PhpMixed::List(list)) = self.inner.arguments.get_mut(arg.get_name()) { + list.push(PhpMixed::String(token.to_string())); + } + + // unexpected argument + } else { + let mut all = self.inner.definition.get_arguments().clone(); + let mut symfony_command_name: Option = None; + let first_key = all.keys().next().cloned(); + if let Some(key) = &first_key { + let input_argument = &all[key]; + if input_argument.get_name() == "command" { + symfony_command_name = self.inner.arguments.get("command").cloned(); + all.shift_remove(key); + } + } + + let message = if !all.is_empty() { + let names: Vec = all.keys().cloned().collect(); + match &symfony_command_name { + Some(symfony_command_name) + if !matches!(symfony_command_name, PhpMixed::Null) => + { + format!( + "Too many arguments to \"{}\" command, expected arguments \"{}\".", + symfony_command_name.clone(), + shirabe_php_shim::implode("\" \"", &names), + ) + } + _ => format!( + "Too many arguments, expected arguments \"{}\".", + shirabe_php_shim::implode("\" \"", &names), + ), + } + } else if symfony_command_name + .as_ref() + .map(|n| !matches!(n, PhpMixed::Null)) + .unwrap_or(false) + { + format!( + "No arguments expected for \"{}\" command, got \"{}\".", + symfony_command_name.unwrap(), + token, + ) + } else { + format!("No arguments expected, got \"{}\".", token) + }; + + return Err(RuntimeException::new(message).into()); + } + + Ok(()) + } + + /// Adds a short option value. + fn add_short_option(&mut self, shortcut: &str, value: PhpMixed) -> anyhow::Result<()> { + if !self.inner.definition.has_shortcut(shortcut) { + return Err(RuntimeException::new(format!( + "The \"-{}\" option does not exist.", + shortcut + )) + .into()); + } + + self.add_long_option( + self.inner + .definition + .get_option_for_shortcut(shortcut)? + .get_name(), + value, + ) + } + + /// Adds a long option value. + fn add_long_option(&mut self, name: &str, mut value: PhpMixed) -> anyhow::Result<()> { + if !self.inner.definition.has_option(name) { + if !self.inner.definition.has_negation(name) { + return Err(RuntimeException::new(format!( + "The \"--{}\" option does not exist.", + name + )) + .into()); + } + + let option_name = self.inner.definition.negation_to_name(name)?; + if !matches!(value, PhpMixed::Null) { + return Err(RuntimeException::new(format!( + "The \"--{}\" option does not accept a value.", + name + )) + .into()); + } + self.inner + .options + .insert(option_name, PhpMixed::Bool(false)); + + return Ok(()); + } + + let option = self.inner.definition.get_option(name)?; + + if !matches!(value, PhpMixed::Null) && !option.accept_value() { + return Err(RuntimeException::new(format!( + "The \"--{}\" option does not accept a value.", + name + )) + .into()); + } + + // in_array($value, ['', null], true) + let value_is_empty_or_null = matches!(&value, PhpMixed::String(s) if s.is_empty()) + || matches!(value, PhpMixed::Null); + if value_is_empty_or_null && option.accept_value() && !self.parsed.is_empty() { + // if option accepts an optional or mandatory argument + // let's see if there is one provided + let next = self.parsed.remove(0); + // (isset($next[0]) && '-' !== $next[0]) || in_array($next, ['', null], true) + let next_first = next.as_bytes().first().copied(); + if (next_first.is_some() && next_first != Some(b'-')) || next.is_empty() { + value = PhpMixed::String(next); + } else { + self.parsed.insert(0, next); + } + } + + if matches!(value, PhpMixed::Null) { + if option.is_value_required() { + return Err(RuntimeException::new(format!( + "The \"--{}\" option requires a value.", + name + )) + .into()); + } + + if !option.is_array() && !option.is_value_optional() { + value = PhpMixed::Bool(true); + } + } + + if option.is_array() { + match self.inner.options.get_mut(name) { + Some(PhpMixed::List(list)) => { + list.push(value); + } + _ => { + self.inner + .options + .insert(name.to_string(), PhpMixed::List(vec![value])); + } + } + } else { + self.inner.options.insert(name.to_string(), value); + } + + Ok(()) + } + + pub fn get_first_argument(&self) -> Option { + let mut is_option = false; + for (i, token) in self.tokens.iter().enumerate() { + if !token.is_empty() && token.as_bytes()[0] == b'-' { + if shirabe_php_shim::str_contains(token, "=") || self.tokens.get(i + 1).is_none() { + continue; + } + + // If it's a long option, consider that everything after "--" is the option name. + // Otherwise, use the last char (if it's a short option set, only the last one can take a value with space separator) + let mut name = if token.as_bytes().get(1) == Some(&b'-') { + shirabe_php_shim::substr(token, 2, None) + } else { + shirabe_php_shim::substr(token, -1, None) + }; + if !self.inner.options.contains_key(&name) + && !self.inner.definition.has_shortcut(&name) + { + // noop + } else { + if !self.inner.options.contains_key(&name) + && let Ok(resolved) = self.inner.definition.shortcut_to_name(&name) + { + name = resolved; + } + if let Some(option_value) = self.inner.options.get(&name) + && self.tokens.get(i + 1).map(|t| t.as_str()) == option_value.as_string() + { + is_option = true; + } + } + + continue; + } + + if is_option { + is_option = false; + continue; + } + + return Some(token.clone()); + } + + None + } + + pub fn has_parameter_option(&self, values: PhpMixed, only_params: bool) -> bool { + let values = to_array(values); + + for token in &self.tokens { + if only_params && token == "--" { + return false; + } + for value in &values { + // Options with values: + // For long options, test for '--option=' at beginning + // For short options, test for '-o' at beginning + let leading = if shirabe_php_shim::str_starts_with(value, "--") { + format!("{}=", value) + } else { + value.clone() + }; + if token == value + || (!leading.is_empty() && shirabe_php_shim::str_starts_with(token, &leading)) + { + return true; + } + } + } + + false + } + + pub fn get_parameter_option( + &self, + values: PhpMixed, + default: PhpMixed, + only_params: bool, + ) -> PhpMixed { + let values = to_array(values); + let mut tokens = self.tokens.clone(); + + while !tokens.is_empty() { + let token = tokens.remove(0); + if only_params && token == "--" { + return default; + } + + for value in &values { + if &token == value { + return match tokens.first() { + Some(_) => PhpMixed::String(tokens.remove(0)), + None => PhpMixed::Null, + }; + } + // Options with values: + // For long options, test for '--option=' at beginning + // For short options, test for '-o' at beginning + let leading = if shirabe_php_shim::str_starts_with(value, "--") { + format!("{}=", value) + } else { + value.clone() + }; + if !leading.is_empty() && shirabe_php_shim::str_starts_with(&token, &leading) { + return PhpMixed::String(shirabe_php_shim::substr( + &token, + shirabe_php_shim::strlen(&leading), + None, + )); + } + } + } + + default + } +} + +/// Returns a stringified representation of the args passed to the command. +impl std::fmt::Display for ArgvInput { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + let tokens: Vec = self + .tokens + .iter() + .map(|token| { + let mut r#match: Vec> = Vec::new(); + if shirabe_php_shim::preg_match(php_regex!("{^(-[^=]+=)(.+)}"), token, &mut r#match) + { + return format!( + "{}{}", + r#match[1].as_deref().unwrap_or(""), + self.inner.escape_token(r#match[2].as_deref().unwrap_or("")) + ); + } + + if !token.is_empty() && token.as_bytes()[0] != b'-' { + return self.inner.escape_token(token); + } + + token.clone() + }) + .collect(); + + write!(f, "{}", shirabe_php_shim::implode(" ", &tokens)) + } +} + +impl InputInterface for ArgvInput { + fn dup(&self) -> std::rc::Rc> { + std::rc::Rc::new(std::cell::RefCell::new(self.clone())) + } + + fn get_first_argument(&self) -> Option { + ArgvInput::get_first_argument(self) + } + + fn has_parameter_option(&self, values: PhpMixed, only_params: bool) -> bool { + ArgvInput::has_parameter_option(self, values, only_params) + } + + fn get_parameter_option( + &self, + values: PhpMixed, + default: PhpMixed, + only_params: bool, + ) -> PhpMixed { + ArgvInput::get_parameter_option(self, values, default, only_params) + } + + fn bind(&mut self, definition: &InputDefinition) -> anyhow::Result<()> { + ArgvInput::bind(self, definition) + } + + fn validate(&mut self) -> anyhow::Result<()> { + self.inner.validate() + } + + fn get_arguments(&self) -> IndexMap { + self.inner.get_arguments() + } + + fn get_argument(&self, name: &str) -> anyhow::Result { + self.inner.get_argument(name) + } + + fn set_argument(&mut self, name: &str, value: PhpMixed) -> anyhow::Result<()> { + self.inner.set_argument(name, value) + } + + fn has_argument(&self, name: &str) -> bool { + self.inner.has_argument(name) + } + + fn get_options(&self) -> IndexMap { + self.inner.get_options() + } + + fn get_option(&self, name: &str) -> anyhow::Result { + self.inner.get_option(name) + } + + fn set_option(&mut self, name: &str, value: PhpMixed) -> anyhow::Result<()> { + self.inner.set_option(name, value) + } + + fn has_option(&self, name: &str) -> bool { + self.inner.has_option(name) + } + + fn is_interactive(&self) -> bool { + self.inner.is_interactive() + } + + fn set_interactive(&mut self, interactive: bool) { + self.inner.set_interactive(interactive) + } + + fn __to_string(&self) -> String { + self.to_string() + } + + fn as_streamable(&self) -> Option<&dyn StreamableInputInterface> { + Some(self) + } + + fn as_streamable_mut(&mut self) -> Option<&mut dyn StreamableInputInterface> { + Some(self) + } +} + +impl StreamableInputInterface for ArgvInput { + fn set_stream(&mut self, stream: shirabe_php_shim::PhpResource) { + self.inner.set_stream(stream) + } + + fn get_stream(&self) -> Option { + self.inner.get_stream() + } +} + +/// PHP `(array) $values` cast: a string becomes a single-element array. +fn to_array(values: PhpMixed) -> Vec { + match values { + PhpMixed::List(list) => list + .into_iter() + .map(|v| shirabe_php_shim::php_to_string(&v)) + .collect(), + PhpMixed::Array(array) => array + .into_iter() + .map(|(_, v)| shirabe_php_shim::php_to_string(&v)) + .collect(), + PhpMixed::Null => vec![], + other => vec![shirabe_php_shim::php_to_string(&other)], + } +} diff --git a/crates/shirabe-symfony-console/src/input/array_input.rs b/crates/shirabe-symfony-console/src/input/array_input.rs new file mode 100644 index 00000000..fa1d4540 --- /dev/null +++ b/crates/shirabe-symfony-console/src/input/array_input.rs @@ -0,0 +1,386 @@ +//! ref: composer/vendor/symfony/console/Input/ArrayInput.php + +use crate::exception::invalid_argument_exception::InvalidArgumentException; +use crate::exception::invalid_option_exception::InvalidOptionException; +use crate::input::input::Input; +use crate::input::input_definition::InputDefinition; +use crate::input::input_interface::InputInterface; +use crate::input::streamable_input_interface::StreamableInputInterface; +use indexmap::IndexMap; +use shirabe_php_shim::PhpMixed; + +/// ArrayInput represents an input provided as an array. +/// +/// Usage: +/// +/// ```php +/// $input = new ArrayInput(['command' => 'foo:bar', 'foo' => 'bar', '--bar' => 'foobar']); +/// ``` +/// +/// PHP arrays can mix integer and string keys; `parameters` preserves both the +/// key type (`PhpMixed::Int` / `PhpMixed::String`) and the insertion order. +#[derive(Debug, Clone)] +pub struct ArrayInput { + pub(crate) inner: Input, + parameters: Vec<(PhpMixed, PhpMixed)>, +} + +impl ArrayInput { + pub fn new( + parameters: Vec<(PhpMixed, PhpMixed)>, + definition: Option, + ) -> anyhow::Result { + let mut array_input = ArrayInput { + inner: Input::new(None)?, + parameters, + }; + + // parent::__construct($definition) + match definition { + None => {} + Some(definition) => { + array_input.bind(&definition)?; + array_input.inner.validate()?; + } + } + + Ok(array_input) + } + + pub fn bind(&mut self, definition: &InputDefinition) -> anyhow::Result<()> { + self.inner.arguments = IndexMap::new(); + self.inner.options = IndexMap::new(); + self.inner.definition = definition.clone(); + + self.parse()?; + + Ok(()) + } + + pub fn get_first_argument(&self) -> Option { + for (param, value) in &self.parameters { + // $param && \is_string($param) && '-' === $param[0] + if let PhpMixed::String(param) = param + && !param.is_empty() + && param.as_bytes()[0] == b'-' + { + continue; + } + + return Some(value.clone()); + } + + None + } + + pub fn has_parameter_option(&self, values: PhpMixed, only_params: bool) -> bool { + let values = to_array(values); + + for (k, v) in &self.parameters { + // if (!\is_int($k)) { $v = $k; } + let v: PhpMixed = match k { + PhpMixed::Int(_) => v.clone(), + _ => k.clone(), + }; + + if only_params && matches!(&v, PhpMixed::String(s) if s == "--") { + return false; + } + + if values.iter().any(|x| x == &v) { + return true; + } + } + + false + } + + pub fn get_parameter_option( + &self, + values: PhpMixed, + default: PhpMixed, + only_params: bool, + ) -> PhpMixed { + let values = to_array(values); + + for (k, v) in &self.parameters { + // $onlyParams && ('--' === $k || (\is_int($k) && '--' === $v)) + if only_params { + let k_is_double_dash = matches!(k, PhpMixed::String(s) if s == "--"); + let int_v_double_dash = + matches!(k, PhpMixed::Int(_)) && matches!(v, PhpMixed::String(s) if s == "--"); + if k_is_double_dash || int_v_double_dash { + return default; + } + } + + match k { + PhpMixed::Int(_) => { + if values.iter().any(|x| x == v) { + return PhpMixed::Bool(true); + } + } + _ => { + if values.iter().any(|x| x == k) { + return v.clone(); + } + } + } + } + + default + } + + fn parse(&mut self) -> anyhow::Result<()> { + // Clone to avoid borrowing self while mutating; PHP iterates over a copy semantically. + let parameters = self.parameters.clone(); + for (key, value) in parameters { + let key = shirabe_php_shim::php_to_string(&key); + if key == "--" { + return Ok(()); + } + if shirabe_php_shim::str_starts_with(&key, "--") { + self.add_long_option(&shirabe_php_shim::substr(&key, 2, None), value)?; + } else if shirabe_php_shim::str_starts_with(&key, "-") { + self.add_short_option(&shirabe_php_shim::substr(&key, 1, None), value)?; + } else { + self.add_argument(&PhpMixed::String(key), value)?; + } + } + + Ok(()) + } + + /// Adds a short option value. + fn add_short_option(&mut self, shortcut: &str, value: PhpMixed) -> anyhow::Result<()> { + if !self.inner.definition.has_shortcut(shortcut) { + return Err(InvalidOptionException::new(format!( + "The \"-{}\" option does not exist.", + shortcut + )) + .into()); + } + + self.add_long_option( + self.inner + .definition + .get_option_for_shortcut(shortcut)? + .get_name(), + value, + ) + } + + /// Adds a long option value. + fn add_long_option(&mut self, name: &str, mut value: PhpMixed) -> anyhow::Result<()> { + if !self.inner.definition.has_option(name) { + if !self.inner.definition.has_negation(name) { + return Err(InvalidOptionException::new(format!( + "The \"--{}\" option does not exist.", + name + )) + .into()); + } + + let option_name = self.inner.definition.negation_to_name(name)?; + self.inner + .options + .insert(option_name, PhpMixed::Bool(false)); + + return Ok(()); + } + + let option = self.inner.definition.get_option(name)?; + + if matches!(value, PhpMixed::Null) { + if option.is_value_required() { + return Err(InvalidOptionException::new(format!( + "The \"--{}\" option requires a value.", + name + )) + .into()); + } + + if !option.is_value_optional() { + value = PhpMixed::Bool(true); + } + } + + self.inner.options.insert(name.to_string(), value); + + Ok(()) + } + + /// Adds an argument value. + fn add_argument(&mut self, name: &PhpMixed, value: PhpMixed) -> anyhow::Result<()> { + if !self.inner.definition.has_argument(name) { + return Err(InvalidArgumentException::new(format!( + "The \"{}\" argument does not exist.", + name.clone() + )) + .into()); + } + + self.inner + .arguments + .insert(shirabe_php_shim::php_to_string(name), value); + + Ok(()) + } +} + +/// Returns a stringified representation of the args passed to the command. +impl std::fmt::Display for ArrayInput { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + let mut params: Vec = vec![]; + for (param, val) in &self.parameters { + // $param && \is_string($param) && '-' === $param[0] + let is_option_key = + matches!(param, PhpMixed::String(s) if !s.is_empty() && s.as_bytes()[0] == b'-'); + if is_option_key { + let param = param.as_string().unwrap(); + let glue = if param.as_bytes().get(1) == Some(&b'-') { + "=" + } else { + " " + }; + if let PhpMixed::List(list) = val { + for v in list { + let v = shirabe_php_shim::php_to_string(v); + params.push(format!( + "{}{}", + param, + if !v.is_empty() { + format!("{}{}", glue, self.inner.escape_token(&v)) + } else { + String::new() + } + )); + } + } else { + let val = shirabe_php_shim::php_to_string(val); + params.push(format!( + "{}{}", + param, + if !val.is_empty() { + format!("{}{}", glue, self.inner.escape_token(&val)) + } else { + String::new() + } + )); + } + } else if let PhpMixed::List(list) = val { + let escaped: Vec = list + .iter() + .map(|v| self.inner.escape_token(&shirabe_php_shim::php_to_string(v))) + .collect(); + params.push(shirabe_php_shim::implode(" ", &escaped)); + } else { + params.push( + self.inner + .escape_token(&shirabe_php_shim::php_to_string(val)), + ); + } + } + + write!(f, "{}", shirabe_php_shim::implode(" ", ¶ms)) + } +} + +impl InputInterface for ArrayInput { + fn dup(&self) -> std::rc::Rc> { + std::rc::Rc::new(std::cell::RefCell::new(self.clone())) + } + + fn get_first_argument(&self) -> Option { + ArrayInput::get_first_argument(self).map(|v| shirabe_php_shim::php_to_string(&v)) + } + + fn has_parameter_option(&self, values: PhpMixed, only_params: bool) -> bool { + ArrayInput::has_parameter_option(self, values, only_params) + } + + fn get_parameter_option( + &self, + values: PhpMixed, + default: PhpMixed, + only_params: bool, + ) -> PhpMixed { + ArrayInput::get_parameter_option(self, values, default, only_params) + } + + fn bind(&mut self, definition: &InputDefinition) -> anyhow::Result<()> { + ArrayInput::bind(self, definition) + } + + fn validate(&mut self) -> anyhow::Result<()> { + self.inner.validate() + } + + fn get_arguments(&self) -> IndexMap { + self.inner.get_arguments() + } + + fn get_argument(&self, name: &str) -> anyhow::Result { + self.inner.get_argument(name) + } + + fn set_argument(&mut self, name: &str, value: PhpMixed) -> anyhow::Result<()> { + self.inner.set_argument(name, value) + } + + fn has_argument(&self, name: &str) -> bool { + self.inner.has_argument(name) + } + + fn get_options(&self) -> IndexMap { + self.inner.get_options() + } + + fn get_option(&self, name: &str) -> anyhow::Result { + self.inner.get_option(name) + } + + fn set_option(&mut self, name: &str, value: PhpMixed) -> anyhow::Result<()> { + self.inner.set_option(name, value) + } + + fn has_option(&self, name: &str) -> bool { + self.inner.has_option(name) + } + + fn is_interactive(&self) -> bool { + self.inner.is_interactive() + } + + fn set_interactive(&mut self, interactive: bool) { + self.inner.set_interactive(interactive) + } + + fn __to_string(&self) -> String { + self.to_string() + } + + fn as_streamable(&self) -> Option<&dyn StreamableInputInterface> { + Some(self) + } +} + +impl StreamableInputInterface for ArrayInput { + fn set_stream(&mut self, stream: shirabe_php_shim::PhpResource) { + self.inner.set_stream(stream) + } + + fn get_stream(&self) -> Option { + self.inner.get_stream() + } +} + +/// PHP `(array) $values` cast: a string becomes a single-element array. +fn to_array(values: PhpMixed) -> Vec { + match values { + PhpMixed::List(list) => list.into_iter().collect(), + PhpMixed::Array(array) => array.into_iter().map(|(_, v)| v).collect(), + PhpMixed::Null => vec![], + other => vec![other], + } +} diff --git a/crates/shirabe-symfony-console/src/input/input.rs b/crates/shirabe-symfony-console/src/input/input.rs new file mode 100644 index 00000000..15190665 --- /dev/null +++ b/crates/shirabe-symfony-console/src/input/input.rs @@ -0,0 +1,225 @@ +//! ref: composer/vendor/symfony/console/Input/Input.php + +use crate::exception::invalid_argument_exception::InvalidArgumentException; +use crate::exception::runtime_exception::RuntimeException; +use crate::input::input_definition::InputDefinition; +use indexmap::IndexMap; +use shirabe_php_shim::{PhpMixed, PhpResource, php_regex}; + +/// Input is the base class for all concrete Input classes. +/// +/// Three concrete classes are provided by default: +/// +/// * `ArgvInput`: The input comes from the CLI arguments (argv) +/// * `StringInput`: The input is provided as a string +/// * `ArrayInput`: The input is provided as an array +#[derive(Debug, Clone)] +pub struct Input { + pub(crate) definition: InputDefinition, + pub(crate) stream: Option, + pub(crate) options: IndexMap, + pub(crate) arguments: IndexMap, + pub(crate) interactive: bool, +} + +impl Input { + pub fn new(definition: Option) -> anyhow::Result { + let mut input = Input { + definition: InputDefinition::new(vec![])?, + stream: None, + options: IndexMap::new(), + arguments: IndexMap::new(), + interactive: true, + }; + + match definition { + None => { + input.definition = InputDefinition::new(vec![])?; + } + Some(definition) => { + input.bind(&definition)?; + input.validate()?; + } + } + + Ok(input) + } + + pub fn bind(&mut self, definition: &InputDefinition) -> anyhow::Result<()> { + self.arguments = IndexMap::new(); + self.options = IndexMap::new(); + self.definition = definition.clone(); + + self.parse()?; + + Ok(()) + } + + /// Processes command line arguments. + /// + /// This is abstract in PHP; concrete subclasses provide their own `parse`. + /// Since `Input` is embedded via `inner` in the subclasses, the subclass + /// drives the parsing instead. + fn parse(&mut self) -> anyhow::Result<()> { + unreachable!("Input::parse is abstract and overridden by subclasses") + } + + pub fn validate(&mut self) -> anyhow::Result<()> { + let definition = &self.definition; + let given_arguments = &self.arguments; + + let missing_arguments: Vec = shirabe_php_shim::array_filter( + &shirabe_php_shim::array_keys(definition.get_arguments()), + |argument: &String| { + !given_arguments.contains_key(argument) + && definition + .get_argument(&PhpMixed::String(argument.clone())) + .map(|a| a.is_required()) + .unwrap_or(false) + }, + ); + + if !missing_arguments.is_empty() { + return Err(RuntimeException::new(format!( + "Not enough arguments (missing: \"{}\").", + shirabe_php_shim::implode(", ", &missing_arguments), + )) + .into()); + } + + Ok(()) + } + + pub fn is_interactive(&self) -> bool { + self.interactive + } + + pub fn set_interactive(&mut self, interactive: bool) { + self.interactive = interactive; + } + + pub fn get_arguments(&self) -> IndexMap { + shirabe_php_shim::array_merge_map( + self.definition.get_argument_defaults(), + self.arguments.clone(), + ) + } + + pub fn get_argument(&self, name: &str) -> anyhow::Result { + if !self + .definition + .has_argument(&PhpMixed::String(name.to_string())) + { + return Err(InvalidArgumentException::new(format!( + "The \"{}\" argument does not exist.", + name + )) + .into()); + } + + Ok(match self.arguments.get(name) { + Some(value) => value.clone(), + None => self + .definition + .get_argument(&PhpMixed::String(name.to_string()))? + .get_default() + .clone(), + }) + } + + pub fn set_argument(&mut self, name: &str, value: PhpMixed) -> anyhow::Result<()> { + if !self + .definition + .has_argument(&PhpMixed::String(name.to_string())) + { + return Err(InvalidArgumentException::new(format!( + "The \"{}\" argument does not exist.", + name + )) + .into()); + } + + self.arguments.insert(name.to_string(), value); + + Ok(()) + } + + pub fn has_argument(&self, name: &str) -> bool { + self.definition + .has_argument(&PhpMixed::String(name.to_string())) + } + + pub fn get_options(&self) -> IndexMap { + shirabe_php_shim::array_merge_map( + self.definition.get_option_defaults(), + self.options.clone(), + ) + } + + pub fn get_option(&self, name: &str) -> anyhow::Result { + if self.definition.has_negation(name) { + let value = self.get_option(&self.definition.negation_to_name(name)?)?; + if matches!(value, PhpMixed::Null) { + return Ok(value); + } + + return Ok(PhpMixed::Bool(!value.as_bool().unwrap_or(false))); + } + + if !self.definition.has_option(name) { + return Err(InvalidArgumentException::new(format!( + "The \"{}\" option does not exist.", + name + )) + .into()); + } + + Ok(if self.options.contains_key(name) { + self.options[name].clone() + } else { + self.definition.get_option(name)?.get_default().clone() + }) + } + + pub fn set_option(&mut self, name: &str, value: PhpMixed) -> anyhow::Result<()> { + if self.definition.has_negation(name) { + let negated = self.definition.negation_to_name(name)?; + self.options + .insert(negated, PhpMixed::Bool(!value.as_bool().unwrap_or(false))); + + return Ok(()); + } else if !self.definition.has_option(name) { + return Err(InvalidArgumentException::new(format!( + "The \"{}\" option does not exist.", + name + )) + .into()); + } + + self.options.insert(name.to_string(), value); + + Ok(()) + } + + pub fn has_option(&self, name: &str) -> bool { + self.definition.has_option(name) || self.definition.has_negation(name) + } + + /// Escapes a token through escapeshellarg if it contains unsafe chars. + pub fn escape_token(&self, token: &str) -> String { + let mut matches: Vec> = vec![]; + if shirabe_php_shim::preg_match(php_regex!("{^[\\w-]+$}"), token, &mut matches) { + token.to_string() + } else { + shirabe_php_shim::escapeshellarg(token) + } + } + + pub fn set_stream(&mut self, stream: PhpResource) { + self.stream = Some(stream); + } + + pub fn get_stream(&self) -> Option { + self.stream.clone() + } +} diff --git a/crates/shirabe-symfony-console/src/input/input_argument.rs b/crates/shirabe-symfony-console/src/input/input_argument.rs new file mode 100644 index 00000000..ebc8e223 --- /dev/null +++ b/crates/shirabe-symfony-console/src/input/input_argument.rs @@ -0,0 +1,96 @@ +//! ref: composer/vendor/symfony/console/Input/InputArgument.php + +use crate::exception::invalid_argument_exception::InvalidArgumentException; +use crate::exception::logic_exception::LogicException; +use shirabe_php_shim::PhpMixed; + +#[derive(Debug, Clone)] +pub struct InputArgument { + name: String, + mode: i64, + default: PhpMixed, + description: String, +} + +impl InputArgument { + pub const REQUIRED: i64 = 1; + pub const OPTIONAL: i64 = 2; + pub const IS_ARRAY: i64 = 4; + + pub fn new( + name: String, + mode: Option, + description: String, + default: PhpMixed, + ) -> anyhow::Result { + let mode = match mode { + None => Self::OPTIONAL, + Some(m) if !(1..=7).contains(&m) => { + return Err(InvalidArgumentException::new(format!( + "Argument mode \"{}\" is not valid.", + m + )) + .into()); + } + Some(m) => m, + }; + + let mut argument = InputArgument { + name, + mode, + description, + default: PhpMixed::Null, + }; + + argument.set_default(default)?; + + Ok(argument) + } + + pub fn get_name(&self) -> &str { + &self.name + } + + pub fn is_required(&self) -> bool { + Self::REQUIRED == (Self::REQUIRED & self.mode) + } + + pub fn is_array(&self) -> bool { + Self::IS_ARRAY == (Self::IS_ARRAY & self.mode) + } + + pub fn set_default(&mut self, default: PhpMixed) -> anyhow::Result<()> { + if self.is_required() && !matches!(default, PhpMixed::Null) { + return Err(LogicException::new( + "Cannot set a default value except for InputArgument::OPTIONAL mode.".to_string(), + ) + .into()); + } + + let default = if self.is_array() { + match default { + PhpMixed::Null => PhpMixed::List(vec![]), + PhpMixed::List(_) => default, + _ => { + return Err(LogicException::new( + "A default value for an array argument must be an array.".to_string(), + ) + .into()); + } + } + } else { + default + }; + + self.default = default; + Ok(()) + } + + pub fn get_default(&self) -> &PhpMixed { + &self.default + } + + pub fn get_description(&self) -> &str { + &self.description + } +} diff --git a/crates/shirabe-symfony-console/src/input/input_aware_interface.rs b/crates/shirabe-symfony-console/src/input/input_aware_interface.rs new file mode 100644 index 00000000..1638b6c7 --- /dev/null +++ b/crates/shirabe-symfony-console/src/input/input_aware_interface.rs @@ -0,0 +1,7 @@ +//! ref: composer/vendor/symfony/console/Input/InputAwareInterface.php + +use crate::input::input_interface::InputInterface; + +pub trait InputAwareInterface { + fn set_input(&mut self, input: Box); +} diff --git a/crates/shirabe-symfony-console/src/input/input_definition.rs b/crates/shirabe-symfony-console/src/input/input_definition.rs new file mode 100644 index 00000000..96f9ce9a --- /dev/null +++ b/crates/shirabe-symfony-console/src/input/input_definition.rs @@ -0,0 +1,450 @@ +//! ref: composer/vendor/symfony/console/Input/InputDefinition.php + +use crate::exception::invalid_argument_exception::InvalidArgumentException; +use crate::exception::logic_exception::LogicException; +use crate::input::input_argument::InputArgument; +use crate::input::input_option::InputOption; +use indexmap::IndexMap; +use shirabe_php_shim::PhpMixed; + +/// A InputDefinition represents a set of valid command line arguments and options. +/// +/// `InputArgument` and `InputOption` are stored behind `Rc` to model PHP's +/// shared object references; this also lets the definition be cloned cheaply +/// (PHP `bind` assigns the definition by reference). +#[derive(Debug, Clone)] +pub struct InputDefinition { + arguments: IndexMap>, + required_count: i64, + last_array_argument: Option>, + last_optional_argument: Option>, + options: IndexMap>, + negations: IndexMap, + shortcuts: IndexMap, +} + +/// A definition entry is either an InputArgument or an InputOption. +#[derive(Debug)] +pub enum DefinitionItem { + InputArgument(InputArgument), + InputOption(InputOption), +} + +impl InputDefinition { + pub fn new(definition: Vec) -> anyhow::Result { + let mut input_definition = InputDefinition { + arguments: IndexMap::new(), + required_count: 0, + last_array_argument: None, + last_optional_argument: None, + options: IndexMap::new(), + negations: IndexMap::new(), + shortcuts: IndexMap::new(), + }; + input_definition.set_definition(definition)?; + Ok(input_definition) + } + + /// Builds an option-only definition that shares the given options by + /// reference, mirroring `new InputDefinition($definition->getOptions())`. + /// `InputOption` is not `Clone` and lives behind `Rc`, so the options are + /// reused rather than reconstructed by value. + pub fn from_options(options: Vec>) -> anyhow::Result { + let mut input_definition = InputDefinition { + arguments: IndexMap::new(), + required_count: 0, + last_array_argument: None, + last_optional_argument: None, + options: IndexMap::new(), + negations: IndexMap::new(), + shortcuts: IndexMap::new(), + }; + for option in options { + input_definition.add_option_rc(option)?; + } + Ok(input_definition) + } + + /// Sets the definition of the input. + pub fn set_definition(&mut self, definition: Vec) -> anyhow::Result<()> { + let mut arguments = vec![]; + let mut options = vec![]; + for item in definition { + match item { + DefinitionItem::InputOption(option) => { + options.push(option); + } + DefinitionItem::InputArgument(argument) => { + arguments.push(argument); + } + } + } + + self.set_arguments(arguments)?; + self.set_options(options)?; + + Ok(()) + } + + /// Sets the InputArgument objects. + pub fn set_arguments(&mut self, arguments: Vec) -> anyhow::Result<()> { + self.arguments = IndexMap::new(); + self.required_count = 0; + self.last_optional_argument = None; + self.last_array_argument = None; + self.add_arguments(Some(arguments))?; + Ok(()) + } + + /// Adds an array of InputArgument objects. + pub fn add_arguments(&mut self, arguments: Option>) -> anyhow::Result<()> { + if let Some(arguments) = arguments { + for argument in arguments { + self.add_argument(argument)?; + } + } + Ok(()) + } + + pub fn add_argument(&mut self, argument: InputArgument) -> anyhow::Result<()> { + let argument = std::rc::Rc::new(argument); + + if self.arguments.contains_key(argument.get_name()) { + return Err(LogicException::new(format!( + "An argument with name \"{}\" already exists.", + argument.get_name(), + )) + .into()); + } + + if let Some(last_array_argument) = &self.last_array_argument { + return Err(LogicException::new(format!( + "Cannot add a required argument \"{}\" after an array argument \"{}\".", + argument.get_name(), + last_array_argument.get_name(), + )) + .into()); + } + + if argument.is_required() + && let Some(last_optional_argument) = &self.last_optional_argument + { + return Err(LogicException::new(format!( + "Cannot add a required argument \"{}\" after an optional one \"{}\".", + argument.get_name(), + last_optional_argument.get_name(), + )) + .into()); + } + + if argument.is_array() { + self.last_array_argument = Some(std::rc::Rc::clone(&argument)); + } + + if argument.is_required() { + self.required_count += 1; + } else { + self.last_optional_argument = Some(std::rc::Rc::clone(&argument)); + } + + self.arguments + .insert(argument.get_name().to_string(), argument); + + Ok(()) + } + + /// Returns an InputArgument by name or by position. + pub fn get_argument(&self, name: &PhpMixed) -> anyhow::Result> { + if !self.has_argument(name) { + return Err(InvalidArgumentException::new(format!( + "The \"{}\" argument does not exist.", + name.clone() + )) + .into()); + } + + match name { + PhpMixed::Int(index) => { + let arguments: Vec> = + self.arguments.values().cloned().collect(); + Ok(std::rc::Rc::clone(&arguments[*index as usize])) + } + _ => { + let key = shirabe_php_shim::php_to_string(name); + Ok(std::rc::Rc::clone(&self.arguments[&key])) + } + } + } + + /// Returns true if an InputArgument object exists by name or position. + pub fn has_argument(&self, name: &PhpMixed) -> bool { + match name { + PhpMixed::Int(index) => { + let arguments: Vec> = + self.arguments.values().cloned().collect(); + *index >= 0 && (*index as usize) < arguments.len() + } + _ => { + let key = shirabe_php_shim::php_to_string(name); + self.arguments.contains_key(&key) + } + } + } + + /// Gets the array of InputArgument objects. + pub fn get_arguments(&self) -> &IndexMap> { + &self.arguments + } + + /// Returns the number of InputArguments. + pub fn get_argument_count(&self) -> i64 { + if self.last_array_argument.is_some() { + i64::MAX + } else { + self.arguments.len() as i64 + } + } + + /// Returns the number of required InputArguments. + pub fn get_argument_required_count(&self) -> i64 { + self.required_count + } + + pub fn get_argument_defaults(&self) -> IndexMap { + let mut values = IndexMap::new(); + for argument in self.arguments.values() { + values.insert( + argument.get_name().to_string(), + argument.get_default().clone(), + ); + } + + values + } + + /// Sets the InputOption objects. + pub fn set_options(&mut self, options: Vec) -> anyhow::Result<()> { + self.options = IndexMap::new(); + self.shortcuts = IndexMap::new(); + self.negations = IndexMap::new(); + self.add_options(options)?; + Ok(()) + } + + /// Adds an array of InputOption objects. + pub fn add_options(&mut self, options: Vec) -> anyhow::Result<()> { + for option in options { + self.add_option(option)?; + } + Ok(()) + } + + pub fn add_option(&mut self, option: InputOption) -> anyhow::Result<()> { + self.add_option_rc(std::rc::Rc::new(option)) + } + + /// Adds an option that is already shared behind `Rc`, mirroring PHP passing + /// `InputOption` objects by reference. + pub fn add_option_rc(&mut self, option: std::rc::Rc) -> anyhow::Result<()> { + if let Some(existing) = self.options.get(option.get_name()) + && !option.equals(existing) + { + return Err(LogicException::new(format!( + "An option named \"{}\" already exists.", + option.get_name() + )) + .into()); + } + if self.negations.contains_key(option.get_name()) { + return Err(LogicException::new(format!( + "An option named \"{}\" already exists.", + option.get_name() + )) + .into()); + } + + if let Some(shortcut) = option.get_shortcut() { + for shortcut in shirabe_php_shim::explode("|", shortcut) { + if let Some(existing_name) = self.shortcuts.get(&shortcut) + && !option.equals(&self.options[existing_name]) + { + return Err(LogicException::new(format!( + "An option with shortcut \"{}\" already exists.", + shortcut.clone(), + )) + .into()); + } + } + } + + self.options + .insert(option.get_name().to_string(), std::rc::Rc::clone(&option)); + if let Some(shortcut) = option.get_shortcut() { + for shortcut in shirabe_php_shim::explode("|", shortcut) { + self.shortcuts + .insert(shortcut, option.get_name().to_string()); + } + } + + if option.is_negatable() { + let negated_name = format!("no-{}", option.get_name()); + if self.options.contains_key(&negated_name) { + return Err(LogicException::new(format!( + "An option named \"{}\" already exists.", + negated_name + )) + .into()); + } + self.negations + .insert(negated_name, option.get_name().to_string()); + } + + Ok(()) + } + + /// Returns an InputOption by name. + pub fn get_option(&self, name: &str) -> anyhow::Result> { + if !self.has_option(name) { + return Err(InvalidArgumentException::new(format!( + "The \"--{}\" option does not exist.", + name + )) + .into()); + } + + Ok(std::rc::Rc::clone(&self.options[name])) + } + + /// Returns true if an InputOption object exists by name. + /// + /// This method can't be used to check if the user included the option when + /// executing the command (use getOption() instead). + pub fn has_option(&self, name: &str) -> bool { + self.options.contains_key(name) + } + + /// Gets the array of InputOption objects. + pub fn get_options(&self) -> &IndexMap> { + &self.options + } + + /// Returns true if an InputOption object exists by shortcut. + pub fn has_shortcut(&self, name: &str) -> bool { + self.shortcuts.contains_key(name) + } + + /// Returns true if an InputOption object exists by negated name. + pub fn has_negation(&self, name: &str) -> bool { + self.negations.contains_key(name) + } + + /// Gets an InputOption by shortcut. + pub fn get_option_for_shortcut( + &self, + shortcut: &str, + ) -> anyhow::Result> { + self.get_option(&self.shortcut_to_name(shortcut)?) + } + + pub fn get_option_defaults(&self) -> IndexMap { + let mut values = IndexMap::new(); + for option in self.options.values() { + values.insert(option.get_name().to_string(), option.get_default().clone()); + } + + values + } + + /// Returns the InputOption name given a shortcut. + pub fn shortcut_to_name(&self, shortcut: &str) -> anyhow::Result { + match self.shortcuts.get(shortcut) { + None => Err(InvalidArgumentException::new(format!( + "The \"-{}\" option does not exist.", + shortcut + )) + .into()), + Some(name) => Ok(name.clone()), + } + } + + /// Returns the InputOption name given a negation. + pub fn negation_to_name(&self, negation: &str) -> anyhow::Result { + match self.negations.get(negation) { + None => Err(InvalidArgumentException::new(format!( + "The \"--{}\" option does not exist.", + negation + )) + .into()), + Some(name) => Ok(name.clone()), + } + } + + /// Gets the synopsis. + pub fn get_synopsis(&self, short: bool) -> String { + let mut elements: Vec = vec![]; + + if short && !self.get_options().is_empty() { + elements.push("[options]".to_string()); + } else if !short { + for option in self.get_options().values() { + let mut value = String::new(); + if option.accept_value() { + value = format!( + " {}{}{}", + if option.is_value_optional() { + "[".to_string() + } else { + String::new() + }, + shirabe_php_shim::strtoupper(option.get_name()), + if option.is_value_optional() { + "]".to_string() + } else { + String::new() + }, + ); + } + + let shortcut = match option.get_shortcut() { + Some(shortcut) => { + format!("-{}|", shortcut) + } + None => String::new(), + }; + let negation = if option.is_negatable() { + format!("|--no-{}", option.get_name()) + } else { + String::new() + }; + elements.push(format!( + "[{}--{}{}{}]", + shortcut, + option.get_name(), + value, + negation, + )); + } + } + + if !elements.is_empty() && !self.get_arguments().is_empty() { + elements.push("[--]".to_string()); + } + + let mut tail = String::new(); + for argument in self.get_arguments().values() { + let mut element = format!("<{}>", argument.get_name()); + if argument.is_array() { + element.push_str("..."); + } + + if !argument.is_required() { + element = format!("[{}", element); + tail.push(']'); + } + + elements.push(element); + } + + format!("{}{}", shirabe_php_shim::implode(" ", &elements), tail) + } +} diff --git a/crates/shirabe-symfony-console/src/input/input_interface.rs b/crates/shirabe-symfony-console/src/input/input_interface.rs new file mode 100644 index 00000000..b3cd2eef --- /dev/null +++ b/crates/shirabe-symfony-console/src/input/input_interface.rs @@ -0,0 +1,60 @@ +//! ref: composer/vendor/symfony/console/Input/InputInterface.php + +use crate::input::input_definition::InputDefinition; +use crate::input::streamable_input_interface::StreamableInputInterface; +use shirabe_php_shim::PhpMixed; + +pub trait InputInterface: std::fmt::Debug + shirabe_php_shim::AsAny { + /// Models PHP's `clone` operatior. + fn dup(&self) -> std::rc::Rc>; + + fn get_first_argument(&self) -> Option; + + fn has_parameter_option(&self, values: PhpMixed, only_params: bool) -> bool; + + fn get_parameter_option( + &self, + values: PhpMixed, + default: PhpMixed, + only_params: bool, + ) -> PhpMixed; + + fn bind(&mut self, definition: &InputDefinition) -> anyhow::Result<()>; + + fn validate(&mut self) -> anyhow::Result<()>; + + fn get_arguments(&self) -> indexmap::IndexMap; + + fn get_argument(&self, name: &str) -> anyhow::Result; + + fn set_argument(&mut self, name: &str, value: PhpMixed) -> anyhow::Result<()>; + + fn has_argument(&self, name: &str) -> bool; + + fn get_options(&self) -> indexmap::IndexMap; + + fn get_option(&self, name: &str) -> anyhow::Result; + + fn set_option(&mut self, name: &str, value: PhpMixed) -> anyhow::Result<()>; + + fn has_option(&self, name: &str) -> bool; + + fn is_interactive(&self) -> bool; + + fn set_interactive(&mut self, interactive: bool); + + /// PHP's `(string) $input` (the `__toString` magic method every Symfony input implements); + /// implementors forward to their `Display` impl. + fn __to_string(&self) -> String; + + /// Models PHP's `$input instanceof StreamableInputInterface` check. Streamable inputs override + /// this to return `Some(self)`; everything else falls back to `None`. + fn as_streamable(&self) -> Option<&dyn StreamableInputInterface> { + None + } + + /// Mutable counterpart of `as_streamable`, needed to call `set_stream`/`set_interactive`. + fn as_streamable_mut(&mut self) -> Option<&mut dyn StreamableInputInterface> { + None + } +} diff --git a/crates/shirabe-symfony-console/src/input/input_option.rs b/crates/shirabe-symfony-console/src/input/input_option.rs new file mode 100644 index 00000000..7312e552 --- /dev/null +++ b/crates/shirabe-symfony-console/src/input/input_option.rs @@ -0,0 +1,193 @@ +//! ref: composer/vendor/symfony/console/Input/InputOption.php + +use crate::exception::invalid_argument_exception::InvalidArgumentException; +use crate::exception::logic_exception::LogicException; +use shirabe_php_shim::{PhpMixed, php_regex}; + +#[derive(Debug, Clone)] +pub struct InputOption { + name: String, + shortcut: Option, + mode: i64, + default: PhpMixed, + description: String, +} + +impl InputOption { + pub const VALUE_NONE: i64 = 1; + pub const VALUE_REQUIRED: i64 = 2; + pub const VALUE_OPTIONAL: i64 = 4; + pub const VALUE_IS_ARRAY: i64 = 8; + pub const VALUE_NEGATABLE: i64 = 16; + + pub fn new( + name: &str, + shortcut: PhpMixed, + mode: Option, + description: String, + default: PhpMixed, + ) -> anyhow::Result { + let name = if let Some(stripped) = name.strip_prefix("--") { + stripped.to_string() + } else { + name.to_string() + }; + + if name.is_empty() { + return Err(InvalidArgumentException::new( + "An option name cannot be empty.".to_string(), + ) + .into()); + } + + let shortcut = match shortcut { + PhpMixed::String(ref s) if s.is_empty() => None, + PhpMixed::List(ref v) if v.is_empty() => None, + PhpMixed::Bool(false) => None, + PhpMixed::Null => None, + PhpMixed::List(ref arr) => { + let parts: Vec = arr + .iter() + .filter_map(|v| { + if let PhpMixed::String(s) = v { + Some(s.clone()) + } else { + None + } + }) + .collect(); + let joined = shirabe_php_shim::implode("|", &parts); + Self::normalize_shortcut(joined)? + } + PhpMixed::String(s) => Self::normalize_shortcut(s)?, + _ => None, + }; + + let mode = match mode { + None => Self::VALUE_NONE, + Some(m) if !(1..(Self::VALUE_NEGATABLE << 1)).contains(&m) => { + return Err(InvalidArgumentException::new(format!( + "Option mode \"{}\" is not valid.", + m + )) + .into()); + } + Some(m) => m, + }; + + let mut option = InputOption { + name, + shortcut, + mode, + description, + default: PhpMixed::Null, + }; + + if option.is_array() && !option.accept_value() { + return Err(InvalidArgumentException::new("Impossible to have an option mode VALUE_IS_ARRAY if the option does not accept a value.".to_string()) + .into()); + } + if option.is_negatable() && option.accept_value() { + return Err(InvalidArgumentException::new("Impossible to have an option mode VALUE_NEGATABLE if the option also accepts a value.".to_string()) + .into()); + } + + option.set_default(default)?; + + Ok(option) + } + + fn normalize_shortcut(s: String) -> anyhow::Result> { + let stripped = shirabe_php_shim::ltrim(&s, Some("-")); + let parts = shirabe_php_shim::preg_split(php_regex!(r"{(\|)-?}"), &stripped); + let filtered: Vec = + shirabe_php_shim::array_filter(&parts, |s: &String| !s.is_empty()); + let result = shirabe_php_shim::implode("|", &filtered); + if result.is_empty() { + return Err(InvalidArgumentException::new( + "An option shortcut cannot be empty.".to_string(), + ) + .into()); + } + Ok(Some(result)) + } + + pub fn get_shortcut(&self) -> Option<&str> { + self.shortcut.as_deref() + } + + pub fn get_name(&self) -> &str { + &self.name + } + + pub fn accept_value(&self) -> bool { + self.is_value_required() || self.is_value_optional() + } + + pub fn is_value_required(&self) -> bool { + Self::VALUE_REQUIRED == (Self::VALUE_REQUIRED & self.mode) + } + + pub fn is_value_optional(&self) -> bool { + Self::VALUE_OPTIONAL == (Self::VALUE_OPTIONAL & self.mode) + } + + pub fn is_array(&self) -> bool { + Self::VALUE_IS_ARRAY == (Self::VALUE_IS_ARRAY & self.mode) + } + + pub fn is_negatable(&self) -> bool { + Self::VALUE_NEGATABLE == (Self::VALUE_NEGATABLE & self.mode) + } + + pub fn set_default(&mut self, default: PhpMixed) -> anyhow::Result<()> { + if Self::VALUE_NONE == (Self::VALUE_NONE & self.mode) && !matches!(default, PhpMixed::Null) + { + return Err(LogicException::new( + "Cannot set a default value when using InputOption::VALUE_NONE mode.".to_string(), + ) + .into()); + } + + let default = if self.is_array() { + match default { + PhpMixed::Null => PhpMixed::List(vec![]), + // PHP `is_array()` accepts both list-style and associative arrays. + PhpMixed::List(_) | PhpMixed::Array(_) => default, + _ => { + return Err(LogicException::new( + "A default value for an array option must be an array.".to_string(), + ) + .into()); + } + } + } else { + default + }; + + self.default = if self.accept_value() || self.is_negatable() { + default + } else { + PhpMixed::Bool(false) + }; + Ok(()) + } + + pub fn get_default(&self) -> &PhpMixed { + &self.default + } + + pub fn get_description(&self) -> &str { + &self.description + } + + pub fn equals(&self, option: &InputOption) -> bool { + option.get_name() == self.get_name() + && option.get_shortcut() == self.get_shortcut() + && option.get_default() == self.get_default() + && option.is_negatable() == self.is_negatable() + && option.is_array() == self.is_array() + && option.is_value_required() == self.is_value_required() + && option.is_value_optional() == self.is_value_optional() + } +} diff --git a/crates/shirabe-symfony-console/src/input/streamable_input_interface.rs b/crates/shirabe-symfony-console/src/input/streamable_input_interface.rs new file mode 100644 index 00000000..559b34a0 --- /dev/null +++ b/crates/shirabe-symfony-console/src/input/streamable_input_interface.rs @@ -0,0 +1,10 @@ +//! ref: composer/vendor/symfony/console/Input/StreamableInputInterface.php + +use crate::input::input_interface::InputInterface; +use shirabe_php_shim::PhpResource; + +pub trait StreamableInputInterface: InputInterface { + fn set_stream(&mut self, stream: PhpResource); + + fn get_stream(&self) -> Option; +} diff --git a/crates/shirabe-symfony-console/src/input/string_input.rs b/crates/shirabe-symfony-console/src/input/string_input.rs new file mode 100644 index 00000000..720e2bef --- /dev/null +++ b/crates/shirabe-symfony-console/src/input/string_input.rs @@ -0,0 +1,243 @@ +//! ref: composer/vendor/symfony/console/Input/StringInput.php + +use crate::exception::invalid_argument_exception::InvalidArgumentException; +use crate::input::argv_input::ArgvInput; +use crate::input::input_definition::InputDefinition; +use crate::input::input_interface::InputInterface; +use crate::input::streamable_input_interface::StreamableInputInterface; +use indexmap::IndexMap; +use shirabe_php_shim::{CaptureKey, PhpMixed, php_regex}; + +/// StringInput represents an input provided as a string. +/// +/// Usage: +/// +/// ```php +/// $input = new StringInput('foo --bar="foobar"'); +/// ``` +#[derive(Debug, Clone)] +pub struct StringInput { + pub(crate) inner: ArgvInput, +} + +impl StringInput { + pub const REGEX_STRING: &'static str = r#"([^\s]+?)(?:\s|(? anyhow::Result { + // parent::__construct([]) + let inner = ArgvInput::new(Some(vec![]), None)?; + + let mut string_input = StringInput { inner }; + + let tokens = string_input.tokenize(input)?; + string_input.inner.set_tokens(tokens); + + Ok(string_input) + } + + /// Tokenizes a string. + fn tokenize(&self, input: &str) -> anyhow::Result> { + let bytes = input.as_bytes(); + let mut tokens: Vec = vec![]; + let length = shirabe_php_shim::strlen(input); + let mut cursor: i64 = 0; + let mut token: Option = None; + while cursor < length { + if bytes[cursor as usize] == b'\\' { + cursor += 1; + let next: String = match bytes.get(cursor as usize) { + Some(b) => String::from_utf8_lossy(&[*b]).into_owned(), + None => String::new(), + }; + token = Some(format!("{}{}", token.unwrap_or_default(), next)); + cursor += 1; + continue; + } + + let mut m: IndexMap> = IndexMap::new(); + if shirabe_php_shim::preg_match2( + php_regex!(r"/\s+/A"), + input, + &mut m, + 0, + cursor as usize, + ) { + if token.is_some() { + tokens.push(token.take().unwrap()); + } + cursor += + shirabe_php_shim::strlen(m[&CaptureKey::ByIndex(0)].as_deref().unwrap_or("")); + } else if shirabe_php_shim::preg_match2( + format!(r#"/([^="'\s]+?)(=?)({}+)/A"#, Self::REGEX_QUOTED_STRING), + input, + &mut m, + 0, + cursor as usize, + ) { + let inner = shirabe_php_shim::substr( + m[&CaptureKey::ByIndex(3)].as_deref().unwrap_or(""), + 1, + Some(-1), + ); + let replaced = + shirabe_php_shim::str_replace_arr(&["\"'", "'\"", "''", "\"\""], "", &inner); + token = Some(format!( + "{}{}{}{}", + token.unwrap_or_default(), + m[&CaptureKey::ByIndex(1)].as_deref().unwrap_or(""), + m[&CaptureKey::ByIndex(2)].as_deref().unwrap_or(""), + shirabe_php_shim::stripcslashes(&replaced) + )); + cursor += + shirabe_php_shim::strlen(m[&CaptureKey::ByIndex(0)].as_deref().unwrap_or("")); + } else if shirabe_php_shim::preg_match2( + format!(r"/{}/A", Self::REGEX_QUOTED_STRING), + input, + &mut m, + 0, + cursor as usize, + ) { + token = Some(format!( + "{}{}", + token.unwrap_or_default(), + shirabe_php_shim::stripcslashes(&shirabe_php_shim::substr( + m[&CaptureKey::ByIndex(0)].as_deref().unwrap_or(""), + 1, + Some(-1) + )) + )); + cursor += + shirabe_php_shim::strlen(m[&CaptureKey::ByIndex(0)].as_deref().unwrap_or("")); + } else if shirabe_php_shim::preg_match2( + format!(r"/{}/A", Self::REGEX_UNQUOTED_STRING), + input, + &mut m, + 0, + cursor as usize, + ) { + token = Some(format!( + "{}{}", + token.unwrap_or_default(), + m[&CaptureKey::ByIndex(1)].as_deref().unwrap_or("") + )); + cursor += + shirabe_php_shim::strlen(m[&CaptureKey::ByIndex(0)].as_deref().unwrap_or("")); + } else { + // should never happen + return Err(InvalidArgumentException::new(format!( + "Unable to parse input near \"... {} ...\".", + shirabe_php_shim::substr(input, cursor, Some(10)), + )) + .into()); + } + } + + if let Some(token) = token { + tokens.push(token); + } + + Ok(tokens) + } +} + +impl std::fmt::Display for StringInput { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + self.inner.fmt(f) + } +} + +impl InputInterface for StringInput { + fn dup(&self) -> std::rc::Rc> { + std::rc::Rc::new(std::cell::RefCell::new(self.clone())) + } + + fn get_first_argument(&self) -> Option { + self.inner.get_first_argument() + } + + fn has_parameter_option(&self, values: PhpMixed, only_params: bool) -> bool { + InputInterface::has_parameter_option(&self.inner, values, only_params) + } + + fn get_parameter_option( + &self, + values: PhpMixed, + default: PhpMixed, + only_params: bool, + ) -> PhpMixed { + InputInterface::get_parameter_option(&self.inner, values, default, only_params) + } + + fn bind(&mut self, definition: &InputDefinition) -> anyhow::Result<()> { + InputInterface::bind(&mut self.inner, definition) + } + + fn validate(&mut self) -> anyhow::Result<()> { + self.inner.validate() + } + + fn get_arguments(&self) -> IndexMap { + InputInterface::get_arguments(&self.inner) + } + + fn get_argument(&self, name: &str) -> anyhow::Result { + self.inner.get_argument(name) + } + + fn set_argument(&mut self, name: &str, value: PhpMixed) -> anyhow::Result<()> { + self.inner.set_argument(name, value) + } + + fn has_argument(&self, name: &str) -> bool { + self.inner.has_argument(name) + } + + fn get_options(&self) -> IndexMap { + InputInterface::get_options(&self.inner) + } + + fn get_option(&self, name: &str) -> anyhow::Result { + self.inner.get_option(name) + } + + fn set_option(&mut self, name: &str, value: PhpMixed) -> anyhow::Result<()> { + self.inner.set_option(name, value) + } + + fn has_option(&self, name: &str) -> bool { + self.inner.has_option(name) + } + + fn is_interactive(&self) -> bool { + self.inner.is_interactive() + } + + fn set_interactive(&mut self, interactive: bool) { + self.inner.set_interactive(interactive) + } + + fn __to_string(&self) -> String { + self.to_string() + } + + fn as_streamable(&self) -> Option<&dyn StreamableInputInterface> { + Some(self) + } + + fn as_streamable_mut(&mut self) -> Option<&mut dyn StreamableInputInterface> { + Some(self) + } +} + +impl StreamableInputInterface for StringInput { + fn set_stream(&mut self, stream: shirabe_php_shim::PhpResource) { + self.inner.set_stream(stream) + } + + fn get_stream(&self) -> Option { + self.inner.get_stream() + } +} -- cgit v1.3.1-4-g156e