use super::{AuditConfig, DuplicatesConfig, FallowConfig, ResolvedConfig};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum PlannedAnalysis {
DeadCode,
Duplication,
Health,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AnalysisRequest {
Named,
Default,
Excluded,
}
impl AnalysisRequest {
#[must_use]
pub const fn from_option(value: Option<bool>) -> Self {
match value {
Some(true) => Self::Named,
Some(false) => Self::Excluded,
None => Self::Default,
}
}
const fn selected(self) -> bool {
!matches!(self, Self::Excluded)
}
const fn is_default(self) -> bool {
matches!(self, Self::Default)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum RunCommand {
Combined,
Audit,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct RunRequest {
pub command: RunCommand,
pub dead_code: AnalysisRequest,
pub duplication: AnalysisRequest,
pub health: AnalysisRequest,
}
impl RunRequest {
#[must_use]
pub const fn all_named(command: RunCommand) -> Self {
Self {
command,
dead_code: AnalysisRequest::Named,
duplication: AnalysisRequest::Named,
health: AnalysisRequest::Named,
}
}
#[must_use]
pub fn from_lists(
command: RunCommand,
only: &[PlannedAnalysis],
skip: &[PlannedAnalysis],
) -> Self {
let request = |analysis: PlannedAnalysis| {
if !only.is_empty() {
if only.contains(&analysis) {
AnalysisRequest::Named
} else {
AnalysisRequest::Excluded
}
} else if skip.contains(&analysis) {
AnalysisRequest::Excluded
} else {
AnalysisRequest::Default
}
};
Self {
command,
dead_code: request(PlannedAnalysis::DeadCode),
duplication: request(PlannedAnalysis::Duplication),
health: request(PlannedAnalysis::Health),
}
}
#[must_use]
pub const fn from_booleans(
command: RunCommand,
dead_code: bool,
duplication: bool,
health: bool,
) -> Self {
const fn request(selected: bool, alone: bool) -> AnalysisRequest {
if !selected {
AnalysisRequest::Excluded
} else if alone {
AnalysisRequest::Named
} else {
AnalysisRequest::Default
}
}
Self {
command,
dead_code: request(dead_code, !duplication && !health),
duplication: request(duplication, !dead_code && !health),
health: request(health, !dead_code && !duplication),
}
}
#[must_use]
pub const fn from_options(
command: RunCommand,
dead_code: Option<bool>,
duplication: Option<bool>,
health: Option<bool>,
) -> Self {
Self {
command,
dead_code: AnalysisRequest::from_option(dead_code),
duplication: AnalysisRequest::from_option(duplication),
health: AnalysisRequest::from_option(health),
}
}
#[must_use]
pub const fn reads_config(&self) -> bool {
match self.command {
RunCommand::Combined => self.duplication.is_default(),
RunCommand::Audit => {
self.dead_code.is_default()
|| self.duplication.is_default()
|| self.health.is_default()
}
}
}
#[must_use]
pub const fn requested(&self, analysis: PlannedAnalysis) -> bool {
self.get(analysis).selected()
}
const fn get(self, analysis: PlannedAnalysis) -> AnalysisRequest {
match analysis {
PlannedAnalysis::DeadCode => self.dead_code,
PlannedAnalysis::Duplication => self.duplication,
PlannedAnalysis::Health => self.health,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ConfigKey {
AuditDeadCode,
AuditHealth,
AuditDupes,
DuplicatesEnabled,
}
impl ConfigKey {
const fn is(self, other: Self) -> bool {
matches!(
(self, other),
(Self::AuditDeadCode, Self::AuditDeadCode)
| (Self::AuditHealth, Self::AuditHealth)
| (Self::AuditDupes, Self::AuditDupes)
| (Self::DuplicatesEnabled, Self::DuplicatesEnabled)
)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SkipReason {
NotRequested,
Config(ConfigKey),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AnalysisSelection {
Run,
Skipped(SkipReason),
}
impl AnalysisSelection {
#[must_use]
pub const fn runs(self) -> bool {
matches!(self, Self::Run)
}
#[must_use]
pub const fn off_by(self, key: ConfigKey) -> bool {
match self {
Self::Skipped(SkipReason::Config(found)) => found.is(key),
Self::Run | Self::Skipped(SkipReason::NotRequested) => false,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct RunPlan {
pub dead_code: AnalysisSelection,
pub duplication: AnalysisSelection,
pub health: AnalysisSelection,
}
impl RunPlan {
#[must_use]
pub const fn runs_any(&self) -> bool {
self.dead_code.runs() || self.duplication.runs() || self.health.runs()
}
}
#[derive(Debug, Clone, Copy)]
pub struct PlanSections<'a> {
pub duplicates: &'a DuplicatesConfig,
pub audit: &'a AuditConfig,
}
impl FallowConfig {
#[must_use]
pub const fn plan_sections(&self) -> PlanSections<'_> {
PlanSections {
duplicates: &self.duplicates,
audit: &self.audit,
}
}
}
impl ResolvedConfig {
#[must_use]
pub const fn plan_sections(&self) -> PlanSections<'_> {
PlanSections {
duplicates: &self.duplicates,
audit: &self.audit,
}
}
}
#[must_use]
pub const fn plan_run(sections: PlanSections<'_>, request: RunRequest) -> RunPlan {
let command = request.command;
let duplicates_off = if sections.duplicates.enabled {
None
} else {
Some(ConfigKey::DuplicatesEnabled)
};
RunPlan {
dead_code: select(
request.dead_code,
command_key(command, ConfigKey::AuditDeadCode, sections.audit.dead_code),
None,
),
duplication: select(
request.duplication,
command_key(command, ConfigKey::AuditDupes, sections.audit.dupes),
duplicates_off,
),
health: select(
request.health,
command_key(command, ConfigKey::AuditHealth, sections.audit.health),
None,
),
}
}
const fn command_key(
command: RunCommand,
key: ConfigKey,
value: Option<bool>,
) -> Option<(ConfigKey, Option<bool>)> {
match command {
RunCommand::Audit => Some((key, value)),
RunCommand::Combined => None,
}
}
const fn select(
request: AnalysisRequest,
command_key: Option<(ConfigKey, Option<bool>)>,
project_off: Option<ConfigKey>,
) -> AnalysisSelection {
match request {
AnalysisRequest::Named => AnalysisSelection::Run,
AnalysisRequest::Excluded => AnalysisSelection::Skipped(SkipReason::NotRequested),
AnalysisRequest::Default => match (command_key, project_off) {
(Some((key, Some(false))), _) => AnalysisSelection::Skipped(SkipReason::Config(key)),
(Some((_, Some(true))), _) | (_, None) => AnalysisSelection::Run,
(_, Some(key)) => AnalysisSelection::Skipped(SkipReason::Config(key)),
},
}
}
#[cfg(test)]
#[path = "run_plan_tests.rs"]
mod tests;