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
use std::{
error::Error,
fmt::{Debug, Display},
};
use crate::{
runtime::{IntoRuntimeResult, RuntimeError, RuntimeErrorType, RuntimeResult},
RantyValue,
};
/// Result type used for data source operations.
pub type DataSourceResult<T> = Result<T, DataSourceError>;
/// Trait for defining a Ranty data source type.
///
/// ## Security
/// This trait can potentially be used to grant Ranty access to network, filesystem, or other sensitive resources.
/// Please take care to ensure that such access is adequately sandboxed, has granular permissions,
/// and that failed access to such resources is handled gracefully.
pub trait DataSource: Debug {
/// Returns a string identifying the type of data source this is;
/// ideally, this should be something short and human-readable.
/// Refer to implementor documentation for the specific string returned.
///
/// ## Security
/// Because implementors can make this method return any string at all,
/// usage should be limited to diagnostic and filtering purposes only.
fn type_id(&self) -> &str;
/// Requests some data from the data source.
///
/// This method is called by Ranty's `[data]` funtion to interact with data sources.
fn request_data(&self, args: Vec<RantyValue>) -> DataSourceResult<RantyValue>;
}
/// Error type for data source operations.
#[derive(Debug, Clone)]
pub enum DataSourceError {
/// User messed up; check string for explanation.
User(String),
/// Data source messed up; check string for explanation.
Internal(String),
}
impl Display for DataSourceError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::User(msg) => write!(f, "user error: {}", msg),
Self::Internal(msg) => write!(f, "internal: {}", msg),
}
}
}
impl Error for DataSourceError {
fn source(&self) -> Option<&(dyn Error + 'static)> {
None
}
fn cause(&self) -> Option<&dyn Error> {
self.source()
}
}
impl<T> IntoRuntimeResult<T> for DataSourceResult<T> {
fn into_runtime_result(self) -> RuntimeResult<T> {
self.map_err(|err| RuntimeError {
error_type: RuntimeErrorType::DataSourceError(err),
description: None,
stack_trace: None,
})
}
}