reinhardt-urls 0.3.0

URL routing and proxy utilities for Reinhardt framework
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

//! Collection operations for filtering and transforming

use super::CollectionProxy;
use crate::proxy::ProxyResult;
use crate::proxy::ScalarValue;

/// Collection operations for filtering and transforming
#[derive(Debug, Clone)]
pub struct CollectionOperations {
	proxy: CollectionProxy,
}

impl CollectionOperations {
	/// Create new collection operations wrapper
	///
	/// # Examples
	///
	/// ```
	/// use reinhardt_urls::proxy::{CollectionProxy, collection::CollectionOperations};
	///
	/// let proxy = CollectionProxy::new("posts", "title");
	/// let ops = CollectionOperations::new(proxy);
	/// // Operations wrapper is ready to use
	/// ```
	pub fn new(proxy: CollectionProxy) -> Self {
		Self { proxy }
	}
	/// Filter collection by predicate
	///
	/// # Examples
	///
	/// ```no_run
	/// use reinhardt_urls::proxy::{CollectionProxy, ScalarValue, collection::CollectionOperations};
	///
	/// # async fn example() -> Result<(), Box<dyn std::error::Error>> {
	/// let proxy = CollectionProxy::new("posts", "title");
	/// let ops = CollectionOperations::new(proxy);
	// let user = ...;
	// let filtered = ops.filter(&user, |v| v.is_null()).await?;
	/// # Ok(())
	/// # }
	/// ```
	pub async fn filter<T, F>(&self, source: &T, predicate: F) -> ProxyResult<Vec<ScalarValue>>
	where
		T: crate::proxy::reflection::Reflectable,
		F: Fn(&ScalarValue) -> bool,
	{
		let values = self.proxy.get_values(source).await?;
		Ok(values.into_iter().filter(|v| predicate(v)).collect())
	}
	/// Map collection values
	///
	/// # Examples
	///
	/// ```no_run
	/// use reinhardt_urls::proxy::{CollectionProxy, ScalarValue, collection::CollectionOperations};
	///
	/// # async fn example() -> Result<(), Box<dyn std::error::Error>> {
	/// let proxy = CollectionProxy::new("posts", "title");
	/// let ops = CollectionOperations::new(proxy);
	// let user = ...;
	// let lengths = ops.map(&user, |v| match v {
	//     ScalarValue::String(s) => s.len(),
	//     _ => 0,
	// }).await?;
	/// # Ok(())
	/// # }
	/// ```
	pub async fn map<T, F, U>(&self, source: &T, mapper: F) -> ProxyResult<Vec<U>>
	where
		T: crate::proxy::reflection::Reflectable,
		F: Fn(&ScalarValue) -> U,
	{
		let values = self.proxy.get_values(source).await?;
		Ok(values.iter().map(mapper).collect())
	}
	/// Sort collection values
	///
	/// # Examples
	///
	/// ```no_run
	/// use reinhardt_urls::proxy::{CollectionProxy, collection::CollectionOperations};
	///
	/// # async fn example() -> Result<(), Box<dyn std::error::Error>> {
	/// let proxy = CollectionProxy::new("posts", "created_at");
	/// let ops = CollectionOperations::new(proxy);
	// let user = ...;
	// let sorted = ops.sort(&user).await?;
	/// # Ok(())
	/// # }
	/// ```
	pub async fn sort<T>(&self, source: &T) -> ProxyResult<Vec<ScalarValue>>
	where
		T: crate::proxy::reflection::Reflectable,
	{
		let mut values = self.proxy.get_values(source).await?;
		values.sort_by(|a, b| format!("{:?}", a).cmp(&format!("{:?}", b)));
		Ok(values)
	}
	/// Get distinct values
	///
	/// # Examples
	///
	/// ```no_run
	/// use reinhardt_urls::proxy::{CollectionProxy, collection::CollectionOperations};
	///
	/// # async fn example() -> Result<(), Box<dyn std::error::Error>> {
	/// let proxy = CollectionProxy::new("posts", "category");
	/// let ops = CollectionOperations::new(proxy);
	// let user = ...;
	// let distinct = ops.distinct(&user).await?;
	/// # Ok(())
	/// # }
	/// ```
	pub async fn distinct<T>(&self, source: &T) -> ProxyResult<Vec<ScalarValue>>
	where
		T: crate::proxy::reflection::Reflectable,
	{
		let mut values = self.proxy.get_values(source).await?;
		values.sort_by(|a, b| format!("{:?}", a).cmp(&format!("{:?}", b)));
		values.dedup_by(|a, b| format!("{:?}", a) == format!("{:?}", b));
		Ok(values)
	}
}