ephemeris_forge_forgejo/plan/

repository.rs

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

use crate::api::model;
use crate::api::request::{self, EditRepoOption};
use crate::operation::repository::Operation;
use crate::{Live, Repository, config};

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

macro_rules! write_unread {
    ($diff:ident, $edit:ident, $desired:ident, $report:ident, $($field:ident),+ $(,)?) => {$(
        if let Some(wanted) = $desired.$field {
            $report.limitations.push(Limitation::WrittenOnEveryApply {
                field: stringify!($field),
            });
            $diff.check(stringify!($field), false, &None::<()>, &wanted);
            $edit.$field = Some(wanted);
        }
    )+};
}

pub(super) fn plan(desired: &Repository, live: &Live, report: &mut Report) -> Vec<Operation> {
    let (edit, topics, diff) = compare_repository(desired, live, report);
    diff.record("repository", report);
    if topics.is_some() || !edit.is_empty() {
        vec![Operation {
            topics,
            edit: Box::new(edit),
        }]
    } else {
        Vec::new()
    }
}

fn compare_repository(
    desired: &Repository,
    live: &Live,
    report: &mut Report,
) -> (EditRepoOption, Option<Vec<String>>, FieldDiff) {
    let actual = &live.repository;
    let mut diff = FieldDiff::default();
    let mut edit = EditRepoOption::default();
    compare!(
        diff,
        edit,
        desired,
        actual,
        allow_fast_forward_only_merge,
        allow_merge_commits,
        allow_rebase,
        allow_rebase_explicit,
        allow_rebase_update,
        allow_squash_merge,
        archived,
        default_allow_maintainer_edit,
        default_branch,
        default_delete_branch_after_merge,
        description,
        globally_editable_wiki,
        has_actions,
        has_issues,
        has_packages,
        has_projects,
        has_pull_requests,
        has_releases,
        has_wiki,
        ignore_whitespace_conflicts,
        private,
        template,
        website,
    );
    if let Some(style) = desired.default_merge_style
        && diff.check(
            "default_merge_style",
            actual.default_merge_style.as_deref() == Some(style.as_str()),
            &actual.default_merge_style,
            &style.as_str(),
        )
    {
        edit.default_merge_style = Some(style.as_str().to_owned());
    }
    if let Some(style) = desired.default_update_style
        && diff.check(
            "default_update_style",
            actual.default_update_style.as_deref() == Some(style.as_str()),
            &actual.default_update_style,
            &style.as_str(),
        )
    {
        edit.default_update_style = Some(style.as_str().to_owned());
    }
    write_unread!(
        diff,
        edit,
        desired,
        report,
        allow_manual_merge,
        autodetect_manual_merge
    );
    compare_wiki(desired, actual, &mut diff, &mut edit, report);
    compare_issues(desired, actual, &mut diff, &mut edit, report);
    compare_mirror(desired, actual, &mut diff, &mut edit, report);
    let current = NameSet::new(live.topics.clone());
    let topics = desired
        .topics
        .as_ref()
        .map(|topics| NameSet::new(topics.iter().map(|topic| topic.as_str().to_owned())))
        .and_then(|wanted| diff.want_set("topics", &wanted, Some(&current)))
        .map(NameSet::into_vec);
    (edit, topics, diff)
}

fn compare_wiki(
    desired: &Repository,
    actual: &model::Repository,
    diff: &mut FieldDiff,
    edit: &mut EditRepoOption,
    report: &mut Report,
) {
    if let Some(branch) = &desired.wiki_branch {
        if actual.wiki_branch.is_none() {
            report.limitations.push(Limitation::NotReported {
                field: "wiki_branch",
            });
        } else if diff.check(
            "wiki_branch",
            actual.wiki_branch.as_ref() == Some(branch),
            &actual.wiki_branch,
            branch,
        ) {
            edit.wiki_branch = Some(branch.clone());
        }
    }
    let Some(wiki) = &desired.external_wiki else {
        return;
    };
    if desired.has_wiki == Some(false) {
        report.limitations.push(Limitation::Ignored {
            field: "external_wiki",
            switch: "has_wiki",
        });
        return;
    }
    let live = actual
        .external_wiki
        .as_ref()
        .and_then(|live| live.external_wiki_url.as_deref());
    if diff.check(
        "external_wiki",
        live == Some(wiki.external_wiki_url.as_str()),
        &live,
        &wiki.external_wiki_url,
    ) {
        edit.external_wiki = Some(wiki.clone());
    }
}

fn compare_issues(
    desired: &Repository,
    actual: &model::Repository,
    diff: &mut FieldDiff,
    edit: &mut EditRepoOption,
    report: &mut Report,
) {
    if desired.has_issues == Some(false) {
        if desired.external_tracker.is_some() {
            report.limitations.push(Limitation::Ignored {
                field: "external_tracker",
                switch: "has_issues",
            });
        }
        return;
    }
    if let Some(tracker) = &desired.external_tracker {
        let live = actual.external_tracker.clone().unwrap_or_default();
        if diff.check(
            "external_tracker",
            external_matches(tracker, &live),
            &live,
            tracker,
        ) {
            edit.external_tracker = Some(request::ExternalTracker::new(tracker, &live));
        }
    } else if desired.internal_tracker.declares_any() {
        let live = actual.internal_tracker.unwrap_or_default();
        let same =
            actual.internal_tracker.is_some() && internal_matches(desired.internal_tracker, live);
        if diff.check(
            "internal_tracker",
            same,
            &actual.internal_tracker,
            &desired.internal_tracker,
        ) {
            edit.internal_tracker = Some(request::InternalTracker::new(
                desired.internal_tracker,
                live,
            ));
        }
    }
}

fn internal_matches(desired: config::InternalTracker, live: model::InternalTracker) -> bool {
    declared_matches(desired.enable_time_tracker, live.enable_time_tracker)
        && declared_matches(
            desired.allow_only_contributors_to_track_time,
            live.allow_only_contributors_to_track_time,
        )
        && declared_matches(
            desired.enable_issue_dependencies,
            live.enable_issue_dependencies,
        )
}

fn external_matches(desired: &config::ExternalTracker, live: &model::ExternalTracker) -> bool {
    live.external_tracker_url.as_deref() == Some(desired.external_tracker_url.as_str())
        && live.external_tracker_format.as_deref() == Some(desired.external_tracker_format.as_str())
        && declared_matches(
            desired
                .external_tracker_style
                .map(config::TrackerStyle::as_str),
            live.external_tracker_style.as_deref(),
        )
        && declared_matches(
            desired.external_tracker_regexp_pattern.as_deref(),
            live.external_tracker_regexp_pattern.as_deref(),
        )
}

fn declared_matches<T: PartialEq>(desired: Option<T>, live: Option<T>) -> bool {
    desired.is_none_or(|wanted| live.is_some_and(|live| live == wanted))
}

fn compare_mirror(
    desired: &Repository,
    actual: &model::Repository,
    diff: &mut FieldDiff,
    edit: &mut EditRepoOption,
    report: &mut Report,
) {
    if desired.mirror_interval.is_none() && desired.enable_prune.is_none() {
        return;
    }
    if actual.mirror != Some(true) {
        report.limitations.push(Limitation::MirrorOnly);
        return;
    }
    if let Some(interval) = &desired.mirror_interval
        && diff.check(
            "mirror_interval",
            actual.mirror_interval.as_ref() == Some(interval),
            &actual.mirror_interval,
            interval,
        )
    {
        edit.mirror_interval = Some(interval.clone());
    }
    write_unread!(diff, edit, desired, report, enable_prune);
}