From bbeb30c9817327f8c6fc7e50580f3e5f567dfafe Mon Sep 17 00:00:00 2001
From: LawnCable <git@lawncable.net>
Date: Fri, 15 Apr 2022 08:37:06 +0200
Subject: do cargo clippy fixes

---
 src/lowlevel/map.rs | 91 ++++++++++++++++++++++++++++++++---------------------
 1 file changed, 56 insertions(+), 35 deletions(-)

(limited to 'src/lowlevel/map.rs')

diff --git a/src/lowlevel/map.rs b/src/lowlevel/map.rs
index 9d0b715..e3e2bfa 100644
--- a/src/lowlevel/map.rs
+++ b/src/lowlevel/map.rs
@@ -1,3 +1,5 @@
+use std::fmt;
+
 use crate::{ensure_element, ensure_tag_name, get_attribute};
 use anyhow::anyhow;
 use rgb::RGBA;
@@ -34,19 +36,23 @@ impl MapOrientation {
     pub fn from_xml_map_node(node: &roxmltree::Node) -> anyhow::Result<MapOrientation> {
         let orientation = node
             .attribute("orientation")
-            .ok_or(anyhow!("map orientation missing"))?;
+            .ok_or_else(|| anyhow!("map orientation missing"))?;
 
         match orientation {
             "orthogonal" => Ok(MapOrientation::Orthogonal),
             "isometric" => Ok(MapOrientation::Isometric),
             "staggered" => {
-                let stagger_axis = StaggerAxis::from_string(node.attribute("staggeraxis").ok_or(
-                    anyhow!("map.staggeraxis missing, it is required for orientation=staggered"),
-                )?)?;
-                let stagger_index =
-                    StaggerIndex::from_string(node.attribute("staggerindex").ok_or(anyhow!(
-                        "map.staggerindex missing, it is required for orientation=staggered"
-                    ))?)?;
+                let stagger_axis =
+                    StaggerAxis::from_string(node.attribute("staggeraxis").ok_or_else(|| {
+                        anyhow!("map.staggeraxis missing, it is required for orientation=staggered")
+                    })?)?;
+                let stagger_index = StaggerIndex::from_string(
+                    node.attribute("staggerindex").ok_or_else(|| {
+                        anyhow!(
+                            "map.staggerindex missing, it is required for orientation=staggered"
+                        )
+                    })?,
+                )?;
 
                 Ok(MapOrientation::Staggered {
                     stagger_axis,
@@ -54,18 +60,24 @@ impl MapOrientation {
                 })
             }
             "hexagonal" => {
-                let stagger_axis = StaggerAxis::from_string(node.attribute("staggeraxis").ok_or(
-                    anyhow!("map.staggeraxis missing, it is required for orientation=hexagonal"),
-                )?)?;
-                let stagger_index =
-                    StaggerIndex::from_string(node.attribute("staggerindex").ok_or(anyhow!(
-                        "map.staggerindex missing, it is required for orientation=hexagonal"
-                    ))?)?;
+                let stagger_axis =
+                    StaggerAxis::from_string(node.attribute("staggeraxis").ok_or_else(|| {
+                        anyhow!("map.staggeraxis missing, it is required for orientation=hexagonal")
+                    })?)?;
+                let stagger_index = StaggerIndex::from_string(
+                    node.attribute("staggerindex").ok_or_else(|| {
+                        anyhow!(
+                            "map.staggerindex missing, it is required for orientation=hexagonal"
+                        )
+                    })?,
+                )?;
                 let hexside_length: i32 = node
                     .attribute("hexsidelength")
-                    .ok_or(anyhow!(
-                        "map.hexsidelength missing, it is required for orientation=hexagonal"
-                    ))?
+                    .ok_or_else(|| {
+                        anyhow!(
+                            "map.hexsidelength missing, it is required for orientation=hexagonal"
+                        )
+                    })?
                     .parse()?;
 
                 Ok(MapOrientation::Hexagonal {
@@ -77,13 +89,15 @@ impl MapOrientation {
             _ => Err(anyhow!("Unknown MapOrientation: {}", orientation)),
         }
     }
+}
 
-    pub fn to_string(self) -> String {
+impl fmt::Display for MapOrientation {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            MapOrientation::Orthogonal => "orthogonal".to_owned(),
-            MapOrientation::Isometric => "isometric".to_owned(),
-            MapOrientation::Staggered { .. } => "staggered".to_owned(),
-            MapOrientation::Hexagonal { .. } => "hexagonal".to_owned(),
+            MapOrientation::Orthogonal => write!(f, "orthogonal"),
+            MapOrientation::Isometric => write!(f, "isometric"),
+            MapOrientation::Staggered { .. } => write!(f, "staggered"),
+            MapOrientation::Hexagonal { .. } => write!(f, "hexagonal"),
         }
     }
 }
@@ -115,13 +129,15 @@ impl MapRenderOrder {
             _ => Err(anyhow!("Unknown MapRenderOrder: {}", string)),
         }
     }
+}
 
-    pub fn to_string(self) -> String {
+impl fmt::Display for MapRenderOrder {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            MapRenderOrder::RightDown => "right-down".to_owned(),
-            MapRenderOrder::RightUp => "right-up".to_owned(),
-            MapRenderOrder::LeftDown => "left-down".to_owned(),
-            MapRenderOrder::LeftUp => "left-up".to_owned(),
+            MapRenderOrder::RightDown => write!(f, "right-down"),
+            MapRenderOrder::RightUp => write!(f, "right-up"),
+            MapRenderOrder::LeftDown => write!(f, "left-down"),
+            MapRenderOrder::LeftUp => write!(f, "left-up"),
         }
     }
 }
@@ -141,11 +157,13 @@ impl StaggerAxis {
             _ => Err(anyhow!("invalid StaggerAxis: {}", string)),
         }
     }
+}
 
-    pub fn to_string(self) -> String {
+impl fmt::Display for StaggerAxis {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            StaggerAxis::X => "x".to_owned(),
-            StaggerAxis::Y => "y".to_owned(),
+            StaggerAxis::X => write!(f, "x"),
+            StaggerAxis::Y => write!(f, "y"),
         }
     }
 }
@@ -165,11 +183,13 @@ impl StaggerIndex {
             _ => Err(anyhow!("invalid StaggerIndex: {}", string)),
         }
     }
+}
 
-    pub fn to_string(self) -> String {
+impl fmt::Display for StaggerIndex {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            StaggerIndex::Even => "even".to_owned(),
-            StaggerIndex::Odd => "odd".to_owned(),
+            StaggerIndex::Even => write!(f, "even"),
+            StaggerIndex::Odd => write!(f, "odd"),
         }
     }
 }
@@ -240,7 +260,8 @@ impl Map {
         let infinite = if let Ok(inf) = get_attribute!(node, "infinite") {
             match inf {
                 "1" => true,
-                "0" | _ => false,
+                "0" => false,
+                _ => false,
             }
         } else {
             false
-- 
cgit v1.2.3-60-g2f50