Add support for enum hints

Author: ucarion

src/lib.rs

@@ -1,28 +1,36 @@
 mod hint_set;
 
 pub use hint_set::HintSet;
+use std::collections::HashSet;
 
 #[derive(Debug)]
 pub struct Hints<'a> {
+    enums: HintSet<'a>,
     values: HintSet<'a>,
     discriminator: HintSet<'a>,
 }
 
 impl<'a> Hints<'a> {
-    pub fn new(values: HintSet<'a>, discriminator: HintSet<'a>) -> Self {
+    pub fn new(enums: HintSet<'a>, values: HintSet<'a>, discriminator: HintSet<'a>) -> Self {
         Hints {
+            enums,
             values,
             discriminator,
         }
     }
 
     fn sub_hints(&self, key: &str) -> Self {
         Self::new(
+            self.enums.sub_hints(key),
             self.values.sub_hints(key),
             self.discriminator.sub_hints(key),
         )
     }
 
+    fn is_enum_active(&self) -> bool {
+        self.enums.is_active()
+    }
+
     fn is_values_active(&self) -> bool {
         self.values.is_active()
     }
@@ -52,6 +60,7 @@ pub enum InferredSchema {
     Float64,
     String,
     Timestamp,
+    Enum(HashSet<String>),
     Array(Box<InferredSchema>),
     Properties {
         required: HashMap<String, InferredSchema>,
@@ -85,7 +94,12 @@ impl InferredSchema {
             (InferredSchema::Unknown, Value::Bool(_)) => InferredSchema::Bool,
             (InferredSchema::Unknown, Value::Number(n)) => minimum_number_type(n),
             (InferredSchema::Unknown, Value::String(s)) => {
-                if DateTime::parse_from_rfc3339(&s).is_ok() {
+                if hints.is_enum_active() {
+                    let mut values = HashSet::new();
+                    values.insert(s);
+
+                    InferredSchema::Enum(values)
+                } else if DateTime::parse_from_rfc3339(&s).is_ok() {
                     InferredSchema::Timestamp
                 } else {
                     InferredSchema::String
@@ -113,8 +127,6 @@ impl InferredSchema {
                     if let Some(Value::String(mapping_key)) = obj.remove(discriminator) {
                         let infer_rest = InferredSchema::Unknown.infer(Value::Object(obj), hints);
 
-                        dbg!("infer rest", &discriminator, &infer_rest);
-
                         let mut mapping = HashMap::new();
                         mapping.insert(mapping_key.to_owned(), infer_rest);
 
@@ -193,6 +205,11 @@ impl InferredSchema {
             (InferredSchema::Timestamp, _) => InferredSchema::Any,
             (InferredSchema::String, Value::String(_)) => InferredSchema::String,
             (InferredSchema::String, _) => InferredSchema::Any,
+            (InferredSchema::Enum(mut values), Value::String(s)) => {
+                values.insert(s);
+                InferredSchema::Enum(values)
+            }
+            (InferredSchema::Enum(_), _) => InferredSchema::Any,
             (InferredSchema::Array(prior), Value::Array(vals)) => {
                 let mut sub_infer = *prior;
                 for (i, v) in vals.into_iter().enumerate() {
@@ -320,6 +337,10 @@ impl InferredSchema {
                 nullable: false,
                 type_value: TypeValue::Timestamp,
             }),
+            InferredSchema::Enum(values) => Form::Enum(form::Enum {
+                nullable: false,
+                values,
+            }),
             InferredSchema::Array(sub_infer) => Form::Elements(form::Elements {
                 nullable: false,
                 schema: Box::new(sub_infer.into_schema()),

src/main.rs

@@ -1,4 +1,4 @@
-use clap::{App, AppSettings, Arg};
+use clap::{crate_version, App, AppSettings, Arg};
 use failure::Error;
 use jtd_infer::{HintSet, Hints, InferredSchema};
 use serde_json::Deserializer;
@@ -9,14 +9,21 @@ use std::io::Read;
 
 fn main() -> Result<(), Error> {
     let matches = App::new("jtd-infer")
-        .version("0.1.0")
-        .about("Infers a JSON Type Definition schema from lines of JSON")
+    .version(crate_version!())
+    .about("Infers a JSON Type Definition schema from lines of JSON")
         .setting(AppSettings::ColoredHelp)
         .arg(
             Arg::with_name("INPUT")
                 .help("Where to read examples from. Dash (hypen) indicates stdin")
                 .default_value("-"),
         )
+        .arg(
+            Arg::with_name("enum-hint")
+                .help("Advise the inferrer that the given path points to an enum. If this hint is proven wrong, a type form will be emitted instead. This flag can be provided multiple times.")
+                .multiple(true)
+                .number_of_values(1)
+                .long("enum-hint"),
+        )
         .arg(
             Arg::with_name("values-hint")
                 .help("Advise the inferrer that the given path points to a values form. If this hint is proven wrong, a properties form will be emitted instead. This flag can be provided multiple times.")
@@ -38,6 +45,12 @@ fn main() -> Result<(), Error> {
         file @ _ => Box::new(File::open(file)?) as Box<dyn Read>,
     });
 
+    let enum_hints: Vec<Vec<_>> = matches
+        .values_of("enum-hint")
+        .unwrap_or_default()
+        .map(parse_json_pointer)
+        .collect();
+
     let values_hints: Vec<Vec<_>> = matches
         .values_of("values-hint")
         .unwrap_or_default()
@@ -51,6 +64,7 @@ fn main() -> Result<(), Error> {
         .collect();
 
     let hints = Hints::new(
+        HintSet::new(enum_hints.iter().map(|p| &p[..]).collect()),
         HintSet::new(values_hints.iter().map(|p| &p[..]).collect()),
         HintSet::new(discriminator_hints.iter().map(|p| &p[..]).collect()),
     );