voltaic-cli 0.1.0

The Voltaic compiler: .sdx in, .xrs containing ordinary Rust out.
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

use crate::build_command::parse_build_args;

use crate::run::usage;

use voltaic_driver::CheckOutcome;

use voltaic_driver::diagnose;

use std::path::PathBuf;

pub(crate) fn check_command(args: &[String]) -> Result<(), String> {
  let parsed = parse_build_args(args)?;
  let shown = parsed.input.display().to_string();
  let source = std::fs::read_to_string(&parsed.input)
    .map_err(|e| format!("error: cannot read {}: {}", shown, e))?;

  let outcome = voltaic_driver::check(&parsed.input, &source)?;
  report(&outcome, parsed.plain)
}

pub(crate) fn report(outcome: &CheckOutcome, plain: bool) -> Result<(), String> {
  if outcome.diagnostics.is_empty() {
    return Ok(());
  }
  let rendered = voltaic_diag::render(&outcome.diagnostics, plain);
  if outcome.failed {
    return Err(rendered);
  }
  eprintln!("{}", rendered);
  Ok(())
}

pub(crate) fn fmt_command(args: &[String]) -> Result<(), String> {
  let parsed = parse_fmt_args(args)?;
  let mut unformatted: Vec<String> = Vec::new();

  for path in &parsed.inputs {
    let shown = path.display().to_string();
    let source =
      std::fs::read_to_string(path).map_err(|e| format!("error: cannot read {}: {}", shown, e))?;

    let program = voltaic_parser::parse_source(&source)
      .map_err(|failure| voltaic_diag::render(&diagnose(path, &source, &failure), parsed.plain))?;

    let formatted = voltaic_fmt::format(&program, &source);
    if formatted == source {
      continue;
    }

    if parsed.check {
      unformatted.push(shown);
    } else {
      std::fs::write(path, &formatted)
        .map_err(|e| format!("error: cannot write {}: {}", shown, e))?;
    }
  }

  if unformatted.is_empty() {
    return Ok(());
  }
  let indented: Vec<String> = unformatted.iter().map(|p| format!("  {}", p)).collect();
  let listed = indented.join("\n");
  Err(format!(
    "error: not formatted:\n{}\nrun `voltaic fmt` on them\n",
    listed
  ))
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct FmtArgs {
  pub(crate) inputs: Vec<PathBuf>,
  pub(crate) check: bool,
  pub(crate) plain: bool,
}

pub(crate) fn parse_fmt_args(args: &[String]) -> Result<FmtArgs, String> {
  let mut inputs = Vec::new();
  let mut check = false;
  let mut plain = false;

  for arg in args {
    match arg.as_str() {
      "--check" => check = true,
      "--plain" => plain = true,
      flag if flag.starts_with('-') => {
        let help = usage();
        return Err(format!("error: unknown flag `{}`\n\n{}", flag, help));
      }
      path => inputs.push(PathBuf::from(path)),
    };
  }

  if inputs.is_empty() {
    let help = usage();
    return Err(format!("error: fmt needs at least one .sdx\n\n{}", help));
  }

  Ok(FmtArgs {
    inputs,
    check,
    plain,
  })
}