After much frustration with glif::write bugs, I rewrote it.

This time I focused on code hygeine etc. I'm much more confident in this
version of glifparser's writer.

New traits: `IntoXML`, `FromXML`.

src/anchor.rs

@@ -1,3 +1,5 @@
+mod xml;
+
 use std::fmt::Debug;
 #[cfg(feature = "glifserde")]
 use serde::{Serialize, Deserialize};
@@ -14,6 +16,7 @@ pub struct Anchor<PD: PointData> {
     pub data: PD,
 }
 
+/// Only Undefined is used, for now.
 #[cfg_attr(feature = "glifserde", derive(Serialize, Deserialize))]
 #[derive(Debug, Copy, Clone, PartialEq)]
 pub enum AnchorType {
@@ -22,7 +25,7 @@ pub enum AnchorType {
     Base,
     MarkMark,
     MarkBase,
-} // Undefined used everywhere for now as getting type requires parsing OpenType features, which we will be using nom to do since I have experience w/it.
+}
 
 impl<PD: PointData> Anchor<PD> {
     pub fn new() -> Self {

src/anchor/xml.rs

@@ -0,0 +1,14 @@
+use crate::glif::IntoXML;
+use crate::xml::Element;
+
+use super::{Anchor, PointData};
+
+impl<PD: PointData> IntoXML for Anchor<PD> {
+    fn xml(&self) -> Element {
+        let mut anchor_node = xmltree::Element::new("anchor");
+        anchor_node.attributes.insert("x".to_owned(), self.x.to_string());
+        anchor_node.attributes.insert("y".to_owned(), self.y.to_string());
+        anchor_node.attributes.insert("name".to_owned(), self.class.to_string());
+        anchor_node
+    }
+}

src/codepoint.rs

@@ -1,3 +1,6 @@
+use crate::glif::IntoXML;
+use crate::xml::Element;
+
 pub trait Codepoint {
     fn display(&self) -> String;
 }
@@ -7,3 +10,11 @@ impl Codepoint for char {
         format!("{:X}", *self as u32)
     }
 }
+
+impl IntoXML for dyn Codepoint {
+    fn xml(&self) -> Element {
+        let mut unicode = xmltree::Element::new("unicode");
+        unicode.attributes.insert("hex".to_owned(), self.display());
+        unicode
+    }
+}

src/component.rs

@@ -1,3 +1,5 @@
+mod xml;
+
 use crate::error::GlifParserError;
 use crate::glif::{self, Glif};
 #[cfg(feature = "mfek")]

src/component/xml.rs

@@ -0,0 +1,15 @@
+use crate::matrix;
+use crate::xml::{Element, IntoXML};
+
+use super::GlifComponent;
+
+impl IntoXML for GlifComponent {
+    fn xml(&self) -> Element {
+        let mut component_node = Element::new("component");
+        component_node
+            .attributes
+            .insert("base".to_string(), self.base.clone());
+        matrix::write!(component_node, self);
+        component_node
+    }
+}

src/error.rs

@@ -13,6 +13,8 @@ use xmltree::{ParseError, Error as XMLTreeError};
 #[cfg(feature = "glifserde")]
 use plist::Error as PlistError;
 
+pub type GlifParserResult<T> = Result<T, GlifParserError>;
+
 #[derive(Debug, Clone)]
 pub enum GlifParserError {
     /// OS error when reading glif

src/glif.rs

@@ -1,5 +1,3 @@
-use plist;
-
 use std::path;
 
 use crate::anchor::Anchor;
@@ -12,15 +10,18 @@ use crate::point::PointData;
 use crate::outline::{Outline, OutlineType};
 
 mod conv;
+mod lib;
+pub use lib::Lib;
 mod read;
+pub use self::read::read_ufo_glif as read;
+pub use self::read::read_ufo_glif_from_filename as read_from_filename;
 mod write;
+pub use self::write::write_ufo_glif as write;
+pub use self::write::write_ufo_glif_to_filename as write_to_filename;
 #[cfg(feature = "mfek")]
 pub mod mfek;
-
-pub use read::read_ufo_glif as read;
-pub use read::read_ufo_glif_from_filename as read_from_filename;
-pub use write::write_ufo_glif as write;
-pub use write::write_ufo_glif_to_filename as write_to_filename;
+pub mod xml;
+pub use self::{read::FromXML, write::IntoXML, xml::XMLConversion};
 
 #[cfg(feature = "glifserde")]
 use serde::{Deserialize, Deserializer, Serialize, Serializer, ser::SerializeStruct, ser::Error as SerdeError, de::Error as SerdeDeError};
@@ -59,7 +60,7 @@ pub struct Glif<PD: PointData> {
     /// It's up to the API consumer to set this.
     pub filename: Option<path::PathBuf>,
     /// glif private library
-    pub lib: Option<plist::Dictionary>,
+    pub lib: Lib,
 }
 
 #[cfg(feature = "glifserde")]

src/glif/lib.rs

@@ -0,0 +1,17 @@
+use crate::xml;
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum Lib {
+    None,
+    Plist(plist::Dictionary),
+    /// This variant is highly undesirable to see as output and means that the user's glif file has
+    /// validity issues. However, to prevent data loss, we attempt to store the broken plist as
+    /// XML, as XML is the parent of plist.
+    Xml(xml::Element),
+}
+
+impl Default for Lib {
+    fn default() -> Self {
+        Self::None
+    }
+}

src/glif/read.rs

@@ -1,10 +1,13 @@
+mod xml;
+pub use self::xml::FromXML;
+
 use std::convert::TryInto;
 use std::path;
 use std::rc::Rc;
 
 use integer_or_float::IntegerOrFloat;
 
-use super::Glif;
+use super::{Glif, Lib};
 use crate::error::GlifParserError::{self, GlifInputError};
 use crate::component::GlifComponent;
 use crate::guideline::Guideline;
@@ -260,8 +263,16 @@ pub fn read_ufo_glif<PD: PointData>(glif: &str) -> Result<Glif<PD>, GlifParserEr
     #[cfg(feature = "glifserde")]
     if let Some(lib) = glif.take_child("lib") {
         let mut plist_temp: Vec<u8> = vec![];
-        lib.write(&mut plist_temp)?;
-        ret.lib = plist::from_bytes(&plist_temp).ok();
+        match lib.write(&mut plist_temp).map(|()|plist::from_bytes(&plist_temp)) {
+            Ok(Ok(lib_p)) => ret.lib = Lib::Plist(lib_p),
+            Err(e) => {
+                log::error!("Failed to serialize .glif lib as XML? Error: {:?}", e);
+                ret.lib = Lib::Xml(lib)
+            },
+            Ok(Err(e)) => {
+                log::error!("Failed to deserialize .glif lib XML as plist? Error: {:?}", e);
+            }
+        }
     }
     #[cfg(not(feature = "glifserde"))]
     if let Some(_) = glif.take_child("lib") {

src/glif/read/xml.rs

@@ -0,0 +1,8 @@
+use crate::error::GlifParserResult;
+
+pub trait FromXML: super::super::write::IntoXML + Sized {
+    fn from_xml(xml: &[u8]) -> GlifParserResult<Self>;
+    fn from_xml_string(xml: &String) -> GlifParserResult<Self> {
+        Self::from_xml(xml.as_bytes())
+    }
+}