Merge pull request #31 from iancleary/feat/abcd-matrices

Feat/abcd matrices

Author: iancleary

Cargo.lock

@@ -7,7 +7,7 @@ homepage = "https://github.com/iancleary/touchstone"
 license = "MIT"
 name = "touchstone"
 repository = "https://github.com/iancleary/touchstone"
-version = "0.8.5"
+version = "0.9.0"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 

Cargo.toml

@@ -16,7 +16,7 @@ impl Config {
             return Err("not enough arguments");
         }
 
-        if args.len() > 2 {
+        if args.len() > 2 && args[1] != "cascade" {
             return Err("too many arguments, expecting only 2, such as `touchstone filepath`");
         }
 
@@ -30,7 +30,92 @@ impl Config {
                 print_help();
                 process::exit(0);
             }
-            _ => {}
+            "cascade" => {
+                // Parse arguments for --name or -n
+                let mut output_name: Option<String> = None;
+                let mut file_paths = Vec::new();
+
+                let mut i = 2;
+                while i < args.len() {
+                    match args[i].as_str() {
+                        "--name" | "-n" => {
+                            if i + 1 < args.len() {
+                                output_name = Some(args[i + 1].clone());
+                                i += 2;
+                            } else {
+                                return Err("missing argument for --name");
+                            }
+                        }
+                        _ => {
+                            file_paths.push(args[i].clone());
+                            i += 1;
+                        }
+                    }
+                }
+
+                if file_paths.len() < 2 {
+                    return Err(
+                        "cascade requires at least 2 files, e.g. `touchstone cascade file1 file2`",
+                    );
+                }
+
+                let mut networks = Vec::new();
+                for path in file_paths.iter() {
+                    networks.push(Network::new(path.clone()));
+                }
+
+                let mut result = networks[0].clone();
+                // Cascade remaining networks
+                for network in networks.iter().skip(1) {
+                    result = result * network.clone();
+                }
+
+                // Determine output path
+                let output_s2p_path = if let Some(name) = output_name {
+                    // If name is provided, use it.
+                    // If it doesn't have an extension, add .s2p?
+                    // Let's assume user provides full filename or we just use it as is.
+                    // But we should probably ensure it ends in .s2p for consistency?
+                    // The prompt says "output s2p file", so let's trust the user or append if missing?
+                    // Let's just use it as is for now.
+                    name
+                } else {
+                    // Default behavior: first file directory, "cascaded_result.html" (but we need s2p now)
+                    let first_file = &file_paths[0];
+                    let path = std::path::Path::new(first_file);
+                    let parent = path.parent().unwrap_or(std::path::Path::new("."));
+                    parent
+                        .join("cascaded_result.s2p")
+                        .to_string_lossy()
+                        .to_string()
+                };
+
+                // Save S2P file
+                if let Err(e) = result.save(&output_s2p_path) {
+                    eprintln!("Failed to save S2P file: {}", e);
+                    // Continue to plot generation? Or return error?
+                    // Let's return error.
+                    return Err("Failed to save S2P file");
+                }
+                println!("Saved cascaded network to {}", output_s2p_path);
+
+                // Generate plot
+                // Plot should be named based on the output s2p file
+                // e.g. output.s2p -> output.s2p.html
+                let output_html_path = format!("{}.html", output_s2p_path);
+
+                generate_plot(&result, output_html_path.clone());
+                open::plot(output_html_path);
+
+                return Ok(Config {});
+            }
+            _ => {
+                if args.len() > 2 {
+                    return Err(
+                        "too many arguments, expecting only 2, such as `touchstone filepath`",
+                    );
+                }
+            }
         }
 
         // cargo run arg[1], such as cargo run files/ntwk1.s2p
@@ -159,15 +244,38 @@ mod tests {
     use std::fs;
 
     use super::*;
+    use std::path::PathBuf;
+
+    fn setup_test_dir(name: &str) -> PathBuf {
+        let mut path = std::env::temp_dir();
+        path.push("touchstone_tests");
+        path.push(name);
+        path.push(format!(
+            "{}",
+            std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap()
+                .as_nanos()
+        ));
+        std::fs::create_dir_all(&path).unwrap();
+        path
+    }
+
     #[test]
     fn test_config_build() {
+        let test_dir = setup_test_dir("test_config_build");
+        let s2p_path = test_dir.join("test_cli_config_build.s2p");
+        fs::copy("files/test_cli_config_build.s2p", &s2p_path).unwrap();
+
         let args = vec![
             String::from("program_name"),
-            String::from("files/test_cli_config_build.s2p"),
+            s2p_path.to_str().unwrap().to_string(),
         ];
         let _cli_run = Config::run(&args).unwrap();
-        let _remove_file = fs::remove_file("files/test_cli_config_build.s2p.html");
-        let _remove_js_folder = fs::remove_dir_all("files/js");
+
+        // Cleanup is optional as it's in temp dir, but good practice if we want to check it doesn't fail
+        // let _remove_file = fs::remove_file(s2p_path.with_extension("s2p.html"));
+        // let _remove_js_folder = fs::remove_dir_all(test_dir.join("js"));
     }
 
     #[test]
@@ -212,12 +320,28 @@ mod tests {
     #[test]
     fn test_run_function() {
         // test relative file
-        let relative_path = String::from("files/test_cli_run_relative_path.s2p");
-        parse_plot_open_in_browser(relative_path);
-        let _relative_remove_file = fs::remove_file("files/test_cli_run_relative_path.s2p.html");
-        let _relative_remove_dir = fs::remove_dir_all("files/js");
+        let test_dir_rel = setup_test_dir("test_run_function_rel");
+        // Create a "files" subdir to match the relative path structure expected if needed,
+        // or just use the file in the temp dir.
+        // The original test used "files/test_cli_run_relative_path.s2p".
+        // parse_plot_open_in_browser handles relative paths.
+
+        let s2p_path_rel = test_dir_rel.join("test_cli_run_relative_path.s2p");
+        fs::copy("files/test_cli_run_relative_path.s2p", &s2p_path_rel).unwrap();
+
+        parse_plot_open_in_browser(s2p_path_rel.to_str().unwrap().to_string());
+        // Output should be next to it
+        assert!(s2p_path_rel.with_extension("s2p.html").exists());
+        assert!(test_dir_rel.join("js").exists());
 
         // test bare filename
+        // This MUST run in CWD because we pass a bare filename.
+        // We can't easily isolate this without changing CWD.
+        // But since we moved other tests out of "files/", this test (using root) shouldn't conflict
+        // with them, UNLESS another test uses root.
+        // The only other test using root is this one.
+        // So we keep it as is, but maybe add a lock if we add more root tests.
+
         let _bare_filename_copy = fs::copy(
             "files/test_cli_run_bare_filename.s2p",
             "test_cli_run_bare_filename.s2p",
@@ -229,13 +353,70 @@ mod tests {
             fs::remove_file("test_cli_run_bare_filename.s2p.html");
         let _bare_filename_remove_dir = fs::remove_dir_all("js");
 
-        // This fails if "files/ntwk1.s2p" is missing on disk
-        let path_buf = std::fs::canonicalize("files/test_cli_run_absolute_path.s2p").unwrap();
+        // test absolute path
+        let test_dir_abs = setup_test_dir("test_run_function_abs");
+        let s2p_path_abs = test_dir_abs.join("test_cli_run_absolute_path.s2p");
+        fs::copy("files/test_cli_run_absolute_path.s2p", &s2p_path_abs).unwrap();
+
+        let path_buf = std::fs::canonicalize(&s2p_path_abs).unwrap();
         let absolute_path: String = path_buf.to_string_lossy().to_string();
+
         parse_plot_open_in_browser(absolute_path);
-        // don't remove s2p file in files/
-        let _absolute_path_remove_file_html =
-            fs::remove_file("files/test_cli_run_absolute_path.s2p.html");
-        let _absolute_path_remove_dir = fs::remove_dir_all("files/js");
+
+        assert!(s2p_path_abs.with_extension("s2p.html").exists());
+        assert!(test_dir_abs.join("js").exists());
+    }
+
+    #[test]
+    fn test_cascade_command() {
+        let test_dir = setup_test_dir("test_cascade_command");
+        let s2p1 = test_dir.join("ntwk1.s2p");
+        let s2p2 = test_dir.join("ntwk2.s2p");
+
+        fs::copy("files/ntwk1.s2p", &s2p1).unwrap();
+        fs::copy("files/ntwk2.s2p", &s2p2).unwrap();
+
+        // Test default output
+        let args = vec![
+            String::from("program_name"),
+            String::from("cascade"),
+            s2p1.to_str().unwrap().to_string(),
+            s2p2.to_str().unwrap().to_string(),
+        ];
+
+        let _cli_run = Config::run(&args).unwrap();
+
+        let expected_output_s2p = test_dir.join("cascaded_result.s2p");
+        let expected_output_html = test_dir.join("cascaded_result.s2p.html");
+        assert!(expected_output_s2p.exists());
+        assert!(expected_output_html.exists());
+        assert!(test_dir.join("js").exists());
+
+        // Test with --name
+        let output_name = test_dir.join("custom_output.s2p");
+        let args_named = vec![
+            String::from("program_name"),
+            String::from("cascade"),
+            s2p1.to_str().unwrap().to_string(),
+            s2p2.to_str().unwrap().to_string(),
+            String::from("--name"),
+            output_name.to_str().unwrap().to_string(),
+        ];
+
+        let _cli_run_named = Config::run(&args_named).unwrap();
+
+        assert!(output_name.exists());
+        assert!(output_name.with_extension("s2p.html").exists());
+    }
+
+    #[test]
+    fn test_cascade_not_enough_args() {
+        let args = vec![
+            String::from("program_name"),
+            String::from("cascade"),
+            String::from("file1"),
+        ];
+        let result = Config::run(&args);
+        assert!(result.is_err());
     }
 }