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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

pub mod cli;
pub mod conversion_map;
pub mod converters;
pub mod pipeline;

use std::path::{Path, PathBuf};

#[derive(Debug, thiserror::Error)]
pub enum Error {
  #[error("Input file {0} does not exist")]
  InputMissing(PathBuf),

  #[error("Output file {0} already exists")]
  OutputExists(PathBuf),

  #[error("Input file {0} has no extension")]
  InputNoExtension(PathBuf),

  #[error("Output file {0} has no extension")]
  OutputNoExtension(PathBuf),

  #[error("Conversion from {from} to {to} is not yet supported.")]
  Unsupported { from: String, to: String },

  #[error("Conversion from {from} to {to} is not yet implemented.")]
  NotImplemented { from: String, to: String },

  #[error(
    "Conversion from {from} to {to} requires `{tool}`, which was not found on PATH."
  )]
  MissingTool {
    from: String,
    to: String,
    tool: &'static str,
  },

  #[error("External tool `{tool}` failed: {message}")]
  ToolFailed { tool: &'static str, message: String },

  #[error(transparent)]
  Io(#[from] std::io::Error),

  #[error(transparent)]
  Csv(#[from] csv::Error),

  #[error("{0}")]
  Other(String),
}

impl Error {
  pub fn other(msg: impl Into<String>) -> Self {
    Error::Other(msg.into())
  }
}

pub type Result<T> = std::result::Result<T, Error>;

#[derive(Debug, Clone, Default)]
pub struct Options {
  pub force: bool,
  pub split: bool,
}

pub struct Job<'a> {
  pub input: &'a Path,
  pub output: &'a Path,
  pub options: &'a Options,
}

pub fn normalize_extension(ext: &str) -> String {
  let lower = ext.to_ascii_lowercase();
  match lower.as_str() {
    "jpg" => "jpeg".to_string(),
    _ => lower,
  }
}

pub fn extension_of(path: &Path) -> Option<String> {
  path
    .extension()
    .and_then(|e| e.to_str())
    .map(normalize_extension)
}

pub fn convert(input: &Path, output: &Path, options: &Options) -> Result<()> {
  if !input.exists() {
    return Err(Error::InputMissing(input.to_path_buf()));
  }

  if output.exists() && !options.force {
    return Err(Error::OutputExists(output.to_path_buf()));
  }

  let from = extension_of(input)
    .ok_or_else(|| Error::InputNoExtension(input.to_path_buf()))?;

  let to = extension_of(output)
    .ok_or_else(|| Error::OutputNoExtension(output.to_path_buf()))?;

  let entry = conversion_map::lookup(&from, &to).ok_or(Error::Unsupported {
    from: from.clone(),
    to: to.clone(),
  })?;

  let job = Job {
    input,
    output,
    options,
  };

  pipeline::run(&from, &to, entry, &job)
}