fix(parser): handle include in hosts

Closes #118

Signed-off-by: Nathanael DEMACON <quantumsheep@users.noreply.github.com>

Author: quantumsheep

Cargo.lock

@@ -32,3 +32,6 @@ strum = "0.26.3"
 strum_macros = "0.26.4"
 tui-input = "0.11.1"
 unicode-width = "0.2.0"
+
+[dev-dependencies]
+tempdir = "0.3.7"

Cargo.toml

@@ -4,7 +4,6 @@ use strum_macros;
 #[derive(Debug, strum_macros::Display, strum_macros::EnumString, Eq, PartialEq, Hash, Clone)]
 #[strum(ascii_case_insensitive)]
 pub enum EntryType {
-    #[strum(disabled)]
     Unknown(String),
     Host,
     Match,

src/ssh_config/host_entry.rs

@@ -58,8 +58,7 @@ impl Parser {
     }
 
     fn parse_raw(&self, reader: &mut impl BufRead) -> Result<(Host, Vec<Host>), ParseError> {
-        let mut global_host = Host::new(Vec::new());
-        let mut is_in_host_block = false;
+        let mut parent_host = Host::new(Vec::new());
         let mut hosts = Vec::new();
 
         let mut line = String::new();
@@ -86,7 +85,6 @@ impl Parser {
                 EntryType::Host => {
                     let patterns = parse_patterns(&entry.1);
                     hosts.push(Host::new(patterns));
-                    is_in_host_block = true;
 
                     continue;
                 }
@@ -122,44 +120,33 @@ impl Parser {
                         };
 
                         let mut file = BufReader::new(File::open(path)?);
-                        let (included_global_host, included_hosts) = self.parse_raw(&mut file)?;
-
-                        if is_in_host_block {
-                            // Can't include hosts inside a host block
-                            if !included_hosts.is_empty() {
-                                return Err(InvalidIncludeError {
-                                    line,
-                                    details: InvalidIncludeErrorDetails::HostsInsideHostBlock,
-                                }
-                                .into());
-                            }
+                        let (included_parent_host, included_hosts) = self.parse_raw(&mut file)?;
 
+                        if hosts.is_empty() {
+                            parent_host.extend_entries(&included_parent_host);
+                        } else {
                             hosts
                                 .last_mut()
                                 .unwrap()
-                                .extend_entries(&included_global_host);
-                        } else {
-                            if !included_global_host.is_empty() {
-                                global_host.extend_entries(&included_global_host);
-                            }
-
-                            hosts.extend(included_hosts);
+                                .extend_entries(&included_parent_host);
                         }
+
+                        hosts.extend(included_hosts);
                     }
 
                     continue;
                 }
                 _ => {}
             }
 
-            if is_in_host_block {
-                hosts.last_mut().unwrap().update(entry);
+            if hosts.is_empty() {
+                parent_host.update(entry);
             } else {
-                global_host.update(entry);
+                hosts.last_mut().unwrap().update(entry);
             }
         }
 
-        Ok((global_host, hosts))
+        Ok((parent_host, hosts))
     }
 }
 
@@ -218,3 +205,172 @@ fn parse_patterns(entry_value: &str) -> Vec<String> {
 
     patterns
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs::File;
+    use std::io::{BufReader, Write};
+    use tempdir::TempDir;
+
+    #[test]
+    fn test_basic_host_parsing() {
+        let config = r#"
+            Host example
+              User testuser
+              Port 22
+        "#;
+        let mut reader = BufReader::new(config.as_bytes());
+        let parser = Parser::new();
+        let result = parser.parse(&mut reader).unwrap();
+
+        assert_eq!(result.len(), 1);
+        let patterns = result[0].get_patterns();
+        assert!(patterns.contains(&"example".to_string()));
+        assert_eq!(result[0].get(&EntryType::User).unwrap(), "testuser");
+        assert_eq!(result[0].get(&EntryType::Port).unwrap(), "22");
+    }
+
+    #[test]
+    fn test_global_settings_applied_to_all_hosts() {
+        let config = r#"
+            User globaluser
+
+            Host server1
+              Port 22
+
+            Host server2
+              Port 2200
+        "#;
+        let mut reader = BufReader::new(config.as_bytes());
+        let parser = Parser::new();
+        let result = parser.parse(&mut reader).unwrap();
+
+        assert_eq!(result.len(), 2);
+        for host in result {
+            assert_eq!(host.get(&EntryType::User).unwrap(), "globaluser");
+        }
+    }
+
+    #[test]
+    fn test_include_file_parsing() {
+        let include_content = r#"
+            Host included
+              Port 2222
+        "#;
+
+        let temp_dir = TempDir::new("sshs").unwrap();
+        let temp_file_path = temp_dir.path().join("included_config");
+        let mut temp_file = File::create(&temp_file_path).unwrap();
+        write!(temp_file, "{}", include_content).unwrap();
+
+        let config = format!(
+            r#"
+                Include {}
+                Host main
+                  Port 22
+            "#,
+            temp_file_path.display()
+        );
+
+        let mut reader = BufReader::new(config.as_bytes());
+        let parser = Parser::new();
+        let result = parser.parse(&mut reader).unwrap();
+
+        assert_eq!(result.len(), 2);
+        let all_patterns: Vec<String> = result
+            .iter()
+            .flat_map(|host| host.get_patterns())
+            .cloned()
+            .collect();
+        assert!(all_patterns.contains(&"included".to_string()));
+        assert!(all_patterns.contains(&"main".to_string()));
+    }
+
+    #[test]
+    fn test_unknown_entry_error_when_not_ignored() {
+        let config = r#"
+            BogusEntry something
+            Host test
+              Port 22
+        "#;
+        let mut reader = BufReader::new(config.as_bytes());
+        let mut parser = Parser::new();
+        parser.ignore_unknown_entries = false;
+
+        let result = parser.parse(&mut reader);
+        assert!(result.is_err());
+        assert!(matches!(result.unwrap_err(), ParseError::UnknownEntry(_)));
+    }
+
+    #[test]
+    fn test_unknown_entry_ignored_when_flag_set() {
+        let config = r#"
+            BogusEntry something
+            Host test
+              Port 22
+        "#;
+        let mut reader = BufReader::new(config.as_bytes());
+        let parser = Parser::new();
+
+        let result = parser.parse(&mut reader);
+        assert!(result.is_ok());
+        let hosts = result.unwrap();
+        assert_eq!(hosts.len(), 1);
+    }
+
+    #[test]
+    fn test_comment_lines_ignored() {
+        let config = r#"
+            # This is a comment
+            Host test # trailing comment
+              User testuser # inline comment
+        "#;
+        let mut reader = BufReader::new(config.as_bytes());
+        let parser = Parser::new();
+
+        let result = parser.parse(&mut reader).unwrap();
+        assert_eq!(result.len(), 1);
+        assert_eq!(result[0].get(&EntryType::User).unwrap(), "testuser");
+    }
+
+    #[test]
+    fn test_unparseable_line_error() {
+        let config = r#"
+            UnparseableLineWithoutValue
+        "#;
+        let mut reader = BufReader::new(config.as_bytes());
+        let parser = Parser::new();
+
+        let result = parser.parse(&mut reader);
+        assert!(matches!(
+            result.unwrap_err(),
+            ParseError::UnparseableLine(_)
+        ));
+    }
+
+    #[test]
+    fn test_parse_patterns_handles_quotes() {
+        let patterns = parse_patterns(r#""host one" host2 "host three""#);
+        assert_eq!(patterns, vec!["host one", "host2", "host three"]);
+    }
+
+    #[test]
+    fn test_parse_file_from_path() {
+        let content = r#"
+            Host fromfile
+              Port 2222
+        "#;
+
+        let temp_dir = TempDir::new("sshs").unwrap();
+        let temp_file_path = temp_dir.path().join("included_config");
+        let mut temp_file = File::create(&temp_file_path).unwrap();
+        write!(temp_file, "{}", content).unwrap();
+
+        let parser = Parser::new();
+        let result = parser.parse_file(temp_file_path).unwrap();
+
+        assert_eq!(result.len(), 1);
+        assert!(result[0].get_patterns().contains(&"fromfile".to_string()));
+    }
+}