phlow 3.0.0

An engine for scripting reactive browsers in Rust by adding custom views to structures
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
117
118
119
120
121
122
123
124

use std::any::Any;

pub use annotate;
use annotate::{Function, Module};
pub use phlow_derive::{RawView, environment, extensions, view};

pub use crate::method::*;
pub use crate::object::*;
pub use crate::views::*;
pub use ctor;

pub mod cloning;
mod method;
mod object;
pub mod printing;
mod views;

#[macro_export]
macro_rules! export_link_macro {
    ($crate_name:ident) => {
        #[macro_export]
        macro_rules! __phlow_generated_link_macro {
            () => {
                const _: () = {
                    #[used]
                    static __PHLOW_GENERATED_LINK: fn() = ::$crate_name::__ensure_linked;
                };
            };
        }

        pub use __phlow_generated_link_macro as link;
    };
}

pub fn extension_modules_of_val<T: 'static>(_value: &T) -> Vec<Module> {
    extension_modules_of_type::<T>()
}

pub fn extension_modules_of_type<T: 'static>() -> Vec<Module> {
    annotate::global_environment().find_modules_such_that(&|module| {
        module.has_attribute_such_that(|attribute| {
            attribute.name() == "tag" && attribute.is_str("phlow-extensions")
        }) && module.has_attribute_such_that(|attribute| {
            attribute.name() == "phlow_type" && attribute.is_type::<T>()
        })
    })
}

pub fn extension_modules_of_any(value: &dyn Any) -> Vec<Module> {
    let type_id = value.type_id();
    annotate::global_environment().find_modules_such_that(&|module| {
        module.has_attribute_such_that(|attribute| {
            attribute.name() == "tag" && attribute.is_str("phlow-extensions")
        }) && module.has_attribute_such_that(|attribute| {
            attribute.name() == "phlow_type" && attribute.is_type_id(&type_id)
        })
    })
}

pub fn view_functions_of_val<T: 'static>(value: &T) -> Vec<DefiningMethod> {
    view_functions_in_modules(&extension_modules_of_val(value))
}

pub fn view_defining_methods_for_type<T: 'static>() -> Vec<DefiningMethod> {
    view_functions_in_modules(&extension_modules_of_type::<T>())
}

pub fn view_functions_of_any(value: &dyn Any) -> Vec<DefiningMethod> {
    view_functions_in_modules(&extension_modules_of_any(value))
}

pub fn vtable_of_type<T: 'static>() -> PhlowVTable {
    vtable_in_modules(&extension_modules_of_type::<T>())
}

pub fn vtable_of_val<T: 'static>(_value: &T) -> PhlowVTable {
    vtable_in_modules(&extension_modules_of_type::<T>())
}

pub fn vtable_of_any(value: &dyn Any) -> PhlowVTable {
    vtable_in_modules(&extension_modules_of_any(value))
}

fn vtable_in_modules(modules: &[Module]) -> PhlowVTable {
    let to_string_fn = functions_in_utility_modules_tagged(modules, "phlow-printing").pop();
    let type_name_fn = functions_in_utility_modules_tagged(modules, "phlow-type-name").pop();
    let as_view_fn = functions_in_utility_modules_tagged(modules, "phlow-as-view").pop();
    let defining_methods_fn =
        functions_in_utility_modules_tagged(modules, "phlow-defining-methods").pop();

    PhlowVTable {
        type_name_fn,
        to_string_fn,
        as_view_fn,
        defining_methods_fn,
    }
}

fn view_functions_in_modules(modules: &[Module]) -> Vec<DefiningMethod> {
    modules
        .iter()
        .flat_map(|module| {
            module.find_functions_such_that(|function| {
                function.has_attribute_such_that(|attribute| {
                    attribute.name() == "tag" && attribute.is_str("phlow-view")
                })
            })
        })
        .map(|each| each.into())
        .collect()
}

fn functions_in_utility_modules_tagged(modules: &[Module], tag: &str) -> Vec<Function> {
    modules
        .iter()
        .flat_map(|module| {
            module.find_functions_such_that(|function| {
                function.has_attribute_such_that(|attribute| {
                    attribute.name() == "tag" && attribute.is_str(tag)
                })
            })
        })
        .collect()
}