njaremko/podcast - Change DP6ASS5FJGSZUG2B4SQOKZVHFAVZLEHFVEWBNFG3BHMC6FZAJNHQC

Improve code

Created by Nathan Jaremko on February 24, 2019

DP6ASS5FJGSZUG2B4SQOKZVHFAVZLEHFVEWBNFG3BHMC6FZAJNHQC

Dependencies

In channels

main

Change contents

Insertion in CHANGELOG at line 1 [4.1]

[4.1]

[5.1]

0.8.0
- Add a few subcommands / subcommand shortcuts
- Internal cleanup

Replacement in Cargo.toml at line 4 [6.62]
B:BD[5.80] → [3.1:19]
```
version = "0.7.5"
```
[5.80]
[7.1199]
```
version = "0.8.0"
```
Replacement in Cargo.toml at line 34 [6.62]
B:BD[8.150] → [9.142:160]
```
yaml-rust = "0.4"
```
[8.150]
[8.168]
```
serde_yaml = "0.8"
```
Replacement in src/actions.rs at line 1 [10.163]
B:BD[10.163] → [5.237:281]
```
use super::structs::*;
use super::utils::*;
```
[10.163]
[11.376]
```
use crate::structs::*;
use crate::utils::*;
```

Replacement in src/actions.rs at line 19 [10.163]

B:BD[12.309] → [12.309:348]

∅:D[12.348] → [13.119:142]

B:BD[13.119] → [13.119:142]

B:BD[13.142] → [12.349:471]

    let mut path = get_podcast_dir()?;
    path.push(".rss");
    DirBuilder::new()
        .recursive(true)
        .create(&path)
        .chain_err(|| UNABLE_TO_CREATE_DIRECTORY)?;

[12.309]

[12.471]

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

Replacement in src/actions.rs at line 56 [10.163]

B:BD[12.1208] → [12.1208:1298]

    let download_limit = config.auto_download_limit as usize;
    if download_limit > 0 {

[12.1208]

[12.1298]

    let mut download_limit = config.auto_download_limit as usize;
    if 0 < download_limit  {

Insertion in src/actions.rs at line 60 [10.163]

[12.1387]

        if episodes.len() < download_limit
        {
            download_limit = episodes.len()
        }

Replacement in src/actions.rs at line 65 [10.163]

B:BD[12.1449] → [12.1449:1510]

            if let Err(err) = ep.download(podcast.title()) {

[12.1449]

[12.1510]

            if let Err(err) = download(podcast.title(), ep) {

Replacement in src/actions.rs at line 76 [10.163]

B:BD[12.1755] → [12.1755:1877]

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

[12.1755]

[12.1877]

    create_dir_if_not_exist(&path)?;

Deletion in src/actions.rs at line 94 [10.163]
∅:D[5.830] → [12.2572:2626]
B:BD[12.2572] → [12.2572:2626]
```
    path = get_podcast_dir()?;
    path.push(".rss");
```

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

B:BD[12.2712] → [12.2712:2787]

    path.push(&filename);
    let mut file = File::create(&path).unwrap();

[12.2712]

[12.2787]


    let mut podcast_rss_path = get_xml_dir()?;
    podcast_rss_path.push(&filename);
    let mut file = File::create(&podcast_rss_path).unwrap();

Replacement in src/actions.rs at line 104 [10.163]

B:BD[14.1126] → [12.2827:2880]

    if podcast.episodes().len() > sub.num_episodes {

[14.1126]

[12.2880]

    if sub.num_episodes < podcast.episodes().len() {

Replacement in src/actions.rs at line 108 [10.163]

B:BD[12.3017] → [12.3017:3082]

                if let Err(err) = ep.download(podcast.title()) {

[12.3017]

[12.3082]

                if let Err(err) = download(podcast.title(), ep) {

Replacement in src/actions.rs at line 129 [10.163]
∅:D[15.350] → [16.329:373]
B:BD[17.176] → [16.329:373]
```
    for podcast in &state.subscriptions() {
```
[15.350]
[2.110]
```
    for podcast in state.subscriptions() {
```

Replacement in src/actions.rs at line 161 [10.163]

B:BD[18.374] → [18.374:471]

                episodes[episodes.len() - ep_num]
                    .download(podcast.title())

[18.374]

[18.471]

                download(podcast.title(), &episodes[episodes.len() - ep_num])

Replacement in src/actions.rs at line 169 [10.163]

B:BD[2.262] → [2.262:420]

            writeln!(&mut handle, "Failed to parse episode number...").ok();
            writeln!(&mut handle, "Attempting to find episode by name...").ok();

[2.262]

[2.420]

            writeln!(
                &mut handle,
                "Failed to parse episode number...\nAttempting to find episode by name..."
            )
            .ok();

Insertion in src/actions.rs at line 178 [10.163]

[19.148]

[18.806]


    Ok(())
}
pub fn download(podcast_name: &str, episode: &Episode) -> Result<()> {
    let stdout = io::stdout();
    let mut path = get_podcast_dir()?;
    path.push(podcast_name);
    create_dir_if_not_exist(&path)?;

Insertion in src/actions.rs at line 189 [10.163]

[18.807]

[19.148]

    if let Some(url) = episode.url() {
            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 {
                    let mut handle = stdout.lock();
                    writeln!(
                        &mut handle,
                        "File already exists: {:?}",
                        &path
                    )
                    .ok();
                }
            }
        }

Replacement in src/actions.rs at line 239 [10.163]

B:BD[19.757] → [19.757:961]

                    .filter(|ep| {
                        ep.title()
                            .unwrap_or_else(|| "".to_string())
                            .contains(e_search)
                    })

[19.757]

[19.961]

                    .filter(|ep| ep.title().is_some())
                    .filter(|ep| ep.title().unwrap().contains(e_search))

Replacement in src/actions.rs at line 242 [10.163]

B:BD[19.998] → [19.998:1072]

                        ep.download(podcast.title()).unwrap_or_else(|_| {

[19.998]

[2.431]

                        download(podcast.title(), ep).unwrap_or_else(|_| {

Insertion in src/actions.rs at line 249 [10.163]

[19.1323]

                    .filter(|ep| ep.title().is_some())

Replacement in src/actions.rs at line 252 [10.163]

B:BD[19.1393] → [19.1393:1456]

                            .unwrap_or_else(|| "".to_string())

[19.1393]

[20.22]

                            .unwrap()

Replacement in src/actions.rs at line 259 [10.163]

B:BD[19.1622] → [19.1622:1671]

                    ep.download(podcast.title())

[19.1622]

[19.1671]

                    download(podcast.title(), ep)

Replacement in src/actions.rs at line 386 [10.163]

B:BD[2.613] → [2.613:690]

            writeln!(&mut handle, "Failed to parse episode number...").ok();

[2.613]

[2.690]

            writeln!(&mut handle, "Failed to parse episode index number...").ok();

Deletion in src/actions.rs at line 458 [10.163]
B:BD[8.498] → [8.498:526]
```
    //println!("{}", resp);
```

Replacement in src/actions.rs at line 506 [10.163]

B:BD[8.991] → [12.8278:8316]

        return Podcast::delete_all();

[8.991]

[8.1150]

        state.subscriptions = vec![];
        return delete_all();

Replacement in src/actions.rs at line 516 [10.163]
B:BD[21.512] → [12.8415:8453]
```
            Podcast::delete(&title)?;
```
[21.512]
[22.973]
```
            delete(&title)?;
```
Replacement in src/actions.rs at line 526 [10.163]
B:BD[8.1710] → [8.1710:1732]
```
# Copyright (C) 2017:
```
[8.1710]
[8.1732]
```
# Copyright (C) 2019:
```
Insertion in src/main.rs at line 17 [6.1346]
[23.157]
[8.2879]
```
extern crate serde_yaml;
```
Deletion in src/main.rs at line 19 [6.1346]
∅:D[8.2898] → [14.1631:1655]
B:BD[23.157] → [14.1631:1655]
```
extern crate yaml_rust;
```

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

[5.2350]

pub mod match_handler;
pub mod migration_handler;
pub mod parser;

Deletion in src/main.rs at line 27 [6.1346]
∅:D[5.2399] → [12.8551:8615]
B:BD[12.8551] → [12.8551:8615]
```
    // Create the Error, ErrorKind, ResultExt, and Result types
```
Deletion in src/main.rs at line 30 [6.1346]
B:BD[6.1380] → [5.2400:2422]
```
use self::actions::*;
```
Deletion in src/main.rs at line 32 [6.1346]
B:BD[5.2465] → [5.2465:2485]
```
use self::utils::*;
```
Replacement in src/main.rs at line 33 [6.1346]
B:BD[8.2900] → [11.2148:2182]
```
use clap::{App, Arg, SubCommand};
```
[8.2900]
[11.2182]
```
const VERSION: &str = "0.8.0";
```
Deletion in src/main.rs at line 35 [6.1346]
B:BD[11.2183] → [3.22:53]
∅:D[24.53] → [6.1465:1466]
∅:D[25.53] → [6.1465:1466]
∅:D[26.53] → [6.1465:1466]
∅:D[27.53] → [6.1465:1466]
∅:D[3.53] → [6.1465:1466]
∅:D[28.53] → [6.1465:1466]
∅:D[29.98] → [6.1465:1466]
∅:D[30.105] → [6.1465:1466]
∅:D[31.117] → [6.1465:1466]
∅:D[32.122] → [6.1465:1466]
∅:D[33.144] → [6.1465:1466]
∅:D[23.174] → [6.1465:1466]
∅:D[34.180] → [6.1465:1466]
∅:D[35.190] → [6.1465:1466]
∅:D[36.195] → [6.1465:1466]
∅:D[37.251] → [6.1465:1466]
∅:D[20.265] → [6.1465:1466]
∅:D[15.437] → [6.1465:1466]
∅:D[38.612] → [6.1465:1466]
∅:D[10.1139] → [6.1465:1466]
∅:D[11.2214] → [6.1465:1466]
∅:D[5.2517] → [6.1465:1466]
∅:D[8.2929] → [6.1465:1466]
∅:D[12.8699] → [6.1465:1466]
B:BD[6.1465] → [6.1465:1466]
```
const VERSION: &str = "0.7.5";
```

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

B:BD[12.8726] → [12.8726:8798]

    create_directories().chain_err(|| "unable to create directories")?;

[12.8726]

[12.8798]

    utils::create_directories().chain_err(|| "unable to create directories")?;
    migration_handler::migrate_old_subscriptions()?;

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

∅:D[14.1688] → [10.1175:1213]

∅:D[12.8910] → [10.1175:1213]

B:BD[6.1637] → [10.1175:1213]

B:BD[10.1213] → [8.2930:2956]

∅:D[39.2264] → [10.1237:1287]

∅:D[8.2956] → [10.1237:1287]

B:BD[10.1237] → [10.1237:1287]

B:BD[10.1287] → [39.2265:2314]

∅:D[39.2314] → [40.907:1252]

B:BD[10.1325] → [40.907:1252]

B:BD[40.1252] → [19.3967:4719]

∅:D[19.4719] → [40.1332:1342]

B:BD[40.1332] → [40.1332:1342]

∅:D[40.1342] → [10.1325:1346]

B:BD[10.1325] → [10.1325:1346]

B:BD[10.1346] → [39.2315:2355]

∅:D[39.2355] → [10.1388:1569]

B:BD[10.1388] → [10.1388:1569]

B:BD[10.1569] → [41.1050:1135]

B:BD[41.1135] → [15.438:480]

∅:D[15.480] → [41.1177:1228]

B:BD[41.1177] → [41.1177:1228]

B:BD[41.1228] → [15.481:780]

∅:D[15.780] → [41.1228:1398]

B:BD[41.1228] → [41.1228:1398]

∅:D[41.1398] → [10.1611:1646]

B:BD[10.1611] → [10.1611:1646]

B:BD[10.1646] → [41.1399:1532]

B:BD[41.1532] → [11.2215:2256]

∅:D[11.2256] → [41.1572:1607]

B:BD[41.1572] → [41.1572:1607]

B:BD[41.1607] → [19.4720:4997]

∅:D[41.1607] → [10.1646:1788]

∅:D[19.4997] → [10.1646:1788]

B:BD[10.1646] → [10.1646:1788]

B:BD[10.1788] → [39.2356:2545]

∅:D[42.1598] → [10.1977:2302]

∅:D[39.2545] → [10.1977:2302]

B:BD[10.1977] → [10.1977:2302]

B:BD[10.2302] → [43.827:1056]

∅:D[43.1056] → [10.2302:2331]

B:BD[10.2302] → [10.2302:2331]

B:BD[10.2331] → [39.2546:2717]

B:BD[39.2717] → [8.2957:3478]

∅:D[42.1711] → [10.2443:2506]

∅:D[39.2883] → [10.2443:2506]

∅:D[8.3478] → [10.2443:2506]

B:BD[10.2443] → [10.2443:2506]

B:BD[10.2506] → [40.1343:1373]

B:BD[40.1373] → [12.8911:9218]

∅:D[12.9218] → [40.1530:1587]

B:BD[40.1530] → [40.1530:1587]

B:BD[40.1587] → [5.2518:2686]

B:BD[5.2686] → [19.4998:5328]

∅:D[19.5328] → [5.2686:2715]

B:BD[5.2686] → [5.2686:2715]

B:BD[5.2715] → [19.5329:5399]

∅:D[19.5399] → [5.2778:2818]

B:BD[5.2778] → [5.2778:2818]

∅:D[5.2818] → [12.9337:9393]

B:BD[39.3127] → [12.9337:9393]

∅:D[17.934] → [40.1707:1731]

∅:D[12.9393] → [40.1707:1731]

B:BD[40.1707] → [40.1707:1731]

B:BD[40.1731] → [15.781:901]

B:BD[15.901] → [5.2819:2883]

∅:D[5.2883] → [12.9394:9463]

B:BD[15.957] → [12.9394:9463]

∅:D[15.984] → [10.2608:2661]

∅:D[39.3226] → [10.2608:2661]

∅:D[12.9463] → [10.2608:2661]

B:BD[10.2608] → [10.2608:2661]

B:BD[10.2661] → [12.9464:9571]

∅:D[17.1048] → [10.2772:2786]

∅:D[12.9571] → [10.2772:2786]

B:BD[10.2772] → [10.2772:2786]

∅:D[10.2786] → [6.1868:1878]

B:BD[6.1868] → [6.1868:1878]

B:BD[6.1878] → [41.1608:1634]

B:BD[41.1634] → [12.9572:9867]

∅:D[12.9867] → [11.2257:2310]

B:BD[41.1779] → [11.2257:2310]

B:BD[11.2310] → [19.5400:5712]

∅:D[19.5712] → [12.9942:9997]

B:BD[12.9942] → [12.9942:9997]

∅:D[12.9997] → [11.2437:2451]

B:BD[11.2437] → [11.2437:2451]

∅:D[44.714] → [41.2142:2152]

∅:D[17.1101] → [41.2142:2152]

∅:D[11.2451] → [41.2142:2152]

B:BD[41.2142] → [41.2142:2152]

B:BD[41.2152] → [43.1057:1088]

B:BD[43.1088] → [12.9998:10371]

∅:D[12.10371] → [43.1274:1340]

B:BD[43.1274] → [43.1274:1340]

B:BD[43.1340] → [12.10372:10417]

∅:D[12.10417] → [43.1384:1405]

B:BD[43.1384] → [43.1384:1405]

B:BD[43.1405] → [12.10418:10455]

∅:D[12.10455] → [43.1441:1465]

B:BD[43.1441] → [43.1441:1465]

∅:D[43.1465] → [8.3479:3573]

B:BD[39.3460] → [8.3479:3573]

B:BD[8.3573] → [12.10456:10725]

∅:D[12.10725] → [8.3814:3856]

B:BD[8.3814] → [8.3814:3856]

B:BD[8.3856] → [12.10726:10879]

∅:D[12.10879] → [8.3933:4105]

B:BD[8.3933] → [8.3933:4105]

∅:D[8.4105] → [39.3522:3573]

B:BD[39.3522] → [39.3522:3573]

B:BD[39.3573] → [12.10880:10934]

∅:D[17.1148] → [10.3106:3123]

∅:D[45.1451] → [10.3106:3123]

∅:D[14.1765] → [10.3106:3123]

∅:D[39.3629] → [10.3106:3123]

∅:D[8.4159] → [10.3106:3123]

∅:D[12.10934] → [10.3106:3123]

B:BD[10.3106] → [10.3106:3123]

B:BD[46.1650] → [46.1650:1656]

    let matches = App::new("podcast")
        .version(VERSION)
        .author("Nathan J. <njaremko@gmail.com>")
        .about("A command line podcast manager")
        .subcommand(
            SubCommand::with_name("download")
                .about("download episodes of podcast")
                .arg(
                    Arg::with_name("PODCAST")
                        .help("Regex for subscribed podcast")
                        .required(true)
                        .index(1),
                )
                .arg(
                    Arg::with_name("EPISODE")
                        .required(false)
                        .help("Episode index")
                        .index(2),
                )
                .arg(
                    Arg::with_name("name")
                        .short("e")
                        .long("episode")
                        .help("Download using episode name instead of number")
                        .required(false),
                )
                .arg(
                    Arg::with_name("all")
                        .short("a")
                        .long("all")
                        .help("Download all matching episodes")
                        .required(false),
                ),
        )
        .subcommand(
            SubCommand::with_name("ls")
                .about("list episodes of podcast")
                .arg(
                    Arg::with_name("PODCAST")
                        .help("Regex for subscribed podcast")
                        .index(1),
                ),
        )
        .subcommand(
            SubCommand::with_name("list")
                .about("list episodes of podcast")
                .arg(
                    Arg::with_name("PODCAST")
                        .help("Regex for subscribed podcast")
                        .index(1),
                ),
        )
        .subcommand(
            SubCommand::with_name("play")
                .about("play an episode")
                .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),
                )
                .arg(
                    Arg::with_name("name")
                        .short("e")
                        .long("episode")
                        .help("Play using episode name instead of number")
                        .required(false),
                ),
        )
        .subcommand(
            SubCommand::with_name("search")
                .about("searches for podcasts")
                .arg(
                    Arg::with_name("debug")
                        .short("d")
                        .help("print debug information verbosely"),
                ),
        )
        .subcommand(
            SubCommand::with_name("subscribe")
                .about("subscribes to a podcast RSS feed")
                .arg(
                    Arg::with_name("URL")
                        .help("URL to RSS feed")
                        .required(true)
                        .index(1),
                )
                .arg(
                    Arg::with_name("download")
                        .short("d")
                        .long("download")
                        .help("auto download based on config"),
                ),
        )
        .subcommand(SubCommand::with_name("refresh").about("refresh subscribed podcasts"))
        .subcommand(SubCommand::with_name("update").about("check for updates"))
        .subcommand(
            SubCommand::with_name("rm")
                .about("unsubscribe from a podcast")
                .arg(Arg::with_name("PODCAST").help("Podcast to delete").index(1)),
        )
        .subcommand(
            SubCommand::with_name("completion")
                .about("install shell completion")
                .arg(
                    Arg::with_name("SHELL")
                        .help("Shell to print completion for")
                        .index(1),
                ),
        )
        .get_matches();
    match matches.subcommand_name() {
        Some("download") => {
            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")?;
            match download_matches.value_of("EPISODE") {
                Some(ep) => {
                    if String::from(ep).contains(|c| c == '-' || c == ',') {
                        download_range(&state, podcast, ep)?
                    } else if download_matches.occurrences_of("name") > 0 {
                        download_episode_by_name(
                            &state,
                            podcast,
                            ep,
                            download_matches.occurrences_of("all") > 0,
                        )?
                    } else {
                        download_episode_by_num(&state, podcast, ep)?
                    }
                }
                None => download_all(&state, podcast)?,
            }
        }
        Some("ls") | Some("list") => {
            let list_matches = matches
                .subcommand_matches("ls")
                .or_else(|| matches.subcommand_matches("list"))
                .chain_err(|| "unable to find subcommand matches")?;
            match list_matches.value_of("PODCAST") {
                Some(regex) => list_episodes(regex)?,
                None => list_subscriptions(&state)?,
            }
        }
        Some("play") => {
            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")?;
            match play_matches.value_of("EPISODE") {
                Some(episode) => {
                    if play_matches.occurrences_of("name") > 0 {
                        play_episode_by_name(&state, podcast, episode)?
                    } else {
                        play_episode_by_num(&state, podcast, episode)?
                    }
                }
                None => play_latest(&state, podcast)?,
            }
        }
        Some("subscribe") => {
            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")?;
            if subscribe_matches.occurrences_of("download") > 0 {
                download_rss(&config, url)?;
            } else {
                subscribe_rss(url)?;
            }
        }
        Some("search") => println!("This feature is coming soon..."),
        Some("rm") => {
            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)?
        }
        Some("completion") => {
            let matches = matches
                .subcommand_matches("completion")
                .chain_err(|| "unable to find subcommand matches")?;
            match matches.value_of("SHELL") {
                Some(shell) => print_completion(shell),
                None => print_completion(""),
            }
        }
        Some("refresh") => update_rss(&mut state),
        Some("update") => check_for_update(VERSION)?,
        _ => (),
    }

[12.8910]

[12.10935]

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

File addition: match_handler.rs (----------)

[6.217]

use clap::ArgMatches;
use crate::actions::*;
use crate::errors::*;
use crate::structs::*;
pub fn handle_matches(
    version: &str,
    state: &mut State,
    config: &Config,
    matches: &ArgMatches,
) -> Result<()> {
    match matches.subcommand_name() {
        Some("download") => {
            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")?;
            match download_matches.value_of("EPISODE") {
                Some(ep) => {
                    if String::from(ep).contains(|c| c == '-' || c == ',') {
                        download_range(&state, podcast, ep)?
                    } else if download_matches.occurrences_of("name") > 0 {
                        download_episode_by_name(
                            &state,
                            podcast,
                            ep,
                            download_matches.occurrences_of("all") > 0,
                        )?
                    } else {
                        download_episode_by_num(&state, podcast, ep)?
                    }
                }
                None => download_all(&state, podcast)?,
            }
        }
        Some("ls") | Some("list") => {
            let list_matches = matches
                .subcommand_matches("ls")
                .or_else(|| matches.subcommand_matches("list"))
                .chain_err(|| "unable to find subcommand matches")?;
            match list_matches.value_of("PODCAST") {
                Some(regex) => list_episodes(regex)?,
                None => list_subscriptions(&state)?,
            }
        }
        Some("play") => {
            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")?;
            match play_matches.value_of("EPISODE") {
                Some(episode) => {
                    if play_matches.occurrences_of("name") > 0 {
                        play_episode_by_name(&state, podcast, episode)?
                    } else {
                        play_episode_by_num(&state, podcast, episode)?
                    }
                }
                None => play_latest(&state, podcast)?,
            }
        }
        Some("sub") | Some("subscribe") => {
            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")?;
            if subscribe_matches.occurrences_of("download") > 0 {
                download_rss(&config, url)?;
            } else {
                subscribe_rss(url)?;
            }
        }
        Some("search") => println!("This feature is coming soon..."),
        Some("rm") => {
            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(state, regex)?
        }
        Some("completion") => {
            let matches = matches
                .subcommand_matches("completion")
                .chain_err(|| "unable to find subcommand matches")?;
            match matches.value_of("SHELL") {
                Some(shell) => print_completion(shell),
                None => print_completion(""),
            }
        }
        Some("refresh") => update_rss(state),
        Some("update") => check_for_update(version)?,
        _ => (),
    };
    Ok(())
}

File addition: migration_handler.rs (----------)

[6.217]

use crate::errors::*;
use crate::utils::*;
use std::fs;
pub fn migrate_old_subscriptions() -> Result<()> {
    let path = get_podcast_dir()?;
    let mut old_path = path.clone();
    old_path.push(".subscriptions");
    if old_path.exists() {
        println!("Migrating old subscriptions file...");
        let new_path = get_sub_file()?;
        fs::rename(&old_path, &new_path)
            .chain_err(|| format!("Unable to move {:?} to {:?}", &old_path, &new_path))?;
    }
    Ok(())
}

File addition: parser.rs (----------)

[6.217]

use clap::{App, Arg, ArgMatches, SubCommand};
pub fn get_matches<'a>(version: &str) -> ArgMatches<'a> {
    App::new("podcast")
        .version(version)
        .author("Nathan J. <njaremko@gmail.com>")
        .about("A command line podcast manager")
        .subcommand(
            SubCommand::with_name("download")
                .about("download episodes of podcast")
                .arg(
                    Arg::with_name("PODCAST")
                        .help("Regex for subscribed podcast")
                        .required(true)
                        .index(1),
                )
                .arg(
                    Arg::with_name("EPISODE")
                        .required(false)
                        .help("Episode index")
                        .index(2),
                )
                .arg(
                    Arg::with_name("name")
                        .short("e")
                        .long("episode")
                        .help("Download using episode name instead of index number")
                        .required(false),
                )
                .arg(
                    Arg::with_name("all")
                        .short("a")
                        .long("all")
                        .help("Download all matching episodes")
                        .required(false),
                ),
        )
        .subcommand(
            SubCommand::with_name("ls")
                .about("list episodes of podcast")
                .arg(
                    Arg::with_name("PODCAST")
                        .help("Regex for subscribed podcast")
                        .index(1),
                ),
        )
        .subcommand(
            SubCommand::with_name("list")
                .about("list episodes of podcast")
                .arg(
                    Arg::with_name("PODCAST")
                        .help("Regex for subscribed podcast")
                        .index(1),
                ),
        )
        .subcommand(
            SubCommand::with_name("play")
                .about("play an episode")
                .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),
                )
                .arg(
                    Arg::with_name("name")
                        .short("e")
                        .long("episode")
                        .help("Play using episode name instead of index number")
                        .required(false),
                ),
        )
        .subcommand(
            SubCommand::with_name("search")
                .about("searches for podcasts")
                .arg(
                    Arg::with_name("debug")
                        .short("d")
                        .help("print debug information verbosely"),
                ),
        )
        .subcommand(
            SubCommand::with_name("subscribe")
                .about("subscribes to a podcast RSS feed")
                .arg(
                    Arg::with_name("URL")
                        .help("URL to RSS feed")
                        .required(true)
                        .index(1),
                )
                .arg(
                    Arg::with_name("download")
                        .short("d")
                        .long("download")
                        .help("auto download based on config"),
                ),
        )
        .subcommand(
            SubCommand::with_name("sub")
                .about("subscribes to a podcast RSS feed")
                .arg(
                    Arg::with_name("URL")
                        .help("URL to RSS feed")
                        .required(true)
                        .index(1),
                )
                .arg(
                    Arg::with_name("download")
                        .short("d")
                        .long("download")
                        .help("auto download based on config"),
                ),
        )
        .subcommand(SubCommand::with_name("refresh").about("refresh subscribed podcasts"))
        .subcommand(SubCommand::with_name("update").about("check for updates"))
        .subcommand(
            SubCommand::with_name("rm")
                .about("unsubscribe from a podcast")
                .arg(Arg::with_name("PODCAST").help("Podcast to delete").index(1)),
        )
        .subcommand(
            SubCommand::with_name("completion")
                .about("install shell completion")
                .arg(
                    Arg::with_name("SHELL")
                        .help("Shell to print completion for")
                        .index(1),
                ),
        )
        .get_matches()
}

Replacement in src/structs.rs at line 6 [6.234]
B:BD[11.2500] → [12.11007:11046]
∅:D[12.11046] → [11.2568:2613]
B:BD[11.2568] → [11.2568:2613]
```
use std::fs::{self, DirBuilder, File};
use std::io::{self, BufReader, Read, Write};
```
[11.2500]
[11.2613]
```
use std::fs::{self, File};
use std::io::{self, BufReader, Write};
```
Deletion in src/structs.rs at line 12 [6.234]
∅:D[34.200] → [10.3131:3144]
∅:D[47.257] → [10.3131:3144]
∅:D[42.2014] → [10.3131:3144]
B:BD[6.234] → [10.3131:3144]
```
use reqwest;
```
Replacement in src/structs.rs at line 14 [6.234]
B:BD[10.3257] → [14.1767:1794]
```
use yaml_rust::YamlLoader;
```
[23.192]
[14.1794]
```
use std::path::PathBuf;
```
Insertion in src/structs.rs at line 27 [6.234]
[34.299]
[14.1795]
```
#[derive(Debug, PartialEq, Serialize, Deserialize)]
```

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

∅:D[12.11154] → [14.1969:2005]

B:BD[14.1969] → [14.1969:2005]

B:BD[14.2039] → [14.2039:2135]

B:BD[14.2135] → [12.11155:11461]

∅:D[12.11461] → [48.435:471]

B:BD[14.2272] → [48.435:471]

∅:D[48.471] → [14.2306:2459]

B:BD[14.2306] → [14.2306:2459]

        let mut download_limit = 1;
        path.push(".config");
        if path.exists() {
            let mut s = String::new();
            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")?;
            if !config.is_empty() {
                let doc = &config[0];
                if let Some(val) = doc["auto_download_limit"].as_i64() {
                    download_limit = val;

[12.11154]

[14.2459]

        path.push(".config.yaml");
        let config = if path.exists() {
            let file = File::open(&path).chain_err(|| UNABLE_TO_OPEN_FILE)?;
            match serde_yaml::from_reader(file) {
                Ok(config) => config,
                Err(err) => {
                    let mut new_path = path.clone();
                    new_path.set_extension("yaml.bk");
                    eprintln!("{}", err);
                    eprintln!("Failed to open config file, moving to {:?}", &new_path);
                    fs::rename(&path, new_path)
                        .chain_err(|| "Failed to move old config file...")?;
                    create_new_config_file(&path)?

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

B:BD[49.158] → [12.11462:11655]

∅:D[49.279] → [14.2620:2630]

∅:D[12.11655] → [14.2620:2630]

B:BD[14.2620] → [14.2620:2630]

B:BD[14.2630] → [12.11656:11676]

∅:D[12.11676] → [14.2647:2696]

B:BD[14.2647] → [14.2647:2696]

B:BD[14.2696] → [12.11677:11688]

            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)?;
        }
        Ok(Config {
            auto_download_limit: download_limit,
        })

[49.158]

[14.2751]

            create_new_config_file(&path)?
        };
        Ok(config)

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

B:BD[14.2761] → [20.267:315]

#[derive(Serialize, Deserialize, Clone, Debug)]

[14.2761]

[10.3347]

fn create_new_config_file(path: &PathBuf) -> Result<Config> {
    println!("Creating new config file at {:?}", &path);
    let download_limit = 1;
    let file = File::create(&path).chain_err(|| UNABLE_TO_CREATE_FILE)?;
    let config = Config {
        auto_download_limit: download_limit,
    };
    serde_yaml::to_writer(file, &config).chain_err(|| UNABLE_TO_WRITE_FILE)?;
    Ok(config)
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]

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

B:BD[10.3419] → [20.316:364]

#[derive(Serialize, Deserialize, Clone, Debug)]

[10.3419]

[50.182]

#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]

Replacement in src/structs.rs at line 84 [6.234]
B:BD[12.11738] → [12.11738:11781]
∅:D[49.402] → [10.3581:3618]
∅:D[13.939] → [10.3581:3618]
∅:D[16.1352] → [10.3581:3618]
∅:D[12.11781] → [10.3581:3618]
B:BD[10.3581] → [10.3581:3618]
```
        let mut path = get_podcast_dir()?;
        path.push(".subscriptions");
```
[12.11738]
[10.3618]
```
        let path = get_sub_file()?;
```

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

B:BD[10.3645] → [10.3645:3684]

B:BD[10.3684] → [38.614:838]

∅:D[38.838] → [32.663:731]

∅:D[12.11966] → [32.663:731]

B:BD[32.663] → [32.663:731]

            let mut s = String::new();
            {
                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)?;
            }
            let mut state: State = match serde_json::from_str(&s) {

[10.3645]

[32.731]

            let file = File::open(&path).chain_err(|| UNABLE_TO_OPEN_FILE)?;
            let mut state: State = match serde_json::from_reader(&file) {

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

B:BD[21.718] → [12.11967:12113]

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

[21.718]

[21.800]

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

Replacement in src/structs.rs at line 106 [6.234]
B:BD[51.289] → [31.121:147]
```
            if Utc::now()
```
[51.289]
[31.147]
```
            if 86400 < Utc::now()
```
Deletion in src/structs.rs at line 109 [6.234]
B:BD[5.2983] → [5.2983:3007]
```
                > 86400
```

Insertion in src/structs.rs at line 117 [6.234]

[10.3819]

[49.489]

            println!("Creating new file {:?}", &path);

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

B:BD[10.3992] → [16.1996:2031]

            set.insert(sub.title);

[10.3992]

[10.4025]

            set.insert(sub.title.clone());

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

B:BD[10.4395] → [10.4395:4450]

B:BD[10.4450] → [21.1412:1447]

    pub fn subscriptions(&self) -> Vec<Subscription> {
        self.subscriptions.clone()

[10.4395]

[10.4473]

    pub fn subscriptions(&self) -> &[Subscription] {
        &self.subscriptions
    }
    pub fn subscriptions_mut(&mut self) -> &mut [Subscription] {
        &mut self.subscriptions

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

B:BD[12.12478] → [12.12478:12521]

∅:D[12.12521] → [46.2114:2155]

B:BD[52.68] → [46.2114:2155]

        let mut path = get_podcast_dir()?;
        path.push(".subscriptions.tmp");

[12.12478]

[12.12522]

        let mut path = get_sub_file()?;
        path.set_extension("json.tmp");

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

∅:D[38.1048] → [12.12796:12879]

B:BD[12.12796] → [12.12796:12879]

        fs::rename(&path, get_sub_file()?).chain_err(|| "unable to rename file")?;

[38.1048]

[10.4757]

        let sub_file_path = get_sub_file()?;
        fs::rename(&path, &sub_file_path)
            .chain_err(|| format!("unable to rename file {:?} to {:?}", &path, &sub_file_path))?;

Deletion in src/structs.rs at line 219 [6.234]
B:BD[8.4438] → [8.4438:4439]

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

B:BD[12.13555] → [12.13555:13662]

        let path = get_xml_dir()?;
        fs::remove_dir_all(path).chain_err(|| UNABLE_TO_READ_DIRECTORY)

[12.13555]

[10.5100]

        fs::remove_dir_all(get_xml_dir()?).chain_err(|| UNABLE_TO_READ_DIRECTORY)

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

B:BD[6.667] → [12.13663:13709]

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

[6.667]

[6.741]

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

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

B:BD[12.13753] → [3.55:141]

        print!("You are about to download all episodes of {} (y/n): ", self.title());

[12.13753]

[36.266]

        print!(
            "You are about to download all episodes of {} (y/n): ",
            self.title()
        );

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

∅:D[34.361] → [36.767:840]

B:BD[36.767] → [36.767:840]

                            if let Err(err) = i.download(self.title()) {

[34.361]

[12.13954]

                            if let Err(err) = download(self.title(), i) {

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

∅:D[48.944] → [42.2145:2210]

∅:D[36.1091] → [42.2145:2210]

B:BD[10.5531] → [42.2145:2210]

                    if let Err(err) = i.download(self.title()) {

[48.944]

[12.14009]

                    if let Err(err) = download(self.title(), i) {

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

∅:D[34.415] → [53.813:910]

B:BD[53.813] → [53.813:910]

                    if let Err(err) = episodes[episodes.len() - ep_num].download(self.title()) {

[34.415]

[2.783]

                    if let Err(err) = download(self.title(), &episodes[episodes.len() - ep_num]) {

Deletion in src/structs.rs at line 319 [6.234]

B:BD[10.6274] → [10.6274:6275]

B:BD[10.6275] → [12.14406:14469]

B:BD[12.14469] → [2.830:866]

∅:D[2.866] → [12.14469:14512]

B:BD[12.14469] → [12.14469:14512]

∅:D[12.14512] → [10.6391:6424]

B:BD[10.6391] → [10.6391:6424]

B:BD[10.6424] → [12.14513:14651]

∅:D[40.1799] → [10.6424:6425]

∅:D[12.14651] → [10.6424:6425]

B:BD[10.6424] → [10.6424:6425]

B:BD[10.6425] → [44.849:889]

∅:D[44.889] → [10.6474:6522]

B:BD[10.6474] → [10.6474:6522]

B:BD[10.6522] → [5.3429:3634]

∅:D[23.334] → [10.6701:6738]

∅:D[5.3634] → [10.6701:6738]

∅:D[12.14772] → [10.6701:6738]

B:BD[10.6701] → [10.6701:6738]

B:BD[10.6738] → [11.2793:2829]

B:BD[11.2829] → [2.867:1062]

∅:D[2.1062] → [12.14773:14963]

B:BD[11.2902] → [12.14773:14963]

∅:D[12.14963] → [11.3022:3081]

B:BD[11.3022] → [11.3022:3081]

B:BD[11.3081] → [12.14964:15087]

B:BD[12.15087] → [5.3635:3742]

∅:D[5.3742] → [11.3216:3241]

∅:D[12.15169] → [11.3216:3241]

B:BD[11.3216] → [11.3216:3241]

B:BD[11.3241] → [2.1063:1245]

∅:D[2.1245] → [11.3357:3375]

∅:D[12.15352] → [11.3357:3375]

B:BD[11.3357] → [11.3357:3375]

∅:D[11.3375] → [10.7029:7043]

B:BD[10.7029] → [10.7029:7043]

∅:D[10.7043] → [6.1291:1301]

B:BD[6.1291] → [6.1291:1301]

B:BD[6.1301] → [10.7044:7059]

∅:D[10.7059] → [6.1301:1307]

B:BD[6.1301] → [6.1301:1307]


    pub fn download(&self, podcast_name: &str) -> Result<()> {
        let stdout = io::stdout();
        let mut path = get_podcast_dir()?;
        path.push(podcast_name);
        DirBuilder::new()
            .recursive(true)
            .create(&path)
            .chain_err(|| UNABLE_TO_CREATE_DIRECTORY)?;
        if let Some(url) = self.url() {
            if let Some(title) = self.title() {
                let mut filename = title;
                filename.push_str(
                    self.extension()
                        .chain_err(|| "unable to retrieve extension")?,
                );
                path.push(filename);
                if !path.exists() {
                    {
                        let mut handle = stdout.lock();
                        writeln!(&mut handle, "Downloading: {}", path.to_str().unwrap()).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.to_str().chain_err(|| UNABLE_TO_CONVERT_TO_STR)?).ok();
                }
            }
        }
        Ok(())
    }

Insertion in src/utils.rs at line 15 [10.7061]

[5.3968]

pub const UNABLE_TO_READ_FILE: &str = "unable to read file";

Insertion in src/utils.rs at line 29 [10.7061]
[5.4864]
[54.2459]

Insertion in src/utils.rs at line 64 [10.7061]

[10.7245]

[12.17053]

pub fn create_dir_if_not_exist(path: &PathBuf) -> Result<()> {
    DirBuilder::new()
        .recursive(true)
        .create(&path)
        .chain_err(|| UNABLE_TO_CREATE_DIRECTORY)?;
        Ok(())
}

Replacement in src/utils.rs at line 75 [10.7061]

B:BD[12.17159] → [12.17159:17281]

    DirBuilder::new()
        .recursive(true)
        .create(&path)
        .chain_err(|| "unable to create directory")

[12.17159]

[12.17281]

    create_dir_if_not_exist(&path)

Insertion in src/utils.rs at line 77 [10.7061]

[12.17283]


pub fn delete(title: &str) -> Result<()> {
        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)
    }

Insertion in src/utils.rs at line 86 [10.7061]

[12.17284]

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

Replacement in src/utils.rs at line 117 [10.7061]
∅:D[12.17738] → [54.3376:3409]
B:BD[54.3376] → [54.3376:3409]
```
    path.push(".subscriptions");
```
[12.17738]
[12.17739]
```
    path.push(".subscriptions.json");
```

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

B:BD[43.1758] → [12.17946:18068]

    DirBuilder::new()
        .recursive(true)
        .create(&path)
        .chain_err(|| "unable to open directory")?;

[43.1758]

[12.18068]

    create_dir_if_not_exist(&path)?;

Improve code

Dependencies

In channels

Change contents

Insertion in CHANGELOG at line 1 [4.1]

Replacement in Cargo.toml at line 4 [6.62]

Replacement in Cargo.toml at line 34 [6.62]

Replacement in src/actions.rs at line 1 [10.163]

Replacement in src/actions.rs at line 19 [10.163]

Replacement in src/actions.rs at line 56 [10.163]

Insertion in src/actions.rs at line 60 [10.163]

Replacement in src/actions.rs at line 65 [10.163]

Replacement in src/actions.rs at line 76 [10.163]

Deletion in src/actions.rs at line 94 [10.163]

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

Replacement in src/actions.rs at line 104 [10.163]

Replacement in src/actions.rs at line 108 [10.163]

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

Replacement in src/actions.rs at line 161 [10.163]

Replacement in src/actions.rs at line 169 [10.163]

Insertion in src/actions.rs at line 178 [10.163]

Insertion in src/actions.rs at line 189 [10.163]

Replacement in src/actions.rs at line 239 [10.163]

Replacement in src/actions.rs at line 242 [10.163]

Insertion in src/actions.rs at line 249 [10.163]

Replacement in src/actions.rs at line 252 [10.163]

Replacement in src/actions.rs at line 259 [10.163]

Replacement in src/actions.rs at line 386 [10.163]

Deletion in src/actions.rs at line 458 [10.163]

Replacement in src/actions.rs at line 506 [10.163]

Replacement in src/actions.rs at line 516 [10.163]

Replacement in src/actions.rs at line 526 [10.163]

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

Deletion in src/main.rs at line 19 [6.1346]

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

Deletion in src/main.rs at line 27 [6.1346]

Deletion in src/main.rs at line 30 [6.1346]

Deletion in src/main.rs at line 32 [6.1346]

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

Deletion in src/main.rs at line 35 [6.1346]

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

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

File addition: match_handler.rs (----------)

File addition: migration_handler.rs (----------)

File addition: parser.rs (----------)

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

Deletion in src/structs.rs at line 12 [6.234]

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

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

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

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

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

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

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

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

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

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

Deletion in src/structs.rs at line 109 [6.234]

Insertion in src/structs.rs at line 117 [6.234]

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

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

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

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

Deletion in src/structs.rs at line 219 [6.234]

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

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

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

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

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

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

Deletion in src/structs.rs at line 319 [6.234]

Insertion in src/utils.rs at line 15 [10.7061]

Insertion in src/utils.rs at line 29 [10.7061]

Insertion in src/utils.rs at line 64 [10.7061]

Replacement in src/utils.rs at line 75 [10.7061]

Insertion in src/utils.rs at line 77 [10.7061]

Insertion in src/utils.rs at line 86 [10.7061]

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

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