Refactor

src/manifest/types.rs

@@ -0,0 +1,341 @@
+use anyhow::Result;
+use indexmap::IndexMap;
+use serde::Deserialize;
+use std::path::{Path, PathBuf};
+
+use crate::tool::ToolConfig;
+
+use super::rule::FlatPickRule;
+
+#[derive(Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct Manifest {
+	pub config: PickConfig,
+	pub tool: ToolConfig,
+	pub rules: PickRules,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct PickConfig {
+	#[serde(default)]
+	pub work_dir: Option<PathBuf>,
+
+	#[serde(default = "default_false")]
+	pub follow_links: bool,
+
+	#[serde(default = "default_true")]
+	pub process_files: bool,
+
+	#[serde(default = "default_false")]
+	pub process_dirs: bool,
+
+	#[serde(default = "default_false")]
+	pub process_links: bool,
+}
+
+impl PickConfig {
+	pub fn work_dir(&self, manifest_path: &Path) -> Result<PathBuf> {
+		// Parent directory should always exist since manifest is a file.
+		#[expect(clippy::unwrap_used)]
+		let p = manifest_path.parent().unwrap().to_path_buf();
+
+		match &self.work_dir {
+			None => Ok(p),
+			Some(path) => {
+				if path.is_absolute() {
+					Ok(path.to_owned())
+				} else {
+					Ok(std::path::absolute(p.join(path))?)
+				}
+			}
+		}
+	}
+}
+
+fn default_true() -> bool {
+	true
+}
+
+fn default_false() -> bool {
+	false
+}
+
+//
+// MARK: rules
+//
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(untagged)]
+pub enum OptVec<T: Clone> {
+	Single(T),
+	Vec(Vec<T>),
+}
+
+impl<T: Clone> OptVec<T> {
+	pub fn len(&self) -> usize {
+		match self {
+			Self::Single(_) => 1,
+			Self::Vec(v) => v.len(),
+		}
+	}
+
+	pub fn is_empty(&self) -> bool {
+		match self {
+			Self::Single(_) => false,
+			Self::Vec(v) => v.is_empty(),
+		}
+	}
+
+	pub fn get(&self, idx: usize) -> Option<&T> {
+		match self {
+			Self::Single(t) => (idx == 0).then_some(t),
+			Self::Vec(v) => v.get(idx),
+		}
+	}
+}
+impl<T: Clone> From<OptVec<T>> for Vec<T> {
+	fn from(val: OptVec<T>) -> Self {
+		match val {
+			OptVec::Single(t) => vec![t],
+			OptVec::Vec(v) => v,
+		}
+	}
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(untagged)]
+#[serde(deny_unknown_fields)]
+pub enum PickRule {
+	Plain(OptVec<String>),
+	Nested(PickRules),
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(transparent)]
+pub struct PickRules(OptVec<IndexMap<String, PickRule>>);
+
+impl PickRules {
+	pub fn iter(&self) -> PickRuleIterator<'_> {
+		PickRuleIterator {
+			stack: vec![PickRuleIterState {
+				rules: self,
+				map_index: 0,
+				entry_index: 0,
+				prefix: Vec::new(),
+			}],
+		}
+	}
+}
+
+impl<'a> IntoIterator for &'a PickRules {
+	type Item = FlatPickRule;
+	type IntoIter = PickRuleIterator<'a>;
+
+	fn into_iter(self) -> Self::IntoIter {
+		self.iter()
+	}
+}
+
+//
+// MARK: rule iterator
+//
+
+struct PickRuleIterState<'a> {
+	rules: &'a PickRules,
+	map_index: usize,
+	entry_index: usize,
+	prefix: Vec<String>,
+}
+pub struct PickRuleIterator<'a> {
+	stack: Vec<PickRuleIterState<'a>>,
+}
+
+impl Iterator for PickRuleIterator<'_> {
+	type Item = FlatPickRule;
+
+	fn next(&mut self) -> Option<Self::Item> {
+		if self.stack.is_empty() {
+			return None;
+		}
+
+		#[expect(clippy::unwrap_used)]
+		let current = self.stack.last_mut().unwrap();
+
+		if current.map_index >= current.rules.0.len() {
+			self.stack.pop();
+			return self.next();
+		}
+
+		#[expect(clippy::unwrap_used)]
+		let current_map = &current.rules.0.get(current.map_index).unwrap();
+
+		if current.entry_index >= current_map.len() {
+			current.map_index += 1;
+			current.entry_index = 0;
+			return self.next();
+		}
+
+		#[expect(clippy::unwrap_used)]
+		let (key, value) = current_map.get_index(current.entry_index).unwrap();
+
+		current.entry_index += 1;
+
+		match value {
+			PickRule::Plain(task) => {
+				let mut patterns = current.prefix.clone();
+				patterns.push(key.to_string());
+
+				Some(FlatPickRule {
+					patterns,
+					tasks: task.clone().into(),
+				})
+			}
+			PickRule::Nested(nested_rules) => {
+				let mut prefix = current.prefix.clone();
+				prefix.push(key.to_string());
+
+				self.stack.push(PickRuleIterState {
+					rules: nested_rules,
+					map_index: 0,
+					entry_index: 0,
+					prefix,
+				});
+
+				self.next()
+			}
+		}
+	}
+}
+
+//
+// MARK: tests
+//
+
+#[cfg(test)]
+#[expect(clippy::unwrap_used)]
+mod tests {
+	use super::*;
+
+	#[derive(Debug, Clone, Deserialize)]
+	struct TestManifest {
+		rules: PickRules,
+	}
+
+	#[test]
+	fn rule_ordering_preserved() {
+		let toml_str = r#"
+			[[rules]]
+			"third" = "c"
+			"first" = "a" 
+			"second" = "b"
+		"#;
+
+		let test_manifest: TestManifest = toml::from_str(toml_str).unwrap();
+		let rules: Vec<FlatPickRule> = test_manifest.rules.iter().collect();
+
+		assert_eq!(rules.len(), 3);
+		assert_eq!(rules[0].patterns, vec!["third"]);
+		assert_eq!(rules[0].tasks, vec!["c"]);
+		assert_eq!(rules[1].patterns, vec!["first"]);
+		assert_eq!(rules[1].tasks, vec!["a"]);
+		assert_eq!(rules[2].patterns, vec!["second"]);
+		assert_eq!(rules[2].tasks, vec!["b"]);
+	}
+
+	#[test]
+	fn nested_rules_order() {
+		let toml_str = r#"
+			[[rules]]
+			"a" = "task_a"
+			"b" = "task_b"
+
+			[[rules."nested"]]
+			"c" = "task_c"
+			"d" = "task_d"
+
+			[[rules]]
+			"e" = "task_e"
+		"#;
+
+		let test_manifest: TestManifest = toml::from_str(toml_str).unwrap();
+		let rules: Vec<FlatPickRule> = test_manifest.rules.iter().collect();
+
+		assert_eq!(rules.len(), 5);
+		assert_eq!(rules[0].patterns, vec!["a"]);
+		assert_eq!(rules[0].tasks, vec!["task_a"]);
+		assert_eq!(rules[1].patterns, vec!["b"]);
+		assert_eq!(rules[1].tasks, vec!["task_b"]);
+		assert_eq!(rules[2].patterns, vec!["nested", "c"]);
+		assert_eq!(rules[2].tasks, vec!["task_c"]);
+		assert_eq!(rules[3].patterns, vec!["nested", "d"]);
+		assert_eq!(rules[3].tasks, vec!["task_d"]);
+		assert_eq!(rules[4].patterns, vec!["e"]);
+		assert_eq!(rules[4].tasks, vec!["task_e"]);
+	}
+
+	#[test]
+	fn deeply_nested_rules() {
+		let toml_str = r#"
+			[[rules."a"."b"."c"]]
+			"d" = "task_d"
+		"#;
+
+		let test_manifest: TestManifest = toml::from_str(toml_str).unwrap();
+		let rules: Vec<FlatPickRule> = test_manifest.rules.iter().collect();
+
+		assert_eq!(rules.len(), 1);
+		assert_eq!(rules[0].patterns, vec!["a", "b", "c", "d"]);
+		assert_eq!(rules[0].tasks, vec!["task_d"]);
+	}
+
+	#[test]
+	fn multiple_maps_same_level() {
+		let toml_str = r#"
+			[[rules]]
+			"a1" = "copy"
+			"a2" = "ignore"
+
+			[[rules]]
+			"b1" = "copy"
+			"b2" = "ignore"
+		"#;
+
+		let test_manifest: TestManifest = toml::from_str(toml_str).unwrap();
+		let rules: Vec<FlatPickRule> = test_manifest.rules.iter().collect();
+
+		assert_eq!(rules.len(), 4);
+		assert_eq!(rules[0].patterns, vec!["a1"]);
+		assert_eq!(rules[0].tasks, vec!["copy"]);
+		assert_eq!(rules[1].patterns, vec!["a2"]);
+		assert_eq!(rules[1].tasks, vec!["ignore"]);
+		assert_eq!(rules[2].patterns, vec!["b1"]);
+		assert_eq!(rules[2].tasks, vec!["copy"]);
+		assert_eq!(rules[3].patterns, vec!["b2"]);
+		assert_eq!(rules[3].tasks, vec!["ignore"]);
+	}
+
+	#[test]
+	fn empty_rules_list() {
+		let toml_str = "
+			[[rules]]
+		";
+
+		let test_manifest: TestManifest = toml::from_str(toml_str).unwrap();
+		let rules: Vec<FlatPickRule> = test_manifest.rules.iter().collect();
+
+		assert_eq!(rules.len(), 0);
+	}
+
+	#[test]
+	fn mixed_rule_types() {
+		let toml_str = r#"
+			[[rules]]
+			"plain" = "copy"
+			"nested" = { invalid_as_string = true }
+		"#;
+
+		let result = toml::from_str::<TestManifest>(toml_str);
+		assert!(result.is_err());
+	}
+}