WIP: Implement custom components and logger

Author: SpriteOvO

spdlog/Cargo.toml

@@ -57,6 +57,7 @@ spdlog-internal = { version = "=0.1.0", path = "../spdlog-internal", optional =
 spdlog-macros = { version = "0.1.0", path = "../spdlog-macros" }
 spin = "0.9.8"
 thiserror = "1.0.37"
+toml = "0.8.8"
 
 [target.'cfg(windows)'.dependencies]
 winapi = { version = "0.3.9", features = ["consoleapi", "debugapi", "handleapi", "processenv", "processthreadsapi", "winbase", "wincon"] }

spdlog/src/config/deser.rs

@@ -0,0 +1,145 @@
+use std::{marker::PhantomData, result::Result as StdResult};
+
+use erased_serde::Deserializer as ErasedDeserializer;
+use serde::{
+    de::{
+        value::{MapAccessDeserializer, UnitDeserializer},
+        Error as SerdeDeError, MapAccess, Visitor,
+    },
+    Deserialize, Deserializer,
+};
+
+use crate::{config, formatter::*, sync::*, Logger, LoggerBuilder, LoggerParams, Result, Sink};
+
+trait Component {
+    type Value;
+
+    fn expecting(formatter: &mut std::fmt::Formatter) -> std::fmt::Result;
+    fn build(name: &str, de: &mut dyn ErasedDeserializer) -> Result<Self::Value>;
+}
+
+struct ComponentFormatter;
+
+impl Component for ComponentFormatter {
+    type Value = Box<dyn Formatter>;
+
+    fn expecting(formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        formatter.write_str("a spdlog-rs formatter")
+    }
+
+    fn build(name: &str, de: &mut dyn ErasedDeserializer) -> Result<Self::Value> {
+        config::registry().build_formatter(&name, de)
+    }
+}
+
+struct ComponentSink;
+
+impl Component for ComponentSink {
+    type Value = Arc<dyn Sink>;
+
+    fn expecting(formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        formatter.write_str("a spdlog-rs sink")
+    }
+
+    fn build(name: &str, de: &mut dyn ErasedDeserializer) -> Result<Self::Value> {
+        config::registry().build_sink(&name, de)
+    }
+}
+
+// Unit for 0 parameter components, map for components with parameters
+struct UnitOrMapDeserializer<A> {
+    map: A,
+}
+
+impl<'de, A> Deserializer<'de> for UnitOrMapDeserializer<A>
+where
+    A: MapAccess<'de>,
+{
+    type Error = A::Error;
+
+    fn deserialize_any<V>(self, visitor: V) -> StdResult<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_map(self.map)
+    }
+
+    fn deserialize_unit<V>(self, visitor: V) -> StdResult<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_unit()
+    }
+
+    fn deserialize_newtype_struct<V>(
+        self,
+        name: &'static str,
+        visitor: V,
+    ) -> StdResult<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_newtype_struct(self)
+    }
+
+    serde::forward_to_deserialize_any! {
+        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
+        bytes byte_buf option enum unit_struct seq tuple
+        tuple_struct map struct identifier ignored_any
+    }
+}
+
+struct ComponentVisitor<C>(PhantomData<C>);
+
+impl<'de, C> Visitor<'de> for ComponentVisitor<C>
+where
+    C: Component,
+{
+    type Value = C::Value;
+
+    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        C::expecting(formatter)
+    }
+
+    fn visit_map<A>(self, mut map: A) -> StdResult<Self::Value, A::Error>
+    where
+        A: MapAccess<'de>,
+    {
+        let name = map
+            .next_entry::<String, String>()?
+            .filter(|(key, _)| key == "name")
+            .map(|(_, value)| value)
+            .ok_or_else(|| SerdeDeError::missing_field("name"))?;
+
+        let mut erased_de = <dyn ErasedDeserializer>::erase(UnitOrMapDeserializer { map });
+        let component = C::build(&name, &mut erased_de).map_err(SerdeDeError::custom)?;
+
+        Ok(component)
+    }
+}
+
+pub fn formatter<'de, D>(de: D) -> StdResult<Option<Box<dyn Formatter>>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    Ok(Some(de.deserialize_map(ComponentVisitor::<
+        ComponentFormatter,
+    >(PhantomData))?))
+}
+
+pub fn sink<'de, D>(de: D) -> StdResult<Option<Arc<dyn Sink>>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    Ok(Some(de.deserialize_map(
+        ComponentVisitor::<ComponentSink>(PhantomData),
+    )?))
+}
+
+pub fn logger<'de, D>(de: D) -> StdResult<Logger, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let params = LoggerParams::deserialize(de)?;
+    LoggerBuilder::build_config(params).map_err(SerdeDeError::custom)
+}

spdlog/src/config/mod.rs

@@ -1,24 +1,114 @@
 mod registry;
 mod source;
 
-pub(crate) mod parse;
+pub(crate) mod deser;
+
+use std::{collections::HashMap, convert::Infallible};
 
 pub use registry::*;
 use serde::{de::DeserializeOwned, Deserialize};
 pub use source::*;
 
 use crate::{sync::*, Result};
 
-// TODO: Force `'static` on name?
-//       Builder?
+// TODO: Builder?
 #[derive(PartialEq, Eq, Hash)]
-pub struct ComponentMetadata<'a> {
-    pub(crate) name: &'a str,
+pub struct ComponentMetadata {
+    name: &'static str,
+}
+
+impl ComponentMetadata {
+    pub fn builder() -> ComponentMetadataBuilder<()> {
+        ComponentMetadataBuilder { name: () }
+    }
+}
+
+pub struct ComponentMetadataBuilder<ArgName> {
+    name: ArgName,
+}
+
+impl<ArgName> ComponentMetadataBuilder<ArgName> {
+    pub fn name(self, name: &'static str) -> ComponentMetadataBuilder<&'static str> {
+        ComponentMetadataBuilder { name }
+    }
+}
+
+impl ComponentMetadataBuilder<()> {
+    #[doc(hidden)]
+    #[deprecated(note = "\n\n\
+        builder compile-time error:\n\
+        - missing required field `name`\n\n\
+    ")]
+    pub fn build(self, _: Infallible) {}
+}
+
+impl ComponentMetadataBuilder<&'static str> {
+    pub fn build(self) -> ComponentMetadata {
+        ComponentMetadata { name: self.name }
+    }
 }
 
 pub trait Configurable: Sized {
     type Params: DeserializeOwned + Default + Send;
 
-    fn metadata() -> ComponentMetadata<'static>;
+    fn metadata() -> ComponentMetadata;
     fn build(params: Self::Params) -> Result<Self>;
 }
+
+mod storage {
+    use serde::Deserialize;
+
+    use super::*;
+
+    #[derive(Deserialize)]
+    #[serde(deny_unknown_fields)]
+    pub(super) struct Logger(
+        #[serde(deserialize_with = "crate::config::deser::logger")] crate::Logger,
+    );
+
+    #[derive(Deserialize)]
+    #[serde(deny_unknown_fields)]
+    pub(super) struct Config {
+        loggers: HashMap<String, Logger>,
+    }
+}
+
+pub struct Config(storage::Config);
+
+impl Config {
+    // TODO: Remember to remove me
+    pub fn new_for_test(inputs: &str) -> Result<Self> {
+        let config = toml::from_str(inputs).unwrap();
+        Ok(Self(config))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_utils::{config::*, TEST_LOGS_PATH};
+
+    #[test]
+    fn full() {
+        let inputs = format!(
+            r#"
+[loggers.default]
+sinks = [
+    {{ name = "$ConfigMockSink1", arg = 114 }},
+    {{ name = "$ConfigMockSink2", arg = 514 }},
+    {{ name = "$ConfigMockSink3", arg = 1919 }},
+    {{ name = "FileSink", path = "{}", formatter = {{ name = "PatternFormatter", template = "114514 {{payload}}{{eol}}" }} }}
+]
+# flush_level_filter = "all" # TODO: design the syntax
+# TODO: flush_period = "10s"
+            "#,
+            TEST_LOGS_PATH.join("unit_test_config_full.log").display()
+        );
+
+        register_global();
+
+        Config::new_for_test(&inputs).unwrap();
+
+        // TODO
+    }
+}