feat: some code cleanup

Signed-off-by: rooot <[e-mail]>

src/bsky.rs

···
         .feed
         .get_post_thread(
             bsky_sdk::api::app::bsky::feed::get_post_thread::ParametersData {
-                depth: LimitedU16::try_from(0 as u16).ok(),
-                parent_height: LimitedU16::try_from(0 as u16).ok(),
+                depth: LimitedU16::try_from(0).ok(),
+                parent_height: LimitedU16::try_from(0).ok(),
                 uri: atproto_uri.clone(),
             }
             .into(),
···
                 };
 
                 if let Unknown::Object(record) = data.record {
-                    if ipld_to_string(record.get_key_value("$type").ok_or(MissingElementError("$type".into()))?.1.deref()) == Ok("app.bsky.feed.post".to_string()) {
+                    if ipld_to_string(record.get_key_value("$type").ok_or(MissingElementError("$type".into()))?.1) == Ok("app.bsky.feed.post".to_string()) {
 
-                        let text = ipld_to_string(record.get_key_value("text").ok_or(MissingElementError("text".into()))?.1.deref()).ok();
+                        let text = ipld_to_string(record.get_key_value("text").ok_or(MissingElementError("text".into()))?.1).ok();
 
                         // todo: format text into markdown so we can embed it nicely
                         // for now we'll just return the text as is
···
                                 // this is also why we need those 2 checks above
                                 let bite_me = video::Main::try_from_unknown(unknown_embed.clone());
 
-                                let video_blob = match bite_me {
-                                    Ok(video) => {
-                                        match &video.clone().video {
-                                            bsky_sdk::api::types::BlobRef::Typed(blob) => {
-                                                match blob {
-                                                    Blob(blob) => Some(blob.clone()),
-                                                }
-                                            },
-                                            bsky_sdk::api::types::BlobRef::Untyped(_) => {
-                                                None
-                                            }
-                                        }
-                                    },
-                                    Err(_) => {
-                                        None
+                                if let Ok(thing) = bite_me {
+                                    if let bsky_sdk::api::types::BlobRef::Typed(Blob(blob)) = &thing.video {
+                                        blobs.push(blob.clone());
                                     }
-                                };
-                                if let Some(blob) = video_blob {
-                                    blobs.push(blob);
                                 }
                             }
                         }
 
                         for image in images {
-                            let image_embed = ImageData::try_from_unknown(Unknown::Other(DataModel::try_from(image)?))?;
-
-                            let blob = match image_embed.image {
-                                bsky_sdk::api::types::BlobRef::Typed(blob) => {
-                                    match blob {
-                                        Blob(blob) => Some(blob),
-                                    }
-                                },
-                                bsky_sdk::api::types::BlobRef::Untyped(_) => {
-                                    None
-                                }
-                            };
-                            if let Some(blob) = blob {
+                            if let bsky_sdk::api::types::BlobRef::Typed(Blob(blob)) = ImageData::try_from_unknown(Unknown::Other(DataModel::try_from(image)?))?.image {
                                 blobs.push(blob);
                             }
                         };
···
 }
 
 fn ipld_to_string(ipld: &Ipld) -> Result<String, ()> {
-    match ipld {
-        Ipld::String(s) => {
-            Ok(s.clone()) // well guess what fuck you
-        }
-        _ => Err(()),
+    if let Ipld::String(s) = ipld {
+        Ok(s.clone())
+    } else {
+        Err(())
     }
 }