feat(symfony-console): port Symfony Console and make the workspace compile

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

4 files changed, 530 insertions, 33 deletions

diff --git a/crates/shirabe-external-packages/src/symfony/console/question/choice_question.rs b/crates/shirabe-external-packages/src/symfony/console/question/choice_question.rs
index 5eb5818..7ad29c8 100644
--- a/crates/shirabe-external-packages/src/symfony/console/question/choice_question.rs
+++ b/crates/shirabe-external-packages/src/symfony/console/question/choice_question.rs
@@ -1,19 +1,235 @@
+use crate::symfony::console::exception::invalid_argument_exception::InvalidArgumentException;
+use crate::symfony::console::exception::logic_exception::LogicException;
 use crate::symfony::console::question::Question;
+use indexmap::IndexMap;
 use shirabe_php_shim::PhpMixed;
 
+/// Represents a choice question.
 #[derive(Debug)]
-pub struct ChoiceQuestion(pub Question);
+pub struct ChoiceQuestion {
+    inner: Question,
+    choices: IndexMap<String, Box<PhpMixed>>,
+    multiselect: bool,
+    prompt: String,
+    error_message: String,
+}
 
 impl ChoiceQuestion {
-    pub fn new(_question: &str, _choices: Vec<PhpMixed>, _default: Option<PhpMixed>) -> Self {
-        todo!()
+    /// `$question` The question to ask to the user.
+    /// `$choices` The list of available choices.
+    /// `$default` The default answer to return.
+    pub fn new(
+        question: String,
+        choices: IndexMap<String, Box<PhpMixed>>,
+        default: Option<PhpMixed>,
+    ) -> Result<Self, LogicException> {
+        if choices.is_empty() {
+            return Err(LogicException(shirabe_php_shim::LogicException {
+                message: "Choice question must have at least 1 choice available.".to_string(),
+                code: 0,
+            }));
+        }
+
+        let mut this = Self {
+            inner: Question::new(question, default),
+            choices: choices.clone(),
+            multiselect: false,
+            prompt: " > ".to_string(),
+            error_message: "Value \"%s\" is invalid".to_string(),
+        };
+
+        let validator = this.get_default_validator();
+        this.inner.set_validator(Some(validator));
+        // setAutocompleterValues never throws for an array argument.
+        this.inner
+            .set_autocompleter_values(Some(PhpMixed::Array(choices)))
+            .expect("autocompleter cannot be set on a hidden question during construction");
+
+        Ok(this)
+    }
+
+    /// Returns available choices.
+    pub fn get_choices(&self) -> &IndexMap<String, Box<PhpMixed>> {
+        &self.choices
+    }
+
+    /// Sets multiselect option.
+    ///
+    /// When multiselect is set to true, multiple choices can be answered.
+    pub fn set_multiselect(&mut self, multiselect: bool) -> &mut Self {
+        self.multiselect = multiselect;
+        let validator = self.get_default_validator();
+        self.inner.set_validator(Some(validator));
+
+        self
+    }
+
+    /// Returns whether the choices are multiselect.
+    pub fn is_multiselect(&self) -> bool {
+        self.multiselect
+    }
+
+    /// Gets the prompt for choices.
+    pub fn get_prompt(&self) -> &str {
+        &self.prompt
     }
 
-    pub fn set_multiselect(&mut self, _multiselect: bool) {
-        todo!()
+    /// Sets the prompt for choices.
+    pub fn set_prompt(&mut self, prompt: String) -> &mut Self {
+        self.prompt = prompt;
+
+        self
     }
 
-    pub fn set_error_message(&mut self, _error_message: &str) {
-        todo!()
+    /// Sets the error message for invalid values.
+    ///
+    /// The error message has a string placeholder (%s) for the invalid value.
+    pub fn set_error_message(&mut self, error_message: String) -> &mut Self {
+        self.error_message = error_message;
+        let validator = self.get_default_validator();
+        self.inner.set_validator(Some(validator));
+
+        self
     }
+
+    fn get_default_validator(
+        &self,
+    ) -> Box<dyn Fn(Option<PhpMixed>) -> Result<PhpMixed, InvalidArgumentException>> {
+        let choices = self.choices.clone();
+        let error_message = self.error_message.clone();
+        let multiselect = self.multiselect;
+        let is_assoc = Question::is_assoc(&PhpMixed::Array(self.choices.clone()));
+        // PHP reads `$this->isTrimmable()` live inside the closure. A 'static boxed
+        // closure cannot borrow `$this`, so the value is snapshotted at validator
+        // creation time. setValidator is re-run on multiselect/errorMessage changes,
+        // but a later setTrimmable would not be reflected. See review notes.
+        let trimmable = self.inner.is_trimmable();
+
+        Box::new(move |selected: Option<PhpMixed>| {
+            let selected = selected.unwrap_or(PhpMixed::Null);
+
+            let selected_choices: Vec<PhpMixed> = if multiselect {
+                // Check for a separated comma values
+                let mut matches: Vec<Option<String>> = Vec::new();
+                if shirabe_php_shim::preg_match(
+                    "/^[^,]+(?:,[^,]+)*$/",
+                    &shirabe_php_shim::strval(&selected),
+                    &mut matches,
+                ) == 0
+                {
+                    return Err(InvalidArgumentException(
+                        shirabe_php_shim::InvalidArgumentException {
+                            message: shirabe_php_shim::sprintf(&error_message, &[selected.clone()]),
+                            code: 0,
+                        },
+                    ));
+                }
+
+                shirabe_php_shim::explode(",", &shirabe_php_shim::strval(&selected))
+                    .into_iter()
+                    .map(PhpMixed::String)
+                    .collect()
+            } else {
+                vec![selected.clone()]
+            };
+
+            let mut selected_choices = selected_choices;
+            if trimmable {
+                for v in selected_choices.iter_mut() {
+                    *v = PhpMixed::String(shirabe_php_shim::trim(
+                        &shirabe_php_shim::strval(v),
+                        None,
+                    ));
+                }
+            }
+
+            let mut multiselect_choices: Vec<PhpMixed> = Vec::new();
+            for value in &selected_choices {
+                let mut results: Vec<String> = Vec::new();
+                for (key, choice) in &choices {
+                    if (**choice) == *value {
+                        results.push(key.clone());
+                    }
+                }
+
+                if results.len() > 1 {
+                    return Err(InvalidArgumentException(
+                        shirabe_php_shim::InvalidArgumentException {
+                            message: shirabe_php_shim::sprintf(
+                                "The provided answer is ambiguous. Value should be one of \"%s\".",
+                                &[PhpMixed::String(shirabe_php_shim::implode(
+                                    "\" or \"", &results,
+                                ))],
+                            ),
+                            code: 0,
+                        },
+                    ));
+                }
+
+                // array_search($value, $choices)
+                let result_key = shirabe_php_shim::array_search(
+                    &shirabe_php_shim::strval(value),
+                    &choices_as_str(&choices),
+                );
+
+                let mut result: PhpMixed;
+                if !is_assoc {
+                    if let Some(found_key) = &result_key {
+                        // $result = $choices[$result];
+                        result = (*choices[found_key]).clone();
+                    } else if let Some(found) = choices.get(&shirabe_php_shim::strval(value)) {
+                        // isset($choices[$value])
+                        result = (**found).clone();
+                    } else {
+                        result = PhpMixed::Bool(false);
+                    }
+                } else if result_key.is_none() {
+                    if let Some(_found) = choices.get(&shirabe_php_shim::strval(value)) {
+                        // false === $result && isset($choices[$value])
+                        result = value.clone();
+                    } else {
+                        result = PhpMixed::Bool(false);
+                    }
+                } else {
+                    // associative, found: keep the matched key
+                    result = PhpMixed::String(result_key.clone().unwrap());
+                }
+
+                // false === $result
+                if matches!(result, PhpMixed::Bool(false)) {
+                    return Err(InvalidArgumentException(
+                        shirabe_php_shim::InvalidArgumentException {
+                            message: shirabe_php_shim::sprintf(&error_message, &[value.clone()]),
+                            code: 0,
+                        },
+                    ));
+                }
+
+                // For associative choices, consistently return the key as string:
+                if is_assoc {
+                    result = PhpMixed::String(shirabe_php_shim::strval(&result));
+                }
+                multiselect_choices.push(result);
+            }
+
+            if multiselect {
+                return Ok(PhpMixed::List(
+                    multiselect_choices.into_iter().map(Box::new).collect(),
+                ));
+            }
+
+            Ok(shirabe_php_shim::current(PhpMixed::List(
+                multiselect_choices.into_iter().map(Box::new).collect(),
+            )))
+        })
+    }
+}
+
+/// array_search operates over the choice values as strings; this projects the
+/// choices map's values into the string-keyed form the shim expects.
+fn choices_as_str(choices: &IndexMap<String, Box<PhpMixed>>) -> IndexMap<String, String> {
+    choices
+        .iter()
+        .map(|(k, v)| (k.clone(), shirabe_php_shim::strval(v)))
+        .collect()
 }
diff --git a/crates/shirabe-external-packages/src/symfony/console/question/confirmation_question.rs b/crates/shirabe-external-packages/src/symfony/console/question/confirmation_question.rs
new file mode 100644
index 0000000..838ec45
--- /dev/null
+++ b/crates/shirabe-external-packages/src/symfony/console/question/confirmation_question.rs
@@ -0,0 +1,57 @@
+use crate::symfony::console::question::Question;
+use shirabe_php_shim::PhpMixed;
+
+/// Represents a yes/no question.
+#[derive(Debug)]
+pub struct ConfirmationQuestion {
+    inner: Question,
+    true_answer_regex: String,
+}
+
+impl ConfirmationQuestion {
+    /// `$question` The question to ask to the user.
+    /// `$default` The default answer to return, true or false.
+    /// `$trueAnswerRegex` A regex to match the "yes" answer.
+    pub fn new(question: String, default: bool, true_answer_regex: String) -> Self {
+        let mut this = Self {
+            inner: Question::new(question, Some(PhpMixed::Bool(default))),
+            true_answer_regex,
+        };
+
+        let normalizer = this.get_default_normalizer();
+        this.inner.set_normalizer(normalizer);
+
+        this
+    }
+
+    /// Returns the default answer normalizer.
+    fn get_default_normalizer(&self) -> Box<dyn Fn(PhpMixed) -> PhpMixed> {
+        let default = self.inner.get_default();
+        let regex = self.true_answer_regex.clone();
+
+        Box::new(move |answer: PhpMixed| {
+            if let PhpMixed::Bool(_) = answer {
+                return answer;
+            }
+
+            let answer_is_true = {
+                let mut matches: Vec<Option<String>> = Vec::new();
+                shirabe_php_shim::preg_match(
+                    &regex,
+                    &shirabe_php_shim::strval(&answer),
+                    &mut matches,
+                ) != 0
+            };
+
+            // false === $default
+            if matches!(default, PhpMixed::Bool(false)) {
+                // $answer && $answerIsTrue
+                return PhpMixed::Bool(!shirabe_php_shim::empty(&answer) && answer_is_true);
+            }
+
+            // '' === $answer || $answerIsTrue
+            let answer_is_empty_string = matches!(&answer, PhpMixed::String(s) if s.is_empty());
+            PhpMixed::Bool(answer_is_empty_string || answer_is_true)
+        })
+    }
+}
diff --git a/crates/shirabe-external-packages/src/symfony/console/question/mod.rs b/crates/shirabe-external-packages/src/symfony/console/question/mod.rs
index 67e7e7b..06e0c2c 100644
--- a/crates/shirabe-external-packages/src/symfony/console/question/mod.rs
+++ b/crates/shirabe-external-packages/src/symfony/console/question/mod.rs
@@ -1,5 +1,7 @@
 pub mod choice_question;
+pub mod confirmation_question;
 pub mod question;
 
 pub use choice_question::*;
+pub use confirmation_question::*;
 pub use question::*;
diff --git a/crates/shirabe-external-packages/src/symfony/console/question/question.rs b/crates/shirabe-external-packages/src/symfony/console/question/question.rs
index 552f780..754f286 100644
--- a/crates/shirabe-external-packages/src/symfony/console/question/question.rs
+++ b/crates/shirabe-external-packages/src/symfony/console/question/question.rs
@@ -1,53 +1,275 @@
+use crate::symfony::console::exception::invalid_argument_exception::InvalidArgumentException;
+use crate::symfony::console::exception::logic_exception::LogicException;
 use shirabe_php_shim::PhpMixed;
 
-#[derive(Debug)]
-pub struct Question;
+/// Represents a Question.
+pub struct Question {
+    question: String,
+    attempts: Option<i64>,
+    hidden: bool,
+    hidden_fallback: bool,
+    autocompleter_callback: Option<Box<dyn Fn(&str) -> Option<Vec<PhpMixed>>>>,
+    validator: Option<Box<dyn Fn(Option<PhpMixed>) -> Result<PhpMixed, InvalidArgumentException>>>,
+    default: Option<PhpMixed>,
+    normalizer: Option<Box<dyn Fn(PhpMixed) -> PhpMixed>>,
+    trimmable: bool,
+    multiline: bool,
+}
+
+impl std::fmt::Debug for Question {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Question")
+            .field("question", &self.question)
+            .field("attempts", &self.attempts)
+            .field("hidden", &self.hidden)
+            .field("hidden_fallback", &self.hidden_fallback)
+            .field("default", &self.default)
+            .field("trimmable", &self.trimmable)
+            .field("multiline", &self.multiline)
+            .finish_non_exhaustive()
+    }
+}
 
 impl Question {
-    pub fn new(_question: &str, _default: Option<PhpMixed>) -> Self {
-        todo!()
+    /// `$question` The question to ask to the user.
+    /// `$default` The default answer to return if the user enters nothing.
+    pub fn new(question: String, default: Option<PhpMixed>) -> Self {
+        Self {
+            question,
+            attempts: None,
+            hidden: false,
+            hidden_fallback: true,
+            autocompleter_callback: None,
+            validator: None,
+            default,
+            normalizer: None,
+            trimmable: true,
+            multiline: false,
+        }
     }
 
-    pub fn set_validator(
-        &mut self,
-        _validator: Option<Box<dyn Fn(Option<PhpMixed>) -> anyhow::Result<PhpMixed>>>,
-    ) {
-        todo!()
+    /// Returns the question.
+    pub fn get_question(&self) -> &str {
+        &self.question
     }
 
-    pub fn set_max_attempts(&mut self, _attempts: Option<i64>) {
-        todo!()
+    /// Returns the default answer.
+    pub fn get_default(&self) -> PhpMixed {
+        self.default.clone().unwrap_or(PhpMixed::Null)
     }
 
-    pub fn set_normalizer(&mut self, _normalizer: Box<dyn Fn(&PhpMixed) -> PhpMixed>) {
-        todo!()
+    /// Returns whether the user response accepts newline characters.
+    pub fn is_multiline(&self) -> bool {
+        self.multiline
     }
 
-    pub fn set_hidden(&mut self, _hidden: bool) {
-        todo!()
+    /// Sets whether the user response should accept newline characters.
+    pub fn set_multiline(&mut self, multiline: bool) -> &mut Self {
+        self.multiline = multiline;
+
+        self
     }
 
-    pub fn set_hidden_fallback(&mut self, _fallback: bool) {
-        todo!()
+    /// Returns whether the user response must be hidden.
+    pub fn is_hidden(&self) -> bool {
+        self.hidden
     }
 
-    pub fn get_question(&self) -> String {
-        todo!()
+    /// Sets whether the user response must be hidden or not.
+    ///
+    /// Throws LogicException in case the autocompleter is also used.
+    pub fn set_hidden(&mut self, hidden: bool) -> Result<&mut Self, LogicException> {
+        if self.autocompleter_callback.is_some() {
+            return Err(LogicException(shirabe_php_shim::LogicException {
+                message: "A hidden question cannot use the autocompleter.".to_string(),
+                code: 0,
+            }));
+        }
+
+        self.hidden = hidden;
+
+        Ok(self)
     }
 
-    pub fn get_default(&self) -> Option<PhpMixed> {
-        todo!()
+    /// In case the response cannot be hidden, whether to fallback on non-hidden question or not.
+    pub fn is_hidden_fallback(&self) -> bool {
+        self.hidden_fallback
     }
 
-    pub fn is_hidden(&self) -> bool {
-        todo!()
+    /// Sets whether to fallback on non-hidden question if the response cannot be hidden.
+    pub fn set_hidden_fallback(&mut self, fallback: bool) -> &mut Self {
+        self.hidden_fallback = fallback;
+
+        self
     }
 
-    pub fn get_validator(&self) -> Option<&dyn Fn(Option<PhpMixed>) -> anyhow::Result<PhpMixed>> {
-        todo!()
+    /// Gets values for the autocompleter.
+    pub fn get_autocompleter_values(&self) -> Option<Vec<PhpMixed>> {
+        let callback = self.get_autocompleter_callback();
+
+        match callback {
+            Some(callback) => callback(""),
+            None => None,
+        }
+    }
+
+    /// Sets values for the autocompleter.
+    ///
+    /// Throws LogicException.
+    pub fn set_autocompleter_values(
+        &mut self,
+        values: Option<PhpMixed>,
+    ) -> Result<&mut Self, LogicException> {
+        let callback: Option<Box<dyn Fn(&str) -> Option<Vec<PhpMixed>>>> = match values {
+            // PHP: `if (\is_array($values))`. Both PhpMixed::List and ::Array model PHP arrays.
+            Some(values) if matches!(values, PhpMixed::List(_) | PhpMixed::Array(_)) => {
+                let values = if Self::is_assoc(&values) {
+                    let array = match &values {
+                        PhpMixed::Array(array) => array,
+                        _ => unreachable!(),
+                    };
+                    // array_merge(array_keys($values), array_values($values))
+                    let mut merged: Vec<PhpMixed> =
+                        array.keys().map(|k| PhpMixed::String(k.clone())).collect();
+                    merged.extend(array.values().map(|v| (**v).clone()));
+                    merged
+                } else {
+                    // array_values($values)
+                    match &values {
+                        PhpMixed::List(list) => list.iter().map(|v| (**v).clone()).collect(),
+                        PhpMixed::Array(array) => array.values().map(|v| (**v).clone()).collect(),
+                        _ => unreachable!(),
+                    }
+                };
+
+                Some(Box::new(move |_input: &str| Some(values.clone())))
+            }
+            // PHP: `elseif ($values instanceof \Traversable)`. In PHP this caches the
+            // iterator result; here non-array iterables are not modeled, so treat any
+            // remaining value as the Traversable branch.
+            Some(values) => {
+                // PHP: `iterator_to_array($values, false)` caches a Traversable.
+                // Non-array iterables are not modeled by PhpMixed; extract any
+                // list/array elements, otherwise treat as an empty iterator.
+                let cached: Vec<PhpMixed> = match values {
+                    PhpMixed::List(list) => list.into_iter().map(|v| *v).collect(),
+                    PhpMixed::Array(array) => array.into_values().map(|v| *v).collect(),
+                    _ => Vec::new(),
+                };
+                Some(Box::new(move |_input: &str| Some(cached.clone())))
+            }
+            None => None,
+        };
+
+        self.set_autocompleter_callback(callback)
+    }
+
+    /// Gets the callback function used for the autocompleter.
+    pub fn get_autocompleter_callback(&self) -> Option<&(dyn Fn(&str) -> Option<Vec<PhpMixed>>)> {
+        self.autocompleter_callback.as_deref()
+    }
+
+    /// Sets the callback function used for the autocompleter.
+    ///
+    /// The callback is passed the user input as argument and should return an iterable of
+    /// corresponding suggestions.
+    pub fn set_autocompleter_callback(
+        &mut self,
+        callback: Option<Box<dyn Fn(&str) -> Option<Vec<PhpMixed>>>>,
+    ) -> Result<&mut Self, LogicException> {
+        if self.hidden && callback.is_some() {
+            return Err(LogicException(shirabe_php_shim::LogicException {
+                message: "A hidden question cannot use the autocompleter.".to_string(),
+                code: 0,
+            }));
+        }
+
+        self.autocompleter_callback = callback;
+
+        Ok(self)
     }
 
+    /// Sets a validator for the question.
+    pub fn set_validator(
+        &mut self,
+        validator: Option<
+            Box<dyn Fn(Option<PhpMixed>) -> Result<PhpMixed, InvalidArgumentException>>,
+        >,
+    ) -> &mut Self {
+        self.validator = validator;
+
+        self
+    }
+
+    /// Gets the validator for the question.
+    pub fn get_validator(
+        &self,
+    ) -> Option<&(dyn Fn(Option<PhpMixed>) -> Result<PhpMixed, InvalidArgumentException>)> {
+        self.validator.as_deref()
+    }
+
+    /// Sets the maximum number of attempts.
+    ///
+    /// Null means an unlimited number of attempts.
+    ///
+    /// Throws InvalidArgumentException in case the number of attempts is invalid.
+    pub fn set_max_attempts(
+        &mut self,
+        attempts: Option<i64>,
+    ) -> Result<&mut Self, InvalidArgumentException> {
+        if let Some(attempts) = attempts {
+            if attempts < 1 {
+                return Err(InvalidArgumentException(
+                    shirabe_php_shim::InvalidArgumentException {
+                        message: "Maximum number of attempts must be a positive value.".to_string(),
+                        code: 0,
+                    },
+                ));
+            }
+        }
+
+        self.attempts = attempts;
+
+        Ok(self)
+    }
+
+    /// Gets the maximum number of attempts.
+    ///
+    /// Null means an unlimited number of attempts.
     pub fn get_max_attempts(&self) -> Option<i64> {
-        todo!()
+        self.attempts
+    }
+
+    /// Sets a normalizer for the response.
+    ///
+    /// The normalizer can be a callable (a string), a closure or a class implementing __invoke.
+    pub fn set_normalizer(&mut self, normalizer: Box<dyn Fn(PhpMixed) -> PhpMixed>) -> &mut Self {
+        self.normalizer = Some(normalizer);
+
+        self
+    }
+
+    /// Gets the normalizer for the response.
+    ///
+    /// The normalizer can ba a callable (a string), a closure or a class implementing __invoke.
+    pub fn get_normalizer(&self) -> Option<&(dyn Fn(PhpMixed) -> PhpMixed)> {
+        self.normalizer.as_deref()
+    }
+
+    // PHP: `(bool) \count(array_filter(array_keys($array), 'is_string'))`.
+    // PhpMixed models a PHP array as either `List` (sequential int keys) or `Array`
+    // (string-keyed map), so the "has string keys" test reduces to the `Array` variant.
+    pub(crate) fn is_assoc(array: &PhpMixed) -> bool {
+        matches!(array, PhpMixed::Array(_))
+    }
+
+    pub fn is_trimmable(&self) -> bool {
+        self.trimmable
+    }
+
+    pub fn set_trimmable(&mut self, trimmable: bool) -> &mut Self {
+        self.trimmable = trimmable;
+
+        self
     }
 }