Merge pull request #192 from projectsyn/feat/rust-2024

simu · web-flow · commit 55482ebfcece · 2025-11-27T13:40:02.000+01:00
Switch to Rust 2024 Edition
diff --git a/.rustfmt.toml b/.rustfmt.toml
@@ -0,0 +1 @@
+edition = "2024"
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,7 +1,8 @@
 [package]
 name = "reclass-rs"
 version = "0.0.0"
-edition = "2021"
+edition = "2024"
+rust-version = "1.87"
 license = "BSD-3-Clause"
 authors = ["VSHN AG <info@vshn.ch>"]
 repository = "https://github.com/projectsyn/reclass-rs"
diff --git a/README.md b/README.md
@@ -43,7 +43,7 @@ Documentation on Reclass extensions introduced in the Kapicorp Reclass fork can
 ## Prerequisites
 
 * Python >= 3.9
-* Rust >= 1.56 (we recommend installing the latest stable toolchain with [rustup])
+* Rust >= 1.87 (we recommend installing the latest stable toolchain with [rustup])
 
 ## Setup local development environment for Python bindings
 
diff --git a/benches/inventory_multi_threaded.rs b/benches/inventory_multi_threaded.rs
@@ -1,4 +1,4 @@
-use criterion::{criterion_group, criterion_main, Criterion};
+use criterion::{Criterion, criterion_group, criterion_main};
 use rayon::ThreadPoolBuilder;
 use std::hint::black_box;
 
diff --git a/benches/inventory_single_threaded.rs b/benches/inventory_single_threaded.rs
@@ -1,4 +1,4 @@
-use criterion::{criterion_group, criterion_main, Criterion};
+use criterion::{Criterion, criterion_group, criterion_main};
 use rayon::ThreadPoolBuilder;
 use std::hint::black_box;
 
diff --git a/src/config.rs b/src/config.rs
@@ -1,18 +1,18 @@
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use fancy_regex::Regex;
 use pyo3::exceptions::PyValueError;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyType};
 use regex::RegexSet;
-use std::collections::hash_map::DefaultHasher;
 use std::collections::HashSet;
+use std::collections::hash_map::DefaultHasher;
 use std::hash::{Hash, Hasher};
 use std::path::PathBuf;
 use std::sync::LazyLock;
 
+use crate::NodeInfoMeta;
 use crate::fsutil::to_lexical_normal;
 use crate::list::{List, UniqueList};
-use crate::NodeInfoMeta;
 
 /// Flags to change reclass-rs behavior to be compaible with Python reclass
 #[pyclass(eq, eq_int)]
diff --git a/src/inventory.rs b/src/inventory.rs
@@ -1,4 +1,4 @@
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use chrono::Local;
 use pyo3::prelude::*;
 use pyo3::types::PyDict;
diff --git a/src/lib.rs b/src/lib.rs
@@ -18,13 +18,13 @@ mod node;
 mod refs;
 pub mod types;
 
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use pyo3::exceptions::PyValueError;
 use pyo3::prelude::*;
 use pyo3::types::PyType;
 use rayon::ThreadPoolBuilder;
 use std::collections::HashMap;
-use std::path::{Path, PathBuf, MAIN_SEPARATOR};
+use std::path::{MAIN_SEPARATOR, Path, PathBuf};
 use walkdir::WalkDir;
 
 use config::{CompatFlag, Config};
@@ -134,12 +134,9 @@ fn walk_entity_dir(
     for entry in WalkDir::new(root).follow_links(true) {
         let entry = entry?;
         // We use `entry.path()` here to get the symlink name for symlinked files.
-        let ext = if let Some(ext) = entry.path().extension() {
-            ext.to_str()
-        } else {
-            None
-        };
-        if ext.is_some() && SUPPORTED_YAML_EXTS.contains(&ext.unwrap()) {
+        if let Some(ext) = entry.path().extension().and_then(|e| e.to_str())
+            && SUPPORTED_YAML_EXTS.contains(&ext)
+        {
             // it's an entity (class or node), process it
             let abspath = to_lexical_absolute(entry.path())?;
             let relpath = abspath.strip_prefix(&entity_root)?;
diff --git a/src/list/removable.rs b/src/list/removable.rs
@@ -1,6 +1,6 @@
 use serde::Deserialize;
 
-use super::{item_pos, List};
+use super::{List, item_pos};
 
 #[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq)]
 #[serde(from = "Vec<String>")]
diff --git a/src/list/unique.rs b/src/list/unique.rs
@@ -1,6 +1,6 @@
 use serde::Deserialize;
 
-use super::{item_pos, List};
+use super::{List, item_pos};
 
 #[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq)]
 #[serde(from = "Vec<String>")]
diff --git a/src/node/mod.rs b/src/node/mod.rs
@@ -1,16 +1,16 @@
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use serde::Deserialize;
 use std::path::PathBuf;
 // TODO(sg): Switch to serde_yaml's `apply_merge()` once it supports recursive merges, cf.
 // https://github.com/dtolnay/serde-yaml/issues/362
 use yaml_merge_keys::merge_keys_serde;
 
+use crate::Reclass;
 use crate::config::RenderOpts;
 use crate::fsutil::to_lexical_absolute;
 use crate::list::{List, RemovableList, UniqueList};
 use crate::refs::{ResolveState, Token};
 use crate::types::{Mapping, Value};
-use crate::Reclass;
 
 mod nodeinfo;
 
@@ -137,7 +137,7 @@ impl Node {
                 _ => {
                     return Err(anyhow!(
                         "Unexpected non-normal path segment in class lookup: {d:?}",
-                    ))
+                    ));
                 }
             }
         }
diff --git a/src/node/nodeinfo.rs b/src/node/nodeinfo.rs
@@ -1,7 +1,7 @@
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
+use chrono::DateTime;
 use chrono::offset::FixedOffset;
 use chrono::offset::Local;
-use chrono::DateTime;
 use pyo3::prelude::*;
 use pyo3::types::PyDict;
 use std::path::PathBuf;
@@ -84,13 +84,14 @@ impl NodeInfoMeta {
             self.name.split('.').collect::<Vec<&str>>()
         } else if part0.starts_with('_') {
             // Always drop path prefix for paths that start with `_`
-            vec![self
-                .parts
-                .iter()
-                .next_back()
-                .ok_or(anyhow!("Unable to extract last segment from node"))?
-                .to_str()
-                .ok_or(anyhow!("Unable to convert path segment to a string"))?]
+            vec![
+                self.parts
+                    .iter()
+                    .next_back()
+                    .ok_or(anyhow!("Unable to extract last segment from node"))?
+                    .to_str()
+                    .ok_or(anyhow!("Unable to convert path segment to a string"))?,
+            ]
         } else {
             // If the compat flag isn't set, we generate the parts list from the provided shortened
             // pathbuf containing the path within `nodes_path` which preserves literal dots in the
diff --git a/src/refs/mod.rs b/src/refs/mod.rs
@@ -4,8 +4,8 @@ use crate::{
     config::RenderOpts,
     types::{Mapping, Value},
 };
-use anyhow::{anyhow, Result};
-use nom_language::error::{convert_error, VerboseError};
+use anyhow::{Result, anyhow};
+use nom_language::error::{VerboseError, convert_error};
 use std::collections::HashSet;
 
 #[derive(Debug, PartialEq, Eq)]
diff --git a/src/refs/parser.rs b/src/refs/parser.rs
@@ -1,12 +1,12 @@
 use nom::{
+    IResult, Parser,
     branch::alt,
     bytes::complete::{tag, take},
     character::complete::none_of,
     combinator::{all_consuming, map, not, peek},
     error::context,
     multi::many1,
     sequence::{delimited, preceded},
-    IResult, Parser,
 };
 use nom_language::error::VerboseError;
 
@@ -18,18 +18,13 @@ fn coalesce_literals(tokens: Vec<Token>) -> Vec<Token> {
     let mut tokiter = tokens.into_iter();
     let mut res = vec![tokiter.next().unwrap()];
     for tok in tokiter {
-        if res.last().unwrap().is_literal() && tok.is_literal() {
-            // TODO(sg): Move the if-let bindings into the if above this comment once the
-            // corresponding Rust feature is stabilized.
-            if let Token::Literal(t) = res.pop().unwrap() {
-                if let Token::Literal(tok) = tok {
-                    res.push(Token::Literal(format!("{t}{tok}")));
-                } else {
-                    unreachable!("Literal token isn't a literal?");
-                }
-            } else {
-                unreachable!("Literal token isn't a literal?");
-            }
+        if let Some(l) = res.last()
+            && l.is_literal()
+            && tok.is_literal()
+            && let Some(Token::Literal(t)) = res.pop()
+            && let Token::Literal(tok) = tok
+        {
+            res.push(Token::Literal(format!("{t}{tok}")));
         } else {
             res.push(tok);
         }
@@ -216,7 +211,10 @@ pub fn parse_ref(input: &str) -> IResult<&str, Token, VerboseError<&str>> {
         if tokens.len() > 1 {
             Token::Combined(tokens)
         } else {
-            tokens.into_iter().next().unwrap()
+            tokens
+                .into_iter()
+                .next()
+                .expect("Expected coalesced parsed reference to have at least one token")
         }
     })
     .parse(input)
diff --git a/src/types/mapping.rs b/src/types/mapping.rs
@@ -1,15 +1,15 @@
 // This implementation is inspired by `serde_yaml::Mapping`
 
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use indexmap::IndexMap;
 use pyo3::prelude::*;
 use pyo3::types::PyDict;
-use std::collections::hash_map::DefaultHasher;
 use std::collections::HashSet;
+use std::collections::hash_map::DefaultHasher;
 use std::hash::{Hash, Hasher};
 
-use super::value::Value;
 use super::KeyPrefix;
+use super::value::Value;
 use crate::config::RenderOpts;
 use crate::refs::ResolveState;
 
@@ -397,37 +397,37 @@ impl Mapping {
                 other.is_const(k),
                 other.is_override(k),
             )?;
-            if other.is_override(k) {
-                if let Some(p) = p {
-                    let mut st = state.clone();
-                    st.push_mapping_key(k)?;
-                    if let Some(errmsg) = p.as_resolve_error() {
-                        if opts.ignore_overwritten_missing_references {
-                            #[cfg(not(feature = "bench"))]
-                            eprintln!("[WARN] Ignoring resolve error: {errmsg}");
-                        } else {
-                            return Err(anyhow!(errmsg.clone()));
-                        }
-                    } else if opts.verbose_warnings {
-                        if let Value::String(s) = p {
-                            if s.contains("${") {
-                                #[cfg(not(feature = "bench"))]
-                                eprintln!(
-                                    "[WARN] Dropping potentially missing reference in \
-                                    overrridden unrendered value '{s}' for parameter '{}'",
-                                    st.current_key()
-                                );
-                            }
-                        } else {
-                            // TODO(sg): can we make this more accurate?
+            if other.is_override(k)
+                && let Some(p) = p
+            {
+                let mut st = state.clone();
+                st.push_mapping_key(k)?;
+                if let Some(errmsg) = p.as_resolve_error() {
+                    if opts.ignore_overwritten_missing_references {
+                        #[cfg(not(feature = "bench"))]
+                        eprintln!("[WARN] Ignoring resolve error: {errmsg}");
+                    } else {
+                        return Err(anyhow!(errmsg.clone()));
+                    }
+                } else if opts.verbose_warnings {
+                    if let Value::String(s) = p {
+                        if s.contains("${") {
                             #[cfg(not(feature = "bench"))]
                             eprintln!(
-                                "[WARN] Dropping unrendered {} which may contain \
-                                missing references for parameter '{}'",
-                                p.variant(),
+                                "[WARN] Dropping potentially missing reference in \
+                                overrridden unrendered value '{s}' for parameter '{}'",
                                 st.current_key()
                             );
                         }
+                    } else {
+                        // TODO(sg): can we make this more accurate?
+                        #[cfg(not(feature = "bench"))]
+                        eprintln!(
+                            "[WARN] Dropping unrendered {} which may contain \
+                            missing references for parameter '{}'",
+                            p.variant(),
+                            st.current_key()
+                        );
                     }
                 }
             }
diff --git a/src/types/value.rs b/src/types/value.rs
diff --git a/src/types/value/value_as_py_obj_tests.rs b/src/types/value/value_as_py_obj_tests.rs

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-use criterion::{criterion_group, criterion_main, Criterion};`
	`1`	`+use criterion::{Criterion, criterion_group, criterion_main};`
`2`	`2`	`use rayon::ThreadPoolBuilder;`
`3`	`3`	`use std::hint::black_box;`
`4`	`4`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-use anyhow::{anyhow, Result};`
	`1`	`+use anyhow::{Result, anyhow};`
`2`	`2`	`use chrono::Local;`
`3`	`3`	`use pyo3::prelude::*;`
`4`	`4`	`use pyo3::types::PyDict;`