@crownpeak/dqm-react-component-dev-mcp 1.2.0

package/data/probe/tests/multiple_capture_groups_tests.rs

@@ -0,0 +1,169 @@
+use regex::Regex;
+use std::collections::{HashMap, HashSet};
+use std::fs::File;
+use std::io::Write;
+use tempfile::tempdir;
+
+// Import the function we want to test
+// Note: We need to make the function public in the actual implementation
+// This is a test-only version of the function
+fn search_file_with_combined_pattern(
+    file_path: &std::path::Path,
+    combined_regex: &regex::Regex,
+    pattern_to_terms: &[HashSet<usize>],
+) -> anyhow::Result<HashMap<usize, HashSet<usize>>> {
+    let mut term_map = HashMap::new();
+
+    // Read the file content
+    let content = std::fs::read_to_string(file_path)?;
+
+    // Process each line
+    for (line_number, line) in content.lines().enumerate() {
+        // Skip lines that are too long
+        if line.len() > 2000 {
+            continue;
+        }
+
+        // Find all matches in the line
+        for cap in combined_regex.captures_iter(line) {
+            // Check all possible pattern groups in this capture
+            for i in 1..=pattern_to_terms.len() {
+                if cap.get(i).is_some() {
+                    let pattern_idx = i - 1;
+
+                    // Add matches for all terms associated with this pattern
+                    for &term_idx in &pattern_to_terms[pattern_idx] {
+                        term_map
+                            .entry(term_idx)
+                            .or_insert_with(HashSet::new)
+                            .insert(line_number + 1); // Convert to 1-based line numbers
+                    }
+
+                    // Note: We removed the break statement here to process all matching groups
+                    // in a capture, not just the first one. This fixes the search instability issue.
+                }
+            }
+        }
+    }
+
+    Ok(term_map)
+}
+
+#[test]
+fn test_multiple_capture_groups_in_line() {
+    // Create a temporary directory for our test file
+    let temp_dir = tempdir().unwrap();
+    let file_path = temp_dir.path().join("test_file.txt");
+
+    // Create a test file with multiple patterns in the same line
+    let mut file = File::create(&file_path).unwrap();
+    writeln!(file, "This line contains pattern1 and also pattern2").unwrap();
+    writeln!(file, "This line only has pattern1").unwrap();
+    writeln!(file, "This line only has pattern2").unwrap();
+    writeln!(file, "This line has neither pattern").unwrap();
+    writeln!(file, "pattern1 pattern2 pattern1 pattern2").unwrap(); // Multiple occurrences
+
+    // Create patterns and term mappings
+    let pattern1 = "pattern1";
+    let pattern2 = "pattern2";
+
+    // Fix the regex pattern by removing the extra closing parenthesis
+    let combined_pattern = format!("({pattern1})|({pattern2}))").replace("))", ")");
+    let combined_regex = Regex::new(&format!("(?i){combined_pattern}")).unwrap();
+
+    // Term 0 is associated with pattern1, term 1 is associated with pattern2
+    let mut pattern1_terms = HashSet::new();
+    pattern1_terms.insert(0);
+
+    let mut pattern2_terms = HashSet::new();
+    pattern2_terms.insert(1);
+
+    let pattern_to_terms = vec![pattern1_terms, pattern2_terms];
+
+    // Search the file
+    let result =
+        search_file_with_combined_pattern(&file_path, &combined_regex, &pattern_to_terms).unwrap();
+
+    // Verify results
+
+    // Term 0 (pattern1) should be found in lines 1, 2, and 5
+    let term0_lines = result.get(&0).unwrap();
+    assert!(term0_lines.contains(&1));
+    assert!(term0_lines.contains(&2));
+    assert!(!term0_lines.contains(&3));
+    assert!(!term0_lines.contains(&4));
+    assert!(term0_lines.contains(&5));
+
+    // Term 1 (pattern2) should be found in lines 1, 3, and 5
+    let term1_lines = result.get(&1).unwrap();
+    assert!(term1_lines.contains(&1));
+    assert!(!term1_lines.contains(&2));
+    assert!(term1_lines.contains(&3));
+    assert!(!term1_lines.contains(&4));
+    assert!(term1_lines.contains(&5));
+
+    // Line 1 should have both terms
+    assert!(term0_lines.contains(&1) && term1_lines.contains(&1));
+
+    // Line 5 should have both terms (multiple occurrences)
+    assert!(term0_lines.contains(&5) && term1_lines.contains(&5));
+}
+
+#[test]
+fn test_overlapping_patterns() {
+    // Create a temporary directory for our test file
+    let temp_dir = tempdir().unwrap();
+    let file_path = temp_dir.path().join("test_file.txt");
+
+    // Create a test file with overlapping patterns
+    let mut file = File::create(&file_path).unwrap();
+    writeln!(file, "This patternXYZ has overlapping patterns").unwrap();
+    writeln!(file, "No overlap here").unwrap();
+    writeln!(file, "patternX and patternY separate").unwrap();
+
+    // Create patterns and term mappings
+    // We'll test with non-overlapping patterns to verify the basic functionality
+    let pattern1 = "patternX";
+    let pattern2 = "patternY"; // Changed from patternXYZ to avoid overlap issues
+
+    // Fix the regex pattern by removing the extra closing parenthesis
+    let combined_pattern = format!("({pattern1})|({pattern2}))").replace("))", ")");
+    let combined_regex = Regex::new(&format!("(?i){combined_pattern}")).unwrap();
+
+    // Term 0 is associated with pattern1, term 1 is associated with pattern2
+    let mut pattern1_terms = HashSet::new();
+    pattern1_terms.insert(0);
+
+    let mut pattern2_terms = HashSet::new();
+    pattern2_terms.insert(1);
+
+    let pattern_to_terms = vec![pattern1_terms, pattern2_terms];
+
+    // Search the file
+    let result =
+        search_file_with_combined_pattern(&file_path, &combined_regex, &pattern_to_terms).unwrap();
+
+    // Verify results
+
+    // Check if term 0 (patternX) exists in the result
+    if let Some(term0_lines) = result.get(&0) {
+        // Term 0 (patternX) should be found in lines 1 and 3
+        assert!(term0_lines.contains(&1)); // Matches "patternX" within "patternXYZ"
+        assert!(!term0_lines.contains(&2));
+        assert!(term0_lines.contains(&3));
+    } else {
+        // If term 0 doesn't exist, that's a failure
+        panic!("Term 0 (patternX) not found in results");
+    }
+
+    // Check if term 1 (patternY) exists in the result
+    if let Some(term1_lines) = result.get(&1) {
+        // Term 1 (patternY) should be found in line 3
+        assert!(!term1_lines.contains(&1));
+        assert!(!term1_lines.contains(&2));
+        assert!(term1_lines.contains(&3));
+    } else {
+        // With non-overlapping patterns, we should find term 1
+        panic!("Term 1 (patternY) not found in results");
+    }
+}

package/data/probe/tests/negative_compound_word_tests.rs

@@ -0,0 +1,246 @@
+use std::fs;
+use std::path::Path;
+use tempfile::TempDir;
+
+use probe_code::search::query::create_query_plan;
+use probe_code::search::{perform_probe, SearchOptions};
+
+/// Test negative compound word handling
+#[test]
+fn test_negative_compound_words() {
+    // Create a temporary directory for testing
+    let temp_dir = TempDir::new().unwrap();
+    let temp_path = temp_dir.path();
+
+    // Create test files
+    create_test_files(temp_path);
+
+    // Test basic negative compound word
+    test_basic_negative_compound_word(temp_path);
+
+    // Test complex query with negative compound word
+    test_complex_negative_compound_word(temp_path);
+
+    // Test excluded terms extraction
+    test_excluded_terms_extraction();
+}
+
+/// Create test files with content for negative compound word tests
+fn create_test_files(temp_dir: &Path) {
+    // File with "network" and "firewall" separately
+    let file1_path = temp_dir.join("network_firewall.go");
+    let file1_content = r#"
+package security
+
+// NetworkConfig configures the network settings
+type NetworkConfig struct {
+    FirewallEnabled bool
+}
+
+// FirewallRule represents a firewall rule
+type FirewallRule struct {
+    Name string
+    Action string
+}
+"#;
+
+    // File with only "network" and "settings"
+    let file2_path = temp_dir.join("network_only.go");
+    let file2_content = r#"
+package network
+
+// NetworkSettings configures the network settings
+type NetworkSettings struct {
+    Enabled bool
+    Settings string
+}
+"#;
+
+    // File with "networkfirewall" as a single term
+    let file3_path = temp_dir.join("networkfirewall.go");
+    let file3_content = r#"
+package security
+
+// NetworkFirewall configures the network firewall
+type NetworkFirewall struct {
+    Enabled bool
+}
+"#;
+
+    // Write files to disk
+    fs::write(file1_path, file1_content).unwrap();
+    fs::write(file2_path, file2_content).unwrap();
+    fs::write(file3_path, file3_content).unwrap();
+}
+
+/// Test basic negative compound word: "-networkfirewall"
+fn test_basic_negative_compound_word(temp_path: &Path) {
+    println!("\n=== Testing basic negative compound word: -networkfirewall ===");
+
+    // Enable debug mode
+    std::env::set_var("DEBUG", "1");
+
+    // Create the query
+    let query = "-networkfirewall";
+    let queries = vec![query.to_string()];
+    let custom_ignores: Vec<String> = vec![];
+
+    // Create SearchOptions
+    let options = SearchOptions {
+        path: temp_path,
+        queries: &queries,
+        files_only: false,
+        custom_ignores: &custom_ignores,
+        exclude_filenames: false,
+        language: None,
+        reranker: "hybrid",
+        frequency_search: true,
+        max_results: None,
+        max_bytes: None,
+        max_tokens: None,
+        allow_tests: true,
+        no_merge: true,
+        merge_threshold: None,
+        dry_run: false,
+        session: None,
+        timeout: 30,
+        question: None,
+        exact: false,
+        no_gitignore: false,
+    };
+
+    // Run the search
+    let search_results = perform_probe(&options).unwrap();
+
+    // Check that we didn't find the file with "networkfirewall" as a single term
+    let found_networkfirewall = search_results
+        .results
+        .iter()
+        .any(|r| r.file.contains("networkfirewall.go"));
+    assert!(
+        !found_networkfirewall,
+        "Should NOT find networkfirewall.go with negative compound word"
+    );
+
+    // Check that we didn't find the file with "network" and "firewall" separately
+    let found_network_firewall = search_results
+        .results
+        .iter()
+        .any(|r| r.file.contains("network_firewall.go"));
+    assert!(
+        !found_network_firewall,
+        "Should NOT find network_firewall.go with negative compound word"
+    );
+
+    // Check that we didn't find the file with only "network"
+    let found_network_only = search_results
+        .results
+        .iter()
+        .any(|r| r.file.contains("network_only.go"));
+    assert!(
+        !found_network_only,
+        "Should NOT find network_only.go with negative compound word"
+    );
+}
+
+/// Test complex query with multiple negative terms: "settings AND -network AND -firewall"
+fn test_complex_negative_compound_word(temp_path: &Path) {
+    println!("\n=== Testing complex query with multiple negative terms: settings AND -network AND -firewall ===");
+
+    // Create the query
+    let query = "settings AND -network AND -firewall";
+    let queries = vec![query.to_string()];
+    let custom_ignores: Vec<String> = vec![];
+
+    // Create SearchOptions
+    let options = SearchOptions {
+        path: temp_path,
+        queries: &queries,
+        files_only: false,
+        custom_ignores: &custom_ignores,
+        exclude_filenames: false,
+        language: None,
+        reranker: "hybrid",
+        frequency_search: true,
+        max_results: None,
+        max_bytes: None,
+        max_tokens: None,
+        allow_tests: true,
+        // Use all terms mode
+        no_merge: true,
+        merge_threshold: None,
+        dry_run: false,
+        session: None,
+        timeout: 30,
+        question: None,
+        exact: false,
+        no_gitignore: false,
+    };
+
+    // Run the search
+    let search_results = perform_probe(&options).unwrap();
+
+    // Check that we found the file with "settings" but not "network" or "firewall"
+    let found_network_only = search_results
+        .results
+        .iter()
+        .any(|r| r.file.contains("network_only.go"));
+    assert!(
+        !found_network_only,
+        "Should NOT find network_only.go with 'settings' but excluding 'network'"
+    );
+
+    // Check that we didn't find the file with "networkfirewall" as a single term
+    let found_networkfirewall = search_results
+        .results
+        .iter()
+        .any(|r| r.file.contains("networkfirewall.go"));
+    assert!(
+        !found_networkfirewall,
+        "Should NOT find networkfirewall.go with negative terms '-network' and '-firewall'"
+    );
+
+    // Check that we didn't find the file with "network" and "firewall" separately
+    let found_network_firewall = search_results
+        .results
+        .iter()
+        .any(|r| r.file.contains("network_firewall.go"));
+    assert!(
+        !found_network_firewall,
+        "Should NOT find network_firewall.go with negative terms '-network' and '-firewall'"
+    );
+}
+
+/// Test excluded terms extraction
+fn test_excluded_terms_extraction() {
+    println!("\n=== Testing excluded terms extraction ===");
+
+    // Create a query plan with a negative compound word
+    let query = "-networkfirewall";
+    let plan = create_query_plan(query, false).unwrap();
+
+    // Check that the original term is in the excluded_terms set
+    assert!(
+        plan.excluded_terms.contains("networkfirewall"),
+        "Original term 'networkfirewall' should be in excluded_terms"
+    );
+
+    // For negative terms, we don't apply compound word splitting anymore
+    // So we don't expect the compound parts to be in the excluded terms set
+
+    // Test with a more complex query
+    let complex_query = "settings AND -networkfirewall";
+    let complex_plan = create_query_plan(complex_query, false).unwrap();
+
+    // Check that the original term is in the excluded_terms set
+    assert!(
+        complex_plan.excluded_terms.contains("networkfirewall"),
+        "Original term 'networkfirewall' should be in excluded_terms"
+    );
+
+    // For negative terms, we don't apply compound word splitting anymore
+    // So we don't expect the compound parts to be in the excluded terms set
+
+    // Reset debug mode
+    std::env::remove_var("DEBUG");
+}

package/data/probe/tests/nested_symbol_extraction_tests.rs

@@ -0,0 +1,99 @@
+use anyhow::Result;
+use std::fs;
+use std::path::PathBuf;
+
+#[test]
+fn test_nested_symbol_extraction() -> Result<()> {
+    // Create a temporary test file with nested symbols
+    let test_content = r#"
+struct ProbeAgentServer {
+    client: Client,
+    config: Config,
+}
+
+impl ProbeAgentServer {
+    pub fn new(client: Client, config: Config) -> Self {
+        Self { client, config }
+    }
+
+    pub fn setupToolHandlers(&self) {
+        // Setup tool handlers
+        println!("Setting up tool handlers");
+
+        // Register search handler
+        self.register_handler("search", |params| {
+            // Search implementation
+        });
+    }
+
+    fn register_handler(&self, name: &str, handler: impl Fn(&str)) {
+        // Register handler implementation
+    }
+}
+"#;
+
+    // Write the test content to a temporary file
+    let temp_dir = tempfile::tempdir()?;
+    let file_path = temp_dir.path().join("test_nested_symbols.rs");
+    fs::write(&file_path, test_content)?;
+
+    // Test extracting the nested symbol
+    let result = extract_nested_symbol(&file_path, "ProbeAgentServer.setupToolHandlers")?;
+
+    // Verify the result contains the setupToolHandlers method
+    assert!(result.contains("pub fn setupToolHandlers"));
+    assert!(result.contains("Setting up tool handlers"));
+
+    // Clean up
+    temp_dir.close()?;
+
+    Ok(())
+}
+
+// Helper function to extract a nested symbol from a file
+fn extract_nested_symbol(path: &PathBuf, symbol: &str) -> Result<String> {
+    // Read the file content
+    let content = fs::read_to_string(path)?;
+
+    // Call the symbol finder function
+    let result = probe_code::extract::symbol_finder::find_symbol_in_file(
+        path, symbol, &content, true, // allow_tests
+        0,    // context_lines
+    )?;
+
+    Ok(result.code)
+}
+
+#[test]
+fn test_simple_symbol_extraction() -> Result<()> {
+    // Create a temporary test file with a simple symbol
+    let test_content = r#"
+struct Config {
+    pub path: String,
+    pub timeout: u64,
+}
+
+impl Config {
+    pub fn new(path: String, timeout: u64) -> Self {
+        Self { path, timeout }
+    }
+}
+"#;
+
+    // Write the test content to a temporary file
+    let temp_dir = tempfile::tempdir()?;
+    let file_path = temp_dir.path().join("test_simple_symbol.rs");
+    fs::write(&file_path, test_content)?;
+
+    // Test extracting a simple symbol
+    let result = extract_nested_symbol(&file_path, "Config")?;
+
+    // Verify the result contains the Config struct
+    assert!(result.contains("struct Config"));
+    assert!(result.contains("pub path: String"));
+
+    // Clean up
+    temp_dir.close()?;
+
+    Ok(())
+}