feat: added diagnostics for flow type

Author: raphael-goetz

cli/src/analyser/diagnostics.rs

@@ -85,6 +85,7 @@ pub struct Diagnose {
 pub enum DiagnosticKind {
     DeserializationError { description: String },
     DuplicateDataTypeIdentifier { identifier: String },
+    DuplicateFlowTypeIdentifier { identifier: String },
     UndefinedDataTypeIdentifier { identifier: String },
     NullField { field_name: String },
     ForbiddenVariant,
@@ -99,6 +100,7 @@ impl DiagnosticKind {
         match self {
             DeserializationError { .. }
             | DuplicateDataTypeIdentifier { .. }
+            | DuplicateFlowTypeIdentifier { .. }
             | UndefinedDataTypeIdentifier { .. }
             | NullField { .. }
             | ForbiddenVariant { .. }
@@ -134,6 +136,8 @@ impl Diagnose {
                 error(format!("A JSON paring error occurred: `{}`", description), &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),
             UndefinedDataTypeIdentifier {  identifier } =>
                 error(format!("`{}` uses an undefined data_type_identifier: `{}`!", self.definition_name, identifier), &path),
             NullField { field_name } =>

cli/src/analyser/mod.rs

@@ -6,7 +6,7 @@ use tucana::shared::definition_data_type_rule::Config;
 use code0_definition_reader::parser::Parser;
 use code0_definition_reader::reader::{MetaType, ParsableDefinition, Reader};
 use crate::analyser::diagnostics::{Diagnose, DiagnosticKind, Reporter};
-use crate::analyser::diagnostics::DiagnosticKind::{DuplicateDataTypeIdentifier, NullField, UndefinedDataTypeIdentifier, UndefinedGenericKey, UndefinedTranslation, UnusedGenericKey};
+use crate::analyser::diagnostics::DiagnosticKind::{DuplicateDataTypeIdentifier, DuplicateFlowTypeIdentifier, NullField, UndefinedDataTypeIdentifier, UndefinedGenericKey, UndefinedTranslation, UnusedGenericKey};
 
 #[derive(Clone)]
 pub struct AnalysableDataType {
@@ -15,6 +15,7 @@ pub struct AnalysableDataType {
     pub id: i16
 }
 
+#[derive(Clone)]
 pub struct AnalysableFlowType {
     pub original_definition: ParsableDefinition,
     pub flow_type: FlowType,
@@ -329,6 +330,76 @@ impl Analyser {
         }
     }
 
+    pub fn analyse_flow_type(&mut self, analysable_flow_type: AnalysableFlowType) {
+        let flow= analysable_flow_type.flow_type.clone();
+        let original_definition = analysable_flow_type.original_definition;
+        let name = flow.identifier;
+
+        // Check if at least one Translation is present
+        if flow.name.is_empty() {
+            self.reporter.add_report(Diagnose::new(
+                name.clone(),
+                original_definition.clone(),
+                UndefinedTranslation { translation_field: String::from("name") }
+            ));
+        }
+
+        if flow.description.is_empty() {
+            self.reporter.add_report(Diagnose::new(
+                name.clone(),
+                original_definition.clone(),
+                UndefinedTranslation { translation_field: String::from("description") }
+            ));
+        }
+
+        if flow.documentation.is_empty() {
+            self.reporter.add_report(Diagnose::new(
+                name.clone(),
+                original_definition.clone(),
+                UndefinedTranslation { translation_field: String::from("documentation") }
+            ));
+        }
+
+        // Check if input identifier exists
+        if let Some(identifier) = flow.input_type_identifier {
+            if !self.data_type_identifier_exists(identifier.clone(), -1) {
+                self.reporter.add_report(Diagnose::new(
+                    name.clone(),
+                    original_definition.clone(),
+                    UndefinedDataTypeIdentifier {identifier}
+                ));
+            }
+        }
+
+        // Check if return identifier exists
+        if let Some(identifier) = flow.return_type_identifier {
+            if !self.data_type_identifier_exists(identifier.clone(), -1) {
+                self.reporter.add_report(Diagnose::new(
+                    name.clone(),
+                    original_definition.clone(),
+                    UndefinedDataTypeIdentifier {identifier}
+                ));
+            }
+        }
+
+        // Check if flow type identifier already exists
+        for flow_type in &self.flow_types {
+            if analysable_flow_type.id == flow_type.id {
+                continue
+            }
+
+            if flow_type.flow_type.identifier.to_lowercase() == name.clone().to_lowercase() {
+                self.reporter.add_report(Diagnose::new(
+                    name.clone(),
+                    original_definition.clone(),
+                    DuplicateFlowTypeIdentifier { identifier: name }
+                ));
+                break;
+            }
+        }
+
+    }
+
     pub fn report(&self) {
         self.reporter.run_report()
     }

cli/src/command/report.rs

@@ -18,6 +18,10 @@ pub fn report_errors(path: Option<String>) {
        analyser.analyse_data_type(data_type.clone());
     }
 
+    for flow_type in analyser.flow_types.clone() {
+        analyser.analyse_flow_type(flow_type.clone());
+    }
+
     analyser.report();
 
     error_table(&parser.features);