Fix warnings

.github/workflows/Basic.yml

@@ -65,7 +65,7 @@ jobs:
         uses: actions-rs/cargo@v1
         with:
           command: clippy
-          # args: -- -D warnings
+          args: -- -D warnings
 
       - name: Generate Schema
         uses: actions-rs/cargo@v1

src/contract.rs

@@ -97,15 +97,15 @@ pub fn execute(
             let sender = info.sender.to_string();
             let farm = FARM_PROFILES.may_load(deps.storage, sender.as_str())?;
 
-            return match farm {
+            match farm {
                 None => Err(throw_err("You do not have a farm")),
                 Some(mut farm) => {
                     farm.till(x.into(), y.into(), env.block.height)?;
                     FARM_PROFILES.save(deps.storage, sender.as_str(), &farm)?;
 
                     Ok(Response::new().add_attribute("action", "tilled"))
                 }
-            };
+            }
         }
 
         ExecuteMsg::ReceiveNft(msg) => receive(deps, env, info, msg),
@@ -115,28 +115,28 @@ pub fn execute(
             let farm: Option<FarmProfile> =
                 FARM_PROFILES.may_load(deps.storage, sender.as_str())?;
 
-            return match farm {
+            match farm {
                 None => Err(throw_err("You do not have a farm")),
                 Some(mut farm) => {
                     farm.water_plant(x.into(), y.into(), env.block.height)?;
                     FARM_PROFILES.save(deps.storage, sender.as_str(), &farm)?;
 
                     Ok(Response::new().add_attribute("action", "watered"))
                 }
-            };
+            }
         }
 
         ExecuteMsg::Harvest { x, y } => {
             let sender = info.sender.to_string();
             let farm = FARM_PROFILES.may_load(deps.storage, sender.as_str())?;
 
-            return match farm {
+            match farm {
                 None => Err(throw_err("You do not have a farm")),
                 Some(mut farm) => {
                     let plot = farm.get_plot(x.into(), y.into());
                     let plant = plot.plant;
 
-                    return match plant {
+                    match plant {
                         None => Err(throw_err(&format!(
                             "Plot [{}, {}] must contain a plant to harvest.",
                             x, y
@@ -165,7 +165,7 @@ pub fn execute(
                             }
 
                             let harvested = farm.harvest(x.into(), y.into(), env.block.height)?;
-                            let mut pts = match points().may_load(deps.storage, &sender.as_str())? {
+                            let mut pts = match points().may_load(deps.storage, sender.as_str())? {
                                 None => Points {
                                     addr: sender.clone(),
                                     plants: HashMap::new(),
@@ -181,9 +181,9 @@ pub fn execute(
                                 .add_attribute("action", "harvested")
                                 .add_messages(messages))
                         }
-                    };
+                    }
                 }
-            };
+            }
         }
         ExecuteMsg::UpdateContractInformation {
             contract_information,
@@ -226,7 +226,7 @@ pub fn query(deps: Deps, env: Env, msg: QueryMsg) -> StdResult<Binary> {
                 .map(|res| match res {
                     Ok((_, v)) => {
                         let total: u64 = v.total();
-                        let addr: String = v.addr.into();
+                        let addr: String = v.addr;
 
                         Ok((addr, total))
                     }
@@ -270,7 +270,7 @@ mod tests {
             .map(|res| match res {
                 Ok((_, v)) => {
                     let total: u64 = v.total();
-                    let addr: String = v.addr.into();
+                    let addr: String = v.addr;
 
                     Ok((addr, total))
                 }

src/farm.rs

@@ -59,9 +59,8 @@ pub struct Plant {
 impl Plant {
     pub fn get_current_stage(&self, block: u64) -> u64 {
         let passed_time = block - self.created_at;
-        let current_period = passed_time / self.growth_period + 1;
 
-        current_period
+        passed_time / self.growth_period + 1
     }
 
     pub fn is_dead(&self, block: u64) -> bool {
@@ -107,7 +106,7 @@ impl Slot {
             return SlotType::Meadow;
         }
 
-        return self.r#type.clone();
+        self.r#type.clone()
     }
 
     pub fn can_till(&self, block: u64) -> bool {

src/helpers.rs

@@ -13,5 +13,5 @@ pub fn admin_error_check(deps: Deps, info: MessageInfo) -> Result<(), ContractEr
 }
 
 pub fn throw_err(msg: &str) -> ContractError {
-    return ContractError::Std(cosmwasm_std::StdError::generic_err(msg));
+    ContractError::Std(cosmwasm_std::StdError::generic_err(msg))
 }

src/receive/mod.rs

@@ -23,7 +23,7 @@ pub fn receive(
     let config = INFORMATION.load(deps.storage)?;
 
     if config.komple_mint_addr.is_none() {
-        return Err(throw_err(&format!("Komple mint address not provided",)));
+        return Err(throw_err("Komple mint address not provided"));
     }
 
     let collections: ResponseWrapper<Vec<CollectionsResponse>> = deps.querier.query_wasm_smart(
@@ -38,7 +38,7 @@ pub fn receive(
     let collection = collections.data.iter().find(|c| info.sender.eq(&c.address));
 
     if collection.is_none() {
-        return Err(throw_err(&format!("Unauthorized collection",)));
+        return Err(throw_err("Unauthorized collection"));
     }
 
     let collection = collection.unwrap();
@@ -51,7 +51,7 @@ pub fn receive(
     )?;
 
     if submodules.data.metadata.is_none() {
-        return Err(throw_err(&format!("Missing Komple metadata submodule",)));
+        return Err(throw_err("Missing Komple metadata submodule"));
     }
 
     let metadata: ResponseWrapper<MetadataResponse> = deps.querier.query_wasm_smart(
@@ -69,7 +69,7 @@ pub fn receive(
         .find(|a| a.trait_type == "type");
 
     if plant_type.is_none() {
-        return Err(throw_err(&format!("Missing metadata type",)));
+        return Err(throw_err("Missing metadata type"));
     }
 
     let plant_type = plant_type.unwrap().value.parse()?;
@@ -137,7 +137,7 @@ mod test {
             });
 
         let collection_addr = "collection_addr";
-        let auth_info = mock_info(collection_addr, &vec![]);
+        let auth_info = mock_info(collection_addr, &[]);
         let nft_owner = "nft_owner";
         let msg = ExecuteMsg::ReceiveNft(Cw721ReceiveMsg {
             sender: nft_owner.to_string(),
@@ -214,7 +214,7 @@ mod test {
                 _ => general_handle_wasm_query(wasm_query),
             });
 
-        let auth_info = mock_info(collection_addr, &vec![]);
+        let auth_info = mock_info(collection_addr, &[]);
         let nft_owner = "nft_owner";
         init_farm(nft_owner, deps.as_mut());
         till(nft_owner, 0, 0, deps.as_mut());
@@ -227,6 +227,6 @@ mod test {
 
         let res = execute(deps.as_mut(), env.to_owned(), auth_info, msg);
 
-        assert_eq!(res.is_ok(), true);
+        assert!(res.is_ok());
     }
 }

src/receive/seed.rs

@@ -7,6 +7,7 @@ use crate::{
     ContractError,
 };
 
+#[allow(clippy::too_many_arguments)]
 pub fn seed(
     deps: DepsMut,
     env: Env,

src/state.rs

@@ -11,21 +11,18 @@ use crate::{
 };
 
 fn plant_dto(plant: &Option<Plant>, block: u64) -> Option<PlantDto> {
-    match plant {
-        None => None,
-        Some(plant) => Some(PlantDto {
-            created_at: plant.created_at,
-            growth_period: plant.growth_period,
-            komple: plant.komple.clone(),
-            stages: plant.stages,
-            r#type: plant.r#type.clone(),
-            watered_at: plant.watered_at.clone(),
-            can_harvest: plant.can_harvest(block),
-            can_water: plant.can_water(block),
-            current_stage: plant.get_current_stage(block),
-            is_dead: plant.is_dead(block),
-        }),
-    }
+    plant.as_ref().map(|plant| PlantDto {
+        created_at: plant.created_at,
+        growth_period: plant.growth_period,
+        komple: plant.komple.clone(),
+        stages: plant.stages,
+        r#type: plant.r#type.clone(),
+        watered_at: plant.watered_at.clone(),
+        can_harvest: plant.can_harvest(block),
+        can_water: plant.can_water(block),
+        current_stage: plant.get_current_stage(block),
+        is_dead: plant.is_dead(block),
+    })
 }
 
 fn slot_dto(slot: &Slot, block: u64) -> SlotDto {
@@ -43,17 +40,14 @@ pub struct FarmProfile {
 }
 
 pub fn farm_profile_dto(farm_profile: &Option<FarmProfile>, block: u64) -> Option<FarmProfileDto> {
-    match farm_profile {
-        None => None,
-        Some(farm_profile) => Some(FarmProfileDto {
-            plots: farm_profile
-                .plots
-                .iter()
-                .map(|rows| rows.iter().map(|slot| slot_dto(slot, block)).collect())
-                .collect(),
-            blocks: block,
-        }),
-    }
+    farm_profile.as_ref().map(|farm_profile| FarmProfileDto {
+        plots: farm_profile
+            .plots
+            .iter()
+            .map(|rows| rows.iter().map(|slot| slot_dto(slot, block)).collect())
+            .collect(),
+        blocks: block,
+    })
 }
 
 #[cw_serde]
@@ -132,21 +126,19 @@ pub fn points<'a>() -> IndexedMap<'a, &'a str, Points, PointsIndexes<'a>> {
 }
 
 fn create_meadow_plot(block: u64) -> Slot {
-    return Slot {
+    Slot {
         r#type: SlotType::Meadow,
         plant: None,
         created_at: block,
-    };
+    }
 }
 
 fn create_field_plot(block: u64) -> Slot {
-    return {
-        Slot {
-            r#type: SlotType::Field,
-            plant: None,
-            created_at: block,
-        }
-    };
+    Slot {
+        r#type: SlotType::Field,
+        plant: None,
+        created_at: block,
+    }
 }
 
 fn create_plant(plant_type: &PlantType, komple: Option<KomplePlant>, block: u64) -> Plant {
@@ -206,7 +198,7 @@ impl FarmProfile {
         let row = self.plots.get(x);
         let col = row.unwrap().get(y);
 
-        return col.unwrap().clone();
+        col.unwrap().clone()
     }
 
     pub fn set_plot(&mut self, x: usize, y: usize, value: Slot) {

src/tests.rs

@@ -35,24 +35,24 @@ pub fn setup_test(
     let env = mock_env();
 
     if let Some(instantiate_msg) = instantiate_msg {
-        let info = mock_info("creator", &vec![]);
+        let info = mock_info("creator", &[]);
 
         let _res = instantiate(dependencies.as_mut(), mock_env(), info, instantiate_msg).unwrap();
     }
 
     (dependencies, env)
 }
 
-pub fn init_farm(addr: &str, deps: DepsMut) -> () {
+pub fn init_farm(addr: &str, deps: DepsMut) {
     let msg = ExecuteMsg::Start {};
-    let info = mock_info(addr, &vec![]);
+    let info = mock_info(addr, &[]);
 
     let _res = execute(deps, mock_env(), info, msg).unwrap();
 }
 
-pub fn till(addr: &str, x: u8, y: u8, deps: DepsMut) -> () {
+pub fn till(addr: &str, x: u8, y: u8, deps: DepsMut) {
     let msg = ExecuteMsg::TillGround { x, y };
-    let info = mock_info(addr, &vec![]);
+    let info = mock_info(addr, &[]);
 
     let _res = execute(deps, mock_env(), info, msg).unwrap();
 }
@@ -101,11 +101,11 @@ fn proper_initialization() {
         admin: None,
         komple_mint_addr: None,
     };
-    let info = mock_info("creator", &vec![]);
+    let info = mock_info("creator", &[]);
 
     let res = instantiate(deps.as_mut(), mock_env(), info, msg);
 
-    assert_eq!(res.is_ok(), true);
+    assert!(res.is_ok());
 
     let information = INFORMATION.load(&deps.storage).unwrap();
 
@@ -121,7 +121,7 @@ fn unauthorized_config_update() {
     }));
 
     let sender = "non-admin";
-    let auth_info = mock_info(sender, &vec![]);
+    let auth_info = mock_info(sender, &[]);
     let msg = ExecuteMsg::UpdateContractInformation {
         contract_information: ContractInformation {
             admin: "non-admin".to_string(),
@@ -140,7 +140,7 @@ fn authorized_config_update() {
     }));
 
     let sender = "admin";
-    let auth_info = mock_info(sender, &vec![]);
+    let auth_info = mock_info(sender, &[]);
     let msg = ExecuteMsg::UpdateContractInformation {
         contract_information: ContractInformation {
             admin: "new-admin".to_string(),