version = "0.2.0"

version = "0.2.1"

    let input = String::from(e_search);
    let range: Vec<usize> = input
        .split('-')
        .map(|i| i.parse::<usize>().unwrap())
        .collect();

            let episodes = podcast.episodes();
            &episodes[episodes.len() - range[1]..episodes.len() - range[0]]
                .par_iter()
                .for_each(|ref ep| if let Err(err) = ep.download(podcast.title()) {
                    println!("{}", err);
                });

            let episodes_to_download = parse_download_episodes(e_search);
            podcast.download_specific(episodes_to_download);

                    if String::from(ep).contains("-") {

                    if String::from(ep).contains(|c| c == '-' || c == ',') {

                        println!("{}", err);
                    }
                }
            },
        );
    }
    pub fn download_specific(&self, episode_numbers: Vec<usize>) {
        let mut path = get_podcast_dir();
        path.push(self.title());
        let downloaded = already_downloaded(self.title());
        let episodes = self.episodes();
        episode_numbers.par_iter().for_each(
            |ep_num| if let Some(ep_title) =
                episodes[episodes.len() - ep_num].title()
            {
                if !downloaded.contains(ep_title) {
                    if let Err(err) = episodes[episodes.len() - ep_num].download(self.title()) {

                        result.insert(String::from(val.trim_right_matches(".mp3")));

                        // TODO There has to be a better way to do this...later
                        result.insert(String::from(
                            val.trim_right_matches(".mp3")
                                .trim_right_matches(".m4a")
                                .trim_right_matches(".ogg"),
                        ));

                    Err(err) => {
                        println!("OsString: {:?} couldn't be converted to String", err);

                    Err(_) => {
                        println!(
                            "OsString: {:?} couldn't be converted to String",
                            entry.file_name()
                        );

pub fn parse_download_episodes(e_search: &str) -> Vec<usize> {
    let input = String::from(e_search);
    let mut ranges = Vec::<(usize, usize)>::new();
    let mut elements = Vec::<usize>::new();
    let comma_separated: Vec<&str> = input.split(',').collect();
    for elem in comma_separated {
        let temp = String::from(elem);
        if temp.contains("-") {
            let range: Vec<usize> = elem.split('-')
                .map(|i| i.parse::<usize>().unwrap())
                .collect();
            ranges.push((range[0], range[1]));
        } else {
            elements.push(elem.parse::<usize>().unwrap());
        }
    }
    for range in ranges {
        // Add 1 to upper range to include given episode in the download
        for num in range.0..range.1 + 1 {
            elements.push(num);
        }
    }
    elements.dedup();
    elements
}