clean: cargo fmt

mutant-remix · Jul 17, 2023 · b76c7fa · b76c7fa
1 parent 2042326
commit b76c7fa
Show file tree

Hide file tree

Showing 8 changed files with 69 additions and 56 deletions.
diff --git a/src/load/manifest.rs b/src/load/manifest.rs
@@ -256,7 +256,7 @@ impl Pack {
                                             .collect::<Vec<String>>();
 
                                         Some(codepoint)
-                                    },
+                                    }
                                     None => panic!(
                                         "Colormap codepoint is not an array in {:?}",
                                         manifest_path
@@ -440,7 +440,10 @@ impl Pack {
                             .map(|c| match c.as_str() {
                                 Some(c) => c.to_string(),
                                 None => {
-                                    panic!("Emoji 'colormap' is not a string in {:?}", manifest_path)
+                                    panic!(
+                                        "Emoji 'colormap' is not a string in {:?}",
+                                        manifest_path
+                                    )
                                 }
                             })
                             .collect(),
@@ -477,7 +480,7 @@ impl Pack {
                                 }
 
                                 name.to_string()
-                            },
+                            }
                             None => panic!("Target name is not a string in {:?}", manifest_path),
                         },
                         None => panic!("Target is missing 'name' in {:?}", manifest_path),
@@ -549,11 +552,14 @@ impl Pack {
                             };
 
                             let flat = match structure.get("flat") {
-                                Some(flat) =>
-                                    flat
-                                    .as_bool()
-                                    .expect(&format!("Target contains invalid 'structure.flat' '{}' in {:?}", flat, manifest_path)),
-                                None => panic!("Target is missing 'structure.flat' in {:?}", manifest_path),
+                                Some(flat) => flat.as_bool().expect(&format!(
+                                    "Target contains invalid 'structure.flat' '{}' in {:?}",
+                                    flat, manifest_path
+                                )),
+                                None => panic!(
+                                    "Target is missing 'structure.flat' in {:?}",
+                                    manifest_path
+                                ),
                             };
 
                             OutputStructure {

diff --git a/src/load/mod.rs b/src/load/mod.rs
@@ -28,7 +28,8 @@ impl Pack {
         stage.inc();
         self.resolve_variables();
 
-        self.logger.load(&format!("Resolving colormaps and recoloring"));
+        self.logger
+            .load(&format!("Resolving colormaps and recoloring"));
         stage.inc();
         self.resolve_colormaps();
 

diff --git a/src/load/svg.rs b/src/load/svg.rs
@@ -1,11 +1,11 @@
 use rayon::prelude::*;
+use regex::Regex;
 use resvg::usvg::Color;
 use std::{fmt, fs, path::PathBuf};
 use svgcleaner::{
     cleaner::{clean_doc, parse_data},
     CleaningOptions, ParseOptions, WriteOptions,
 };
-use regex::Regex;
 
 use crate::load::Pack;
 

diff --git a/src/logger.rs b/src/logger.rs
@@ -76,7 +76,9 @@ impl Logger {
                 String::from(env!("CARGO_PKG_VERSION"))
             );
             println!("github.com/mutant-remix/mrxbuilder");
-            println!("Running in no tty mode with pretty printing disabled due to unsupported terminal");
+            println!(
+                "Running in no tty mode with pretty printing disabled due to unsupported terminal"
+            );
             println!();
 
             return Self {
@@ -136,9 +138,7 @@ impl Logger {
 
                 Bar::new(Some(current_bar))
             }
-            Bar::Notty(_) => {
-                Bar::new(None)
-            }
+            Bar::Notty(_) => Bar::new(None),
         }
     }
 
@@ -168,7 +168,8 @@ impl Logger {
     pub fn load(&mut self, message: &str) {
         match &mut self.total_bar {
             Bar::Tty(_) => {
-                self.total_bar.write(&format!("{} {}", "LOAD ".colorize("bold yellow"), message));
+                self.total_bar
+                    .write(&format!("{} {}", "LOAD ".colorize("bold yellow"), message));
             }
             Bar::Notty(_) => {
                 println!("LOAD {}", message);
@@ -179,7 +180,8 @@ impl Logger {
     pub fn info(&mut self, message: &str) {
         match &mut self.total_bar {
             Bar::Tty(_) => {
-                self.total_bar.write(&format!("{} {}", "INFO ".colorize("bold blue"), message));
+                self.total_bar
+                    .write(&format!("{} {}", "INFO ".colorize("bold blue"), message));
             }
             Bar::Notty(_) => {
                 println!("INFO  {}", message);
@@ -190,7 +192,8 @@ impl Logger {
     pub fn build(&mut self, message: &str) {
         match &mut self.total_bar {
             Bar::Tty(_) => {
-                self.total_bar.write(&format!("{} {}", "BUILD".colorize("bold magenta"), message));
+                self.total_bar
+                    .write(&format!("{} {}", "BUILD".colorize("bold magenta"), message));
             }
             Bar::Notty(_) => {
                 println!("BUILD {}", message);

diff --git a/src/process/cache.rs b/src/process/cache.rs
@@ -1,5 +1,5 @@
-use std::{fs, path::PathBuf, fmt};
 use crate::process::encode::EncodeTarget;
+use std::{fmt, fs, path::PathBuf};
 
 pub struct Cache {
     path: PathBuf,
@@ -26,7 +26,7 @@ impl Cache {
 
     pub fn save(&self, svg: &str, format: &EncodeTarget, size: u32, raster: &Vec<u8>) {
         match fs::create_dir_all(&self.path) {
-            Ok(_) => {},
+            Ok(_) => {}
             Err(err) => panic!("Failed to create cache directory: {}", err),
         }
 
@@ -37,7 +37,7 @@ impl Cache {
         path.set_extension(format.to_extension());
 
         match fs::write(path, raster) {
-            Ok(_) => {},
+            Ok(_) => {}
             Err(err) => panic!("Failed to write cache file: {}", err),
         }
     }

diff --git a/src/process/encode/mod.rs b/src/process/encode/mod.rs
@@ -1,6 +1,6 @@
 use core::num::NonZeroU8;
-use oxipng::Deflaters;
 use image::RgbaImage;
+use oxipng::Deflaters;
 
 pub mod avif;
 pub mod png_image;
@@ -21,7 +21,7 @@ pub enum EncodeTarget {
         quality: f32, // 100.0-0.0
         speed: u8,    // 1-10
     },
-    Webp
+    Webp,
 }
 
 impl EncodeTarget {
@@ -38,9 +38,12 @@ impl EncodeTarget {
 pub fn encode_raster(raster: &RgbaImage, target: &EncodeTarget) -> Vec<u8> {
     match target {
         EncodeTarget::PngOxipng(oxipng_mode) => match oxipng_mode {
-            OxiPngMode::Libdeflater(compression) => {
-                png_oxipng::encode(&raster, Deflaters::Libdeflater { compression: *compression })
-            }
+            OxiPngMode::Libdeflater(compression) => png_oxipng::encode(
+                &raster,
+                Deflaters::Libdeflater {
+                    compression: *compression,
+                },
+            ),
             OxiPngMode::Zopfli(iterations) => png_oxipng::encode(
                 &raster,
                 Deflaters::Zopfli {

diff --git a/src/process/mod.rs b/src/process/mod.rs
@@ -1,5 +1,5 @@
-use std::{fs, thread};
 use rayon::prelude::*;
+use std::{fs, thread};
 
 pub mod encode;
 use encode::encode_raster;
@@ -15,7 +15,7 @@ use metadata::generate_metadata;
 mod package;
 use package::Package;
 
-use crate::load::manifest::{OutputFormat, FilenameFormat, Emoji};
+use crate::load::manifest::{Emoji, FilenameFormat, OutputFormat};
 use crate::Pack;
 
 pub struct EmojiEncoded {
@@ -161,17 +161,17 @@ impl Pack {
                 // Write emojis
                 for emoji in &emojis {
                     match &target.output_format {
-                        OutputFormat::None => {},
+                        OutputFormat::None => {}
                         OutputFormat::Svg => {
                             package.add_file(
                                 &emoji.emoji.svg.as_ref().unwrap().0.as_bytes().to_vec(),
-                                emoji.filename.as_ref().unwrap()
+                                emoji.filename.as_ref().unwrap(),
                             );
                         }
                         OutputFormat::Raster { format: _, size: _ } => {
                             package.add_file(
                                 emoji.raster.as_ref().unwrap(),
-                                emoji.filename.as_ref().unwrap()
+                                emoji.filename.as_ref().unwrap(),
                             );
                         }
                     }
@@ -186,16 +186,25 @@ impl Pack {
                     let filename = match file.file_name() {
                         Some(filename) => filename.to_str().unwrap(),
                         None => {
-                            panic!("Failed to get filename for file '{}' while building target '{}'", file.display(), target.name);
+                            panic!(
+                                "Failed to get filename for file '{}' while building target '{}'",
+                                file.display(),
+                                target.name
+                            );
                         }
                     };
 
                     match fs::read(file) {
                         Ok(file) => {
                             package.add_file(&file, filename);
-                        },
+                        }
                         Err(error) => {
-                            panic!("Failed to read file '{}' while building target '{}': {}", file.display(), target.name, error);
+                            panic!(
+                                "Failed to read file '{}' while building target '{}': {}",
+                                file.display(),
+                                target.name,
+                                error
+                            );
                         }
                     };
                 }

diff --git a/src/process/package.rs b/src/process/package.rs
@@ -1,15 +1,15 @@
 use crate::load::manifest::{Container, TarCompression};
 use bzip2::{write::BzEncoder, Compression as BzipCompression};
+use libflate::gzip::Encoder as GzipEncoder;
 use std::{
     fs::{self, File},
-    io::{Error, ErrorKind::NotFound, Write, BufWriter},
+    io::{BufWriter, Error, ErrorKind::NotFound, Write},
     path::PathBuf,
 };
 use tar::{Builder as TarBuilder, Header as TarHeader};
 use xz2::write::XzEncoder;
 use zip::{write::FileOptions, CompressionMethod as ZipCompressionMethod, ZipWriter};
 use zstd::stream::write::Encoder as ZstdEncoder;
-use libflate::gzip::Encoder as GzipEncoder;
 
 enum TarCompressor<'a> {
     None(TarBuilder<BufWriter<File>>),
@@ -211,7 +211,6 @@ impl Package<'_> {
     }
 
     pub fn finish(self) {
-
         match self.kind {
             PackageKind::Dry => {}
             PackageKind::Zip(mut writer, _) => {
@@ -228,33 +227,25 @@ impl Package<'_> {
                 // This code has to be ugly because of the different types of the writer
                 // They have roughly the same interface, but they are not the same type
                 let result: Result<_, Error> = match writer {
-                    TarCompressor::None(mut writer) => {
-                        writer.finish()
-                    },
+                    TarCompressor::None(mut writer) => writer.finish(),
                     TarCompressor::Gzip(writer) => {
                         match writer.into_inner().unwrap().finish().into_result() {
                             Ok(_) => Ok(()),
-                            Err(err) => Err(err)
+                            Err(err) => Err(err),
                         }
+                    }
+                    TarCompressor::Bzip2(writer) => match writer.into_inner().unwrap().finish() {
+                        Ok(_) => Ok(()),
+                        Err(err) => Err(err),
                     },
-                    TarCompressor::Bzip2(writer) => {
-                        match writer.into_inner().unwrap().finish() {
-                            Ok(_) => Ok(()),
-                            Err(err) => Err(err)
-                        }
+                    TarCompressor::Xz(writer) => match writer.into_inner().unwrap().finish() {
+                        Ok(_) => Ok(()),
+                        Err(err) => Err(err),
                     },
-                    TarCompressor::Xz(writer) => {
-                        match writer.into_inner().unwrap().finish() {
-                            Ok(_) => Ok(()),
-                            Err(err) => Err(err)
-                        }
+                    TarCompressor::Zstd(writer) => match writer.into_inner().unwrap().finish() {
+                        Ok(_) => Ok(()),
+                        Err(err) => Err(err),
                     },
-                    TarCompressor::Zstd(writer) => {
-                        match writer.into_inner().unwrap().finish() {
-                            Ok(_) => Ok(()),
-                            Err(err) => Err(err)
-                        }
-                    }
                 };
 
                 match result {