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) <noreply@anthropic.com>

1 files changed, 0 insertions, 243 deletions

diff --git a/crates/shirabe-external-packages/src/symfony/console/input/string_input.rs b/crates/shirabe-external-packages/src/symfony/console/input/string_input.rs
deleted file mode 100644
index 0ca8c975..00000000
--- a/crates/shirabe-external-packages/src/symfony/console/input/string_input.rs
+++ /dev/null
@@ -1,243 +0,0 @@
-//! ref: composer/vendor/symfony/console/Input/StringInput.php
-
-use crate::symfony::console::exception::invalid_argument_exception::InvalidArgumentException;
-use crate::symfony::console::input::argv_input::ArgvInput;
-use crate::symfony::console::input::input_definition::InputDefinition;
-use crate::symfony::console::input::input_interface::InputInterface;
-use crate::symfony::console::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|(?<!\\)"|(?<!\\)'|$)"#;
-    pub const REGEX_UNQUOTED_STRING: &'static str = r#"([^\s\\]+?)"#;
-    pub const REGEX_QUOTED_STRING: &'static str =
-        r#"(?:"([^"\\]*(?:\\.[^"\\]*)*)"|'([^'\\]*(?:\\.[^'\\]*)*)')"#;
-
-    pub fn new(input: &str) -> anyhow::Result<Self> {
-        // 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<Vec<String>> {
-        let bytes = input.as_bytes();
-        let mut tokens: Vec<String> = vec![];
-        let length = shirabe_php_shim::strlen(input);
-        let mut cursor: i64 = 0;
-        let mut token: Option<String> = 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<CaptureKey, Option<String>> = 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::cell::RefCell<dyn InputInterface>> {
-        std::rc::Rc::new(std::cell::RefCell::new(self.clone()))
-    }
-
-    fn get_first_argument(&self) -> Option<String> {
-        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<String, PhpMixed> {
-        InputInterface::get_arguments(&self.inner)
-    }
-
-    fn get_argument(&self, name: &str) -> anyhow::Result<PhpMixed> {
-        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<String, PhpMixed> {
-        InputInterface::get_options(&self.inner)
-    }
-
-    fn get_option(&self, name: &str) -> anyhow::Result<PhpMixed> {
-        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<shirabe_php_shim::PhpResource> {
-        self.inner.get_stream()
-    }
-}