Remove serde-derive dependency

Musl target does not work with proc-macro.
See rust-lang/rust#40174

Removing serde-derive allows building tectonic for musl targets.

Author: malbarbo

Cargo.lock

@@ -52,7 +52,6 @@ tempfile = "^3.0"
 md-5 = "^0.8"
 sha2 = "^0.8"
 serde = "^1.0"
-serde_derive = "^1.0"
 tectonic_xdv = { path = "xdv", version = "0.1.9-dev" }
 termcolor = "^1.0"
 toml = "^0.4"

Cargo.toml

@@ -16,10 +16,14 @@ use std::ffi::OsStr;
 use std::fs::File;
 use std::path::PathBuf;
 use std::sync::atomic::{AtomicBool, Ordering};
+use std::result;
+use std::fmt;
 
 use app_dirs::{app_dir, app_root, get_app_root, sanitized, AppDataType};
 use toml;
 
+use serde::de::{self, Deserialize, Deserializer, Visitor, MapAccess};
+
 use errors::{ErrorKind, Result};
 use io::itarbundle::{HttpITarIoFactory, ITarBundle};
 use io::local_cache::LocalCache;
@@ -47,16 +51,157 @@ url = "https://archive.org/services/purl/net/pkgwpub/tectonic-default"
 "#;
 
 
-#[derive(Deserialize)]
 pub struct PersistentConfig {
     default_bundles: Vec<BundleInfo>,
 }
 
-#[derive(Deserialize)]
+// Manual implementation of Deserialize because serde_derive does not work with musl
+// See https://github.com/rust-lang/rust/issues/40174
+// Implementation based on https://serde.rs/deserialize-struct.html
+impl<'de> Deserialize<'de> for PersistentConfig {
+    fn deserialize<D>(deserializer: D) -> result::Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        enum Field { DefaultBundles };
+
+        impl<'de> Deserialize<'de> for Field {
+            fn deserialize<D>(deserializer: D) -> result::Result<Field, D::Error>
+            where
+                D: Deserializer<'de>,
+            {
+                struct FieldVisitor;
+
+                impl<'de> Visitor<'de> for FieldVisitor {
+                    type Value = Field;
+
+                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                        formatter.write_str("`default_bundles`")
+                    }
+
+                    fn visit_str<E>(self, value: &str) -> result::Result<Field, E>
+                    where
+                        E: de::Error,
+                    {
+                        match value {
+                            "default_bundles" => Ok(Field::DefaultBundles),
+                            _ => Err(de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+
+                deserializer.deserialize_identifier(FieldVisitor)
+            }
+        }
+
+        struct PersistentConfigVisitor;
+
+        impl<'de> Visitor<'de> for PersistentConfigVisitor {
+            type Value = PersistentConfig;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str("struct PersistentConfig")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> result::Result<PersistentConfig, V::Error>
+            where
+                V: MapAccess<'de>,
+            {
+                let mut default_bundles = None;
+                while let Some(key) = map.next_key()? {
+                    match key {
+                        Field::DefaultBundles => {
+                            if default_bundles.is_some() {
+                                return Err(de::Error::duplicate_field("default_bundles"));
+                            }
+                            default_bundles = Some(map.next_value()?);
+                        }
+                    }
+                }
+                let default_bundles = default_bundles.ok_or_else(|| de::Error::missing_field("default_bundles"))?;
+                Ok(PersistentConfig { default_bundles })
+            }
+        }
+
+        const FIELDS: &'static [&'static str] = &["default_bundles"];
+        deserializer.deserialize_struct("PersistentConfig", FIELDS, PersistentConfigVisitor)
+    }
+}
+
 pub struct BundleInfo {
     url: String,
 }
 
+impl<'de> Deserialize<'de> for BundleInfo {
+    fn deserialize<D>(deserializer: D) -> result::Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        enum Field { Url };
+
+        impl<'de> Deserialize<'de> for Field {
+            fn deserialize<D>(deserializer: D) -> result::Result<Field, D::Error>
+            where
+                D: Deserializer<'de>,
+            {
+                struct FieldVisitor;
+
+                impl<'de> Visitor<'de> for FieldVisitor {
+                    type Value = Field;
+
+                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                        formatter.write_str("`url`")
+                    }
+
+                    fn visit_str<E>(self, value: &str) -> result::Result<Field, E>
+                    where
+                        E: de::Error,
+                    {
+                        match value {
+                            "url" => Ok(Field::Url),
+                            _ => Err(de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+
+                deserializer.deserialize_identifier(FieldVisitor)
+            }
+        }
+
+        struct BundleInfoVisitor;
+
+        impl<'de> Visitor<'de> for BundleInfoVisitor {
+            type Value = BundleInfo;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str("struct BundleInfo")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> result::Result<BundleInfo, V::Error>
+            where
+                V: MapAccess<'de>,
+            {
+                let mut url = None;
+                while let Some(key) = map.next_key()? {
+                    match key {
+                        Field::Url => {
+                            if url.is_some() {
+                                return Err(de::Error::duplicate_field("url"));
+                            }
+                            url = Some(map.next_value()?);
+                        }
+                    }
+                }
+                let url = url.ok_or_else(|| de::Error::missing_field("url"))?;
+                Ok(BundleInfo { url })
+            }
+        }
+
+        const FIELDS: &'static [&'static str] = &["url"];
+        deserializer.deserialize_struct("BundleInfo", FIELDS, BundleInfoVisitor)
+    }
+}
+
 impl PersistentConfig {
     pub fn open(auto_create_config_file: bool) -> Result<PersistentConfig> {
         let mut cfg_path = if auto_create_config_file {

src/config.rs

@@ -59,7 +59,6 @@ extern crate hyper_native_tls;
 extern crate libc;
 extern crate md5;
 extern crate tempfile;
-#[macro_use] extern crate serde_derive;
 extern crate serde;
 extern crate sha2;
 extern crate tectonic_xdv;