tusktsk 2.0.1

🦀 TuskTsk Enhanced - Ultra-fast Rust configuration parser with maximum syntax flexibility
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

use clap::Subcommand;
use crate::{TuskResult, parse, serialize};
use std::fs;
use std::path::Path;

#[derive(Subcommand)]
pub enum UtilityCommand {
    Parse { file: String },
    Validate { file: String },
    Convert { input: String, output: String },
    Get { file: String, key_path: String },
    Set { file: String, key_path: String, value: String },
}

pub fn run(cmd: UtilityCommand) -> TuskResult<()> {
    match cmd {
        UtilityCommand::Parse { file } => {
            utility_parse(&file)?;
            Ok(())
        }
        UtilityCommand::Validate { file } => {
            utility_validate(&file)?;
            Ok(())
        }
        UtilityCommand::Convert { input, output } => { 
            println!("[utility convert {} -> {}] stub", input, output); 
            Ok(()) 
        }
        UtilityCommand::Get { file, key_path } => { 
            println!("[utility get {} {}] stub", file, key_path); 
            Ok(()) 
        }
        UtilityCommand::Set { file, key_path, value } => { 
            println!("[utility set {} {} {}] stub", file, key_path, value); 
            Ok(()) 
        }
    }
}

/// Parse TuskLang file and display contents
fn utility_parse(file: &str) -> TuskResult<()> {
    let content = fs::read_to_string(file)
        .map_err(|e| {
            eprintln!("❌ File not found: {}", file);
            std::process::exit(3); // File not found
        })?;

    match parse(&content) {
        Ok(config) => {
            println!("✅ Successfully parsed '{}'", file);
            println!("📄 File contents:");
            println!("{}", serialize(&config)?);
            Ok(())
        }
        Err(e) => {
            eprintln!("❌ Parse error: {}", e);
            std::process::exit(1); // General error
        }
    }
}

/// Validate TuskLang file syntax
fn utility_validate(file: &str) -> TuskResult<()> {
    let content = fs::read_to_string(file)
        .map_err(|e| {
            eprintln!("❌ File not found: {}", file);
            std::process::exit(3); // File not found
        })?;

    match parse(&content) {
        Ok(_) => {
            println!("✅ File '{}' is valid TuskLang syntax", file);
            Ok(())
        }
        Err(e) => {
            eprintln!("❌ Validation failed: {}", e);
            if let Some(line) = e.line_number() {
                eprintln!("   Error occurred at line {}", line);
            }
            std::process::exit(1); // General error
        }
    }
}