Linting Configuration Cleanup — heartwood

A collection of changes that all work to decrease the amount of linter customization we need to maintain.

 git-ref-format-core = { version = "0.6.0", default-features = false }
 radicle-surf = "0.27.1"
 [workspace.lints]
 clippy.type_complexity = "allow"
 clippy.enum_variant_names = "allow"
 clippy.indexing_slicing = "deny"
 clippy.fallible_impl_from = "deny"
 clippy.wildcard_enum_match_arm = "deny"
 clippy.unneeded_field_pattern = "deny"
 clippy.fn_params_excessive_bools = "deny"
 clippy.must_use_candidate = "deny"
 [workspace.lints.clippy]
 fallible_impl_from = "deny"
 fn_params_excessive_bools = "deny"
 indexing_slicing = "deny"
 must_use_candidate = "deny"
 unneeded_field_pattern = "deny"
 wildcard_enum_match_arm = "deny"
 [profile.container]
 inherits = "release"

 #![allow(clippy::collapsible_else_if)]
 use std::borrow::Cow;
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};

 #![allow(clippy::or_fun_call)]
 #![allow(clippy::collapsible_else_if)]
 mod args;
 pub use args::Args;

                 continue;
             }
         };
         if !authors.is_empty() {
             if !authors.contains(patch.author().id()) {
                 continue;
             }
         if !authors.is_empty() && !authors.contains(patch.author().id()) {
             continue;
         }
         all.push((id, patch));
     }

 /// A single review item. Can be a hunk or eg. a file move.
 /// Files are usually split into multiple review items.
 #[derive(Debug)]
 #[allow(clippy::enum_variant_names)]
 pub enum ReviewItem {
     FileAdded {
         path: PathBuf,

+	`allow-unwrap-in-tests = true`
	`\ No newline at end of file`

 #![allow(clippy::box_default)]
 mod args;
 use std::path::PathBuf;

         self.hunk().and_then(|h| HunkHeader::try_from(h).ok())
     }
     #[allow(clippy::type_complexity)]
     fn paths(&self) -> (Option<(&Path, Oid)>, Option<(&Path, Oid)>) {
         match self {
             Self::FileAdded { path, new, .. } => (None, Some((path, Oid::from(*new.oid)))),

 #![allow(clippy::collapsible_if)]
 #![allow(clippy::or_fun_call)]
 #![allow(clippy::too_many_arguments)]
 pub mod commands;
 pub mod git;

 // Copyright © 2021 The Radicle Link Contributors
 #![warn(clippy::unwrap_used)]
 #![deny(clippy::unwrap_used)]
 //! # Collaborative Objects
 //!
 //! Collaborative objects are graphs of CRDTs.

 #![allow(dead_code)]
 use std::collections::HashSet;
 use std::iter;
 use std::net;

 //! A simple P2P network simulator. Acts as the _reactor_, but without doing any I/O.
 #![allow(clippy::collapsible_if)]
 #![allow(dead_code)]
 #![allow(clippy::type_complexity)]
 use std::cell::RefCell;
 use std::collections::{BTreeMap, BTreeSet, HashSet, VecDeque};

                         let conn = (node, id);
                         let attempted = link.is_outbound() && self.attempts.remove(&conn);
                         if attempted || link.is_inbound() {
                             if self.connections.insert(conn) {
                                 p.connected(id, addr, link);
                             }
                         if (attempted || link.is_inbound()) && self.connections.insert(conn) {
                             p.connected(id, addr, link);
                         }
                     }
                     Input::Disconnected(id, reason) => {

 #![allow(clippy::identity_op)]
 use std::ops::{Deref, DerefMut};
 pub use bloomy::BloomFilter;

 /// Size in bytes of *large* bloom filter.
 /// It can store about 13'675 items with a false positive rate of 1%.
 pub const FILTER_SIZE_L: usize = 16 * 1024;
 pub const FILTER_SIZE_L: usize = 1024 * 16;
 /// Size in bytes of *medium* bloom filter.
 /// It can store about 3'419 items with a false positive rate of 1%.
 pub const FILTER_SIZE_M: usize = 4 * 1024;
 pub const FILTER_SIZE_M: usize = 1024 * 4;
 /// Size in bytes of *small* bloom filter.
 /// It can store about 855 items with a false positive rate of 1%.
 pub const FILTER_SIZE_S: usize = 1 * 1024;
 pub const FILTER_SIZE_S: usize = 1024;
 /// Valid filter sizes.
 pub const FILTER_SIZES: [usize; 3] = [FILTER_SIZE_S, FILTER_SIZE_M, FILTER_SIZE_L];

 #![warn(clippy::unwrap_used)]
 #![deny(clippy::unwrap_used)]
 pub mod cache;
 pub mod common;
 pub mod external;

         let id = issue.id;
         let mut issue = issues.get_mut(&id).unwrap();
         let (_, reply1) = &issue.replies_to(&root).nth(0).unwrap();
         let (_, reply1) = &issue.replies_to(&root).next().unwrap();
         let (_, reply2) = &issue.replies_to(&root).nth(1).unwrap();
         assert_eq!(reply1.body(), "Hi hi hi.");

         let issue = issues.get(&id).unwrap().unwrap();
         assert_eq!(issue.replies_to(&c1).nth(0).unwrap().1.body(), "Re: Hi.");
         assert_eq!(issue.replies_to(&c2).nth(0).unwrap().1.body(), "Re: Ha.");
         assert_eq!(issue.replies_to(&c1).next().unwrap().1.body(), "Re: Hi.");
         assert_eq!(issue.replies_to(&c2).next().unwrap().1.body(), "Re: Ha.");
         assert_eq!(
             issue.replies_to(&c2).nth(1).unwrap().1.body(),
             "Re: Ha. Ha."

         let id = issue.id;
         let issue = issues.get(&id).unwrap().unwrap();
         let (_, c0) = &issue.comments().nth(0).unwrap();
         let (_, c0) = &issue.comments().next().unwrap();
         let (_, c1) = &issue.comments().nth(1).unwrap();
         let (_, c2) = &issue.comments().nth(2).unwrap();

         let review = revision.review_by(alice.signer.public_key()).unwrap();
         assert_eq!(review.verdict(), Some(Verdict::Reject));
         assert_eq!(review.comments().count(), 2);
         assert_eq!(review.comments().nth(0).unwrap().1.body(), "First comment!");
         assert_eq!(review.comments().next().unwrap().1.body(), "First comment!");
         assert_eq!(
             review.comments().nth(1).unwrap().1.body(),
             "Second comment!"

         assert_eq!(patch.revisions.len(), 2);
         assert_eq!(patch.revisions().count(), 2);
         assert_eq!(
             patch.revisions().nth(0).unwrap().1.description(),
             patch.revisions().next().unwrap().1.description(),
             "Blah blah blah."
         );
         assert_eq!(

 //! Generic COB storage.
 #![allow(clippy::large_enum_variant)]
 #![allow(clippy::type_complexity)]
 use std::fmt::Debug;
 use std::marker::PhantomData;

 #![allow(clippy::unwrap_used)]
 use std::marker::PhantomData;
 use std::ops::Deref;

         let a3 = alice.redact(a1.id());
         thread.op(a3, [], &repo).unwrap();
         let (_, comment0) = thread.comments().nth(0).unwrap();
         let (_, comment0) = thread.comments().next().unwrap();
         let (_, comment1) = thread.comments().nth(1).unwrap();
         assert_eq!(thread.comments().count(), 2);

 #![warn(clippy::unwrap_used)]
 #![deny(clippy::unwrap_used)]
 pub mod crefs;
 pub mod did;
 pub mod doc;

     /// Returns `true` if the [`HostName`] is a Tor onion address.
     #[cfg(feature = "tor")]
     pub fn is_onion(&self) -> bool {
         match self.0.host {
             HostName::Tor(_) => true,
             _ => false,
         }
         matches!(self.0.host, HostName::Tor(_))
     }
     /// Return the port number of the [`Address`].

 #![allow(clippy::type_complexity)]
 use std::num::TryFromIntError;
 use std::str::FromStr;

         timestamp: Timestamp,
     ) -> Result<bool, Error>;
     /// Get the repos seeded by the given node.
     #[allow(clippy::type_complexity)]
     fn seeded_by(
         &self,
         nid: &NodeId,

 #![allow(clippy::let_unit_value)]
 use std::io;
 use std::path::Path;
 use std::str::FromStr;

 #![allow(clippy::unwrap_used)]
 use crypto::{signature, test::signer::MockSigner, PublicKey, Signer as _};
 use qcheck::TestResult;
 use qcheck_macros::quickcheck;

 #![allow(clippy::unwrap_used)]
 mod mock;
 use mock::*;