tsk-45: Added infer crate

.gitea/workflows/tag_release.yml

@@ -4,9 +4,6 @@ on:
   push:
     branches:
       - main
-  pull_request:
-    branches:
-      - main
 
 jobs:
   release:

Cargo.lock

@@ -104,7 +104,7 @@ dependencies = [
 
 [[package]]
 name = "icarus_meta"
-version = "0.4.5"
+version = "0.4.2"
 dependencies = [
  "imghdr",
  "infer",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "icarus_meta"
-version = "0.4.5"
+version = "0.4.2"
 edition = "2024"
 rust-version = "1.90"
 

src/detection/coverart.rs

@@ -1,16 +1,8 @@
 /// Gets the file type of a CoverArt given it's path
-pub fn file_type_from_filepath(
-    filepath: &str,
-) -> Result<crate::detection::FileType, std::io::Error> {
+pub fn file_type_from_filepath(filepath: &str) -> Result<String, std::io::Error> {
     match imghdr::from_file(filepath) {
-        Ok(Some(imghdr::Type::Jpeg)) => Ok(crate::detection::FileType {
-            mime: String::from(constants::mime::JPEG),
-            file_type: String::from(constants::JPEG_TYPE),
-        }),
-        Ok(Some(imghdr::Type::Png)) => Ok(crate::detection::FileType {
-            mime: String::from(constants::mime::PNG),
-            file_type: String::from(constants::PNG_TYPE),
-        }),
+        Ok(Some(imghdr::Type::Jpeg)) => Ok(String::from("jpeg")),
+        Ok(Some(imghdr::Type::Png)) => Ok(String::from("png")),
         Ok(None) => Err(std::io::Error::other("Image file not supported")),
         Err(err) => Err(err),
         _ => Err(std::io::Error::other("Image file not supported")),
@@ -18,32 +10,15 @@ pub fn file_type_from_filepath(
 }
 
 /// Gets the file type of a CoverArt given it's data
-pub fn file_type_from_data(data: &Vec<u8>) -> Result<crate::detection::FileType, std::io::Error> {
+pub fn file_type_from_data(data: &Vec<u8>) -> Result<String, std::io::Error> {
     match imghdr::from_bytes(data) {
-        Some(imghdr::Type::Jpeg) => Ok(crate::detection::FileType {
-            mime: String::from(constants::mime::JPEG),
-            file_type: String::from(constants::JPEG_TYPE),
-        }),
-        Some(imghdr::Type::Png) => Ok(crate::detection::FileType {
-            mime: String::from(constants::mime::PNG),
-            file_type: String::from(constants::PNG_TYPE),
-        }),
+        Some(imghdr::Type::Jpeg) => Ok(String::from("jpeg")),
+        Some(imghdr::Type::Png) => Ok(String::from("png")),
         None => Err(std::io::Error::other("Image file not supported")),
         _ => Err(std::io::Error::other("Image file not supported")),
     }
 }
 
-pub mod constants {
-    pub const PNG_TYPE: &str = "png";
-    pub const JPEG_TYPE: &str = "jpeg";
-    pub const JPG_TYPE: &str = "jpg";
-
-    pub mod mime {
-        pub const JPEG: &str = "image/jpeg";
-        pub const PNG: &str = "image/png";
-    }
-}
-
 #[cfg(test)]
 mod tests {
     #[test]
@@ -55,8 +30,7 @@ mod tests {
         match super::file_type_from_filepath(&filepath) {
             Ok(filetype) => {
                 assert_eq!(
-                    filetype.file_type,
-                    super::constants::PNG_TYPE,
+                    filetype, "png",
                     "The file type of the CoverArt should have been png"
                 );
             }
@@ -76,8 +50,7 @@ mod tests {
         match super::file_type_from_data(&data) {
             Ok(filetype) => {
                 assert_eq!(
-                    filetype.file_type,
-                    super::constants::PNG_TYPE,
+                    filetype, "png",
                     "The file type of the CoverArt should have been png"
                 );
             }

src/detection/mod.rs

@@ -1,34 +1 @@
 pub mod coverart;
-pub mod song;
-
-#[derive(Debug, Default)]
-pub struct FileType {
-    pub mime: String,
-    pub file_type: String,
-}
-
-/// Initializes a FileType given a filetype passed.
-pub fn init_filetype(filetype: &str) -> Result<FileType, std::io::Error> {
-    if filetype == song::constants::FLAC_TYPE {
-        Ok(FileType {
-            mime: String::from(song::constants::mime::FLAC),
-            file_type: String::from(song::constants::FLAC_TYPE),
-        })
-    } else if filetype == coverart::constants::PNG_TYPE {
-        Ok(FileType {
-            mime: String::from(coverart::constants::mime::PNG),
-            file_type: String::from(coverart::constants::PNG_TYPE),
-        })
-    } else if filetype == coverart::constants::JPEG_TYPE
-        || filetype == coverart::constants::JPG_TYPE
-    {
-        Ok(FileType {
-            mime: String::from(coverart::constants::mime::JPEG),
-            file_type: String::from(coverart::constants::JPEG_TYPE),
-        })
-    } else {
-        Err(std::io::Error::other(format!(
-            "Unsupported FileType: {filetype:?}"
-        )))
-    }
-}

src/detection/song.rs

@@ -1,90 +0,0 @@
-/// Gets the file type of a Song from it's path
-pub fn file_type_from_filepath(
-    filepath: &str,
-) -> Result<crate::detection::FileType, std::io::Error> {
-    match infer::get_from_path(filepath) {
-        Ok(Some(kind)) => {
-            let mime = kind.mime_type();
-            if mime == constants::mime::FLAC {
-                Ok(crate::detection::FileType {
-                    mime: String::from(mime),
-                    file_type: String::from(constants::FLAC_TYPE),
-                })
-            } else {
-                Err(std::io::Error::other("Unsupported file type"))
-            }
-        }
-        Ok(None) => Err(std::io::Error::other("File type not determined")),
-        Err(err) => Err(err),
-    }
-}
-
-/// Gets the file type of a Song given it's data
-pub fn file_type_from_data(data: &[u8]) -> Result<crate::detection::FileType, std::io::Error> {
-    match infer::get(data) {
-        Some(kind) => {
-            let mime = kind.mime_type();
-            if mime == constants::mime::FLAC {
-                Ok(crate::detection::FileType {
-                    mime: String::from(mime),
-                    file_type: String::from(constants::FLAC_TYPE),
-                })
-            } else {
-                Err(std::io::Error::other("Unsupported file type"))
-            }
-        }
-        None => Err(std::io::Error::other("File type not determined")),
-    }
-}
-
-pub mod constants {
-    pub const FLAC_TYPE: &str = "flac";
-
-    pub mod mime {
-        pub const FLAC: &str = "audio/x-flac";
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    #[test]
-    fn test_song_file_type() {
-        let directory = String::from(crate::test_util::util::TESTFILEDIRECTORY);
-        let filename = String::from("track01.flac");
-        let filepath = format!("{directory}/{filename}");
-
-        match super::file_type_from_filepath(&filepath) {
-            Ok(filetype) => {
-                assert_eq!(
-                    filetype.file_type,
-                    crate::detection::song::constants::FLAC_TYPE,
-                    "Types do not match"
-                )
-            }
-            Err(err) => {
-                assert!(false, "Error: {err:?}")
-            }
-        }
-    }
-
-    #[test]
-    fn test_song_file_type_from_data() {
-        let directory = String::from(crate::test_util::util::TESTFILEDIRECTORY);
-        let filename = String::from("track01.flac");
-        let filepath = format!("{directory}/{filename}");
-        let data = crate::test_util::util::get_data_from_file(&filepath).unwrap();
-
-        match super::file_type_from_data(&data) {
-            Ok(filetype) => {
-                assert_eq!(
-                    filetype.file_type,
-                    crate::detection::song::constants::FLAC_TYPE,
-                    "Types do not match"
-                )
-            }
-            Err(err) => {
-                assert!(false, "Error: {err:?}")
-            }
-        }
-    }
-}

src/lib.rs

@@ -19,7 +19,10 @@ pub mod test_util {
                 Err(err) => Err(err),
             }
         }
-        pub fn get_full_path(directory: &str, filename: &str) -> Result<String, std::io::Error> {
+        pub fn get_full_path(
+            directory: &String,
+            filename: &String,
+        ) -> Result<String, std::io::Error> {
             match path_buf(directory, filename) {
                 Ok(pf) => Ok(pf.display().to_string()),
                 Err(err) => Err(err),
@@ -36,12 +39,6 @@ pub mod test_util {
             std::fs::copy(src_path, dest_path)
         }
 
-        pub fn remove_file(filepath: &str) -> Result<(), std::io::Error> {
-            let f_path = std::path::Path::new(filepath);
-
-            std::fs::remove_file(f_path)
-        }
-
         pub fn get_data_from_file(source_path: &str) -> Result<Vec<u8>, std::io::Error> {
             match std::fs::File::open(source_path) {
                 Ok(mut file) => {
@@ -55,23 +52,13 @@ pub mod test_util {
             }
         }
 
-        pub fn file_exists(directory: &str, filename: &str) -> Result<bool, std::io::Error> {
+        pub fn file_exists(directory: &String, filename: &String) -> Result<bool, std::io::Error> {
             match path_buf(directory, filename) {
                 Ok(pf) => Ok(pf.exists()),
                 Err(err) => Err(err),
             }
         }
 
-        pub fn generate_newfilepath(directory: &str) -> Result<String, std::io::Error> {
-            match generate_filename() {
-                Ok(filename) => match get_full_path(directory, &filename) {
-                    Ok(filepath) => Ok(filepath),
-                    Err(err) => Err(err),
-                },
-                Err(err) => Err(err),
-            }
-        }
-
         pub fn generate_filename() -> Result<String, std::io::Error> {
             let mut filename = String::from("track-");
             let length = 20;
@@ -91,7 +78,10 @@ pub mod test_util {
             Ok(format!("{filename}.flac"))
         }
 
-        fn path_buf(directory: &str, filename: &str) -> Result<std::path::PathBuf, std::io::Error> {
+        fn path_buf(
+            directory: &String,
+            filename: &String,
+        ) -> Result<std::path::PathBuf, std::io::Error> {
             let dir_path = std::path::Path::new(&directory);
             Ok(dir_path.join(filename))
         }

src/properties.rs

@@ -0,0 +1,51 @@
+use lofty::file::AudioFile;
+
+pub fn get_duration(song_path: &String) -> Result<std::time::Duration, std::io::Error> {
+    match std::fs::File::open(song_path) {
+        Ok(mut content) => {
+            match lofty::flac::FlacFile::read_from(&mut content, lofty::config::ParseOptions::new())
+            {
+                Ok(flac_file) => {
+                    let properties = flac_file.properties();
+                    Ok(properties.duration())
+                }
+                Err(err) => Err(std::io::Error::other(err.to_string())),
+            }
+        }
+        Err(err) => Err(err),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::test_util;
+
+    #[test]
+    fn test_get_duration() {
+        let filename = test_util::util::get_filename(1);
+        let dir = String::from(test_util::util::TESTFILEDIRECTORY);
+
+        match test_util::util::file_exists(&dir, &filename) {
+            Ok(_) => {
+                let filepath = test_util::util::get_full_path(&dir, &filename).unwrap();
+                match super::get_duration(&filepath) {
+                    Ok(duration) => {
+                        let song_duration: u64 = 41;
+                        let fetched_song_duration = duration.as_secs();
+
+                        assert_eq!(
+                            song_duration, fetched_song_duration,
+                            "Durations should match, but they don't {song_duration} {fetched_song_duration} ({duration:?})"
+                        );
+                    }
+                    Err(err) => {
+                        assert!(false, "Error: {err:?}");
+                    }
+                }
+            }
+            Err(err) => {
+                assert!(false, "Error: {err:?}");
+            }
+        }
+    }
+}

src/properties/audio.rs

@@ -1,14 +0,0 @@
-use lofty::file::AudioFile;
-
-pub fn get_properties(songpath: &str) -> Result<lofty::flac::FlacProperties, std::io::Error> {
-    match std::fs::File::open(songpath) {
-        Ok(mut content) => {
-            match lofty::flac::FlacFile::read_from(&mut content, lofty::config::ParseOptions::new())
-            {
-                Ok(flac_file) => Ok(*flac_file.properties()),
-                Err(err) => Err(std::io::Error::other(err.to_string())),
-            }
-        }
-        Err(err) => Err(err),
-    }
-}

src/properties/mod.rs

@@ -1,139 +0,0 @@
-pub mod audio;
-
-#[derive(Clone, Debug, Default)]
-pub struct SongProperties {
-    pub duration: std::time::Duration,
-    pub sample_rate: u32,
-    pub bitrate: u32,
-    pub overall_bitrate: u32,
-    pub bit_depth: u8,
-    pub channels: u8,
-}
-
-pub fn get_song_properties(song_path: &str) -> Result<SongProperties, std::io::Error> {
-    match audio::get_properties(song_path) {
-        Ok(flac_properties) => Ok(SongProperties {
-            duration: flac_properties.duration(),
-            sample_rate: flac_properties.sample_rate(),
-            bitrate: flac_properties.audio_bitrate(),
-            overall_bitrate: flac_properties.overall_bitrate(),
-            bit_depth: flac_properties.bit_depth(),
-            channels: flac_properties.channels(),
-        }),
-        Err(err) => Err(err),
-    }
-}
-
-pub fn get_duration(song_path: &str) -> Result<std::time::Duration, std::io::Error> {
-    match get_song_properties(song_path) {
-        Ok(song_properties) => Ok(song_properties.duration),
-        Err(err) => Err(err),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::test_util;
-
-    #[test]
-    fn test_get_duration() {
-        let filename = test_util::util::get_filename(1);
-        let dir = String::from(test_util::util::TESTFILEDIRECTORY);
-
-        match test_util::util::file_exists(&dir, &filename) {
-            Ok(_) => {
-                let filepath = test_util::util::get_full_path(&dir, &filename).unwrap();
-                let new_filepath = test_util::util::generate_newfilepath(&dir).unwrap();
-
-                match test_util::util::copy_file(&filepath, &new_filepath) {
-                    Ok(_) => match super::get_duration(&new_filepath) {
-                        Ok(duration) => {
-                            test_util::util::remove_file(&new_filepath).unwrap();
-
-                            let song_duration: u64 = 41;
-                            let fetched_song_duration = duration.as_secs();
-
-                            assert_eq!(
-                                song_duration, fetched_song_duration,
-                                "Durations should match, but they don't {song_duration} {fetched_song_duration} ({duration:?})"
-                            );
-                        }
-                        Err(err) => {
-                            assert!(false, "Error: {err:?}");
-                        }
-                    },
-                    Err(err) => {
-                        assert!(false, "Error: {err:?}");
-                    }
-                }
-            }
-            Err(err) => {
-                assert!(false, "Error: {err:?}");
-            }
-        }
-    }
-
-    #[test]
-    fn test_song_properties() {
-        let filename = test_util::util::get_filename(1);
-        let dir = String::from(test_util::util::TESTFILEDIRECTORY);
-
-        match test_util::util::file_exists(&dir, &filename) {
-            Ok(_) => {
-                let filepath = test_util::util::get_full_path(&dir, &filename).unwrap();
-                let new_filepath = test_util::util::generate_newfilepath(&dir).unwrap();
-
-                match test_util::util::copy_file(&filepath, &new_filepath) {
-                    Ok(_) => match super::get_song_properties(&new_filepath) {
-                        Ok(song_properties) => {
-                            test_util::util::remove_file(&new_filepath).unwrap();
-
-                            let song_duration: u64 = 41;
-                            let bitrate: u32 = 1;
-                            let overall_bitrate: u32 = 3;
-                            let bit_depth: u8 = 24;
-                            let channels: u8 = 2;
-
-                            let fetched_song_duration = song_properties.duration.as_secs();
-                            let fetched_bitrate = song_properties.bitrate;
-                            let fetched_overall_bitrate = song_properties.overall_bitrate;
-                            let fetched_bit_depth = song_properties.bit_depth;
-                            let fetched_channels = song_properties.channels;
-
-                            assert_eq!(
-                                song_duration, fetched_song_duration,
-                                "Durations should match, but they don't {song_duration} {fetched_song_duration} ({song_properties:?})"
-                            );
-
-                            assert_eq!(
-                                bitrate, fetched_bitrate,
-                                "Bitrates do not match {bitrate:?} {fetched_bitrate:?} {song_properties:?}"
-                            );
-                            assert_eq!(
-                                overall_bitrate, fetched_overall_bitrate,
-                                "Overall bitrates do not match {overall_bitrate:?} {fetched_overall_bitrate:?} {song_properties:?}"
-                            );
-                            assert_eq!(
-                                bit_depth, fetched_bit_depth,
-                                "Bit depth do not match {bit_depth:?} {fetched_bit_depth:?} {song_properties:?}"
-                            );
-                            assert_eq!(
-                                channels, fetched_channels,
-                                "Channels do not match {channels:?} {fetched_channels:?} {song_properties:?}"
-                            );
-                        }
-                        Err(err) => {
-                            assert!(false, "Error: {err:?}");
-                        }
-                    },
-                    Err(err) => {
-                        assert!(false, "Error: {err:?}");
-                    }
-                }
-            }
-            Err(err) => {
-                assert!(false, "Error: {err:?}");
-            }
-        }
-    }
-}