Mirrored_Repos/AppFlowy
1
0
Fork 0
mirror of https://github.com/AppFlowy-IO/AppFlowy.git synced 2024-08-30 18:12:39 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor FromBytes and ToBytes trait auto impl in flowy-sys

Browse Source
This commit is contained in:
appflowy 2021-07-03 23:14:38 +08:00
parent 4a82d7157c
commit e5ca614ceb
7 changed files with 121 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
rust-lib/flowy-ast/src/ty_ext.rs
View File

@ -99,7 +99,7 @@ pub fn generate_hashmap_ty_info<'a>(
ident: &path_segment.ident,
ty,
primitive_ty: PrimitiveTy::Map(MapInfo::new(key, value)),
bracket_ty_info,
bracket_ty_info: bracket_ty_info,
});
}

10
rust-lib/flowy-derive/src/proto_buf/protobuf_trait.rs Normal file
View File

@ -0,0 +1,10 @@
pub trait SerializeProtoBuf {
type ProtoBufType;
fn to_protobuf(&self) -> Self::ProtoBufType;
}
pub trait DeserializeProtoBuf {
type ProtoBufType;
type ObjectType;
fn from_protobuf(pb: &mut Self::ProtoBufType) -> Self::ObjectType;
}

17
rust-lib/flowy-derive/src/proto_buf/util.rs Normal file
View File

@ -0,0 +1,17 @@
pub enum TypeCategory {
Array,
Map,
Str,
Protobuf,
Bytes,
Enum,
Opt,
Primitive,
}
fn category_from_str(type_str: &str) -> TypeCategory { TypeCategory::Protobuf }
pub fn ident_category(ident: &syn::Ident) -> TypeCategory {
let ident_str: &str = &ident.to_string();
category_from_str(ident_str)
}

43
rust-lib/flowy-sdk/tests/sdk/helper.rs
View File

@ -33,35 +33,36 @@ pub struct EventTester {
}
impl EventTester {
pub fn new<E>(event: E, payload: Payload) -> Self
pub fn new<E, P>(event: E, payload: P) -> Self
where
E: Eq + Hash + Debug + Clone + Display,
P: std::convert::Into<Payload>,
{
init_sdk();
Self {
request: DispatchRequest::new(event, payload),
request: DispatchRequest::new(event, payload.into()),
}
}
#[allow(dead_code)]
pub fn bytes_payload<T>(mut self, payload: T) -> Self
where
T: serde::Serialize,
{
let bytes: Vec<u8> = bincode::serialize(&payload).unwrap();
self.request = self.request.payload(Payload::Bytes(bytes));
self
}
#[allow(dead_code)]
pub fn protobuf_payload<T>(mut self, payload: T) -> Self
where
T: ::protobuf::Message,
{
let bytes: Vec<u8> = payload.write_to_bytes().unwrap();
self.request = self.request.payload(Payload::Bytes(bytes));
self
}
// #[allow(dead_code)]
// pub fn bytes_payload<T>(mut self, payload: T) -> Self
// where
// T: serde::Serialize,
// {
// let bytes: Vec<u8> = bincode::serialize(&payload).unwrap();
// self.request = self.request.payload(Payload::Bytes(bytes));
// self
// }
//
// #[allow(dead_code)]
// pub fn protobuf_payload<T>(mut self, payload: T) -> Self
// where
// T: ::protobuf::Message,
// {
// let bytes: Vec<u8> = payload.write_to_bytes().unwrap();
// self.request = self.request.payload(Payload::Bytes(bytes));
// self
// }
#[allow(dead_code)]
pub async fn async_send(self) -> EventResponse {

14
rust-lib/flowy-sdk/tests/sdk/user_check.rs
View File

@ -6,15 +6,17 @@ use tokio::time::{sleep, Duration};
#[test]
#[should_panic]
fn auth_check_no_payload() {
let resp = EventTester::new(AuthCheck).sync_send();
let resp = EventTester::new(AuthCheck, Payload::None).sync_send();
assert_eq!(resp.status_code, StatusCode::Ok);
}
#[tokio::test]
async fn auth_check_with_user_name_email_payload() {
let user_data = UserData::new("jack".to_owned(), "helloworld@gmail.com".to_owned());
EventTester::new(AuthCheck)
.bytes_payload(user_data)
.sync_send();
// let user_data = UserData::new("jack".to_owned(),
// "helloworld@gmail.com".to_owned());
//
//
// EventTester::new(AuthCheck)
// .bytes_payload(user_data)
// .sync_send();
}

72
rust-lib/flowy-sys/src/request/request.rs
View File

@ -116,34 +116,56 @@ impl<T> ops::DerefMut for Data<T> {
fn deref_mut(&mut self) -> &mut T { &mut self.0 }
}
#[cfg(feature = "use_serde")]
impl<T> FromRequest for Data<T>
where
T: serde::de::DeserializeOwned + 'static,
{
type Error = SystemError;
type Future = Ready<Result<Self, SystemError>>;
#[inline]
fn from_request(req: &EventRequest, payload: &mut Payload) -> Self::Future {
match payload {
Payload::None => ready(Err(unexpected_none_payload(req))),
Payload::Bytes(bytes) => {
let s = String::from_utf8_lossy(bytes);
match serde_json::from_str(s.as_ref()) {
Ok(data) => ready(Ok(Data(data))),
Err(e) => ready(Err(InternalError::new(format!("{:?}", e)).into())),
}
},
}
}
}
// #[cfg(feature = "use_serde")]
// impl<T> FromRequest for Data<T>
// where
// T: serde::de::DeserializeOwned + 'static,
// {
// type Error = SystemError;
// type Future = Ready<Result<Self, SystemError>>;
//
// #[inline]
// fn from_request(req: &EventRequest, payload: &mut Payload) ->
// Self::Future { match payload {
// Payload::None => ready(Err(unexpected_none_payload(req))),
// Payload::Bytes(bytes) => {
// let s = String::from_utf8_lossy(bytes);
// match serde_json::from_str(s.as_ref()) {
// Ok(data) => ready(Ok(Data(data))),
// Err(e) => ready(Err(InternalError::new(format!("{:?}",
// e)).into())), }
// },
// }
// }
// }
pub trait FromBytes: Sized {
fn parse_from_bytes(bytes: &Vec<u8>) -> Result<Self, SystemError>;
}
#[cfg(not(feature = "use_serde"))]
impl<T> FromBytes for T
where
// https://stackoverflow.com/questions/62871045/tryfromu8-trait-bound-in-trait
T: for<'a> std::convert::TryFrom<&'a Vec<u8>, Error = SystemError>,
{
fn parse_from_bytes(bytes: &Vec<u8>) -> Result<Self, SystemError> { T::try_from(bytes) }
}
#[cfg(feature = "use_serde")]
impl<T> FromBytes for T
where
T: serde::de::DeserializeOwned + 'static,
{
fn parse_from_bytes(bytes: &Vec<u8>) -> Result<Self, SystemError> {
let s = String::from_utf8_lossy(bytes);
match serde_json::from_str::<T>(s.as_ref()) {
Ok(data) => Ok(data),
Err(e) => InternalError::new(format!("{:?}", e)).into(),
}
}
}
impl<T> FromRequest for Data<T>
where
T: FromBytes + 'static,
@ -155,9 +177,9 @@ where
fn from_request(req: &EventRequest, payload: &mut Payload) -> Self::Future {
match payload {
Payload::None => ready(Err(unexpected_none_payload(req))),
Payload::Bytes(bytes) => {
let data = T::parse_from_bytes(bytes).unwrap();
ready(Ok(Data(data)))
Payload::Bytes(bytes) => match T::parse_from_bytes(bytes) {
Ok(data) => ready(Ok(Data(data))),
Err(e) => ready(Err(InternalError::new(format!("{:?}", e)).into())),
},
}
}

32
rust-lib/flowy-sys/src/response/responder.rs
View File

@ -1,11 +1,11 @@
#[allow(unused_imports)]
use crate::error::{InternalError, SystemError};
use crate::{
error::SystemError,
request::{Data, EventRequest},
response::{EventResponse, ResponseBuilder},
};
use bytes::Bytes;
pub trait Responder {
fn respond_to(self, req: &EventRequest) -> EventResponse;
}
@ -42,26 +42,27 @@ pub trait ToBytes {
fn into_bytes(self) -> Result<Vec<u8>, SystemError>;
}
#[cfg(not(feature = "use_serde"))]
impl<T> ToBytes for T
where
T: std::convert::TryInto<Vec<u8>, Error = SystemError>,
{
fn into_bytes(self) -> Result<Vec<u8>, SystemError> { self.try_into() }
}
#[cfg(feature = "use_serde")]
impl<T> Responder for Data<T>
impl<T> ToBytes for T
where
T: serde::Serialize,
{
fn respond_to(self, _request: &EventRequest) -> EventResponse {
let bytes: Vec<u8> = bincode::serialize(&self.0).unwrap();
ResponseBuilder::Ok().data(bytes).build()
fn into_bytes(self) -> Result<Vec<u8>, SystemError> {
match serde_json::to_string(&self.0) {
Ok(s) => Ok(s.into_bytes()),
Err(e) => InternalError::new(format!("{:?}", e)).into(),
}
}
}
#[cfg(feature = "use_serde")]
impl<T> std::convert::From<T> for Data<T>
where
T: serde::Serialize,
{
fn from(val: T) -> Self { Data(val) }
}
#[cfg(not(feature = "use_serde"))]
impl<T> Responder for Data<T>
where
T: ToBytes,
@ -74,7 +75,6 @@ where
}
}
#[cfg(not(feature = "use_serde"))]
impl<T> std::convert::From<T> for Data<T>
where
T: ToBytes,