feat: show error when no input file specified

Cargo.toml

@@ -15,6 +15,7 @@ license = "GPL-3.0"
 
 [dependencies]
 anyhow = "1.0.75"
+atty = "0.2.14"
 bio = "1.5.0"
 bzip2 = "0.4.4"
 chrono = "0.4.30"
@@ -36,4 +37,4 @@ xz2 = "0.1.7"
 
 
 [profile.release]
-strip = true
+strip = true

src/cli/barcode.rs

@@ -4,15 +4,16 @@ use bio::io::fastq;
 use log::*;
 use std::collections::HashMap;
 use std::io::BufRead;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use std::time::Instant;
 
 fn barcode_list(file: &String, rev_comp: bool) -> Result<HashMap<String, String>> {
-    info!("reading from barcode list file: {}", file);
 
-    let fp = file_reader(Some(file))?;
     let mut maps = HashMap::new();
     let mut error_flag = "";
+    let fp = file_reader(Some(file))?;
+    info!("reading from barcode list file: {}", file);
+
     if rev_comp {
         for line in fp.lines().map_while(std::io::Result::ok) {
             let item = line.split('\t').collect::<Vec<&str>>(); // barcode => sample
@@ -125,31 +126,31 @@ pub fn split_fq(
         let mut fq_hand = Vec::new();
         for (bar_seq, name) in maps {
             let fq1 = if gzip {
-                format!("{}/{}_1.fq.gz", outdir, name)
+                PathBuf::from(outdir).join(format!("{}_1.fq.gz",name))
             } else if bzip2 {
-                format!("{}/{}_1.fq.bz2", outdir, name)
+                PathBuf::from(outdir).join(format!("{}_1.fq.bz2",name))
             } else if xz {
-                format!("{}/{}_1.fq.xz", outdir, name)
+                PathBuf::from(outdir).join(format!("{}_1.fq.xz",name))
             } else {
-                format!("{}/{}_1.fq", outdir, name)
+                PathBuf::from(outdir).join(format!("{}_1.fq",name))
             };
             let fq2 = if gzip {
-                format!("{}/{}_2.fq.gz", outdir, name)
+                PathBuf::from(outdir).join(format!("{}_2.fq.gz",name))
             } else if bzip2 {
-                format!("{}/{}_2.fq.bz2", outdir, name)
+                PathBuf::from(outdir).join(format!("{}_2.fq.bz2",name))
             } else if xz {
-                format!("{}/{}_2.fq.xz", outdir, name)
+                PathBuf::from(outdir).join(format!("{}_2.fq.xz",name))
             } else {
-                format!("{}/{}_2.fq", outdir, name)
+                PathBuf::from(outdir).join(format!("{}_2.fq",name))
             };
             let bar = if gzip {
-                format!("{}/{}_barcode.fq.gz", outdir, name)
+                PathBuf::from(outdir).join(format!("{}_barcode.fq.gz",name))
             } else if bzip2 {
-                format!("{}/{}_barcode.fq.bz2", outdir, name)
+                PathBuf::from(outdir).join(format!("{}_barcode.fq.bz2",name))
             } else if xz {
-                format!("{}/{}_barcode.fq.xz", outdir, name)
+                PathBuf::from(outdir).join(format!("{}_barcode.fq.xz",name))
             } else {
-                format!("{}/{}_barcode.fq", outdir, name)
+                PathBuf::from(outdir).join(format!("{}_barcode.fq",name))
             };
 
             let fh1 = fastq::Writer::new(file_writer_append(&fq1, compression_level)?);
@@ -159,14 +160,14 @@ pub fn split_fq(
             fq_hand.push((bar_seq, len, fh1, fh2, fhb));
         }
 
-        info!("reading from read1 file: {}", big_fq1);
-        info!("reading from read2 file: {}", big_fq2);
-        info!("barcode position mode: {}", mode);
-
         let bar_count = fq_hand.len();
         let fq1_reader = fastq::Reader::new(file_reader(Some(big_fq1))?);
         let fq2_reader = fastq::Reader::new(file_reader(Some(big_fq2))?);
         let (mut read_pair, mut get_pair) = (0u64, 0u64);
+
+        info!("reading from read1 file: {}", big_fq1);
+        info!("reading from read2 file: {}", big_fq2);
+        info!("barcode position mode: {}", mode);
 
         if mode == 2 {
             for (rec1, rec2) in fq1_reader

src/cli/check.rs

@@ -10,15 +10,16 @@ pub fn check_fastq(
     out: Option<&String>,
     compression_level: u32,
 ) -> Result<()> {
+    let start = Instant::now();
+
+    let (mut total, mut ok_read, mut err_read) = (0, 0, 0);
+    let fp_reader = file_reader(file).map(fastq::Reader::new)?;
     if let Some(file) = file {
         info!("reading from file: {}", file);
     } else {
         info!("reading from stdin");
     }
 
-    let start = Instant::now();
-    let (mut total, mut ok_read, mut err_read) = (0, 0, 0);
-    let fp_reader = file_reader(file).map(fastq::Reader::new)?;
     if save {
         let mut out_writer = file_writer(out, compression_level).map(fastq::Writer::new)?;
         for rec in fp_reader.records().flatten() {

src/cli/concat.rs

@@ -11,16 +11,14 @@ pub fn concat_fqstq_lane(
     out_r2: &String,
     compression_level: u32,
 ) -> Result<(), Error> {
-    info!("read forward reads for lane list: {}", r1_list);
-    info!("read forward reads for lane list: {}", r2_list);
-    info!("outout read1 in file: {}", out_r1);
-    info!("outout read1 in file: {}", out_r2);
     let start = Instant::now();
 
     let mut vec1 = vec![];
     let mut vec2 = vec![];
     let fp1 = file_reader(Some(r1_list))?;
     let fp2 = file_reader(Some(r2_list))?;
+    info!("read forward reads for lane list: {}", r1_list);
+    info!("read forward reads for lane list: {}", r2_list); 
 
     for r1 in fp1.lines().map_while(Result::ok) {
         vec1.push(r1);
@@ -35,6 +33,9 @@ pub fn concat_fqstq_lane(
         );
         std::process::exit(1);
     }
+
+    info!("outout read1 in file: {}", out_r1);
+    info!("outout read1 in file: {}", out_r2);
 
     let mut out_writer1 = file_writer(Some(out_r1), compression_level).map(fastq::Writer::new)?;
     let mut out_writer2 = file_writer(Some(out_r2), compression_level).map(fastq::Writer::new)?;

src/cli/cutadapter.rs

@@ -14,6 +14,8 @@ pub fn cut_adapter(
     compression_level: u32,
 ) -> Result<(), Error> {
     let start = Instant::now();
+
+    let seqfile_reader = file_reader(Some(seqfile)).map(fasta::Reader::new)?;
     if let Some(file) = input {
         info!("reading seq from file: {}", seqfile);
         info!("reading from file: {}", file);
@@ -22,8 +24,6 @@ pub fn cut_adapter(
     }
 
     let mut seqs = HashMap::new();
-    let seqfile_reader = file_reader(Some(seqfile)).map(fasta::Reader::new)?;
-
     let mut iters = seqfile_reader.records();
     while let Some(each) = iters.next() {
         let rec = each?;

src/cli/flatten.rs

@@ -12,6 +12,8 @@ pub fn flatten_fq(
     compression_level: u32,
 ) -> Result<(), Error> {
     let start = Instant::now();
+
+    let fq_reader = file_reader(file).map(fastq::Reader::new)?;
     if let Some(file) = file {
         info!("reading from file: {}", file);
     } else {
@@ -23,8 +25,7 @@ pub fn flatten_fq(
         error!("error flag numer: {}, flag range [1..15]", flag);
         std::process::exit(1);
     }
-
-    let fq_reader = file_reader(file).map(fastq::Reader::new)?;
+
     let mut out_writer = file_writer(out, compression_level)?;
     let flags = format!("{:b}", flag).chars().rev().collect::<Vec<char>>();
     let mut fields = vec![];

src/cli/fq2fa.rs

@@ -11,17 +11,17 @@ pub fn fq2fa(
     out: Option<&String>,
     compression_level: u32,
 ) -> Result<(), Error> {
+    let start = Instant::now();
+
+    let mut num = 0usize;
+    let fq_reader = fastq::Reader::new(file_reader(file)?);
     if let Some(file) = file {
         info!("reading from file: {}", file);
     } else {
         info!("reading from stdin");
     }
-    let start = Instant::now();
-    let mut num = 0usize;
-
-    let fq_reader = fastq::Reader::new(file_reader(file)?);
+
     let mut fo = fasta::Writer::new(file_writer(out, compression_level)?);
-
     if remove {
         for rec in fq_reader.records().flatten() {
             num += 1;

src/cli/fqscore.rs

@@ -11,6 +11,9 @@ pub fn phred_score(
     to64: bool,
     compression_level: u32,
 ) -> Result<()> {
+    let start = Instant::now();
+
+    let fq_reader = file_reader(file).map(fastq::Reader::new)?;
     if let Some(r) = file {
         info!("read file from: {}", r);
     } else {
@@ -33,10 +36,7 @@ pub fn phred_score(
         std::process::exit(1);
     }
 
-    let start = Instant::now();
-    let fq_reader = file_reader(file).map(fastq::Reader::new)?;
     let mut fq_writer = file_writer(out, compression_level).map(fastq::Writer::new)?;
-
     for rec in fq_reader.records().flatten() {
         let mut qual = vec![];
         if to33 {

src/cli/gcplot.rs

@@ -18,14 +18,15 @@ pub fn gc_content(
     types: &str,
     compression_level: u32,
 ) -> Result<(), Error> {
+    let start = Instant::now();
+
+    let fq_reader = file_reader(fqin).map(fastq::Reader::new)?;
     if let Some(inp) = fqin {
         info!("reading from file: {}", inp);
     } else {
         info!("reading from stdin");
     }
-    let start = Instant::now();
-
-    let fq_reader = file_reader(fqin).map(fastq::Reader::new)?;
+
     let mut fo = file_writer(output, compression_level)?;
     let mut df_hash = HashMap::new();
 

src/cli/grep.rs

@@ -12,33 +12,33 @@ pub fn grep_fastq(
     out: Option<&String>,
     compression_level: u32,
 ) -> Result<()> {
+    let start = Instant::now();
+
+    let fq_reader = file_reader(fq).map(fastq::Reader::new)?;
     if let Some(file) = fq {
         info!("reading from file: {}", file);
     } else {
         info!("reading from stdin");
     }
-    info!("reading reads id from file: {}", list);
 
-    let start = Instant::now();
     let mut num = 0usize;
     let mut ids = vec![];
-
     let fp_id = file_reader(Some(list))?;
+    info!("reading reads id from file: {}", list);
     for id in fp_id.lines().map_while(std::io::Result::ok) {
         ids.push(id);
     }
     if ids.is_empty() {
         error!("no reads id in file: {}", list);
         std::process::exit(1);
     }
+
     if let Some(out) = out {
         info!("reads write to file: {}", out);
     } else {
         info!("reads write to stdout");
     }
-
     let mut fo = file_writer(out, compression_level).map(fastq::Writer::new)?;
-    let fq_reader = file_reader(fq).map(fastq::Reader::new)?;
     for rec in fq_reader.records().flatten() {
         let name = if full_name {
             if let Some(desc) = rec.desc() {

src/cli/length.rs

@@ -10,17 +10,18 @@ pub fn fq_length(
     out: Option<&String>,
     compression_level: u32,
 ) -> Result<(), Error> {
+    let start = Instant::now();
+
+    let mut reads_len = HashMap::new();
+    let mut total = 0usize;
+    let fp_reader = file_reader(file).map(fastq::Reader::new)?;
     if let Some(file) = file {
         info!("reading from file: {}", file);
     } else {
         info!("reading from stdin");
     }
-    let start = Instant::now();
-    let mut reads_len = HashMap::new();
-    let mut total = 0usize;
-    let fp_reader = file_reader(file).map(fastq::Reader::new)?;
+
     let mut fo = file_writer(out, compression_level)?;
-
     for rec in fp_reader.records().flatten() {
         let rlen = rec.seq().len();
         *reads_len.entry(rlen).or_insert(0usize) += 1;
@@ -30,7 +31,6 @@ pub fn fq_length(
     let mut sort_len: Vec<(&usize, &usize)> = reads_len.iter().collect();
     sort_len.sort_by_key(|x| x.0);
 
-    //fo.write("lenth\tcount\n".as_bytes())?;
     fo.write_all("lenth\tcount\n".as_bytes())?;
     for (k, v) in sort_len.iter() {
         fo.write_all(format!("{}\t{}\n", k, v).as_bytes())?;

src/cli/mask.rs

@@ -12,19 +12,19 @@ pub fn mask_fastq(
     out: Option<&String>,
     compression_level: u32,
 ) -> Result<()> {
+    let start = Instant::now();
+
+    let (mut mask_base, mut mask_read) = (0, 0);
+    let fp_reader = file_reader(file).map(fastq::Reader::new)?;
     if let Some(file) = file {
         info!("reading from file: {}", file);
     } else {
         info!("reading from stdin");
     }
     info!("low quality value： {}", qual_limit);
     info!("mask low quality bases with: {}", nt);
-    let start = Instant::now();
-
-    let (mut mask_base, mut mask_read) = (0, 0);
-    let fp_reader = file_reader(file).map(fastq::Reader::new)?;
+
     let mut fp_writer = file_writer(out, compression_level).map(fastq::Writer::new)?;
-
     for rec in fp_reader.records().flatten() {
         let score_min = rec.qual().iter().min().unwrap() - phred;
         if score_min > qual_limit {

src/cli/merge.rs

@@ -10,15 +10,15 @@ pub fn interleaved(
     out: Option<&String>,
     compression_level: u32,
 ) -> Result<(), Error> {
-    info!("reading from file: {}", file1);
-    info!("reading from file: {}", file2);
     let start = Instant::now();
 
     let mut num = 0usize;
     let fq1_reader = fastq::Reader::new(file_reader(Some(file1))?);
     let fq2_reader = fastq::Reader::new(file_reader(Some(file2))?);
+    info!("reading from file: {}", file1);
+    info!("reading from file: {}", file2);
+
     let mut fq_writer = fastq::Writer::new(file_writer(out, compression_level)?);
-
     for (rec1, rec2) in fq1_reader
         .records()
         .flatten()

src/cli/range.rs

@@ -11,18 +11,18 @@ pub fn range_fastq(
     output: Option<&String>,
     compression_level: u32,
 ) -> Result<()> {
+    let start = Instant::now();
+
+    let fp_reader = file_reader(input).map(fastq::Reader::new)?;
     if let Some(file) = input {
         info!("reading from file: {}", file);
     } else {
         info!("reading from stdin");
     }
     info!("skip first {} records", skip);
     info!("get {} records", take);
-    let start = Instant::now();
-
-    let fp_reader = file_reader(input).map(fastq::Reader::new)?;
+
     let mut fp_writer = file_writer(output, compression_level).map(fastq::Writer::new)?;
-
     for rec in fp_reader.records().skip(skip).take(take).flatten() {
         fp_writer.write_record(&rec)?;
     }