0.4.4
- Add ability to play latest episode by omitting episode number
- Fix update check working correctly
- Fix download still being case-sensitive

- Update all dependencies to their latest respective versions

- Add ability to print zsh shell completion
- Add ability to unsubscribe from podcasts

- Add ability to unsubscribe from podcasts
- Add ability to print zsh shell completion

- Update all dependencies to their latest respective versions
- rename list -> ls 

- rename list -> ls 

version = "0.4.3"

version = "0.4.4"

use structs::*;
use utils::*;
use std::collections::HashSet;
use std::fs::{self, DirBuilder, File};
use std::io::{self, BufReader, Read, Write};
use std::process::Command;

use std::collections::HashSet;
use std::fs::{self, DirBuilder, File};
use std::io::{self, BufReader, Read, Write};
use std::process::Command;
use structs::*;
use utils::*;

    let re_pod = Regex::new(p_search).unwrap();

    let re_pod = Regex::new(&format!("(?i){}", &p_search)).expect("Failed to parse regex");

            }
        }
    }
}
pub fn play_latest(state: &State, p_search: &str) {
    let re_pod = Regex::new(&format!("(?i){}", &p_search)).expect("Failed to parse regex");
    let mut path = get_xml_dir();
    if let Err(err) = DirBuilder::new().recursive(true).create(&path) {
        eprintln!(
            "Couldn't create directory: {}\nReason: {}",
            path.to_str().unwrap(),
            err
        );
        return;
    }
    for subscription in &state.subscriptions {
        if re_pod.is_match(&subscription.title) {
            let mut filename = subscription.title.clone();
            filename.push_str(".xml");
            path.push(filename);
            let mut file = File::open(&path).unwrap();
            let mut content: Vec<u8> = Vec::new();
            file.read_to_end(&mut content).unwrap();
            let podcast = Podcast::from(Channel::read_from(content.as_slice()).unwrap());
            let episodes = podcast.episodes();
            let episode = episodes[0].clone();
            filename = String::from(episode.title().unwrap());
            filename.push_str(episode.extension().unwrap());
            path = get_podcast_dir();
            path.push(podcast.title());
            path.push(filename);
            if path.exists() {
                launch_player(path.to_str().unwrap());
            } else {
                launch_player(episode.url().unwrap());

            return;

                println!("New version avaliable: {}", latest);

                println!("New version avaliable: {} -> {}", version, latest);

use clap::{App, Arg, SubCommand};
use structs::*;

use structs::*;

const VERSION: &str = "0.4.3";

use clap::{App, Arg, SubCommand};
const VERSION: &str = "0.4.4";

                        .required(true)

                        .required(false)

            let episode = play_matches.value_of("EPISODE").unwrap();
            play_episode(&state, podcast, episode);

            match play_matches.value_of("EPISODE") {
                Some(episode) => play_episode(&state, podcast, episode),
                None => play_latest(&state, podcast),
            }

use utils::*;
use std::collections::BTreeSet;
use std::fs::{self, remove_dir_all, remove_file, DirBuilder, File};
use std::io::{self, BufReader, Read, Write};

use std::collections::BTreeSet;
use std::fs::{self, remove_dir_all, remove_file, DirBuilder, File};
use std::io::{self, BufReader, Read, Write};
use utils::*;

                        }, 

                        },

            state.version = String::from(version);

            if let Err(err) = state.save() {
                eprintln!("{}", err);
            }

                println!("Downloading: {}", path.to_str().unwrap());
                let mut file = File::create(&path)?;
                let mut resp = reqwest::get(url).unwrap();
                let mut content: Vec<u8> = Vec::new();
                resp.read_to_end(&mut content)?;
                file.write_all(&content)?;
                return Ok(());

                if !path.exists() {
                    println!("Downloading: {}", path.to_str().unwrap());
                    let mut file = File::create(&path)?;
                    let mut resp = reqwest::get(url).unwrap();
                    let mut content: Vec<u8> = Vec::new();
                    resp.read_to_end(&mut content)?;
                    file.write_all(&content)?;
                    return Ok(());
                } else {
                    println!("File already exists: {}", path.to_str().unwrap());
                    return Ok(());
                }

use std::num::ParseIntError;
use std::path::PathBuf;

use std::num::ParseIntError;
use std::path::PathBuf;