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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use crate::types::directory::Id;
use crate::types::firmware::Firmware;
use crate::types::flip::Flip;
use crate::validators::{ProjectNameValidator, URLValidator};
use anyhow::anyhow;
use cliclack::{confirm, input, intro, outro, select};
use std::path::Path;
use tokio::fs;
use tracing::{debug, info, instrument};

pub async fn run<P: AsRef<Path>>(path: P) -> anyhow::Result<()> {
    intro("flippy new")?;

    debug!("Extracting default name from provided path");
    let default_name_opt: Option<&str> = path.as_ref().file_name().and_then(|v| v.to_str());

    debug!("Starting new flip wizard");

    let config = new_wizard(default_name_opt.map(str::to_string))?;

    debug!("Flip config: {:?}", config);

    debug!("Prompting user to confirm flip creation");
    let confirm = confirm("Create a new flip with these settings?").interact()?;

    if !confirm {
        info!("Cancelled flip creation.");
        return Ok(());
    }

    let final_path = {
        if default_name_opt == Some(&config.0) {
            path.as_ref().to_path_buf()
        } else {
            path.as_ref().join(&config.0)
        }
    };

    if final_path.exists() {
        return Err(anyhow!("directory {} already exists", final_path.display()));
    }

    let config = Flip {
        name: config.0,
        firmware: config.1,
        source_path: final_path,
        ..Flip::default()
    };

    debug!(
        "Creating project directory: {}",
        config.source_path.display()
    );

    // makes both project dir and store
    fs::create_dir_all(config.source_path.join("store")).await?;

    debug!("Creating flip.toml");
    config.write().await?;

    outro("flip created successfuly")?;

    Ok(())
}

#[instrument]
fn new_wizard(default_name: Option<String>) -> anyhow::Result<(String, Firmware)> {
    debug!("Prompting for project name");
    let mut name = input("Name").validate_interactively(ProjectNameValidator);

    if let Some(default_name) = default_name {
        name = name.default_input(&default_name);
    }

    let name = name.interact()?;

    debug!("Prompting for firmware source");
    let firmware = {
        let firmware_type = select("Firmware source")
            .item("official", "Official", "maintained by flipper staff")
            .item("unleashed", "Unleashed", "")
            .item("momentum", "Momentum", "")
            .item(
                "custom",
                "Custom (.tgz)",
                "supply a custom firmware through a direct link to a .tgz file",
            )
            .interact()?;

        debug!(firmware_type, "User selected firmware:");

        if firmware_type == "custom" {
            debug!("Prompting for custom firmware URL");
            Firmware::Custom(
                input("URL to custom firmware")
                    .validate(URLValidator)
                    .interact()?,
            )
        } else {
            let channel = select("Channel")
                .initial_value(Id::Release)
                .item(Id::Release, "Release", "Stable releases")
                .item(
                    Id::ReleaseCanidate,
                    "Release candidate",
                    "This is going to be released soon",
                )
                .item(
                    Id::Development,
                    "Development",
                    "Latest builds, not tested, and may be unstable, be careful",
                )
                .interact()?;

            match firmware_type {
                "official" => Firmware::Official(channel),
                "unleashed" => Firmware::Unleashed(channel),
                "momentum" => Firmware::Momentum(channel),

                _ => unreachable!("todo: add more fw matches"),
            }
        }
    };

    Ok((name, firmware))
}