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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

use std::error::Error;
use std::fmt::{self, Display, Formatter};
use std::path::{Path, PathBuf};

use super::syntax::ByteSpan;

#[derive(Debug)]
pub(crate) enum ParseError {
	Language(String),
	ParseReturnedNone,
}

impl Display for ParseError {
	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
		match self {
			Self::Language(message) => write!(f, "failed to load paradox language: {message}"),
			Self::ParseReturnedNone => write!(f, "tree-sitter returned no parse tree"),
		}
	}
}

impl Error for ParseError {}

#[derive(Debug)]
pub(crate) enum ProjectionError {
	MissingField {
		node_kind: &'static str,
		field: &'static str,
	},
	UnexpectedNode {
		kind: String,
		span: ByteSpan,
	},
}

impl Display for ProjectionError {
	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
		match self {
			Self::MissingField { node_kind, field } => {
				write!(f, "missing field `{field}` on `{node_kind}` node")
			}
			Self::UnexpectedNode { kind, span } => write!(
				f,
				"unexpected node `{kind}` at byte span {}..{}",
				span.start, span.end,
			),
		}
	}
}

impl Error for ProjectionError {}

#[derive(Debug)]
pub(crate) enum CwtLoadError {
	Io {
		path: PathBuf,
		source: std::io::Error,
	},
	NoRuleFiles {
		root: PathBuf,
	},
	Syntax(ParseError),
	Projection(ProjectionError),
	InvalidSchema {
		path: Option<PathBuf>,
		message: String,
	},
	Codec {
		message: String,
	},
}

impl CwtLoadError {
	/// Names `file` as the schema file an invalid-schema error came from,
	/// unless the error already names one.
	pub(crate) fn in_file(self, file: &Path) -> Self {
		match self {
			Self::InvalidSchema {
				path: None,
				message,
			} => Self::InvalidSchema {
				path: Some(file.to_path_buf()),
				message,
			},
			other => other,
		}
	}
}

impl Display for CwtLoadError {
	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
		match self {
			Self::Io { path, source } => {
				write!(f, "failed to read `{}`: {source}", path.display())
			}
			Self::NoRuleFiles { root } => {
				write!(f, "no `.cwt` rule files under `{}`", root.display())
			}
			Self::Syntax(error) => write!(f, "syntax parse failed: {error}"),
			Self::Projection(error) => write!(f, "syntax projection failed: {error}"),
			Self::InvalidSchema { path, message } => {
				if let Some(path) = path {
					write!(f, "invalid schema `{}`: {message}", path.display())
				} else {
					write!(f, "invalid schema: {message}")
				}
			}
			Self::Codec { message } => write!(f, "compiled schema codec failed: {message}"),
		}
	}
}

impl Error for CwtLoadError {
	fn source(&self) -> Option<&(dyn Error + 'static)> {
		match self {
			Self::Io { source, .. } => Some(source),
			Self::Syntax(error) => Some(error),
			Self::Projection(error) => Some(error),
			Self::NoRuleFiles { .. } | Self::InvalidSchema { .. } | Self::Codec { .. } => None,
		}
	}
}

impl From<ParseError> for CwtLoadError {
	fn from(value: ParseError) -> Self {
		Self::Syntax(value)
	}
}

impl From<ProjectionError> for CwtLoadError {
	fn from(value: ProjectionError) -> Self {
		Self::Projection(value)
	}
}