Change the interface

IvanUkhov · IvanUkhov · commit e542b220a465 · 2025-02-28T09:58:24.000+01:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -26,7 +26,7 @@ build = "build.rs"
 [features]
 default = ["version1", "version2"]
 
-binary = ["arguments", "version1", "version2"]
+binary = ["arguments"]
 version1 = []
 version2 = []
 
diff --git a/src/main.rs b/src/main.rs
@@ -1,51 +1,73 @@
+use std::fs::{read, write};
 use std::path::PathBuf;
 
+#[allow(unused_variables)]
 fn main() {
     let arguments::Arguments {
         options, orphans, ..
     } = arguments::parse(std::env::args()).expect("failed to parse arguments");
     #[allow(clippy::get_first)]
     let source = match orphans.get(0) {
         Some(value) => PathBuf::from(value),
-        _ => {
-            eprintln!("Error: a source should be given.");
-            std::process::exit(1);
-        }
+        _ => usage(),
     };
     let destination = match orphans.get(1) {
         Some(value) => PathBuf::from(value),
-        _ => {
-            eprintln!("Error: a destination should be given.");
-            std::process::exit(1);
-        }
+        _ => usage(),
     };
-    let source_extension = source.extension().and_then(|value| value.to_str());
-    let destination_extension = destination.extension().and_then(|value| value.to_str());
-    if source_extension
-        .map(|value| value == "woff")
-        .unwrap_or(false)
-        || destination_extension
-            .map(|value| value == "woff")
-            .unwrap_or(false)
-    {
-        woff::version1::convert(source, destination).expect("failed to transform");
-    } else if source_extension
-        .map(|value| value == "woff2")
-        .unwrap_or(false)
-        || destination_extension
-            .map(|value| value == "woff2")
-            .unwrap_or(false)
-    {
-        woff::version2::convert(
-            source,
-            destination,
-            options.get::<String>("metadata"),
-            options.get::<usize>("quality"),
-            options.get::<bool>("transform"),
-        )
-        .expect("failed to transform");
-    } else {
-        eprintln!("Error: one file should end with either .woff or .woff2.");
-        std::process::exit(1);
+    #[allow(unused_mut)]
+    let mut data = read(&source).expect("failed to read the source");
+    match (
+        source.extension().and_then(|value| value.to_str()),
+        destination.extension().and_then(|value| value.to_str()),
+    ) {
+        #[cfg(feature = "version1")]
+        (_, Some("woff")) => {
+            data = woff::version1::compress(
+                &data,
+                options.get::<usize>("major").unwrap_or(1),
+                options.get::<usize>("minor").unwrap_or(0),
+            )
+            .expect("failed to compress");
+        }
+        #[cfg(feature = "version1")]
+        (Some("woff"), _) => {
+            data = woff::version1::decompress(&data).expect("failed to decompress");
+        }
+        #[cfg(feature = "version2")]
+        (_, Some("woff2")) => {
+            data = woff::version2::compress(
+                &data,
+                options.get::<usize>("quality").unwrap_or(8),
+                options.get::<String>("metadata").unwrap_or_default(),
+                options.get::<bool>("transform").unwrap_or(true),
+            )
+            .expect("failed to compress");
+        }
+        #[cfg(feature = "version2")]
+        (Some("woff2"), _) => {
+            data = woff::version2::decompress(&data).expect("failed to decompress");
+        }
+        _ => usage(),
     }
+    #[allow(unreachable_code)]
+    write(destination, data).expect("failed to write to the destination");
+}
+
+fn usage() -> ! {
+    eprintln!(
+        r#"Usage: <source> <destination> [options]
+
+Either the source or destination should end with either .woff or .woff2.
+
+Options for WOFF:
+    --major <number>
+    --minor <number>
+
+Options for WOFF2:
+    --quality <number>
+    --metadata <string>
+    --no-transform"#
+    );
+    std::process::exit(1);
 }
diff --git a/src/version1/mod.rs b/src/version1/mod.rs
@@ -4,19 +4,16 @@
 
 mod ffi;
 
-use std::io::{Error, Result};
-use std::path::Path;
-
 /// Compress.
-pub fn compress(data: &[u8]) -> Option<Vec<u8>> {
+pub fn compress(data: &[u8], major_version: usize, minor_version: usize) -> Option<Vec<u8>> {
     let mut size = 0;
     let mut status = 0;
     let data = unsafe {
         ffi::woffEncode(
             data.as_ptr() as _,
             data.len() as _,
-            1,
-            0,
+            major_version as _,
+            minor_version as _,
             &mut size,
             &mut status,
         )
@@ -35,29 +32,6 @@ pub fn decompress(data: &[u8]) -> Option<Vec<u8>> {
     finalize(data, size, status)
 }
 
-/// Compress or decompress.
-pub fn convert<T: AsRef<Path>>(source: T, destination: T) -> Result<()> {
-    let data = std::fs::read(source)?;
-    let destination = destination.as_ref();
-    let data = if destination
-        .extension()
-        .and_then(|value| value.to_str())
-        .map(|value| value == "woff")
-        .unwrap_or(false)
-    {
-        match compress(&data) {
-            Some(data) => data,
-            _ => return Err(Error::other("failed to compress")),
-        }
-    } else {
-        match decompress(&data) {
-            Some(data) => data,
-            _ => return Err(Error::other("failed to decompress")),
-        }
-    };
-    std::fs::write(destination, data)
-}
-
 fn finalize(data: *const u8, size: u32, status: u32) -> Option<Vec<u8>> {
     if !data.is_null() && status == 0 {
         let mut buffer = Vec::with_capacity(size as _);
@@ -79,31 +53,46 @@ fn finalize(data: *const u8, size: u32, status: u32) -> Option<Vec<u8>> {
 
 #[cfg(test)]
 mod tests {
+    use std::fs::{read, write};
+
+    const DEFAULT_MAJOR: usize = 1;
+    const DEFAULT_MINOR: usize = 0;
+
+    macro_rules! ok(($result:expr) => ($result.unwrap()));
+
     #[test]
     fn otf() {
-        super::convert(
-            "tests/fixtures/Roboto-Regular.otf",
-            "tests/fixtures/Roboto-Regular.otf.woff",
-        )
-        .unwrap();
-        super::convert(
+        ok!(write(
             "tests/fixtures/Roboto-Regular.otf.woff",
+            ok!(super::compress(
+                &ok!(read("tests/fixtures/Roboto-Regular.otf")),
+                DEFAULT_MAJOR,
+                DEFAULT_MINOR,
+            )),
+        ));
+        ok!(write(
             "tests/fixtures/Roboto-Regular.otf",
-        )
-        .unwrap();
+            ok!(super::decompress(&ok!(read(
+                "tests/fixtures/Roboto-Regular.otf.woff"
+            )))),
+        ));
     }
 
     #[test]
     fn ttf() {
-        super::convert(
-            "tests/fixtures/Roboto-Regular.ttf",
-            "tests/fixtures/Roboto-Regular.ttf.woff",
-        )
-        .unwrap();
-        super::convert(
+        ok!(write(
             "tests/fixtures/Roboto-Regular.ttf.woff",
+            ok!(super::compress(
+                &ok!(read("tests/fixtures/Roboto-Regular.ttf")),
+                DEFAULT_MAJOR,
+                DEFAULT_MINOR,
+            )),
+        ));
+        ok!(write(
             "tests/fixtures/Roboto-Regular.ttf",
-        )
-        .unwrap();
+            ok!(super::decompress(&ok!(read(
+                "tests/fixtures/Roboto-Regular.ttf.woff"
+            )))),
+        ));
     }
 }
diff --git a/src/version2/mod.rs b/src/version2/mod.rs
@@ -4,22 +4,22 @@
 
 mod ffi;
 
-use std::io::{Error, Result};
-use std::path::Path;
-
 /// Compress.
-pub fn compress(data: &[u8], metadata: String, quality: usize, transform: bool) -> Option<Vec<u8>> {
-    let metadata_length = metadata.len();
+pub fn compress<T>(data: &[u8], quality: usize, metadata: T, transform: bool) -> Option<Vec<u8>>
+where
+    T: Into<Vec<u8>>,
+{
     let metadata = match std::ffi::CString::new(metadata) {
         Ok(metadata) => metadata,
         _ => return None,
     };
+    let metadata_size = metadata.count_bytes();
     let size = unsafe {
         ffi::ComputeTTFToWOFF2Size(
             data.as_ptr() as *const _,
             data.len(),
             metadata.as_ptr() as *const _,
-            metadata_length,
+            metadata_size,
         )
     };
     let mut buffer = vec![0; size];
@@ -31,7 +31,7 @@ pub fn compress(data: &[u8], metadata: String, quality: usize, transform: bool)
             buffer.as_mut_ptr() as *mut _,
             &mut size as *mut _,
             metadata.as_ptr() as *const _,
-            metadata_length,
+            metadata_size,
             quality as core::ffi::c_int,
             transform as core::ffi::c_int,
         )
@@ -63,79 +63,51 @@ pub fn decompress(data: &[u8]) -> Option<Vec<u8>> {
     buffer.into()
 }
 
-/// Compress or decompress.
-pub fn convert<T: AsRef<Path>>(
-    source: T,
-    destination: T,
-    metadata: Option<String>,
-    quality: Option<usize>,
-    transform: Option<bool>,
-) -> Result<()> {
-    let data = std::fs::read(source)?;
-    let destination = destination.as_ref();
-    let data = if destination
-        .extension()
-        .and_then(|value| value.to_str())
-        .map(|value| value == "woff2")
-        .unwrap_or(false)
-    {
-        match compress(
-            &data,
-            metadata.unwrap_or_default(),
-            quality.unwrap_or(8),
-            transform.unwrap_or(true),
-        ) {
-            Some(data) => data,
-            _ => return Err(Error::other("failed to compress")),
-        }
-    } else {
-        match decompress(&data) {
-            Some(data) => data,
-            _ => return Err(Error::other("failed to decompress")),
-        }
-    };
-    std::fs::write(destination, data)
-}
-
 #[cfg(test)]
 mod tests {
+    use std::fs::{read, write};
+
+    const DEFAULT_QUALITY: usize = 8;
+    const DEFAULT_METADATA: &str = "";
+    const DEFAULT_TRANSFORM: bool = true;
+
+    macro_rules! ok(($result:expr) => ($result.unwrap()));
+
     #[test]
     fn otf() {
-        super::convert(
-            "tests/fixtures/Roboto-Regular.otf",
-            "tests/fixtures/Roboto-Regular.otf.woff2",
-            None,
-            None,
-            None,
-        )
-        .unwrap();
-        super::convert(
+        ok!(write(
             "tests/fixtures/Roboto-Regular.otf.woff2",
+            ok!(super::compress(
+                &ok!(read("tests/fixtures/Roboto-Regular.otf")),
+                DEFAULT_QUALITY,
+                DEFAULT_METADATA,
+                DEFAULT_TRANSFORM,
+            )),
+        ));
+        ok!(write(
             "tests/fixtures/Roboto-Regular.otf",
-            None,
-            None,
-            None,
-        )
-        .unwrap();
+            ok!(super::decompress(&ok!(read(
+                "tests/fixtures/Roboto-Regular.otf.woff2"
+            )))),
+        ));
     }
 
     #[test]
     fn ttf() {
-        super::convert(
-            "tests/fixtures/Roboto-Regular.ttf",
-            "tests/fixtures/Roboto-Regular.ttf.woff2",
-            None,
-            None,
-            None,
-        )
-        .unwrap();
-        super::convert(
+        ok!(write(
             "tests/fixtures/Roboto-Regular.ttf.woff2",
+            ok!(super::compress(
+                &ok!(read("tests/fixtures/Roboto-Regular.ttf")),
+                DEFAULT_QUALITY,
+                DEFAULT_METADATA,
+                DEFAULT_TRANSFORM,
+            )),
+        ));
+        ok!(write(
             "tests/fixtures/Roboto-Regular.ttf",
-            None,
-            None,
-            None,
-        )
-        .unwrap();
+            ok!(super::decompress(&ok!(read(
+                "tests/fixtures/Roboto-Regular.ttf.woff2"
+            )))),
+        ));
     }
 }
