mmft 0.2.1

A minimal fasta toolkit.
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

use crate::utils::{error, parse::parse_region, stdin};
use anyhow::{bail, Result};
use bio::io::fasta;
use std::io;

pub fn extract_region(matches: &clap::ArgMatches) -> Result<()> {
    let input_file = crate::get_fasta_files(matches);
    let region = matches
        .get_one::<String>("region")
        .expect("handled by clap");

    let parsed_region = parse_region(region)?;

    // writer here?
    let mut writer = fasta::Writer::new(io::stdout());

    match input_file {
        // read directly from files
        Some(f) => {
            for el in f.iter() {
                let basename = crate::get_basename_from_pathbuf(el)?;

                let reader = fasta::Reader::from_file(el)?;
                for record in reader.records() {
                    let record = record?;
                    let id = record.id();
                    let seq = record.seq().get(parsed_region[0]..parsed_region[1]);

                    let seq_res = match seq {
                        Some(s) => s,
                        None => bail!(error::RegionError::SeqExtractError),
                    };
                    // write to stdout
                    let description =
                        format!("{}: {}-{}", basename, parsed_region[0], parsed_region[1]);
                    writer
                        .write(id, Some(&description), seq_res)
                        .map_err(|_| error::FastaWriteError::CouldNotWrite)?;
                }
            }
        }
        // read from stdin
        None => match stdin::is_stdin() {
            true => {
                let mut records = fasta::Reader::new(io::stdin()).records();
                while let Some(Ok(record)) = records.next() {
                    let id = record.id();
                    let seq = record.seq().get(parsed_region[0]..parsed_region[1]);

                    let seq_res = match seq {
                        Some(s) => s,
                        None => bail!(error::RegionError::SeqExtractError),
                    };
                    // write to stdout
                    let description = format!("{}-{}", parsed_region[0], parsed_region[1]);
                    writer
                        .write(id, Some(&description), seq_res)
                        .map_err(|_| error::FastaWriteError::CouldNotWrite)?;
                }
            }
            false => {
                bail!(error::StdinError::NoSequence)
            }
        },
    }
    Ok(())
}