0.8.2
- Add completion generation for all major shells

toml = "0.4"

toml = "0.4"

use clap::App;
use clap::Shell;

    if 0 < download_limit  {

    if 0 < download_limit {

        if episodes.len() < download_limit
        {

        if episodes.len() < download_limit {

            if let Some(title) = episode.title() {
                let mut filename = title;
                filename.push_str(
                    episode.extension()
                        .chain_err(|| "unable to retrieve extension")?,
                );
                path.push(filename);
                if !path.exists() {
                    {
                        let mut handle = stdout.lock();
                        writeln!(&mut handle, "Downloading: {:?}", &path).ok();
                    }
                    let mut file = File::create(&path).chain_err(|| UNABLE_TO_CREATE_FILE)?;
                    let mut resp = reqwest::get(url).chain_err(|| UNABLE_TO_GET_HTTP_RESPONSE)?;
                    let mut content: Vec<u8> = Vec::new();
                    resp.read_to_end(&mut content)
                        .chain_err(|| UNABLE_TO_READ_RESPONSE_TO_END)?;
                    file.write_all(&content)
                        .chain_err(|| UNABLE_TO_WRITE_FILE)?;
                } else {

        if let Some(title) = episode.title() {
            let mut filename = title;
            filename.push_str(
                episode
                    .extension()
                    .chain_err(|| "unable to retrieve extension")?,
            );
            path.push(filename);
            if !path.exists() {
                {

                    writeln!(
                        &mut handle,
                        "File already exists: {:?}",
                        &path
                    )
                    .ok();

                    writeln!(&mut handle, "Downloading: {:?}", &path).ok();

                let mut file = File::create(&path).chain_err(|| UNABLE_TO_CREATE_FILE)?;
                let mut resp = reqwest::get(url).chain_err(|| UNABLE_TO_GET_HTTP_RESPONSE)?;
                let mut content: Vec<u8> = Vec::new();
                resp.read_to_end(&mut content)
                    .chain_err(|| UNABLE_TO_READ_RESPONSE_TO_END)?;
                file.write_all(&content)
                    .chain_err(|| UNABLE_TO_WRITE_FILE)?;
            } else {
                let mut handle = stdout.lock();
                writeln!(&mut handle, "File already exists: {:?}", &path).ok();

    }

                    download(podcast.title(), ep)
                        .chain_err(|| "unable to download episode")?;

                    download(podcast.title(), ep).chain_err(|| "unable to download episode")?;

}
pub fn print_completion(arg: &str) {
    let zsh = r#"#compdef podcast
#autoload
# Copyright (C) 2019:
#    Nathan Jaremko <njaremko@gmail.com>
# All Rights Reserved.
# This file is licensed under the GPLv2+. Please see COPYING for more information.
_podcast() {
    local ret=1
    _arguments -C \
        '1: :_podcast_cmds' \
        && ret=0
}
_podcast_cmds () {
    local subcommands;
    subcommands=(
    "download:Download episodes of podcast"
    "help:Prints this message or the help of the given subcommand(s)"
    "ls:List podcasts or episodes of a podcast"
    "play:Play episodes of a podcast"
    "refresh:Refreshes subscribed podcasts"
    "rm:Unsubscribe from a podcast"
    "completion:Shell Completions"
    "search:Searches for podcasts"
    "subscribe:Subscribe to a podcast RSS feed"
    "update:check for updates"
    )
    _describe -t commands 'podcast' subcommands
    _arguments : \
        "--version[Output version information]" \
        "--help[Output help message]"

_podcast"#;
    //let bash = "";
    //let sh = "";

pub fn print_completion(app: &mut App, arg: &str) {

        "zsh" => println!("{}", zsh),
        //"bash" => println!("{}", bash),
        //"sh" => println!("{}", sh),
        _ => println!("Only options avaliable are: zsh"),

        "zsh" => app.gen_completions_to("podcast", Shell::Zsh, &mut io::stdout()),
        "bash" => app.gen_completions_to("podcast", Shell::Bash, &mut io::stdout()),
        "powershell" => app.gen_completions_to("podcast", Shell::PowerShell, &mut io::stdout()),
        "fish" => app.gen_completions_to("podcast", Shell::Fish, &mut io::stdout()),
        "elvish" => app.gen_completions_to("podcast", Shell::Elvish, &mut io::stdout()),
        other => eprintln!("Completions are not available for {}", other),

const VERSION: &str = "0.8.1";

const VERSION: &str = "0.8.2";

    let matches = parser::get_matches(&VERSION);
    match_handler::handle_matches(&VERSION, &mut state, &config, &matches)?;

    let mut app = parser::get_app(&VERSION);
    let matches = app.clone().get_matches();
    match_handler::handle_matches(&VERSION, &mut state, &config, &mut app, &matches)?;

use clap::ArgMatches;

use clap::{App, ArgMatches};
use std::env;
use std::path::Path;

    app: &mut App,

                Some(shell) => print_completion(shell),
                None => print_completion(""),

                Some(shell) => print_completion(app, shell),
                None => {
                    let shell_path_env = env::var("SHELL");
                    if let Ok(p) = shell_path_env {
                        let shell_path = Path::new(&p);
                        if let Some(shell) = shell_path.file_name() {
                            print_completion(app, shell.to_str().chain_err(|| format!("Unable to convert {:?} to string", shell))?)
                        }
                    }
                }

use clap::{App, Arg, ArgMatches, SubCommand};

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

pub fn get_matches<'a>(version: &str) -> ArgMatches<'a> {

pub fn get_app<'a, 'b>(version: &'a str) -> App<'a, 'b> {

        .get_matches()

            if 86400 < Utc::now()
                .signed_duration_since(state.last_run_time)
                .num_seconds()

            if 86400
                < Utc::now()
                    .signed_duration_since(state.last_run_time)
                    .num_seconds()

        Ok(())

    Ok(())

        let mut path = get_xml_dir()?;
        let mut filename = String::from(title);
        filename.push_str(".xml");
        path.push(filename);
        fs::remove_file(path).chain_err(|| UNABLE_TO_REMOVE_FILE)
    }

    let mut path = get_xml_dir()?;
    let mut filename = String::from(title);
    filename.push_str(".xml");
    path.push(filename);
    fs::remove_file(path).chain_err(|| UNABLE_TO_REMOVE_FILE)
}

    pub fn delete_all() -> Result<()> {
        fs::remove_dir_all(get_xml_dir()?).chain_err(|| UNABLE_TO_READ_DIRECTORY)
    }

pub fn delete_all() -> Result<()> {
    fs::remove_dir_all(get_xml_dir()?).chain_err(|| UNABLE_TO_READ_DIRECTORY)
}