nostr/nostr-rs-relay
1
0
Fork 0
mirror of https://github.com/scsibug/nostr-rs-relay.git synced 2024-11-23 09:29:06 -05:00
Code Issues Packages Projects Releases Wiki Activity

refactor: clippy suggestions

Browse Source
This commit is contained in:
Greg Heartsfield 2024-03-28 10:15:00 -05:00
parent 44c6e3d88b
commit 39a3a258a0
10 changed files with 42 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/bin/bulkloader.rs
View File

@ -143,7 +143,7 @@ fn write_event(tx: &Transaction, e: Event) -> Result<usize> {
let event_id = tx.last_insert_rowid(); let event_id = tx.last_insert_rowid();
// look at each event, and each tag, creating new tag entries if appropriate. // look at each event, and each tag, creating new tag entries if appropriate.
for t in e.tags.iter().filter(|x| x.len() > 1) { for t in e.tags.iter().filter(|x| x.len() > 1) {
let tagname = t.get(0).unwrap(); let tagname = t.first().unwrap();
let tagnamechar_opt = single_char_tagname(tagname); let tagnamechar_opt = single_char_tagname(tagname);
if tagnamechar_opt.is_none() { if tagnamechar_opt.is_none() {
continue; continue;

4
src/conn.rs
View File

@ -185,10 +185,10 @@ impl ClientConn {
let mut relay: Option<&str> = None; let mut relay: Option<&str> = None;
for tag in &event.tags { for tag in &event.tags {
if tag.len() == 2 && tag.get(0) == Some(&"challenge".into()) { if tag.len() == 2 && tag.first() == Some(&"challenge".into()) {
challenge = tag.get(1).map(|x| x.as_str()); challenge = tag.get(1).map(|x| x.as_str());
} }
if tag.len() == 2 && tag.get(0) == Some(&"relay".into()) { if tag.len() == 2 && tag.first() == Some(&"relay".into()) {
relay = tag.get(1).map(|x| x.as_str()); relay = tag.get(1).map(|x| x.as_str());
} }
} }

16
src/event.rs
View File

@ -160,11 +160,11 @@ impl Event {
.tags .tags
.iter() .iter()
.filter(|x| !x.is_empty()) .filter(|x| !x.is_empty())
.filter(|x| x.get(0).unwrap() == "expiration") .filter(|x| x.first().unwrap() == "expiration")
.map(|x| x.get(1).unwrap_or(&default)) .map(|x| x.get(1).unwrap_or(&default))
.take(1) .take(1)
.collect(); .collect();
let val_first = dvals.get(0); let val_first = dvals.first();
val_first.and_then(|t| t.parse::<u64>().ok()) val_first.and_then(|t| t.parse::<u64>().ok())
} }
@ -192,11 +192,11 @@ impl Event {
.tags .tags
.iter() .iter()
.filter(|x| !x.is_empty()) .filter(|x| !x.is_empty())
.filter(|x| x.get(0).unwrap() == "d") .filter(|x| x.first().unwrap() == "d")
.map(|x| x.get(1).unwrap_or(&default)) .map(|x| x.get(1).unwrap_or(&default))
.take(1) .take(1)
.collect(); .collect();
let dval_first = dvals.get(0); let dval_first = dvals.first();
match dval_first { match dval_first {
Some(_) => dval_first.map(|x| x.to_string()), Some(_) => dval_first.map(|x| x.to_string()),
None => Some(default), None => Some(default),
@ -232,7 +232,7 @@ impl Event {
.tags .tags
.iter() .iter()
.filter(|x| x.len() == 4) .filter(|x| x.len() == 4)
.filter(|x| x.get(0).unwrap() == "delegation") .filter(|x| x.first().unwrap() == "delegation")
.take(1) .take(1)
.next()? .next()?
.clone(); // get first tag .clone(); // get first tag
@ -277,7 +277,7 @@ impl Event {
let mut idx: HashMap<char, HashSet<String>> = HashMap::new(); let mut idx: HashMap<char, HashSet<String>> = HashMap::new();
// iterate over tags that have at least 2 elements // iterate over tags that have at least 2 elements
for t in self.tags.iter().filter(|x| x.len() > 1) { for t in self.tags.iter().filter(|x| x.len() > 1) {
let tagname = t.get(0).unwrap(); let tagname = t.first().unwrap();
let tagnamechar_opt = single_char_tagname(tagname); let tagnamechar_opt = single_char_tagname(tagname);
if tagnamechar_opt.is_none() { if tagnamechar_opt.is_none() {
continue; continue;
@ -285,7 +285,7 @@ impl Event {
let tagnamechar = tagnamechar_opt.unwrap(); let tagnamechar = tagnamechar_opt.unwrap();
let tagval = t.get(1).unwrap(); let tagval = t.get(1).unwrap();
// ensure a vector exists for this tag // ensure a vector exists for this tag
idx.entry(tagnamechar).or_insert_with(HashSet::new); idx.entry(tagnamechar).or_default();
// get the tag vec and insert entry // get the tag vec and insert entry
let idx_tag_vec = idx.get_mut(&tagnamechar).expect("could not get tag vector"); let idx_tag_vec = idx.get_mut(&tagnamechar).expect("could not get tag vector");
idx_tag_vec.insert(tagval.clone()); idx_tag_vec.insert(tagval.clone());
@ -310,7 +310,7 @@ impl Event {
self.tags self.tags
.iter() .iter()
.filter(|x| x.len() > 1) .filter(|x| x.len() > 1)
.filter(|x| x.get(0).unwrap() == tag_name) .filter(|x| x.first().unwrap() == tag_name)
.map(|x| x.get(1).unwrap().clone()) .map(|x| x.get(1).unwrap().clone())
.collect() .collect()
} }

2
src/repo/postgres_migration.rs
View File

@ -205,7 +205,7 @@ CREATE INDEX tag_value_hex_idx ON tag USING btree (value_hex);
let event: Event = serde_json::from_str(&String::from_utf8(event_bytes).unwrap())?; let event: Event = serde_json::from_str(&String::from_utf8(event_bytes).unwrap())?;
for t in event.tags.iter().filter(|x| x.len() > 1) { for t in event.tags.iter().filter(|x| x.len() > 1) {
let tagname = t.get(0).unwrap(); let tagname = t.first().unwrap();
let tagnamechar_opt = single_char_tagname(tagname); let tagnamechar_opt = single_char_tagname(tagname);
if tagnamechar_opt.is_none() { if tagnamechar_opt.is_none() {
continue; continue;

3
src/repo/sqlite.rs
View File

@ -993,7 +993,7 @@ fn query_from_filter(f: &ReqFilter) -> (String, Vec<Box<dyn ToSql>>, Option<Stri
let mut auth_searches: Vec<String> = vec![]; let mut auth_searches: Vec<String> = vec![];
for auth in authvec { for auth in authvec {
auth_searches.push("author=?".to_owned()); auth_searches.push("author=?".to_owned());
let auth_bin = hex::decode(&auth).ok(); let auth_bin = hex::decode(auth).ok();
params.push(Box::new(auth_bin)); params.push(Box::new(auth_bin));
} }
if !authvec.is_empty() { if !authvec.is_empty() {
@ -1282,6 +1282,7 @@ pub async fn db_checkpoint_task(
} }
#[derive(Debug)] #[derive(Debug)]
#[allow(dead_code)]
enum SqliteStatus { enum SqliteStatus {
Ok, Ok,
Busy, Busy,

8
src/repo/sqlite_migration.rs
View File

@ -295,7 +295,7 @@ pub fn rebuild_tags(conn: &mut PooledConnection) -> Result<()> {
let event: Event = serde_json::from_str(&event_json)?; let event: Event = serde_json::from_str(&event_json)?;
// look at each event, and each tag, creating new tag entries if appropriate. // look at each event, and each tag, creating new tag entries if appropriate.
for t in event.tags.iter().filter(|x| x.len() > 1) { for t in event.tags.iter().filter(|x| x.len() > 1) {
let tagname = t.get(0).unwrap(); let tagname = t.first().unwrap();
let tagnamechar_opt = single_char_tagname(tagname); let tagnamechar_opt = single_char_tagname(tagname);
if tagnamechar_opt.is_none() { if tagnamechar_opt.is_none() {
continue; continue;
@ -325,7 +325,7 @@ pub fn rebuild_tags(conn: &mut PooledConnection) -> Result<()> {
Ok(()) Ok(())
} }
//// Migration Scripts // Migration Scripts
fn mig_1_to_2(conn: &mut PooledConnection) -> Result<usize> { fn mig_1_to_2(conn: &mut PooledConnection) -> Result<usize> {
// only change is adding a hidden column to events. // only change is adding a hidden column to events.
@ -461,7 +461,7 @@ fn mig_5_to_6(conn: &mut PooledConnection) -> Result<usize> {
let event: Event = serde_json::from_str(&event_json)?; let event: Event = serde_json::from_str(&event_json)?;
// look at each event, and each tag, creating new tag entries if appropriate. // look at each event, and each tag, creating new tag entries if appropriate.
for t in event.tags.iter().filter(|x| x.len() > 1) { for t in event.tags.iter().filter(|x| x.len() > 1) {
let tagname = t.get(0).unwrap(); let tagname = t.first().unwrap();
let tagnamechar_opt = single_char_tagname(tagname); let tagnamechar_opt = single_char_tagname(tagname);
if tagnamechar_opt.is_none() { if tagnamechar_opt.is_none() {
continue; continue;
@ -749,7 +749,7 @@ CREATE INDEX IF NOT EXISTS tag_covering_index ON tag(name,kind,value,created_at,
let event: Event = serde_json::from_str(&event_json)?; let event: Event = serde_json::from_str(&event_json)?;
// look at each event, and each tag, creating new tag entries if appropriate. // look at each event, and each tag, creating new tag entries if appropriate.
for t in event.tags.iter().filter(|x| x.len() > 1) { for t in event.tags.iter().filter(|x| x.len() > 1) {
let tagname = t.get(0).unwrap(); let tagname = t.first().unwrap();
let tagnamechar_opt = single_char_tagname(tagname); let tagnamechar_opt = single_char_tagname(tagname);
if tagnamechar_opt.is_none() { if tagnamechar_opt.is_none() {
continue; continue;

1
src/server.rs
View File

@ -653,6 +653,7 @@ fn get_header_string(header: &str, headers: &HeaderMap) -> Option<String> {
async fn ctrl_c_or_signal(mut shutdown_signal: Receiver<()>) { async fn ctrl_c_or_signal(mut shutdown_signal: Receiver<()>) {
let mut term_signal = tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate()) let mut term_signal = tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate())
.expect("could not define signal"); .expect("could not define signal");
#[allow(clippy::never_loop)]
loop { loop {
tokio::select! { tokio::select! {
_ = shutdown_signal.recv() => { _ = shutdown_signal.recv() => {

18
src/subscription.rs
View File

@ -361,7 +361,7 @@ mod tests {
let s: Subscription = serde_json::from_str(raw_json)?; let s: Subscription = serde_json::from_str(raw_json)?;
assert_eq!(s.id, "some-id"); assert_eq!(s.id, "some-id");
assert_eq!(s.filters.len(), 1); assert_eq!(s.filters.len(), 1);
assert_eq!(s.filters.get(0).unwrap().authors, None); assert_eq!(s.filters.first().unwrap().authors, None);
Ok(()) Ok(())
} }
@ -425,7 +425,7 @@ mod tests {
let s: Subscription = serde_json::from_str(raw_json)?; let s: Subscription = serde_json::from_str(raw_json)?;
assert_eq!(s.id, "some-id"); assert_eq!(s.id, "some-id");
assert_eq!(s.filters.len(), 1); assert_eq!(s.filters.len(), 1);
let first_filter = s.filters.get(0).unwrap(); let first_filter = s.filters.first().unwrap();
assert_eq!( assert_eq!(
first_filter.authors, first_filter.authors,
Some(vec!("test-author-id".to_owned())) Some(vec!("test-author-id".to_owned()))
@ -656,11 +656,11 @@ mod tests {
let s: Subscription = serde_json::from_str( let s: Subscription = serde_json::from_str(
r##"["REQ","xyz",{"authors":["abc", "bcd"], "since": 10, "until": 20, "limit":100, "#e": ["foo", "bar"], "#d": ["test"]}]"##, r##"["REQ","xyz",{"authors":["abc", "bcd"], "since": 10, "until": 20, "limit":100, "#e": ["foo", "bar"], "#d": ["test"]}]"##,
)?; )?;
let f = s.filters.get(0); let f = s.filters.first();
let serialized = serde_json::to_string(&f)?; let serialized = serde_json::to_string(&f)?;
let serialized_wrapped = format!(r##"["REQ", "xyz",{}]"##, serialized); let serialized_wrapped = format!(r##"["REQ", "xyz",{}]"##, serialized);
let parsed: Subscription = serde_json::from_str(&serialized_wrapped)?; let parsed: Subscription = serde_json::from_str(&serialized_wrapped)?;
let parsed_filter = parsed.filters.get(0); let parsed_filter = parsed.filters.first();
if let Some(pf) = parsed_filter { if let Some(pf) = parsed_filter {
assert_eq!(pf.since, Some(10)); assert_eq!(pf.since, Some(10));
assert_eq!(pf.until, Some(20)); assert_eq!(pf.until, Some(20));
@ -673,11 +673,11 @@ mod tests {
#[test] #[test]
fn is_scraper() -> Result<()> { fn is_scraper() -> Result<()> {
assert_eq!(true, serde_json::from_str::<Subscription>(r#"["REQ","some-id",{"kinds": [1984],"since": 123,"limit":1}]"#)?.is_scraper()); assert!(serde_json::from_str::<Subscription>(r#"["REQ","some-id",{"kinds": [1984],"since": 123,"limit":1}]"#)?.is_scraper());
assert_eq!(true, serde_json::from_str::<Subscription>(r#"["REQ","some-id",{"kinds": [1984]},{"kinds": [1984],"authors":["aaaa"]}]"#)?.is_scraper()); assert!(serde_json::from_str::<Subscription>(r#"["REQ","some-id",{"kinds": [1984]},{"kinds": [1984],"authors":["aaaa"]}]"#)?.is_scraper());
assert_eq!(false, serde_json::from_str::<Subscription>(r#"["REQ","some-id",{"kinds": [1984],"authors":["aaaa"]}]"#)?.is_scraper()); assert!(!serde_json::from_str::<Subscription>(r#"["REQ","some-id",{"kinds": [1984],"authors":["aaaa"]}]"#)?.is_scraper());
assert_eq!(false, serde_json::from_str::<Subscription>(r#"["REQ","some-id",{"ids": ["aaaa"]}]"#)?.is_scraper()); assert!(!serde_json::from_str::<Subscription>(r#"["REQ","some-id",{"ids": ["aaaa"]}]"#)?.is_scraper());
assert_eq!(false, serde_json::from_str::<Subscription>(r##"["REQ","some-id",{"#p": ["aaaa"],"kinds":[1,4]}]"##)?.is_scraper()); assert!(!serde_json::from_str::<Subscription>(r##"["REQ","some-id",{"#p": ["aaaa"],"kinds":[1,4]}]"##)?.is_scraper());
Ok(()) Ok(())
} }
} }

5
tests/common/mod.rs
View File

@ -103,8 +103,5 @@ fn get_available_port() -> Option<u16> {
} }
pub fn port_is_available(port: u16) -> bool { pub fn port_is_available(port: u16) -> bool {
info!("checking on port {}", port); info!("checking on port {}", port);
match TcpListener::bind(("127.0.0.1", port)) { TcpListener::bind(("127.0.0.1", port)).is_ok()
Ok(_) => true,
Err(_) => false,
}
} }

26
tests/conn.rs
View File

@ -52,7 +52,7 @@ mod tests {
let challenge = client_conn.auth_challenge().unwrap(); let challenge = client_conn.auth_challenge().unwrap();
let event = auth_event(challenge); let event = auth_event(challenge);
let result = client_conn.authenticate(&event, RELAY.into()); let result = client_conn.authenticate(&event, RELAY);
assert!(matches!(result, Ok(()))); assert!(matches!(result, Ok(())));
assert_eq!(client_conn.auth_challenge(), None); assert_eq!(client_conn.auth_challenge(), None);
@ -67,7 +67,7 @@ mod tests {
assert_eq!(client_conn.auth_pubkey(), None); assert_eq!(client_conn.auth_pubkey(), None);
let event = auth_event(&"challenge".into()); let event = auth_event(&"challenge".into());
let result = client_conn.authenticate(&event, RELAY.into()); let result = client_conn.authenticate(&event, RELAY);
assert!(matches!(result, Err(Error::AuthFailure))); assert!(matches!(result, Err(Error::AuthFailure)));
} }
@ -87,14 +87,14 @@ mod tests {
let challenge = client_conn.auth_challenge().unwrap().clone(); let challenge = client_conn.auth_challenge().unwrap().clone();
let event = auth_event(&challenge); let event = auth_event(&challenge);
let result = client_conn.authenticate(&event, RELAY.into()); let result = client_conn.authenticate(&event, RELAY);
assert!(matches!(result, Ok(()))); assert!(matches!(result, Ok(())));
assert_eq!(client_conn.auth_challenge(), None); assert_eq!(client_conn.auth_challenge(), None);
assert_eq!(client_conn.auth_pubkey(), Some(&event.pubkey)); assert_eq!(client_conn.auth_pubkey(), Some(&event.pubkey));
let event1 = auth_event(&challenge); let event1 = auth_event(&challenge);
let result1 = client_conn.authenticate(&event1, RELAY.into()); let result1 = client_conn.authenticate(&event1, RELAY);
assert!(matches!(result1, Ok(()))); assert!(matches!(result1, Ok(())));
assert_eq!(client_conn.auth_challenge(), None); assert_eq!(client_conn.auth_challenge(), None);
@ -118,7 +118,7 @@ mod tests {
let mut event = auth_event(challenge); let mut event = auth_event(challenge);
event.sig = event.sig.chars().rev().collect::<String>(); event.sig = event.sig.chars().rev().collect::<String>();
let result = client_conn.authenticate(&event, RELAY.into()); let result = client_conn.authenticate(&event, RELAY);
assert!(matches!(result, Err(Error::AuthFailure))); assert!(matches!(result, Err(Error::AuthFailure)));
} }
@ -138,7 +138,7 @@ mod tests {
let challenge = client_conn.auth_challenge().unwrap(); let challenge = client_conn.auth_challenge().unwrap();
let event = auth_event_with_kind(challenge, 9999999999999999); let event = auth_event_with_kind(challenge, 9999999999999999);
let result = client_conn.authenticate(&event, RELAY.into()); let result = client_conn.authenticate(&event, RELAY);
assert!(matches!(result, Err(Error::AuthFailure))); assert!(matches!(result, Err(Error::AuthFailure)));
} }
@ -158,7 +158,7 @@ mod tests {
let challenge = client_conn.auth_challenge().unwrap(); let challenge = client_conn.auth_challenge().unwrap();
let event = auth_event_with_created_at(challenge, unix_time() - 1200); // 20 minutes let event = auth_event_with_created_at(challenge, unix_time() - 1200); // 20 minutes
let result = client_conn.authenticate(&event, RELAY.into()); let result = client_conn.authenticate(&event, RELAY);
assert!(matches!(result, Err(Error::AuthFailure))); assert!(matches!(result, Err(Error::AuthFailure)));
} }
@ -178,7 +178,7 @@ mod tests {
let challenge = client_conn.auth_challenge().unwrap(); let challenge = client_conn.auth_challenge().unwrap();
let event = auth_event_with_created_at(challenge, unix_time() + 1200); // 20 minutes let event = auth_event_with_created_at(challenge, unix_time() + 1200); // 20 minutes
let result = client_conn.authenticate(&event, RELAY.into()); let result = client_conn.authenticate(&event, RELAY);
assert!(matches!(result, Err(Error::AuthFailure))); assert!(matches!(result, Err(Error::AuthFailure)));
} }
@ -197,7 +197,7 @@ mod tests {
let event = auth_event_without_tags(); let event = auth_event_without_tags();
let result = client_conn.authenticate(&event, RELAY.into()); let result = client_conn.authenticate(&event, RELAY);
assert!(matches!(result, Err(Error::AuthFailure))); assert!(matches!(result, Err(Error::AuthFailure)));
} }
@ -216,7 +216,7 @@ mod tests {
let event = auth_event_without_challenge(); let event = auth_event_without_challenge();
let result = client_conn.authenticate(&event, RELAY.into()); let result = client_conn.authenticate(&event, RELAY);
assert!(matches!(result, Err(Error::AuthFailure))); assert!(matches!(result, Err(Error::AuthFailure)));
} }
@ -236,7 +236,7 @@ mod tests {
let challenge = client_conn.auth_challenge().unwrap(); let challenge = client_conn.auth_challenge().unwrap();
let event = auth_event_without_relay(challenge); let event = auth_event_without_relay(challenge);
let result = client_conn.authenticate(&event, RELAY.into()); let result = client_conn.authenticate(&event, RELAY);
assert!(matches!(result, Err(Error::AuthFailure))); assert!(matches!(result, Err(Error::AuthFailure)));
} }
@ -255,7 +255,7 @@ mod tests {
let event = auth_event(&"invalid challenge".into()); let event = auth_event(&"invalid challenge".into());
let result = client_conn.authenticate(&event, RELAY.into()); let result = client_conn.authenticate(&event, RELAY);
assert!(matches!(result, Err(Error::AuthFailure))); assert!(matches!(result, Err(Error::AuthFailure)));
} }
@ -275,7 +275,7 @@ mod tests {
let challenge = client_conn.auth_challenge().unwrap(); let challenge = client_conn.auth_challenge().unwrap();
let event = auth_event_with_relay(challenge, &"xyz".into()); let event = auth_event_with_relay(challenge, &"xyz".into());
let result = client_conn.authenticate(&event, RELAY.into()); let result = client_conn.authenticate(&event, RELAY);
assert!(matches!(result, Err(Error::AuthFailure))); assert!(matches!(result, Err(Error::AuthFailure)));
} }