njaremko/podcast - Change ELOFCNQ3LBRPKY33PMIHYSM32UIDSHJIM3W6ZO6TMRTO26NNIQHAC

Refactor podcast searching logic into it's own library: podcast_search

Created by jaremn on July 15, 2020

ELOFCNQ3LBRPKY33PMIHYSM32UIDSHJIM3W6ZO6TMRTO26NNIQHAC

Dependencies

In channels

main

Change contents

Replacement in Cargo.toml at line 4 [4.62]
B:BD[3.80] → [2.57:76]
```
version = "0.15.0"
```
[3.80]
[5.1199]
```
version = "0.16.0"
```

Replacement in Cargo.toml at line 39 [4.62]

B:BD[6.179] → [6.179:226]

tokio = { version = "0.2", features = ["full"]}

[6.179]

tokio = { version = "0.2", features = ["full"]}
podcast_search = "0.1"

File deletion: search.rs

BF:BFD[4.217] → [7.1807:1840]

BF:BFD[7.1840] → [7.1:1]

B:BD[7.1] → [7.2:22]

B:BD[7.22] → [8.614:677]

∅:D[8.677] → [7.87:100]

B:BD[7.87] → [7.87:100]

∅:D[2.734] → [7.116:117]

B:BD[7.116] → [7.116:117]

B:BD[7.117] → [2.735:1345]

∅:D[2.1345] → [7.117:176]

B:BD[7.117] → [7.117:176]

∅:D[2.4848] → [7.249:252]

B:BD[7.249] → [7.249:252]

∅:D[2.4944] → [7.333:340]

B:BD[7.333] → [7.333:340]

∅:D[2.5021] → [7.399:708]

B:BD[7.399] → [7.399:708]

∅:D[2.5096] → [7.752:753]

B:BD[7.752] → [7.752:753]

∅:D[2.5509] → [7.1048:1061]

∅:D[6.6525] → [7.1048:1061]

B:BD[7.1048] → [7.1048:1061]

∅:D[2.5607] → [8.757:919]

∅:D[6.6612] → [8.757:919]

B:BD[7.1141] → [8.757:919]

∅:D[8.919] → [7.1307:1398]

B:BD[7.1307] → [7.1307:1398]

∅:D[2.5684] → [7.1488:1501]

∅:D[6.6678] → [7.1488:1501]

B:BD[7.1488] → [7.1488:1501]

∅:D[2.5766] → [8.920:998]

∅:D[6.6752] → [8.920:998]

B:BD[7.1568] → [8.920:998]

∅:D[2.5932] → [7.1794:1806]

∅:D[6.6821] → [7.1794:1806]

B:BD[7.1794] → [7.1794:1806]

B:BD[8.998] → [2.5767:5932]

B:BD[7.1501] → [2.5685:5766]

B:BD[7.1398] → [2.5608:5684]

B:BD[7.1061] → [2.5510:5607]

B:BD[7.753] → [2.5097:5509]

B:BD[7.708] → [2.5022:5096]

B:BD[7.340] → [2.4945:5021]

B:BD[7.252] → [2.4849:4944]

B:BD[7.176] → [2.1346:4848]

B:BD[7.100] → [2.548:734]

use failure::Error;
use percent_encoding::{utf8_percent_encode, NON_ALPHANUMERIC};
use reqwest;
#[derive(Debug, Serialize, Deserialize)]
pub struct ArtistSearchResult {
    #[serde(rename = "wrapperType")]
    pub wrapper_type: Option<String>,
    #[serde(rename = "artistType")]
    pub artist_type: Option<String>,
    #[serde(rename = "artistName")]
    pub artist_name: Option<String>,
    #[serde(rename = "artistLinkUrl")]
    pub artist_link_url: Option<String>,
    #[serde(rename = "artistId")]
    pub artist_id: Option<i64>,
    #[serde(rename = "primaryGenreName")]
    pub primary_genre_name: Option<String>,
    #[serde(rename = "primaryGenreId")]
    pub primary_genre_id: Option<i64>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
}
    }
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct RssResponse {
    error: Option<String>,
    url: Option<String>,
}
impl RssResponse {
    pub fn error(&self) -> &Option<String> {
        &self.error
    }
    pub fn url(&self) -> &Option<String> {
        &self.url
    }
}
    Ok(r)
}
    let podcast_encoded = utf8_percent_encode(podcast, NON_ALPHANUMERIC).to_string();
    let ep_encoded = utf8_percent_encode(ep, NON_ALPHANUMERIC).to_string();
    let url = BASE.to_string() + "/query/" + &podcast_encoded + "/episode/" + &ep_encoded;
    Ok(r)
}
    let encoded = utf8_percent_encode(podcast, NON_ALPHANUMERIC).to_string();
    Ok(r)
}
    let url =  format!("https://itunes.apple.com/lookup?id={}&entity=podcast", encoded);
    let r = reqwest::get(&url).await?.json::<TrackSearchResponse>().await?;
pub async fn retrieve_rss(podcast: &str) -> Result<TrackSearchResponse, Error> {
    let r = reqwest::get(&url).await?.json::<TrackSearchResponse>().await?;
pub async fn search_for_episode(podcast: &str, ep: &str) -> Result<TrackSearchResponse, Error> {
pub async fn search_for_podcast(podcast: &str) -> Result<TrackSearchResponse, Error> {
    let encoded: String = podcast.chars().map(|c| {
        if c == ' ' {
            return '+';
        }
        return c;
    }).collect();
    let url =  format!("https://itunes.apple.com/search?media=podcast&entity=podcast&term={}", encoded);
    let r = reqwest::get(&url).await?.json::<TrackSearchResponse>().await?;
const BASE: &str = "https://itunes.apple.com/search?media=podcast&term=";
    pub fn results(&self) -> &[PodcastSearchResult] {
        &self.results
impl TrackSearchResponse {
    pub fn result_count(&self) -> usize {
        self.result_count
pub struct PodcastSearchResult {
    #[serde(rename = "wrapperType")]
    wrapper_type: Option<WrapperType>,
    kind: Option<Kind>,
    #[serde(rename = "artistId")]
    artist_id: Option<i64>,
    #[serde(rename = "collectionId")]
    collection_id: Option<i64>,
    #[serde(rename = "trackId")]
    track_id: Option<i64>,
    #[serde(rename = "artistName")]
    artist_name: Option<String>,
    #[serde(rename = "collectionName")]
    pub collection_name: Option<String>,
    #[serde(rename = "trackName")]
    track_name: Option<String>,
    #[serde(rename = "collectionCensoredName")]
    collection_censored_name: Option<String>,
    #[serde(rename = "trackCensoredName")]
    track_censored_name: Option<String>,
    #[serde(rename = "artistViewUrl")]
    artist_view_url: Option<String>,
    #[serde(rename = "collectionViewUrl")]
    collection_view_url: Option<String>,
    #[serde(rename = "feedUrl")]
    pub feed_url: Option<String>,
    #[serde(rename = "trackViewUrl")]
    track_view_url: Option<String>,
    #[serde(rename = "artworkUrl30")]
    artwork_url30: Option<String>,
    #[serde(rename = "artworkUrl60")]
    artwork_url60: Option<String>,
    #[serde(rename = "artworkUrl100")]
    artwork_url100: Option<String>,
    #[serde(rename = "collectionPrice")]
    collection_price: Option<f64>,
    #[serde(rename = "trackPrice")]
    track_price: Option<f64>,
    #[serde(rename = "trackRentalPrice")]
    track_rental_price: Option<f64>,
    #[serde(rename = "collectionHdPrice")]
    collection_hd_price: Option<f64>,
    #[serde(rename = "trackHdPrice")]
    track_hd_price: Option<f64>,
    #[serde(rename = "trackHdRentalPrice")]
    track_hd_rental_price: Option<f64>,
    #[serde(rename = "releaseDate")]
    release_date: Option<String>,
    #[serde(rename = "collectionExplicitness")]
    collection_explicitness: Option<Explicitness>,
    #[serde(rename = "trackExplicitness")]
    track_explicitness: Option<Explicitness>,
    #[serde(rename = "trackCount")]
    track_count: Option<i64>,
    country: Option<Country>,
    currency: Option<Currency>,
    #[serde(rename = "primaryGenreName")]
    primary_genre_name: Option<String>,
    #[serde(rename = "contentAdvisoryRating")]
    content_advisory_rating: Option<ContentAdvisoryRating>,
    #[serde(rename = "artworkUrl600")]
    artwork_url600: Option<String>,
    #[serde(rename = "genreIds")]
    genre_ids: Option<Vec<String>>,
    genres: Option<Vec<String>>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum Explicitness {
    #[serde(rename = "cleaned")]
    Cleaned,
    #[serde(rename = "explicit")]
    Explicit,
    #[serde(rename = "notExplicit")]
    NotExplicit,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum ContentAdvisoryRating {
    Clean,
    Explicit,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum Country {
    #[serde(rename = "USA")]
    Usa,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum Currency {
    #[serde(rename = "USD")]
    Usd,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum Kind {
    #[serde(rename = "podcast")]
    Podcast,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum WrapperType {
    #[serde(rename = "track")]
    Track,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct TrackSearchResponse {
    #[serde(rename = "resultCount")]
    pub result_count: usize,
    pub results: Vec<PodcastSearchResult>
#[derive(Debug, Serialize, Deserialize)]
pub struct ArtistSearchResponse {
    #[serde(rename = "resultCount")]
    pub result_count: usize,
    pub results: Vec<ArtistSearchResult>,
}

Deletion in src/arg_parser.rs at line 12 [11.3622]
B:BD[9.2958] → [10.757:776]
```
use crate::search;
```

Replacement in src/arg_parser.rs at line 114 [11.3622]

B:BD[10.1263] → [6.2621:2680]

    let resp = search::search_for_podcast(podcast).await?;

[10.1263]

[2.161]

    let resp = podcast_search::search(podcast).await?;

Replacement in src/arg_parser.rs at line 124 [11.3622]

B:BD[2.251] → [2.251:360]

            writeln!(&mut lock, "({}) {}", i, r.collection_name.clone().unwrap_or_else(|| "".to_string()))?;

[2.251]

[11.7522]

            writeln!(
                &mut lock,
                "({}) {} [{}]",
                i,
                r.collection_name.clone().unwrap_or_else(|| "".to_string()),
                r.feed_url.clone().unwrap_or_else(|| "".to_string())
            )?;

Deletion in src/main.rs at line 28 [4.1346]
B:BD[9.15262] → [10.3252:3264]
```
mod search;
```
Replacement in src/main.rs at line 41 [4.1346]
B:BD[12.2900] → [2.514:546]
```
const VERSION: &str = "0.15.0";
```
[12.2900]
[13.2182]
```
const VERSION: &str = "0.16.0";
```
Replacement in src/structs.rs at line 254 [4.234]
B:BD[14.6274] → [2.5934:5935]
```
}
```
[14.6274]
```
}
```

Refactor podcast searching logic into it's own library: podcast_search

Dependencies

In channels

Change contents

Replacement in Cargo.toml at line 4 [4.62]

Replacement in Cargo.toml at line 39 [4.62]

File deletion: search.rs

Deletion in src/arg_parser.rs at line 12 [11.3622]

Replacement in src/arg_parser.rs at line 114 [11.3622]

Replacement in src/arg_parser.rs at line 124 [11.3622]

Deletion in src/main.rs at line 28 [4.1346]

Replacement in src/main.rs at line 41 [4.1346]

Replacement in src/structs.rs at line 254 [4.234]