datagen-rs 0.1.0

A random data generator written in rust
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

use crate::generate::current_schema::CurrentSchemaRef;
use crate::generate::generated_schema::GeneratedSchema;
use crate::schema::transform::Transform;
use crate::util::types::Result;
use indexmap::IndexMap;
use std::sync::Arc;

pub trait MapSchema {
    fn map_index_map<K, F: Fn(&CurrentSchemaRef, K) -> Result<Arc<GeneratedSchema>>>(
        &self,
        map: IndexMap<String, K>,
        transform: Option<Vec<Transform>>,
        finalize: bool,
        func: F,
    ) -> Result<Arc<GeneratedSchema>>;

    fn map_array<K: Clone, F: Fn(&CurrentSchemaRef, K) -> Result<Arc<GeneratedSchema>>>(
        &self,
        num: usize,
        arg: K,
        transform: Option<Vec<Transform>>,
        finalize: bool,
        func: F,
    ) -> Result<Arc<GeneratedSchema>>;
}

#[cfg(feature = "map-schema")]
pub mod generate {
    use crate::generate::current_schema::{CurrentSchema, CurrentSchemaRef};
    use crate::generate::generated_schema::GeneratedSchema;
    use crate::generate::schema_mapper::MapSchema;
    use crate::schema::transform::Transform;
    use crate::util::traits::generate::TransformTrait;
    use crate::util::types::Result;
    use indexmap::IndexMap;
    use std::sync::Arc;

    impl MapSchema for CurrentSchemaRef {
        fn map_index_map<K, F: Fn(&CurrentSchemaRef, K) -> Result<Arc<GeneratedSchema>>>(
            &self,
            map: IndexMap<String, K>,
            transform: Option<Vec<Transform>>,
            finalize: bool,
            func: F,
        ) -> Result<Arc<GeneratedSchema>> {
            let mut res = IndexMap::new();
            let mut current_schema: Option<CurrentSchemaRef> = None;

            for (key, value) in map {
                current_schema = if let Some(cur) = current_schema {
                    Some(CurrentSchema::child(self.clone(), Some(cur), key.clone()).into())
                } else {
                    Some(CurrentSchema::child(self.clone(), None, key.clone()).into())
                };

                res.insert(key, func(current_schema.as_ref().unwrap(), value)?);
            }

            if finalize {
                let mut res = GeneratedSchema::Object(res).into();
                if let Some(transform) = transform {
                    res = transform.transform(self.clone(), res)?;
                }

                Ok(self.finalize(res))
            } else {
                Ok(GeneratedSchema::Object(res).into())
            }
        }

        fn map_array<K: Clone, F: Fn(&CurrentSchemaRef, K) -> Result<Arc<GeneratedSchema>>>(
            &self,
            length: usize,
            value: K,
            transform: Option<Vec<Transform>>,
            finalize: bool,
            func: F,
        ) -> Result<Arc<GeneratedSchema>> {
            let mut res = Vec::with_capacity(length as _);

            for i in 0..length {
                let current_schema = CurrentSchema::child(self.clone(), None, i.to_string()).into();
                res.push(func(&current_schema, value.clone())?);
            }

            if finalize {
                let mut res = GeneratedSchema::Array(res).into();
                if let Some(transform) = transform {
                    res = transform.transform(self.clone(), res)?;
                }

                Ok(self.finalize(res))
            } else {
                Ok(GeneratedSchema::Array(res).into())
            }
        }
    }
}