interprex-github 6.1.0

GitHub provider for all Interprex development-platform domains
Documentation
use interprex::{
    ProviderError, Repository, Result, ReviewRequestTarget, ReviewRequestTargetInspection,
    ReviewTarget, ReviewTeam, ReviewTeamId, ReviewTeamKind,
};
use percent_encoding::{NON_ALPHANUMERIC, utf8_percent_encode};
use serde::Deserialize;

use crate::{GithubProvider, client::external, client::is_not_found};

use super::actors::{GithubUser, rest_actor};

const INSPECT_TARGET: &str = "inspect review request target";

#[derive(Deserialize)]
struct GithubTeam {
    node_id: String,
    slug: String,
    name: String,
}

impl GithubProvider {
    pub(super) async fn github_review_request_target(
        &self,
        _repository: &Repository,
        target: &ReviewRequestTarget,
    ) -> Result<ReviewRequestTargetInspection> {
        let observed = match target {
            ReviewRequestTarget::User(login) => {
                self.github_actor(user_lookup_candidates(login)).await?
            }
            ReviewRequestTarget::Bot(login) => {
                self.github_actor(bot_lookup_candidates(login)).await?
            }
            ReviewRequestTarget::Team(identifier) => self.github_team(identifier).await?,
        };
        Ok(
            observed.map_or(ReviewRequestTargetInspection::NotResolvable, |observed| {
                ReviewRequestTargetInspection::from_observation(target, observed)
            }),
        )
    }

    async fn github_actor(&self, candidates: Vec<String>) -> Result<Option<ReviewTarget>> {
        for login in candidates {
            let segment = utf8_percent_encode(&login, NON_ALPHANUMERIC);
            let response: std::result::Result<GithubUser, octocrab::Error> = self
                .user()?
                .get(format!("/users/{segment}"), None::<&()>)
                .await;
            match response {
                Ok(user) => return rest_actor(user).map(ReviewTarget::Actor).map(Some),
                Err(error) if is_not_found(&error) => {}
                Err(error) => return Err(external(INSPECT_TARGET, error)),
            }
        }
        Ok(None)
    }

    async fn github_team(&self, identifier: &str) -> Result<Option<ReviewTarget>> {
        let (organization, slug) = parse_team_identifier(identifier)?;
        let organization = utf8_percent_encode(organization, NON_ALPHANUMERIC);
        let slug = utf8_percent_encode(slug, NON_ALPHANUMERIC);
        let response: std::result::Result<GithubTeam, octocrab::Error> = self
            .user()?
            .get(format!("/orgs/{organization}/teams/{slug}"), None::<&()>)
            .await;
        match response {
            Ok(team) => Ok(Some(ReviewTarget::Team(ReviewTeam {
                id: ReviewTeamId::new(team.node_id).map_err(|error| {
                    ProviderError::Unrepresentable {
                        provider: "github",
                        fact: error.to_string(),
                    }
                })?,
                slug: team.slug,
                name: team.name,
                kind: ReviewTeamKind::Organization,
            }))),
            Err(error) if is_not_found(&error) => Ok(None),
            Err(error) => Err(external(INSPECT_TARGET, error)),
        }
    }
}

fn user_lookup_candidates(login: &str) -> Vec<String> {
    let mut candidates = vec![login.to_owned()];
    if !login.ends_with("[bot]") {
        candidates.push(format!("{login}[bot]"));
    }
    candidates
}

fn bot_lookup_candidates(login: &str) -> Vec<String> {
    match login.strip_suffix("[bot]") {
        Some(stem) => vec![login.to_owned(), stem.to_owned()],
        None => vec![format!("{login}[bot]"), login.to_owned()],
    }
}

fn parse_team_identifier(identifier: &str) -> Result<(&str, &str)> {
    let mut segments = identifier.split('/');
    let organization = segments.next().unwrap_or_default();
    let slug = segments.next().unwrap_or_default();
    if organization.is_empty() || slug.is_empty() || segments.next().is_some() {
        return Err(ProviderError::InvalidInput {
            provider: "github",
            fact: format!(
                "review team target `{identifier}` must have the form organization/team-slug"
            ),
        });
    }
    Ok((organization, slug))
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn candidate_order_preserves_the_requested_lookup_rules() {
        assert_eq!(
            user_lookup_candidates("reviewer"),
            ["reviewer", "reviewer[bot]"]
        );
        assert_eq!(user_lookup_candidates("reviewer[bot]"), ["reviewer[bot]"]);
        assert_eq!(
            bot_lookup_candidates("reviewer"),
            ["reviewer[bot]", "reviewer"]
        );
        assert_eq!(
            bot_lookup_candidates("reviewer[bot]"),
            ["reviewer[bot]", "reviewer"]
        );
    }

    #[test]
    fn team_identifiers_have_two_nonempty_segments() {
        assert_eq!(
            parse_team_identifier("civitas-forge/maintainers").expect("team identifier"),
            ("civitas-forge", "maintainers")
        );
        for invalid in ["maintainers", "/maintainers", "civitas-forge/", "a/b/c"] {
            assert!(matches!(
                parse_team_identifier(invalid),
                Err(ProviderError::InvalidInput { .. })
            ));
        }
    }
}