Rename TiledError to Error + Add Result type

src/animation.rs

@@ -3,7 +3,7 @@
 use xml::attribute::OwnedAttribute;
 
 use crate::{
-    error::TiledError,
+    error::{Error, Result},
     util::{get_attrs, parse_tag, XmlEventResult},
 };
 
@@ -20,14 +20,14 @@ pub struct Frame {
 }
 
 impl Frame {
-    pub(crate) fn new(attrs: Vec<OwnedAttribute>) -> Result<Frame, TiledError> {
+    pub(crate) fn new(attrs: Vec<OwnedAttribute>) -> Result<Frame> {
         let (tile_id, duration) = get_attrs!(
             attrs,
             required: [
                 ("tileid", tile_id, |v:String| v.parse().ok()),
                 ("duration", duration, |v:String| v.parse().ok()),
             ],
-            TiledError::MalformedAttributes("A frame must have tileid and duration".to_string())
+            Error::MalformedAttributes("A frame must have tileid and duration".to_string())
         );
         Ok(Frame {
             tile_id: tile_id,
@@ -38,7 +38,7 @@ impl Frame {
 
 pub(crate) fn parse_animation(
     parser: &mut impl Iterator<Item = XmlEventResult>,
-) -> Result<Vec<Frame>, TiledError> {
+) -> Result<Vec<Frame>> {
     let mut animation = Vec::new();
     parse_tag!(parser, "animation", {
         "frame" => |attrs| {

src/cache.rs

@@ -15,13 +15,13 @@ pub type ResourcePathBuf = PathBuf;
 /// [`ResourcePath`] to prevent loading them more than once.
 pub trait ResourceCache {
     /// Obtains a tileset from the cache, if it exists.
-    /// 
+    ///
     /// # Example
     /// ```
     /// use std::fs::File;
     /// use tiled::{FilesystemResourceCache, ResourceCache, Tileset};
-    /// # use tiled::TiledError;
-    /// # fn main() -> Result<(), TiledError> {
+    /// # use tiled::Result;
+    /// # fn main() -> Result<()> {
     /// let mut cache = FilesystemResourceCache::new();
     /// let path = "assets/tilesheet.tsx";
     ///
@@ -32,7 +32,7 @@ pub trait ResourceCache {
     /// # }
     /// ```
     fn get_tileset(&self, path: impl AsRef<ResourcePath>) -> Option<Arc<Tileset>>;
-    
+
     /// Returns the tileset mapped to `path` if it exists, otherwise calls `f` and, depending on its
     /// result, it will:
     /// - Insert the object into the cache, if the result was [`Ok`].

src/error.rs

@@ -3,7 +3,7 @@ use std::{fmt, path::PathBuf};
 /// Errors which occured when parsing the file
 #[derive(Debug)]
 #[non_exhaustive]
-pub enum TiledError {
+pub enum Error {
     /// A attribute was missing, had the wrong type of wasn't formated
     /// correctly.
     MalformedAttributes(String),
@@ -51,56 +51,59 @@ pub enum TiledError {
     },
 }
 
-impl fmt::Display for TiledError {
-    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+/// A result with an error variant of [`tiled::error::Error`].
+pub type Result<T> = std::result::Result<T, Error>;
+
+impl fmt::Display for Error {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> std::result::Result<(), fmt::Error> {
         match self {
-            TiledError::MalformedAttributes(s) => write!(fmt, "{}", s),
-            TiledError::DecompressingError(e) => write!(fmt, "{}", e),
-            TiledError::Base64DecodingError(e) => write!(fmt, "{}", e),
-            TiledError::XmlDecodingError(e) => write!(fmt, "{}", e),
-            TiledError::PrematureEnd(e) => write!(fmt, "{}", e),
-            TiledError::PathIsNotFile => {
+            Error::MalformedAttributes(s) => write!(fmt, "{}", s),
+            Error::DecompressingError(e) => write!(fmt, "{}", e),
+            Error::Base64DecodingError(e) => write!(fmt, "{}", e),
+            Error::XmlDecodingError(e) => write!(fmt, "{}", e),
+            Error::PrematureEnd(e) => write!(fmt, "{}", e),
+            Error::PathIsNotFile => {
                 write!(
                     fmt,
                     "The path given is invalid because it isn't contained in any folder."
                 )
             }
-            TiledError::CouldNotOpenFile { path, err } => {
+            Error::CouldNotOpenFile { path, err } => {
                 write!(
                     fmt,
                     "Could not open '{}'. Error: {}",
                     path.to_string_lossy(),
                     err
                 )
             }
-            TiledError::InvalidTileFound => write!(fmt, "Invalid tile found in map being parsed"),
-            TiledError::InvalidEncodingFormat { encoding: None, compression: None } => 
+            Error::InvalidTileFound => write!(fmt, "Invalid tile found in map being parsed"),
+            Error::InvalidEncodingFormat { encoding: None, compression: None } => 
                 write!(
                     fmt,
                     "Deprecated combination of encoding and compression"
                 ),
-            TiledError::InvalidEncodingFormat { encoding, compression } => 
+            Error::InvalidEncodingFormat { encoding, compression } => 
                 write!(
                     fmt,
                     "Unknown encoding or compression format or invalid combination of both (for tile layers): {} encoding with {} compression",
                     encoding.as_deref().unwrap_or("no"),
                     compression.as_deref().unwrap_or("no")
                 ),
-            TiledError::InvalidPropertyValue{description} =>
+            Error::InvalidPropertyValue{description} =>
                 write!(fmt, "Invalid property value: {}", description),
-            TiledError::UnknownPropertyType { type_name } =>
+            Error::UnknownPropertyType { type_name } =>
                 write!(fmt, "Unknown property value type '{}'", type_name),
         }
     }
 }
 
-impl std::error::Error for TiledError {
+impl std::error::Error for Error {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
         match self {
-            TiledError::DecompressingError(e) => Some(e as &dyn std::error::Error),
-            TiledError::Base64DecodingError(e) => Some(e as &dyn std::error::Error),
-            TiledError::XmlDecodingError(e) => Some(e as &dyn std::error::Error),
-            TiledError::CouldNotOpenFile { err, .. } => Some(err as &dyn std::error::Error),
+            Error::DecompressingError(e) => Some(e as &dyn std::error::Error),
+            Error::Base64DecodingError(e) => Some(e as &dyn std::error::Error),
+            Error::XmlDecodingError(e) => Some(e as &dyn std::error::Error),
+            Error::CouldNotOpenFile { err, .. } => Some(err as &dyn std::error::Error),
             _ => None,
         }
     }

src/image.rs

@@ -2,7 +2,11 @@ use std::path::{Path, PathBuf};
 
 use xml::attribute::OwnedAttribute;
 
-use crate::{error::TiledError, properties::Color, util::*};
+use crate::{
+    error::{Error, Result},
+    properties::Color,
+    util::*,
+};
 
 /// A reference to an image stored somewhere within the filesystem.
 #[derive(Debug, PartialEq, Eq, Clone)]
@@ -26,7 +30,7 @@ pub struct Image {
     /// use std::fs::File;
     /// use tiled::*;
     ///
-    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
+    /// # fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
     /// let map = Map::parse_file(
     ///     "assets/folder/tiled_relative_paths.tmx",
     ///     &mut FilesystemResourceCache::new(),
@@ -78,7 +82,7 @@ impl Image {
         parser: &mut impl Iterator<Item = XmlEventResult>,
         attrs: Vec<OwnedAttribute>,
         path_relative_to: impl AsRef<Path>,
-    ) -> Result<Image, TiledError> {
+    ) -> Result<Image> {
         let (c, (s, w, h)) = get_attrs!(
             attrs,
             optionals: [
@@ -89,10 +93,10 @@ impl Image {
                 ("width", width, |v:String| v.parse().ok()),
                 ("height", height, |v:String| v.parse().ok()),
             ],
-            TiledError::MalformedAttributes("Image must have a source, width and height with correct types".to_string())
+            Error::MalformedAttributes("Image must have a source, width and height with correct types".to_string())
         );
 
-        parse_tag!(parser, "image", { });
+        parse_tag!(parser, "image", {});
         Ok(Image {
             source: path_relative_to.as_ref().join(s),
             width: w,

src/layers/group.rs

@@ -2,12 +2,12 @@ use std::collections::HashMap;
 use std::path::Path;
 
 use crate::{
-    error::TiledError,
+    error::Result,
     layers::{LayerData, LayerTag},
     map::MapTilesetGid,
     properties::{parse_properties, Properties},
     util::*,
-    Layer, Map,
+    Error, Layer, Map,
 };
 
 #[derive(Debug, PartialEq, Clone)]
@@ -21,7 +21,7 @@ impl GroupLayerData {
         infinite: bool,
         map_path: &Path,
         tilesets: &[MapTilesetGid],
-    ) -> Result<(Self, Properties), TiledError> {
+    ) -> Result<(Self, Properties)> {
         let mut properties = HashMap::new();
         let mut layers = Vec::new();
         parse_tag!(parser, "group", {

src/layers/image.rs

@@ -2,8 +2,8 @@ use std::{collections::HashMap, path::Path};
 
 use crate::{
     parse_properties,
-    util::{parse_tag, XmlEventResult, map_wrapper},
-    Image, Properties, TiledError,
+    util::{map_wrapper, parse_tag, XmlEventResult},
+    Error, Image, Properties, Result,
 };
 
 #[derive(Debug, PartialEq, Clone)]
@@ -15,11 +15,11 @@ impl ImageLayerData {
     pub(crate) fn new(
         parser: &mut impl Iterator<Item = XmlEventResult>,
         map_path: &Path,
-    ) -> Result<(Self, Properties), TiledError> {
+    ) -> Result<(Self, Properties)> {
         let mut image: Option<Image> = None;
         let mut properties = HashMap::new();
 
-        let path_relative_to = map_path.parent().ok_or(TiledError::PathIsNotFile)?;
+        let path_relative_to = map_path.parent().ok_or(Error::PathIsNotFile)?;
 
         parse_tag!(parser, "imagelayer", {
             "image" => |attrs| {

src/layers/mod.rs

@@ -2,7 +2,12 @@ use std::path::Path;
 
 use xml::attribute::OwnedAttribute;
 
-use crate::{error::TiledError, properties::Properties, util::*, Color, Map, MapTilesetGid};
+use crate::{
+    error::{Result},
+    properties::Properties,
+    util::*,
+    Color, Map, MapTilesetGid,
+};
 
 mod image;
 pub use image::*;
@@ -52,7 +57,7 @@ impl LayerData {
         infinite: bool,
         map_path: &Path,
         tilesets: &[MapTilesetGid],
-    ) -> Result<Self, TiledError> {
+    ) -> Result<Self> {
         let (opacity, tint_color, visible, offset_x, offset_y, parallax_x, parallax_y, name, id) = get_attrs!(
             attrs,
             optionals: [

src/layers/object.rs

@@ -5,7 +5,7 @@ use xml::attribute::OwnedAttribute;
 use crate::{
     parse_properties,
     util::{get_attrs, map_wrapper, parse_tag, XmlEventResult},
-    Color, Map, MapTilesetGid, Object, ObjectData, Properties, TiledError,
+    Color, Error, Map, MapTilesetGid, Object, ObjectData, Properties, Result,
 };
 
 /// Raw data referring to a map object layer or tile collision data.
@@ -24,7 +24,7 @@ impl ObjectLayerData {
         parser: &mut impl Iterator<Item = XmlEventResult>,
         attrs: Vec<OwnedAttribute>,
         tilesets: Option<&[MapTilesetGid]>,
-    ) -> Result<(ObjectLayerData, Properties), TiledError> {
+    ) -> Result<(ObjectLayerData, Properties)> {
         let c = get_attrs!(
             attrs,
             optionals: [

src/layers/tile/finite.rs

@@ -2,7 +2,7 @@ use xml::attribute::OwnedAttribute;
 
 use crate::{
     util::{get_attrs, map_wrapper, XmlEventResult},
-    LayerTile, LayerTileData, MapTilesetGid, TiledError,
+    LayerTile, LayerTileData, MapTilesetGid, Result,
 };
 
 use super::util::parse_data_line;
@@ -31,7 +31,7 @@ impl FiniteTileLayerData {
         width: u32,
         height: u32,
         tilesets: &[MapTilesetGid],
-    ) -> Result<Self, TiledError> {
+    ) -> Result<Self> {
         let (e, c) = get_attrs!(
             attrs,
             optionals: [
@@ -65,7 +65,7 @@ map_wrapper!(
 
 impl<'map> FiniteTileLayer<'map> {
     /// Obtains the tile present at the position given.
-    /// 
+    ///
     /// If the position given is invalid or the position is empty, this function will return [`None`].
     pub fn get_tile(&self, x: i32, y: i32) -> Option<LayerTile> {
         self.data

src/layers/tile/infinite.rs

@@ -4,7 +4,7 @@ use xml::attribute::OwnedAttribute;
 
 use crate::{
     util::{floor_div, get_attrs, map_wrapper, parse_tag, XmlEventResult},
-    LayerTile, LayerTileData, MapTilesetGid, TiledError,
+    Error, LayerTile, LayerTileData, MapTilesetGid, Result,
 };
 
 use super::util::parse_data_line;
@@ -25,7 +25,7 @@ impl InfiniteTileLayerData {
         parser: &mut impl Iterator<Item = XmlEventResult>,
         attrs: Vec<OwnedAttribute>,
         tilesets: &[MapTilesetGid],
-    ) -> Result<Self, TiledError> {
+    ) -> Result<Self> {
         let (e, c) = get_attrs!(
             attrs,
             optionals: [
@@ -123,7 +123,7 @@ impl InternalChunk {
         encoding: Option<String>,
         compression: Option<String>,
         tilesets: &[MapTilesetGid],
-    ) -> Result<Self, TiledError> {
+    ) -> Result<Self> {
         let (x, y, width, height) = get_attrs!(
             attrs,
             required: [
@@ -132,7 +132,7 @@ impl InternalChunk {
                 ("width", width, |v: String| v.parse().ok()),
                 ("height", height, |v: String| v.parse().ok()),
             ],
-            TiledError::MalformedAttributes("chunk must have x, y, width & height attributes".to_string())
+            Error::MalformedAttributes("chunk must have x, y, width & height attributes".to_string())
         );
 
         let tiles = parse_data_line(encoding, compression, parser, tilesets)?;

src/layers/tile/mod.rs

@@ -5,7 +5,7 @@ use xml::attribute::OwnedAttribute;
 use crate::{
     parse_properties,
     util::{get_attrs, map_wrapper, parse_tag, XmlEventResult},
-    Gid, Map, MapTilesetGid, Properties, Tile, TileId, TiledError, Tileset,
+    Error, Gid, Map, MapTilesetGid, Properties, Result, Tile, TileId, Tileset,
 };
 
 mod finite;
@@ -74,14 +74,14 @@ impl TileLayerData {
         attrs: Vec<OwnedAttribute>,
         infinite: bool,
         tilesets: &[MapTilesetGid],
-    ) -> Result<(Self, Properties), TiledError> {
+    ) -> Result<(Self, Properties)> {
         let (width, height) = get_attrs!(
             attrs,
             required: [
                 ("width", width, |v: String| v.parse().ok()),
                 ("height", height, |v: String| v.parse().ok()),
             ],
-            TiledError::MalformedAttributes("layer parsing error, width and height attributes required".to_string())
+            Error::MalformedAttributes("layer parsing error, width and height attributes required".to_string())
         );
         let mut result = Self::Finite(Default::default());
         let mut properties = HashMap::new();
@@ -174,7 +174,7 @@ impl<'map> TileLayer<'map> {
     }
 
     /// Obtains the tile present at the position given.
-    /// 
+    ///
     /// If the position given is invalid or the position is empty, this function will return [`None`].
     pub fn get_tile(&self, x: i32, y: i32) -> Option<LayerTile> {
         match self {