Skip to main content

ephemeris_forge_github/reconcile/
rulesets.rs

1use ephemeris_forge::{Caller, Mode, RepoRef};
2
3use super::Client;
4use crate::api::{Api, ForgeError};
5use crate::operation::rulesets::Operation;
6use crate::{Live, Rulesets};
7
8impl<A: Api> Client<A> {
9    pub(super) async fn read_rulesets(
10        &self,
11        repository: &RepoRef,
12        config: Option<&Rulesets>,
13        live: &mut Live,
14    ) -> Result<(), ForgeError> {
15        let Some(config) = config else {
16            return Ok(());
17        };
18        if config.mode != Mode::Owned && config.rulesets.is_empty() {
19            return Ok(());
20        }
21        if let Some(name) = config
22            .rulesets
23            .iter()
24            .find_map(|(name, ruleset)| ruleset.bypassed_by_own_app().then_some(name))
25        {
26            let caller = self.read_caller(repository.owner()).await?;
27            if !matches!(
28                caller,
29                Caller::App {
30                    id: _,
31                    slug: _,
32                    admin: _
33                }
34            ) {
35                return Err(ForgeError::OwnAppBypassWithoutApp {
36                    ruleset: name.clone(),
37                });
38            }
39            live.access.caller = Some(caller);
40        }
41        live.rulesets = self.api.rulesets(repository).await?;
42        Ok(())
43    }
44
45    pub(super) async fn apply_rulesets(
46        &self,
47        repository: &RepoRef,
48        operation: &Operation,
49    ) -> Result<(), ForgeError> {
50        match operation {
51            Operation::Create { name, ruleset } => {
52                self.api.create_ruleset(repository, name, ruleset).await
53            }
54            Operation::Update {
55                id,
56                name,
57                ruleset,
58                unmanaged_rules,
59            } => {
60                self.api
61                    .update_ruleset(repository, *id, name, ruleset, unmanaged_rules)
62                    .await
63            }
64            Operation::Delete { id, name: _ } => self.api.delete_ruleset(repository, *id).await,
65        }
66    }
67}