njaremko/podcast - Change JDSHG6Q3GBJBEMIQRIDLYSCRUIH6PZD5P2DF6VGXAW5RRZAK73FQC

Attempt to find episodes by name if parsing number fails

Created by Nathan Jaremko on January 15, 2019

JDSHG6Q3GBJBEMIQRIDLYSCRUIH6PZD5P2DF6VGXAW5RRZAK73FQC

Dependencies

In channels

main

Change contents

Replacement in Cargo.toml at line 4 [4.62]
B:BD[3.80] → [2.1:19]
```
version = "0.7.1"
```
[3.80]
[5.1199]
```
version = "0.7.2"
```

Deletion in src/actions.rs at line 156 [7.163]

B:BD[6.4493] → [6.4493:4595]

    let ep_num = e_search
        .parse::<usize>()
        .chain_err(|| "unable to parse number")?;

Replacement in src/actions.rs at line 157 [7.163]

B:BD[8.273] → [9.128:175]

∅:D[9.175] → [10.614:664]

B:BD[10.614] → [10.614:664]

B:BD[10.664] → [6.4596:4930]

    for subscription in &state.subscriptions {
        if re_pod.is_match(&subscription.title) {
            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")?;

[8.273]

[11.132]

    if let Ok(ep_num) = e_search.parse::<usize>() {
        for subscription in &state.subscriptions {
            if re_pod.is_match(&subscription.title) {
                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 168 [7.163]

[11.142]

    } else {
        println!("Failed to parse episode number...");
        println!("Attempting to find episode by name...");
        download_episode_by_name(state, p_search, e_search, false)
            .chain_err(|| "Failed to download episode.")?;

Insertion in src/actions.rs at line 174 [7.163]
[11.148]
[11.148]

Replacement in src/actions.rs at line 298 [7.163]

B:BD[6.6944] → [6.6944:7053]

∅:D[12.1416] → [13.1018:1229]

∅:D[6.7053] → [13.1018:1229]

B:BD[14.156] → [13.1018:1229]

B:BD[13.1229] → [6.7054:7077]

∅:D[6.7077] → [13.1245:1251]

B:BD[13.1245] → [13.1245:1251]

B:BD[13.1251] → [9.224:271]

∅:D[9.271] → [10.938:988]

B:BD[10.938] → [10.938:988]

B:BD[10.988] → [6.7078:7145]

∅:D[10.1047] → [15.977:1049]

∅:D[16.1618] → [15.977:1049]

∅:D[6.7145] → [15.977:1049]

B:BD[15.977] → [15.977:1049]

    let ep_num: usize = ep_num_string.parse::<usize>().unwrap();
    let mut path: PathBuf = 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 Ok(());
    }
    for subscription in &state.subscriptions {
        if re_pod.is_match(&subscription.title) {
            let mut filename: String = subscription.title.clone();
            filename.push_str(".xml");
            path.push(filename);

[6.6944]

[15.1049]

    if let Ok(ep_num) = ep_num_string.parse::<usize>() {
        let mut path: PathBuf = 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 Ok(());
        }
        for subscription in &state.subscriptions {
            if re_pod.is_match(&subscription.title) {
                let mut filename: String = subscription.title.clone();
                filename.push_str(".xml");
                path.push(filename);

Replacement in src/actions.rs at line 314 [7.163]

B:BD[15.1050] → [6.7146:7207]

∅:D[6.7207] → [15.1105:1209]

B:BD[15.1105] → [15.1105:1209]

            let mut file: File = File::open(&path).unwrap();
            let mut content: Vec<u8> = Vec::new();
            file.read_to_end(&mut content).unwrap();

[15.1050]

[15.1209]

                let mut file: File = File::open(&path).unwrap();
                let mut content: Vec<u8> = Vec::new();
                file.read_to_end(&mut content).unwrap();

Replacement in src/actions.rs at line 318 [7.163]

B:BD[15.1210] → [15.1210:1300]

∅:D[17.228] → [8.616:663]

∅:D[15.1300] → [8.616:663]

B:BD[8.616] → [8.616:663]

B:BD[8.663] → [17.229:298]

            let podcast = Podcast::from(Channel::read_from(content.as_slice()).unwrap());
            let episodes = podcast.episodes();
            let episode = episodes[episodes.len() - ep_num].clone();

[15.1210]

[15.1301]

                let podcast = Podcast::from(Channel::read_from(content.as_slice()).unwrap());
                let episodes = podcast.episodes();
                let episode = episodes[episodes.len() - ep_num].clone();

Replacement in src/actions.rs at line 322 [7.163]

B:BD[15.1302] → [3.1745:1794]

∅:D[15.1365] → [18.30:91]

∅:D[3.1794] → [18.30:91]

B:BD[17.370] → [18.30:91]

B:BD[18.91] → [6.7208:7247]

∅:D[15.1404] → [19.2:42]

∅:D[6.7247] → [19.2:42]

B:BD[18.91] → [19.2:42]

∅:D[19.42] → [17.440:473]

∅:D[18.91] → [17.440:473]

B:BD[17.440] → [17.440:473]

B:BD[17.473] → [20.654:685]

B:BD[20.685] → [6.7248:7335]

∅:D[21.105] → [20.737:758]

∅:D[22.237] → [20.737:758]

∅:D[6.7335] → [20.737:758]

B:BD[20.737] → [20.737:758]

B:BD[20.758] → [3.1795:1979]

            filename = 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().chain_err(|| UNABLE_TO_CONVERT_TO_STR)?)?;
            } else {
                launch_player(
                    episode
                        .url()
                        .chain_err(|| "unable to retrieve episode url")?,
                )?;

[15.1302]

[11.1870]

                filename = 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().chain_err(|| UNABLE_TO_CONVERT_TO_STR)?)?;
                } else {
                    launch_player(
                        episode
                            .url()
                            .chain_err(|| "unable to retrieve episode url")?,
                    )?;
                }
                return Ok(());

Deletion in src/actions.rs at line 338 [7.163]
B:BD[11.1884] → [11.1884:1911]
```
            return Ok(());
```

Insertion in src/actions.rs at line 339 [7.163]

[11.1921]

    } else {
        println!("Failed to parse episode number...");
        println!("Attempting to find episode by name...");
        play_episode_by_name(state, p_search, ep_num_string)
            .chain_err(|| "Failed to play episode by name.")?;