test5 0.1.3

A short description of my package
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

use std::{collections::BTreeSet, iter::FromIterator};
use std::path::Path;

pub mod m1 {
    pub fn f1() -> i32 {
        println!("edderocks1111111111111111");
        111
    }

    pub fn f2() -> i32 {
        println!("edderocks222222222222222222222222");
        222
    }
}

pub fn f3() -> i32 {
    println!("fffffffffffffffffff333333333333333333333333");
    333
}



pub trait MyTraitForStringSlice<'a> {
    fn equals_to_one_of_2(self, a: &str, b: &str) -> bool;
    fn equals_to_one_of_3(self, a: &str, b: &str, c: &str) -> bool;
    fn get_regex_matched_group_n(self, regex: &str, n: usize) -> Option<String>;
    fn name_increase_width_2(self) -> String;
    fn to_path(self) -> &'a Path;
    fn to_vec_char(self) -> Vec<char>;
    fn to_vec_u8(self) -> Vec<u8>;
    fn ends_with_vec(self, v: Vec<&str>) -> bool;
    fn get_file_name(self) -> &'a str;
    fn get_folder_name(self) -> &'a str;
}

impl<'a> MyTraitForStringSlice<'a> for &'a str {
    fn equals_to_one_of_2(self, a: &str, b: &str) -> bool {
        if self == a || self == b {
            return true;
        }
        false
    }

    fn equals_to_one_of_3(self, a: &str, b: &str, c: &str) -> bool {
        if self == a || self == b || self == c {
            return true;
        }
        false
    }

    fn get_regex_matched_group_n(self, regex: &str, n: usize) -> Option<String> {
        let re = regex::Regex::new(regex).unwrap();
        let result = re.captures(self)?;
        Some(result[n].to_string())
    }

    fn name_increase_width_2(self) -> String {
        fn inc(s: &str) -> String {
            let mut i = s.parse::<i32>().unwrap();
            i = i + 1;
            let width = s.chars().count();
            format!("[{:0>w$}]", i, w = width)
        }

        fn get_default(w: usize) -> String {
            format!("[{}]", "0".repeat(w))
        }

        let width: usize = 2;
        let file = Path::new(self);
        let re = regex::Regex::new(&format!(r"(?i)^(.+?)(\[({})\])?(\.\w+)?$", r"\d".repeat(width))).unwrap();
        let result = re.captures(file.to_str().unwrap()).unwrap();

        let mut t;
        if result.get(2).is_none() {
            t = format!("{}{}{}", &result.get(1).map_or("", |e| e.as_str()), get_default(width), &result.get(4).map_or("", |e| e.as_str()));
        } else {
            t = format!("{}{}{}", &result.get(1).map_or("", |e| e.as_str()), inc(&result.get(3).map(|e| e.as_str()).unwrap()), &result.get(4).map_or("", |e| e.as_str()));
        }

        while t.as_str().to_path().is_file() || t.as_str().to_path().is_dir() {
            t = t.name_increase_width_2();
        }
        t
    }

    fn to_path(self) -> &'a Path {
        Path::new(self)
    }

    fn to_vec_char(self) -> Vec<char> {
        self.chars().collect::<Vec<_>>()
    }

    fn to_vec_u8(self) -> Vec<u8> {
        self.as_bytes().to_vec()
    }

    fn ends_with_vec(self, v: Vec<&str>) -> bool {
        for e in v {
            if self.ends_with(e) {
                return true;
            }
        }
        false
    }

    fn get_file_name(self) -> &'a str {
        let x = Path::new(self);
        x.file_name().unwrap().to_str().unwrap()
    }

    fn get_folder_name(self) -> &'a str {
        let x = Path::new(self);
        x.parent().map_or("", |e| e.to_str().unwrap())
    }
}