fixed tests and some rustfmt

Author: reuvenpo

packages/storage/Readme.md

@@ -30,52 +30,52 @@ This is the simplest storage object in this toolkit. It based on the similarly n
 
 This object is meant to be initialized as a static constant in `state.rs`. However, it would also work perfectly fine if it was initialized during run time with a variable key (in this case though, you'd have to remind it what type of object is stored and its serde). Import it using the following lines:
 
-```rust
+```ignore
 use secret_toolkit_storage::{Item}
 ```
 
 And initialize it using the following lines:
 
-```rust
+```ignore
 pub static OWNER: Item<HumanAddr> = Item::new(b"owner");
 ```
 
 This uses Bincode2 to serde HumanAddr by default. To specify the Serde algorithm as Json, first import it from `secret-toolkit-serialization`
 
-```rust
+```ignore
 use secret_toolkit_serialization::{Bincode2, Json};
 ```
 
 then
 
-```rust
+```ignore
 pub static SOME_ENUM: Item<SomeEnum, Json> = Item::new(b"some_enum");
 ```
 
 #### **Read/Write**
 
 The way to read/write to/from strorage is to use its methods. These methods are `save`, `load`, `may_load`, `remove`, `update`. Here is an example usecase for each in execution inside `contract.rs`:
 
-```rust
+```ignore
 // The compiler knows that owner_addr is HumanAddr
 let owner_addr = OWNER.load(&deps.storage)?;
 ```
 
-```rust
+```ignore
 OWNER.save(&mut deps.storage, &env.message.sender)?;
 ```
 
-```rust
+```ignore
 // The compiler knows that may_addr is Option<HumanAddr>
 let may_addr = OWNER.may_load(&deps.storage)?;
 ```
 
-```rust
+```ignore
 // The compiler knows that may_addr is Option<HumanAddr>
 let may_addr = OWNER.remove(&mut deps.storage)?;
 ```
 
-```rust
+```ignore
 // The compiler knows that may_addr is Option<HumanAddr>
 let may_addr = OWNER.update(&mut deps.storage, |_x| Ok(env.message.sender))?;
 ```
@@ -97,19 +97,19 @@ The same conventions from `Item` also apply here, that is:
 
 To import and intialize this storage object as a static constant in `state.rs`, do the following:
 
-```rust
+```ignore
 use secret_toolkit::storage::{AppendStore}
 ```
 
-```rust
+```ignore
 pub static COUNT_STORE: AppendStore<i32> = AppendStore::new(b"count");
 ```
 
 > ❗ Initializing the object as const instead of static will also work but be less efficient since the variable won't be able to cache length data.
 
 Often times we need these storage objects to be associated to a user address or some other key that is variable. In this case, you need not initialize a completely new AppendStore inside `contract.rs`. Instead, you can create a new AppendStore by adding a suffix to an already existing AppendStore. This has the benefit of preventing you from having to rewrite the signature of the AppendStore. For example
 
-```rust
+```ignore
 // The compiler knows that user_count_store is AppendStore<i32, Bincode2>
 let user_count_store = COUNT_STORE.add_suffix(env.message.sender.to_string().as_bytes());
 ```
@@ -122,13 +122,13 @@ The main user facing methods to read/write to AppendStore are `pop`, `push`, `ge
 
 AppendStore also implements a readonly iterator feature. This feature is also used to create a paging wrapper method called `paging`. The way you create the iterator is:
 
-```rust
+```ignore
 let iter = user_count_store.iter(&deps.storage)?;
 ```
 
 More examples can be found in the unit tests. And the paging wrapper is used in the following manner:
 
-```rust
+```ignore
 let start_page: u32 = 0;
 let page_size: u32 = 5;
 // The compiler knows that values is Vec<i32>
@@ -143,11 +143,11 @@ This is a storage wrapper based on AppendStore that replicates a double ended li
 
 To import and intialize this storage object as a static constant in `state.rs`, do the following:
 
-```rust
+```ignore
 use secret_toolkit_storage::{DequeStore}
 ```
 
-```rust
+```ignore
 pub static COUNT_STORE: DequeStore<i32> = DequeStore::new(b"count");
 ```
 
@@ -172,11 +172,11 @@ be returned in each page.
 
 To import and intialize this storage object as a static constant in `state.rs`, do the following:
 
-```rust
+```ignore
 use secret_toolkit_storage::{Keymap}
 ```
 
-```rust
+```ignore
 pub static ADDR_VOTE: Keymap<HumanAddr, Foo> = Keymap::new(b"vote");
 pub static BET_STORE: Keymap<u32, BetInfo> = Keymap::new(b"vote");
 ```
@@ -189,7 +189,7 @@ If you need to associate a keymap to a user address (or any other variable), the
 
 For example suppose that in your contract, a user can make multiple bets. Then, you'd want a Keymap to be associated to each user. You would achieve this my doing the following during execution in `contract.rs`.
 
-```rust
+```ignore
 // The compiler knows that user_bet_store is AppendStore<u32, BetInfo>
 let user_count_store = BET_STORE.add_suffix(env.message.sender.to_string().as_bytes());
 ```
@@ -200,7 +200,7 @@ You can find more examples of using keymaps in the unit tests of Keymap in `keym
 
 To insert, remove, read from the keymap, do the following:
 
-```rust
+```ignore
 let user_addr: HumanAddr = env.message.sender;
 
 let foo = Foo {
@@ -224,7 +224,7 @@ Keymap also has two paging methods, these are `.paging` and `.paging_keys`. `pag
 
 Here are some select examples from the unit tests:
 
-```rust
+```ignore
 fn test_keymap_iter_keys() -> StdResult<()> {
     let mut storage = MockStorage::new();
 
@@ -256,7 +256,7 @@ fn test_keymap_iter_keys() -> StdResult<()> {
 }
 ```
 
-```rust
+```ignore
 fn test_keymap_iter() -> StdResult<()> {
     let mut storage = MockStorage::new();
 

packages/storage/src/append_store.rs

@@ -4,22 +4,22 @@
 //! This is achieved by storing each item in a separate storage entry. A special key is reserved
 //! for storing the length of the collection so far.
 use std::any::type_name;
-use std::sync::Mutex;
-use std::{convert::TryInto};
+use std::convert::TryInto;
 use std::marker::PhantomData;
+use std::sync::Mutex;
 
 use serde::{de::DeserializeOwned, Serialize};
 
 use cosmwasm_std::{ReadonlyStorage, StdError, StdResult, Storage};
 
-use secret_toolkit_serialization::{Serde, Bincode2};
+use secret_toolkit_serialization::{Bincode2, Serde};
 
 const LEN_KEY: &[u8] = b"len";
 
 pub struct AppendStore<'a, T, Ser = Bincode2>
-    where
-        T: Serialize + DeserializeOwned,
-        Ser: Serde,
+where
+    T: Serialize + DeserializeOwned,
+    Ser: Serde,
 {
     /// prefix of the newly constructed Storage
     namespace: &'a [u8],
@@ -31,7 +31,7 @@ pub struct AppendStore<'a, T, Ser = Bincode2>
     serialization_type: PhantomData<Ser>,
 }
 
-impl<'a, T: Serialize + DeserializeOwned, Ser: Serde> AppendStore<'a, T, Ser>{
+impl<'a, T: Serialize + DeserializeOwned, Ser: Serde> AppendStore<'a, T, Ser> {
     /// constructor
     pub const fn new(prefix: &'a [u8]) -> Self {
         Self {
@@ -65,19 +65,22 @@ impl<'a, T: Serialize + DeserializeOwned, Ser: Serde> AppendStore<'a, T, Ser> {
     pub fn get_len<S: ReadonlyStorage>(&self, storage: &S) -> StdResult<u32> {
         let mut may_len = self.length.lock().unwrap();
         match *may_len {
-            Some(len) => { Ok(len) },
+            Some(len) => Ok(len),
             None => {
                 let len_key = [self.as_slice(), LEN_KEY].concat();
                 if let Some(len_vec) = storage.get(&len_key) {
-                    let len_bytes = len_vec.as_slice().try_into().map_err(|err| StdError::parse_err("u32", err))?;
+                    let len_bytes = len_vec
+                        .as_slice()
+                        .try_into()
+                        .map_err(|err| StdError::parse_err("u32", err))?;
                     let len = u32::from_be_bytes(len_bytes);
                     *may_len = Some(len);
                     Ok(len)
                 } else {
                     *may_len = Some(0);
                     Ok(0)
                 }
-            },
+            }
         }
     }
     /// checks if the collection has any elements
@@ -87,7 +90,9 @@ impl<'a, T: Serialize + DeserializeOwned, Ser: Serde> AppendStore<'a, T, Ser> {
     /// gets the element at pos if within bounds
     pub fn get_at<S: ReadonlyStorage>(&self, storage: &S, pos: u32) -> StdResult<T> {
         let len = self.get_len(storage)?;
-        if pos > len { return Err(StdError::generic_err("AppendStore access out of bounds")); }
+        if pos > len {
+            return Err(StdError::generic_err("AppendStore access out of bounds"));
+        }
         self.get_at_unchecked(storage, pos)
     }
     /// tries to get the element at pos
@@ -111,7 +116,9 @@ impl<'a, T: Serialize + DeserializeOwned, Ser: Serde> AppendStore<'a, T, Ser> {
     /// Replaces data at a position within bounds
     pub fn set_at<S: Storage>(&self, storage: &mut S, pos: u32, item: &T) -> StdResult<()> {
         let len = self.get_len(storage)?;
-        if pos >= len { return Err(StdError::generic_err("AppendStore access out of bounds")); }
+        if pos >= len {
+            return Err(StdError::generic_err("AppendStore access out of bounds"));
+        }
         self.set_at_unchecked(storage, pos, item)
     }
     /// Sets data at a given index
@@ -127,7 +134,7 @@ impl<'a, T: Serialize + DeserializeOwned, Ser: Serde> AppendStore<'a, T, Ser> {
     }
     /// Pops an item from AppendStore
     pub fn pop<S: Storage>(&self, storage: &mut S) -> StdResult<T> {
-        if let Some(len) = self.get_len(storage)?.checked_sub(1) { 
+        if let Some(len) = self.get_len(storage)?.checked_sub(1) {
             let item = self.get_at_unchecked(storage, len);
             self.set_len(storage, len);
             item
@@ -150,7 +157,7 @@ impl<'a, T: Serialize + DeserializeOwned, Ser: Serde> AppendStore<'a, T, Ser> {
             return Err(StdError::generic_err("DequeStorage access out of bounds"));
         }
         let item = self.get_at_unchecked(storage, pos);
-        
+
         for i in pos..(len - 1) {
             let element_to_shift = self.get_at_unchecked(storage, i + 1)?;
             self.set_at_unchecked(storage, i, &element_to_shift)?;
@@ -159,14 +166,25 @@ impl<'a, T: Serialize + DeserializeOwned, Ser: Serde> AppendStore<'a, T, Ser> {
         item
     }
     /// Returns a readonly iterator
-    pub fn iter<S: ReadonlyStorage>(&self, storage: &'a S) -> StdResult<AppendStoreIter<T, S, Ser>> {
+    pub fn iter<S: ReadonlyStorage>(
+        &self,
+        storage: &'a S,
+    ) -> StdResult<AppendStoreIter<T, S, Ser>> {
         let len = self.get_len(storage)?;
         let iter = AppendStoreIter::new(self, storage, 0, len);
         Ok(iter)
     }
     /// does paging with the given parameters
-    pub fn paging<S: ReadonlyStorage>(&self, storage: &S, start_page: u32, size: u32) -> StdResult<Vec<T>> {
-        self.iter(storage)?.skip((start_page as usize)*(size as usize)).take(size as usize).collect()
+    pub fn paging<S: ReadonlyStorage>(
+        &self,
+        storage: &S,
+        start_page: u32,
+        size: u32,
+    ) -> StdResult<Vec<T>> {
+        self.iter(storage)?
+            .skip((start_page as usize) * (size as usize))
+            .take(size as usize)
+            .collect()
     }
 }
 
@@ -177,7 +195,8 @@ impl<'a, T: Serialize + DeserializeOwned, Ser: Serde> Clone for AppendStore<'a,
             prefix: self.prefix.clone(),
             length: Mutex::new(None),
             item_type: self.item_type.clone(),
-            serialization_type: self.serialization_type.clone() }
+            serialization_type: self.serialization_type.clone(),
+        }
     }
 }
 
@@ -234,17 +253,17 @@ where
 }
 
 impl<'a, T, S, Ser> AppendStoreIter<'a, T, S, Ser>
-    where
-        T: Serialize + DeserializeOwned,
-        S: ReadonlyStorage,
-        Ser: Serde,
+where
+    T: Serialize + DeserializeOwned,
+    S: ReadonlyStorage,
+    Ser: Serde,
 {
     /// constructor
     pub fn new(
         append_store: &'a AppendStore<'a, T, Ser>,
         storage: &'a S,
         start: u32,
-        end: u32
+        end: u32,
     ) -> Self {
         Self {
             append_store,
@@ -256,10 +275,10 @@ impl<'a, T, S, Ser> AppendStoreIter<'a, T, S, Ser>
 }
 
 impl<'a, T, S, Ser> Iterator for AppendStoreIter<'a, T, S, Ser>
-    where
-        T: Serialize + DeserializeOwned,
-        S: ReadonlyStorage,
-        Ser: Serde,
+where
+    T: Serialize + DeserializeOwned,
+    S: ReadonlyStorage,
+    Ser: Serde,
 {
     type Item = StdResult<T>;
 
@@ -291,10 +310,10 @@ impl<'a, T, S, Ser> Iterator for AppendStoreIter<'a, T, S, Ser>
 }
 
 impl<'a, T, S, Ser> DoubleEndedIterator for AppendStoreIter<'a, T, S, Ser>
-    where
-        T: Serialize + DeserializeOwned,
-        S: ReadonlyStorage,
-        Ser: Serde,
+where
+    T: Serialize + DeserializeOwned,
+    S: ReadonlyStorage,
+    Ser: Serde,
 {
     fn next_back(&mut self) -> Option<Self::Item> {
         if self.start >= self.end {
@@ -323,13 +342,14 @@ where
     T: Serialize + DeserializeOwned,
     S: ReadonlyStorage,
     Ser: Serde,
-{}
+{
+}
 
 #[cfg(test)]
 mod tests {
-    use cosmwasm_std::{testing::{MockStorage}};
+    use cosmwasm_std::testing::MockStorage;
 
-    use secret_toolkit_serialization::{Json};
+    use secret_toolkit_serialization::Json;
 
     use super::*;
 
@@ -590,7 +610,7 @@ mod tests {
         let mut storage = MockStorage::new();
         let json_append_store: AppendStore<i32, Json> = AppendStore::new(b"test2");
         json_append_store.push(&mut storage, &1234)?;
-        
+
         let key = [json_append_store.as_slice(), &0_u32.to_be_bytes()].concat();
         let bytes = storage.get(&key);
         assert_eq!(bytes, Some(b"1234".to_vec()));
@@ -686,4 +706,4 @@ mod tests {
 
         Ok(())
     }
-}
+}