use std::num::NonZeroUsize;
use std::path::PathBuf;
use crate::config::Config;
use crate::lock::Lock;
use crate::projection::diagnostic::ProjectionWarning;
use super::ConflictResolver;
use super::hooks::HookOutcome;
use super::model::{ChangeSet, ConflictKind, ReconciliationPolicy, RemovalReason};
#[derive(Debug, Clone, Default)]
pub struct LockSet {
pub base: Option<Lock>,
pub local: Option<Lock>,
}
pub struct SyncRequest<'a> {
pub base_config: &'a Config,
pub local_config: Option<&'a Config>,
pub locks: LockSet,
pub options: SyncOptions,
pub resolver: Option<&'a dyn ConflictResolver>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct SyncOptions {
pub source_policy: SourcePolicy,
pub conflict_policy: ConflictPolicy,
pub prune_policy: PrunePolicy,
pub hook_policy: HookPolicy,
pub moved_pin_policy: MovedPinPolicy,
pub concurrency: Concurrency,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SourcePolicy {
Locked,
Refresh,
Frozen,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ConflictPolicy {
Refuse,
ResolveInteractively,
Overwrite,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PrunePolicy {
KeepOrphans,
RemoveOrphans,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum HookPolicy {
All,
NoTransitive,
None,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MovedPinPolicy {
Seal,
FastForward,
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct Concurrency {
pub jobs: Option<NonZeroUsize>,
}
impl From<&SyncOptions> for ReconciliationPolicy {
fn from(options: &SyncOptions) -> Self {
Self {
force: matches!(options.conflict_policy, ConflictPolicy::Overwrite),
prune: matches!(options.prune_policy, PrunePolicy::RemoveOrphans),
follow_moved_pin: matches!(options.moved_pin_policy, MovedPinPolicy::FastForward),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum AppliedChange {
Deployed {
target: String,
source: String,
artifact: String,
},
Overwritten {
target: String,
source: String,
artifact: String,
},
OverlayRewritten {
target: String,
source: String,
artifact: String,
},
Ejected {
target: String,
source: String,
artifact: String,
},
Removed {
target: String,
source: String,
artifact: String,
reason: RemovalReason,
},
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum SkippedChange {
Conflict {
target: String,
source: String,
artifact: String,
kind: ConflictKind,
},
Failed {
target: String,
source: String,
artifact: String,
message: String,
},
ReadonlyOverlayRewrite {
target: String,
source: String,
artifact: String,
},
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum SyncWarning {
Projection(ProjectionWarning),
MalformedTransitiveHooks {
target: String,
detail: String,
},
LinkPathNotPortable {
source: String,
path: PathBuf,
},
ReferenceMoved {
source: String,
target: String,
from: String,
to: String,
},
OrphanedRecords {
count: usize,
},
PruneSkippedAfterFailures,
PruneRefused {
path: PathBuf,
reason: String,
},
OrphanRecordPathUnknown {
source: String,
artifact: String,
layout: String,
},
FastForwardKeptLive {
source: String,
artifact: String,
path: PathBuf,
},
FastForwardDropped {
source: String,
artifact: String,
},
CrossDeviceFallback {
destination: PathBuf,
},
ConflictModified {
source: String,
artifact: String,
changed: Vec<PathBuf>,
},
ConflictForeign {
path: PathBuf,
},
UntrustedTransitiveHooks {
count: usize,
},
HistoryContentFilter {
source: String,
attributes: bool,
autocrlf: bool,
},
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub enum SyncStatus {
#[default]
Success,
Failed,
}
#[derive(Debug)]
pub struct SyncReport {
pub locks: LockSet,
pub changes: ChangeSet,
pub applied: Vec<AppliedChange>,
pub skipped: Vec<SkippedChange>,
pub warnings: Vec<SyncWarning>,
pub hook_outcomes: Vec<HookOutcome>,
pub status: SyncStatus,
}
#[derive(Debug, Default)]
pub(super) struct SyncEvents {
pub(super) applied: Vec<AppliedChange>,
pub(super) skipped: Vec<SkippedChange>,
pub(super) warnings: Vec<SyncWarning>,
}