feat(port): port Bitbucket.php, GitDriver.php, GitHub.php, BumpCommand.php, VersionSelector.php

1 files changed, 369 insertions, 0 deletions

diff --git a/crates/shirabe/src/command/bump_command.rs b/crates/shirabe/src/command/bump_command.rs
index 7199d9d..2787fcc 100644
--- a/crates/shirabe/src/command/bump_command.rs
+++ b/crates/shirabe/src/command/bump_command.rs
@@ -1 +1,370 @@
 //! ref: composer/src/Composer/Command/BumpCommand.php
+
+use anyhow::Result;
+use shirabe_external_packages::composer::pcre::preg::Preg;
+use shirabe_external_packages::symfony::console::input::input_interface::InputInterface;
+use shirabe_external_packages::symfony::console::output::output_interface::OutputInterface;
+use shirabe_php_shim::{file_get_contents, file_put_contents, is_writable, strtolower, PhpMixed};
+
+use crate::command::base_command::BaseCommand;
+use crate::command::completion_trait::CompletionTrait;
+use crate::console::input::input_argument::InputArgument;
+use crate::console::input::input_option::InputOption;
+use crate::factory::Factory;
+use crate::io::io_interface::IOInterface;
+use crate::json::json_file::JsonFile;
+use crate::json::json_manipulator::JsonManipulator;
+use crate::package::alias_package::AliasPackage;
+use crate::package::base_package::BasePackage;
+use crate::package::version::version_bumper::VersionBumper;
+use crate::repository::platform_repository::PlatformRepository;
+use crate::util::filesystem::Filesystem;
+use crate::util::silencer::Silencer;
+
+#[derive(Debug)]
+pub struct BumpCommand {
+    inner: BaseCommand,
+}
+
+impl CompletionTrait for BumpCommand {}
+
+impl BumpCommand {
+    const ERROR_GENERIC: i64 = 1;
+    const ERROR_LOCK_OUTDATED: i64 = 2;
+
+    pub fn configure(&mut self) {
+        let suggest_root_requirement = self.suggest_root_requirement();
+        self.inner
+            .set_name("bump")
+            .set_description("Increases the lower limit of your composer.json requirements to the currently installed versions")
+            .set_definition(vec![
+                InputArgument::new(
+                    "packages",
+                    Some(InputArgument::IS_ARRAY | InputArgument::OPTIONAL),
+                    "Optional package name(s) to restrict which packages are bumped.",
+                    None,
+                    suggest_root_requirement,
+                ),
+                InputOption::new("dev-only", Some(PhpMixed::String("D".to_string())), Some(InputOption::VALUE_NONE), "Only bump requirements in \"require-dev\".", None, vec![]),
+                InputOption::new("no-dev-only", Some(PhpMixed::String("R".to_string())), Some(InputOption::VALUE_NONE), "Only bump requirements in \"require\".", None, vec![]),
+                InputOption::new("dry-run", None, Some(InputOption::VALUE_NONE), "Outputs the packages to bump, but will not execute anything.", None, vec![]),
+            ])
+            .set_help(
+                "The <info>bump</info> command increases the lower limit of your composer.json requirements\n\
+                to the currently installed versions. This helps to ensure your dependencies do not\n\
+                accidentally get downgraded due to some other conflict, and can slightly improve\n\
+                dependency resolution performance as it limits the amount of package versions\n\
+                Composer has to look at.\n\n\
+                Running this blindly on libraries is **NOT** recommended as it will narrow down\n\
+                your allowed dependencies, which may cause dependency hell for your users.\n\
+                Running it with <info>--dev-only</info> on libraries may be fine however as dev requirements\n\
+                are local to the library and do not affect consumers of the package.\n"
+            );
+    }
+
+    pub fn execute(
+        &self,
+        input: &dyn InputInterface,
+        _output: &dyn OutputInterface,
+    ) -> Result<i64> {
+        let packages_filter: Vec<String> = input
+            .get_argument("packages")
+            .as_list()
+            .map(|l| {
+                l.iter()
+                    .filter_map(|v| v.as_string().map(|s| s.to_string()))
+                    .collect()
+            })
+            .unwrap_or_default();
+
+        self.do_bump(
+            self.inner.get_io(),
+            input.get_option("dev-only").as_bool().unwrap_or(false),
+            input.get_option("no-dev-only").as_bool().unwrap_or(false),
+            input.get_option("dry-run").as_bool().unwrap_or(false),
+            packages_filter,
+            "--dev-only".to_string(),
+        )
+    }
+
+    pub fn do_bump(
+        &self,
+        io: &dyn IOInterface,
+        dev_only: bool,
+        no_dev_only: bool,
+        dry_run: bool,
+        packages_filter: Vec<String>,
+        dev_only_flag_hint: String,
+    ) -> Result<i64> {
+        let composer_json_path = Factory::get_composer_file();
+
+        if !Filesystem::is_readable(&composer_json_path) {
+            io.write_error(
+                PhpMixed::String(format!("<error>{} is not readable.</error>", composer_json_path)),
+                true,
+                IOInterface::NORMAL,
+            );
+            return Ok(Self::ERROR_GENERIC);
+        }
+
+        let composer_json = JsonFile::new(composer_json_path.clone());
+        let contents = match file_get_contents(&composer_json.get_path()) {
+            Some(c) => c,
+            None => {
+                io.write_error(
+                    PhpMixed::String(format!(
+                        "<error>{} is not readable.</error>",
+                        composer_json_path
+                    )),
+                    true,
+                    IOInterface::NORMAL,
+                );
+                return Ok(Self::ERROR_GENERIC);
+            }
+        };
+
+        if !is_writable(&composer_json_path)
+            && Silencer::call(|| {
+                file_put_contents(&composer_json_path, contents.as_bytes())
+                    .map(|_| ())
+                    .ok_or_else(|| anyhow::anyhow!("file_put_contents failed"))
+            })
+            .is_err()
+        {
+            io.write_error(
+                PhpMixed::String(format!(
+                    "<error>{} is not writable.</error>",
+                    composer_json_path
+                )),
+                true,
+                IOInterface::NORMAL,
+            );
+            return Ok(Self::ERROR_GENERIC);
+        }
+
+        let composer = self.inner.require_composer()?;
+        let has_lock_file_disabled = !composer.get_config().has("lock")
+            || composer.get_config().get("lock").as_bool().unwrap_or(true);
+        let repo = if !has_lock_file_disabled {
+            composer.get_locker().get_locked_repository(true)?
+        } else if composer.get_locker().is_locked() {
+            if !composer.get_locker().is_fresh() {
+                io.write_error(
+                    PhpMixed::String(
+                        "<error>The lock file is not up to date with the latest changes in composer.json. Run the appropriate `update` to fix that before you use the `bump` command.</error>".to_string(),
+                    ),
+                    true,
+                    IOInterface::NORMAL,
+                );
+                return Ok(Self::ERROR_LOCK_OUTDATED);
+            }
+            composer.get_locker().get_locked_repository(true)?
+        } else {
+            composer.get_repository_manager().get_local_repository()
+        };
+
+        if composer.get_package().get_type() != "project" && !dev_only {
+            io.write_error(
+                PhpMixed::String(
+                    "<warning>Warning: Bumping dependency constraints is not recommended for libraries as it will narrow down your dependencies and may cause problems for your users.</warning>".to_string(),
+                ),
+                true,
+                IOInterface::NORMAL,
+            );
+
+            let contents_data = composer_json.read()?;
+            if !contents_data.contains_key("type") {
+                io.write_error(
+                    PhpMixed::String(
+                        "If your package is not a library, you can explicitly specify the \"type\" by using \"composer config type project\".".to_string(),
+                    ),
+                    true,
+                    IOInterface::NORMAL,
+                );
+                io.write_error(
+                    PhpMixed::String(format!(
+                        "<warning>Alternatively you can use {} to only bump dependencies within \"require-dev\".</warning>",
+                        dev_only_flag_hint
+                    )),
+                    true,
+                    IOInterface::NORMAL,
+                );
+            }
+        }
+
+        let bumper = VersionBumper;
+        let mut tasks = indexmap::IndexMap::new();
+        if !dev_only {
+            tasks.insert("require", composer.get_package().get_requires());
+        }
+        if !no_dev_only {
+            tasks.insert("require-dev", composer.get_package().get_dev_requires());
+        }
+
+        let packages_filter = if !packages_filter.is_empty() {
+            let packages_filter: Vec<String> = packages_filter
+                .iter()
+                .map(|constraint| {
+                    Preg::replace(r"{[:= ].+}", "", constraint.clone())
+                        .unwrap_or_else(|_| constraint.clone())
+                })
+                .collect();
+            let mut unique_lower: Vec<String> = packages_filter
+                .iter()
+                .map(|s| strtolower(s))
+                .collect::<std::collections::HashSet<_>>()
+                .into_iter()
+                .collect();
+            let pattern =
+                BasePackage::package_names_to_regexp(&unique_lower);
+            for (key, reqs) in tasks.iter_mut() {
+                reqs.retain(|pkg_name, _| {
+                    Preg::is_match(&pattern, pkg_name).unwrap_or(false)
+                });
+            }
+            packages_filter
+        } else {
+            packages_filter
+        };
+
+        let mut updates: indexmap::IndexMap<&str, indexmap::IndexMap<String, String>> =
+            indexmap::IndexMap::new();
+        for (key, reqs) in &tasks {
+            for (pkg_name, link) in reqs {
+                if PlatformRepository::is_platform_package(pkg_name) {
+                    continue;
+                }
+                let current_constraint = link.get_pretty_constraint();
+
+                let package_opt = repo.find_package(pkg_name, "*");
+                let package = match package_opt {
+                    None => continue,
+                    Some(p) => p,
+                };
+                let mut package = package;
+                while let Some(alias) = package.as_any().downcast_ref::<AliasPackage>() {
+                    package = alias.get_alias_of();
+                }
+
+                let bumped = bumper
+                    .bump_requirement(link.get_constraint().as_ref(), package.as_ref())?;
+
+                if bumped == current_constraint {
+                    continue;
+                }
+
+                updates
+                    .entry(key)
+                    .or_default()
+                    .insert(pkg_name.clone(), bumped);
+            }
+        }
+
+        if !dry_run && !self.update_file_cleanly(&composer_json, &updates)? {
+            let mut composer_definition = composer_json.read()?;
+            for (key, packages) in &updates {
+                for (package, version) in packages {
+                    composer_definition
+                        .entry(key.to_string())
+                        .or_insert_with(indexmap::IndexMap::new)
+                        .insert(package.clone(), version.clone());
+                }
+            }
+            composer_json.write(composer_definition)?;
+        }
+
+        let change_count: usize = updates.values().map(|m| m.len()).sum();
+        if change_count > 0 {
+            if dry_run {
+                io.write(
+                    PhpMixed::String(format!(
+                        "<info>{} would be updated with:</info>",
+                        composer_json_path
+                    )),
+                    true,
+                    IOInterface::NORMAL,
+                );
+                for (require_type, packages) in &updates {
+                    for (package, version) in packages {
+                        io.write(
+                            PhpMixed::String(format!(
+                                "<info> - {}.{}: {}</info>",
+                                require_type, package, version
+                            )),
+                            true,
+                            IOInterface::NORMAL,
+                        );
+                    }
+                }
+            } else {
+                io.write(
+                    PhpMixed::String(format!(
+                        "<info>{} has been updated ({} changes).</info>",
+                        composer_json_path, change_count
+                    )),
+                    true,
+                    IOInterface::NORMAL,
+                );
+            }
+        } else {
+            io.write(
+                PhpMixed::String(format!(
+                    "<info>No requirements to update in {}.</info>",
+                    composer_json_path
+                )),
+                true,
+                IOInterface::NORMAL,
+            );
+        }
+
+        if !dry_run
+            && composer.get_locker().is_locked()
+            && composer.get_config().get("lock").as_bool().unwrap_or(true)
+            && change_count > 0
+        {
+            composer.get_locker().update_hash(&composer_json)?;
+        }
+
+        if dry_run && change_count > 0 {
+            return Ok(Self::ERROR_GENERIC);
+        }
+
+        Ok(0)
+    }
+
+    fn update_file_cleanly(
+        &self,
+        json: &JsonFile,
+        updates: &indexmap::IndexMap<&str, indexmap::IndexMap<String, String>>,
+    ) -> Result<bool> {
+        let contents = match file_get_contents(&json.get_path()) {
+            Some(c) => c,
+            None => {
+                return Err(shirabe_php_shim::RuntimeException {
+                    message: format!("Unable to read {} contents.", json.get_path()),
+                    code: 0,
+                }
+                .into());
+            }
+        };
+
+        let mut manipulator = JsonManipulator::new(contents)?;
+
+        for (key, packages) in updates {
+            for (package, version) in packages {
+                if !manipulator.add_link(key, package, version)? {
+                    return Ok(false);
+                }
+            }
+        }
+
+        match file_put_contents(&json.get_path(), manipulator.get_contents().as_bytes()) {
+            Some(_) => Ok(true),
+            None => Err(shirabe_php_shim::RuntimeException {
+                message: format!("Unable to write new {} contents.", json.get_path()),
+                code: 0,
+            }
+            .into()),
+        }
+    }
+}