Fixed error message when no similar configs are found.

Added linting for EnvOp

Signed-off-by: Nichol Yip <[email protected]>

Author: Nichol Yip

crates/spk-schema/src/environ.rs

@@ -1,6 +1,7 @@
 // Copyright (c) Sony Pictures Imageworks, et al.
 // SPDX-License-Identifier: Apache-2.0
 // https://github.com/imageworks/spk
+use ngrammatic::CorpusBuilder;
 use serde::{Deserialize, Serialize};
 use spk_schema_foundation::option_map::Stringified;
 
@@ -18,7 +19,7 @@ const OP_COMMENT: &str = "comment";
 const OP_PREPEND: &str = "prepend";
 const OP_PRIORITY: &str = "priority";
 const OP_SET: &str = "set";
-const OP_NAMES: &[&str] = &[OP_APPEND, OP_COMMENT, OP_PREPEND, OP_SET];
+const OP_NAMES: &[&str] = &[OP_APPEND, OP_COMMENT, OP_PREPEND, OP_SET, OP_PRIORITY];
 
 /// The set of operation types for use in deserialization
 #[derive(Copy, Clone, Debug, PartialEq)]
@@ -126,6 +127,7 @@ impl<'de> Deserialize<'de> for EnvOp {
             op_and_var: Option<(OpKind, ConfKind)>,
             value: Option<String>,
             separator: Option<String>,
+            lints: Vec<String>,
         }
 
         impl<'de> serde::de::Visitor<'de> for EnvOpVisitor {
@@ -175,7 +177,24 @@ impl<'de> Deserialize<'de> for EnvOp {
                         "separator" => {
                             self.separator = map.next_value::<Option<Stringified>>()?.map(|s| s.0)
                         }
-                        _ => {
+                        unknown_config => {
+                            self.lints
+                                .push(format!("Unknown config: {unknown_config}. "));
+                            let mut corpus = CorpusBuilder::new().finish();
+                            for op_name in OP_NAMES.iter() {
+                                corpus.add_text(op_name);
+                            }
+
+                            match corpus.search(unknown_config, 0.6).first() {
+                                Some(s) => self
+                                    .lints
+                                    .push(format!("The most similar config is: {}", s.text)),
+                                None => self.lints.push(format!(
+                                    "No similar config found for: {}.",
+                                    unknown_config
+                                )),
+                            };
+
                             // ignore any unknown field for the sake of
                             // forward compatibility
                             map.next_value::<serde::de::IgnoredAny>()?;
@@ -184,12 +203,15 @@ impl<'de> Deserialize<'de> for EnvOp {
                 }
 
                 // Comments and priority configs don't have any values.
-                let value = match self.op_and_var.as_ref().unwrap().0 {
-                    OpKind::Comment | OpKind::Priority => String::from(""),
-                    _ => self
-                        .value
-                        .take()
-                        .ok_or_else(|| serde::de::Error::missing_field("value"))?,
+                let value = match self.op_and_var.as_ref() {
+                    Some(v) => match v.0 {
+                        OpKind::Comment | OpKind::Priority => String::from(""),
+                        _ => self
+                            .value
+                            .take()
+                            .ok_or_else(|| serde::de::Error::missing_field("value"))?,
+                    },
+                    None => String::from(""),
                 };
 
                 let value = shellexpand::env(&value)
@@ -198,30 +220,34 @@ impl<'de> Deserialize<'de> for EnvOp {
 
                 match self.op_and_var.take() {
                     Some((op, var)) => match op {
-                        OpKind::Prepend => Ok(EnvOp::Prepend(PrependEnv{
+                        OpKind::Prepend => Ok(EnvOp::Prepend(PrependEnv {
                             prepend: var.get_op(),
                             separator: self.separator.take(),
-                            value
+                            value,
                         })),
-                        OpKind::Append => Ok(EnvOp::Append(AppendEnv{
+                        OpKind::Append => Ok(EnvOp::Append(AppendEnv {
                             append: var.get_op(),
                             separator: self.separator.take(),
-                            value
+                            value,
                         })),
-                        OpKind::Set => Ok(EnvOp::Set(SetEnv{
+                        OpKind::Set => Ok(EnvOp::Set(SetEnv {
                             set: var.get_op(),
-                            value
+                            value,
+                        })),
+                        OpKind::Comment => Ok(EnvOp::Comment(CommentEnv {
+                            comment: var.get_op(),
                         })),
-                        OpKind::Comment => Ok(EnvOp::Comment(CommentEnv{
-                            comment: var.get_op()
+                        OpKind::Priority => Ok(EnvOp::Priority(Priority {
+                            priority: var.get_priority(),
                         })),
-                        OpKind::Priority => Ok(EnvOp::Priority(Priority{
-                            priority: var.get_priority()
-                        }))
                     },
-                    None => Err(serde::de::Error::custom(format!(
-                        "missing field to define operation and variable, expected one of {OP_NAMES:?}",
-                    ))),
+                    None => {
+                        let mut err_msg = String::from("");
+                        for lint in self.lints.iter() {
+                            err_msg = err_msg + lint;
+                        }
+                        Err(serde::de::Error::custom(err_msg))
+                    }
                 }
             }
         }

crates/spk-schema/src/install_spec.rs

@@ -144,16 +144,15 @@ where
                     corpus.add_text("components");
                     corpus.add_text("environment");
 
-                    let results = corpus.search(unknown_config, 0.6);
-                    let no_match = format!("No similar config found for: {}", unknown_config);
-                    let top_match = match results.first() {
-                        Some(s) => &s.text,
-                        None => &no_match,
+                    match corpus.search(unknown_config, 0.6).first() {
+                        Some(s) => self
+                            .lints
+                            .push(format!("The most similar config is: {}", s.text)),
+                        None => self
+                            .lints
+                            .push(format!("No similar config found for: {}.", unknown_config)),
                     };
 
-                    self.lints
-                        .push(format!("The most similar config is: {}", top_match));
-
                     // ignore any unrecognized field, but consume the value anyway
                     // TODO: could we warn about fields that look like typos?
                     map.next_value::<serde::de::IgnoredAny>()?;

crates/spk-schema/src/v0/spec.rs

@@ -994,16 +994,15 @@ where
                     corpus.add_text("install");
                     corpus.add_text("api");
 
-                    let results = corpus.search(unknown_config, 0.6);
-                    let no_match = format!("No similar config found for: {}", unknown_config);
-                    let top_match = match results.first() {
-                        Some(s) => &s.text,
-                        None => &no_match,
+                    match corpus.search(unknown_config, 0.6).first() {
+                        Some(s) => self
+                            .lints
+                            .push(format!("The most similar config is: {}", s.text)),
+                        None => self
+                            .lints
+                            .push(format!("No similar config found for: {}.", unknown_config)),
                     };
 
-                    self.lints
-                        .push(format!("The most similar config is: {}", top_match));
-
                     // ignore any unrecognized field, but consume the value anyway
                     // TODO: could we warn about fields that look like typos?
                     map.next_value::<serde::de::IgnoredAny>()?;