show proper message when server reference can't be resolved

src/main.rs

@@ -65,23 +65,54 @@ enum ServerReference {
 }
 
 impl ServerReference {
-  pub fn resolve(self, configured_servers: &[Server]) -> Option<Server> {
-    self.resolve_lazy(&mut LazyCell::new(|| configured_servers))
+  pub fn get_name(&self) -> &str {
+    match self {
+      ServerReference::Resolved(server) => &server.ssh_name,
+      ServerReference::Name(name) => name,
+    }
   }
 
+  pub fn resolve(self, configured_servers: &[Server]) -> Option<Server> {
+    match self {
+      ServerReference::Resolved(server) => Some(server),
+      ServerReference::Name(name) => Self::resolve_server_name(&name, configured_servers),
+    }
+  }
   pub fn resolve_lazy<S, F>(self, provider: &mut LazyCell<S, F>) -> Option<Server>
   where
     S: Deref<Target = [Server]>,
-    F: FnOnce() -> S
+    F: FnOnce() -> S,
   {
     match self {
       ServerReference::Resolved(server) => Some(server),
-      ServerReference::Name(name) => provider
-        .iter()
-        .find(|server| server.ssh_name == name)
-        .cloned(),
+      ServerReference::Name(name) => Self::resolve_server_name(&name, provider),
     }
   }
+
+  pub fn try_resolve_lazy<S, F, E>(
+    self,
+    provider: &mut LazyCell<Result<S, E>, F>,
+  ) -> Result<Option<Server>, E>
+  where
+    S: Deref<Target = [Server]>,
+    F: FnOnce() -> Result<S, E>,
+    E: Clone,
+  {
+    match self {
+      ServerReference::Resolved(server) => Ok(Some(server)),
+      ServerReference::Name(name) => provider
+        .as_ref()
+        .map_err(|e| e.clone())
+        .map(|servers| Self::resolve_server_name(&name, servers)),
+    }
+  }
+
+  fn resolve_server_name(name: &str, servers: &[Server]) -> Option<Server> {
+    servers
+      .iter()
+      .find(|server| server.ssh_name == name)
+      .cloned()
+  }
 }
 
 impl FromStr for ServerReference {
@@ -150,8 +181,25 @@ fn main() -> Result<(), String> {
   let args = Args::parse();
   dbg!(&args);
 
-  let configured_servers = parse_server_configuration_from_env()?;
-  dbg!(&configured_servers);
+  let mut configured_servers = LazyCell::new(parse_server_configuration_from_env);
+  let servers = args
+    .servers
+    .iter()
+    .map(|server_reference| {
+      let server_name = server_reference.get_name();
+      server_reference
+        .clone()
+        .try_resolve_lazy(&mut configured_servers)
+        .map_err(|msg| format!("Can't resolve server directory for '{server_name}': {msg}"))
+        .and_then(|opt_server| {
+          opt_server.ok_or(format!(
+            "no server directory has been configured for server '{server_name}'"
+          ))
+        })
+    })
+    .collect::<Result<Vec<_>, _>>()?;
+
+  dbg!(&servers);
 
   Ok(())
 }