Update scan command to display module names in output format and add wildcard filter matching (#9)

* Initial plan

* Update scan output to include module names in format "<filename>": "module.<module_name>"

Co-authored-by: manoelhc <185583+manoelhc@users.noreply.github.com>

* Add test to verify scan returns module names

Co-authored-by: manoelhc <185583+manoelhc@users.noreply.github.com>

* Add wildcard matching support for scan filters

Co-authored-by: manoelhc <185583+manoelhc@users.noreply.github.com>

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: manoelhc <185583+manoelhc@users.noreply.github.com>

Author: Copilot

src/lib.rs

@@ -1020,57 +1020,71 @@ pub fn find_all_tf_files(dir: &std::path::Path) -> Result<Vec<PathBuf>> {
     Ok(tf_files)
 }
 
-pub fn scan_files(query: &str, dir: &std::path::Path) -> Result<Vec<PathBuf>> {
+pub fn scan_files(query: &str, dir: &std::path::Path) -> Result<Vec<(PathBuf, String)>> {
     let scan_query = parse_scan_query(query)?;
     let tf_files = find_all_tf_files(dir)?;
 
-    let mut matching_files = Vec::new();
+    let mut results = Vec::new();
 
     for file_path in tf_files {
-        if matches_query(&file_path, &scan_query)? {
-            matching_files.push(file_path);
+        let module_names = find_matching_modules(&file_path, &scan_query)?;
+        for module_name in module_names {
+            results.push((file_path.clone(), module_name));
         }
     }
 
-    Ok(matching_files)
+    Ok(results)
 }
 
-fn matches_query(file_path: &std::path::Path, scan_query: &ScanQuery) -> Result<bool> {
+fn find_matching_modules(file_path: &std::path::Path, scan_query: &ScanQuery) -> Result<Vec<String>> {
     let content = fs::read_to_string(file_path)
         .with_context(|| format!("Failed to read file: {:?}", file_path))?;
 
     let body: Body = content
         .parse()
         .with_context(|| format!("Failed to parse HCL: {:?}", file_path))?;
 
+    let mut matching_modules = Vec::new();
+    
     // Look for blocks matching the query
     for structure in body.iter() {
         if let Some(block) = structure.as_block() {
             if block.ident.as_str() != scan_query.block_type {
                 continue;
             }
 
+            // Get the block label (module name for module blocks)
+            let labels: Vec<String> = block
+                .labels
+                .iter()
+                .map(|l| l.as_str().to_string())
+                .collect();
+            
+            let block_label = labels.first().map(|s| s.as_str());
+            
             // Check block label if specified
             if let Some(ref expected_label) = scan_query.block_label {
-                let labels: Vec<String> = block
-                    .labels
-                    .iter()
-                    .map(|l| l.as_str().to_string())
-                    .collect();
-                
-                if labels.first().map(|s| s.as_str()) != Some(expected_label.as_str()) {
+                if block_label != Some(expected_label.as_str()) {
                     continue;
                 }
             }
 
             // If no nested blocks or attribute specified, we found a match
             if scan_query.nested_blocks.is_empty() && scan_query.attribute.is_none() {
-                return Ok(true);
+                // For blocks with labels (like modules), use the label
+                // For blocks without labels (like terraform), use the block type
+                if let Some(label) = block_label {
+                    matching_modules.push(label.to_string());
+                } else {
+                    matching_modules.push(scan_query.block_type.clone());
+                }
+                continue;
             }
 
             // Navigate through nested blocks
             let mut current_body = &block.body;
 
+            let mut nested_matched = true;
             for nested_name in &scan_query.nested_blocks {
                 let mut found_this_level = false;
 
@@ -1085,11 +1099,15 @@ fn matches_query(file_path: &std::path::Path, scan_query: &ScanQuery) -> Result<
                 }
 
                 if !found_this_level {
-                    // Couldn't find nested block, so this file doesn't match
-                    return Ok(false);
+                    nested_matched = false;
+                    break;
                 }
             }
 
+            if !nested_matched {
+                continue;
+            }
+            
             // Check attribute if specified
             if let Some(ref attr_name) = scan_query.attribute {
                 for item in current_body.iter() {
@@ -1103,27 +1121,91 @@ fn matches_query(file_path: &std::path::Path, scan_query: &ScanQuery) -> Result<
                                 }
                             }
 
-                            return Ok(true);
+                            // For blocks with labels, use the label
+                            // For blocks without labels, use the block type
+                            if let Some(label) = block_label {
+                                matching_modules.push(label.to_string());
+                            } else {
+                                matching_modules.push(scan_query.block_type.clone());
+                            }
+                            break;
                         }
                     }
                 }
             } else {
                 // No specific attribute required, nested blocks matched
-                return Ok(true);
+                if let Some(label) = block_label {
+                    matching_modules.push(label.to_string());
+                } else {
+                    matching_modules.push(scan_query.block_type.clone());
+                }
             }
         }
     }
 
-    Ok(false)
+    Ok(matching_modules)
 }
 
 fn matches_filter(value_str: &str, filter: &AttributeFilter) -> Result<bool> {
     // Extract the value based on the filter attribute (url, ref, path, etc.)
     let extracted = extract_param_from_source(value_str, &filter.attribute)?;
 
     if let Some(extracted_value) = extracted {
-        Ok(extracted_value == filter.value)
+        Ok(wildcard_match(&filter.value, &extracted_value))
     } else {
         Ok(false)
     }
 }
+
+fn wildcard_match(pattern: &str, text: &str) -> bool {
+    // Simple wildcard matching with * as wildcard
+    // If no wildcards, do exact match
+    if !pattern.contains('*') {
+        return pattern == text;
+    }
+    
+    let parts: Vec<&str> = pattern.split('*').collect();
+    
+    // Handle edge cases
+    if parts.is_empty() {
+        return true;
+    }
+    
+    let mut text_pos = 0;
+    
+    for (i, part) in parts.iter().enumerate() {
+        if part.is_empty() {
+            continue;
+        }
+        
+        // First part must match at the beginning (unless pattern starts with *)
+        if i == 0 && !pattern.starts_with('*') {
+            if !text[text_pos..].starts_with(part) {
+                return false;
+            }
+            text_pos += part.len();
+        }
+        // Last part must match at the end (unless pattern ends with *)
+        else if i == parts.len() - 1 && !pattern.ends_with('*') {
+            if !text[text_pos..].ends_with(part) {
+                return false;
+            }
+            // Move position to the end
+            if let Some(pos) = text[text_pos..].rfind(part) {
+                text_pos += pos + part.len();
+            } else {
+                return false;
+            }
+        }
+        // Middle parts can be anywhere after current position
+        else {
+            if let Some(pos) = text[text_pos..].find(part) {
+                text_pos += pos + part.len();
+            } else {
+                return false;
+            }
+        }
+    }
+    
+    true
+}

src/main.rs

@@ -61,9 +61,9 @@ fn main() -> Result<()> {
             set_value(&query, &value, file.as_deref())?;
         }
         Commands::Scan { query, dir } => {
-            let files = scan_files(&query, &dir)?;
-            for file in files {
-                println!("{}", file.display());
+            let results = scan_files(&query, &dir)?;
+            for (file, module_name) in results {
+                println!("\"{}\": \"module.{}\"", file.display(), module_name);
             }
         }
     }

tests/scan_tests.rs

@@ -120,6 +120,38 @@ fn test_scan_with_path_filter() {
     assert_eq!(results.len(), 1);
 }
 
+#[test]
+fn test_scan_with_wildcard_url_filter() {
+    let files = vec![
+        ("main.tf", common::SIMPLE_MODULE_TF),
+        ("other.tf", common::MODULE_WITH_PATH_TF),
+    ];
+    let temp_dir = common::create_test_dir_with_files(&files);
+    
+    // Test wildcard matching with *
+    let results = scan_files(
+        "module.*.source[url==\"*terraform-aws-modules*vpc*\"]",
+        temp_dir.path()
+    ).unwrap();
+    assert_eq!(results.len(), 1); // Should match SIMPLE_MODULE_TF which has terraform-aws-modules/terraform-aws-vpc
+}
+
+#[test]
+fn test_scan_with_wildcard_ref_filter() {
+    let files = vec![
+        ("main.tf", common::SIMPLE_MODULE_TF),
+        ("other.tf", common::MODULE_WITH_PATH_TF),
+    ];
+    let temp_dir = common::create_test_dir_with_files(&files);
+    
+    // Test wildcard matching with ref
+    let results = scan_files(
+        "module.*.source[ref==\"v*.0.0\"]",
+        temp_dir.path()
+    ).unwrap();
+    assert_eq!(results.len(), 2); // Both have v*.0.0 pattern
+}
+
 #[test]
 fn test_scan_nested_directories() {
     let files = vec![
@@ -219,7 +251,7 @@ fn test_scan_multiple_modules_in_one_file() {
     let temp_dir = common::create_test_dir_with_files(&files);
 
     let results = scan_files("module.*", temp_dir.path()).unwrap();
-    assert_eq!(results.len(), 1); // One file with multiple modules
+    assert_eq!(results.len(), 2); // Two modules in one file
 }
 
 #[test]
@@ -235,3 +267,19 @@ fn test_scan_specific_module_in_multi_module_file() {
     let results_vpc = scan_files("module.vpc", temp_dir.path()).unwrap();
     assert_eq!(results_vpc.len(), 1);
 }
+
+#[test]
+fn test_scan_returns_module_names() {
+    let files = vec![
+        ("main.tf", common::MULTIPLE_MODULES_TF),
+    ];
+    let temp_dir = common::create_test_dir_with_files(&files);
+    
+    let results = scan_files("module.*", temp_dir.path()).unwrap();
+    assert_eq!(results.len(), 2);
+    
+    // Verify that module names are returned
+    let module_names: Vec<String> = results.iter().map(|(_, name)| name.clone()).collect();
+    assert!(module_names.contains(&"vpc".to_string()));
+    assert!(module_names.contains(&"eks".to_string()));
+}