foch 0.0.2

EU4 mod analysis and merge toolkit
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

use crate::model::{AnalysisMode, ChannelMode};
use std::path::{Path, PathBuf};

use crate::game::eu4::base::snapshot::InstalledBaseSnapshotIdentity;
use crate::input::config::Config;
use crate::playset::Playset;

#[derive(Clone, Debug)]
pub struct InputRequest {
	pub source: InputSource,
	pub config: Config,
	/// Content identity supplied by a parent measurement process. Input
	/// resolution verifies it before retaining its own exact load token.
	pub expected_base_snapshot_identity: Option<String>,
	/// Exact parent-owned snapshot lease. Commit workflows use this for
	/// internal revalidation without recapturing or current-checking the file.
	pub(crate) base_snapshot_lease: Option<InstalledBaseSnapshotIdentity>,
	/// Exact game installation selected by a read-only inspection. Resolution
	/// must not silently fall back to a different Steam library afterwards.
	pub(crate) expected_game_root: Option<PathBuf>,
	/// Playset captured by a read-only inspection. Keeping this out of
	/// [`InputSource`] preserves the public source shape while allowing a later
	/// request to consume the exact inspected load order.
	pub(crate) preloaded_playset: Option<Playset>,
}

impl InputRequest {
	pub fn new(source: InputSource, config: Config) -> Self {
		Self {
			source,
			config,
			expected_base_snapshot_identity: None,
			base_snapshot_lease: None,
			expected_game_root: None,
			preloaded_playset: None,
		}
	}

	pub fn from_playset_path(playset_path: PathBuf, config: Config) -> Self {
		Self::new(InputSource::DlcLoad(playset_path), config)
	}

	pub fn from_manifest_path(manifest_path: PathBuf, config: Config) -> Self {
		Self::new(InputSource::Manifest(manifest_path), config)
	}

	pub fn with_expected_base_snapshot_identity(mut self, identity: impl Into<String>) -> Self {
		self.expected_base_snapshot_identity = Some(identity.into());
		self
	}

	pub(crate) fn with_base_snapshot_lease(
		mut self,
		lease: Option<InstalledBaseSnapshotIdentity>,
	) -> Self {
		self.base_snapshot_lease = lease;
		self
	}

	pub(crate) fn with_preloaded_playset(mut self, playset: Playset) -> Self {
		debug_assert!(
			matches!(self.source, InputSource::DlcLoad(_)),
			"only dlc_load input may retain a preloaded playset"
		);
		self.preloaded_playset = Some(playset);
		self
	}

	pub(crate) fn with_expected_game_root(mut self, game_root: PathBuf) -> Self {
		self.expected_game_root = Some(game_root);
		self
	}

	pub fn source_path(&self) -> &Path {
		self.source.path()
	}
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub enum InputSource {
	DlcLoad(PathBuf),
	Manifest(PathBuf),
}

impl InputSource {
	pub fn from_path(path: PathBuf) -> Self {
		if path.file_name().and_then(|name| name.to_str()) == Some("foch.toml") {
			Self::Manifest(path)
		} else {
			Self::DlcLoad(path)
		}
	}

	pub fn path(&self) -> &Path {
		match self {
			Self::DlcLoad(path) | Self::Manifest(path) => path,
		}
	}
}

#[derive(Clone, Debug)]
pub struct CheckOptions {
	pub analysis_mode: AnalysisMode,
	pub channel_mode: ChannelMode,
	pub include_game_base: bool,
}

impl Default for CheckOptions {
	fn default() -> Self {
		Self {
			analysis_mode: AnalysisMode::default(),
			channel_mode: ChannelMode::default(),
			include_game_base: true,
		}
	}
}