update: cleanup

charybdis-parser/src/fields.rs

@@ -112,11 +112,14 @@ impl<'a> Field<'a> {
         FieldAttributes::from_attributes(&field.attrs)
             .map(|char_attrs| {
                 let ignore = char_attrs.ignore.unwrap_or(false);
-
-                let column_type = char_attrs.column_type.clone().map(
-                    |tname| CqlType::from_str(tname.as_str()).unwrap()
-                ).unwrap_or_else(|| Field::outer_type(&field.ty, ignore));
-
+                let column_type =
+                    char_attrs
+                        .column_type
+                        .as_ref()
+                        .map_or(Field::outer_type(&field.ty, ignore), |tname| {
+                            let error = format!("Unknown column type: {}", tname);
+                            CqlType::from_str(tname.as_str()).expect(&error)
+                        });
                 let ident = field.ident.clone().unwrap();
 
                 Field {
@@ -128,7 +131,7 @@ impl<'a> Field<'a> {
                         _ => panic!("Only type path is supported!"),
                     },
                     outer_type: column_type,
-                    column_type_override: char_attrs.column_type.clone(),
+                    column_type_override: char_attrs.column_type,
                     span: field.span(),
                     attrs: &field.attrs,
                     ignore,

charybdis/tests/integrations/custom_fields.rs

@@ -1,7 +1,8 @@
-use charybdis::scylla::deserialize::DeserializeValue;
-use charybdis::scylla::frame::response::result::ColumnType;
 use charybdis::scylla::SerializeValue;
 use charybdis::types::Text;
+use scylla::_macro_internal::{CellWriter, ColumnType, WrittenCellProof};
+use scylla::deserialize::{DeserializationError, DeserializeValue, FrameSlice, TypeCheckError};
+use scylla::serialize::SerializationError;
 
 #[derive(Debug, Default, Clone, PartialEq, strum::FromRepr)]
 #[repr(i8)]
@@ -21,31 +22,29 @@ impl std::fmt::Display for AddressTypeCustomDeserializeErr {
 impl std::error::Error for AddressTypeCustomDeserializeErr {}
 
 impl<'frame, 'metadata> DeserializeValue<'frame, 'metadata> for AddressTypeCustomField {
-    fn type_check(
-        typ: &scylla::frame::response::result::ColumnType,
-    ) -> std::result::Result<(), scylla::deserialize::TypeCheckError> {
+    fn type_check(typ: &ColumnType) -> Result<(), TypeCheckError> {
         <i8 as DeserializeValue<'frame, 'metadata>>::type_check(typ)
     }
 
     fn deserialize(
         typ: &'metadata ColumnType<'metadata>,
-        v: Option<scylla::deserialize::FrameSlice<'frame>>,
-    ) -> std::result::Result<Self, scylla::deserialize::DeserializationError> {
+        v: Option<FrameSlice<'frame>>,
+    ) -> Result<Self, DeserializationError> {
         let si8 = <i8 as DeserializeValue<'frame, 'metadata>>::deserialize(typ, v)?;
         let s = Self::from_repr(si8);
-        s.ok_or_else(|| scylla::deserialize::DeserializationError::new(AddressTypeCustomDeserializeErr(si8)))
+        s.ok_or_else(|| DeserializationError::new(AddressTypeCustomDeserializeErr(si8)))
     }
 }
 
 impl SerializeValue for AddressTypeCustomField {
     fn serialize<'b>(
         &self,
         typ: &ColumnType,
-        writer: scylla::serialize::writers::CellWriter<'b>,
-    ) -> Result<scylla::serialize::writers::WrittenCellProof<'b>, scylla::serialize::SerializationError> {
+        writer: CellWriter<'b>,
+    ) -> Result<WrittenCellProof<'b>, SerializationError> {
         let disc = self.clone() as i8;
 
-        let v  = <i8 as SerializeValue>::serialize(&disc, typ, writer)?;
+        let v = <i8 as SerializeValue>::serialize(&disc, typ, writer)?;
         Ok(v)
     }
 }
@@ -57,7 +56,9 @@ pub struct UserExtraDataCustomField {
 
 impl Default for UserExtraDataCustomField {
     fn default() -> Self {
-        Self { user_tags: vec![("some_key".to_string(), "some_value".to_string())] }
+        Self {
+            user_tags: vec![("some_key".to_string(), "some_value".to_string())],
+        }
     }
 }
 
@@ -71,37 +72,29 @@ impl std::fmt::Display for UserExtraDataDeserializeErr {
 impl std::error::Error for UserExtraDataDeserializeErr {}
 
 impl<'frame, 'metadata> DeserializeValue<'frame, 'metadata> for UserExtraDataCustomField {
-    fn type_check(
-        typ: &scylla::frame::response::result::ColumnType,
-    ) -> std::result::Result<(), scylla::deserialize::TypeCheckError> {
+    fn type_check(typ: &ColumnType) -> Result<(), TypeCheckError> {
         <Text as DeserializeValue<'frame, 'metadata>>::type_check(typ)
     }
 
     fn deserialize(
         typ: &'metadata ColumnType<'metadata>,
-        v: Option<scylla::deserialize::FrameSlice<'frame>>,
-    ) -> std::result::Result<Self, scylla::deserialize::DeserializationError> {
+        v: Option<FrameSlice<'frame>>,
+    ) -> Result<Self, DeserializationError> {
         let si8 = <Text as DeserializeValue<'frame, 'metadata>>::deserialize(typ, v)?;
         serde_json::from_str::<UserExtraDataCustomField>(&si8)
-            .map_err(
-                |_e| scylla::deserialize::DeserializationError::new(
-                        UserExtraDataDeserializeErr(si8)))
+            .map_err(|_e| DeserializationError::new(UserExtraDataDeserializeErr(si8)))
     }
 }
 
 impl SerializeValue for UserExtraDataCustomField {
     fn serialize<'b>(
         &self,
         typ: &ColumnType,
-        writer: scylla::serialize::writers::CellWriter<'b>,
-    ) -> Result<scylla::serialize::writers::WrittenCellProof<'b>, scylla::serialize::SerializationError> {
+        writer: CellWriter<'b>,
+    ) -> Result<WrittenCellProof<'b>, SerializationError> {
+        let disc = serde_json::to_string(&self).map_err(|_e| SerializationError::new(_e))?;
 
-        let disc = serde_json::to_string(&self)
-            .map_err(|_e| scylla::serialize::SerializationError::new(
-                _e
-            ))?;
-
-        let v  = <Text as SerializeValue>::serialize(&disc, typ, writer)?;
+        let v = <Text as SerializeValue>::serialize(&disc, typ, writer)?;
         Ok(v)
     }
-}
+}

charybdis/tests/integrations/main.rs

@@ -1,5 +1,4 @@
 mod common;
+mod custom_fields;
 mod model;
 mod query;
-
-mod custom_fields;

charybdis/tests/integrations/model.rs

@@ -1,5 +1,5 @@
 use crate::common::db_session;
-use crate::custom_fields::{AddressTypeCustomField,UserExtraDataCustomField};
+use crate::custom_fields::{AddressTypeCustomField, UserExtraDataCustomField};
 
 use charybdis::batch::ModelBatch;
 use charybdis::errors::CharybdisError;
@@ -81,7 +81,7 @@ impl User {
                 addr_type: AddressTypeCustomField::WorkAddress,
             }),
             is_confirmed: true,
-            user_extra_data: UserExtraDataCustomField::default()
+            user_extra_data: UserExtraDataCustomField::default(),
         }
     }
 }