shulkerscript-cli 0.1.0

Command line tool to compile Shulkerscript projects
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

use clap::ValueEnum;

use anyhow::Result;
use shulkerscript::base::{FsProvider, PrintHandler};
use std::path::PathBuf;

use crate::{config::PackConfig, util};

#[derive(Debug, clap::Args, Clone)]
pub struct LangDebugArgs {
    /// The path of the project to compile.
    #[arg(default_value = ".")]
    pub path: PathBuf,
    /// The state to dump.
    ///
    /// Output can be the raw tokens, the abstract syntax tree, or the transpiled datapack.
    #[arg(short, long, value_name = "STATE", default_value = "ast")]
    pub dump: DumpState,
    /// Pretty-print the output.
    #[arg(short, long)]
    pub pretty: bool,
}

#[derive(ValueEnum, Debug, Clone, Copy, Default)]
pub enum DumpState {
    Tokens,
    #[default]
    Ast,
    Datapack,
}

pub fn lang_debug(args: &LangDebugArgs) -> Result<()> {
    let file_provider = FsProvider::default();
    match args.dump {
        DumpState::Tokens => {
            let tokens = shulkerscript::tokenize(
                &PrintHandler::new(),
                &file_provider,
                &args.path,
                args.path.file_stem().map_or(String::from("main"), |s| {
                    s.to_string_lossy().into_owned().to_string()
                }),
            )?;
            if args.pretty {
                println!("{:#?}", tokens);
            } else {
                println!("{:?}", tokens);
            }
        }
        DumpState::Ast => {
            let ast = shulkerscript::parse(
                &PrintHandler::new(),
                &file_provider,
                &args.path,
                args.path.file_stem().map_or(String::from("main"), |s| {
                    s.to_string_lossy().into_owned().to_string()
                }),
            )?;
            if args.pretty {
                println!("{:#?}", ast);
            } else {
                println!("{:?}", ast);
            }
        }
        DumpState::Datapack => {
            let program_paths = super::build::get_script_paths(
                &util::get_project_path(&args.path)
                    .unwrap_or(args.path.clone())
                    .join("src"),
            )?;
            let datapack = shulkerscript::transpile(
                &PrintHandler::new(),
                &file_provider,
                PackConfig::DEFAULT_PACK_FORMAT,
                &program_paths,
            )?;
            if args.pretty {
                println!("{:#?}", datapack);
            } else {
                println!("{:?}", datapack);
            }
        }
    }
    Ok(())
}