protozoa 0.1.8

A scraper for various anime websites
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

use std::{cmp::min, str::Chars};

use anyhow::Context as _;
use serde_json::Value;

#[derive(Clone, Debug, PartialEq)]
pub struct SearchResult {
	pub title: String,
	pub id: String,
}

pub async fn search(query: &str) -> Result<SearchResult, anyhow::Error> {
	let json: Value = reqwest::get(format!(
		"https://myanimelist.net/search/prefix.json?type=anime&keyword={query}"
	))
	.await?
	.json()
	.await?;

	let items = json["categories"][0]["items"]
		.as_array()
		.context("No items")?;

	let results: Vec<SearchResult> = items
		.iter()
		.map(|item| {
			let title = item["name"].as_str().unwrap();
			let id = item["id"].as_u64().unwrap();

			SearchResult {
				title: title.to_string(),
				id: id.to_string(),
			}
		})
		.collect();

	let best = results
		.iter()
		.max_by(|a, b|{
			normalized_levenshtein(&a.title, query)
				.partial_cmp(&normalized_levenshtein(&b.title, query))
				.unwrap()
		})
		.context("No results")?;

	Ok(best.clone())
}

// https://github.com/rapidfuzz/strsim-rs/blob/main/src/lib.rs#L166
struct StringWrapper<'a>(&'a str);

impl<'b> IntoIterator for &StringWrapper<'b> {
	type Item = char;
	type IntoIter = Chars<'b>;

	fn into_iter(self) -> Self::IntoIter {
		self.0.chars()
	}
}

// https://github.com/rapidfuzz/strsim-rs/blob/main/src/lib.rs#L233
fn generic_levenshtein<'a, 'b, Iter1, Iter2, Elem1, Elem2>(a: &'a Iter1, b: &'b Iter2) -> usize
where
	&'a Iter1: IntoIterator<Item = Elem1>,
	&'b Iter2: IntoIterator<Item = Elem2>,
	Elem1: PartialEq<Elem2>,
{
	let b_len = b.into_iter().count();
	let mut cache: Vec<usize> = (1..b_len + 1).collect();
	let mut result = b_len;
	for (i, a_elem) in a.into_iter().enumerate() {
		result = i + 1;
		let mut distance_b = i;
		for (j, b_elem) in b.into_iter().enumerate() {
			let cost = usize::from(a_elem != b_elem);
			let distance_a = distance_b + cost;
			distance_b = cache[j];
			result = min(result + 1, min(distance_a, distance_b + 1));
			cache[j] = result;
		}
	}
	result
}

// https://github.com/rapidfuzz/strsim-rs/blob/main/src/lib.rs#L269
fn levenshtein(a: &str, b: &str) -> usize {
	generic_levenshtein(&StringWrapper(a), &StringWrapper(b))
}

// https://github.com/rapidfuzz/strsim-rs/blob/main/src/lib.rs#L285
fn normalized_levenshtein(a: &str, b: &str) -> f64 {
	if a.is_empty() && b.is_empty() {
		return 1.0;
	}
	1.0 - (levenshtein(a, b) as f64) / (a.chars().count().max(b.chars().count()) as f64)
}

#[tokio::test]
async fn test_search() {
	let result = search("One Piece").await.unwrap();
	assert_eq!(
		result,
		SearchResult {
			title: "One Piece".to_string(),
			id: "21".to_string(),
		}
	);
}