Add find_shortest_cycle to pathfinding

Author: Peter554

rust/src/graph/pathfinding.rs

@@ -1,6 +1,7 @@
 use crate::errors::{GrimpError, GrimpResult};
 use crate::graph::{Graph, ModuleToken, EMPTY_MODULE_TOKENS};
 use indexmap::{IndexMap, IndexSet};
+use itertools::Itertools;
 use rustc_hash::{FxHashMap, FxHashSet, FxHasher};
 use slotmap::SecondaryMap;
 use std::hash::BuildHasherDefault;
@@ -49,6 +50,23 @@ pub fn find_shortest_path(
     )
 }
 
+/// Finds the shortest cycle from `modules` to `modules`, via a bidirectional BFS.
+pub fn find_shortest_cycle(
+    graph: &Graph,
+    modules: &FxHashSet<ModuleToken>,
+    excluded_modules: &FxHashSet<ModuleToken>,
+    excluded_imports: &FxHashMap<ModuleToken, FxHashSet<ModuleToken>>,
+) -> GrimpResult<Option<Vec<ModuleToken>>> {
+    // Exclude imports internal to `modules`
+    let mut excluded_imports = excluded_imports.clone();
+    for (m1, m2) in modules.iter().tuple_combinations() {
+        excluded_imports.entry(*m1).or_default().insert(*m2);
+        excluded_imports.entry(*m2).or_default().insert(*m1);
+    }
+
+    _find_shortest_path(graph, modules, modules, excluded_modules, &excluded_imports)
+}
+
 fn _find_shortest_path(
     graph: &Graph,
     from_modules: &FxHashSet<ModuleToken>,
@@ -140,3 +158,105 @@ fn import_is_excluded(
             .contains(to_module)
     }
 }
+
+#[cfg(test)]
+mod test_find_shortest_cycle {
+    use super::*;
+
+    #[test]
+    fn test_finds_cycle_single_module() -> GrimpResult<()> {
+        let mut graph = Graph::default();
+        let foo = graph.get_or_add_module("foo").token;
+        let bar = graph.get_or_add_module("bar").token;
+        let baz = graph.get_or_add_module("baz").token;
+        let x = graph.get_or_add_module("x").token;
+        let y = graph.get_or_add_module("y").token;
+        let z = graph.get_or_add_module("z").token;
+        // Shortest cycle
+        graph.add_import(foo, bar);
+        graph.add_import(bar, baz);
+        graph.add_import(baz, foo);
+        // Longer cycle
+        graph.add_import(foo, x);
+        graph.add_import(x, y);
+        graph.add_import(y, z);
+        graph.add_import(z, foo);
+
+        let path = find_shortest_cycle(
+            &graph,
+            &foo.into(),
+            &FxHashSet::default(),
+            &FxHashMap::default(),
+        )?;
+        assert_eq!(path, Some(vec![foo, bar, baz, foo]));
+
+        graph.remove_import(baz, foo);
+
+        let path = find_shortest_cycle(
+            &graph,
+            &foo.into(),
+            &FxHashSet::default(),
+            &FxHashMap::default(),
+        )?;
+        assert_eq!(path, Some(vec![foo, x, y, z, foo]));
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_returns_none_if_no_cycle() -> GrimpResult<()> {
+        let mut graph = Graph::default();
+        let foo = graph.get_or_add_module("foo").token;
+        let bar = graph.get_or_add_module("bar").token;
+        let baz = graph.get_or_add_module("baz").token;
+        graph.add_import(foo, bar);
+        graph.add_import(bar, baz);
+
+        let path = find_shortest_cycle(
+            &graph,
+            &foo.into(),
+            &FxHashSet::default(),
+            &FxHashMap::default(),
+        )?;
+
+        assert_eq!(path, None);
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_finds_cycle_multiple_module() -> GrimpResult<()> {
+        let mut graph = Graph::default();
+
+        graph.get_or_add_module("colors");
+        let red = graph.get_or_add_module("colors.red").token;
+        let blue = graph.get_or_add_module("colors.blue").token;
+        let a = graph.get_or_add_module("a").token;
+        let b = graph.get_or_add_module("b").token;
+        let c = graph.get_or_add_module("c").token;
+        let d = graph.get_or_add_module("d").token;
+
+        // The computation should not be confused by these two imports internal to `modules`.
+        graph.add_import(red, blue);
+        graph.add_import(blue, red);
+        // This is the part we expect to find.
+        graph.add_import(red, a);
+        graph.add_import(a, b);
+        graph.add_import(b, blue);
+        // A longer path.
+        graph.add_import(a, c);
+        graph.add_import(c, d);
+        graph.add_import(d, b);
+
+        let path = find_shortest_cycle(
+            &graph,
+            &FxHashSet::from_iter([red, blue]),
+            &FxHashSet::default(),
+            &FxHashMap::default(),
+        )?;
+
+        assert_eq!(path, Some(vec![red, a, b, blue]));
+
+        Ok(())
+    }
+}