feat(port): port GitBitbucketDriver.php

1 files changed, 853 insertions, 0 deletions

diff --git a/crates/shirabe/src/repository/vcs/git_bitbucket_driver.rs b/crates/shirabe/src/repository/vcs/git_bitbucket_driver.rs
index 9eb944f..495b427 100644
--- a/crates/shirabe/src/repository/vcs/git_bitbucket_driver.rs
+++ b/crates/shirabe/src/repository/vcs/git_bitbucket_driver.rs
@@ -1 +1,854 @@
 //! ref: composer/src/Composer/Repository/Vcs/GitBitbucketDriver.php
+
+use anyhow::Result;
+use chrono::{DateTime, Utc};
+use indexmap::IndexMap;
+use shirabe_external_packages::composer::pcre::preg::Preg;
+use shirabe_php_shim::{
+    array_key_exists, array_search_mixed, extension_loaded, http_build_query_mixed, implode,
+    in_array, is_array, sprintf, strpos, InvalidArgumentException, LogicException, PhpMixed,
+    RuntimeException,
+};
+
+use crate::cache::Cache;
+use crate::config::Config;
+use crate::downloader::transport_exception::TransportException;
+use crate::io::io_interface::IOInterface;
+use crate::json::json_file::JsonFile;
+use crate::repository::vcs::git_driver::GitDriver;
+use crate::repository::vcs::vcs_driver::VcsDriver;
+use crate::repository::vcs::vcs_driver_interface::VcsDriverInterface;
+use crate::util::bitbucket::Bitbucket;
+use crate::util::http::response::Response;
+
+#[derive(Debug)]
+pub struct GitBitbucketDriver {
+    pub(crate) inner: VcsDriver,
+    /// @var string
+    pub(crate) owner: String,
+    /// @var string
+    pub(crate) repository: String,
+    /// @var bool
+    has_issues: bool,
+    /// @var ?string
+    root_identifier: Option<String>,
+    /// @var array<int|string, string> Map of tag name to identifier
+    tags: Option<IndexMap<String, String>>,
+    /// @var array<int|string, string> Map of branch name to identifier
+    branches: Option<IndexMap<String, String>>,
+    /// @var string
+    branches_url: String,
+    /// @var string
+    tags_url: String,
+    /// @var string
+    home_url: String,
+    /// @var string
+    website: String,
+    /// @var string
+    clone_https_url: String,
+    /// @var array<string, mixed>
+    repo_data: IndexMap<String, PhpMixed>,
+    /// @var ?VcsDriver
+    pub(crate) fallback_driver: Option<Box<dyn VcsDriverInterface>>,
+    /// @var string|null if set either git or hg
+    vcs_type: Option<String>,
+}
+
+impl GitBitbucketDriver {
+    /// @inheritDoc
+    pub fn initialize(&mut self) -> Result<()> {
+        let matched = Preg::is_match_strict_groups(
+            r"#^https?://bitbucket\.org/([^/]+)/([^/]+?)(?:\.git|/?)?$#i",
+            &self.inner.url,
+        );
+        if matched.is_none() {
+            return Err(InvalidArgumentException {
+                message: sprintf(
+                    "The Bitbucket repository URL %s is invalid. It must be the HTTPS URL of a Bitbucket repository.",
+                    &[PhpMixed::String(self.inner.url.clone())],
+                ),
+                code: 0,
+            }
+            .into());
+        }
+        let m = matched.unwrap();
+
+        self.owner = m.get(1).cloned().unwrap_or_default();
+        self.repository = m.get(2).cloned().unwrap_or_default();
+        self.inner.origin_url = "bitbucket.org".to_string();
+        self.inner.cache = Some(Cache::new(
+            &*self.inner.io,
+            &implode(
+                "/",
+                &[
+                    self.inner
+                        .config
+                        .get("cache-repo-dir")
+                        .as_string()
+                        .unwrap_or("")
+                        .to_string(),
+                    self.inner.origin_url.clone(),
+                    self.owner.clone(),
+                    self.repository.clone(),
+                ],
+            ),
+            None,
+        ));
+        self.inner
+            .cache
+            .as_mut()
+            .unwrap()
+            .set_read_only(self.inner.config.get("cache-read-only").as_bool().unwrap_or(false));
+
+        Ok(())
+    }
+
+    /// @inheritDoc
+    pub fn get_url(&self) -> String {
+        if let Some(fallback) = self.fallback_driver.as_ref() {
+            return fallback.get_url();
+        }
+
+        self.clone_https_url.clone()
+    }
+
+    /// Attempts to fetch the repository data via the BitBucket API and
+    /// sets some parameters which are used in other methods
+    ///
+    /// @phpstan-impure
+    fn get_repo_data(&mut self) -> Result<bool> {
+        let resource = sprintf(
+            "https://api.bitbucket.org/2.0/repositories/%s/%s?%s",
+            &[
+                PhpMixed::String(self.owner.clone()),
+                PhpMixed::String(self.repository.clone()),
+                PhpMixed::String(http_build_query_mixed(
+                    &{
+                        let mut m: IndexMap<String, PhpMixed> = IndexMap::new();
+                        m.insert(
+                            "fields".to_string(),
+                            PhpMixed::String("-project,-owner".to_string()),
+                        );
+                        m
+                    },
+                    "",
+                    "&",
+                )),
+            ],
+        );
+
+        let repo_data = self
+            .fetch_with_oauth_credentials(&resource, true)?
+            .decode_json()?;
+        if self.fallback_driver.is_some() {
+            return Ok(false);
+        }
+        let clone_links = repo_data
+            .get("links")
+            .and_then(|v| match v {
+                PhpMixed::Array(m) => m.get("clone"),
+                _ => None,
+            })
+            .cloned();
+        self.parse_clone_urls(clone_links);
+
+        self.has_issues = !shirabe_php_shim::empty(
+            repo_data.get("has_issues").cloned().as_ref().unwrap_or(&PhpMixed::Null),
+        );
+        self.branches_url = repo_data
+            .get("links")
+            .and_then(|v| match v {
+                PhpMixed::Array(m) => m.get("branches"),
+                _ => None,
+            })
+            .and_then(|v| match v.as_ref() {
+                PhpMixed::Array(m) => m.get("href").and_then(|v| v.as_string()).map(String::from),
+                _ => None,
+            })
+            .unwrap_or_default();
+        self.tags_url = repo_data
+            .get("links")
+            .and_then(|v| match v {
+                PhpMixed::Array(m) => m.get("tags"),
+                _ => None,
+            })
+            .and_then(|v| match v.as_ref() {
+                PhpMixed::Array(m) => m.get("href").and_then(|v| v.as_string()).map(String::from),
+                _ => None,
+            })
+            .unwrap_or_default();
+        self.home_url = repo_data
+            .get("links")
+            .and_then(|v| match v {
+                PhpMixed::Array(m) => m.get("html"),
+                _ => None,
+            })
+            .and_then(|v| match v.as_ref() {
+                PhpMixed::Array(m) => m.get("href").and_then(|v| v.as_string()).map(String::from),
+                _ => None,
+            })
+            .unwrap_or_default();
+        self.website = repo_data
+            .get("website")
+            .and_then(|v| v.as_string())
+            .map(String::from)
+            .unwrap_or_default();
+        self.vcs_type = repo_data
+            .get("scm")
+            .and_then(|v| v.as_string())
+            .map(String::from);
+
+        self.repo_data = repo_data;
+
+        Ok(true)
+    }
+
+    /// @inheritDoc
+    pub fn get_composer_information(
+        &mut self,
+        identifier: &str,
+    ) -> Result<Option<IndexMap<String, PhpMixed>>> {
+        if let Some(fallback) = self.fallback_driver.as_mut() {
+            return fallback.get_composer_information(identifier);
+        }
+
+        if !self.inner.info_cache.contains_key(identifier) {
+            let mut composer: Option<IndexMap<String, PhpMixed>> = None;
+            if self.inner.should_cache(identifier)
+                && {
+                    let res = self
+                        .inner
+                        .cache
+                        .as_ref()
+                        .and_then(|c| c.read(identifier).ok().flatten());
+                    if let Some(res) = res {
+                        composer = Some(JsonFile::parse_json(&res, None)?);
+                        true
+                    } else {
+                        false
+                    }
+                }
+            {
+                // composer already set above
+            } else {
+                composer = self.inner.get_base_composer_information(identifier)?;
+
+                if self.inner.should_cache(identifier) {
+                    self.inner.cache.as_ref().unwrap().write(
+                        identifier,
+                        &JsonFile::encode(
+                            &PhpMixed::Array(
+                                composer
+                                    .clone()
+                                    .unwrap_or_default()
+                                    .into_iter()
+                                    .map(|(k, v)| (k, Box::new(v)))
+                                    .collect(),
+                            ),
+                            shirabe_php_shim::JSON_UNESCAPED_UNICODE
+                                | shirabe_php_shim::JSON_UNESCAPED_SLASHES,
+                            JsonFile::INDENT_DEFAULT,
+                        ),
+                    )?;
+                }
+            }
+
+            if let Some(mut composer_map) = composer.clone() {
+                // specials for bitbucket
+                if composer_map.contains_key("support")
+                    && !is_array(composer_map.get("support").unwrap())
+                {
+                    composer_map.insert(
+                        "support".to_string(),
+                        PhpMixed::Array(IndexMap::new()),
+                    );
+                }
+                let support_has_source = composer_map
+                    .get("support")
+                    .and_then(|v| match v {
+                        PhpMixed::Array(m) => Some(m.contains_key("source")),
+                        _ => None,
+                    })
+                    .unwrap_or(false);
+                if !support_has_source {
+                    let tags = self.get_tags()?;
+                    let branches_for_search = self.get_branches()?;
+                    let label = array_search_mixed(
+                        &PhpMixed::String(identifier.to_string()),
+                        &PhpMixed::Array(
+                            tags.iter()
+                                .map(|(k, v)| (k.clone(), Box::new(PhpMixed::String(v.clone()))))
+                                .collect(),
+                        ),
+                        false,
+                    )
+                    .or_else(|| {
+                        array_search_mixed(
+                            &PhpMixed::String(identifier.to_string()),
+                            &PhpMixed::Array(
+                                branches_for_search
+                                    .iter()
+                                    .map(|(k, v)| {
+                                        (k.clone(), Box::new(PhpMixed::String(v.clone())))
+                                    })
+                                    .collect(),
+                            ),
+                            false,
+                        )
+                    })
+                    .map(|v| v.as_string().unwrap_or("").to_string())
+                    .unwrap_or_else(|| identifier.to_string());
+
+                    let tags2 = self.get_tags()?;
+                    let branches2 = self.get_branches()?;
+                    let mut hash: Option<String> = None;
+                    if array_key_exists(&label, &tags2) {
+                        hash = tags2.get(&label).cloned();
+                    } else if array_key_exists(&label, &branches2) {
+                        hash = branches2.get(&label).cloned();
+                    }
+
+                    let support_entry = composer_map
+                        .entry("support".to_string())
+                        .or_insert(PhpMixed::Array(IndexMap::new()));
+                    if hash.is_none() {
+                        if let PhpMixed::Array(support_map) = support_entry {
+                            support_map.insert(
+                                "source".to_string(),
+                                Box::new(PhpMixed::String(sprintf(
+                                    "https://%s/%s/%s/src",
+                                    &[
+                                        PhpMixed::String(self.inner.origin_url.clone()),
+                                        PhpMixed::String(self.owner.clone()),
+                                        PhpMixed::String(self.repository.clone()),
+                                    ],
+                                ))),
+                            );
+                        }
+                    } else if let PhpMixed::Array(support_map) = support_entry {
+                        support_map.insert(
+                            "source".to_string(),
+                            Box::new(PhpMixed::String(sprintf(
+                                "https://%s/%s/%s/src/%s/?at=%s",
+                                &[
+                                    PhpMixed::String(self.inner.origin_url.clone()),
+                                    PhpMixed::String(self.owner.clone()),
+                                    PhpMixed::String(self.repository.clone()),
+                                    PhpMixed::String(hash.unwrap()),
+                                    PhpMixed::String(label.clone()),
+                                ],
+                            ))),
+                        );
+                    }
+                }
+                let support_has_issues = composer_map
+                    .get("support")
+                    .and_then(|v| match v {
+                        PhpMixed::Array(m) => Some(m.contains_key("issues")),
+                        _ => None,
+                    })
+                    .unwrap_or(false);
+                if !support_has_issues && self.has_issues {
+                    let support_entry = composer_map
+                        .entry("support".to_string())
+                        .or_insert(PhpMixed::Array(IndexMap::new()));
+                    if let PhpMixed::Array(support_map) = support_entry {
+                        support_map.insert(
+                            "issues".to_string(),
+                            Box::new(PhpMixed::String(sprintf(
+                                "https://%s/%s/%s/issues",
+                                &[
+                                    PhpMixed::String(self.inner.origin_url.clone()),
+                                    PhpMixed::String(self.owner.clone()),
+                                    PhpMixed::String(self.repository.clone()),
+                                ],
+                            ))),
+                        );
+                    }
+                }
+                if !composer_map.contains_key("homepage") {
+                    composer_map.insert(
+                        "homepage".to_string(),
+                        if self.website.is_empty() {
+                            PhpMixed::String(self.home_url.clone())
+                        } else {
+                            PhpMixed::String(self.website.clone())
+                        },
+                    );
+                }
+                composer = Some(composer_map);
+            }
+
+            self.inner.info_cache.insert(identifier.to_string(), composer);
+        }
+
+        Ok(self.inner.info_cache.get(identifier).cloned().flatten())
+    }
+
+    /// @inheritDoc
+    pub fn get_file_content(
+        &mut self,
+        file: &str,
+        identifier: &str,
+    ) -> Result<Option<String>> {
+        if let Some(fallback) = self.fallback_driver.as_mut() {
+            return fallback.get_file_content(file, identifier);
+        }
+
+        let mut identifier = identifier.to_string();
+        if strpos(&identifier, "/").is_some() {
+            let branches = self.get_branches()?;
+            if let Some(b) = branches.get(&identifier) {
+                identifier = b.clone();
+            }
+        }
+
+        let resource = sprintf(
+            "https://api.bitbucket.org/2.0/repositories/%s/%s/src/%s/%s",
+            &[
+                PhpMixed::String(self.owner.clone()),
+                PhpMixed::String(self.repository.clone()),
+                PhpMixed::String(identifier),
+                PhpMixed::String(file.to_string()),
+            ],
+        );
+
+        Ok(Some(
+            self.fetch_with_oauth_credentials(&resource, false)?
+                .get_body(),
+        ))
+    }
+
+    /// @inheritDoc
+    pub fn get_change_date(&mut self, identifier: &str) -> Result<Option<DateTime<Utc>>> {
+        if let Some(fallback) = self.fallback_driver.as_mut() {
+            return fallback.get_change_date(identifier);
+        }
+
+        let mut identifier = identifier.to_string();
+        if strpos(&identifier, "/").is_some() {
+            let branches = self.get_branches()?;
+            if let Some(b) = branches.get(&identifier) {
+                identifier = b.clone();
+            }
+        }
+
+        let resource = sprintf(
+            "https://api.bitbucket.org/2.0/repositories/%s/%s/commit/%s?fields=date",
+            &[
+                PhpMixed::String(self.owner.clone()),
+                PhpMixed::String(self.repository.clone()),
+                PhpMixed::String(identifier),
+            ],
+        );
+        let commit = self
+            .fetch_with_oauth_credentials(&resource, false)?
+            .decode_json()?;
+
+        // TODO(phase-b): port PHP `new \DateTimeImmutable($commit['date'])`
+        let date_str = commit
+            .get("date")
+            .and_then(|v| v.as_string())
+            .unwrap_or("");
+        let date: DateTime<Utc> = chrono::DateTime::parse_from_rfc3339(date_str)
+            .map_err(|e| anyhow::anyhow!(e))?
+            .with_timezone(&Utc);
+        Ok(Some(date))
+    }
+
+    /// @inheritDoc
+    pub fn get_source(&self, identifier: &str) -> IndexMap<String, String> {
+        if let Some(fallback) = self.fallback_driver.as_ref() {
+            return fallback.get_source(identifier);
+        }
+
+        let mut m: IndexMap<String, String> = IndexMap::new();
+        m.insert(
+            "type".to_string(),
+            self.vcs_type.clone().unwrap_or_default(),
+        );
+        m.insert("url".to_string(), self.get_url());
+        m.insert("reference".to_string(), identifier.to_string());
+        m
+    }
+
+    /// @inheritDoc
+    pub fn get_dist(&self, identifier: &str) -> Option<IndexMap<String, String>> {
+        if let Some(fallback) = self.fallback_driver.as_ref() {
+            return fallback.get_dist(identifier);
+        }
+
+        let url = sprintf(
+            "https://bitbucket.org/%s/%s/get/%s.zip",
+            &[
+                PhpMixed::String(self.owner.clone()),
+                PhpMixed::String(self.repository.clone()),
+                PhpMixed::String(identifier.to_string()),
+            ],
+        );
+
+        let mut m: IndexMap<String, String> = IndexMap::new();
+        m.insert("type".to_string(), "zip".to_string());
+        m.insert("url".to_string(), url);
+        m.insert("reference".to_string(), identifier.to_string());
+        m.insert("shasum".to_string(), String::new());
+        Some(m)
+    }
+
+    /// @inheritDoc
+    pub fn get_tags(&mut self) -> Result<IndexMap<String, String>> {
+        if let Some(fallback) = self.fallback_driver.as_mut() {
+            return fallback.get_tags();
+        }
+
+        if self.tags.is_none() {
+            let mut tags: IndexMap<String, String> = IndexMap::new();
+            let mut resource = sprintf(
+                "%s?%s",
+                &[
+                    PhpMixed::String(self.tags_url.clone()),
+                    PhpMixed::String(http_build_query_mixed(
+                        &{
+                            let mut m: IndexMap<String, PhpMixed> = IndexMap::new();
+                            m.insert("pagelen".to_string(), PhpMixed::Int(100));
+                            m.insert(
+                                "fields".to_string(),
+                                PhpMixed::String(
+                                    "values.name,values.target.hash,next".to_string(),
+                                ),
+                            );
+                            m.insert(
+                                "sort".to_string(),
+                                PhpMixed::String("-target.date".to_string()),
+                            );
+                            m
+                        },
+                        "",
+                        "&",
+                    )),
+                ],
+            );
+            let mut has_next = true;
+            while has_next {
+                let tags_data = self
+                    .fetch_with_oauth_credentials(&resource, false)?
+                    .decode_json()?;
+                let values = tags_data.get("values").cloned();
+                if let Some(PhpMixed::List(list)) = values {
+                    for data in list {
+                        if let PhpMixed::Array(m) = data.as_ref() {
+                            let name = m
+                                .get("name")
+                                .and_then(|v| v.as_string())
+                                .unwrap_or("")
+                                .to_string();
+                            let hash = m
+                                .get("target")
+                                .and_then(|v| match v.as_ref() {
+                                    PhpMixed::Array(m) => m.get("hash"),
+                                    _ => None,
+                                })
+                                .and_then(|v| v.as_string())
+                                .unwrap_or("")
+                                .to_string();
+                            tags.insert(name, hash);
+                        }
+                    }
+                }
+                if shirabe_php_shim::empty(
+                    tags_data.get("next").cloned().as_ref().unwrap_or(&PhpMixed::Null),
+                ) {
+                    has_next = false;
+                } else {
+                    resource = tags_data
+                        .get("next")
+                        .and_then(|v| v.as_string())
+                        .unwrap_or("")
+                        .to_string();
+                }
+            }
+
+            self.tags = Some(tags);
+        }
+
+        Ok(self.tags.clone().unwrap_or_default())
+    }
+
+    /// @inheritDoc
+    pub fn get_branches(&mut self) -> Result<IndexMap<String, String>> {
+        if let Some(fallback) = self.fallback_driver.as_mut() {
+            return fallback.get_branches();
+        }
+
+        if self.branches.is_none() {
+            let mut branches: IndexMap<String, String> = IndexMap::new();
+            let mut resource = sprintf(
+                "%s?%s",
+                &[
+                    PhpMixed::String(self.branches_url.clone()),
+                    PhpMixed::String(http_build_query_mixed(
+                        &{
+                            let mut m: IndexMap<String, PhpMixed> = IndexMap::new();
+                            m.insert("pagelen".to_string(), PhpMixed::Int(100));
+                            m.insert(
+                                "fields".to_string(),
+                                PhpMixed::String(
+                                    "values.name,values.target.hash,values.heads,next"
+                                        .to_string(),
+                                ),
+                            );
+                            m.insert(
+                                "sort".to_string(),
+                                PhpMixed::String("-target.date".to_string()),
+                            );
+                            m
+                        },
+                        "",
+                        "&",
+                    )),
+                ],
+            );
+            let mut has_next = true;
+            while has_next {
+                let branch_data = self
+                    .fetch_with_oauth_credentials(&resource, false)?
+                    .decode_json()?;
+                let values = branch_data.get("values").cloned();
+                if let Some(PhpMixed::List(list)) = values {
+                    for data in list {
+                        if let PhpMixed::Array(m) = data.as_ref() {
+                            let name = m
+                                .get("name")
+                                .and_then(|v| v.as_string())
+                                .unwrap_or("")
+                                .to_string();
+                            let hash = m
+                                .get("target")
+                                .and_then(|v| match v.as_ref() {
+                                    PhpMixed::Array(m) => m.get("hash"),
+                                    _ => None,
+                                })
+                                .and_then(|v| v.as_string())
+                                .unwrap_or("")
+                                .to_string();
+                            branches.insert(name, hash);
+                        }
+                    }
+                }
+                if shirabe_php_shim::empty(
+                    branch_data.get("next").cloned().as_ref().unwrap_or(&PhpMixed::Null),
+                ) {
+                    has_next = false;
+                } else {
+                    resource = branch_data
+                        .get("next")
+                        .and_then(|v| v.as_string())
+                        .unwrap_or("")
+                        .to_string();
+                }
+            }
+
+            self.branches = Some(branches);
+        }
+
+        Ok(self.branches.clone().unwrap_or_default())
+    }
+
+    /// Get the remote content.
+    ///
+    /// @phpstan-impure
+    fn fetch_with_oauth_credentials(
+        &mut self,
+        url: &str,
+        fetching_repo_data: bool,
+    ) -> Result<Response> {
+        match self.inner.get_contents(url, false) {
+            Ok(r) => Ok(r),
+            Err(e) => {
+                // TODO(phase-b): only handle TransportException
+                let bitbucket_util = Bitbucket::new(
+                    &*self.inner.io,
+                    &self.inner.config,
+                    Some(self.inner.process.clone()),
+                    Some(self.inner.http_downloader.clone()),
+                );
+
+                if let Some(te) = e.downcast_ref::<TransportException>() {
+                    let code = te.get_code();
+                    let in_set = in_array(
+                        PhpMixed::Int(code),
+                        &PhpMixed::List(vec![
+                            Box::new(PhpMixed::Int(403)),
+                            Box::new(PhpMixed::Int(404)),
+                        ]),
+                        true,
+                    );
+                    if in_set
+                        || (401 == code && strpos(te.get_message(), "Could not authenticate against") == Some(0))
+                    {
+                        if !self.inner.io.has_authentication(&self.inner.origin_url)
+                            && bitbucket_util.authorize_oauth(&self.inner.origin_url)
+                        {
+                            return self.inner.get_contents(url, false);
+                        }
+
+                        if !self.inner.io.is_interactive() && fetching_repo_data {
+                            self.attempt_clone_fallback()?;
+
+                            let mut headers: IndexMap<String, PhpMixed> = IndexMap::new();
+                            headers.insert(
+                                "url".to_string(),
+                                PhpMixed::String("dummy".to_string()),
+                            );
+                            return Ok(Response::new(headers, 200, IndexMap::new(), "null".to_string()));
+                        }
+                    }
+                }
+
+                Err(e)
+            }
+        }
+    }
+
+    /// Generate an SSH URL
+    fn generate_ssh_url(&self) -> String {
+        format!(
+            "git@{}:{}/{}.git",
+            self.inner.origin_url, self.owner, self.repository
+        )
+    }
+
+    /// @phpstan-impure
+    ///
+    /// @return true
+    /// @throws \RuntimeException
+    fn attempt_clone_fallback(&mut self) -> Result<bool> {
+        match self.setup_fallback_driver(&self.generate_ssh_url()) {
+            Ok(()) => Ok(true),
+            Err(e) => {
+                // TODO(phase-b): only catch RuntimeException
+                self.fallback_driver = None;
+
+                self.inner.io.write_error(&format!(
+                    "<error>Failed to clone the {} repository, try running in interactive mode so that you can enter your Bitbucket OAuth consumer credentials</error>",
+                    self.generate_ssh_url()
+                ));
+                Err(e)
+            }
+        }
+    }
+
+    fn setup_fallback_driver(&mut self, url: &str) -> Result<()> {
+        let mut repo_config: IndexMap<String, PhpMixed> = IndexMap::new();
+        repo_config.insert("url".to_string(), PhpMixed::String(url.to_string()));
+        // TODO(phase-b): construct VcsDriver from repo_config / io / config / etc.
+        let mut driver = GitDriver {
+            inner: todo!("phase-b: build VcsDriver for fallback GitDriver"),
+            tags: None,
+            branches: None,
+            root_identifier: None,
+            repo_dir: String::new(),
+        };
+        driver.initialize()?;
+        self.fallback_driver = Some(Box::new(driver));
+        Ok(())
+    }
+
+    /// @param  array<array{name: string, href: string}> $cloneLinks
+    fn parse_clone_urls(&mut self, clone_links: Option<Box<PhpMixed>>) {
+        let list = match clone_links.as_deref() {
+            Some(PhpMixed::List(l)) => l.clone(),
+            _ => return,
+        };
+        for clone_link in list {
+            if let PhpMixed::Array(m) = clone_link.as_ref() {
+                if m.get("name").and_then(|v| v.as_string()) == Some("https") {
+                    // Format: https://(user@)bitbucket.org/{user}/{repo}
+                    // Strip username from URL (only present in clone URL's for private repositories)
+                    self.clone_https_url = Preg::replace(
+                        r"/https:\/\/([^@]+@)?/",
+                        "https://",
+                        m.get("href").and_then(|v| v.as_string()).unwrap_or(""),
+                    );
+                }
+            }
+        }
+    }
+
+    /// @inheritDoc
+    pub fn get_root_identifier(&mut self) -> Result<String> {
+        if let Some(fallback) = self.fallback_driver.as_mut() {
+            return fallback.get_root_identifier();
+        }
+
+        if self.root_identifier.is_none() {
+            if !self.get_repo_data()? {
+                if self.fallback_driver.is_none() {
+                    return Err(LogicException {
+                        message:
+                            "A fallback driver should be setup if getRepoData returns false"
+                                .to_string(),
+                        code: 0,
+                    }
+                    .into());
+                }
+
+                return self.fallback_driver.as_mut().unwrap().get_root_identifier();
+            }
+
+            if self.vcs_type.as_deref() != Some("git") {
+                return Err(RuntimeException {
+                    message: format!(
+                        "{} does not appear to be a git repository, use {} but remember that Bitbucket no longer supports the mercurial repositories. https://bitbucket.org/blog/sunsetting-mercurial-support-in-bitbucket",
+                        self.inner.url, self.clone_https_url
+                    ),
+                    code: 0,
+                }
+                .into());
+            }
+
+            self.root_identifier = self
+                .repo_data
+                .get("mainbranch")
+                .and_then(|v| match v {
+                    PhpMixed::Array(m) => m.get("name"),
+                    _ => None,
+                })
+                .and_then(|v| v.as_string())
+                .map(String::from)
+                .or_else(|| Some("master".to_string()));
+        }
+
+        Ok(self.root_identifier.clone().unwrap_or_default())
+    }
+
+    /// @inheritDoc
+    pub fn supports(
+        io: &dyn IOInterface,
+        _config: &Config,
+        url: &str,
+        _deep: bool,
+    ) -> bool {
+        if !Preg::is_match(
+            r"#^https?://bitbucket\.org/([^/]+)/([^/]+?)(\.git|/?)?$#i",
+            url,
+        ) {
+            return false;
+        }
+
+        if !extension_loaded("openssl") {
+            io.write_error(
+                &format!(
+                    "Skipping Bitbucket git driver for {} because the OpenSSL PHP extension is missing.",
+                    url
+                ),
+            );
+            // PHP: writeError(..., true, IOInterface::VERBOSE)
+            // TODO(phase-b): IOInterface::VERBOSE verbosity argument
+
+            return false;
+        }
+
+        true
+    }
+}