flutter_rust_bridge_codegen 2.12.0

Flutter/Dart <-> Rust binding generator, feature-rich, but seamless and simple
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

use crate::codegen::dumper::internal_config::{ConfigDumpContent, DumperInternalConfig};
use crate::codegen::generator::acc::Acc;
use crate::codegen::generator::misc::path_texts::PathTexts;
use crate::codegen::generator::misc::target::TargetOrCommon;
use crate::utils::file_utils::create_dir_all_and_write;
use crate::utils::path_utils::path_to_string;
use anyhow::Context;
use convert_case::{Case, Casing};
use log::debug;
use pathdiff::diff_paths;
use serde::Serialize;
use std::path::Path;
use strum::IntoEnumIterator;

pub(super) mod internal_config;

#[derive(Clone)]
pub(crate) struct Dumper<'a> {
    config: &'a DumperInternalConfig,
    content: Option<ConfigDumpContent>,
    name_prefix: String,
}

impl<'a> Dumper<'a> {
    pub(crate) fn new(config: &'a DumperInternalConfig) -> Self {
        Self {
            config,
            content: None,
            name_prefix: "".to_string(),
        }
    }

    pub(crate) fn with_content(&self, content: ConfigDumpContent) -> Self {
        Self {
            content: Some(content),
            ..self.clone()
        }
    }

    pub(crate) fn with_add_name_prefix(&self, add_name_prefix: &str) -> Self {
        Self {
            name_prefix: format!("{}{}", self.name_prefix, add_name_prefix),
            ..self.clone()
        }
    }

    pub(crate) fn dump<T: Serialize>(&self, name: &str, data: &T) -> anyhow::Result<()> {
        if !self.is_enabled() {
            return Ok(());
        }

        self.dump_str(name, &serde_json::to_string_pretty(data)?)
    }

    pub(crate) fn dump_path_texts(
        &self,
        partial_name: &str,
        path_texts: &PathTexts,
        base_dir: &Path,
    ) -> anyhow::Result<()> {
        if !self.is_enabled() {
            return Ok(());
        }

        for path_text in path_texts.0.iter() {
            self.dump_str(
                &format!(
                    "{partial_name}/{}",
                    path_to_string(
                        &diff_paths(&path_text.path, base_dir).context("cannot diff path")?
                    )?
                ),
                &path_text.text.all_code(),
            )?;
        }

        Ok(())
    }

    pub(crate) fn dump_acc(
        &self,
        partial_name: &str,
        extension: &str,
        acc: &Acc<Option<String>>,
    ) -> anyhow::Result<()> {
        if !self.is_enabled() {
            return Ok(());
        }

        for target in TargetOrCommon::iter() {
            self.dump_str(
                &format!("{partial_name}/{target}.{extension}"),
                &acc[target].clone().unwrap_or_default(),
            )?;
        }

        Ok(())
    }

    pub(crate) fn dump_str(&self, partial_name: &str, text: &str) -> anyhow::Result<()> {
        if !self.is_enabled() {
            return Ok(());
        }

        let name = format!("{}{}", self.name_prefix, partial_name);
        let path = (self.config.dump_directory)
            .join(self.content.unwrap().to_string().to_case(Case::Snake))
            .join(&name);
        debug!("Dumping {name} into {path:?}");

        create_dir_all_and_write(path, text)
    }

    fn is_enabled(&self) -> bool {
        self.config.dump_contents.contains(&self.content.unwrap())
    }
}