foundry_config/
utils.rs

1//! Utility functions
2
3use crate::Config;
4use alloy_primitives::U256;
5use figment::value::Value;
6use foundry_compilers::artifacts::remappings::{Remapping, RemappingError};
7use serde::{Deserialize, Deserializer, Serializer, de::Error};
8use std::{
9    io,
10    path::{Path, PathBuf},
11    str::FromStr,
12};
13
14// TODO: Why do these exist separately from `Config::load`?
15
16/// Loads the config for the current project workspace.
17pub fn load_config() -> eyre::Result<Config> {
18    load_config_with_root(None)
19}
20
21/// Loads the config for the current project workspace or the provided root path.
22pub fn load_config_with_root(root: Option<&Path>) -> eyre::Result<Config> {
23    let root = match root {
24        Some(root) => root,
25        None => &find_project_root(None)?,
26    };
27    Ok(Config::load_with_root(root)?.sanitized())
28}
29
30/// Returns the path of the top-level directory of the working git tree.
31pub fn find_git_root(relative_to: &Path) -> io::Result<Option<PathBuf>> {
32    let root =
33        if relative_to.is_absolute() { relative_to } else { &dunce::canonicalize(relative_to)? };
34    Ok(root.ancestors().find(|p| p.join(".git").exists()).map(Path::to_path_buf))
35}
36
37/// Returns the root path to set for the project root.
38///
39/// Traverse the dir tree up and look for a `foundry.toml` file starting at the given path or cwd,
40/// but only until the root dir of the current repo so that:
41///
42/// ```text
43/// -- foundry.toml
44///
45/// -- repo
46///   |__ .git
47///   |__sub
48///      |__ [given_path | cwd]
49/// ```
50///
51/// will still detect `repo` as root.
52///
53/// Returns `repo` or `cwd` if no `foundry.toml` is found in the tree.
54///
55/// Returns an error if:
56/// - `cwd` is `Some` and is not a valid directory;
57/// - `cwd` is `None` and the [`std::env::current_dir`] call fails.
58pub fn find_project_root(cwd: Option<&Path>) -> io::Result<PathBuf> {
59    let cwd = match cwd {
60        Some(path) => path,
61        None => &std::env::current_dir()?,
62    };
63    let boundary = find_git_root(cwd)?;
64    let found = cwd
65        .ancestors()
66        // Don't look outside of the git repo if it exists.
67        .take_while(|p| if let Some(boundary) = &boundary { p.starts_with(boundary) } else { true })
68        .find(|p| p.join(Config::FILE_NAME).is_file())
69        .map(Path::to_path_buf);
70    Ok(found.or(boundary).unwrap_or_else(|| cwd.to_path_buf()))
71}
72
73/// Returns all [`Remapping`]s contained in the `remappings` str separated by newlines
74///
75/// # Example
76///
77/// ```
78/// use foundry_config::remappings_from_newline;
79/// let remappings: Result<Vec<_>, _> = remappings_from_newline(
80///     r#"
81///              file-ds-test/=lib/ds-test/
82///              file-other/=lib/other/
83///          "#,
84/// )
85/// .collect();
86/// ```
87pub fn remappings_from_newline(
88    remappings: &str,
89) -> impl Iterator<Item = Result<Remapping, RemappingError>> + '_ {
90    remappings.lines().map(|x| x.trim()).filter(|x| !x.is_empty()).map(Remapping::from_str)
91}
92
93/// Returns the remappings from the given var
94///
95/// Returns `None` if the env var is not set, otherwise all Remappings, See
96/// `remappings_from_newline`
97pub fn remappings_from_env_var(env_var: &str) -> Option<Result<Vec<Remapping>, RemappingError>> {
98    let val = std::env::var(env_var).ok()?;
99    Some(remappings_from_newline(&val).collect())
100}
101
102/// Converts the `val` into a `figment::Value::Array`
103///
104/// The values should be separated by commas, surrounding brackets are also supported `[a,b,c]`
105pub fn to_array_value(val: &str) -> Result<Value, figment::Error> {
106    let value: Value = match Value::from(val) {
107        Value::String(_, val) => val
108            .trim_start_matches('[')
109            .trim_end_matches(']')
110            .split(',')
111            .map(|s| s.to_string())
112            .collect::<Vec<_>>()
113            .into(),
114        Value::Empty(_, _) => Vec::<Value>::new().into(),
115        val @ Value::Array(_, _) => val,
116        _ => return Err(format!("Invalid value `{val}`, expected an array").into()),
117    };
118    Ok(value)
119}
120
121/// Returns a list of _unique_ paths to all folders under `root` that contain a `foundry.toml` file
122///
123/// This will also resolve symlinks
124///
125/// # Example
126///
127/// ```no_run
128/// use foundry_config::utils;
129/// let dirs = utils::foundry_toml_dirs("./lib");
130/// ```
131///
132/// for following layout this will return
133/// `["lib/dep1", "lib/dep2"]`
134///
135/// ```text
136/// lib
137/// └── dep1
138/// │   ├── foundry.toml
139/// └── dep2
140///     ├── foundry.toml
141/// ```
142pub fn foundry_toml_dirs(root: impl AsRef<Path>) -> Vec<PathBuf> {
143    walkdir::WalkDir::new(root)
144        .max_depth(1)
145        .into_iter()
146        .filter_map(Result::ok)
147        .filter(|e| e.file_type().is_dir())
148        .filter_map(|e| dunce::canonicalize(e.path()).ok())
149        .filter(|p| p.join(Config::FILE_NAME).exists())
150        .collect()
151}
152
153/// Returns a remapping for the given dir
154pub(crate) fn get_dir_remapping(dir: impl AsRef<Path>) -> Option<Remapping> {
155    let dir = dir.as_ref();
156    if let Some(dir_name) = dir.file_name().and_then(|s| s.to_str()).filter(|s| !s.is_empty()) {
157        let mut r = Remapping {
158            context: None,
159            name: format!("{dir_name}/"),
160            path: format!("{}", dir.display()),
161        };
162        if !r.path.ends_with('/') {
163            r.path.push('/')
164        }
165        Some(r)
166    } else {
167        None
168    }
169}
170
171/// Deserialize stringified percent. The value must be between 0 and 100 inclusive.
172pub(crate) fn deserialize_stringified_percent<'de, D>(deserializer: D) -> Result<u32, D::Error>
173where
174    D: Deserializer<'de>,
175{
176    let num: U256 = Numeric::deserialize(deserializer)?.into();
177    let num: u64 = num.try_into().map_err(serde::de::Error::custom)?;
178    if num <= 100 {
179        num.try_into().map_err(serde::de::Error::custom)
180    } else {
181        Err(serde::de::Error::custom("percent must be lte 100"))
182    }
183}
184
185/// Deserialize a `u64` or "max" for `u64::MAX`.
186pub(crate) fn deserialize_u64_or_max<'de, D>(deserializer: D) -> Result<u64, D::Error>
187where
188    D: Deserializer<'de>,
189{
190    #[derive(Deserialize)]
191    #[serde(untagged)]
192    enum Val {
193        Number(u64),
194        String(String),
195    }
196
197    match Val::deserialize(deserializer)? {
198        Val::Number(num) => Ok(num),
199        Val::String(s) if s.eq_ignore_ascii_case("max") => Ok(u64::MAX),
200        Val::String(s) => s.parse::<u64>().map_err(D::Error::custom),
201    }
202}
203
204/// Deserialize a `usize` or "max" for `usize::MAX`.
205pub(crate) fn deserialize_usize_or_max<'de, D>(deserializer: D) -> Result<usize, D::Error>
206where
207    D: Deserializer<'de>,
208{
209    deserialize_u64_or_max(deserializer)?.try_into().map_err(D::Error::custom)
210}
211
212/// Serialize a `usize` as `"max"` if it equals `usize::MAX`, as a string if it exceeds
213/// `i64::MAX` (TOML integer limit), or as a plain number otherwise.
214pub(crate) fn serialize_usize_or_max<S>(value: &usize, serializer: S) -> Result<S::Ok, S::Error>
215where
216    S: Serializer,
217{
218    if *value == usize::MAX {
219        serializer.serialize_str("max")
220    } else if *value > i64::MAX as usize {
221        serializer.serialize_str(&value.to_string())
222    } else {
223        serializer.serialize_u64(*value as u64)
224    }
225}
226
227/// Deserialize into `U256` from either a `u64`, a `U256` hex string, or a decimal string.
228pub fn deserialize_u64_to_u256<'de, D>(deserializer: D) -> Result<U256, D::Error>
229where
230    D: Deserializer<'de>,
231{
232    #[derive(Deserialize)]
233    #[serde(untagged)]
234    enum NumericValue {
235        U256(U256),
236        U64(u64),
237        String(String),
238    }
239
240    match NumericValue::deserialize(deserializer)? {
241        NumericValue::U64(n) => Ok(U256::from(n)),
242        NumericValue::U256(n) => Ok(n),
243        NumericValue::String(s) => {
244            // Handle decimal strings (e.g., "18446744073709551615")
245            U256::from_str(&s).map_err(D::Error::custom)
246        }
247    }
248}
249
250/// Serialize `U256` as `u64` if it fits, otherwise as a hex string.
251/// If the number fits into a i64, serialize it as number without quotation marks.
252/// If the number fits into a u64, serialize it as a stringified number with quotation marks.
253/// Otherwise, serialize it as a hex string with quotation marks.
254pub fn serialize_u64_or_u256<S>(n: &U256, serializer: S) -> Result<S::Ok, S::Error>
255where
256    S: Serializer,
257{
258    // The TOML specification handles integers as i64 so the number representation is limited to
259    // i64. If the number is larger than `i64::MAX` and up to `u64::MAX`, we serialize it as a
260    // string to avoid losing precision.
261    if let Ok(n_i64) = i64::try_from(*n) {
262        serializer.serialize_i64(n_i64)
263    } else if let Ok(n_u64) = u64::try_from(*n) {
264        serializer.serialize_str(&n_u64.to_string())
265    } else {
266        serializer.serialize_str(&format!("{n:#x}"))
267    }
268}
269
270/// Helper type to parse both `u64` and `U256`
271#[derive(Clone, Copy, Deserialize)]
272#[serde(untagged)]
273pub enum Numeric {
274    /// A [U256] value.
275    U256(U256),
276    /// A `u64` value.
277    Num(u64),
278}
279
280impl From<Numeric> for U256 {
281    fn from(n: Numeric) -> Self {
282        match n {
283            Numeric::U256(n) => n,
284            Numeric::Num(n) => Self::from(n),
285        }
286    }
287}
288
289impl FromStr for Numeric {
290    type Err = String;
291
292    fn from_str(s: &str) -> Result<Self, Self::Err> {
293        if s.starts_with("0x") {
294            U256::from_str_radix(s, 16).map(Numeric::U256).map_err(|err| err.to_string())
295        } else {
296            U256::from_str(s).map(Numeric::U256).map_err(|err| err.to_string())
297        }
298    }
299}
foundry_config/utils.rs

foundry_config/
utils.rs
