permeable 0.3.2

A permission-demand trait. Decouples the permission-demander from the permission / auth provider.
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

// (c) 2023 - NORICS GmbH - coding@migmedia.de
//! This crate provides generic trait to be implemented by a permission-provider.
pub use perm_err::PermissionError;

mod perm_err;
///
/// Simplest possible Trait to ask for permission. Can be implemented by a permission-provider
/// distinguishing between users.
///
/// # Example
/// ```rust
/// use permeable::{Permeable, PermissionError};
///
/// const RO_THIS : &str = "RoThis";
/// const RW_THIS : &str = "RwThis";
/// const ACCESS_THAT : &str = "AccessThat";
///
/// struct User {
///     name: String,
/// };
///
/// // A naive implementation of a the Permeable-Trait.
/// impl Permeable for User {
///
///     fn has_perm(&self, permission: &str) -> Result<(), PermissionError>{
///         match (self.name.as_str(), permission) {
///             ("admin", _) => Ok(()),
///             ("peter", ACCESS_THAT) => Ok(()),
///             ("peter", RO_THIS) => Ok(()),
///             ("paul", RO_THIS) => Ok(()),
///             ("paul", RW_THIS) => Ok(()),
///             // catch all
///             (_, perm) => Err(PermissionError::denied(permission, &self.name)),
///         }
///     }
/// }
///
/// let admin = User { name: String::from("admin") };
/// assert_eq!(admin.has_perm(RW_THIS), Ok(()));
/// let peter = User { name: String::from("peter") };
/// assert_eq!(peter.has_perm(ACCESS_THAT), Ok(()));
/// assert_eq!(peter.has_perm(RW_THIS).is_err(), true);
/// ```
pub trait Permeable {
    /// Returns `Result::Ok(())` if the given `permission` is granted.
    ///
    /// # Errors
    /// if the `permission` is not granted or unknown it returns a
    /// [`PermissionError`](./enum.PermissionError.html).
    #[allow(unused)]
    fn has_perm(&self, permission: &str) -> Result<(), PermissionError>;
}

/// A everything-allow `Permeable`. For testing-purposes.
pub struct AllowAllPermission();

impl Permeable for AllowAllPermission {
    fn has_perm(&self, _permission: &str) -> Result<(), PermissionError> {
        Ok(())
    }
}

/// A everything-deny `Permeable`. For testing-purposes.
pub struct DenyAllPermission();

impl Permeable for DenyAllPermission {
    fn has_perm(&self, permission: &str) -> Result<(), PermissionError> {
        Err(PermissionError::denied(permission, "DenyAllPermission"))
    }
}