jscpd-rs 0.1.6

50x+ faster duplicate-code detector for CI/CD; jscpd-compatible CLI, SARIF, JSON, HTML reports
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

use std::{collections::HashMap, error::Error, fmt};

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct MemoryStoreError {
    namespace: String,
    key: String,
}

impl MemoryStoreError {
    pub fn new(namespace: impl Into<String>, key: impl Into<String>) -> Self {
        Self {
            namespace: namespace.into(),
            key: key.into(),
        }
    }

    pub fn namespace(&self) -> &str {
        &self.namespace
    }

    pub fn key(&self) -> &str {
        &self.key
    }
}

impl fmt::Display for MemoryStoreError {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            formatter,
            "key '{}' not found in namespace '{}'",
            self.key, self.namespace
        )
    }
}

impl Error for MemoryStoreError {}

#[derive(Clone, Debug)]
pub struct MemoryStore<T> {
    namespace: String,
    values: HashMap<String, HashMap<String, T>>,
}

impl<T> Default for MemoryStore<T> {
    fn default() -> Self {
        Self::new()
    }
}

impl<T> MemoryStore<T> {
    pub fn new() -> Self {
        Self {
            namespace: String::new(),
            values: HashMap::new(),
        }
    }

    pub fn namespace(&mut self, namespace: impl Into<String>) {
        self.namespace = namespace.into();
        self.values.entry(self.namespace.clone()).or_default();
    }

    pub fn current_namespace(&self) -> &str {
        &self.namespace
    }

    pub fn get(&self, key: impl AsRef<str>) -> Result<&T, MemoryStoreError> {
        let key = key.as_ref();
        self.values
            .get(&self.namespace)
            .and_then(|namespace| namespace.get(key))
            .ok_or_else(|| MemoryStoreError::new(self.namespace.clone(), key))
    }

    pub fn set(&mut self, key: impl Into<String>, value: T) -> &T {
        let key = key.into();
        self.values
            .entry(self.namespace.clone())
            .or_default()
            .entry(key)
            .insert_entry(value)
            .into_mut()
    }

    pub fn close(&mut self) {
        self.values.clear();
    }

    pub fn is_empty(&self) -> bool {
        self.values.values().all(HashMap::is_empty)
    }

    pub fn len(&self) -> usize {
        self.values.values().map(HashMap::len).sum()
    }
}