univert 0.2.0

Universal file converter (library and CLI)
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

use clap::Parser;
use std::path::PathBuf;
use std::process::ExitCode;

use crate::{Options, conversion_map, convert};

/// Universal file converter.
#[derive(Parser, Debug)]
#[command(
  name = "univert",
  version,
  about = "Universal file converter",
  override_usage = "univert <input-file> <output-file> [OPTIONS]"
)]
pub struct Args {
  /// Overwrite existing file
  #[arg(short, long)]
  pub force: bool,

  /// List all available conversions
  #[arg(short, long)]
  pub list: bool,

  /// Split source file into several target files (where applicable)
  #[arg(short, long)]
  pub split: bool,

  /// Input file
  pub input: Option<PathBuf>,

  /// Output file
  pub output: Option<PathBuf>,
}

pub fn run() -> ExitCode {
  // Restore default SIGPIPE behavior so piping into `head` etc. terminates
  // cleanly instead of panicking from a broken-pipe write.
  #[cfg(unix)]
  {
    use std::os::raw::c_int;
    unsafe extern "C" {
      fn signal(signum: c_int, handler: usize) -> usize;
    }
    const SIGPIPE: c_int = 13;
    const SIG_DFL: usize = 0;
    unsafe {
      signal(SIGPIPE, SIG_DFL);
    }
  }

  let args = Args::parse();

  if args.list {
    for (from, to) in conversion_map::list_all() {
      println!("{from} -> {to}");
    }
    return ExitCode::SUCCESS;
  }

  let (Some(input), Some(output)) = (args.input.as_ref(), args.output.as_ref())
  else {
    eprintln!("usage: univert <input-file> <output-file> [OPTIONS]");
    return ExitCode::from(2);
  };

  let options = Options {
    force: args.force,
    split: args.split,
  };

  match convert(input, output, &options) {
    Ok(()) => {
      println!("Converted {} to {}", input.display(), output.display());
      ExitCode::SUCCESS
    }
    Err(err) => {
      eprintln!("{err}");
      ExitCode::FAILURE
    }
  }
}