Merge pull request #248 from seddonym/cargo-fmt

Cargo fmt

Author: seddonym

.github/workflows/main.yml

@@ -48,6 +48,9 @@ jobs:
           toolchain: stable
       - name: Print versions
         run: cargo version --verbose && cargo clippy --version
+      - name: Check formatting
+        run: cargo fmt --check
+        working-directory: ./rust
       - name: Run tests
         run: cargo test --no-default-features
         working-directory: ./rust

rust/src/filesystem.rs

@@ -9,10 +9,8 @@ use std::path::{Path, PathBuf};
 use std::sync::LazyLock;
 use unindent::unindent;
 
-
-static ENCODING_RE: LazyLock<Regex> = LazyLock::new(|| {
-    Regex::new(r"^[ \t\f]*#.*?coding[:=][ \t]*([-_.a-zA-Z0-9]+)").unwrap()
-});
+static ENCODING_RE: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(r"^[ \t\f]*#.*?coding[:=][ \t]*([-_.a-zA-Z0-9]+)").unwrap());
 
 pub trait FileSystem: Send + Sync {
     fn sep(&self) -> &str;
@@ -47,7 +45,9 @@ impl FileSystem for RealBasicFileSystem {
         for component in components {
             path.push(component);
         }
-        path.to_str().expect("Path components should be valid unicode").to_string()
+        path.to_str()
+            .expect("Path components should be valid unicode")
+            .to_string()
     }
 
     fn split(&self, file_name: &str) -> (String, String) {
@@ -66,8 +66,12 @@ impl FileSystem for RealBasicFileSystem {
         };
 
         (
-            head.to_str().expect("Path components should be valid unicode").to_string(),
-            tail.to_str().expect("Path components should be valid unicode").to_string(),
+            head.to_str()
+                .expect("Path components should be valid unicode")
+                .to_string(),
+            tail.to_str()
+                .expect("Path components should be valid unicode")
+                .to_string(),
         )
     }
 
@@ -88,17 +92,17 @@ impl FileSystem for RealBasicFileSystem {
         })?;
 
         let s = String::from_utf8_lossy(&bytes);
-        
 
         let mut detected_encoding: Option<String> = None;
 
         // Coding specification needs to be in the first two lines, or it's ignored.
         for line in s.lines().take(2) {
             if let Some(captures) = ENCODING_RE.captures(line)
-                && let Some(encoding_name) = captures.get(1) {
-                    detected_encoding = Some(encoding_name.as_str().to_string());
-                    break;
-                }
+                && let Some(encoding_name) = captures.get(1)
+            {
+                detected_encoding = Some(encoding_name.as_str().to_string());
+                break;
+            }
         }
 
         if let Some(enc_name) = detected_encoding {
@@ -217,8 +221,12 @@ impl FileSystem for FakeBasicFileSystem {
             tail = path.file_name().unwrap_or(OsStr::new(""));
         }
         (
-            head.to_str().expect("Path components should be valid unicode").to_string(),
-            tail.to_str().expect("Path components should be valid unicode").to_string(),
+            head.to_str()
+                .expect("Path components should be valid unicode")
+                .to_string(),
+            tail.to_str()
+                .expect("Path components should be valid unicode")
+                .to_string(),
         )
     }
 
@@ -230,7 +238,9 @@ impl FileSystem for FakeBasicFileSystem {
     fn read(&self, file_name: &str) -> PyResult<String> {
         match self.contents.get(file_name) {
             Some(file_name) => Ok(file_name.clone()),
-            None => Err(PyFileNotFoundError::new_err(format!("No such file: {file_name}"))),
+            None => Err(PyFileNotFoundError::new_err(format!(
+                "No such file: {file_name}"
+            ))),
         }
     }
 }
@@ -267,11 +277,11 @@ impl PyFakeBasicFileSystem {
     fn read(&self, file_name: &str) -> PyResult<String> {
         self.inner.read(file_name)
     }
-    
+
     // Temporary workaround method for Python tests.
     fn convert_to_basic(&self) -> PyResult<Self> {
         Ok(PyFakeBasicFileSystem {
-            inner: self.inner.clone()
+            inner: self.inner.clone(),
         })
     }
 }
@@ -354,7 +364,10 @@ pub fn parse_indented_file_system_string(file_system_string: &str) -> HashMap<St
     // Edge case: If the very first line was a file and it ended up on the stack, it needs to be processed.
     // This handles single-file inputs like "myfile.txt"
     if !path_stack.is_empty()
-        && !path_stack.last().expect("path_stack should be non-empty").ends_with('/')
+        && !path_stack
+            .last()
+            .expect("path_stack should be non-empty")
+            .ends_with('/')
         && !file_paths_map.contains_key(&path_stack.join("/"))
     {
         file_paths_map.insert(path_stack.join("/"), String::new());

rust/src/graph/mod.rs

@@ -15,18 +15,12 @@ pub mod import_chain_queries;
 
 pub(crate) mod pathfinding;
 
-static MODULE_NAMES: LazyLock<RwLock<StringInterner<StringBackend>>> = LazyLock::new(|| {
-    RwLock::new(StringInterner::default())
-});
-static IMPORT_LINE_CONTENTS: LazyLock<RwLock<StringInterner<StringBackend>>> = LazyLock::new(|| {
-    RwLock::new(StringInterner::default())
-});
-static EMPTY_MODULE_TOKENS: LazyLock<FxHashSet<ModuleToken>> = LazyLock::new(|| {
-    FxHashSet::default()
-});
-static EMPTY_IMPORT_DETAILS: LazyLock<FxHashSet<ImportDetails>> = LazyLock::new(|| {
-    FxHashSet::default()
-});
+static MODULE_NAMES: LazyLock<RwLock<StringInterner<StringBackend>>> =
+    LazyLock::new(|| RwLock::new(StringInterner::default()));
+static IMPORT_LINE_CONTENTS: LazyLock<RwLock<StringInterner<StringBackend>>> =
+    LazyLock::new(|| RwLock::new(StringInterner::default()));
+static EMPTY_MODULE_TOKENS: LazyLock<FxHashSet<ModuleToken>> = LazyLock::new(FxHashSet::default);
+static EMPTY_IMPORT_DETAILS: LazyLock<FxHashSet<ImportDetails>> = LazyLock::new(FxHashSet::default);
 
 new_key_type! { pub struct ModuleToken; }
 

rust/src/module_expressions.rs

@@ -6,9 +6,8 @@ use std::fmt::Display;
 use std::str::FromStr;
 use std::sync::LazyLock;
 
-static MODULE_EXPRESSION_PATTERN: LazyLock<Regex> = LazyLock::new(|| {
-        Regex::new(r"^(\w+|\*{1,2})(\.(\w+|\*{1,2}))*$").unwrap()
-});
+static MODULE_EXPRESSION_PATTERN: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(r"^(\w+|\*{1,2})(\.(\w+|\*{1,2}))*$").unwrap());
 
 /// A module expression is used to refer to sets of modules.
 ///