flippy 0.4.3

Automates upgrades and pulls remote databases, files, and firmware for the Flipper Zero
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

use gix::bstr::{BString, ByteVec};
use serde::{Deserialize, Serialize};

/// 3) One field per known mapping type
#[derive(Debug, Deserialize, Serialize, Default)]
#[serde(deny_unknown_fields)]
pub struct Mappings {
    pub ibutton: Option<MappingEntry>,
    pub subghz: Option<MappingEntry>,
    pub badusb: Option<MappingEntry>,
    pub rfid: Option<MappingEntry>,
    pub nfc: Option<MappingEntry>,
    pub ir: Option<MappingEntry>,
}

/// 4) Shared include/exclude lists
#[derive(Debug, Deserialize, Serialize)]
pub struct MappingEntry {
    pub include: Vec<String>,
    pub exclude: Vec<String>,
}

impl MappingEntry {
    pub fn patterns(&self) -> impl Iterator<Item = BString> + '_ {
        let inc = self.include.iter().map(|s| BString::from(s.as_str()));
        let exc = self.exclude.iter().map(|s| {
            let mut buf = BString::from(":(exclude)");
            buf.push_str(s);
            buf
        });

        inc.chain(exc)
    }
}

#[derive(Debug)]
pub enum Mapping<'a> {
    SubGHz(&'a MappingEntry),
    Rfid(&'a MappingEntry),
    Nfc(&'a MappingEntry),
    IR(&'a MappingEntry),
    IButton(&'a MappingEntry),
    BadUSB(&'a MappingEntry),
}

#[derive(Debug)]
pub struct MappingInfo<'a> {
    pub patterns: &'a MappingEntry,
    pub destination: &'static str,
    pub ignore: &'static [&'static str],
}

impl Mapping<'_> {
    pub fn info(&self) -> MappingInfo<'_> {
        match self {
            Mapping::SubGHz(patterns) => MappingInfo {
                patterns,
                destination: "/ext/subghz",
                ignore: &["assets"],
            },
            Mapping::Nfc(patterns) => MappingInfo {
                patterns,
                destination: "/ext/nfc",
                ignore: &["assets", ".cache"],
            },
            Mapping::BadUSB(patterns) => MappingInfo {
                patterns,
                destination: "/ext/badusb",
                ignore: &["assets", ".badusb.settings"],
            },
            Mapping::Rfid(patterns) => MappingInfo {
                patterns,
                destination: "/ext/lfrfid",
                ignore: &[],
            },
            Mapping::IButton(patterns) => MappingInfo {
                patterns,
                destination: "/ext/ibutton",
                ignore: &[],
            },
            Mapping::IR(patterns) => MappingInfo {
                patterns,
                destination: "/ext/infared",
                ignore: &["assets"],
            },
        }
    }
}

impl Mappings {
    /// Iterate over every `include` and `exclude` path in every defined mapping,
    /// yielding `(true, path)` for includes and `(false, path)` for excludes.
    pub fn iter(&self) -> impl Iterator<Item = Mapping<'_>> {
        let ibutton = self.ibutton.iter().map(Mapping::IButton);
        let subghz = self.subghz.iter().map(Mapping::SubGHz);
        let badusb = self.badusb.iter().map(Mapping::BadUSB);
        let rfid = self.rfid.iter().map(Mapping::Rfid);
        let nfc = self.nfc.iter().map(Mapping::Nfc);
        let ir = self.ir.iter().map(Mapping::IR);

        // chain them all into one lazy iterator
        ibutton
            .chain(subghz)
            .chain(badusb)
            .chain(rfid)
            .chain(nfc)
            .chain(ir)
    }
}