Clippy

18 files changed, 61 insertions, 75 deletions

diff --git a/builder/src/main.rs b/builder/src/main.rs
index 319963e..5878893 100644
--- a/builder/src/main.rs
+++ b/builder/src/main.rs
@@ -18,9 +18,9 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let docker_root = crates.main_cache_dir().join("docker");
     prepare_docker(&docker_root)?;
 
-    let filter = std::env::args().skip(1).next();
+    let filter = std::env::args().nth(1);
 
-    for (_, all) in crates.all_crates_io_crates() {
+    for all in crates.all_crates_io_crates().values() {
         if stopped() {
             break;
         }
@@ -38,7 +38,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 }
 
 fn analyze_crate(all: &CratesIndexCrate, db: &BuildDb, crates: &KitchenSink, docker_root: &Path) -> Result<(), Box<dyn std::error::Error>> {
-    let ref origin = Origin::from_crates_io_name(all.name());
+    let origin = &Origin::from_crates_io_name(all.name());
 
     let compat_info = db.get_compat(origin)?;
     // look for missing 1.24 tests (ignoring the "probably" ones that aren't authoritative)
diff --git a/builder/src/parse.rs b/builder/src/parse.rs
index fa40281..617875f 100644
--- a/builder/src/parse.rs
+++ b/builder/src/parse.rs
@@ -74,10 +74,8 @@ fn parse_analysis(stdout: &str, stderr: &str) -> Option<Findings> {
                         findings.crates.insert((None, name, ver, Compat::Incompatible));
                     } else if reason == "compiler-artifact" {
                         findings.crates.insert((None, name, ver, Compat::VerifiedWorks));
-                    } else {
-                        if level != "warning" && reason != "build-script-executed" && !(level == "" && reason == "compiler-message") {
-                            eprintln!("unknown line {} {} {}", level, reason, line);
-                        }
+                    } else if level != "warning" && reason != "build-script-executed" && !(level == "" && reason == "compiler-message") {
+                        eprintln!("unknown line {} {} {}", level, reason, line);
                     }
                 }
             } else {
diff --git a/cargo_toml b/cargo_toml
-Subproject e31529ed387a1692ea0bb9e3a7d5fd175f89b2e
+Subproject 5edb460b79114b072939caa229fe7a4cdb8b976
diff --git a/categories/src/categories.rs b/categories/src/categories.rs
index adeaf34..72d37d8 100644
--- a/categories/src/categories.rs
+++ b/categories/src/categories.rs
@@ -132,11 +132,9 @@ impl Categories {
             let mut chars = s.chars().peekable();
             while let Some(cur) = chars.next() {
                 // look for a:b instead of a::b
-                if cur == ':' {
-                    if chars.peek().map_or(false, |&c| c == ':') {
-                        chars.next(); // OK, skip second ':'
-                        continue;
-                    }
+                if cur == ':' && chars.peek().map_or(false, |&c| c == ':') {
+                    chars.next(); // OK, skip second ':'
+                    continue;
                 }
                 if cur == '-' || cur.is_ascii_lowercase() || cur.is_ascii_digit() {
                     continue;
@@ -151,7 +149,7 @@ impl Categories {
                 return Some((depth, idx, slug.into()));
             }
             let depth = s.split("::").count();
-            Some((depth, idx, Cow::Borrowed(s.as_ref())))
+            Some((depth, idx, Cow::Borrowed(s)))
         })
         .filter(|(_, _, s)| {
             if CATEGORIES.from_slug(s).next().is_none() {
diff --git a/categories/src/tuning.rs b/categories/src/tuning.rs
index 54da934..4ab1ab1 100644
--- a/categories/src/tuning.rs
+++ b/categories/src/tuning.rs
@@ -1094,7 +1094,7 @@ lazy_static! {
         (Cond::All(&["3d", "format"]), &[("rendering::data-formats", 1.3, 0.3), ("value-formatting", 0.5, 0.), ("filesystem", 0.7, 0.), ("development-tools::ffi", 0.8, 0.)]),
         (Cond::Any(&["2d", "3d", "sprite"]), &[("rendering::graphics-api", 1.11, 0.), ("data-structures", 1.1, 0.), ("rendering::data-formats", 1.2, 0.), ("rendering", 1.1, 0.), ("games", 0.8, 0.), ("multimedia::audio", 0.8, 0.), ("rendering::graphics-api", 1.1, 0.)]),
 
-    ].iter().map(|s|*s).collect();
+    ].iter().copied().collect();
 }
 
 /// Based on the set of keywords, adjust relevance of given categories
@@ -1127,7 +1127,7 @@ pub fn adjusted_relevance(mut candidates: HashMap<String, f64>, keywords: &HashS
 
     let min_category_match_threshold = min_category_match_threshold.max(max_score * 0.951);
 
-    let mut res: Vec<_> = candidates.clone().into_iter()
+    let mut res: Vec<_> = candidates.into_iter()
         .filter(|&(_, v)| v >= min_category_match_threshold)
         .filter(|&(ref k, _)| CATEGORIES.from_slug(k).next().is_some() /* FIXME: that checks top level only */)
         .take(max_num_categories)
diff --git a/crate_db/src/lib_crate_db.rs b/crate_db/src/lib_crate_db.rs
index b4dd568..85f8411 100644
--- a/crate_db/src/lib_crate_db.rs
+++ b/crate_db/src/lib_crate_db.rs
@@ -276,7 +276,7 @@ impl CrateDb {
 
             // replace ' ' with '-'
             // keep if 3 words or less
-            for (i, (w2, k)) in rake_keywords.into_iter().chain(keywords).take(25).enumerate() {
+            for (i, (w2, k)) in rake_keywords.chain(keywords).take(25).enumerate() {
                 let w: f64 = w2 * 150. / (80 + i) as f64;
                 insert_keyword.add(&k, w, false);
             }
diff --git a/crate_db/src/stopwords.rs b/crate_db/src/stopwords.rs
index e8eb868..e6df134 100644
--- a/crate_db/src/stopwords.rs
+++ b/crate_db/src/stopwords.rs
@@ -143,5 +143,5 @@ lazy_static! {
         ("squatting", None), // spam
         ("malware", None), // spam
         ("unfinished", None), // spam
-    ].iter().map(|s|*s).collect();
+    ].iter().copied().collect();
 }
diff --git a/deps_index/src/index.rs b/deps_index/src/index.rs
index c53ab8e..0c327ca 100644
--- a/deps_index/src/index.rs
+++ b/deps_index/src/index.rs
@@ -254,7 +254,7 @@ impl Index {
                     let mut t = enable.splitn(2, '/');
                     let dep_name = t.next().unwrap();
                     let enabled = to_enable.entry(dep_name.to_owned())
-                        .or_insert(FxHashSet::default());
+                        .or_insert_with(FxHashSet::default);
                     if let Some(enable) = t.next() {
                         enabled.insert(enable);
                     }
@@ -340,7 +340,7 @@ impl Index {
                 .or_insert_with(|| (has_default_features, matched.clone(), semver, FxHashSet::default()));
             all_features.extend(features.iter().cloned());
             if let Some(s) = enable_dep_features {
-                all_features.extend(s.iter().map(|s| s.to_string()));
+                all_features.extend(s.iter().copied().map(|s| s.to_string()));
             }
         }
 
diff --git a/front_end/src/crate_page.rs b/front_end/src/crate_page.rs
index 54307cf..50e1c5e 100644
--- a/front_end/src/crate_page.rs
+++ b/front_end/src/crate_page.rs
@@ -837,7 +837,7 @@ impl<'a> CratePage<'a> {
                 main_crate_size.1 += uncompr_weighed;
 
                 for (&lang, val) in &crate_stats.langs {
-                    let e = main_lang_stats.langs.entry(lang).or_insert(Lines::default());
+                    let e = main_lang_stats.langs.entry(lang).or_insert_with(Lines::default);
                     e.code += (val.code as f32 * weight) as u32;
                     e.comments += (val.comments as f32 * weight) as u32;
                 }
@@ -863,7 +863,7 @@ impl<'a> CratePage<'a> {
 
     async fn get_crate_of_dependency(&self, name: &str, _semver: ()) -> CResult<Arc<RichCrateVersion>> {
         // FIXME: caching doesn't hold multiple versions, so fetchnig of precise old versions is super expensive
-        return self.kitchen_sink.rich_crate_version_async(&Origin::from_crates_io_name(name)).await;
+        self.kitchen_sink.rich_crate_version_async(&Origin::from_crates_io_name(name)).await
 
         // let krate = self.kitchen_sink.index.crate_by_name(&Origin::from_crates_io_name(name))?;
         // let ver = krate.versions()
@@ -875,7 +875,7 @@ impl<'a> CratePage<'a> {
 
     fn is_same_project(one: &RichCrateVersion, two: &RichCrateVersion) -> bool {
         match (one.repository(), two.repository()) {
-            (Some(a), Some(b)) if a.host == b.host => return true,
+            (Some(a), Some(b)) if a.host == b.host => true,
             _ => false,
         }
     }
diff --git a/front_end/src/download_graph.rs b/front_end/src/download_graph.rs
index b6ee24d..7b7aa94 100644
--- a/front_end/src/download_graph.rs
+++ b/front_end/src/download_graph.rs
@@ -107,7 +107,7 @@ impl DownloadsGraph {
                 let overdraw = 1; // mix with border for style
                 let left_tick = ((i as f32) * item_width).round() as usize;
                 let right_tick = (((i + 1) as f32) * item_width).round() as usize;
-                (left + left_tick, chart_y + chart_height - h, right_tick - left_tick, h + overdraw, color.clone(), label)
+                (left + left_tick, chart_y + chart_height - h, right_tick - left_tick, h + overdraw, color, label)
             })
             .collect()
     }
diff --git a/front_end/src/front_end.rs b/front_end/src/front_end.rs
index d57cf93..dffb190 100644
--- a/front_end/src/front_end.rs
+++ b/front_end/src/front_end.rs
@@ -76,7 +76,7 @@ impl Page {
     }
 
     pub fn local_css_data(&self) -> Option<templates::Html<&'static str>> {
-        self.local_css_data.map(|data| templates::Html(data))
+        self.local_css_data.map(templates::Html)
     }
 }
 
@@ -288,7 +288,7 @@ pub fn limit_text_len<'t>(text: &'t str, mut len_min: usize, mut len_max: usize)
     let mut cut = &text[..len_max];
     let optional = &cut[len_min..];
     if let Some(pos) = optional.find(&['.', ',', '!', '\n', '?', ')', ']'][..]).or_else(|| optional.find(' ')) {
-        cut = cut[..len_min + pos + 1].trim_end_matches(&['.', ',', '!', '\n', '?', ' '][..]);
+        cut = cut[..=len_min + pos].trim_end_matches(&['.', ',', '!', '\n', '?', ' '][..]);
     };
     return format!("{}…", cut).into();
 }
diff --git a/front_end/src/reverse_dependencies.rs b/front_end/src/reverse_dependencies.rs
index fa97359..404832c 100644
--- a/front_end/src/reverse_dependencies.rs
+++ b/front_end/src/reverse_dependencies.rs
@@ -59,10 +59,9 @@ impl<'a> CratePageRevDeps<'a> {
             let origin = Origin::from_crates_io_name(rev_dep);
             let downloads = kitchen_sink.downloads_per_month(&origin).await.ok().and_then(|x| x).unwrap_or(0);
             let depender = kitchen_sink.index.crate_highest_version(&rev_dep.to_lowercase(), true).expect("rev dep integrity");
-            let (is_optional, req, kind) = depender.dependencies().iter().filter(|d| {
+            let (is_optional, req, kind) = depender.dependencies().iter().find(|d| {
                 own_name.eq_ignore_ascii_case(d.crate_name())
             })
-            .next()
             .map(|d| {
                 (d.is_optional(), d.requirement(), d.kind().unwrap_or_default())
             })
diff --git a/kitchen_sink/src/lib_kitchen_sink.rs b/kitchen_sink/src/lib_kitchen_sink.rs
index 1fe68f5..ecaed64 100644
--- a/kitchen_sink/src/lib_kitchen_sink.rs
+++ b/kitchen_sink/src/lib_kitchen_sink.rs
@@ -307,24 +307,21 @@ impl KitchenSink {
         }).collect();
         if let Ok(stats) = self.index.deps_stats().await {
             for (o, score) in &mut top {
-                match o {
-                    Origin::CratesIo(name) => {
-                        if let Some(s) = stats.counts.get(name) {
-                            // if it's a dependency of another top crate, its not trending, it's riding that crate
-                            if s.rev_dep_names.iter().any(|parent| crates_present.contains(parent)) {
-                                *score = 0.;
-                            } else {
-                                // it should be trending users, not just download hits
-                                if s.direct.all() > 10 {
-                                    *score *= 1.1;
-                                }
-                                if s.direct.all() > 100 {
-                                    *score *= 1.1;
-                                }
+                if let Origin::CratesIo(name) = o {
+                    if let Some(s) = stats.counts.get(name) {
+                        // if it's a dependency of another top crate, its not trending, it's riding that crate
+                        if s.rev_dep_names.iter().any(|parent| crates_present.contains(parent)) {
+                            *score = 0.;
+                        } else {
+                            // it should be trending users, not just download hits
+                            if s.direct.all() > 10 {
+                                *score *= 1.1;
+                            }
+                            if s.direct.all() > 100 {
+                                *score *= 1.1;
                             }
                         }
-                    },
-                    _ => {},
+                    }
                 }
             }
 
@@ -482,7 +479,7 @@ impl KitchenSink {
         let all = tokio::task::block_in_place(|| {
             self.index.crates_io_crates() // too slow to scan all GH crates
         });
-        let stream = futures::stream::iter(all.into_iter())
+        let stream = futures::stream::iter(all.iter())
             .filter_map(move |(name, _)| async move {
                 self.rich_crate_async(&Origin::from_crates_io_name(&*name)).await.map_err(|e| eprintln!("{}: {}", name, e)).ok()
             });
@@ -696,7 +693,7 @@ impl KitchenSink {
                 self.index_crate_highest_version(origin).await?;
                 match self.crate_db.rich_crate_version_data(origin).await {
                     Ok(v) => v,
-                    Err(e) => Err(e)?,
+                    Err(e) => return Err(e),
                 }
             },
         };
@@ -840,10 +837,8 @@ impl KitchenSink {
             // it may contain data from nowhere! https://github.com/rust-lang/crates.io/issues/1624
             if let Some(repo) = crates_io_krate.repository {
                 package.repository = Some(repo);
-            } else {
-                if package.homepage.as_ref().map_or(false, |h| Repo::looks_like_repo_url(h)) {
-                    package.repository = package.homepage.take();
-                }
+            } else if package.homepage.as_ref().map_or(false, |h| Repo::looks_like_repo_url(h)) {
+                package.repository = package.homepage.take();
             }
         }
 
@@ -953,7 +948,7 @@ impl KitchenSink {
             has_buildrs,
             has_code_of_conduct,
             readme: meta.readme,
-            lib_file: meta.lib_file.map(|s| s.into()),
+            lib_file: meta.lib_file,
             github_description,
             github_keywords,
             is_yanked,
@@ -1925,7 +1920,7 @@ impl KitchenSink {
         }
         let mut top_keywords: Vec<_> = top_keywords.into_iter().collect();
         top_keywords.sort_by(|a, b| b.1.cmp(&a.1));
-        let top_keywords: HashSet<_> = top_keywords.iter().take((top_keywords.len() / 10).min(10).max(2)).map(|(k, _)| k.to_string()).collect();
+        let top_keywords: HashSet<_> = top_keywords.iter().copied().take((top_keywords.len() / 10).min(10).max(2)).map(|(k, _)| k.to_string()).collect();
         eprintln!("top cat keywords {:?}", top_keywords);
 
         crates.clear();
@@ -2015,7 +2010,7 @@ impl KitchenSink {
             .as_ref()
             .ok_or(KitchenSinkErr::CategoryQueryFailed)
             .and_then(|h| {
-                h.get(slug).map(|&c| c).ok_or_else(|| {
+                h.get(slug).copied().ok_or_else(|| {
                     KitchenSinkErr::CategoryNotFound(slug.to_string())
                 })
             })
diff --git a/kitchen_sink/src/yearly.rs b/kitchen_sink/src/yearly.rs
index 1ff325c..aad2481 100644
--- a/kitchen_sink/src/yearly.rs
+++ b/kitchen_sink/src/yearly.rs
@@ -94,8 +94,8 @@ impl<'de> BigArray<'de> for [u32; 366]
                 where A: SeqAccess<'de>
             {
                 let mut arr = [u32::default(); 366];
-                for i in 0..366 {
-                    arr[i] = seq.next_element()?
+                for (i, a) in arr.iter_mut().enumerate() {
+                    *a = seq.next_element()?
                         .ok_or_else(|| Error::invalid_length(i, &self))?;
                 }
                 Ok(arr)
diff --git a/reindex/src/bin/discover.rs b/reindex/src/bin/discover.rs
index ef8af9b..eb8faaa 100644
--- a/reindex/src/bin/discover.rs
+++ b/reindex/src/bin/discover.rs
@@ -44,17 +44,15 @@ fn check_repo(line: &str, crates: &KitchenSink) -> Result<(), Box<dyn std::error
                 }
                 if crates.crate_exists(&Origin::from_github(gh.clone(), pkg.name.as_str())) {
                     print!("// GIT alredy exists! ");
-                } else {
-                    if crates.crate_exists(&Origin::from_crates_io_name(&pkg.name)) {
-                        print!("// crate alredy exists! https://lib.rs/crates/{} ", pkg.name);
-                        if let Some(d) = &pkg.description {
-                            print!("// {} // ", d.trim());
-                        }
-                    }
-                    else if let Some(d) = &pkg.description {
-                        println!("// {}", d.trim());
+                } else if crates.crate_exists(&Origin::from_crates_io_name(&pkg.name)) {
+                    print!("// crate alredy exists! https://lib.rs/crates/{} ", pkg.name);
+                    if let Some(d) = &pkg.description {
+                        print!("// {} // ", d.trim());
                     }
                 }
+                else if let Some(d) = &pkg.description {
+                    println!("// {}", d.trim());
+                }
                 println!("github:{}/{}/{}\n,{}", gh.owner, gh.repo, pkg.name, if path != "" && path != pkg.name {format!(" // in {}", path)} else {String::new()});
             }
         }
diff --git a/reindex/src/bin/reindex_users.rs b/reindex/src/bin/reindex_users.rs
index 7375162..20010e1 100644
--- a/reindex/src/bin/reindex_users.rs
+++ b/reindex/src/bin/reindex_users.rs
@@ -71,7 +71,7 @@ async fn main() {
             }).map(drop));
         }
         if stopped() {return;}
-        let _ = waiting.collect::<()>().await;
+        waiting.collect::<()>().await;
         eprintln!("Finished sending");
         tx.send(None).unwrap();
         if stopped() {return;}
diff --git a/repo_url/src/repo.rs b/repo_url/src/repo.rs
index a03a7eb..c5d51fb 100644
--- a/repo_url/src/repo.rs
+++ b/repo_url/src/repo.rs
@@ -57,7 +57,7 @@ impl std::fmt::Display for GitError {
 impl Repo {
     /// Parse the given URL
     pub fn new(url: &str) -> GResult<Self> {
-        let url = Url::parse(url).map_err(|e| GitError::InvalidUrl(e))?;
+        let url = Url::parse(url).map_err(GitError::InvalidUrl)?;
         Ok(Repo {
             host: match (&url.host_str(), url.path_segments()) {
                 (Some("www.github.com"), Some(path)) |
@@ -227,7 +227,7 @@ impl RepoHost {
         match self {
             RepoHost::GitHub(SimpleRepo { ref owner, .. }) |
             RepoHost::BitBucket(SimpleRepo { ref owner, .. }) |
-            RepoHost::GitLab(SimpleRepo { ref owner, .. }) => return Some(owner),
+            RepoHost::GitLab(SimpleRepo { ref owner, .. }) => Some(owner),
             RepoHost::Other => None,
         }
     }
@@ -240,7 +240,7 @@ impl RepoHost {
         match self {
             RepoHost::GitHub(repo) |
             RepoHost::BitBucket(repo) |
-            RepoHost::GitLab(repo) => return Some(repo),
+            RepoHost::GitLab(repo) => Some(repo),
             RepoHost::Other => None,
         }
     }
diff --git a/simple_cache/src/db.rs b/simple_cache/src/db.rs
index be8e40f..13cafaa 100644
--- a/simple_cache/src/db.rs
+++ b/simple_cache/src/db.rs
@@ -97,15 +97,13 @@ impl SimpleCache {
     pub async fn get_cached(&self, key: (&str, &str), url: impl AsRef<str>) -> Result<Option<Vec<u8>>, Error> {
         Ok(if let Some(data) = self.get(key)? {
             Some(data)
+        } else if self.cache_only {
+            None
         } else {
-            if self.cache_only {
-                None
-            } else {
-                let _s = self.sem.acquire().await;
-                let data = Self::fetch(url.as_ref()).await?;
-                self.set(key, &data)?;
-                Some(data)
-            }
+            let _s = self.sem.acquire().await;
+            let data = Self::fetch(url.as_ref()).await?;
+            self.set(key, &data)?;
+            Some(data)
         })
     }