feat: preview mutations with dry run flag

Author: howenyap

lib/endpoints/raindrops.rs

@@ -1,6 +1,6 @@
 use crate::client::RaindropClient;
 use crate::error::Error;
-use crate::http::Response;
+use crate::http::{Response, ResponseMetadata};
 use crate::models::common::{
     BoolResponse, CollectionScope, ItemResponse, ItemsResponse, ModifiedResponse,
 };
@@ -34,6 +34,20 @@ impl RaindropsApi {
         })
     }
 
+    pub async fn get_many(&self, ids: &[i64]) -> Result<Response<Vec<Raindrop>>, Error> {
+        let mut items = Vec::with_capacity(ids.len());
+
+        for id in ids {
+            let response = self.get(RaindropId::new(*id)).await?;
+            items.push(response.data);
+        }
+
+        Ok(Response {
+            data: items,
+            meta: ResponseMetadata::default(),
+        })
+    }
+
     pub async fn create(&self, payload: &CreateRaindrop) -> Result<Response<Raindrop>, Error> {
         let res = self
             .client

lib/models/raindrops.rs

@@ -30,6 +30,49 @@ impl Raindrop {
                 .is_some_and(|value| value.id == i64::from(scope)),
         }
     }
+
+    pub fn change_lines(&self, payload: &UpdateRaindrop) -> Vec<String> {
+        let existing_title = self.title.as_deref().unwrap_or("(untitled)");
+        let mut changes = Vec::new();
+
+        if let Some(title) = payload.title.as_deref() {
+            changes.push(format!("Title: {existing_title} -> {title}"));
+        }
+
+        if let Some(excerpt) = payload.excerpt.as_deref() {
+            let existing_excerpt = self.excerpt.as_deref().unwrap_or("(none)");
+
+            changes.push(format!("Excerpt: {existing_excerpt} -> {excerpt}"));
+        }
+
+        if let Some(collection) = payload.collection.as_ref() {
+            let from_collection = self
+                .collection
+                .as_ref()
+                .map(|value| CollectionScope::from(value.id).to_string())
+                .unwrap_or_else(|| "(none)".to_string());
+            let to_collection = CollectionScope::from(collection.id);
+
+            changes.push(format!("Collection: {from_collection} -> {to_collection}"));
+        }
+
+        if let Some(tags) = payload.tags.as_ref() {
+            let existing_tags = if self.tags.is_empty() {
+                "(none)".to_string()
+            } else {
+                self.tags.join(", ")
+            };
+            let updated_tags = if tags.is_empty() {
+                "(none)".to_string()
+            } else {
+                tags.join(", ")
+            };
+
+            changes.push(format!("Tags: {existing_tags} -> {updated_tags}"));
+        }
+
+        changes
+    }
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]

src/app.rs

@@ -2,19 +2,32 @@ use crate::Command;
 use crate::config::Config;
 use puddle::{Error, RaindropClient};
 
+pub(crate) struct RunContext {
+    pub(crate) is_dry_run: bool,
+}
+
 pub(crate) struct CliApp {
     pub(crate) config: Config,
     pub(crate) client: RaindropClient,
+    pub(crate) context: RunContext,
 }
 
 impl CliApp {
-    pub(crate) fn new() -> Result<Self, Box<dyn std::error::Error>> {
+    pub(crate) fn new(context: RunContext) -> Result<Self, Box<dyn std::error::Error>> {
         let config = Config::load()?;
         let client = RaindropClient::builder()
             .access_token(config.values().access_token.clone())
             .build()?;
 
-        Ok(Self { config, client })
+        Ok(Self {
+            config,
+            client,
+            context,
+        })
+    }
+
+    pub(crate) fn is_dry_run(&self) -> bool {
+        self.context.is_dry_run
     }
 
     pub(crate) async fn run_command(

src/collections.rs

@@ -1,5 +1,9 @@
 use crate::app::CliApp;
 use crate::common::{display_text, read_upload_file};
+use crate::previews::{
+    CreateCollectionPreview, DeleteCollectionPreview, UpdateCollectionPreview,
+    UploadCollectionCoverPreview,
+};
 use clap::{Args, Subcommand};
 use puddle::models::collections::{Collection, CreateCollection, UpdateCollection};
 use puddle::models::common::CollectionScope;
@@ -99,6 +103,13 @@ impl CliApp {
             parent: args.parent,
             extra: HashMap::new(),
         };
+
+        if self.is_dry_run() {
+            println!("{}", CreateCollectionPreview::new(&payload));
+
+            return Ok(());
+        }
+
         let response = self.client.collections().create(&payload).await?;
         print_collection_detail(&response.data);
 
@@ -114,6 +125,23 @@ impl CliApp {
             parent: args.parent,
             extra: HashMap::new(),
         };
+
+        if self.is_dry_run() {
+            let existing_collection = self
+                .client
+                .collections()
+                .get(CollectionScope::from(args.id))
+                .await?
+                .data;
+
+            println!(
+                "{}",
+                UpdateCollectionPreview::new(&existing_collection, &payload)
+            );
+
+            return Ok(());
+        }
+
         let response = self.client.collections().update(args.id, &payload).await?;
         print_collection_detail(&response.data);
 
@@ -124,6 +152,19 @@ impl CliApp {
         &self,
         args: DeleteCollectionArgs,
     ) -> Result<(), Box<dyn std::error::Error>> {
+        if self.is_dry_run() {
+            let existing_collection = self
+                .client
+                .collections()
+                .get(CollectionScope::from(args.id))
+                .await?
+                .data;
+
+            println!("{}", DeleteCollectionPreview::new(&existing_collection));
+
+            return Ok(());
+        }
+
         let response = self.client.collections().delete(args.id).await?;
         println!("deleted: {}", response.data);
 
@@ -134,6 +175,23 @@ impl CliApp {
         &self,
         args: UploadCollectionCoverArgs,
     ) -> Result<(), Box<dyn std::error::Error>> {
+        if self.is_dry_run() {
+            let _ = read_upload_file(&args.path)?;
+            let existing_collection = self
+                .client
+                .collections()
+                .get(CollectionScope::from(args.id))
+                .await?
+                .data;
+
+            println!(
+                "{}",
+                UploadCollectionCoverPreview::new(&existing_collection, &args.path)
+            );
+
+            return Ok(());
+        }
+
         let (bytes, mime, file_name) = read_upload_file(&args.path)?;
         let response = self
             .client
@@ -189,7 +247,6 @@ fn format_collection_summary(item: &Collection) -> String {
 
     parts.join(" | ")
 }
-
 #[cfg(test)]
 mod tests {
     use super::*;

src/main.rs

@@ -4,11 +4,12 @@ mod common;
 mod config;
 mod constants;
 mod filters;
+mod previews;
 mod raindrops;
 mod tags;
 mod user;
 
-use crate::app::CliApp;
+use crate::app::{CliApp, RunContext};
 use crate::config::{ConfigValues, global_config_path};
 use crate::constants::{
     AUTHORIZE_URL_BASE, DEFAULT_OAUTH_DEBUG_REDIRECT_URI, RAINDROP_INTEGRATIONS_URI,
@@ -25,6 +26,8 @@ use url::form_urlencoded;
 #[derive(Debug, Parser)]
 #[command(name = "puddle", version, about = "")]
 struct Cli {
+    #[arg(long = "dry-run", global = true)]
+    is_dry_run: bool,
     #[command(subcommand)]
     command: Option<Command>,
 }
@@ -94,7 +97,11 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             println!("{}", path.display());
         }
         command => {
-            let mut app = CliApp::new()?;
+            let context = RunContext {
+                is_dry_run: cli.is_dry_run,
+            };
+
+            let mut app = CliApp::new(context)?;
             app.run_command(command).await?;
         }
     }