Some renames, and granges_filter() work.

 - Prototype of one branch of granges_filter()
 - Renamed GenomicRangeParsers enum to GenomicRangeParser

src/commands.rs

@@ -1,7 +1,7 @@
 use std::path::PathBuf;
 
 use crate::{
- io::{OutputFile, parsers::GenomicRangesParsers},
+ io::{OutputFile, parsers::GenomicRangesParser},
  prelude::*,
  ranges::operations::adjust_range,
  reporting::{CommandOutput, Report},
@@ -68,57 +68,73 @@ pub fn granges_adjust(
 
  let ranges_iter = GenomicRangesFile::parsing_iterator(bedfile)?;
  match ranges_iter {
- GenomicRangesParsers::Bed3(iter) => {
+ GenomicRangesParser::Bed3(iter) => {
  let gr = GRangesEmpty::from_iter(iter, &genome)?;
  gr.adjust_ranges(-both, both).to_tsv(output)?
  },
- GenomicRangesParsers::Bedlike(iter) => {
+ GenomicRangesParser::Bedlike(iter) => {
  // Note the call to try_unwrap_data() here: this is because
  // we know that the records *do* have data. Unwrapping the Option<String>
  // values means that writing to TSV doesn't have to deal with this (which 
  // always creates headaches).
  let gr = GRanges::from_iter(iter.try_unwrap_data()?, &genome)?;
  gr.adjust_ranges(-both, both).to_tsv(output)?
  },
- GenomicRangesParsers::Unsupported => {
+ GenomicRangesParser::Unsupported => {
  return Err(GRangesError::UnsupportedGenomicRangesFileFormat)
  },
 
  }
  }
  Ok(CommandOutput::new((), report))
 }
-//
-// /// Retain only the ranges that have at least one overlap with another set of ranges.
-// pub fn granges_filter<DL, DR>(
-// seqlens: &PathBuf,
-// left_granges: GRanges<VecRangesEmpty, DL>,
-// right_granges: GRanges<VecRangesEmpty, DR>,
-// sort: bool,
-// ) -> Result<CommandOutput<()>, GRangesError>
-// where
-// // we must be able to iterate over left ranges
-// VecRangesEmpty: IterableRangeContainer, 
-// // we must be able to convert the right GRanges to interval trees
-// GRanges<VecRangesEmpty, ()>: GenomicRangesToIntervalTrees<()>,
-// {
-// let right_granges = right_granges.to_coitrees()?;
-//
-// // let intersection = left_granges.filter_overlaps_(&right_granges)?;
-//
-// //// output stream -- header is None for now (TODO)
-// //let output_stream = output.map_or(OutputFile::new_stdout(None), |file| {
-// // OutputFile::new(file, None)
-// //});
-// //let mut writer = output_stream.writer()?;
-//
-// // for reporting stuff to the user
-// let mut report = Report::new();
-//
-// //intersection.sort().to_tsv(output)?;
-//
-// Ok(CommandOutput::new((), report))
-// }
+
+/// Retain only the ranges that have at least one overlap with another set of ranges.
+pub fn granges_filter(
+ seqlens: &PathBuf,
+ left_path: &PathBuf,
+ right_path: &PathBuf,
+ output: Option<&PathBuf>,
+ sort: bool,
+) -> Result<CommandOutput<()>, GRangesError> {
+ let genome = read_seqlens(seqlens)?;
+
+ let left_iter = GenomicRangesFile::parsing_iterator(left_path)?;
+ let right_iter = GenomicRangesFile::parsing_iterator(right_path)?;
+
+ let output_stream = output.as_ref().map_or(OutputFile::new_stdout(None), |file| {
+ OutputFile::new(file, None)
+ });
+ let mut writer = output_stream.writer()?;
+
+ // for reporting stuff to the user
+ let mut report = Report::new();
+
+ match (left_iter, right_iter) {
+ (GenomicRangesParser::Bed3(left), GenomicRangesParser::Bed3(right)) => {
+
+ let left_gr = GRangesEmpty::from_iter(left, &genome)?; let right_gr =
+ GRangesEmpty::from_iter(right, &genome)?;
+
+ let right_gr = right_gr.to_coitrees()?;
+
+ let intersection = left_gr.filter_overlaps(&right_gr)?;
+ intersection.to_tsv(output)?;
+
+ Ok(CommandOutput::new((), report))
+ }
+ (GenomicRangesParser::Bed3(left), GenomicRangesParser::Bedlike(right)) => {
+ Ok(CommandOutput::new((), report))
+ }
+ (GenomicRangesParser::Bedlike(left), GenomicRangesParser::Bed3(right)) => {
+ Ok(CommandOutput::new((), report))
+ }
+ (GenomicRangesParser::Bedlike(left), GenomicRangesParser::Bedlike(right)) => {
+ Ok(CommandOutput::new((), report))
+ }
+ _ => Ok(CommandOutput::new((), report)),
+ }
+}
 
 /// Generate a random BED-like file with genomic ranges.
 pub fn granges_random_bed(

src/io/mod.rs

@@ -6,4 +6,4 @@ pub mod noodles;
 pub mod parsers;
 
 pub use file::{InputFile, OutputFile};
-pub use parsers::{Bed3Iterator, BedlikeIterator, GenomicRangesFile, GenomicRangesParsers, TsvRecordIterator};
+pub use parsers::{Bed3Iterator, BedlikeIterator, GenomicRangesFile, GenomicRangesParser, TsvRecordIterator};

src/io/parsers.rs

@@ -145,7 +145,7 @@ fn valid_bedlike(input_file: &mut InputFile) -> Result<bool, GRangesError> {
 
 /// Enum that connects a genomic ranges file type to its specific parser.
 #[derive(Debug)]
-pub enum GenomicRangesParsers {
+pub enum GenomicRangesParser {
  Bed3(Bed3Iterator),
  Bedlike(BedlikeIterator),
  Unsupported,
@@ -215,14 +215,14 @@ impl GenomicRangesFile {
  /// 
  /// This returns a [`GenomicRangesParsers`] enum, since the parsing iterator filetype 
  /// cannot be known at compile time.
- pub fn parsing_iterator(filepath: impl Clone + Into<PathBuf>) -> Result<GenomicRangesParsers, GRangesError> {
+ pub fn parsing_iterator(filepath: impl Clone + Into<PathBuf>) -> Result<GenomicRangesParser, GRangesError> {
  let path = filepath.into();
  dbg!(&path);
  match Self::detect(path)? {
  GenomicRangesFile::Bed3(path) =>
- Ok(GenomicRangesParsers::Bed3(Bed3Iterator::new(path)?)),
+ Ok(GenomicRangesParser::Bed3(Bed3Iterator::new(path)?)),
  GenomicRangesFile::Bedlike(path) => 
- Ok(GenomicRangesParsers::Bedlike(BedlikeIterator::new(path)?)),
+ Ok(GenomicRangesParser::Bedlike(BedlikeIterator::new(path)?)),
  GenomicRangesFile::Unsupported => {
  Err(GRangesError::UnsupportedGenomicRangesFileFormat)
  }

src/lib.rs

@@ -26,7 +26,7 @@ pub mod prelude {
  pub use crate::error::GRangesError;
  pub use crate::granges::{GRanges, GRangesEmpty};
  pub use crate::io::file::read_seqlens;
- pub use crate::io::{Bed3Iterator, BedlikeIterator, GenomicRangesFile, TsvRecordIterator, GenomicRangesParsers};
+ pub use crate::io::{Bed3Iterator, BedlikeIterator, GenomicRangesFile, TsvRecordIterator, GenomicRangesParser};
 
  pub use crate::ranges::vec::{VecRangesEmpty, VecRangesIndexed};
  pub use crate::traits::{

src/main/mod.rs

@@ -2,7 +2,7 @@ use std::path::PathBuf;
 
 use clap::{Args, Parser, Subcommand};
 use granges::{
- commands::{granges_adjust},
+ commands::{granges_adjust, granges_filter},
  io::{parsers::Bed3Iterator, OutputFile},
  prelude::{read_seqlens, GRanges, GRangesError, GenomicRangesFile},
  reporting::{Report, CommandOutput},
@@ -115,47 +115,7 @@ fn run() -> Result<(), GRangesError> {
  output,
  sort,
  }) => {
- let genome = read_seqlens(seqlens)?;
- let mut report = Report::new();
-
- let left_filetype = GenomicRangesFile::detect(left)?;
- let right_filetype = GenomicRangesFile::detect(right)?;
-
- match (left_filetype, right_filetype) {
- (GenomicRangesFile::Bed3(left_file), GenomicRangesFile::Bed3(right_file)) => {
- let left_iter = Bed3Iterator::new(left_file)?;
- let right_iter = Bed3Iterator::new(right_file)?;
-
- let left_gr = GRangesEmpty::from_iter(left_iter, &genome)?; let right_gr =
- GRangesEmpty::from_iter(right_iter, &genome)?;
-
- let right_gr = right_gr.to_coitrees()?;
-
- let intersection = left_gr.filter_overlaps(&right_gr);
- right_gr.len();
-
- let output_stream = output.as_ref().map_or(OutputFile::new_stdout(None), |file| {
- OutputFile::new(file, None)
- });
- let mut writer = output_stream.writer()?;
-
- // for reporting stuff to the user
- let mut report = Report::new();
-
- Ok(CommandOutput::new((), report))
- }
- (GenomicRangesFile::Bed3(left_file), GenomicRangesFile::Bedlike(right_file)) => {
- Ok(CommandOutput::new((), report))
- }
- (GenomicRangesFile::Bedlike(left_file), GenomicRangesFile::Bed3(right_file)) => {
- Ok(CommandOutput::new((), report))
- }
- (GenomicRangesFile::Bedlike(left_file), GenomicRangesFile::Bedlike(right_file)) => {
- Ok(CommandOutput::new((), report))
- }
- _ => Ok(CommandOutput::new((), report)),
- }
- // granges_filter(left, right, output.as_ref(), *sort)
+ granges_filter(seqlens, left, right, output.as_ref(), *sort)
  }
  #[cfg(feature = "dev-commands")]
  Some(Commands::RandomBed {