boltffi_cli 0.26.0

CLI for BoltFFI - generate Swift, Kotlin, and WASM bindings from Rust
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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use crate::cli::Result;
use crate::config::{Config, Target};
use crate::reporter::Reporter;

use super::{
    PackAllOptions, PackAndroidOptions, PackAppleOptions, PackCSharpOptions, PackDartOptions,
    PackJavaOptions, PackKmpOptions, PackPythonOptions, PackWasmOptions, pack_android, pack_apple,
    pack_csharp, pack_dart, pack_java, pack_kmp, pack_python, pack_wasm, prepare_java_packaging,
};

pub(super) fn pack_all(
    config: &Config,
    options: PackAllOptions,
    reporter: &Reporter,
) -> Result<()> {
    super::ensure_java_no_build_supported(
        config,
        options.execution.no_build,
        options.experimental,
        "pack all",
    )?;
    super::ensure_kmp_no_build_supported(
        config,
        options.execution.no_build,
        options.experimental,
        "pack all",
    )?;
    let prepared_java_packaging = config
        .should_process(Target::Java, options.experimental)
        .then(|| {
            prepare_java_packaging(
                config,
                options.execution.release,
                &options.execution.cargo_args,
            )
        })
        .transpose()?;

    let mut packed_any = false;

    if config.is_apple_enabled() {
        pack_apple(
            config,
            PackAppleOptions {
                execution: options.execution.clone(),
                version: None,
                spm_only: false,
                xcframework_only: false,
                layout: None,
            },
            reporter,
        )?;
        packed_any = true;
    }

    if config.is_android_enabled() {
        pack_android(
            config,
            PackAndroidOptions {
                execution: options.execution.clone(),
            },
            reporter,
        )?;
        packed_any = true;
    }

    if config.should_process(Target::KotlinMultiplatform, options.experimental) {
        pack_kmp(
            config,
            PackKmpOptions {
                execution: options.execution.clone(),
                experimental: options.experimental,
            },
            reporter,
        )?;
        packed_any = true;
    }

    if config.is_wasm_enabled() {
        pack_wasm(
            config,
            PackWasmOptions {
                execution: options.execution.clone(),
            },
            reporter,
        )?;
        packed_any = true;
    }

    if config.should_process(Target::Java, options.experimental) {
        pack_java(
            config,
            PackJavaOptions {
                execution: options.execution.clone(),
                experimental: options.experimental,
            },
            prepared_java_packaging,
            reporter,
        )?;
        packed_any = true;
    }

    if config.should_process(Target::Python, options.experimental) {
        pack_python(
            config,
            PackPythonOptions {
                execution: options.execution.clone(),
                experimental: options.experimental,
                python_interpreters: options.python_interpreters.clone(),
            },
            reporter,
        )?;
        packed_any = true;
    }

    if config.should_process(Target::Dart, options.experimental) {
        pack_dart(
            config,
            PackDartOptions {
                execution: options.execution.clone(),
                experimental: options.experimental,
            },
            reporter,
        )?;
        packed_any = true;
    }

    if config.is_csharp_enabled() {
        pack_csharp(
            config,
            PackCSharpOptions {
                execution: options.execution,
            },
            reporter,
        )?;
        packed_any = true;
    }

    if !packed_any {
        reporter.warning("no targets enabled in config");
    }

    reporter.finish();
    Ok(())
}