use anyhow::{bail, Context, Result};
use std::fs::File;
use std::io::IsTerminal;
use std::io::{BufWriter, Read, Write};
use std::path::{Path, PathBuf};
use termcolor::{Ansi, ColorChoice, NoColor, StandardStream, WriteColor};
#[derive(clap::Parser)]
pub struct GeneralOpts {
#[clap(long = "verbose", short = 'v', action = clap::ArgAction::Count)]
verbose: u8,
#[clap(long = "color", default_value = "auto")]
pub color: ColorChoice,
}
impl GeneralOpts {
pub fn init_logger(&self) {
let default = match self.verbose {
0 => "warn",
1 => "info",
2 => "debug",
_ => "trace",
};
env_logger::Builder::from_env(env_logger::Env::default().default_filter_or(default))
.format_target(false)
.init();
}
}
#[derive(clap::Parser)]
pub struct InputOutput {
#[clap(flatten)]
input: InputArg,
#[clap(flatten)]
output: OutputArg,
#[clap(flatten)]
general: GeneralOpts,
}
#[derive(clap::Parser)]
pub struct InputArg {
input: Option<PathBuf>,
}
impl InputArg {
pub fn parse_wasm(&self) -> Result<Vec<u8>> {
if let Some(path) = &self.input {
if path != Path::new("-") {
let bytes = wat::parse_file(path)?;
return Ok(bytes);
}
}
let mut stdin = Vec::new();
std::io::stdin()
.read_to_end(&mut stdin)
.context("failed to read <stdin>")?;
let bytes = wat::parse_bytes(&stdin).map_err(|mut e| {
e.set_path("<stdin>");
e
})?;
Ok(bytes.into_owned())
}
}
#[derive(clap::Parser)]
pub struct OutputArg {
#[clap(short, long)]
output: Option<PathBuf>,
}
pub enum Output<'a> {
#[cfg(feature = "component")]
Wit {
resolve: &'a wit_parser::Resolve,
ids: &'a [wit_parser::PackageId],
printer: wit_component::WitPrinter,
},
Wasm(&'a [u8]),
Wat {
wasm: &'a [u8],
config: wasmprinter::Config,
},
Json(&'a str),
}
impl InputOutput {
pub fn parse_input_wasm(&self) -> Result<Vec<u8>> {
self.input.parse_wasm()
}
pub fn output_wasm(&self, wasm: &[u8], wat: bool) -> Result<()> {
if wat {
self.output(Output::Wat {
wasm,
config: Default::default(),
})
} else {
self.output(Output::Wasm(wasm))
}
}
pub fn output(&self, bytes: Output<'_>) -> Result<()> {
self.output.output(&self.general, bytes)
}
pub fn output_writer(&self) -> Result<Box<dyn WriteColor>> {
self.output.output_writer(self.general.color)
}
pub fn output_path(&self) -> Option<&Path> {
self.output.output.as_deref()
}
pub fn input_path(&self) -> Option<&Path> {
self.input.input.as_deref()
}
pub fn general_opts(&self) -> &GeneralOpts {
&self.general
}
}
impl OutputArg {
pub fn output_wasm(&self, general: &GeneralOpts, wasm: &[u8], wat: bool) -> Result<()> {
if wat {
self.output(
general,
Output::Wat {
wasm,
config: Default::default(),
},
)
} else {
self.output(general, Output::Wasm(wasm))
}
}
pub fn output(&self, general: &GeneralOpts, output: Output<'_>) -> Result<()> {
match output {
Output::Wat { wasm, config } => {
let mut writer = self.output_writer(general.color)?;
config.print(wasm, &mut wasmprinter::PrintTermcolor(&mut writer))
}
Output::Wasm(bytes) => {
match &self.output {
Some(path) => {
std::fs::write(path, bytes)
.context(format!("failed to write `{}`", path.display()))?;
}
None => {
let mut stdout = std::io::stdout();
if stdout.is_terminal() {
bail!("cannot print binary wasm output to a terminal, pass the `-t` flag to print the text format");
}
stdout
.write_all(bytes)
.context("failed to write to stdout")?;
}
}
Ok(())
}
Output::Json(s) => self.output_str(s),
#[cfg(feature = "component")]
Output::Wit {
resolve,
ids,
mut printer,
} => {
let output = printer.print(resolve, ids)?;
self.output_str(&output)
}
}
}
fn output_str(&self, output: &str) -> Result<()> {
match &self.output {
Some(path) => {
std::fs::write(path, output)
.context(format!("failed to write `{}`", path.display()))?;
}
None => std::io::stdout()
.write_all(output.as_bytes())
.context("failed to write to stdout")?,
}
Ok(())
}
pub fn output_path(&self) -> Option<&Path> {
self.output.as_deref()
}
pub fn output_writer(&self, color: ColorChoice) -> Result<Box<dyn WriteColor>> {
match &self.output {
Some(output) => {
let writer = BufWriter::new(File::create(&output)?);
if color == ColorChoice::AlwaysAnsi {
Ok(Box::new(Ansi::new(writer)))
} else {
Ok(Box::new(NoColor::new(writer)))
}
}
None => {
let stdout = std::io::stdout();
if color == ColorChoice::Auto && !stdout.is_terminal() {
Ok(Box::new(StandardStream::stdout(ColorChoice::Never)))
} else {
Ok(Box::new(StandardStream::stdout(color)))
}
}
}
}
}