ucan 0.4.0

Implement UCAN-based authorization with conciseness and ease!
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

use std::ops::Deref;

use anyhow::{anyhow, Error, Result};
use serde_json::{Map, Value};

#[derive(Clone)]
pub struct Caveat(Map<String, Value>);

impl Caveat {
    /// Determines if this [Caveat] enables/allows the provided caveat.
    ///
    /// ```
    /// use ucan::capability::{Caveat};
    /// use serde_json::json;
    ///
    /// let no_caveat = Caveat::try_from(json!({})).unwrap();
    /// let x_caveat = Caveat::try_from(json!({ "x": true })).unwrap();
    /// let x_diff_caveat = Caveat::try_from(json!({ "x": false })).unwrap();
    /// let y_caveat = Caveat::try_from(json!({ "y": true })).unwrap();
    /// let xz_caveat = Caveat::try_from(json!({ "x": true, "z": true })).unwrap();
    ///
    /// assert!(no_caveat.enables(&no_caveat));
    /// assert!(x_caveat.enables(&x_caveat));
    /// assert!(no_caveat.enables(&x_caveat));
    /// assert!(x_caveat.enables(&xz_caveat));
    ///
    /// assert!(!x_caveat.enables(&x_diff_caveat));
    /// assert!(!x_caveat.enables(&no_caveat));
    /// assert!(!x_caveat.enables(&y_caveat));
    /// ```
    pub fn enables(&self, other: &Caveat) -> bool {
        if self.is_empty() {
            return true;
        }

        if other.is_empty() {
            return false;
        }

        if self == other {
            return true;
        }

        for (key, value) in self.iter() {
            if let Some(other_value) = other.get(key) {
                if value != other_value {
                    return false;
                }
            } else {
                return false;
            }
        }

        true
    }
}

impl Deref for Caveat {
    type Target = Map<String, Value>;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl PartialEq for Caveat {
    fn eq(&self, other: &Caveat) -> bool {
        self.0 == other.0
    }
}

impl TryFrom<Value> for Caveat {
    type Error = Error;
    fn try_from(value: Value) -> Result<Caveat> {
        Ok(Caveat(match value {
            Value::Object(obj) => obj,
            _ => return Err(anyhow!("Caveat must be an object")),
        }))
    }
}

impl TryFrom<&Value> for Caveat {
    type Error = Error;
    fn try_from(value: &Value) -> Result<Caveat> {
        Caveat::try_from(value.to_owned())
    }
}