0.11.0
- Add podcast search support. Podcast index is a work in progress, but I'm working on it.

version = "0.10.3"

version = "0.11.0"

toml = "0.4"

toml = "0.4"
percent-encoding = "1"

use crate::utils::*;

use crate::utils;

    let path = get_xml_dir()?;
    create_dir_if_not_exist(&path)?;

    let path = utils::get_xml_dir()?;
    utils::create_dir_if_not_exist(&path)?;

    let mut path: PathBuf = get_podcast_dir()?;

    let mut path: PathBuf = utils::get_podcast_dir()?;

    create_dir_if_not_exist(&path)?;

    utils::create_dir_if_not_exist(&path)?;

        titles.insert(trim_extension(

        titles.insert(utils::trim_extension(

    let mut podcast_rss_path = get_xml_dir()?;
    podcast_rss_path.push(podcast.title());
    podcast_rss_path.set_extension("xml");

    let mut podcast_rss_path = utils::get_xml_dir()?;
    let title = utils::append_extension(podcast.title(), "xml");
    podcast_rss_path.push(title);

        .expect(&format!("Cargo.toml didn't have a version {:?}", config));

        .unwrap_or_else(|| panic!("Cargo.toml didn't have a version {:?}", config));

        return delete_all();

        return utils::delete_all();

            delete(&title)?;

            utils::delete(&title)?;

use std::io;
use std::io::Write;

use crate::search;

pub fn subscribe(state: &mut State, config: &Config, matches: &ArgMatches) -> Result<()> {

pub fn subscribe(state: &mut State, config: Config, matches: &ArgMatches) -> Result<()> {

    sub(state, config, url)?;
    Ok(())
}
fn sub(state: &mut State, config: Config, url: &str) -> Result<()> {

    download::download_rss(&config, url)?;

    download::download_rss(config, url)?;

        }
    }
    Ok(())
}
pub fn search(state: &mut State, config: Config, matches: &ArgMatches) -> Result<()> {
    let matches = matches.subcommand_matches("search").unwrap();
    let podcast = matches.value_of("PODCAST").unwrap();
    let resp = search::search_for_podcast(podcast)?;
    if resp.found().is_empty() {
        println!("No Results");
        return Ok(());
    }
    {
        let stdout = io::stdout();
        let mut lock = stdout.lock();
        for (i, r) in resp.found().iter().enumerate() {
            writeln!(&mut lock, "({}) {}", i, r)?;

    }
    print!("Would you like to subscribe to any of these? (y/n): ");
    io::stdout().flush().ok();
    let mut input = String::new();
    io::stdin().read_line(&mut input)?;
    if input.to_lowercase().trim() != "y" {
        return Ok(());
    }
    print!("Which one? (#): ");
    io::stdout().flush().ok();
    let mut num_input = String::new();
    io::stdin().read_line(&mut num_input)?;
    let n: usize = num_input.trim().parse()?;
    if n > resp.found().len() {
        eprintln!("Invalid!");
        return Ok(());

    let rss_resp = search::retrieve_rss(&resp.found()[n])?;
    if let Some(err) = rss_resp.error() {
        eprintln!("{}", err);
        return Ok(());
    }
    match rss_resp.url() {
        Some(r) => sub(state, config, r)?,
        None => eprintln!("Subscription failed. No url in API response."),
    }
    

    config: &Config,

    config: Config,

            println!("This feature is coming soon...");

            arg_parser::search(state, config, matches)?;

use crate::utils::*;

use crate::utils;

use failure::Fail;

use failure::Fail;

    AlreadyExists {
        path: String,
    }

    AlreadyExists { path: String },

    let mut path = get_podcast_dir()?;

    let mut path = utils::get_podcast_dir()?;

    create_dir_if_not_exist(&path)?;

    utils::create_dir_if_not_exist(&path)?;

        episode.extension().map(|ext|  {
            if !title.ends_with(".") {
                title.push_str(".");
            }
            title.push_str(&ext);
        });   

        if let Some(ext) = episode.extension() {
            title = utils::append_extension(&title, &ext);
        }

            return Err(DownloadError::AlreadyExists{path: path.to_str().unwrap().to_string()}.into());

            return Err(DownloadError::AlreadyExists {
                path: path.to_str().unwrap().to_string(),
            }
            .into());

            let mut path = get_podcast_dir()?;

            let mut path = utils::get_podcast_dir()?;

            already_downloaded(podcast.title()).map(|downloaded| {

            utils::already_downloaded(podcast.title()).map(|downloaded| {

pub fn download_rss(config: &Config, url: &str) -> Result<(), Error> {
    let channel = download_rss_feed(url)?;

pub fn download_rss(config: Config, url: &str) -> Result<(), Error> {
    let channel = utils::download_rss_feed(url)?;

extern crate percent_encoding;

mod search;

const VERSION: &str = "0.10.3";

const VERSION: &str = "0.11.0";

    command_handler::handle_matches(&VERSION, &mut state, &config, &mut app, &matches)?;

    command_handler::handle_matches(&VERSION, &mut state, config, &mut app, &matches)?;

                )
                .arg(
                    Arg::with_name("PODCAST")
                        .help("Regex for subscribed podcast")
                        .required(true)
                        .index(1),
                )
                .arg(
                    Arg::with_name("EPISODE")
                        .help("Episode index")
                        .required(false)
                        .index(2),

    if name.contains(".") {

    if name.contains('.') {

    let s: Vec<String> = input.split(".").map(|s| s.to_string()).collect();

    let s: Vec<String> = input.split('.').map(|s| s.to_string()).collect();

pub fn append_extension(filename: &str, ext: &str) -> String {
    let mut f = filename.to_string();
    if !f.ends_with('.') {
        f.push_str(".");
    }
    f.push_str(ext);
    f
}