fxtools 0.2.39

A collection of commandline Fasta/Fastq utility tools
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

use std::io::stdin;

use super::{match_output_stream, write_mut_output, write_mut_output_with_invalid};
use anyhow::Result;
use fxread::{initialize_reader, initialize_stdin_reader, Record};

/// Format prints the sequence as uppercase
fn format_print(record: &mut Record) -> &str {
    record.upper();
    record.as_str()
}

/// Runs uppercase
pub fn run(
    input: Option<String>,
    output: Option<String>,
    compression_threads: Option<usize>,
    compression_level: Option<usize>,
    allow_invalid: bool,
) -> Result<()> {
    let reader = if let Some(path) = input {
        initialize_reader(&path)
    } else {
        initialize_stdin_reader(stdin().lock())
    }?;
    let mut writer = match_output_stream(output, compression_threads, compression_level)?;
    if allow_invalid {
        write_mut_output_with_invalid(&mut writer, reader, &format_print);
    } else {
        write_mut_output(&mut writer, reader, &format_print);
    }
    Ok(())
}

#[cfg(test)]
mod test {
    use super::{format_print, match_output_stream, write_mut_output};
    use crate::commands::io::write_mut_output_with_invalid;
    use fxread::{FastaReader, FastqReader, FastxRead, Record};
    use std::fs::File;

    fn fasta_reader() -> Box<dyn FastxRead<Item = Record>> {
        let sequence: &'static [u8] =
            b">ap2s1_asjdajsdas\nact\n>ap2s1_asdkjasd\nacc\n>ap2s2_aosdjiasj\nact\n";
        Box::new(FastaReader::new(sequence))
    }

    fn invalid_fasta_reader() -> Box<dyn FastxRead<Item = Record>> {
        let sequence: &'static [u8] =
            b">ap2s1_asjdajsdas\nbrb\n>ap2s1_asdkjasd\nacc\n>ap2s2_aosdjiasj\nact\n";
        Box::new(FastaReader::new(sequence))
    }

    fn fastq_reader() -> Box<dyn FastxRead<Item = Record>> {
        let sequence: &'static [u8] = b"@ap2s1_asjdajsdas\nact\n+\n123\n@ap2s1_asdkjasd\nacc\n+\n123\n@ap2s2_aosdjiasj\nact\n+\n123\n";
        Box::new(FastqReader::new(sequence))
    }

    fn invalid_fastq_reader() -> Box<dyn FastxRead<Item = Record>> {
        let sequence: &'static [u8] = b"@ap2s1_asjdajsdas\nbrb\n+\n123\n@ap2s1_asdkjasd\nacc\n+\n123\n@ap2s2_aosdjiasj\nact\n+\n123\n";
        Box::new(FastqReader::new(sequence))
    }

    #[test]
    fn run_fasta() {
        let mut reader = fasta_reader();
        let mut record = reader.next().unwrap();
        let upper = format_print(&mut record);
        assert_eq!(upper, ">ap2s1_asjdajsdas\nACT\n");
    }

    #[test]
    fn run_fastq() {
        let mut reader = fastq_reader();
        let mut record = reader.next().unwrap();
        let upper = format_print(&mut record);
        assert_eq!(upper, "@ap2s1_asjdajsdas\nACT\n+\n123\n");
    }

    #[test]
    #[should_panic]
    fn run_invalid_fasta() {
        let reader = invalid_fasta_reader();
        let mut writer = match_output_stream(None, None, None).unwrap();
        write_mut_output(&mut writer, reader, &format_print)
    }

    #[test]
    fn run_invalid_fasta_allow_invalid() {
        let reader = invalid_fasta_reader();
        let mut writer = File::create("/dev/null").unwrap();
        write_mut_output_with_invalid(&mut writer, reader, &format_print)
    }

    #[test]
    #[should_panic]
    fn run_invalid_fastq() {
        let reader = invalid_fastq_reader();
        let mut writer = match_output_stream(None, None, None).unwrap();
        write_mut_output(&mut writer, reader, &format_print)
    }

    #[test]
    fn run_invalid_fastq_allow_invalid() {
        let reader = invalid_fastq_reader();
        let mut writer = File::create("/dev/null").unwrap();
        write_mut_output_with_invalid(&mut writer, reader, &format_print)
    }
}