feat(port): port ClassLoader.php

1 files changed, 533 insertions, 0 deletions

diff --git a/crates/shirabe/src/autoload/class_loader.rs b/crates/shirabe/src/autoload/class_loader.rs
index 57a0d6b..9727a45 100644
--- a/crates/shirabe/src/autoload/class_loader.rs
+++ b/crates/shirabe/src/autoload/class_loader.rs
@@ -1 +1,534 @@
 //! ref: composer/src/Composer/Autoload/ClassLoader.php
+
+use indexmap::IndexMap;
+use std::sync::{LazyLock, Mutex};
+
+use shirabe_php_shim::{
+    apcu_add, apcu_fetch, array_merge, array_values, call_user_func_array, defined, file_exists,
+    filter_var, function_exists, include_file, ini_get, spl_autoload_register,
+    spl_autoload_unregister, stream_resolve_include_path, strlen, strpos, strrpos, strtr, substr,
+    InvalidArgumentException, PhpMixed, DIRECTORY_SEPARATOR, FILTER_VALIDATE_BOOLEAN,
+};
+
+/// @var array<string, self>
+static REGISTERED_LOADERS: LazyLock<Mutex<IndexMap<String, ClassLoader>>> =
+    LazyLock::new(|| Mutex::new(IndexMap::new()));
+
+/// ClassLoader implements a PSR-0, PSR-4 and classmap class loader.
+#[derive(Debug, Clone)]
+pub struct ClassLoader {
+    // PHP: private static $includeFile — TODO(phase-b): stash include closure as a static
+    /// @var string|null
+    vendor_dir: Option<String>,
+
+    // PSR-4
+    /// @var array<string, array<string, int>>
+    prefix_lengths_psr4: IndexMap<String, IndexMap<String, i64>>,
+    /// @var array<string, list<string>>
+    prefix_dirs_psr4: IndexMap<String, Vec<String>>,
+    /// @var list<string>
+    fallback_dirs_psr4: Vec<String>,
+
+    // PSR-0
+    /// List of PSR-0 prefixes
+    ///
+    /// Structured as array('F (first letter)' => array('Foo\Bar (full prefix)' => array('path', 'path2')))
+    ///
+    /// @var array<string, array<string, list<string>>>
+    prefixes_psr0: IndexMap<String, IndexMap<String, Vec<String>>>,
+    /// @var list<string>
+    fallback_dirs_psr0: Vec<String>,
+
+    /// @var bool
+    use_include_path: bool,
+
+    /// @var array<string, string>
+    class_map: IndexMap<String, String>,
+
+    /// @var bool
+    class_map_authoritative: bool,
+
+    /// @var array<string, bool>
+    missing_classes: IndexMap<String, bool>,
+
+    /// @var string|null
+    apcu_prefix: Option<String>,
+}
+
+impl ClassLoader {
+    /// @param string|null $vendorDir
+    pub fn new(vendor_dir: Option<String>) -> Self {
+        let this = Self {
+            vendor_dir,
+            prefix_lengths_psr4: IndexMap::new(),
+            prefix_dirs_psr4: IndexMap::new(),
+            fallback_dirs_psr4: vec![],
+            prefixes_psr0: IndexMap::new(),
+            fallback_dirs_psr0: vec![],
+            use_include_path: false,
+            class_map: IndexMap::new(),
+            class_map_authoritative: false,
+            missing_classes: IndexMap::new(),
+            apcu_prefix: None,
+        };
+        Self::initialize_include_closure();
+        this
+    }
+
+    /// @return array<string, list<string>>
+    pub fn get_prefixes(&self) -> IndexMap<String, Vec<String>> {
+        if !self.prefixes_psr0.is_empty() {
+            // PHP: call_user_func_array('array_merge', array_values($this->prefixesPsr0))
+            let prefixes_as_mixed: IndexMap<String, PhpMixed> = self
+                .prefixes_psr0
+                .iter()
+                .map(|(k, v)| {
+                    (
+                        k.clone(),
+                        PhpMixed::Array(
+                            v.iter()
+                                .map(|(k2, v2)| {
+                                    (
+                                        k2.clone(),
+                                        Box::new(PhpMixed::List(
+                                            v2.iter()
+                                                .map(|s| Box::new(PhpMixed::String(s.clone())))
+                                                .collect(),
+                                        )),
+                                    )
+                                })
+                                .collect(),
+                        ),
+                    )
+                })
+                .collect();
+            let arrays = array_values(&prefixes_as_mixed);
+            let result = call_user_func_array(
+                "array_merge",
+                &PhpMixed::List(arrays.into_iter().map(Box::new).collect()),
+            );
+            // TODO(phase-b): cast result back to IndexMap<String, Vec<String>>
+            let _ = result;
+            return IndexMap::new();
+        }
+
+        IndexMap::new()
+    }
+
+    /// @return array<string, list<string>>
+    pub fn get_prefixes_psr4(&self) -> &IndexMap<String, Vec<String>> {
+        &self.prefix_dirs_psr4
+    }
+
+    /// @return list<string>
+    pub fn get_fallback_dirs(&self) -> &Vec<String> {
+        &self.fallback_dirs_psr0
+    }
+
+    /// @return list<string>
+    pub fn get_fallback_dirs_psr4(&self) -> &Vec<String> {
+        &self.fallback_dirs_psr4
+    }
+
+    /// @return array<string, string> Array of classname => path
+    pub fn get_class_map(&self) -> &IndexMap<String, String> {
+        &self.class_map
+    }
+
+    /// @param array<string, string> $classMap Class to filename map
+    pub fn add_class_map(&mut self, class_map: IndexMap<String, String>) {
+        if !self.class_map.is_empty() {
+            // PHP: $this->classMap = array_merge($this->classMap, $classMap);
+            let merged = array_merge(
+                PhpMixed::Array(
+                    self.class_map
+                        .iter()
+                        .map(|(k, v)| (k.clone(), Box::new(PhpMixed::String(v.clone()))))
+                        .collect(),
+                ),
+                PhpMixed::Array(
+                    class_map
+                        .iter()
+                        .map(|(k, v)| (k.clone(), Box::new(PhpMixed::String(v.clone()))))
+                        .collect(),
+                ),
+            );
+            // TODO(phase-b): cast merged back to IndexMap<String, String>
+            let _ = merged;
+            self.class_map.extend(class_map);
+        } else {
+            self.class_map = class_map;
+        }
+    }
+
+    /// Registers a set of PSR-0 directories for a given prefix, either
+    /// appending or prepending to the ones previously set for this prefix.
+    pub fn add(&mut self, prefix: &str, paths: Vec<String>, prepend: bool) {
+        if prefix.is_empty() {
+            if prepend {
+                let mut new_dirs = paths.clone();
+                new_dirs.extend(self.fallback_dirs_psr0.drain(..));
+                self.fallback_dirs_psr0 = new_dirs;
+            } else {
+                self.fallback_dirs_psr0.extend(paths);
+            }
+
+            return;
+        }
+
+        let first = prefix.chars().next().unwrap_or('\0').to_string();
+        let entry = self
+            .prefixes_psr0
+            .entry(first.clone())
+            .or_insert_with(IndexMap::new);
+        if !entry.contains_key(prefix) {
+            entry.insert(prefix.to_string(), paths);
+            return;
+        }
+        let existing = entry.get_mut(prefix).unwrap();
+        if prepend {
+            let mut new_dirs = paths.clone();
+            new_dirs.extend(existing.drain(..));
+            *existing = new_dirs;
+        } else {
+            existing.extend(paths);
+        }
+    }
+
+    /// Registers a set of PSR-4 directories for a given namespace, either
+    /// appending or prepending to the ones previously set for this namespace.
+    ///
+    /// @throws \InvalidArgumentException
+    pub fn add_psr4(
+        &mut self,
+        prefix: &str,
+        paths: Vec<String>,
+        prepend: bool,
+    ) -> anyhow::Result<()> {
+        if prefix.is_empty() {
+            // Register directories for the root namespace.
+            if prepend {
+                let mut new_dirs = paths.clone();
+                new_dirs.extend(self.fallback_dirs_psr4.drain(..));
+                self.fallback_dirs_psr4 = new_dirs;
+            } else {
+                self.fallback_dirs_psr4.extend(paths);
+            }
+        } else if !self.prefix_dirs_psr4.contains_key(prefix) {
+            // Register directories for a new namespace.
+            let length = strlen(prefix);
+            if "\\" != &prefix[(length as usize - 1)..(length as usize)] {
+                return Err(InvalidArgumentException {
+                    message: "A non-empty PSR-4 prefix must end with a namespace separator."
+                        .to_string(),
+                    code: 0,
+                }
+                .into());
+            }
+            let first = prefix.chars().next().unwrap_or('\0').to_string();
+            self.prefix_lengths_psr4
+                .entry(first)
+                .or_insert_with(IndexMap::new)
+                .insert(prefix.to_string(), length);
+            self.prefix_dirs_psr4.insert(prefix.to_string(), paths);
+        } else if prepend {
+            // Prepend directories for an already registered namespace.
+            let existing = self.prefix_dirs_psr4.get_mut(prefix).unwrap();
+            let mut new_dirs = paths.clone();
+            new_dirs.extend(existing.drain(..));
+            *existing = new_dirs;
+        } else {
+            // Append directories for an already registered namespace.
+            let existing = self.prefix_dirs_psr4.get_mut(prefix).unwrap();
+            existing.extend(paths);
+        }
+        Ok(())
+    }
+
+    /// Registers a set of PSR-0 directories for a given prefix,
+    /// replacing any others previously set for this prefix.
+    pub fn set(&mut self, prefix: &str, paths: Vec<String>) {
+        if prefix.is_empty() {
+            self.fallback_dirs_psr0 = paths;
+        } else {
+            let first = prefix.chars().next().unwrap_or('\0').to_string();
+            self.prefixes_psr0
+                .entry(first)
+                .or_insert_with(IndexMap::new)
+                .insert(prefix.to_string(), paths);
+        }
+    }
+
+    /// Registers a set of PSR-4 directories for a given namespace,
+    /// replacing any others previously set for this namespace.
+    ///
+    /// @throws \InvalidArgumentException
+    pub fn set_psr4(&mut self, prefix: &str, paths: Vec<String>) -> anyhow::Result<()> {
+        if prefix.is_empty() {
+            self.fallback_dirs_psr4 = paths;
+        } else {
+            let length = strlen(prefix);
+            if "\\" != &prefix[(length as usize - 1)..(length as usize)] {
+                return Err(InvalidArgumentException {
+                    message: "A non-empty PSR-4 prefix must end with a namespace separator."
+                        .to_string(),
+                    code: 0,
+                }
+                .into());
+            }
+            let first = prefix.chars().next().unwrap_or('\0').to_string();
+            self.prefix_lengths_psr4
+                .entry(first)
+                .or_insert_with(IndexMap::new)
+                .insert(prefix.to_string(), length);
+            self.prefix_dirs_psr4.insert(prefix.to_string(), paths);
+        }
+        Ok(())
+    }
+
+    /// Turns on searching the include path for class files.
+    pub fn set_use_include_path(&mut self, use_include_path: bool) {
+        self.use_include_path = use_include_path;
+    }
+
+    /// Can be used to check if the autoloader uses the include path to check
+    /// for classes.
+    pub fn get_use_include_path(&self) -> bool {
+        self.use_include_path
+    }
+
+    /// Turns off searching the prefix and fallback directories for classes
+    /// that have not been registered with the class map.
+    pub fn set_class_map_authoritative(&mut self, class_map_authoritative: bool) {
+        self.class_map_authoritative = class_map_authoritative;
+    }
+
+    /// Should class lookup fail if not found in the current class map?
+    pub fn is_class_map_authoritative(&self) -> bool {
+        self.class_map_authoritative
+    }
+
+    /// APCu prefix to use to cache found/not-found classes, if the extension is enabled.
+    pub fn set_apcu_prefix(&mut self, apcu_prefix: Option<String>) {
+        self.apcu_prefix = if function_exists("apcu_fetch")
+            && filter_var(
+                &ini_get("apc.enabled").unwrap_or_default(),
+                FILTER_VALIDATE_BOOLEAN,
+            )
+        {
+            apcu_prefix
+        } else {
+            None
+        };
+    }
+
+    /// The APCu prefix in use, or null if APCu caching is not enabled.
+    pub fn get_apcu_prefix(&self) -> Option<&str> {
+        self.apcu_prefix.as_deref()
+    }
+
+    /// Registers this instance as an autoloader.
+    pub fn register(&self, prepend: bool) {
+        spl_autoload_register(
+            // PHP: array($this, 'loadClass')
+            Box::new(|_class: &str| -> PhpMixed { PhpMixed::Null }),
+            true,
+            prepend,
+        );
+
+        if self.vendor_dir.is_none() {
+            return;
+        }
+
+        let mut registered = REGISTERED_LOADERS.lock().unwrap();
+        if prepend {
+            let mut new_map: IndexMap<String, ClassLoader> = IndexMap::new();
+            new_map.insert(self.vendor_dir.clone().unwrap(), self.clone());
+            let old_map: IndexMap<String, ClassLoader> =
+                std::mem::take(&mut *registered);
+            for (k, v) in old_map {
+                if !new_map.contains_key(&k) {
+                    new_map.insert(k, v);
+                }
+            }
+            *registered = new_map;
+        } else {
+            registered.shift_remove(self.vendor_dir.as_ref().unwrap());
+            registered.insert(self.vendor_dir.clone().unwrap(), self.clone());
+        }
+    }
+
+    /// Unregisters this instance as an autoloader.
+    pub fn unregister(&self) {
+        spl_autoload_unregister(Box::new(|_class: &str| -> PhpMixed { PhpMixed::Null }));
+
+        if self.vendor_dir.is_some() {
+            REGISTERED_LOADERS
+                .lock()
+                .unwrap()
+                .shift_remove(self.vendor_dir.as_ref().unwrap());
+        }
+    }
+
+    /// Loads the given class or interface.
+    ///
+    /// @return true|null True if loaded, null otherwise
+    pub fn load_class(&mut self, class: &str) -> Option<bool> {
+        let file = self.find_file(class);
+        if let Some(file) = file {
+            include_file(&file);
+
+            return Some(true);
+        }
+
+        None
+    }
+
+    /// Finds the path to the file where the class is defined.
+    ///
+    /// @return string|false The path if found, false otherwise
+    pub fn find_file(&mut self, class: &str) -> Option<String> {
+        // class map lookup
+        if let Some(path) = self.class_map.get(class) {
+            return Some(path.clone());
+        }
+        if self.class_map_authoritative || self.missing_classes.contains_key(class) {
+            return None;
+        }
+        if self.apcu_prefix.is_some() {
+            let mut hit = false;
+            let file = apcu_fetch(
+                &format!("{}{}", self.apcu_prefix.as_ref().unwrap(), class),
+                &mut hit,
+            );
+            if hit {
+                return file.as_string().map(String::from);
+            }
+        }
+
+        let mut file = self.find_file_with_extension(class, ".php");
+
+        // Search for Hack files if we are running on HHVM
+        if file.is_none() && defined("HHVM_VERSION") {
+            file = self.find_file_with_extension(class, ".hh");
+        }
+
+        if self.apcu_prefix.is_some() {
+            apcu_add(
+                &format!("{}{}", self.apcu_prefix.as_ref().unwrap(), class),
+                match file.as_ref() {
+                    Some(s) => PhpMixed::String(s.clone()),
+                    None => PhpMixed::Bool(false),
+                },
+            );
+        }
+
+        if file.is_none() {
+            // Remember that this class does not exist.
+            self.missing_classes.insert(class.to_string(), true);
+        }
+
+        file
+    }
+
+    /// Returns the currently registered loaders keyed by their corresponding vendor directories.
+    ///
+    /// @return array<string, self>
+    pub fn get_registered_loaders() -> IndexMap<String, ClassLoader> {
+        REGISTERED_LOADERS.lock().unwrap().clone()
+    }
+
+    /// @return string|false
+    fn find_file_with_extension(&self, class: &str, ext: &str) -> Option<String> {
+        // PSR-4 lookup
+        let logical_path_psr4 = format!("{}{}", strtr(class, "\\", DIRECTORY_SEPARATOR), ext);
+
+        let first = class.chars().next().unwrap_or('\0').to_string();
+        if self.prefix_lengths_psr4.contains_key(&first) {
+            let mut sub_path = class.to_string();
+            loop {
+                let last_pos = strrpos(&sub_path, "\\");
+                if last_pos.is_none() {
+                    break;
+                }
+                let last_pos = last_pos.unwrap();
+                sub_path = substr(&sub_path, 0, Some(last_pos as i64));
+                let search = format!("{}\\", sub_path);
+                if let Some(dirs) = self.prefix_dirs_psr4.get(&search) {
+                    let path_end = format!(
+                        "{}{}",
+                        DIRECTORY_SEPARATOR,
+                        substr(&logical_path_psr4, (last_pos + 1) as i64, None)
+                    );
+                    for dir in dirs {
+                        let file = format!("{}{}", dir, path_end);
+                        if file_exists(&file) {
+                            return Some(file);
+                        }
+                    }
+                }
+            }
+        }
+
+        // PSR-4 fallback dirs
+        for dir in &self.fallback_dirs_psr4 {
+            let file = format!("{}{}{}", dir, DIRECTORY_SEPARATOR, logical_path_psr4);
+            if file_exists(&file) {
+                return Some(file);
+            }
+        }
+
+        // PSR-0 lookup
+        let logical_path_psr0: String;
+        if let Some(pos) = strrpos(class, "\\") {
+            // namespaced class name
+            logical_path_psr0 = format!(
+                "{}{}",
+                substr(&logical_path_psr4, 0, Some((pos + 1) as i64)),
+                strtr(
+                    &substr(&logical_path_psr4, (pos + 1) as i64, None),
+                    "_",
+                    DIRECTORY_SEPARATOR
+                )
+            );
+        } else {
+            // PEAR-like class name
+            logical_path_psr0 = format!("{}{}", strtr(class, "_", DIRECTORY_SEPARATOR), ext);
+        }
+
+        if let Some(prefixes) = self.prefixes_psr0.get(&first) {
+            for (prefix, dirs) in prefixes {
+                if Some(0) == strpos(class, prefix) {
+                    for dir in dirs {
+                        let file = format!("{}{}{}", dir, DIRECTORY_SEPARATOR, logical_path_psr0);
+                        if file_exists(&file) {
+                            return Some(file);
+                        }
+                    }
+                }
+            }
+        }
+
+        // PSR-0 fallback dirs
+        for dir in &self.fallback_dirs_psr0 {
+            let file = format!("{}{}{}", dir, DIRECTORY_SEPARATOR, logical_path_psr0);
+            if file_exists(&file) {
+                return Some(file);
+            }
+        }
+
+        // PSR-0 include paths.
+        if self.use_include_path {
+            if let Some(file) = stream_resolve_include_path(&logical_path_psr0) {
+                return Some(file);
+            }
+        }
+
+        None
+    }
+
+    fn initialize_include_closure() {
+        // TODO(phase-b): preserve PHP `\Closure::bind(static fn($file) => include $file, null, null)`
+        // Rust has no `include` operator; this is a no-op placeholder.
+    }
+}