Use level and category enums

Author: marschattha

Cargo.lock

@@ -21,7 +21,8 @@ use qlty_config::config::issue_transformer::IssueTransformer;
 use qlty_config::config::{DriverType, Match, PluginDef, Set, Triage};
 use qlty_config::config::{IssueMode, PluginMode};
 use qlty_config::{QltyConfig, Workspace};
-use qlty_types::analysis::v1::ExecutionVerb;
+use qlty_types::analysis::v1::ExecutionVerb; 
+use qlty_types::{level_from_str, category_from_str};
 use rayon::prelude::*;
 use std::collections::HashMap;
 use std::time::Instant;
@@ -291,8 +292,8 @@ impl Planner {
             for issue_override in &self.config.overrides {
                 triages.push(Triage {
                     set: Set {
-                        level: issue_override.level.clone(),
-                        category: issue_override.category.clone(),
+                        level: issue_override.level.as_ref().map(|l| level_from_str(l)),
+                        category: issue_override.category.as_ref().map(|c| category_from_str(c)),
                         mode: issue_override.mode.map(|m| match m {
                             IssueMode::Block => PluginMode::Block,
                             IssueMode::Comment => PluginMode::Comment,

qlty-check/src/planner.rs

@@ -2,10 +2,10 @@ use super::ignore::is_rule_issue_match;
 use super::plugin::PluginMode;
 use crate::config::issue_transformer::IssueTransformer;
 use globset::{Glob, GlobSet, GlobSetBuilder};
-use qlty_types::category_from_str;
-use qlty_types::{analysis::v1::Issue, level_from_str};
+use qlty_types::analysis::v1::{Category, Issue, Level};
+use qlty_types::{category_from_str, level_from_str};
 use schemars::JsonSchema;
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Serialize, Deserializer};
 use std::sync::RwLock;
 
 #[derive(Debug, Serialize, Deserialize, Default, JsonSchema)]
@@ -34,13 +34,13 @@ impl Clone for Match {
     }
 }
 
-#[derive(Debug, Serialize, Deserialize, Default, Clone, JsonSchema)]
+#[derive(Debug, Serialize, Default, Clone, JsonSchema)]
 pub struct Set {
     #[serde(default)]
-    pub level: Option<String>,
+    pub level: Option<Level>,
 
     #[serde(default)]
-    pub category: Option<String>,
+    pub category: Option<Category>,
 
     #[serde(default)]
     pub mode: Option<PluginMode>,
@@ -49,6 +49,37 @@ pub struct Set {
     pub ignored: bool,
 }
 
+impl<'de> Deserialize<'de> for Set {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        #[derive(Deserialize)]
+        struct SetHelper {
+            #[serde(default)]
+            level: Option<String>,
+            
+            #[serde(default)]
+            category: Option<String>,
+            
+            #[serde(default)]
+            mode: Option<PluginMode>,
+            
+            #[serde(default)]
+            ignored: bool,
+        }
+
+        let helper = SetHelper::deserialize(deserializer)?;
+        
+        Ok(Set {
+            level: helper.level.as_deref().map(level_from_str),
+            category: helper.category.as_deref().map(category_from_str),
+            mode: helper.mode,
+            ignored: helper.ignored,
+        })
+    }
+}
+
 #[derive(Debug, Serialize, Deserialize, Default, Clone, JsonSchema)]
 pub struct Triage {
     #[serde(default)]
@@ -111,11 +142,11 @@ impl IssueTransformer for Triage {
             let mut new_issue = issue.clone();
 
             if let Some(level) = &self.set.level {
-                new_issue.level = level_from_str(level).into();
+                new_issue.level = *level as i32;
             }
 
             if let Some(category) = &self.set.category {
-                new_issue.category = category_from_str(category).into();
+                new_issue.category = *category as i32;
             }
 
             if let Some(mode) = &self.set.mode {

qlty-config/src/config/triage.rs

@@ -19,5 +19,7 @@ clap.workspace = true
 pbjson-types.workspace = true
 pbjson.workspace = true
 prost.workspace = true
+schemars.workspace = true
 serde.workspace = true
+serde_json.workspace = true
 tree-sitter.workspace = true

qlty-types/Cargo.toml

@@ -1,4 +1,9 @@
 use pbjson_types::{value::Kind, Struct, Value};
+use schemars::{
+    schema::{InstanceType, Schema, SchemaObject, SingleOrVec},
+    JsonSchema,
+};
+use serde_json;
 use std::cmp::Ordering;
 use std::{
     collections::HashMap,
@@ -383,3 +388,61 @@ impl AddAssign for tests::v1::CoverageSummary {
         *self = *self + other;
     }
 }
+
+impl JsonSchema for analysis::v1::Level {
+    fn schema_name() -> String {
+        "Level".to_owned()
+    }
+
+    fn json_schema(_gen: &mut schemars::gen::SchemaGenerator) -> Schema {
+        let mut schema = SchemaObject::default();
+        schema.instance_type = Some(SingleOrVec::Single(Box::new(InstanceType::String)));
+
+        let enum_values = vec![
+            serde_json::Value::String("unspecified".to_owned()),
+            serde_json::Value::String("note".to_owned()),
+            serde_json::Value::String("fmt".to_owned()),
+            serde_json::Value::String("low".to_owned()),
+            serde_json::Value::String("medium".to_owned()),
+            serde_json::Value::String("high".to_owned()),
+        ];
+
+        schema.enum_values = Some(enum_values);
+
+        Schema::Object(schema)
+    }
+}
+
+impl JsonSchema for analysis::v1::Category {
+    fn schema_name() -> String {
+        "Category".to_owned()
+    }
+
+    fn json_schema(_gen: &mut schemars::gen::SchemaGenerator) -> Schema {
+        let mut schema = SchemaObject::default();
+        schema.instance_type = Some(SingleOrVec::Single(Box::new(InstanceType::String)));
+
+        let enum_values = vec![
+            serde_json::Value::String("unspecified".to_owned()),
+            serde_json::Value::String("bug".to_owned()),
+            serde_json::Value::String("vulnerability".to_owned()),
+            serde_json::Value::String("structure".to_owned()),
+            serde_json::Value::String("duplication".to_owned()),
+            serde_json::Value::String("security_hotspot".to_owned()),
+            serde_json::Value::String("performance".to_owned()),
+            serde_json::Value::String("documentation".to_owned()),
+            serde_json::Value::String("type_check".to_owned()),
+            serde_json::Value::String("style".to_owned()),
+            serde_json::Value::String("anti_pattern".to_owned()),
+            serde_json::Value::String("accessibility".to_owned()),
+            serde_json::Value::String("dead_code".to_owned()),
+            serde_json::Value::String("lint".to_owned()),
+            serde_json::Value::String("secret".to_owned()),
+            serde_json::Value::String("dependency_alert".to_owned()),
+        ];
+
+        schema.enum_values = Some(enum_values);
+
+        Schema::Object(schema)
+    }
+}