tinty 0.26.1

Change the theme of your terminal, text editor and anything else with one command!
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

use crate::constants::{
    CURRENT_SCHEME_FILE_NAME, CUSTOM_SCHEMES_DIR_NAME, REPO_DIR, REPO_NAME, SCHEMES_REPO_NAME,
};
use anyhow::{anyhow, Result};
use std::fs;
use std::path::Path;
use tinted_builder_rust::utils::get_scheme_files;

/// Prints out the name of the last scheme applied
pub fn current(data_path: &Path, property_name: &str) -> Result<()> {
    let current_scheme_slug =
        fs::read_to_string(data_path.join(CURRENT_SCHEME_FILE_NAME)).unwrap_or_default();
    let schemes_path = data_path.join(format!("{}/{}", REPO_DIR, SCHEMES_REPO_NAME));

    if current_scheme_slug.is_empty() {
        return Err(anyhow!(
            "Failed to read last scheme from file. Try applying a scheme and try again."
        ));
    }

    if property_name.is_empty() {
        println!("{}", current_scheme_slug);

        return Ok(());
    }

    if !schemes_path.is_dir() {
        return Err(anyhow!(
            "No schemes exist. Run `{} sync` and try again.",
            REPO_NAME
        ));
    }

    let custom_schemes_path = data_path.join(CUSTOM_SCHEMES_DIR_NAME);
    let scheme_files = {
        let mut scheme_files = get_scheme_files(&schemes_path, true)?;

        if custom_schemes_path.is_dir() {
            let custom_scheme_files = get_scheme_files(&custom_schemes_path, true)?;
            scheme_files.extend(custom_scheme_files);
        }

        scheme_files
    };

    let current_scheme_container = scheme_files.iter().find_map(|scheme_file| {
        let path = scheme_file.get_path().unwrap_or_default();
        let file_stem = path
            .file_stem()
            .unwrap_or_default()
            .to_str()
            .unwrap_or_default();

        if current_scheme_slug.contains(file_stem) {
            if let Ok(scheme) = scheme_file.get_scheme() {
                let scheme_slug = scheme.get_scheme_slug();
                let system = scheme.get_scheme_system();
                let tinty_slug = format!("{}-{}", system, scheme_slug);

                if tinty_slug == current_scheme_slug {
                    return Some(scheme);
                }
            }
        }

        None
    });

    if let Some(current_scheme_container) = current_scheme_container {
        match property_name {
            "author" => {
                println!("{}", current_scheme_container.get_scheme_author());
            }
            "description" => {
                println!("{}", current_scheme_container.get_scheme_description());
            }
            "name" => {
                println!("{}", current_scheme_container.get_scheme_name());
            }
            "slug" => {
                println!("{}", current_scheme_container.get_scheme_slug());
            }
            "system" => {
                println!("{}", current_scheme_container.get_scheme_system());
            }
            "variant" => {
                println!("{}", current_scheme_container.get_scheme_variant());
            }
            _ => {
                eprintln!("Unable to find property: {}", property_name);
            }
        }
    } else {
        eprintln!("Unable to find property: {}", property_name);
    }

    Ok(())
}