chore: good rust

Author: Daanvdplas

.github/workflows/ci.yml

@@ -158,8 +158,7 @@ jobs:
       checks: write
       packages: read
     env:
-      # We cannot propagate the "missing_docs" flag, as otherwise other tests fail.
-      RUSTFLAGS: "-Dwarnings -Dmissing_docs"
+      RUSTDOCFLAGS: "-Dwarnings -Dmissing_docs"
     steps:
       - uses: actions/checkout@v4
 

Cargo.lock

@@ -25,7 +25,6 @@ tempfile = { version = "3", optional = true }
 [dev-dependencies]
 tokio-test = "0.4"
 tempfile = "3"
-serial_test = "3"
 
 [profile.release]
 opt-level = "z"     # Optimize for size
@@ -36,3 +35,36 @@ panic = "abort"     # Smaller binary
 
 [profile.production]
 inherits = "release"
+
+[lints.rust]
+missing_docs = "deny"
+unsafe_code = "deny"
+rust_2018_idioms = "deny"
+trivial_casts = "deny"
+trivial_numeric_casts = "deny"
+unused_lifetimes = "deny"
+unused_qualifications = "deny"
+
+[lints.clippy]
+correctness = "deny"
+complexity = "deny"
+perf = "deny"
+style = "deny"
+suspicious = "deny"
+unwrap_used = "deny"
+expect_used = "deny"
+panic = "deny"
+todo = "deny"
+unimplemented = "deny"
+dbg_macro = "deny"
+print_stdout = "deny"
+print_stderr = "deny"
+clone_on_ref_ptr = "deny"
+empty_structs_with_brackets = "deny"
+expl_impl_clone_on_copy = "deny"
+implicit_clone = "deny"
+manual_string_new = "deny"
+redundant_closure_for_method_calls = "deny"
+semicolon_if_nothing_returned = "deny"
+str_to_string = "deny"
+use_self = "deny"

Cargo.toml

@@ -23,11 +23,11 @@ pub enum PopMcpError {
 impl fmt::Display for PopMcpError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            PopMcpError::CommandExecution(msg) => write!(f, "Command execution error: {}", msg),
-            PopMcpError::InvalidInput(msg) => write!(f, "Invalid input: {}", msg),
-            PopMcpError::ResourceNotFound(msg) => write!(f, "Resource not found: {}", msg),
-            PopMcpError::NetworkError(msg) => write!(f, "Network error: {}", msg),
-            PopMcpError::Internal(msg) => write!(f, "Internal error: {}", msg),
+            Self::CommandExecution(msg) => write!(f, "Command execution error: {}", msg),
+            Self::InvalidInput(msg) => write!(f, "Invalid input: {}", msg),
+            Self::ResourceNotFound(msg) => write!(f, "Resource not found: {}", msg),
+            Self::NetworkError(msg) => write!(f, "Network error: {}", msg),
+            Self::Internal(msg) => write!(f, "Internal error: {}", msg),
         }
     }
 }
@@ -36,12 +36,12 @@ impl std::error::Error for PopMcpError {}
 
 impl From<anyhow::Error> for PopMcpError {
     fn from(err: anyhow::Error) -> Self {
-        PopMcpError::Internal(err.to_string())
+        Self::Internal(err.to_string())
     }
 }
 
 impl From<reqwest::Error> for PopMcpError {
     fn from(err: reqwest::Error) -> Self {
-        PopMcpError::NetworkError(err.to_string())
+        Self::NetworkError(err.to_string())
     }
 }

src/error.rs

@@ -6,11 +6,14 @@ use std::process::Command;
 
 use crate::error::{PopMcpError, PopMcpResult};
 
-/// Output from command execution
+/// Output from command execution.
 #[derive(Debug, Clone)]
 pub struct CommandOutput {
+    /// Standard output from the command.
     pub stdout: String,
+    /// Standard error from the command.
     pub stderr: String,
+    /// Whether the command exited successfully.
     pub success: bool,
 }
 
@@ -31,7 +34,7 @@ impl CommandOutput {
         }
 
         if result.is_empty() {
-            "(Command succeeded but produced no output)".to_string()
+            "(Command succeeded but produced no output)".to_owned()
         } else {
             result
         }
@@ -49,6 +52,7 @@ pub struct PopExecutor {
 }
 
 impl PopExecutor {
+    /// Create a new executor with default settings.
     pub fn new() -> Self {
         Self::default()
     }
@@ -112,8 +116,8 @@ mod tests {
     #[test]
     fn command_output_combines_streams() {
         let output = CommandOutput {
-            stdout: "stdout content".to_string(),
-            stderr: "stderr content".to_string(),
+            stdout: "stdout content".to_owned(),
+            stderr: "stderr content".to_owned(),
             success: true,
         };
         assert!(output.combined().contains("stderr content"));

src/executor.rs

@@ -6,16 +6,20 @@ use rmcp::ErrorData as McpError;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
+/// Parameters for the search_documentation tool.
 #[derive(Debug, Clone, Deserialize, Serialize, JsonSchema)]
 pub struct SearchDocumentationParams {
+    /// Search query or topic.
     #[schemars(description = "Search query or topic")]
     pub query: String,
+    /// Scope to limit search to specific documentation.
     #[schemars(
         description = "Limit search to specific documentation: 'ink', 'pop', 'xcm', 'dedot', or 'all'"
     )]
     pub scope: Option<String>,
 }
 
+/// Search through Polkadot documentation for specific topics.
 pub async fn search_documentation(
     params: SearchDocumentationParams,
 ) -> Result<CallToolResult, McpError> {
@@ -126,6 +130,7 @@ async fn fetch_external_doc(url: &str) -> Result<String> {
     Ok(text)
 }
 
+/// Search documentation with the given query and optional scope filter.
 pub async fn search_docs(query: &str, scope: Option<String>) -> Result<CallToolResult> {
     let search_scope = match scope.as_deref() {
         Some("ink") => "ink",
@@ -151,7 +156,7 @@ pub async fn search_docs(query: &str, scope: Option<String>) -> Result<CallToolR
         }
 
         let content = match &res.source {
-            ResourceSource::Embedded(text) => text.to_string(),
+            ResourceSource::Embedded(text) => (*text).to_owned(),
             ResourceSource::External(url) => match fetch_external_doc(url).await {
                 Ok(text) => text,
                 Err(e) => {
@@ -209,16 +214,17 @@ pub async fn search_docs(query: &str, scope: Option<String>) -> Result<CallToolR
     Ok(CallToolResult::success(vec![Content::text(response)]))
 }
 
+/// List all available documentation resources.
 pub async fn list_resources() -> Result<ListResourcesResult> {
     let resources: Vec<Resource> = RESOURCES
         .iter()
         .map(|res| {
             Resource::new(
                 rmcp::model::RawResource {
-                    uri: res.uri.to_string(),
-                    name: res.name.to_string(),
+                    uri: (*res.uri).to_owned(),
+                    name: (*res.name).to_owned(),
                     description: Some(format!("{} resource", res.scope)),
-                    mime_type: Some("text/plain".to_string()),
+                    mime_type: Some("text/plain".to_owned()),
                     title: None,
                     size: None,
                     icons: None,
@@ -234,18 +240,19 @@ pub async fn list_resources() -> Result<ListResourcesResult> {
     })
 }
 
+/// Read a documentation resource by URI.
 pub async fn read_resource(uri: &str) -> Result<ReadResourceResult> {
     for res in RESOURCES {
         if res.uri == uri {
             let content = match &res.source {
-                ResourceSource::Embedded(text) => text.to_string(),
+                ResourceSource::Embedded(text) => (*text).to_owned(),
                 ResourceSource::External(url) => fetch_external_doc(url).await?,
             };
 
             return Ok(ReadResourceResult {
                 contents: vec![rmcp::model::ResourceContents::text(
                     content,
-                    uri.to_string(),
+                    (*uri).to_owned(),
                 )],
             });
         }