libikarus 0.1.14

The core functionality of Ikarus wrapped neatly in a rust library
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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

use crate::objects::blueprint::Blueprint;
use crate::objects::blueprint_folder::BlueprintFolder;
use crate::objects::entity::{Entity, EntityValue};
use crate::objects::entity_folder::EntityFolder;
use crate::objects::object::Object;
use crate::objects::property::{Property, PropertyScope, PropertyType};
use crate::objects::property_folder::PropertyFolder;
use crate::objects::property_settings::PropertySettings;
use crate::persistence::project::Project;
use crate::types::location::FolderPosition;
use std::collections::HashSet;

mod entity;
mod object;
mod project;
mod property;

const NAME: &'static str = "name";
const INFO: &'static str = "info";

fn new_blueprint(project: &Project) -> Blueprint {
    Blueprint::new(
        project.db.clone(),
        None,
        FolderPosition::EndOfFolder,
        NAME,
        INFO,
    )
    .expect("unable to create blueprint")
}

fn new_blueprint_folder(project: &Project) -> BlueprintFolder {
    BlueprintFolder::new(
        project.db.clone(),
        None,
        FolderPosition::EndOfFolder,
        NAME,
        INFO,
    )
    .expect("unable to create blueprint folder")
}

fn new_property(
    project: &Project,
    scope: PropertyScope,
    property_type: PropertyType,
    settings: Option<PropertySettings>,
    default_value: Option<EntityValue>,
) -> Property {
    Property::new(
        project.db.clone(),
        scope,
        None,
        FolderPosition::EndOfFolder,
        NAME,
        INFO,
        property_type,
        settings.unwrap_or(property_type.default_settings()),
        default_value.unwrap_or(property_type.default_value()),
    )
    .expect("unable to create property")
}

fn new_property_folder(project: &Project, blueprint: Blueprint) -> PropertyFolder {
    PropertyFolder::new(
        project.db.clone(),
        PropertyScope::Blueprint(blueprint.clone()),
        None,
        FolderPosition::EndOfFolder,
        NAME,
        INFO,
    )
    .expect("unable to create property folder")
}

fn new_entity(project: &Project, blueprints: HashSet<&Blueprint>) -> Entity {
    Entity::new(
        project.db.clone(),
        blueprints,
        None,
        FolderPosition::EndOfFolder,
        NAME,
        INFO,
    )
    .expect("unable to create entity")
}

fn new_entity_folder(project: &Project) -> EntityFolder {
    EntityFolder::new(
        project.db.clone(),
        None,
        FolderPosition::EndOfFolder,
        NAME,
        INFO,
    )
    .expect("unable to create entity folder")
}

fn one_object_of_each_type(project: &Project) -> Vec<Object> {
    let blueprint = new_blueprint(project);
    vec![
        blueprint.to_object(),
        new_blueprint_folder(project).to_object(),
        new_property(
            project,
            PropertyScope::Blueprint(blueprint.clone()),
            PropertyType::Toggle,
            None,
            None,
        )
        .to_object(),
        new_property_folder(project, blueprint.clone()).to_object(),
        new_entity(project, HashSet::default()).to_object(),
        new_entity_folder(project).to_object(),
    ]
}