Release v1.0.0 with clippy fixes and duplicate query fix

- Bump version to 1.0.0
- Add clippy pedantic and nursery lints configuration
- Fix all clippy warnings (format string inlining, Self usage, etc.)
- Fix duplicate RDAP query when referral points to same server
- Skip registrar referral if host matches registry server

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: Showfom

Cargo.lock

@@ -1,13 +1,32 @@
 [package]
 name = "rdap"
-version = "0.2.1"
+version = "1.0.0"
 edition = "2024"
 authors = ["xTom", "Akaere Networks"]
 description = "A modern RDAP (Registration Data Access Protocol) client"
 license = "MIT"
 homepage = "https://github.com/xtomcom/rdap"
 repository = "https://github.com/xtomcom/rdap"
 
+[lints.clippy]
+pedantic = { level = "warn", priority = -1 }
+nursery = { level = "warn", priority = -1 }
+# Allow these common patterns
+module_name_repetitions = "allow"
+must_use_candidate = "allow"
+return_self_not_must_use = "allow"
+missing_errors_doc = "allow"
+missing_panics_doc = "allow"
+redundant_pub_crate = "allow"
+too_many_lines = "allow"
+struct_excessive_bools = "allow"
+unused_self = "allow"
+cast_possible_truncation = "allow"
+items_after_statements = "allow"
+if_not_else = "allow"
+branches_sharing_code = "allow"
+assigning_clones = "allow"
+
 [dependencies]
 # HTTP client
 reqwest = { version = "0.13", features = ["json", "rustls"] }

Cargo.toml

@@ -45,20 +45,20 @@ impl BootstrapClient {
             QueryType::Tld => {
                 // TLD queries always go to IANA RDAP
                 let url = Url::parse(config::IANA_RDAP_URL)
-                    .map_err(|e| RdapError::Bootstrap(format!("Invalid IANA RDAP URL: {}", e)))?;
+                    .map_err(|e| RdapError::Bootstrap(format!("Invalid IANA RDAP URL: {e}")))?;
                 Ok(vec![url])
             }
             QueryType::Domain => {
                 // Priority: tlds.json first, then bootstrap
                 if let Some(url) = config::lookup_tld_override(&self.tld_overrides, &request.query)
                 {
-                    log::debug!("Found TLD override for {}: {}", request.query, url);
+                    log::debug!("Found TLD override for {}: {url}", request.query);
                     return Ok(vec![url]);
                 }
 
                 // Fall back to IANA bootstrap
                 let registry = self.fetch_registry(&self.config.bootstrap.dns).await?;
-                self.match_domain(&registry, &request.query)
+                Ok(self.match_domain(&registry, &request.query))
             }
             QueryType::Ip => {
                 let bootstrap_url = if request.query.contains(':') {
@@ -74,24 +74,24 @@ impl BootstrapClient {
                 self.match_asn(&registry, &request.query)
             }
             QueryType::Entity => Err(RdapError::Bootstrap(
-                "Entity queries require explicit server (-s/--server)".to_string(),
+                "Entity queries require explicit server (-s/--server)".to_owned(),
             )),
             _ => Err(RdapError::Bootstrap(
-                "This query type requires explicit server (-s/--server)".to_string(),
+                "This query type requires explicit server (-s/--server)".to_owned(),
             )),
         }
     }
 
     /// Fetch bootstrap registry file from URL
     async fn fetch_registry(&self, url: &str) -> Result<BootstrapRegistry> {
-        log::debug!("Fetching bootstrap registry: {}", url);
+        log::debug!("Fetching bootstrap registry: {url}");
 
         let response = self.http_client.get(url).send().await?;
 
         if !response.status().is_success() {
+            let status = response.status();
             return Err(RdapError::Bootstrap(format!(
-                "Failed to fetch registry: HTTP {}",
-                response.status()
+                "Failed to fetch registry: HTTP {status}"
             )));
         }
 
@@ -100,7 +100,7 @@ impl BootstrapClient {
     }
 
     /// Match domain name
-    fn match_domain(&self, registry: &BootstrapRegistry, domain: &str) -> Result<Vec<Url>> {
+    fn match_domain(&self, registry: &BootstrapRegistry, domain: &str) -> Vec<Url> {
         let domain = domain.trim_end_matches('.').to_lowercase();
 
         // Build lookup map
@@ -111,7 +111,7 @@ impl BootstrapClient {
             {
                 let url_strings: Vec<String> = urls
                     .iter()
-                    .filter_map(|v| v.as_str().map(|s| s.to_string()))
+                    .filter_map(|v| v.as_str().map(std::borrow::ToOwned::to_owned))
                     .collect();
 
                 for entry in entries {
@@ -128,34 +128,34 @@ impl BootstrapClient {
         while !parts.is_empty() {
             let test_domain = parts.join(".");
             if let Some(urls) = map.get(&test_domain) {
-                return Ok(urls.iter().filter_map(|s| Url::parse(s).ok()).collect());
+                return urls.iter().filter_map(|s| Url::parse(s).ok()).collect();
             }
             parts.remove(0);
         }
 
-        Ok(vec![])
+        vec![]
     }
 
     /// Match IP address (supports standard IPs, shorthand IPs, and CIDR)
     fn match_ip(&self, registry: &BootstrapRegistry, ip_query: &str) -> Result<Vec<Url>> {
         // Normalize the IP (handles shorthand like 1.1 -> 1.0.0.1)
         let normalized = ip::normalize_ip(ip_query)
-            .ok_or_else(|| RdapError::InvalidQuery(format!("Invalid IP address: {}", ip_query)))?;
+            .ok_or_else(|| RdapError::InvalidQuery(format!("Invalid IP address: {ip_query}")))?;
 
         // Extract the IP part (for CIDR queries like 8.8.8.0/24, we match using the network address)
         let ip_str = ip::extract_ip_from_cidr(&normalized);
 
         let addr: IpAddr = ip_str
             .parse()
-            .map_err(|_| RdapError::InvalidQuery(format!("Invalid IP address: {}", ip_str)))?;
+            .map_err(|_| RdapError::InvalidQuery(format!("Invalid IP address: {ip_str}")))?;
 
         for service in &registry.services {
             if service.len() >= 2
                 && let (Some(entries), Some(urls)) = (service[0].as_array(), service[1].as_array())
             {
                 for entry in entries {
                     if let Some(cidr) = entry.as_str()
-                        && self.ip_in_network(&addr, cidr)
+                        && Self::ip_in_network(&addr, cidr)
                     {
                         let url_list: Vec<Url> = urls
                             .iter()
@@ -171,7 +171,7 @@ impl BootstrapClient {
     }
 
     /// Check if IP is in CIDR network using ipnet
-    fn ip_in_network(&self, addr: &IpAddr, cidr: &str) -> bool {
+    fn ip_in_network(addr: &IpAddr, cidr: &str) -> bool {
         if let Ok(network) = cidr.parse::<IpNet>() {
             return network.contains(addr);
         }
@@ -188,15 +188,15 @@ impl BootstrapClient {
         };
         let asn: u32 = asn_str
             .parse()
-            .map_err(|_| RdapError::InvalidQuery(format!("Invalid AS number: {}", asn_str)))?;
+            .map_err(|_| RdapError::InvalidQuery(format!("Invalid AS number: {asn_str}")))?;
 
         for service in &registry.services {
             if service.len() >= 2
                 && let (Some(entries), Some(urls)) = (service[0].as_array(), service[1].as_array())
             {
                 for entry in entries {
                     if let Some(range_str) = entry.as_str()
-                        && self.asn_in_range(asn, range_str)
+                        && Self::asn_in_range(asn, range_str)
                     {
                         let url_list: Vec<Url> = urls
                             .iter()
@@ -212,7 +212,7 @@ impl BootstrapClient {
     }
 
     /// Check if AS number is in range
-    fn asn_in_range(&self, asn: u32, range_str: &str) -> bool {
+    fn asn_in_range(asn: u32, range_str: &str) -> bool {
         if let Some(dash_pos) = range_str.find('-') {
             // Range: "1000-2000"
             if let (Ok(start), Ok(end)) = (

src/bootstrap.rs

@@ -14,9 +14,7 @@ pub struct Cache {
 impl Cache {
     /// Create a new cache (~/.cache/rdap/ on all platforms)
     pub fn new() -> Result<Self> {
-        let cache_dir = std::env::var("HOME")
-            .map(|h| PathBuf::from(h).join(".cache/rdap"))
-            .unwrap_or_else(|_| PathBuf::from(".cache/rdap"));
+        let cache_dir = std::env::var("HOME").map_or_else(|_| PathBuf::from(".cache/rdap"), |h| PathBuf::from(h).join(".cache/rdap"));
 
         fs::create_dir_all(&cache_dir)?;
 
@@ -27,7 +25,7 @@ impl Cache {
     }
 
     /// Set cache TTL
-    pub fn with_ttl(mut self, ttl: Duration) -> Self {
+    pub const fn with_ttl(mut self, ttl: Duration) -> Self {
         self.ttl = ttl;
         self
     }
@@ -46,7 +44,7 @@ impl Cache {
             && let Ok(elapsed) = SystemTime::now().duration_since(modified)
             && elapsed > self.ttl
         {
-            log::debug!("Cache expired for {}", key);
+            log::debug!("Cache expired for {key}");
             let _ = fs::remove_file(&path);
             return None;
         }

src/cache.rs

@@ -48,13 +48,13 @@ impl RdapClient {
     }
 
     /// Set timeout
-    pub fn with_timeout(mut self, timeout: Duration) -> Self {
+    pub const fn with_timeout(mut self, timeout: Duration) -> Self {
         self.timeout = timeout;
         self
     }
 
     /// Enable or disable following registrar referrals (default: enabled)
-    pub fn with_follow_referral(mut self, follow: bool) -> Self {
+    pub const fn with_follow_referral(mut self, follow: bool) -> Self {
         self.follow_referral = follow;
         self
     }
@@ -85,7 +85,7 @@ impl RdapClient {
         for base_url in &urls {
             let url = request.build_url(base_url)?;
 
-            log::debug!("Querying RDAP server: {}", url);
+            log::debug!("Querying RDAP server: {url}");
 
             match self.fetch_rdap(&url).await {
                 Ok(obj) => {
@@ -95,7 +95,21 @@ impl RdapClient {
                         && let RdapObject::Domain(ref domain) = obj
                         && let Some(registrar_rdap_url) = self.extract_registrar_rdap_url(domain)
                     {
-                        log::debug!("Following registrar referral: {}", registrar_rdap_url);
+                        // Skip if referral points to the same server (same host)
+                        if Self::is_same_server(&url, &registrar_rdap_url) {
+                            log::debug!(
+                                "Skipping referral: same server as registry ({})",
+                                registrar_rdap_url.host_str().unwrap_or("unknown")
+                            );
+                            return Ok(RdapQueryResult {
+                                registry: obj,
+                                registry_url: url,
+                                registrar: None,
+                                registrar_url: None,
+                            });
+                        }
+
+                        log::debug!("Following registrar referral: {registrar_rdap_url}");
                         match self.fetch_rdap(&registrar_rdap_url).await {
                             Ok(registrar_obj) => {
                                 return Ok(RdapQueryResult {
@@ -106,7 +120,7 @@ impl RdapClient {
                                 });
                             }
                             Err(e) => {
-                                log::warn!("Failed to fetch registrar data: {}", e);
+                                log::warn!("Failed to fetch registrar data: {e}");
                                 // Continue with registry-only result
                             }
                         }
@@ -120,7 +134,7 @@ impl RdapClient {
                 }
                 Err(RdapError::NotFound) => return Err(RdapError::NotFound),
                 Err(e) => {
-                    log::warn!("Server {} failed: {}", url, e);
+                    log::warn!("Server {url} failed: {e}");
                     last_error = Some(e);
                 }
             }
@@ -129,6 +143,11 @@ impl RdapClient {
         Err(last_error.unwrap_or(RdapError::NoWorkingServers))
     }
 
+    /// Check if two URLs point to the same server (same host)
+    fn is_same_server(url1: &Url, url2: &Url) -> bool {
+        url1.host() == url2.host()
+    }
+
     /// Extract registrar RDAP URL from domain response
     fn extract_registrar_rdap_url(&self, domain: &Domain) -> Option<Url> {
         // Look for a link with rel="related" and type containing "rdap"
@@ -200,7 +219,7 @@ impl RdapClient {
                     description: err_obj.description,
                 })
             } else {
-                Err(RdapError::Other(format!("HTTP error: {}", status)))
+                Err(RdapError::Other(format!("HTTP error: {status}")))
             }
         }
     }

src/client.rs

@@ -78,9 +78,7 @@ impl Default for CacheConfig {
 
 /// Get the user config directory path (~/.config/rdap/)
 pub fn user_config_dir() -> Result<PathBuf> {
-    let dir = std::env::var("HOME")
-        .map(|h| PathBuf::from(h).join(".config/rdap"))
-        .unwrap_or_else(|_| PathBuf::from(".config/rdap"));
+    let dir = std::env::var("HOME").map_or_else(|_| PathBuf::from(".config/rdap"), |h| PathBuf::from(h).join(".config/rdap"));
     Ok(dir)
 }
 
@@ -90,7 +88,7 @@ pub fn system_config_dir() -> PathBuf {
 }
 
 impl Config {
-    /// Get the config directory path (alias for user_config_dir)
+    /// Get the config directory path (alias for `user_config_dir`)
     pub fn config_dir() -> Result<PathBuf> {
         user_config_dir()
     }
@@ -132,7 +130,7 @@ impl Config {
 
         // Fall back to built-in default
         log::debug!("Using built-in config");
-        let config: Config = serde_json::from_str(BUILTIN_CONFIG)?;
+        let config: Self = serde_json::from_str(BUILTIN_CONFIG)?;
         Ok(config)
     }
 
@@ -265,11 +263,11 @@ pub async fn update_configs() -> Result<UpdateResult> {
                         result.config_error = Some("Invalid config.json format".to_string());
                     }
                 }
-                Err(e) => result.config_error = Some(format!("Failed to read response: {}", e)),
+                Err(e) => result.config_error = Some(format!("Failed to read response: {e}")),
             }
         }
         Ok(response) => result.config_error = Some(format!("HTTP {}", response.status())),
-        Err(e) => result.config_error = Some(format!("Request failed: {}", e)),
+        Err(e) => result.config_error = Some(format!("Request failed: {e}")),
     }
 
     // Update tlds.json
@@ -287,11 +285,11 @@ pub async fn update_configs() -> Result<UpdateResult> {
                         result.tlds_error = Some("Invalid tlds.json format".to_string());
                     }
                 }
-                Err(e) => result.tlds_error = Some(format!("Failed to read response: {}", e)),
+                Err(e) => result.tlds_error = Some(format!("Failed to read response: {e}")),
             }
         }
         Ok(response) => result.tlds_error = Some(format!("HTTP {}", response.status())),
-        Err(e) => result.tlds_error = Some(format!("Request failed: {}", e)),
+        Err(e) => result.tlds_error = Some(format!("Request failed: {e}")),
     }
 
     // Update tlds.txt (IANA TLD list)
@@ -314,11 +312,11 @@ pub async fn update_configs() -> Result<UpdateResult> {
                         result.tld_list_error = Some("Invalid tlds.txt format".to_string());
                     }
                 }
-                Err(e) => result.tld_list_error = Some(format!("Failed to read response: {}", e)),
+                Err(e) => result.tld_list_error = Some(format!("Failed to read response: {e}")),
             }
         }
         Ok(response) => result.tld_list_error = Some(format!("HTTP {}", response.status())),
-        Err(e) => result.tld_list_error = Some(format!("Request failed: {}", e)),
+        Err(e) => result.tld_list_error = Some(format!("Request failed: {e}")),
     }
 
     Ok(result)