diff options
| -rw-r--r-- | crates/shirabe/src/factory.rs | 1430 |
1 files changed, 1430 insertions, 0 deletions
diff --git a/crates/shirabe/src/factory.rs b/crates/shirabe/src/factory.rs index fcbf24d..6411027 100644 --- a/crates/shirabe/src/factory.rs +++ b/crates/shirabe/src/factory.rs @@ -1 +1,1431 @@ //! ref: composer/src/Composer/Factory.php + +use indexmap::IndexMap; + +use shirabe_external_packages::symfony::component::console::formatter::output_formatter::OutputFormatter; +use shirabe_external_packages::symfony::component::console::formatter::output_formatter_style::OutputFormatterStyle; +use shirabe_external_packages::symfony::component::console::output::console_output::ConsoleOutput; +use shirabe_php_shim::{ + array_keys, array_replace_recursive, class_exists, dirname, extension_loaded, file_exists, + file_get_contents, file_put_contents, implode, in_array, is_array, is_dir, is_file, is_string, + json_decode, pathinfo, realpath, str_replace, strpos, strtr, substr, trim, InvalidArgumentException, + Phar, PhpMixed, RuntimeException, UnexpectedValueException, ZipArchive, PATHINFO_EXTENSION, + PHP_EOL, +}; + +use crate::autoload::autoload_generator::AutoloadGenerator; +use crate::composer::Composer; +use crate::config::Config; +use crate::config::json_config_source::JsonConfigSource; +use crate::downloader::download_manager::DownloadManager; +use crate::downloader::file_downloader::FileDownloader; +use crate::downloader::fossil_downloader::FossilDownloader; +use crate::downloader::git_downloader::GitDownloader; +use crate::downloader::gzip_downloader::GzipDownloader; +use crate::downloader::hg_downloader::HgDownloader; +use crate::downloader::path_downloader::PathDownloader; +use crate::downloader::perforce_downloader::PerforceDownloader; +use crate::downloader::phar_downloader::PharDownloader; +use crate::downloader::rar_downloader::RarDownloader; +use crate::downloader::svn_downloader::SvnDownloader; +use crate::downloader::tar_downloader::TarDownloader; +use crate::downloader::transport_exception::TransportException; +use crate::downloader::xz_downloader::XzDownloader; +use crate::downloader::zip_downloader::ZipDownloader; +use crate::event_dispatcher::event::Event; +use crate::event_dispatcher::event_dispatcher::EventDispatcher; +use crate::exception::no_ssl_exception::NoSslException; +use crate::installer::binary_installer::BinaryInstaller; +use crate::installer::installation_manager::InstallationManager; +use crate::installer::library_installer::LibraryInstaller; +use crate::installer::metapackage_installer::MetapackageInstaller; +use crate::installer::plugin_installer::PluginInstaller; +use crate::io::io_interface::IOInterface; +use crate::json::json_file::JsonFile; +use crate::json::json_validation_exception::JsonValidationException; +use crate::package::archiver::archive_manager::ArchiveManager; +use crate::package::archiver::phar_archiver::PharArchiver; +use crate::package::archiver::zip_archiver::ZipArchiver; +use crate::package::locker::Locker; +use crate::package::loader::root_package_loader::RootPackageLoader; +use crate::package::root_package_interface::RootPackageInterface; +use crate::package::version::version_guesser::VersionGuesser; +use crate::package::version::version_parser::VersionParser; +use crate::partial_composer::PartialComposer; +use crate::plugin::plugin_events::PluginEvents; +use crate::plugin::plugin_manager::PluginManager; +use crate::repository::filesystem_repository::FilesystemRepository; +use crate::repository::installed_filesystem_repository::InstalledFilesystemRepository; +use crate::repository::installed_repository_interface::InstalledRepositoryInterface; +use crate::repository::repository_factory::RepositoryFactory; +use crate::repository::repository_manager::RepositoryManager; +use crate::util::cache::Cache; +use crate::util::filesystem::Filesystem; +use crate::util::http_downloader::HttpDownloader; +use crate::util::r#loop::Loop; +use crate::util::platform::Platform; +use crate::util::process_executor::ProcessExecutor; +use crate::util::silencer::Silencer; + +/// Either a configuration array or a filename to read from. PHP's `$localConfig` accepts both. +pub enum LocalConfigInput { + Path(String), + Data(IndexMap<String, PhpMixed>), +} + +/// PHP's `$disablePlugins` accepts `bool|'local'|'global'`. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum DisablePlugins { + None, + All, + Local, + Global, +} + +impl DisablePlugins { + fn is_disabled_at_all(self) -> bool { + !matches!(self, DisablePlugins::None) + } +} + +/// Creates a configured instance of composer. +pub struct Factory; + +impl Factory { + fn get_home_dir() -> anyhow::Result<String> { + let home = Platform::get_env("COMPOSER_HOME"); + if let Some(h) = home { + if !h.is_empty() { + return Ok(h); + } + } + + if Platform::is_windows() { + if Platform::get_env("APPDATA").map(|s| s.is_empty()).unwrap_or(true) { + return Err(anyhow::anyhow!(RuntimeException { + message: + "The APPDATA or COMPOSER_HOME environment variable must be set for composer to run correctly" + .to_string(), + code: 0, + })); + } + + let appdata = Platform::get_env("APPDATA").unwrap_or_default(); + return Ok(format!( + "{}/Composer", + trim(&strtr(&appdata, "\\", "/"), "/") + )); + } + + let user_dir = Self::get_user_dir()?; + let mut dirs: Vec<String> = Vec::new(); + + if Self::use_xdg() { + // XDG Base Directory Specifications + let mut xdg_config = Platform::get_env("XDG_CONFIG_HOME").unwrap_or_default(); + if xdg_config.is_empty() { + xdg_config = format!("{}/.config", user_dir); + } + + dirs.push(format!("{}/composer", xdg_config)); + } + + dirs.push(format!("{}/.composer", user_dir)); + + // select first dir which exists of: $XDG_CONFIG_HOME/composer or ~/.composer + for dir in &dirs { + let dir_copy = dir.clone(); + let exists = Silencer::call(|| Ok::<bool, anyhow::Error>(is_dir(&dir_copy))) + .unwrap_or(false); + if exists { + return Ok(dir.clone()); + } + } + + // if none exists, we default to first defined one (XDG one if system uses it, or ~/.composer otherwise) + Ok(dirs[0].clone()) + } + + fn get_cache_dir(home: &str) -> anyhow::Result<String> { + let cache_dir = Platform::get_env("COMPOSER_CACHE_DIR").unwrap_or_default(); + if !cache_dir.is_empty() { + return Ok(cache_dir); + } + + let home_env = Platform::get_env("COMPOSER_HOME").unwrap_or_default(); + if !home_env.is_empty() { + return Ok(format!("{}/cache", home_env)); + } + + if Platform::is_windows() { + let mut cache_dir = Platform::get_env("LOCALAPPDATA").unwrap_or_default(); + if !cache_dir.is_empty() { + cache_dir = format!("{}/Composer", cache_dir); + } else { + cache_dir = format!("{}/cache", home); + } + + return Ok(trim(&strtr(&cache_dir, "\\", "/"), "/")); + } + + let user_dir = Self::get_user_dir()?; + if Platform::php_os() == "Darwin" { + // Migrate existing cache dir in old location if present + if is_dir(&format!("{}/cache", home)) + && !is_dir(&format!("{}/Library/Caches/composer", user_dir)) + { + let from = format!("{}/cache", home); + let to = format!("{}/Library/Caches/composer", user_dir); + let _ = Silencer::call(|| { + Ok::<bool, anyhow::Error>(Platform::rename(&from, &to)) + }); + } + + return Ok(format!("{}/Library/Caches/composer", user_dir)); + } + + if home == format!("{}/.composer", user_dir).as_str() + && is_dir(&format!("{}/cache", home)) + { + return Ok(format!("{}/cache", home)); + } + + if Self::use_xdg() { + let xdg_cache = Platform::get_env("XDG_CACHE_HOME").unwrap_or_default(); + let xdg_cache = if xdg_cache.is_empty() { + format!("{}/.cache", user_dir) + } else { + xdg_cache + }; + + return Ok(format!("{}/composer", xdg_cache)); + } + + Ok(format!("{}/cache", home)) + } + + fn get_data_dir(home: &str) -> anyhow::Result<String> { + let home_env = Platform::get_env("COMPOSER_HOME").unwrap_or_default(); + if !home_env.is_empty() { + return Ok(home_env); + } + + if Platform::is_windows() { + return Ok(strtr(home, "\\", "/")); + } + + let user_dir = Self::get_user_dir()?; + if home != format!("{}/.composer", user_dir) && Self::use_xdg() { + let xdg_data = Platform::get_env("XDG_DATA_HOME").unwrap_or_default(); + let xdg_data = if xdg_data.is_empty() { + format!("{}/.local/share", user_dir) + } else { + xdg_data + }; + + return Ok(format!("{}/composer", xdg_data)); + } + + Ok(home.to_string()) + } + + pub fn create_config(io: Option<&dyn IOInterface>, cwd: Option<&str>) -> anyhow::Result<Config> { + let cwd = cwd.map(|s| s.to_string()).unwrap_or_else(|| Platform::get_cwd(true)); + + let mut config = Config::new(true, cwd); + + // determine and add main dirs to the config + let home = Self::get_home_dir()?; + let mut defaults: IndexMap<String, PhpMixed> = IndexMap::new(); + let mut inner: IndexMap<String, PhpMixed> = IndexMap::new(); + inner.insert("home".to_string(), PhpMixed::String(home.clone())); + inner.insert( + "cache-dir".to_string(), + PhpMixed::String(Self::get_cache_dir(&home)?), + ); + inner.insert( + "data-dir".to_string(), + PhpMixed::String(Self::get_data_dir(&home)?), + ); + defaults.insert( + "config".to_string(), + PhpMixed::Array(inner.into_iter().map(|(k, v)| (k, Box::new(v))).collect()), + ); + config.merge(defaults, Config::SOURCE_DEFAULT); + + // load global config + let file = JsonFile::new(format!("{}/config.json", config.get_str("home")?), None, io); + if file.exists() { + if let Some(io_ref) = io { + io_ref.write_error( + PhpMixed::String(format!("Loading config file {}", file.get_path())), + true, + <dyn IOInterface>::DEBUG, + ); + } + Self::validate_json_schema(io, ValidateJsonInput::File(file.clone()), JsonFile::LAX_SCHEMA, None)?; + config.merge(file.read()?, file.get_path().to_string()); + } + config.set_config_source(JsonConfigSource::new(file.clone(), false)); + + let htaccess_protect = config + .get("htaccess-protect") + .and_then(|v| v.as_bool()) + .unwrap_or(false); + if htaccess_protect { + // Protect directory against web access. Since HOME could be + // the www-data's user home and be web-accessible it is a + // potential security risk + let dirs = [ + config.get_str("home")?, + config.get_str("cache-dir")?, + config.get_str("data-dir")?, + ]; + for dir in &dirs { + if !file_exists(&format!("{}/.htaccess", dir)) { + if !is_dir(dir) { + let dir_owned = dir.clone(); + let _ = Silencer::call(|| { + Ok::<bool, anyhow::Error>(Platform::mkdir(&dir_owned, 0o777, true)) + }); + } + let path = format!("{}/.htaccess", dir); + let _ = Silencer::call(|| { + Ok::<Option<i64>, anyhow::Error>(file_put_contents(&path, b"Deny from all")) + }); + } + } + } + + // load global auth file + let auth_file = JsonFile::new( + format!("{}/auth.json", config.get_str("home")?), + None, + io, + ); + if auth_file.exists() { + if let Some(io_ref) = io { + io_ref.write_error( + PhpMixed::String(format!("Loading config file {}", auth_file.get_path())), + true, + <dyn IOInterface>::DEBUG, + ); + } + Self::validate_json_schema( + io, + ValidateJsonInput::File(auth_file.clone()), + JsonFile::AUTH_SCHEMA, + None, + )?; + let mut wrapped: IndexMap<String, PhpMixed> = IndexMap::new(); + wrapped.insert("config".to_string(), PhpMixed::Array(auth_file.read()? + .into_iter().map(|(k, v)| (k, Box::new(v))).collect())); + config.merge(wrapped, auth_file.get_path().to_string()); + } + config.set_auth_config_source(JsonConfigSource::new(auth_file, true)); + + Self::load_composer_auth_env(&mut config, io)?; + + Ok(config) + } + + pub fn get_composer_file() -> anyhow::Result<String> { + let env = Platform::get_env("COMPOSER"); + if let Some(env_str) = env { + let env_trimmed = trim(&env_str, " \t\n\r\0\u{0B}"); + if env_trimmed != "" { + if is_dir(&env_trimmed) { + return Err(anyhow::anyhow!(RuntimeException { + message: format!( + "The COMPOSER environment variable is set to {} which is a directory, this variable should point to a composer.json or be left unset.", + env_trimmed + ), + code: 0, + })); + } + + return Ok(env_trimmed); + } + } + + Ok("./composer.json".to_string()) + } + + pub fn get_lock_file(composer_file: &str) -> String { + let ext = pathinfo(PhpMixed::String(composer_file.to_string()), PATHINFO_EXTENSION); + let is_json = match ext { + PhpMixed::String(s) => s == "json", + _ => false, + }; + if is_json { + format!("{}lock", substr(composer_file, 0, Some(composer_file.len() as i64 - 4))) + } else { + format!("{}.lock", composer_file) + } + } + + pub fn create_additional_styles() -> IndexMap<String, OutputFormatterStyle> { + let mut styles: IndexMap<String, OutputFormatterStyle> = IndexMap::new(); + styles.insert( + "highlight".to_string(), + OutputFormatterStyle::new(Some("red".to_string()), None, Vec::new()), + ); + styles.insert( + "warning".to_string(), + OutputFormatterStyle::new(Some("black".to_string()), Some("yellow".to_string()), Vec::new()), + ); + styles + } + + pub fn create_output() -> ConsoleOutput { + let styles = Self::create_additional_styles(); + let formatter = OutputFormatter::new(false, styles); + + ConsoleOutput::new_with_formatter(ConsoleOutput::VERBOSITY_NORMAL, None, formatter) + } + + /// Creates a Composer instance + pub fn create_composer( + &self, + io: &dyn IOInterface, + local_config: Option<LocalConfigInput>, + disable_plugins: DisablePlugins, + cwd: Option<&str>, + full_load: bool, + disable_scripts: bool, + ) -> anyhow::Result<PartialComposerOrComposer> { + // if a custom composer.json path is given, we change the default cwd to be that file's directory + let mut local_config = local_config; + let mut cwd = cwd.map(|s| s.to_string()); + if let Some(LocalConfigInput::Path(ref s)) = local_config { + if is_file(s) && cwd.is_none() { + cwd = Some(dirname(s)); + } + } + + let cwd = cwd.unwrap_or_else(|| Platform::get_cwd(true)); + + // load Composer configuration + if local_config.is_none() { + local_config = Some(LocalConfigInput::Path(Self::get_composer_file()?)); + } + + let mut local_config_source = Config::SOURCE_UNKNOWN.to_string(); + let mut composer_file: Option<String> = None; + let mut local_config_data: IndexMap<String, PhpMixed> = IndexMap::new(); + if let Some(LocalConfigInput::Path(path)) = &local_config { + composer_file = Some(path.clone()); + + let file = JsonFile::new(path.clone(), None, Some(io)); + + if !file.exists() { + let message = if path == "./composer.json" || path == "composer.json" { + format!("Composer could not find a composer.json file in {}", cwd) + } else { + format!("Composer could not find the config file: {}", path) + }; + let instructions = if full_load { + "To initialize a project, please create a composer.json file. See https://getcomposer.org/basic-usage" + } else { + "" + }; + return Err(anyhow::anyhow!(InvalidArgumentException { + message: format!("{}{}{}", message, PHP_EOL, instructions), + code: 0, + })); + } + + if !Platform::is_input_completion_process() { + if let Err(e) = file.validate_schema(JsonFile::LAX_SCHEMA) { + if let Some(jve) = e.downcast_ref::<JsonValidationException>() { + let errors = + format!(" - {}", implode(&format!("{} - ", PHP_EOL), jve.get_errors())); + let message = + format!("{}:{}{}", jve.get_message(), PHP_EOL, errors); + return Err(anyhow::anyhow!(JsonValidationException::new( + message, + jve.get_errors().clone(), + ))); + } + return Err(e); + } + } + + local_config_data = file.read()?; + local_config_source = file.get_path().to_string(); + } else if let Some(LocalConfigInput::Data(data)) = local_config { + local_config_data = data; + } + + // Load config and override with local config/auth config + let mut config = Self::create_config(Some(io), Some(&cwd))?; + let is_global = local_config_source != Config::SOURCE_UNKNOWN + && realpath(&config.get_str("home")?) == realpath(&dirname(&local_config_source)); + config.merge(local_config_data.clone(), local_config_source.clone()); + + if let Some(ref composer_file_path) = composer_file { + io.write_error( + PhpMixed::String(format!( + "Loading config file {} ({})", + composer_file_path, + realpath(composer_file_path).unwrap_or_default() + )), + true, + <dyn IOInterface>::DEBUG, + ); + config.set_config_source(JsonConfigSource::new( + JsonFile::new(realpath(composer_file_path).unwrap_or_default(), None, Some(io)), + false, + )); + + let local_auth_file = JsonFile::new( + format!( + "{}/auth.json", + dirname(&realpath(composer_file_path).unwrap_or_default()) + ), + None, + Some(io), + ); + if local_auth_file.exists() { + io.write_error( + PhpMixed::String(format!( + "Loading config file {}", + local_auth_file.get_path() + )), + true, + <dyn IOInterface>::DEBUG, + ); + Self::validate_json_schema( + Some(io), + ValidateJsonInput::File(local_auth_file.clone()), + JsonFile::AUTH_SCHEMA, + None, + )?; + let mut wrapped: IndexMap<String, PhpMixed> = IndexMap::new(); + wrapped.insert( + "config".to_string(), + PhpMixed::Array( + local_auth_file + .read()? + .into_iter() + .map(|(k, v)| (k, Box::new(v))) + .collect(), + ), + ); + config.merge(wrapped, local_auth_file.get_path().to_string()); + config.set_local_auth_config_source(JsonConfigSource::new(local_auth_file, true)); + } + } + + // make sure we load the auth env again over the local auth.json + composer.json config + Self::load_composer_auth_env(&mut config, Some(io))?; + + let vendor_dir = config.get_str("vendor-dir")?; + + // initialize composer + let mut composer: PartialComposerOrComposer = if full_load { + PartialComposerOrComposer::Full(Composer::new()) + } else { + PartialComposerOrComposer::Partial(PartialComposer::default()) + }; + composer.set_config(config.clone()); + if is_global { + composer.set_global(); + } + + if full_load { + // load auth configs into the IO instance + io.load_configuration(&config); + + // load existing Composer\InstalledVersions instance if available and scripts/plugins are allowed, as they might need it + // we only load if the InstalledVersions class wasn't defined yet so that this is only loaded once + let installed_versions_path = + format!("{}/composer/installed.php", config.get_str("vendor-dir")?); + if !disable_plugins.is_disabled_at_all() + && !disable_scripts + && !class_exists("Composer\\InstalledVersions") + && file_exists(&installed_versions_path) + { + // force loading the class at this point so it is loaded from the composer phar and not from the vendor dir + // as we cannot guarantee integrity of that file + if class_exists("Composer\\InstalledVersions") { + FilesystemRepository::safely_load_installed_versions(&installed_versions_path); + } + } + } + + let http_downloader = Self::create_http_downloader(io, &config, IndexMap::new())?; + let process = ProcessExecutor::new(io); + let r#loop = Loop::new(http_downloader.clone(), process.clone()); + composer.set_loop(r#loop.clone()); + + // initialize event dispatcher + let mut dispatcher = EventDispatcher::new( + composer.as_partial(), + io.clone_box(), + Some(process.clone()), + ); + dispatcher.set_run_scripts(!disable_scripts); + composer.set_event_dispatcher(dispatcher.clone()); + + // initialize repository manager + let rm = RepositoryFactory::manager( + io, + &config, + &http_downloader, + &dispatcher, + &process, + )?; + composer.set_repository_manager(rm.clone()); + + // force-set the version of the global package if not defined as + // guessing it adds no value and only takes time + if !full_load && !local_config_data.contains_key("version") { + local_config_data.insert( + "version".to_string(), + PhpMixed::String("1.0.0".to_string()), + ); + } + + // load package + let parser = VersionParser::new(); + let guesser = VersionGuesser::new(&config, process.clone(), parser.clone()); + let mut loader = self.load_root_package(rm.clone(), config.clone(), parser, guesser, io.clone_box()); + let package = loader.load( + local_config_data + .iter() + .map(|(k, v)| (k.clone(), Box::new(v.clone()))) + .collect(), + "Composer\\Package\\RootPackage", + Some(&cwd), + )?; + composer.set_package(package); + + // load local repository + self.add_local_repository(io, rm.clone(), &vendor_dir, composer.get_package(), Some(&process)); + + // initialize installation manager + let im = self.create_installation_manager(r#loop.clone(), io.clone_box(), Some(dispatcher.clone())); + composer.set_installation_manager(im.clone()); + + if let PartialComposerOrComposer::Full(ref mut composer_full) = composer { + // initialize download manager + let dm = self.create_download_manager(io, &config, &http_downloader, &process, Some(&dispatcher))?; + composer_full.set_download_manager(dm.clone()); + + // initialize autoload generator + let generator = AutoloadGenerator::new(&dispatcher, io.clone_box()); + composer_full.set_autoload_generator(generator); + + // initialize archive manager + let am = self.create_archive_manager(&config, &dm, &r#loop)?; + composer_full.set_archive_manager(am); + } + + // add installers to the manager (must happen after download manager is created since they read it out of $composer) + self.create_default_installers(&im, &composer, io, Some(&process)); + + // init locker if possible + if let PartialComposerOrComposer::Full(ref mut composer_full) = composer { + if let Some(ref composer_file_path) = composer_file { + let lock_file = Self::get_lock_file(composer_file_path); + let lock_enabled = + config.get("lock").and_then(|v| v.as_bool()).unwrap_or(true); + if !lock_enabled && file_exists(&lock_file) { + io.write_error( + PhpMixed::String(format!( + "<warning>{} is present but ignored as the \"lock\" config option is disabled.</warning>", + lock_file + )), + true, + <dyn IOInterface>::NORMAL, + ); + } + + let locker = Locker::new( + io.clone_box(), + JsonFile::new( + if lock_enabled { + lock_file + } else { + Platform::get_dev_null() + }, + None, + Some(io), + ), + im.clone(), + file_get_contents(composer_file_path).unwrap_or_default(), + process.clone(), + ); + composer_full.set_locker(locker); + } else { + let locker = Locker::new( + io.clone_box(), + JsonFile::new(Platform::get_dev_null(), None, Some(io)), + im.clone(), + JsonFile::encode(&PhpMixed::Array( + local_config_data + .iter() + .map(|(k, v)| (k.clone(), Box::new(v.clone()))) + .collect(), + )), + process.clone(), + ); + composer_full.set_locker(locker); + } + } + + if let PartialComposerOrComposer::Full(ref mut composer_full) = composer { + let mut global_composer: Option<PartialComposer> = None; + if !composer_full.is_global() { + global_composer = self.create_global_composer( + io, + &config, + disable_plugins, + disable_scripts, + false, + ); + } + + let mut pm = self.create_plugin_manager(io, composer_full, global_composer.as_ref(), disable_plugins); + composer_full.set_plugin_manager(pm.clone()); + + if composer_full.is_global() { + pm.set_running_in_global_dir(true); + } + + pm.load_installed_plugins(); + } + + if full_load { + let init_event = Event::from_name(PluginEvents::INIT.to_string()); + composer + .get_event_dispatcher_mut() + .dispatch(Some(init_event.get_name()), Some(init_event))?; + + // once everything is initialized we can + // purge packages from local repos if they have been deleted on the filesystem + self.purge_packages(rm.get_local_repository(), &im); + } + + Ok(composer) + } + + pub fn create_global( + io: &dyn IOInterface, + disable_plugins: DisablePlugins, + disable_scripts: bool, + ) -> Option<Composer> { + let factory = Self; + + let config = Self::create_config(Some(io), None).ok()?; + factory + .create_global_composer(io, &config, disable_plugins, disable_scripts, true) + .and_then(|pc| match pc { + _ => None, // TODO(phase-b): downcast PartialComposer to Composer when fullLoad=true + }) + } + + fn add_local_repository( + &self, + io: &dyn IOInterface, + mut rm: RepositoryManager, + vendor_dir: &str, + root_package: &dyn RootPackageInterface, + process: Option<&ProcessExecutor>, + ) { + let fs = process.map(|p| Filesystem::new(Some(p.clone()))); + + rm.set_local_repository(Box::new(InstalledFilesystemRepository::new( + JsonFile::new( + format!("{}/composer/installed.json", vendor_dir), + None, + Some(io), + ), + true, + root_package.clone_box(), + fs, + ))); + } + + fn create_global_composer( + &self, + io: &dyn IOInterface, + config: &Config, + disable_plugins: DisablePlugins, + disable_scripts: bool, + full_load: bool, + ) -> Option<PartialComposer> { + // make sure if disable plugins was 'local' it is now turned off + let disable_plugins = if matches!(disable_plugins, DisablePlugins::Global | DisablePlugins::All) { + DisablePlugins::All + } else { + DisablePlugins::None + }; + + let composer = match self.create_composer( + io, + Some(LocalConfigInput::Path(format!( + "{}/composer.json", + config.get_str("home").ok()? + ))), + disable_plugins, + Some(&config.get_str("home").ok()?), + full_load, + disable_scripts, + ) { + Ok(c) => Some(c.into_partial()), + Err(e) => { + io.write_error( + PhpMixed::String(format!( + "Failed to initialize global composer: {}", + e + )), + true, + <dyn IOInterface>::DEBUG, + ); + None + } + }; + + composer + } + + pub fn create_download_manager( + &self, + io: &dyn IOInterface, + config: &Config, + http_downloader: &HttpDownloader, + process: &ProcessExecutor, + event_dispatcher: Option<&EventDispatcher>, + ) -> anyhow::Result<DownloadManager> { + let mut cache: Option<Cache> = None; + if config + .get("cache-files-ttl") + .and_then(|v| v.as_int()) + .unwrap_or(0) + > 0 + { + let mut c = Cache::new(io, &config.get_str("cache-files-dir")?, "a-z0-9_./"); + c.set_read_only( + config + .get("cache-read-only") + .and_then(|v| v.as_bool()) + .unwrap_or(false), + ); + cache = Some(c); + } + + let fs = Filesystem::new(Some(process.clone())); + + let mut dm = DownloadManager::new(io.clone_box(), false, fs.clone()); + let preferred = config.get("preferred-install").cloned(); + match preferred.as_ref().and_then(|v| v.as_string()) { + Some("dist") => { + dm.set_prefer_dist(true); + } + Some("source") => { + dm.set_prefer_source(true); + } + Some("auto") | _ => { + // noop + } + } + + if let Some(PhpMixed::Array(prefs)) = preferred { + dm.set_preferences( + prefs + .into_iter() + .map(|(k, v)| { + ( + k, + match *v { + PhpMixed::String(s) => s, + _ => String::new(), + }, + ) + }) + .collect(), + ); + } + + dm.set_downloader( + "git", + Box::new(GitDownloader::new(io.clone_box(), config.clone(), process.clone(), fs.clone())), + ); + dm.set_downloader( + "svn", + Box::new(SvnDownloader::new(io.clone_box(), config.clone(), process.clone(), fs.clone())), + ); + dm.set_downloader( + "fossil", + Box::new(FossilDownloader::new(io.clone_box(), config.clone(), process.clone(), fs.clone())), + ); + dm.set_downloader( + "hg", + Box::new(HgDownloader::new(io.clone_box(), config.clone(), process.clone(), fs.clone())), + ); + dm.set_downloader( + "perforce", + Box::new(PerforceDownloader::new(io.clone_box(), config.clone(), process.clone(), fs.clone())), + ); + dm.set_downloader( + "zip", + Box::new(ZipDownloader::new( + io.clone_box(), + config.clone(), + http_downloader.clone(), + event_dispatcher.cloned(), + cache.clone(), + fs.clone(), + process.clone(), + )), + ); + dm.set_downloader( + "rar", + Box::new(RarDownloader::new( + io.clone_box(), + config.clone(), + http_downloader.clone(), + event_dispatcher.cloned(), + cache.clone(), + fs.clone(), + process.clone(), + )), + ); + dm.set_downloader( + "tar", + Box::new(TarDownloader::new( + io.clone_box(), + config.clone(), + http_downloader.clone(), + event_dispatcher.cloned(), + cache.clone(), + fs.clone(), + process.clone(), + )), + ); + dm.set_downloader( + "gzip", + Box::new(GzipDownloader::new( + io.clone_box(), + config.clone(), + http_downloader.clone(), + event_dispatcher.cloned(), + cache.clone(), + fs.clone(), + process.clone(), + )), + ); + dm.set_downloader( + "xz", + Box::new(XzDownloader::new( + io.clone_box(), + config.clone(), + http_downloader.clone(), + event_dispatcher.cloned(), + cache.clone(), + fs.clone(), + process.clone(), + )), + ); + dm.set_downloader( + "phar", + Box::new(PharDownloader::new( + io.clone_box(), + config.clone(), + http_downloader.clone(), + event_dispatcher.cloned(), + cache.clone(), + fs.clone(), + process.clone(), + )), + ); + dm.set_downloader( + "file", + Box::new(FileDownloader::new( + io.clone_box(), + config.clone(), + http_downloader.clone(), + event_dispatcher.cloned(), + cache.clone(), + fs.clone(), + process.clone(), + )), + ); + dm.set_downloader( + "path", + Box::new(PathDownloader::new( + io.clone_box(), + config.clone(), + http_downloader.clone(), + event_dispatcher.cloned(), + cache.clone(), + fs.clone(), + process.clone(), + )), + ); + + Ok(dm) + } + + pub fn create_archive_manager( + &self, + _config: &Config, + dm: &DownloadManager, + r#loop: &Loop, + ) -> anyhow::Result<ArchiveManager> { + let mut am = ArchiveManager::new(dm.clone(), r#loop.clone()); + if class_exists("ZipArchive") { + am.add_archiver(Box::new(ZipArchiver::new())); + } + if class_exists("Phar") { + am.add_archiver(Box::new(PharArchiver::new())); + } + + Ok(am) + } + + fn create_plugin_manager( + &self, + io: &dyn IOInterface, + composer: &Composer, + global_composer: Option<&PartialComposer>, + disable_plugins: DisablePlugins, + ) -> PluginManager { + PluginManager::new(io.clone_box(), composer.clone(), global_composer.cloned(), disable_plugins) + } + + pub fn create_installation_manager( + &self, + r#loop: Loop, + io: Box<dyn IOInterface>, + event_dispatcher: Option<EventDispatcher>, + ) -> InstallationManager { + InstallationManager::new(r#loop, io, event_dispatcher) + } + + fn create_default_installers( + &self, + im: &InstallationManager, + composer: &PartialComposerOrComposer, + io: &dyn IOInterface, + process: Option<&ProcessExecutor>, + ) { + let fs = Filesystem::new(process.cloned()); + let bin_dir = trim( + &composer + .get_config() + .get_str("bin-dir") + .unwrap_or_default(), + "/", + ); + let bin_compat = composer + .get_config() + .get_str("bin-compat") + .unwrap_or_default(); + let vendor_dir = trim( + &composer + .get_config() + .get_str("vendor-dir") + .unwrap_or_default(), + "/", + ); + let binary_installer = BinaryInstaller::new( + io.clone_box(), + bin_dir, + bin_compat, + fs.clone(), + vendor_dir, + ); + + let mut im = im.clone(); + im.add_installer(Box::new(LibraryInstaller::new( + io.clone_box(), + composer.as_partial(), + None, + fs.clone(), + binary_installer.clone(), + ))); + im.add_installer(Box::new(PluginInstaller::new( + io.clone_box(), + composer.as_partial(), + fs.clone(), + binary_installer.clone(), + ))); + im.add_installer(Box::new(MetapackageInstaller::new(io.clone_box()))); + } + + fn purge_packages( + &self, + repo: &dyn InstalledRepositoryInterface, + im: &InstallationManager, + ) { + for package in repo.get_packages() { + if !im.is_package_installed(repo, package.as_ref()) { + // TODO(phase-b): mutable access on repo trait object + let _ = package; + } + } + } + + fn load_root_package( + &self, + rm: RepositoryManager, + config: Config, + parser: VersionParser, + guesser: VersionGuesser, + io: Box<dyn IOInterface>, + ) -> RootPackageLoader { + RootPackageLoader::new(rm, config, Some(parser), Some(guesser), Some(io)) + } + + pub fn create( + io: &dyn IOInterface, + config: Option<LocalConfigInput>, + disable_plugins: DisablePlugins, + disable_scripts: bool, + ) -> anyhow::Result<Composer> { + let factory = Self; + + // for BC reasons, if a config is passed in either as array or a path that is not the default composer.json path + // we disable local plugins as they really should not be loaded from CWD + // If you want to avoid this behavior, you should be calling createComposer directly with a $cwd arg set correctly + // to the path where the composer.json being loaded resides + let default_composer_file = Self::get_composer_file()?; + let config_is_default = matches!( + config.as_ref(), + Some(LocalConfigInput::Path(p)) if *p == default_composer_file + ); + let disable_plugins = if config.is_some() + && !config_is_default + && matches!(disable_plugins, DisablePlugins::None) + { + DisablePlugins::Local + } else { + disable_plugins + }; + + match factory.create_composer(io, config, disable_plugins, None, true, disable_scripts)? { + PartialComposerOrComposer::Full(c) => Ok(c), + PartialComposerOrComposer::Partial(_) => { + // TODO(phase-b): unreachable when fullLoad=true; downcasting needs design. + Err(anyhow::anyhow!(RuntimeException { + message: "Composer expected with fullLoad=true".to_string(), + code: 0, + })) + } + } + } + + /// If you are calling this in a plugin, you probably should instead use `$composer->getLoop()->getHttpDownloader()` + pub fn create_http_downloader( + io: &dyn IOInterface, + config: &Config, + options: IndexMap<String, PhpMixed>, + ) -> anyhow::Result<HttpDownloader> { + // TODO(plugin): static `$warned` flag — port as a OnceCell or atomic in Phase B. + static mut WARNED: bool = false; + let mut disable_tls = false; + // allow running the config command if disable-tls is in the arg list, even if openssl is missing, to allow disabling it via the config command + let argv = Platform::server_argv().unwrap_or_default(); + if !argv.is_empty() + && argv.contains(&"disable-tls".to_string()) + && (argv.contains(&"conf".to_string()) || argv.contains(&"config".to_string())) + { + unsafe { WARNED = true }; + disable_tls = !extension_loaded("openssl"); + } else if config + .get("disable-tls") + .and_then(|v| v.as_bool()) + .unwrap_or(false) + { + if !unsafe { WARNED } { + io.write_error( + PhpMixed::String( + "<warning>You are running Composer with SSL/TLS protection disabled.</warning>" + .to_string(), + ), + true, + <dyn IOInterface>::NORMAL, + ); + } + unsafe { WARNED = true }; + disable_tls = true; + } else if !extension_loaded("openssl") { + return Err(anyhow::anyhow!(NoSslException(RuntimeException { + message: + "The openssl extension is required for SSL/TLS protection but is not available. If you can not enable the openssl extension, you can disable this error, at your own risk, by setting the 'disable-tls' option to true." + .to_string(), + code: 0, + }))); + } + let mut http_downloader_options: IndexMap<String, PhpMixed> = IndexMap::new(); + if !disable_tls { + if "" != config.get_str("cafile").unwrap_or_default() { + let mut ssl_map: IndexMap<String, PhpMixed> = IndexMap::new(); + ssl_map.insert( + "cafile".to_string(), + PhpMixed::String(config.get_str("cafile").unwrap_or_default()), + ); + http_downloader_options.insert( + "ssl".to_string(), + PhpMixed::Array(ssl_map.into_iter().map(|(k, v)| (k, Box::new(v))).collect()), + ); + } + if "" != config.get_str("capath").unwrap_or_default() { + let existing_ssl = http_downloader_options + .get("ssl") + .and_then(|v| v.as_array()) + .cloned() + .unwrap_or_default(); + let mut ssl_map: IndexMap<String, Box<PhpMixed>> = existing_ssl; + ssl_map.insert( + "capath".to_string(), + Box::new(PhpMixed::String(config.get_str("capath").unwrap_or_default())), + ); + http_downloader_options.insert("ssl".to_string(), PhpMixed::Array(ssl_map)); + } + http_downloader_options = + array_replace_recursive(http_downloader_options, options.clone()); + } + let http_downloader = match HttpDownloader::new_full(io.clone_box(), config.clone(), http_downloader_options, disable_tls) { + Ok(h) => h, + Err(e) => { + if let Some(te) = e.downcast_ref::<TransportException>() { + if strpos(&te.get_message(), "cafile").is_some() { + io.write( + PhpMixed::String( + "<error>Unable to locate a valid CA certificate file. You must set a valid 'cafile' option.</error>" + .to_string(), + ), + true, + <dyn IOInterface>::NORMAL, + ); + io.write( + PhpMixed::String( + "<error>A valid CA certificate file is required for SSL/TLS protection.</error>" + .to_string(), + ), + true, + <dyn IOInterface>::NORMAL, + ); + io.write( + PhpMixed::String( + "<error>You can disable this error, at your own risk, by setting the 'disable-tls' option to true.</error>" + .to_string(), + ), + true, + <dyn IOInterface>::NORMAL, + ); + } + } + return Err(e); + } + }; + + Ok(http_downloader) + } + + fn load_composer_auth_env( + config: &mut Config, + io: Option<&dyn IOInterface>, + ) -> anyhow::Result<()> { + let composer_auth_env = Platform::get_env("COMPOSER_AUTH"); + let composer_auth_env_str = match composer_auth_env { + Some(s) if !s.is_empty() => s, + _ => return Ok(()), + }; + + let auth_data = json_decode(&composer_auth_env_str, false)?; + if matches!(auth_data, PhpMixed::Null) { + return Err(anyhow::anyhow!(UnexpectedValueException { + message: + "COMPOSER_AUTH environment variable is malformed, should be a valid JSON object" + .to_string(), + code: 0, + })); + } + + if let Some(io_ref) = io { + io_ref.write_error( + PhpMixed::String("Loading auth config from COMPOSER_AUTH".to_string()), + true, + <dyn IOInterface>::DEBUG, + ); + } + Self::validate_json_schema( + io, + ValidateJsonInput::Data(auth_data.clone()), + JsonFile::AUTH_SCHEMA, + Some("COMPOSER_AUTH"), + )?; + let auth_data_assoc = json_decode(&composer_auth_env_str, true)?; + if !matches!(auth_data_assoc, PhpMixed::Null) { + let mut wrapped: IndexMap<String, PhpMixed> = IndexMap::new(); + wrapped.insert("config".to_string(), auth_data_assoc); + config.merge(wrapped, "COMPOSER_AUTH".to_string()); + } + Ok(()) + } + + fn use_xdg() -> bool { + for key in array_keys(&Platform::server_env()) { + if strpos(&key, "XDG_") == Some(0) { + return true; + } + } + + Silencer::call(|| Ok::<bool, anyhow::Error>(is_dir("/etc/xdg"))).unwrap_or(false) + } + + fn get_user_dir() -> anyhow::Result<String> { + let home = Platform::get_env("HOME").unwrap_or_default(); + if home.is_empty() { + return Err(anyhow::anyhow!(RuntimeException { + message: + "The HOME or COMPOSER_HOME environment variable must be set for composer to run correctly" + .to_string(), + code: 0, + })); + } + + Ok(trim(&strtr(&home, "\\", "/"), "/")) + } + + fn validate_json_schema( + io: Option<&dyn IOInterface>, + file_or_data: ValidateJsonInput, + schema: i64, + source: Option<&str>, + ) -> anyhow::Result<()> { + if Platform::is_input_completion_process() { + return Ok(()); + } + + let result = match file_or_data { + ValidateJsonInput::File(file) => file.validate_schema(schema), + ValidateJsonInput::Data(data) => { + let source = source.ok_or_else(|| { + anyhow::anyhow!(InvalidArgumentException { + message: + "$source is required to be provided if $fileOrData is arbitrary data" + .to_string(), + code: 0, + }) + })?; + JsonFile::validate_json_schema(source, &data, schema) + } + }; + + if let Err(e) = result { + if let Some(jve) = e.downcast_ref::<JsonValidationException>() { + let msg = format!( + "{}, this may result in errors and should be resolved:{} - {}", + jve.get_message(), + PHP_EOL, + implode(&format!("{} - ", PHP_EOL), jve.get_errors()) + ); + if let Some(io_ref) = io { + io_ref.write_error( + PhpMixed::String(format!("<warning>{}</>", msg)), + true, + <dyn IOInterface>::NORMAL, + ); + } else { + return Err(anyhow::anyhow!(UnexpectedValueException { message: msg, code: 0 })); + } + } else { + return Err(e); + } + } + Ok(()) + } +} + +enum ValidateJsonInput { + File(JsonFile), + Data(PhpMixed), +} + +/// `Factory::createComposer` returns either a `Composer` (`$fullLoad=true`) or a `PartialComposer`. +pub enum PartialComposerOrComposer { + Full(Composer), + Partial(PartialComposer), +} + +impl PartialComposerOrComposer { + fn set_config(&mut self, config: Config) { + match self { + Self::Full(c) => c.set_config(config), + Self::Partial(p) => p.set_config(config), + } + } + fn set_global(&mut self) { + match self { + Self::Full(c) => c.set_global(), + Self::Partial(p) => p.set_global(), + } + } + fn set_loop(&mut self, r#loop: Loop) { + match self { + Self::Full(c) => c.set_loop(r#loop), + Self::Partial(p) => p.set_loop(r#loop), + } + } + fn set_event_dispatcher(&mut self, dispatcher: EventDispatcher) { + match self { + Self::Full(c) => c.set_event_dispatcher(dispatcher), + Self::Partial(p) => p.set_event_dispatcher(dispatcher), + } + } + fn set_repository_manager(&mut self, rm: RepositoryManager) { + match self { + Self::Full(c) => c.set_repository_manager(rm), + Self::Partial(p) => p.set_repository_manager(rm), + } + } + fn set_installation_manager(&mut self, im: InstallationManager) { + match self { + Self::Full(c) => c.set_installation_manager(im), + Self::Partial(p) => p.set_installation_manager(im), + } + } + fn set_package(&mut self, package: Box<dyn RootPackageInterface>) { + match self { + Self::Full(c) => c.set_package(package), + Self::Partial(p) => p.set_package(package), + } + } + fn get_package(&self) -> &dyn RootPackageInterface { + match self { + Self::Full(c) => c.get_package(), + Self::Partial(p) => p.get_package(), + } + } + fn get_config(&self) -> &Config { + match self { + Self::Full(c) => c.get_config(), + Self::Partial(p) => p.get_config(), + } + } + fn get_event_dispatcher_mut(&mut self) -> &mut EventDispatcher { + match self { + Self::Full(c) => c.get_event_dispatcher_mut(), + Self::Partial(p) => p.get_event_dispatcher_mut(), + } + } + fn as_partial(&self) -> PartialComposer { + // TODO(phase-b): exact clone semantics differ across Composer/PartialComposer. + match self { + Self::Full(_) => PartialComposer::default(), + Self::Partial(p) => p.clone(), + } + } + fn into_partial(self) -> PartialComposer { + match self { + Self::Full(_) => PartialComposer::default(), + Self::Partial(p) => p, + } + } +} |