Add support for Fasta records

CHANGELOG.md

@@ -1,3 +1,7 @@
+# Version 0.7.0 (2020-03-21)
+
+- Add support for Fasta files
+
 # Version 0.6.0 (2018-08-10)
 
 - Make `RecordRefReader` public.

README.md

@@ -2,10 +2,10 @@
 
 # A fast parser for fastq.
 
-This library can process fastq files at about the speed of the
+This library can process fast{q,a} files at about the speed of the
 coreutils `wc -l` (about 2GB/s on my laptop, `seqan` runs at
 about 150MB/s). It also makes it easy to distribute the
-processing of fastq records to many cores, without losing much
+processing of fast{q,a} records to many cores, without losing much
 of the performance.
 
 See the [documentation](https://docs.rs/fastq/) for details and examples.

examples/alignment_count.rs

@@ -1,6 +1,6 @@
-use fastq::{parse_path, Record};
-use std::env::args;
+use fastq::{parse_path_fq, Record};
 use parasailors as align;
+use std::env::args;
 
 extern crate fastq;
 extern crate parasailors;
@@ -12,29 +12,31 @@ const ADAPTER: &'static [u8] = b"AATGATACGGCGACCACCGAGA\
 fn main() {
     let filename = args().nth(1);
     let path = match filename.as_ref().map(String::as_ref) {
-        None | Some("-") => { None },
-        Some(name) => Some(name)
+        None | Some("-") => None,
+        Some(name) => Some(name),
     };
 
-    let results = parse_path(path, |parser| {
+    let results = parse_path_fq(path, |parser| {
         let nthreads = 2;
-        let results: Vec<usize> = parser.parallel_each(nthreads, |record_sets| {
-            let matrix = align::Matrix::new(align::MatrixType::Identity);
-            let profile = align::Profile::new(ADAPTER, &matrix);
-            let mut thread_total = 0;
+        let results: Vec<usize> = parser
+            .parallel_each(nthreads, |record_sets| {
+                let matrix = align::Matrix::new(align::MatrixType::Identity);
+                let profile = align::Profile::new(ADAPTER, &matrix);
+                let mut thread_total = 0;
 
-            for record_set in record_sets {
-                for record in record_set.iter() {
-                    let score = align::local_alignment_score(
-                            &profile, record.seq(), 8, 1);
-                    if score > 10 {
-                        thread_total += 1;
+                for record_set in record_sets {
+                    for record in record_set.iter() {
+                        let score = align::local_alignment_score(&profile, record.seq(), 8, 1);
+                        if score > 10 {
+                            thread_total += 1;
+                        }
                     }
                 }
-            }
-            thread_total
-        }).expect("Invalid fastq file");
+                thread_total
+            })
+            .expect("Invalid fastq file");
         results
-    }).expect("Invalid compression");
+    })
+    .expect("Invalid compression");
     println!("{}", results.iter().sum::<usize>());
 }

examples/bio-count.rs

@@ -1,21 +1,24 @@
+use bio::io::fastq::{Reader, Record};
 use std::io::stdin;
 use std::sync::mpsc::sync_channel;
 use std::thread::Builder;
-use bio::io::fastq::{Reader, Record};
 
 extern crate bio;
 
 fn main() {
     let reader = Reader::new(stdin());
     let (tx, rx) = sync_channel::<Vec<Record>>(10);
 
-    let handle = Builder::new().name("worker".to_string()).spawn(move || {
-        let mut count: usize = 0;
-        while let Ok(val) = rx.recv() {
-            count += val.len();
-        }
-        count
-    }).unwrap();
+    let handle = Builder::new()
+        .name("worker".to_string())
+        .spawn(move || {
+            let mut count: usize = 0;
+            while let Ok(val) = rx.recv() {
+                count += val.len();
+            }
+            count
+        })
+        .unwrap();
 
     //let mut record = Record::new();
     //while let Ok(_) = reader.read(&mut record) {

examples/fastq-count-thread.rs

@@ -1,23 +1,26 @@
-use fastq::parse_path;
+use fastq::parse_path_fq;
 use std::env::args;
 
 extern crate fastq;
 
 fn main() {
     let filename = args().nth(1);
     let path = match filename.as_ref().map(String::as_ref) {
-        None | Some("-") => { None },
-        Some(name) => Some(name)
+        None | Some("-") => None,
+        Some(name) => Some(name),
     };
 
-    parse_path(path, |parser| {
-        let results: Vec<usize> = parser.parallel_each(1, |record_sets| {
-            let mut thread_total = 0;
-            for record_set in record_sets {
-                thread_total += record_set.len();
-            }
-            thread_total
-        }).expect("Invalid fastq file");
+    parse_path_fq(path, |parser| {
+        let results: Vec<usize> = parser
+            .parallel_each(1, |record_sets| {
+                let mut thread_total = 0;
+                for record_set in record_sets {
+                    thread_total += record_set.len();
+                }
+                thread_total
+            })
+            .expect("Invalid fastq file");
         println!("{}", results.iter().sum::<usize>());
-    }).expect("Invalid compression");
+    })
+    .expect("Invalid compression");
 }

examples/fastq-count.rs

@@ -1,22 +1,24 @@
-use fastq::parse_path;
+use fastq::parse_path_fq;
 use std::env::args;
 
 extern crate fastq;
 
-
 fn main() {
     let filename = args().nth(1);
     let path = match filename.as_ref().map(String::as_ref) {
-        None | Some("-") => { None },
-        Some(name) => Some(name)
+        None | Some("-") => None,
+        Some(name) => Some(name),
     };
 
     let mut total: usize = 0;
-    parse_path(path, |parser| {
-        parser.each(|_| {
-            total += 1;
-            true
-        }).expect("Invalid fastq file");
-    }).expect("Invalid compression");
+    parse_path_fq(path, |parser| {
+        parser
+            .each(|_| {
+                total += 1;
+                true
+            })
+            .expect("Invalid fastq file");
+    })
+    .expect("Invalid compression");
     println!("{}", total);
 }

examples/multiple-files.rs

@@ -1,17 +1,16 @@
-use fastq::{parse_path, each_zipped};
+use fastq::{each_zipped, parse_path_fq};
 use std::env::args;
 
 extern crate fastq;
 
-
 fn main() {
     let path1 = args().nth(1).expect("Need two input files.");
     let path2 = args().nth(2).expect("Need two input files.");
 
     let mut counts = (0u64, 0u64);
 
-    parse_path(Some(path1), |parser1| {
-        parse_path(Some(path2), |parser2| {
+    parse_path_fq(Some(path1), |parser1| {
+        parse_path_fq(Some(path2), |parser2| {
             each_zipped(parser1, parser2, |rec1, rec2| {
                 if rec1.is_some() {
                     counts.0 += 1;
@@ -20,9 +19,12 @@ fn main() {
                     counts.1 += 1;
                 }
                 (true, true)
-            }).expect("Invalid record.");
-        }).expect("Unknown format for file 2.");
-    }).expect("Unknown format for file 1.");
+            })
+            .expect("Invalid record.");
+        })
+        .expect("Unknown format for file 2.");
+    })
+    .expect("Unknown format for file 1.");
 
     println!("Number of reads: ({}, {})", counts.0, counts.1);
 }

fuzz/Cargo.toml

@@ -27,3 +27,11 @@ path = "fuzz_targets/fuzz_target_1.rs"
 [[bin]]
 name = "fuzz_target_2"
 path = "fuzz_targets/fuzz_target_2.rs"
+
+[[bin]]
+name = "fuzz_target_3"
+path = "fuzz_targets/fuzz_target_3.rs"
+
+[[bin]]
+name = "fuzz_target_4"
+path = "fuzz_targets/fuzz_target_4.rs"

fuzz/fuzz_targets/fuzz_target_1.rs

@@ -1,18 +1,21 @@
 #![no_main]
 
-use std::io::Cursor;
 use fastq::Record;
+use std::io::Cursor;
 
-#[macro_use] extern crate libfuzzer_sys;
-extern crate fastq;
+#[macro_use]
+extern crate libfuzzer_sys;
 extern crate criterion;
-
+extern crate fastq;
 
 fuzz_target!(|data: &[u8]| {
     let reader = Cursor::new(data);
-    let mut parser = fastq::Parser::new(reader);
+    let mut parser = fastq::Parser::new(reader, fastq::ParserKind::Fastq);
 
     let mut sum: usize = 0;
-    let _ = parser.each(|rec| {sum += rec.seq().len(); true});
+    let _ = parser.each(|rec| {
+        sum += rec.seq().len();
+        true
+    });
     criterion::black_box(sum);
 });

fuzz/fuzz_targets/fuzz_target_2.rs

@@ -1,15 +1,15 @@
 #![no_main]
 
-use std::io::Cursor;
 use fastq::Record;
+use std::io::Cursor;
 
-#[macro_use] extern crate libfuzzer_sys;
+#[macro_use]
+extern crate libfuzzer_sys;
 extern crate fastq;
 
-
 fuzz_target!(|data: &[u8]| {
     let reader = Cursor::new(data);
-    let mut parser = fastq::Parser::new(reader);
+    let mut parser = fastq::Parser::new(reader, fastq::ParserKind::Fastq);
 
     let _: Result<Vec<_>, _> = parser.parallel_each(3, |sets| {
         for set in sets {

fuzz/fuzz_targets/fuzz_target_3.rs

@@ -0,0 +1,21 @@
+#![no_main]
+
+use fastq::Record;
+use std::io::Cursor;
+
+#[macro_use]
+extern crate libfuzzer_sys;
+extern crate criterion;
+extern crate fastq;
+
+fuzz_target!(|data: &[u8]| {
+    let reader = Cursor::new(data);
+    let mut parser = fastq::Parser::new(reader, fastq::ParserKind::Fasta);
+
+    let mut sum: usize = 0;
+    let _ = parser.each(|rec| {
+        sum += rec.seq().len();
+        true
+    });
+    criterion::black_box(sum);
+});

fuzz/fuzz_targets/fuzz_target_4.rs

@@ -0,0 +1,22 @@
+#![no_main]
+
+use fastq::Record;
+use std::io::Cursor;
+
+#[macro_use]
+extern crate libfuzzer_sys;
+extern crate fastq;
+
+fuzz_target!(|data: &[u8]| {
+    let reader = Cursor::new(data);
+    let mut parser = fastq::Parser::new(reader, fastq::ParserKind::Fasta);
+
+    let _: Result<Vec<_>, _> = parser.parallel_each(3, |sets| {
+        for set in sets {
+            for rec in set.iter() {
+                rec.seq();
+            }
+        }
+        true
+    });
+});