exonum · aleksuss · Oct 24, 2019 · Oct 9, 2019 · Oct 9, 2019 · Oct 10, 2019
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -39,8 +39,16 @@ The project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html)
 
 #### exonum-proto
 
-- Introduced new crate `exonum-proto`. Trait `ProtobufConvert` is moved to
-  `exonum-proto` crate. (#1496)
+- Introduced a new crate `exonum-proto`. Trait `ProtobufConvert` is moved
+  to this crate. (#1496)
+
+#### exonum-proto-derive
+
+- Introduced a new crate `exonum-proto-derive`. Derive macro `ProtobufConvert` is
+  moved to this crate. (#1501)
+
+- Derive macro `ProtobufConvert` now doesn't derive `BinaryValue` and `ObjectHash`
+  traits. There are separate derive macros for them in `exonum-derive` crate. (#1501)
 
 #### exonum-build
 

diff --git a/Cargo.toml b/Cargo.toml
@@ -16,5 +16,6 @@ members = [
     "components/keys",
     "components/merkledb",
     "components/proto",
+    "components/proto-derive",
 ]
 exclude = [ "exonum/fuzz" ]
diff --git a/components/derive/src/db_traits.rs b/components/derive/src/db_traits.rs
@@ -0,0 +1,118 @@
+// Copyright 2019 The Exonum Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use darling::FromDeriveInput;
+use proc_macro::TokenStream;
+use proc_macro2::{Ident, Span};
+use quote::{quote, ToTokens};
+use syn::DeriveInput;
+
+#[derive(Debug, FromDeriveInput)]
+struct BinaryValueStruct {
+    ident: Ident,
+}
+
+#[derive(Debug, FromDeriveInput)]
+struct ObjectHashStruct {
+    ident: Ident,
+}
+
+impl ObjectHashStruct {
+    pub fn implement_object_hash(&self) -> impl ToTokens {
+        let name = &self.ident;
+
+        quote! {
+            impl exonum_merkledb::ObjectHash for #name {
+                fn object_hash(&self) -> exonum_crypto::Hash {
+                    use exonum_merkledb::BinaryValue;
+                    let v = self.to_bytes();
+                    exonum_crypto::hash(&v)
+                }
+            }
+        }
+    }
+}
+
+impl BinaryValueStruct {
+    pub fn implement_binary_value(&self) -> impl ToTokens {
+        let name = &self.ident;
+
+        quote! {
+            // This trait assumes that we work with trusted data so we can unwrap here.
+            impl exonum_merkledb::BinaryValue for #name {
+                fn to_bytes(&self) -> Vec<u8> {
+                    self.to_pb().write_to_bytes().expect(
+                        concat!("Failed to serialize in BinaryValue for ", stringify!(#name))
+                    )
+                }
+
+                fn from_bytes(value: std::borrow::Cow<[u8]>) -> Result<Self, failure::Error> {
+                    let mut block = <Self as exonum_proto::ProtobufConvert>::ProtoStruct::new();
+                    block.merge_from_bytes(value.as_ref())?;
+                    exonum_proto::ProtobufConvert::from_pb(block)
+                }
+            }
+        }
+    }
+}
+
+impl ToTokens for BinaryValueStruct {
+    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
+        let mod_name = Ident::new(
+            &format!("binary_value_impl_{}", self.ident),
+            Span::call_site(),
+        );
+
+        let binary_value = self.implement_binary_value();
+        let expanded = quote! {
+            mod #mod_name {
+                use super::*;
+
+                use protobuf::Message as _ProtobufMessage;
+                use exonum_proto::ProtobufConvert;
+
+                #binary_value
+            }
+        };
+
+        tokens.extend(expanded);
+    }
+}
+
+impl ToTokens for ObjectHashStruct {
+    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
+        let object_hash = self.implement_object_hash();
+        let expanded = quote! { #object_hash };
+
+        tokens.extend(expanded);
+    }
+}
+
+pub fn binary_value(input: TokenStream) -> TokenStream {
+    let input: DeriveInput = syn::parse(input).unwrap();
+
+    let db_object = BinaryValueStruct::from_derive_input(&input)
+        .unwrap_or_else(|e| panic!("BinaryValue: {}", e));
+    let tokens = quote! { #db_object };
+    tokens.into()
+}
+
+pub fn object_hash(input: TokenStream) -> TokenStream {
+    let input: DeriveInput = syn::parse(input).unwrap();
+
+    let db_object =
+        ObjectHashStruct::from_derive_input(&input).unwrap_or_else(|e| panic!("ObjectHash: {}", e));
+    let tokens = quote! { #db_object };
+    tokens.into()
+}
diff --git a/components/derive/src/lib.rs b/components/derive/src/lib.rs
@@ -20,56 +20,58 @@
 
 extern crate proc_macro;
 
+mod db_traits;
 mod execution_error;
 mod exonum_service;
-mod pb_convert;
 mod service_factory;
 
 use darling::FromMeta;
 use proc_macro::TokenStream;
 use quote::ToTokens;
 use syn::{Attribute, NestedMeta};
 
-/// Derive `ProtobufConvert` trait.
+/// Derive `BinaryValue` trait.
+/// Target type must implement `ProtobufConvert` trait.
 ///
-/// Attributes:
-///
-/// ## Required
-///
-/// * `#[exonum(pb = "path")]`
-///
-/// Path is the name of the corresponding protobuf generated struct.
-///
-/// ## Optional
-///
-/// * `#[exonum(crate = "path")]`
+/// # Example
+/// ```ignore
+/// #[derive(Clone, Debug, BinaryValue)]
+/// #[protobuf_convert(source = "proto::Wallet")]
+/// pub struct Wallet {
+///     /// `PublicKey` of the wallet.
+///     pub pub_key: PublicKey,
+///     /// Current balance of the wallet.
+///     pub balance: u64,
+/// }
 ///
-/// Prefix of the `exonum` crate(usually "crate" or "exonum").
+/// let wallet = Wallet::new();
+/// let bytes = wallet.to_bytes();
+/// ```
+#[proc_macro_derive(BinaryValue)]
+pub fn binary_value(input: TokenStream) -> TokenStream {
+    db_traits::binary_value(input)
+}
+
+/// Derive `ObjectHash` trait.
+/// Target type must implement `BinaryValue` trait.
 ///
-/// * `#[exonum(serde_pb_convert)]`
-///
-/// Implement `serde::{Serialize, Deserialize}` using structs that were generated with
-/// protobuf.
-/// For example, it should be used if you want json representation of your struct
-/// to be compatible with protobuf representation (including proper nesting of fields).
-/// ```text
-/// For example, struct with `exonum::crypto::Hash` with this
-/// (de)serializer will be represented as
-/// StructName {
-///     "hash": {
-///         data: [1, 2, ...]
-///     },
-///     // ...
-    /// }
-/// // With default (de)serializer.
-/// StructName {
-///     "hash": "12af..." // HEX
-///     // ...
+/// # Example
+/// ```ignore
+/// #[protobuf_convert(source = "proto::Wallet")]
+/// #[derive(Clone, Debug, ProtobufConvert, BinaryValue, ObjectHash)]
+/// pub struct Wallet {
+///     /// `PublicKey` of the wallet.
+///     pub pub_key: PublicKey,
+///     /// Current balance of the wallet.
+///     pub balance: u64,
 /// }
+///
+/// let wallet = Wallet::new();
+/// let hash = wallet.object_hash();
 /// ```
-#[proc_macro_derive(ProtobufConvert, attributes(exonum))]
-pub fn generate_protobuf_convert(input: TokenStream) -> TokenStream {
-    pb_convert::implement_protobuf_convert(input)
+#[proc_macro_derive(ObjectHash)]
+pub fn object_hash(input: TokenStream) -> TokenStream {
+    db_traits::object_hash(input)
 }
 
 /// Derive `ServiceFactory` and `ServiceDispatcher` traits.

diff --git a/components/proto-derive/Cargo.toml b/components/proto-derive/Cargo.toml
@@ -0,0 +1,23 @@
+[package]
+name = "exonum-proto-derive"
+version = "0.12.0"
+edition = "2018"
+authors = ["The Exonum Team <exonum@bitfury.com>"]
+homepage = "https://exonum.com/"
+repository = "https://github.com/exonum/exonum"
+documentation = "https://docs.rs/exonum-proto-derive"
+license = "Apache-2.0"
+keywords = ["protobuf", "exonum"]
+categories = ["development-tools"]
+description = "Helper macros for serialization structs in protobuf."
+
+[lib]
+proc-macro = true
+
+[dependencies]
+darling = "0.10.0"
+heck = "0.3.1"
+proc-macro2 = "1.0"
+quote = "1.0"
+syn = "1.0"
+semver = "0.9"
diff --git a/components/proto-derive/src/lib.rs b/components/proto-derive/src/lib.rs
@@ -0,0 +1,124 @@
+// Copyright 2019 The Exonum Team
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! This crate provides macros for deriving some useful methods and traits for the exonum services.
+
+#![recursion_limit = "128"]
+#![deny(unsafe_code, bare_trait_objects)]
+#![warn(missing_docs, missing_debug_implementations)]
+
+extern crate proc_macro;
+
+mod pb_convert;
+
+use proc_macro::TokenStream;
+use syn::{Attribute, NestedMeta};
+
+/// ProtobufConvert derive macro.
+///
+/// Attributes:
+///
+/// ## Required
+///
+/// * `#[protobuf_convert(source = "path")]`
+///
+/// ```ignore
+/// #[derive(Clone, Debug, BinaryValue, ObjectHash, ProtobufConvert)]
+/// #[protobuf_convert(source = "proto::Wallet")]
+/// pub struct Wallet {
+///     /// `PublicKey` of the wallet.
+///     pub pub_key: PublicKey,
+///     /// Current balance of the wallet.
+///     pub balance: u64,
+/// }
+///
+/// let wallet = Wallet::new();
+/// let serialized_wallet = wallet.to_pb();
+///
+/// let deserialized_wallet = ProtobufConvert::from_pb(serialized_wallet).unwrap();
+/// assert_eq!(wallet, deserialized_wallet);
+/// ```
+///
+/// Corresponding proto file:
+/// ```proto
+/// message Wallet {
+///     // Public key of the wallet owner.
+///     exonum.crypto.PublicKey pub_key = 1;
+///     // Current balance.
+///     uint64 balance = 2;
+/// }
+/// ```
+///
+/// This macro can also be applied to enums. In proto files enums are represented
+/// by `oneof` field. You can specify `oneof` field name, default is "message".
+/// Corresponding proto file must contain only this oneof field. Possible enum
+/// variants are zero-field and one-field variants.
+/// ```ignore
+/// #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize, ProtobufConvert)]
+/// #[protobuf_convert(source = "schema::runtime::ConfigChange", oneof_field = "message")]
+/// pub enum ConfigChange {
+///     /// New consensus config.
+///     Consensus(ConsensusConfig),
+///     /// New service instance config.
+///     Service(ServiceConfig),
+/// }
+/// ```
+///
+/// Corresponding proto file:
+/// ```proto
+/// message ConfigChange {
+///     oneof message {
+///         // New consensus config.
+///         exonum.Config consensus = 1;
+///         // New service instance config.
+///         ServiceConfig service = 2;
+///     }
+/// }
+/// ```
+///
+/// Path is the name of the corresponding protobuf generated struct.
+///
+/// * `#[protobuf_convert(source = "path", serde_pb_convert)]`
+///
+/// Implement `serde::{Serialize, Deserialize}` using structs that were generated with
+/// protobuf.
+/// For example, it should be used if you want json representation of your struct
+/// to be compatible with protobuf representation (including proper nesting of fields).
+/// For example, struct with `exonum::crypto::Hash` with this
+/// (de)serializer will be represented as
+/// ```text
+/// StructName {
+///     "hash": {
+///         "data": [1, 2, ...]
+///     },
+///     // ...
+/// }
+/// // With default (de)serializer.
+/// StructName {
+///     "hash": "12af..." // HEX
+///     // ...
+/// }
+/// ```
+#[proc_macro_derive(ProtobufConvert, attributes(protobuf_convert))]
+pub fn protobuf_convert(input: TokenStream) -> TokenStream {
+    pb_convert::implement_protobuf_convert(input)
+}
+
+pub(crate) fn find_protobuf_convert_meta(args: &[Attribute]) -> Option<NestedMeta> {
+    args.as_ref()
+        .iter()
+        .filter_map(|a| a.parse_meta().ok())
+        .find(|m| m.path().is_ident("protobuf_convert"))
+        .map(NestedMeta::from)
+}