diff options
Diffstat (limited to 'crates/shirabe')
| -rw-r--r-- | crates/shirabe/src/downloader/git_downloader.rs | 1335 |
1 files changed, 1335 insertions, 0 deletions
diff --git a/crates/shirabe/src/downloader/git_downloader.rs b/crates/shirabe/src/downloader/git_downloader.rs index 2a8d028..6957ba1 100644 --- a/crates/shirabe/src/downloader/git_downloader.rs +++ b/crates/shirabe/src/downloader/git_downloader.rs @@ -1 +1,1336 @@ //! ref: composer/src/Composer/Downloader/GitDownloader.php + +use anyhow::Result; +use indexmap::IndexMap; +use shirabe_external_packages::composer::pcre::preg::Preg; +use shirabe_external_packages::react::promise; +use shirabe_external_packages::react::promise::promise_interface::PromiseInterface; +use shirabe_php_shim::{ + array_map, basename, dirname, implode, in_array, is_dir, preg_quote, realpath, rtrim, sprintf, + strlen, strpos, substr, trim, version_compare, PhpMixed, RuntimeException, +}; + +use crate::cache::Cache; +use crate::config::Config; +use crate::downloader::dvcs_downloader_interface::DvcsDownloaderInterface; +use crate::downloader::vcs_downloader::VcsDownloader; +use crate::io::io_interface::IOInterface; +use crate::package::package_interface::PackageInterface; +use crate::util::filesystem::Filesystem; +use crate::util::git::Git as GitUtil; +use crate::util::platform::Platform; +use crate::util::process_executor::ProcessExecutor; +use crate::util::url::Url; + +#[derive(Debug)] +pub struct GitDownloader { + inner: VcsDownloader, + /// @var array<string, bool> + has_stashed_changes: IndexMap<String, bool>, + /// @var array<string, bool> + has_discarded_changes: IndexMap<String, bool>, + git_util: GitUtil, + /// @var array<int, array<string, bool>> + cached_packages: IndexMap<i64, IndexMap<String, bool>>, +} + +impl GitDownloader { + pub fn new( + io: Box<dyn IOInterface>, + config: Config, + process: Option<ProcessExecutor>, + fs: Option<Filesystem>, + ) -> Self { + let inner = VcsDownloader::new(io, config, process, fs); + let git_util = GitUtil::new( + &*inner.io, + &inner.config, + &inner.process, + &inner.filesystem, + ); + Self { + inner, + has_stashed_changes: IndexMap::new(), + has_discarded_changes: IndexMap::new(), + git_util, + cached_packages: IndexMap::new(), + } + } + + pub(crate) fn do_download( + &mut self, + package: &dyn PackageInterface, + _path: &str, + url: &str, + _prev_package: Option<&dyn PackageInterface>, + ) -> Result<Box<dyn PromiseInterface>> { + // Do not create an extra local cache when repository is already local + if Filesystem::is_local_path(url) { + return Ok(promise::resolve(None)); + } + + GitUtil::clean_env(&self.inner.process); + + let cache_path = format!( + "{}/{}/", + self.inner.config.get("cache-vcs-dir").as_string().unwrap_or(""), + Preg::replace(r"{[^a-z0-9.]}i", "-", Url::sanitize(url.to_string())), + ); + let git_version = GitUtil::get_version(&self.inner.process); + + // --dissociate option is only available since git 2.3.0-rc0 + if git_version.is_some() + && version_compare(git_version.as_deref().unwrap_or(""), "2.3.0-rc0", ">=") + && Cache::is_usable(&cache_path) + { + self.inner.io.write_error( + PhpMixed::String(format!( + " - Syncing <info>{}</info> (<comment>{}</comment>) into cache", + package.get_name(), + package.get_full_pretty_version(), + )), + true, + IOInterface::NORMAL, + ); + self.inner.io.write_error( + PhpMixed::String(sprintf( + " Cloning to cache at %s", + &[PhpMixed::String(cache_path.clone())], + )), + true, + IOInterface::DEBUG, + ); + let r#ref = package.get_source_reference(); + if self.git_util.fetch_ref_or_sync_mirror( + url, + &cache_path, + r#ref.unwrap_or(""), + Some(package.get_pretty_version()), + ) && is_dir(&cache_path) + { + self.cached_packages + .entry(package.get_id()) + .or_insert_with(IndexMap::new) + .insert(r#ref.unwrap_or("").to_string(), true); + } + } else if git_version.is_none() { + return Err(RuntimeException { + message: "git was not found in your PATH, skipping source download".to_string(), + code: 0, + } + .into()); + } + + Ok(promise::resolve(None)) + } + + pub(crate) fn do_install( + &mut self, + package: &dyn PackageInterface, + path: &str, + url: &str, + ) -> Result<Box<dyn PromiseInterface>> { + GitUtil::clean_env(&self.inner.process); + let path = self.normalize_path(path); + let cache_path = format!( + "{}/{}/", + self.inner.config.get("cache-vcs-dir").as_string().unwrap_or(""), + Preg::replace(r"{[^a-z0-9.]}i", "-", Url::sanitize(url.to_string())), + ); + let r#ref = package.get_source_reference().unwrap_or("").to_string(); + + let msg; + let commands: Vec<Vec<String>>; + let has_cached = self + .cached_packages + .get(&package.get_id()) + .and_then(|m| m.get(&r#ref)) + .copied() + .unwrap_or(false); + if has_cached { + msg = format!("Cloning {} from cache", self.get_short_hash(&r#ref)); + + let mut clone_flags: Vec<String> = vec![ + "--dissociate".to_string(), + "--reference".to_string(), + cache_path.clone(), + ]; + let transport_options = package.get_transport_options(); + if let Some(git_opts) = transport_options.get("git").and_then(|v| v.as_array()) { + if let Some(single) = git_opts + .get("single_use_clone") + .and_then(|v| v.as_bool()) + { + if single { + clone_flags = vec![]; + } + } + } + + commands = vec![ + { + let mut base = vec![ + "git".to_string(), + "clone".to_string(), + "--no-checkout".to_string(), + cache_path.clone(), + path.clone(), + ]; + base.extend(clone_flags); + base + }, + vec![ + "git".to_string(), + "remote".to_string(), + "set-url".to_string(), + "origin".to_string(), + "--".to_string(), + "%sanitizedUrl%".to_string(), + ], + vec![ + "git".to_string(), + "remote".to_string(), + "add".to_string(), + "composer".to_string(), + "--".to_string(), + "%sanitizedUrl%".to_string(), + ], + ]; + } else { + msg = format!("Cloning {}", self.get_short_hash(&r#ref)); + commands = vec![ + vec![ + "git".to_string(), + "clone".to_string(), + "--no-checkout".to_string(), + "--".to_string(), + "%url%".to_string(), + path.clone(), + ], + vec![ + "git".to_string(), + "remote".to_string(), + "add".to_string(), + "composer".to_string(), + "--".to_string(), + "%url%".to_string(), + ], + vec![ + "git".to_string(), + "fetch".to_string(), + "composer".to_string(), + ], + vec![ + "git".to_string(), + "remote".to_string(), + "set-url".to_string(), + "origin".to_string(), + "--".to_string(), + "%sanitizedUrl%".to_string(), + ], + vec![ + "git".to_string(), + "remote".to_string(), + "set-url".to_string(), + "composer".to_string(), + "--".to_string(), + "%sanitizedUrl%".to_string(), + ], + ]; + if Platform::get_env("COMPOSER_DISABLE_NETWORK").is_some() { + return Err(RuntimeException { + message: format!( + "The required git reference for {} is not in cache and network is disabled, aborting", + package.get_name(), + ), + code: 0, + } + .into()); + } + } + + self.inner + .io + .write_error(PhpMixed::String(msg), true, IOInterface::NORMAL); + + self.git_util.run_commands(commands, url, &path, true); + + let source_url = package.get_source_url(); + if url != source_url.unwrap_or("") && source_url.is_some() { + self.update_origin_url(&path, source_url.unwrap()); + } else { + self.set_push_url(&path, url); + } + + if let Some(new_ref) = + self.update_to_commit(package, &path, &r#ref, package.get_pretty_version())? + { + if package.get_dist_reference() == package.get_source_reference() { + // TODO(phase-b): set_dist_reference requires &mut PackageInterface + // package.set_dist_reference(Some(new_ref.clone())); + } + // package.set_source_reference(Some(new_ref)); + let _ = new_ref; + } + + Ok(promise::resolve(None)) + } + + pub(crate) fn do_update( + &mut self, + _initial: &dyn PackageInterface, + target: &dyn PackageInterface, + path: &str, + url: &str, + ) -> Result<Box<dyn PromiseInterface>> { + GitUtil::clean_env(&self.inner.process); + let path = self.normalize_path(path); + if !self.has_metadata_repository(&path) { + return Err(RuntimeException { + message: format!( + "The .git directory is missing from {}, see https://getcomposer.org/commit-deps for more information", + path + ), + code: 0, + } + .into()); + } + + let cache_path = format!( + "{}/{}/", + self.inner.config.get("cache-vcs-dir").as_string().unwrap_or(""), + Preg::replace(r"{[^a-z0-9.]}i", "-", Url::sanitize(url.to_string())), + ); + let r#ref = target.get_source_reference().unwrap_or("").to_string(); + + let msg; + let remote_url; + let has_cached = self + .cached_packages + .get(&target.get_id()) + .and_then(|m| m.get(&r#ref)) + .copied() + .unwrap_or(false); + if has_cached { + msg = format!("Checking out {} from cache", self.get_short_hash(&r#ref)); + remote_url = cache_path.clone(); + } else { + msg = format!("Checking out {}", self.get_short_hash(&r#ref)); + remote_url = "%url%".to_string(); + if Platform::get_env("COMPOSER_DISABLE_NETWORK").is_some() { + return Err(RuntimeException { + message: format!( + "The required git reference for {} is not in cache and network is disabled, aborting", + target.get_name(), + ), + code: 0, + } + .into()); + } + } + + self.inner + .io + .write_error(PhpMixed::String(msg), true, IOInterface::NORMAL); + + let mut output = String::new(); + if self.inner.process.execute( + &vec![ + "git".to_string(), + "rev-parse".to_string(), + "--quiet".to_string(), + "--verify".to_string(), + format!("{}^{{commit}}", r#ref), + ], + &mut output, + Some(path.clone()), + ) != 0 + { + let commands = vec![ + vec![ + "git".to_string(), + "remote".to_string(), + "set-url".to_string(), + "composer".to_string(), + "--".to_string(), + remote_url.clone(), + ], + vec![ + "git".to_string(), + "fetch".to_string(), + "composer".to_string(), + ], + vec![ + "git".to_string(), + "fetch".to_string(), + "--tags".to_string(), + "composer".to_string(), + ], + ]; + + self.git_util.run_commands(commands, url, &path, false); + } + + let command = vec![ + "git".to_string(), + "remote".to_string(), + "set-url".to_string(), + "composer".to_string(), + "--".to_string(), + "%sanitizedUrl%".to_string(), + ]; + self.git_util.run_commands(vec![command], url, &path, false); + + if let Some(new_ref) = + self.update_to_commit(target, &path, &r#ref, target.get_pretty_version())? + { + if target.get_dist_reference() == target.get_source_reference() { + // TODO(phase-b): set_dist_reference requires &mut PackageInterface + // target.set_dist_reference(Some(new_ref.clone())); + } + // target.set_source_reference(Some(new_ref)); + let _ = new_ref; + } + + let mut update_origin_url = false; + let mut output = String::new(); + if self.inner.process.execute( + &vec!["git".to_string(), "remote".to_string(), "-v".to_string()], + &mut output, + Some(path.clone()), + ) == 0 + { + let origin_match = Preg::is_match_strict_groups(r"{^origin\s+(?P<url>\S+)}m", &output); + let composer_match = Preg::is_match_strict_groups(r"{^composer\s+(?P<url>\S+)}m", &output); + if let (Some(origin_match), Some(composer_match)) = (origin_match, composer_match) { + let origin_url = origin_match.get("url").cloned().unwrap_or_default(); + let composer_url = composer_match.get("url").cloned().unwrap_or_default(); + if origin_url == composer_url + && Some(composer_url.as_str()) != target.get_source_url() + { + update_origin_url = true; + } + } + } + if update_origin_url && target.get_source_url().is_some() { + self.update_origin_url(&path, target.get_source_url().unwrap()); + } + + Ok(promise::resolve(None)) + } + + pub fn get_local_changes(&self, _package: &dyn PackageInterface, path: &str) -> Option<String> { + GitUtil::clean_env(&self.inner.process); + if !self.has_metadata_repository(path) { + return None; + } + + let command = vec![ + "git".to_string(), + "status".to_string(), + "--porcelain".to_string(), + "--untracked-files=no".to_string(), + ]; + let mut output = String::new(); + if self + .inner + .process + .execute(&command, &mut output, Some(path.to_string())) + != 0 + { + // TODO(phase-b): cannot throw from &self / non-Result fn; bubble error via Result later + panic!( + "{}", + format!( + "Failed to execute {}\n\n{}", + implode(" ", &command), + self.inner.process.get_error_output(), + ) + ); + } + + let output = trim(&output, None); + + if strlen(&output) > 0 { + Some(output) + } else { + None + } + } + + pub fn get_unpushed_changes( + &self, + _package: &dyn PackageInterface, + path: &str, + ) -> Option<String> { + GitUtil::clean_env(&self.inner.process); + let path = self.normalize_path(path); + if !self.has_metadata_repository(&path) { + return None; + } + + let command = vec![ + "git".to_string(), + "show-ref".to_string(), + "--head".to_string(), + "-d".to_string(), + ]; + let mut output = String::new(); + if self + .inner + .process + .execute(&command, &mut output, Some(path.clone())) + != 0 + { + // TODO(phase-b): bubble error via Result later + panic!( + "{}", + format!( + "Failed to execute {}\n\n{}", + implode(" ", &command), + self.inner.process.get_error_output(), + ) + ); + } + + let mut refs = trim(&output, None); + let head_ref = match Preg::is_match_strict_groups(r"{^([a-f0-9]+) HEAD$}mi", &refs) { + Some(m) => m.get(1).cloned().unwrap_or_default(), + // could not match the HEAD for some reason + None => return None, + }; + + let candidate_branches: Vec<String> = match Preg::is_match_all_strict_groups( + &format!("{{^{} refs/heads/(.+)$}}mi", preg_quote(&head_ref, None)), + &refs, + ) { + Some(m) => m.get(1).cloned().unwrap_or_default(), + // not on a branch, we are either on a not-modified tag or some sort of detached head, so skip this + None => return None, + }; + + // use the first match as branch name for now + let mut branch = candidate_branches[0].clone(); + let mut unpushed_changes: Option<String> = None; + let mut branch_not_found_error = false; + + // do two passes, as if we find anything we want to fetch and then re-try + for i in 0..=1 { + let mut remote_branches: Vec<String> = vec![]; + + // try to find matching branch names in remote repos + for candidate in &candidate_branches { + if let Some(m) = Preg::is_match_all_strict_groups( + &format!( + "{{^[a-f0-9]+ refs/remotes/((?:[^/]+)/{})$}}mi", + preg_quote(candidate, None) + ), + &refs, + ) { + let matches: Vec<String> = m.get(1).cloned().unwrap_or_default(); + for match_ in matches { + branch = candidate.clone(); + remote_branches.push(match_); + } + break; + } + } + + // if it doesn't exist, then we assume it is an unpushed branch + // this is bad as we have no reference point to do a diff so we just bail listing + // the branch as being unpushed + if remote_branches.is_empty() { + unpushed_changes = Some(format!( + "Branch {} could not be found on any remote and appears to be unpushed", + branch + )); + branch_not_found_error = true; + } else { + // if first iteration found no remote branch but it has now found some, reset $unpushedChanges + // so we get the real diff output no matter its length + if branch_not_found_error { + unpushed_changes = None; + } + for remote_branch in &remote_branches { + let command = vec![ + "git".to_string(), + "diff".to_string(), + "--name-status".to_string(), + format!("{}...{}", remote_branch, branch), + "--".to_string(), + ]; + let mut output = String::new(); + if self.inner.process.execute( + &command, + &mut output, + Some(path.clone()), + ) != 0 + { + // TODO(phase-b): bubble error via Result later + panic!( + "{}", + format!( + "Failed to execute {}\n\n{}", + implode(" ", &command), + self.inner.process.get_error_output(), + ) + ); + } + + let output = trim(&output, None); + // keep the shortest diff from all remote branches we compare against + if unpushed_changes.is_none() + || strlen(&output) + < strlen(unpushed_changes.as_deref().unwrap_or("")) + { + unpushed_changes = Some(output); + } + } + } + + // first pass and we found unpushed changes, fetch from all remotes to make sure we have up to date + // remotes and then try again as outdated remotes can sometimes cause false-positives + if unpushed_changes.is_some() && i == 0 { + let mut output = String::new(); + self.inner.process.execute( + &vec![ + "git".to_string(), + "fetch".to_string(), + "--all".to_string(), + ], + &mut output, + Some(path.clone()), + ); + + // update list of refs after fetching + let command = vec![ + "git".to_string(), + "show-ref".to_string(), + "--head".to_string(), + "-d".to_string(), + ]; + let mut output = String::new(); + if self + .inner + .process + .execute(&command, &mut output, Some(path.clone())) + != 0 + { + // TODO(phase-b): bubble error via Result later + panic!( + "{}", + format!( + "Failed to execute {}\n\n{}", + implode(" ", &command), + self.inner.process.get_error_output(), + ) + ); + } + refs = trim(&output, None); + } + + // abort after first pass if we didn't find anything + if unpushed_changes.is_none() { + break; + } + } + + unpushed_changes + } + + pub(crate) fn clean_changes( + &mut self, + package: &dyn PackageInterface, + path: &str, + update: bool, + ) -> Result<Box<dyn PromiseInterface>> { + GitUtil::clean_env(&self.inner.process); + let path = self.normalize_path(path); + + let unpushed = self.get_unpushed_changes(package, &path); + if let Some(unpushed) = unpushed.as_deref() { + if self.inner.io.is_interactive() + || self.inner.config.get("discard-changes").as_bool() != Some(true) + { + return Err(RuntimeException { + message: format!( + "Source directory {} has unpushed changes on the current branch: \n{}", + path, unpushed + ), + code: 0, + } + .into()); + } + } + + let changes = match self.get_local_changes(package, &path) { + Some(c) => c, + None => return Ok(promise::resolve(None)), + }; + + if !self.inner.io.is_interactive() { + let discard_changes = self.inner.config.get("discard-changes"); + if discard_changes.as_bool() == Some(true) { + return self.discard_changes(&path); + } + if discard_changes.as_string() == Some("stash") { + if !update { + return self.inner.clean_changes(package, &path, update); + } + + return self.stash_changes(&path); + } + + return self.inner.clean_changes(package, &path, update); + } + + let changes: Vec<String> = array_map( + |elem: &String| format!(" {}", elem), + &Preg::split(r"{\s*\r?\n\s*}", &changes), + ); + self.inner.io.write_error( + PhpMixed::String(format!( + " <error>{} has modified files:</error>", + package.get_pretty_name() + )), + true, + IOInterface::NORMAL, + ); + let slice_end = 10_usize.min(changes.len()); + self.inner.io.write_error( + PhpMixed::List( + changes[..slice_end] + .iter() + .map(|s| Box::new(PhpMixed::String(s.clone()))) + .collect(), + ), + true, + IOInterface::NORMAL, + ); + if (changes.len() as i64) > 10 { + self.inner.io.write_error( + PhpMixed::String(format!( + " <info>{} more files modified, choose \"v\" to view the full list</info>", + changes.len() as i64 - 10 + )), + true, + IOInterface::NORMAL, + ); + } + + 'outer: loop { + let answer = self + .inner + .io + .ask( + format!( + " <info>Discard changes [y,n,v,{}?]?</info> ", + if update { "s," } else { "" } + ), + PhpMixed::String("?".to_string()), + ) + .as_string() + .map(|s| s.to_string()); + let mut do_help = false; + match answer.as_deref() { + Some("y") => { + self.discard_changes(&path)?; + break 'outer; + } + Some("s") => { + if !update { + // goto help; + do_help = true; + } else { + self.stash_changes(&path)?; + break 'outer; + } + } + Some("n") => { + return Err(RuntimeException { + message: "Update aborted".to_string(), + code: 0, + } + .into()); + } + Some("v") => { + self.inner.io.write_error( + PhpMixed::List( + changes + .iter() + .map(|s| Box::new(PhpMixed::String(s.clone()))) + .collect(), + ), + true, + IOInterface::NORMAL, + ); + } + Some("d") => { + self.view_diff(&path); + } + _ => { + // case '?': default: + do_help = true; + } + } + + if do_help { + // help: + self.inner.io.write_error( + PhpMixed::List(vec![ + Box::new(PhpMixed::String(format!( + " y - discard changes and apply the {}", + if update { "update" } else { "uninstall" } + ))), + Box::new(PhpMixed::String(format!( + " n - abort the {} and let you manually clean things up", + if update { "update" } else { "uninstall" } + ))), + Box::new(PhpMixed::String( + " v - view modified files".to_string(), + )), + Box::new(PhpMixed::String( + " d - view local modifications (diff)".to_string(), + )), + ]), + true, + IOInterface::NORMAL, + ); + if update { + self.inner.io.write_error( + PhpMixed::String( + " s - stash changes and try to reapply them after the update" + .to_string(), + ), + true, + IOInterface::NORMAL, + ); + } + self.inner.io.write_error( + PhpMixed::String(" ? - print help".to_string()), + true, + IOInterface::NORMAL, + ); + } + } + + Ok(promise::resolve(None)) + } + + pub(crate) fn reapply_changes(&mut self, path: &str) -> Result<()> { + let path = self.normalize_path(path); + if self + .has_stashed_changes + .get(&path) + .copied() + .unwrap_or(false) + { + self.has_stashed_changes.shift_remove(&path); + self.inner.io.write_error( + PhpMixed::String(" <info>Re-applying stashed changes</info>".to_string()), + true, + IOInterface::NORMAL, + ); + let mut output = String::new(); + if self.inner.process.execute( + &vec![ + "git".to_string(), + "stash".to_string(), + "pop".to_string(), + ], + &mut output, + Some(path.clone()), + ) != 0 + { + return Err(RuntimeException { + message: format!( + "Failed to apply stashed changes:\n\n{}", + self.inner.process.get_error_output() + ), + code: 0, + } + .into()); + } + } + + self.has_discarded_changes.shift_remove(&path); + Ok(()) + } + + /// Updates the given path to the given commit ref + /// + /// @throws \RuntimeException + /// @return null|string if a string is returned, it is the commit reference that was checked out if the original could not be found + pub(crate) fn update_to_commit( + &mut self, + package: &dyn PackageInterface, + path: &str, + reference: &str, + pretty_version: &str, + ) -> Result<Option<String>> { + let force: Vec<String> = if self + .has_discarded_changes + .get(path) + .copied() + .unwrap_or(false) + || self.has_stashed_changes.get(path).copied().unwrap_or(false) + { + vec!["-f".to_string()] + } else { + vec![] + }; + + // This uses the "--" sequence to separate branch from file parameters. + // + // Otherwise git tries the branch name as well as file name. + // If the non-existent branch is actually the name of a file, the file + // is checked out. + + let mut branch = + Preg::replace(r"{(?:^dev-|(?:\.x)?-dev$)}i", "", pretty_version.to_string()); + + // Closure equivalent: $execute = function(array $command) use (&$output, $path) { ... }; + // Inlined below at each call site. + + let mut branches: Option<String> = None; + { + let mut output = String::new(); + if self.inner.process.execute( + &vec!["git".to_string(), "branch".to_string(), "-r".to_string()], + &mut output, + Some(path.to_string()), + ) == 0 + { + branches = Some(output); + } + } + + // check whether non-commitish are branches or tags, and fetch branches with the remote name + let git_ref = reference.to_string(); + if !Preg::is_match(r"{^[a-f0-9]{40}$}", reference).unwrap_or(false) + && branches.is_some() + && Preg::is_match( + &format!( + "{{^\\s+composer/{}$}}m", + preg_quote(reference, None) + ), + branches.as_deref().unwrap_or(""), + ) + .unwrap_or(false) + { + let mut command1: Vec<String> = vec!["git".to_string(), "checkout".to_string()]; + command1.extend(force.clone()); + command1.extend(vec![ + "-B".to_string(), + branch.clone(), + format!("composer/{}", reference), + "--".to_string(), + ]); + let command2 = vec![ + "git".to_string(), + "reset".to_string(), + "--hard".to_string(), + format!("composer/{}", reference), + "--".to_string(), + ]; + + let mut output = String::new(); + let ok1 = self.inner.process.execute( + &command1, + &mut output, + Some(path.to_string()), + ) == 0; + let ok2 = if ok1 { + let mut output = String::new(); + self.inner.process.execute( + &command2, + &mut output, + Some(path.to_string()), + ) == 0 + } else { + false + }; + if ok1 && ok2 { + return Ok(None); + } + } + + // try to checkout branch by name and then reset it so it's on the proper branch name + if Preg::is_match(r"{^[a-f0-9]{40}$}", reference).unwrap_or(false) { + // add 'v' in front of the branch if it was stripped when generating the pretty name + if branches.is_some() + && !Preg::is_match( + &format!( + "{{^\\s+composer/{}$}}m", + preg_quote(&branch, None) + ), + branches.as_deref().unwrap_or(""), + ) + .unwrap_or(false) + && Preg::is_match( + &format!( + "{{^\\s+composer/v{}$}}m", + preg_quote(&branch, None) + ), + branches.as_deref().unwrap_or(""), + ) + .unwrap_or(false) + { + branch = format!("v{}", branch); + } + + let command = vec![ + "git".to_string(), + "checkout".to_string(), + branch.clone(), + "--".to_string(), + ]; + let mut fallback_command: Vec<String> = + vec!["git".to_string(), "checkout".to_string()]; + fallback_command.extend(force.clone()); + fallback_command.extend(vec![ + "-B".to_string(), + branch.clone(), + format!("composer/{}", branch), + "--".to_string(), + ]); + let reset_command = vec![ + "git".to_string(), + "reset".to_string(), + "--hard".to_string(), + reference.to_string(), + "--".to_string(), + ]; + + let mut output = String::new(); + let ok_command = self.inner.process.execute( + &command, + &mut output, + Some(path.to_string()), + ) == 0; + let ok_fallback = if !ok_command { + let mut output = String::new(); + self.inner.process.execute( + &fallback_command, + &mut output, + Some(path.to_string()), + ) == 0 + } else { + false + }; + let ok_reset = if ok_command || ok_fallback { + let mut output = String::new(); + self.inner.process.execute( + &reset_command, + &mut output, + Some(path.to_string()), + ) == 0 + } else { + false + }; + if (ok_command || ok_fallback) && ok_reset { + return Ok(None); + } + } + + let mut command1: Vec<String> = vec!["git".to_string(), "checkout".to_string()]; + command1.extend(force.clone()); + command1.extend(vec![git_ref.clone(), "--".to_string()]); + let command2 = vec![ + "git".to_string(), + "reset".to_string(), + "--hard".to_string(), + git_ref.clone(), + "--".to_string(), + ]; + { + let mut output = String::new(); + let ok1 = self.inner.process.execute( + &command1, + &mut output, + Some(path.to_string()), + ) == 0; + let ok2 = if ok1 { + let mut output = String::new(); + self.inner.process.execute( + &command2, + &mut output, + Some(path.to_string()), + ) == 0 + } else { + false + }; + if ok1 && ok2 { + return Ok(None); + } + } + + let mut exception_extra = String::new(); + + // reference was not found (prints "fatal: reference is not a tree: $ref") + if strpos(self.inner.process.get_error_output(), reference).is_some() { + self.inner.io.write_error( + PhpMixed::String(format!( + " <warning>{} is gone (history was rewritten?)</warning>", + reference + )), + true, + IOInterface::NORMAL, + ); + exception_extra = format!( + "\nIt looks like the commit hash is not available in the repository, maybe {}? Run \"composer update {}\" to resolve this.", + if package.is_dev() { + "the commit was removed from the branch" + } else { + "the tag was recreated" + }, + package.get_pretty_name(), + ); + } + + let command = format!("{} && {}", implode(" ", &command1), implode(" ", &command2)); + + Err(RuntimeException { + message: Url::sanitize(format!( + "Failed to execute {}\n\n{}{}", + command, + self.inner.process.get_error_output(), + exception_extra, + )), + code: 0, + } + .into()) + } + + pub(crate) fn update_origin_url(&mut self, path: &str, url: &str) { + let mut output = String::new(); + self.inner.process.execute( + &vec![ + "git".to_string(), + "remote".to_string(), + "set-url".to_string(), + "origin".to_string(), + "--".to_string(), + url.to_string(), + ], + &mut output, + Some(path.to_string()), + ); + self.set_push_url(path, url); + } + + pub(crate) fn set_push_url(&mut self, path: &str, url: &str) { + // set push url for github projects + if let Some(match_) = Preg::is_match_strict_groups( + &format!( + "{{^(?:https?|git)://{}/([^/]+)/([^/]+?)(?:\\.git)?$}}", + GitUtil::get_github_domains_regex(&self.inner.config) + ), + url, + ) { + let protocols = self.inner.config.get("github-protocols"); + let m1 = match_.get(1).cloned().unwrap_or_default(); + let m2 = match_.get(2).cloned().unwrap_or_default(); + let m3 = match_.get(3).cloned().unwrap_or_default(); + let mut push_url = format!("git@{}:{}/{}.git", m1, m2, m3); + if !in_array(PhpMixed::String("ssh".to_string()), &protocols, true) { + push_url = format!("https://{}/{}/{}.git", m1, m2, m3); + } + let cmd = vec![ + "git".to_string(), + "remote".to_string(), + "set-url".to_string(), + "--push".to_string(), + "origin".to_string(), + "--".to_string(), + push_url, + ]; + let mut ignored_output = String::new(); + self.inner + .process + .execute(&cmd, &mut ignored_output, Some(path.to_string())); + } + } + + pub(crate) fn get_commit_logs( + &mut self, + from_reference: &str, + to_reference: &str, + path: &str, + ) -> Result<String> { + let path = self.normalize_path(path); + let mut args = vec![ + "--format=%h - %an: %s".to_string(), + format!("{}..{}", from_reference, to_reference), + ]; + args.extend(GitUtil::get_no_show_signature_flags(&self.inner.process)); + let command = GitUtil::build_rev_list_command(&self.inner.process, args); + + let mut output = String::new(); + if self + .inner + .process + .execute(&command, &mut output, Some(path.clone())) + != 0 + { + return Err(RuntimeException { + message: format!( + "Failed to execute {}\n\n{}", + implode(" ", &command), + self.inner.process.get_error_output(), + ), + code: 0, + } + .into()); + } + + Ok(GitUtil::parse_rev_list_output(&output, &self.inner.process)) + } + + /// @phpstan-return PromiseInterface<void|null> + /// @throws \RuntimeException + pub(crate) fn discard_changes(&mut self, path: &str) -> Result<Box<dyn PromiseInterface>> { + let path = self.normalize_path(path); + let mut output = String::new(); + if self.inner.process.execute( + &vec![ + "git".to_string(), + "clean".to_string(), + "-df".to_string(), + ], + &mut output, + Some(path.clone()), + ) != 0 + { + return Err(RuntimeException { + message: format!("Could not reset changes\n\n:{}", output), + code: 0, + } + .into()); + } + let mut output = String::new(); + if self.inner.process.execute( + &vec![ + "git".to_string(), + "reset".to_string(), + "--hard".to_string(), + ], + &mut output, + Some(path.clone()), + ) != 0 + { + return Err(RuntimeException { + message: format!("Could not reset changes\n\n:{}", output), + code: 0, + } + .into()); + } + + self.has_discarded_changes.insert(path, true); + + Ok(promise::resolve(None)) + } + + /// @phpstan-return PromiseInterface<void|null> + /// @throws \RuntimeException + pub(crate) fn stash_changes(&mut self, path: &str) -> Result<Box<dyn PromiseInterface>> { + let path = self.normalize_path(path); + let mut output = String::new(); + if self.inner.process.execute( + &vec![ + "git".to_string(), + "stash".to_string(), + "--include-untracked".to_string(), + ], + &mut output, + Some(path.clone()), + ) != 0 + { + return Err(RuntimeException { + message: format!("Could not stash changes\n\n:{}", output), + code: 0, + } + .into()); + } + + self.has_stashed_changes.insert(path, true); + + Ok(promise::resolve(None)) + } + + /// @throws \RuntimeException + pub(crate) fn view_diff(&mut self, path: &str) { + let path = self.normalize_path(path); + let mut output = String::new(); + if self.inner.process.execute( + &vec![ + "git".to_string(), + "diff".to_string(), + "HEAD".to_string(), + ], + &mut output, + Some(path.clone()), + ) != 0 + { + // TODO(phase-b): cannot throw from non-Result fn; bubble error via Result later + panic!("{}", format!("Could not view diff\n\n:{}", output)); + } + + self.inner + .io + .write_error(PhpMixed::String(output), true, IOInterface::NORMAL); + } + + pub(crate) fn normalize_path(&self, path: &str) -> String { + let mut path = path.to_string(); + if Platform::is_windows() && strlen(&path) > 0 { + let mut base_path = path.clone(); + let mut removed: Vec<String> = vec![]; + + while !is_dir(&base_path) && base_path != "\\" { + let mut new_removed = vec![basename(&base_path)]; + new_removed.extend(removed); + removed = new_removed; + base_path = dirname(&base_path); + } + + if base_path == "\\" { + return path; + } + + path = rtrim( + &format!( + "{}/{}", + realpath(&base_path).unwrap_or_default(), + implode("/", &removed), + ), + Some("/"), + ); + } + + path + } + + pub(crate) fn has_metadata_repository(&self, path: &str) -> bool { + let path = self.normalize_path(path); + + is_dir(&format!("{}/.git", path)) + } + + pub(crate) fn get_short_hash(&self, reference: &str) -> String { + if !self.inner.io.is_verbose() + && Preg::is_match(r"{^[0-9a-f]{40}$}", reference).unwrap_or(false) + { + return substr(reference, 0, Some(10)); + } + + reference.to_string() + } +} + +impl DvcsDownloaderInterface for GitDownloader { + fn get_unpushed_changes(&self, package: &dyn PackageInterface, path: String) -> Option<String> { + GitDownloader::get_unpushed_changes(self, package, &path) + } +} + |