Add allow_unconnected_components config option

When `true`, the graph will be considered valid even if it has
unconnected components that are not reachable from the root.

Signed-off-by: Sahas Subramanian <[email protected]>

Author: shsms

src/config.rs

@@ -6,6 +6,10 @@
 /// Configuration options for the `ComponentGraph`.
 #[derive(Clone, Default, Debug)]
 pub struct ComponentGraphConfig {
+    /// Whether to allow unconnected components in the graph, that are not
+    /// reachable from the root.
+    pub allow_unconnected_components: bool,
+
     /// Whether to allow untyped inverters in the graph.  When this is `true`,
     /// inverters that have `InverterType::Unspecified` will be assumed to be
     /// Battery inverters.

src/graph/creation.rs

@@ -175,7 +175,8 @@ mod tests {
         // are treated as battery inverters.
         assert!(builder
             .build(Some(ComponentGraphConfig {
-                allow_unspecified_inverters: true
+                allow_unspecified_inverters: true,
+                ..Default::default()
             }))
             .is_ok());
 

src/graph/formulas/generators/battery.rs

@@ -206,6 +206,7 @@ mod tests {
 
         let graph = builder.build(Some(ComponentGraphConfig {
             allow_unspecified_inverters: true,
+            ..Default::default()
         }))?;
         let formula = graph.battery_formula(None)?;
         assert_eq!(

src/graph/validation.rs

@@ -38,8 +38,14 @@ where
         validator.validate_acyclicity(root, vec![])?;
 
         let mut errors = vec![];
+        let mut validation_failed = false;
+
+        if let Err(err) = validator.validate_connected_graph(root) {
+            errors.push(err);
+            validation_failed = !self.config.allow_unconnected_components;
+        }
+
         for result in [
-            validator.validate_connected_graph(root),
             validator.validate_root(),
             validator.validate_meters(),
             validator.validate_inverters(),
@@ -49,18 +55,33 @@ where
         ] {
             if let Err(e) = result {
                 errors.push(e);
+                validation_failed = true;
             }
         }
-        if errors.len() == 1 {
-            return Err(errors[0].clone());
-        } else if !errors.is_empty() {
-            let error_messages = "Multiple validation failures:\n    ".to_string()
-                + &errors
-                    .into_iter()
-                    .map(|e| e.to_string())
-                    .collect::<Vec<_>>()
-                    .join("\n    ");
-            return Err(Error::invalid_graph(error_messages));
+        match errors.len() {
+            0 => {}
+            1 => {
+                if validation_failed {
+                    return Err(errors[0].clone());
+                } else {
+                    tracing::warn!("{}", errors[0]);
+                }
+            }
+            _ => {
+                let err = Error::invalid_graph(format!(
+                    "Multiple validation failures:\n    {}",
+                    errors
+                        .iter()
+                        .map(ToString::to_string)
+                        .collect::<Vec<_>>()
+                        .join("\n    ")
+                ));
+                if validation_failed {
+                    return Err(err);
+                } else {
+                    tracing::warn!("{}", err);
+                }
+            }
         }
         Ok(())
     }

src/graph/validation/validate_graph.rs

@@ -152,12 +152,23 @@ mod tests {
 
         connections.push(TestConnection::new(11, 12));
 
+        // With the default config, this fails validation.
         assert!(
             ComponentGraph::try_new(components.clone(), connections.clone(), config.clone())
                 .is_err_and(
                     |e| e == Error::invalid_graph("Nodes [11, 12] are not connected to the root.")
                 )
         );
+        // With `allow_unconnected_components=true`, this passes validation.
+        assert!(ComponentGraph::try_new(
+            components.clone(),
+            connections.clone(),
+            ComponentGraphConfig {
+                allow_unconnected_components: true,
+                ..config.clone()
+            }
+        )
+        .is_ok());
 
         connections.pop();
         components.pop();