ephemeris_forge_github/plan/

repository.rs

use ephemeris_forge::{FieldDiff, Limitation, NameSet, Report};

use crate::api::model;
use crate::api::request::RepositoryPatch;
use crate::operation::repository::Operation;
use crate::{Live, Repository};

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

/// The repository writes split around the other planners' writes.
pub(super) struct Planned {
    /// Runs before every other write, so an archived repository accepts them.
    pub(super) before: Option<Operation>,
    /// Runs after every other write.
    pub(super) after: Vec<Operation>,
}

pub(super) fn plan(desired: &Repository, state: &Live, report: &mut Report) -> Planned {
    let live = &state.repository;
    let mut diff = FieldDiff::default();
    let mut patch = RepositoryPatch::default();
    compare!(
        diff,
        patch,
        desired,
        live,
        description,
        homepage,
        has_issues,
        has_projects,
        has_wiki,
        has_pull_requests,
        has_discussions,
        pull_request_creation_policy,
        is_template,
        allow_squash_merge,
        allow_merge_commit,
        allow_rebase_merge,
        allow_auto_merge,
        delete_branch_on_merge,
        allow_update_branch,
        web_commit_signoff_required,
    );
    if let Some(visibility) = desired.visibility
        && diff.check(
            "visibility",
            live.visibility == Some(visibility),
            &live.visibility,
            &Some(visibility),
        )
    {
        patch.visibility = Some(visibility);
    }
    if let Some(branch) = &desired.default_branch
        && diff.check(
            "default_branch",
            live.default_branch.as_deref() == Some(branch),
            &live.default_branch,
            &Some(branch),
        )
    {
        patch.default_branch = Some(branch.clone());
    }
    if let Some(forking) = desired.allow_forking {
        if live.allow_forking.is_none() {
            report.limitations.push(Limitation::NotReported {
                field: "allow_forking",
            });
        } else if diff.check(
            "allow_forking",
            live.allow_forking == Some(forking),
            &live.allow_forking,
            &Some(forking),
        ) {
            patch.allow_forking = Some(forking);
        }
    }
    squash_commit(desired, live, &mut diff, &mut patch);
    merge_commit(desired, live, &mut diff, &mut patch);
    let immutable = immutable_releases(desired, state, &mut diff, report);
    let archived = diff.want("archived", desired.archived.as_ref(), &live.archived);
    let current = NameSet::new(live.topics.clone());
    let topics = desired
        .topics
        .clone()
        .map(NameSet::new)
        .and_then(|wanted| diff.want_set("topics", &wanted, Some(&current)))
        .map(NameSet::into_vec);
    diff.record("repository", report);
    let mut after = Vec::new();
    after.extend(topics.map(Operation::ReplaceTopics));
    if !patch.is_empty() {
        after.push(Operation::PatchRepository(patch));
    }
    after.extend(immutable.map(Operation::SetImmutableReleases));
    let before = if archived == Some(false) {
        archived.map(Operation::SetArchived)
    } else {
        after.extend(archived.map(Operation::SetArchived));
        None
    };
    Planned { before, after }
}

fn immutable_releases(
    desired: &Repository,
    state: &Live,
    diff: &mut FieldDiff,
    report: &mut Report,
) -> Option<bool> {
    let wanted = desired.immutable_releases?;
    let Some(live) = state.immutable_releases else {
        report.limitations.push(Limitation::Unavailable {
            field: "immutable_releases",
        });
        return None;
    };
    if live.enforced_by_owner && live.enabled != wanted {
        report.limitations.push(Limitation::EnforcedByOwner {
            field: "immutable_releases",
        });
        return None;
    }
    diff.check(
        "immutable_releases",
        live.enabled == wanted,
        &live.enabled,
        &wanted,
    )
    .then_some(wanted)
}

fn squash_commit(
    desired: &Repository,
    live: &model::Repository,
    diff: &mut FieldDiff,
    patch: &mut RepositoryPatch,
) {
    let title = desired.squash_merge_commit_title.is_some_and(|wanted| {
        diff.check(
            "squash_merge_commit_title",
            live.squash_merge_commit_title == wanted,
            &live.squash_merge_commit_title,
            &wanted,
        )
    });
    let message = desired.squash_merge_commit_message.is_some_and(|wanted| {
        diff.check(
            "squash_merge_commit_message",
            live.squash_merge_commit_message == wanted,
            &live.squash_merge_commit_message,
            &wanted,
        )
    });
    if title || message {
        patch.squash_merge_commit_title = Some(
            desired
                .squash_merge_commit_title
                .unwrap_or(live.squash_merge_commit_title),
        );
        patch.squash_merge_commit_message = Some(
            desired
                .squash_merge_commit_message
                .unwrap_or(live.squash_merge_commit_message),
        );
    }
}

fn merge_commit(
    desired: &Repository,
    live: &model::Repository,
    diff: &mut FieldDiff,
    patch: &mut RepositoryPatch,
) {
    let title = desired.merge_commit_title.is_some_and(|wanted| {
        diff.check(
            "merge_commit_title",
            live.merge_commit_title == wanted,
            &live.merge_commit_title,
            &wanted,
        )
    });
    let message = desired.merge_commit_message.is_some_and(|wanted| {
        diff.check(
            "merge_commit_message",
            live.merge_commit_message == wanted,
            &live.merge_commit_message,
            &wanted,
        )
    });
    if title || message {
        patch.merge_commit_title = Some(
            desired
                .merge_commit_title
                .unwrap_or(live.merge_commit_title),
        );
        patch.merge_commit_message = Some(
            desired
                .merge_commit_message
                .unwrap_or(live.merge_commit_message),
        );
    }
}