feat: started to implement the analyser into every command

Author: raphael-goetz

cli/src/analyser/diagnostics.rs

@@ -1,12 +1,12 @@
+use crate::formatter::{error, warning};
+use code0_definition_reader::reader::ParsableDefinition;
 use std::cmp::PartialEq;
 use std::path::Path;
 use std::process::exit;
-use code0_definition_reader::reader::ParsableDefinition;
-use crate::formatter::{error, warning};
 
 #[derive(Default)]
 pub struct Reporter {
-    diagnose: Vec<Diagnose>
+    diagnose: Vec<Diagnose>,
 }
 
 impl PartialEq for Severity {
@@ -35,13 +35,11 @@ impl PartialEq for Severity {
 }
 
 impl Reporter {
-
     pub fn add_report(&mut self, diagnose: Diagnose) {
         self.diagnose.push(diagnose);
     }
 
-    pub fn run_report(&self) {
-
+    pub fn run_report(&self, will_exit: bool) {
         for error in &self.get_errors() {
             println!("{}", error.print());
         }
@@ -50,30 +48,37 @@ impl Reporter {
             println!("{}", warning.print());
         }
 
-        if !self.get_errors().is_empty() {
+        if !self.get_errors().is_empty() && will_exit {
             exit(1)
         }
-
     }
 
     pub fn get_errors(&self) -> Vec<&Diagnose> {
-        self.diagnose.iter().filter(|p| p.kind.severity() == Severity::Error).collect()
+        self.diagnose
+            .iter()
+            .filter(|p| p.kind.severity() == Severity::Error)
+            .collect()
     }
 
     pub fn get_warnings(&self) -> Vec<&Diagnose> {
-        self.diagnose.iter().filter(|p| p.kind.severity() == Severity::Warning).collect()
+        self.diagnose
+            .iter()
+            .filter(|p| p.kind.severity() == Severity::Warning)
+            .collect()
     }
 
     pub fn get_debug(&self) -> Vec<&Diagnose> {
-        self.diagnose.iter().filter(|p| p.kind.severity() == Severity::Debug).collect()
+        self.diagnose
+            .iter()
+            .filter(|p| p.kind.severity() == Severity::Debug)
+            .collect()
     }
-
 }
 
 pub enum Severity {
     Error,
     Warning,
-    Debug
+    Debug,
 }
 
 pub struct Diagnose {
@@ -90,7 +95,7 @@ pub enum DiagnosticKind {
     DuplicateRuntimeParameterIdentifier { identifier: String },
     UndefinedDataTypeIdentifier { identifier: String },
     EmptyGenericMapper,
-    GenericKeyNotInMappingTarget {key: String, target: String },
+    GenericKeyNotInMappingTarget { key: String, target: String },
     NullField { field_name: String },
     ForbiddenVariant,
     UnusedGenericKey { key: String },
@@ -120,8 +125,11 @@ impl DiagnosticKind {
 }
 
 impl Diagnose {
-
-    pub fn new(definition_name: String, definition: ParsableDefinition, kind: DiagnosticKind) -> Self {
+    pub fn new(
+        definition_name: String,
+        definition: ParsableDefinition,
+        kind: DiagnosticKind,
+    ) -> Self {
         Self {
             definition_name,
             definition,
@@ -130,7 +138,6 @@ impl Diagnose {
     }
 
     pub fn print(&self) -> String {
-
         let path = format!(
             "{}:{}:{}",
             Path::new(&self.definition.path.clone().unwrap_or_default()).display(),
@@ -140,32 +147,94 @@ impl Diagnose {
 
         use DiagnosticKind::*;
         match &self.kind {
-            EmptyGenericMapper =>
-                error(format!("`{}` defined a generic_type but its mapper are empty!`", self.definition_name), &path),
-            DeserializationError { description } =>
-                error(format!("A JSON paring error occurred: `{}`", description), &path),
-            GenericKeyNotInMappingTarget {key, target} =>
-                error(format!("`{}` is mapping the key: {} onto the target: {}. But the target did not define this generic_key!", self.definition_name, key, target), &path),
-            DuplicateDataTypeIdentifier { identifier } =>
-                error(format!("The data_type `{}` is already defined resulting in a duplicate!", identifier), &path),
-            DuplicateFlowTypeIdentifier { identifier } =>
-                error(format!("The flow_type `{}` is already defined resulting in a duplicate!", identifier), &path),
-            DuplicateRuntimeFunctionIdentifier { identifier } =>
-                error(format!("The runtime_function `{}` is already defined resulting in a duplicate!", identifier), &path),
-            DuplicateRuntimeParameterIdentifier { identifier } =>
-                error(format!("The runtime_parameter `{}` is already defined resulting in a duplicate!", identifier), &path),
-            UndefinedDataTypeIdentifier {  identifier } =>
-                error(format!("`{}` uses an undefined data_type_identifier: `{}`!", self.definition_name, identifier), &path),
-            NullField { field_name } =>
-                error ( format!("`{}` has a field (`{}`) that is null!", self.definition_name, field_name), &path),
-            ForbiddenVariant =>
-                error(format!("The data_type variant of `{}` is 0 and thus incorrect!", self.definition_name), &path),
-            UnusedGenericKey { key } =>
-                error(format!("`{}` defined a generic_key (`{}`) that is never used!", self.definition_name, key), &path),
-            UndefinedGenericKey { key } =>
-                error(format!("`{}` uses a generic_key (`{}`) that's not defined!", self.definition_name, key), &path),
-            UndefinedTranslation { translation_field } =>
-                warning(format!("`{}` has an empty field  (`{}`) of translations!", self.definition_name, translation_field), &path),
+            EmptyGenericMapper => error(
+                format!(
+                    "`{}` defined a generic_type but its mapper are empty!`",
+                    self.definition_name
+                ),
+                &path,
+            ),
+            DeserializationError { description } => error(
+                format!("A JSON paring error occurred: `{}`", description),
+                &path,
+            ),
+            GenericKeyNotInMappingTarget { key, target } => error(
+                format!(
+                    "`{}` is mapping the key: {} onto the target: {}. But the target did not define this generic_key!",
+                    self.definition_name, key, target
+                ),
+                &path,
+            ),
+            DuplicateDataTypeIdentifier { identifier } => error(
+                format!(
+                    "The data_type `{}` is already defined resulting in a duplicate!",
+                    identifier
+                ),
+                &path,
+            ),
+            DuplicateFlowTypeIdentifier { identifier } => error(
+                format!(
+                    "The flow_type `{}` is already defined resulting in a duplicate!",
+                    identifier
+                ),
+                &path,
+            ),
+            DuplicateRuntimeFunctionIdentifier { identifier } => error(
+                format!(
+                    "The runtime_function `{}` is already defined resulting in a duplicate!",
+                    identifier
+                ),
+                &path,
+            ),
+            DuplicateRuntimeParameterIdentifier { identifier } => error(
+                format!(
+                    "The runtime_parameter `{}` is already defined resulting in a duplicate!",
+                    identifier
+                ),
+                &path,
+            ),
+            UndefinedDataTypeIdentifier { identifier } => error(
+                format!(
+                    "`{}` uses an undefined data_type_identifier: `{}`!",
+                    self.definition_name, identifier
+                ),
+                &path,
+            ),
+            NullField { field_name } => error(
+                format!(
+                    "`{}` has a field (`{}`) that is null!",
+                    self.definition_name, field_name
+                ),
+                &path,
+            ),
+            ForbiddenVariant => error(
+                format!(
+                    "The data_type variant of `{}` is 0 and thus incorrect!",
+                    self.definition_name
+                ),
+                &path,
+            ),
+            UnusedGenericKey { key } => error(
+                format!(
+                    "`{}` defined a generic_key (`{}`) that is never used!",
+                    self.definition_name, key
+                ),
+                &path,
+            ),
+            UndefinedGenericKey { key } => error(
+                format!(
+                    "`{}` uses a generic_key (`{}`) that's not defined!",
+                    self.definition_name, key
+                ),
+                &path,
+            ),
+            UndefinedTranslation { translation_field } => warning(
+                format!(
+                    "`{}` has an empty field  (`{}`) of translations!",
+                    self.definition_name, translation_field
+                ),
+                &path,
+            ),
         }
     }
 }