feat(port): port RootPackageLoader.php

1 files changed, 429 insertions, 0 deletions

diff --git a/crates/shirabe/src/package/loader/root_package_loader.rs b/crates/shirabe/src/package/loader/root_package_loader.rs
index 7e8e940..eef7d70 100644
--- a/crates/shirabe/src/package/loader/root_package_loader.rs
+++ b/crates/shirabe/src/package/loader/root_package_loader.rs
@@ -1 +1,430 @@
 //! ref: composer/src/Composer/Package/Loader/RootPackageLoader.php
+
+use indexmap::IndexMap;
+use shirabe_external_packages::composer::pcre::preg::Preg;
+use shirabe_php_shim::{strtolower, ucfirst, LogicException, RuntimeException, UnexpectedValueException};
+
+use crate::config::Config;
+use crate::io::io_interface::IOInterface;
+use crate::package::base_package::{BasePackage, STABILITIES, SUPPORTED_LINK_TYPES};
+use crate::package::loader::array_loader::ArrayLoader;
+use crate::package::loader::validating_array_loader::ValidatingArrayLoader;
+use crate::package::package_interface::PackageInterface;
+use crate::package::root_alias_package::RootAliasPackage;
+use crate::package::root_package::RootPackage;
+use crate::package::version::version_guesser::VersionGuesser;
+use crate::package::version::version_parser::VersionParser;
+use crate::repository::repository_factory::RepositoryFactory;
+use crate::repository::repository_manager::RepositoryManager;
+use crate::util::platform::Platform;
+use crate::util::process_executor::ProcessExecutor;
+
+#[derive(Debug)]
+pub struct RootPackageLoader {
+    inner: ArrayLoader,
+    manager: RepositoryManager,
+    config: Config,
+    version_guesser: VersionGuesser,
+    io: Option<Box<dyn IOInterface>>,
+}
+
+impl RootPackageLoader {
+    pub fn new(
+        manager: RepositoryManager,
+        config: Config,
+        parser: Option<VersionParser>,
+        version_guesser: Option<VersionGuesser>,
+        io: Option<Box<dyn IOInterface>>,
+    ) -> Self {
+        let inner = ArrayLoader::new(parser);
+        let version_guesser = version_guesser.unwrap_or_else(|| {
+            let mut process_executor = ProcessExecutor::new(io.as_deref());
+            process_executor.enable_async();
+            VersionGuesser::new(&config, process_executor, inner.version_parser.clone())
+        });
+        Self {
+            inner,
+            manager,
+            config,
+            version_guesser,
+            io,
+        }
+    }
+
+    pub fn load(
+        &mut self,
+        config: IndexMap<String, Box<shirabe_php_shim::PhpMixed>>,
+        class: &str,
+        cwd: Option<&str>,
+    ) -> anyhow::Result<Box<dyn PackageInterface>> {
+        if class != "Composer\\Package\\RootPackage" {
+            shirabe_php_shim::trigger_error(
+                "The $class arg is deprecated, please reach out to Composer maintainers ASAP if you still need this.",
+                shirabe_php_shim::E_USER_DEPRECATED,
+            );
+        }
+
+        let mut config = config;
+
+        if !config.contains_key("name") {
+            config.insert(
+                "name".to_string(),
+                Box::new(shirabe_php_shim::PhpMixed::String("__root__".to_string())),
+            );
+        } else if let Some(err) = ValidatingArrayLoader::has_package_naming_error(
+            config["name"].as_string().unwrap_or(""),
+            false,
+        ) {
+            return Err(anyhow::anyhow!(RuntimeException {
+                message: format!("Your package name {}", err),
+                code: 0,
+            }));
+        }
+
+        let mut auto_versioned = false;
+        if !config.contains_key("version") {
+            let mut commit: Option<String> = None;
+
+            if Platform::get_env("COMPOSER_ROOT_VERSION").is_some() {
+                let version = self.version_guesser.get_root_version_from_env();
+                config.insert(
+                    "version".to_string(),
+                    Box::new(shirabe_php_shim::PhpMixed::String(version)),
+                );
+            } else {
+                let cwd_str = cwd.map(|s| s.to_string()).unwrap_or_else(|| Platform::get_cwd(true));
+                let version_data = self.version_guesser.guess_version(&config, &cwd_str);
+                if let Some(data) = version_data {
+                    config.insert(
+                        "version".to_string(),
+                        Box::new(shirabe_php_shim::PhpMixed::String(data.pretty_version.clone())),
+                    );
+                    config.insert(
+                        "version_normalized".to_string(),
+                        Box::new(shirabe_php_shim::PhpMixed::String(data.version.clone())),
+                    );
+                    commit = data.commit;
+                }
+            }
+
+            if !config.contains_key("version") {
+                if let Some(ref io) = self.io {
+                    let name = config["name"].as_string().unwrap_or("");
+                    let package_type = config
+                        .get("type")
+                        .and_then(|v| v.as_string())
+                        .unwrap_or("");
+                    if name != "__root__" && package_type != "project" {
+                        io.warning(&format!(
+                            "Composer could not detect the root package ({}) version, defaulting to '1.0.0'. See https://getcomposer.org/root-version",
+                            name
+                        ));
+                    }
+                }
+                config.insert(
+                    "version".to_string(),
+                    Box::new(shirabe_php_shim::PhpMixed::String("1.0.0".to_string())),
+                );
+                auto_versioned = true;
+            }
+
+            if let Some(commit_hash) = commit {
+                let mut source = IndexMap::new();
+                source.insert(
+                    "type".to_string(),
+                    Box::new(shirabe_php_shim::PhpMixed::String(String::new())),
+                );
+                source.insert(
+                    "url".to_string(),
+                    Box::new(shirabe_php_shim::PhpMixed::String(String::new())),
+                );
+                source.insert(
+                    "reference".to_string(),
+                    Box::new(shirabe_php_shim::PhpMixed::String(commit_hash.clone())),
+                );
+                config.insert(
+                    "source".to_string(),
+                    Box::new(shirabe_php_shim::PhpMixed::Array(source)),
+                );
+
+                let mut dist = IndexMap::new();
+                dist.insert(
+                    "type".to_string(),
+                    Box::new(shirabe_php_shim::PhpMixed::String(String::new())),
+                );
+                dist.insert(
+                    "url".to_string(),
+                    Box::new(shirabe_php_shim::PhpMixed::String(String::new())),
+                );
+                dist.insert(
+                    "reference".to_string(),
+                    Box::new(shirabe_php_shim::PhpMixed::String(commit_hash)),
+                );
+                config.insert(
+                    "dist".to_string(),
+                    Box::new(shirabe_php_shim::PhpMixed::Array(dist)),
+                );
+            }
+        }
+
+        let package = self.inner.load(config.clone(), "Composer\\Package\\RootPackage")?;
+
+        let real_package: &mut RootPackage = if let Some(alias_pkg) =
+            package.as_any_mut().downcast_mut::<RootAliasPackage>()
+        {
+            alias_pkg
+                .get_alias_of_mut()
+                .as_any_mut()
+                .downcast_mut::<RootPackage>()
+                .ok_or_else(|| {
+                    anyhow::anyhow!(LogicException {
+                        message: "Expecting a Composer\\Package\\RootPackage at this point"
+                            .to_string(),
+                        code: 0,
+                    })
+                })?
+        } else if let Some(root_pkg) = package.as_any_mut().downcast_mut::<RootPackage>() {
+            root_pkg
+        } else {
+            return Err(anyhow::anyhow!(LogicException {
+                message: "Expecting a Composer\\Package\\RootPackage at this point".to_string(),
+                code: 0,
+            }));
+        };
+
+        if auto_versioned {
+            real_package
+                .replace_version(real_package.get_version().to_string(), RootPackage::DEFAULT_PRETTY_VERSION.to_string());
+        }
+
+        if let Some(min_stability) = config
+            .get("minimum-stability")
+            .and_then(|v| v.as_string())
+        {
+            real_package
+                .set_minimum_stability(VersionParser::normalize_stability(min_stability).to_string());
+        }
+
+        let mut aliases: Vec<IndexMap<String, String>> = vec![];
+        let mut stability_flags: IndexMap<String, i64> = IndexMap::new();
+        let mut references: IndexMap<String, String> = IndexMap::new();
+
+        for link_type in ["require", "require-dev"] {
+            if config.contains_key(link_type) {
+                let link_info = &SUPPORTED_LINK_TYPES[link_type];
+                let method = format!("get_{}", link_info.method);
+                let links: IndexMap<String, String> = real_package
+                    .call_get_links_method(&method)
+                    .iter()
+                    .map(|(target, link)| {
+                        (
+                            target.clone(),
+                            link.get_constraint()
+                                .map(|c| c.get_pretty_string().to_string())
+                                .unwrap_or_default(),
+                        )
+                    })
+                    .collect();
+                aliases = self.extract_aliases(&links, aliases);
+                stability_flags = Self::extract_stability_flags(
+                    &links,
+                    real_package.get_minimum_stability(),
+                    stability_flags,
+                );
+                references = Self::extract_references(&links, references);
+
+                let package_name = config["name"].as_string().unwrap_or("").to_string();
+                if links.contains_key(&package_name) {
+                    return Err(anyhow::anyhow!(RuntimeException {
+                        message: format!(
+                            "Root package '{}' cannot require itself in its composer.json\nDid you accidentally name your root package after an external package?",
+                            package_name
+                        ),
+                        code: 0,
+                    }));
+                }
+            }
+        }
+
+        for link_type in SUPPORTED_LINK_TYPES.keys() {
+            if let Some(section) = config.get(*link_type) {
+                if let Some(section_map) = section.as_array() {
+                    for (link_name, _constraint) in section_map {
+                        if let Some(err) =
+                            ValidatingArrayLoader::has_package_naming_error(link_name, true)
+                        {
+                            return Err(anyhow::anyhow!(RuntimeException {
+                                message: format!("{}.{}", link_type, err),
+                                code: 0,
+                            }));
+                        }
+                    }
+                }
+            }
+        }
+
+        real_package.set_aliases(aliases);
+        real_package.set_stability_flags(stability_flags);
+        real_package.set_references(references);
+
+        if let Some(prefer_stable) = config.get("prefer-stable").and_then(|v| v.as_bool()) {
+            real_package.set_prefer_stable(prefer_stable);
+        }
+
+        if let Some(pkg_config) = config.get("config").and_then(|v| v.as_array()) {
+            real_package.set_config(
+                pkg_config
+                    .iter()
+                    .map(|(k, v)| (k.clone(), (**v).clone()))
+                    .collect(),
+            );
+        }
+
+        let repos = RepositoryFactory::default_repos(None, &self.config, &mut self.manager)?;
+        for repo in repos {
+            self.manager.add_repository(repo);
+        }
+        real_package.set_repositories(self.config.get_repositories());
+
+        Ok(package)
+    }
+
+    fn extract_aliases(
+        &self,
+        requires: &IndexMap<String, String>,
+        mut aliases: Vec<IndexMap<String, String>>,
+    ) -> Vec<IndexMap<String, String>> {
+        for (req_name, req_version) in requires {
+            if let Some(m) = Preg::is_match_strict_groups(
+                r"(?:^|\| *|, *)([^,\s#|]+)(?:#[^ ]+)? +as +([^,\s|]+)(?:$| *\|| *,)",
+                req_version,
+            )
+            .unwrap_or(None)
+            {
+                let mut alias = IndexMap::new();
+                alias.insert("package".to_string(), strtolower(req_name));
+                alias.insert(
+                    "version".to_string(),
+                    self.inner
+                        .version_parser
+                        .normalize(&m[1], req_version)
+                        .unwrap_or_default(),
+                );
+                alias.insert("alias".to_string(), m[2].clone());
+                alias.insert(
+                    "alias_normalized".to_string(),
+                    self.inner
+                        .version_parser
+                        .normalize(&m[2], req_version)
+                        .unwrap_or_default(),
+                );
+                aliases.push(alias);
+            } else if req_version.contains(" as ") {
+                return {
+                    panic!(
+                        "{}",
+                        UnexpectedValueException {
+                            message: format!(
+                                "Invalid alias definition in \"{}\": \"{}\". Aliases should be in the form \"exact-version as other-exact-version\".",
+                                req_name, req_version
+                            ),
+                            code: 0,
+                        }
+                        .message
+                    )
+                };
+            }
+        }
+        aliases
+    }
+
+    pub fn extract_stability_flags(
+        requires: &IndexMap<String, String>,
+        minimum_stability: &str,
+        mut stability_flags: IndexMap<String, i64>,
+    ) -> IndexMap<String, i64> {
+        let stabilities = &*STABILITIES;
+        let minimum_stability_val = stabilities[minimum_stability];
+
+        for (req_name, req_version) in requires {
+            let mut constraints: Vec<String> = vec![];
+
+            let or_split = Preg::split(r"\s*\|\|?\s*", req_version.trim()).unwrap_or_default();
+            for or_constraint in &or_split {
+                let and_split = Preg::split(
+                    r"(?<!^|as|[=>< ,]) *(?<!-)[, ](?!-) *(?!,|as|$)",
+                    or_constraint,
+                )
+                .unwrap_or_default();
+                for and_constraint in and_split {
+                    constraints.push(and_constraint);
+                }
+            }
+
+            let stability_names: Vec<&str> = stabilities.keys().copied().collect();
+            let pattern = format!(
+                "^[^@]*?@({})$",
+                stability_names.join("|")
+            );
+
+            let mut matched = false;
+            for constraint in &constraints {
+                if let Some(Some(m)) =
+                    Preg::is_match_strict_groups(&pattern, constraint).ok()
+                {
+                    let name = strtolower(req_name);
+                    let stability = stabilities[VersionParser::normalize_stability(&m[1])];
+
+                    if stability_flags.get(&name).copied().unwrap_or(i64::MAX) > stability {
+                        continue;
+                    }
+                    stability_flags.insert(name, stability);
+                    matched = true;
+                }
+            }
+
+            if matched {
+                continue;
+            }
+
+            for constraint in &constraints {
+                let req_version_stripped =
+                    Preg::replace(r"^([^,\s@]+) as .+$", "$1", constraint).unwrap_or_default();
+                if Preg::is_match(r"^[^,\s@]+$", &req_version_stripped).unwrap_or(false) {
+                    let stability_name = VersionParser::parse_stability(&req_version_stripped);
+                    if stability_name != "stable" {
+                        let name = strtolower(req_name);
+                        let stability = stabilities[stability_name];
+                        if stability_flags.get(&name).copied().unwrap_or(i64::MAX) > stability
+                            || minimum_stability_val > stability
+                        {
+                            continue;
+                        }
+                        stability_flags.insert(name, stability);
+                    }
+                }
+            }
+        }
+
+        stability_flags
+    }
+
+    pub fn extract_references(
+        requires: &IndexMap<String, String>,
+        mut references: IndexMap<String, String>,
+    ) -> IndexMap<String, String> {
+        for (req_name, req_version) in requires {
+            let req_version =
+                Preg::replace(r"^([^,\s@]+) as .+$", "$1", req_version).unwrap_or_default();
+            if let Some(Some(m)) =
+                Preg::is_match_strict_groups(r"^[^,\s@]+?#([a-f0-9]+)$", &req_version).ok()
+            {
+                if VersionParser::parse_stability(&req_version) == "dev" {
+                    let name = strtolower(req_name);
+                    references.insert(name, m[1].clone());
+                }
+            }
+        }
+        references
+    }
+}