regorus 0.10.1

A fast, lightweight Rego (OPA policy language) interpreter
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

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.

use alloc::collections::BTreeSet;
use alloc::string::String;
use alloc::vec::Vec;

use crate::languages::azure_rbac::ast::{ConditionExpr, IdentifierExpression, SetLiteral};
use crate::value::Value;

use super::error::ConditionEvalError;
use super::eval::Evaluator;

impl<'a> Evaluator<'a> {
    pub(super) fn eval_set_literal(
        &mut self,
        set: &SetLiteral,
    ) -> Result<Value, ConditionEvalError> {
        let mut values = BTreeSet::new();
        for elem in &set.elements {
            let value = self.evaluate_value(elem)?;
            values.insert(value);
        }
        Ok(Value::from(values))
    }

    pub(super) fn eval_list_literal(
        &mut self,
        elements: &[ConditionExpr],
    ) -> Result<Value, ConditionEvalError> {
        let mut values = Vec::with_capacity(elements.len());
        for elem in elements {
            values.push(self.evaluate_value(elem)?);
        }
        Ok(Value::from(values))
    }

    pub(super) fn eval_identifier(&self, identifier: &IdentifierExpression) -> Value {
        match identifier.name.as_str() {
            "operationName" => self
                .context
                .action
                .clone()
                .map(|s: String| Value::String(s.into()))
                .unwrap_or(Value::Undefined),
            "subOperationName" => self
                .context
                .suboperation
                .clone()
                .map(|s: String| Value::String(s.into()))
                .unwrap_or(Value::Undefined),
            "action" => self
                .context
                .request
                .action
                .clone()
                .map(|s: String| Value::String(s.into()))
                .unwrap_or(Value::Undefined),
            "dataAction" => self
                .context
                .request
                .data_action
                .clone()
                .map(|s: String| Value::String(s.into()))
                .unwrap_or(Value::Undefined),
            "principalId" => Value::String(self.context.principal.id.as_str().into()),
            "resourceId" => Value::String(self.context.resource.id.as_str().into()),
            "resourceScope" => Value::String(self.context.resource.scope.as_str().into()),
            "resourceType" => Value::String(self.context.resource.resource_type.as_str().into()),
            _ => Value::Undefined,
        }
    }
}