Add better hints support

Author: ucarion

src/hint_set.rs

@@ -0,0 +1,36 @@
+const WILDCARD: &'static str = "-";
+
+#[derive(Debug)]
+pub struct HintSet<'a> {
+    values: Vec<&'a [String]>,
+}
+
+impl<'a> HintSet<'a> {
+    pub fn new(values: Vec<&'a [String]>) -> Self {
+        HintSet { values }
+    }
+
+    pub fn sub_hints(&self, key: &str) -> Self {
+        Self::new(
+            self.values
+                .iter()
+                .filter(|values| {
+                    let first = values.first().map(String::as_str);
+                    first == Some(WILDCARD) || first == Some(key)
+                })
+                .map(|values| &values[1..])
+                .collect(),
+        )
+    }
+
+    pub fn is_active(&self) -> bool {
+        self.values.iter().any(|values| values.is_empty())
+    }
+
+    pub fn peek_active(&self) -> Option<&str> {
+        self.values
+            .iter()
+            .find(|values| values.len() == 1)
+            .and_then(|values| values.first().map(String::as_str))
+    }
+}

src/hints.rs

@@ -1,6 +1,36 @@
-mod hints;
+mod hint_set;
 
-pub use hints::Hints;
+pub use hint_set::HintSet;
+
+#[derive(Debug)]
+pub struct Hints<'a> {
+    values: HintSet<'a>,
+    discriminator: HintSet<'a>,
+}
+
+impl<'a> Hints<'a> {
+    pub fn new(values: HintSet<'a>, discriminator: HintSet<'a>) -> Self {
+        Hints {
+            values,
+            discriminator,
+        }
+    }
+
+    fn sub_hints(&self, key: &str) -> Self {
+        Self::new(
+            self.values.sub_hints(key),
+            self.discriminator.sub_hints(key),
+        )
+    }
+
+    fn is_values_active(&self) -> bool {
+        self.values.is_active()
+    }
+
+    fn peek_active_discriminator(&self) -> Option<&str> {
+        self.discriminator.peek_active()
+    }
+}
 
 use chrono::DateTime;
 use jtd::form::{self, TypeValue};
@@ -69,26 +99,42 @@ impl InferredSchema {
 
                 InferredSchema::Array(Box::new(sub_infer))
             }
-            (InferredSchema::Unknown, Value::Object(obj)) => {
+            (InferredSchema::Unknown, Value::Object(mut obj)) => {
                 if hints.is_values_active() {
                     let mut sub_infer = InferredSchema::Unknown;
                     for (k, v) in obj {
                         sub_infer = sub_infer.infer(v, &hints.sub_hints(&k));
                     }
 
-                    InferredSchema::Values(Box::new(sub_infer))
-                } else {
-                    let mut props = HashMap::new();
-                    for (k, v) in obj {
-                        let sub_infer = InferredSchema::Unknown.infer(v, &hints.sub_hints(&k));
-                        props.insert(k, sub_infer);
-                    }
+                    return InferredSchema::Values(Box::new(sub_infer));
+                }
+
+                if let Some(discriminator) = hints.peek_active_discriminator() {
+                    if let Some(Value::String(mapping_key)) = obj.remove(discriminator) {
+                        let infer_rest = InferredSchema::Unknown.infer(Value::Object(obj), hints);
 
-                    InferredSchema::Properties {
-                        required: props,
-                        optional: HashMap::new(),
+                        dbg!("infer rest", &discriminator, &infer_rest);
+
+                        let mut mapping = HashMap::new();
+                        mapping.insert(mapping_key.to_owned(), infer_rest);
+
+                        return InferredSchema::Discriminator {
+                            discriminator: discriminator.to_owned(),
+                            mapping,
+                        };
                     }
                 }
+
+                let mut props = HashMap::new();
+                for (k, v) in obj {
+                    let sub_infer = InferredSchema::Unknown.infer(v, &hints.sub_hints(&k));
+                    props.insert(k, sub_infer);
+                }
+
+                InferredSchema::Properties {
+                    required: props,
+                    optional: HashMap::new(),
+                }
             }
             (InferredSchema::Any, _) => InferredSchema::Any,
             (InferredSchema::Bool, Value::Bool(_)) => InferredSchema::Bool,
@@ -198,7 +244,35 @@ impl InferredSchema {
 
                 return InferredSchema::Values(Box::new(sub_infer));
             }
-            _ => unimplemented!(),
+            (InferredSchema::Values(_), _) => InferredSchema::Any,
+            (
+                InferredSchema::Discriminator {
+                    discriminator,
+                    mut mapping,
+                },
+                Value::Object(mut obj),
+            ) => {
+                let mapping_key = obj.remove(&discriminator);
+                if let Some(Value::String(mapping_key_str)) = mapping_key {
+                    if !mapping.contains_key(&mapping_key_str) {
+                        mapping.insert(mapping_key_str.clone(), InferredSchema::Unknown);
+                    }
+
+                    let sub_infer = mapping
+                        .remove(&mapping_key_str)
+                        .unwrap()
+                        .infer(Value::Object(obj), hints);
+                    mapping.insert(mapping_key_str, sub_infer);
+
+                    InferredSchema::Discriminator {
+                        discriminator,
+                        mapping,
+                    }
+                } else {
+                    InferredSchema::Any
+                }
+            }
+            (InferredSchema::Discriminator { .. }, _) => InferredSchema::Any,
         }
     }
 

src/lib.rs

@@ -1,6 +1,6 @@
 use clap::{App, AppSettings, Arg};
 use failure::Error;
-use jtd_infer::{Hints, InferredSchema};
+use jtd_infer::{HintSet, Hints, InferredSchema};
 use serde_json::Deserializer;
 use std::fs::File;
 use std::io::stdin;
@@ -50,10 +50,11 @@ fn main() -> Result<(), Error> {
         .map(parse_json_pointer)
         .collect();
 
-    let value_hint_slices = values_hints.iter().map(|p| &p[..]).collect();
-    let discriminator_hint_slices = discriminator_hints.iter().map(|p| &p[..]).collect();
+    let hints = Hints::new(
+        HintSet::new(values_hints.iter().map(|p| &p[..]).collect()),
+        HintSet::new(discriminator_hints.iter().map(|p| &p[..]).collect()),
+    );
 
-    let hints = Hints::new(value_hint_slices, discriminator_hint_slices);
     let mut inference = InferredSchema::Unknown;
 
     let stream = Deserializer::from_reader(reader);