alef 0.71.0

Opinionated polyglot binding generator for Rust libraries
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

mod functions;
mod helpers;
mod native;
mod public_api;
mod public_api_args;
mod public_api_delegates;
mod public_api_opaque_methods;
mod public_api_render;
mod public_files;
mod rust_items;
mod service_api;
#[cfg(test)]
mod tests;
mod types;

use crate::core::backend::{
    Backend, BuildConfig, BuildDependency, Capabilities, GeneratedFile, TraitBridgeRegistrationSurface,
};
use crate::core::config::{Language, ResolvedCrateConfig};
use crate::core::ir::ApiSurface;

pub struct RustlerBackend;

impl Backend for RustlerBackend {
    fn name(&self) -> &str {
        "rustler"
    }

    fn language(&self) -> Language {
        Language::Elixir
    }

    fn capabilities(&self) -> Capabilities {
        Capabilities {
            supports_async: true,
            supports_classes: true,
            supports_enums: true,
            supports_option: true,
            supports_result: true,
            supports_service_api: true,
            ..Capabilities::default()
        }
    }

    fn generate_bindings(&self, api: &ApiSurface, config: &ResolvedCrateConfig) -> anyhow::Result<Vec<GeneratedFile>> {
        crate::codegen::config_gen::validate_rust_default_functions(api)?;
        native::generate_bindings(&crate::backends::ir_order::with_sorted_items(api), config)
    }

    fn generate_public_api(
        &self,
        api: &ApiSurface,
        config: &ResolvedCrateConfig,
    ) -> anyhow::Result<Vec<GeneratedFile>> {
        public_api::generate_public_api(&crate::backends::ir_order::with_sorted_items(api), config)
    }

    fn generate_service_api(
        &self,
        api: &ApiSurface,
        config: &ResolvedCrateConfig,
    ) -> anyhow::Result<Vec<GeneratedFile>> {
        service_api::generate(&crate::backends::ir_order::with_sorted_items(api), config)
    }

    fn build_config(&self) -> Option<BuildConfig> {
        Some(BuildConfig {
            tool: "mix",
            crate_suffix: "-rustler",
            build_dep: BuildDependency::None,
            post_build: vec![],
        })
    }

    /// Elixir consumers call the delegates on the generated app module, which forward to the
    /// same-named NIFs on `<AppModule>.Native`. `trait_bridge::active_bridge_trait` is the gate
    /// `public_api_delegates` applies — `exclude_languages` under both the `elixir` and `rustler`
    /// spellings, plus the trait resolving in the `ApiSurface`. ~keep
    fn trait_bridge_registration_surface(
        &self,
        api: &ApiSurface,
        config: &ResolvedCrateConfig,
    ) -> Vec<TraitBridgeRegistrationSurface> {
        use heck::ToPascalCase;
        use public_api_delegates::elixir_delegate_name;

        let app_module = config.elixir_app_name().to_pascal_case();
        let qualified = |configured: &Option<String>| {
            configured
                .as_deref()
                .map(|name| format!("{app_module}.{}", elixir_delegate_name(name)))
        };
        config
            .trait_bridges
            .iter()
            .filter(|bridge| crate::backends::rustler::trait_bridge::active_bridge_trait(bridge, api).is_some())
            .filter(|bridge| {
                bridge.register_fn.is_some() || bridge.unregister_fn.is_some() || bridge.clear_fn.is_some()
            })
            .map(|bridge| TraitBridgeRegistrationSurface {
                trait_name: bridge.trait_name.clone(),
                register_symbol: qualified(&bridge.register_fn),
                unregister_symbol: qualified(&bridge.unregister_fn),
                clear_symbol: qualified(&bridge.clear_fn),
            })
            .collect()
    }
}