rototo 0.1.0-alpha.8

Control plane for runtime configuration of your application.
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

use std::path::Path;
use std::process::ExitCode;

use serde::Serialize;

use rototo::{PackagedArchive, Result, RototoError, SourceOptions, pack_package, project_package};

use crate::PackageArgs;
use crate::package_source_string_or_current;
use crate::style;

pub(crate) async fn run_package(
    args: PackageArgs,
    source_options: &SourceOptions,
    json: bool,
    quiet: bool,
) -> Result<ExitCode> {
    let source = package_source_string_or_current(args.package).await?;

    if let Some(target) = &args.unpacked {
        let written = project_package(&source, source_options, target).await?;

        if json {
            println!(
                "{}",
                serde_json::to_string_pretty(&UnpackedOutput {
                    package: &source,
                    directory: &target.display().to_string(),
                    files: written.len(),
                })
                .map_err(|err| RototoError::new(err.to_string()))?
            );
            return Ok(ExitCode::SUCCESS);
        }

        if quiet {
            println!("{}", target.display());
            return Ok(ExitCode::SUCCESS);
        }

        println!("{} {}", style::label("package"), style::bold(&source));
        println!(
            "{} {}  {}",
            style::label("unpacked"),
            style::bold(&target.display().to_string()),
            style::dim(&format!("{} files", written.len()))
        );
        return Ok(ExitCode::SUCCESS);
    }

    let archive = pack_package(&source, source_options).await?;
    let path = write_archive(&args.output, &archive).await?;

    if json {
        println!(
            "{}",
            serde_json::to_string_pretty(&PackageOutput {
                package: &source,
                release_id: &archive.release_id,
                archive: &path.display().to_string(),
                bytes: archive.bytes.len(),
            })
            .map_err(|err| RototoError::new(err.to_string()))?
        );
        return Ok(ExitCode::SUCCESS);
    }

    if quiet {
        println!("{}", path.display());
        return Ok(ExitCode::SUCCESS);
    }

    println!("{} {}", style::label("package"), style::bold(&source));
    println!(
        "{} {}",
        style::label("release"),
        style::sea_bold(&archive.release_id)
    );
    println!(
        "{} {}  {}",
        style::label("archive"),
        style::bold(&path.display().to_string()),
        style::dim(&format!("{} bytes", archive.bytes.len()))
    );
    Ok(ExitCode::SUCCESS)
}

async fn write_archive(output: &Path, archive: &PackagedArchive) -> Result<std::path::PathBuf> {
    tokio::fs::create_dir_all(output).await.map_err(|err| {
        RototoError::new(format!(
            "failed to create output directory {}: {err}",
            output.display()
        ))
    })?;
    let path = output.join(&archive.file_name);
    tokio::fs::write(&path, &archive.bytes)
        .await
        .map_err(|err| {
            RototoError::new(format!(
                "failed to write package archive {}: {err}",
                path.display()
            ))
        })?;
    Ok(path)
}

#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct UnpackedOutput<'a> {
    package: &'a str,
    directory: &'a str,
    files: usize,
}

#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct PackageOutput<'a> {
    package: &'a str,
    release_id: &'a str,
    archive: &'a str,
    bytes: usize,
}