dd-sensitive-data-scanner 0.0.0

Core Sensitive Data Scanner library for detecting and redacting sensitive information.
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

use nom::{
    Compare, CompareResult, FindSubstring, InputIter, InputLength, InputTake, Needed, Offset,
    Slice, UnspecializedInput,
};
use std::ops::{RangeFrom, RangeTo};
use std::str::{CharIndices, Chars};

/// This implements a custom nom input type that also tracks the recursion depth, which
/// allows limiting the recursion depth to prevent stack overflows from deep recursion.

#[derive(Copy, Clone, Debug)]
pub struct Input<'a> {
    pub value: &'a str,
    pub depth: usize,
}

impl InputLength for Input<'_> {
    fn input_len(&self) -> usize {
        self.value.len()
    }
}

impl InputTake for Input<'_> {
    fn take(&self, count: usize) -> Self {
        Self {
            value: self.value.take(count),
            depth: self.depth,
        }
    }

    fn take_split(&self, count: usize) -> (Self, Self) {
        let (a, b) = self.value.take_split(count);
        (
            Self {
                value: a,
                depth: self.depth,
            },
            Self {
                value: b,
                depth: self.depth,
            },
        )
    }
}

impl<'a> InputIter for Input<'a> {
    type Item = char;
    type Iter = CharIndices<'a>;
    type IterElem = Chars<'a>;

    fn iter_indices(&self) -> Self::Iter {
        self.value.iter_indices()
    }

    fn iter_elements(&self) -> Self::IterElem {
        self.value.iter_elements()
    }

    fn position<P>(&self, predicate: P) -> Option<usize>
    where
        P: Fn(Self::Item) -> bool,
    {
        self.value.position(predicate)
    }

    fn slice_index(&self, count: usize) -> Result<usize, Needed> {
        self.value.slice_index(count)
    }
}

impl UnspecializedInput for Input<'_> {
    // Automatically implements InputTakeAtPosition and Compare<Self>
}

// This is implementing comparison directly to &str instead of Self so functions like `tag`
// can directly use strings instead of having to make up an arbitrary `Input`
impl<'a> Compare<&'a str> for Input<'a> {
    fn compare(&self, t: &'a str) -> CompareResult {
        self.value.compare(t)
    }

    fn compare_no_case(&self, t: &'a str) -> CompareResult {
        self.value.compare_no_case(t)
    }
}

impl<'a> From<(&'a str, usize)> for Input<'a> {
    fn from(value: (&'a str, usize)) -> Self {
        Self {
            value: value.0,
            depth: value.1,
        }
    }
}

impl Slice<RangeFrom<usize>> for Input<'_> {
    fn slice(&self, range: RangeFrom<usize>) -> Self {
        Self {
            value: self.value.slice(range),
            depth: self.depth,
        }
    }
}

impl Slice<RangeTo<usize>> for Input<'_> {
    fn slice(&self, range: RangeTo<usize>) -> Self {
        Self {
            value: self.value.slice(range),
            depth: self.depth,
        }
    }
}

impl Offset for Input<'_> {
    fn offset(&self, second: &Self) -> usize {
        self.value.offset(second.value)
    }
}

impl<'a> FindSubstring<&'a str> for Input<'a> {
    fn find_substring(&self, substr: &'a str) -> Option<usize> {
        self.value.find_substring(substr)
    }
}