chore: fix Phase 2 formatting and clippy lints · str4d.xyz/atproto-devtool@0d77fef

+63 -51

1 changed file

expand all

src

common

identity.rs

+63 -51

src/common/identity.rs

··· 260 260 #[async_trait] 261 261 impl HttpClient for RealHttpClient { 262 262 async fn get_bytes(&self, url: &Url) -> Result<(u16, Vec<u8>), IdentityError> { 263 - let response = self 264 - .inner 265 - .get(url.clone()) 266 - .send() 267 - .await 268 - .map_err(|e| IdentityError::HttpTransport { 269 - source: Box::new(e), 270 - })?; 263 + let response = 264 + self.inner 265 + .get(url.clone()) 266 + .send() 267 + .await 268 + .map_err(|e| IdentityError::HttpTransport { 269 + source: Box::new(e), 270 + })?; 271 271 let status = response.status().as_u16(); 272 272 let bytes = response 273 273 .bytes() ··· 291 291 .expect("failed to build DNS resolver") 292 292 .build(); 293 293 Self { inner: resolver } 294 + } 295 + } 296 + 297 + impl Default for RealDnsResolver { 298 + fn default() -> Self { 299 + Self::new() 294 300 } 295 301 } 296 302 ··· 309 315 .map(|record| { 310 316 Ok(record 311 317 .iter() 312 - .map(|data| { 313 - String::from_utf8(data.to_vec()).unwrap_or_default() 314 - }) 318 + .map(|data| String::from_utf8(data.to_vec()).unwrap_or_default()) 315 319 .collect::<Vec<_>>() 316 320 .join("")) 317 321 }) ··· 332 336 if handle.is_empty() 333 337 || handle.starts_with('.') 334 338 || handle.ends_with('.') 335 - || !handle.chars().all(|c| c.is_ascii()) 339 + || !handle.is_ascii() 336 340 || !handle.contains('.') 337 341 { 338 342 return Err(IdentityError::InvalidHandle); ··· 367 371 368 372 // HTTPS fallback: GET https://<handle>/.well-known/atproto-did. 369 373 let url = format!("https://{}/.well-known/atproto-did", handle); 370 - let url = url.parse::<Url>().map_err(|_| IdentityError::InvalidHandle)?; 374 + let url = url 375 + .parse::<Url>() 376 + .map_err(|_| IdentityError::InvalidHandle)?; 371 377 372 378 let mut http_error_opt: Option<Box<IdentityError>> = None; 373 379 374 380 match http.get_bytes(&url).await { 375 - Ok((status, bytes)) if status == 200 => { 381 + Ok((200, bytes)) => { 376 382 let did_str = String::from_utf8_lossy(&bytes).trim().to_string(); 377 383 if !did_str.is_empty() { 378 384 let did = Did(did_str); ··· 413 419 let (url, source_name) = match did.method() { 414 420 DidMethod::Plc => { 415 421 let url_str = format!("https://plc.directory/{}", did.0); 416 - let url = url_str.parse::<Url>().map_err(|_| { 417 - IdentityError::DidResolutionFailed { 422 + let url = url_str 423 + .parse::<Url>() 424 + .map_err(|_| IdentityError::DidResolutionFailed { 418 425 status: 400, 419 426 body: "Invalid DID format".to_string(), 420 - } 421 - })?; 427 + })?; 422 428 (url.clone(), url.to_string()) 423 429 } 424 430 DidMethod::Web => { ··· 447 453 format!("https://{}/{}/did.json", host, path) 448 454 }; 449 455 450 - let url = url_str.parse::<Url>().map_err(|_| { 451 - IdentityError::DidResolutionFailed { 456 + let url = url_str 457 + .parse::<Url>() 458 + .map_err(|_| IdentityError::DidResolutionFailed { 452 459 status: 400, 453 460 body: "Invalid URL".to_string(), 454 - } 455 - })?; 461 + })?; 456 462 (url.clone(), url.to_string()) 457 463 } 458 464 DidMethod::Other => { ··· 505 511 for service in services { 506 512 // Match both "#fragment" and "did:...#fragment" forms. 507 513 let matches_id = service.id.ends_with(&format!("#{}", id_fragment)) 508 - || service.id.ends_with(&format!("#{}:{}", id_fragment, id_fragment)); 514 + || service 515 + .id 516 + .ends_with(&format!("#{}:{}", id_fragment, id_fragment)); 509 517 510 518 if matches_id && service.type_ == expected_type { 511 519 return Some(service); ··· 517 525 518 526 /// Parses a multikey string into a verifying key. 519 527 pub fn parse_multikey(raw: &str) -> Result<ParsedMultikey, IdentityError> { 520 - tracing::debug!( 521 - target = "atproto_devtool::identity", 522 - "parsing multikey" 523 - ); 528 + tracing::debug!(target = "atproto_devtool::identity", "parsing multikey"); 524 529 525 - let (base, bytes) = multibase::decode(raw).map_err(|_| { 526 - IdentityError::MultikeyDecodeFailed { 530 + let (base, bytes) = 531 + multibase::decode(raw).map_err(|_| IdentityError::MultikeyDecodeFailed { 527 532 source: Box::new(IdentityError::UnsupportedMultibase( 528 533 "failed to decode multibase".to_string(), 529 534 )), 530 - } 531 - })?; 535 + })?; 532 536 533 537 // Require base58btc encoding. 534 538 if base != multibase::Base::Base58Btc { ··· 586 590 verifying_key: AnyVerifyingKey::P256(key), 587 591 }) 588 592 } 589 - _ => { 590 - Err(IdentityError::UnsupportedCurve { 591 - codec_prefix: curve_bytes.to_vec(), 592 - }) 593 - } 593 + _ => Err(IdentityError::UnsupportedCurve { 594 + codec_prefix: curve_bytes.to_vec(), 595 + }), 594 596 } 595 597 } 596 598 ··· 631 633 #[async_trait] 632 634 impl HttpClient for FakeHttpClient { 633 635 async fn get_bytes(&self, url: &Url) -> Result<(u16, Vec<u8>), IdentityError> { 634 - self.responses 635 - .get(url.as_str()) 636 - .cloned() 637 - .ok_or_else(|| IdentityError::DidResolutionFailed { 636 + self.responses.get(url.as_str()).cloned().ok_or_else(|| { 637 + IdentityError::DidResolutionFailed { 638 638 status: 404, 639 639 body: "Not found".to_string(), 640 - }) 640 + } 641 + }) 641 642 } 642 643 } 643 644 ··· 661 662 #[tokio::test] 662 663 async fn resolve_handle_via_dns() { 663 664 let mut records = HashMap::new(); 664 - records.insert("_atproto.alice.example".to_string(), vec![ 665 - "did=did:plc:abc123".to_string(), 666 - ]); 665 + records.insert( 666 + "_atproto.alice.example".to_string(), 667 + vec!["did=did:plc:abc123".to_string()], 668 + ); 667 669 let dns = FakeDnsResolver { records }; 668 670 let http = FakeHttpClient { 669 671 responses: HashMap::new(), ··· 708 710 709 711 assert!(result.is_err()); 710 712 match result.unwrap_err() { 711 - IdentityError::HandleUnresolvable { dns_error, http_error } => { 713 + IdentityError::HandleUnresolvable { 714 + dns_error, 715 + http_error, 716 + } => { 712 717 assert!(dns_error.is_some()); 713 718 assert!(http_error.is_some()); 714 719 } ··· 733 738 let raw_doc = result.unwrap(); 734 739 assert_eq!(raw_doc.parsed.id, "did:plc:ar7c4by46qjdydhdevvrndac"); 735 740 assert!(raw_doc.source_bytes.as_ref() == plc_doc); 736 - assert_eq!(raw_doc.source_name, "https://plc.directory/did:plc:ar7c4by46qjdydhdevvrndac"); 741 + assert_eq!( 742 + raw_doc.source_name, 743 + "https://plc.directory/did:plc:ar7c4by46qjdydhdevvrndac" 744 + ); 737 745 738 746 // Verify the service is present. 739 747 let services = raw_doc.parsed.service.unwrap(); ··· 757 765 assert!(result.is_ok()); 758 766 let raw_doc = result.unwrap(); 759 767 assert_eq!(raw_doc.parsed.id, "did:web:example.com"); 760 - assert_eq!(raw_doc.source_name, "https://example.com/.well-known/did.json"); 768 + assert_eq!( 769 + raw_doc.source_name, 770 + "https://example.com/.well-known/did.json" 771 + ); 761 772 } 762 773 763 774 #[tokio::test] ··· 882 893 // Build a multikey with an unsupported curve prefix (0x01 0x00). 883 894 let mut unsupported_bytes = vec![0x01, 0x00]; 884 895 unsupported_bytes.extend_from_slice(&[0; 33]); // Fake 33-byte key. 885 - let multikey = format!("z{}", multibase::encode(multibase::Base::Base58Btc, unsupported_bytes)); 896 + let multikey = format!( 897 + "z{}", 898 + multibase::encode(multibase::Base::Base58Btc, unsupported_bytes) 899 + ); 886 900 887 901 let result = parse_multikey(&multikey); 888 902 assert!(result.is_err()); 889 903 890 904 match result.unwrap_err() { 891 - IdentityError::UnsupportedCurve { 892 - codec_prefix: _, 893 - } => {} 905 + IdentityError::UnsupportedCurve { codec_prefix: _ } => {} 894 906 _ => panic!("Expected UnsupportedCurve error"), 895 907 } 896 908 }

Configure Feed

Configure Feed