factor concat function

Author: doubleailes

Cargo.lock

@@ -14,7 +14,6 @@ use std::collections::HashMap;
 use std::fs;
 use std::{clone::Clone, path::PathBuf};
 
-
 /// # parse_dir
 /// List files and directories in the targeted directory, take a `String` as
 /// input and return a `Vec<String>` of the entries.
@@ -23,11 +22,9 @@ pub fn parse_dir(input_path: &str) -> Paths {
     Paths::new(
         paths_dir
             .filter_map(|entry| {
-                entry.ok().and_then(|e| {
-                    e.path()
-                        .file_name()
-                        .map(PathBuf::from)
-                })
+                entry
+                    .ok()
+                    .and_then(|e| e.path().file_name().map(PathBuf::from))
             })
             .collect::<Vec<PathBuf>>(),
     )
@@ -42,11 +39,9 @@ pub fn recursive_dir(input_path: &str) -> Paths {
             .sort(true)
             .into_iter()
             .filter_map(|entry| {
-                entry.ok().and_then(|e| {
-                    e.path()
-                        .file_name()
-                        .map(PathBuf::from)
-                })
+                entry
+                    .ok()
+                    .and_then(|e| e.path().file_name().map(PathBuf::from))
             })
             .collect::<Vec<PathBuf>>(),
     )
@@ -286,13 +281,64 @@ fn test_continuity() {
     assert_eq!(expected, group_continuity(&source));
 }
 #[test]
-fn test_create_frame_string() {
-    let source: Vec<String> = vec![
-        "001".to_string(),
-        "005".to_string(),
-        "003".to_string(),
-        "002".to_string(),
-    ];
-    let expected: String = "1-3,5".to_string();
-    assert_eq!(expected, create_frame_string(source));
+fn test_convert_vec_to_str() {
+    let source: Vec<Vec<isize>> = vec![vec![1, 2, 3], vec![5, 6, 7], vec![11, 12], vec![45]];
+    let expected: String = "1-3,5-7,11-12,45".to_string();
+    assert_eq!(expected, convert_vec_to_str(source));
+}
+
+fn concat_line(main_string: String, frame_string: String) -> String {
+    let buf: bool = false;
+    if buf {
+        let from: String = String::from("#####");
+        main_string.replace(&from, &frame_string)
+    } else {
+        format!("{}@{}", main_string, frame_string)
+    }
+}
+#[test]
+fn test_concat_line() {
+    let main_string: String = String::from("toto");
+    let frame_string: String = String::from("bar");
+    let expected: String = String::from("toto@bar");
+    assert_eq!(expected, concat_line(main_string, frame_string));
+}
+pub fn basic(frames: Vec<String>) -> Vec<String> {
+    let frames_dict: HashMap<String, Vec<String>> = parse_result(frames);
+    let mut out_frames: Vec<String> = Vec::new();
+    for (key, value) in frames_dict {
+        if value[0] == "None" && value.len() == 1 {
+            out_frames.push(key);
+        } else {
+            let i = convert_vec(value);
+            let j = group_continuity(&i);
+            let k = convert_vec_to_str(j);
+            out_frames.push(concat_line(key, k));
+        }
+    }
+    out_frames
+}
+
+pub fn listing(root_path: String, frames: Vec<String>) -> Vec<String> {
+    let re: Regex = Regex::new(r".*.exr$").unwrap();
+    let frames_dict: HashMap<String, Vec<String>> = parse_result(frames);
+    let mut out_frames: Vec<String> = Vec::new();
+    for (key, value) in frames_dict {
+        if value[0] == "None" && value.len() == 1 {
+            out_frames.push(key);
+        } else {
+            let to = value.first().unwrap();
+            let from = String::from_utf8(vec![b'#'; to.len()]).unwrap();
+            let new_path = &key.replace(&from, to);
+            if re.is_match(new_path) {
+                let path = format!("{}{}", root_path, new_path);
+                read_meta(path);
+            };
+            let i = convert_vec(value);
+            let j = group_continuity(&i);
+            let k = convert_vec_to_str(j);
+            out_frames.push(concat_line(key, k));
+        }
+    }
+    out_frames
 }

src/lib.rs

@@ -13,6 +13,10 @@ struct Args {
     #[arg(short, long)]
     recursive: bool,
 
+    /// Display Buf format
+    #[arg(short, long)]
+    buf: bool,
+
     /// Path to parse
     #[arg(default_value_t = String::from("./"), last = true)]
     root: String,