nucleob 1.1.1

bioinformatics: nucleobases and amino acids statistics
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

// NUCLEOB VERSION 1.1.1 / MIT LICENSE © 2022–2023 PIOTR BAJDEK

// MODULE STAT

// CLIPPY LINTS

#![warn(clippy::nursery, clippy::pedantic)]
#![allow(clippy::missing_panics_doc, clippy::too_many_lines)]

// IMPORTS

use std::env;
use std::fs;
use std::path::Path;

pub mod amino_acids;
pub mod nucleobases;

// OPTIONS FOR CALCULATIONS

pub fn slct(reset: &str, grey: &str, red: &str, violet: &str, yellow: &str) {
    let args: Vec<String> = env::args().collect();

    let input1 = args.get(1).expect(&(red.to_owned() + "Invalid or missing arguments! See: --help" + reset));
    let input2 = args.get(2).expect(&(red.to_owned() + "Invalid or missing arguments! See: --help" + reset));

    if input1 == "-a" && input2 == "-a" {
        panic!("{}", red.to_owned() + "Invalid arguments provided! See: --help" + reset);
    }

    if input1 == "-n" && input2 == "-n" {
        panic!("{}", red.to_owned() + "Invalid arguments provided! See: --help" + reset);
    }

    if input1 == "-a" && input2 == "-n" {
        panic!("{}", red.to_owned() + "Invalid arguments provided! See: --help" + reset);
    }

    if input1 == "-n" && input2 == "-a" {
        panic!("{}", red.to_owned() + "Invalid arguments provided! See: --help" + reset);
    }

    // AMINO ACIDS

    if input1 == "-a" || input2 == "-a" {
        if input1 == "-a" {
            let isdir: bool = Path::new(input2).is_dir();
            let isfile: bool = Path::new(input2).is_file();
            if isdir {
                for file in fs::read_dir(input2).unwrap() {
                    let data0 = file.unwrap().path();

                    let data_n = data0.clone();
                    let fl_name0 = data_n.file_name().unwrap().to_str();
                    let fl_name: &str = fl_name0.unwrap().trim();

                    let data = fs::read_to_string(data0).expect(&(red.to_owned() + "Something went wrong reading the file!" + reset));
                    amino_acids::a_count(&data, reset, grey, red, violet, yellow, fl_name);
                    println!();
                }
            } else if isfile {
                let fl_name: &str = input2.trim();
                let data = fs::read_to_string(input2).expect(&(red.to_owned() + "Something went wrong reading the file!" + reset));
                amino_acids::a_count(&data, reset, grey, red, violet, yellow, fl_name);
            } else {
                panic!("{}", red.to_owned() + "Something went wrong reading the file or directory!" + reset);
            }
        } else if input2 == "-a" {
            let isdir: bool = Path::new(input1).is_dir();
            let isfile: bool = Path::new(input1).is_file();
            if isdir {
                for file in fs::read_dir(input1).unwrap() {
                    let data0 = file.unwrap().path();

                    let data_n = data0.clone();
                    let fl_name0 = data_n.file_name().unwrap().to_str();
                    let fl_name: &str = fl_name0.unwrap().trim();

                    let data = fs::read_to_string(data0).expect(&(red.to_owned() + "Something went wrong reading the file!" + reset));
                    amino_acids::a_count(&data, reset, grey, red, violet, yellow, fl_name);
                    println!();
                }
            } else if isfile {
                let fl_name: &str = input1.trim();
                let data = fs::read_to_string(input1).expect(&(red.to_owned() + "Something went wrong reading the file!" + reset));
                amino_acids::a_count(&data, reset, grey, red, violet, yellow, fl_name);
            } else {
                panic!("{}", red.to_owned() + "Something went wrong reading the file or directory!" + reset);
            }
        }
        return;
    }

    // NUCLEOBASES

    if input1 == "-n" || input2 == "-n" {
        if input1 == "-n" {
            let isdir: bool = Path::new(input2).is_dir();
            let isfile: bool = Path::new(input2).is_file();
            if isdir {
                for file in fs::read_dir(input2).unwrap() {
                    let data0 = file.unwrap().path();

                    let data_n = data0.clone();
                    let fl_name0 = data_n.file_name().unwrap().to_str();
                    let fl_name: &str = fl_name0.unwrap().trim();

                    let data = fs::read_to_string(data0).expect(&(red.to_owned() + "Something went wrong reading the file!" + reset));
                    nucleobases::n_count(&data, reset, grey, red, violet, yellow, fl_name);
                    println!();
                }
            } else if isfile {
                let fl_name: &str = input2.trim();
                let data = fs::read_to_string(input2).expect(&(red.to_owned() + "Something went wrong reading the file!" + reset));
                nucleobases::n_count(&data, reset, grey, red, violet, yellow, fl_name);
            } else {
                panic!("{}", red.to_owned() + "Something went wrong reading the file or directory!" + reset);
            }
        } else if input2 == "-n" {
            let isdir: bool = Path::new(input1).is_dir();
            let isfile: bool = Path::new(input1).is_file();
            if isdir {
                for file in fs::read_dir(input1).unwrap() {
                    let data0 = file.unwrap().path();

                    let data_n = data0.clone();
                    let fl_name0 = data_n.file_name().unwrap().to_str();
                    let fl_name: &str = fl_name0.unwrap().trim();

                    let data = fs::read_to_string(data0).expect(&(red.to_owned() + "Something went wrong reading the file!" + reset));
                    nucleobases::n_count(&data, reset, grey, red, violet, yellow, fl_name);
                    println!();
                }
            } else if isfile {
                let fl_name: &str = input1.trim();
                let data = fs::read_to_string(input1).expect(&(red.to_owned() + "Something went wrong reading the file!" + reset));
                nucleobases::n_count(&data, reset, grey, red, violet, yellow, fl_name);
            } else {
                panic!("{}", red.to_owned() + "Something went wrong reading the file or directory!" + reset);
            }
        }
        return;
    }

    panic!("{}", red.to_owned() + "Invalid arguments provided! See: --help" + reset);
}