ephemeris_forge_forgejo/api/request/

branch_rules.rs

use ephemeris_forge::{FieldDiff, NameSet};
use facet::Facet;

use crate::api::model::BranchProtection;
use crate::{BranchRule, PushAccess};

macro_rules! compare {
    ($diff:ident, $edit:ident, $desired:ident, $live:ident, $($field:ident),+ $(,)?) => {$(
        if let Some(wanted) =
            $diff.want(stringify!($field), &$desired.$field, $live.$field.as_ref())
        {
            $edit.$field = Some(wanted);
        }
    )+};
}

macro_rules! compare_sets {
    ($diff:ident, $edit:ident, $desired:ident, $live:ident, $($field:ident),+ $(,)?) => {$(
        let wanted = NameSet::new($desired.$field.iter().cloned());
        let current = $live.$field.clone().map(NameSet::new);
        if let Some(set) = $diff.want_set(stringify!($field), &wanted, current.as_ref()) {
            $edit.$field = Some(set.into_vec());
        }
    )+};
}

macro_rules! compare_patterns {
    ($diff:ident, $edit:ident, $desired:ident, $live:ident, $($field:ident),+ $(,)?) => {$(
        let wanted = NameSet::new($desired.$field.iter().cloned());
        let current = $live.$field.as_deref().map(NameSet::from_patterns);
        if let Some(set) = $diff.want_set(stringify!($field), &wanted, current.as_ref()) {
            $edit.$field = Some(set.to_patterns());
        }
    )+};
}

/// The managed subset of `EditBranchProtectionOption`.
///
/// Pointers with `omitempty`, so only the differing properties are sent.
#[derive(Clone, Debug, Default, Eq, Facet, PartialEq)]
#[facet(skip_all_unless_truthy)]
pub struct EditBranchProtectionOption {
    /// Whether the protection also applies to repository administrators.
    pub apply_to_admins: Option<bool>,
    /// The teams whose approvals count, when the approvals whitelist is on.
    pub approvals_whitelist_teams: Option<Vec<String>>,
    /// The users whose approvals count, when the approvals whitelist is on.
    pub approvals_whitelist_username: Option<Vec<String>>,
    /// Whether an official code owner review request blocks merging until
    /// resolved.
    pub block_on_official_review_requests: Option<bool>,
    /// Whether merging is blocked while the branch is behind its base.
    pub block_on_outdated_branch: Option<bool>,
    /// Whether a requested change blocks merging until it is resolved.
    pub block_on_rejected_reviews: Option<bool>,
    /// Whether a new commit dismisses existing approvals.
    pub dismiss_stale_approvals: Option<bool>,
    /// Whether only the approvals whitelist counts toward the required
    /// approvals.
    pub enable_approvals_whitelist: Option<bool>,
    /// Whether only the merge whitelist may merge.
    pub enable_merge_whitelist: Option<bool>,
    /// Whether direct pushes to the branch are allowed at all.
    pub enable_push: Option<bool>,
    /// Whether only the push whitelist may push.
    pub enable_push_whitelist: Option<bool>,
    /// Whether status checks must pass before merging.
    pub enable_status_check: Option<bool>,
    /// Whether approvals on an outdated commit stop counting.
    pub ignore_stale_approvals: Option<bool>,
    /// The teams that may merge, when the merge whitelist is on.
    pub merge_whitelist_teams: Option<Vec<String>>,
    /// The users that may merge, when the merge whitelist is on.
    pub merge_whitelist_usernames: Option<Vec<String>>,
    /// Semicolon separated glob patterns for files that only whitelisted
    /// pushers may change.
    pub protected_file_patterns: Option<String>,
    /// Whether deploy keys may push, when the push whitelist is on.
    pub push_whitelist_deploy_keys: Option<bool>,
    /// The teams that may push, when the push whitelist is on.
    pub push_whitelist_teams: Option<Vec<String>>,
    /// The users that may push, when the push whitelist is on.
    pub push_whitelist_usernames: Option<Vec<String>>,
    /// Whether every commit on the branch must be signed.
    pub require_signed_commits: Option<bool>,
    /// The number of approving reviews required before merging.
    pub required_approvals: Option<i64>,
    /// The status check contexts that must report success.
    pub status_check_contexts: Option<Vec<String>>,
    /// Semicolon separated glob patterns for files that any pusher may
    /// change despite the protected patterns.
    pub unprotected_file_patterns: Option<String>,
}

/// The managed subset of `CreateBranchProtectionOption`.
///
/// Every property is plain `bool`, `int64` or `[]string` with no `omitempty`,
/// so Forgejo stores an omitted property as `false`, `0` or empty and still
/// reports success. A differential `POST` would therefore create a rule with
/// protection switched off. Every managed property is sent on every create.
///
/// The deprecated `branch_name` is never sent: `rule_name` supersedes it, and
/// sending both lets the forge pick.
#[derive(Clone, Debug, Eq, Facet, PartialEq)]
#[expect(
    clippy::struct_excessive_bools,
    reason = "this mirrors CreateBranchProtectionOption, whose plain bools are the point"
)]
pub struct CreateBranchProtectionOption {
    /// The rule's name.
    pub rule_name: String,
    /// Whether the protection also applies to repository administrators.
    pub apply_to_admins: bool,
    /// The teams whose approvals count, when the approvals whitelist is on.
    pub approvals_whitelist_teams: Vec<String>,
    /// The users whose approvals count, when the approvals whitelist is on.
    pub approvals_whitelist_username: Vec<String>,
    /// Whether an official code owner review request blocks merging until
    /// resolved.
    pub block_on_official_review_requests: bool,
    /// Whether merging is blocked while the branch is behind its base.
    pub block_on_outdated_branch: bool,
    /// Whether a requested change blocks merging until it is resolved.
    pub block_on_rejected_reviews: bool,
    /// Whether a new commit dismisses existing approvals.
    pub dismiss_stale_approvals: bool,
    /// Whether only the approvals whitelist counts toward the required
    /// approvals.
    pub enable_approvals_whitelist: bool,
    /// Whether only the merge whitelist may merge.
    pub enable_merge_whitelist: bool,
    /// Whether direct pushes to the branch are allowed at all.
    pub enable_push: bool,
    /// Whether only the push whitelist may push.
    pub enable_push_whitelist: bool,
    /// Whether status checks must pass before merging.
    pub enable_status_check: bool,
    /// Whether approvals on an outdated commit stop counting.
    pub ignore_stale_approvals: bool,
    /// The teams that may merge, when the merge whitelist is on.
    pub merge_whitelist_teams: Vec<String>,
    /// The users that may merge, when the merge whitelist is on.
    pub merge_whitelist_usernames: Vec<String>,
    /// Semicolon separated glob patterns for files that only whitelisted
    /// pushers may change.
    pub protected_file_patterns: String,
    /// Whether deploy keys may push, when the push whitelist is on.
    pub push_whitelist_deploy_keys: bool,
    /// The teams that may push, when the push whitelist is on.
    pub push_whitelist_teams: Vec<String>,
    /// The users that may push, when the push whitelist is on.
    pub push_whitelist_usernames: Vec<String>,
    /// Whether every commit on the branch must be signed.
    pub require_signed_commits: bool,
    /// The number of approving reviews required before merging.
    pub required_approvals: i64,
    /// The status check contexts that must report success.
    pub status_check_contexts: Vec<String>,
    /// Semicolon separated glob patterns for files that any pusher may
    /// change despite the protected patterns.
    pub unprotected_file_patterns: String,
}

impl EditBranchProtectionOption {
    /// The body that writes the differences of `desired` from `actual`, with
    /// the comparison of every field.
    #[must_use]
    pub fn between(desired: &BranchRule, actual: &BranchProtection) -> (Self, FieldDiff) {
        let mut diff = FieldDiff::default();
        let mut edit = Self::default();
        compare!(
            diff,
            edit,
            desired,
            actual,
            apply_to_admins,
            block_on_official_review_requests,
            block_on_outdated_branch,
            block_on_rejected_reviews,
            dismiss_stale_approvals,
            enable_approvals_whitelist,
            enable_merge_whitelist,
            enable_status_check,
            ignore_stale_approvals,
            push_whitelist_deploy_keys,
            require_signed_commits,
            required_approvals,
        );
        compare_sets!(
            diff,
            edit,
            desired,
            actual,
            approvals_whitelist_teams,
            approvals_whitelist_username,
            merge_whitelist_teams,
            merge_whitelist_usernames,
            push_whitelist_teams,
            push_whitelist_usernames,
            status_check_contexts,
        );
        compare_patterns!(
            diff,
            edit,
            desired,
            actual,
            protected_file_patterns,
            unprotected_file_patterns,
        );
        let push_differs = diff.check(
            "push",
            actual.push_access() == Some(desired.push),
            &actual.push_access(),
            &desired.push,
        );
        if push_differs || edit.push_whitelist_deploy_keys.is_some() {
            edit.carry_push(desired.push);
        }
        (edit, diff)
    }

    /// Whether the body would carry no property at all.
    #[must_use]
    pub fn is_empty(&self) -> bool {
        *self == Self::default()
    }

    /// Carry both push flags. Forgejo only applies the whitelist and deploy
    /// key flags when `enable_push` is in the same payload.
    pub const fn carry_push(&mut self, push: PushAccess) {
        self.enable_push = Some(push.enables_push());
        self.enable_push_whitelist = Some(push.restricts_to_whitelist());
    }
}

impl CreateBranchProtectionOption {
    /// Build a complete create body from the desired state.
    #[must_use]
    pub fn new(rule_name: &str, desired: &BranchRule) -> Self {
        Self {
            rule_name: rule_name.to_owned(),
            apply_to_admins: desired.apply_to_admins,
            approvals_whitelist_teams: NameSet::new(
                desired.approvals_whitelist_teams.iter().cloned(),
            )
            .into_vec(),
            approvals_whitelist_username: NameSet::new(
                desired.approvals_whitelist_username.iter().cloned(),
            )
            .into_vec(),
            block_on_official_review_requests: desired.block_on_official_review_requests,
            block_on_outdated_branch: desired.block_on_outdated_branch,
            block_on_rejected_reviews: desired.block_on_rejected_reviews,
            dismiss_stale_approvals: desired.dismiss_stale_approvals,
            enable_approvals_whitelist: desired.enable_approvals_whitelist,
            enable_merge_whitelist: desired.enable_merge_whitelist,
            enable_push: desired.push.enables_push(),
            enable_push_whitelist: desired.push.restricts_to_whitelist(),
            enable_status_check: desired.enable_status_check,
            ignore_stale_approvals: desired.ignore_stale_approvals,
            merge_whitelist_teams: NameSet::new(desired.merge_whitelist_teams.iter().cloned())
                .into_vec(),
            merge_whitelist_usernames: NameSet::new(
                desired.merge_whitelist_usernames.iter().cloned(),
            )
            .into_vec(),
            protected_file_patterns: NameSet::new(desired.protected_file_patterns.iter().cloned())
                .to_patterns(),
            push_whitelist_deploy_keys: desired.push_whitelist_deploy_keys,
            push_whitelist_teams: NameSet::new(desired.push_whitelist_teams.iter().cloned())
                .into_vec(),
            push_whitelist_usernames: NameSet::new(
                desired.push_whitelist_usernames.iter().cloned(),
            )
            .into_vec(),
            require_signed_commits: desired.require_signed_commits,
            required_approvals: desired.required_approvals,
            status_check_contexts: desired.contexts().into_vec(),
            unprotected_file_patterns: NameSet::new(
                desired.unprotected_file_patterns.iter().cloned(),
            )
            .to_patterns(),
        }
    }
}