Code reorganizing (#17)

Reviewed-on: #17
Co-authored-by: phoenix <kundeng00@pm.me>
Co-committed-by: phoenix <kundeng00@pm.me>

.gitea/workflows/tag_release.yml

@@ -5,8 +5,6 @@ on:
     branches:
       - main
       - devel
-    tags:
-      - 'v*' # Trigger on tags matching v*
 
 jobs:
   release:
@@ -20,7 +18,7 @@ jobs:
       - name: Install Rust
         uses: actions-rs/toolchain@v1
         with:
-          toolchain: 1.85.0
+          toolchain: 1.86.0
           components: cargo
 
       - name: Extract Version from Cargo.toml

.gitea/workflows/workflow.yml

@@ -18,7 +18,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
-          toolchain: 1.85.0
+          toolchain: 1.86.0
       - run: |
           mkdir -p ~/.ssh
           echo "${{ secrets.MYREPO_TOKEN }}" > ~/.ssh/gitlab_deploy_key
@@ -36,7 +36,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
-          toolchain: 1.85.0
+          toolchain: 1.86.0
       - run: |
           mkdir -p ~/.ssh
           echo "${{ secrets.MYREPO_TOKEN }}" > ~/.ssh/gitlab_deploy_key
@@ -54,7 +54,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
-          toolchain: 1.85.0
+          toolchain: 1.86.0
       - run: rustup component add rustfmt
       - run: |
           mkdir -p ~/.ssh
@@ -73,7 +73,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
-          toolchain: 1.85.0
+          toolchain: 1.86.0
       - run: rustup component add clippy
       - run: |
           mkdir -p ~/.ssh
@@ -92,7 +92,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
-          toolchain: 1.85.0
+          toolchain: 1.86.0
       - run: |
           mkdir -p ~/.ssh
           echo "${{ secrets.MYREPO_TOKEN }}" > ~/.ssh/gitlab_deploy_key
@@ -100,5 +100,4 @@ jobs:
           ssh-keyscan ${{ vars.MYHOST }} >> ~/.ssh/known_hosts
           eval $(ssh-agent -s)
           ssh-add -v ~/.ssh/gitlab_deploy_key
-          cargo build --release
-
+          cargo build --release

Cargo.toml

@@ -2,6 +2,8 @@
 name = "icarus_meta"
 version = "0.1.0"
 edition = "2024"
+rust-version = "1.86"
 
 [dependencies]
-icarus-models = { git = "ssh://git@git.kundeng.us/phoenix/icarus-models.git", tag = "v0.1.14" }
+lofty = { version = "0.22.3" }
+icarus_models = { git = "ssh://git@git.kundeng.us/phoenix/icarus_models.git", tag = "v0.4.3" }

src/lib.rs

@@ -1,14 +1,2 @@
-pub fn add(left: u64, right: u64) -> u64 {
-    left + right
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn it_works() {
-        let result = add(2, 2);
-        assert_eq!(result, 4);
-    }
-}
+pub mod meta;
+pub mod types;

src/meta.rs

@@ -0,0 +1,228 @@
+use lofty::file::AudioFile;
+
+use crate::types;
+
+fn get_type(t: types::Type) -> Result<String, std::io::Error> {
+    match t {
+        types::Type::Title => Ok("TITLE".to_owned()),
+        types::Type::Artist => Ok("ARTIST".to_owned()),
+        types::Type::Album => Ok("ALBUM".to_owned()),
+        types::Type::Genre => Ok("GENRE".to_owned()),
+        types::Type::Date => Ok("DATE".to_owned()),
+        types::Type::Track => Ok("TRACKNUMBER".to_owned()),
+    }
+}
+
+pub fn get_meta(t: types::Type, filepath: &String) -> Result<String, std::io::Error> {
+    match std::fs::File::open(filepath) {
+        Ok(mut content) => {
+            match lofty::flac::FlacFile::read_from(&mut content, lofty::config::ParseOptions::new())
+            {
+                Ok(flac_file) => match flac_file.vorbis_comments() {
+                    Some(vb) => {
+                        let type_str: String = get_type(t).unwrap();
+                        match vb.get(&type_str) {
+                            Some(val) => Ok(val.to_owned()),
+                            None => Err(std::io::Error::new(
+                                std::io::ErrorKind::InvalidData,
+                                "Could not get tag data",
+                            )),
+                        }
+                    }
+                    None => Err(std::io::Error::new(
+                        std::io::ErrorKind::InvalidData,
+                        "No tags found",
+                    )),
+                },
+                Err(err) => Err(std::io::Error::new(
+                    std::io::ErrorKind::InvalidData,
+                    err.to_string(),
+                )),
+            }
+        }
+        Err(err) => Err(err),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use util::{file_exists, get_full_path};
+
+    use super::*;
+
+    mod util {
+        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),
+            }
+        }
+
+        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),
+            }
+        }
+
+        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))
+        }
+
+        pub fn test_file_directory() -> String {
+            String::from("tests/sample_tracks3")
+        }
+    }
+
+    #[test]
+    fn test_get_title() {
+        let filename = String::from("track01.flac");
+        let dir = util::test_file_directory();
+
+        match file_exists(&dir, &filename) {
+            Ok(_) => {
+                let filepath = get_full_path(&dir, &filename).unwrap();
+
+                match get_meta(types::Type::Title, &filepath) {
+                    Ok(title) => {
+                        let found = title == "Just roll it";
+                        assert!(found, "Meta information was not found {:?}", title);
+                    }
+                    Err(err) => {
+                        assert!(false, "Error: {:?}", err);
+                    }
+                }
+            }
+            Err(err) => {
+                assert!(false, "Error: File does not exist {:?}", err.to_string());
+            }
+        };
+    }
+    #[test]
+    fn test_get_artist() {
+        let filename = String::from("track01.flac");
+        let dir = util::test_file_directory();
+
+        match file_exists(&dir, &filename) {
+            Ok(_) => {
+                let filepath = get_full_path(&dir, &filename).unwrap();
+
+                match get_meta(types::Type::Artist, &filepath) {
+                    Ok(artist) => {
+                        let found = artist == "KD";
+                        assert!(found, "Meta information was not found {:?}", artist);
+                    }
+                    Err(err) => {
+                        assert!(false, "Error: {:?}", err);
+                    }
+                }
+            }
+            Err(err) => {
+                assert!(false, "Error: File does not exist {:?}", err.to_string());
+            }
+        };
+    }
+    #[test]
+    fn test_get_album() {
+        let filename = String::from("track01.flac");
+        let dir = util::test_file_directory();
+
+        match file_exists(&dir, &filename) {
+            Ok(_) => {
+                let filepath = get_full_path(&dir, &filename).unwrap();
+
+                match get_meta(types::Type::Album, &filepath) {
+                    Ok(album) => {
+                        let found = album == "Sample Tracks 3";
+                        assert!(found, "Meta information was not found {:?}", album);
+                    }
+                    Err(err) => {
+                        assert!(false, "Error: {:?}", err);
+                    }
+                }
+            }
+            Err(err) => {
+                assert!(false, "Error: File does not exist {:?}", err.to_string());
+            }
+        };
+    }
+    #[test]
+    fn test_get_genre() {
+        let filename = String::from("track01.flac");
+        let dir = util::test_file_directory();
+
+        match file_exists(&dir, &filename) {
+            Ok(_) => {
+                let filepath = get_full_path(&dir, &filename).unwrap();
+
+                match get_meta(types::Type::Genre, &filepath) {
+                    Ok(genre) => {
+                        let found = genre == "Metal";
+                        assert!(found, "Meta information was not found {:?}", genre);
+                    }
+                    Err(err) => {
+                        assert!(false, "Error: {:?}", err);
+                    }
+                }
+            }
+            Err(err) => {
+                assert!(false, "Error: File does not exist {:?}", err.to_string());
+            }
+        };
+    }
+    #[test]
+    fn test_get_year() {
+        let filename = String::from("track01.flac");
+        let dir = util::test_file_directory();
+
+        match file_exists(&dir, &filename) {
+            Ok(_) => {
+                let filepath = get_full_path(&dir, &filename).unwrap();
+
+                match get_meta(types::Type::Date, &filepath) {
+                    Ok(year) => {
+                        let found = year == "2025-04-11";
+                        assert!(found, "Meta information was not found {:?}", year);
+                    }
+                    Err(err) => {
+                        assert!(false, "Error: {:?}", err);
+                    }
+                }
+            }
+            Err(err) => {
+                assert!(false, "Error: File does not exist {:?}", err.to_string());
+            }
+        };
+    }
+    #[test]
+    fn test_get_track() {
+        let filename = String::from("track01.flac");
+        let dir = util::test_file_directory();
+
+        match file_exists(&dir, &filename) {
+            Ok(_) => {
+                let filepath = get_full_path(&dir, &filename).unwrap();
+
+                match get_meta(types::Type::Track, &filepath) {
+                    Ok(track) => {
+                        let found = track == "1";
+                        assert!(found, "Meta information was not found {:?}", track);
+                    }
+                    Err(err) => {
+                        assert!(false, "Error: {:?}", err);
+                    }
+                }
+            }
+            Err(err) => {
+                assert!(false, "Error: File does not exist {:?}", err.to_string());
+            }
+        };
+    }
+}

src/types.rs

@@ -0,0 +1,8 @@
+pub enum Type {
+    Title,
+    Artist,
+    Album,
+    Genre,
+    Date,
+    Track,
+}