core_types: Update to 2018 edition

crates/core_types/Cargo.toml

@@ -9,15 +9,15 @@ license = "GPL-3.0-only"
 readme = "README.md"
 documentation = "https://github.com/holochain/holochain-rust"
 repository = "https://github.com/holochain/holochain-rust"
+edition = "2018"
 
 [dependencies]
 futures = "=0.3.1"
 arrayref = "=0.3.5"
 base64 = "=0.10.1"
 backtrace = "=0.3.27"
 chrono = "=0.4.6"
-serde = "=1.0.89"
-serde_derive = "=1.0.89"
+serde = { version = "=1.0.89", features = ["derive"] }
 serde_json = { version = "=1.0.39", features = ["preserve_order"] }
 lazy_static = "=1.2.0"
 multihash = "=0.8.0"

crates/core_types/src/agent.rs

@@ -1,4 +1,6 @@
 use crate::{entry::Entry, error::HcResult};
+use holochain_json_derive::DefaultJson;
+use serde::{Deserialize, Serialize};
 
 use holochain_persistence_api::cas::content::{Address, AddressableContent, Content};
 

crates/core_types/src/chain_header.rs

@@ -11,6 +11,8 @@ use crate::{
     signature::{Provenance, Signature},
     time::{test_iso_8601, Iso8601},
 };
+use holochain_json_derive::DefaultJson;
+use serde::{Deserialize, Serialize};
 
 use holochain_persistence_api::cas::content::{Address, AddressableContent, Content};
 

crates/core_types/src/chain_migrate.rs

@@ -1,4 +1,5 @@
 //! NOT YET AVAILABLE
+use serde::{Deserialize, Serialize};
 
 #[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]
 pub struct ChainMigrate {}

crates/core_types/src/crud_status.rs

@@ -4,8 +4,10 @@
 //! even including an entry being marked as deleted.
 
 use crate::eav::EntityAttributeValueIndex;
+use holochain_json_derive::DefaultJson;
+use serde::{Deserialize, Serialize};
 
-use eav::Attribute;
+use crate::eav::Attribute;
 use std::{convert::TryInto, str::FromStr};
 
 use holochain_persistence_api::{

crates/core_types/src/dna/bridges.rs

@@ -1,5 +1,6 @@
 use crate::dna::fn_declarations::Trait;
 use holochain_persistence_api::cas::content::Address;
+use serde::{Deserialize, Serialize};
 
 use std::collections::BTreeMap;
 

crates/core_types/src/dna/capabilities.rs

@@ -1,10 +1,12 @@
+use holochain_json_api::{error::JsonError, json::JsonString};
+use holochain_json_derive::DefaultJson;
+use holochain_persistence_api::cas::content::Address;
+use serde::{Deserialize, Serialize};
+
 /// capabilities implements the capability request functionality used to check
 /// that a given capability has been granted for actions like zome calls
 use crate::signature::{Provenance, Signature};
 
-use holochain_json_api::{error::JsonError, json::JsonString};
-use holochain_persistence_api::cas::content::Address;
-
 //--------------------------------------------------------------------------------------------------
 // CapabilityRequest
 //--------------------------------------------------------------------------------------------------

crates/core_types/src/dna/entry_types.rs

@@ -1,9 +1,9 @@
 //! File holding all the structs for handling entry types defined by DNA.
 
-use dna::zome::ZomeEntryTypes;
-use entry::entry_type::EntryType;
+use crate::{dna::zome::ZomeEntryTypes, entry::entry_type::EntryType};
 use holochain_json_api::{error::JsonError, json::JsonString};
-use serde::{ser::SerializeMap, Deserialize, Deserializer, Serializer};
+use holochain_json_derive::DefaultJson;
+use serde::{ser::SerializeMap, Deserialize, Deserializer, Serialize, Serializer};
 use std::collections::BTreeMap;
 
 /// Enum for Zome EntryType "sharing" property.

crates/core_types/src/dna/fn_declarations.rs

@@ -1,5 +1,7 @@
 //! File holding all the structs for handling function declarations defined in DNA.
 
+use serde::{Deserialize, Serialize};
+
 /// Represents the type declaration for zome function parameter
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Hash)]
 pub struct FnParameter {

crates/core_types/src/dna/mod.rs

@@ -41,6 +41,9 @@ use crate::{
     entry::entry_type::EntryType,
     error::{DnaError, HcResult, HolochainError},
 };
+use holochain_json_derive::DefaultJson;
+use serde::{Deserialize, Serialize};
+use serde_json::json;
 
 use holochain_persistence_api::cas::content::{AddressableContent, Content};
 
@@ -49,7 +52,7 @@ use holochain_json_api::{
     json::JsonString,
 };
 
-use entry::entry_type::AppEntryType;
+use crate::entry::entry_type::AppEntryType;
 use multihash;
 use serde_json::{self, Value};
 use std::{
@@ -307,7 +310,6 @@ impl PartialEq for Dna {
 #[cfg(test)]
 pub mod tests {
     use super::*;
-    extern crate base64;
     use crate::{
         dna::{
             bridges::{Bridge, BridgePresence, BridgeReference},
@@ -317,8 +319,10 @@ pub mod tests {
         },
         entry::entry_type::{AppEntryType, EntryType},
     };
+    use base64;
     use holochain_json_api::json::JsonString;
     use holochain_persistence_api::cas::content::Address;
+    use maplit::btreemap;
     use std::convert::TryFrom;
 
     pub fn test_dna() -> Dna {

crates/core_types/src/dna/wasm.rs

@@ -1,14 +1,15 @@
 //! holochain_core_types::dna::wasm is a module for managing webassembly code
 //!  - within the in-memory dna struct
 //!  - and serialized to json
-use backtrace::Backtrace;
-
 use crate::error::HolochainError;
+use backtrace::Backtrace;
 use base64;
+use log::debug;
 use serde::{
     self,
     de::{Deserializer, Visitor},
     ser::Serializer,
+    Deserialize, Serialize,
 };
 use std::{
     fmt,
@@ -41,7 +42,7 @@ impl Deref for ModuleArc {
     }
 }
 impl fmt::Debug for ModuleArc {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "ModuleMutex")
     }
 }
@@ -67,7 +68,7 @@ where
         type Value = Vec<u8>;
 
         /// we only want to accept strings
-        fn expecting(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        fn expecting(&self, formatter: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
             formatter.write_str("string")
         }
 
@@ -122,7 +123,7 @@ fn empty_module() -> Arc<RwLock<Option<ModuleArc>>> {
 }
 
 impl fmt::Debug for DnaWasm {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "<<<DNA WASM CODE>>>")
     }
 }

crates/core_types/src/dna/zome.rs

@@ -9,10 +9,12 @@ use crate::{
     },
     entry::entry_type::EntryType,
 };
+use holochain_json_derive::DefaultJson;
+use serde::{Deserialize, Serialize};
 
 use holochain_json_api::{error::JsonError, json::JsonString};
 
-use dna::entry_types::{self, deserialize_entry_types, serialize_entry_types, EntryTypeDef};
+use crate::dna::entry_types::{self, deserialize_entry_types, serialize_entry_types, EntryTypeDef};
 use std::collections::BTreeMap;
 
 /// Represents the "config" object on a "zome".

crates/core_types/src/eav/eavi.rs

@@ -3,6 +3,7 @@
 //! being used to define relationships between AddressableContent values.
 //! See [wikipedia](https://en.wikipedia.org/wiki/Entity%E2%80%93attribute%E2%80%93value_model) to learn more about this pattern.
 
+use holochain_json_derive::DefaultJson;
 use holochain_persistence_api::{
     cas::content::{Address, AddressableContent, Content},
     eav::{
@@ -13,6 +14,8 @@ use holochain_persistence_api::{
     },
     error::{PersistenceError, PersistenceResult},
 };
+use lazy_static::lazy_static;
+use serde::{Deserialize, Serialize};
 
 use holochain_json_api::{error::JsonError, json::JsonString};
 
@@ -71,7 +74,7 @@ impl From<AttributeError> for HolochainError {
 }
 
 impl fmt::Display for Attribute {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             Attribute::CrudStatus => write!(f, "crud-status"),
             Attribute::CrudLink => write!(f, "crud-link"),

crates/core_types/src/eav/query.rs

@@ -1,4 +1,4 @@
-use eav::eavi::Attribute;
+use crate::eav::eavi::Attribute;
 
 /// Represents a set of filtering operations on the EAVI store.
 pub type EaviQuery<'a> = holochain_persistence_api::eav::query::EaviQuery<'a, Attribute>;

crates/core_types/src/eav/storage.rs

@@ -1,5 +1,7 @@
-use eav::{eavi::EntityAttributeValueIndex, query::EaviQuery};
-use error::{HcResult, HolochainError};
+use crate::{
+    eav::{eavi::EntityAttributeValueIndex, query::EaviQuery},
+    error::{HcResult, HolochainError},
+};
 use objekt;
 use std::{
     collections::BTreeSet,
@@ -25,7 +27,7 @@ pub trait EntityAttributeValueStorage: objekt::Clone + Send + Sync + Debug {
     /// - Some(Value) = requires the given value (e.g. all entities referencing an Address)
     fn fetch_eavi(
         &self,
-        query: &EaviQuery,
+        query: &EaviQuery<'_>,
     ) -> Result<BTreeSet<EntityAttributeValueIndex>, HolochainError>;
 
     // @TODO: would like to do this, but can't because of the generic type param
@@ -34,7 +36,7 @@ pub trait EntityAttributeValueStorage: objekt::Clone + Send + Sync + Debug {
     //     I: Iterator<Item = EntityAttributeValueIndex>;
 }
 
-clone_trait_object!(EntityAttributeValueStorage);
+objekt::clone_trait_object!(EntityAttributeValueStorage);
 
 #[derive(Clone, Debug, Default)]
 pub struct ExampleEntityAttributeValueStorage {
@@ -60,7 +62,7 @@ impl EntityAttributeValueStorage for ExampleEntityAttributeValueStorage {
 
     fn fetch_eavi(
         &self,
-        query: &EaviQuery,
+        query: &EaviQuery<'_>,
     ) -> Result<BTreeSet<EntityAttributeValueIndex>, HolochainError> {
         let lock = self.storage.read()?;
         let set = (*lock).clone();

crates/core_types/src/entry/cap_entries.rs

@@ -1,4 +1,6 @@
 use crate::{entry::Entry, error::HolochainError};
+use holochain_json_derive::DefaultJson;
+use serde::{Deserialize, Serialize};
 
 use holochain_persistence_api::cas::content::{Address, AddressableContent};
 

crates/core_types/src/entry/deletion_entry.rs

@@ -1,5 +1,7 @@
 use holochain_json_api::{error::JsonError, json::JsonString};
+use holochain_json_derive::DefaultJson;
 use holochain_persistence_api::cas::content::Address;
+use serde::{Deserialize, Serialize};
 
 //-------------------------------------------------------------------------------------------------
 // DeletionEntry

crates/core_types/src/entry/entry_type.rs

@@ -1,5 +1,7 @@
-use error::HolochainError;
+use crate::error::HolochainError;
 use holochain_json_api::{error::JsonError, json::JsonString};
+use holochain_json_derive::DefaultJson;
+use serde::{Deserialize, Serialize};
 use std::{
     convert::TryFrom,
     fmt::{Display, Formatter, Result as FmtResult},
@@ -153,7 +155,7 @@ impl From<&'static str> for EntryType {
 }
 
 impl Display for EntryType {
-    fn fmt(&self, f: &mut Formatter) -> FmtResult {
+    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
         write!(f, "{}", String::from(self.to_owned()))
     }
 }

crates/core_types/src/entry/mod.rs

@@ -11,20 +11,23 @@ use self::{
     cap_entries::{CapTokenClaim, CapTokenGrant},
     deletion_entry::DeletionEntry,
 };
-use agent::{test_agent_id, AgentId};
-use chain_header::ChainHeader;
-use chain_migrate::ChainMigrate;
-use crud_status::CrudStatus;
-use dna::Dna;
-use entry::entry_type::{test_app_entry_type, test_app_entry_type_b, AppEntryType, EntryType};
+use crate::{
+    agent::{test_agent_id, AgentId},
+    chain_header::ChainHeader,
+    chain_migrate::ChainMigrate,
+    crud_status::CrudStatus,
+    dna::Dna,
+    entry::entry_type::{test_app_entry_type, test_app_entry_type_b, AppEntryType, EntryType},
+    link::{link_data::LinkData, link_list::LinkList},
+};
 use holochain_json_api::{
     error::{JsonError, JsonResult},
     json::{JsonString, RawString},
 };
+use holochain_json_derive::DefaultJson;
 use holochain_persistence_api::cas::content::{Address, AddressableContent, Content};
-use link::{link_data::LinkData, link_list::LinkList};
 use multihash::Hash;
-use serde::{ser::SerializeTuple, Deserialize, Deserializer, Serializer};
+use serde::{ser::SerializeTuple, Deserialize, Deserializer, Serialize, Serializer};
 use snowflake;
 use std::convert::TryFrom;
 

crates/core_types/src/error/dna_error.rs

@@ -1,3 +1,4 @@
+use serde::{Deserialize, Serialize};
 use std::{error::Error, fmt};
 
 #[derive(Clone, Debug, PartialEq, Hash, Eq, Serialize, Deserialize, PartialOrd, Ord)]
@@ -10,7 +11,7 @@ pub enum DnaError {
 impl Error for DnaError {}
 
 impl fmt::Display for DnaError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let msg = match self {
             DnaError::ZomeNotFound(err_msg) => err_msg,
             DnaError::TraitNotFound(err_msg) => err_msg,

crates/core_types/src/error/mod.rs

@@ -11,9 +11,11 @@ use holochain_json_api::{
     error::{JsonError, JsonResult},
     json::*,
 };
+use holochain_json_derive::DefaultJson;
 use holochain_locksmith::LocksmithError;
 use holochain_persistence_api::{error::PersistenceError, hash::HashString};
 use lib3h_crypto_api::CryptoError;
+use serde::{Deserialize, Serialize};
 
 use serde_json::Error as SerdeError;
 use std::{
@@ -77,7 +79,7 @@ impl ::std::convert::TryFrom<ZomeApiInternalResult> for CoreError {
 }
 
 impl fmt::Display for CoreError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(
             f,
             "Holochain Core error: {}\n  --> {}:{}\n",
@@ -135,7 +137,7 @@ impl From<rust_base58::base58::FromBase58Error> for HolochainError {
 }
 
 impl fmt::Display for HolochainError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             ErrorGeneric(err_msg) => write!(f, "{}", err_msg),
             CryptoError(crypto_error) => write!(f, "{}", crypto_error),

crates/core_types/src/error/ribosome_error.rs

@@ -1,8 +1,9 @@
 use self::{RibosomeEncodedValue::*, RibosomeErrorCode::*};
 use crate::error::HolochainError;
 use holochain_json_api::{error::JsonError, json::JsonString};
+use holochain_json_derive::DefaultJson;
 
-use bits_n_pieces::u64_split_bits;
+use crate::bits_n_pieces::u64_split_bits;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use std::{convert::TryFrom, str::FromStr};
 

crates/core_types/src/hdk_version.rs

@@ -1,4 +1,5 @@
-use error::{HcResult, HolochainError};
+use crate::error::{HcResult, HolochainError};
+use lazy_static::lazy_static;
 
 lazy_static! {
     pub static ref HDK_VERSION: HDKVersion = {