EventAdapter implementation (#1)

.github/workflows/ci.yml

@@ -100,6 +100,7 @@ jobs:
           - arcana-codegen-shim
           - arcana-codegen
           - arcana
+          - arcana-example-chat
         os:
           - ubuntu
           - macOS
@@ -168,6 +169,7 @@ jobs:
           - arcana-codegen-shim
           - arcana-codegen
           - arcana
+          - arcana-example-chat
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2

CHANGELOG.md

@@ -23,7 +23,18 @@ All user visible changes to this project will be documented in this file. This p
   - Proc macros
     - `Event` derive
     - `VersionedEvent` derive
-
+  - Transforming Events
+    - Traits
+      - `Adapter`
+      - `Transformer`
+      - `Adapt`
+      - `Strategy`
+    - Structs
+      - `strategy::AsIs`
+      - `strategy::Custom`
+      - `strategy::Into`
+      - `strategy::Skip`
+      - `strategy::Split`
 
 
 

Cargo.toml

@@ -26,9 +26,9 @@ es = ["arcana-core/es"]
 arcana-core = { version = "0.1.0-dev", path = "./core" }
 arcana-codegen = { version = "0.1.0-dev", path = "./codegen", optional = true }
 
-[[example]]
-name = "event"
-required-features = ["derive", "es"]
-
 [workspace]
-members = ["codegen", "codegen/impl", "codegen/shim", "core"]
+members = [
+    "codegen", "codegen/impl", "codegen/shim",
+    "core",
+    "examples/chat",
+]

codegen/impl/Cargo.toml

@@ -18,7 +18,7 @@ all-features = true
 rustdoc-args = ["--cfg", "docsrs"]
 
 [features]
-doc = ["arcana-core"] # only for generating documentation
+doc = ["arcana-core", "futures"] # only for generating documentation
 
 [dependencies]
 proc-macro2 = { version = "1.0.4", default-features = false }
@@ -28,3 +28,4 @@ synthez = { version = "0.1.3", default-features = false }
 
 # `doc` feature
 arcana-core = { version = "0.1.0-dev", path = "../../core", features = ["es"], optional = true }
+futures = { version = "0.3", default-features = false, optional = true }

codegen/impl/src/es/event/adapter.rs

@@ -0,0 +1,185 @@
+//! `#[derive(event::Adapter)]` macro implementation.
+
+use std::convert::TryFrom;
+
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::parse_quote;
+use synthez::{ParseAttrs, Required, ToTokens};
+
+/// Expands `#[derive(event::Adapter)]` macro.
+///
+/// # Errors
+///
+/// If failed to parse [`Attrs`].
+pub fn derive(input: TokenStream) -> syn::Result<TokenStream> {
+    let input = syn::parse2::<syn::DeriveInput>(input)?;
+    let definition = Definition::try_from(input)?;
+
+    Ok(quote! { #definition })
+}
+
+/// Helper attributes of `#[derive(event::Adapter)]` macro.
+#[derive(Debug, Default, ParseAttrs)]
+pub struct Attrs {
+    /// [`Returning::Transformed`][0] associated type.
+    ///
+    /// [0]: arcana_core::es::event::adapter::Returning::Transformed
+    #[parse(value, alias = into)]
+    pub transformed: Required<syn::Type>,
+
+    /// [`Returning::Error`][0] associated type.
+    ///
+    /// [0]: arcana_core::es::event::adapter::Returning::Error
+    #[parse(value, alias = err)]
+    pub error: Option<syn::Type>,
+}
+
+/// Representation of a struct implementing [`event::Adapter`][0], used for
+/// code generation.
+///
+/// [0]: arcana_core::es::event::Adapter
+#[derive(Debug, ToTokens)]
+#[to_tokens(append(impl_returning))]
+pub struct Definition {
+    /// [`syn::Ident`](struct@syn::Ident) of this type.
+    pub ident: syn::Ident,
+
+    /// [`syn::Generics`] of this type.
+    pub generics: syn::Generics,
+
+    /// [`Returning::Transformed`][0] associated type.
+    ///
+    /// [0]: arcana_core::es::event::adapter::Returning::Transformed
+    pub transformed: syn::Type,
+
+    /// [`Returning::Error`][0] associated type.
+    ///
+    /// [0]: arcana_core::es::event::adapter::Returning::Error
+    pub error: syn::Type,
+}
+
+impl TryFrom<syn::DeriveInput> for Definition {
+    type Error = syn::Error;
+
+    fn try_from(input: syn::DeriveInput) -> syn::Result<Self> {
+        let attrs: Attrs = Attrs::parse_attrs("adapter", &input)?;
+
+        Ok(Self {
+            ident: input.ident,
+            generics: input.generics,
+            transformed: attrs.transformed.into_inner(),
+            error: attrs
+                .error
+                .unwrap_or_else(|| parse_quote! { ::std::convert::Infallible }),
+        })
+    }
+}
+
+impl Definition {
+    /// Generates code to derive [`Returning`][0] trait.
+    ///
+    /// [0]: arcana_core::es::event::adapter::Returning
+    #[must_use]
+    pub fn impl_returning(&self) -> TokenStream {
+        let ty = &self.ident;
+        let (impl_gens, ty_gens, where_clause) = self.generics.split_for_impl();
+        let (transformed, error) = (&self.transformed, &self.error);
+
+        quote! {
+            #[automatically_derived]
+            impl #impl_gens ::arcana::es::event::adapter::Returning for
+                 #ty #ty_gens
+                 #where_clause
+            {
+                type Error = #error;
+                type Transformed = #transformed;
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod spec {
+    use quote::quote;
+    use syn::parse_quote;
+
+    #[test]
+    fn derives_impl() {
+        let input = parse_quote! {
+            #[adapter(into = Event, error = CustomError)]
+            struct Adapter;
+        };
+
+        let output = quote! {
+            #[automatically_derived]
+            impl ::arcana::es::event::adapter::Returning for Adapter {
+                type Error = CustomError;
+                type Transformed = Event;
+            }
+        };
+
+        assert_eq!(
+            super::derive(input).unwrap().to_string(),
+            output.to_string(),
+        );
+    }
+
+    #[test]
+    fn derives_impl_with_default_infallible_error() {
+        let input = parse_quote! {
+            #[adapter(into = Event)]
+            struct Adapter;
+        };
+
+        let output = quote! {
+            #[automatically_derived]
+            impl ::arcana::es::event::adapter::Returning for Adapter {
+                type Error = ::std::convert::Infallible;
+                type Transformed = Event;
+            }
+        };
+
+        assert_eq!(
+            super::derive(input).unwrap().to_string(),
+            output.to_string(),
+        );
+    }
+
+    #[test]
+    fn derives_impl_with_generics() {
+        let input = parse_quote! {
+            #[adapter(transformed = Event, err = CustomError)]
+            struct Adapter<T>(T);
+        };
+
+        let output = quote! {
+            #[automatically_derived]
+            impl<T> ::arcana::es::event::adapter::Returning for Adapter<T> {
+                type Error = CustomError;
+                type Transformed = Event;
+            }
+        };
+
+        assert_eq!(
+            super::derive(input).unwrap().to_string(),
+            output.to_string(),
+        );
+    }
+
+    #[test]
+    fn transformed_arg_is_required() {
+        let input = parse_quote! {
+            #[adapter(error = CustomError)]
+            struct Adapter;
+        };
+
+        let err = super::derive(input).unwrap_err();
+
+        assert_eq!(
+            err.to_string(),
+            "either `into` or `transformed` argument of `#[adapter]` attribute \
+             is expected to be present, but is absent",
+        );
+    }
+}