use serde::{Deserialize, Serialize};
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
pub enum SettingScope {
App,
Persona,
Session,
Graph,
Surface,
}
impl SettingScope {
pub const BROAD_TO_NARROW: [SettingScope; 5] = [
Self::App,
Self::Persona,
Self::Session,
Self::Graph,
Self::Surface,
];
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum Permission {
Inherit,
Allow,
Prompt,
Deny,
}
impl Permission {
fn restrictiveness(self) -> Option<u8> {
match self {
Self::Inherit => None,
Self::Allow => Some(0),
Self::Prompt => Some(1),
Self::Deny => Some(2),
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ScopedPermission {
pub scope: SettingScope,
pub permission: Permission,
}
impl ScopedPermission {
pub fn new(scope: SettingScope, permission: Permission) -> Self {
Self { scope, permission }
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ResolvedPermission {
pub effective: Permission,
pub decided_by: Option<SettingScope>,
}
pub fn resolve_permission(chain: &[ScopedPermission], default: Permission) -> ResolvedPermission {
let winner = chain
.iter()
.filter(|scoped| scoped.permission.restrictiveness().is_some())
.max_by_key(|scoped| scoped.permission.restrictiveness().unwrap_or(0));
match winner {
Some(scoped) => ResolvedPermission {
effective: scoped.permission,
decided_by: Some(scoped.scope),
},
None => ResolvedPermission {
effective: default,
decided_by: None,
},
}
}
#[cfg(test)]
mod tests {
use super::*;
use SettingScope::*;
fn chain(items: &[(SettingScope, Permission)]) -> Vec<ScopedPermission> {
items
.iter()
.map(|&(scope, permission)| ScopedPermission::new(scope, permission))
.collect()
}
#[test]
fn narrower_deny_overrides_broader_allow() {
let c = chain(&[(App, Permission::Allow), (Session, Permission::Deny)]);
let r = resolve_permission(&c, Permission::Allow);
assert_eq!(r.effective, Permission::Deny);
assert_eq!(r.decided_by, Some(Session));
}
#[test]
fn narrower_allow_cannot_broaden_a_broader_deny() {
let c = chain(&[(App, Permission::Deny), (Surface, Permission::Allow)]);
let r = resolve_permission(&c, Permission::Allow);
assert_eq!(
r.effective,
Permission::Deny,
"narrower scope broadened a Deny"
);
assert_eq!(r.decided_by, Some(App));
}
#[test]
fn prompt_sits_between_allow_and_deny() {
let c = chain(&[(App, Permission::Allow), (Persona, Permission::Prompt)]);
assert_eq!(
resolve_permission(&c, Permission::Allow).effective,
Permission::Prompt
);
let c = chain(&[(Persona, Permission::Prompt), (Graph, Permission::Deny)]);
assert_eq!(
resolve_permission(&c, Permission::Allow).effective,
Permission::Deny
);
}
#[test]
fn all_inherit_falls_back_to_default() {
let c = chain(&[(App, Permission::Inherit), (Session, Permission::Inherit)]);
let r = resolve_permission(&c, Permission::Prompt);
assert_eq!(r.effective, Permission::Prompt);
assert_eq!(r.decided_by, None);
}
#[test]
fn decided_by_is_the_narrowest_among_equally_restrictive() {
let c = chain(&[(Session, Permission::Deny), (Surface, Permission::Deny)]);
assert_eq!(
resolve_permission(&c, Permission::Allow).decided_by,
Some(Surface)
);
}
#[test]
fn scopes_are_ordered_broad_to_narrow() {
assert!(App < Persona && Persona < Session && Session < Graph && Graph < Surface);
assert_eq!(SettingScope::BROAD_TO_NARROW.len(), 5);
}
}