podup 0.11.0

Translate and run docker-compose files on rootless Podman
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

//! Development watch configuration types for the `develop:` service key.
//!
//! [`DevelopConfig`] holds a list of [`WatchRule`]s that drive the file-watch
//! engine. Each rule specifies a host path to monitor, an [`WatchAction`] to
//! take on change (sync, rebuild, restart, or sync+exec), and optional
//! ignore/include glob filters.

use serde::{Deserialize, Serialize};

/// `develop:` service key — holds file-watch rules for the `watch` command.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct DevelopConfig {
	#[serde(default, skip_serializing_if = "Vec::is_empty")]
	pub watch: Vec<WatchRule>,
}

/// A single `develop.watch` rule: a path to watch, an action to take, and optional ignore filters.
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct WatchRule {
	pub path: String,
	pub action: WatchAction,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub target: Option<String>,
	#[serde(default, skip_serializing_if = "Vec::is_empty")]
	pub ignore: Vec<String>,
	#[serde(default, skip_serializing_if = "Vec::is_empty")]
	pub include: Vec<String>,
	#[serde(default)]
	pub initial_sync: bool,
	#[serde(skip_serializing_if = "Option::is_none")]
	pub exec: Option<WatchExec>,
}

/// Action triggered by a `develop.watch` rule: `sync`, `rebuild`, `restart`, `sync+restart`, or `sync+exec`.
#[derive(Debug, Clone, Serialize, Default, PartialEq, Eq)]
pub enum WatchAction {
	#[default]
	Sync,
	Rebuild,
	Restart,
	SyncAndRestart,
	SyncAndExec,
}

impl<'de> Deserialize<'de> for WatchAction {
	fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
		let s = String::deserialize(d)?;
		match s.as_str() {
			"sync" => Ok(WatchAction::Sync),
			"rebuild" => Ok(WatchAction::Rebuild),
			"restart" => Ok(WatchAction::Restart),
			"sync+restart" => Ok(WatchAction::SyncAndRestart),
			"sync+exec" => Ok(WatchAction::SyncAndExec),
			other => Err(serde::de::Error::custom(format!(
				"unknown watch action: {other}"
			))),
		}
	}
}

/// Exec command run as part of a `sync+exec` watch action.
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct WatchExec {
	pub command: Vec<String>,
}

// ---------------------------------------------------------------------------
// Unit tests
// ---------------------------------------------------------------------------

#[cfg(test)]
mod tests {
	use super::*;

	#[test]
	fn watch_action_sync() {
		let a: WatchAction = serde_yaml::from_str("\"sync\"").unwrap();
		assert_eq!(a, WatchAction::Sync);
	}

	#[test]
	fn watch_action_rebuild() {
		let a: WatchAction = serde_yaml::from_str("\"rebuild\"").unwrap();
		assert_eq!(a, WatchAction::Rebuild);
	}

	#[test]
	fn watch_action_restart() {
		let a: WatchAction = serde_yaml::from_str("\"restart\"").unwrap();
		assert_eq!(a, WatchAction::Restart);
	}

	#[test]
	fn watch_action_sync_and_restart() {
		let a: WatchAction = serde_yaml::from_str("\"sync+restart\"").unwrap();
		assert_eq!(a, WatchAction::SyncAndRestart);
	}

	#[test]
	fn watch_action_sync_and_exec() {
		let a: WatchAction = serde_yaml::from_str("\"sync+exec\"").unwrap();
		assert_eq!(a, WatchAction::SyncAndExec);
	}

	#[test]
	fn watch_action_unknown_is_error() {
		assert!(serde_yaml::from_str::<WatchAction>("\"deploy\"").is_err());
	}
}