sqry-nl 10.0.1

Natural language to sqry query translation layer
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

//! Cache key generation for context-aware caching.

use std::hash::{Hash, Hasher};

/// Context-aware cache key.
///
/// The key includes the query text plus context that affects translation:
/// - Languages specified
/// - Path root (working directory)
/// - Default limit setting
#[derive(Debug, Clone, Eq, PartialEq)]
pub struct CacheKey {
    /// The normalized query text
    query: String,
    /// Languages specified in context
    languages: Vec<String>,
    /// Path root (affects path validation)
    path_root: Option<String>,
    /// Default limit (affects command generation)
    default_limit: u32,
}

impl CacheKey {
    /// Create a new cache key.
    #[must_use]
    pub fn new(
        query: &str,
        languages: &[String],
        path_root: Option<String>,
        default_limit: u32,
    ) -> Self {
        Self {
            query: query.to_lowercase().trim().to_string(),
            languages: languages.to_vec(),
            path_root,
            default_limit,
        }
    }

    /// Get the query text.
    #[must_use]
    pub fn query(&self) -> &str {
        &self.query
    }
}

impl Hash for CacheKey {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.query.hash(state);
        self.languages.hash(state);
        self.path_root.hash(state);
        self.default_limit.hash(state);
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::collections::hash_map::DefaultHasher;

    fn hash_key(key: &CacheKey) -> u64 {
        let mut hasher = DefaultHasher::new();
        key.hash(&mut hasher);
        hasher.finish()
    }

    #[test]
    fn test_key_normalization() {
        let key1 = CacheKey::new("Find Foo", &[], None, 100);
        let key2 = CacheKey::new("  find foo  ", &[], None, 100);

        assert_eq!(key1.query(), key2.query());
    }

    #[test]
    fn test_key_equality() {
        let key1 = CacheKey::new("find foo", &["rust".to_string()], None, 100);
        let key2 = CacheKey::new("find foo", &["rust".to_string()], None, 100);

        assert_eq!(key1, key2);
        assert_eq!(hash_key(&key1), hash_key(&key2));
    }

    #[test]
    fn test_key_inequality_language() {
        let key1 = CacheKey::new("find foo", &["rust".to_string()], None, 100);
        let key2 = CacheKey::new("find foo", &["python".to_string()], None, 100);

        assert_ne!(key1, key2);
    }

    #[test]
    fn test_key_inequality_limit() {
        let key1 = CacheKey::new("find foo", &[], None, 100);
        let key2 = CacheKey::new("find foo", &[], None, 50);

        assert_ne!(key1, key2);
    }

    #[test]
    fn test_key_inequality_path_root() {
        let key1 = CacheKey::new("find foo", &[], Some("/project1".to_string()), 100);
        let key2 = CacheKey::new("find foo", &[], Some("/project2".to_string()), 100);

        assert_ne!(key1, key2);
    }
}