releez 1.0.3

An utility tool to run application release-checklist safely.
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

use crate::constants;
use crate::out;
use crate::prelude::*;
use crate::types::{HaltConfig, LastCheckedConfig, ReleaseConfig};
use chrono::offset::Local;
use colored::*;
use semver::Version;
use std::collections::HashMap;
use std::path::Path;
use tokio::fs;

pub async fn calculate_start_task_ids(release_config: &ReleaseConfig, halt_config: Option<&HaltConfig>) -> (u64, u64) {
    let mut last_checked_task_ids: Option<(u64, u64)> = None;

    if let Some(halt_config) = halt_config {
        if halt_config.version == release_config.version
            && ask_user_to_continue_with_halt(release_config, halt_config)
                .await
                .unwrap_or(false)
        {
            last_checked_task_ids = Some((halt_config.last_checked.task_id, halt_config.last_checked.sub_task_id));
        }
    }

    let (last_checked_task_id, last_checked_sub_task_id) = match last_checked_task_ids {
        Some(ids) => ids,
        None => return (0, 0),
    };

    if let Some(last_checked_task) = release_config.checklist.get(last_checked_task_id as usize) {
        if (last_checked_sub_task_id + 1) < (last_checked_task.sub_tasks().len() as u64) {
            (last_checked_task_id, last_checked_sub_task_id + 1)
        } else {
            (last_checked_task_id + 1, 0)
        }
    } else {
        (0, 0)
    }
}

pub async fn ask_confirmation(message: &str, default_val: &str, padding: &str) -> crate::Result<bool> {
    out::print(format!(
        "{}{} {} ({}){}",
        padding,
        "?".cyan(),
        message.trim(),
        default_val,
        " › ".bright_black(),
    ))
    .await?;

    let mut line = out::read_line().await?;

    if line.is_empty() {
        line = default_val.to_owned();
    }

    Ok(constants::BOOL_POSSIBLE_TRUTHY_INPUTS.contains(&line.to_lowercase().as_str()))
}

pub async fn ask_user_to_continue_with_halt(
    release_config: &ReleaseConfig,
    halt_config: &HaltConfig,
) -> crate::Result<bool> {
    out::print("\n").await?;

    out::print(format!("Previous release was not completed properly.\n")).await?;

    let (last_checked_task_name, is_partial_completion) = release_config
        .checklist
        .get(halt_config.last_checked.task_id as usize)
        .map(|t| {
            (
                t.name.as_str(),
                halt_config.last_checked.sub_task_id < ((t.sub_tasks().len() as u64) - 1),
            )
        })
        .unwrap_or(("na", false));

    if is_partial_completion {
        out::print(format!(
            "Last partially checked task: '{}'.\n",
            last_checked_task_name.cyan()
        ))
        .await?;
    } else {
        out::print(format!("Last checked task: '{}'.\n", last_checked_task_name.cyan())).await?;
    }

    let confirmation = ask_confirmation("Do you want to resume the release?", "yes", "").await?;

    Ok(confirmation)
}

pub fn gen_vars_data(release_version: &Version) -> HashMap<String, String> {
    let mut h = HashMap::new();
    h.insert(constants::VAR_NAME_VERSION.to_owned(), release_version.to_string());
    h
}

pub async fn save_last_checked(
    release_config: &ReleaseConfig,
    last_checked_task_id: u64,
    last_checked_sub_task_id: u64,
    root_dir: &Path,
) -> crate::Result<()> {
    let halt_config = HaltConfig {
        version: release_config.version.clone(),
        last_checked: LastCheckedConfig {
            task_id: last_checked_task_id,
            sub_task_id: last_checked_sub_task_id,
            date: Local::now().timestamp_millis(),
        },
    };

    let data = serde_yaml::to_vec(&halt_config).context("Couldn't convert halt config to yaml")?;

    fs::write(root_dir.join(constants::HALT_CONFIG_FILE_NAME), data)
        .await
        .context(format!(
            "Couldn't write task's checked state to halt config file: {}",
            constants::HALT_CONFIG_FILE_NAME
        ))?;

    Ok(())
}