oca-rs 0.6.6

OCA rust ecosytem facade
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

use std::str::FromStr;

use oca_ast_semantics::ast::{
    CommandType, NestedAttrType, NestedValue, OCAAst, ObjectKind, OverlayType,
    RefValue,
};
use said::SelfAddressingIdentifier;

use crate::facade::build::ValidationError;

pub trait References {
    fn find(&self, refn: &str) -> Option<String>;
    fn save(&mut self, refn: &str, value: String);
}

// Iterate over all commands and dereference all attribute references
pub fn replace_refn_with_refs<R: References>(
    oca_ast: &mut OCAAst,
    references: &R,
) -> Result<(), ValidationError> {
    for command in oca_ast.commands.iter_mut() {
        if let (CommandType::Add, ObjectKind::CaptureBase(content)) =
            (&command.kind, &mut command.object_kind)
        {
            if let Some(attributes) = &mut content.attributes {
                for (_, attr_type) in attributes {
                    match attr_type {
                        NestedAttrType::Reference(RefValue::Name(refn)) => {
                            if let Some(said) = references.find(refn) {
                                let said = SelfAddressingIdentifier::from_str(&said).unwrap(); // todo
                                *attr_type = NestedAttrType::Reference(RefValue::Said(said));
                            } else {
                                return Err(ValidationError::UnknownRefn(refn.clone()));
                            }
                        }
                        NestedAttrType::Array(box_attr_type) => {
                            if let NestedAttrType::Reference(RefValue::Name(refn)) =
                                &**box_attr_type
                            {
                                if let Some(said) = references.find(refn) {
                                    let said = SelfAddressingIdentifier::from_str(&said).unwrap(); // todo
                                    **box_attr_type =
                                        NestedAttrType::Reference(RefValue::Said(said));
                                } else {
                                    return Err(ValidationError::UnknownRefn(refn.clone()));
                                }
                            }
                        }
                        _ => (),
                    }
                }
            }
        }

        if let (
            CommandType::Add,
            ObjectKind::Overlay(OverlayType::Link, content),
        ) = (&command.kind, &mut command.object_kind)
        {
            if let Some(properties) = &mut content.properties {
                if let Some(NestedValue::Reference(RefValue::Name(refn))) =
                    properties.get("target")
                {
                    if let Some(said) = references.find(refn) {
                        let said =
                            SelfAddressingIdentifier::from_str(&said).unwrap(); // todo
                        properties.insert(
                            "target".to_string(),
                            NestedValue::Reference(RefValue::Said(said)),
                        );
                        *properties = properties.clone();
                    } else {
                        return Err(ValidationError::UnknownRefn(refn.clone()));
                    }
                }
            }
        }
    }
    Ok(())
}