njaremko/podcast - Change 3YR56Y65UIAL3J7PUXWVJMOOHYZYDIX4V54OT2TJPZ25WQ6MXHCQC

Improve error handling

Created by Nathan Jaremko on May 13, 2018

3YR56Y65UIAL3J7PUXWVJMOOHYZYDIX4V54OT2TJPZ25WQ6MXHCQC

Dependencies

In channels

main

Change contents

Insertion in CHANGELOG at line 1 [4.1]

[4.1]

[5.1]

0.5.4
- Improve error handling throughout the application (using error-chain)

Replacement in Cargo.toml at line 3 [6.62]
B:BD[6.90] → [3.1:19]
```
version = "0.5.3"
```
[6.90]
[7.1199]
```
version = "0.5.4"
```
Insertion in Cargo.toml at line 23 [6.62]
[8.15]
[8.15]
```
error-chain = "0.11"
```
Insertion in src/actions.rs at line 9 [11.163]
[9.520]
[10.2]
```
use errors::*;
```
Insertion in src/actions.rs at line 14 [11.163]
[12.33]
[8.184]
```
use std::path::PathBuf;
```
Replacement in src/actions.rs at line 17 [11.163]
B:BD[11.199] → [13.43:80]
```
pub fn list_episodes(search: &str) {
```
[11.199]
[14.22]
```
pub fn list_episodes(search: &str) -> Result<()> {
```

Replacement in src/actions.rs at line 21 [11.163]

∅:D[14.90] → [15.998:1084]

B:BD[13.80] → [15.998:1084]

∅:D[15.1084] → [13.81:119]

B:BD[16.96] → [13.81:119]

    let re = Regex::new(&format!("(?i){}", &search)).expect("Failed to parse regex");
    let mut path = get_podcast_dir();

[14.90]

[13.119]

    let re = Regex::new(&format!("(?i){}", &search)).chain_err(|| UNABLE_TO_PARSE_REGEX)?;
    let mut path = get_podcast_dir()?;

Replacement in src/actions.rs at line 24 [11.163]

B:BD[13.142] → [13.142:288]

    DirBuilder::new().recursive(true).create(&path).unwrap();
    for entry in fs::read_dir(&path).unwrap() {
        let entry = entry.unwrap();

[13.142]

[13.288]

    DirBuilder::new()
        .recursive(true)
        .create(&path)
        .chain_err(|| UNABLE_TO_CREATE_DIRECTORY)?;
    for entry in fs::read_dir(&path).chain_err(|| UNABLE_TO_READ_DIRECTORY)? {
        let entry = entry.chain_err(|| UNABLE_TO_READ_ENTRY)?;

Replacement in src/actions.rs at line 31 [11.163]

B:BD[13.356] → [13.356:492]

            let file = File::open(&entry.path()).unwrap();
            let channel = Channel::read_from(BufReader::new(file)).unwrap();

[13.356]

[13.492]

            let file = File::open(&entry.path()).chain_err(|| UNABLE_TO_OPEN_FILE)?;
            let channel = Channel::read_from(BufReader::new(file))
                .chain_err(|| UNABLE_TO_CREATE_CHANNEL_FROM_FILE)?;

Replacement in src/actions.rs at line 41 [11.163]

B:BD[14.223] → [14.223:263]

B:BD[14.263] → [3.22:49]

                    ep.title().unwrap()
                ).is_ok();

[14.223]

[11.712]

                    ep.title().chain_err(|| "unable to retrieve episode title")?
                ).chain_err(|| "unable to write to stdout")?

Replacement in src/actions.rs at line 44 [11.163]
B:BD[11.726] → [13.727:747]
```
            return;
```
[11.726]
[11.727]
```
            return Ok(());
```
Insertion in src/actions.rs at line 47 [11.163]
[11.743]
[11.743]
```
    Ok(())
```
Replacement in src/actions.rs at line 50 [11.163]
B:BD[11.746] → [17.2:36]
```
pub fn subscribe_rss(url: &str) {
```
[11.746]
[18.259]
```
pub fn subscribe_rss(url: &str) -> Result<Channel> {
```

Replacement in src/actions.rs at line 52 [11.163]

B:BD[18.300] → [17.37:127]

    if let Err(err) = download_rss_feed(url) {
        eprintln!("Error: {}", err);
    }

[18.300]

[17.127]

    download_rss_feed(url)

Replacement in src/actions.rs at line 55 [11.163]

B:BD[19.149] → [17.130:180]

pub fn download_rss(config: &Config, url: &str) {

[19.149]

[17.180]

pub fn download_rss(config: &Config, url: &str) -> Result<()> {

Replacement in src/actions.rs at line 57 [11.163]

B:BD[17.223] → [17.223:494]

B:BD[17.494] → [2.2:72]

∅:D[2.72] → [17.569:765]

B:BD[17.569] → [17.569:765]

    match download_rss_feed(url) {
        Ok(channel) => {
            let download_limit = config.auto_download_limit as usize;
            if download_limit > 0 {
                let podcast = Podcast::from(channel);
                let episodes = podcast.episodes();
                episodes[..download_limit].par_iter().for_each(|ep| {
                    if let Err(err) = ep.download(podcast.title()) {
                        eprintln!("Error downloading {}: {}", podcast.title(), err);
                    }
                });

[17.223]

[19.533]

    let channel = download_rss_feed(url)?;
    let download_limit = config.auto_download_limit as usize;
    if download_limit > 0 {
        let podcast = Podcast::from(channel);
        let episodes = podcast.episodes();
        episodes[..download_limit].par_iter().for_each(|ep| {
            if let Err(err) = ep.download(podcast.title()) {
                eprintln!("Error downloading {}: {}", podcast.title(), err);

Replacement in src/actions.rs at line 66 [11.163]
B:BD[19.547] → [17.766:825]
```
        }
        Err(err) => eprintln!("Error: {}", err),
```
[19.547]
[19.559]
```
        });
```
Insertion in src/actions.rs at line 68 [11.163]
[19.565]
[18.833]
```
    Ok(())
```

Replacement in src/actions.rs at line 71 [11.163]

B:BD[18.836] → [19.566:651]

B:BD[19.651] → [2.73:129]

∅:D[20.79] → [21.190:232]

∅:D[2.129] → [21.190:232]

∅:D[22.239] → [21.190:232]

∅:D[23.241] → [21.190:232]

∅:D[19.702] → [21.190:232]

∅:D[15.1133] → [21.190:232]

B:BD[21.190] → [21.190:232]

B:BD[21.232] → [22.240:271]

∅:D[22.271] → [21.259:325]

∅:D[19.735] → [21.259:325]

B:BD[21.259] → [21.259:325]

pub fn update_rss(state: &mut State) {
    println!("Checking for new episodes...");
    state.subscriptions.par_iter_mut().for_each(|sub| {
        let mut path = get_podcast_dir();
        path.push(&sub.title);
        DirBuilder::new().recursive(true).create(&path).unwrap();

[18.836]

[19.736]

pub fn update_subscription(sub: &mut Subscription) -> Result<()> {
    let mut path: PathBuf = get_podcast_dir()?;
    path.push(&sub.title);
    DirBuilder::new()
        .recursive(true)
        .create(&path)
        .chain_err(|| UNABLE_TO_CREATE_DIRECTORY)?;
    let mut titles = HashSet::new();
    for entry in fs::read_dir(&path).chain_err(|| UNABLE_TO_READ_DIRECTORY)? {
        let unwrapped_entry = &entry.chain_err(|| UNABLE_TO_READ_ENTRY)?;
        titles.insert(trim_extension(&unwrapped_entry
            .file_name()
            .into_string()
            .unwrap()));
    }

Replacement in src/actions.rs at line 88 [11.163]

B:BD[19.737] → [19.737:966]

        let mut titles = HashSet::new();
        for entry in fs::read_dir(&path).unwrap() {
            let entry = entry.unwrap();
            titles.insert(trim_extension(&entry.file_name().into_string().unwrap()));
        }

[19.737]

[19.966]

    let mut resp = reqwest::get(&sub.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)?;
    let podcast = Podcast::from(Channel::read_from(BufReader::new(&content[..]))
        .chain_err(|| UNABLE_TO_CREATE_CHANNEL_FROM_RESPONSE)?);
    path = get_podcast_dir()?;
    path.push(".rss");

Replacement in src/actions.rs at line 97 [11.163]

B:BD[19.967] → [22.272:328]

∅:D[22.328] → [18.895:991]

B:BD[18.895] → [18.895:991]

B:BD[18.991] → [19.968:1125]

        let mut resp = reqwest::get(&sub.url).unwrap();
        let mut content: Vec<u8> = Vec::new();
        resp.read_to_end(&mut content).unwrap();
        let podcast = Podcast::from(Channel::read_from(BufReader::new(&content[..])).unwrap());
        path = get_podcast_dir();
        path.push(".rss");

[19.967]

[19.1125]

    let mut filename = String::from(podcast.title());
    filename.push_str(".xml");
    path.push(&filename);
    let mut file = File::create(&path).unwrap();
    file.write_all(&content).unwrap();

Replacement in src/actions.rs at line 103 [11.163]

B:BD[19.1126] → [19.1126:1184]

∅:D[19.1184] → [21.443:478]

B:BD[21.443] → [21.443:478]

B:BD[21.478] → [19.1185:1215]

∅:D[19.1215] → [21.507:560]

B:BD[21.507] → [21.507:560]

B:BD[21.712] → [21.712:755]

        let mut filename = String::from(podcast.title());
        filename.push_str(".xml");
        path.push(&filename);
        let mut file = File::create(&path).unwrap();
        file.write_all(&content).unwrap();

[19.1126]

[19.1216]

    if podcast.episodes().len() > sub.num_episodes {
        podcast.episodes()[..podcast.episodes().len() - sub.num_episodes]
            .par_iter()
            .for_each(|ep: &Episode| {
                if let Err(err) = ep.download(podcast.title()) {
                    eprintln!("Error downloading {}: {}", podcast.title(), err);
                }
            });
    }
    sub.num_episodes = podcast.episodes().len();
    Ok(())
}

Replacement in src/actions.rs at line 116 [11.163]

B:BD[19.1217] → [19.1217:1274]

B:BD[19.1274] → [2.130:208]

∅:D[2.208] → [19.1353:1381]

B:BD[19.1353] → [19.1353:1381]

B:BD[19.1381] → [2.209:242]

∅:D[2.242] → [15.1171:1347]

B:BD[15.1171] → [15.1171:1347]

∅:D[15.1347] → [19.1546:1629]

B:BD[19.1546] → [19.1546:1629]

∅:D[19.1629] → [23.242:250]

B:BD[21.755] → [23.242:250]

        if podcast.episodes().len() > sub.num_episodes {
            podcast.episodes()[..podcast.episodes().len() - sub.num_episodes]
                .par_iter()
                .for_each(|ep| {
                    if let Err(err) = ep.download(podcast.title()) {
                        eprintln!("Error downloading {}: {}", podcast.title(), err);
                    }
                });
        }
        sub.num_episodes = podcast.episodes().len();
    });

[19.1217]

[21.761]

pub fn update_rss(state: &mut State) {
    println!("Checking for new episodes...");
    let _result: Vec<Result<()>> = state
        .subscriptions
        .par_iter_mut()
        .map(|sub: &mut Subscription| update_subscription(sub))
        .collect();

Replacement in src/actions.rs at line 125 [11.163]

B:BD[21.764] → [16.133:176]

pub fn list_subscriptions(state: &State) {

[21.764]

[14.283]

pub fn list_subscriptions(state: &State) -> Result<()> {

Replacement in src/actions.rs at line 129 [11.163]

B:BD[22.373] → [3.50:111]

        write!(&mut handle, "{}\n", &podcast.title).is_ok();

[22.373]

[23.251]

        write!(&mut handle, "{}\n", &podcast.title).chain_err(|| "unable to write to stdout")?;

Insertion in src/actions.rs at line 131 [11.163]
[23.257]
[23.257]
```
    Ok(())
```

Replacement in src/actions.rs at line 134 [11.163]

B:BD[23.260] → [23.260:331]

B:BD[23.331] → [8.195:287]

pub fn download_range(state: &State, p_search: &str, e_search: &str) {
    let re_pod = Regex::new(&format!("(?i){}", &p_search)).expect("Failed to parse regex");

[23.260]

[23.539]

pub fn download_range(state: &State, p_search: &str, e_search: &str) -> Result<()> {
    let re_pod = Regex::new(&format!("(?i){}", &p_search)).chain_err(|| UNABLE_TO_PARSE_REGEX)?;

Replacement in src/actions.rs at line 139 [11.163]

B:BD[22.502] → [24.92:153]

B:BD[24.153] → [15.1442:1565]

B:BD[15.1565] → [2.243:336]

∅:D[2.336] → [15.1657:1714]

B:BD[15.1657] → [15.1657:1714]

∅:D[15.1714] → [24.489:515]

B:BD[24.489] → [24.489:515]

B:BD[24.580] → [24.580:602]

B:BD[24.602] → [15.1715:1795]

∅:D[15.1795] → [24.620:677]

B:BD[24.620] → [24.620:677]

∅:D[24.677] → [25.219:233]

B:BD[25.219] → [25.219:233]

            match Podcast::from_title(&subscription.title) {
                Ok(podcast) => match parse_download_episodes(e_search) {
                    Ok(episodes_to_download) => {
                        if let Err(err) = podcast.download_specific(&episodes_to_download) {
                            eprintln!("Error: {}", err);
                        }
                    }
                    Err(err) => eprintln!("Error: {}", err),
                },
                Err(err) => eprintln!("Error: {}", err),
            }

[22.502]

[23.1007]

            let podcast = Podcast::from_title(&subscription.title)
                .chain_err(|| UNABLE_TO_RETRIEVE_PODCAST_BY_TITLE)?;
            let episodes_to_download = parse_download_episodes(e_search)
                .chain_err(|| "unable to parse episodes to download")?;
            podcast
                .download_specific(&episodes_to_download)
                .chain_err(|| "unable to download episodes")?;

Insertion in src/actions.rs at line 148 [11.163]
[26.270]
[26.270]
```
    Ok(())
```

Replacement in src/actions.rs at line 151 [11.163]

B:BD[27.3] → [16.177:250]

B:BD[16.250] → [9.521:613]

∅:D[16.298] → [27.124:177]

∅:D[9.613] → [27.124:177]

B:BD[27.124] → [27.124:177]

pub fn download_episode(state: &State, p_search: &str, e_search: &str) {
    let re_pod = Regex::new(&format!("(?i){}", &p_search)).expect("Failed to parse regex");
    let ep_num = e_search.parse::<usize>().unwrap();

[27.3]

[26.272]

pub fn download_episode(state: &State, p_search: &str, e_search: &str) -> Result<()> {
    let re_pod = Regex::new(&format!("(?i){}", &p_search)).chain_err(|| UNABLE_TO_PARSE_REGEX)?;
    let ep_num = e_search
        .parse::<usize>()
        .chain_err(|| "unable to parse number")?;

Replacement in src/actions.rs at line 159 [11.163]

B:BD[22.664] → [24.678:1070]

∅:D[25.292] → [27.549:563]

∅:D[16.428] → [27.549:563]

∅:D[24.1070] → [27.549:563]

B:BD[27.549] → [27.549:563]

            match Podcast::from_title(&subscription.title) {
                Ok(podcast) => {
                    let episodes = podcast.episodes();
                    if let Err(err) = episodes[episodes.len() - ep_num].download(podcast.title()) {
                        eprintln!("{}", err);
                    }
                }
                Err(err) => eprintln!("Error: {}", err),
            }

[22.664]

[27.563]

            let podcast = Podcast::from_title(&subscription.title)
                .chain_err(|| UNABLE_TO_RETRIEVE_PODCAST_BY_TITLE)?;
            let episodes = podcast.episodes();
            episodes[episodes.len() - ep_num]
                .download(podcast.title())
                .chain_err(|| "unable to download episode")?;

Insertion in src/actions.rs at line 167 [11.163]
[27.579]
[27.579]
```
    Ok(())
```

Replacement in src/actions.rs at line 170 [11.163]

B:BD[27.582] → [16.429:482]

B:BD[16.482] → [15.1796:1888]

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

[27.582]

[27.683]

pub fn download_all(state: &State, p_search: &str) -> Result<()> {
    let re_pod = Regex::new(&format!("(?i){}", &p_search)).chain_err(|| UNABLE_TO_PARSE_REGEX)?;

Replacement in src/actions.rs at line 175 [11.163]

B:BD[22.826] → [24.1071:1132]

B:BD[24.1132] → [15.1889:2020]

∅:D[15.2020] → [24.1310:1367]

B:BD[24.1310] → [24.1310:1367]

B:BD[24.1367] → [9.614:628]

            match Podcast::from_title(&subscription.title) {
                Ok(podcast) => if let Err(err) = podcast.download() {
                    eprintln!("{}", err);
                },
                Err(err) => eprintln!("Error: {}", err),
            }

[22.826]

[9.628]

            let podcast = Podcast::from_title(&subscription.title)
                .chain_err(|| UNABLE_TO_RETRIEVE_PODCAST_BY_TITLE)?;
            podcast
                .download()
                .chain_err(|| "unable to download podcast")?;

Insertion in src/actions.rs at line 182 [11.163]
[9.644]
[9.644]
```
    Ok(())
```

Replacement in src/actions.rs at line 185 [11.163]

B:BD[9.647] → [9.647:1058]

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;
    }

[9.647]

[9.1058]

pub fn play_latest(state: &State, p_search: &str) -> Result<()> {
    let re_pod: Regex =
        Regex::new(&format!("(?i){}", &p_search)).chain_err(|| UNABLE_TO_PARSE_REGEX)?;
    let mut path: PathBuf = get_xml_dir()?;
    DirBuilder::new()
        .recursive(true)
        .create(&path)
        .chain_err(|| UNABLE_TO_CREATE_DIRECTORY)?;

Replacement in src/actions.rs at line 195 [11.163]

B:BD[9.1155] → [9.1155:1214]

            let mut filename = subscription.title.clone();

[9.1155]

[9.1214]

            let mut filename: String = subscription.title.clone();

Replacement in src/actions.rs at line 199 [11.163]

B:BD[9.1287] → [9.1287:1342]

            let mut file = File::open(&path).unwrap();

[9.1287]

[9.1342]

            let mut file: File = File::open(&path).chain_err(|| UNABLE_TO_OPEN_FILE)?;

Replacement in src/actions.rs at line 201 [11.163]

B:BD[9.1393] → [9.1393:1446]

            file.read_to_end(&mut content).unwrap();

[9.1393]

[9.1446]

            file.read_to_end(&mut content)
                .chain_err(|| "unable to read file to end")?;

Replacement in src/actions.rs at line 204 [11.163]

B:BD[9.1447] → [9.1447:1537]

            let podcast = Podcast::from(Channel::read_from(content.as_slice()).unwrap());

[9.1447]

[9.1537]

            let podcast: Podcast = Podcast::from(Channel::read_from(content.as_slice())
                .chain_err(|| UNABLE_TO_CREATE_CHANNEL_FROM_FILE)?);

Replacement in src/actions.rs at line 209 [11.163]

B:BD[9.1632] → [9.1632:1794]

            filename = String::from(episode.title().unwrap());
            filename.push_str(episode.extension().unwrap());
            path = get_podcast_dir();

[9.1632]

[9.1794]

            filename = String::from(episode
                .title()
                .chain_err(|| "unable to retrieve episode name")?);
            filename.push_str(episode
                .extension()
                .chain_err(|| "unable to retrieve episode extension")?);
            path = get_podcast_dir()?;

Replacement in src/actions.rs at line 219 [11.163]

B:BD[9.1898] → [9.1898:1953]

                launch_player(path.to_str().unwrap());

[9.1898]

[9.1953]

                launch_player(path.to_str()
                    .chain_err(|| "unable to convert path to &str")?)?;

Replacement in src/actions.rs at line 222 [11.163]

B:BD[9.1974] → [9.1974:2029]

                launch_player(episode.url().unwrap());

[9.1974]

[24.1367]

                launch_player(episode
                    .url()
                    .chain_err(|| "unable to retrieve episode url")?)?;

Replacement in src/actions.rs at line 226 [11.163]
B:BD[24.1381] → [9.2030:2050]
```
            return;
```
[24.1381]
[27.886]
```
            return Ok(());
```
Insertion in src/actions.rs at line 229 [11.163]
[27.902]
[27.902]
```
    Ok(())
```

Replacement in src/actions.rs at line 232 [11.163]

B:BD[27.905] → [16.531:605]

B:BD[16.605] → [15.2021:2113]

∅:D[16.653] → [28.91:149]

∅:D[15.2113] → [28.91:149]

B:BD[26.392] → [28.91:149]

B:BD[28.149] → [24.1382:1416]

pub fn play_episode(state: &State, p_search: &str, ep_num_string: &str) {
    let re_pod = Regex::new(&format!("(?i){}", &p_search)).expect("Failed to parse regex");
    let ep_num = ep_num_string.parse::<usize>().unwrap();
    let mut path = get_xml_dir();

[27.905]

[23.1018]

pub fn play_episode(state: &State, p_search: &str, ep_num_string: &str) -> Result<()> {
    let re_pod: Regex =
        Regex::new(&format!("(?i){}", &p_search)).chain_err(|| UNABLE_TO_PARSE_REGEX)?;
    let ep_num: usize = ep_num_string.parse::<usize>().unwrap();
    let mut path: PathBuf = get_xml_dir()?;

Replacement in src/actions.rs at line 243 [11.163]
B:BD[23.1229] → [23.1229:1245]
```
        return;
```
[23.1229]
[23.1245]
```
        return Ok(());
```

Replacement in src/actions.rs at line 247 [11.163]

B:BD[22.988] → [22.988:1047]

            let mut filename = subscription.title.clone();

[22.988]

[21.977]

            let mut filename: String = subscription.title.clone();

Replacement in src/actions.rs at line 251 [11.163]

B:BD[21.1050] → [21.1050:1105]

            let mut file = File::open(&path).unwrap();

[21.1050]

[21.1105]

            let mut file: File = File::open(&path).unwrap();

Replacement in src/actions.rs at line 261 [11.163]

B:BD[29.91] → [21.1366:1404]

            path = get_podcast_dir();

[29.91]

[30.2]

            path = get_podcast_dir()?;

Replacement in src/actions.rs at line 265 [11.163]

B:BD[16.685] → [31.50:105]

                launch_player(path.to_str().unwrap());

[16.685]

[16.737]

                launch_player(path.to_str().chain_err(|| UNABLE_TO_CONVERT_TO_STR)?)?;

Replacement in src/actions.rs at line 267 [11.163]

B:BD[16.758] → [31.106:161]

                launch_player(episode.url().unwrap());

[16.758]

[28.628]

                launch_player(episode.url().chain_err(|| "unable to retrieve episode url")?)?;

Replacement in src/actions.rs at line 269 [11.163]
B:BD[28.642] → [12.219:239]
```
            return;
```
[28.642]
[26.746]
```
            return Ok(());
```
Insertion in src/actions.rs at line 272 [11.163]
[31.168]
[31.168]
```
    Ok(())
```

Replacement in src/actions.rs at line 275 [11.163]

B:BD[31.171] → [8.288:329]

pub fn check_for_update(version: &str) {

[31.171]

[15.2159]

pub fn check_for_update(version: &str) -> Result<()> {

Replacement in src/actions.rs at line 279 [11.163]
B:BD[8.447] → [8.447:462]
```
    ).unwrap()
```
[8.447]
[8.462]
```
    ).chain_err(|| UNABLE_TO_GET_HTTP_RESPONSE)?
```

Replacement in src/actions.rs at line 281 [11.163]

B:BD[8.478] → [8.478:497]

        .unwrap();

[8.478]

[8.497]

        .chain_err(|| "unable to convert response to text")?;

Replacement in src/actions.rs at line 284 [11.163]

B:BD[8.526] → [8.526:663]

B:BD[8.663] → [20.272:307]

B:BD[20.307] → [9.2051:2129]

∅:D[9.2129] → [20.308:332]

B:BD[8.762] → [20.308:332]

∅:D[20.332] → [8.792:834]

B:BD[8.792] → [8.792:834]

    match resp.parse::<toml::Value>() {
        Ok(config) => {
            let latest = config["package"]["version"].as_str().unwrap();
            if version != latest {
                println!("New version avaliable: {} -> {}", version, latest);
            }
        }
        Err(err) => eprintln!("{}", err),

[8.526]

[8.834]

    let config = resp.parse::<toml::Value>()
        .chain_err(|| "unable to parse toml")?;
    let latest = config["package"]["version"]
        .as_str()
        .chain_err(|| UNABLE_TO_CONVERT_TO_STR)?;
    if version != latest {
        println!("New version avaliable: {} -> {}", version, latest);

Insertion in src/actions.rs at line 292 [11.163]
[8.840]
[15.2200]
```
    Ok(())
```
Replacement in src/actions.rs at line 295 [11.163]
∅:D[15.2203] → [23.1252:1282]
B:BD[31.171] → [23.1252:1282]
```
fn launch_player(url: &str) {
```
[15.2203]
[2.337]
```
fn launch_player(url: &str) -> Result<()> {
```
Replacement in src/actions.rs at line 297 [11.163]
B:BD[2.371] → [2.371:395]
```
        launch_vlc(url)
```
[2.371]
[11.869]
```
        return launch_vlc(url);
```
Insertion in src/actions.rs at line 299 [11.163]
[11.875]
[26.757]
```
    Ok(())
```
Replacement in src/actions.rs at line 302 [11.163]
B:BD[26.760] → [8.841:886]
```
fn launch_mpv(url: &str) -> io::Result<()> {
```
[26.760]
[23.1283]
```
fn launch_mpv(url: &str) -> Result<()> {
```
Deletion in src/actions.rs at line 310 [11.163]
B:BD[31.550] → [31.550:583]
```
                return Err(err);
```
Replacement in src/actions.rs at line 317 [11.163]
B:BD[32.435] → [31.672:699]
```
fn launch_vlc(url: &str) {
```
[32.435]
[31.699]
```
fn launch_vlc(url: &str) -> Result<()> {
```

Replacement in src/actions.rs at line 321 [11.163]

B:BD[31.847] → [31.847:912]

                eprintln!("vlc not found in PATH\nAborting...");

[31.847]

[23.1422]

                eprintln!("Couldn't open vlc...aborting");

Insertion in src/actions.rs at line 326 [11.163]
[8.903]
[8.903]
```
    Ok(())
```

Replacement in src/actions.rs at line 329 [11.163]

B:BD[8.907] → [8.907:966]

pub fn remove_podcast(state: &mut State, p_search: &str) {

[8.906]

[8.966]

pub fn remove_podcast(state: &mut State, p_search: &str) -> Result<()> {

Replacement in src/actions.rs at line 331 [11.163]

B:BD[8.991] → [8.991:1150]

        match Podcast::delete_all() {
            Ok(_) => println!("Success"),
            Err(err) => eprintln!("Error: {}", err),
        }
        return;

[8.991]

[8.1150]

        return Podcast::delete_all();

Replacement in src/actions.rs at line 334 [11.163]

B:BD[8.1157] → [8.1157:1249]

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

[8.1157]

[8.1249]

    let re_pod = Regex::new(&format!("(?i){}", &p_search)).chain_err(|| UNABLE_TO_PARSE_REGEX)?;

Replacement in src/actions.rs at line 340 [11.163]

∅:D[20.512] → [8.1438:1618]

B:BD[8.1438] → [8.1438:1618]

            match Podcast::delete(&title) {
                Ok(_) => println!("Success"),
                Err(err) => eprintln!("Error: {}", err),
            }
            break;

[20.512]

[31.973]

            Podcast::delete(&title)?;

Insertion in src/actions.rs at line 343 [11.163]
[8.1625]
[8.1625]
```
    Ok(())
```
Insertion in src/main.rs at line 1 [6.1346]
[6.1346]
[33.115]
```
#![recursion_limit = "1024"]
```
Insertion in src/main.rs at line 5 [6.1346]
[29.112]
[23.1438]
```
#[macro_use]
extern crate error_chain;
```

Insertion in src/main.rs at line 20 [6.1346]

[11.1087]

[6.1379]

mod errors {
    // Create the Error, ErrorKind, ResultExt, and Result types
    error_chain!{}
}

Replacement in src/main.rs at line 26 [6.1346]
B:BD[29.174] → [10.108:122]
```
use utils::*;
```
[11.1104]
[9.2131]
```
use errors::*;
```
Insertion in src/main.rs at line 28 [6.1346]
[9.2147]
[8.2899]
```
use utils::*;
```
Replacement in src/main.rs at line 32 [6.1346]
B:BD[9.2183] → [3.113:144]
```
const VERSION: &str = "0.5.3";
```
[9.2183]
[6.1465]
```
const VERSION: &str = "0.5.4";
```

Replacement in src/main.rs at line 34 [6.1346]

B:BD[6.1466] → [6.1466:1478]

B:BD[6.1478] → [10.123:220]

B:BD[10.220] → [20.514:562]

∅:D[20.562] → [10.261:378]

B:BD[10.261] → [10.261:378]

∅:D[34.139] → [19.1656:1688]

∅:D[10.378] → [19.1656:1688]

B:BD[11.1174] → [19.1656:1688]

fn main() {
    if let Err(err) = create_directories() {
        eprintln!("{}", err);
        return;
    }
    let mut state = match State::new(VERSION) {
        Ok(val) => val,
        Err(err) => {
            eprintln!("{}", err);
            return;
        }
    };
    let config = Config::new();

[6.1466]

[11.1175]

fn main() -> Result<()> {
    create_directories().chain_err(|| "unable to create directories")?;
    let mut state = State::new(VERSION).chain_err(|| "unable to load state")?;
    let config = Config::new()?;

Replacement in src/main.rs at line 132 [6.1346]

B:BD[27.1373] → [27.1373:1530]

            let download_matches = matches.subcommand_matches("download").unwrap();
            let podcast = download_matches.value_of("PODCAST").unwrap();

[27.1373]

[27.1530]

            let download_matches = matches
                .subcommand_matches("download")
                .chain_err(|| "unable to find subcommand matches")?;
            let podcast = download_matches
                .value_of("PODCAST")
                .chain_err(|| "unable to find subcommand match")?;

Replacement in src/main.rs at line 140 [6.1346]

B:BD[15.2969] → [15.2969:3025]

                    download_range(&state, podcast, ep)

[15.2969]

[15.3025]

                    download_range(&state, podcast, ep)?

Replacement in src/main.rs at line 142 [6.1346]

B:BD[15.3050] → [15.3050:3108]

                    download_episode(&state, podcast, ep)

[15.3050]

[15.3108]

                    download_episode(&state, podcast, ep)?

Replacement in src/main.rs at line 144 [6.1346]
∅:D[23.1989] → [16.879:934]
∅:D[15.3127] → [16.879:934]
B:BD[16.879] → [16.879:934]
```
                None => download_all(&state, podcast),
```
[15.3127]
[27.1707]
```
                None => download_all(&state, podcast)?,
```

Replacement in src/main.rs at line 151 [6.1346]

B:BD[14.957] → [14.957:984]

                .unwrap();

[14.957]

[11.2608]

                .chain_err(|| "unable to find subcommand matches")?;

Replacement in src/main.rs at line 153 [6.1346]

B:BD[11.2661] → [13.749:802]

∅:D[13.802] → [16.996:1048]

B:BD[16.996] → [16.996:1048]

                Some(regex) => list_episodes(regex),
                None => list_subscriptions(&state),

[11.2661]

[11.2772]

                Some(regex) => list_episodes(regex)?,
                None => list_subscriptions(&state)?,

Replacement in src/main.rs at line 158 [6.1346]

B:BD[26.1634] → [26.1634:1779]

            let play_matches = matches.subcommand_matches("play").unwrap();
            let podcast = play_matches.value_of("PODCAST").unwrap();

[26.1634]

[9.2257]

            let play_matches = matches
                .subcommand_matches("play")
                .chain_err(|| "unable to find subcommand matches")?;
            let podcast = play_matches
                .value_of("PODCAST")
                .chain_err(|| "unable to find subcommand match")?;

Replacement in src/main.rs at line 165 [6.1346]

B:BD[9.2310] → [9.2310:2437]

                Some(episode) => play_episode(&state, podcast, episode),
                None => play_latest(&state, podcast),

[9.2310]

[9.2437]

                Some(episode) => play_episode(&state, podcast, episode)?,
                None => play_latest(&state, podcast)?,

Replacement in src/main.rs at line 170 [6.1346]

B:BD[17.1088] → [17.1088:1274]

            let subscribe_matches = matches.subcommand_matches("subscribe").unwrap();
            let url = subscribe_matches.value_of("URL").unwrap();
            state.subscribe(url);

[17.1088]

[17.1274]

            let subscribe_matches = matches
                .subcommand_matches("subscribe")
                .chain_err(|| "unable to find subcommand matches")?;
            let url = subscribe_matches
                .value_of("URL")
                .chain_err(|| "unable to find subcommand match")?;
            state.subscribe(url).chain_err(|| "unable to subscribe")?;

Replacement in src/main.rs at line 178 [6.1346]

B:BD[17.1340] → [17.1340:1384]

                download_rss(&config, url);

[17.1340]

[17.1384]

                download_rss(&config, url)?;

Replacement in src/main.rs at line 180 [6.1346]

B:BD[17.1405] → [17.1405:1441]

                subscribe_rss(url);

[17.1405]

[17.1441]

                subscribe_rss(url)?;

Replacement in src/main.rs at line 185 [6.1346]

B:BD[8.3573] → [8.3573:3762]

B:BD[8.3762] → [2.397:433]

∅:D[2.433] → [8.3800:3814]

B:BD[8.3800] → [8.3800:3814]

            let rm_matches = matches.subcommand_matches("rm").unwrap();
            match rm_matches.value_of("PODCAST") {
                Some(regex) => remove_podcast(&mut state, regex),
                None => println!(),
            }

[8.3573]

[8.3814]

            let rm_matches = matches
                .subcommand_matches("rm")
                .chain_err(|| "unable to find subcommand matches")?;
            let regex = rm_matches.value_of("PODCAST").chain_err(|| "")?;
            remove_podcast(&mut state, regex)?

Replacement in src/main.rs at line 192 [6.1346]

B:BD[8.3856] → [8.3856:3933]

            let matches = matches.subcommand_matches("completion").unwrap();

[8.3856]

[8.3933]

            let matches = matches
                .subcommand_matches("completion")
                .chain_err(|| "unable to find subcommand matches")?;

Replacement in src/main.rs at line 201 [6.1346]

B:BD[15.3573] → [8.4106:4159]

        Some("update") => check_for_update(VERSION),

[15.3573]

[11.3106]

        Some("update") => check_for_update(VERSION)?,

Deletion in src/main.rs at line 203 [6.1346]
B:BD[11.3123] → [11.3123:3129]
B:BD[11.3129] → [35.22:59]
B:BD[35.59] → [18.1620:1650]
```
    }
    if let Err(err) = state.save() {
        eprintln!("{}", err);
```
Insertion in src/main.rs at line 204 [6.1346]
[18.1656]
[5.196]
```
    state.save().chain_err(|| "unable to save state")
```
Insertion in src/structs.rs at line 2 [6.234]
[12.257]
[9.2453]
```
use errors::*;
```

Replacement in src/structs.rs at line 6 [6.234]

B:BD[9.2500] → [9.2500:2568]

use std::fs::{self, remove_dir_all, remove_file, DirBuilder, File};

[9.2500]

[9.2568]

use std::fs::{self, DirBuilder, File};

Replacement in src/structs.rs at line 12 [6.234]
B:BD[11.3144] → [11.3144:3176]
```
use rss::{self, Channel, Item};
```
[11.3144]
[29.176]
```
use rss::{Channel, Item};
```

Replacement in src/structs.rs at line 21 [6.234]

B:BD[19.1898] → [19.1898:1969]

    pub fn new() -> Config {
        let mut path = get_podcast_dir();

[19.1898]

[19.1969]

    pub fn new() -> Result<Config> {
        let mut path = get_podcast_dir()?;

Replacement in src/structs.rs at line 27 [6.234]

B:BD[19.2135] → [19.2135:2272]

            File::open(&path).unwrap().read_to_string(&mut s).unwrap();
            let config = YamlLoader::load_from_str(&s).unwrap();

[19.2135]

[2.435]

            File::open(&path)
                .chain_err(|| UNABLE_TO_OPEN_FILE)?
                .read_to_string(&mut s)
                .chain_err(|| UNABLE_TO_READ_FILE_TO_STRING)?;
            let config =
                YamlLoader::load_from_str(&s).chain_err(|| "unable to load yaml from string")?;

Replacement in src/structs.rs at line 40 [6.234]

B:BD[34.158] → [34.158:279]

            let mut file = File::create(&path).unwrap();
            file.write_all(b"auto_download_limit: 1").unwrap();

[34.158]

[19.2620]

            let mut file = File::create(&path).chain_err(|| UNABLE_TO_CREATE_FILE)?;
            file.write_all(b"auto_download_limit: 1")
                .chain_err(|| UNABLE_TO_WRITE_FILE)?;

Replacement in src/structs.rs at line 44 [6.234]
B:BD[19.2630] → [19.2630:2647]
```
        Config {
```
[19.2630]
[19.2647]
```
        Ok(Config {
```
Replacement in src/structs.rs at line 46 [6.234]
B:BD[19.2741] → [19.2741:2751]
```
        }
```
[19.2696]
[19.2751]
```
        })
```

Replacement in src/structs.rs at line 65 [6.234]

B:BD[11.3511] → [20.632:689]

∅:D[20.689] → [13.897:939]

B:BD[22.1352] → [13.897:939]

    pub fn new(version: &str) -> Result<State, String> {
        let mut path = get_podcast_dir();

[11.3511]

[11.3581]

    pub fn new(version: &str) -> Result<State> {
        let mut path = get_podcast_dir()?;

Replacement in src/structs.rs at line 70 [6.234]

B:BD[11.3684] → [10.380:663]

            let mut file = match File::open(&path) {
                Ok(val) => val,
                Err(err) => return Err(format!("{}", err)),
            };
            if let Err(err) = file.read_to_string(&mut s) {
                return Err(format!("{}", err));
            };

[11.3684]

[10.663]

            let mut file = File::open(&path).chain_err(|| UNABLE_TO_OPEN_FILE)?;
            file.read_to_string(&mut s)
                .chain_err(|| UNABLE_TO_READ_FILE_TO_STRING)?;

Replacement in src/structs.rs at line 77 [6.234]

B:BD[20.718] → [20.718:800]

                    let v: serde_json::Value = serde_json::from_str(&s).unwrap();

[20.718]

[20.800]

                    let v: serde_json::Value =
                        serde_json::from_str(&s).chain_err(|| "unable to read json from string")?;

Replacement in src/structs.rs at line 84 [6.234]

B:BD[20.1021] → [20.1021:1111]

                            Err(_) => serde_json::from_value(v["subs"].clone()).unwrap(),

[20.1021]

[9.2615]

                            Err(_) => serde_json::from_value(v["subs"].clone())
                                .chain_err(|| "unable to parse value from json")?,

Replacement in src/structs.rs at line 97 [6.234]

B:BD[10.1262] → [20.1217:1267]

                check_for_update(&state.version);

[10.1262]

[33.595]

                check_for_update(&state.version)?;

Replacement in src/structs.rs at line 100 [6.234]

B:BD[10.1309] → [9.2695:2792]

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

[10.1309]

            state.save()?;

Replacement in src/structs.rs at line 111 [6.234]

B:BD[11.3866] → [17.1467:1512]

    pub fn subscribe(&mut self, url: &str) {

[11.3866]

[11.3911]

    pub fn subscribe(&mut self, url: &str) -> Result<()> {

Replacement in src/structs.rs at line 124 [6.234]
B:BD[11.4284] → [16.1150:1190]
B:BD[16.1190] → [35.105:139]
∅:D[35.139] → [11.4378:4388]
∅:D[16.1223] → [11.4378:4388]
B:BD[11.4378] → [11.4378:4388]
```
        if let Err(err) = self.save() {
            eprintln!("{}", err);
        }
```
[11.4284]
[11.4388]
```
        self.save()
```

Replacement in src/structs.rs at line 131 [6.234]

B:BD[11.4480] → [11.4480:4530]

∅:D[33.986] → [11.4530:4572]

B:BD[11.4530] → [11.4530:4572]

    pub fn save(&self) -> Result<(), io::Error> {
        let mut path = get_podcast_dir();

[11.4480]

[18.2114]

    pub fn save(&self) -> Result<()> {
        let mut path = get_podcast_dir()?;

Replacement in src/structs.rs at line 134 [6.234]

∅:D[18.2155] → [11.4609:4757]

B:BD[11.4609] → [11.4609:4757]

B:BD[11.4757] → [18.2156:2200]

        let serialized = serde_json::to_string(self)?;
        let mut file = File::create(&path)?;
        file.write_all(serialized.as_bytes())?;
        fs::rename(&path, get_sub_file())?;

[18.2155]

[11.4757]

        let serialized = serde_json::to_string(self).chain_err(|| "unable to serialize state")?;
        let mut file = File::create(&path).chain_err(|| UNABLE_TO_CREATE_FILE)?;
        file.write_all(serialized.as_bytes())
            .chain_err(|| UNABLE_TO_WRITE_FILE)?;
        fs::rename(&path, get_sub_file()?).chain_err(|| "unable to rename file")?;

Replacement in src/structs.rs at line 172 [6.234]

∅:D[24.1514] → [11.4906:5090]

B:BD[11.4906] → [11.4906:5090]

B:BD[11.5090] → [24.1515:1525]

    pub fn from_url(url: &str) -> Result<Podcast, rss::Error> {
        match Channel::from_url(url) {
            Ok(val) => Ok(Podcast::from(val)),
            Err(err) => Err(err),
        }

[24.1514]

[24.1525]

    pub fn from_url(url: &str) -> Result<Podcast> {
        Ok(
            Podcast::from(Channel::from_url(url).chain_err(|| UNABLE_TO_CREATE_CHANNEL_FROM_RESPONSE)?),
        )

Replacement in src/structs.rs at line 178 [6.234]

B:BD[24.1532] → [24.1532:1634]

    pub fn from_title(title: &str) -> Result<Podcast, String> {
        let mut path = get_xml_dir();

[24.1532]

[24.1634]

    pub fn from_title(title: &str) -> Result<Podcast> {
        let mut path = get_xml_dir()?;

Replacement in src/structs.rs at line 184 [6.234]

B:BD[24.1747] → [24.1747:1781]

B:BD[24.1781] → [15.3631:3704]

B:BD[15.3704] → [2.472:591]

∅:D[2.591] → [15.3837:3852]

B:BD[15.3837] → [15.3837:3852]

B:BD[15.3852] → [2.592:648]

∅:D[2.648] → [11.5090:5100]

∅:D[24.2108] → [11.5090:5100]

B:BD[11.5090] → [11.5090:5100]

        match File::open(&path) {
            Ok(file) => match Channel::read_from(BufReader::new(file)) {
                Ok(podcast) => Ok(Podcast::from(podcast)),
                Err(err) => Err(format!("Error: {}", err)),
            },
            Err(err) => Err(format!("Error: {}", err)),
        }

[24.1747]

[8.4230]

        let file = File::open(&path).chain_err(|| UNABLE_TO_OPEN_FILE)?;
        Ok(Podcast::from(Channel::read_from(BufReader::new(file))
            .chain_err(|| UNABLE_TO_CREATE_CHANNEL_FROM_FILE)?))

Replacement in src/structs.rs at line 189 [6.234]

B:BD[8.4237] → [8.4237:4326]

    pub fn delete(title: &str) -> io::Result<()> {
        let mut path = get_xml_dir();

[8.4237]

[8.4326]

    pub fn delete(title: &str) -> Result<()> {
        let mut path = get_xml_dir()?;

Replacement in src/structs.rs at line 195 [6.234]

B:BD[8.4439] → [2.649:675]

        remove_file(path)

[8.4439]

[8.4473]

        fs::remove_file(path).chain_err(|| UNABLE_TO_REMOVE_FILE)

Replacement in src/structs.rs at line 198 [6.234]

B:BD[8.4480] → [8.4480:4558]

B:BD[8.4558] → [2.676:705]

    pub fn delete_all() -> io::Result<()> {
        let path = get_xml_dir();
        remove_dir_all(path)

[8.4480]

[11.5100]

    pub fn delete_all() -> Result<()> {
        let path = get_xml_dir()?;
        fs::remove_dir_all(path).chain_err(|| UNABLE_TO_READ_DIRECTORY)

Replacement in src/structs.rs at line 205 [6.234]

B:BD[6.667] → [6.667:741]


        let items = self.0.items().to_vec();
        for item in items {

[6.667]

[6.741]

        for item in self.0.items().to_vec() {

Replacement in src/structs.rs at line 211 [6.234]

B:BD[6.820] → [24.2109:2163]

    pub fn download(&self) -> Result<(), io::Error> {

[6.820]

[5.200]

    pub fn download(&self) -> Result<()> {

Replacement in src/structs.rs at line 215 [6.234]

B:BD[5.340] → [2.706:799]

        if io::stdin().read_line(&mut input).is_ok() && input.to_lowercase().trim() != "y" {

[5.340]

[2.799]

        io::stdin()
            .read_line(&mut input)
            .chain_err(|| "unable to read stdin")?;
        if input.to_lowercase().trim() != "y" {

Replacement in src/structs.rs at line 222 [6.234]
∅:D[5.507] → [11.5192:5234]
∅:D[24.2163] → [11.5192:5234]
B:BD[11.5192] → [11.5192:5234]
```
        let mut path = get_podcast_dir();
```
[5.507]
[11.5234]
```
        let mut path = get_podcast_dir()?;
```

Replacement in src/structs.rs at line 231 [6.234]

B:BD[5.840] → [5.840:893]

                                println!("{}", err);

[5.840]

[5.893]

                                eprintln!("{}", err);

Replacement in src/structs.rs at line 240 [6.234]

B:BD[23.2210] → [36.238:283]

                        println!("{}", err);

[23.2210]

[36.283]

                        eprintln!("{}", err);

Replacement in src/structs.rs at line 249 [6.234]

B:BD[36.356] → [2.945:1035]

∅:D[2.1035] → [36.423:465]

∅:D[24.2333] → [36.423:465]

B:BD[36.423] → [36.423:465]

    pub fn download_specific(&self, episode_numbers: &[usize]) -> Result<(), io::Error> {
        let mut path = get_podcast_dir();

[36.356]

[36.465]

    pub fn download_specific(&self, episode_numbers: &[usize]) -> Result<()> {
        let mut path = get_podcast_dir()?;

Replacement in src/structs.rs at line 282 [6.234]

∅:D[29.271] → [11.5907:5942]

∅:D[28.848] → [11.5907:5942]

B:BD[11.5907] → [11.5907:5942]

B:BD[11.5942] → [15.4146:4416]

∅:D[15.4416] → [11.6232:6258]

B:BD[11.6232] → [11.6232:6258]

        match self.0.enclosure() {
            Some(enclosure) => match enclosure.mime_type() {
                "audio/mpeg" => Some(".mp3"),
                "audio/mp4" => Some(".m4a"),
                "audio/ogg" => Some(".ogg"),
                _ => find_extension(self.url().unwrap()),
            },
            None => None,

[29.271]

[11.6258]

        match self.0.enclosure()?.mime_type() {
            "audio/mpeg" => Some(".mp3"),
            "audio/mp4" => Some(".m4a"),
            "audio/ogg" => Some(".ogg"),
            _ => find_extension(self.url().unwrap()),

Replacement in src/structs.rs at line 290 [6.234]

∅:D[19.3339] → [11.6275:6391]

B:BD[11.6275] → [11.6275:6391]

    pub fn download(&self, podcast_name: &str) -> Result<(), io::Error> {
        let mut path = get_podcast_dir();

[11.6275]

[11.6391]

    pub fn download(&self, podcast_name: &str) -> Result<()> {
        let mut path = get_podcast_dir()?;

Replacement in src/structs.rs at line 293 [6.234]

B:BD[11.6424] → [27.1733:1799]

        DirBuilder::new().recursive(true).create(&path).unwrap();

[11.6424]

        DirBuilder::new()
            .recursive(true)
            .create(&path)
            .chain_err(|| UNABLE_TO_CREATE_DIRECTORY)?;

Replacement in src/structs.rs at line 301 [6.234]

B:BD[11.6630] → [29.272:334]

                filename.push_str(self.extension().unwrap());

[11.6630]

[11.6701]

                filename.push_str(self.extension()
                    .chain_err(|| "unable to retrieve extension")?);

Replacement in src/structs.rs at line 306 [6.234]

B:BD[9.2902] → [9.2902:3022]

                    let mut file = File::create(&path)?;
                    let mut resp = reqwest::get(url).unwrap();

[9.2902]

[9.3022]

                    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)?;

Replacement in src/structs.rs at line 309 [6.234]

B:BD[9.3081] → [9.3081:3216]

                    resp.read_to_end(&mut content)?;
                    file.write_all(&content)?;
                    return Ok(());

[9.3081]

[9.3216]

                    resp.read_to_end(&mut content)
                        .chain_err(|| UNABLE_TO_READ_RESPONSE_TO_END)?;
                    file.write_all(&content).chain_err(|| UNABLE_TO_WRITE_FILE)?;

Replacement in src/structs.rs at line 313 [6.234]

B:BD[9.3241] → [9.3241:3357]

                    println!("File already exists: {}", path.to_str().unwrap());
                    return Ok(());

[9.3241]

[9.3357]

                    println!(
                        "File already exists: {}",
                        path.to_str().chain_err(|| UNABLE_TO_CONVERT_TO_STR)?
                    );

Replacement in src/utils.rs at line 4 [11.7061]
B:BD[17.1553] → [17.1553:1598]
∅:D[17.1598] → [9.3377:3406]
B:BD[24.2458] → [9.3377:3406]
```
use std::io::{self, BufReader, Read, Write};
use std::num::ParseIntError;
```
[17.1553]
[9.3406]
```
use std::io::{BufReader, Read, Write};
```
Insertion in src/utils.rs at line 7 [11.7061]
[17.1600]
[17.1600]
```
use errors::*;
```

Insertion in src/utils.rs at line 11 [11.7061]

[11.7146]

[24.2459]

pub const UNABLE_TO_PARSE_REGEX: &'static str = "unable to parse regex";
pub const UNABLE_TO_OPEN_FILE: &'static str = "unable to open file";
pub const UNABLE_TO_CREATE_FILE: &'static str = "unable to create file";
pub const UNABLE_TO_WRITE_FILE: &'static str = "unable to write file";
pub const UNABLE_TO_READ_FILE_TO_STRING: &'static str = "unable to read file to string";
pub const UNABLE_TO_READ_DIRECTORY: &'static str = "unable to read directory";
pub const UNABLE_TO_READ_ENTRY: &'static str = "unable to read entry";
pub const UNABLE_TO_CREATE_DIRECTORY: &'static str = "unable to create directory";
pub const UNABLE_TO_READ_RESPONSE_TO_END: &'static str = "unable to read response to end";
pub const UNABLE_TO_GET_HTTP_RESPONSE: &'static str = "unable to get http response";
pub const UNABLE_TO_CONVERT_TO_STR: &'static str = "unable to convert to &str";
pub const UNABLE_TO_REMOVE_FILE: &'static str = "unable to remove file";
pub const UNABLE_TO_CREATE_CHANNEL_FROM_RESPONSE: &'static str =
    "unable to create channel from http response";
pub const UNABLE_TO_CREATE_CHANNEL_FROM_FILE: &'static str =
    "unable to create channel from xml file";
pub const UNABLE_TO_RETRIEVE_PODCAST_BY_TITLE: &'static str = "unable to retrieve podcast by title";

Replacement in src/utils.rs at line 30 [11.7061]

B:BD[19.3557] → [24.2518:2634]

    match name.rfind('.') {
        Some(index) => Some(String::from(&name[0..index])),
        None => None,
    }

[19.3557]

[19.3633]

    let index = name.rfind('.')?;
    Some(String::from(&name[0..index]))

Replacement in src/utils.rs at line 51 [11.7061]

B:BD[13.1242] → [10.1469:1521]

∅:D[10.1521] → [13.1290:1423]

B:BD[13.1290] → [13.1290:1423]

B:BD[13.1423] → [10.1522:1671]

pub fn create_directories() -> Result<(), String> {
    let mut path = get_podcast_dir();
    path.push(".rss");
    if let Err(err) = DirBuilder::new().recursive(true).create(&path) {
        return Err(format!(
            "Couldn't create directory: {}\nReason: {}",
            path.to_str().unwrap(),
            err
        ));

[13.1242]

[19.3975]

pub fn get_podcast_dir() -> Result<PathBuf> {
    match env::var_os("PODCAST") {
        Some(val) => Ok(PathBuf::from(val)),
        None => {
            let mut path = env::home_dir().chain_err(|| "Couldn't find your home directory")?;
            path.push("Podcasts");
            Ok(path)
        }

Deletion in src/utils.rs at line 60 [11.7061]
B:BD[19.3981] → [13.1623:1634]
```
    Ok(())
```

Replacement in src/utils.rs at line 62 [11.7061]

B:BD[11.7245] → [24.2635:2712]

pub fn already_downloaded(dir: &str) -> Result<HashSet<String>, io::Error> {

[11.7245]

[19.4042]

pub fn create_directories() -> Result<()> {
    let mut path = get_podcast_dir()?;
    path.push(".rss");
    DirBuilder::new()
        .recursive(true)
        .create(&path)
        .chain_err(|| "unable to create directory")
}
pub fn already_downloaded(dir: &str) -> Result<HashSet<String>> {

Replacement in src/utils.rs at line 74 [11.7061]
∅:D[19.4080] → [11.7245:7283]
B:BD[11.7245] → [11.7245:7283]
```
    let mut path = get_podcast_dir();
```
[19.4080]
[11.7283]
```
    let mut path = get_podcast_dir()?;
```

Replacement in src/utils.rs at line 77 [11.7061]

B:BD[11.7304] → [24.2713:2752]

    let entries = fs::read_dir(path)?;

[11.7304]

[24.2752]

    let entries = fs::read_dir(path).chain_err(|| "unable to read directory")?;

Replacement in src/utils.rs at line 79 [11.7061]

B:BD[24.2779] → [24.2779:2807]

        let entry = entry?;

[24.2779]

[24.2807]

        let entry = entry.chain_err(|| "unable to read entry")?;

Replacement in src/utils.rs at line 82 [11.7061]

∅:D[2.1063] → [24.2926:2979]

B:BD[24.2926] → [24.2926:2979]

                let index = name.find('.').unwrap();

[2.1063]

[24.2979]

                let index = name.find('.').chain_err(|| "unable to find string index")?;

Replacement in src/utils.rs at line 86 [11.7061]
B:BD[24.3079] → [24.3079:3105]
```
                println!(
```
[24.3079]
[24.3105]
```
                eprintln!(
```

Deletion in src/utils.rs at line 94 [11.7061]

∅:D[24.3248] → [11.7820:7861]

B:BD[11.7820] → [11.7820:7861]

B:BD[11.7861] → [23.2239:2274]

∅:D[23.2274] → [32.676:717]

B:BD[32.676] → [32.676:717]

B:BD[32.717] → [18.2202:2220]

B:BD[18.2220] → [24.3249:3337]

∅:D[24.3337] → [18.2273:2341]

B:BD[18.2273] → [18.2273:2341]

}
pub fn get_podcast_dir() -> PathBuf {
    match env::var_os("PODCAST") {
        Some(val) => PathBuf::from(val),
        None => {
            let mut path = env::home_dir().expect("Couldn't find your home directory");
            path.push("Podcasts");
            path
        }
    }

Replacement in src/utils.rs at line 96 [11.7061]

B:BD[18.2344] → [18.2344:2379]

B:BD[18.2379] → [24.3338:3376]

pub fn get_sub_file() -> PathBuf {
    let mut path = get_podcast_dir();

[18.2344]

[24.3376]

pub fn get_sub_file() -> Result<PathBuf> {
    let mut path = get_podcast_dir()?;

Replacement in src/utils.rs at line 99 [11.7061]
B:BD[24.3409] → [24.3409:3418]
```
    path
```
[24.3409]
[24.3418]
```
    Ok(path)
```

Replacement in src/utils.rs at line 102 [11.7061]

B:BD[24.3421] → [24.3421:3493]

pub fn get_xml_dir() -> PathBuf {
    let mut path = get_podcast_dir();

[24.3421]

[24.3493]

pub fn get_xml_dir() -> Result<PathBuf> {
    let mut path = get_podcast_dir()?;

Replacement in src/utils.rs at line 105 [11.7061]
B:BD[24.3516] → [24.3516:3525]
```
    path
```
[24.3516]
[11.7942]
```
    Ok(path)
```

Replacement in src/utils.rs at line 108 [11.7061]

B:BD[36.1472] → [17.1632:1735]

pub fn download_rss_feed(url: &str) -> Result<Channel, String> {
    let mut path = get_podcast_dir();

[36.1472]

[17.1735]

pub fn download_rss_feed(url: &str) -> Result<Channel> {
    let mut path = get_podcast_dir()?;

Replacement in src/utils.rs at line 111 [11.7061]

B:BD[17.1758] → [17.1758:1867]

    DirBuilder::new().recursive(true).create(&path).unwrap();
    let mut resp = reqwest::get(url).unwrap();

[17.1758]

[17.1867]

    DirBuilder::new()
        .recursive(true)
        .create(&path)
        .chain_err(|| "unable to open directory")?;
    let mut resp = reqwest::get(url).chain_err(|| "unable to open url")?;

Replacement in src/utils.rs at line 117 [11.7061]

B:BD[17.1910] → [17.1910:2032]

    resp.read_to_end(&mut content).unwrap();
    let channel = Channel::read_from(BufReader::new(&content[..])).unwrap();

[17.1910]

[17.2032]

    resp.read_to_end(&mut content)
        .chain_err(|| "unable to read http response to end")?;
    let channel = Channel::read_from(BufReader::new(&content[..]))
        .chain_err(|| "unable to create channel from xml http response")?;

Replacement in src/utils.rs at line 124 [11.7061]

B:BD[17.2142] → [17.2142:2230]

    let mut file = File::create(&path).unwrap();
    file.write_all(&content).unwrap();

[17.2142]

[17.2230]

    let mut file = File::create(&path).chain_err(|| "unable to create file")?;
    file.write_all(&content)
        .chain_err(|| "unable to write file")?;

Replacement in src/utils.rs at line 130 [11.7061]

∅:D[17.2249] → [25.510:596]

B:BD[36.1472] → [25.510:596]

pub fn parse_download_episodes(e_search: &str) -> Result<Vec<usize>, ParseIntError> {

[17.2249]

[36.1535]

pub fn parse_download_episodes(e_search: &str) -> Result<Vec<usize>> {

Replacement in src/utils.rs at line 139 [11.7061]

B:BD[36.1892] → [36.1892:1974]

                .map(|i| i.parse::<usize>().unwrap())
                .collect();

[36.1892]

[36.1974]

                .map(|i| i.parse::<usize>().chain_err(|| "unable to parse number"))
                .collect::<Result<Vec<usize>>>()
                .chain_err(|| "unable to collect ranges")?;

Replacement in src/utils.rs at line 144 [11.7061]

B:BD[36.2038] → [25.597:648]

            elements.push(elem.parse::<usize>()?);

[36.2038]

[36.2097]

            elements.push(elem.parse::<usize>()
                .chain_err(|| "unable to parse number")?);

Improve error handling

Dependencies

In channels

Change contents

Insertion in CHANGELOG at line 1 [4.1]

Replacement in Cargo.toml at line 3 [6.62]

Insertion in Cargo.toml at line 23 [6.62]

Insertion in src/actions.rs at line 9 [11.163]

Insertion in src/actions.rs at line 14 [11.163]

Replacement in src/actions.rs at line 17 [11.163]

Replacement in src/actions.rs at line 21 [11.163]

Replacement in src/actions.rs at line 24 [11.163]

Replacement in src/actions.rs at line 31 [11.163]

Replacement in src/actions.rs at line 41 [11.163]

Replacement in src/actions.rs at line 44 [11.163]

Insertion in src/actions.rs at line 47 [11.163]

Replacement in src/actions.rs at line 50 [11.163]

Replacement in src/actions.rs at line 52 [11.163]

Replacement in src/actions.rs at line 55 [11.163]

Replacement in src/actions.rs at line 57 [11.163]

Replacement in src/actions.rs at line 66 [11.163]

Insertion in src/actions.rs at line 68 [11.163]

Replacement in src/actions.rs at line 71 [11.163]

Replacement in src/actions.rs at line 88 [11.163]

Replacement in src/actions.rs at line 97 [11.163]

Replacement in src/actions.rs at line 103 [11.163]

Replacement in src/actions.rs at line 116 [11.163]

Replacement in src/actions.rs at line 125 [11.163]

Replacement in src/actions.rs at line 129 [11.163]

Insertion in src/actions.rs at line 131 [11.163]

Replacement in src/actions.rs at line 134 [11.163]

Replacement in src/actions.rs at line 139 [11.163]

Insertion in src/actions.rs at line 148 [11.163]

Replacement in src/actions.rs at line 151 [11.163]

Replacement in src/actions.rs at line 159 [11.163]

Insertion in src/actions.rs at line 167 [11.163]

Replacement in src/actions.rs at line 170 [11.163]

Replacement in src/actions.rs at line 175 [11.163]

Insertion in src/actions.rs at line 182 [11.163]

Replacement in src/actions.rs at line 185 [11.163]

Replacement in src/actions.rs at line 195 [11.163]

Replacement in src/actions.rs at line 199 [11.163]

Replacement in src/actions.rs at line 201 [11.163]

Replacement in src/actions.rs at line 204 [11.163]

Replacement in src/actions.rs at line 209 [11.163]

Replacement in src/actions.rs at line 219 [11.163]

Replacement in src/actions.rs at line 222 [11.163]

Replacement in src/actions.rs at line 226 [11.163]

Insertion in src/actions.rs at line 229 [11.163]

Replacement in src/actions.rs at line 232 [11.163]

Replacement in src/actions.rs at line 243 [11.163]

Replacement in src/actions.rs at line 247 [11.163]

Replacement in src/actions.rs at line 251 [11.163]

Replacement in src/actions.rs at line 261 [11.163]

Replacement in src/actions.rs at line 265 [11.163]

Replacement in src/actions.rs at line 267 [11.163]

Replacement in src/actions.rs at line 269 [11.163]

Insertion in src/actions.rs at line 272 [11.163]

Replacement in src/actions.rs at line 275 [11.163]

Replacement in src/actions.rs at line 279 [11.163]

Replacement in src/actions.rs at line 281 [11.163]

Replacement in src/actions.rs at line 284 [11.163]

Insertion in src/actions.rs at line 292 [11.163]

Replacement in src/actions.rs at line 295 [11.163]

Replacement in src/actions.rs at line 297 [11.163]

Insertion in src/actions.rs at line 299 [11.163]

Replacement in src/actions.rs at line 302 [11.163]

Deletion in src/actions.rs at line 310 [11.163]

Replacement in src/actions.rs at line 317 [11.163]

Replacement in src/actions.rs at line 321 [11.163]

Insertion in src/actions.rs at line 326 [11.163]

Replacement in src/actions.rs at line 329 [11.163]

Replacement in src/actions.rs at line 331 [11.163]

Replacement in src/actions.rs at line 334 [11.163]

Replacement in src/actions.rs at line 340 [11.163]

Insertion in src/actions.rs at line 343 [11.163]

Insertion in src/main.rs at line 1 [6.1346]

Insertion in src/main.rs at line 5 [6.1346]

Insertion in src/main.rs at line 20 [6.1346]

Replacement in src/main.rs at line 26 [6.1346]