mbed-core 0.1.7

Embed and transform assets into your Rust crate.
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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

use std::{borrow::Cow::Borrowed, fs::File, ops::Deref};

use mbed_macros::{Artifact, LocalFile, Writer};
use tanager::Parse;

#[proc_macro]
pub fn include_bytes(item: proc_macro::TokenStream) -> proc_macro::TokenStream {
    #[derive(Debug, Hash, Parse)]
    #[tanager(transparent)]
    struct Input(Files);

    impl std::fmt::Display for Input {
        #[inline]
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            write!(f, "mbed::include_bytes {}", self.0)
        }
    }

    mbed_macros::execute_fn(item.into(), |deps, input: Input| {
        deps.track_files(&*input.0);

        let mut writer = Writer::new()?;

        for path in input.0.iter() {
            std::io::copy(&mut File::open(path)?, &mut writer)?;
        }

        std::io::Result::Ok(Artifact {
            mime: input
                .0
                .first()
                .map(|x| {
                    mime_guess::from_path(x)
                        .first_or_octet_stream()
                        .to_string()
                        .into()
                })
                .unwrap_or(Borrowed("application/octet-stream")),

            ..writer.finish()?
        })
    })
    .into()
}

#[proc_macro]
pub fn include_str(item: proc_macro::TokenStream) -> proc_macro::TokenStream {
    #[derive(Debug, Hash, Parse)]
    #[tanager(transparent)]
    struct Input(Files);

    impl std::fmt::Display for Input {
        #[inline]
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            write!(f, "mbed::include_str {}", self.0)
        }
    }

    mbed_macros::execute_fn(item.into(), |deps, input: Input| {
        deps.track_files(&*input.0);

        let mut writer = Writer::new()?;

        for path in input.0.iter() {
            std::io::copy(&mut File::open(path)?, &mut writer)?;
        }

        std::io::Result::Ok(Artifact {
            mime: input
                .0
                .first()
                .map(|x| {
                    mime_guess::from_path(x)
                        .first_or_text_plain()
                        .to_string()
                        .into()
                })
                .unwrap_or(Borrowed("text/plain")),

            ..writer.finish()?.into_text_artifact()
        })
    })
    .into()
}

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Parse)]
#[tanager(transparent)]
struct Files(Box<[LocalFile]>);

impl std::fmt::Display for Files {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let cwd = std::env::current_dir().ok();

        let paths = self
            .0
            .iter()
            .map(|x| {
                cwd.as_ref()
                    .and_then(|cwd| x.strip_prefix(cwd).ok())
                    .unwrap_or(x.as_path())
            })
            .map(|x| x.to_string_lossy());

        write!(f, "[ ")?;

        let mut b: usize = 80;

        for (index, path) in paths.enumerate() {
            if index != 0 {
                write!(f, ", ")?;

                b = b.saturating_sub(path.len());

                if b != 0 {
                    write!(f, "{path}")?;
                } else {
                    write!(f, "...")?;
                }
            } else {
                b = b.saturating_sub(path.len());

                write!(f, "{path}")?;
            }
        }

        write!(f, " ]")?;

        Ok(())
    }
}

impl Deref for Files {
    type Target = [LocalFile];

    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}