dodo-bindgen-cli 1.0.2

A CLI tool for parsing rust source code and generating a close TypeScript equivalent. works with the `dodo_bindgen` crate
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

use std::path::PathBuf;

use clap::Parser;
use dodo_bindgen_codegen::CodegenOpts;

// interactive mode if no subcommand was passed

// parse-expand source file, autodetect modules, prompt for features with
// auto-detected suggestions no parse-expand, prompt for features manually
// no parse-expand, no prompt, include all features
// no parse-expand, no prompt. no features

// default behavior

#[derive(Debug, Parser)]
#[command(
    name = "deno-bindgen2",
    version,
    about = "A Rust FFI bindings generator for Deno. Use this CLI tool with the `deno_bindgen2` library crate",
    long_about = None
)]
pub struct Cli {
    /// Path to output file. Defaults to `<pkg_root>/dist/mod.ts` if unspecified
    #[arg(short = 'o', long, value_hint = clap::ValueHint::FilePath)]
    pub output: Option<PathBuf>,

    /// Build for release
    #[arg(short = 'r', long)]
    pub release: bool,

    /// Lazily load the generated module. Useful when the dylib will be
    /// fetched/downloaded remotely.
    #[arg(short = 'l', long)]
    lazy: bool,

    /// Whether to print the rust type declarations in the same typescript
    /// module or to write it on a separate file. Useful when linking together
    /// multiple ffi libraries to use the same rust types
    #[arg(short = 'i', long, group = "link")]
    pub inline: bool,

    /// If false, uses the opaque representations of rust types with no
    /// implementation to interface with rust data structures
    ///
    /// If true, uses the extended rust types with methods for interfacing
    /// with rust data structures, but embeds the ffi symbols on the same dyli
    #[arg(short = 'e', long, default_value_t = true)]
    pub extended: bool,

    /// If provided, writes the extended rust types on a  separate
    /// file and uses the dylib from this path for the typescript representation
    /// of the extended rust types. Incompatible with `inline=true`
    #[arg(short = 'm', long, group = "link")]
    embedded: Option<PathBuf>,

    /// Disables source code expansion and module scanning
    #[arg(short = 'n', long)]
    no_expand: bool,

    /// Set to false to disable guided mode
    #[arg(short = 'I', long)]
    interactive: bool,

    /// Disables generation/linking of utility modules
    #[arg(short = 'N', long)]
    no_modules: bool,
}

impl Cli {
    pub fn to_codegen_opts(&self, file_name: String, dylib_path: PathBuf) -> CodegenOpts {
        CodegenOpts {
            file_name,
            dylib_path: dylib_path
                .to_str()
                .expect("unknown utf8 character on dylib path")
                .to_string(),
            lazy: self.lazy,
            extended: self.extended,
            embedded: self.embedded.clone(),
        }
    }
}