Issue #48 travis-ci, Rustfmt & Clippy (#49)

* Cargo make `Makefile.toml`

* domain - channel - remove unused import

* Add `.travis.yml`

* run `rustfmt`

* Remove `Makefile.toml` and simplify `.travis.yml`

* `.travis.yml` - add env. to run `rustfmt` & `clippy` in `ci-flow`

* `.travis.yml` - remove `cache` & add Makefile.toml to override clippy and fail on warnings

* Makefile - override only the `args` of `tasks.clippy`

* README - add badge + fix some typos

* Makefile.toml - add `CARGO_MAKE_EXTEND_WORKSPACE_MAKEFILE = true` to apply the same rules for the `workspace` crates

* domain - channel - Fix merge conflict

* .travis.yml - conditionally install `cargo-make` and `cache: cargo`

* fix `clippy` warnings

* run `rustfmt`

Author: elpiel

.travis.yml

@@ -0,0 +1,13 @@
+language: rust
+rust:
+  - nightly-2019-05-08
+cache: cargo
+env:
+  global:
+    - CARGO_MAKE_RUN_CHECK_FORMAT="true"
+    - CARGO_MAKE_RUN_CLIPPY="true"
+matrix:
+  fast_finish: true
+install:
+  - if [[ $(cargo list | grep -c make) == 0 ]]; then cargo install --debug cargo-make ; else echo "Cargo make already installed, continuing..."; fi
+  - cargo make ci-flow

Makefile.toml

@@ -0,0 +1,5 @@
+[env]
+CARGO_MAKE_EXTEND_WORKSPACE_MAKEFILE = "true"
+
+[tasks.clippy]
+args = ["clippy", "--all-features", "--", "-D", "warnings"]

README.md

@@ -1,4 +1,4 @@
-# adex-validator-stack-rust
+# Adex Validator Stack in Rust [![Build Status](https://travis-ci.com/AdExNetwork/adex-validator-stack-rust.svg?token=TBKq9g6p9sWDrzNyX4kC&branch=master)](https://travis-ci.com/AdExNetwork/adex-validator-stack-rust)
 
 Rust implementation of the Validator Stack
 
@@ -20,7 +20,7 @@ GET `/channel/list` - get a list of all channels - TODO
 ### Rust setup
 
 - Requires `nightly 2019-05-08`, because of the new syntax for `await` and our `tower-web` dependency fails to build.
-We've setup `rust-toolchain` but you can manually override it as well with `rustup override set nightly-2019-04-07`.
+We've setup `rust-toolchain` but you can manually override it as well with `rustup override set nightly-2019-05-08`.
 
 #### Linux
 - The crate `openssl-sys` requires `libssl-dev` and `pkg-config` for Ubuntu.

domain/src/ad_unit.rs

@@ -1,9 +1,9 @@
-use chrono::{DateTime, Utc};
 use chrono::serde::ts_milliseconds;
+use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
 
-use crate::TargetingTag;
 use crate::util::serde::ts_milliseconds_option;
+use crate::TargetingTag;
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
 #[serde(rename_all = "camelCase")]
@@ -49,5 +49,4 @@ pub struct AdUnit {
     /// UTC timestamp in milliseconds, changed every time modifiable property is changed
     #[serde(default, with = "ts_milliseconds_option")]
     pub modified: Option<DateTime<Utc>>,
-
-}
+}

domain/src/bignum.rs

@@ -7,8 +7,11 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct BigNum(
-    #[serde(deserialize_with = "biguint_from_str", serialize_with = "biguint_to_str")]
-    BigUint
+    #[serde(
+        deserialize_with = "biguint_from_str",
+        serialize_with = "biguint_to_str"
+    )]
+    BigUint,
 );
 
 impl BigNum {
@@ -21,9 +24,8 @@ impl TryFrom<&str> for BigNum {
     type Error = super::DomainError;
 
     fn try_from(num: &str) -> Result<Self, Self::Error> {
-        let big_uint = BigUint::from_str(&num).map_err(|err| {
-            super::DomainError::InvalidArgument(err.description().to_string())
-        })?;
+        let big_uint = BigUint::from_str(&num)
+            .map_err(|err| super::DomainError::InvalidArgument(err.description().to_string()))?;
 
         Ok(Self(big_uint))
     }
@@ -44,16 +46,16 @@ impl TryFrom<u32> for BigNum {
 }
 
 fn biguint_from_str<'de, D>(deserializer: D) -> Result<BigUint, D::Error>
-    where
-        D: Deserializer<'de>,
+where
+    D: Deserializer<'de>,
 {
     let num = String::deserialize(deserializer)?;
     Ok(BigUint::from_str(&num).map_err(serde::de::Error::custom)?)
 }
 
 fn biguint_to_str<S>(num: &BigUint, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer
+where
+    S: Serializer,
 {
     serializer.serialize_str(&num.to_str_radix(10))
 }

domain/src/channel.rs

@@ -1,14 +1,14 @@
 use std::convert::TryFrom;
 
-use chrono::{DateTime, Utc};
 use chrono::serde::{ts_milliseconds, ts_seconds};
-use hex::{FromHex, ToHex};
+use chrono::{DateTime, Utc};
+use hex::FromHex;
 use serde::{Deserialize, Serialize};
 use serde_hex::{SerHex, StrictPfx};
 
-use crate::{AdUnit, Asset, DomainError, EventSubmission, TargetingTag, ValidatorDesc};
 use crate::bignum::BigNum;
 use crate::util::serde::ts_milliseconds_option;
+use crate::{AdUnit, Asset, DomainError, EventSubmission, TargetingTag, ValidatorDesc};
 
 #[cfg(feature = "repositories")]
 pub use self::repository::ChannelRepository;
@@ -55,7 +55,9 @@ impl TryFrom<&str> for ChannelId {
     fn try_from(value: &str) -> Result<Self, Self::Error> {
         let bytes = value.as_bytes();
         if bytes.len() != 32 {
-            return Err(DomainError::InvalidArgument("The value of the id should have exactly 32 bytes".to_string()));
+            return Err(DomainError::InvalidArgument(
+                "The value of the id should have exactly 32 bytes".to_string(),
+            ));
         }
         let mut id = [0; 32];
         id.copy_from_slice(&bytes[..32]);
@@ -83,9 +85,12 @@ impl ChannelId {
     pub fn try_from_hex(hex: &str) -> Result<Self, DomainError> {
         let s = hex.trim_start_matches("0x");
 
-        let bytes: Vec<u8> = Vec::from_hex(s).map_err(|err| DomainError::InvalidArgument(err.to_string()))?;
+        let bytes: Vec<u8> =
+            Vec::from_hex(s).map_err(|err| DomainError::InvalidArgument(err.to_string()))?;
         if bytes.len() != 32 {
-            return Err(DomainError::InvalidArgument("The value of the id should have exactly 32 bytes".to_string()));
+            return Err(DomainError::InvalidArgument(
+                "The value of the id should have exactly 32 bytes".to_string(),
+            ));
         }
 
         let mut id = [0; 32];
@@ -137,7 +142,11 @@ pub struct ChannelSpec {
     pub created: DateTime<Utc>,
     /// A millisecond timestamp representing the time you want this campaign to become active (optional)
     /// Used by the AdViewManager
-    #[serde(default, skip_serializing_if = "Option::is_none", with = "ts_milliseconds_option")]
+    #[serde(
+        default,
+        skip_serializing_if = "Option::is_none",
+        with = "ts_milliseconds_option"
+    )]
     pub active_from: Option<DateTime<Utc>>,
     /// A random number to ensure the campaignSpec hash is unique
     pub nonce: BigNum,
@@ -166,20 +175,25 @@ pub struct ChannelListParams {
 }
 
 impl ChannelListParams {
-    pub fn new(valid_until_ge: DateTime<Utc>, limit: u32, page: u32, validator: Option<String>) -> Result<Self, DomainError> {
+    pub fn new(
+        valid_until_ge: DateTime<Utc>,
+        limit: u32,
+        page: u32,
+        validator: Option<String>,
+    ) -> Result<Self, DomainError> {
         if page < 1 {
-            return Err(DomainError::InvalidArgument("Page should be >= 1".to_string()));
+            return Err(DomainError::InvalidArgument(
+                "Page should be >= 1".to_string(),
+            ));
         }
 
         if limit < 1 {
-            return Err(DomainError::InvalidArgument("Limit should be >= 1".to_string()));
+            return Err(DomainError::InvalidArgument(
+                "Limit should be >= 1".to_string(),
+            ));
         }
 
-        let validator = validator
-            .and_then(|s| match s.is_empty() {
-                true => None,
-                false => Some(s),
-            });
+        let validator = validator.and_then(|s| if s.is_empty() { None } else { Some(s) });
 
         Ok(Self {
             valid_until_ge,
@@ -213,4 +227,4 @@ pub mod fixtures;
 
 #[cfg(test)]
 #[path = "./channel_test.rs"]
-mod test;
+mod test;

domain/src/channel_fixtures.rs

@@ -4,9 +4,9 @@ use chrono::{DateTime, Utc};
 use fake::faker::*;
 
 use crate::asset::fixtures::get_asset;
-use crate::BigNum;
 use crate::fixtures::{get_targeting_tags, get_validators};
 use crate::test_util;
+use crate::BigNum;
 use crate::ValidatorDesc;
 
 use super::{Channel, ChannelId, ChannelSpec};
@@ -27,13 +27,19 @@ pub fn get_channel_id(channel_id: &str) -> ChannelId {
     ChannelId { id }
 }
 
-pub fn get_channel(id: &str, valid_until: &Option<DateTime<Utc>>, spec: Option<ChannelSpec>) -> Channel {
+pub fn get_channel(
+    id: &str,
+    valid_until: &Option<DateTime<Utc>>,
+    spec: Option<ChannelSpec>,
+) -> Channel {
     let channel_id = get_channel_id(id);
-    let deposit_amount = BigNum::try_from(<Faker as Number>::between(100_u32, 5000_u32)).expect("BigNum error when creating from random number");
-    let valid_until: DateTime<Utc> = valid_until.unwrap_or(test_util::time::datetime_between(&Utc::now(), None));
+    let deposit_amount = BigNum::try_from(<Faker as Number>::between(100_u32, 5000_u32))
+        .expect("BigNum error when creating from random number");
+    let valid_until: DateTime<Utc> =
+        valid_until.unwrap_or(test_util::time::datetime_between(&Utc::now(), None));
     let creator = <Faker as Name>::name();
     let deposit_asset = get_asset();
-    let spec = spec.unwrap_or(get_channel_spec(id, ValidatorsOption::Count(3)));
+    let spec = spec.unwrap_or_else(|| get_channel_spec(id, ValidatorsOption::Count(3)));
 
     Channel {
         id: channel_id,
@@ -49,7 +55,8 @@ pub fn get_channels(count: usize, valid_until_ge: Option<DateTime<Utc>>) -> Vec<
     (1..=count)
         .map(|c| {
             // if we have a valid_until_ge, use it to generate a valid_util for each channel
-            let valid_until = valid_until_ge.and_then(|ref dt| Some(test_util::time::datetime_between(dt, None)));
+            let valid_until =
+                valid_until_ge.and_then(|ref dt| Some(test_util::time::datetime_between(dt, None)));
             let channel_id = format!("channel {}", c);
 
             get_channel(&channel_id, &valid_until, None)
@@ -77,10 +84,14 @@ pub fn get_channel_spec(prefix: &str, validators_option: ValidatorsOption) -> Ch
     let title_string = Some(<Faker as Lorem>::sentence(3, 4));
 
     let title = take_one(&[&title_string, &None]).to_owned();
-    let max_per_impression = BigNum::try_from(<Faker as Number>::between(250_u32, 500_u32)).expect("BigNum error when creating from random number");
-    let min_per_impression = BigNum::try_from(<Faker as Number>::between(1_u32, 250_u32)).expect("BigNum error when creating from random number");
-    let nonce = BigNum::try_from(<Faker as Number>::between(100_000_000_u32, 999_999_999_u32)).expect("BigNum error when creating from random number");
-    let min_targeting_score = take_one(&[&None, &Some(<Faker as Number>::between(1, 500))]).to_owned();
+    let max_per_impression = BigNum::try_from(<Faker as Number>::between(250_u32, 500_u32))
+        .expect("BigNum error when creating from random number");
+    let min_per_impression = BigNum::try_from(<Faker as Number>::between(1_u32, 250_u32))
+        .expect("BigNum error when creating from random number");
+    let nonce = BigNum::try_from(<Faker as Number>::between(100_000_000_u32, 999_999_999_u32))
+        .expect("BigNum error when creating from random number");
+    let min_targeting_score =
+        take_one(&[&None, &Some(<Faker as Number>::between(1, 500))]).to_owned();
 
     ChannelSpec {
         validators,
@@ -97,4 +108,4 @@ pub fn get_channel_spec(prefix: &str, validators_option: ValidatorsOption) -> Ch
         withdraw_period_start: Utc::now(),
         ad_units: Vec::new(),
     }
-}
+}

domain/src/channel_test.rs

@@ -4,23 +4,44 @@ use crate::channel::ChannelId;
 
 #[test]
 fn coverts_str_to_channel_id() {
-    let channel_id = ChannelId::try_from("12345678901234567890123456789012").expect("Should create ChannelId from &str with 32 len numeric value");
-
-    assert_eq!("12345678901234567890123456789012".as_bytes(), &channel_id.id);
-
-    assert!(ChannelId::try_from("1234567890123456789012345678901").is_err(), "ChannelId was created from a &str of 31 len bytes value");
-    assert!(ChannelId::try_from("123456789012345678901234567890123").is_err(), "ChannelId was created from a &str of 33 len bytes value");
+    let channel_id = ChannelId::try_from("12345678901234567890123456789012")
+        .expect("Should create ChannelId from &str with 32 len numeric value");
+
+    assert_eq!(
+        "12345678901234567890123456789012".as_bytes(),
+        &channel_id.id
+    );
+
+    assert!(
+        ChannelId::try_from("1234567890123456789012345678901").is_err(),
+        "ChannelId was created from a &str of 31 len bytes value"
+    );
+    assert!(
+        ChannelId::try_from("123456789012345678901234567890123").is_err(),
+        "ChannelId was created from a &str of 33 len bytes value"
+    );
 }
 
 #[test]
 fn compares_channel_ids() {
-    let first = ChannelId::try_from("12345678901234567890123456789012").expect("Should create ChannelId from &str of 32 len bytes value");
+    let first = ChannelId::try_from("12345678901234567890123456789012")
+        .expect("Should create ChannelId from &str of 32 len bytes value");
     let second = ChannelId::try_from("12345678901234567890123456789012").unwrap();
     let first_copy = first;
 
-    assert_eq!(first, first.clone(), "ChannelId and it's clone should be equal to each other");
-    assert_eq!(first, first_copy, "ChannelId and it's copy should be equal to each other");
-    assert_eq!(first, second, "ChannelId and it's clone should be equal to each other");
+    assert_eq!(
+        first,
+        first.clone(),
+        "ChannelId and it's clone should be equal to each other"
+    );
+    assert_eq!(
+        first, first_copy,
+        "ChannelId and it's copy should be equal to each other"
+    );
+    assert_eq!(
+        first, second,
+        "ChannelId and it's clone should be equal to each other"
+    );
 }
 
 #[test]
@@ -36,4 +57,4 @@ fn serialize_and_deserialize_channel_id() {
 
     let from_hex: ChannelId = serde_json::from_str(expected_json).unwrap();
     assert_eq!(from_hex, channel_id);
-}
+}

domain/src/event_submission.rs

@@ -24,4 +24,4 @@ pub struct RateLimit {
     /// in milliseconds
     #[serde(rename = "timeframe")]
     pub time_frame: u64,
-}
+}

domain/src/lib.rs

@@ -7,9 +7,9 @@ pub use util::tests as test_util;
 pub use self::ad_unit::AdUnit;
 pub use self::asset::Asset;
 pub use self::bignum::BigNum;
-pub use self::channel::{Channel, ChannelId, ChannelListParams, ChannelSpec};
 #[cfg(feature = "repositories")]
 pub use self::channel::ChannelRepository;
+pub use self::channel::{Channel, ChannelId, ChannelListParams, ChannelSpec};
 pub use self::event_submission::EventSubmission;
 #[cfg(feature = "repositories")]
 pub use self::repository::*;